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

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