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

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