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

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