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

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