2003-11-26 07:19:47 +08:00
|
|
|
/* ldif.c - routines for dealing with LDIF files */
|
1999-09-09 03:06:24 +08:00
|
|
|
/* $OpenLDAP$ */
|
2003-11-26 07:19:47 +08:00
|
|
|
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
|
|
|
|
*
|
2007-01-03 04:00:42 +08:00
|
|
|
* Copyright 1998-2007 The OpenLDAP Foundation.
|
2003-11-26 07:19:47 +08:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted only as authorized by the OpenLDAP
|
|
|
|
* Public License.
|
|
|
|
*
|
|
|
|
* A copy of this license is available in the file LICENSE in the
|
|
|
|
* top-level directory of the distribution or, alternatively, at
|
|
|
|
* <http://www.OpenLDAP.org/license.html>.
|
|
|
|
*/
|
|
|
|
/* Portions Copyright (c) 1992-1996 Regents of the University of Michigan.
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms are permitted
|
|
|
|
* provided that this notice is preserved and that due credit is given
|
|
|
|
* to the University of Michigan at Ann Arbor. The name of the
|
|
|
|
* University may not be used to endorse or promote products derived
|
|
|
|
* from this software without specific prior written permission. This
|
|
|
|
* software is provided ``as is'' without express or implied warranty.
|
|
|
|
*/
|
|
|
|
/* This work was originally developed by the University of Michigan
|
|
|
|
* and distributed as part of U-MICH LDAP.
|
1999-08-05 07:57:27 +08:00
|
|
|
*/
|
1998-08-09 08:43:13 +08:00
|
|
|
|
1998-10-25 11:13:43 +08:00
|
|
|
#include "portable.h"
|
|
|
|
|
1998-08-09 08:43:13 +08:00
|
|
|
#include <stdio.h>
|
1999-06-03 08:37:44 +08:00
|
|
|
|
|
|
|
#include <ac/stdlib.h>
|
|
|
|
#include <ac/ctype.h>
|
1998-10-25 11:13:43 +08:00
|
|
|
|
|
|
|
#include <ac/string.h>
|
|
|
|
#include <ac/socket.h>
|
|
|
|
#include <ac/time.h>
|
|
|
|
|
1998-12-22 09:34:01 +08:00
|
|
|
int ldif_debug = 0;
|
|
|
|
|
1998-10-26 09:18:41 +08:00
|
|
|
#include "ldap_log.h"
|
1999-01-26 09:21:35 +08:00
|
|
|
#include "lber_pvt.h"
|
1998-08-09 08:43:13 +08:00
|
|
|
#include "ldif.h"
|
|
|
|
|
|
|
|
#define RIGHT2 0x03
|
|
|
|
#define RIGHT4 0x0f
|
2001-09-26 02:48:48 +08:00
|
|
|
#define CONTINUED_LINE_MARKER '\r'
|
1998-08-09 08:43:13 +08:00
|
|
|
|
1999-08-20 02:48:17 +08:00
|
|
|
#ifdef CSRIMALLOC
|
|
|
|
#define ber_memalloc malloc
|
|
|
|
#define ber_memcalloc calloc
|
|
|
|
#define ber_memrealloc realloc
|
|
|
|
#define ber_strdup strdup
|
|
|
|
#endif
|
|
|
|
|
1999-07-30 02:39:32 +08:00
|
|
|
static const char nib2b64[0x40] =
|
1998-08-09 08:43:13 +08:00
|
|
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
|
|
|
|
1999-03-09 16:40:36 +08:00
|
|
|
static const unsigned char b642nib[0x80] = {
|
1998-08-09 08:43:13 +08:00
|
|
|
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
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
1998-12-21 06:28:33 +08:00
|
|
|
* ldif_parse_line - takes a line of the form "type:[:] value" and splits it
|
1998-08-09 08:43:13 +08:00
|
|
|
* into components "type" and "value". if a double colon separates type from
|
|
|
|
* value, then value is encoded in base 64, and parse_line un-decodes it
|
2005-01-19 13:05:53 +08:00
|
|
|
* (in place) before returning. The type and value are stored in malloc'd
|
|
|
|
* memory which must be freed by the caller.
|
|
|
|
*
|
|
|
|
* ldif_parse_line2 - operates in-place on input buffer, returning type
|
|
|
|
* in-place. Will return value in-place if possible, (must malloc for
|
2005-01-19 20:07:06 +08:00
|
|
|
* fetched URLs). If freeval is NULL, all return data will be malloc'd
|
|
|
|
* and the input line will be unmodified. Otherwise freeval is set to
|
|
|
|
* True if the value was malloc'd.
|
1998-08-09 08:43:13 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
1998-12-21 06:28:33 +08:00
|
|
|
ldif_parse_line(
|
1999-05-19 09:12:33 +08:00
|
|
|
LDAP_CONST char *line,
|
1999-07-31 10:17:26 +08:00
|
|
|
char **typep,
|
|
|
|
char **valuep,
|
|
|
|
ber_len_t *vlenp
|
1998-08-09 08:43:13 +08:00
|
|
|
)
|
2005-01-19 13:05:53 +08:00
|
|
|
{
|
2005-01-19 20:07:06 +08:00
|
|
|
struct berval type, value;
|
|
|
|
int rc = ldif_parse_line2( (char *)line, &type, &value, NULL );
|
|
|
|
|
|
|
|
*typep = type.bv_val;
|
|
|
|
*valuep = value.bv_val;
|
|
|
|
*vlenp = value.bv_len;
|
|
|
|
return rc;
|
2005-01-19 13:05:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ldif_parse_line2(
|
2005-01-19 20:07:06 +08:00
|
|
|
char *line,
|
|
|
|
struct berval *type,
|
|
|
|
struct berval *value,
|
|
|
|
int *freeval
|
2005-01-19 13:05:53 +08:00
|
|
|
)
|
1998-08-09 08:43:13 +08:00
|
|
|
{
|
1999-07-31 10:17:26 +08:00
|
|
|
char *s, *p, *d;
|
1998-08-09 08:43:13 +08:00
|
|
|
char nib;
|
1999-07-31 10:17:26 +08:00
|
|
|
int b64, url;
|
|
|
|
|
2005-01-19 20:07:06 +08:00
|
|
|
BER_BVZERO( type );
|
|
|
|
BER_BVZERO( value );
|
1998-08-09 08:43:13 +08:00
|
|
|
|
|
|
|
/* skip any leading space */
|
1999-02-23 01:57:22 +08:00
|
|
|
while ( isspace( (unsigned char) *line ) ) {
|
1998-08-09 08:43:13 +08:00
|
|
|
line++;
|
|
|
|
}
|
|
|
|
|
2005-01-19 20:07:06 +08:00
|
|
|
if ( freeval ) {
|
|
|
|
*freeval = 0;
|
2005-01-19 13:05:53 +08:00
|
|
|
} else {
|
|
|
|
line = ber_strdup( line );
|
1999-07-31 10:17:26 +08:00
|
|
|
|
2005-01-19 13:05:53 +08:00
|
|
|
if( line == NULL ) {
|
|
|
|
ber_pvt_log_printf( LDAP_DEBUG_ANY, ldif_debug,
|
|
|
|
_("ldif_parse_line: line malloc failed\n"));
|
|
|
|
return( -1 );
|
|
|
|
}
|
1999-07-31 10:17:26 +08:00
|
|
|
}
|
|
|
|
|
2005-01-19 20:07:06 +08:00
|
|
|
type->bv_val = line;
|
1999-07-31 10:17:26 +08:00
|
|
|
|
2005-01-19 20:07:06 +08:00
|
|
|
s = strchr( type->bv_val, ':' );
|
1999-07-31 10:17:26 +08:00
|
|
|
|
|
|
|
if ( s == NULL ) {
|
1999-05-19 09:12:33 +08:00
|
|
|
ber_pvt_log_printf( LDAP_DEBUG_PARSE, ldif_debug,
|
2003-04-06 14:47:31 +08:00
|
|
|
_("ldif_parse_line: missing ':' after %s\n"),
|
2005-04-27 01:50:52 +08:00
|
|
|
type->bv_val );
|
2005-01-19 20:07:06 +08:00
|
|
|
if ( !freeval ) ber_memfree( line );
|
1998-08-09 08:43:13 +08:00
|
|
|
return( -1 );
|
|
|
|
}
|
|
|
|
|
|
|
|
/* trim any space between type and : */
|
2005-01-19 20:07:06 +08:00
|
|
|
for ( p = &s[-1]; p > type->bv_val && isspace( * (unsigned char *) p ); p-- ) {
|
1998-08-09 08:43:13 +08:00
|
|
|
*p = '\0';
|
|
|
|
}
|
|
|
|
*s++ = '\0';
|
2005-01-19 20:07:06 +08:00
|
|
|
type->bv_len = s - type->bv_val - 1;
|
1998-08-09 08:43:13 +08:00
|
|
|
|
1999-09-04 04:19:18 +08:00
|
|
|
url = 0;
|
|
|
|
b64 = 0;
|
|
|
|
|
2002-12-03 02:46:53 +08:00
|
|
|
if ( *s == '<' ) {
|
1999-07-31 10:17:26 +08:00
|
|
|
s++;
|
|
|
|
url = 1;
|
2002-12-02 12:19:01 +08:00
|
|
|
|
1999-07-31 10:17:26 +08:00
|
|
|
} else if ( *s == ':' ) {
|
|
|
|
/* base 64 encoded value */
|
1998-08-09 08:43:13 +08:00
|
|
|
s++;
|
|
|
|
b64 = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* skip space between : and value */
|
1999-02-23 01:57:22 +08:00
|
|
|
while ( isspace( (unsigned char) *s ) ) {
|
1998-08-09 08:43:13 +08:00
|
|
|
s++;
|
|
|
|
}
|
|
|
|
|
1999-09-24 10:30:33 +08:00
|
|
|
/* 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';
|
|
|
|
|
1998-08-09 08:43:13 +08:00
|
|
|
if ( b64 ) {
|
1999-07-31 10:17:26 +08:00
|
|
|
char *byte = s;
|
|
|
|
|
2002-12-02 12:19:01 +08:00
|
|
|
if ( *s == '\0' ) {
|
|
|
|
/* no value is present, error out */
|
|
|
|
ber_pvt_log_printf( LDAP_DEBUG_PARSE, ldif_debug,
|
2005-04-27 01:50:52 +08:00
|
|
|
_("ldif_parse_line: %s missing base64 value\n"),
|
|
|
|
type->bv_val );
|
2005-01-19 20:07:06 +08:00
|
|
|
if ( !freeval ) ber_memfree( line );
|
2002-12-03 06:46:07 +08:00
|
|
|
return( -1 );
|
2002-12-02 12:19:01 +08:00
|
|
|
}
|
|
|
|
|
2005-01-19 20:07:06 +08:00
|
|
|
byte = value->bv_val = s;
|
1999-07-31 10:17:26 +08:00
|
|
|
|
2005-01-19 20:07:06 +08:00
|
|
|
for ( p = s, value->bv_len = 0; p < d; p += 4, value->bv_len += 3 ) {
|
1999-07-31 10:17:26 +08:00
|
|
|
int i;
|
1998-12-14 12:21:04 +08:00
|
|
|
for ( i = 0; i < 4; i++ ) {
|
1998-08-09 08:43:13 +08:00
|
|
|
if ( p[i] != '=' && (p[i] & 0x80 ||
|
|
|
|
b642nib[ p[i] & 0x7f ] > 0x3f) ) {
|
1999-05-19 09:12:33 +08:00
|
|
|
ber_pvt_log_printf( LDAP_DEBUG_ANY, ldif_debug,
|
2003-04-06 14:47:31 +08:00
|
|
|
_("ldif_parse_line: %s: invalid base64 encoding"
|
|
|
|
" char (%c) 0x%x\n"),
|
2005-04-27 01:50:52 +08:00
|
|
|
type->bv_val, p[i], p[i] );
|
2005-01-19 20:07:06 +08:00
|
|
|
if ( !freeval ) ber_memfree( line );
|
1998-08-09 08:43:13 +08:00
|
|
|
return( -1 );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* first digit */
|
|
|
|
nib = b642nib[ p[0] & 0x7f ];
|
|
|
|
byte[0] = nib << 2;
|
|
|
|
/* second digit */
|
|
|
|
nib = b642nib[ p[1] & 0x7f ];
|
|
|
|
byte[0] |= nib >> 4;
|
|
|
|
byte[1] = (nib & RIGHT4) << 4;
|
|
|
|
/* third digit */
|
|
|
|
if ( p[2] == '=' ) {
|
2005-01-19 20:07:06 +08:00
|
|
|
value->bv_len += 1;
|
1998-08-09 08:43:13 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
nib = b642nib[ p[2] & 0x7f ];
|
|
|
|
byte[1] |= nib >> 2;
|
|
|
|
byte[2] = (nib & RIGHT2) << 6;
|
|
|
|
/* fourth digit */
|
|
|
|
if ( p[3] == '=' ) {
|
2005-01-19 20:07:06 +08:00
|
|
|
value->bv_len += 2;
|
1998-08-09 08:43:13 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
nib = b642nib[ p[3] & 0x7f ];
|
|
|
|
byte[2] |= nib;
|
|
|
|
|
|
|
|
byte += 3;
|
|
|
|
}
|
2005-01-19 20:07:06 +08:00
|
|
|
s[ value->bv_len ] = '\0';
|
1999-07-31 10:17:26 +08:00
|
|
|
|
|
|
|
} else if ( url ) {
|
2002-12-02 12:19:01 +08:00
|
|
|
if ( *s == '\0' ) {
|
|
|
|
/* no value is present, error out */
|
|
|
|
ber_pvt_log_printf( LDAP_DEBUG_PARSE, ldif_debug,
|
2005-04-27 01:50:52 +08:00
|
|
|
_("ldif_parse_line: %s missing URL value\n"),
|
|
|
|
type->bv_val );
|
2005-01-19 20:07:06 +08:00
|
|
|
if ( !freeval ) ber_memfree( line );
|
2002-12-03 06:46:07 +08:00
|
|
|
return( -1 );
|
2002-12-02 12:19:01 +08:00
|
|
|
}
|
|
|
|
|
2005-01-19 20:07:06 +08:00
|
|
|
if( ldif_fetch_url( s, &value->bv_val, &value->bv_len ) ) {
|
1999-07-31 10:17:26 +08:00
|
|
|
ber_pvt_log_printf( LDAP_DEBUG_ANY, ldif_debug,
|
2003-04-06 14:47:31 +08:00
|
|
|
_("ldif_parse_line: %s: URL \"%s\" fetch failed\n"),
|
2005-04-27 01:50:52 +08:00
|
|
|
type->bv_val, s );
|
2005-01-19 20:07:06 +08:00
|
|
|
if ( !freeval ) ber_memfree( line );
|
1999-07-31 10:17:26 +08:00
|
|
|
return( -1 );
|
|
|
|
}
|
2005-01-19 20:07:06 +08:00
|
|
|
if ( freeval ) *freeval = 1;
|
1999-07-31 10:17:26 +08:00
|
|
|
|
1998-08-09 08:43:13 +08:00
|
|
|
} else {
|
2005-01-19 20:07:06 +08:00
|
|
|
value->bv_val = s;
|
|
|
|
value->bv_len = (int) (d - s);
|
1999-07-31 10:17:26 +08:00
|
|
|
}
|
|
|
|
|
2005-01-19 20:07:06 +08:00
|
|
|
if ( !freeval ) {
|
|
|
|
struct berval bv = *type;
|
|
|
|
|
|
|
|
ber_dupbv( type, &bv );
|
1999-07-31 10:17:26 +08:00
|
|
|
|
2005-01-19 20:07:06 +08:00
|
|
|
if( BER_BVISNULL( type )) {
|
1999-07-31 10:17:26 +08:00
|
|
|
ber_pvt_log_printf( LDAP_DEBUG_ANY, ldif_debug,
|
2005-01-19 13:05:53 +08:00
|
|
|
_("ldif_parse_line: type malloc failed\n"));
|
2005-01-19 20:07:06 +08:00
|
|
|
if( url ) ber_memfree( value->bv_val );
|
2005-01-19 13:05:53 +08:00
|
|
|
ber_memfree( line );
|
1999-07-31 10:17:26 +08:00
|
|
|
return( -1 );
|
|
|
|
}
|
1998-08-09 08:43:13 +08:00
|
|
|
|
2005-01-19 13:05:53 +08:00
|
|
|
if( !url ) {
|
2005-01-19 20:07:06 +08:00
|
|
|
bv = *value;
|
|
|
|
ber_dupbv( value, &bv );
|
|
|
|
if( BER_BVISNULL( value )) {
|
2005-01-19 13:05:53 +08:00
|
|
|
ber_pvt_log_printf( LDAP_DEBUG_ANY, ldif_debug,
|
|
|
|
_("ldif_parse_line: value malloc failed\n"));
|
2005-01-19 20:07:06 +08:00
|
|
|
ber_memfree( type->bv_val );
|
2005-01-19 13:05:53 +08:00
|
|
|
ber_memfree( line );
|
|
|
|
return( -1 );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ber_memfree( line );
|
|
|
|
}
|
1999-07-31 10:17:26 +08:00
|
|
|
|
1998-08-09 08:43:13 +08:00
|
|
|
return( 0 );
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1998-12-21 06:28:33 +08:00
|
|
|
* ldif_getline - return the next "line" (minus newline) of input from a
|
1998-08-09 08:43:13 +08:00
|
|
|
* string buffer of lines separated by newlines, terminated by \n\n
|
|
|
|
* or \0. this routine handles continued lines, bundling them into
|
|
|
|
* a single big line before returning. if a line begins with a white
|
|
|
|
* space character, it is a continuation of the previous line. the white
|
|
|
|
* space character (nb: only one char), and preceeding newline are changed
|
|
|
|
* into CONTINUED_LINE_MARKER chars, to be deleted later by the
|
1999-07-31 07:00:02 +08:00
|
|
|
* ldif_parse_line() routine above.
|
1998-08-09 08:43:13 +08:00
|
|
|
*
|
1999-07-31 07:00:02 +08:00
|
|
|
* ldif_getline will skip over any line which starts '#'.
|
|
|
|
*
|
|
|
|
* ldif_getline takes a pointer to a pointer to the buffer on the first call,
|
1998-08-09 08:43:13 +08:00
|
|
|
* which it updates and must be supplied on subsequent calls.
|
|
|
|
*/
|
|
|
|
|
2005-01-24 11:40:29 +08:00
|
|
|
int
|
|
|
|
ldif_countlines( LDAP_CONST char *buf )
|
|
|
|
{
|
|
|
|
char *nl;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if ( !buf ) return ret;
|
|
|
|
|
|
|
|
for ( nl = strchr(buf, '\n'); nl; nl = strchr(nl, '\n') ) {
|
|
|
|
nl++;
|
|
|
|
if ( *nl != ' ' ) ret++;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
1998-08-09 08:43:13 +08:00
|
|
|
char *
|
1998-12-21 06:28:33 +08:00
|
|
|
ldif_getline( char **next )
|
1998-08-09 08:43:13 +08:00
|
|
|
{
|
1999-07-30 02:39:32 +08:00
|
|
|
char *line;
|
1998-08-09 08:43:13 +08:00
|
|
|
|
1999-07-30 02:39:32 +08:00
|
|
|
do {
|
|
|
|
if ( *next == NULL || **next == '\n' || **next == '\0' ) {
|
|
|
|
return( NULL );
|
|
|
|
}
|
|
|
|
|
|
|
|
line = *next;
|
1998-08-09 08:43:13 +08:00
|
|
|
|
1999-07-30 02:39:32 +08:00
|
|
|
while ( (*next = strchr( *next, '\n' )) != NULL ) {
|
2001-09-26 02:48:48 +08:00
|
|
|
#if CONTINUED_LINE_MARKER != '\r'
|
|
|
|
if ( (*next)[-1] == '\r' ) {
|
|
|
|
(*next)[-1] = CONTINUED_LINE_MARKER;
|
|
|
|
}
|
|
|
|
#endif
|
1999-07-30 07:05:15 +08:00
|
|
|
|
2001-09-26 03:50:46 +08:00
|
|
|
if ( (*next)[1] != ' ' ) {
|
|
|
|
if ( (*next)[1] == '\r' && (*next)[2] == '\n' ) {
|
2001-09-26 03:45:23 +08:00
|
|
|
*(*next)++ = '\0';
|
|
|
|
}
|
|
|
|
*(*next)++ = '\0';
|
|
|
|
break;
|
1999-07-30 02:39:32 +08:00
|
|
|
}
|
1999-07-30 07:05:15 +08:00
|
|
|
|
|
|
|
**next = CONTINUED_LINE_MARKER;
|
2001-09-26 02:48:48 +08:00
|
|
|
(*next)[1] = CONTINUED_LINE_MARKER;
|
1999-07-30 02:39:32 +08:00
|
|
|
(*next)++;
|
1998-08-09 08:43:13 +08:00
|
|
|
}
|
1999-07-30 02:39:32 +08:00
|
|
|
} while( *line == '#' );
|
1998-08-09 08:43:13 +08:00
|
|
|
|
1999-07-30 02:39:32 +08:00
|
|
|
return( line );
|
1998-08-09 08:43:13 +08:00
|
|
|
}
|
|
|
|
|
2005-04-09 23:19:36 +08:00
|
|
|
/*
|
|
|
|
* name and OID of attributeTypes that must be base64 encoded in any case
|
|
|
|
*/
|
|
|
|
typedef struct must_b64_encode_s {
|
|
|
|
struct berval name;
|
|
|
|
struct berval oid;
|
|
|
|
} must_b64_encode_s;
|
|
|
|
|
|
|
|
static must_b64_encode_s default_must_b64_encode[] = {
|
|
|
|
{ BER_BVC( "userPassword" ), BER_BVC( "2.5.4.35" ) },
|
|
|
|
{ BER_BVNULL, BER_BVNULL }
|
|
|
|
};
|
|
|
|
|
|
|
|
static must_b64_encode_s *must_b64_encode = default_must_b64_encode;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* register name and OID of attributeTypes that must always be base64
|
|
|
|
* encoded
|
|
|
|
*
|
|
|
|
* NOTE: this routine mallocs memory in a static struct which must
|
|
|
|
* be explicitly freed when no longer required
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
ldif_must_b64_encode_register( LDAP_CONST char *name, LDAP_CONST char *oid )
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
ber_len_t len;
|
|
|
|
|
2005-07-18 14:22:33 +08:00
|
|
|
assert( must_b64_encode != NULL );
|
|
|
|
assert( name != NULL );
|
|
|
|
assert( oid != NULL );
|
2005-04-09 23:19:36 +08:00
|
|
|
|
|
|
|
len = strlen( name );
|
|
|
|
|
|
|
|
for ( i = 0; !BER_BVISNULL( &must_b64_encode[i].name ); i++ ) {
|
|
|
|
if ( len != must_b64_encode[i].name.bv_len ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( strcasecmp( name, must_b64_encode[i].name.bv_val ) == 0 ) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( !BER_BVISNULL( &must_b64_encode[i].name ) ) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for ( i = 0; !BER_BVISNULL( &must_b64_encode[i].name ); i++ )
|
|
|
|
/* just count */ ;
|
|
|
|
|
|
|
|
if ( must_b64_encode == default_must_b64_encode ) {
|
|
|
|
must_b64_encode = ber_memalloc( sizeof( must_b64_encode_s ) * ( i + 2 ) );
|
|
|
|
|
|
|
|
for ( i = 0; !BER_BVISNULL( &default_must_b64_encode[i].name ); i++ ) {
|
|
|
|
ber_dupbv( &must_b64_encode[i].name, &default_must_b64_encode[i].name );
|
|
|
|
ber_dupbv( &must_b64_encode[i].oid, &default_must_b64_encode[i].oid );
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
must_b64_encode_s *tmp;
|
|
|
|
|
|
|
|
tmp = ber_memrealloc( must_b64_encode,
|
|
|
|
sizeof( must_b64_encode_s ) * ( i + 2 ) );
|
|
|
|
if ( tmp == NULL ) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
must_b64_encode = tmp;
|
|
|
|
}
|
|
|
|
|
|
|
|
ber_str2bv( name, len, 1, &must_b64_encode[i].name );
|
|
|
|
ber_str2bv( oid, 0, 1, &must_b64_encode[i].oid );
|
|
|
|
|
|
|
|
BER_BVZERO( &must_b64_encode[i + 1].name );
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ldif_must_b64_encode_release( void )
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2005-07-18 14:22:33 +08:00
|
|
|
assert( must_b64_encode != NULL );
|
2005-04-09 23:19:36 +08:00
|
|
|
|
|
|
|
if ( must_b64_encode == default_must_b64_encode ) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for ( i = 0; !BER_BVISNULL( &must_b64_encode[i].name ); i++ ) {
|
|
|
|
ber_memfree( must_b64_encode[i].name.bv_val );
|
|
|
|
ber_memfree( must_b64_encode[i].oid.bv_val );
|
|
|
|
}
|
|
|
|
|
|
|
|
ber_memfree( must_b64_encode );
|
|
|
|
|
|
|
|
must_b64_encode = default_must_b64_encode;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* returns 1 iff the string corresponds to the name or the OID of any
|
|
|
|
* of the attributeTypes listed in must_b64_encode
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
ldif_must_b64_encode( LDAP_CONST char *s )
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct berval bv;
|
|
|
|
|
2005-07-18 14:22:33 +08:00
|
|
|
assert( must_b64_encode != NULL );
|
|
|
|
assert( s != NULL );
|
2005-04-09 23:19:36 +08:00
|
|
|
|
|
|
|
ber_str2bv( s, 0, 0, &bv );
|
|
|
|
|
|
|
|
for ( i = 0; !BER_BVISNULL( &must_b64_encode[i].name ); i++ ) {
|
|
|
|
if ( ber_bvstrcasecmp( &must_b64_encode[i].name, &bv ) == 0
|
2005-04-11 00:01:24 +08:00
|
|
|
|| ber_bvcmp( &must_b64_encode[i].oid, &bv ) == 0 )
|
2005-04-09 23:19:36 +08:00
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
1999-07-31 07:00:02 +08:00
|
|
|
/* compatibility with U-Mich off by one bug */
|
|
|
|
#define LDIF_KLUDGE 1
|
|
|
|
|
1998-08-09 08:43:13 +08:00
|
|
|
void
|
1999-07-31 07:00:02 +08:00
|
|
|
ldif_sput(
|
1999-05-19 09:12:33 +08:00
|
|
|
char **out,
|
1999-07-31 07:00:02 +08:00
|
|
|
int type,
|
|
|
|
LDAP_CONST char *name,
|
1999-05-19 09:12:33 +08:00
|
|
|
LDAP_CONST char *val,
|
1999-07-31 07:00:02 +08:00
|
|
|
ber_len_t vlen )
|
1998-08-09 08:43:13 +08:00
|
|
|
{
|
1999-08-18 05:09:26 +08:00
|
|
|
const unsigned char *byte, *stop;
|
1998-08-09 08:43:13 +08:00
|
|
|
unsigned char buf[3];
|
|
|
|
unsigned long bits;
|
|
|
|
char *save;
|
1999-07-31 07:00:02 +08:00
|
|
|
int pad;
|
2001-12-07 10:26:33 +08:00
|
|
|
int namelen = 0;
|
1999-07-31 07:00:02 +08:00
|
|
|
|
|
|
|
ber_len_t savelen;
|
|
|
|
ber_len_t len=0;
|
|
|
|
ber_len_t i;
|
|
|
|
|
|
|
|
/* prefix */
|
|
|
|
switch( type ) {
|
|
|
|
case LDIF_PUT_COMMENT:
|
|
|
|
*(*out)++ = '#';
|
|
|
|
len++;
|
|
|
|
|
|
|
|
if( vlen ) {
|
|
|
|
*(*out)++ = ' ';
|
|
|
|
len++;
|
|
|
|
}
|
|
|
|
|
2000-06-25 08:35:17 +08:00
|
|
|
break;
|
1998-08-09 08:43:13 +08:00
|
|
|
|
1999-07-31 07:00:02 +08:00
|
|
|
case LDIF_PUT_SEP:
|
|
|
|
*(*out)++ = '\n';
|
|
|
|
return;
|
1998-08-09 08:43:13 +08:00
|
|
|
}
|
1999-07-31 07:00:02 +08:00
|
|
|
|
|
|
|
/* name (attribute type) */
|
|
|
|
if( name != NULL ) {
|
|
|
|
/* put the name + ":" */
|
2001-12-07 10:26:33 +08:00
|
|
|
namelen = strlen(name);
|
|
|
|
strcpy(*out, name);
|
|
|
|
*out += namelen;
|
|
|
|
len += namelen;
|
1999-07-31 07:00:02 +08:00
|
|
|
|
|
|
|
if( type != LDIF_PUT_COMMENT ) {
|
|
|
|
*(*out)++ = ':';
|
|
|
|
len++;
|
|
|
|
}
|
|
|
|
|
1999-08-22 11:35:10 +08:00
|
|
|
}
|
1999-07-31 07:00:02 +08:00
|
|
|
#ifdef LDAP_DEBUG
|
1999-08-22 11:35:10 +08:00
|
|
|
else {
|
1999-07-31 07:00:02 +08:00
|
|
|
assert( type == LDIF_PUT_COMMENT );
|
|
|
|
}
|
1999-08-22 11:35:10 +08:00
|
|
|
#endif
|
1999-07-31 07:00:02 +08:00
|
|
|
|
2000-02-04 06:28:12 +08:00
|
|
|
if( vlen == 0 ) {
|
|
|
|
*(*out)++ = '\n';
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
1999-07-31 07:00:02 +08:00
|
|
|
switch( type ) {
|
|
|
|
case LDIF_PUT_NOVALUE:
|
|
|
|
*(*out)++ = '\n';
|
|
|
|
return;
|
|
|
|
|
|
|
|
case LDIF_PUT_URL: /* url value */
|
|
|
|
*(*out)++ = '<';
|
|
|
|
len++;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case LDIF_PUT_B64: /* base64 value */
|
|
|
|
*(*out)++ = ':';
|
|
|
|
len++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch( type ) {
|
|
|
|
case LDIF_PUT_TEXT:
|
|
|
|
case LDIF_PUT_URL:
|
|
|
|
case LDIF_PUT_B64:
|
|
|
|
*(*out)++ = ' ';
|
|
|
|
len++;
|
|
|
|
/* fall-thru */
|
|
|
|
|
|
|
|
case LDIF_PUT_COMMENT:
|
|
|
|
/* pre-encoded names */
|
|
|
|
for ( i=0; i < vlen; i++ ) {
|
|
|
|
if ( len > LDIF_LINE_WIDTH ) {
|
|
|
|
*(*out)++ = '\n';
|
|
|
|
*(*out)++ = ' ';
|
|
|
|
len = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
*(*out)++ = val[i];
|
|
|
|
len++;
|
|
|
|
}
|
|
|
|
*(*out)++ = '\n';
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
1998-08-09 08:43:13 +08:00
|
|
|
save = *out;
|
|
|
|
savelen = len;
|
1999-07-31 07:00:02 +08:00
|
|
|
|
1998-08-09 08:43:13 +08:00
|
|
|
*(*out)++ = ' ';
|
1999-07-31 07:00:02 +08:00
|
|
|
len++;
|
|
|
|
|
1999-08-18 05:09:26 +08:00
|
|
|
stop = (const unsigned char *) (val + vlen);
|
1999-07-31 07:00:02 +08:00
|
|
|
|
1999-08-05 08:30:45 +08:00
|
|
|
if ( type == LDIF_PUT_VALUE
|
2002-04-08 17:43:22 +08:00
|
|
|
&& isgraph( (unsigned char) val[0] ) && val[0] != ':' && val[0] != '<'
|
|
|
|
&& isgraph( (unsigned char) val[vlen-1] )
|
2000-02-04 06:28:12 +08:00
|
|
|
#ifndef LDAP_BINARY_DEBUG
|
|
|
|
&& strstr( name, ";binary" ) == NULL
|
|
|
|
#endif
|
1999-12-08 12:37:59 +08:00
|
|
|
#ifndef LDAP_PASSWD_DEBUG
|
2005-04-09 23:19:36 +08:00
|
|
|
&& !ldif_must_b64_encode( name )
|
1999-12-08 12:37:59 +08:00
|
|
|
#endif
|
1999-08-05 08:30:45 +08:00
|
|
|
) {
|
1999-07-31 07:00:02 +08:00
|
|
|
int b64 = 0;
|
|
|
|
|
1999-08-18 05:09:26 +08:00
|
|
|
for ( byte = (const unsigned char *) val; byte < stop;
|
1999-07-31 07:00:02 +08:00
|
|
|
byte++, len++ )
|
|
|
|
{
|
1998-08-09 08:43:13 +08:00
|
|
|
if ( !isascii( *byte ) || !isprint( *byte ) ) {
|
|
|
|
b64 = 1;
|
|
|
|
break;
|
|
|
|
}
|
1999-07-31 07:00:02 +08:00
|
|
|
if ( len > LDIF_LINE_WIDTH+LDIF_KLUDGE ) {
|
1998-08-09 08:43:13 +08:00
|
|
|
*(*out)++ = '\n';
|
|
|
|
*(*out)++ = ' ';
|
|
|
|
len = 1;
|
|
|
|
}
|
|
|
|
*(*out)++ = *byte;
|
|
|
|
}
|
1999-07-31 07:00:02 +08:00
|
|
|
|
|
|
|
if( !b64 ) {
|
|
|
|
*(*out)++ = '\n';
|
|
|
|
return;
|
|
|
|
}
|
1998-08-09 08:43:13 +08:00
|
|
|
}
|
|
|
|
|
1999-07-31 07:00:02 +08:00
|
|
|
*out = save;
|
|
|
|
*(*out)++ = ':';
|
|
|
|
*(*out)++ = ' ';
|
|
|
|
len = savelen + 2;
|
|
|
|
|
|
|
|
/* convert to base 64 (3 bytes => 4 base 64 digits) */
|
1999-08-18 05:09:26 +08:00
|
|
|
for ( byte = (const unsigned char *) val;
|
1999-07-31 07:00:02 +08:00
|
|
|
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++, len++, bits <<= 6 ) {
|
|
|
|
if ( len > LDIF_LINE_WIDTH+LDIF_KLUDGE ) {
|
|
|
|
*(*out)++ = '\n';
|
|
|
|
*(*out)++ = ' ';
|
|
|
|
len = 1;
|
1998-08-09 08:43:13 +08:00
|
|
|
}
|
1999-07-31 07:00:02 +08:00
|
|
|
|
|
|
|
/* get b64 digit from high order 6 bits */
|
|
|
|
*(*out)++ = nib2b64[ (bits & 0xfc0000L) >> 18 ];
|
1998-08-09 08:43:13 +08:00
|
|
|
}
|
1999-07-31 07:00:02 +08:00
|
|
|
}
|
1998-08-09 08:43:13 +08:00
|
|
|
|
1999-07-31 07:00:02 +08:00
|
|
|
/* 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++, len++, bits <<= 6 ) {
|
|
|
|
if ( len > LDIF_LINE_WIDTH+LDIF_KLUDGE ) {
|
|
|
|
*(*out)++ = '\n';
|
|
|
|
*(*out)++ = ' ';
|
|
|
|
len = 1;
|
1998-08-09 08:43:13 +08:00
|
|
|
}
|
|
|
|
|
1999-07-31 07:00:02 +08:00
|
|
|
if( i + pad < 4 ) {
|
|
|
|
/* get b64 digit from low order 6 bits */
|
|
|
|
*(*out)++ = nib2b64[ (bits & 0xfc0000L) >> 18 ];
|
|
|
|
} else {
|
|
|
|
*(*out)++ = '=';
|
1998-08-09 08:43:13 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*(*out)++ = '\n';
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
1999-07-31 07:00:02 +08:00
|
|
|
* ldif_type_and_value return BER malloc'd, zero-terminated LDIF line
|
1998-08-09 08:43:13 +08:00
|
|
|
*/
|
1999-07-31 07:00:02 +08:00
|
|
|
char *
|
|
|
|
ldif_put(
|
|
|
|
int type,
|
|
|
|
LDAP_CONST char *name,
|
|
|
|
LDAP_CONST char *val,
|
|
|
|
ber_len_t vlen )
|
1998-08-09 08:43:13 +08:00
|
|
|
{
|
|
|
|
char *buf, *p;
|
1999-07-31 07:00:02 +08:00
|
|
|
ber_len_t nlen;
|
1998-08-09 08:43:13 +08:00
|
|
|
|
1999-07-31 07:00:02 +08:00
|
|
|
nlen = ( name != NULL ) ? strlen( name ) : 0;
|
|
|
|
|
|
|
|
buf = (char *) ber_memalloc( LDIF_SIZE_NEEDED( nlen, vlen ) + 1 );
|
|
|
|
|
|
|
|
if ( buf == NULL ) {
|
1999-05-19 09:12:33 +08:00
|
|
|
ber_pvt_log_printf( LDAP_DEBUG_ANY, ldif_debug,
|
2003-04-06 14:47:31 +08:00
|
|
|
_("ldif_type_and_value: malloc failed!"));
|
1999-01-26 09:21:35 +08:00
|
|
|
return NULL;
|
1998-08-09 08:43:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
p = buf;
|
1999-07-31 07:00:02 +08:00
|
|
|
ldif_sput( &p, type, name, val, vlen );
|
1998-08-09 08:43:13 +08:00
|
|
|
*p = '\0';
|
|
|
|
|
|
|
|
return( buf );
|
|
|
|
}
|
1999-07-31 07:00:02 +08:00
|
|
|
|
|
|
|
int ldif_is_not_printable(
|
|
|
|
LDAP_CONST char *val,
|
|
|
|
ber_len_t vlen )
|
|
|
|
{
|
|
|
|
if( vlen == 0 || val == NULL ) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2002-04-08 17:43:22 +08:00
|
|
|
if( isgraph( (unsigned char) val[0] ) && val[0] != ':' && val[0] != '<' &&
|
|
|
|
isgraph( (unsigned char) val[vlen-1] ) )
|
1999-07-31 07:00:02 +08:00
|
|
|
{
|
|
|
|
ber_len_t i;
|
|
|
|
|
|
|
|
for ( i = 0; val[i]; i++ ) {
|
2006-04-02 07:44:42 +08:00
|
|
|
if ( !isascii( val[i] ) || !isprint( (unsigned char) val[i] ) ) {
|
1999-07-31 07:00:02 +08:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
1999-08-18 03:00:59 +08:00
|
|
|
|
2005-05-12 08:46:39 +08:00
|
|
|
LDIFFP *
|
|
|
|
ldif_open(
|
2005-07-06 18:50:03 +08:00
|
|
|
LDAP_CONST char *file,
|
|
|
|
LDAP_CONST char *mode
|
2005-05-12 08:46:39 +08:00
|
|
|
)
|
|
|
|
{
|
|
|
|
FILE *fp = fopen( file, mode );
|
|
|
|
LDIFFP *lfp = NULL;
|
|
|
|
|
|
|
|
if ( fp ) {
|
|
|
|
lfp = ber_memalloc( sizeof( LDIFFP ));
|
|
|
|
lfp->fp = fp;
|
|
|
|
lfp->prev = NULL;
|
|
|
|
}
|
|
|
|
return lfp;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ldif_close(
|
|
|
|
LDIFFP *lfp
|
|
|
|
)
|
|
|
|
{
|
|
|
|
LDIFFP *prev;
|
|
|
|
|
|
|
|
while ( lfp ) {
|
|
|
|
fclose( lfp->fp );
|
|
|
|
prev = lfp->prev;
|
|
|
|
ber_memfree( lfp );
|
|
|
|
lfp = prev;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-11-28 02:59:04 +08:00
|
|
|
#define LDIF_MAXLINE 4096
|
|
|
|
|
1999-08-18 03:00:59 +08:00
|
|
|
/*
|
2005-05-12 08:46:39 +08:00
|
|
|
* ldif_read_record - read an ldif record. Return 1 for success, 0 for EOF.
|
1999-08-18 03:00:59 +08:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
ldif_read_record(
|
2005-05-12 08:46:39 +08:00
|
|
|
LDIFFP *lfp,
|
1999-08-18 03:00:59 +08:00
|
|
|
int *lno, /* ptr to line number counter */
|
|
|
|
char **bufp, /* ptr to malloced output buffer */
|
|
|
|
int *buflenp ) /* ptr to length of *bufp */
|
|
|
|
{
|
2006-11-28 02:59:04 +08:00
|
|
|
char linebuf[LDIF_MAXLINE], *line, *nbufp;
|
1999-08-18 03:00:59 +08:00
|
|
|
ber_len_t lcur = 0, len, linesize;
|
2003-11-01 03:13:20 +08:00
|
|
|
int last_ch = '\n', found_entry = 0, stop, top_comment = 0;
|
1999-08-18 03:00:59 +08:00
|
|
|
|
|
|
|
line = linebuf;
|
|
|
|
linesize = sizeof( linebuf );
|
|
|
|
|
2005-05-12 08:46:39 +08:00
|
|
|
for ( stop = 0; !stop; last_ch = line[len-1] ) {
|
|
|
|
/* If we're at the end of this file, see if we should pop
|
|
|
|
* back to a previous file. (return from an include)
|
|
|
|
*/
|
|
|
|
while ( feof( lfp->fp )) {
|
|
|
|
if ( lfp->prev ) {
|
|
|
|
LDIFFP *tmp = lfp->prev;
|
|
|
|
fclose( lfp->fp );
|
|
|
|
*lfp = *tmp;
|
|
|
|
ber_memfree( tmp );
|
|
|
|
} else {
|
|
|
|
stop = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ( stop )
|
|
|
|
break;
|
|
|
|
|
|
|
|
if ( fgets( line, linesize, lfp->fp ) == NULL ) {
|
1999-08-18 03:00:59 +08:00
|
|
|
stop = 1;
|
|
|
|
/* Add \n in case the file does not end with newline */
|
|
|
|
line = "\n";
|
|
|
|
}
|
|
|
|
len = strlen( line );
|
|
|
|
|
|
|
|
if ( last_ch == '\n' ) {
|
|
|
|
(*lno)++;
|
|
|
|
|
2006-10-08 06:18:15 +08:00
|
|
|
if ( line[0] == '\n' ||
|
|
|
|
( line[0] == '\r' && line[1] == '\n' )) {
|
2003-11-01 03:13:20 +08:00
|
|
|
if ( !found_entry ) {
|
|
|
|
lcur = 0;
|
|
|
|
top_comment = 0;
|
1999-08-18 03:00:59 +08:00
|
|
|
continue;
|
2003-11-01 03:13:20 +08:00
|
|
|
}
|
1999-08-18 03:00:59 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( !found_entry ) {
|
2003-11-01 03:13:20 +08:00
|
|
|
if ( line[0] == '#' ) {
|
|
|
|
top_comment = 1;
|
|
|
|
} else if ( ! ( top_comment && line[0] == ' ' ) ) {
|
|
|
|
/* Found a new entry */
|
|
|
|
found_entry = 1;
|
|
|
|
|
|
|
|
if ( isdigit( (unsigned char) line[0] ) ) {
|
|
|
|
/* skip index */
|
|
|
|
continue;
|
|
|
|
}
|
2005-05-12 08:46:39 +08:00
|
|
|
if ( !strncasecmp( line, "include:",
|
|
|
|
STRLENOF("include:"))) {
|
|
|
|
FILE *fp2;
|
|
|
|
char *ptr;
|
|
|
|
found_entry = 0;
|
|
|
|
|
|
|
|
if ( line[len-1] == '\n' ) {
|
|
|
|
len--;
|
|
|
|
line[len] = '\0';
|
|
|
|
}
|
|
|
|
if ( line[len-1] == '\r' ) {
|
|
|
|
len--;
|
|
|
|
line[len] = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
ptr = line + STRLENOF("include:");
|
2006-04-02 07:44:42 +08:00
|
|
|
while (isspace((unsigned char) *ptr)) ptr++;
|
2005-05-12 08:46:39 +08:00
|
|
|
fp2 = ldif_open_url( ptr );
|
|
|
|
if ( fp2 ) {
|
|
|
|
LDIFFP *lnew = ber_memalloc( sizeof( LDIFFP ));
|
2007-08-21 18:52:16 +08:00
|
|
|
if ( lnew == NULL ) {
|
2007-09-04 00:18:17 +08:00
|
|
|
fclose( fp2 );
|
2007-08-21 18:52:16 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2005-05-12 08:46:39 +08:00
|
|
|
lnew->prev = lfp->prev;
|
|
|
|
lnew->fp = lfp->fp;
|
|
|
|
lfp->prev = lnew;
|
|
|
|
lfp->fp = fp2;
|
2005-05-12 10:56:11 +08:00
|
|
|
line[len] = '\n';
|
|
|
|
len++;
|
2005-05-12 08:46:39 +08:00
|
|
|
continue;
|
|
|
|
} else {
|
|
|
|
/* We failed to open the file, this should
|
|
|
|
* be reported as an error somehow.
|
|
|
|
*/
|
2007-09-02 10:16:52 +08:00
|
|
|
ber_pvt_log_printf( LDAP_DEBUG_ANY, ldif_debug,
|
|
|
|
_("ldif_read_record: include %s failed\n"), ptr );
|
|
|
|
return 0;
|
2005-05-12 08:46:39 +08:00
|
|
|
}
|
|
|
|
}
|
1999-08-18 03:00:59 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( *buflenp - lcur <= len ) {
|
2006-11-28 02:59:04 +08:00
|
|
|
*buflenp += len + LDIF_MAXLINE;
|
1999-08-22 11:35:10 +08:00
|
|
|
nbufp = ber_memrealloc( *bufp, *buflenp );
|
1999-08-18 03:00:59 +08:00
|
|
|
if( nbufp == NULL ) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
*bufp = nbufp;
|
|
|
|
}
|
|
|
|
strcpy( *bufp + lcur, line );
|
|
|
|
lcur += len;
|
|
|
|
}
|
|
|
|
|
|
|
|
return( found_entry );
|
1999-08-18 03:54:37 +08:00
|
|
|
}
|