Use getpassphrase() instead of getpass() if available.

[openldap] / libraries / liblber / decode.c

diff --git a/libraries/liblber/decode.c b/libraries/liblber/decode.c
index 246a315ae269b9a7e5dc7fa077473d0ceb540284..ca24e89c3887ce58416fd44c5863d51a674ecd55 100644 (file)
--- a/libraries/liblber/decode.c
+++ b/libraries/liblber/decode.c
@@ -1,6 +1,7 @@
 /* decode.c - ber input decoding routines */
+/* $OpenLDAP$ */
 /*
- * Copyright 1998-1999 The OpenLDAP Foundation, All Rights Reserved.
+ * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
  */
 /* Portions
@@ -25,12 +26,9 @@
 #include <ac/string.h>
 #include <ac/socket.h>
 
-#undef LDAP_F_PRE
-#define LDAP_F_PRE LDAP_F_EXPORT
-
 #include "lber-int.h"
 
-static ber_tag_t ber_getnint LDAP_P((
+static ber_len_t ber_getnint LDAP_P((
        BerElement *ber,
        ber_int_t *num,
        ber_len_t len ));
@@ -41,7 +39,6 @@ ber_get_tag( BerElement *ber )
 {
        unsigned char   xbyte;
        ber_tag_t       tag;
-       char            *tagp;
        unsigned int    i;
 
        assert( ber != NULL );
@@ -50,16 +47,17 @@ ber_get_tag( BerElement *ber )
        if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 )
                return( LBER_DEFAULT );
 
+       tag = xbyte;
+
        if ( (xbyte & LBER_BIG_TAG_MASK) != LBER_BIG_TAG_MASK )
-               return( (ber_tag_t) xbyte );
+               return tag;
 
-       tagp = (char *) &tag;
-       tagp[0] = xbyte;
        for ( i = 1; i < sizeof(ber_tag_t); i++ ) {
                if ( ber_read( ber, (char *) &xbyte, 1 ) != 1 )
                        return( LBER_DEFAULT );
 
-               tagp[i] = xbyte;
+               tag <<= 8;
+               tag |= 0x00ffUL & (ber_tag_t) xbyte;
 
                if ( ! (xbyte & LBER_MORE_TAG_MASK) )
                        break;
@@ -69,8 +67,7 @@ ber_get_tag( BerElement *ber )
        if ( i == sizeof(ber_tag_t) )
                return( LBER_DEFAULT );
 
-       /* want leading, not trailing 0's */
-       return( tag >> (sizeof(ber_tag_t) - i - 1) );
+       return tag;
 }
 
 ber_tag_t
@@ -78,9 +75,8 @@ ber_skip_tag( BerElement *ber, ber_len_t *len )
 {
        ber_tag_t       tag;
        unsigned char   lc;
-       ber_len_t       noctets;
-       int             diff;
-       ber_len_t       netlen;
+       ber_len_t       i, noctets;
+       unsigned char netlen[sizeof(ber_len_t)];
 
        assert( ber != NULL );
        assert( len != NULL );
@@ -96,6 +92,8 @@ ber_skip_tag( BerElement *ber, ber_len_t *len )
         *      2) primitive encodings used whenever possible
         */
 
+       *len = 0;
+
        /*
         * First, we read the tag.
         */
@@ -107,21 +105,28 @@ ber_skip_tag( BerElement *ber, ber_len_t *len )
         * Next, read the length.  The first byte contains the length of
         * the length.  If bit 8 is set, the length is the long form,
         * otherwise it's the short form.  We don't allow a length that's
-        * greater than what we can hold in an unsigned long.
+        * greater than what we can hold in a ber_len_t.
         */
 
-       *len = netlen = 0;
        if ( ber_read( ber, (char *) &lc, 1 ) != 1 )
                return( LBER_DEFAULT );
+
        if ( lc & 0x80U ) {
                noctets = (lc & 0x7fU);
-               if ( noctets > sizeof(ber_len_t) )
+
+               if ( noctets > sizeof(ber_len_t) ) {
                        return( LBER_DEFAULT );
-               diff = sizeof(ber_len_t) - noctets;
-               if ( (unsigned) ber_read( ber, (char *) &netlen + diff, noctets )
-                   != noctets )
+               }
+
+               if( (unsigned) ber_read( ber, netlen, noctets ) != noctets ) {
                        return( LBER_DEFAULT );
-               *len = LBER_LEN_NTOH( netlen );
+               }
+
+               for( i = 0; i < noctets; i++ ) {
+                       *len <<= 8;
+                       *len |= netlen[i];
+               }
+
        } else {
                *len = lc;
        }
@@ -131,7 +136,7 @@ ber_skip_tag( BerElement *ber, ber_len_t *len )
 
 ber_tag_t
 ber_peek_tag(
-       LDAP_CONST BerElement *ber_in,
+       BerElement *ber_in,
        ber_len_t *len )
 {
        ber_tag_t       tag;
@@ -140,6 +145,8 @@ ber_peek_tag(
        assert( ber_in != NULL );
        assert( BER_VALID( ber_in ) );
 
+       *len = 0;
+
        ber = ber_dup( ber_in );
 
        if( ber == NULL ) {
@@ -154,7 +161,7 @@ ber_peek_tag(
        return( tag );
 }
 
-static ber_tag_t
+static ber_len_t
 ber_getnint(
        BerElement *ber,
        ber_int_t *num,
@@ -215,12 +222,20 @@ ber_get_int(
        if ( (tag = ber_skip_tag( ber, &len )) == LBER_DEFAULT )
                return( LBER_DEFAULT );
 
-       if ( (unsigned long) ber_getnint( ber, num, len ) != len )
+       if ( ber_getnint( ber, num, len ) != len )
                return( LBER_DEFAULT );
        else
                return( tag );
 }
 
+ber_tag_t
+ber_get_enum(
+       BerElement *ber,
+       ber_int_t *num )
+{
+       return ber_get_int( ber, num );
+}
+
 ber_tag_t
 ber_get_stringb(
        BerElement *ber,
@@ -242,7 +257,7 @@ ber_get_stringb(
        if ( datalen > (*len - 1) )
                return( LBER_DEFAULT );
 
-       if ( (unsigned long) ber_read( ber, buf, datalen ) != datalen )
+       if ( (ber_len_t) ber_read( ber, buf, datalen ) != datalen )
                return( LBER_DEFAULT );
 
        buf[datalen] = '\0';
@@ -289,7 +304,7 @@ ber_get_stringa( BerElement *ber, char **buf )
        if ( (*buf = (char *) LBER_MALLOC( datalen + 1 )) == NULL )
                return( LBER_DEFAULT );
 
-       if ( (unsigned long) ber_read( ber, *buf, datalen ) != datalen ) {
+       if ( (ber_len_t) ber_read( ber, *buf, datalen ) != datalen ) {
                LBER_FREE( *buf );
                *buf = NULL;
                return( LBER_DEFAULT );
@@ -393,7 +408,7 @@ ber_get_bitstringa(
                return( LBER_DEFAULT );
        }
 
-       if ( (unsigned long) ber_read( ber, *buf, datalen ) != datalen ) {
+       if ( (ber_len_t) ber_read( ber, *buf, datalen ) != datalen ) {
                LBER_FREE( buf );
                *buf = NULL;
                return( LBER_DEFAULT );
@@ -469,7 +484,7 @@ ber_tag_t
 ber_next_element(
        BerElement *ber,
        ber_len_t *len,
-       char *last )
+       LDAP_CONST char *last )
 {
        assert( ber != NULL );
        assert( len != NULL );
@@ -486,21 +501,11 @@ ber_next_element(
 
 /* VARARGS */
 ber_tag_t
-ber_scanf
-#if HAVE_STDARG
-       ( BerElement *ber,
+ber_scanf ( BerElement *ber,
        LDAP_CONST char *fmt,
        ... )
-#else
-       ( va_alist )
-va_dcl
-#endif
 {
        va_list         ap;
-#ifndef HAVE_STDARG
-       BerElement      *ber;
-       char            *fmt;
-#endif
        LDAP_CONST char         *fmt_reset;
        char            *last;
        char            *s, **ss, ***sss;
@@ -512,13 +517,7 @@ va_dcl
        ber_tag_t       rc, tag;
        ber_len_t       len;
 
-#ifdef HAVE_STDARG
        va_start( ap, fmt );
-#else
-       va_start( ap );
-       ber = va_arg( ap, BerElement * );
-       fmt = va_arg( ap, char * );
-#endif
 
        assert( ber != NULL );
        assert( fmt != NULL );
@@ -672,13 +671,7 @@ va_dcl
             * Error.  Reclaim malloced memory that was given to the caller.
             * Set allocated pointers to NULL, "data length" outvalues to 0.
             */
-#ifdef HAVE_STDARG
            va_start( ap, fmt );
-#else
-           va_start( ap );
-           (void) va_arg( ap, BerElement * );
-           (void) va_arg( ap, char * );
-#endif
 
            for ( ; fmt_reset < fmt; fmt_reset++ ) {
                switch ( *fmt_reset ) {