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

   1 /* encode.c - ber output encoding routines */
   2 /*
   3  * Copyright (c) 1990 Regents of the University of Michigan.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms are permitted
   7  * provided that this notice is preserved and that due credit is given
   8  * to the University of Michigan at Ann Arbor. The name of the University
   9  * may not be used to endorse or promote products derived from this
  10  * software without specific prior written permission. This software
  11  * is provided ``as is'' without express or implied warranty.
  12  */
  13
  14 #include "portable.h"
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <ac/string.h>
  19
  20 #ifdef STDC_HEADERS
  21 #include <stdarg.h>
  22 #else
  23 #include <varargs.h>
  24 #endif
  25
  26 #include <sys/types.h>
  27 #include <ac/socket.h>
  28
  29 #include "lber.h"
  30
  31 static int ber_put_len LDAP_P(( BerElement *ber,
  32         unsigned long len, int nosos ));
  33
  34 static int ber_start_seqorset LDAP_P(( BerElement *ber,
  35         unsigned long tag ));
  36
  37 static int ber_put_seqorset LDAP_P(( BerElement *ber ));
  38
  39 static int ber_put_int_or_enum LDAP_P(( BerElement *ber,
  40         long num, unsigned long tag ));
  41
  42
  43 static int
  44 ber_calc_taglen( unsigned long tag )
  45 {
  46         int     i;
  47         long    mask;
  48
  49         /* find the first non-all-zero byte in the tag */
  50         for ( i = sizeof(long) - 1; i > 0; i-- ) {
  51                 mask = (0xffL << (i * 8));
  52                 /* not all zero */
  53                 if ( tag & mask )
  54                         break;
  55         }
  56
  57         return( i + 1 );
  58 }
  59
  60 static int
  61 ber_put_tag( BerElement *ber, unsigned long tag, int nosos )
  62 {
  63         int             taglen;
  64         unsigned long   ntag;
  65
  66         taglen = ber_calc_taglen( tag );
  67
  68         ntag = HTONL( tag );
  69
  70         return( ber_write( ber, ((char *) &ntag) + sizeof(long) - taglen,
  71             taglen, nosos ) );
  72 }
  73
  74 static int
  75 ber_calc_lenlen( unsigned long len )
  76 {
  77         /*
  78          * short len if it's less than 128 - one byte giving the len,
  79          * with bit 8 0.
  80          */
  81
  82         if ( len <= 0x7F )
  83                 return( 1 );
  84
  85         /*
  86          * long len otherwise - one byte with bit 8 set, giving the
  87          * length of the length, followed by the length itself.
  88          */
  89
  90         if ( len <= 0xFF )
  91                 return( 2 );
  92         if ( len <= 0xFFFFL )
  93                 return( 3 );
  94         if ( len <= 0xFFFFFFL )
  95                 return( 4 );
  96
  97         return( 5 );
  98 }
  99
 100 static int
 101 ber_put_len( BerElement *ber, unsigned long len, int nosos )
 102 {
 103         int             i;
 104         char            lenlen;
 105         long            mask;
 106         unsigned long   netlen;
 107
 108         /*
 109          * short len if it's less than 128 - one byte giving the len,
 110          * with bit 8 0.
 111          */
 112
 113         if ( len <= 127 ) {
 114                 netlen = HTONL( len );
 115                 return( ber_write( ber, (char *) &netlen + sizeof(long) - 1,
 116                     1, nosos ) );
 117         }
 118
 119         /*
 120          * long len otherwise - one byte with bit 8 set, giving the
 121          * length of the length, followed by the length itself.
 122          */
 123
 124         /* find the first non-all-zero byte */
 125         for ( i = sizeof(long) - 1; i > 0; i-- ) {
 126                 mask = (0xffL << (i * 8));
 127                 /* not all zero */
 128                 if ( len & mask )
 129                         break;
 130         }
 131         lenlen = ++i;
 132         if ( lenlen > 4 )
 133                 return( -1 );
 134         lenlen |= 0x80;
 135
 136         /* write the length of the length */
 137         if ( ber_write( ber, &lenlen, 1, nosos ) != 1 )
 138                 return( -1 );
 139
 140         /* write the length itself */
 141         netlen = HTONL( len );
 142         if ( ber_write( ber, (char *) &netlen + (sizeof(long) - i), i, nosos )
 143             != i )
 144                 return( -1 );
 145
 146         return( i + 1 );
 147 }
 148
 149 static int
 150 ber_put_int_or_enum( BerElement *ber, long num, unsigned long tag )
 151 {
 152         int     i, sign, taglen;
 153         int     len, lenlen;
 154         long    netnum, mask;
 155
 156         sign = (num < 0);
 157
 158         /*
 159          * high bit is set - look for first non-all-one byte
 160          * high bit is clear - look for first non-all-zero byte
 161          */
 162         for ( i = sizeof(long) - 1; i > 0; i-- ) {
 163                 mask = (0xffL << (i * 8));
 164
 165                 if ( sign ) {
 166                         /* not all ones */
 167                         if ( (num & mask) != mask )
 168                                 break;
 169                 } else {
 170                         /* not all zero */
 171                         if ( num & mask )
 172                                 break;
 173                 }
 174         }
 175
 176         /*
 177          * we now have the "leading byte".  if the high bit on this
 178          * byte matches the sign bit, we need to "back up" a byte.
 179          */
 180         mask = (num & (0x80L << (i * 8)));
 181         if ( (mask && !sign) || (sign && !mask) )
 182                 i++;
 183
 184         len = i + 1;
 185
 186         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 )
 187                 return( -1 );
 188
 189         if ( (lenlen = ber_put_len( ber, len, 0 )) == -1 )
 190                 return( -1 );
 191         i++;
 192         netnum = HTONL( num );
 193         if ( ber_write( ber, (char *) &netnum + (sizeof(long) - i), i, 0 )
 194            != i )
 195                 return( -1 );
 196
 197         /* length of tag + length + contents */
 198         return( taglen + lenlen + i );
 199 }
 200
 201 int
 202 ber_put_enum( BerElement *ber, long num, unsigned long tag )
 203 {
 204         if ( tag == LBER_DEFAULT )
 205                 tag = LBER_ENUMERATED;
 206
 207         return( ber_put_int_or_enum( ber, num, tag ) );
 208 }
 209
 210 int
 211 ber_put_int( BerElement *ber, long num, unsigned long tag )
 212 {
 213         if ( tag == LBER_DEFAULT )
 214                 tag = LBER_INTEGER;
 215
 216         return( ber_put_int_or_enum( ber, num, tag ) );
 217 }
 218
 219 int
 220 ber_put_ostring( BerElement *ber, char *str, unsigned long len,
 221         unsigned long tag )
 222 {
 223         int     taglen, lenlen, rc;
 224 #ifdef STR_TRANSLATION
 225         int     free_str;
 226 #endif /* STR_TRANSLATION */
 227
 228         if ( tag == LBER_DEFAULT )
 229                 tag = LBER_OCTETSTRING;
 230
 231         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 )
 232                 return( -1 );
 233
 234 #ifdef STR_TRANSLATION
 235         if ( len > 0 && ( ber->ber_options & LBER_TRANSLATE_STRINGS ) != 0 &&
 236             ber->ber_encode_translate_proc != NULL ) {
 237                 if ( (*(ber->ber_encode_translate_proc))( &str, &len, 0 )
 238                     != 0 ) {
 239                         return( -1 );
 240                 }
 241                 free_str = 1;
 242         } else {
 243                 free_str = 0;
 244         }
 245 #endif /* STR_TRANSLATION */
 246
 247         if ( (lenlen = ber_put_len( ber, len, 0 )) == -1 ||
 248                 (unsigned long) ber_write( ber, str, len, 0 ) != len ) {
 249                 rc = -1;
 250         } else {
 251                 /* return length of tag + length + contents */
 252                 rc = taglen + lenlen + len;
 253         }
 254
 255 #ifdef STR_TRANSLATION
 256         if ( free_str ) {
 257                 free( str );
 258         }
 259 #endif /* STR_TRANSLATION */
 260
 261         return( rc );
 262 }
 263
 264 int
 265 ber_put_string( BerElement *ber, char *str, unsigned long tag )
 266 {
 267         return( ber_put_ostring( ber, str, strlen( str ), tag ));
 268 }
 269
 270 int
 271 ber_put_bitstring( BerElement *ber, char *str,
 272         unsigned long blen /* in bits */, unsigned long tag )
 273 {
 274         int             taglen, lenlen, len;
 275         unsigned char   unusedbits;
 276
 277         if ( tag == LBER_DEFAULT )
 278                 tag = LBER_BITSTRING;
 279
 280         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 )
 281                 return( -1 );
 282
 283         len = ( blen + 7 ) / 8;
 284         unusedbits = (unsigned char) ((len * 8) - blen);
 285         if ( (lenlen = ber_put_len( ber, len + 1, 0 )) == -1 )
 286                 return( -1 );
 287
 288         if ( ber_write( ber, (char *)&unusedbits, 1, 0 ) != 1 )
 289                 return( -1 );
 290
 291         if ( ber_write( ber, str, len, 0 ) != len )
 292                 return( -1 );
 293
 294         /* return length of tag + length + unused bit count + contents */
 295         return( taglen + 1 + lenlen + len );
 296 }
 297
 298 int
 299 ber_put_null( BerElement *ber, unsigned long tag )
 300 {
 301         int     taglen;
 302
 303         if ( tag == LBER_DEFAULT )
 304                 tag = LBER_NULL;
 305
 306         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 )
 307                 return( -1 );
 308
 309         if ( ber_put_len( ber, 0, 0 ) != 1 )
 310                 return( -1 );
 311
 312         return( taglen + 1 );
 313 }
 314
 315 int
 316 ber_put_boolean( BerElement *ber, int boolval, unsigned long tag )
 317 {
 318         int             taglen;
 319         unsigned char   trueval = 0xff;
 320         unsigned char   falseval = 0x00;
 321
 322         if ( tag == LBER_DEFAULT )
 323                 tag = LBER_BOOLEAN;
 324
 325         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 )
 326                 return( -1 );
 327
 328         if ( ber_put_len( ber, 1, 0 ) != 1 )
 329                 return( -1 );
 330
 331         if ( ber_write( ber, (char *)(boolval ? &trueval : &falseval), 1, 0 )
 332             != 1 )
 333                 return( -1 );
 334
 335         return( taglen + 2 );
 336 }
 337
 338 #define FOUR_BYTE_LEN   5
 339
 340 static int
 341 ber_start_seqorset( BerElement *ber, unsigned long tag )
 342 {
 343         Seqorset        *new;
 344
 345         if ( (new = (Seqorset *) calloc( sizeof(Seqorset), 1 ))
 346             == NULLSEQORSET )
 347                 return( -1 );
 348         new->sos_ber = ber;
 349         if ( ber->ber_sos == NULLSEQORSET )
 350                 new->sos_first = ber->ber_ptr;
 351         else
 352                 new->sos_first = ber->ber_sos->sos_ptr;
 353
 354         /* Set aside room for a 4 byte length field */
 355         new->sos_ptr = new->sos_first + ber_calc_taglen( tag ) + FOUR_BYTE_LEN;
 356         new->sos_tag = tag;
 357
 358         new->sos_next = ber->ber_sos;
 359         ber->ber_sos = new;
 360
 361         return( 0 );
 362 }
 363
 364 int
 365 ber_start_seq( BerElement *ber, unsigned long tag )
 366 {
 367         if ( tag == LBER_DEFAULT )
 368                 tag = LBER_SEQUENCE;
 369
 370         return( ber_start_seqorset( ber, tag ) );
 371 }
 372
 373 int
 374 ber_start_set( BerElement *ber, unsigned long tag )
 375 {
 376         if ( tag == LBER_DEFAULT )
 377                 tag = LBER_SET;
 378
 379         return( ber_start_seqorset( ber, tag ) );
 380 }
 381
 382 static int
 383 ber_put_seqorset( BerElement *ber )
 384 {
 385         unsigned long   len, netlen;
 386         int             taglen, lenlen;
 387         unsigned char   ltag = 0x80 + FOUR_BYTE_LEN - 1;
 388         Seqorset        *next;
 389         Seqorset        **sos = &ber->ber_sos;
 390
 391         /*
 392          * If this is the toplevel sequence or set, we need to actually
 393          * write the stuff out.  Otherwise, it's already been put in
 394          * the appropriate buffer and will be written when the toplevel
 395          * one is written.  In this case all we need to do is update the
 396          * length and tag.
 397          */
 398
 399         len = (*sos)->sos_clen;
 400         netlen = HTONL( len );
 401         if ( sizeof(long) > 4 && len > 0xFFFFFFFFL )
 402                 return( -1 );
 403
 404         if ( ber->ber_options & LBER_USE_DER ) {
 405                 lenlen = ber_calc_lenlen( len );
 406         } else {
 407                 lenlen = FOUR_BYTE_LEN;
 408         }
 409
 410         if ( (next = (*sos)->sos_next) == NULLSEQORSET ) {
 411                 /* write the tag */
 412                 if ( (taglen = ber_put_tag( ber, (*sos)->sos_tag, 1 )) == -1 )
 413                         return( -1 );
 414
 415                 if ( ber->ber_options & LBER_USE_DER ) {
 416                         /* Write the length in the minimum # of octets */
 417                         if ( ber_put_len( ber, len, 1 ) == -1 )
 418                                 return( -1 );
 419
 420                         if (lenlen != FOUR_BYTE_LEN) {
 421                                 /*
 422                                  * We set aside FOUR_BYTE_LEN bytes for
 423                                  * the length field.  Move the data if
 424                                  * we don't actually need that much
 425                                  */
 426                                 SAFEMEMCPY( (*sos)->sos_first + taglen +
 427                                     lenlen, (*sos)->sos_first + taglen +
 428                                     FOUR_BYTE_LEN, len );
 429                         }
 430                 } else {
 431                         /* Fill FOUR_BYTE_LEN bytes for length field */
 432                         /* one byte of length length */
 433                         if ( ber_write( ber, (char *)&ltag, 1, 1 ) != 1 )
 434                                 return( -1 );
 435
 436                         /* the length itself */
 437                         if ( ber_write( ber, (char *) &netlen + sizeof(long)
 438                             - (FOUR_BYTE_LEN - 1), FOUR_BYTE_LEN - 1, 1 )
 439                             != FOUR_BYTE_LEN - 1 )
 440                                 return( -1 );
 441                 }
 442                 /* The ber_ptr is at the set/seq start - move it to the end */
 443                 (*sos)->sos_ber->ber_ptr += len;
 444         } else {
 445                 unsigned long   ntag;
 446
 447                 /* the tag */
 448                 taglen = ber_calc_taglen( (*sos)->sos_tag );
 449                 ntag = HTONL( (*sos)->sos_tag );
 450                 SAFEMEMCPY( (*sos)->sos_first, (char *) &ntag +
 451                     sizeof(long) - taglen, taglen );
 452
 453                 if ( ber->ber_options & LBER_USE_DER ) {
 454                         ltag = (lenlen == 1)
 455                                 ? (unsigned char) len
 456                                 : 0x80 + (lenlen - 1);
 457                 }
 458
 459                 /* one byte of length length */
 460                 SAFEMEMCPY( (*sos)->sos_first + 1, &ltag, 1 );
 461
 462                 if ( ber->ber_options & LBER_USE_DER ) {
 463                         if (lenlen > 1) {
 464                                 /* Write the length itself */
 465                                 SAFEMEMCPY( (*sos)->sos_first + 2,
 466                                     (char *)&netlen + sizeof(unsigned long) -
 467                                     (lenlen - 1),
 468                                     lenlen - 1 );
 469                         }
 470                         if (lenlen != FOUR_BYTE_LEN) {
 471                                 /*
 472                                  * We set aside FOUR_BYTE_LEN bytes for
 473                                  * the length field.  Move the data if
 474                                  * we don't actually need that much
 475                                  */
 476                                 SAFEMEMCPY( (*sos)->sos_first + taglen +
 477                                     lenlen, (*sos)->sos_first + taglen +
 478                                     FOUR_BYTE_LEN, len );
 479                         }
 480                 } else {
 481                         /* the length itself */
 482                         SAFEMEMCPY( (*sos)->sos_first + taglen + 1,
 483                             (char *) &netlen + sizeof(long) -
 484                             (FOUR_BYTE_LEN - 1), FOUR_BYTE_LEN - 1 );
 485                 }
 486
 487                 next->sos_clen += (taglen + lenlen + len);
 488                 next->sos_ptr += (taglen + lenlen + len);
 489         }
 490
 491         /* we're done with this seqorset, so free it up */
 492         free( (char *) (*sos) );
 493         *sos = next;
 494
 495         return( taglen + lenlen + len );
 496 }
 497
 498 int
 499 ber_put_seq( BerElement *ber )
 500 {
 501         return( ber_put_seqorset( ber ) );
 502 }
 503
 504 int
 505 ber_put_set( BerElement *ber )
 506 {
 507         return( ber_put_seqorset( ber ) );
 508 }
 509
 510 /* VARARGS */
 511 int
 512 ber_printf
 513 #ifdef STDC_HEADERS
 514         ( BerElement *ber, char *fmt, ... )
 515 #else
 516         ( va_alist )
 517 va_dcl
 518 #endif
 519 {
 520         va_list         ap;
 521 #ifndef STDC_HEADERS
 522         BerElement      *ber;
 523         char            *fmt;
 524 #endif
 525         char            *s, **ss;
 526         struct berval   **bv;
 527         int             rc, i;
 528         unsigned long   len;
 529
 530 #ifdef STDC_HEADERS
 531         va_start( ap, fmt );
 532 #else
 533         va_start( ap );
 534         ber = va_arg( ap, BerElement * );
 535         fmt = va_arg( ap, char * );
 536 #endif
 537
 538         for ( rc = 0; *fmt && rc != -1; fmt++ ) {
 539                 switch ( *fmt ) {
 540                 case 'b':       /* boolean */
 541                         i = va_arg( ap, int );
 542                         rc = ber_put_boolean( ber, i, ber->ber_tag );
 543                         break;
 544
 545                 case 'i':       /* int */
 546                         i = va_arg( ap, int );
 547                         rc = ber_put_int( ber, i, ber->ber_tag );
 548                         break;
 549
 550                 case 'e':       /* enumeration */
 551                         i = va_arg( ap, int );
 552                         rc = ber_put_enum( ber, i, ber->ber_tag );
 553                         break;
 554
 555                 case 'n':       /* null */
 556                         rc = ber_put_null( ber, ber->ber_tag );
 557                         break;
 558
 559                 case 'o':       /* octet string (non-null terminated) */
 560                         s = va_arg( ap, char * );
 561                         len = va_arg( ap, int );
 562                         rc = ber_put_ostring( ber, s, len, ber->ber_tag );
 563                         break;
 564
 565                 case 's':       /* string */
 566                         s = va_arg( ap, char * );
 567                         rc = ber_put_string( ber, s, ber->ber_tag );
 568                         break;
 569
 570                 case 'B':       /* bit string */
 571                         s = va_arg( ap, char * );
 572                         len = va_arg( ap, int );        /* in bits */
 573                         rc = ber_put_bitstring( ber, s, len, ber->ber_tag );
 574                         break;
 575
 576                 case 't':       /* tag for the next element */
 577                         ber->ber_tag = va_arg( ap, unsigned long );
 578                         ber->ber_usertag = 1;
 579                         break;
 580
 581                 case 'v':       /* vector of strings */
 582                         if ( (ss = va_arg( ap, char ** )) == NULL )
 583                                 break;
 584                         for ( i = 0; ss[i] != NULL; i++ ) {
 585                                 if ( (rc = ber_put_string( ber, ss[i],
 586                                     ber->ber_tag )) == -1 )
 587                                         break;
 588                         }
 589                         break;
 590
 591                 case 'V':       /* sequences of strings + lengths */
 592                         if ( (bv = va_arg( ap, struct berval ** )) == NULL )
 593                                 break;
 594                         for ( i = 0; bv[i] != NULL; i++ ) {
 595                                 if ( (rc = ber_put_ostring( ber, bv[i]->bv_val,
 596                                     bv[i]->bv_len, ber->ber_tag )) == -1 )
 597                                         break;
 598                         }
 599                         break;
 600
 601                 case '{':       /* begin sequence */
 602                         rc = ber_start_seq( ber, ber->ber_tag );
 603                         break;
 604
 605                 case '}':       /* end sequence */
 606                         rc = ber_put_seqorset( ber );
 607                         break;
 608
 609                 case '[':       /* begin set */
 610                         rc = ber_start_set( ber, ber->ber_tag );
 611                         break;
 612
 613                 case ']':       /* end set */
 614                         rc = ber_put_seqorset( ber );
 615                         break;
 616
 617                 default:
 618 #ifdef LDAP_LIBUI
 619                         fprintf( stderr, "unknown fmt %c\n", *fmt );
 620 #endif /* LDAP_LIBUI */
 621                         rc = -1;
 622                         break;
 623                 }
 624
 625                 if ( ber->ber_usertag == 0 )
 626                         ber->ber_tag = LBER_DEFAULT;
 627                 else
 628                         ber->ber_usertag = 0;
 629         }
 630
 631         va_end( ap );
 632
 633         return( rc );
 634 }