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

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