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-2004 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
  60 static int
  61 ber_calc_taglen( ber_tag_t tag )
  62 {
  63         int     i;
  64         ber_tag_t       mask;
  65
  66         /* find the first non-all-zero byte in the tag */
  67         for ( i = sizeof(ber_tag_t) - 1; i > 0; i-- ) {
  68                 mask = ((ber_tag_t)0xffU << (i * 8));
  69                 /* not all zero */
  70                 if ( tag & mask ) break;
  71         }
  72
  73         return i + 1;
  74 }
  75
  76 static int
  77 ber_put_tag(
  78         BerElement      *ber,
  79         ber_tag_t tag,
  80         int nosos )
  81 {
  82         int rc;
  83         int     taglen;
  84         int     i;
  85         unsigned char nettag[sizeof(ber_tag_t)];
  86
  87         assert( ber != NULL );
  88         assert( LBER_VALID( ber ) );
  89
  90         taglen = ber_calc_taglen( tag );
  91
  92         for( i=0; i<taglen; i++ ) {
  93                 nettag[(sizeof(ber_tag_t)-1) - i] = (unsigned char)(tag & 0xffU);
  94                 tag >>= 8;
  95         }
  96
  97         rc = ber_write( ber,
  98                 (char *) &nettag[sizeof(ber_tag_t) - taglen],
  99             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         for ( i = sizeof(ber_len_t) - 1; i > 0; i-- ) {
 155                 mask = ((ber_len_t)0xffU << (i * 8));
 156                 /* not all zero */
 157                 if ( len & mask ) break;
 158         }
 159         lenlen = (unsigned char) ++i;
 160         if ( lenlen > 4 ) return -1;
 161
 162         lenlen |= 0x80UL;
 163
 164         /* write the length of the length */
 165         if ( ber_write( ber, &lenlen, 1, nosos ) != 1 ) return -1;
 166
 167         for( j=0; j<i; j++) {
 168                 netlen[(sizeof(ber_len_t)-1) - j] = (unsigned char)(len & 0xffU);
 169                 len >>= 8;
 170         }
 171
 172         /* write the length itself */
 173         rc = ber_write( ber,
 174                 (char *) &netlen[sizeof(ber_len_t)-i],
 175                 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         for ( i = sizeof(ber_int_t) - 1; i > 0; i-- ) {
 203                 mask = ((ber_uint_t)0xffU << (i * 8));
 204
 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         }
 213
 214         /*
 215          * we now have the "leading byte".  if the high bit on this
 216          * byte matches the sign bit, we need to "back up" a byte.
 217          */
 218         mask = (unum & ((ber_uint_t)0x80U << (i * 8)));
 219         if ( (mask && !sign) || (sign && !mask) ) {
 220                 i++;
 221         }
 222
 223         len = i + 1;
 224
 225         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
 226                 return -1;
 227         }
 228
 229         if ( (lenlen = ber_put_len( ber, len, 0 )) == -1 ) {
 230                 return -1;
 231         }
 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                 (char *) &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( LBER_VALID( ber ) );
 255
 256         if ( tag == LBER_DEFAULT ) {
 257                 tag = LBER_ENUMERATED;
 258         }
 259
 260         return ber_put_int_or_enum( ber, num, tag );
 261 }
 262
 263 int
 264 ber_put_int(
 265         BerElement *ber,
 266         ber_int_t num,
 267         ber_tag_t tag )
 268 {
 269         assert( ber != NULL );
 270         assert( LBER_VALID( ber ) );
 271
 272         if ( tag == LBER_DEFAULT ) {
 273                 tag = LBER_INTEGER;
 274         }
 275
 276         return ber_put_int_or_enum( ber, num, tag );
 277 }
 278
 279 int
 280 ber_put_ostring(
 281         BerElement *ber,
 282         LDAP_CONST char *str,
 283         ber_len_t len,
 284         ber_tag_t tag )
 285 {
 286         int taglen, lenlen, rc;
 287
 288         assert( ber != NULL );
 289         assert( str != NULL );
 290
 291         assert( LBER_VALID( ber ) );
 292
 293         if ( tag == LBER_DEFAULT ) {
 294                 tag = LBER_OCTETSTRING;
 295         }
 296
 297         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 )
 298                 return -1;
 299
 300         if ( (lenlen = ber_put_len( ber, len, 0 )) == -1 ||
 301                 (ber_len_t) ber_write( ber, str, len, 0 ) != len )
 302         {
 303                 rc = -1;
 304         } else {
 305                 /* return length of tag + length + contents */
 306                 rc = taglen + lenlen + len;
 307         }
 308
 309         return rc;
 310 }
 311
 312 int
 313 ber_put_berval(
 314         BerElement *ber,
 315         struct berval *bv,
 316         ber_tag_t tag )
 317 {
 318         assert( ber != NULL );
 319         assert( LBER_VALID( ber ) );
 320
 321         if( bv == NULL || bv->bv_len == 0 ) {
 322                 return ber_put_ostring( ber, "", (ber_len_t) 0, tag );
 323         }
 324
 325         return ber_put_ostring( ber, bv->bv_val, bv->bv_len, tag );
 326 }
 327
 328 int
 329 ber_put_string(
 330         BerElement *ber,
 331         LDAP_CONST char *str,
 332         ber_tag_t tag )
 333 {
 334         assert( ber != NULL );
 335         assert( str != NULL );
 336
 337         assert( LBER_VALID( ber ) );
 338
 339         return ber_put_ostring( ber, str, strlen( str ), tag );
 340 }
 341
 342 int
 343 ber_put_bitstring(
 344         BerElement *ber,
 345         LDAP_CONST char *str,
 346         ber_len_t blen /* in bits */,
 347         ber_tag_t tag )
 348 {
 349         int                             taglen, lenlen;
 350         ber_len_t               len;
 351         unsigned char   unusedbits;
 352
 353         assert( ber != NULL );
 354         assert( str != NULL );
 355
 356         assert( LBER_VALID( ber ) );
 357
 358         if ( tag == LBER_DEFAULT ) {
 359                 tag = LBER_BITSTRING;
 360         }
 361
 362         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
 363                 return -1;
 364         }
 365
 366         len = ( blen + 7 ) / 8;
 367         unusedbits = (unsigned char) ((len * 8) - blen);
 368         if ( (lenlen = ber_put_len( ber, len + 1, 0 )) == -1 ) {
 369                 return -1;
 370         }
 371
 372         if ( ber_write( ber, (char *)&unusedbits, 1, 0 ) != 1 ) {
 373                 return -1;
 374         }
 375
 376         if ( (ber_len_t) ber_write( ber, str, len, 0 ) != len ) {
 377                 return -1;
 378         }
 379
 380         /* return length of tag + length + unused bit count + contents */
 381         return taglen + 1 + lenlen + len;
 382 }
 383
 384 int
 385 ber_put_null( BerElement *ber, ber_tag_t tag )
 386 {
 387         int     taglen;
 388
 389         assert( ber != NULL );
 390         assert( LBER_VALID( ber ) );
 391
 392         if ( tag == LBER_DEFAULT ) {
 393                 tag = LBER_NULL;
 394         }
 395
 396         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
 397                 return -1;
 398         }
 399
 400         if ( ber_put_len( ber, 0, 0 ) != 1 ) {
 401                 return -1;
 402         }
 403
 404         return taglen + 1;
 405 }
 406
 407 int
 408 ber_put_boolean(
 409         BerElement *ber,
 410         ber_int_t boolval,
 411         ber_tag_t tag )
 412 {
 413         int                             taglen;
 414         unsigned char   c;
 415
 416         assert( ber != NULL );
 417         assert( LBER_VALID( ber ) );
 418
 419         if ( tag == LBER_DEFAULT )
 420                 tag = LBER_BOOLEAN;
 421
 422         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
 423                 return -1;
 424         }
 425
 426         if ( ber_put_len( ber, 1, 0 ) != 1 ) {
 427                 return -1;
 428         }
 429
 430         c = boolval ? (unsigned char) ~0U : (unsigned char) 0U;
 431
 432         if ( ber_write( ber, (char *) &c, 1, 0 ) != 1 ) {
 433                 return -1;
 434         }
 435
 436         return taglen + 2;
 437 }
 438
 439 #define FOUR_BYTE_LEN   5
 440
 441 static int
 442 ber_start_seqorset(
 443         BerElement *ber,
 444         ber_tag_t tag )
 445 {
 446         Seqorset        *new;
 447
 448         assert( ber != NULL );
 449         assert( LBER_VALID( ber ) );
 450
 451         new = (Seqorset *) ber_memcalloc_x( 1, sizeof(Seqorset), ber->ber_memctx );
 452
 453         if ( new == NULL ) {
 454                 return -1;
 455         }
 456
 457         new->sos_ber = ber;
 458         if ( ber->ber_sos == NULL ) {
 459                 new->sos_first = ber->ber_ptr;
 460         } else {
 461                 new->sos_first = ber->ber_sos->sos_ptr;
 462         }
 463
 464         /* Set aside room for a 4 byte length field */
 465         new->sos_ptr = new->sos_first + ber_calc_taglen( tag ) + FOUR_BYTE_LEN;
 466         new->sos_tag = tag;
 467
 468         new->sos_next = ber->ber_sos;
 469         ber->ber_sos = new;
 470
 471         return 0;
 472 }
 473
 474 int
 475 ber_start_seq( BerElement *ber, ber_tag_t tag )
 476 {
 477         assert( ber != NULL );
 478         assert( LBER_VALID( ber ) );
 479
 480         if ( tag == LBER_DEFAULT ) {
 481                 tag = LBER_SEQUENCE;
 482         }
 483
 484         return ber_start_seqorset( ber, tag );
 485 }
 486
 487 int
 488 ber_start_set( BerElement *ber, ber_tag_t tag )
 489 {
 490         assert( ber != NULL );
 491         assert( LBER_VALID( ber ) );
 492
 493         if ( tag == LBER_DEFAULT ) {
 494                 tag = LBER_SET;
 495         }
 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         int                     taglen;
 507         ber_len_t       lenlen;
 508         unsigned char   ltag = 0x80U + FOUR_BYTE_LEN - 1;
 509         Seqorset        *next;
 510         Seqorset        **sos = &ber->ber_sos;
 511
 512         assert( ber != NULL );
 513         assert( LBER_VALID( ber ) );
 514
 515         if( *sos == NULL ) return -1;
 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
 531         if ( ber->ber_options & LBER_USE_DER ) {
 532                 lenlen = ber_calc_lenlen( len );
 533
 534         } else {
 535                 lenlen = FOUR_BYTE_LEN;
 536         }
 537
 538         if( lenlen > 1 ) {
 539                 ber_len_t i;
 540                 for( i=0; i < lenlen-1; i++ ) {
 541                         netlen[(sizeof(ber_len_t)-1) - i] =
 542                                 (unsigned char)((len >> i*8) & 0xffU);
 543                 }
 544         } else {
 545                 netlen[sizeof(ber_len_t)-1] = (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                 if ( ber->ber_options & LBER_USE_DER ) {
 554                         /* Write the length in the minimum # of octets */
 555                         if ( ber_put_len( ber, len, 1 ) == -1 ) {
 556                                 return -1;
 557                         }
 558
 559                         if (lenlen != FOUR_BYTE_LEN) {
 560                                 /*
 561                                  * We set aside FOUR_BYTE_LEN bytes for
 562                                  * the length field.  Move the data if
 563                                  * we don't actually need that much
 564                                  */
 565                                 AC_MEMCPY( (*sos)->sos_first + taglen +
 566                                     lenlen, (*sos)->sos_first + taglen +
 567                                     FOUR_BYTE_LEN, len );
 568                         }
 569                 } else {
 570                         /* Fill FOUR_BYTE_LEN bytes for length field */
 571                         /* one byte of length length */
 572                         if ( ber_write( ber, (char *)&ltag, 1, 1 ) != 1 ) {
 573                                 return -1;
 574                         }
 575
 576                         /* the length itself */
 577                         rc  = ber_write( ber,
 578                                 (char *) &netlen[sizeof(ber_len_t) - (FOUR_BYTE_LEN-1)],
 579                                 FOUR_BYTE_LEN-1, 1 );
 580
 581                         if( rc != FOUR_BYTE_LEN - 1 ) {
 582                                 return -1;
 583                         }
 584                 }
 585                 /* The ber_ptr is at the set/seq start - move it to the end */
 586                 (*sos)->sos_ber->ber_ptr += len;
 587
 588         } else {
 589                 int i;
 590                 unsigned char nettag[sizeof(ber_tag_t)];
 591                 ber_tag_t tmptag = (*sos)->sos_tag;
 592
 593                 if( ber->ber_sos->sos_ptr > ber->ber_end ) {
 594                         /* The sos_ptr exceeds the end of the BerElement
 595                          * this can happen, for example, when the sos_ptr
 596                          * is near the end and no data was written for the
 597                          * 'V'.  We must realloc the BerElement to ensure
 598                          * we don't overwrite the buffer when writing
 599                          * the tag and length fields.
 600                          */
 601                         ber_len_t ext = ber->ber_sos->sos_ptr - ber->ber_end;
 602
 603                         if( ber_realloc( ber,  ext ) != 0 ) {
 604                                 return -1;
 605                         }
 606                 }
 607
 608                 /* the tag */
 609                 taglen = ber_calc_taglen( tmptag );
 610
 611                 for( i = 0; i < taglen; i++ ) {
 612                         nettag[(sizeof(ber_tag_t)-1) - i] = (unsigned char)(tmptag & 0xffU);
 613                         tmptag >>= 8;
 614                 }
 615
 616                 AC_FMEMCPY( (*sos)->sos_first,
 617                         &nettag[sizeof(ber_tag_t) - taglen],
 618                         taglen );
 619
 620                 if ( ber->ber_options & LBER_USE_DER ) {
 621                         ltag = (lenlen == 1)
 622                                 ? (unsigned char) len
 623                                 : (unsigned char) (0x80U + (lenlen - 1));
 624                 }
 625
 626                 /* one byte of length length */
 627                 (*sos)->sos_first[1] = ltag;
 628
 629                 if ( ber->ber_options & LBER_USE_DER ) {
 630                         if (lenlen > 1) {
 631                                 /* Write the length itself */
 632                                 AC_FMEMCPY( (*sos)->sos_first + 2,
 633                                     &netlen[sizeof(ber_len_t) - (lenlen - 1)],
 634                                         lenlen - 1 );
 635                         }
 636                         if (lenlen != FOUR_BYTE_LEN) {
 637                                 /*
 638                                  * We set aside FOUR_BYTE_LEN bytes for
 639                                  * the length field.  Move the data if
 640                                  * we don't actually need that much
 641                                  */
 642                                 AC_FMEMCPY( (*sos)->sos_first + taglen +
 643                                     lenlen, (*sos)->sos_first + taglen +
 644                                     FOUR_BYTE_LEN, len );
 645                         }
 646                 } else {
 647                         /* the length itself */
 648                         AC_FMEMCPY( (*sos)->sos_first + taglen + 1,
 649                             &netlen[sizeof(ber_len_t) - (FOUR_BYTE_LEN - 1)],
 650                                 FOUR_BYTE_LEN - 1 );
 651                 }
 652
 653                 next->sos_clen += (taglen + lenlen + len);
 654                 next->sos_ptr += (taglen + lenlen + len);
 655         }
 656
 657         /* we're done with this seqorset, so free it up */
 658         ber_memfree_x( (char *) (*sos), ber->ber_memctx );
 659         *sos = next;
 660
 661         return taglen + lenlen + len;
 662 }
 663
 664 int
 665 ber_put_seq( BerElement *ber )
 666 {
 667         assert( ber != NULL );
 668         assert( LBER_VALID( ber ) );
 669
 670         return ber_put_seqorset( ber );
 671 }
 672
 673 int
 674 ber_put_set( BerElement *ber )
 675 {
 676         assert( ber != NULL );
 677         assert( LBER_VALID( ber ) );
 678
 679         return ber_put_seqorset( ber );
 680 }
 681
 682 /* N tag */
 683 static ber_tag_t lber_int_null = 0;
 684
 685 /* VARARGS */
 686 int
 687 ber_printf( BerElement *ber, LDAP_CONST char *fmt, ... )
 688 {
 689         va_list         ap;
 690         char            *s, **ss;
 691         struct berval   *bv, **bvp;
 692         int             rc;
 693         ber_int_t       i;
 694         ber_len_t       len;
 695
 696         assert( ber != NULL );
 697         assert( fmt != NULL );
 698
 699         assert( LBER_VALID( ber ) );
 700
 701         va_start( ap, fmt );
 702
 703         for ( rc = 0; *fmt && rc != -1; fmt++ ) {
 704                 switch ( *fmt ) {
 705                 case '!': { /* hook */
 706                                 BEREncodeCallback *f;
 707                                 void *p;
 708
 709                                 f = va_arg( ap, BEREncodeCallback * );
 710                                 p = va_arg( ap, void * );
 711
 712                                 rc = (*f)( ber, p );
 713                         } break;
 714
 715                 case 'b':       /* boolean */
 716                         i = va_arg( ap, ber_int_t );
 717                         rc = ber_put_boolean( ber, i, ber->ber_tag );
 718                         break;
 719
 720                 case 'i':       /* int */
 721                         i = va_arg( ap, ber_int_t );
 722                         rc = ber_put_int( ber, i, ber->ber_tag );
 723                         break;
 724
 725                 case 'e':       /* enumeration */
 726                         i = va_arg( ap, ber_int_t );
 727                         rc = ber_put_enum( ber, i, ber->ber_tag );
 728                         break;
 729
 730                 case 'n':       /* null */
 731                         rc = ber_put_null( ber, ber->ber_tag );
 732                         break;
 733
 734                 case 'N':       /* Debug NULL */
 735                         if( lber_int_null != 0 ) {
 736                                 /* Insert NULL to ensure peer ignores unknown tags */
 737                                 rc = ber_put_null( ber, lber_int_null );
 738                         } else {
 739                                 rc = 0;
 740                         }
 741                         break;
 742
 743                 case 'o':       /* octet string (non-null terminated) */
 744                         s = va_arg( ap, char * );
 745                         len = va_arg( ap, ber_len_t );
 746                         rc = ber_put_ostring( ber, s, len, ber->ber_tag );
 747                         break;
 748
 749                 case 'O':       /* berval octet string */
 750                         bv = va_arg( ap, struct berval * );
 751                         if( bv == NULL ) break;
 752                         rc = ber_put_berval( ber, bv, ber->ber_tag );
 753                         break;
 754
 755                 case 's':       /* string */
 756                         s = va_arg( ap, char * );
 757                         rc = ber_put_string( ber, s, ber->ber_tag );
 758                         break;
 759
 760                 case 'B':       /* bit string */
 761                 case 'X':       /* bit string (deprecated) */
 762                         s = va_arg( ap, char * );
 763                         len = va_arg( ap, int );        /* in bits */
 764                         rc = ber_put_bitstring( ber, s, len, ber->ber_tag );
 765                         break;
 766
 767                 case 't':       /* tag for the next element */
 768                         ber->ber_tag = va_arg( ap, ber_tag_t );
 769                         ber->ber_usertag = 1;
 770                         break;
 771
 772                 case 'v':       /* vector of strings */
 773                         if ( (ss = va_arg( ap, char ** )) == NULL )
 774                                 break;
 775                         for ( i = 0; ss[i] != NULL; i++ ) {
 776                                 if ( (rc = ber_put_string( ber, ss[i],
 777                                     ber->ber_tag )) == -1 )
 778                                         break;
 779                         }
 780                         break;
 781
 782                 case 'V':       /* sequences of strings + lengths */
 783                         if ( (bvp = va_arg( ap, struct berval ** )) == NULL )
 784                                 break;
 785                         for ( i = 0; bvp[i] != NULL; i++ ) {
 786                                 if ( (rc = ber_put_berval( ber, bvp[i],
 787                                     ber->ber_tag )) == -1 )
 788                                         break;
 789                         }
 790                         break;
 791
 792                 case 'W':       /* BerVarray */
 793                         if ( (bv = va_arg( ap, BerVarray )) == NULL )
 794                                 break;
 795                         for ( i = 0; bv[i].bv_val != NULL; i++ ) {
 796                                 if ( (rc = ber_put_berval( ber, &bv[i],
 797                                     ber->ber_tag )) == -1 )
 798                                         break;
 799                         }
 800                         break;
 801
 802                 case '{':       /* begin sequence */
 803                         rc = ber_start_seq( ber, ber->ber_tag );
 804                         break;
 805
 806                 case '}':       /* end sequence */
 807                         rc = ber_put_seqorset( ber );
 808                         break;
 809
 810                 case '[':       /* begin set */
 811                         rc = ber_start_set( ber, ber->ber_tag );
 812                         break;
 813
 814                 case ']':       /* end set */
 815                         rc = ber_put_seqorset( ber );
 816                         break;
 817
 818                 default:
 819                         if( ber->ber_debug ) {
 820 #ifdef NEW_LOGGING
 821                                 LDAP_LOG( BER, ERR,
 822                                         "ber_printf: unknown fmt %c\n", *fmt, 0, 0 );
 823 #else
 824                                 ber_log_printf( LDAP_DEBUG_ANY, ber->ber_debug,
 825                                         "ber_printf: unknown fmt %c\n", *fmt );
 826 #endif
 827                         }
 828                         rc = -1;
 829                         break;
 830                 }
 831
 832                 if ( ber->ber_usertag == 0 ) {
 833                         ber->ber_tag = LBER_DEFAULT;
 834                 } else {
 835                         ber->ber_usertag = 0;
 836                 }
 837         }
 838
 839         va_end( ap );
 840
 841         return rc;
 842 }