ldif.c 44.9 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/>.
 *
5
 * Copyright 2005-2009 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
40
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 */
};
41

42
/* Per-database data */
Howard Chu's avatar
Howard Chu committed
43
struct ldif_info {
44
45
46
47
48
49
50
51
52
53
54
55
	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
56
57
};

Howard Chu's avatar
Howard Chu committed
58
59
#ifdef _WIN32
#define mkdir(a,b)	mkdir(a)
60
61
62
#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
63
#endif
64
#define move_dir(from, to) rename(from, to)
Howard Chu's avatar
Howard Chu committed
65

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

Howard Chu's avatar
Howard Chu committed
67
#define LDIF	".ldif"
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
68
69
70
71
72
73
#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
74
75
 * 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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 *
 * 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
98

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
99
100
101
#else /* _WIN32 */

/* Windows version - Microsoft's list of unsafe characters, except '\\' */
102
#define LDIF_ESCAPE_CHAR	'^'			/* Not '\\' (unsafe on Windows) */
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
103
104
105
106
107
108
109
110
111
112
113
#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.
 */
114
115
116
117
118
119
120
#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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
/*
 * 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))

147
148
149
150
151
152
153
154
155
156
157
158
/* 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
159

Howard Chu's avatar
Howard Chu committed
160

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

static ConfigOCs ldifocs[] = {
173
174
	{ "( OLcfgDbOc:2.1 "
		"NAME 'olcLdifConfig' "
175
		"DESC 'LDIF backend configuration' "
Howard Chu's avatar
Howard Chu committed
176
		"SUP olcDatabaseConfig "
177
		"MUST ( olcDbDirectory ) )", Cft_Database, ldifcfg },
Howard Chu's avatar
Howard Chu committed
178
	{ NULL, 0, NULL }
179
180
};

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

182
183
184
185
/*
 * Handle file/directory names.
 */

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
186
/* Set *res = LDIF filename path for the normalized DN */
Howard Chu's avatar
Howard Chu committed
187
static void
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
188
dn2path( BackendDB *be, struct berval *dn, struct berval *res )
Howard Chu's avatar
Howard Chu committed
189
{
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
190
191
192
193
194
195
196
197
198
	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 ) );
199
200
	assert( suffixdn != NULL );
	assert( !BER_BVISNULL( suffixdn ) );
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
201
	assert( dnIsSuffix( dn, suffixdn ) );
Pierangelo Masarati's avatar
Pierangelo Masarati committed
202

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
203
204
	start = dn->bv_val;
	end = start + dn->bv_len;
Pierangelo Masarati's avatar
Pierangelo Masarati committed
205

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
206
207
208
209
210
211
	/* 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
212
	}
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
213
214
215
216
217
218
219
220
	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 ) )
221
				break;
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
		}
		/* 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];
			}
237
		}
238
	}
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
239
240
	ptr = lutil_strcopy( ptr, LDIF );
	res->bv_len = ptr - res->bv_val;
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
241

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
242
	assert( res->bv_len <= len );
Howard Chu's avatar
Howard Chu committed
243
244
}

245
246
247
248
249
250
251
252
253
254
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
/*
 * *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;
}

/*
 * 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 )
{
	int rc, fd, len;
	int res = -1;	/* 0:success, <0:error, >0:file too big/growing. */
327
	struct stat st;
328
	char *data = NULL, *ptr;
329

330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
	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
354
		}
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
		if ( close( fd ) < 0 )
			res = -1;
	}

 done:
	if ( res == 0 ) {
		Debug( LDAP_DEBUG_TRACE, "ldif_read_file: %s: \"%s\"\n",
			datap ? "read entry file" : "entry file exists", path, 0 );
		rc = LDAP_SUCCESS;
	} 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
374
		}
375
376
		if ( data != NULL )
			SLAP_FREE( data );
Howard Chu's avatar
Howard Chu committed
377
	}
378
	return rc;
Howard Chu's avatar
Howard Chu committed
379
380
}

381
/*
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
382
 * return nonnegative for success or -1 for error
383
384
 * do not return numbers less than -1
 */
385
386
387
static int
spew_file( int fd, const char *spew, int len, int *save_errno )
{
388
	int writeres = 0;
389

390
391
	while(len > 0) {
		writeres = write(fd, spew, len);
Howard Chu's avatar
Howard Chu committed
392
		if(writeres == -1) {
393
394
395
			*save_errno = errno;
			if (*save_errno != EINTR)
				break;
Howard Chu's avatar
Howard Chu committed
396
397
		}
		else {
398
399
			spew += writeres;
			len -= writeres;
Howard Chu's avatar
Howard Chu committed
400
		}
Howard Chu's avatar
Howard Chu committed
401
402
403
404
	}
	return writeres;
}

405
/* Write an entry LDIF file.  Create parentdir first if non-NULL. */
406
static int
407
408
409
410
411
412
ldif_write_entry(
	Operation *op,
	Entry *e,
	const struct berval *path,
	const char *parentdir,
	const char **text )
413
{
414
415
416
417
418
419
420
421
	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 ) {
422
		save_errno = errno;
423
424
425
426
427
428
429
430
431
432
433
434
435
436
		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)";
437
438

	} else {
439
		ber_len_t dn_len = e->e_name.bv_len;
440
441
442
443
		struct berval rdn;

		/* Only save the RDN onto disk */
		dnRdn( &e->e_name, &rdn );
444
		if ( rdn.bv_len != dn_len ) {
445
446
			e->e_name.bv_val[rdn.bv_len] = '\0';
			e->e_name.bv_len = rdn.bv_len;
447
448
		}

449
450
451
452
453
454
		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 );
455
456

		/* Restore full DN */
457
458
459
		if ( rdn.bv_len != dn_len ) {
			e->e_name.bv_val[rdn.bv_len] = ',';
			e->e_name.bv_len = dn_len;
460
461
		}

462
463
464
465
		if ( close( fd ) < 0 && res >= 0 ) {
			res = -1;
			save_errno = errno;
		}
466

467
468
469
470
471
		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;
472
			} else {
473
474
475
476
477
				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)";
478
			}
479
480
481
482
		} 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
483
		}
484

485
		if ( rc != LDAP_SUCCESS ) {
486
			unlink( tmpfname );
Howard Chu's avatar
Howard Chu committed
487
488
		}
	}
489

490
491
492
	if ( tmpfname )
		SLAP_FREE( tmpfname );
	return rc;
Howard Chu's avatar
Howard Chu committed
493
494
}

495
496
497
498
499
500
501
502
503
/*
 * 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,
504
	struct berval *pdn,
505
506
507
	struct berval *pndn,
	Entry **entryp,
	const char **text )
508
{
509
510
511
512
	int rc;
	Entry *entry;
	char *entry_as_string;
	struct berval rdn;
Howard Chu's avatar
Howard Chu committed
513

514
515
516
517
518
	/* 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
519

520
521
522
523
524
525
526
527
528
529
530
531
532
	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
533
		}
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
		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
551
	}
552
553

	return rc;
Howard Chu's avatar
Howard Chu committed
554
555
}

556
557
558
559
560
/*
 * 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
561
562
563
564
static int
get_entry(
	Operation *op,
	Entry **entryp,
565
566
	struct berval *pathp,
	const char **text )
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
567
568
{
	int rc;
569
	struct berval path, pdn, pndn;
Howard Chu's avatar
Howard Chu committed
570

571
572
	dnParent( &op->o_req_dn, &pdn );
	dnParent( &op->o_req_ndn, &pndn );
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
573
	dn2path( op->o_bd, &op->o_req_ndn, &path );
574
	rc = ldif_read_entry( op, path.bv_val, &pdn, &pndn, entryp, text );
Howard Chu's avatar
Howard Chu committed
575

Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
576
577
578
	if ( rc == LDAP_SUCCESS && pathp != NULL ) {
		*pathp = path;
	} else {
579
		SLAP_FREE( path.bv_val );
580
	}
Quanah Gibson-Mount's avatar
Quanah Gibson-Mount committed
581
	return rc;
Howard Chu's avatar
Howard Chu committed
582
583
584
}


585
586
587
588
589
590
/*
 * 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.
 */
591
592
typedef struct bvlist {
	struct bvlist *next;
593
594
595
	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
596
597
598
	/* 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)
599
600
} bvlist;

601
602
static int
ldif_send_entry( Operation *op, SlapReply *rs, Entry *e, int scope )
603
{
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
	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
628
		}
629

630
631
632
633
634
635
636
637
638
639
640
641
642
		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
643
		}
644

645
646
647
648
649
650
		else if ( test_filter( op, e, op->ors_filter ) == LDAP_COMPARE_TRUE ) {
			rs->sr_entry = e;
			rs->sr_attrs = op->ors_attrs;
			rs->sr_flags = REP_ENTRY_MODIFIABLE;
			rc = send_search_entry( op, rs );
			rs->sr_entry = NULL;
651
		}
Howard Chu's avatar
Howard Chu committed
652
	}
653

654
655
656
657
 done:
	entry_free( e );
	return rc;
}
Howard Chu's avatar
Howard Chu committed
658

659
660
661
662
663
664
665
666
667
668
669
/* 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;
670

671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
	*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
691
		}
692
693
694
695
696
697
698
699

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

		while ( (dir = readdir( dir_of_path )) != NULL ) {
			size_t fname_len;
700
			bvlist *bvl, **prev;
701
			char *trunc, *idxp, *endp, *endp2;
702

703
704
			fname_len = strlen( dir->d_name );
			if ( fname_len < STRLENOF( "x=" LDIF )) /* min filename size */
Howard Chu's avatar
Howard Chu committed
705
				continue;
706
			if ( strcmp( dir->d_name + fname_len - STRLENOF(LDIF), LDIF ))
707
				continue;
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730

			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;
731
732
				}
			}
733
734
735
736
737
738
739
740
741
			bvl->inum = INT_MIN;
		truncate:
			bvl->trunc = trunc;
			bvl->savech = *trunc;
			*trunc = '\0';

			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) )
742
					break;
Howard Chu's avatar
Howard Chu committed
743
			}
744
			*prev = bvl;
745
			bvl->next = ptr;
Howard Chu's avatar
Howard Chu committed
746
		}
747
748
749
750
751
752
753
754
755
756
757

		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
758
		}
Howard Chu's avatar
Howard Chu committed
759
	}
760

761
	return rc;
Howard Chu's avatar
Howard Chu committed
762
763
}

764
765
766
767
768
769
770
771
/*
 * 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.
 */
772
static int
773
774
775
776
777
778
ldif_search_entry(
	Operation *op,
	SlapReply *rs,
	Entry *e,
	int scope,
	struct berval *path )
779
{
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
	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;
872
	struct berval path;
873
	struct berval pdn, pndn;
874

875
876
877
878
879
880
881
882
883
884
885
	dn2path( op->o_bd, &op->o_req_ndn, &path );
	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
886
887
	ch_free( path.bv_val );
	return rc;
Howard Chu's avatar
Howard Chu committed
888
889
}

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

891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
/*
 * 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
908
{
909
910
911
912
913
914
915
916
917
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
	BackendDB *be = op->o_bd;
	struct ldif_info *li = (struct ldif_info *) be->be_private;
	struct berval *ndn = &e->e_nname;
	struct berval ppath = BER_BVNULL;
	struct stat st;
	Entry *parent = NULL;
	int rc = LDAP_SUCCESS;

	if ( op->o_abandon )
		return SLAPD_ABANDON;

	dn2path( be, ndn, dnpath );

	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
977
			break;
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
		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
994
995
}

996
997
998
999
1000
static int
apply_modify_to_entry(
	Entry *entry,
	Modifications *modlist,
	Operation *op,