Back to index

lightning-sunbird  0.9+nobinonly
Defines | Functions | Variables
line64.c File Reference
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/socket.h>
#include "ldaplog.h"
#include "ldif.h"

Go to the source code of this file.

Defines

#define isascii(c)   (!((c) & ~0177))
#define RIGHT2   0x03
#define RIGHT4   0x0f
#define CONTINUED_LINE_MARKER   '\001'
#define ISBLANK(c)   (c == ' ' || c == '\t' || c == '\n') /* not "\r\v\f" */
#define LDIF_OPT_ISSET(value, opt)   (((value) & (opt)) != 0 )
#define LDIF_SAFE_CHAR(c)   ( (c) != '\r' && (c) != '\n' )
#define LDIF_CONSERVATIVE_CHAR(c)
#define LDIF_SAFE_INITCHAR(c)
#define LDIF_CONSERVATIVE_INITCHAR(c)
#define LDIF_CONSERVATIVE_FINALCHAR(c)   ( (c) != ' ' )

Functions

static int ldif_base64_encode_internal (unsigned char *src, char *dst, int srclen, int lenused, int wraplen)
int ldif_parse_line (char *line, char **type, char **value, int *vlen)
int ldif_base64_decode (char *src, unsigned char *dst)
char * ldif_getline (char **next)
void ldif_put_type_and_value_with_options (char **out, char *t, char *val, int vlen, unsigned long options)
void ldif_put_type_and_value (char **out, char *t, char *val, int vlen)
void ldif_put_type_and_value_nowrap (char **out, char *t, char *val, int vlen)
int ldif_base64_encode (unsigned char *src, char *dst, int srclen, int lenused)
int ldif_base64_encode_nowrap (unsigned char *src, char *dst, int srclen, int lenused)
char * ldif_type_and_value_with_options (char *type, char *val, int vlen, unsigned long options)
char * ldif_type_and_value (char *type, char *val, int vlen)
char * ldif_type_and_value_nowrap (char *type, char *val, int vlen)
char * ldif_get_entry (FILE *fp, int *lineno)

Variables

static char nib2b64 [0x40f] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
static unsigned char b642nib [0x80]

Define Documentation

Definition at line 61 of file line64.c.

#define isascii (   c)    (!((c) & ~0177))

Definition at line 56 of file line64.c.

#define ISBLANK (   c)    (c == ' ' || c == '\t' || c == '\n') /* not "\r\v\f" */

Definition at line 63 of file line64.c.

Value:
( LDIF_SAFE_CHAR(c) && isascii((c)) \
                                    && ( isprint((c)) || (c) == '\t' ))

Definition at line 321 of file line64.c.

#define LDIF_CONSERVATIVE_FINALCHAR (   c)    ( (c) != ' ' )

Definition at line 327 of file line64.c.

Value:
( LDIF_SAFE_INITCHAR( c ) && \
                                    ! ( isascii((c)) && isspace((c))))

Definition at line 325 of file line64.c.

#define LDIF_OPT_ISSET (   value,
  opt 
)    (((value) & (opt)) != 0 )

Definition at line 65 of file line64.c.

#define LDIF_SAFE_CHAR (   c)    ( (c) != '\r' && (c) != '\n' )

Definition at line 320 of file line64.c.

Value:
( LDIF_SAFE_CHAR(c) && (c) != ':' \
                                    && (c) != ' ' && (c) != '<' )

Definition at line 323 of file line64.c.

#define RIGHT2   0x03

Definition at line 59 of file line64.c.

#define RIGHT4   0x0f

Definition at line 60 of file line64.c.


Function Documentation

int ldif_base64_decode ( char *  src,
unsigned char *  dst 
)

Definition at line 211 of file line64.c.

{
       char          *p, *stop;
       unsigned char nib, *byte;
       int           i, len;

       stop = strchr( src, '\0' );
       byte = dst;
       for ( p = src, len = 0; p < stop; p += 4, len += 3 ) {
              for ( i = 0; i < 4; i++ ) {
                     if ( p[i] != '=' && (p[i] & 0x80 ||
                         b642nib[ p[i] & 0x7f ] > 0x3f) ) {
                            return( -1 );
                     }
              }

              /* first digit */
              nib = b642nib[ p[0] & 0x7f ];
              byte[0] = nib << 2;

              /* second digit */
              nib = b642nib[ p[1] & 0x7f ];
              byte[0] |= nib >> 4;

              /* third digit */
              if ( p[2] == '=' ) {
                     len += 1;
                     break;
              }
              byte[1] = (nib & RIGHT4) << 4;
              nib = b642nib[ p[2] & 0x7f ];
              byte[1] |= nib >> 2;

              /* fourth digit */
              if ( p[3] == '=' ) {
                     len += 2;
                     break;
              }
              byte[2] = (nib & RIGHT2) << 6;
              nib = b642nib[ p[3] & 0x7f ];
              byte[2] |= nib;

              byte += 3;
       }

       return( len );
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ldif_base64_encode ( unsigned char *  src,
char *  dst,
int  srclen,
int  lenused 
)

Definition at line 504 of file line64.c.

{
    return ldif_base64_encode_internal( src, dst, srclen, lenused, LDIF_MAX_LINE_WIDTH );
}

Here is the call graph for this function:

static int ldif_base64_encode_internal ( unsigned char *  src,
char *  dst,
int  srclen,
int  lenused,
int  wraplen 
) [static]

Definition at line 438 of file line64.c.

{
       unsigned char *byte, *stop;
       unsigned char buf[3];
       char          *out;
       unsigned long bits;
       int           i, pad, len;

       len = 0;
       out = dst;
       stop = src + srclen;

       /* convert to base 64 (3 bytes => 4 base 64 digits) */
       for ( byte = src; byte < stop - 2; byte += 3 ) {
              bits = (byte[0] & 0xff) << 16;
              bits |= (byte[1] & 0xff) << 8;
              bits |= (byte[2] & 0xff);

              for ( i = 0; i < 4; i++, bits <<= 6 ) {
                     if ( wraplen != -1 &&  lenused >= 0 && lenused++ > wraplen ) {
                            *out++ = '\n';
                            *out++ = ' ';
                            lenused = 2;
                     }

                     /* get b64 digit from high order 6 bits */
                     *out++ = nib2b64[ (bits & 0xfc0000L) >> 18 ];
              }
       }

       /* add padding if necessary */
       if ( byte < stop ) {
              for ( i = 0; byte + i < stop; i++ ) {
                     buf[i] = byte[i];
              }
              for ( pad = 0; i < 3; i++, pad++ ) {
                     buf[i] = '\0';
              }
              byte = buf;
              bits = (byte[0] & 0xff) << 16;
              bits |= (byte[1] & 0xff) << 8;
              bits |= (byte[2] & 0xff);

              for ( i = 0; i < 4; i++, bits <<= 6 ) {
                     if ( wraplen != -1 && lenused >= 0 && lenused++ > wraplen ) {
                            *out++ = '\n';
                            *out++ = ' ';
                            lenused = 2;
                     }

                     if (( i == 3 && pad > 0 ) || ( i == 2 && pad == 2 )) {
                            /* Pad as appropriate */
                            *out++ = '=';
                     } else {
                            /* get b64 digit from low order 6 bits */
                            *out++ = nib2b64[ (bits & 0xfc0000L) >> 18 ];
                     }
              }
       }

       *out = '\0';

       return( out - dst );
}

Here is the caller graph for this function:

int ldif_base64_encode_nowrap ( unsigned char *  src,
char *  dst,
int  srclen,
int  lenused 
)

Definition at line 510 of file line64.c.

{
    return ldif_base64_encode_internal( src, dst, srclen, lenused, -1 );
}

Here is the call graph for this function:

char* ldif_get_entry ( FILE fp,
int lineno 
)

Definition at line 555 of file line64.c.

{
       char   line[BUFSIZ];
       char   *buf;
       int    max, cur, len, gotsome;

       buf = NULL;
       max = cur = gotsome = 0;
       while ( fgets( line, sizeof(line), fp ) != NULL ) {
              if ( lineno != NULL ) {
                     (*lineno)++;
              }
              /* ldif entries are terminated by a \n on a line by itself */
              if ( line[0] == '\0' || line[0] == '\n'
#if !defined( XP_WIN32 )
                   || ( line[0] == '\r' && line[1] == '\n' ) /* DOS format */
#endif
                 ) {
                     if ( gotsome ) {
                            break;
                     } else {
                            continue;
                     }
              } else if ( line[0] == '#' ) {
                     continue;
              }
              gotsome = 1;
              len = strlen( line );
#if !defined( XP_WIN32 )
              /* DOS format */
              if ( len > 0 && line[len-1] == '\r' ) {
                     --len;
                     line[len] = '\0';
              } else if ( len > 1 && line[len-2] == '\r' && line[len-1] == '\n' ) {
                     --len;
                     line[len-1] = line[len];
                     line[len] = '\0';
              }
#endif
              while ( cur + (len + 1) > max ) {
                     if ( buf == NULL ) {
                            max += BUFSIZ;
                            buf = (char *) malloc( max );
                     } else {
                            max *= 2;
                            buf = (char *) realloc( buf, max );
                     }
                     if ( buf == NULL ) {
                            return( NULL );
                     }
              }

              memcpy( buf + cur, line, len + 1 );
              cur += len;
       }

       return( buf );
}

Here is the call graph for this function:

char* ldif_getline ( char **  next)

Definition at line 277 of file line64.c.

{
       char   *l;
       char   c;
       char   *p;

       if ( *next == NULL || **next == '\n' || **next == '\0' ) {
              return( NULL );
       }

       while ( **next == '#' ) {   /* skip comment lines */
              if (( *next = strchr( *next, '\n' )) == NULL ) {
                     return( NULL );
              }
              (*next)++;
       }

       l = *next;
       while ( (*next = strchr( *next, '\n' )) != NULL ) {
              p = *next - 1; /* pointer to character previous to the newline */
              c = *(*next + 1); /* character after the newline */
              if ( ISBLANK( c ) && c != '\n' ) {
                     /* DOS EOL is \r\n, so if the character before */
                     /* the \n is \r, continue it too */
                     if (*p == '\r')
                            *p = CONTINUED_LINE_MARKER;
                     **next = CONTINUED_LINE_MARKER;
                     *(*next+1) = CONTINUED_LINE_MARKER;
              } else {
                     /* DOS EOL is \r\n, so if the character before */
                     /* the \n is \r, null it too */
                     if (*p == '\r')
                            *p = '\0';
                     *(*next)++ = '\0';
                     break;
              }
              (*next)++;
       }

       return( l );
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ldif_parse_line ( char *  line,
char **  type,
char **  value,
int vlen 
)

Definition at line 100 of file line64.c.

{
       char   *p, *s, *d;
       int    b64;

       /* skip any leading space */
       while ( ISBLANK( *line ) ) {
              line++;
       }
       *type = line;

       for ( s = line; *s && *s != ':'; s++ )
              ;      /* NULL */
       if ( *s == '\0' ) {

              /* Comment-out while we address calling libldif from ns-back-ldbm
                     on NT. 1 of 3 */
#if defined( _WIN32 )
              /*
#endif
               LDAPDebug( LDAP_DEBUG_PARSE, "ldif_parse_line: missing ':' "
                     "on line \"%s\"\n", line, 0, 0 ); 
#if defined( _WIN32 )
              */
#endif
              return( -1 );
       }

       /* trim any space between type and : */
       for ( p = s - 1; p > line && ISBLANK( *p ); p-- ) {
              *p = '\0';
       }
       *s++ = '\0';

       /* check for double : - indicates base 64 encoded value */
       if ( *s == ':' ) {
              s++;
              b64 = 1;

       /* single : - normally encoded value */
       } else {
              b64 = 0;
       }

       /* skip space between : and value */
       while ( ISBLANK( *s ) ) {
              s++;
       }

       /* 
        * If no value is present, return a zero-length string for
        * *value, with *vlen set to zero.
        */
       if ( *s == '\0' ) {
              *value = s;
              *vlen = 0;
              return( 0 );
       }

       /* check for continued line markers that should be deleted */
       for ( p = s, d = s; *p; p++ ) {
              if ( *p != CONTINUED_LINE_MARKER )
                     *d++ = *p;
       }
       *d = '\0';

       *value = s;
       if ( b64 ) {
              if (( *vlen = ldif_base64_decode( s, (unsigned char *)s ))
                  < 0 ) {
                     /* Comment-out while we address calling libldif from ns-back-ldbm
                            on NT. 3 of 3 */
#if defined( _WIN32 )
              /*
#endif
                      LDAPDebug( LDAP_DEBUG_ANY,
                         "ldif_parse_line: invalid base 64 char on line \"%s\"\n",
                         line, 0, 0 ); 
#if defined( _WIN32 )
              */
#endif
                     return( -1 );
              }
              s[ *vlen ] = '\0';
       } else {
              *vlen = (int) (d - s);
       }

       return( 0 );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ldif_put_type_and_value ( char **  out,
char *  t,
char *  val,
int  vlen 
)

Definition at line 411 of file line64.c.

Here is the call graph for this function:

void ldif_put_type_and_value_nowrap ( char **  out,
char *  t,
char *  val,
int  vlen 
)

Definition at line 417 of file line64.c.

Here is the call graph for this function:

void ldif_put_type_and_value_with_options ( char **  out,
char *  t,
char *  val,
int  vlen,
unsigned long  options 
)

Definition at line 331 of file line64.c.

{
       unsigned char *p, *byte, *stop;
       char          *save;
       int           b64, len, savelen, wraplen;
       len = 0;

       if ( LDIF_OPT_ISSET( options, LDIF_OPT_NOWRAP )) {
              wraplen = -1;
       } else {
              wraplen = LDIF_MAX_LINE_WIDTH;
       }

       /* put the type + ": " */
       for ( p = (unsigned char *) t; *p; p++, len++ ) {
              *(*out)++ = *p;
       }
       *(*out)++ = ':';
       len++;
       if ( LDIF_OPT_ISSET( options, LDIF_OPT_VALUE_IS_URL )) {
              *(*out)++ = '<';     /* add '<' for URLs */
              len++;
       }
       save = *out;
       savelen = len;
       b64 = 0;

       stop = (unsigned char *)val;
       if ( val && vlen > 0 ) {
              *(*out)++ = ' ';
              stop = (unsigned char *) (val + vlen);
              if ( LDIF_OPT_ISSET( options, LDIF_OPT_MINIMAL_ENCODING )) {
                     if ( !LDIF_SAFE_INITCHAR( val[0] )) {
                            b64 = 1;
                     }
              } else {
                     if ( !LDIF_CONSERVATIVE_INITCHAR( val[0] ) ||
                             !LDIF_CONSERVATIVE_FINALCHAR( val[vlen-1] )) {
                            b64 = 1;
                     }
              }
       }

       if ( !b64 ) {
              for ( byte = (unsigned char *) val; byte < stop;
                  byte++, len++ ) {
                     if ( LDIF_OPT_ISSET( options,
                         LDIF_OPT_MINIMAL_ENCODING )) {
                            if ( !LDIF_SAFE_CHAR( *byte )) {
                                   b64 = 1;
                                   break;
                            }
                     } else if ( !LDIF_CONSERVATIVE_CHAR( *byte )) {
                            b64 = 1;
                            break;
                     }
                     
                     if ( wraplen != -1 && len > wraplen ) {
                            *(*out)++ = '\n';
                            *(*out)++ = ' ';
                            len = 1;
                     }
                     *(*out)++ = *byte;
              }
       }

       if ( b64 ) {
              *out = save;
              *(*out)++ = ':';
              *(*out)++ = ' ';
              len = ldif_base64_encode_internal( (unsigned char *)val, *out, vlen,
                  savelen + 2, wraplen );
              *out += len;
       }

       *(*out)++ = '\n';
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* ldif_type_and_value ( char *  type,
char *  val,
int  vlen 
)

Definition at line 538 of file line64.c.

{
    return ldif_type_and_value_with_options( type, val, vlen, 0 );
}

Here is the call graph for this function:

char* ldif_type_and_value_nowrap ( char *  type,
char *  val,
int  vlen 
)

Definition at line 544 of file line64.c.

Here is the call graph for this function:

char* ldif_type_and_value_with_options ( char *  type,
char *  val,
int  vlen,
unsigned long  options 
)

Definition at line 520 of file line64.c.

{
    char      *buf, *p;
    int              tlen;

    tlen = strlen( type );
    if (( buf = (char *)malloc( LDIF_SIZE_NEEDED( tlen, vlen ) + 1 )) !=
           NULL ) {
       p = buf;
       ldif_put_type_and_value_with_options( &p, type, val, vlen, options );
       *p = '\0';
    }

    return( buf );
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

unsigned char b642nib[0x80] [static]
Initial value:
 {
       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
       0xff, 0xff, 0xff, 0x3e, 0xff, 0xff, 0xff, 0x3f,
       0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
       0x3c, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
       0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
       0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
       0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
       0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff,
       0xff, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
       0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
       0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
       0x31, 0x32, 0x33, 0xff, 0xff, 0xff, 0xff, 0xff
}

Definition at line 70 of file line64.c.

char nib2b64[0x40f] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" [static]

Definition at line 67 of file line64.c.