-
Notifications
You must be signed in to change notification settings - Fork 81
/
urp.c
2239 lines (2034 loc) · 88.6 KB
/
urp.c
1
2
3
4
5
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
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
327
328
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
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
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
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
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
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
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
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
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
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
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
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
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/** BEGIN COPYRIGHT BLOCK
* Copyright (C) 2001 Sun Microsystems, Inc. Used by permission.
* Copyright (C) 2005 Red Hat, Inc.
* All rights reserved.
*
* License: GPL (version 3 or any later version).
* See LICENSE for details.
* END COPYRIGHT BLOCK **/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
/*
* urp.c - Update Resolution Procedures
*/
#include "slapi-plugin.h"
#include "repl5.h"
#include "urp.h"
extern int slapi_log_urp;
static int urp_add_resolve_parententry(Slapi_PBlock *pb, char *sessionid, Slapi_Entry *entry, Slapi_Entry *parententry, CSN *opcsn);
static int urp_add_check_tombstone(Slapi_PBlock *pb, char *sessionid, Slapi_Entry *entry, CSN *opcsn);
static int urp_delete_check_conflict(char *sessionid, Slapi_Entry *tombstone_entry, CSN *opcsn);
static int urp_add_new_entry_to_conflict(Slapi_PBlock *pb, char *sessionid, Slapi_Entry *addentry, CSN *opcsn);
static int urp_annotate_dn(char *sessionid, const Slapi_Entry *entry, CSN *opcsn, const char *optype, char **conflict_dn);
static int urp_conflict_to_glue(char *sessionid, const Slapi_Entry *entry, Slapi_DN *parentdn, CSN *opcsn);
static char *urp_find_tombstone_for_glue(Slapi_PBlock *pb, char *sessionid, const Slapi_Entry *entry, Slapi_DN *parentdn, CSN *opcsn);
static char *urp_find_valid_entry_to_delete(Slapi_PBlock *pb, const Slapi_Entry *deleteentry, char *sessionid, CSN *opcsn);
static int urp_naming_conflict_removal(Slapi_PBlock *pb, char *sessionid, CSN *opcsn, const char *optype);
static int mod_namingconflict_attr(const char *uniqueid, const Slapi_DN *entrysdn, const Slapi_DN *conflictsdn, CSN *opcsn, const char *optype);
static int mod_objectclass_attr(const char *uniqueid, const Slapi_DN *entrysdn, const Slapi_DN *conflictsdn, CSN *opcsn, const char *optype);
static int del_replconflict_attr(const Slapi_Entry *entry, CSN *opcsn, int opflags);
static char *get_dn_plus_uniqueid(char *sessionid,const Slapi_DN *oldsdn,const char *uniqueid);
static int is_suffix_entry(Slapi_PBlock *pb, Slapi_Entry *entry, Slapi_DN **parenddn);
static int is_renamed_entry(Slapi_PBlock *pb, Slapi_Entry *entry, CSN *opcsn);
static int urp_fixup_add_cenotaph(Slapi_PBlock *pb, char *sessionid, CSN *opcsn);
static int is_deleted_at_csn(const Slapi_Entry *entry, CSN *opcsn);
static char * urp_get_valid_parent_nsuniqueid(Slapi_DN *parentdn);
static int urp_rename_conflict_children(const char *old_parent, const Slapi_DN *new_parent);
static Slapi_Entry *urp_get_min_naming_conflict_entry(Slapi_PBlock *pb, const char *collision_dn, char *sessionid, CSN *opcsn);
/*
* Return 0 for OK, -1 for Error.
*/
int
urp_modify_operation(Slapi_PBlock *pb)
{
Slapi_Entry *modifyentry = NULL;
int op_result = 0;
int rc = 0; /* OK */
char sessionid[REPL_SESSION_ID_SIZE];
CSN *opcsn;
if (slapi_op_abandoned(pb)) {
return rc;
}
get_repl_session_id(pb, sessionid, &opcsn);
slapi_pblock_get(pb, SLAPI_MODIFY_EXISTING_ENTRY, &modifyentry);
if (modifyentry != NULL) {
/*
* The entry to be modified exists.
* - the entry could be a tombstone... but that's OK.
* - the entry could be glue... that may not be OK. JCMREPL
*/
rc = 0; /* OK, Modify the entry */
PROFILE_POINT; /* Modify Conflict; Entry Exists; Apply Modification */
} else {
/*
* The entry to be modified could not be found.
*/
op_result = LDAP_NO_SUCH_OBJECT;
slapi_pblock_set(pb, SLAPI_RESULT_CODE, &op_result);
rc = SLAPI_PLUGIN_NOOP; /* Must discard this Modification */
slapi_log_err(slapi_log_urp, sessionid,
"urp_modify_operation - No such entry\n");
PROFILE_POINT; /* Modify Conflict; Entry Does Not Exist; Discard Modification */
}
return rc;
}
/*
* Return 0 for OK,
* -1 for Ignore or Error depending on SLAPI_RESULT_CODE,
* >0 for action code
* Action Code Bit 0: Fetch existing entry.
* Action Code Bit 1: Fetch parent entry.
* The function is called as a be pre-op on consumers.
*/
int
urp_add_operation(Slapi_PBlock *pb)
{
Slapi_Entry *existing_uniqueid_entry;
Slapi_Entry *existing_dn_entry;
Slapi_Entry *addentry;
CSN *opcsn;
const char *basedn;
char sessionid[REPL_SESSION_ID_SIZE];
int r;
int op_result = 0;
int rc = 0; /* OK */
if (slapi_op_abandoned(pb)) {
return rc;
}
get_repl_session_id(pb, sessionid, &opcsn);
slapi_pblock_get(pb, SLAPI_ADD_EXISTING_UNIQUEID_ENTRY, &existing_uniqueid_entry);
if (existing_uniqueid_entry != NULL) {
/*
* An entry with this uniqueid already exists.
* - It could be a replay of the same Add, or
* - It could be a UUID generation collision, or
*/
/*
* This operation won't be replayed. That is, this CSN won't update
* the max csn in RUV. The CSN is left uncommitted in RUV unless an
* error is set to op_result. Just to get rid of this CSN from RUV,
* setting an error to op_result
*/
/* op_result = LDAP_SUCCESS; */
slapi_log_err(slapi_log_urp, sessionid,
"urp_add_operation - %s - An entry with this uniqueid already exists.\n",
slapi_entry_get_dn_const(existing_uniqueid_entry));
op_result = LDAP_ALREADY_EXISTS;
slapi_pblock_set(pb, SLAPI_RESULT_CODE, &op_result);
rc = SLAPI_PLUGIN_NOOP; /* Ignore this Operation */
PROFILE_POINT; /* Add Conflict; UniqueID Exists; Ignore */
goto bailout;
}
slapi_pblock_get(pb, SLAPI_ADD_ENTRY, &addentry);
slapi_pblock_get(pb, SLAPI_ADD_EXISTING_DN_ENTRY, &existing_dn_entry);
slapi_log_err(SLAPI_LOG_REPL, sessionid,
"urp_add_operation - handling add of (%s).\n",
slapi_entry_get_dn_const(addentry));
/* first check if there was an existing entry at the time of this add
* in that case the new entry will become a conflict entry independent
* of the case if the other entry still exists
*/
rc = urp_add_check_tombstone(pb, sessionid, addentry, opcsn);
if (rc == 1) {
/* the new entry is conflicting with an already deleted entry
* transform to conflict entry
*/
rc = urp_add_new_entry_to_conflict(pb, sessionid, addentry, opcsn);
slapi_log_err(SLAPI_LOG_REPL, sessionid,
"urp_add_operation - new entry to conflictentry (%s).\n",
slapi_entry_get_dn_const(addentry));
goto bailout;
} else if (rc == 2) {
/* the tombstone is newer than the added entry
* inform the caller that this needs to become a tombstone operation
* and turn the tombstone to a conflict
*/
rc = SLAPI_PLUGIN_NOOP_TOMBSTONE;
slapi_log_err(SLAPI_LOG_REPL, sessionid,
"urp_add_operation - new entry to tombstone (%s).\n",
slapi_entry_get_dn_const(addentry));
goto bailout;
}
if (existing_dn_entry == NULL) /* The target DN does not exist */
{
/* Check for parent entry... this could be an orphan. */
Slapi_Entry *parententry;
slapi_pblock_get(pb, SLAPI_ADD_PARENT_ENTRY, &parententry);
rc = urp_add_resolve_parententry(pb, sessionid, addentry, parententry, opcsn);
PROFILE_POINT; /* Add Entry */
goto bailout;
}
/*
* Naming conflict: an entry with the target DN already exists.
* Compare the DistinguishedNameCSN of the existing entry
* and the OperationCSN. The smaller CSN wins. The loser changes
* its RDN to uniqueid+baserdn, and adds operational attribute
* ATTR_NSDS5_REPLCONFLIC.
*/
basedn = slapi_entry_get_ndn (addentry);
r = csn_compare (entry_get_dncsn(existing_dn_entry), opcsn);
if (r < 0) {
/* Entry to be added is a loser */
rc = urp_add_new_entry_to_conflict(pb, sessionid, addentry, opcsn);
} else if (r > 0) {
char *conflict_dn = NULL;
/* Existing entry is a loser */
if (!urp_annotate_dn(sessionid, existing_dn_entry, opcsn, "ADD", &conflict_dn)) {
op_result= LDAP_OPERATIONS_ERROR;
slapi_pblock_set(pb, SLAPI_RESULT_CODE, &op_result);
slapi_log_err(slapi_log_urp, sessionid,
"urp_add_operation - %s - Entry to be added is a loser; "
"urp_annotate_dn failed.\n", basedn);
rc = SLAPI_PLUGIN_NOOP; /* Ignore this Operation */
} else {
/* The backend add code should now search for the existing entry again. */
rc= slapi_setbit_int(rc,SLAPI_RTN_BIT_FETCH_EXISTING_DN_ENTRY);
rc= slapi_setbit_int(rc,SLAPI_RTN_BIT_FETCH_PARENT_ENTRY);
slapi_pblock_set(pb, SLAPI_URP_NAMING_COLLISION_DN, conflict_dn);
}
PROFILE_POINT; /* Add Conflict; Entry Exists; Rename Existing Entry */
} else /* r==0 */
{
/* The CSN of the Operation and the Entry DN are the same.
* This could only happen if:
* a) There are two replicas with the same ReplicaID.
* b) We've seen the Operation before.
* Let's go with (b) and ignore the little bastard.
*/
/*
* This operation won't be replayed. That is, this CSN won't update
* the max csn in RUV. The CSN is left uncommitted in RUV unless an
* error is set to op_result. Just to get rid of this CSN from RUV,
* setting an error to op_result
*/
/* op_result = LDAP_SUCCESS; */
slapi_log_err(slapi_log_urp, sessionid,
"urp_add_operation - %s - The CSN of the Operation and the Entry DN are the same.",
slapi_entry_get_dn_const(existing_dn_entry));
op_result = LDAP_UNWILLING_TO_PERFORM;
slapi_pblock_set(pb, SLAPI_RESULT_CODE, &op_result);
rc = SLAPI_PLUGIN_NOOP; /* Ignore this Operation */
PROFILE_POINT; /* Add Conflict; Entry Exists; Same CSN */
}
bailout:
return rc;
}
/*
* Return 0 for OK, -1 for Error, >0 for action code
* Action Code Bit 0: Fetch existing entry.
* Action Code Bit 1: Fetch parent entry.
*/
int
urp_modrdn_operation(Slapi_PBlock *pb)
{
slapi_operation_parameters *op_params = NULL;
Slapi_Entry *parent_entry;
Slapi_Entry *new_parent_entry;
Slapi_DN *newsuperior = NULL;
Slapi_DN *parentdn = NULL;
Slapi_Entry *target_entry;
Slapi_Entry *existing_entry;
const CSN *target_entry_dncsn;
CSN *opcsn = NULL;
char *op_uniqueid = NULL;
const char *existing_uniqueid = NULL;
const Slapi_DN *target_sdn;
const Slapi_DN *existing_sdn;
char *newrdn;
char sessionid[REPL_SESSION_ID_SIZE];
int r;
int op_result = 0;
int rc = 0; /* OK */
int del_old_replconflict_attr = 0;
if (slapi_op_abandoned(pb)) {
return rc;
}
slapi_pblock_get(pb, SLAPI_MODRDN_TARGET_ENTRY, &target_entry);
if (target_entry == NULL) {
/* An entry can't be found for the Unique Identifier */
op_result = LDAP_NO_SUCH_OBJECT;
slapi_pblock_set(pb, SLAPI_RESULT_CODE, &op_result);
rc = -1; /* No entry to modrdn */
PROFILE_POINT; /* ModRDN Conflict; Entry does not Exist; Discard ModRDN */
goto bailout;
}
get_repl_session_id(pb, sessionid, &opcsn);
target_entry_dncsn = entry_get_dncsn(target_entry);
if (csn_compare(target_entry_dncsn, opcsn) >= 0) {
/*
* The Operation CSN is not newer than the DN CSN.
* Either we're beaten by another ModRDN or we've applied the op.
*/
/* op_result= LDAP_SUCCESS; */
/*
* This operation won't be replayed. That is, this CSN won't update
* the max csn in RUV. The CSN is left uncommitted in RUV unless an
* error is set to op_result. Just to get rid of this CSN from RUV,
* setting an error to op_result
*/
slapi_log_err(slapi_log_urp, sessionid,
"urp_modrdn_operation - %s - operation CSN is newer than the DN CSN.\n",
slapi_entry_get_dn_const(target_entry));
op_result = LDAP_UNWILLING_TO_PERFORM;
slapi_pblock_set(pb, SLAPI_RESULT_CODE, &op_result);
rc = SLAPI_PLUGIN_NOOP; /* Ignore the modrdn */
PROFILE_POINT; /* ModRDN Conflict; Entry with Target DN Exists; OPCSN is not newer. */
goto bailout;
}
/* The DN CSN is older than the Operation CSN. Apply the operation */
target_sdn = slapi_entry_get_sdn_const(target_entry);
/* newrdn is no need to be case-ignored (get_rdn_plus_uniqueid) */
slapi_pblock_get(pb, SLAPI_MODRDN_NEWRDN, &newrdn);
slapi_pblock_get(pb, SLAPI_TARGET_UNIQUEID, &op_uniqueid);
slapi_pblock_get(pb, SLAPI_MODRDN_PARENT_ENTRY, &parent_entry);
slapi_pblock_get(pb, SLAPI_MODRDN_NEWPARENT_ENTRY, &new_parent_entry);
slapi_pblock_get(pb, SLAPI_MODRDN_NEWSUPERIOR_SDN, &newsuperior);
if (is_conflict_entry (target_entry)) {
slapi_log_err(SLAPI_LOG_REPL, sessionid,
"urp_modrdn_operation - Target_entry %s is a conflict; what to do ?\n",
slapi_entry_get_dn((Slapi_Entry *)target_entry));
}
if (is_tombstone_entry(target_entry)) {
/*
* It is a non-trivial task to rename a tombstone.
* This op has been ignored so far by
* setting SLAPI_RESULT_CODE to LDAP_NO_SUCH_OBJECT
* and rc to -1.
*/
/* Turn the tombstone to glue before rename it */
/* check if the delete was after the modrdn */
char *del_str = (char*)slapi_entry_attr_get_ref(target_entry, "nstombstonecsn");
CSN *del_csn = csn_new_by_string(del_str);
if (csn_compare(del_csn,opcsn)>0) {
char *glue_dn = (char*)slapi_entry_attr_get_ref(target_entry, "nscpentrydn");
Slapi_DN *glue_sdn = slapi_sdn_new_dn_byval(glue_dn);
op_result = tombstone_to_glue (pb, sessionid, target_entry,
glue_sdn, "renameTombstone", opcsn, NULL);
slapi_log_err(SLAPI_LOG_REPL, sessionid,
"urp_modrdn_operation - Target_entry %s is a tombstone; Renaming since delete was after rename.\n",
slapi_entry_get_dn((Slapi_Entry *)target_entry));
slapi_sdn_free(&glue_sdn);
} else {
op_result = LDAP_NO_SUCH_OBJECT;
slapi_log_err(SLAPI_LOG_REPL, sessionid,
"urp_modrdn_operation - Target_entry %s is a tombstone; returning LDAP_NO_SUCH_OBJECT.\n",
slapi_entry_get_dn((Slapi_Entry *)target_entry));
}
csn_free(&del_csn);
slapi_pblock_set(pb, SLAPI_RESULT_CODE, &op_result);
if (op_result == 0) {
/*
* Remember to turn this entry back to tombstone in post op.
* We'll just borrow an obsolete pblock type here. ???
*/
/* no. slapi_pblock_set (pb, SLAPI_URP_TOMBSTONE_UNIQUEID, slapi_ch_strdup(op_uniqueid)); */
rc = slapi_setbit_int(rc, SLAPI_RTN_BIT_FETCH_TARGET_ENTRY);
rc = 0;
} else {
slapi_log_err(slapi_log_urp, sessionid,
"urp_modrdn_operation - %s - Target entry is a tombstone.\n",
slapi_entry_get_dn_const(target_entry));
rc = SLAPI_PLUGIN_NOOP; /* Ignore the modrdn */
}
PROFILE_POINT; /* ModRDN Conflict; Entry with Target DN Exists; OPCSN is not newer. */
goto bailout;
}
slapi_pblock_get(pb, SLAPI_MODRDN_EXISTING_ENTRY, &existing_entry);
if (existing_entry != NULL) {
/*
* An entry with the target DN already exists.
* The smaller dncsn wins. The loser changes its RDN to
* uniqueid+baserdn, and adds operational attribute
* ATTR_NSDS5_REPLCONFLICT
*/
if (is_conflict_entry (existing_entry)) {
slapi_log_err(SLAPI_LOG_REPL, sessionid,
"urp_modrdn_operation - Existing_entry %s is a conflict; what to do ?\n",
slapi_entry_get_dn((Slapi_Entry *)existing_entry));
}
existing_uniqueid = slapi_entry_get_uniqueid(existing_entry);
existing_sdn = slapi_entry_get_sdn_const(existing_entry);
/*
* It used to dismiss the operation if the existing entry is
* the same as the target one.
* But renaming the RDN with the one which only cases are different,
* cn=ABC --> cn=Abc, this case matches. We should go forward the op.
*/
if (strcmp(op_uniqueid, existing_uniqueid) == 0) {
op_result = LDAP_SUCCESS;
slapi_pblock_set(pb, SLAPI_RESULT_CODE, &op_result);
rc = 0; /* Don't ignore the op */
PROFILE_POINT; /* ModRDN Replay */
goto bailout;
}
r = csn_compare(entry_get_dncsn(existing_entry), opcsn);
if (r == 0) {
/*
* The CSN of the Operation and the Entry DN are the same
* but the uniqueids are not.
* There might be two replicas with the same ReplicaID.
*/
slapi_log_err(slapi_log_urp, sessionid,
"urp_modrdn_operation - Duplicated CSN for different uniqueids [%s][%s]",
existing_uniqueid, op_uniqueid);
op_result = LDAP_OPERATIONS_ERROR;
slapi_pblock_set(pb, SLAPI_RESULT_CODE, &op_result);
rc = SLAPI_PLUGIN_NOOP; /* Ignore this Operation */
PROFILE_POINT; /* ModRDN Conflict; Duplicated CSN for Different Entries */
goto bailout;
}
if (r < 0) {
/* The target entry is a loser */
char *newrdn_with_uniqueid;
newrdn_with_uniqueid = get_rdn_plus_uniqueid(sessionid, newrdn, op_uniqueid);
if (newrdn_with_uniqueid == NULL) {
op_result = LDAP_OPERATIONS_ERROR;
slapi_pblock_set(pb, SLAPI_RESULT_CODE, &op_result);
rc = -1; /* Ignore this Operation */
PROFILE_POINT; /* ModRDN Conflict; Entry with Target DN Exists;
Unique ID already in RDN - Change to Lost and Found entry */
goto bailout;
}
mod_namingconflict_attr(op_uniqueid, target_sdn, existing_sdn, opcsn, "MODRDN");
mod_objectclass_attr(op_uniqueid, target_sdn, target_sdn, opcsn, "MODRDN");
slapi_pblock_set(pb, SLAPI_MODRDN_NEWRDN, newrdn_with_uniqueid);
slapi_log_err(slapi_log_urp, sessionid,
"urp_modrdn_operation - Naming conflict MODRDN. Rename target entry from %s to %s\n",
newrdn, newrdn_with_uniqueid);
rc = slapi_setbit_int(rc, SLAPI_RTN_BIT_FETCH_EXISTING_DN_ENTRY);
PROFILE_POINT; /* ModRDN Conflict; Entry with Target DN Exists; Rename Operation Entry */
goto bailout;
}
if (r > 0) {
/* The existing entry is a loser */
int resolve = urp_annotate_dn(sessionid, existing_entry, opcsn, "MODRDN", NULL);
if (!resolve) {
op_result = LDAP_OPERATIONS_ERROR;
slapi_pblock_set(pb, SLAPI_RESULT_CODE, &op_result);
rc = -1; /* Abort this Operation */
goto bailout;
}
rc = slapi_setbit_int(rc, SLAPI_RTN_BIT_FETCH_EXISTING_DN_ENTRY);
rc = slapi_setbit_int(rc, SLAPI_RTN_BIT_FETCH_NEWPARENT_ENTRY);
if (LDAP_NO_SUCH_OBJECT == resolve) {
/* This means that existing_dn_entry did not really exist!!!
* This indicates that a get_copy_of_entry -> dn2entry returned
* an entry (existing_dn_entry) that was already removed from the ldbm.
* This is bad, because it indicates a dn cache or DB corruption.
* However, as far as the conflict is concerned, this error is harmless:
* if the existing_dn_entry did not exist in the first place, there was no
* conflict!! Return 0 for success to break the ldbm_back_modrdn loop
* and get out of this inexistent conflict resolution ASAP.
*/
rc = 0;
}
/* Set flag to remove possible old naming conflict */
del_old_replconflict_attr = 1;
PROFILE_POINT; /* ModRDN Conflict; Entry with Target DN Exists; Rename Entry with Target DN */
goto bailout;
}
} else {
/*
* No entry with the target DN exists.
*/
/* Set flag to remove possible old naming conflict */
del_old_replconflict_attr = 1;
if (new_parent_entry != NULL) {
/* The new superior entry exists */
rc = 0; /* OK, Apply the ModRDN */
PROFILE_POINT; /* ModRDN Conflict; OK */
goto bailout;
}
/* The new superior entry doesn't exist */
slapi_pblock_get(pb, SLAPI_MODRDN_NEWSUPERIOR_SDN, &newsuperior);
if (newsuperior == NULL) {
/* (new_parent_entry==NULL && newsuperiordn==NULL)
* This is ok - SLAPI_MODRDN_NEWPARENT_ENTRY will
* only be set if SLAPI_MODRDN_NEWSUPERIOR_SDN was
* suplied by the client. If it wasn't, we're just
* changing the RDN of the entry. In that case,
* if the entry exists, its parent won't change
* when it's renamed, and therefore we can assume
* its parent exists.
*/
rc = 0;
PROFILE_POINT; /* ModRDN OK */
goto bailout;
}
if ((0 == slapi_sdn_compare(slapi_entry_get_sdn(parent_entry),
newsuperior)) ||
is_suffix_dn(pb, newsuperior, &parentdn)) {
/*
* The new superior is the same as the current one, or
* this entry is a suffix whose parent can be absent.
*/
rc = 0; /* OK, Move the entry */
PROFILE_POINT; /* ModRDN Conflict; Absent Target Parent; Create Suffix Entry */
goto bailout;
}
/*
* This entry is not a suffix entry, so the parent entry should exist.
* (This shouldn't happen in a ds5 server)
*/
slapi_pblock_get(pb, SLAPI_OPERATION_PARAMETERS, &op_params);
op_result = create_glue_entry(pb, sessionid, newsuperior,
op_params->p.p_modrdn.modrdn_newsuperior_address.uniqueid, opcsn);
if (LDAP_SUCCESS != op_result) {
/*
* FATAL ERROR
* We should probably just abort the rename
* this will cause replication divergence requiring
* admin intercession
*/
slapi_log_err(SLAPI_LOG_ERR, sessionid,
"urp_modrdn_operation - Parent %s couldn't be found, nor recreated as a glue entry\n",
slapi_sdn_get_dn(newsuperior));
op_result = LDAP_OPERATIONS_ERROR;
slapi_pblock_set(pb, SLAPI_RESULT_CODE, &op_result);
rc = SLAPI_PLUGIN_FAILURE; /* Ignore this Operation */
PROFILE_POINT;
goto bailout;
}
/* The backend add code should now search for the parent again. */
rc = slapi_setbit_int(rc, SLAPI_RTN_BIT_FETCH_NEWPARENT_ENTRY);
PROFILE_POINT; /* ModRDN Conflict; Absent Target Parent - Change to Lost and Found entry */
goto bailout;
}
bailout:
if (del_old_replconflict_attr && rc == 0) {
del_replconflict_attr(target_entry, opcsn, 0);
}
if (parentdn)
slapi_sdn_free(&parentdn);
return rc;
}
/*
* Return 0 for OK, -1 for Error
*/
int
urp_delete_operation(Slapi_PBlock *pb)
{
Slapi_Entry *deleteentry;
CSN *opcsn = NULL;
char sessionid[REPL_SESSION_ID_SIZE];
int op_result = 0;
int rc = SLAPI_PLUGIN_SUCCESS; /* OK */
if (slapi_op_abandoned(pb)) {
return rc;
}
slapi_pblock_get(pb, SLAPI_DELETE_EXISTING_ENTRY, &deleteentry);
get_repl_session_id(pb, sessionid, &opcsn);
if (deleteentry == NULL) /* uniqueid can't be found */
{
op_result = LDAP_NO_SUCH_OBJECT;
slapi_pblock_set(pb, SLAPI_RESULT_CODE, &op_result);
rc = SLAPI_PLUGIN_FAILURE; /* Don't apply the Delete */
slapi_log_err(slapi_log_urp, sessionid,
"urp_delete_operation - Entry %s does not exist; returning NO_SUCH_OBJECT.\n",
slapi_entry_get_dn((Slapi_Entry *)deleteentry));
PROFILE_POINT; /* Delete Operation; Entry not exist. */
} else if (is_tombstone_entry(deleteentry)) {
/* The entry is already a Tombstone,
* either because the operation was already applied,
* then ignore this delete.
* check if the tombstone csn matches the operationcsn
*/
if (is_deleted_at_csn(deleteentry, opcsn)) {
op_result= LDAP_ALREADY_EXISTS;
slapi_pblock_set(pb, SLAPI_RESULT_CODE, &op_result);
rc = SLAPI_PLUGIN_NOOP; /* Don't apply the Delete */
slapi_log_err(slapi_log_urp, sessionid,
"urp_delete_operation - Entry \"%s\" is already a Tombstone.\n",
slapi_entry_get_dn_const(deleteentry));
} else if (urp_delete_check_conflict (sessionid, deleteentry, opcsn)) {
/* the other option is that an entry was turned into a conflict
* when a conflicting add was handled for an already delted entry
* This means that now the conflict has also to be turned into a tombstone
* Check if such a conflict exists - and turn to a tombstone
*/
op_result= LDAP_SUCCESS;
slapi_pblock_set(pb, SLAPI_RESULT_CODE, &op_result);
rc = SLAPI_PLUGIN_NOOP_COMMIT; /* Don't apply the Delete */
slapi_log_err(slapi_log_urp, sessionid,
"urp_delete_operation - Deleted conflict entry instead of tombstone \"%s\"\n",
slapi_entry_get_dn_const(deleteentry));
} else {
/* no already deleted tombstone and no alternative to delete
* do nothing
*/
op_result= LDAP_OPERATIONS_ERROR;
slapi_pblock_set(pb, SLAPI_RESULT_CODE, &op_result);
rc = SLAPI_PLUGIN_NOOP; /* Don't apply the Delete */
slapi_log_err(slapi_log_urp, sessionid,
"urp_delete_operation - Entry \"%s\" cannot be deleted.\n",
slapi_entry_get_dn_const(deleteentry));
}
PROFILE_POINT; /* Delete Operation; Already a Tombstone. */
} else /* The entry to be deleted exists and is not a tombstone */
{
get_repl_session_id(pb, sessionid, &opcsn);
/* Check if the entry has children. */
if (!slapi_entry_has_children(deleteentry)) {
/* Remove possible conflict attributes */
rc = SLAPI_PLUGIN_SUCCESS; /* OK, to delete the entry */
if (is_conflict_entry(deleteentry)) {
Slapi_DN *sdn = NULL;
slapi_pblock_get(pb, SLAPI_DELETE_TARGET_SDN, &sdn);
if (0 == slapi_sdn_compare(sdn, slapi_entry_get_sdn(deleteentry))) {
/* the delete directly targetd the conflict entry, just continue */
} else {
/* check if there is a valid entry added before the delete,
* then we need to delete this entry
*/
char *valid_uniqueid = urp_find_valid_entry_to_delete(pb, deleteentry, sessionid, opcsn);
if (valid_uniqueid) {
/* do we need to free SLAPI_TARGET_UNIQUEID ? */
slapi_pblock_set( pb, SLAPI_TARGET_UNIQUEID, (void*)valid_uniqueid);
rc = slapi_setbit_int(rc,SLAPI_RTN_BIT_FETCH_EXISTING_UNIQUEID_ENTRY);
} else {
del_replconflict_attr (deleteentry, opcsn, 0);
rc= slapi_setbit_int(rc,SLAPI_RTN_BIT_FETCH_EXISTING_DN_ENTRY);
}
}
} else if (is_renamed_entry(pb, deleteentry, opcsn)) {
/* the entry was renamed before the delete, ignore the delete */
op_result= LDAP_SUCCESS;
slapi_pblock_set(pb, SLAPI_RESULT_CODE, &op_result);
rc = SLAPI_PLUGIN_NOOP; /* Don't apply the Delete */
}
PROFILE_POINT; /* Delete Operation; OK. */
} else {
/* the entry has children, so it is either the orphan-glue
* scenario or the more complex situatin when there is a conflict entry
* for the entry to be deleted which would be restored in the post_delete
* phase. We would just have to swap the entries and be done,
* but unfortunately as a plugin this is not possible.
* So the approach is:
* - move the children to th conflict entry
* - let the delete happen
* - let the post_del rename the conflict entry
*/
Slapi_Entry *conflict_entry = urp_get_min_naming_conflict_entry (pb, slapi_entry_get_dn_const(deleteentry), sessionid, opcsn);
if (conflict_entry) {
urp_rename_conflict_children(slapi_entry_get_dn_const(deleteentry),
slapi_entry_get_sdn_const(conflict_entry));
slapi_entry_free(conflict_entry);
rc = SLAPI_PLUGIN_SUCCESS; /* OK, to delete the entry */
} else {
/* Turn this entry into a glue_absent_parent entry */
rc = entry_to_glue(sessionid, deleteentry, REASON_RESURRECT_ENTRY, opcsn);
/* Turn the Delete into a No-Op */
op_result= LDAP_SUCCESS;
slapi_pblock_set(pb, SLAPI_RESULT_CODE, &op_result);
if (rc == 0) {
/* Don't apply the Delete, but commit the glue change */
rc = SLAPI_PLUGIN_NOOP_COMMIT;
} else {
rc = SLAPI_PLUGIN_NOOP; /* Don't apply the Delete */
}
slapi_log_err(slapi_log_urp, sessionid,
"urp_delete_operation - Turn entry \"%s\" into a glue_absent_parent entry.\n",
slapi_entry_get_dn_const(deleteentry));
PROFILE_POINT; /* Delete Operation; Entry has children. */
}
}
}
return rc;
}
/*
* Return 0 for OK, -1 for Error
*/
int
urp_post_add_operation(Slapi_PBlock *pb)
{
char sessionid[REPL_SESSION_ID_SIZE];
Slapi_Operation *op;
CSN *opcsn;
Slapi_Entry *addentry;
char *conflict_dn = NULL;
const char *valid_dn = NULL;
int rc = 0;
slapi_pblock_get( pb, SLAPI_URP_NAMING_COLLISION_DN, &conflict_dn );
if (conflict_dn) {
/* the existing entry was turned into a conflict,
* move children to the valid entry
*/
slapi_pblock_get( pb, SLAPI_OPERATION, &op);
get_repl_session_id (pb, sessionid, &opcsn);
slapi_log_err(SLAPI_LOG_REPL, sessionid,
"urp_post_add_operation - Entry %s is conflict entry, check for children\n",
conflict_dn);
slapi_pblock_get( pb, SLAPI_ADD_ENTRY, &addentry );
valid_dn = slapi_entry_get_dn_const(addentry);
slapi_log_err(SLAPI_LOG_REPL, sessionid,
"urp_post_add_operation - Entry %s is valid entry, check for children\n",
valid_dn);
rc = urp_rename_conflict_children(conflict_dn, slapi_entry_get_sdn_const(addentry));
}
slapi_ch_free_string(&conflict_dn);
slapi_pblock_set( pb, SLAPI_URP_NAMING_COLLISION_DN, NULL );
slapi_pblock_get( pb, SLAPI_URP_TOMBSTONE_CONFLICT_DN, &conflict_dn );
if (conflict_dn) {
/* a tombstone was tirned into a conflict
* move it to a valid parent if parent is also a conflict
*/
Slapi_DN *conflict_sdn = slapi_sdn_new_dn_byval(conflict_dn);
char *parent_dn = slapi_dn_parent(conflict_dn);
slapi_pblock_get( pb, SLAPI_OPERATION, &op);
get_repl_session_id (pb, sessionid, &opcsn);
slapi_log_err(SLAPI_LOG_REPL, sessionid,
"urp_post_add_operation - Entry %s is conflict from tombstone, check parent\n",
conflict_dn);
rc = tombstone_to_conflict_check_parent(sessionid, parent_dn, NULL, NULL, opcsn, conflict_sdn);
slapi_sdn_free(&conflict_sdn);
slapi_ch_free_string(&parent_dn);
}
return rc;
}
int
urp_post_modrdn_operation(Slapi_PBlock *pb)
{
CSN *opcsn;
char sessionid[REPL_SESSION_ID_SIZE];
char *tombstone_uniqueid;
Slapi_Entry *postentry;
Slapi_Operation *op;
int rc = SLAPI_PLUGIN_SUCCESS; /* OK */
int oprc = 0;
/* only execute if operation was successful */
slapi_pblock_get(pb, SLAPI_PLUGIN_OPRETURN, &oprc);
if (oprc) return rc;
/*
* Do not abandon the post op - the processed CSN needs to be
* committed to keep the consistency between the changelog
* and the backend DB.
* if ( slapi_op_abandoned(pb) ) return 0;
*/
slapi_pblock_get(pb, SLAPI_URP_TOMBSTONE_UNIQUEID, &tombstone_uniqueid);
if (tombstone_uniqueid == NULL) {
/*
* The entry is not resurrected from tombstone. Hence
* we need to check if any naming conflict with its
* old dn can be resolved.
*/
slapi_pblock_get(pb, SLAPI_OPERATION, &op);
if (!operation_is_flag_set(op, OP_FLAG_REPL_FIXUP)) {
get_repl_session_id(pb, sessionid, &opcsn);
urp_naming_conflict_removal(pb, sessionid, opcsn, "MODRDN");
/* keep track of the entry's lifetime befor renaming
* by creating a cenotaph
*/
urp_fixup_add_cenotaph(pb, sessionid, opcsn);
}
} else {
/*
* The entry was a resurrected tombstone.
* This could happen when we applied a rename
* to a tombstone to avoid server divergence. Now
* it's time to put the entry back to tombstone.
*/
slapi_pblock_get(pb, SLAPI_ENTRY_POST_OP, &postentry);
if (postentry && strcmp(tombstone_uniqueid, slapi_entry_get_uniqueid(postentry)) == 0) {
entry_to_tombstone(pb, postentry);
}
slapi_ch_free((void **)&tombstone_uniqueid);
slapi_pblock_set(pb, SLAPI_URP_TOMBSTONE_UNIQUEID, NULL);
}
return rc;
}
/*
* Conflict removal
*/
int
urp_post_delete_operation(Slapi_PBlock *pb)
{
Slapi_Operation *op;
Slapi_Entry *entry;
CSN *opcsn;
char sessionid[REPL_SESSION_ID_SIZE];
int op_result;
int oprc = 0;
/* only execute if operation was successful */
slapi_pblock_get(pb, SLAPI_PLUGIN_OPRETURN, &oprc);
if (oprc) return 0;
/*
* Do not abandon the post op - the processed CSN needs to be
* committed to keep the consistency between the changelog
* and the backend DB
* if ( slapi_op_abandoned(pb) ) return 0;
*/
get_repl_session_id(pb, sessionid, &opcsn);
/*
* Conflict removal from the parent entry:
* If the parent is glue and has no more children,
* turn the parent to tombstone
*/
slapi_pblock_get(pb, SLAPI_DELETE_GLUE_PARENT_ENTRY, &entry);
if (entry != NULL) {
op_result = entry_to_tombstone(pb, entry);
if (op_result == LDAP_SUCCESS) {
slapi_log_err(slapi_log_urp, sessionid,
"urp_post_delete_operation - Tombstoned glue entry %s since it has no more children\n",
slapi_entry_get_dn_const(entry));
}
}
slapi_pblock_get(pb, SLAPI_OPERATION, &op);
if (!operation_is_flag_set(op, OP_FLAG_REPL_FIXUP)) {
/*
* Conflict removal from the peers of the old dn
*/
urp_naming_conflict_removal(pb, sessionid, opcsn, "DEL");
}
return 0;
}
static int
urp_fixup_add_cenotaph(Slapi_PBlock *pb, char *sessionid, CSN *opcsn)
{
Slapi_PBlock *add_pb;
Slapi_Entry *cenotaph = NULL;
Slapi_Entry *pre_entry = NULL;
int ret = 0;
Slapi_DN *pre_sdn = NULL;
Slapi_RDN *rdn = NULL;
char *parentdn = NULL;
char *newdn;
const char *entrydn;
const char *uniqueid = NULL;
CSN *dncsn = NULL;
char csnstr[CSN_STRSIZE+1];
slapi_pblock_get (pb, SLAPI_ENTRY_PRE_OP, &pre_entry);
if (pre_entry == NULL) {
slapi_log_err(SLAPI_LOG_ERR, sessionid,
"urp_fixup_add_cenotaph - failed to get preop entry\n");
return -1;
}
slapi_pblock_get(pb, SLAPI_MODRDN_TARGET_SDN, &pre_sdn);
entrydn = slapi_sdn_get_ndn(pre_sdn);
/* pre_sdn = slapi_entry_get_sdn(pre_entry);
entrydn = slapi_entry_get_ndn (pre_entry);*/
uniqueid = slapi_entry_get_uniqueid (pre_entry);
parentdn = slapi_dn_parent(entrydn);
rdn = slapi_rdn_new();
slapi_sdn_get_rdn(pre_sdn, rdn);
slapi_rdn_remove_attr (rdn, SLAPI_ATTR_UNIQUEID );
slapi_rdn_add(rdn, "cenotaphID", uniqueid);
newdn = slapi_ch_smprintf("%s,%s", slapi_rdn_get_rdn(rdn), parentdn);
slapi_rdn_free(&rdn);
slapi_ch_free_string(&parentdn);
/* slapi_sdn_free(&pre_sdn); */
cenotaph = slapi_entry_alloc();
slapi_entry_init(cenotaph, slapi_ch_strdup(newdn), NULL);
dncsn = (CSN *)entry_get_dncsn (pre_entry);
slapi_entry_add_string(cenotaph, SLAPI_ATTR_OBJECTCLASS, "extensibleobject");
slapi_entry_add_string(cenotaph, SLAPI_ATTR_OBJECTCLASS, "nstombstone");
slapi_entry_add_string(cenotaph,"cenotaphfrom", csn_as_string(dncsn, PR_FALSE, csnstr));
slapi_entry_add_string(cenotaph,"cenotaphto", csn_as_string(opcsn, PR_FALSE, csnstr));
slapi_entry_add_string(cenotaph,"nstombstonecsn", csn_as_string(opcsn, PR_FALSE, csnstr));
slapi_entry_add_string(cenotaph, SLAPI_ATTR_NSCP_ENTRYDN, entrydn);
slapi_log_err(SLAPI_LOG_REPL, sessionid,
"urp_fixup_add_cenotaph - addinng cenotaph: %s \n", newdn);
add_pb = slapi_pblock_new();
slapi_pblock_init(add_pb);
slapi_add_entry_internal_set_pb(add_pb,
cenotaph,
NULL,
repl_get_plugin_identity(PLUGIN_MULTIMASTER_REPLICATION),
OP_FLAG_REPL_FIXUP|OP_FLAG_NOOP|OP_FLAG_CENOTAPH_ENTRY|SLAPI_OP_FLAG_BYPASS_REFERRALS);
slapi_add_internal_pb(add_pb);
slapi_pblock_get(add_pb, SLAPI_PLUGIN_INTOP_RESULT, &ret);
slapi_pblock_destroy(add_pb);
if (ret == LDAP_ALREADY_EXISTS) {
/* the cenotaph already exists, probably because of a loop
* in renaming entries. Update it with new csns
*/
slapi_log_err(SLAPI_LOG_REPL, sessionid,
"urp_fixup_add_cenotaph - cenotaph (%s) already exists, updating\n", newdn);
Slapi_PBlock *mod_pb = slapi_pblock_new();
Slapi_Mods smods;
Slapi_DN *sdn = slapi_sdn_new_dn_byval(newdn);
slapi_mods_init(&smods, 4);
slapi_mods_add_string(&smods, LDAP_MOD_REPLACE, "cenotaphfrom", csn_as_string(dncsn, PR_FALSE, csnstr));
slapi_mods_add_string(&smods, LDAP_MOD_REPLACE, "cenotaphto", csn_as_string(opcsn, PR_FALSE, csnstr));
slapi_mods_add_string(&smods, LDAP_MOD_REPLACE, "nstombstonecsn", csn_as_string(opcsn, PR_FALSE, csnstr));
slapi_modify_internal_set_pb_ext(
mod_pb,
sdn,
slapi_mods_get_ldapmods_byref(&smods),
NULL, /* Controls */
NULL,
repl_get_plugin_identity(PLUGIN_MULTIMASTER_REPLICATION),
OP_FLAG_REPL_FIXUP|OP_FLAG_NOOP|OP_FLAG_CENOTAPH_ENTRY|SLAPI_OP_FLAG_BYPASS_REFERRALS);
slapi_modify_internal_pb(mod_pb);
slapi_pblock_get(mod_pb, SLAPI_PLUGIN_INTOP_RESULT, &ret);
if (ret != LDAP_SUCCESS) {
slapi_log_err(SLAPI_LOG_ERR, sessionid,
"urp_fixup_add_cenotaph - failed to modify cenotaph, err= %d\n", ret);
}
slapi_mods_done(&smods);
slapi_sdn_free(&sdn);
slapi_pblock_destroy(mod_pb);
} else if (ret != LDAP_SUCCESS) {
slapi_log_err(SLAPI_LOG_ERR, sessionid,
"urp_fixup_add_cenotaph - failed to add cenotaph, err= %d\n", ret);
}
slapi_ch_free_string(&newdn);
return ret;
}
int
urp_fixup_add_entry(Slapi_Entry *e, const char *target_uniqueid, const char *parentuniqueid, CSN *opcsn, int opflags)
{
Slapi_PBlock *newpb;
Slapi_Operation *op;
int op_result;
newpb = slapi_pblock_new();
/*
* Mark this operation as replicated, so that the front end
* doesn't add extra attributes.
*/
slapi_add_entry_internal_set_pb(
newpb,
e, /* entry will be consumed */
NULL, /*Controls*/
repl_get_plugin_identity(PLUGIN_MULTIMASTER_REPLICATION),
OP_FLAG_REPLICATED | OP_FLAG_REPL_FIXUP | opflags);
if (target_uniqueid) {
slapi_pblock_set(newpb, SLAPI_TARGET_UNIQUEID, (void *)target_uniqueid);
}
if (parentuniqueid) {
struct slapi_operation_parameters *op_params;
slapi_pblock_get(newpb, SLAPI_OPERATION_PARAMETERS, &op_params);
op_params->p.p_add.parentuniqueid = (char *)parentuniqueid; /* Consumes parentuniqueid */
}
slapi_pblock_get(newpb, SLAPI_OPERATION, &op);
operation_set_csn(op, opcsn);
slapi_add_internal_pb(newpb);
slapi_pblock_get(newpb, SLAPI_PLUGIN_INTOP_RESULT, &op_result);
slapi_pblock_destroy(newpb);
return op_result;
}
int
urp_fixup_modrdn_entry (const Slapi_DN *entrydn, const char *newrdn, const Slapi_DN *newsuperior, const char *entryuniqueid, const char *parentuniqueid, CSN *opcsn, int opflags)
{
Slapi_PBlock *newpb;
Slapi_Operation *op;