405
/* Write an entry LDIF file. Create parentdir first if non-NULL. */
270
spew_entry( Entry * e, struct berval * path, int dolock, int *save_errnop )
410
const struct berval *path,
411
const char *parentdir,
272
int rs, save_errno = 0;
276
char * entry_as_string;
277
char *tmpfname = NULL;
279
tmpfname = ch_malloc( path->bv_len + STRLENOF( "XXXXXX" ) + 1 );
280
AC_MEMCPY( tmpfname, path->bv_val, path->bv_len );
281
AC_MEMCPY( &tmpfname[ path->bv_len ], "XXXXXX", STRLENOF( "XXXXXX" ) + 1 );
283
openres = mkstemp( tmpfname );
284
if ( openres == -1 ) {
286
rs = LDAP_UNWILLING_TO_PERFORM;
287
Debug( LDAP_DEBUG_ANY, "could not create tmpfile \"%s\": %s\n",
288
tmpfname, STRERROR( save_errno ), 0 );
414
int rc = LDAP_OTHER, res, save_errno = 0;
415
int fd, entry_length;
416
char *entry_as_string, *tmpfname;
419
return SLAPD_ABANDON;
421
if ( parentdir != NULL && mkdir( parentdir, 0750 ) < 0 ) {
423
Debug( LDAP_DEBUG_ANY, "ldif_write_entry: %s \"%s\": %s\n",
424
"cannot create parent directory",
425
parentdir, STRERROR( save_errno ) );
426
*text = "internal error (cannot create parent directory)";
430
tmpfname = ldif_tempname( path );
431
fd = tmpfname == NULL ? -1 : mkstemp( tmpfname );
434
Debug( LDAP_DEBUG_ANY, "ldif_write_entry: %s for \"%s\": %s\n",
435
"cannot create file", e->e_dn, STRERROR( save_errno ) );
436
*text = "internal error (cannot create file)";
439
ber_len_t dn_len = e->e_name.bv_len;
291
440
struct berval rdn;
294
442
/* Only save the RDN onto disk */
295
443
dnRdn( &e->e_name, &rdn );
296
if ( rdn.bv_len != e->e_name.bv_len ) {
444
if ( rdn.bv_len != dn_len ) {
297
445
e->e_name.bv_val[rdn.bv_len] = '\0';
298
tmp = e->e_name.bv_len;
299
446
e->e_name.bv_len = rdn.bv_len;
305
ldap_pvt_thread_mutex_lock(&entry2str_mutex);
308
entry_as_string = entry2str(e, &entry_length);
309
if ( entry_as_string != NULL ) {
310
spew_res = spew_file( openres,
311
entry_as_string, entry_length );
312
if ( spew_res == -1 ) {
318
ldap_pvt_thread_mutex_unlock(&entry2str_mutex);
450
ldap_pvt_thread_mutex_lock( &entry2str_mutex );
451
entry_as_string = entry2str( e, &entry_length );
452
if ( entry_as_string != NULL )
453
res = spew_file( fd, entry_as_string, entry_length, &save_errno );
454
ldap_pvt_thread_mutex_unlock( &entry2str_mutex );
321
456
/* Restore full DN */
322
if ( rdn.bv_len != e->e_name.bv_len ) {
323
e->e_name.bv_val[e->e_name.bv_len] = ',';
324
e->e_name.bv_len = rdn.bv_len;
327
res = close( openres );
328
rs = LDAP_UNWILLING_TO_PERFORM;
330
if ( spew_res > -2 ) {
331
if ( res == -1 || spew_res == -1 ) {
332
if ( save_errno == 0 ) {
335
Debug( LDAP_DEBUG_ANY, "write error to tmpfile \"%s\": %s\n",
336
tmpfname, STRERROR( save_errno ), 0 );
457
if ( rdn.bv_len != dn_len ) {
458
e->e_name.bv_val[rdn.bv_len] = ',';
459
e->e_name.bv_len = dn_len;
462
if ( close( fd ) < 0 && res >= 0 ) {
468
if ( move_file( tmpfname, path->bv_val ) == 0 ) {
469
Debug( LDAP_DEBUG_TRACE, "ldif_write_entry: "
470
"wrote entry \"%s\"\n", e->e_name.bv_val, 0, 0 );
339
res = rename( tmpfname, path->bv_val );
345
switch ( save_errno ) {
347
rs = LDAP_NO_SUCH_OBJECT;
474
Debug( LDAP_DEBUG_ANY, "ldif_write_entry: "
475
"could not put entry file for \"%s\" in place: %s\n",
476
e->e_name.bv_val, STRERROR( save_errno ), 0 );
477
*text = "internal error (could not put entry file in place)";
479
} else if ( res == -1 ) {
480
Debug( LDAP_DEBUG_ANY, "ldif_write_entry: %s \"%s\": %s\n",
481
"write error to", tmpfname, STRERROR( save_errno ) );
482
*text = "internal error (write error to entry file)";
357
if ( rs != LDAP_SUCCESS ) {
485
if ( rc != LDAP_SUCCESS ) {
358
486
unlink( tmpfname );
364
if ( rs != LDAP_SUCCESS && save_errnop != NULL ) {
365
*save_errnop = save_errno;
491
SLAP_FREE( tmpfname );
371
static Entry * get_entry_for_fd(int fd,
496
* Read the entry at path, or if entryp==NULL just see if it exists.
497
* pdn and pndn are the parent's DN and normalized DN, or both NULL.
498
* Return an LDAP result code.
372
504
struct berval *pdn,
375
char * entry = (char *) slurp_file(fd);
376
Entry * ldentry = NULL;
378
/* error reading file */
383
ldentry = str2entry(entry);
386
rdn = ldentry->e_name;
387
build_new_dn( &ldentry->e_name, pdn, &rdn, NULL );
388
ch_free( rdn.bv_val );
389
rdn = ldentry->e_nname;
390
build_new_dn( &ldentry->e_nname, pndn, &rdn, NULL );
391
ch_free( rdn.bv_val );
511
char *entry_as_string;
514
/* TODO: Does slapd prevent Abandon of Bind as per rfc4511?
515
* If so we need not check for LDAP_REQ_BIND here.
517
if ( op->o_abandon && op->o_tag != LDAP_REQ_BIND )
518
return SLAPD_ABANDON;
520
rc = ldif_read_file( path, entryp ? &entry_as_string : NULL );
524
if ( entryp == NULL )
526
*entryp = entry = str2entry( entry_as_string );
527
SLAP_FREE( entry_as_string );
528
if ( entry == NULL ) {
531
*text = "internal error (cannot parse some entry file)";
534
if ( pdn == NULL || BER_BVISEMPTY( pdn ) )
536
/* Append parent DN to DN from LDIF file */
538
build_new_dn( &entry->e_name, pdn, &rdn, NULL );
539
SLAP_FREE( rdn.bv_val );
540
rdn = entry->e_nname;
541
build_new_dn( &entry->e_nname, pndn, &rdn, NULL );
542
SLAP_FREE( rdn.bv_val );
548
? "internal error (cannot read some entry file)"
549
: "internal error (cannot stat some entry file)";
557
* Read the operation's entry, or if entryp==NULL just see if it exists.
558
* Return an LDAP result code. May set *text to a message on failure.
559
* If pathp is non-NULL, set it to the entry filename on success.
409
struct berval *pathp )
565
struct berval *pathp,
412
569
struct berval path, pdn, pndn;
415
dnParent(&op->o_req_dn, &pdn);
416
dnParent(&op->o_req_ndn, &pndn);
571
dnParent( &op->o_req_dn, &pdn );
572
dnParent( &op->o_req_ndn, &pndn );
417
573
dn2path( op->o_bd, &op->o_req_ndn, &path );
418
fd = open(path.bv_val, O_RDONLY);
419
/* error opening file (mebbe should log error) */
420
if ( fd == -1 && ( errno != ENOENT || op->o_tag != LDAP_REQ_ADD ) ) {
421
Debug( LDAP_DEBUG_ANY, "failed to open file \"%s\": %s\n",
422
path.bv_val, STRERROR(errno), 0 );
424
*entryp = fd < 0 ? NULL : get_entry_for_fd( fd, &pdn, &pndn );
425
rc = *entryp ? LDAP_SUCCESS : LDAP_NO_SUCH_OBJECT;
574
rc = ldif_read_entry( op, path.bv_val, &pdn, &pndn, entryp, text );
427
576
if ( rc == LDAP_SUCCESS && pathp != NULL ) {
430
SLAP_FREE(path.bv_val);
579
SLAP_FREE( path.bv_val );
435
static void fullpath(struct berval *base, struct berval *name, struct berval *res) {
437
res->bv_len = name->bv_len + base->bv_len + 1;
438
res->bv_val = ch_malloc( res->bv_len + 1 );
439
strcpy(res->bv_val, base->bv_val);
440
ptr = res->bv_val + base->bv_len;
441
*ptr++ = LDAP_DIRSEP[0];
442
strcpy(ptr, name->bv_val);
586
* RDN-named directory entry, with special handling of "attr={num}val" RDNs.
587
* For sorting, filename "attr=val.ldif" is truncated to "attr="val\0ldif",
588
* and filename "attr={num}val.ldif" to "attr={\0um}val.ldif".
589
* Does not sort escaped chars correctly, would need to un-escape them.
445
591
typedef struct bvlist {
446
592
struct bvlist *next;
593
char *trunc; /* filename was truncated here */
594
int inum; /* num from "attr={num}" in filename, or INT_MIN */
595
char savech; /* original char at *trunc */
596
char fname; /* variable length array BVL_NAME(bvl) = &fname */
597
# define BVL_NAME(bvl) ((char *) (bvl) + offsetof(bvlist, fname))
598
# define BVL_SIZE(namelen) (sizeof(bvlist) + (namelen))
454
static int r_enum_tree(enumCookie *ck, struct berval *path, int base,
455
struct berval *pdn, struct berval *pndn)
602
ldif_send_entry( Operation *op, SlapReply *rs, Entry *e, int scope )
458
int fd = 0, rc = LDAP_SUCCESS;
461
fd = open( path->bv_val, O_RDONLY );
463
Debug( LDAP_DEBUG_TRACE,
464
"=> ldif_enum_tree: failed to open %s: %s\n",
465
path->bv_val, STRERROR(errno), 0 );
466
return LDAP_NO_SUCH_OBJECT;
469
e = get_entry_for_fd(fd, pdn, pndn);
471
Debug( LDAP_DEBUG_ANY,
472
"=> ldif_enum_tree: failed to read entry for %s\n",
473
path->bv_val, 0, 0 );
477
if ( ck->op->ors_scope == LDAP_SCOPE_BASE ||
478
ck->op->ors_scope == LDAP_SCOPE_SUBTREE ) {
479
/* Send right away? */
482
* if it's a referral, add it to the list of referrals. only do
483
* this for non-base searches, and don't check the filter
484
* explicitly here since it's only a candidate anyway.
486
if ( !get_manageDSAit( ck->op )
487
&& ck->op->ors_scope != LDAP_SCOPE_BASE
488
&& is_entry_referral( e ) )
490
BerVarray erefs = get_entry_referrals( ck->op, e );
491
ck->rs->sr_ref = referral_rewrite( erefs,
493
ck->op->oq_search.rs_scope == LDAP_SCOPE_ONELEVEL
494
? LDAP_SCOPE_BASE : LDAP_SCOPE_SUBTREE );
496
ck->rs->sr_entry = e;
497
rc = send_search_reference( ck->op, ck->rs );
498
ber_bvarray_free( ck->rs->sr_ref );
499
ber_bvarray_free( erefs );
500
ck->rs->sr_ref = NULL;
501
ck->rs->sr_entry = NULL;
503
} else if ( test_filter( ck->op, e, ck->op->ors_filter ) == LDAP_COMPARE_TRUE )
505
ck->rs->sr_entry = e;
506
ck->rs->sr_attrs = ck->op->ors_attrs;
507
ck->rs->sr_flags = REP_ENTRY_MODIFIABLE;
508
rc = send_search_entry(ck->op, ck->rs);
509
ck->rs->sr_entry = NULL;
604
int rc = LDAP_SUCCESS;
606
if ( scope == LDAP_SCOPE_BASE || scope == LDAP_SCOPE_SUBTREE ) {
608
/* Save the entry for tool mode */
609
struct ldif_tool *tl =
610
&((struct ldif_info *) op->o_bd->be_private)->li_tool;
612
if ( tl->ecount >= tl->elen ) {
613
/* Allocate/grow entries */
614
ID elen = tl->elen ? tl->elen * 2 : ENTRY_BUFF_INCREMENT;
615
Entry **entries = (Entry **) SLAP_REALLOC( tl->entries,
616
sizeof(Entry *) * elen );
617
if ( entries == NULL ) {
618
Debug( LDAP_DEBUG_ANY,
619
"ldif_send_entry: out of memory\n", 0, 0, 0 );
515
/* Queueing up for tool mode */
516
if(ck->entries == NULL) {
517
ck->entries = (Entry **) ch_malloc(sizeof(Entry *) * ENTRY_BUFF_INCREMENT);
518
ck->elen = ENTRY_BUFF_INCREMENT;
520
if(ck->eind >= ck->elen) { /* grow entries if necessary */
521
ck->entries = (Entry **) ch_realloc(ck->entries, sizeof(Entry *) * (ck->elen) * 2);
525
ck->entries[ck->eind++] = e;
624
tl->entries = entries;
626
tl->entries[tl->ecount++] = e;
630
else if ( !get_manageDSAit( op ) && is_entry_referral( e ) ) {
631
/* Send a continuation reference.
632
* (ldif_back_referrals() handles baseobject referrals.)
633
* Don't check the filter since it's only a candidate.
635
BerVarray refs = get_entry_referrals( op, e );
636
rs->sr_ref = referral_rewrite( refs, &e->e_name, NULL, scope );
638
rc = send_search_reference( op, rs );
639
ber_bvarray_free( rs->sr_ref );
640
ber_bvarray_free( refs );
645
else if ( test_filter( op, e, op->ors_filter ) == LDAP_COMPARE_TRUE ) {
647
rs->sr_attrs = op->ors_attrs;
648
rs->sr_flags = REP_ENTRY_MODIFIABLE;
649
rc = send_search_entry( op, rs );
533
if ( ck->op->ors_scope != LDAP_SCOPE_BASE ) {
535
bvlist *list = NULL, *ptr;
537
path->bv_len -= STRLENOF( LDIF );
538
path->bv_val[path->bv_len] = '\0';
540
dir_of_path = opendir(path->bv_val);
541
if(dir_of_path == NULL) { /* can't open directory */
542
if ( errno != ENOENT ) {
543
/* it shouldn't be treated as an error
544
* only if the directory doesn't exist */
546
Debug( LDAP_DEBUG_ANY,
547
"=> ldif_enum_tree: failed to opendir %s (%d)\n",
548
path->bv_val, errno, 0 );
659
/* Read LDIF directory <path> into <listp>. Set *fname_maxlenp. */
664
const struct berval *path,
666
ber_len_t *fname_maxlenp )
668
int rc = LDAP_SUCCESS;
674
dir_of_path = opendir( path->bv_val );
675
if ( dir_of_path == NULL ) {
676
int save_errno = errno;
677
struct ldif_info *li = (struct ldif_info *) op->o_bd->be_private;
678
int is_rootDSE = (path->bv_len == li->li_base_path.bv_len);
680
/* Absent directory is OK (leaf entry), except the database dir */
681
if ( is_rootDSE || save_errno != ENOENT ) {
682
Debug( LDAP_DEBUG_ANY,
683
"=> ldif_search_entry: failed to opendir \"%s\": %s\n",
684
path->bv_val, STRERROR( save_errno ), 0 );
688
save_errno != ENOENT ? "internal error (bad directory)"
689
: !is_rootDSE ? "internal error (missing directory)"
690
: "internal error (database directory does not exist)";
554
struct berval fname, itmp;
698
while ( (dir = readdir( dir_of_path )) != NULL ) {
556
700
bvlist *bvl, **prev;
558
dir = readdir(dir_of_path);
559
if(dir == NULL) break; /* end of the directory */
560
fname.bv_len = strlen( dir->d_name );
561
if ( fname.bv_len <= STRLENOF( LDIF ))
563
if ( strcmp( dir->d_name + (fname.bv_len - STRLENOF(LDIF)), LDIF))
565
fname.bv_val = dir->d_name;
567
bvl = ch_malloc( sizeof(bvlist) );
568
ber_dupbv( &bvl->bv, &fname );
569
BER_BVZERO( &bvl->num );
570
itmp.bv_val = ber_bvchr( &bvl->bv, IX_FSL );
574
itmp.bv_len = bvl->bv.bv_len
575
- ( itmp.bv_val - bvl->bv.bv_val );
576
ptr = ber_bvchr( &itmp, IX_FSR );
578
itmp.bv_len = ptr - itmp.bv_val;
579
ber_dupbv( &bvl->num, &itmp );
580
bvl->inum = strtol( itmp.bv_val, NULL, 0 );
581
itmp.bv_val[0] = '\0';
582
bvl->off = itmp.bv_val - bvl->bv.bv_val;
701
char *trunc, *idxp, *endp, *endp2;
703
fname_len = strlen( dir->d_name );
704
if ( fname_len < STRLENOF( "x=" LDIF )) /* min filename size */
706
if ( strcmp( dir->d_name + fname_len - STRLENOF(LDIF), LDIF ))
709
if ( *fname_maxlenp < fname_len )
710
*fname_maxlenp = fname_len;
712
bvl = SLAP_MALLOC( BVL_SIZE( fname_len ) );
718
strcpy( BVL_NAME( bvl ), dir->d_name );
720
/* Make it sortable by ("attr=val" or <preceding {num}, num>) */
721
trunc = BVL_NAME( bvl ) + fname_len - STRLENOF( LDIF );
722
if ( (idxp = strchr( BVL_NAME( bvl ) + 2, IX_FSL )) != NULL &&
723
(endp = strchr( ++idxp, IX_FSR )) != NULL && endp > idxp &&
724
(eq_unsafe || idxp[-2] == '=' || endp + 1 == trunc) )
726
/* attr={n}val or bconfig.c's "pseudo-indexed" attr=val{n} */
727
bvl->inum = strtol( idxp, &endp2, 10 );
728
if ( endp2 == endp ) {
736
bvl->savech = *trunc;
586
for (prev = &list; (ptr = *prev) != NULL; prev = &ptr->next) {
587
int cmp = strcmp( bvl->bv.bv_val, ptr->bv.bv_val );
588
if ( !cmp && bvl->num.bv_val )
589
cmp = bvl->inum - ptr->inum;
739
for ( prev = listp; (ptr = *prev) != NULL; prev = &ptr->next ) {
740
int cmp = strcmp( BVL_NAME( bvl ), BVL_NAME( ptr ));
741
if ( cmp < 0 || (cmp == 0 && bvl->inum < ptr->inum) )
597
closedir(dir_of_path);
599
if (ck->op->ors_scope == LDAP_SCOPE_ONELEVEL)
600
ck->op->ors_scope = LDAP_SCOPE_BASE;
601
else if ( ck->op->ors_scope == LDAP_SCOPE_SUBORDINATE)
602
ck->op->ors_scope = LDAP_SCOPE_SUBTREE;
604
while ( ( ptr = list ) ) {
609
if ( rc == LDAP_SUCCESS ) {
610
if ( ptr->num.bv_val )
611
AC_MEMCPY( ptr->bv.bv_val + ptr->off, ptr->num.bv_val,
613
fullpath( path, &ptr->bv, &fpath );
614
rc = r_enum_tree(ck, &fpath, 0,
615
e != NULL ? &e->e_name : pdn,
616
e != NULL ? &e->e_nname : pndn );
619
if ( ptr->num.bv_val )
620
free( ptr->num.bv_val );
621
free(ptr->bv.bv_val);
626
if ( fd ) entry_free( e );
748
if ( closedir( dir_of_path ) < 0 ) {
752
rs->sr_text = "internal error (bad directory)";
754
if ( rc != LDAP_SUCCESS ) {
755
Debug( LDAP_DEBUG_ANY, "ldif_search_entry: %s \"%s\": %s\n",
756
"error reading directory", path->bv_val,
757
STRERROR( save_errno ) );
765
* Send an entry, recursively search its children, and free or save it.
766
* Return an LDAP result code. Parameters:
767
* op, rs operation and reply. rs == NULL for slap tools.
768
* e entry to search, or NULL for rootDSE.
769
* scope scope for the part of the search from this entry.
770
* path LDIF filename -- bv_len and non-directory part are overwritten.
778
struct berval *path )
780
int rc = LDAP_SUCCESS;
781
struct berval dn = BER_BVC( "" ), ndn = BER_BVC( "" );
783
if ( scope != LDAP_SCOPE_BASE && e != NULL ) {
784
/* Copy DN/NDN since we send the entry with REP_ENTRY_MODIFIABLE,
785
* which bconfig.c seems to need. (TODO: see config_rename_one.)
787
if ( ber_dupbv( &dn, &e->e_name ) == NULL ||
788
ber_dupbv( &ndn, &e->e_nname ) == NULL )
790
Debug( LDAP_DEBUG_ANY,
791
"ldif_search_entry: out of memory\n", 0, 0, 0 );
797
/* Send the entry if appropriate, and free or save it */
799
rc = ldif_send_entry( op, rs, e, scope );
801
/* Search the children */
802
if ( scope != LDAP_SCOPE_BASE && rc == LDAP_SUCCESS ) {
804
struct berval fpath; /* becomes child pathname */
805
char *dir_end; /* will point past dirname in fpath */
807
ldif2dir_len( *path );
808
ldif2dir_name( *path );
809
rc = ldif_readdir( op, rs, path, &list, &fpath.bv_len );
811
if ( list != NULL ) {
812
const char **text = rs == NULL ? NULL : &rs->sr_text;
814
if ( scope == LDAP_SCOPE_ONELEVEL )
815
scope = LDAP_SCOPE_BASE;
816
else if ( scope == LDAP_SCOPE_SUBORDINATE )
817
scope = LDAP_SCOPE_SUBTREE;
819
/* Allocate fpath and fill in directory part */
820
dir_end = fullpath_alloc( &fpath, path, fpath.bv_len );
821
if ( dir_end == NULL )
827
if ( rc == LDAP_SUCCESS ) {
828
*ptr->trunc = ptr->savech;
829
FILL_PATH( &fpath, dir_end, BVL_NAME( ptr ));
831
rc = ldif_read_entry( op, fpath.bv_val, &dn, &ndn,
835
rc = ldif_search_entry( op, rs, e, scope, &fpath );
837
case LDAP_NO_SUCH_OBJECT:
838
/* Only the search baseDN may produce noSuchObject. */
841
rs->sr_text = "internal error "
842
"(did someone just remove an entry file?)";
843
Debug( LDAP_DEBUG_ANY, "ldif_search_entry: "
844
"file listed in parent directory does not exist: "
845
"\"%s\"\n", fpath.bv_val, 0, 0 );
852
} while ( list != NULL );
854
if ( !BER_BVISNULL( &fpath ) )
855
SLAP_FREE( fpath.bv_val );
860
if ( !BER_BVISEMPTY( &dn ) )
861
ber_memfree( dn.bv_val );
862
if ( !BER_BVISEMPTY( &ndn ) )
863
ber_memfree( ndn.bv_val );
868
search_tree( Operation *op, SlapReply *rs )
870
int rc = LDAP_SUCCESS;
635
872
struct berval path;
636
873
struct berval pdn, pndn;
639
dnParent( &ck->op->o_req_dn, &pdn );
640
dnParent( &ck->op->o_req_ndn, &pndn );
641
dn2path( ck->op->o_bd, &ck->op->o_req_ndn, &path );
642
rc = r_enum_tree(ck, &path, BER_BVISEMPTY( &ck->op->o_req_ndn ) ? 1 : 0, &pdn, &pndn);
875
dn2path( op->o_bd, &op->o_req_ndn, &path );
876
if ( !BER_BVISEMPTY( &op->o_req_ndn ) ) {
877
/* Read baseObject */
878
dnParent( &op->o_req_dn, &pdn );
879
dnParent( &op->o_req_ndn, &pndn );
880
rc = ldif_read_entry( op, path.bv_val, &pdn, &pndn, &e,
881
rs == NULL ? NULL : &rs->sr_text );
883
if ( rc == LDAP_SUCCESS )
884
rc = ldif_search_entry( op, rs, e, op->ors_scope, &path );
643
886
ch_free( path.bv_val );
648
/* Get the parent directory path, plus the LDIF suffix overwritten by a \0 */
650
get_parent_path( struct berval *dnpath, struct berval *res )
892
* Prepare to create or rename an entry:
893
* Check that the entry does not already exist.
894
* Check that the parent entry exists and can have subordinates,
895
* unless need_dir is NULL or adding the suffix entry.
897
* Return an LDAP result code. May set *text to a message on failure.
898
* If success, set *dnpath to LDIF entry path and *need_dir to
899
* (directory must be created ? dirname : NULL).
905
struct berval *dnpath,
652
int dnpathlen = dnpath->bv_len;
655
for(i = dnpathlen;i>0;i--) /* find the first path seperator */
656
if(dnpath->bv_val[i] == LDAP_DIRSEP[0])
659
res->bv_val = ch_malloc( res->bv_len + 1 + STRLENOF(LDIF) );
660
strncpy(res->bv_val, dnpath->bv_val, i);
661
strcpy(res->bv_val+i, LDIF);
662
res->bv_val[i] = '\0';
909
BackendDB *be = op->o_bd;
910
struct ldif_info *li = (struct ldif_info *) be->be_private;
911
struct berval *ndn = &e->e_nname;
912
struct berval ppath = BER_BVNULL;
914
Entry *parent = NULL;
915
int rc = LDAP_SUCCESS;
918
return SLAPD_ABANDON;
920
dn2path( be, ndn, dnpath );
922
if ( stat( dnpath->bv_val, &st ) == 0 ) { /* entry .ldif file */
923
rc = LDAP_ALREADY_EXISTS;
925
} else if ( errno != ENOENT ) {
926
Debug( LDAP_DEBUG_ANY,
927
"ldif_prepare_create: cannot stat \"%s\": %s\n",
928
dnpath->bv_val, STRERROR( errno ), 0 );
930
*text = "internal error (cannot check entry file)";
932
} else if ( need_dir != NULL ) {
934
rc = get_parent_path( dnpath, &ppath );
935
/* If parent dir exists, so does parent .ldif:
936
* The directory gets created after and removed before the .ldif.
937
* Except with the database directory, which has no matching entry.
939
if ( rc == LDAP_SUCCESS && stat( ppath.bv_val, &st ) < 0 ) {
940
rc = errno == ENOENT && ppath.bv_len > li->li_base_path.bv_len
941
? LDAP_NO_SUCH_OBJECT : LDAP_OTHER;
944
case LDAP_NO_SUCH_OBJECT:
945
/* No parent dir, check parent .ldif */
946
dir2ldif_name( ppath );
947
rc = ldif_read_entry( op, ppath.bv_val, NULL, NULL,
948
(op->o_tag != LDAP_REQ_ADD || get_manageDSAit( op )
953
/* Check that parent is not a referral, unless
954
* ldif_back_referrals() already checked.
956
if ( parent != NULL ) {
957
int is_ref = is_entry_referral( parent );
958
entry_free( parent );
960
rc = LDAP_AFFECTS_MULTIPLE_DSAS;
961
*text = op->o_tag == LDAP_REQ_MODDN
962
? "newSuperior is a referral object"
963
: "parent is a referral object";
967
/* Must create parent directory. */
968
ldif2dir_name( ppath );
969
*need_dir = ppath.bv_val;
971
case LDAP_NO_SUCH_OBJECT:
972
*text = op->o_tag == LDAP_REQ_MODDN
973
? "newSuperior object does not exist"
974
: "parent does not exist";
979
Debug( LDAP_DEBUG_ANY,
980
"ldif_prepare_create: cannot stat \"%s\" parent dir: %s\n",
981
ndn->bv_val, STRERROR( errno ), 0 );
982
*text = "internal error (cannot stat parent dir)";
985
if ( *need_dir == NULL && ppath.bv_val != NULL )
986
SLAP_FREE( ppath.bv_val );
989
if ( rc != LDAP_SUCCESS ) {
990
SLAP_FREE( dnpath->bv_val );
991
BER_BVZERO( dnpath );
665
static int apply_modify_to_entry(Entry * entry,
666
Modifications * modlist,
997
apply_modify_to_entry(
999
Modifications *modlist,
670
1003
char textbuf[SLAP_TEXT_BUFLEN];
671
1004
int rc = modlist ? LDAP_UNWILLING_TO_PERFORM : LDAP_SUCCESS;
726
1059
if(rc != LDAP_SUCCESS) break;
729
if(rc == LDAP_SUCCESS) {
1062
if ( rc == LDAP_SUCCESS ) {
1063
rs->sr_text = NULL; /* Needed at least with SLAP_MOD_SOFTADD */
731
1065
entry->e_ocflags = 0;
733
1067
/* check that the entry still obeys the schema */
734
rc = entry_schema_check( op, entry, NULL, 0, 0,
1068
rc = entry_schema_check( op, entry, NULL, 0, 0, NULL,
735
1069
&rs->sr_text, textbuf, sizeof( textbuf ) );
742
1077
ldif_back_referrals( Operation *op, SlapReply *rs )
744
struct ldif_info *li = NULL;
746
int rc = LDAP_SUCCESS;
749
if ( op->o_tag == LDAP_REQ_SEARCH ) {
750
/* let search take care of itself */
755
if ( get_manageDSAit( op ) ) {
756
/* let op take care of DSA management */
760
if ( BER_BVISEMPTY( &op->o_req_ndn ) ) {
761
/* the empty DN cannot be a referral */
765
li = (struct ldif_info *)op->o_bd->be_private;
1079
struct ldif_info *li = (struct ldif_info *) op->o_bd->be_private;
1080
struct berval path, dn = op->o_req_dn, ndn = op->o_req_ndn;
1081
ber_len_t min_dnlen;
1082
Entry *entry = NULL, **entryp;
1086
min_dnlen = op->o_bd->be_nsuffix[0].bv_len;
1087
if ( min_dnlen == 0 ) {
1088
/* Catch root DSE (empty DN), it is not a referral */
1090
if ( BER_BVISEMPTY( &ndn ) )
1091
return LDAP_SUCCESS;
1094
entryp = get_manageDSAit( op ) ? NULL : &entry;
1095
dn2path( op->o_bd, &ndn, &path );
766
1096
ldap_pvt_thread_rdwr_rlock( &li->li_rdwr );
767
get_entry( op, &entry, NULL );
769
/* no object is found for them */
770
if ( entry == NULL ) {
771
struct berval odn = op->o_req_dn;
772
struct berval ondn = op->o_req_ndn;
773
struct berval pndn = ondn;
774
ber_len_t min_dnlen = op->o_bd->be_nsuffix[0].bv_len;
776
if ( min_dnlen == 0 )
777
min_dnlen = 1; /* catch empty DN */
779
for ( ; entry == NULL; ) {
780
dnParent( &pndn, &pndn );
781
if ( pndn.bv_len < min_dnlen ) {
786
op->o_req_ndn = pndn;
788
get_entry( op, &entry, NULL );
791
ldap_pvt_thread_rdwr_runlock( &li->li_rdwr );
794
op->o_req_ndn = ondn;
1099
dnParent( &dn, &dn );
1100
dnParent( &ndn, &ndn );
1101
rc = ldif_read_entry( op, path.bv_val, &dn, &ndn,
1102
entryp, &rs->sr_text );
1103
if ( rc != LDAP_NO_SUCH_OBJECT )
796
1106
rc = LDAP_SUCCESS;
797
rs->sr_matched = NULL;
798
if ( entry != NULL ) {
1107
if ( ndn.bv_len < min_dnlen )
1109
(void) get_parent_path( &path, NULL );
1110
dir2ldif_name( path );
1114
ldap_pvt_thread_rdwr_runlock( &li->li_rdwr );
1115
SLAP_FREE( path.bv_val );
1117
if ( entry != NULL ) {
1118
if ( is_entry_referral( entry ) ) {
799
1119
Debug( LDAP_DEBUG_TRACE,
800
1120
"ldif_back_referrals: tag=%lu target=\"%s\" matched=\"%s\"\n",
801
(unsigned long) op->o_tag, op->o_req_dn.bv_val, entry->e_name.bv_val );
803
if ( is_entry_referral( entry ) ) {
1121
(unsigned long) op->o_tag, op->o_req_dn.bv_val, entry->e_dn );
1123
ref = get_entry_referrals( op, entry );
1124
rs->sr_ref = referral_rewrite( ref, &entry->e_name, &op->o_req_dn,
1125
op->o_tag == LDAP_REQ_SEARCH ?
1126
op->ors_scope : LDAP_SCOPE_DEFAULT );
1127
ber_bvarray_free( ref );
1129
if ( rs->sr_ref != NULL ) {
1131
rc = rs->sr_err = LDAP_REFERRAL;
1132
rs->sr_matched = entry->e_dn;
1133
send_ldap_result( op, rs );
1134
ber_bvarray_free( rs->sr_ref );
804
1137
rc = LDAP_OTHER;
805
rs->sr_ref = get_entry_referrals( op, entry );
807
rs->sr_matched = ber_strdup_x(
808
entry->e_name.bv_val, op->o_tmpmemctx );
1138
rs->sr_text = "bad referral object";
814
} else if ( default_referral != NULL ) {
816
rs->sr_ref = referral_rewrite( default_referral,
817
NULL, &op->o_req_dn, LDAP_SCOPE_DEFAULT );
820
if ( rs->sr_ref != NULL ) {
822
rc = rs->sr_err = LDAP_REFERRAL;
823
send_ldap_result( op, rs );
824
ber_bvarray_free( rs->sr_ref );
827
} else if ( rc != LDAP_SUCCESS ) {
828
rs->sr_text = rs->sr_matched ? "bad referral object" : NULL;
831
if ( rs->sr_matched ) {
832
op->o_tmpfree( (char *)rs->sr_matched, op->o_tmpmemctx );
833
1140
rs->sr_matched = NULL;
839
ldap_pvt_thread_rdwr_runlock( &li->li_rdwr );
841
if ( is_entry_referral( entry ) ) {
842
/* entry is a referral */
843
BerVarray refs = get_entry_referrals( op, entry );
844
rs->sr_ref = referral_rewrite(
845
refs, &entry->e_name, &op->o_req_dn, LDAP_SCOPE_DEFAULT );
847
Debug( LDAP_DEBUG_TRACE,
848
"ldif_back_referrals: tag=%lu target=\"%s\" matched=\"%s\"\n",
849
(unsigned long) op->o_tag, op->o_req_dn.bv_val, entry->e_name.bv_val );
851
rs->sr_matched = entry->e_name.bv_val;
852
if ( rs->sr_ref != NULL ) {
853
rc = rs->sr_err = LDAP_REFERRAL;
854
send_ldap_result( op, rs );
855
ber_bvarray_free( rs->sr_ref );
860
rs->sr_text = "bad referral object";
863
rs->sr_matched = NULL;
864
ber_bvarray_free( refs );
1143
entry_free( entry );
919
1196
/* let the front-end send success */
1197
return_val = LDAP_SUCCESS;
924
1200
ldap_pvt_thread_rdwr_runlock(&li->li_rdwr);
1201
if(return_val != LDAP_SUCCESS)
926
1202
send_ldap_result( op, rs );
927
1203
if(entry != NULL)
928
1204
entry_free(entry);
929
1205
return return_val;
932
static int ldif_back_search(Operation *op, SlapReply *rs)
1209
ldif_back_search( Operation *op, SlapReply *rs )
934
1211
struct ldif_info *li = (struct ldif_info *) op->o_bd->be_private;
935
enumCookie ck = { NULL, NULL, NULL, 0, 0 };
939
1213
ldap_pvt_thread_rdwr_rlock(&li->li_rdwr);
940
rs->sr_err = enum_tree( &ck );
1214
rs->sr_err = search_tree( op, rs );
941
1215
ldap_pvt_thread_rdwr_runlock(&li->li_rdwr);
942
1216
send_ldap_result(op, rs);
944
1218
return rs->sr_err;
947
static int ldif_back_add(Operation *op, SlapReply *rs) {
1222
ldif_back_add( Operation *op, SlapReply *rs )
948
1224
struct ldif_info *li = (struct ldif_info *) op->o_bd->be_private;
949
1225
Entry * e = op->ora_e;
950
struct berval dn = e->e_nname;
951
struct berval leaf_path = BER_BVNULL;
954
1228
char textbuf[SLAP_TEXT_BUFLEN];
956
Debug( LDAP_DEBUG_TRACE, "ldif_back_add: \"%s\"\n", dn.bv_val, 0, 0);
958
rs->sr_err = entry_schema_check(op, e, NULL, 0, 1,
1231
Debug( LDAP_DEBUG_TRACE, "ldif_back_add: \"%s\"\n", e->e_dn, 0, 0 );
1233
rc = entry_schema_check( op, e, NULL, 0, 1, NULL,
959
1234
&rs->sr_text, textbuf, sizeof( textbuf ) );
960
if ( rs->sr_err != LDAP_SUCCESS ) goto send_res;
962
rs->sr_err = slap_add_opattrs( op,
963
&rs->sr_text, textbuf, sizeof( textbuf ), 1 );
964
if ( rs->sr_err != LDAP_SUCCESS ) goto send_res;
966
ldap_pvt_thread_rdwr_wlock(&li->li_rdwr);
968
dn2path( op->o_bd, &dn, &leaf_path );
970
if(leaf_path.bv_val != NULL) {
971
struct berval base = BER_BVNULL;
972
/* build path to container and ldif of container */
973
get_parent_path(&leaf_path, &base);
975
statres = stat(base.bv_val, &stats); /* check if container exists */
976
if(statres == -1 && errno == ENOENT) { /* container missing */
977
base.bv_val[base.bv_len] = LDIF_FILETYPE_SEP;
978
statres = stat(base.bv_val, &stats); /* check for leaf node */
979
base.bv_val[base.bv_len] = '\0';
980
if(statres == -1 && errno == ENOENT) {
981
rs->sr_err = LDAP_NO_SUCH_OBJECT; /* parent doesn't exist */
982
rs->sr_text = "Parent does not exist";
984
else if(statres != -1) { /* create parent */
985
int mkdirres = mkdir(base.bv_val, 0750);
987
rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
988
rs->sr_text = "Could not create parent folder";
989
Debug( LDAP_DEBUG_ANY, "could not create folder \"%s\": %s\n",
990
base.bv_val, STRERROR( errno ), 0 );
994
rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
995
}/* container was possibly created, move on to add the entry */
996
if(rs->sr_err == LDAP_SUCCESS) {
997
statres = stat(leaf_path.bv_val, &stats);
998
if(statres == -1 && errno == ENOENT) {
999
rs->sr_err = spew_entry(e, &leaf_path, 1, NULL);
1001
else if ( statres == -1 ) {
1002
rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
1003
Debug( LDAP_DEBUG_ANY, "could not stat file \"%s\": %s\n",
1004
leaf_path.bv_val, STRERROR( errno ), 0 );
1006
else /* it already exists */
1007
rs->sr_err = LDAP_ALREADY_EXISTS;
1009
SLAP_FREE(base.bv_val);
1010
SLAP_FREE(leaf_path.bv_val);
1235
if ( rc != LDAP_SUCCESS )
1238
rc = slap_add_opattrs( op, &rs->sr_text, textbuf, sizeof( textbuf ), 1 );
1239
if ( rc != LDAP_SUCCESS )
1242
ldap_pvt_thread_mutex_lock( &li->li_modop_mutex );
1244
rc = ldif_prepare_create( op, e, &path, &parentdir, &rs->sr_text );
1245
if ( rc == LDAP_SUCCESS ) {
1246
ldap_pvt_thread_rdwr_wlock( &li->li_rdwr );
1247
rc = ldif_write_entry( op, e, &path, parentdir, &rs->sr_text );
1248
ldap_pvt_thread_rdwr_wunlock( &li->li_rdwr );
1250
SLAP_FREE( path.bv_val );
1251
if ( parentdir != NULL )
1252
SLAP_FREE( parentdir );
1013
ldap_pvt_thread_rdwr_wunlock(&li->li_rdwr);
1255
ldap_pvt_thread_mutex_unlock( &li->li_modop_mutex );
1016
Debug( LDAP_DEBUG_TRACE,
1017
"ldif_back_add: err: %d text: %s\n", rs->sr_err, rs->sr_text ?
1018
rs->sr_text : "", 0);
1019
send_ldap_result(op, rs);
1259
Debug( LDAP_DEBUG_TRACE, "ldif_back_add: err: %d text: %s\n",
1260
rc, rs->sr_text ? rs->sr_text : "", 0 );
1261
send_ldap_result( op, rs );
1020
1262
slap_graduate_commit_csn( op );
1021
1263
return rs->sr_err;
1024
static int ldif_back_modify(Operation *op, SlapReply *rs) {
1267
ldif_back_modify( Operation *op, SlapReply *rs )
1025
1269
struct ldif_info *li = (struct ldif_info *) op->o_bd->be_private;
1026
1270
Modifications * modlst = op->orm_modlist;
1027
1271
struct berval path;
1031
1275
slap_mods_opattrs( op, &op->orm_modlist, 1 );
1033
ldap_pvt_thread_rdwr_wlock(&li->li_rdwr);
1277
ldap_pvt_thread_mutex_lock( &li->li_modop_mutex );
1035
rs->sr_err = get_entry( op, &entry, &path );
1037
rs->sr_err = apply_modify_to_entry(entry, modlst, op, rs);
1038
if(rs->sr_err == LDAP_SUCCESS) {
1040
spew_res = spew_entry(entry, &path, 1, &save_errno);
1041
if(spew_res == -1) {
1042
Debug( LDAP_DEBUG_ANY,
1043
"%s ldif_back_modify: could not output entry \"%s\": %s\n",
1044
op->o_log_prefix, entry->e_name.bv_val, STRERROR( save_errno ) );
1045
rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
1279
rc = get_entry( op, &entry, &path, &rs->sr_text );
1280
if ( rc == LDAP_SUCCESS ) {
1281
rc = apply_modify_to_entry( entry, modlst, op, rs );
1282
if ( rc == LDAP_SUCCESS ) {
1283
ldap_pvt_thread_rdwr_wlock( &li->li_rdwr );
1284
rc = ldif_write_entry( op, entry, &path, NULL, &rs->sr_text );
1285
ldap_pvt_thread_rdwr_wunlock( &li->li_rdwr );
1049
1288
entry_free( entry );
1050
1289
SLAP_FREE( path.bv_val );
1054
ldap_pvt_thread_rdwr_wunlock(&li->li_rdwr);
1055
send_ldap_result(op, rs);
1292
ldap_pvt_thread_mutex_unlock( &li->li_modop_mutex );
1295
send_ldap_result( op, rs );
1056
1296
slap_graduate_commit_csn( op );
1057
1297
return rs->sr_err;
1060
static int ldif_back_delete(Operation *op, SlapReply *rs) {
1301
ldif_back_delete( Operation *op, SlapReply *rs )
1061
1303
struct ldif_info *li = (struct ldif_info *) op->o_bd->be_private;
1062
1304
struct berval path;
1305
int rc = LDAP_SUCCESS;
1065
1307
if ( BER_BVISEMPTY( &op->o_csn )) {
1066
1308
struct berval csn;
1122
1369
ldif_move_entry(
1125
struct berval *oldpath )
1373
struct berval *oldpath,
1376
struct ldif_info *li = (struct ldif_info *) op->o_bd->be_private;
1129
1377
struct berval newpath;
1131
dn2path( op->o_bd, &entry->e_nname, &newpath );
1133
if((entry == NULL || oldpath->bv_val == NULL) || newpath.bv_val == NULL) {
1134
/* some object doesn't exist */
1135
res = LDAP_NO_SUCH_OBJECT;
1137
else { /* do the modrdn */
1138
exists_res = open(newpath.bv_val, O_RDONLY);
1139
if(exists_res == -1 && errno == ENOENT) {
1140
ldap_pvt_thread_mutex_lock( &entry2str_mutex );
1141
res = spew_entry(entry, &newpath, 0, NULL);
1143
/* if this fails we should log something bad */
1144
res = unlink( oldpath->bv_val );
1145
oldpath->bv_val[oldpath->bv_len - STRLENOF(".ldif")] = '\0';
1146
newpath.bv_val[newpath.bv_len - STRLENOF(".ldif")] = '\0';
1147
res = rename( oldpath->bv_val, newpath.bv_val );
1152
res = LDAP_NO_SUCH_OBJECT;
1154
res = LDAP_UNWILLING_TO_PERFORM;
1155
unlink(newpath.bv_val); /* in case file was created */
1157
ldap_pvt_thread_mutex_unlock( &entry2str_mutex );
1159
else if(exists_res) {
1160
int close_res = close(exists_res);
1161
res = LDAP_ALREADY_EXISTS;
1162
if(close_res == -1) {
1163
/* log heinous error */
1167
res = LDAP_UNWILLING_TO_PERFORM;
1171
if(newpath.bv_val != NULL)
1172
SLAP_FREE(newpath.bv_val);
1378
char *parentdir = NULL, *trash;
1385
rc = ldif_prepare_create( op, entry, &newpath,
1386
op->orr_newSup ? &parentdir : NULL, text );
1389
if ( rc == LDAP_SUCCESS ) {
1390
ldap_pvt_thread_rdwr_wlock( &li->li_rdwr );
1392
rc = ldif_write_entry( op, entry, &newpath, parentdir, text );
1393
if ( rc == LDAP_SUCCESS && !same_ndn ) {
1394
trash = oldpath->bv_val; /* will be .ldif file to delete */
1395
ldif2dir_len( newpath );
1396
ldif2dir_len( *oldpath );
1397
/* Move subdir before deleting old entry,
1398
* so .ldif always exists if subdir does.
1400
ldif2dir_name( newpath );
1401
ldif2dir_name( *oldpath );
1402
rename_res = move_dir( oldpath->bv_val, newpath.bv_val );
1403
if ( rename_res != 0 && errno != ENOENT ) {
1405
*text = "internal error (cannot move this subtree)";
1406
trash = newpath.bv_val;
1409
/* Delete old entry, or if error undo change */
1411
dir2ldif_name( newpath );
1412
dir2ldif_name( *oldpath );
1413
if ( unlink( trash ) == 0 )
1415
if ( rc == LDAP_SUCCESS ) {
1416
/* Prepare to undo change and return failure */
1418
*text = "internal error (cannot move this entry)";
1419
trash = newpath.bv_val;
1420
if ( rename_res != 0 )
1422
/* First move subdirectory back */
1423
ldif2dir_name( newpath );
1424
ldif2dir_name( *oldpath );
1425
if ( move_dir( newpath.bv_val, oldpath->bv_val ) == 0 )
1428
*text = "added new but couldn't delete old entry!";
1432
if ( rc != LDAP_SUCCESS ) {
1434
snprintf( s, sizeof s, "%s (%s)", *text, STRERROR( errno ));
1435
Debug( LDAP_DEBUG_ANY,
1436
"ldif_move_entry: %s: \"%s\" -> \"%s\"\n",
1437
s, op->o_req_dn.bv_val, entry->e_dn );
1441
ldap_pvt_thread_rdwr_wunlock( &li->li_rdwr );
1443
SLAP_FREE( newpath.bv_val );
1444
if ( parentdir != NULL )
1445
SLAP_FREE( parentdir );
1177
ldif_back_modrdn(Operation *op, SlapReply *rs)
1452
ldif_back_modrdn( Operation *op, SlapReply *rs )
1179
1454
struct ldif_info *li = (struct ldif_info *) op->o_bd->be_private;
1180
1455
struct berval new_dn = BER_BVNULL, new_ndn = BER_BVNULL;
1181
1456
struct berval p_dn, old_path;
1185
1460
slap_mods_opattrs( op, &op->orr_modlist, 1 );
1187
ldap_pvt_thread_rdwr_wlock( &li->li_rdwr );
1462
ldap_pvt_thread_mutex_lock( &li->li_modop_mutex );
1189
rc = get_entry( op, &entry, &old_path );
1464
rc = get_entry( op, &entry, &old_path, &rs->sr_text );
1190
1465
if ( rc == LDAP_SUCCESS ) {
1191
1466
/* build new dn, and new ndn for the entry */
1192
1467
if ( op->oq_modrdn.rs_newSup != NULL ) {
1193
struct berval op_dn = op->o_req_dn,
1194
op_ndn = op->o_req_ndn;
1198
1468
p_dn = *op->oq_modrdn.rs_newSup;
1199
op->o_req_dn = *op->oq_modrdn.rs_newSup;
1200
op->o_req_ndn = *op->oq_modrdn.rs_nnewSup;
1201
rc = get_entry( op, &np, NULL );
1202
op->o_req_dn = op_dn;
1203
op->o_req_ndn = op_ndn;
1204
if ( rc != LDAP_SUCCESS ) {
1205
goto no_such_object;
1209
1470
dnParent( &entry->e_name, &p_dn );
1211
build_new_dn( &new_dn, &p_dn, &op->oq_modrdn.rs_newrdn, NULL );
1472
build_new_dn( &new_dn, &p_dn, &op->oq_modrdn.rs_newrdn, NULL );
1212
1473
dnNormalize( 0, NULL, NULL, &new_dn, &new_ndn, NULL );
1474
same_ndn = !ber_bvcmp( &entry->e_nname, &new_ndn );
1213
1475
ber_memfree_x( entry->e_name.bv_val, NULL );
1214
1476
ber_memfree_x( entry->e_nname.bv_val, NULL );
1215
1477
entry->e_name = new_dn;
added
removed
servers/slapd/back-ldif/ldif.c
