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