git.sur5r.net Git - openldap/blob - libraries/liblber/encode.c

   1 /* Encode.c - ber output encoding routines */
   2 /* $OpenLDAP$ */
   3 /*
   4  * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
   5  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   6  */
   7 /* Portions
   8  * Copyright (c) 1990 Regents of the University of Michigan.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms are permitted
  12  * provided that this notice is preserved and that due credit is given
  13  * to the University of Michigan at Ann Arbor. The name of the University
  14  * may not be used to endorse or promote products derived from this
  15  * software without specific prior written permission. This software
  16  * is provided ``as is'' without express or implied warranty.
  17  */
  18
  19 #include "portable.h"
  20
  21 #include <stdio.h>
  22
  23 #include <ac/stdlib.h>
  24
  25 #include <ac/stdarg.h>
  26 #include <ac/socket.h>
  27 #include <ac/string.h>
  28
  29 #include "lber-int.h"
  30
  31 static int ber_put_len LDAP_P((
  32         BerElement *ber,
  33         ber_len_t len,
  34         int nosos ));
  35
  36 static int ber_start_seqorset LDAP_P((
  37         BerElement *ber,
  38         ber_tag_t tag ));
  39
  40 static int ber_put_seqorset LDAP_P(( BerElement *ber ));
  41
  42 static int ber_put_int_or_enum LDAP_P((
  43         BerElement *ber,
  44         ber_int_t num,
  45         ber_tag_t tag ));
  46
  47
  48 static ber_len_t
  49 ber_calc_taglen( ber_tag_t tag )
  50 {
  51         int     i;
  52         ber_tag_t       mask;
  53
  54         /* find the first non-all-zero byte in the tag */
  55         for ( i = sizeof(ber_tag_t) - 1; i > 0; i-- ) {
  56                 mask = ((ber_tag_t)0xffU << (i * 8));
  57                 /* not all zero */
  58                 if ( tag & mask ) break;
  59         }
  60
  61         return i + 1;
  62 }
  63
  64 static int
  65 ber_put_tag(
  66         BerElement      *ber,
  67         ber_tag_t tag,
  68         int nosos )
  69 {
  70         int rc;
  71         ber_len_t       taglen;
  72         ber_len_t       i;
  73         unsigned char nettag[sizeof(ber_tag_t)];
  74
  75         assert( ber != NULL );
  76         assert( LBER_VALID( ber ) );
  77
  78         taglen = ber_calc_taglen( tag );
  79
  80         for( i=0; i<taglen; i++ ) {
  81                 nettag[(sizeof(ber_tag_t)-1) - i] = (unsigned char)(tag & 0xffU);
  82                 tag >>= 8;
  83         }
  84
  85         rc = ber_write( ber,
  86                 &nettag[sizeof(ber_tag_t) - taglen],
  87             taglen, nosos );
  88
  89         return rc;
  90 }
  91
  92 static ber_len_t
  93 ber_calc_lenlen( ber_len_t len )
  94 {
  95         /*
  96          * short len if it's less than 128 - one byte giving the len,
  97          * with bit 8 0.
  98          */
  99
 100         if ( len <= (ber_len_t) 0x7FU )
 101                 return 1;
 102
 103         /*
 104          * long len otherwise - one byte with bit 8 set, giving the
 105          * length of the length, followed by the length itself.
 106          */
 107
 108         if ( len <= (ber_len_t) 0xffU )
 109                 return 2;
 110         if ( len <= (ber_len_t) 0xffffU )
 111                 return 3;
 112         if ( len <= (ber_len_t) 0xffffffU )
 113                 return 4;
 114
 115         return 5;
 116 }
 117
 118 static int
 119 ber_put_len( BerElement *ber, ber_len_t len, int nosos )
 120 {
 121         int rc;
 122         int             i,j;
 123         char            lenlen;
 124         ber_len_t       mask;
 125         unsigned char netlen[sizeof(ber_len_t)];
 126
 127         assert( ber != NULL );
 128         assert( LBER_VALID( ber ) );
 129
 130         /*
 131          * short len if it's less than 128 - one byte giving the len,
 132          * with bit 8 0.
 133          */
 134
 135         if ( len <= 127 ) {
 136                 char length_byte = (char) len;
 137                 return ber_write( ber, &length_byte, 1, nosos );
 138         }
 139
 140         /*
 141          * long len otherwise - one byte with bit 8 set, giving the
 142          * length of the length, followed by the length itself.
 143          */
 144
 145         /* find the first non-all-zero byte */
 146         for ( i = sizeof(ber_len_t) - 1; i > 0; i-- ) {
 147                 mask = ((ber_len_t)0xffU << (i * 8));
 148                 /* not all zero */
 149                 if ( len & mask ) break;
 150         }
 151         lenlen = (unsigned char) ++i;
 152         if ( lenlen > 4 )
 153                 return -1;
 154
 155         lenlen |= 0x80UL;
 156
 157         /* write the length of the length */
 158         if ( ber_write( ber, &lenlen, 1, nosos ) != 1 )
 159                 return -1;
 160
 161         for( j=0; j<i; j++) {
 162                 netlen[(sizeof(ber_len_t)-1) - j] = (unsigned char)(len & 0xffU);
 163                 len >>= 8;
 164         }
 165
 166         /* write the length itself */
 167         rc = ber_write( ber,
 168                 &netlen[sizeof(ber_len_t)-i],
 169                 i, nosos );
 170
 171         return rc == i ?  i+1 : -1;
 172 }
 173
 174 static int
 175 ber_put_int_or_enum(
 176         BerElement *ber,
 177         ber_int_t num,
 178         ber_tag_t tag )
 179 {
 180         int rc;
 181         int     i, j, sign;
 182         ber_len_t       len, lenlen, taglen;
 183         ber_uint_t      unum, mask;
 184         unsigned char netnum[sizeof(ber_uint_t)];
 185
 186         assert( ber != NULL );
 187         assert( LBER_VALID( ber ) );
 188
 189         sign = (num < 0);
 190         unum = num;     /* Bit fiddling should be done with unsigned values */
 191
 192         /*
 193          * high bit is set - look for first non-all-one byte
 194          * high bit is clear - look for first non-all-zero byte
 195          */
 196         for ( i = sizeof(ber_int_t) - 1; i > 0; i-- ) {
 197                 mask = ((ber_uint_t)0xffU << (i * 8));
 198
 199                 if ( sign ) {
 200                         /* not all ones */
 201                         if ( (unum & mask) != mask ) break;
 202                 } else {
 203                         /* not all zero */
 204                         if ( unum & mask ) break;
 205                 }
 206         }
 207
 208         /*
 209          * we now have the "leading byte".  if the high bit on this
 210          * byte matches the sign bit, we need to "back up" a byte.
 211          */
 212         mask = (unum & ((ber_uint_t)0x80U << (i * 8)));
 213         if ( (mask && !sign) || (sign && !mask) ) {
 214                 i++;
 215         }
 216
 217         len = i + 1;
 218
 219         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
 220                 return -1;
 221         }
 222
 223         if ( (lenlen = ber_put_len( ber, len, 0 )) == -1 )
 224                 return -1;
 225         i++;
 226
 227         for( j=0; j<i; j++ ) {
 228                 netnum[(sizeof(ber_int_t)-1) - j] = (unsigned char)(unum & 0xffU);
 229                 unum >>= 8;
 230         }
 231
 232         rc = ber_write( ber,
 233                 &netnum[sizeof(ber_int_t) - i],
 234                 i, 0 );
 235
 236         /* length of tag + length + contents */
 237         return rc == i ? taglen + lenlen + i : -1;
 238 }
 239
 240 int
 241 ber_put_enum(
 242         BerElement *ber,
 243         ber_int_t num,
 244         ber_tag_t tag )
 245 {
 246         assert( ber != NULL );
 247         assert( LBER_VALID( ber ) );
 248
 249         if ( tag == LBER_DEFAULT ) {
 250                 tag = LBER_ENUMERATED;
 251         }
 252
 253         return ber_put_int_or_enum( ber, num, tag );
 254 }
 255
 256 int
 257 ber_put_int(
 258         BerElement *ber,
 259         ber_int_t num,
 260         ber_tag_t tag )
 261 {
 262         assert( ber != NULL );
 263         assert( LBER_VALID( ber ) );
 264
 265         if ( tag == LBER_DEFAULT ) {
 266                 tag = LBER_INTEGER;
 267         }
 268
 269         return ber_put_int_or_enum( ber, num, tag );
 270 }
 271
 272 int
 273 ber_put_ostring(
 274         BerElement *ber,
 275         LDAP_CONST char *str,
 276         ber_len_t len,
 277         ber_tag_t tag )
 278 {
 279         ber_len_t       taglen, lenlen;
 280         int rc;
 281
 282         assert( ber != NULL );
 283         assert( str != NULL );
 284
 285         assert( LBER_VALID( ber ) );
 286
 287         if ( tag == LBER_DEFAULT ) {
 288                 tag = LBER_OCTETSTRING;
 289         }
 290
 291         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 )
 292                 return -1;
 293
 294         if ( (lenlen = ber_put_len( ber, len, 0 )) == -1 ||
 295                 (ber_len_t) ber_write( ber, str, len, 0 ) != len ) {
 296                 rc = -1;
 297         } else {
 298                 /* return length of tag + length + contents */
 299                 rc = taglen + lenlen + len;
 300         }
 301
 302         return rc;
 303 }
 304
 305 int
 306 ber_put_berval(
 307         BerElement *ber,
 308         LDAP_CONST struct berval *bv,
 309         ber_tag_t tag )
 310 {
 311         assert( ber != NULL );
 312         assert( LBER_VALID( ber ) );
 313
 314         if( bv == NULL || bv->bv_len == 0 ) {
 315                 return ber_put_ostring( ber, "", (ber_len_t) 0, tag );
 316         }
 317
 318         return ber_put_ostring( ber, bv->bv_val, bv->bv_len, tag );
 319 }
 320
 321 int
 322 ber_put_string(
 323         BerElement *ber,
 324         LDAP_CONST char *str,
 325         ber_tag_t tag )
 326 {
 327         assert( ber != NULL );
 328         assert( str != NULL );
 329
 330         assert( LBER_VALID( ber ) );
 331
 332         return ber_put_ostring( ber, str, strlen( str ), tag );
 333 }
 334
 335 int
 336 ber_put_bitstring(
 337         BerElement *ber,
 338         LDAP_CONST char *str,
 339         ber_len_t blen /* in bits */,
 340         ber_tag_t tag )
 341 {
 342         ber_len_t               taglen, lenlen, len;
 343         unsigned char   unusedbits;
 344
 345         assert( ber != NULL );
 346         assert( str != NULL );
 347
 348         assert( LBER_VALID( ber ) );
 349
 350         if ( tag == LBER_DEFAULT ) {
 351                 tag = LBER_BITSTRING;
 352         }
 353
 354         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
 355                 return -1;
 356         }
 357
 358         len = ( blen + 7 ) / 8;
 359         unusedbits = (unsigned char) ((len * 8) - blen);
 360         if ( (lenlen = ber_put_len( ber, len + 1, 0 )) == -1 ) {
 361                 return -1;
 362         }
 363
 364         if ( ber_write( ber, (char *)&unusedbits, 1, 0 ) != 1 ) {
 365                 return -1;
 366         }
 367
 368         if ( (ber_len_t) ber_write( ber, str, len, 0 ) != len ) {
 369                 return -1;
 370         }
 371
 372         /* return length of tag + length + unused bit count + contents */
 373         return taglen + 1 + lenlen + len;
 374 }
 375
 376 int
 377 ber_put_null( BerElement *ber, ber_tag_t tag )
 378 {
 379         ber_len_t       taglen;
 380
 381         assert( ber != NULL );
 382         assert( LBER_VALID( ber ) );
 383
 384         if ( tag == LBER_DEFAULT ) {
 385                 tag = LBER_NULL;
 386         }
 387
 388         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
 389                 return -1;
 390         }
 391
 392         if ( ber_put_len( ber, 0, 0 ) != 1 ) {
 393                 return -1;
 394         }
 395
 396         return taglen + 1;
 397 }
 398
 399 int
 400 ber_put_boolean(
 401         BerElement *ber,
 402         ber_int_t boolval,
 403         ber_tag_t tag )
 404 {
 405         ber_len_t               taglen;
 406         unsigned char   trueval = (unsigned char) -1;
 407         unsigned char   falseval = 0;
 408
 409         assert( ber != NULL );
 410         assert( LBER_VALID( ber ) );
 411
 412         if ( tag == LBER_DEFAULT )
 413                 tag = LBER_BOOLEAN;
 414
 415         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
 416                 return -1;
 417         }
 418
 419         if ( ber_put_len( ber, 1, 0 ) != 1 ) {
 420                 return -1;
 421         }
 422
 423         if ( ber_write( ber, (char *)(boolval ? &trueval : &falseval), 1, 0 )
 424                 != 1 )
 425         {
 426                 return -1;
 427         }
 428
 429         return taglen + 2;
 430 }
 431
 432 #define FOUR_BYTE_LEN   5
 433
 434 static int
 435 ber_start_seqorset(
 436         BerElement *ber,
 437         ber_tag_t tag )
 438 {
 439         Seqorset        *new;
 440
 441         assert( ber != NULL );
 442         assert( LBER_VALID( ber ) );
 443
 444         new = (Seqorset *) LBER_CALLOC( 1, sizeof(Seqorset) );
 445
 446         if ( new == NULL ) {
 447                 return -1;
 448         }
 449
 450         new->sos_ber = ber;
 451         if ( ber->ber_sos == NULL ) {
 452                 new->sos_first = ber->ber_ptr;
 453         } else {
 454                 new->sos_first = ber->ber_sos->sos_ptr;
 455         }
 456
 457         /* Set aside room for a 4 byte length field */
 458         new->sos_ptr = new->sos_first + ber_calc_taglen( tag ) + FOUR_BYTE_LEN;
 459         new->sos_tag = tag;
 460
 461         new->sos_next = ber->ber_sos;
 462         ber->ber_sos = new;
 463
 464         return 0;
 465 }
 466
 467 int
 468 ber_start_seq( BerElement *ber, ber_tag_t tag )
 469 {
 470         assert( ber != NULL );
 471         assert( LBER_VALID( ber ) );
 472
 473         if ( tag == LBER_DEFAULT ) {
 474                 tag = LBER_SEQUENCE;
 475         }
 476
 477         return ber_start_seqorset( ber, tag );
 478 }
 479
 480 int
 481 ber_start_set( BerElement *ber, ber_tag_t tag )
 482 {
 483         assert( ber != NULL );
 484         assert( LBER_VALID( ber ) );
 485
 486         if ( tag == LBER_DEFAULT ) {
 487                 tag = LBER_SET;
 488         }
 489
 490         return ber_start_seqorset( ber, tag );
 491 }
 492
 493 static int
 494 ber_put_seqorset( BerElement *ber )
 495 {
 496         int rc;
 497         ber_len_t       len;
 498         unsigned char netlen[sizeof(ber_len_t)];
 499         ber_len_t       taglen, lenlen;
 500         unsigned char   ltag = 0x80U + FOUR_BYTE_LEN - 1;
 501         Seqorset        *next;
 502         Seqorset        **sos = &ber->ber_sos;
 503
 504         assert( ber != NULL );
 505         assert( LBER_VALID( ber ) );
 506
 507         if( *sos == NULL ) return -1;
 508
 509         /*
 510          * If this is the toplevel sequence or set, we need to actually
 511          * write the stuff out.  Otherwise, it's already been put in
 512          * the appropriate buffer and will be written when the toplevel
 513          * one is written.  In this case all we need to do is update the
 514          * length and tag.
 515          */
 516
 517         len = (*sos)->sos_clen;
 518
 519         if ( sizeof(ber_len_t) > 4 && len > 0xffffffffUL ) {
 520                 return -1;
 521         }
 522
 523         if ( ber->ber_options & LBER_USE_DER ) {
 524                 lenlen = ber_calc_lenlen( len );
 525
 526         } else {
 527                 lenlen = FOUR_BYTE_LEN;
 528         }
 529
 530         if( lenlen > 1 ) {
 531                 ber_len_t i;
 532                 for( i=0; i < lenlen-1; i++ ) {
 533                         netlen[(sizeof(ber_len_t)-1) - i] =
 534                                 (unsigned char)((len >> i*8) & 0xffU);
 535                 }
 536         } else {
 537                 netlen[sizeof(ber_len_t)-1] = (unsigned char)(len & 0x7fU);
 538         }
 539
 540         if ( (next = (*sos)->sos_next) == NULL ) {
 541                 /* write the tag */
 542                 if ( (taglen = ber_put_tag( ber, (*sos)->sos_tag, 1 )) == -1 )
 543                         return( -1 );
 544
 545                 if ( ber->ber_options & LBER_USE_DER ) {
 546                         /* Write the length in the minimum # of octets */
 547                         if ( ber_put_len( ber, len, 1 ) == -1 ) {
 548                                 return -1;
 549                         }
 550
 551                         if (lenlen != FOUR_BYTE_LEN) {
 552                                 /*
 553                                  * We set aside FOUR_BYTE_LEN bytes for
 554                                  * the length field.  Move the data if
 555                                  * we don't actually need that much
 556                                  */
 557                                 AC_MEMCPY( (*sos)->sos_first + taglen +
 558                                     lenlen, (*sos)->sos_first + taglen +
 559                                     FOUR_BYTE_LEN, len );
 560                         }
 561                 } else {
 562                         /* Fill FOUR_BYTE_LEN bytes for length field */
 563                         /* one byte of length length */
 564                         if ( ber_write( ber, (char *)&ltag, 1, 1 ) != 1 ) {
 565                                 return -1;
 566                         }
 567
 568                         /* the length itself */
 569                         rc  = ber_write( ber,
 570                                 &netlen[sizeof(ber_len_t) - (FOUR_BYTE_LEN-1)],
 571                                 FOUR_BYTE_LEN-1, 1 );
 572
 573                         if( rc != FOUR_BYTE_LEN - 1 ) {
 574                                 return -1;
 575                         }
 576                 }
 577                 /* The ber_ptr is at the set/seq start - move it to the end */
 578                 (*sos)->sos_ber->ber_ptr += len;
 579
 580         } else {
 581                 ber_len_t i;
 582                 unsigned char nettag[sizeof(ber_tag_t)];
 583                 ber_tag_t tmptag = (*sos)->sos_tag;
 584
 585                 if( ber->ber_sos->sos_ptr > ber->ber_end ) {
 586                         /* The sos_ptr exceeds the end of the BerElement
 587                          * this can happen, for example, when the sos_ptr
 588                          * is near the end and no data was written for the
 589                          * 'V'.  We must realloc the BerElement to ensure
 590                          * we don't overwrite the buffer when writing
 591                          * the tag and length fields.
 592                          */
 593                         ber_len_t ext = ber->ber_sos->sos_ptr - ber->ber_end;
 594
 595                         if( ber_realloc( ber,  ext ) != 0 ) {
 596                                 return -1;
 597                         }
 598                 }
 599
 600                 /* the tag */
 601                 taglen = ber_calc_taglen( tmptag );
 602
 603                 for( i = 0; i < taglen; i++ ) {
 604                         nettag[(sizeof(ber_tag_t)-1) - i] = (unsigned char)(tmptag & 0xffU);
 605                         tmptag >>= 8;
 606                 }
 607
 608                 AC_FMEMCPY( (*sos)->sos_first,
 609                         &nettag[sizeof(ber_tag_t) - taglen],
 610                         taglen );
 611
 612                 if ( ber->ber_options & LBER_USE_DER ) {
 613                         ltag = (lenlen == 1)
 614                                 ? (unsigned char) len
 615                                 : (unsigned char) (0x80U + (lenlen - 1));
 616                 }
 617
 618                 /* one byte of length length */
 619                 (*sos)->sos_first[1] = ltag;
 620
 621                 if ( ber->ber_options & LBER_USE_DER ) {
 622                         if (lenlen > 1) {
 623                                 /* Write the length itself */
 624                                 AC_FMEMCPY( (*sos)->sos_first + 2,
 625                                     &netlen[sizeof(ber_len_t) - (lenlen - 1)],
 626                                         lenlen - 1 );
 627                         }
 628                         if (lenlen != FOUR_BYTE_LEN) {
 629                                 /*
 630                                  * We set aside FOUR_BYTE_LEN bytes for
 631                                  * the length field.  Move the data if
 632                                  * we don't actually need that much
 633                                  */
 634                                 AC_FMEMCPY( (*sos)->sos_first + taglen +
 635                                     lenlen, (*sos)->sos_first + taglen +
 636                                     FOUR_BYTE_LEN, len );
 637                         }
 638                 } else {
 639                         /* the length itself */
 640                         AC_FMEMCPY( (*sos)->sos_first + taglen + 1,
 641                             &netlen[sizeof(ber_len_t) - (FOUR_BYTE_LEN - 1)],
 642                                 FOUR_BYTE_LEN - 1 );
 643                 }
 644
 645                 next->sos_clen += (taglen + lenlen + len);
 646                 next->sos_ptr += (taglen + lenlen + len);
 647         }
 648
 649         /* we're done with this seqorset, so free it up */
 650         LBER_FREE( (char *) (*sos) );
 651         *sos = next;
 652
 653         return taglen + lenlen + len;
 654 }
 655
 656 int
 657 ber_put_seq( BerElement *ber )
 658 {
 659         assert( ber != NULL );
 660         assert( LBER_VALID( ber ) );
 661
 662         return ber_put_seqorset( ber );
 663 }
 664
 665 int
 666 ber_put_set( BerElement *ber )
 667 {
 668         assert( ber != NULL );
 669         assert( LBER_VALID( ber ) );
 670
 671         return ber_put_seqorset( ber );
 672 }
 673
 674 /* N tag */
 675 static ber_tag_t lber_int_null = 0;
 676
 677 /* VARARGS */
 678 int
 679 ber_printf( BerElement *ber, LDAP_CONST char *fmt, ... )
 680 {
 681         va_list         ap;
 682         char            *s, **ss;
 683         struct berval   *bv, **bvp;
 684         int             rc;
 685         ber_int_t       i;
 686         ber_len_t       len;
 687
 688         assert( ber != NULL );
 689         assert( fmt != NULL );
 690
 691         assert( LBER_VALID( ber ) );
 692
 693         va_start( ap, fmt );
 694
 695         for ( rc = 0; *fmt && rc != -1; fmt++ ) {
 696                 switch ( *fmt ) {
 697                 case '!': { /* hook */
 698                                 BEREncodeCallback *f;
 699                                 void *p;
 700
 701                                 f = va_arg( ap, BEREncodeCallback * );
 702                                 p = va_arg( ap, void * );
 703
 704                                 rc = (*f)( ber, p );
 705                         } break;
 706
 707                 case 'b':       /* boolean */
 708                         i = va_arg( ap, ber_int_t );
 709                         rc = ber_put_boolean( ber, i, ber->ber_tag );
 710                         break;
 711
 712                 case 'i':       /* int */
 713                         i = va_arg( ap, ber_int_t );
 714                         rc = ber_put_int( ber, i, ber->ber_tag );
 715                         break;
 716
 717                 case 'e':       /* enumeration */
 718                         i = va_arg( ap, ber_int_t );
 719                         rc = ber_put_enum( ber, i, ber->ber_tag );
 720                         break;
 721
 722                 case 'n':       /* null */
 723                         rc = ber_put_null( ber, ber->ber_tag );
 724                         break;
 725
 726                 case 'N':       /* Debug NULL */
 727                         if( lber_int_null != 0 ) {
 728                                 /* Insert NULL to ensure peer ignores unknown tags */
 729                                 rc = ber_put_null( ber, lber_int_null );
 730                         } else {
 731                                 rc = 0;
 732                         }
 733                         break;
 734
 735                 case 'o':       /* octet string (non-null terminated) */
 736                         s = va_arg( ap, char * );
 737                         len = va_arg( ap, ber_len_t );
 738                         rc = ber_put_ostring( ber, s, len, ber->ber_tag );
 739                         break;
 740
 741                 case 'O':       /* berval octet string */
 742                         bv = va_arg( ap, struct berval * );
 743                         if( bv == NULL ) break;
 744                         rc = ber_put_berval( ber, bv, ber->ber_tag );
 745                         break;
 746
 747                 case 's':       /* string */
 748                         s = va_arg( ap, char * );
 749                         rc = ber_put_string( ber, s, ber->ber_tag );
 750                         break;
 751
 752                 case 'B':       /* bit string */
 753                 case 'X':       /* bit string (deprecated) */
 754                         s = va_arg( ap, char * );
 755                         len = va_arg( ap, int );        /* in bits */
 756                         rc = ber_put_bitstring( ber, s, len, ber->ber_tag );
 757                         break;
 758
 759                 case 't':       /* tag for the next element */
 760                         ber->ber_tag = va_arg( ap, ber_tag_t );
 761                         ber->ber_usertag = 1;
 762                         break;
 763
 764                 case 'v':       /* vector of strings */
 765                         if ( (ss = va_arg( ap, char ** )) == NULL )
 766                                 break;
 767                         for ( i = 0; ss[i] != NULL; i++ ) {
 768                                 if ( (rc = ber_put_string( ber, ss[i],
 769                                     ber->ber_tag )) == -1 )
 770                                         break;
 771                         }
 772                         break;
 773
 774                 case 'V':       /* sequences of strings + lengths */
 775                         if ( (bvp = va_arg( ap, struct berval ** )) == NULL )
 776                                 break;
 777                         for ( i = 0; bvp[i] != NULL; i++ ) {
 778                                 if ( (rc = ber_put_berval( ber, bvp[i],
 779                                     ber->ber_tag )) == -1 )
 780                                         break;
 781                         }
 782                         break;
 783
 784                 case 'W':       /* BVarray */
 785                         if ( (bv = va_arg( ap, BVarray )) == NULL )
 786                                 break;
 787                         for ( i = 0; bv[i].bv_val != NULL; i++ ) {
 788                                 if ( (rc = ber_put_berval( ber, &bv[i],
 789                                     ber->ber_tag )) == -1 )
 790                                         break;
 791                         }
 792                         break;
 793
 794                 case '{':       /* begin sequence */
 795                         rc = ber_start_seq( ber, ber->ber_tag );
 796                         break;
 797
 798                 case '}':       /* end sequence */
 799                         rc = ber_put_seqorset( ber );
 800                         break;
 801
 802                 case '[':       /* begin set */
 803                         rc = ber_start_set( ber, ber->ber_tag );
 804                         break;
 805
 806                 case ']':       /* end set */
 807                         rc = ber_put_seqorset( ber );
 808                         break;
 809
 810                 default:
 811                         if( ber->ber_debug ) {
 812 #ifdef NEW_LOGGING
 813                                 LDAP_LOG(( "liblber", LDAP_LEVEL_ERR,
 814                                            "ber_printf: unknown fmt %c\n", *fmt ));
 815 #else
 816                                 ber_log_printf( LDAP_DEBUG_ANY, ber->ber_debug,
 817                                         "ber_printf: unknown fmt %c\n", *fmt );
 818 #endif
 819                         }
 820                         rc = -1;
 821                         break;
 822                 }
 823
 824                 if ( ber->ber_usertag == 0 )
 825                         ber->ber_tag = LBER_DEFAULT;
 826                 else
 827                         ber->ber_usertag = 0;
 828         }
 829
 830         va_end( ap );
 831
 832         return rc;
 833 }