1 /* Encode.c - ber output encoding routines */
4 * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
5 * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
8 * Copyright (c) 1990 Regents of the University of Michigan.
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.
23 #include <ac/stdlib.h>
25 #include <ac/stdarg.h>
26 #include <ac/socket.h>
27 #include <ac/string.h>
31 static int ber_put_len LDAP_P((
36 static int ber_start_seqorset LDAP_P((
40 static int ber_put_seqorset LDAP_P(( BerElement *ber ));
42 static int ber_put_int_or_enum LDAP_P((
49 ber_calc_taglen( ber_tag_t tag )
54 /* find the first non-all-zero byte in the tag */
55 for ( i = sizeof(ber_tag_t) - 1; i > 0; i-- ) {
56 mask = ((ber_tag_t)0xffU << (i * 8));
58 if ( tag & mask ) break;
73 unsigned char nettag[sizeof(ber_tag_t)];
75 assert( ber != NULL );
76 assert( LBER_VALID( ber ) );
78 taglen = ber_calc_taglen( tag );
80 for( i=0; i<taglen; i++ ) {
81 nettag[(sizeof(ber_tag_t)-1) - i] = (unsigned char)(tag & 0xffU);
86 &nettag[sizeof(ber_tag_t) - taglen],
93 ber_calc_lenlen( ber_len_t len )
96 * short len if it's less than 128 - one byte giving the len,
100 if ( len <= (ber_len_t) 0x7FU )
104 * long len otherwise - one byte with bit 8 set, giving the
105 * length of the length, followed by the length itself.
108 if ( len <= (ber_len_t) 0xffU )
110 if ( len <= (ber_len_t) 0xffffU )
112 if ( len <= (ber_len_t) 0xffffffU )
119 ber_put_len( BerElement *ber, ber_len_t len, int nosos )
125 unsigned char netlen[sizeof(ber_len_t)];
127 assert( ber != NULL );
128 assert( LBER_VALID( ber ) );
131 * short len if it's less than 128 - one byte giving the len,
136 char length_byte = (char) len;
137 return ber_write( ber, &length_byte, 1, nosos );
141 * long len otherwise - one byte with bit 8 set, giving the
142 * length of the length, followed by the length itself.
145 /* find the first non-all-zero byte */
146 for ( i = sizeof(ber_len_t) - 1; i > 0; i-- ) {
147 mask = ((ber_len_t)0xffU << (i * 8));
149 if ( len & mask ) break;
151 lenlen = (unsigned char) ++i;
157 /* write the length of the length */
158 if ( ber_write( ber, &lenlen, 1, nosos ) != 1 )
161 for( j=0; j<i; j++) {
162 netlen[(sizeof(ber_len_t)-1) - j] = (unsigned char)(len & 0xffU);
166 /* write the length itself */
168 &netlen[sizeof(ber_len_t)-i],
171 return rc == i ? i+1 : -1;
182 ber_len_t len, lenlen, taglen;
183 ber_uint_t unum, mask;
184 unsigned char netnum[sizeof(ber_uint_t)];
186 assert( ber != NULL );
187 assert( LBER_VALID( ber ) );
190 unum = num; /* Bit fiddling should be done with unsigned values */
193 * high bit is set - look for first non-all-one byte
194 * high bit is clear - look for first non-all-zero byte
196 for ( i = sizeof(ber_int_t) - 1; i > 0; i-- ) {
197 mask = ((ber_uint_t)0xffU << (i * 8));
201 if ( (unum & mask) != mask ) break;
204 if ( unum & mask ) break;
209 * we now have the "leading byte". if the high bit on this
210 * byte matches the sign bit, we need to "back up" a byte.
212 mask = (unum & ((ber_uint_t)0x80U << (i * 8)));
213 if ( (mask && !sign) || (sign && !mask) ) {
219 if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
223 if ( (lenlen = ber_put_len( ber, len, 0 )) == -1 )
227 for( j=0; j<i; j++ ) {
228 netnum[(sizeof(ber_int_t)-1) - j] = (unsigned char)(unum & 0xffU);
233 &netnum[sizeof(ber_int_t) - i],
236 /* length of tag + length + contents */
237 return rc == i ? taglen + lenlen + i : -1;
246 assert( ber != NULL );
247 assert( LBER_VALID( ber ) );
249 if ( tag == LBER_DEFAULT ) {
250 tag = LBER_ENUMERATED;
253 return ber_put_int_or_enum( ber, num, tag );
262 assert( ber != NULL );
263 assert( LBER_VALID( ber ) );
265 if ( tag == LBER_DEFAULT ) {
269 return ber_put_int_or_enum( ber, num, tag );
275 LDAP_CONST char *str,
279 ber_len_t taglen, lenlen;
282 assert( ber != NULL );
283 assert( str != NULL );
285 assert( LBER_VALID( ber ) );
287 if ( tag == LBER_DEFAULT ) {
288 tag = LBER_OCTETSTRING;
291 if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 )
294 if ( (lenlen = ber_put_len( ber, len, 0 )) == -1 ||
295 (ber_len_t) ber_write( ber, str, len, 0 ) != len ) {
298 /* return length of tag + length + contents */
299 rc = taglen + lenlen + len;
311 assert( ber != NULL );
312 assert( LBER_VALID( ber ) );
314 if( bv == NULL || bv->bv_len == 0 ) {
315 return ber_put_ostring( ber, "", (ber_len_t) 0, tag );
318 return ber_put_ostring( ber, bv->bv_val, bv->bv_len, tag );
324 LDAP_CONST char *str,
327 assert( ber != NULL );
328 assert( str != NULL );
330 assert( LBER_VALID( ber ) );
332 return ber_put_ostring( ber, str, strlen( str ), tag );
338 LDAP_CONST char *str,
339 ber_len_t blen /* in bits */,
342 ber_len_t taglen, lenlen, len;
343 unsigned char unusedbits;
345 assert( ber != NULL );
346 assert( str != NULL );
348 assert( LBER_VALID( ber ) );
350 if ( tag == LBER_DEFAULT ) {
351 tag = LBER_BITSTRING;
354 if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
358 len = ( blen + 7 ) / 8;
359 unusedbits = (unsigned char) ((len * 8) - blen);
360 if ( (lenlen = ber_put_len( ber, len + 1, 0 )) == -1 ) {
364 if ( ber_write( ber, (char *)&unusedbits, 1, 0 ) != 1 ) {
368 if ( (ber_len_t) ber_write( ber, str, len, 0 ) != len ) {
372 /* return length of tag + length + unused bit count + contents */
373 return taglen + 1 + lenlen + len;
377 ber_put_null( BerElement *ber, ber_tag_t tag )
381 assert( ber != NULL );
382 assert( LBER_VALID( ber ) );
384 if ( tag == LBER_DEFAULT ) {
388 if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
392 if ( ber_put_len( ber, 0, 0 ) != 1 ) {
406 unsigned char trueval = (unsigned char) -1;
407 unsigned char falseval = 0;
409 assert( ber != NULL );
410 assert( LBER_VALID( ber ) );
412 if ( tag == LBER_DEFAULT )
415 if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
419 if ( ber_put_len( ber, 1, 0 ) != 1 ) {
423 if ( ber_write( ber, (char *)(boolval ? &trueval : &falseval), 1, 0 )
432 #define FOUR_BYTE_LEN 5
441 assert( ber != NULL );
442 assert( LBER_VALID( ber ) );
444 new = (Seqorset *) LBER_CALLOC( 1, sizeof(Seqorset) );
451 if ( ber->ber_sos == NULL ) {
452 new->sos_first = ber->ber_ptr;
454 new->sos_first = ber->ber_sos->sos_ptr;
457 /* Set aside room for a 4 byte length field */
458 new->sos_ptr = new->sos_first + ber_calc_taglen( tag ) + FOUR_BYTE_LEN;
461 new->sos_next = ber->ber_sos;
468 ber_start_seq( BerElement *ber, ber_tag_t tag )
470 assert( ber != NULL );
471 assert( LBER_VALID( ber ) );
473 if ( tag == LBER_DEFAULT ) {
477 return ber_start_seqorset( ber, tag );
481 ber_start_set( BerElement *ber, ber_tag_t tag )
483 assert( ber != NULL );
484 assert( LBER_VALID( ber ) );
486 if ( tag == LBER_DEFAULT ) {
490 return ber_start_seqorset( ber, tag );
494 ber_put_seqorset( BerElement *ber )
498 unsigned char netlen[sizeof(ber_len_t)];
499 ber_len_t taglen, lenlen;
500 unsigned char ltag = 0x80U + FOUR_BYTE_LEN - 1;
502 Seqorset **sos = &ber->ber_sos;
504 assert( ber != NULL );
505 assert( LBER_VALID( ber ) );
507 if( *sos == NULL ) return -1;
510 * If this is the toplevel sequence or set, we need to actually
511 * write the stuff out. Otherwise, it's already been put in
512 * the appropriate buffer and will be written when the toplevel
513 * one is written. In this case all we need to do is update the
517 len = (*sos)->sos_clen;
519 if ( sizeof(ber_len_t) > 4 && len > 0xffffffffUL ) {
523 if ( ber->ber_options & LBER_USE_DER ) {
524 lenlen = ber_calc_lenlen( len );
527 lenlen = FOUR_BYTE_LEN;
532 for( i=0; i < lenlen-1; i++ ) {
533 netlen[(sizeof(ber_len_t)-1) - i] =
534 (unsigned char)((len >> i*8) & 0xffU);
537 netlen[sizeof(ber_len_t)-1] = (unsigned char)(len & 0x7fU);
540 if ( (next = (*sos)->sos_next) == NULL ) {
542 if ( (taglen = ber_put_tag( ber, (*sos)->sos_tag, 1 )) == -1 )
545 if ( ber->ber_options & LBER_USE_DER ) {
546 /* Write the length in the minimum # of octets */
547 if ( ber_put_len( ber, len, 1 ) == -1 ) {
551 if (lenlen != FOUR_BYTE_LEN) {
553 * We set aside FOUR_BYTE_LEN bytes for
554 * the length field. Move the data if
555 * we don't actually need that much
557 AC_MEMCPY( (*sos)->sos_first + taglen +
558 lenlen, (*sos)->sos_first + taglen +
559 FOUR_BYTE_LEN, len );
562 /* Fill FOUR_BYTE_LEN bytes for length field */
563 /* one byte of length length */
564 if ( ber_write( ber, (char *)<ag, 1, 1 ) != 1 ) {
568 /* the length itself */
570 &netlen[sizeof(ber_len_t) - (FOUR_BYTE_LEN-1)],
571 FOUR_BYTE_LEN-1, 1 );
573 if( rc != FOUR_BYTE_LEN - 1 ) {
577 /* The ber_ptr is at the set/seq start - move it to the end */
578 (*sos)->sos_ber->ber_ptr += len;
582 unsigned char nettag[sizeof(ber_tag_t)];
583 ber_tag_t tmptag = (*sos)->sos_tag;
585 if( ber->ber_sos->sos_ptr > ber->ber_end ) {
586 /* The sos_ptr exceeds the end of the BerElement
587 * this can happen, for example, when the sos_ptr
588 * is near the end and no data was written for the
589 * 'V'. We must realloc the BerElement to ensure
590 * we don't overwrite the buffer when writing
591 * the tag and length fields.
593 ber_len_t ext = ber->ber_sos->sos_ptr - ber->ber_end;
595 if( ber_realloc( ber, ext ) != 0 ) {
601 taglen = ber_calc_taglen( tmptag );
603 for( i = 0; i < taglen; i++ ) {
604 nettag[(sizeof(ber_tag_t)-1) - i] = (unsigned char)(tmptag & 0xffU);
608 AC_FMEMCPY( (*sos)->sos_first,
609 &nettag[sizeof(ber_tag_t) - taglen],
612 if ( ber->ber_options & LBER_USE_DER ) {
614 ? (unsigned char) len
615 : (unsigned char) (0x80U + (lenlen - 1));
618 /* one byte of length length */
619 (*sos)->sos_first[1] = ltag;
621 if ( ber->ber_options & LBER_USE_DER ) {
623 /* Write the length itself */
624 AC_FMEMCPY( (*sos)->sos_first + 2,
625 &netlen[sizeof(ber_len_t) - (lenlen - 1)],
628 if (lenlen != FOUR_BYTE_LEN) {
630 * We set aside FOUR_BYTE_LEN bytes for
631 * the length field. Move the data if
632 * we don't actually need that much
634 AC_FMEMCPY( (*sos)->sos_first + taglen +
635 lenlen, (*sos)->sos_first + taglen +
636 FOUR_BYTE_LEN, len );
639 /* the length itself */
640 AC_FMEMCPY( (*sos)->sos_first + taglen + 1,
641 &netlen[sizeof(ber_len_t) - (FOUR_BYTE_LEN - 1)],
645 next->sos_clen += (taglen + lenlen + len);
646 next->sos_ptr += (taglen + lenlen + len);
649 /* we're done with this seqorset, so free it up */
650 LBER_FREE( (char *) (*sos) );
653 return taglen + lenlen + len;
657 ber_put_seq( BerElement *ber )
659 assert( ber != NULL );
660 assert( LBER_VALID( ber ) );
662 return ber_put_seqorset( ber );
666 ber_put_set( BerElement *ber )
668 assert( ber != NULL );
669 assert( LBER_VALID( ber ) );
671 return ber_put_seqorset( ber );
675 static ber_tag_t lber_int_null = 0;
679 ber_printf( BerElement *ber, LDAP_CONST char *fmt, ... )
683 struct berval *bv, **bvp;
688 assert( ber != NULL );
689 assert( fmt != NULL );
691 assert( LBER_VALID( ber ) );
695 for ( rc = 0; *fmt && rc != -1; fmt++ ) {
697 case '!': { /* hook */
698 BEREncodeCallback *f;
701 f = va_arg( ap, BEREncodeCallback * );
702 p = va_arg( ap, void * );
707 case 'b': /* boolean */
708 i = va_arg( ap, ber_int_t );
709 rc = ber_put_boolean( ber, i, ber->ber_tag );
713 i = va_arg( ap, ber_int_t );
714 rc = ber_put_int( ber, i, ber->ber_tag );
717 case 'e': /* enumeration */
718 i = va_arg( ap, ber_int_t );
719 rc = ber_put_enum( ber, i, ber->ber_tag );
723 rc = ber_put_null( ber, ber->ber_tag );
726 case 'N': /* Debug NULL */
727 if( lber_int_null != 0 ) {
728 /* Insert NULL to ensure peer ignores unknown tags */
729 rc = ber_put_null( ber, lber_int_null );
735 case 'o': /* octet string (non-null terminated) */
736 s = va_arg( ap, char * );
737 len = va_arg( ap, ber_len_t );
738 rc = ber_put_ostring( ber, s, len, ber->ber_tag );
741 case 'O': /* berval octet string */
742 bv = va_arg( ap, struct berval * );
743 if( bv == NULL ) break;
744 rc = ber_put_berval( ber, bv, ber->ber_tag );
747 case 's': /* string */
748 s = va_arg( ap, char * );
749 rc = ber_put_string( ber, s, ber->ber_tag );
752 case 'B': /* bit string */
753 case 'X': /* bit string (deprecated) */
754 s = va_arg( ap, char * );
755 len = va_arg( ap, int ); /* in bits */
756 rc = ber_put_bitstring( ber, s, len, ber->ber_tag );
759 case 't': /* tag for the next element */
760 ber->ber_tag = va_arg( ap, ber_tag_t );
761 ber->ber_usertag = 1;
764 case 'v': /* vector of strings */
765 if ( (ss = va_arg( ap, char ** )) == NULL )
767 for ( i = 0; ss[i] != NULL; i++ ) {
768 if ( (rc = ber_put_string( ber, ss[i],
769 ber->ber_tag )) == -1 )
774 case 'V': /* sequences of strings + lengths */
775 if ( (bvp = va_arg( ap, struct berval ** )) == NULL )
777 for ( i = 0; bvp[i] != NULL; i++ ) {
778 if ( (rc = ber_put_berval( ber, bvp[i],
779 ber->ber_tag )) == -1 )
784 case 'W': /* BerVarray */
785 if ( (bv = va_arg( ap, BerVarray )) == NULL )
787 for ( i = 0; bv[i].bv_val != NULL; i++ ) {
788 if ( (rc = ber_put_berval( ber, &bv[i],
789 ber->ber_tag )) == -1 )
794 case '{': /* begin sequence */
795 rc = ber_start_seq( ber, ber->ber_tag );
798 case '}': /* end sequence */
799 rc = ber_put_seqorset( ber );
802 case '[': /* begin set */
803 rc = ber_start_set( ber, ber->ber_tag );
806 case ']': /* end set */
807 rc = ber_put_seqorset( ber );
811 if( ber->ber_debug ) {
813 LDAP_LOG(( "liblber", LDAP_LEVEL_ERR,
814 "ber_printf: unknown fmt %c\n", *fmt ));
816 ber_log_printf( LDAP_DEBUG_ANY, ber->ber_debug,
817 "ber_printf: unknown fmt %c\n", *fmt );
824 if ( ber->ber_usertag == 0 )
825 ber->ber_tag = LBER_DEFAULT;
827 ber->ber_usertag = 0;