Diff for /libraries/liblber/encode.c between versions 1.21 and 1.22

version 1.21, 1999/06/03 16:24:23 version 1.22, 1999/06/18 21:53:07
Line 30 Line 30
   
 #include "lber-int.h"  #include "lber-int.h"
   
 static int ber_put_len LDAP_P(( BerElement *ber,  static int ber_put_len LDAP_P((
         unsigned long len, int nosos ));          BerElement *ber,
           ber_len_t len,
           int nosos ));
   
 static int ber_start_seqorset LDAP_P(( BerElement *ber,  static int ber_start_seqorset LDAP_P((
         unsigned long tag ));          BerElement *ber,
           ber_tag_t tag ));
   
 static int ber_put_seqorset LDAP_P(( BerElement *ber ));  static int ber_put_seqorset LDAP_P(( BerElement *ber ));
   
 static int ber_put_int_or_enum LDAP_P(( BerElement *ber,  static int ber_put_int_or_enum LDAP_P((
         long num, unsigned long tag ));          BerElement *ber,
           ber_int_t num,
           ber_tag_t tag ));
   
   
 static int  static ber_len_t
 ber_calc_taglen( unsigned long tag )  ber_calc_taglen( ber_tag_t tag )
 {  {
         int     i;          int     i;
         unsigned long   mask;          ber_tag_t       mask;
   
         /* find the first non-all-zero byte in the tag */          /* find the first non-all-zero byte in the tag */
         for ( i = sizeof(long) - 1; i > 0; i-- ) {          for ( i = sizeof(ber_tag_t) - 1; i > 0; i-- ) {
                 mask = (0xffUL << (i * 8));                  mask = ((ber_tag_t)0xffU << (i * 8));
                 /* not all zero */                  /* not all zero */
                 if ( tag & mask )                  if ( tag & mask )
                         break;                          break;
Line 60  ber_calc_taglen( unsigned long tag ) Line 65  ber_calc_taglen( unsigned long tag )
 }  }
   
 static int  static int
 ber_put_tag( BerElement *ber, unsigned long tag, int nosos )  ber_put_tag(
 {          BerElement      *ber,
         int             taglen;          ber_tag_t tag,
         unsigned long   ntag;          int nosos )
   {
           int rc;
           ber_len_t       taglen;
           ber_tag_t       ntag;
   
         assert( ber != NULL );          assert( ber != NULL );
         assert( BER_VALID( ber ) );          assert( BER_VALID( ber ) );
   
         taglen = ber_calc_taglen( tag );          taglen = ber_calc_taglen( tag );
   
         ntag = AC_HTONL( tag );          ntag = LBER_TAG_HTON( tag );
   
           rc = ber_write( ber,
                   ((char *) &ntag) + sizeof(ber_tag_t) - taglen,
               taglen, nosos );
   
         return( ber_write( ber, ((char *) &ntag) + sizeof(long) - taglen,          return rc;
             taglen, nosos ) );  
 }  }
   
 static int  static ber_len_t
 ber_calc_lenlen( unsigned long len )  ber_calc_lenlen( ber_len_t len )
 {  {
         /*          /*
          * short len if it's less than 128 - one byte giving the len,           * short len if it's less than 128 - one byte giving the len,
          * with bit 8 0.           * with bit 8 0.
          */           */
   
         if ( len <= 0x7FUL )          if ( len <= (ber_len_t) 0x7FU )
                 return( 1 );                  return( 1 );
   
         /*          /*
Line 92  ber_calc_lenlen( unsigned long len ) Line 104  ber_calc_lenlen( unsigned long len )
          * length of the length, followed by the length itself.           * length of the length, followed by the length itself.
          */           */
   
         if ( len <= 0xffUL )          if ( len <= (ber_len_t) 0xffU )
                 return( 2 );                  return( 2 );
         if ( len <= 0xffffUL )          if ( len <= (ber_len_t) 0xffffU )
                 return( 3 );                  return( 3 );
         if ( len <= 0xffffffUL )          if ( len <= (ber_len_t) 0xffffffU )
                 return( 4 );                  return( 4 );
   
         return( 5 );          return( 5 );
 }  }
   
 static int  static int
 ber_put_len( BerElement *ber, unsigned long len, int nosos )  ber_put_len( BerElement *ber, ber_len_t len, int nosos )
 {  {
         int             i;          int             i;
         char            lenlen;          char            lenlen;
         unsigned long   mask;          ber_len_t       mask;
         unsigned long   netlen;          ber_len_t       netlen;
   
         assert( ber != NULL );          assert( ber != NULL );
         assert( BER_VALID( ber ) );          assert( BER_VALID( ber ) );
Line 119  ber_put_len( BerElement *ber, unsigned l Line 131  ber_put_len( BerElement *ber, unsigned l
          */           */
   
         if ( len <= 127 ) {          if ( len <= 127 ) {
                 netlen = AC_HTONL( len );                  netlen = LBER_LEN_HTON( len );
                 return( ber_write( ber, (char *) &netlen + sizeof(long) - 1,                  return( ber_write( ber, (char *) &netlen + sizeof(long) - 1,
                     1, nosos ) );                      1, nosos ) );
         }          }
Line 130  ber_put_len( BerElement *ber, unsigned l Line 142  ber_put_len( BerElement *ber, unsigned l
          */           */
   
         /* find the first non-all-zero byte */          /* find the first non-all-zero byte */
         for ( i = sizeof(long) - 1; i > 0; i-- ) {          for ( i = sizeof(ber_len_t) - 1; i > 0; i-- ) {
                 mask = (0xffUL << (i * 8));                  mask = (0xffU << (i * 8));
                 /* not all zero */                  /* not all zero */
                 if ( len & mask )                  if ( len & mask )
                         break;                          break;
Line 146  ber_put_len( BerElement *ber, unsigned l Line 158  ber_put_len( BerElement *ber, unsigned l
                 return( -1 );                  return( -1 );
   
         /* write the length itself */          /* write the length itself */
         netlen = AC_HTONL( len );          netlen = LBER_LEN_HTON( len );
         if ( ber_write( ber, (char *) &netlen + (sizeof(long) - i), i, nosos )          if ( ber_write( ber, (char *) &netlen + (sizeof(ber_len_t) - i), i, nosos )
             != i )              != i )
                 return( -1 );                  return( -1 );
   
Line 155  ber_put_len( BerElement *ber, unsigned l Line 167  ber_put_len( BerElement *ber, unsigned l
 }  }
   
 static int  static int
 ber_put_int_or_enum( BerElement *ber, long num, unsigned long tag )  ber_put_int_or_enum(
           BerElement *ber,
           ber_int_t num,
           ber_tag_t tag )
 {  {
         int     i, sign, taglen;          int     i, sign;
         int     len, lenlen;          ber_len_t       len, lenlen, taglen;
         long    netnum, mask;          ber_int_t       netnum, mask;
   
         assert( ber != NULL );          assert( ber != NULL );
         assert( BER_VALID( ber ) );          assert( BER_VALID( ber ) );
Line 170  ber_put_int_or_enum( BerElement *ber, lo Line 185  ber_put_int_or_enum( BerElement *ber, lo
          * high bit is set - look for first non-all-one byte           * high bit is set - look for first non-all-one byte
          * high bit is clear - look for first non-all-zero byte           * high bit is clear - look for first non-all-zero byte
          */           */
         for ( i = sizeof(long) - 1; i > 0; i-- ) {          for ( i = sizeof(ber_int_t) - 1; i > 0; i-- ) {
                 mask = (0xffUL << (i * 8));                  mask = (0xffU << (i * 8));
   
                 if ( sign ) {                  if ( sign ) {
                         /* not all ones */                          /* not all ones */
Line 188  ber_put_int_or_enum( BerElement *ber, lo Line 203  ber_put_int_or_enum( BerElement *ber, lo
          * we now have the "leading byte".  if the high bit on this           * we now have the "leading byte".  if the high bit on this
          * byte matches the sign bit, we need to "back up" a byte.           * byte matches the sign bit, we need to "back up" a byte.
          */           */
         mask = (num & (0x80UL << (i * 8)));          mask = (num & (0x80U << (i * 8)));
         if ( (mask && !sign) || (sign && !mask) )          if ( (mask && !sign) || (sign && !mask) )
                 i++;                  i++;
   
Line 200  ber_put_int_or_enum( BerElement *ber, lo Line 215  ber_put_int_or_enum( BerElement *ber, lo
         if ( (lenlen = ber_put_len( ber, len, 0 )) == -1 )          if ( (lenlen = ber_put_len( ber, len, 0 )) == -1 )
                 return( -1 );                  return( -1 );
         i++;          i++;
         netnum = AC_HTONL( num );          netnum = LBER_INT_HTON( num );
         if ( ber_write( ber, (char *) &netnum + (sizeof(long) - i), i, 0 )          if ( ber_write( ber, (char *) &netnum + (sizeof(ber_int_t) - i), i, 0 )
            != i )             != i )
                 return( -1 );                  return( -1 );
   
Line 210  ber_put_int_or_enum( BerElement *ber, lo Line 225  ber_put_int_or_enum( BerElement *ber, lo
 }  }
   
 int  int
 ber_put_enum( BerElement *ber, long num, unsigned long tag )  ber_put_enum(
           BerElement *ber,
           ber_int_t num,
           ber_tag_t tag )
 {  {
         assert( ber != NULL );          assert( ber != NULL );
         assert( BER_VALID( ber ) );          assert( BER_VALID( ber ) );
Line 222  ber_put_enum( BerElement *ber, long num, Line 240  ber_put_enum( BerElement *ber, long num,
 }  }
   
 int  int
 ber_put_int( BerElement *ber, long num, unsigned long tag )  ber_put_int(
           BerElement *ber,
           ber_int_t num,
           ber_tag_t tag )
 {  {
         assert( ber != NULL );          assert( ber != NULL );
         assert( BER_VALID( ber ) );          assert( BER_VALID( ber ) );
Line 237  int Line 258  int
 ber_put_ostring(  ber_put_ostring(
         BerElement *ber,          BerElement *ber,
         LDAP_CONST char *str,          LDAP_CONST char *str,
         unsigned long len,          ber_len_t len,
         unsigned long tag )          ber_tag_t tag )
 {  {
         int     taglen, lenlen, rc;          ber_len_t       taglen, lenlen;
           int rc;
 #ifdef STR_TRANSLATION  #ifdef STR_TRANSLATION
         int     free_str;          int     free_str;
 #endif /* STR_TRANSLATION */  #endif /* STR_TRANSLATION */
Line 285  ber_put_ostring( Line 307  ber_put_ostring(
   
         return( rc );          return( rc );
 }  }
   
 int  int
 ber_put_berval(  ber_put_berval(
         BerElement *ber,          BerElement *ber,
         LDAP_CONST struct berval *bv,          LDAP_CONST struct berval *bv,
         unsigned long tag )          ber_tag_t tag )
 {  {
         assert( ber != NULL );          assert( ber != NULL );
         assert( bv != NULL );          assert( bv != NULL );
Line 307  int Line 330  int
 ber_put_string(  ber_put_string(
         BerElement *ber,          BerElement *ber,
         LDAP_CONST char *str,          LDAP_CONST char *str,
         unsigned long tag )          ber_tag_t tag )
 {  {
         assert( ber != NULL );          assert( ber != NULL );
         assert( str != NULL );          assert( str != NULL );
Line 321  int Line 344  int
 ber_put_bitstring(  ber_put_bitstring(
         BerElement *ber,          BerElement *ber,
         LDAP_CONST char *str,          LDAP_CONST char *str,
         unsigned long blen /* in bits */,          ber_len_t blen /* in bits */,
         unsigned long tag )          ber_tag_t tag )
 {  {
         int             taglen, lenlen, len;          ber_len_t               taglen, lenlen, len;
         unsigned char   unusedbits;          unsigned char   unusedbits;
   
         assert( ber != NULL );          assert( ber != NULL );
Line 346  ber_put_bitstring( Line 369  ber_put_bitstring(
         if ( ber_write( ber, (char *)&unusedbits, 1, 0 ) != 1 )          if ( ber_write( ber, (char *)&unusedbits, 1, 0 ) != 1 )
                 return( -1 );                  return( -1 );
   
         if ( ber_write( ber, str, len, 0 ) != len )          if ( (ber_len_t) ber_write( ber, str, len, 0 ) != len )
                 return( -1 );                  return( -1 );
   
         /* return length of tag + length + unused bit count + contents */          /* return length of tag + length + unused bit count + contents */
Line 354  ber_put_bitstring( Line 377  ber_put_bitstring(
 }  }
   
 int  int
 ber_put_null( BerElement *ber, unsigned long tag )  ber_put_null( BerElement *ber, ber_tag_t tag )
 {  {
         int     taglen;          ber_len_t       taglen;
   
         assert( ber != NULL );          assert( ber != NULL );
         assert( BER_VALID( ber ) );          assert( BER_VALID( ber ) );
Line 374  ber_put_null( BerElement *ber, unsigned Line 397  ber_put_null( BerElement *ber, unsigned
 }  }
   
 int  int
 ber_put_boolean( BerElement *ber, int boolval, unsigned long tag )  ber_put_boolean(
           BerElement *ber,
           ber_int_t boolval,
           ber_tag_t tag )
 {  {
         int             taglen;          ber_len_t               taglen;
         unsigned char   trueval = 0xffU;          unsigned char   trueval = 0xFFU;
         unsigned char   falseval = 0x00U;          unsigned char   falseval = 0x00U;
   
         assert( ber != NULL );          assert( ber != NULL );
Line 402  ber_put_boolean( BerElement *ber, int bo Line 428  ber_put_boolean( BerElement *ber, int bo
 #define FOUR_BYTE_LEN   5  #define FOUR_BYTE_LEN   5
   
 static int  static int
 ber_start_seqorset( BerElement *ber, unsigned long tag )  ber_start_seqorset(
           BerElement *ber,
           ber_tag_t tag )
 {  {
         Seqorset        *new;          Seqorset        *new;
   
Line 411  ber_start_seqorset( BerElement *ber, uns Line 439  ber_start_seqorset( BerElement *ber, uns
   
         new = (Seqorset *) LBER_CALLOC( 1, sizeof(Seqorset) );          new = (Seqorset *) LBER_CALLOC( 1, sizeof(Seqorset) );
   
         if ( new == NULLSEQORSET )          if ( new == NULL )
                 return( -1 );                  return( -1 );
   
         new->sos_ber = ber;          new->sos_ber = ber;
         if ( ber->ber_sos == NULLSEQORSET )          if ( ber->ber_sos == NULL )
                 new->sos_first = ber->ber_ptr;                  new->sos_first = ber->ber_ptr;
         else          else
                 new->sos_first = ber->ber_sos->sos_ptr;                  new->sos_first = ber->ber_sos->sos_ptr;
Line 431  ber_start_seqorset( BerElement *ber, uns Line 459  ber_start_seqorset( BerElement *ber, uns
 }  }
   
 int  int
 ber_start_seq( BerElement *ber, unsigned long tag )  ber_start_seq( BerElement *ber, ber_tag_t tag )
 {  {
         assert( ber != NULL );          assert( ber != NULL );
         assert( BER_VALID( ber ) );          assert( BER_VALID( ber ) );
Line 443  ber_start_seq( BerElement *ber, unsigned Line 471  ber_start_seq( BerElement *ber, unsigned
 }  }
   
 int  int
 ber_start_set( BerElement *ber, unsigned long tag )  ber_start_set( BerElement *ber, ber_tag_t tag )
 {  {
         assert( ber != NULL );          assert( ber != NULL );
         assert( BER_VALID( ber ) );          assert( BER_VALID( ber ) );
Line 457  ber_start_set( BerElement *ber, unsigned Line 485  ber_start_set( BerElement *ber, unsigned
 static int  static int
 ber_put_seqorset( BerElement *ber )  ber_put_seqorset( BerElement *ber )
 {  {
         unsigned long   len, netlen;          ber_len_t       len, netlen;
         int             taglen, lenlen;          ber_len_t       taglen, lenlen;
         unsigned char   ltag = 0x80U + FOUR_BYTE_LEN - 1;          unsigned char   ltag = 0x80U + FOUR_BYTE_LEN - 1;
         Seqorset        *next;          Seqorset        *next;
         Seqorset        **sos = &ber->ber_sos;          Seqorset        **sos = &ber->ber_sos;
Line 475  ber_put_seqorset( BerElement *ber ) Line 503  ber_put_seqorset( BerElement *ber )
          */           */
   
         len = (*sos)->sos_clen;          len = (*sos)->sos_clen;
         netlen = AC_HTONL( len );          netlen = LBER_LEN_HTON( len );
         if ( sizeof(long) > 4 && len > 0xffffffffUL )          if ( sizeof(ber_len_t) > 4 && len > 0xffffffffUL )
                 return( -1 );                  return( -1 );
   
         if ( ber->ber_options & LBER_USE_DER ) {          if ( ber->ber_options & LBER_USE_DER ) {
Line 485  ber_put_seqorset( BerElement *ber ) Line 513  ber_put_seqorset( BerElement *ber )
                 lenlen = FOUR_BYTE_LEN;                  lenlen = FOUR_BYTE_LEN;
         }          }
   
         if ( (next = (*sos)->sos_next) == NULLSEQORSET ) {          if ( (next = (*sos)->sos_next) == NULL ) {
                 /* write the tag */                  /* write the tag */
                 if ( (taglen = ber_put_tag( ber, (*sos)->sos_tag, 1 )) == -1 )                  if ( (taglen = ber_put_tag( ber, (*sos)->sos_tag, 1 )) == -1 )
                         return( -1 );                          return( -1 );
Line 520  ber_put_seqorset( BerElement *ber ) Line 548  ber_put_seqorset( BerElement *ber )
                 /* The ber_ptr is at the set/seq start - move it to the end */                  /* The ber_ptr is at the set/seq start - move it to the end */
                 (*sos)->sos_ber->ber_ptr += len;                  (*sos)->sos_ber->ber_ptr += len;
         } else {          } else {
                 unsigned long   ntag;                  ber_tag_t       ntag;
   
                 /* the tag */                  /* the tag */
                 taglen = ber_calc_taglen( (*sos)->sos_tag );                  taglen = ber_calc_taglen( (*sos)->sos_tag );
                 ntag = AC_HTONL( (*sos)->sos_tag );                  ntag = LBER_TAG_HTON( (*sos)->sos_tag );
                 SAFEMEMCPY( (*sos)->sos_first, (char *) &ntag +                  SAFEMEMCPY( (*sos)->sos_first, (char *) &ntag +
                     sizeof(long) - taglen, taglen );                      sizeof(ber_tag_t) - taglen, taglen );
   
                 if ( ber->ber_options & LBER_USE_DER ) {                  if ( ber->ber_options & LBER_USE_DER ) {
                         ltag = (lenlen == 1)                          ltag = (lenlen == 1)
                                 ? (unsigned char) len                                  ? (unsigned char) len
                                 : (unsigned char) (0x80UL + (lenlen - 1));                                  : (unsigned char) (0x80U + (lenlen - 1));
                 }                  }
   
                 /* one byte of length length */                  /* one byte of length length */
Line 541  ber_put_seqorset( BerElement *ber ) Line 569  ber_put_seqorset( BerElement *ber )
                         if (lenlen > 1) {                          if (lenlen > 1) {
                                 /* Write the length itself */                                  /* Write the length itself */
                                 SAFEMEMCPY( (*sos)->sos_first + 2,                                  SAFEMEMCPY( (*sos)->sos_first + 2,
                                     (char *)&netlen + sizeof(unsigned long) -                                      (char *)&netlen + sizeof(ber_len_t) -
                                     (lenlen - 1),                                      (lenlen - 1),
                                     lenlen - 1 );                                      lenlen - 1 );
                         }                          }
Line 558  ber_put_seqorset( BerElement *ber ) Line 586  ber_put_seqorset( BerElement *ber )
                 } else {                  } else {
                         /* the length itself */                          /* the length itself */
                         SAFEMEMCPY( (*sos)->sos_first + taglen + 1,                          SAFEMEMCPY( (*sos)->sos_first + taglen + 1,
                             (char *) &netlen + sizeof(long) -                              (char *) &netlen + sizeof(ber_len_t) -
                             (FOUR_BYTE_LEN - 1), FOUR_BYTE_LEN - 1 );                              (FOUR_BYTE_LEN - 1), FOUR_BYTE_LEN - 1 );
                 }                  }
   
Line 610  va_dcl Line 638  va_dcl
 #endif  #endif
         char            *s, **ss;          char            *s, **ss;
         struct berval   *bv, **bvp;          struct berval   *bv, **bvp;
         int             rc, i;          int             rc;
         unsigned long   len;          ber_int_t       i;
           ber_len_t       len;
   
 #ifdef HAVE_STDARG  #ifdef HAVE_STDARG
         va_start( ap, fmt );          va_start( ap, fmt );
Line 639  va_dcl Line 668  va_dcl
                         } break;                          } break;
   
                 case 'b':       /* boolean */                  case 'b':       /* boolean */
                         i = va_arg( ap, int );                          i = va_arg( ap, ber_int_t );
                         rc = ber_put_boolean( ber, i, ber->ber_tag );                          rc = ber_put_boolean( ber, i, ber->ber_tag );
                         break;                          break;
   
                 case 'i':       /* int */                  case 'i':       /* int */
                         i = va_arg( ap, int );                          i = va_arg( ap, ber_int_t );
                         rc = ber_put_int( ber, i, ber->ber_tag );                          rc = ber_put_int( ber, i, ber->ber_tag );
                         break;                          break;
   
                 case 'e':       /* enumeration */                  case 'e':       /* enumeration */
                         i = va_arg( ap, int );                          i = va_arg( ap, ber_int_t );
                         rc = ber_put_enum( ber, i, ber->ber_tag );                          rc = ber_put_enum( ber, i, ber->ber_tag );
                         break;                          break;
   
Line 659  va_dcl Line 688  va_dcl
   
                 case 'o':       /* octet string (non-null terminated) */                  case 'o':       /* octet string (non-null terminated) */
                         s = va_arg( ap, char * );                          s = va_arg( ap, char * );
                         len = va_arg( ap, int );                          len = va_arg( ap, ber_len_t );
                         rc = ber_put_ostring( ber, s, len, ber->ber_tag );                          rc = ber_put_ostring( ber, s, len, ber->ber_tag );
                         break;                          break;
   
Line 681  va_dcl Line 710  va_dcl
                         break;                          break;
   
                 case 't':       /* tag for the next element */                  case 't':       /* tag for the next element */
                         ber->ber_tag = va_arg( ap, unsigned long );                          ber->ber_tag = va_arg( ap, ber_tag_t );
                         ber->ber_usertag = 1;                          ber->ber_usertag = 1;
                         break;                          break;
   

Removed from v.1.21  
changed lines
  Added in v.1.22


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org