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
   7 #include <ac/stdlib.h>
   8 #include <ac/ctype.h>
   9
  10 #include <ac/string.h>
  11 #include <ac/socket.h>
  12 #include <ac/time.h>
  13
  14 int ldif_debug = 0;
  15
  16 #include "ldap_log.h"
  17 #include "lber_pvt.h"
  18 #include "ldif.h"
  19
  20 #define RIGHT2                  0x03
  21 #define RIGHT4                  0x0f
  22 #define CONTINUED_LINE_MARKER   '\001'
  23
  24 static const char nib2b64[0x40] =
  25         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  26
  27 static const unsigned char b642nib[0x80] = {
  28         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  29         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  30         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  31         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  32         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  33         0xff, 0xff, 0xff, 0x3e, 0xff, 0xff, 0xff, 0x3f,
  34         0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
  35         0x3c, 0x3d, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  36         0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
  37         0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
  38         0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
  39         0x17, 0x18, 0x19, 0xff, 0xff, 0xff, 0xff, 0xff,
  40         0xff, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
  41         0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
  42         0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
  43         0x31, 0x32, 0x33, 0xff, 0xff, 0xff, 0xff, 0xff
  44 };
  45
  46 /*
  47  * ldif_parse_line - takes a line of the form "type:[:] value" and splits it
  48  * into components "type" and "value".  if a double colon separates type from
  49  * value, then value is encoded in base 64, and parse_line un-decodes it
  50  * (in place) before returning.
  51  */
  52
  53 int
  54 ldif_parse_line(
  55     LDAP_CONST char     *line,
  56     char        **type,
  57     char        **value,
  58     ber_len_t *vlen
  59 )
  60 {
  61         char    *p, *s, *d, *byte, *stop;
  62         char    nib;
  63         int     i, b64;
  64
  65         /* skip any leading space */
  66         while ( isspace( (unsigned char) *line ) ) {
  67                 line++;
  68         }
  69         *type = line;
  70
  71         for ( s = line; *s && *s != ':'; s++ )
  72                 /* EMPTY */;
  73         if ( *s == '\0' ) {
  74                 ber_pvt_log_printf( LDAP_DEBUG_PARSE, ldif_debug,
  75                         "ldif_parse_line missing ':'\n");
  76                 return( -1 );
  77         }
  78
  79         /* trim any space between type and : */
  80         for ( p = s - 1; p > line && isspace( (unsigned char) *p ); p-- ) {
  81                 *p = '\0';
  82         }
  83         *s++ = '\0';
  84
  85         /* check for double : - indicates base 64 encoded value */
  86         if ( *s == ':' ) {
  87                 s++;
  88                 b64 = 1;
  89
  90         /* single : - normally encoded value */
  91         } else {
  92                 b64 = 0;
  93         }
  94
  95         /* skip space between : and value */
  96         while ( isspace( (unsigned char) *s ) ) {
  97                 s++;
  98         }
  99
 100         /* if no value is present, error out */
 101         if ( *s == '\0' ) {
 102                 ber_pvt_log_printf( LDAP_DEBUG_PARSE, ldif_debug,
 103                         "ldif_parse_line missing value\n");
 104                 return( -1 );
 105         }
 106
 107         /* check for continued line markers that should be deleted */
 108         for ( p = s, d = s; *p; p++ ) {
 109                 if ( *p != CONTINUED_LINE_MARKER )
 110                         *d++ = *p;
 111         }
 112         *d = '\0';
 113
 114         *value = s;
 115         if ( b64 ) {
 116                 stop = strchr( s, '\0' );
 117                 byte = s;
 118                 for ( p = s, *vlen = 0; p < stop; p += 4, *vlen += 3 ) {
 119                         for ( i = 0; i < 4; i++ ) {
 120                                 if ( p[i] != '=' && (p[i] & 0x80 ||
 121                                     b642nib[ p[i] & 0x7f ] > 0x3f) ) {
 122                                         ber_pvt_log_printf( LDAP_DEBUG_ANY, ldif_debug,
 123 "ldif_parse_line: invalid base 64 encoding char (%c) 0x%x\n",
 124                                             p[i], p[i] );
 125                                         return( -1 );
 126                                 }
 127                         }
 128
 129                         /* first digit */
 130                         nib = b642nib[ p[0] & 0x7f ];
 131                         byte[0] = nib << 2;
 132                         /* second digit */
 133                         nib = b642nib[ p[1] & 0x7f ];
 134                         byte[0] |= nib >> 4;
 135                         byte[1] = (nib & RIGHT4) << 4;
 136                         /* third digit */
 137                         if ( p[2] == '=' ) {
 138                                 *vlen += 1;
 139                                 break;
 140                         }
 141                         nib = b642nib[ p[2] & 0x7f ];
 142                         byte[1] |= nib >> 2;
 143                         byte[2] = (nib & RIGHT2) << 6;
 144                         /* fourth digit */
 145                         if ( p[3] == '=' ) {
 146                                 *vlen += 2;
 147                                 break;
 148                         }
 149                         nib = b642nib[ p[3] & 0x7f ];
 150                         byte[2] |= nib;
 151
 152                         byte += 3;
 153                 }
 154                 s[ *vlen ] = '\0';
 155         } else {
 156                 *vlen = (int) (d - s);
 157         }
 158
 159         return( 0 );
 160 }
 161
 162 /*
 163  * ldif_getline - return the next "line" (minus newline) of input from a
 164  * string buffer of lines separated by newlines, terminated by \n\n
 165  * or \0.  this routine handles continued lines, bundling them into
 166  * a single big line before returning.  if a line begins with a white
 167  * space character, it is a continuation of the previous line. the white
 168  * space character (nb: only one char), and preceeding newline are changed
 169  * into CONTINUED_LINE_MARKER chars, to be deleted later by the
 170  * ldif_parse_line() routine above.
 171  *
 172  * ldif_getline will skip over any line which starts '#'.
 173  *
 174  * ldif_getline takes a pointer to a pointer to the buffer on the first call,
 175  * which it updates and must be supplied on subsequent calls.
 176  */
 177
 178 char *
 179 ldif_getline( char **next )
 180 {
 181         char *line;
 182
 183         do {
 184                 if ( *next == NULL || **next == '\n' || **next == '\0' ) {
 185                         return( NULL );
 186                 }
 187
 188                 line = *next;
 189
 190                 while ( (*next = strchr( *next, '\n' )) != NULL ) {
 191                         unsigned char c = *(*next + 1);
 192
 193                         if ( !isspace( c ) || c == '\n' ) {
 194                                 *(*next)++ = '\0';
 195                                 break;
 196                         }
 197
 198                         **next = CONTINUED_LINE_MARKER;
 199                         *(*next+1) = CONTINUED_LINE_MARKER;
 200                         (*next)++;
 201                 }
 202         } while( *line == '#' );
 203
 204         return( line );
 205 }
 206
 207 /* compatibility with U-Mich off by one bug */
 208 #define LDIF_KLUDGE 1
 209
 210 void
 211 ldif_sput(
 212         char **out,
 213         int type,
 214         LDAP_CONST char *name,
 215         LDAP_CONST char *val,
 216         ber_len_t vlen )
 217 {
 218         unsigned char   *byte, *stop;
 219         unsigned char   buf[3];
 220         unsigned long   bits;
 221         char            *save;
 222         int             pad;
 223
 224         ber_len_t savelen;
 225         ber_len_t len=0;
 226         ber_len_t i;
 227
 228         /* prefix */
 229         switch( type ) {
 230         case LDIF_PUT_COMMENT:
 231                 if( name != NULL ) break;
 232
 233                 *(*out)++ = '#';
 234                 len++;
 235
 236                 if( vlen ) {
 237                         *(*out)++ = ' ';
 238                         len++;
 239                         break;
 240                 }
 241
 242                 /* no value, fall-thru */
 243
 244         case LDIF_PUT_SEP:
 245                 *(*out)++ = '\n';
 246                 return;
 247         }
 248
 249         /* name (attribute type) */
 250         if( name != NULL ) {
 251                 /* put the name + ":" */
 252                 for ( i=0 ; name[i]; i++ ) {
 253                         *(*out)++ = name[i];
 254                         len++;
 255                 }
 256
 257                 if( type != LDIF_PUT_COMMENT ) {
 258                         *(*out)++ = ':';
 259                         len++;
 260                 }
 261
 262 #ifdef LDAP_DEBUG
 263         } else {
 264                 assert( type == LDIF_PUT_COMMENT );
 265 #endif
 266         }
 267
 268         switch( type ) {
 269         case LDIF_PUT_NOVALUE:
 270                 *(*out)++ = '\n';
 271                 return;
 272
 273         case LDIF_PUT_URL: /* url value */
 274                 *(*out)++ = '<';
 275                 len++;
 276                 break;
 277
 278         case LDIF_PUT_B64: /* base64 value */
 279                 *(*out)++ = ':';
 280                 len++;
 281                 break;
 282         }
 283
 284         switch( type ) {
 285         case LDIF_PUT_TEXT:
 286         case LDIF_PUT_URL:
 287         case LDIF_PUT_B64:
 288                 *(*out)++ = ' ';
 289                 len++;
 290                 /* fall-thru */
 291
 292         case LDIF_PUT_COMMENT:
 293                 /* pre-encoded names */
 294                 for ( i=0; i < vlen; i++ ) {
 295                         if ( len > LDIF_LINE_WIDTH ) {
 296                                 *(*out)++ = '\n';
 297                                 *(*out)++ = ' ';
 298                                 len = 1;
 299                         }
 300
 301                         *(*out)++ = val[i];
 302                         len++;
 303                 }
 304                 *(*out)++ = '\n';
 305                 return;
 306         }
 307
 308         save = *out;
 309         savelen = len;
 310
 311         *(*out)++ = ' ';
 312         len++;
 313
 314         if( vlen == 0 ) {
 315                 *(*out)++ = '\n';
 316                 return;
 317         }
 318
 319         stop = (unsigned char *) (val + vlen);
 320
 321         if ( type == LDIF_PUT_VALUE &&
 322                 isgraph( val[0] ) && val[0] != ':' && val[0] != '<' &&
 323                 isgraph( val[vlen-1] ) )
 324         {
 325                 int b64 = 0;
 326
 327                 for ( byte = (unsigned char *) val; byte < stop;
 328                     byte++, len++ )
 329                 {
 330                         if ( !isascii( *byte ) || !isprint( *byte ) ) {
 331                                 b64 = 1;
 332                                 break;
 333                         }
 334                         if ( len > LDIF_LINE_WIDTH+LDIF_KLUDGE ) {
 335                                 *(*out)++ = '\n';
 336                                 *(*out)++ = ' ';
 337                                 len = 1;
 338                         }
 339                         *(*out)++ = *byte;
 340                 }
 341
 342                 if( !b64 ) {
 343                         *(*out)++ = '\n';
 344                         return;
 345                 }
 346         }
 347
 348         *out = save;
 349         *(*out)++ = ':';
 350         *(*out)++ = ' ';
 351         len = savelen + 2;
 352
 353         /* convert to base 64 (3 bytes => 4 base 64 digits) */
 354         for ( byte = (unsigned char *) val;
 355                 byte < stop - 2;
 356             byte += 3 )
 357         {
 358                 bits = (byte[0] & 0xff) << 16;
 359                 bits |= (byte[1] & 0xff) << 8;
 360                 bits |= (byte[2] & 0xff);
 361
 362                 for ( i = 0; i < 4; i++, len++, bits <<= 6 ) {
 363                         if ( len > LDIF_LINE_WIDTH+LDIF_KLUDGE ) {
 364                                 *(*out)++ = '\n';
 365                                 *(*out)++ = ' ';
 366                                 len = 1;
 367                         }
 368
 369                         /* get b64 digit from high order 6 bits */
 370                         *(*out)++ = nib2b64[ (bits & 0xfc0000L) >> 18 ];
 371                 }
 372         }
 373
 374         /* add padding if necessary */
 375         if ( byte < stop ) {
 376                 for ( i = 0; byte + i < stop; i++ ) {
 377                         buf[i] = byte[i];
 378                 }
 379                 for ( pad = 0; i < 3; i++, pad++ ) {
 380                         buf[i] = '\0';
 381                 }
 382                 byte = buf;
 383                 bits = (byte[0] & 0xff) << 16;
 384                 bits |= (byte[1] & 0xff) << 8;
 385                 bits |= (byte[2] & 0xff);
 386
 387                 for ( i = 0; i < 4; i++, len++, bits <<= 6 ) {
 388                         if ( len > LDIF_LINE_WIDTH+LDIF_KLUDGE ) {
 389                                 *(*out)++ = '\n';
 390                                 *(*out)++ = ' ';
 391                                 len = 1;
 392                         }
 393
 394                         if( i + pad < 4 ) {
 395                                 /* get b64 digit from low order 6 bits */
 396                                 *(*out)++ = nib2b64[ (bits & 0xfc0000L) >> 18 ];
 397                         } else {
 398                                 *(*out)++ = '=';
 399                         }
 400                 }
 401         }
 402         *(*out)++ = '\n';
 403 }
 404
 405
 406 /*
 407  * ldif_type_and_value return BER malloc'd, zero-terminated LDIF line
 408  */
 409 char *
 410 ldif_put(
 411         int type,
 412         LDAP_CONST char *name,
 413         LDAP_CONST char *val,
 414         ber_len_t vlen )
 415 {
 416     char        *buf, *p;
 417     ber_len_t nlen;
 418
 419     nlen = ( name != NULL ) ? strlen( name ) : 0;
 420
 421         buf = (char *) ber_memalloc( LDIF_SIZE_NEEDED( nlen, vlen ) + 1 );
 422
 423     if ( buf == NULL ) {
 424                 ber_pvt_log_printf( LDAP_DEBUG_ANY, ldif_debug,
 425                         "ldif_type_and_value: malloc failed!" );
 426                 return NULL;
 427     }
 428
 429     p = buf;
 430     ldif_sput( &p, type, name, val, vlen );
 431     *p = '\0';
 432
 433     return( buf );
 434 }
 435
 436 int ldif_is_not_printable(
 437         LDAP_CONST char *val,
 438         ber_len_t vlen )
 439 {
 440         if( vlen == 0 || val == NULL  ) {
 441                 return -1;
 442         }
 443
 444         if( isgraph( val[0] ) && val[0] != ':' && val[0] != '<' &&
 445                 isgraph( val[vlen-1] ) )
 446         {
 447                 ber_len_t i;
 448
 449                 for ( i = 0; val[i]; i++ ) {
 450                         if ( !isascii( val[i] ) || !isprint( val[i] ) ) {
 451                                 return 1;
 452                         }
 453                 }
 454
 455                 return 0;
 456         }
 457
 458         return 1;
 459 }