git.sur5r.net Git - openldap/blob - libraries/libldif/line64.c

   1 /* line64.c - routines for dealing with the slapd line format */
   2
   3 #include "portable.h"
   4
   5 #include <stdio.h>
   6 #include <ctype.h>
   7
   8 #include <ac/string.h>
   9 #include <ac/socket.h>
  10
  11 #include "lber.h"
  12 #include "ldap.h"
  13 #include "ldif.h"
  14
  15 #define RIGHT2                  0x03
  16 #define RIGHT4                  0x0f
  17 #define CONTINUED_LINE_MARKER   '\001'
  18
  19 static char nib2b64[0x40f] =
  20         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  21
  22 static unsigned char b642nib[0x80] = {
  23         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  24         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  25         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  26         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  27         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  28         0xff, 0xff, 0xff, 0x3e, 0xff, 0xff, 0xff, 0x3f,
  29         0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
  30         0x3c, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  31         0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
  32         0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
  33         0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
  34         0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff,
  35         0xff, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
  36         0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
  37         0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
  38         0x31, 0x32, 0x33, 0xff, 0xff, 0xff, 0xff, 0xff
  39 };
  40
  41 /*
  42  * str_parse_line - takes a line of the form "type:[:] value" and splits it
  43  * into components "type" and "value".  if a double colon separates type from
  44  * value, then value is encoded in base 64, and parse_line un-decodes it
  45  * (in place) before returning.
  46  */
  47
  48 int
  49 str_parse_line(
  50     char        *line,
  51     char        **type,
  52     char        **value,
  53     int         *vlen
  54 )
  55 {
  56         char    *p, *s, *d, *byte, *stop;
  57         char    nib;
  58         int     i, b64;
  59
  60         /* skip any leading space */
  61         while ( isspace( *line ) ) {
  62                 line++;
  63         }
  64         *type = line;
  65
  66         for ( s = line; *s && *s != ':'; s++ )
  67                 ;       /* NULL */
  68         if ( *s == '\0' ) {
  69                 Debug( LDAP_DEBUG_PARSE, "parse_line missing ':'\n", 0, 0, 0 );
  70                 return( -1 );
  71         }
  72
  73         /* trim any space between type and : */
  74         for ( p = s - 1; p > line && isspace( *p ); p-- ) {
  75                 *p = '\0';
  76         }
  77         *s++ = '\0';
  78
  79         /* check for double : - indicates base 64 encoded value */
  80         if ( *s == ':' ) {
  81                 s++;
  82                 b64 = 1;
  83
  84         /* single : - normally encoded value */
  85         } else {
  86                 b64 = 0;
  87         }
  88
  89         /* skip space between : and value */
  90         while ( isspace( *s ) ) {
  91                 s++;
  92         }
  93
  94         /* if no value is present, error out */
  95         if ( *s == '\0' ) {
  96                 Debug( LDAP_DEBUG_PARSE, "parse_line missing value\n", 0,0,0 );
  97                 return( -1 );
  98         }
  99
 100         /* check for continued line markers that should be deleted */
 101         for ( p = s, d = s; *p; p++ ) {
 102                 if ( *p != CONTINUED_LINE_MARKER )
 103                         *d++ = *p;
 104         }
 105         *d = '\0';
 106
 107         *value = s;
 108         if ( b64 ) {
 109                 stop = strchr( s, '\0' );
 110                 byte = s;
 111                 for ( p = s, *vlen = 0; p < stop; p += 4, *vlen += 3 ) {
 112                         for ( i = 0; i < 3; i++ ) {
 113                                 if ( p[i] != '=' && (p[i] & 0x80 ||
 114                                     b642nib[ p[i] & 0x7f ] > 0x3f) ) {
 115                                         Debug( LDAP_DEBUG_ANY,
 116                                     "invalid base 64 encoding char (%c) 0x%x\n",
 117                                             p[i], p[i], 0 );
 118                                         return( -1 );
 119                                 }
 120                         }
 121
 122                         /* first digit */
 123                         nib = b642nib[ p[0] & 0x7f ];
 124                         byte[0] = nib << 2;
 125                         /* second digit */
 126                         nib = b642nib[ p[1] & 0x7f ];
 127                         byte[0] |= nib >> 4;
 128                         byte[1] = (nib & RIGHT4) << 4;
 129                         /* third digit */
 130                         if ( p[2] == '=' ) {
 131                                 *vlen += 1;
 132                                 break;
 133                         }
 134                         nib = b642nib[ p[2] & 0x7f ];
 135                         byte[1] |= nib >> 2;
 136                         byte[2] = (nib & RIGHT2) << 6;
 137                         /* fourth digit */
 138                         if ( p[3] == '=' ) {
 139                                 *vlen += 2;
 140                                 break;
 141                         }
 142                         nib = b642nib[ p[3] & 0x7f ];
 143                         byte[2] |= nib;
 144
 145                         byte += 3;
 146                 }
 147                 s[ *vlen ] = '\0';
 148         } else {
 149                 *vlen = (int) (d - s);
 150         }
 151
 152         return( 0 );
 153 }
 154
 155 /*
 156  * str_getline - return the next "line" (minus newline) of input from a
 157  * string buffer of lines separated by newlines, terminated by \n\n
 158  * or \0.  this routine handles continued lines, bundling them into
 159  * a single big line before returning.  if a line begins with a white
 160  * space character, it is a continuation of the previous line. the white
 161  * space character (nb: only one char), and preceeding newline are changed
 162  * into CONTINUED_LINE_MARKER chars, to be deleted later by the
 163  * str_parse_line() routine above.
 164  *
 165  * it takes a pointer to a pointer to the buffer on the first call,
 166  * which it updates and must be supplied on subsequent calls.
 167  */
 168
 169 char *
 170 str_getline( char **next )
 171 {
 172         char    *l;
 173         char    c;
 174
 175         if ( *next == NULL || **next == '\n' || **next == '\0' ) {
 176                 return( NULL );
 177         }
 178
 179         l = *next;
 180         while ( (*next = strchr( *next, '\n' )) != NULL ) {
 181                 c = *(*next + 1);
 182                 if ( isspace( c ) && c != '\n' ) {
 183                         **next = CONTINUED_LINE_MARKER;
 184                         *(*next+1) = CONTINUED_LINE_MARKER;
 185                 } else {
 186                         *(*next)++ = '\0';
 187                         break;
 188                 }
 189                 *(*next)++;
 190         }
 191
 192         return( l );
 193 }
 194
 195 void
 196 put_type_and_value( char **out, char *t, char *val, int vlen )
 197 {
 198         unsigned char   *byte, *p, *stop;
 199         unsigned char   buf[3];
 200         unsigned long   bits;
 201         char            *save;
 202         int             i, b64, pad, len, savelen;
 203         len = 0;
 204
 205         /* put the type + ": " */
 206         for ( p = (unsigned char *) t; *p; p++, len++ ) {
 207                 *(*out)++ = *p;
 208         }
 209         *(*out)++ = ':';
 210         len++;
 211         save = *out;
 212         savelen = len;
 213         *(*out)++ = ' ';
 214         b64 = 0;
 215
 216         stop = (unsigned char *) (val + vlen);
 217         if ( isascii( val[0] ) && isspace( val[0] ) || val[0] == ':' ) {
 218                 b64 = 1;
 219         } else {
 220                 for ( byte = (unsigned char *) val; byte < stop;
 221                     byte++, len++ ) {
 222                         if ( !isascii( *byte ) || !isprint( *byte ) ) {
 223                                 b64 = 1;
 224                                 break;
 225                         }
 226                         if ( len > LINE_WIDTH ) {
 227                                 *(*out)++ = '\n';
 228                                 *(*out)++ = ' ';
 229                                 len = 1;
 230                         }
 231                         *(*out)++ = *byte;
 232                 }
 233         }
 234         if ( b64 ) {
 235                 *out = save;
 236                 *(*out)++ = ':';
 237                 *(*out)++ = ' ';
 238                 len = savelen + 2;
 239                 /* convert to base 64 (3 bytes => 4 base 64 digits) */
 240                 for ( byte = (unsigned char *) val; byte < stop - 2;
 241                     byte += 3 ) {
 242                         bits = (byte[0] & 0xff) << 16;
 243                         bits |= (byte[1] & 0xff) << 8;
 244                         bits |= (byte[2] & 0xff);
 245
 246                         for ( i = 0; i < 4; i++, len++, bits <<= 6 ) {
 247                                 if ( len > LINE_WIDTH ) {
 248                                         *(*out)++ = '\n';
 249                                         *(*out)++ = ' ';
 250                                         len = 1;
 251                                 }
 252
 253                                 /* get b64 digit from high order 6 bits */
 254                                 *(*out)++ = nib2b64[ (bits & 0xfc0000L) >> 18 ];
 255                         }
 256                 }
 257
 258                 /* add padding if necessary */
 259                 if ( byte < stop ) {
 260                         for ( i = 0; byte + i < stop; i++ ) {
 261                                 buf[i] = byte[i];
 262                         }
 263                         for ( pad = 0; i < 3; i++, pad++ ) {
 264                                 buf[i] = '\0';
 265                         }
 266                         byte = buf;
 267                         bits = (byte[0] & 0xff) << 16;
 268                         bits |= (byte[1] & 0xff) << 8;
 269                         bits |= (byte[2] & 0xff);
 270
 271                         for ( i = 0; i < 4; i++, len++, bits <<= 6 ) {
 272                                 if ( len > LINE_WIDTH ) {
 273                                         *(*out)++ = '\n';
 274                                         *(*out)++ = ' ';
 275                                         len = 1;
 276                                 }
 277
 278                                 /* get b64 digit from low order 6 bits */
 279                                 *(*out)++ = nib2b64[ (bits & 0xfc0000L) >> 18 ];
 280                         }
 281
 282                         for ( ; pad > 0; pad-- ) {
 283                                 *(*out - pad) = '=';
 284                         }
 285                 }
 286         }
 287         *(*out)++ = '\n';
 288 }
 289
 290
 291 char *
 292 ldif_type_and_value( char *type, char *val, int vlen )
 293 /*
 294  * return malloc'd, zero-terminated LDIF line
 295  */
 296 {
 297     char        *buf, *p;
 298     int         tlen;
 299
 300     tlen = strlen( type );
 301     if (( buf = (char *)malloc( LDIF_SIZE_NEEDED( tlen, vlen ) + 1 )) !=
 302             NULL ) {
 303     }
 304
 305     p = buf;
 306     put_type_and_value( &p, type, val, vlen );
 307     *p = '\0';
 308
 309     return( buf );
 310 }