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

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