ldif.c 51.1 KB
Newer Older
Howard Chu's avatar
Howard Chu committed
1
2
3
4
/* ldif.c - the ldif backend */
/* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
 *
Kurt Zeilenga's avatar
Kurt Zeilenga committed
5
 * Copyright 2005-2011 The OpenLDAP Foundation.
Howard Chu's avatar
Howard Chu committed
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 * 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>.
 */
/* ACKNOWLEDGEMENTS:
 * This work was originally developed by Eric Stokes for inclusion
 * in OpenLDAP Software.
 */

#include "portable.h"
#include <stdio.h>
#include <ac/string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <ac/dirent.h>
#include <fcntl.h>
#include <ac/errno.h>
#include <ac/unistd.h>
#include "slap.h"
#include "lutil.h"
32
#include "config.h"
Howard Chu's avatar
Howard Chu committed
33

34
35
36
37
38
39
struct ldif_tool {
	Entry	**entries;			/* collected by bi_tool_entry_first() */
	ID		elen;				/* length of entries[] array */
	ID		ecount;				/* number of entries */
	ID		ecurrent;			/* bi_tool_entry_next() position */
#	define	ENTRY_BUFF_INCREMENT 500 /* initial entries[] length */
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
40
41
42
	struct berval	*tl_base;
	int		tl_scope;
	Filter		*tl_filter;
43
};
44

45
/* Per-database data */
Howard Chu's avatar
Howard Chu committed
46
struct ldif_info {
47
48
49
50
51
52
53
54
55
56
57
58
	struct berval li_base_path;			/* database directory */
	struct ldif_tool li_tool;			/* for slap tools */
	/*
	 * Read-only LDAP requests readlock li_rdwr for filesystem input.
	 * Update requests first lock li_modop_mutex for filesystem I/O,
	 * and then writelock li_rdwr as well for filesystem output.
	 * This allows update requests to do callbacks that acquire
	 * read locks, e.g. access controls that inspect entries.
	 * (An alternative would be recursive read/write locks.)
	 */
	ldap_pvt_thread_mutex_t	li_modop_mutex; /* serialize update requests */
	ldap_pvt_thread_rdwr_t	li_rdwr;	/* no other I/O when writing */
Howard Chu's avatar
Howard Chu committed
59
60
};

61
62
static int write_data( int fd, const char *spew, int len, int *save_errno );

Howard Chu's avatar
Howard Chu committed
63
64
#ifdef _WIN32
#define mkdir(a,b)	mkdir(a)
65
66
67
#define move_file(from, to) (!MoveFileEx(from, to, MOVEFILE_REPLACE_EXISTING))
#else
#define move_file(from, to) rename(from, to)
Howard Chu's avatar
Howard Chu committed
68
#endif
69
#define move_dir(from, to) rename(from, to)
Howard Chu's avatar
Howard Chu committed
70

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
71

Howard Chu's avatar
Howard Chu committed
72
#define LDIF	".ldif"
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
73
74
75
76
77
78
#define LDIF_FILETYPE_SEP	'.'			/* LDIF[0] */

/*
 * Unsafe/translated characters in the filesystem.
 *
 * LDIF_UNSAFE_CHAR(c) returns true if the character c is not to be used
79
80
 * in relative filenames, except it should accept '\\', '{' and '}' even
 * if unsafe.  The value should be a constant expression.
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 *
 * If '\\' is unsafe, #define LDIF_ESCAPE_CHAR as a safe character.
 * If '{' and '}' are unsafe, #define IX_FSL/IX_FSR as safe characters.
 * (Not digits, '-' or '+'.  IX_FSL == IX_FSR is allowed.)
 *
 * Characters are escaped as LDIF_ESCAPE_CHAR followed by two hex digits,
 * except '\\' is replaced with LDIF_ESCAPE_CHAR and {} with IX_FS[LR].
 * Also some LDIF special chars are hex-escaped.
 *
 * Thus an LDIF filename is a valid normalized RDN (or suffix DN)
 * followed by ".ldif", except with '\\' replaced with LDIF_ESCAPE_CHAR.
 */

#ifndef _WIN32

/*
 * Unix/MacOSX version.  ':' vs '/' can cause confusion on MacOSX so we
 * escape both.  We escape them on Unix so both OS variants get the same
 * filenames.
 */
#define LDIF_ESCAPE_CHAR	'\\'
#define LDIF_UNSAFE_CHAR(c)	((c) == '/' || (c) == ':')
Howard Chu's avatar
Howard Chu committed
103

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
104
105
106
#else /* _WIN32 */

/* Windows version - Microsoft's list of unsafe characters, except '\\' */
107
#define LDIF_ESCAPE_CHAR	'^'			/* Not '\\' (unsafe on Windows) */
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
108
109
110
111
112
113
114
115
116
117
118
#define LDIF_UNSAFE_CHAR(c)	\
	((c) == '/' || (c) == ':' || \
	 (c) == '<' || (c) == '>' || (c) == '"' || \
	 (c) == '|' || (c) == '?' || (c) == '*')

#endif /* !_WIN32 */

/*
 * Left and Right "{num}" prefix to ordered RDNs ("olcDatabase={1}bdb").
 * IX_DN* are for LDAP RDNs, IX_FS* for their .ldif filenames.
 */
119
120
121
122
123
124
125
#define IX_DNL	'{'
#define	IX_DNR	'}'
#ifndef IX_FSL
#define	IX_FSL	IX_DNL
#define IX_FSR	IX_DNR
#endif

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
/*
 * Test for unsafe chars, as well as chars handled specially by back-ldif:
 * - If the escape char is not '\\', it must itself be escaped.  Otherwise
 *   '\\' and the escape char would map to the same character.
 * - Escape the '.' in ".ldif", so the directory for an RDN that actually
 *   ends with ".ldif" can not conflict with a file of the same name.  And
 *   since some OSes/programs choke on multiple '.'s, escape all of them.
 * - If '{' and '}' are translated to some other characters, those
 *   characters must in turn be escaped when they occur in an RDN.
 */
#ifndef LDIF_NEED_ESCAPE
#define	LDIF_NEED_ESCAPE(c) \
	((LDIF_UNSAFE_CHAR(c)) || \
	 LDIF_MAYBE_UNSAFE(c, LDIF_ESCAPE_CHAR) || \
	 LDIF_MAYBE_UNSAFE(c, LDIF_FILETYPE_SEP) || \
	 LDIF_MAYBE_UNSAFE(c, IX_FSL) || \
	 (IX_FSR != IX_FSL && LDIF_MAYBE_UNSAFE(c, IX_FSR)))
#endif
/*
 * Helper macro for LDIF_NEED_ESCAPE(): Treat character x as unsafe if
 * back-ldif does not already treat is specially.
 */
#define LDIF_MAYBE_UNSAFE(c, x) \
	(!(LDIF_UNSAFE_CHAR(x) || (x) == '\\' || (x) == IX_DNL || (x) == IX_DNR) \
	 && (c) == (x))

152
153
154
155
156
157
158
159
160
161
162
163
/* Collect other "safe char" tests here, until someone needs a fix. */
enum {
	eq_unsafe = LDIF_UNSAFE_CHAR('='),
	safe_filenames = STRLENOF("" LDAP_DIRSEP "") == 1 && !(
		LDIF_UNSAFE_CHAR('-') || /* for "{-1}frontend" in bconfig.c */
		LDIF_UNSAFE_CHAR(LDIF_ESCAPE_CHAR) ||
		LDIF_UNSAFE_CHAR(IX_FSL) || LDIF_UNSAFE_CHAR(IX_FSR))
};
/* Sanity check: Try to force a compilation error if !safe_filenames */
typedef struct {
	int assert_safe_filenames : safe_filenames ? 2 : -2;
} assert_safe_filenames[safe_filenames ? 2 : -2];
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
164

Howard Chu's avatar
Howard Chu committed
165

166
167
168
static ConfigTable ldifcfg[] = {
	{ "directory", "dir", 2, 2, 0, ARG_BERVAL|ARG_OFFSET,
		(void *)offsetof(struct ldif_info, li_base_path),
169
		"( OLcfgDbAt:0.1 NAME 'olcDbDirectory' "
170
171
			"DESC 'Directory for database content' "
			"EQUALITY caseIgnoreMatch "
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
172
			"SYNTAX OMsDirectoryString SINGLE-VALUE )", NULL, NULL },
173
174
175
176
177
	{ NULL, NULL, 0, 0, 0, ARG_IGNORED,
		NULL, NULL, NULL, NULL }
};

static ConfigOCs ldifocs[] = {
178
179
	{ "( OLcfgDbOc:2.1 "
		"NAME 'olcLdifConfig' "
180
		"DESC 'LDIF backend configuration' "
Howard Chu's avatar
Howard Chu committed
181
		"SUP olcDatabaseConfig "
182
		"MUST ( olcDbDirectory ) )", Cft_Database, ldifcfg },
Howard Chu's avatar
Howard Chu committed
183
	{ NULL, 0, NULL }
184
185
};

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
186

187
188
189
190
/*
 * Handle file/directory names.
 */

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
191
/* Set *res = LDIF filename path for the normalized DN */
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
192
193
static int
ndn2path( Operation *op, struct berval *dn, struct berval *res, int empty_ok )
Howard Chu's avatar
Howard Chu committed
194
{
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
195
	BackendDB *be = op->o_bd;
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
196
197
198
199
200
201
202
203
204
	struct ldif_info *li = (struct ldif_info *) be->be_private;
	struct berval *suffixdn = &be->be_nsuffix[0];
	const char *start, *end, *next, *p;
	char ch, *ptr;
	ber_len_t len;
	static const char hex[] = "0123456789ABCDEF";

	assert( dn != NULL );
	assert( !BER_BVISNULL( dn ) );
205
206
	assert( suffixdn != NULL );
	assert( !BER_BVISNULL( suffixdn ) );
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
207
	assert( dnIsSuffix( dn, suffixdn ) );
Pierangelo Masarati's avatar
Pierangelo Masarati committed
208

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
209
210
211
212
	if ( dn->bv_len == 0 && !empty_ok ) {
		return LDAP_UNWILLING_TO_PERFORM;
	}

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
213
214
	start = dn->bv_val;
	end = start + dn->bv_len;
Pierangelo Masarati's avatar
Pierangelo Masarati committed
215

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
216
217
218
219
220
221
	/* Room for dir, dirsep, dn, LDIF, "\hexpair"-escaping of unsafe chars */
	len = li->li_base_path.bv_len + dn->bv_len + (1 + STRLENOF( LDIF ));
	for ( p = start; p < end; ) {
		ch = *p++;
		if ( LDIF_NEED_ESCAPE( ch ) )
			len += 2;
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
222
	}
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
223
224
225
226
227
228
229
230
	res->bv_val = ch_malloc( len + 1 );

	ptr = lutil_strcopy( res->bv_val, li->li_base_path.bv_val );
	for ( next = end - suffixdn->bv_len; end > start; end = next ) {
		/* Set p = start of DN component, next = &',' or start of DN */
		while ( (p = next) > start ) {
			--next;
			if ( DN_SEPARATOR( *next ) )
231
				break;
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
		}
		/* Append <dirsep> <p..end-1: RDN or database-suffix> */
		for ( *ptr++ = LDAP_DIRSEP[0]; p < end; *ptr++ = ch ) {
			ch = *p++;
			if ( LDIF_ESCAPE_CHAR != '\\' && ch == '\\' ) {
				ch = LDIF_ESCAPE_CHAR;
			} else if ( IX_FSL != IX_DNL && ch == IX_DNL ) {
				ch = IX_FSL;
			} else if ( IX_FSR != IX_DNR && ch == IX_DNR ) {
				ch = IX_FSR;
			} else if ( LDIF_NEED_ESCAPE( ch ) ) {
				*ptr++ = LDIF_ESCAPE_CHAR;
				*ptr++ = hex[(ch & 0xFFU) >> 4];
				ch = hex[ch & 0x0FU];
			}
247
		}
248
	}
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
249
250
	ptr = lutil_strcopy( ptr, LDIF );
	res->bv_len = ptr - res->bv_val;
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
251

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
252
	assert( res->bv_len <= len );
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
253
254

	return LDAP_SUCCESS;
Howard Chu's avatar
Howard Chu committed
255
256
}

257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
/*
 * *dest = dupbv(<dir + LDAP_DIRSEP>), plus room for <more>-sized filename.
 * Return pointer past the dirname.
 */
static char *
fullpath_alloc( struct berval *dest, const struct berval *dir, ber_len_t more )
{
	char *s = SLAP_MALLOC( dir->bv_len + more + 2 );

	dest->bv_val = s;
	if ( s == NULL ) {
		dest->bv_len = 0;
		Debug( LDAP_DEBUG_ANY, "back-ldif: out of memory\n", 0, 0, 0 );
	} else {
		s = lutil_strcopy( dest->bv_val, dir->bv_val );
		*s++ = LDAP_DIRSEP[0];
		*s = '\0';
		dest->bv_len = s - dest->bv_val;
	}
	return s;
}

/*
 * Append filename to fullpath_alloc() dirname or replace previous filename.
 * dir_end = fullpath_alloc() return value.
 */
#define FILL_PATH(fpath, dir_end, filename) \
	((fpath)->bv_len = lutil_strcopy(dir_end, filename) - (fpath)->bv_val)


/* .ldif entry filename length <-> subtree dirname length. */
#define ldif2dir_len(bv)  ((bv).bv_len -= STRLENOF(LDIF))
#define dir2ldif_len(bv)  ((bv).bv_len += STRLENOF(LDIF))
/* .ldif entry filename <-> subtree dirname, both with dirname length. */
#define ldif2dir_name(bv) ((bv).bv_val[(bv).bv_len] = '\0')
#define dir2ldif_name(bv) ((bv).bv_val[(bv).bv_len] = LDIF_FILETYPE_SEP)

/* Get the parent directory path, plus the LDIF suffix overwritten by a \0. */
static int
get_parent_path( struct berval *dnpath, struct berval *res )
{
	ber_len_t i = dnpath->bv_len;

	while ( i > 0 && dnpath->bv_val[ --i ] != LDAP_DIRSEP[0] ) ;
	if ( res == NULL ) {
		res = dnpath;
	} else {
		res->bv_val = SLAP_MALLOC( i + 1 + STRLENOF(LDIF) );
		if ( res->bv_val == NULL )
			return LDAP_OTHER;
		AC_MEMCPY( res->bv_val, dnpath->bv_val, i );
	}
	res->bv_len = i;
	strcpy( res->bv_val + i, LDIF );
	res->bv_val[i] = '\0';
	return LDAP_SUCCESS;
}

/* Make temporary filename pattern for mkstemp() based on dnpath. */
static char *
ldif_tempname( const struct berval *dnpath )
{
	static const char suffix[] = ".XXXXXX";
	ber_len_t len = dnpath->bv_len - STRLENOF( LDIF );
	char *name = SLAP_MALLOC( len + sizeof( suffix ) );

	if ( name != NULL ) {
		AC_MEMCPY( name, dnpath->bv_val, len );
		strcpy( name + len, suffix );
	}
	return name;
}

330
331
332
333
334
335
/* CRC-32 table for the polynomial:
 * x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
 *
 * As used by zlib
 */

336
static const ber_uint_t crctab[256] = {
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
	0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
	0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
	0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
	0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
	0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
	0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
	0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
	0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
	0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
	0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
	0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
	0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
	0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
	0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
	0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
	0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
	0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
	0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
	0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
	0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
	0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
	0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
	0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
	0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
	0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
	0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
	0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
	0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
	0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
	0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
	0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
	0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
	0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
	0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
	0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
	0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
	0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
	0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
	0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
	0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
	0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
	0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
	0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
	0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
	0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
	0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
	0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
	0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
	0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
	0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
	0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
	0x2d02ef8dL
};

#define CRC1	crc = crctab[(crc ^ *buf++) & 0xff] ^ (crc >> 8)
#define CRC8	CRC1; CRC1; CRC1; CRC1; CRC1; CRC1; CRC1; CRC1
393
394
unsigned int
crc32(const void *vbuf, int len)
395
{
396
397
	const unsigned char	*buf = vbuf;
	ber_uint_t		crc = 0xffffffff;
398
399
400
401
402
403
404
405
406
407
408
409
410
411
	int				i;

	while (len > 7) {
		CRC8;
		len -= 8;
	}
	while (len) {
		CRC1;
		len--;
	}

	return crc ^ 0xffffffff;
}

412
413
414
415
416
417
418
/*
 * Read a file, or stat() it if datap == NULL.  Allocate and fill *datap.
 * Return LDAP_SUCCESS, LDAP_NO_SUCH_OBJECT (no such file), or another error.
 */
static int
ldif_read_file( const char *path, char **datap )
{
419
	int rc = LDAP_SUCCESS, fd, len;
420
	int res = -1;	/* 0:success, <0:error, >0:file too big/growing. */
421
	struct stat st;
422
	char *data = NULL, *ptr = NULL;
423

424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
	if ( datap == NULL ) {
		res = stat( path, &st );
		goto done;
	}
	fd = open( path, O_RDONLY );
	if ( fd >= 0 ) {
		if ( fstat( fd, &st ) == 0 ) {
			if ( st.st_size > INT_MAX - 2 ) {
				res = 1;
			} else {
				len = st.st_size + 1; /* +1 detects file size > st.st_size */
				*datap = data = ptr = SLAP_MALLOC( len + 1 );
				if ( ptr != NULL ) {
					while ( len && (res = read( fd, ptr, len )) ) {
						if ( res > 0 ) {
							len -= res;
							ptr += res;
						} else if ( errno != EINTR ) {
							break;
						}
					}
					*ptr = '\0';
				}
			}
Howard Chu's avatar
Howard Chu committed
448
		}
449
450
451
452
453
454
		if ( close( fd ) < 0 )
			res = -1;
	}

 done:
	if ( res == 0 ) {
455
#ifdef LDAP_DEBUG
456
457
		Debug( LDAP_DEBUG_TRACE, "ldif_read_file: %s: \"%s\"\n",
			datap ? "read entry file" : "entry file exists", path, 0 );
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
		if ( datap ) {
			len = ptr - data;
			ptr = strstr( data, "\n# CRC32" );
			if (!ptr) {
				Debug( LDAP_DEBUG_TRACE, "ldif_read_file: no checksum \"%s\"\n",
					path, 0, 0 );
			} else {
				unsigned int crc1 = 0, crc2 = 1;
				if ( sscanf( ptr + 9, "%08x", &crc1) == 1) {
					ptr = strchr(ptr+1, '\n');
					if ( ptr ) {
						ptr++;
						len -= (ptr - data);
						crc2 = crc32( ptr, len );
					}
				}
				if ( crc1 != crc2 ) {
					Debug( LDAP_DEBUG_ANY, "ldif_read_file: checksum error on \"%s\"\n",
						path, 0, 0 );
				}
			}
		}
480
#endif /* LDAP_DEBUG */
481
482
483
484
485
486
487
488
489
490
	} else {
		if ( res < 0 && errno == ENOENT ) {
			Debug( LDAP_DEBUG_TRACE, "ldif_read_file: "
				"no entry file \"%s\"\n", path, 0, 0 );
			rc = LDAP_NO_SUCH_OBJECT;
		} else {
			const char *msg = res < 0 ? STRERROR( errno ) : "bad stat() size";
			Debug( LDAP_DEBUG_ANY, "ldif_read_file: %s for \"%s\"\n",
				msg, path, 0 );
			rc = LDAP_OTHER;
Howard Chu's avatar
Howard Chu committed
491
		}
492
493
		if ( data != NULL )
			SLAP_FREE( data );
Howard Chu's avatar
Howard Chu committed
494
	}
495
	return rc;
Howard Chu's avatar
Howard Chu committed
496
497
}

498
/*
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
499
 * return nonnegative for success or -1 for error
500
501
 * do not return numbers less than -1
 */
502
503
504
static int
spew_file( int fd, const char *spew, int len, int *save_errno )
{
505
506
	int writeres;
#define HEADER	"# AUTO-GENERATED FILE - DO NOT EDIT!! Use ldapmodify.\n"
507
	char header[sizeof(HEADER "# CRC32 12345678\n")];
508

509
	sprintf(header, HEADER "# CRC32 %08x\n", crc32(spew, len));
510
511
512
513
514
515
516
517
	writeres = write_data(fd, header, sizeof(header)-1, save_errno);
	return writeres < 0 ? writeres : write_data(fd, spew, len, save_errno);
}

static int
write_data( int fd, const char *spew, int len, int *save_errno )
{
	int writeres = 0;
518
519
	while(len > 0) {
		writeres = write(fd, spew, len);
Howard Chu's avatar
Howard Chu committed
520
		if(writeres == -1) {
521
522
523
			*save_errno = errno;
			if (*save_errno != EINTR)
				break;
Howard Chu's avatar
Howard Chu committed
524
525
		}
		else {
526
527
			spew += writeres;
			len -= writeres;
Howard Chu's avatar
Howard Chu committed
528
		}
Howard Chu's avatar
Howard Chu committed
529
530
531
532
	}
	return writeres;
}

533
/* Write an entry LDIF file.  Create parentdir first if non-NULL. */
534
static int
535
536
537
538
539
540
ldif_write_entry(
	Operation *op,
	Entry *e,
	const struct berval *path,
	const char *parentdir,
	const char **text )
541
{
542
543
544
545
546
547
548
549
	int rc = LDAP_OTHER, res, save_errno = 0;
	int fd, entry_length;
	char *entry_as_string, *tmpfname;

	if ( op->o_abandon )
		return SLAPD_ABANDON;

	if ( parentdir != NULL && mkdir( parentdir, 0750 ) < 0 ) {
550
		save_errno = errno;
551
552
553
554
555
556
557
558
559
560
561
562
563
564
		Debug( LDAP_DEBUG_ANY, "ldif_write_entry: %s \"%s\": %s\n",
			"cannot create parent directory",
			parentdir, STRERROR( save_errno ) );
		*text = "internal error (cannot create parent directory)";
		return rc;
	}

	tmpfname = ldif_tempname( path );
	fd = tmpfname == NULL ? -1 : mkstemp( tmpfname );
	if ( fd < 0 ) {
		save_errno = errno;
		Debug( LDAP_DEBUG_ANY, "ldif_write_entry: %s for \"%s\": %s\n",
			"cannot create file", e->e_dn, STRERROR( save_errno ) );
		*text = "internal error (cannot create file)";
565
566

	} else {
567
		ber_len_t dn_len = e->e_name.bv_len;
568
569
570
571
		struct berval rdn;

		/* Only save the RDN onto disk */
		dnRdn( &e->e_name, &rdn );
572
		if ( rdn.bv_len != dn_len ) {
573
574
			e->e_name.bv_val[rdn.bv_len] = '\0';
			e->e_name.bv_len = rdn.bv_len;
575
576
		}

577
578
579
580
581
582
		res = -2;
		ldap_pvt_thread_mutex_lock( &entry2str_mutex );
		entry_as_string = entry2str( e, &entry_length );
		if ( entry_as_string != NULL )
			res = spew_file( fd, entry_as_string, entry_length, &save_errno );
		ldap_pvt_thread_mutex_unlock( &entry2str_mutex );
583
584

		/* Restore full DN */
585
586
587
		if ( rdn.bv_len != dn_len ) {
			e->e_name.bv_val[rdn.bv_len] = ',';
			e->e_name.bv_len = dn_len;
588
589
		}

590
591
592
593
		if ( close( fd ) < 0 && res >= 0 ) {
			res = -1;
			save_errno = errno;
		}
594

595
596
597
598
599
		if ( res >= 0 ) {
			if ( move_file( tmpfname, path->bv_val ) == 0 ) {
				Debug( LDAP_DEBUG_TRACE, "ldif_write_entry: "
					"wrote entry \"%s\"\n", e->e_name.bv_val, 0, 0 );
				rc = LDAP_SUCCESS;
600
			} else {
601
602
603
604
605
				save_errno = errno;
				Debug( LDAP_DEBUG_ANY, "ldif_write_entry: "
					"could not put entry file for \"%s\" in place: %s\n",
					e->e_name.bv_val, STRERROR( save_errno ), 0 );
				*text = "internal error (could not put entry file in place)";
606
			}
607
608
609
610
		} else if ( res == -1 ) {
			Debug( LDAP_DEBUG_ANY, "ldif_write_entry: %s \"%s\": %s\n",
				"write error to", tmpfname, STRERROR( save_errno ) );
			*text = "internal error (write error to entry file)";
Howard Chu's avatar
Howard Chu committed
611
		}
612

613
		if ( rc != LDAP_SUCCESS ) {
614
			unlink( tmpfname );
Howard Chu's avatar
Howard Chu committed
615
616
		}
	}
617

618
619
620
	if ( tmpfname )
		SLAP_FREE( tmpfname );
	return rc;
Howard Chu's avatar
Howard Chu committed
621
622
}

623
624
625
626
627
628
629
630
631
/*
 * Read the entry at path, or if entryp==NULL just see if it exists.
 * pdn and pndn are the parent's DN and normalized DN, or both NULL.
 * Return an LDAP result code.
 */
static int
ldif_read_entry(
	Operation *op,
	const char *path,
632
	struct berval *pdn,
633
634
635
	struct berval *pndn,
	Entry **entryp,
	const char **text )
636
{
637
638
639
640
	int rc;
	Entry *entry;
	char *entry_as_string;
	struct berval rdn;
Howard Chu's avatar
Howard Chu committed
641

642
643
644
645
646
	/* TODO: Does slapd prevent Abandon of Bind as per rfc4511?
	 * If so we need not check for LDAP_REQ_BIND here.
	 */
	if ( op->o_abandon && op->o_tag != LDAP_REQ_BIND )
		return SLAPD_ABANDON;
Howard Chu's avatar
Howard Chu committed
647

648
649
650
651
652
653
654
655
656
657
658
659
660
	rc = ldif_read_file( path, entryp ? &entry_as_string : NULL );

	switch ( rc ) {
	case LDAP_SUCCESS:
		if ( entryp == NULL )
			break;
		*entryp = entry = str2entry( entry_as_string );
		SLAP_FREE( entry_as_string );
		if ( entry == NULL ) {
			rc = LDAP_OTHER;
			if ( text != NULL )
				*text = "internal error (cannot parse some entry file)";
			break;
Howard Chu's avatar
Howard Chu committed
661
		}
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
		if ( pdn == NULL || BER_BVISEMPTY( pdn ) )
			break;
		/* Append parent DN to DN from LDIF file */
		rdn = entry->e_name;
		build_new_dn( &entry->e_name, pdn, &rdn, NULL );
		SLAP_FREE( rdn.bv_val );
		rdn = entry->e_nname;
		build_new_dn( &entry->e_nname, pndn, &rdn, NULL );
		SLAP_FREE( rdn.bv_val );
		break;

	case LDAP_OTHER:
		if ( text != NULL )
			*text = entryp
				? "internal error (cannot read some entry file)"
				: "internal error (cannot stat some entry file)";
		break;
Howard Chu's avatar
Howard Chu committed
679
	}
680
681

	return rc;
Howard Chu's avatar
Howard Chu committed
682
683
}

684
685
686
687
688
/*
 * Read the operation's entry, or if entryp==NULL just see if it exists.
 * Return an LDAP result code.  May set *text to a message on failure.
 * If pathp is non-NULL, set it to the entry filename on success.
 */
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
689
690
691
692
static int
get_entry(
	Operation *op,
	Entry **entryp,
693
694
	struct berval *pathp,
	const char **text )
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
695
696
{
	int rc;
697
	struct berval path, pdn, pndn;
Howard Chu's avatar
Howard Chu committed
698

699
700
	dnParent( &op->o_req_dn, &pdn );
	dnParent( &op->o_req_ndn, &pndn );
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
701
702
703
704
705
	rc = ndn2path( op, &op->o_req_ndn, &path, 0 );
	if ( rc != LDAP_SUCCESS ) {
		goto done;
	}

706
	rc = ldif_read_entry( op, path.bv_val, &pdn, &pndn, entryp, text );
Howard Chu's avatar
Howard Chu committed
707

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
708
709
710
	if ( rc == LDAP_SUCCESS && pathp != NULL ) {
		*pathp = path;
	} else {
711
		SLAP_FREE( path.bv_val );
712
	}
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
713
 done:
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
714
	return rc;
Howard Chu's avatar
Howard Chu committed
715
716
717
}


718
719
720
721
722
723
/*
 * RDN-named directory entry, with special handling of "attr={num}val" RDNs.
 * For sorting, filename "attr=val.ldif" is truncated to "attr="val\0ldif",
 * and filename "attr={num}val.ldif" to "attr={\0um}val.ldif".
 * Does not sort escaped chars correctly, would need to un-escape them.
 */
724
725
typedef struct bvlist {
	struct bvlist *next;
726
727
728
	char *trunc;	/* filename was truncated here */
	int  inum;		/* num from "attr={num}" in filename, or INT_MIN */
	char savech;	/* original char at *trunc */
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
729
730
731
	/* BVL_NAME(&bvlist) is the filename, allocated after the struct: */
#	define BVL_NAME(bvl)     ((char *) ((bvl) + 1))
#	define BVL_SIZE(namelen) (sizeof(bvlist) + (namelen) + 1)
732
733
} bvlist;

734
735
static int
ldif_send_entry( Operation *op, SlapReply *rs, Entry *e, int scope )
736
{
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
	int rc = LDAP_SUCCESS;

	if ( scope == LDAP_SCOPE_BASE || scope == LDAP_SCOPE_SUBTREE ) {
		if ( rs == NULL ) {
			/* Save the entry for tool mode */
			struct ldif_tool *tl =
				&((struct ldif_info *) op->o_bd->be_private)->li_tool;

			if ( tl->ecount >= tl->elen ) {
				/* Allocate/grow entries */
				ID elen = tl->elen ? tl->elen * 2 : ENTRY_BUFF_INCREMENT;
				Entry **entries = (Entry **) SLAP_REALLOC( tl->entries,
					sizeof(Entry *) * elen );
				if ( entries == NULL ) {
					Debug( LDAP_DEBUG_ANY,
						"ldif_send_entry: out of memory\n", 0, 0, 0 );
					rc = LDAP_OTHER;
					goto done;
				}
				tl->elen = elen;
				tl->entries = entries;
			}
			tl->entries[tl->ecount++] = e;
			return rc;
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
761
		}
762

763
764
765
766
767
768
769
770
771
772
773
774
775
		else if ( !get_manageDSAit( op ) && is_entry_referral( e ) ) {
			/* Send a continuation reference.
			 * (ldif_back_referrals() handles baseobject referrals.)
			 * Don't check the filter since it's only a candidate.
			 */
			BerVarray refs = get_entry_referrals( op, e );
			rs->sr_ref = referral_rewrite( refs, &e->e_name, NULL, scope );
			rs->sr_entry = e;
			rc = send_search_reference( op, rs );
			ber_bvarray_free( rs->sr_ref );
			ber_bvarray_free( refs );
			rs->sr_ref = NULL;
			rs->sr_entry = NULL;
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
776
		}
777

778
779
780
		else if ( test_filter( op, e, op->ors_filter ) == LDAP_COMPARE_TRUE ) {
			rs->sr_entry = e;
			rs->sr_attrs = op->ors_attrs;
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
781
782
783
784
			/* Could set REP_ENTRY_MUSTBEFREED too for efficiency,
			 * but refraining lets us test unFREEable MODIFIABLE
			 * entries.  Like entries built on the stack.
			 */
785
786
787
			rs->sr_flags = REP_ENTRY_MODIFIABLE;
			rc = send_search_entry( op, rs );
			rs->sr_entry = NULL;
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
788
			rs->sr_attrs = NULL;
789
		}
Howard Chu's avatar
Howard Chu committed
790
	}
791

792
793
794
795
 done:
	entry_free( e );
	return rc;
}
Howard Chu's avatar
Howard Chu committed
796

797
798
799
800
801
802
803
804
805
806
807
/* Read LDIF directory <path> into <listp>.  Set *fname_maxlenp. */
static int
ldif_readdir(
	Operation *op,
	SlapReply *rs,
	const struct berval *path,
	bvlist **listp,
	ber_len_t *fname_maxlenp )
{
	int rc = LDAP_SUCCESS;
	DIR *dir_of_path;
808

809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
	*listp = NULL;
	*fname_maxlenp = 0;

	dir_of_path = opendir( path->bv_val );
	if ( dir_of_path == NULL ) {
		int save_errno = errno;
		struct ldif_info *li = (struct ldif_info *) op->o_bd->be_private;
		int is_rootDSE = (path->bv_len == li->li_base_path.bv_len);

		/* Absent directory is OK (leaf entry), except the database dir */
		if ( is_rootDSE || save_errno != ENOENT ) {
			Debug( LDAP_DEBUG_ANY,
				"=> ldif_search_entry: failed to opendir \"%s\": %s\n",
				path->bv_val, STRERROR( save_errno ), 0 );
			rc = LDAP_OTHER;
			if ( rs != NULL )
				rs->sr_text =
					save_errno != ENOENT ? "internal error (bad directory)"
					: !is_rootDSE ? "internal error (missing directory)"
					: "internal error (database directory does not exist)";
Howard Chu's avatar
Howard Chu committed
829
		}
830
831
832
833
834
835
836
837

	} else {
		bvlist *ptr;
		struct dirent *dir;
		int save_errno = 0;

		while ( (dir = readdir( dir_of_path )) != NULL ) {
			size_t fname_len;
838
			bvlist *bvl, **prev;
839
			char *trunc, *idxp, *endp, *endp2;
840

841
842
			fname_len = strlen( dir->d_name );
			if ( fname_len < STRLENOF( "x=" LDIF )) /* min filename size */
Howard Chu's avatar
Howard Chu committed
843
				continue;
844
			if ( strcmp( dir->d_name + fname_len - STRLENOF(LDIF), LDIF ))
845
				continue;
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868

			if ( *fname_maxlenp < fname_len )
				*fname_maxlenp = fname_len;

			bvl = SLAP_MALLOC( BVL_SIZE( fname_len ) );
			if ( bvl == NULL ) {
				rc = LDAP_OTHER;
				save_errno = errno;
				break;
			}
			strcpy( BVL_NAME( bvl ), dir->d_name );

			/* Make it sortable by ("attr=val" or <preceding {num}, num>) */
			trunc = BVL_NAME( bvl ) + fname_len - STRLENOF( LDIF );
			if ( (idxp = strchr( BVL_NAME( bvl ) + 2, IX_FSL )) != NULL &&
				 (endp = strchr( ++idxp, IX_FSR )) != NULL && endp > idxp &&
				 (eq_unsafe || idxp[-2] == '=' || endp + 1 == trunc) )
			{
				/* attr={n}val or bconfig.c's "pseudo-indexed" attr=val{n} */
				bvl->inum = strtol( idxp, &endp2, 10 );
				if ( endp2 == endp ) {
					trunc = idxp;
					goto truncate;
869
870
				}
			}
871
872
873
874
875
876
			bvl->inum = INT_MIN;
		truncate:
			bvl->trunc = trunc;
			bvl->savech = *trunc;
			*trunc = '\0';

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
877
			/* Insertion sort */
878
879
880
			for ( prev = listp; (ptr = *prev) != NULL; prev = &ptr->next ) {
				int cmp = strcmp( BVL_NAME( bvl ), BVL_NAME( ptr ));
				if ( cmp < 0 || (cmp == 0 && bvl->inum < ptr->inum) )
881
					break;
Howard Chu's avatar
Howard Chu committed
882
			}
883
			*prev = bvl;
884
			bvl->next = ptr;
Howard Chu's avatar
Howard Chu committed
885
		}
886
887
888
889
890
891
892
893
894
895
896

		if ( closedir( dir_of_path ) < 0 ) {
			save_errno = errno;
			rc = LDAP_OTHER;
			if ( rs != NULL )
				rs->sr_text = "internal error (bad directory)";
		}
		if ( rc != LDAP_SUCCESS ) {
			Debug( LDAP_DEBUG_ANY, "ldif_search_entry: %s \"%s\": %s\n",
				"error reading directory", path->bv_val,
				STRERROR( save_errno ) );
Howard Chu's avatar
Howard Chu committed
897
		}
Howard Chu's avatar
Howard Chu committed
898
	}
899

900
	return rc;
Howard Chu's avatar
Howard Chu committed
901
902
}

903
904
905
906
907
908
909
910
/*
 * Send an entry, recursively search its children, and free or save it.
 * Return an LDAP result code.  Parameters:
 *  op, rs  operation and reply.  rs == NULL for slap tools.
 *  e       entry to search, or NULL for rootDSE.
 *  scope   scope for the part of the search from this entry.
 *  path    LDIF filename -- bv_len and non-directory part are overwritten.
 */
911
static int
912
913
914
915
916
917
ldif_search_entry(
	Operation *op,
	SlapReply *rs,
	Entry *e,
	int scope,
	struct berval *path )
918
{
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
	int rc = LDAP_SUCCESS;
	struct berval dn = BER_BVC( "" ), ndn = BER_BVC( "" );

	if ( scope != LDAP_SCOPE_BASE && e != NULL ) {
		/* Copy DN/NDN since we send the entry with REP_ENTRY_MODIFIABLE,
		 * which bconfig.c seems to need.  (TODO: see config_rename_one.)
		 */
		if ( ber_dupbv( &dn,  &e->e_name  ) == NULL ||
			 ber_dupbv( &ndn, &e->e_nname ) == NULL )
		{
			Debug( LDAP_DEBUG_ANY,
				"ldif_search_entry: out of memory\n", 0, 0, 0 );
			rc = LDAP_OTHER;
			goto done;
		}
	}

	/* Send the entry if appropriate, and free or save it */
	if ( e != NULL )
		rc = ldif_send_entry( op, rs, e, scope );

	/* Search the children */
	if ( scope != LDAP_SCOPE_BASE && rc == LDAP_SUCCESS ) {
		bvlist *list, *ptr;
		struct berval fpath;	/* becomes child pathname */
		char *dir_end;	/* will point past dirname in fpath */

		ldif2dir_len( *path );
		ldif2dir_name( *path );
		rc = ldif_readdir( op, rs, path, &list, &fpath.bv_len );

		if ( list != NULL ) {
			const char **text = rs == NULL ? NULL : &rs->sr_text;

			if ( scope == LDAP_SCOPE_ONELEVEL )
				scope = LDAP_SCOPE_BASE;
			else if ( scope == LDAP_SCOPE_SUBORDINATE )
				scope = LDAP_SCOPE_SUBTREE;

			/* Allocate fpath and fill in directory part */
			dir_end = fullpath_alloc( &fpath, path, fpath.bv_len );
			if ( dir_end == NULL )
				rc = LDAP_OTHER;

			do {
				ptr = list;

				if ( rc == LDAP_SUCCESS ) {
					*ptr->trunc = ptr->savech;
					FILL_PATH( &fpath, dir_end, BVL_NAME( ptr ));

					rc = ldif_read_entry( op, fpath.bv_val, &dn, &ndn,
						&e, text );
					switch ( rc ) {
					case LDAP_SUCCESS:
						rc = ldif_search_entry( op, rs, e, scope, &fpath );
						break;
					case LDAP_NO_SUCH_OBJECT:
						/* Only the search baseDN may produce noSuchObject. */
						rc = LDAP_OTHER;
						if ( rs != NULL )
							rs->sr_text = "internal error "
								"(did someone just remove an entry file?)";
						Debug( LDAP_DEBUG_ANY, "ldif_search_entry: "
							"file listed in parent directory does not exist: "
							"\"%s\"\n", fpath.bv_val, 0, 0 );
						break;
					}
				}

				list = ptr->next;
				SLAP_FREE( ptr );
			} while ( list != NULL );

			if ( !BER_BVISNULL( &fpath ) )
				SLAP_FREE( fpath.bv_val );
		}
	}

 done:
	if ( !BER_BVISEMPTY( &dn ) )
		ber_memfree( dn.bv_val );
	if ( !BER_BVISEMPTY( &ndn ) )
		ber_memfree( ndn.bv_val );
	return rc;
}

static int
search_tree( Operation *op, SlapReply *rs )
{
	int rc = LDAP_SUCCESS;
	Entry *e = NULL;
1011
	struct berval path;
1012
	struct berval pdn, pndn;
1013

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1014
	(void) ndn2path( op, &op->o_req_ndn, &path, 1 );
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
	if ( !BER_BVISEMPTY( &op->o_req_ndn ) ) {
		/* Read baseObject */
		dnParent( &op->o_req_dn, &pdn );
		dnParent( &op->o_req_ndn, &pndn );
		rc = ldif_read_entry( op, path.bv_val, &pdn, &pndn, &e,
			rs == NULL ? NULL : &rs->sr_text );
	}
	if ( rc == LDAP_SUCCESS )
		rc = ldif_search_entry( op, rs, e, op->ors_scope, &path );

Howard Chu's avatar
Howard Chu committed
1025
1026
	ch_free( path.bv_val );
	return rc;
Howard Chu's avatar
Howard Chu committed
1027
1028
}

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1029

1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
/*
 * Prepare to create or rename an entry:
 * Check that the entry does not already exist.
 * Check that the parent entry exists and can have subordinates,
 * unless need_dir is NULL or adding the suffix entry.
 *
 * Return an LDAP result code.  May set *text to a message on failure.
 * If success, set *dnpath to LDIF entry path and *need_dir to
 * (directory must be created ? dirname : NULL).
 */
static int
ldif_prepare_create(
	Operation *op,
	Entry *e,
	struct berval *dnpath,
	char **need_dir,
	const char **text )
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1047
{
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1048
	struct ldif_info *li = (struct ldif_info *) op->o_bd->be_private;
1049
1050
1051
1052
	struct berval *ndn = &e->e_nname;
	struct berval ppath = BER_BVNULL;
	struct stat st;
	Entry *parent = NULL;
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1053
	int rc;
1054
1055
1056
1057

	if ( op->o_abandon )
		return SLAPD_ABANDON;

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1058
1059
1060
1061
	rc = ndn2path( op, ndn, dnpath, 0 );
	if ( rc != LDAP_SUCCESS ) {
		return rc;
	}
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117

	if ( stat( dnpath->bv_val, &st ) == 0 ) { /* entry .ldif file */
		rc = LDAP_ALREADY_EXISTS;

	} else if ( errno != ENOENT ) {
		Debug( LDAP_DEBUG_ANY,
			"ldif_prepare_create: cannot stat \"%s\": %s\n",
			dnpath->bv_val, STRERROR( errno ), 0 );
		rc = LDAP_OTHER;
		*text = "internal error (cannot check entry file)";

	} else if ( need_dir != NULL ) {
		*need_dir = NULL;
		rc = get_parent_path( dnpath, &ppath );
		/* If parent dir exists, so does parent .ldif:
		 * The directory gets created after and removed before the .ldif.
		 * Except with the database directory, which has no matching entry.
		 */
		if ( rc == LDAP_SUCCESS && stat( ppath.bv_val, &st ) < 0 ) {
			rc = errno == ENOENT && ppath.bv_len > li->li_base_path.bv_len
				? LDAP_NO_SUCH_OBJECT : LDAP_OTHER;
		}
		switch ( rc ) {
		case LDAP_NO_SUCH_OBJECT:
			/* No parent dir, check parent .ldif */
			dir2ldif_name( ppath );
			rc = ldif_read_entry( op, ppath.bv_val, NULL, NULL,
				(op->o_tag != LDAP_REQ_ADD || get_manageDSAit( op )
				 ? &parent : NULL),
				text );
			switch ( rc ) {
			case LDAP_SUCCESS:
				/* Check that parent is not a referral, unless
				 * ldif_back_referrals() already checked.
				 */
				if ( parent != NULL ) {
					int is_ref = is_entry_referral( parent );
					entry_free( parent );
					if ( is_ref ) {
						rc = LDAP_AFFECTS_MULTIPLE_DSAS;
						*text = op->o_tag == LDAP_REQ_MODDN
							? "newSuperior is a referral object"
							: "parent is a referral object";
						break;
					}
				}
				/* Must create parent directory. */
				ldif2dir_name( ppath );
				*need_dir = ppath.bv_val;
				break;
			case LDAP_NO_SUCH_OBJECT:
				*text = op->o_tag == LDAP_REQ_MODDN
					? "newSuperior object does not exist"
					: "parent does not exist";
				break;
			}
Howard Chu's avatar
Howard Chu committed
1118
			break;
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
		case LDAP_OTHER:
			Debug( LDAP_DEBUG_ANY,
				"ldif_prepare_create: cannot stat \"%s\" parent dir: %s\n",
				ndn->bv_val, STRERROR( errno ), 0 );
			*text = "internal error (cannot stat parent dir)";
			break;
		}
		if ( *need_dir == NULL && ppath.bv_val != NULL )
			SLAP_FREE( ppath.bv_val );
	}

	if ( rc != LDAP_SUCCESS ) {
		SLAP_FREE( dnpath->bv_val );
		BER_BVZERO( dnpath );
	}
	return rc;
Howard Chu's avatar
Howard Chu committed
1135
1136
}

1137
1138
1139
1140
1141
static int
apply_modify_to_entry(
	Entry *entry,
	Modifications *modlist,
	Operation *op,
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1142
1143
	SlapReply *rs,
	char *textbuf )
Howard Chu's avatar
Howard Chu committed
1144
{
Pierangelo Masarati's avatar
Pierangelo Masarati committed
1145
1146
	int rc = modlist ? LDAP_UNWILLING_TO_PERFORM : LDAP_SUCCESS;
	int is_oc = 0;
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1147
	Modification *mods;
Howard Chu's avatar
Howard Chu committed
1148
1149

	if (!acl_check_modlist(op, entry, modlist)) {
Howard Chu's avatar
Howard Chu committed
1150
		return LDAP_INSUFFICIENT_ACCESS;
Howard Chu's avatar
Howard Chu committed
1151
1152
1153
	}

	for (; modlist != NULL; modlist = modlist->sml_next) {
Howard Chu's avatar
Howard Chu committed
1154
1155
		mods = &modlist->sml_mod;

Pierangelo Masarati's avatar
Pierangelo Masarati committed
1156
1157
1158
		if ( mods->sm_desc == slap_schema.si_ad_objectClass ) {
			is_oc = 1;
		}
Howard Chu's avatar
Howard Chu committed
1159
1160
1161
1162
1163
		switch (mods->sm_op) {
		case LDAP_MOD_ADD:
			rc = modify_add_values(entry, mods,
				   get_permissiveModify(op),
				   &rs->sr_text, textbuf,
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1164
				   SLAP_TEXT_BUFLEN );
Howard Chu's avatar
Howard Chu committed
1165
			break;
1166

Howard Chu's avatar
Howard Chu committed
1167
1168
1169
1170
		case LDAP_MOD_DELETE:
			rc = modify_delete_values(entry, mods,
				get_permissiveModify(op),
				&rs->sr_text, textbuf,
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1171
				SLAP_TEXT_BUFLEN );
Howard Chu's avatar
Howard Chu committed
1172
			break;
1173

Howard Chu's avatar
Howard Chu committed
1174
1175
1176
1177
		case LDAP_MOD_REPLACE:
			rc = modify_replace_values(entry, mods,
				 get_permissiveModify(op),
				 &rs->sr_text, textbuf,
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1178
				 SLAP_TEXT_BUFLEN );
Howard Chu's avatar
Howard Chu committed
1179
			break;
1180

Howard Chu's avatar
Howard Chu committed
1181
		case LDAP_MOD_INCREMENT:
1182
1183
1184
			rc = modify_increment_values( entry,
				mods, get_permissiveModify(op),
				&rs->sr_text, textbuf,
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1185
				SLAP_TEXT_BUFLEN );
1186
1187
			break;

Howard Chu's avatar
Howard Chu committed
1188
1189
1190
1191
1192
		case SLAP_MOD_SOFTADD:
			mods->sm_op = LDAP_MOD_ADD;
			rc = modify_add_values(entry, mods,
				   get_permissiveModify(op),
				   &rs->sr_text, textbuf,
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1193
				   SLAP_TEXT_BUFLEN );
Howard Chu's avatar
Howard Chu committed
1194
1195
			mods->sm_op = SLAP_MOD_SOFTADD;
			if (rc == LDAP_TYPE_OR_VALUE_EXISTS) {
1196
				rc = LDAP_SUCCESS;
Howard Chu's avatar
Howard Chu committed
1197
1198
1199
1200
			}
			break;
		}
		if(rc != LDAP_SUCCESS) break;
Howard Chu's avatar
Howard Chu committed
1201
	}
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1202

1203
1204
	if ( rc == LDAP_SUCCESS ) {
		rs->sr_text = NULL; /* Needed at least with SLAP_MOD_SOFTADD */
Pierangelo Masarati's avatar
Pierangelo Masarati committed
1205
		if ( is_oc ) {
Howard Chu's avatar
Howard Chu committed
1206
1207
1208
			entry->e_ocflags = 0;
		}
		/* check that the entry still obeys the schema */
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1209
		rc = entry_schema_check( op, entry, NULL, 0, 0, NULL,
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1210
			  &rs->sr_text, textbuf, SLAP_TEXT_BUFLEN );
Howard Chu's avatar
Howard Chu committed
1211
	}
Pierangelo Masarati's avatar
Pierangelo Masarati committed
1212

Howard Chu's avatar
Howard Chu committed
1213
1214
1215
	return rc;
}

1216
1217

static int
1218
1219
ldif_back_referrals( Operation *op, SlapReply *rs )
{
1220
1221
1222
1223
1224
1225
	struct ldif_info *li = (struct ldif_info *) op->o_bd->be_private;
	struct berval path, dn = op->o_req_dn, ndn = op->o_req_ndn;
	ber_len_t min_dnlen;
	Entry *entry = NULL, **entryp;
	BerVarray ref;
	int rc;
1226

1227
1228
1229
1230
	min_dnlen = op->o_bd->be_nsuffix[0].bv_len;
	if ( min_dnlen == 0 ) {
		/* Catch root DSE (empty DN), it is not a referral */
		min_dnlen = 1;
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1231
1232
1233
	}
	if ( ndn2path( op, &ndn, &path, 0 ) != LDAP_SUCCESS ) {
		return LDAP_SUCCESS;	/* Root DSE again */
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1234
1235
	}

1236
	entryp = get_manageDSAit( op ) ? NULL : &entry;
1237
	ldap_pvt_thread_rdwr_rlock( &li->li_rdwr );
1238

1239
1240
1241
1242
1243
1244
1245
	for (;;) {
		dnParent( &dn, &dn );
		dnParent( &ndn, &ndn );
		rc = ldif_read_entry( op, path.bv_val, &dn, &ndn,
			entryp, &rs->sr_text );
		if ( rc != LDAP_NO_SUCH_OBJECT )
			break;
1246

1247
1248
1249
1250
1251
1252
1253
		rc = LDAP_SUCCESS;
		if ( ndn.bv_len < min_dnlen )
			break;
		(void) get_parent_path( &path, NULL );
		dir2ldif_name( path );
		entryp = &entry;
	}
1254

1255
1256
	ldap_pvt_thread_rdwr_runlock( &li->li_rdwr );
	SLAP_FREE( path.bv_val );
1257

1258
1259
	if ( entry != NULL ) {
		if ( is_entry_referral( entry ) ) {
1260
			Debug( LDAP_DEBUG_TRACE,
1261
				"ldif_back_referrals: tag=%lu target=\"%s\" matched=\"%s\"\n",
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
				(unsigned long) op->o_tag, op->o_req_dn.bv_val, entry->e_dn );

			ref = get_entry_referrals( op, entry );
			rs->sr_ref = referral_rewrite( ref, &entry->e_name, &op->o_req_dn,
				op->o_tag == LDAP_REQ_SEARCH ?
				op->ors_scope : LDAP_SCOPE_DEFAULT );
			ber_bvarray_free( ref );

			if ( rs->sr_ref != NULL ) {
				/* send referral */
				rc = rs->sr_err = LDAP_REFERRAL;
				rs->sr_matched = entry->e_dn;
				send_ldap_result( op, rs );
				ber_bvarray_free( rs->sr_ref );
				rs->sr_ref = NULL;
			} else {
1278
				rc = LDAP_OTHER;
1279
				rs->sr_text = "bad referral object";
1280
1281
1282
1283
			}
			rs->sr_matched = NULL;
		}

1284
		entry_free( entry );
1285
1286
1287
1288
1289
	}

	return rc;
}

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1290
1291
1292

/* LDAP operations */

Howard Chu's avatar
Howard Chu committed
1293
1294
1295
static int
ldif_back_bind( Operation *op, SlapReply *rs )
{
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1296
1297
	struct ldif_info *li;
	Attribute *a;
Howard Chu's avatar
Howard Chu committed
1298
	AttributeDescription *password = slap_schema.si_ad_userPassword;
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1299
	int return_val;
1300
	Entry *entry = NULL;
Howard Chu's avatar
Howard Chu committed
1301

1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
	switch ( be_rootdn_bind( op, rs ) ) {
	case SLAP_CB_CONTINUE:
		break;

	default:
		/* in case of success, front end will send result;
		 * otherwise, be_rootdn_bind() did */
		return rs->sr_err;
	}

	li = (struct ldif_info *) op->o_bd->be_private;
	ldap_pvt_thread_rdwr_rlock(&li->li_rdwr);
1314
	return_val = get_entry(op, &entry, NULL, NULL);
Howard Chu's avatar
Howard Chu committed
1315
1316

	/* no object is found for them */
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
1317
	if(return_val != LDAP_SUCCESS) {
1318
		rs->sr_err = return_val = LDAP_INVALID_CREDENTIALS;
1319
		goto return_result;
Howard Chu's avatar
Howard Chu committed
1320
1321
1322
1323
	}

	/* they don't have userpassword */
	if((a = attr_find(entry->e_attrs, password)) == NULL) {
Howard Chu's avatar
Howard Chu committed
1324
1325
1326
		rs->sr_err = LDAP_INAPPROPRIATE_AUTH;
		return_val = 1;
		goto return_result;
Howard Chu's avatar
Howard Chu committed
1327
1328
1329
1330
	}

	/* authentication actually failed */
	if(slap_passwd_check(op, entry, a, &op->oq_bind.rb_cred,
Howard Chu's avatar
Howard Chu committed
1331
1332
1333
1334
			     &rs->sr_text) != 0) {
		rs->sr_err = LDAP_INVALID_CREDENTIALS;
		return_val = 1;
		goto return_result;
Howard Chu's avatar
Howard Chu committed
1335
1336
1337
	}

	/* let the front-end send success */
1338
	return_val = LDAP_SUCCESS;
Howard Chu's avatar
Howard Chu committed
1339
1340

 return_result:
1341
	ldap_pvt_thread_rdwr_runlock(&li->li_rdwr);
1342
	if(return_val != LDAP_SUCCESS)
Howard Chu's avatar
Howard Chu committed
1343
		send_ldap_result( op, rs );
Howard Chu's avatar
Howard Chu committed
1344
	if(entry != NULL)
Howard Chu's avatar
Howard Chu committed
1345
		entry_free(entry);
Howard Chu's avatar
Howard Chu committed
1346
1347
1348
	return return_val;
}

1349
1350
static int
ldif_back_search( Operation *op, SlapReply *rs )
Howard Chu's avatar
Howard Chu committed
1351
{
1352
	struct ldif_info *li = (struct ldif_info *) op->o_bd->be_private;
Howard Chu's avatar
Howard Chu committed
1353

1354
	ldap_pvt_thread_rdwr_rlock(&li->li_rdwr);
1355
	rs->sr_err = search_tree( op, rs );
1356
	ldap_pvt_thread_rdwr_runlock(&li->li_rdwr);
1357
	send_ldap_result(op, rs);
Howard Chu's avatar
Howard Chu committed
1358

1359
	return rs->sr_err;
Howard Chu's avatar
Howard Chu committed
1360
1361
}

1362
1363
1364
static int
ldif_back_add( Operation *op, SlapReply *rs )
{
1365
	struct ldif_info *li = (struct ldif_info *) op->o_bd->be_private;
Howard Chu's avatar
Howard Chu committed
1366
	Entry * e = op->ora_e;
1367
1368
	struct