Diff for /libraries/liblber/encode.c between versions 1.23.4.5 and 1.23.4.6

version 1.23.4.5, 2000/07/29 01:53:07 version 1.23.4.6, 2000/10/12 19:52:39
Line 1 Line 1
 /* encode.c - ber output encoding routines */  /* encode.c - ber output encoding routines */
 /* $OpenLDAP: pkg/ldap/libraries/liblber/encode.c,v 1.23.4.4 2000/07/04 17:58:50 kurt Exp $ */  /* $OpenLDAP: pkg/ldap/libraries/liblber/encode.c,v 1.23.4.5 2000/07/29 01:53:07 kurt Exp $ */
 /*  /*
  * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.   * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file   * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
Line 55  ber_calc_taglen( ber_tag_t tag ) Line 55  ber_calc_taglen( ber_tag_t tag )
         for ( i = sizeof(ber_tag_t) - 1; i > 0; i-- ) {          for ( i = sizeof(ber_tag_t) - 1; i > 0; i-- ) {
                 mask = ((ber_tag_t)0xffU << (i * 8));                  mask = ((ber_tag_t)0xffU << (i * 8));
                 /* not all zero */                  /* not all zero */
                 if ( tag & mask )                  if ( tag & mask ) break;
                         break;  
         }          }
   
         return( i + 1 );          return i + 1;
 }  }
   
 static int  static int
Line 99  ber_calc_lenlen( ber_len_t len ) Line 98  ber_calc_lenlen( ber_len_t len )
          */           */
   
         if ( len <= (ber_len_t) 0x7FU )          if ( len <= (ber_len_t) 0x7FU )
                 return( 1 );                  return 1;
   
         /*          /*
          * long len otherwise - one byte with bit 8 set, giving the           * long len otherwise - one byte with bit 8 set, giving the
Line 107  ber_calc_lenlen( ber_len_t len ) Line 106  ber_calc_lenlen( ber_len_t len )
          */           */
   
         if ( len <= (ber_len_t) 0xffU )          if ( len <= (ber_len_t) 0xffU )
                 return( 2 );                  return 2;
         if ( len <= (ber_len_t) 0xffffU )          if ( len <= (ber_len_t) 0xffffU )
                 return( 3 );                  return 3;
         if ( len <= (ber_len_t) 0xffffffU )          if ( len <= (ber_len_t) 0xffffffU )
                 return( 4 );                  return 4;
   
         return( 5 );          return 5;
 }  }
   
 static int  static int
Line 135  ber_put_len( BerElement *ber, ber_len_t Line 134  ber_put_len( BerElement *ber, ber_len_t
   
         if ( len <= 127 ) {          if ( len <= 127 ) {
                 char length_byte = (char) len;                  char length_byte = (char) len;
                 return( ber_write( ber, &length_byte, 1, nosos ) );                  return ber_write( ber, &length_byte, 1, nosos );
         }          }
   
         /*          /*
Line 147  ber_put_len( BerElement *ber, ber_len_t Line 146  ber_put_len( BerElement *ber, ber_len_t
         for ( i = sizeof(ber_len_t) - 1; i > 0; i-- ) {          for ( i = sizeof(ber_len_t) - 1; i > 0; i-- ) {
                 mask = ((ber_len_t)0xffU << (i * 8));                  mask = ((ber_len_t)0xffU << (i * 8));
                 /* not all zero */                  /* not all zero */
                 if ( len & mask )                  if ( len & mask ) break;
                         break;  
         }          }
         lenlen = (unsigned char) ++i;          lenlen = (unsigned char) ++i;
         if ( lenlen > 4 )          if ( lenlen > 4 )
                 return( -1 );                  return -1;
   
         lenlen |= 0x80UL;          lenlen |= 0x80UL;
   
         /* write the length of the length */          /* write the length of the length */
         if ( ber_write( ber, &lenlen, 1, nosos ) != 1 )          if ( ber_write( ber, &lenlen, 1, nosos ) != 1 )
                 return( -1 );                  return -1;
   
         for( j=0; j<i; j++) {          for( j=0; j<i; j++) {
                 netlen[(sizeof(ber_len_t)-1) - j] = (unsigned char)(len & 0xffU);                  netlen[(sizeof(ber_len_t)-1) - j] = (unsigned char)(len & 0xffU);
Line 200  ber_put_int_or_enum( Line 198  ber_put_int_or_enum(
   
                 if ( sign ) {                  if ( sign ) {
                         /* not all ones */                          /* not all ones */
                         if ( (unum & mask) != mask )                          if ( (unum & mask) != mask ) break;
                                 break;  
                 } else {                  } else {
                         /* not all zero */                          /* not all zero */
                         if ( unum & mask )                          if ( unum & mask ) break;
                                 break;  
                 }                  }
         }          }
   
Line 214  ber_put_int_or_enum( Line 210  ber_put_int_or_enum(
          * 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 = (unum & ((ber_uint_t)0x80U << (i * 8)));          mask = (unum & ((ber_uint_t)0x80U << (i * 8)));
         if ( (mask && !sign) || (sign && !mask) )          if ( (mask && !sign) || (sign && !mask) ) {
                 i++;                  i++;
           }
   
         len = i + 1;          len = i + 1;
   
         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 )          if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
                 return( -1 );                  return -1;
           }
   
         if ( (lenlen = ber_put_len( ber, len, 0 )) == -1 )          if ( (lenlen = ber_put_len( ber, len, 0 )) == -1 )
                 return( -1 );                  return -1;
         i++;          i++;
   
         for( j=0; j<i; j++ ) {          for( j=0; j<i; j++ ) {
Line 248  ber_put_enum( Line 246  ber_put_enum(
         assert( ber != NULL );          assert( ber != NULL );
         assert( BER_VALID( ber ) );          assert( BER_VALID( ber ) );
   
         if ( tag == LBER_DEFAULT )          if ( tag == LBER_DEFAULT ) {
                 tag = LBER_ENUMERATED;                  tag = LBER_ENUMERATED;
           }
   
         return( ber_put_int_or_enum( ber, num, tag ) );          return ber_put_int_or_enum( ber, num, tag );
 }  }
   
 int  int
Line 263  ber_put_int( Line 262  ber_put_int(
         assert( ber != NULL );          assert( ber != NULL );
         assert( BER_VALID( ber ) );          assert( BER_VALID( ber ) );
   
         if ( tag == LBER_DEFAULT )          if ( tag == LBER_DEFAULT ) {
                 tag = LBER_INTEGER;                  tag = LBER_INTEGER;
           }
   
         return( ber_put_int_or_enum( ber, num, tag ) );          return ber_put_int_or_enum( ber, num, tag );
 }  }
   
 int  int
Line 284  ber_put_ostring( Line 284  ber_put_ostring(
   
         assert( BER_VALID( ber ) );          assert( BER_VALID( ber ) );
   
         if ( tag == LBER_DEFAULT )          if ( tag == LBER_DEFAULT ) {
                 tag = LBER_OCTETSTRING;                  tag = LBER_OCTETSTRING;
           }
   
         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 )          if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 )
                 return( -1 );                  return -1;
   
         if ( (lenlen = ber_put_len( ber, len, 0 )) == -1 ||          if ( (lenlen = ber_put_len( ber, len, 0 )) == -1 ||
                 (ber_len_t) ber_write( ber, str, len, 0 ) != len ) {                  (ber_len_t) ber_write( ber, str, len, 0 ) != len ) {
Line 298  ber_put_ostring( Line 299  ber_put_ostring(
                 rc = taglen + lenlen + len;                  rc = taglen + lenlen + len;
         }          }
   
         return( rc );          return rc;
 }  }
   
 int  int
Line 328  ber_put_string( Line 329  ber_put_string(
   
         assert( BER_VALID( ber ) );          assert( BER_VALID( ber ) );
   
         return( ber_put_ostring( ber, str, strlen( str ), tag ));          return ber_put_ostring( ber, str, strlen( str ), tag );
 }  }
   
 int  int
Line 346  ber_put_bitstring( Line 347  ber_put_bitstring(
   
         assert( BER_VALID( ber ) );          assert( BER_VALID( ber ) );
   
         if ( tag == LBER_DEFAULT )          if ( tag == LBER_DEFAULT ) {
                 tag = LBER_BITSTRING;                  tag = LBER_BITSTRING;
           }
   
         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 )          if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
                 return( -1 );                  return -1;
           }
   
         len = ( blen + 7 ) / 8;          len = ( blen + 7 ) / 8;
         unusedbits = (unsigned char) ((len * 8) - blen);          unusedbits = (unsigned char) ((len * 8) - blen);
         if ( (lenlen = ber_put_len( ber, len + 1, 0 )) == -1 )          if ( (lenlen = ber_put_len( ber, len + 1, 0 )) == -1 ) {
                 return( -1 );                  return -1;
           }
   
         if ( ber_write( ber, (char *)&unusedbits, 1, 0 ) != 1 )          if ( ber_write( ber, (char *)&unusedbits, 1, 0 ) != 1 ) {
                 return( -1 );                  return -1;
           }
   
         if ( (ber_len_t) 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 */
         return( taglen + 1 + lenlen + len );          return taglen + 1 + lenlen + len;
 }  }
   
 int  int
Line 375  ber_put_null( BerElement *ber, ber_tag_t Line 381  ber_put_null( BerElement *ber, ber_tag_t
         assert( ber != NULL );          assert( ber != NULL );
         assert( BER_VALID( ber ) );          assert( BER_VALID( ber ) );
   
         if ( tag == LBER_DEFAULT )          if ( tag == LBER_DEFAULT ) {
                 tag = LBER_NULL;                  tag = LBER_NULL;
           }
   
         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 )          if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
                 return( -1 );                  return -1;
           }
   
         if ( ber_put_len( ber, 0, 0 ) != 1 )          if ( ber_put_len( ber, 0, 0 ) != 1 ) {
                 return( -1 );                  return -1;
           }
   
         return( taglen + 1 );          return taglen + 1;
 }  }
   
 int  int
Line 403  ber_put_boolean( Line 412  ber_put_boolean(
         if ( tag == LBER_DEFAULT )          if ( tag == LBER_DEFAULT )
                 tag = LBER_BOOLEAN;                  tag = LBER_BOOLEAN;
   
         if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 )          if ( (taglen = ber_put_tag( ber, tag, 0 )) == -1 ) {
                 return( -1 );                  return -1;
           }
   
         if ( ber_put_len( ber, 1, 0 ) != 1 )          if ( ber_put_len( ber, 1, 0 ) != 1 ) {
                 return( -1 );                  return -1;
           }
   
         if ( ber_write( ber, (char *)(boolval ? &trueval : &falseval), 1, 0 )          if ( ber_write( ber, (char *)(boolval ? &trueval : &falseval), 1, 0 )
             != 1 )                  != 1 )
                 return( -1 );          {
                   return -1;
           }
   
         return( taglen + 2 );          return taglen + 2;
 }  }
   
 #define FOUR_BYTE_LEN   5  #define FOUR_BYTE_LEN   5
Line 430  ber_start_seqorset( Line 443  ber_start_seqorset(
   
         new = (Seqorset *) LBER_CALLOC( 1, sizeof(Seqorset) );          new = (Seqorset *) LBER_CALLOC( 1, sizeof(Seqorset) );
   
         if ( new == NULL )          if ( new == NULL ) {
                 return( -1 );                  return -1;
           }
   
         new->sos_ber = ber;          new->sos_ber = ber;
         if ( ber->ber_sos == NULL )          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;
           }
   
         /* Set aside room for a 4 byte length field */          /* Set aside room for a 4 byte length field */
         new->sos_ptr = new->sos_first + ber_calc_taglen( tag ) + FOUR_BYTE_LEN;          new->sos_ptr = new->sos_first + ber_calc_taglen( tag ) + FOUR_BYTE_LEN;
Line 446  ber_start_seqorset( Line 461  ber_start_seqorset(
         new->sos_next = ber->ber_sos;          new->sos_next = ber->ber_sos;
         ber->ber_sos = new;          ber->ber_sos = new;
   
         return( 0 );          return 0;
 }  }
   
 int  int
Line 455  ber_start_seq( BerElement *ber, ber_tag_ Line 470  ber_start_seq( BerElement *ber, ber_tag_
         assert( ber != NULL );          assert( ber != NULL );
         assert( BER_VALID( ber ) );          assert( BER_VALID( ber ) );
   
         if ( tag == LBER_DEFAULT )          if ( tag == LBER_DEFAULT ) {
                 tag = LBER_SEQUENCE;                  tag = LBER_SEQUENCE;
           }
   
         return( ber_start_seqorset( ber, tag ) );          return ber_start_seqorset( ber, tag );
 }  }
   
 int  int
Line 467  ber_start_set( BerElement *ber, ber_tag_ Line 483  ber_start_set( BerElement *ber, ber_tag_
         assert( ber != NULL );          assert( ber != NULL );
         assert( BER_VALID( ber ) );          assert( BER_VALID( ber ) );
   
         if ( tag == LBER_DEFAULT )          if ( tag == LBER_DEFAULT ) {
                 tag = LBER_SET;                  tag = LBER_SET;
           }
   
         return( ber_start_seqorset( ber, tag ) );          return ber_start_seqorset( ber, tag );
 }  }
   
 static int  static int
Line 497  ber_put_seqorset( BerElement *ber ) Line 514  ber_put_seqorset( BerElement *ber )
   
         len = (*sos)->sos_clen;          len = (*sos)->sos_clen;
   
         if ( sizeof(ber_len_t) > 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 ) {
                 lenlen = ber_calc_lenlen( len );                  lenlen = ber_calc_lenlen( len );
Line 524  ber_put_seqorset( BerElement *ber ) Line 542  ber_put_seqorset( BerElement *ber )
   
                 if ( ber->ber_options & LBER_USE_DER ) {                  if ( ber->ber_options & LBER_USE_DER ) {
                         /* Write the length in the minimum # of octets */                          /* Write the length in the minimum # of octets */
                         if ( ber_put_len( ber, len, 1 ) == -1 )                          if ( ber_put_len( ber, len, 1 ) == -1 ) {
                                 return( -1 );                                  return -1;
                           }
   
                         if (lenlen != FOUR_BYTE_LEN) {                          if (lenlen != FOUR_BYTE_LEN) {
                                 /*                                  /*
Line 540  ber_put_seqorset( BerElement *ber ) Line 559  ber_put_seqorset( BerElement *ber )
                 } else {                  } else {
                         /* Fill FOUR_BYTE_LEN bytes for length field */                          /* Fill FOUR_BYTE_LEN bytes for length field */
                         /* one byte of length length */                          /* one byte of length length */
                         if ( ber_write( ber, (char *)&ltag, 1, 1 ) != 1 )                          if ( ber_write( ber, (char *)&ltag, 1, 1 ) != 1 ) {
                                 return( -1 );                                  return -1;
                           }
   
                         /* the length itself */                          /* the length itself */
                         rc  = ber_write( ber,                          rc  = ber_write( ber,
Line 549  ber_put_seqorset( BerElement *ber ) Line 569  ber_put_seqorset( BerElement *ber )
                                 FOUR_BYTE_LEN-1, 1 );                                  FOUR_BYTE_LEN-1, 1 );
   
                         if( rc != FOUR_BYTE_LEN - 1 ) {                          if( rc != FOUR_BYTE_LEN - 1 ) {
                                 return( -1 );                                  return -1;
                         }                          }
                 }                  }
                 /* 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 */
Line 628  ber_put_seqorset( BerElement *ber ) Line 648  ber_put_seqorset( BerElement *ber )
         LBER_FREE( (char *) (*sos) );          LBER_FREE( (char *) (*sos) );
         *sos = next;          *sos = next;
   
         return( taglen + lenlen + len );          return taglen + lenlen + len;
 }  }
   
 int  int
Line 637  ber_put_seq( BerElement *ber ) Line 657  ber_put_seq( BerElement *ber )
         assert( ber != NULL );          assert( ber != NULL );
         assert( BER_VALID( ber ) );          assert( BER_VALID( ber ) );
   
         return( ber_put_seqorset( ber ) );          return ber_put_seqorset( ber );
 }  }
   
 int  int
Line 646  ber_put_set( BerElement *ber ) Line 666  ber_put_set( BerElement *ber )
         assert( ber != NULL );          assert( ber != NULL );
         assert( BER_VALID( ber ) );          assert( BER_VALID( ber ) );
   
         return( ber_put_seqorset( ber ) );          return ber_put_seqorset( ber );
 }  }
   
 /* N tag */  /* N tag */
Line 792  ber_printf( BerElement *ber, LDAP_CONST Line 812  ber_printf( BerElement *ber, LDAP_CONST
   
         va_end( ap );          va_end( ap );
   
         return( rc );          return rc;
 }  }

Removed from v.1.23.4.5  
changed lines
  Added in v.1.23.4.6


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