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