| blob | e5baefc4cb431a59d0035322075295269c567a68 |
1 /*
2 ldb database library
4 Copyright (C) Simo Sorce 2004-2008
5 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005-2013
6 Copyright (C) Andrew Tridgell 2005-2009
7 Copyright (C) Stefan Metzmacher <metze@samba.org> 2007
8 Copyright (C) Matthieu Patou <mat@samba.org> 2010-2011
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 */
24 /*
25 * Name: ldb
26 *
27 * Component: ldb repl_meta_data module
28 *
29 * Description: - add a unique objectGUID onto every new record,
30 * - handle whenCreated, whenChanged timestamps
31 * - handle uSNCreated, uSNChanged numbers
32 * - handle replPropertyMetaData attribute
33 *
34 * Author: Simo Sorce
35 * Author: Stefan Metzmacher
36 */
54 #undef DBGC_CLASS
55 #define DBGC_CLASS DBGC_DRS_REPL
57 /* the RMD_VERSION for linked attributes starts from 1 */
58 #define RMD_VERSION_INITIAL 1
60 /*
61 * It's 29/12/9999 at 23:59:59 UTC as specified in MS-ADTS 7.1.1.4.2
62 * Deleted Objects Container
63 */
78 };
84 };
93 /* the controls we pass down */
96 /*
97 * Backlinks for the replmd_add() case (we want to create
98 * backlinks after creating the user, but before the end of
99 * the ADD request)
100 */
103 /* details for the mode where we apply a bunch of inbound replication meessages */
115 };
118 static int replmd_delete_internals(struct ldb_module *module, struct ldb_request *req, bool re_delete);
141 };
149 };
155 {
163 }
165 }
170 }
177 }
179 }
185 }
187 }
192 }
194 }
199 }
205 }
206 }
219 };
221 /* Attributes looked for when updating or deleting, to check for a urgent replication needed */
226 NULL
227 };
232 {
238 }
244 }
245 }
246 }
248 }
251 {
254 }
256 }
260 /*
261 initialise the module
262 allocate the private structure and build the list
263 of partition DNs for use by replmd_notify()
264 */
266 {
279 }
288 }
293 replmd_private->sorted_links
295 SAMBA_COMPATIBLE_FEATURES_ATTR,
296 SAMBA_SORTED_LINKS_FEATURE);
297 }
301 }
303 /*
304 cleanup our per-transaction contexts
305 */
307 {
312 }
321 };
323 /*
324 a ldb_modify request operating on modules below the
325 current module
326 */
330 {
341 }
344 message,
345 NULL,
346 res,
347 ldb_modify_default_callback,
348 parent);
353 }
359 }
361 /* Run the new request */
366 }
370 }
372 /*
373 process a backlinks we accumulated during a transaction, adding and
374 deleting the backlinks from the target objects
375 */
376 static int replmd_process_backlink(struct ldb_module *module, struct la_backlink *bl, struct ldb_request *parent)
377 {
385 /*
386 - find DN of target
387 - find DN of source
388 - construct ldb_message
389 - either an add or a delete
390 */
399 }
406 }
414 /* Filter down to the attributes we want in the backlink */
417 }
419 /* construct a ldb_message for adding/deleting the backlink */
426 }
431 }
434 /* a backlink should never be single valued. Unfortunately the
435 exchange schema has a attribute
436 msExchBridgeheadedLocalConnectorsDNBL which is single
437 valued and a backlink. We need to cope with that by
438 ignoring the single value flag */
443 /* we allow LDB_ERR_NO_SUCH_ATTRIBUTE as success to
444 cope with possible corruption where the backlink has
445 already been removed */
459 }
462 }
464 /*
465 add a backlink to the list of backlinks to add/delete in the prepare
466 commit
468 forward_dn is stolen onto the defereed context
469 */
478 {
486 }
490 /*
491 * windows 2003 has a broken schema where the
492 * definition of msDS-IsDomainFor is missing (which is
493 * supposed to be the backlink of the
494 * msDS-HasDomainNCs attribute
495 */
497 }
507 }
509 /*
510 add a backlink to the list of backlinks to add/delete in the prepare
511 commit
512 */
520 {
527 /*
528 * windows 2003 has a broken schema where the
529 * definition of msDS-IsDomainFor is missing (which is
530 * supposed to be the backlink of the
531 * msDS-HasDomainNCs attribute
532 */
534 }
543 }
546 /*
547 * Callback for most write operations in this module:
548 *
549 * notify the repl task that a object has changed. The notifies are
550 * gathered up in the replmd_private structure then written to the
551 * @REPLCHANGED object in each partition during the prepare_commit
552 */
554 {
571 /*
572 * Remove the current partition control from what we pass up
573 * the chain if it hasn't been requested manually.
574 */
576 partition_ctrl);
577 }
589 }
592 /*
593 * Set at DBG_NOTICE as once these start to happe, they
594 * will happen a lot until resolved, due to repeated
595 * replication. The caller will probably print the
596 * ldb error string anyway.
597 */
603 ac,
604 LDB_CHANGETYPE_ADD,
605 msg);
611 s);
615 }
621 }
625 /*
626 * process our backlink list after an replmd_add(),
627 * creating and deleting backlinks as necessary (this
628 * code is sync). The other cases are handled inline
629 * with the modify.
630 */
636 }
637 }
638 }
644 }
654 }
655 }
663 }
669 }
671 }
677 }
678 }
681 }
682 }
688 }
691 /* free the partition control container here, for the
692 * common path. Other cases will have it cleaned up
693 * eventually with the ares */
697 }
698 }
701 /*
702 * update a @REPLCHANGED record in each partition if there have been
703 * any writes of replicated data in the partition
704 */
706 {
721 }
729 DSDB_EXTENDED_SCHEMA_UPDATE_NOW_OID,
730 ext_res,
731 DSDB_FLAG_NEXT_MODULE,
732 parent);
735 }
737 }
741 }
744 }
747 /*
748 created a replmd_replicated_request context
749 */
752 {
763 }
775 }
777 /* get our invocationId */
784 }
788 }
790 /*
791 add a time element to a record
792 */
794 {
801 }
806 }
811 }
814 /* always set as replace. This works because on add ops, the flag
815 is ignored */
819 }
821 /*
822 add a uint64_t element to a record
823 */
826 {
832 }
837 }
840 /* always set as replace. This works because on add ops, the flag
841 is ignored */
845 }
850 {
851 /*
852 * This assignment seems inoccous, but it is critical for the
853 * system, as we need to do the comparisons as a unsigned
854 * quantity, not signed (enums are signed integers)
855 */
861 }
863 /*
864 * See above regarding this being an unsigned comparison.
865 * Otherwise when the high bit is set on non-standard
866 * attributes, they would end up first, before objectClass
867 * (0).
868 */
870 }
875 {
881 }
883 /* the objectClass attribute is value 0x00000000, so must be first */
889 }
892 }
897 {
898 /* Note this is O(n^2) for the almost-sorted case, which this is */
900 replmd_replPropertyMetaData1_attid_sort);
902 }
907 {
911 /*
912 * TODO: make this faster by caching the dsdb_attribute pointer
913 * on the ldb_messag_element
914 */
919 /*
920 * TODO: remove this check, we should rely on e1 and e2 having valid attribute names
921 * in the schema
922 */
925 }
928 }
930 }
934 {
935 LDB_TYPESAFE_QSORT(msg->elements, msg->num_elements, schema, replmd_ldb_message_element_attid_sort);
936 }
952 /*
953 fix up linked attributes in replmd_add.
954 This involves setting up the right meta-data in extended DN
955 components, and creating backlinks to the object
956 */
961 NTTIME now,
965 {
970 /* We will take a reference to the schema in replmd_add_backlink */
979 "Attribute %s is single valued but "
984 }
991 }
997 }
1004 }
1014 }
1019 parent);
1023 }
1026 }
1031 }
1036 {
1039 /* Calculate an extended DN for any linked attributes */
1043 }
1047 }
1054 }
1055 }
1058 }
1060 /*
1061 intercept add requests
1062 */
1064 {
1072 DATA_BLOB guid_blob_stack;
1079 /*
1080 * The use of a time_t here seems odd, but as the NTTIME
1081 * elements are actually declared as NTTIME_1sec in the IDL,
1082 * getting a higher resolution timestamp is not required.
1083 */
1085 NTTIME now;
1099 /* check if there's a show relax control (used by provision to say 'I know what I'm doing') */
1103 }
1105 /* do not manipulate our control entries */
1108 }
1126 }
1127 /* we remove this attribute as it can be a string and
1128 * will not be treated correctly and then we will re-add
1129 * it later on in the good format */
1131 }
1133 /* a new GUID */
1138 /* This can't fail */
1142 }
1147 }
1151 /* Get a sequence number from the backend */
1156 }
1158 /* we have to copy the message as the caller might have it as a const */
1164 }
1166 /* generated times */
1173 }
1176 }
1178 /*
1179 * remove autogenerated attributes
1180 */
1187 /*
1188 * readd replicated attributes
1189 */
1195 }
1197 /* build the replication meta_data */
1208 }
1218 i++;
1220 }
1229 }
1231 if ((sa->systemFlags & DS_FLAG_ATTR_NOT_REPLICATED) || (sa->systemFlags & DS_FLAG_ATTR_IS_CONSTRUCTED)) {
1232 /* if the attribute is not replicated (0x00000001)
1233 * or constructed (0x00000004) it has no metadata
1234 */
1235 i++;
1237 }
1242 guid_blob,
1247 }
1248 }
1250 /*
1251 * Prepare the context for the backlinks and
1252 * create metadata for the forward links. The
1253 * backlinks are created in
1254 * replmd_op_callback() after the successful
1255 * ADD of the object.
1256 */
1260 extended_dn,
1265 }
1266 /* linked attributes are not stored in
1267 replPropertyMetaData in FL above w2k */
1268 i++;
1270 }
1282 }
1286 /*
1287 * Set the originating_change_time to 29/12/9999 at 23:59:59
1288 * as specified in MS-ADTS 7.1.1.4.2 Deleted Objects Container
1289 */
1293 }
1296 }
1300 ni++;
1303 i++;
1305 }
1310 i++;
1312 }
1315 }
1317 /* fix meta data count */
1320 /*
1321 * sort meta data array
1322 */
1328 }
1330 /* generated NDR encoded values */
1338 }
1340 /*
1341 * add the autogenerated values
1342 */
1348 }
1354 }
1360 }
1366 }
1372 }
1374 /*
1375 * sort the attributes by attid before storing the object
1376 */
1379 /*
1380 * Assert that we do have an objectClass
1381 */
1389 }
1391 REPL_URGENT_ON_CREATE);
1395 msg,
1398 req);
1404 }
1406 /* current partition control is needed by "replmd_op_callback" */
1409 DSDB_CONTROL_CURRENT_PARTITION_OID,
1414 }
1415 }
1422 }
1423 }
1425 /* mark the control done */
1428 }
1429 /* go on with the call chain */
1431 }
1434 /*
1435 * update the replPropertyMetaData for one element
1436 */
1445 NTTIME now,
1449 {
1459 /* allow this to make it possible for dbcheck
1460 to remove bad attributes */
1462 }
1467 }
1471 if ((a->systemFlags & DS_FLAG_ATTR_NOT_REPLICATED) || (a->systemFlags & DS_FLAG_ATTR_IS_CONSTRUCTED)) {
1473 }
1475 /*
1476 * if the attribute's value haven't changed, and this isn't
1477 * just a delete of everything then return LDB_SUCCESS Unless
1478 * we have the provision control or if the attribute is
1479 * interSiteTopologyGenerator as this page explain:
1480 * http://support.microsoft.com/kb/224815 this attribute is
1481 * periodicaly written by the DC responsible for the intersite
1482 * generation in a given site
1483 *
1484 * Unchanged could be deleting or replacing an already-gone
1485 * thing with an unconstrained delete/empty replace or a
1486 * replace with the same value, but not an add with the same
1487 * value because that could be about adding a duplicate (which
1488 * is for someone else to error out on).
1489 */
1493 }
1499 }
1502 /*
1503 * We intentionally skip the version bump when attempting to
1504 * vanish links.
1505 *
1506 * The control is set by dbcheck and expunge-tombstones which
1507 * both attempt to be non-replicating. Otherwise, making an
1508 * alteration to the replication state would trigger a
1509 * broadcast of all expunged objects.
1510 */
1512 }
1517 }
1522 /*
1523 * allow this to make it possible for dbcheck
1524 * to rebuild broken metadata
1525 */
1527 }
1528 }
1531 /*
1532 * First check if we find it under the msDS-IntID,
1533 * then check if we find it under the OID and
1534 * prefixMap ID.
1535 *
1536 * This allows the administrator to simply re-write
1537 * the attributes and so restore replication, which is
1538 * likely what they will try to do.
1539 */
1542 }
1546 }
1547 }
1550 /* linked attributes are not stored in
1551 replPropertyMetaData in FL above w2k, but we do
1552 raise the seqnum for the object */
1556 }
1558 }
1561 /* we need to add a new one */
1567 }
1570 }
1572 /* Get a new sequence number from the backend. We only do this
1573 * if we have a change that requires a new
1574 * replPropertyMetaData element
1575 */
1580 }
1581 }
1594 }
1598 /*
1599 * Set the originating_change_time to 29/12/9999 at 23:59:59
1600 * as specified in MS-ADTS 7.1.1.4.2 Deleted Objects Container
1601 */
1605 }
1608 }
1614 /* Force version to 0 to be overriden later via replication */
1616 }
1619 }
1621 /*
1622 * Bump the replPropertyMetaData version on an attribute, and if it
1623 * has changed (or forced by leaving rdn_old NULL), update the value
1624 * in the entry.
1625 *
1626 * This is important, as calling a modify operation may not change the
1627 * version number if the values appear unchanged, but a rename between
1628 * parents bumps this value.
1629 *
1630 */
1637 NTTIME now,
1640 {
1646 rdn_name;
1652 };
1658 };
1664 }
1665 }
1673 }
1676 {
1684 }
1685 }
1687 }
1689 /*
1690 * update the replPropertyMetaData object each time we modify an
1691 * object. This is needed for DRS replication, as the merge on the
1692 * client is based on this object
1693 */
1701 {
1706 NTTIME now;
1725 }
1731 }
1739 }
1744 }
1748 /* this happens during an initial vampire while
1749 updating the schema */
1752 }
1760 }
1763 }
1765 /* if isDeleted is present and is TRUE, then we consider we are deleting,
1766 * otherwise we consider we are updating */
1773 }
1776 /* In this case the change_replmetadata control was supplied */
1777 /* We check that it's the only attribute that is provided
1778 * (it's a rare case so it's better to keep the code simplier)
1779 * We also check that the highest local_usn is bigger or the same as
1780 * uSNChanged. */
1788 }
1790 DEBUG(0,(__location__ ": changereplmetada control can't be called when deleting an object\n"));
1792 }
1798 }
1805 }
1808 DSDB_FLAG_NEXT_MODULE |
1809 DSDB_SEARCH_SHOW_RECYCLED |
1810 DSDB_SEARCH_SHOW_EXTENDED_DN |
1811 DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT |
1816 }
1823 /*
1824 * The test here now allows for a new
1825 * replPropertyMetaData with no change, if was
1826 * just dbcheck re-sorting the values.
1827 */
1833 }
1834 }
1837 /* search for the existing replPropertyMetaDataBlob. We need
1838 * to use REVEAL and ask for DNs in storage format to support
1839 * the check for values being the same in
1840 * replmd_update_rpmd_element()
1841 */
1843 DSDB_FLAG_NEXT_MODULE |
1844 DSDB_SEARCH_SHOW_RECYCLED |
1845 DSDB_SEARCH_SHOW_EXTENDED_DN |
1846 DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT |
1850 }
1857 }
1865 }
1871 }
1880 our_invocation_id,
1882 is_forced_rodc,
1883 req);
1886 }
1890 }
1893 i++;
1895 }
1900 i++;
1902 }
1905 }
1906 }
1908 /*
1909 * Assert that we have an objectClass attribute - this is major
1910 * corruption if we don't have this!
1911 */
1914 /*
1915 * Now check if this objectClass means we need to do urgent replication
1916 */
1918 situation)) {
1920 }
1926 }
1928 /*
1929 * replmd_update_rpmd_element has done an update if the
1930 * seq_num is set
1931 */
1936 /*if we are RODC and this is a DRSR update then its ok*/
1945 }
1951 }
1952 }
1958 }
1964 }
1972 }
1979 }
1983 }
1986 }
1989 {
1994 }
1996 }
1998 /*
1999 get a series of message element values as an array of DNs and GUIDs
2000 the result is sorted by GUID
2001 */
2005 {
2013 }
2019 }
2023 NTSTATUS status;
2032 }
2039 /* we got a DN without a GUID - go find the GUID */
2047 dn_str);
2052 }
2054 }
2058 }
2061 }
2066 }
2067 }
2068 /* keep a pointer to the original ldb_val */
2070 }
2073 }
2075 }
2077 /*
2078 * Get a series of trusted message element values. The result is sorted by
2079 * GUID, even though the GUIDs might not be known. That works because we trust
2080 * the database to give us the elements like that if the
2081 * replmd_private->sorted_links flag is set.
2082 *
2083 * We also ensure that the links are in the Functional Level 2003
2084 * linked attributes format.
2085 */
2093 {
2099 }
2102 /* We need to sort the list. This is the slow old path we want
2103 to avoid.
2104 */
2106 parent);
2109 }
2111 /* Here we get a list of 'struct parsed_dns' without the parsing */
2117 }
2121 }
2122 }
2124 /*
2125 * This upgrades links to FL2003 style, and sorts the result
2126 * if that was needed.
2127 *
2128 * TODO: Add a database feature that asserts we have no FL2000
2129 * style links to avoid this check or add a feature that
2130 * uses a similar check to find sorted/unsorted links
2131 * for an on-the-fly upgrade.
2132 */
2136 el,
2137 ldap_oid);
2140 }
2143 }
2145 /*
2146 Return LDB_SUCCESS if a parsed_dn list contains no duplicate values,
2147 otherwise an error code. For compatibility the error code differs depending
2148 on whether or not the attribute is "member".
2150 As always, the parsed_dn list is assumed to be sorted.
2151 */
2155 {
2163 "Linked attribute %s has "
2170 }
2171 }
2172 }
2174 }
2176 /*
2177 build a new extended DN, including all meta data fields
2179 RMD_FLAGS = DSDB_RMD_FLAG_* bits
2180 RMD_ADDTIME = originating_add_time
2181 RMD_INVOCID = originating_invocation_id
2182 RMD_CHANGETIME = originating_change_time
2183 RMD_ORIGINATING_USN = originating_usn
2184 RMD_LOCAL_USN = local_usn
2185 RMD_VERSION = version
2186 */
2191 {
2195 }
2197 static int replmd_update_la_val(TALLOC_CTX *mem_ctx, struct ldb_val *v, struct dsdb_dn *dsdb_dn,
2202 /*
2203 check if any links need upgrading from w2k format
2204 */
2209 {
2213 NTSTATUS status;
2218 ldap_oid);
2221 }
2222 }
2227 /*
2228 * We optimistically assume they are all the same; if
2229 * the first one is fixed, they are all fixed.
2230 *
2231 * If the first one was *not* fixed and we find a
2232 * later one that is, that is an occasion to shout
2233 * with DEBUG(0).
2234 */
2237 }
2241 }
2247 }
2248 }
2251 /* it's an old one that needs upgrading */
2257 }
2258 }
2260 /*
2261 * This sort() is critical for the operation of
2262 * get_parsed_dns_trusted() because callers of this function
2263 * expect a sorted list, and FL2000 style links are not
2264 * sorted. In particular, as well as the upgrade case,
2265 * get_parsed_dns_trusted() is called from
2266 * replmd_delete_remove_link() even in FL2000 mode
2267 *
2268 * We do not normally pay the cost of the qsort() due to the
2269 * early return in the RMD_VERSION found case.
2270 */
2273 }
2275 /*
2276 Sets the value for a linked attribute, including all meta data fields
2278 see replmd_build_la_val for value names
2279 */
2284 {
2292 NTSTATUS status;
2301 }
2307 }
2313 }
2319 }
2324 }
2330 /* get the ADDTIME from the original */
2334 }
2337 }
2342 }
2344 /* use our invocation id */
2348 /* changetime is the current time */
2352 /* update the USN */
2367 }
2371 }
2373 /**
2374 * Updates the value for a linked attribute, including all meta data fields
2375 */
2376 static int replmd_update_la_val(TALLOC_CTX *mem_ctx, struct ldb_val *v, struct dsdb_dn *dsdb_dn,
2380 {
2383 NTSTATUS status;
2385 /*
2386 * We're updating the linked attribute locally, so increase the version
2387 * by 1 so that other DCs will see the change when it gets replicated out
2388 */
2394 }
2398 }
2400 /*
2401 handle adding a linked attribute
2402 */
2414 {
2425 NTTIME now;
2432 }
2434 /* get the DNs to be added, fully parsed.
2435 *
2436 * We need full parsing because they came off the wire and we don't
2437 * trust them, besides which we need their details to know where to put
2438 * them.
2439 */
2445 }
2447 /* get the existing DNs, lazily parsed */
2455 }
2464 }
2472 }
2474 /*
2475 * For each new value, find where it would go in the list. If there is
2476 * a matching GUID there, we update the existing value; otherwise we
2477 * put it in place.
2478 */
2494 }
2497 /*
2498 * We are trying to add one that exists, which is only
2499 * allowed if it was previously deleted.
2500 *
2501 * When we do undelete a link we change it in place.
2502 * It will be copied across into the right spot in due
2503 * course.
2504 */
2511 "Attribute %s already "
2517 /* error codes for 'member' need to be
2518 special cased */
2523 }
2524 }
2534 }
2537 schema,
2538 msg_dn,
2541 schema_attr,
2542 parent);
2546 }
2548 }
2549 /*
2550 * Here we don't have an exact match.
2551 *
2552 * If next is NULL, this one goes beyond the end of the
2553 * existing list, so we need to add all of those ones first.
2554 *
2555 * If next is not NULL, we need to add all the ones before
2556 * next.
2557 */
2561 /* next should have been parsed, but let's make sure */
2567 }
2568 }
2570 }
2572 /* put all the old ones before next on the list */
2575 num_values++;
2576 }
2582 parent);
2583 /* Make the new linked attribute ldb_val. */
2590 }
2591 num_values++;
2595 }
2596 }
2597 /* copy the rest of the old ones (if any) */
2600 num_values++;
2601 }
2606 }
2612 /* we now tell the backend to replace all existing values
2613 with the one we have constructed */
2617 }
2620 /*
2621 handle deleting all active linked attributes
2622 */
2634 {
2645 NTTIME now;
2652 }
2655 /* there is nothing to delete... */
2657 /* and we're deleting nothing, so that's OK */
2659 }
2661 }
2666 }
2673 }
2682 }
2689 }
2690 }
2692 /* we empty out el->values here to avoid damage if we return early. */
2696 /*
2697 * If vanish links is set, we are actually removing members of
2698 * old_el->values; otherwise we are just marking them deleted.
2699 *
2700 * There is a special case when no values are given: we remove them
2701 * all. When we have the vanish_links control we just have to remove
2702 * the backlinks and change our element to replace the existing values
2703 * with the empty list.
2704 */
2714 }
2715 }
2719 parent);
2723 }
2726 }
2731 }
2740 }
2741 }
2747 }
2748 }
2757 NULL,
2765 }
2778 }
2779 }
2789 "attribute %s to %s, because "
2792 }
2793 }
2795 /* remove the backlink */
2797 replmd_private,
2798 schema,
2799 msg_dn,
2802 parent);
2806 }
2808 /* We flag the deletion and tidy it up later. */
2811 }
2827 }
2828 }
2837 }
2842 parent);
2846 }
2847 }
2858 }
2862 }
2864 j++;
2865 }
2868 }
2870 }
2877 /* we now tell the backend to replace all existing values
2878 with the one we have constructed */
2882 }
2884 /*
2885 handle replacing a linked attribute
2886 */
2898 {
2910 NTTIME now;
2917 }
2919 /*
2920 * The replace operation is unlike the replace and delete cases in that
2921 * we need to look at every existing link to see whether it is being
2922 * retained or deleted. In other words, we can't avoid parsing the GUIDs.
2923 *
2924 * As we are trying to combine two sorted lists, the algorithm we use
2925 * is akin to the merge phase of a merge sort. We interleave the two
2926 * lists, doing different things depending on which side the current
2927 * item came from.
2928 *
2929 * There are three main cases, with some sub-cases.
2930 *
2931 * - a DN is in the old list but not the new one. It needs to be
2932 * marked as deleted (but left in the list).
2933 * - maybe it is already deleted, and we have less to do.
2934 *
2935 * - a DN is in both lists. The old data gets replaced by the new,
2936 * and the list doesn't grow. The old link may have been marked as
2937 * deleted, in which case we undelete it.
2938 *
2939 * - a DN is in the new list only. We add it in the right place.
2940 */
2947 /* There is nothing to do! */
2949 }
2955 }
2961 }
2968 }
2975 }
2982 }
2994 /* the new list is empty, read the old list */
2999 /* the old list is empty, read new list */
3005 }
3008 /*
3009 * An old ones that come before the next replacement
3010 * (if any). We mark it as deleted and add it to the
3011 * final list.
3012 */
3018 invocation_id,
3024 }
3027 schema,
3028 msg_dn,
3030 schema_attr,
3031 parent);
3035 }
3036 }
3038 old_i++;
3040 /*
3041 * We are overwriting one. If it was previously
3042 * deleted, we need to add a backlink.
3043 *
3044 * Note that if any RMD_FLAGs in an extended new DN
3045 * will be ignored.
3046 */
3052 invocation_id,
3058 }
3063 schema,
3064 msg_dn,
3066 schema_attr,
3067 parent);
3071 }
3072 }
3075 old_i++;
3076 new_i++;
3078 /*
3079 * Replacements that don't match an existing one. We
3080 * just add them to the final list.
3081 */
3085 invocation_id,
3090 }
3092 schema,
3093 msg_dn,
3095 schema_attr,
3096 parent);
3100 }
3102 new_i++;
3103 }
3104 }
3107 }
3115 }
3118 /*
3119 handle linked attributes in modify requests
3120 */
3127 {
3135 /*
3136 * Nothing special is required for modifying or vanishing links
3137 * in fl2000 since they are just strings in a multi-valued
3138 * attribute.
3139 */
3141 DSDB_CONTROL_REPLMD_VANISH_LINKS);
3144 }
3146 }
3148 /*
3149 * TODO:
3150 *
3151 * We should restrict this to the intersection of the list of
3152 * linked attributes in the schema and the list of attributes
3153 * being modified.
3154 *
3155 * This will help performance a little, as otherwise we have
3156 * to allocate the entire object value-by-value.
3157 */
3159 DSDB_FLAG_NEXT_MODULE |
3160 DSDB_SEARCH_SHOW_RECYCLED |
3161 DSDB_SEARCH_REVEAL_INTERNALS |
3162 DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT,
3163 parent);
3166 }
3181 }
3184 }
3190 DSDB_CONTROL_REPLMD_VANISH_LINKS);
3194 }
3196 DSDB_CONTROL_DBCHECK);
3199 }
3200 }
3202 /* Odd is for the target. Illegal to modify */
3206 }
3214 parent);
3221 parent);
3228 parent);
3235 }
3240 /* Return codes as found on Windows 2012r2 */
3245 }
3248 }
3252 }
3255 }
3260 /* TODO: this relises a bit too heavily on the exact
3261 behaviour of ldb_msg_find_element and
3262 ldb_msg_remove_element */
3266 i--;
3267 }
3268 }
3272 }
3278 {
3284 WERROR werr;
3297 server_dn);
3298 }
3299 }
3303 }
3306 domain,
3311 }
3314 }
3318 {
3335 /* do not manipulate our control entries */
3338 }
3341 DSDB_CONTROL_SEC_DESC_PROPAGATION_OID);
3345 }
3350 }
3353 }
3358 DSDB_CONTROL_DBCHECK_FIX_DUPLICATE_LINKS);
3365 }
3369 }
3374 }
3380 }
3384 }
3388 }
3391 DSDB_CONTROL_DBCHECK_FIX_LINK_DN_NAME);
3398 }
3402 }
3406 }
3410 }
3414 }
3419 }
3424 }
3430 }
3434 }
3438 }
3440 /*
3441 * If we are run from dbcheck and we are not updating
3442 * a link (as these would need to be sorted and so
3443 * can't go via such a simple update, then do not
3444 * trigger replicated updates and a new USN from this
3445 * change, it wasn't a real change, just a new
3446 * (correct) string DN
3447 */
3451 }
3460 }
3465 }
3469 /* we have to copy the message as the caller might have it as a const */
3475 }
3490 }
3495 }
3502 }
3504 /* TODO:
3505 * - replace the old object with the newly constructed one
3506 */
3511 msg,
3514 req);
3519 }
3521 /* current partition control is needed by "replmd_op_callback" */
3524 DSDB_CONTROL_CURRENT_PARTITION_OID,
3529 }
3530 }
3532 /* If we are in functional level 2000, then
3533 * replmd_modify_handle_linked_attribs will have done
3534 * nothing */
3540 }
3541 }
3545 /* we only change whenChanged and uSNChanged if the seq_num
3546 has changed */
3553 }
3560 }
3561 }
3563 /* go on with the call chain */
3565 }
3569 /*
3570 handle a rename request
3572 On a rename we need to do an extra ldb_modify which sets the
3573 whenChanged and uSNChanged attributes. We do this in a callback after the success.
3574 */
3576 {
3582 /* do not manipulate our control entries */
3585 }
3594 }
3606 }
3608 /* go on with the call chain */
3610 }
3612 /* After the rename is compleated, update the whenchanged etc */
3614 {
3637 }
3644 LDB_ERR_OPERATIONS_ERROR);
3645 }
3647 /* TODO:
3648 * - replace the old object with the newly constructed one
3649 */
3655 }
3666 }
3668 /* normalize the rdn attribute name */
3674 }
3682 }
3688 }
3693 }
3698 }
3703 }
3705 /*
3706 * here we let replmd_update_rpmd() only search for
3707 * the existing "replPropertyMetaData" and rdn_name attributes.
3708 *
3709 * We do not want the existing "name" attribute as
3710 * the "name" attribute needs to get the version
3711 * updated on rename even if the rdn value hasn't changed.
3712 *
3713 * This is the diff of the meta data, for a moved user
3714 * on a w2k8r2 server:
3715 *
3716 * # record 1
3717 * -dn: CN=sdf df,CN=Users,DC=bla,DC=base
3718 * +dn: CN=sdf df,OU=TestOU,DC=bla,DC=base
3719 * replPropertyMetaData: NDR: struct replPropertyMetaDataBlob
3720 * version : 0x00000001 (1)
3721 * reserved : 0x00000000 (0)
3722 * @@ -66,11 +66,11 @@ replPropertyMetaData: NDR: struct re
3723 * local_usn : 0x00000000000037a5 (14245)
3724 * array: struct replPropertyMetaData1
3725 * attid : DRSUAPI_ATTID_name (0x90001)
3726 * - version : 0x00000001 (1)
3727 * - originating_change_time : Wed Feb 9 17:20:49 2011 CET
3728 * + version : 0x00000002 (2)
3729 * + originating_change_time : Wed Apr 6 15:21:01 2011 CEST
3730 * originating_invocation_id: 0d36ca05-5507-4e62-aca3-354bab0d39e1
3731 * - originating_usn : 0x00000000000037a5 (14245)
3732 * - local_usn : 0x00000000000037a5 (14245)
3733 * + originating_usn : 0x0000000000003834 (14388)
3734 * + local_usn : 0x0000000000003834 (14388)
3735 * array: struct replPropertyMetaData1
3736 * attid : DRSUAPI_ATTID_userAccountControl (0x90008)
3737 * version : 0x00000004 (4)
3738 */
3752 }
3757 }
3764 }
3768 msg,
3771 req);
3776 }
3778 /* current partition control is needed by "replmd_op_callback" */
3781 DSDB_CONTROL_CURRENT_PARTITION_OID,
3786 }
3787 }
3796 }
3803 }
3805 /* go on with the call chain - do the modify after the rename */
3807 }
3809 /*
3810 * remove links from objects that point at this object when an object
3811 * is deleted. We remove it from the NEXT module per MS-DRSR 5.160
3812 * RemoveObj which states that link removal due to the object being
3813 * deleted is NOT an originating update - they just go away!
3814 *
3815 */
3824 {
3847 }
3853 }
3855 /* remove the link */
3861 }
3869 }
3878 }
3882 DSDB_FLAG_NEXT_MODULE |
3883 DSDB_SEARCH_SHOW_EXTENDED_DN |
3884 DSDB_SEARCH_SHOW_RECYCLED,
3885 parent);
3890 }
3898 }
3900 /*
3901 * This call 'upgrades' the links in link_dns, but we
3902 * do not commit the result back into the database, so
3903 * this is safe to call in FL2000 or on databases that
3904 * have been run at that level in the past.
3905 */
3912 }
3922 }
3926 "Failed to find forward link on %s "
3934 }
3937 /* This needs to get the Binary DN, by first searching */
3945 /*
3946 * Ensure that we tell the modification to vanish any linked
3947 * attributes (not simply mark them as isDeleted = TRUE)
3948 */
3955 }
3956 }
3959 }
3962 /*
3963 handle update of replication meta data for deletion of objects
3965 This also handles the mapping of delete to a rename operation
3966 to allow deletes to be replicated.
3968 It also handles the incoming deleted objects, to ensure they are
3969 fully deleted here. In that case re_delete is true, and we do not
3970 use this as a signal to change the deleted state, just reinforce it.
3972 */
3973 static int replmd_delete_internals(struct ldb_module *module, struct ldb_request *req, bool re_delete)
3974 {
3988 /* yes, this really is a hard coded list. See MS-ADTS
3989 section 3.1.1.5.5.1.1 */
4031 NULL
4032 };
4034 DSDB_SECRET_ATTRIBUTES,
4036 NULL
4037 };
4041 };
4050 }
4052 /*
4053 * We have to allow dbcheck to remove an object that
4054 * is beyond repair, and to do so totally. This could
4055 * mean we we can get a partial object from the other
4056 * DC, causing havoc, so dbcheck suggests
4057 * re-replication first. dbcheck sets both DBCHECK
4058 * and RELAX in this situation.
4059 */
4062 /* really, really remove it */
4064 }
4070 }
4076 }
4080 /* we need the complete msg off disk, so we can work out which
4081 attributes need to be removed */
4083 DSDB_FLAG_NEXT_MODULE |
4084 DSDB_SEARCH_SHOW_RECYCLED |
4085 DSDB_SEARCH_REVEAL_INTERNALS |
4095 }
4102 /* This supports us noticing an incoming isDeleted and acting on it */
4106 }
4109 /*
4110 * We have to prevent objects being deleted, even if
4111 * the administrator really wants them gone, as
4112 * without the tombstone, we can get a partial object
4113 * from the other DC, causing havoc.
4114 *
4115 * The only other valid case is when the 180 day
4116 * timeout has expired, when relax is specified.
4117 */
4119 /* it is already deleted - really remove it this time */
4122 }
4128 }
4135 }
4142 }
4146 /* consider the SYSTEM_FLAG_DISALLOW_MOVE_ON_DELETE flag */
4147 disallow_move_on_delete =
4151 /* work out where we will be renaming this object to */
4157 /*
4158 * We should not move objects if we can't find the
4159 * deleted objects DN. Not moving (or otherwise
4160 * harming) the Deleted Objects DN itself is handled
4161 * in the caller.
4162 */
4169 }
4171 /* this is probably an attempted delete on a partition
4172 * that doesn't allow delete operations, such as the
4173 * schema partition */
4180 }
4187 }
4188 }
4190 /* get the objects GUID from the search we just did */
4197 ldb,
4198 new_dn,
4200 guid);
4205 }
4214 }
4217 /*
4218 * No matter what has happened with other renames etc, try again to
4219 * get this to be under the deleted DN. See MS-DRSR 5.160 RemoveObj
4220 */
4230 }
4241 }
4242 }
4244 /*
4245 now we need to modify the object in the following ways:
4247 - add isDeleted=TRUE
4248 - update rDN and name, with new rDN
4249 - remove linked attributes
4250 - remove objectCategory and sAMAccountType
4251 - remove attribs not on the preserved list
4252 - preserved if in above list, or is rDN
4253 - remove all linked attribs from this object
4254 - remove all links from other objects to this object
4255 - add lastKnownParent
4256 - update replPropertyMetaData?
4258 see MS-ADTS "Tombstone Requirements" section 3.1.1.5.5.1.1
4259 */
4266 /* we need the storage form of the parent GUID */
4269 DSDB_FLAG_NEXT_MODULE |
4270 DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT |
4271 DSDB_SEARCH_REVEAL_INTERNALS|
4275 "repmd_delete: Failed to %s %s, "
4283 }
4285 /*
4286 * Now we can use the DB version,
4287 * it will have the extended DN info in it
4288 */
4291 parent_dn,
4296 }
4299 parent_dn_str);
4302 ": Failed to add lastKnownParent "
4307 }
4313 }
4320 ": Failed to add msDS-LastKnownRDN "
4325 }
4331 }
4333 }
4334 }
4341 /*
4342 * MS-ADTS 3.1.1.5.5.1.1 Tombstone Requirements
4343 * describes what must be removed from a tombstone
4344 * object
4345 *
4346 * MS-ADTS 3.1.1.5.5.1.3 Recycled-Object Requirements
4347 * describes what must be removed from a recycled
4348 * object
4349 *
4350 */
4352 /*
4353 * we also mark it as recycled, meaning this object can't be
4354 * recovered (we are stripping its attributes).
4355 * This is done only if we have this schema object of course ...
4356 * This behavior is identical to the one of Windows 2008R2 which
4357 * always set the isRecycled attribute, even if the recycle-bin is
4358 * not activated and what ever the forest level is.
4359 */
4370 }
4372 }
4376 /* work out which of the old attributes we will be removing */
4384 }
4386 /* don't remove the rDN */
4388 }
4391 /*
4392 we have a backlink in this object
4393 that needs to be removed. We're not
4394 allowed to remove it directly
4395 however, so we instead setup a
4396 modify to delete the corresponding
4397 forward link
4398 */
4400 replmd_private,
4404 /*
4405 * now we continue, which means we
4406 * won't remove this backlink
4407 * directly
4408 */
4410 }
4416 __location__
4417 ": Failed to remove backlink of "
4420 old_dn_str,
4424 }
4426 /*
4427 * Otherwise vanish the link, we are
4428 * out of sync and the controlling
4429 * object does not have the source
4430 * link any more
4431 */
4438 }
4441 }
4443 /*
4444 * Ensure that we tell the modification to vanish any linked
4445 * attributes (not simply mark them as isDeleted = TRUE)
4446 */
4448 }
4454 }
4455 }
4460 /*
4461 * MS-ADTS 3.1.1.5.5.1.2 Deleted-Object Requirements
4462 * describes what must be removed from a deleted
4463 * object
4464 */
4471 }
4478 }
4484 }
4489 /* work out what the new rdn value is, for updating the
4490 rDN and name fields */
4495 }
4501 }
4508 }
4517 }
4519 }
4520 }
4522 /*
4523 * TODO: Per MS-DRSR 5.160 RemoveObj we should remove links directly, not as an originating update!
4524 *
4525 */
4527 /*
4528 * No matter what has happned with other renames, try again to
4529 * get this to be under the deleted DN.
4530 */
4532 /* now rename onto the new DN */
4541 }
4543 }
4551 }
4556 }
4559 {
4561 }
4565 {
4567 }
4569 static int replmd_replicated_request_werror(struct replmd_replicated_request *ar, WERROR status)
4570 {
4572 /* TODO: do some error mapping */
4574 /* Let the caller know the full WERROR */
4578 }
4584 {
4591 }
4592 }
4594 }
4597 /*
4598 return true if an update is newer than an existing entry
4599 see section 5.11 of MS-ADTS
4600 */
4605 NTTIME current_change_time,
4606 NTTIME update_change_time)
4607 {
4610 }
4613 }
4615 }
4619 {
4626 }
4631 {
4634 /*
4635 * If the new replPropertyMetaData entry for this attribute is
4636 * not provided (this happens in the case where we look for
4637 * ATTID_name, but the name was not changed), then the local
4638 * state is clearly still current, as the remote
4639 * server didn't send it due to being older the high watermark
4640 * USN we sent.
4641 */
4644 }
4647 /*
4648 * if we compare equal then do an
4649 * update. This is used when a client
4650 * asks for a FULL_SYNC, and can be
4651 * used to recover a corrupt
4652 * replica.
4653 *
4654 * This call is a bit tricky, what we
4655 * are doing it turning the 'is_newer'
4656 * call into a 'not is older' by
4657 * swapping cur_m and new_m, and negating the
4658 * outcome.
4659 */
4661 cur_m);
4664 new_m);
4665 }
4667 }
4670 /*
4671 form a DN for a deleted (DEL:) or conflict (CNF:) DN
4672 */
4680 {
4694 }
4696 /*
4697 * TODO: Per MS-ADTS 3.1.1.5.5 Delete Operation
4698 * we should truncate this value to ensure the RDN is not more than 255 chars.
4699 *
4700 * However we MS-ADTS 3.1.1.5.1.2 Naming Constraints indicates that:
4701 *
4702 * "Naming constraints are not enforced for replicated
4703 * updates." so this is safe and we don't have to work out not
4704 * splitting a UTF8 char right now.
4705 */
4708 /*
4709 * sizeof(guid_str.buf) will always be longer than
4710 * strlen(guid_str.buf) but we allocate using this and
4711 * waste the trailing bytes to avoid scaring folks
4712 * with memcpy() using strlen() below
4713 */
4715 deleted_child_rdn_val.data
4725 }
4734 /*
4735 * talloc won't allocate more than 256MB so we can't
4736 * overflow but just to be sure
4737 */
4740 }
4749 /* Now set the value into the RDN, without parsing it */
4751 dn,
4753 rdn_name,
4754 deleted_child_rdn_val);
4757 }
4760 /*
4761 form a conflict DN
4762 */
4767 {
4777 }
4782 }
4787 rdn_name,
4788 rdn_val,
4792 }
4794 }
4796 /*
4797 form a deleted DN
4798 */
4805 {
4809 rdn_name,
4810 rdn_value,
4811 guid);
4812 }
4815 /*
4816 perform a modify operation which sets the rDN and name attributes to
4817 their current values. This has the effect of changing these
4818 attributes to have been last updated by the current DC. This is
4819 needed to ensure that renames performed as part of conflict
4820 resolution are propagated to other DCs
4821 */
4824 {
4834 }
4840 }
4842 /* normalize the rdn attribute name */
4846 }
4852 }
4856 }
4859 }
4862 }
4865 }
4867 /*
4868 * We have to mark this as a replicated update otherwise
4869 * schema_data may reject a rename in the schema partition
4870 */
4874 req);
4880 }
4886 failed:
4891 }
4894 /*
4895 callback for conflict DN handling where we have renamed the incoming
4896 record. After renaming it, we need to ensure the change of name and
4897 rDN for the incoming record is seen as an originating update by this DC.
4899 This also handles updating lastKnownParent for entries sent to lostAndFound
4900 */
4902 {
4909 /* call the normal callback for everything except success */
4911 }
4922 }
4924 /* perform a modify of the rDN and name of the record */
4929 }
4936 }
4941 ldb_dn_get_extended_linearized(msg, ar->objs->objects[ar->index_current].last_known_parent, 1));
4946 }
4955 }
4957 }
4960 }
4962 /*
4963 callback for replmd_replicated_apply_add()
4964 This copes with the creation of conflict records in the case where
4965 the DN exists, but with a different objectGUID
4966 */
4967 static int replmd_op_possible_conflict_callback(struct ldb_request *req, struct ldb_reply *ares, int (*callback)(struct ldb_request *req, struct ldb_reply *ares))
4968 {
4983 /* call the normal callback for success */
4986 }
4988 /*
4989 * we have a conflict, and need to decide if we will keep the
4990 * new record or the old record
4991 */
4996 /* For failures other than conflicts, fail the whole operation here */
4998 ldb_asprintf_errstring(ldb_module_get_ctx(ar->module), "Failed to locally apply remote add of %s: %s",
5003 LDB_ERR_OPERATIONS_ERROR);
5004 }
5008 ldb_asprintf_errstring(ldb_module_get_ctx(ar->module), "Failed to determine if we are an RODC when attempting to form conflict DN: %s", ldb_errstring(ldb_module_get_ctx(ar->module)));
5010 LDB_ERR_OPERATIONS_ERROR);
5012 }
5015 /*
5016 * We are on an RODC, or were a GC for this
5017 * partition, so we have to fail this until
5018 * someone who owns the partition sorts it
5019 * out
5020 */
5022 "Conflict adding object '%s' from incoming replication as we are read only for the partition. \n"
5027 }
5029 /*
5030 * first we need the replPropertyMetaData attribute from the
5031 * local, conflicting record
5032 */
5034 attrs,
5035 DSDB_FLAG_NEXT_MODULE |
5036 DSDB_SEARCH_SHOW_DELETED |
5042 }
5049 }
5057 }
5061 /*
5062 * we decide which is newer based on the RPMD on the name
5063 * attribute. See [MS-DRSR] ResolveNameConflict.
5064 *
5065 * We expect omd_name to be present, as this is from a local
5066 * search, but while rmd_name should have been given to us by
5067 * the remote server, if it is missing we just prefer the
5068 * local name in
5069 * replmd_replPropertyMetaData1_new_should_be_taken()
5070 */
5074 DEBUG(0,(__location__ ": Failed to find name attribute in local LDB replPropertyMetaData for %s\n",
5077 }
5079 /*
5080 * Should we preserve the current record, and so rename the
5081 * incoming record to be a conflict?
5082 */
5083 rename_incoming_record
5084 = !replmd_replPropertyMetaData1_new_should_be_taken(ar->objs->dsdb_repl_flags & DSDB_REPL_FLAG_PRIORITISE_INCOMING,
5096 }
5104 }
5109 /* re-submit the request, but with the new DN */
5113 /* we are renaming the existing record */
5122 }
5131 }
5144 }
5146 /*
5147 * now we need to ensure that the rename is seen as an
5148 * originating update. We do that with a modify.
5149 */
5153 }
5155 DEBUG(2,(__location__ ": With conflicting record renamed, re-apply replicated creation of '%s'\n",
5157 }
5161 req,
5162 msg,
5164 ar,
5165 callback,
5166 req);
5169 }
5172 /* current partition control needed by "repmd_op_callback" */
5174 DSDB_CONTROL_CURRENT_PARTITION_OID,
5178 }
5181 /* this tells the partition module to make it a
5182 partial replica if creating an NC */
5184 DSDB_CONTROL_PARTIAL_REPLICA,
5188 }
5189 }
5191 /*
5192 * Finally we re-run the add, otherwise the new record won't
5193 * exist, as we are here because of that exact failure!
5194 */
5196 failed:
5198 /* on failure make the caller get the error. This means
5199 * replication will stop with an error, but there is not much
5200 * else we can do.
5201 */
5204 }
5206 ret);
5207 }
5209 /*
5210 callback for replmd_replicated_apply_add()
5211 This copes with the creation of conflict records in the case where
5212 the DN exists, but with a different objectGUID
5213 */
5215 {
5220 /* This is like a conflict DN, where we put the object in LostAndFound
5221 see MS-DRSR 4.1.10.6.10 FindBestParentObject */
5223 }
5226 }
5228 /*
5229 this is called when a new object comes in over DRS
5230 */
5232 {
5243 NTTIME now;
5259 }
5266 }
5268 ret = ldb_msg_add_string(msg, "whenChanged", ar->objs->objects[ar->index_current].when_changed);
5271 }
5276 }
5281 }
5283 /* remove any message elements that have zero values */
5293 }
5299 i--;
5301 }
5302 }
5308 LDB_CHANGETYPE_ADD,
5309 msg);
5312 s));
5319 }
5323 /*
5324 * the meta data array is already sorted by the caller, except
5325 * for the RDN, which needs to be added.
5326 */
5334 ldb_asprintf_errstring(ldb, "%s: error during DRS repl ADD: %s", __func__, ldb_errstring(ldb));
5336 }
5340 ldb_asprintf_errstring(ldb, "%s: error during DRS repl ADD: %s", __func__, ldb_errstring(ldb));
5342 }
5346 }
5352 }
5356 }
5366 }
5367 }
5372 ldb,
5373 ar,
5374 msg,
5376 ar,
5377 replmd_op_add_callback,
5382 /* current partition control needed by "repmd_op_callback" */
5384 DSDB_CONTROL_CURRENT_PARTITION_OID,
5389 /* this tells the partition module to make it a
5390 partial replica if creating an NC */
5392 DSDB_CONTROL_PARTIAL_REPLICA,
5395 }
5398 }
5402 {
5409 LDB_ERR_OPERATIONS_ERROR);
5410 }
5412 /*
5413 * The error NO_SUCH_OBJECT is not expected, unless the search
5414 * base is the partition DN, and that case doesn't happen here
5415 * because then we wouldn't get a parent_guid_value in any
5416 * case.
5417 */
5421 }
5425 {
5433 /* Per MS-DRSR 4.1.10.6.10
5434 * FindBestParentObject we need to move this
5435 * new object under a deleted object to
5436 * lost-and-found */
5442 "No suitable NC root found for %s. "
5443 "We need to move this object because parent object %s "
5450 "Unable to find NC root for %s: %s. "
5451 "We need to move this object because parent object %s "
5457 }
5460 nc_root,
5461 DS_GUID_LOSTANDFOUND_CONTAINER,
5465 "Unable to find LostAndFound Container for %s "
5466 "in partition %s: %s. "
5467 "We need to move this object because parent object %s "
5473 }
5478 parent_dn
5481 }
5489 }
5490 }
5494 }
5496 }
5498 /* we ignore referrals */
5515 }
5517 /*
5518 * This error code is really important, as it
5519 * is the flag back to the callers to retry
5520 * this with DRSUAPI_DRS_GET_ANC, and so get
5521 * the parent objects before the child
5522 * objects
5523 */
5526 }
5532 }
5535 }
5536 }
5540 }
5542 /*
5543 * Look for the parent object, so we put the new object in the right
5544 * place This is akin to NameObject in MS-DRSR - this routine and the
5545 * callbacks find the right parent name, and correct name for this
5546 * object
5547 */
5550 {
5566 }
5567 }
5576 ldb,
5577 ar,
5579 LDB_SCOPE_SUBTREE,
5580 filter,
5581 attrs,
5582 NULL,
5583 ar,
5584 replmd_replicated_apply_search_for_parent_callback,
5589 DSDB_SEARCH_SHOW_RECYCLED|
5590 DSDB_SEARCH_SHOW_DELETED|
5591 DSDB_SEARCH_SHOW_EXTENDED_DN);
5594 }
5597 }
5599 /*
5600 handle renames that come in over DRS replication
5601 */
5606 {
5631 }
5635 ldb_asprintf_errstring(ldb_module_get_ctx(ar->module), "Failed to locally apply remote rename from %s to %s: %s",
5640 }
5648 }
5649 /*
5650 * we have a conflict, and need to decide if we will keep the
5651 * new record or the old record
5652 */
5657 /*
5658 * We are on an RODC, or were a GC for this
5659 * partition, so we have to fail this until
5660 * someone who owns the partition sorts it
5661 * out
5662 */
5664 "Conflict adding object '%s' from incoming replication but we are read only for the partition. \n"
5669 }
5671 /*
5672 * first we need the replPropertyMetaData attribute from the
5673 * old record
5674 */
5676 attrs,
5677 DSDB_FLAG_NEXT_MODULE |
5678 DSDB_SEARCH_SHOW_DELETED |
5684 }
5691 }
5699 }
5703 /*
5704 * we decide which is newer based on the RPMD on the name
5705 * attribute. See [MS-DRSR] ResolveNameConflict.
5706 *
5707 * We expect omd_name to be present, as this is from a local
5708 * search, but while rmd_name should have been given to us by
5709 * the remote server, if it is missing we just prefer the
5710 * local name in
5711 * replmd_replPropertyMetaData1_new_should_be_taken()
5712 */
5716 DEBUG(0,(__location__ ": Failed to find name attribute in local LDB replPropertyMetaData for %s\n",
5719 }
5721 /*
5722 * Should we preserve the current record, and so rename the
5723 * incoming record to be a conflict?
5724 */
5725 rename_incoming_record =
5742 }
5754 }
5759 }
5761 /* we are renaming the existing record */
5768 }
5777 }
5790 }
5792 /*
5793 * now we need to ensure that the rename is seen as an
5794 * originating update. We do that with a modify.
5795 */
5799 }
5801 DEBUG(2,(__location__ ": With conflicting record renamed, re-apply replicated rename '%s' -> '%s'\n",
5814 }
5818 failed:
5819 /*
5820 * On failure make the caller get the error
5821 * This means replication will stop with an error,
5822 * but there is not much else we can do. In the
5823 * LDB_ERR_ENTRY_ALREADY_EXISTS case this is exactly what is
5824 * needed.
5825 */
5828 }
5832 }
5836 {
5859 NTSTATUS nt_status;
5864 NTTIME now;
5877 /* find existing meta data */
5885 }
5889 }
5890 }
5901 s,
5909 rmd)));
5918 }
5925 /*
5926 * Fill in the remote_parent_guid with the GUID or an all-zero
5927 * GUID.
5928 */
5933 }
5935 /*
5936 * To ensure we follow a complex rename chain around, we have
5937 * to confirm that the DN is the same (mostly to confirm the
5938 * RDN) and the parentGUID is the same.
5939 *
5940 * This ensures we keep things under the correct parent, which
5941 * replmd_replicated_handle_rename() will do.
5942 */
5948 /*
5949 * handle renames, even just by case that come in over
5950 * DRS. Changes in the parent DN don't hit us here,
5951 * because the search for a parent will clean up those
5952 * components.
5953 *
5954 * We also have already filtered out the case where
5955 * the peer has an older name to what we have (see
5956 * replmd_replicated_apply_search_callback())
5957 */
5959 }
5968 }
5971 /*
5972 * Set the callback to one that will fix up the name
5973 * metadata on the new conflict DN
5974 */
5976 }
5986 /* first copy the old meta data */
5989 ni++;
5990 }
5993 /* now merge in the new meta data */
6002 }
6009 /* replace the entry */
6015 }
6016 }
6027 }
6030 }
6037 }
6039 /* we don't want to apply this change so remove the attribute */
6041 removed_attrs++;
6045 }
6054 }
6055 }
6066 }
6067 ni++;
6068 }
6070 /*
6071 * finally correct the size of the meta_data array
6072 */
6083 ldb_asprintf_errstring(ldb, "%s: error during DRS repl merge: %s", __func__, ldb_errstring(ldb));
6085 }
6086 }
6087 /*
6088 * sort the new meta data array
6089 */
6092 ldb_asprintf_errstring(ldb, "%s: error during DRS repl merge: %s", __func__, ldb_errstring(ldb));
6094 }
6096 /*
6097 * Work out if this object is deleted, so we can prune any extra attributes. See MS-DRSR 4.1.10.6.9
6098 * UpdateObject.
6099 *
6100 * This also controls SD propagation below
6101 */
6106 }
6110 /*
6111 * check if some replicated attributes left, otherwise skip the ldb_modify() call
6112 */
6118 }
6125 }
6133 }
6134 }
6136 /* create the meta data value */
6142 }
6144 /*
6145 * when we know that we'll modify the record, add the whenChanged, uSNChanged
6146 * and replPopertyMetaData attributes
6147 */
6148 ret = ldb_msg_add_string(msg, "whenChanged", ar->objs->objects[ar->index_current].when_changed);
6151 }
6155 }
6159 }
6163 /* we want to replace the old values */
6172 }
6173 }
6174 }
6180 LDB_CHANGETYPE_MODIFY,
6181 msg);
6185 s));
6194 }
6197 ldb,
6198 ar,
6199 msg,
6201 ar,
6202 callback,
6207 /* current partition control needed by "repmd_op_callback" */
6209 DSDB_CONTROL_CURRENT_PARTITION_OID,
6214 }
6218 {
6225 LDB_ERR_OPERATIONS_ERROR);
6226 }
6231 }
6239 /* we ignore referrals */
6243 {
6255 /*
6256 * This is the ADD case, find the appropriate parent,
6257 * as this object doesn't exist locally:
6258 */
6263 }
6266 }
6268 /*
6269 * Otherwise, in the MERGE case, work out if we are
6270 * attempting a rename, and if so find the parent the
6271 * newly renamed object wants to belong under (which
6272 * may not be the parent in it's attached string DN
6273 */
6278 /* find existing meta data */
6287 }
6291 }
6292 }
6300 "as local object has an all-zero parentGUID attribute, "
6304 }
6306 /*
6307 * now we need to check for double renames. We could have a
6308 * local rename pending which our replication partner hasn't
6309 * received yet. We choose which one wins by looking at the
6310 * attribute stamps on the two objects, the newer one wins.
6311 *
6312 * This also simply applies the correct algorithms for
6313 * determining if a change was made to name at all, or
6314 * if the object has just been renamed under the same
6315 * parent.
6316 */
6320 DEBUG(0,(__location__ ": Failed to find name attribute in local LDB replPropertyMetaData for %s\n",
6323 }
6325 /*
6326 * if there is no name attribute given then we have to assume the
6327 * object we've received has the older name
6328 */
6336 /* Merge on the existing object, with rename */
6351 /*
6352 * Merge on the existing object, force no
6353 * rename (code below just to explain why in
6354 * the DEBUG() logs)
6355 */
6369 }
6378 }
6379 /*
6380 * This assignment ensures that the strcmp()
6381 * and GUID_equal() calls in
6382 * replmd_replicated_apply_merge() avoids the
6383 * rename call
6384 */
6390 }
6393 }
6394 }
6395 }
6399 }
6401 /**
6402 * Stores the linked attributes received in the replication chunk - these get
6403 * applied at the end of the transaction. We also check that each linked
6404 * attribute is valid, i.e. source and target objects are known.
6405 */
6407 {
6419 /* save away the linked attributes for the end of the transaction */
6425 }
6430 }
6436 }
6440 /* we need to steal the non-scalars so they stay
6441 around until the end of the transaction */
6449 }
6452 }
6455 }
6460 {
6474 /*
6475 * Now that we've applied all the objects, check the new linked
6476 * attributes and store them (we apply them in .prepare_commit)
6477 */
6482 }
6484 /* done applying objects, move on to the next stage */
6486 }
6499 ldb,
6500 ar,
6502 LDB_SCOPE_SUBTREE,
6503 filter,
6504 attrs,
6505 NULL,
6506 ar,
6507 replmd_replicated_apply_search_callback,
6515 }
6518 }
6520 /*
6521 * This is essentially a wrapper for replmd_replicated_apply_next()
6522 *
6523 * This is needed to ensure that both codepaths call this handler.
6524 */
6526 {
6531 if (ar->isDeleted && (ret != LDB_SUCCESS || ldb_dn_compare(msg->dn, deleted_objects_dn) != 0)) {
6532 /*
6533 * Do a delete here again, so that if there is
6534 * anything local that conflicts with this
6535 * object being deleted, it is removed. This
6536 * includes links. See MS-DRSR 4.1.10.6.9
6537 * UpdateObject.
6538 *
6539 * If the object is already deleted, and there
6540 * is no more work required, it doesn't do
6541 * anything.
6542 */
6544 /* This has been updated to point to the DN we eventually did the modify on */
6553 }
6560 }
6562 /* Build a delete request, which hopefully will artually turn into nothing */
6565 NULL,
6566 res,
6567 ldb_modify_default_callback,
6573 }
6575 /*
6576 * This is the guts of the call, call back
6577 * into our delete code, but setting the
6578 * re_delete flag so we delete anything that
6579 * shouldn't be there on a deleted or recycled
6580 * object
6581 */
6585 }
6590 }
6591 }
6595 }
6599 {
6607 LDB_ERR_OPERATIONS_ERROR);
6608 }
6612 }
6617 LDB_ERR_OPERATIONS_ERROR);
6618 }
6623 }
6626 {
6645 NTTIME now;
6659 /* this happens for a REPL_OBJ call where we are
6660 creating the target object by replicating it. The
6661 subdomain join code does this for the partition DN
6662 */
6665 }
6672 }
6674 /*
6675 * first create the new replUpToDateVector
6676 */
6684 }
6688 }
6689 }
6691 /*
6692 * the new uptodateness vector will at least
6693 * contain 1 entry, one for the source_dsa
6694 *
6695 * plus optional values from our old vector and the one from the source_dsa
6696 */
6702 if (!nuv.ctr.ctr2.cursors) return replmd_replicated_request_werror(ar, WERR_NOT_ENOUGH_MEMORY);
6704 /* first copy the old vector */
6707 ni++;
6708 }
6710 /* merge in the source_dsa vector is available */
6717 }
6723 }
6729 }
6731 }
6735 /* if it's not there yet, add it */
6737 ni++;
6738 }
6740 /*
6741 * finally correct the size of the cursors array
6742 */
6745 /*
6746 * sort the cursors
6747 */
6750 /*
6751 * create the change ldb_message
6752 */
6762 }
6766 }
6769 /*
6770 * now create the new repsFrom value from the given repsFromTo1 structure
6771 */
6779 /*
6780 * first see if we already have a repsFrom value for the current source dsa
6781 * if so we'll later replace this value
6782 */
6796 }
6800 }
6802 /*
6803 * we compare the source dsa objectGUID not the invocation_id
6804 * because we want only one repsFrom value per source dsa
6805 * and when the invocation_id of the source dsa has changed we don't need
6806 * the old repsFrom with the old invocation_id
6807 */
6812 }
6817 }
6819 /*
6820 * copy over all old values to the new ldb_message
6821 */
6825 }
6827 /*
6828 * if we haven't found an old repsFrom value for the current source dsa
6829 * we'll add a new value
6830 */
6838 }
6840 /* we now fill the value which is already attached to ldb_message */
6847 }
6849 /*
6850 * the ldb_message_element for the attribute, has all the old values and the new one
6851 * so we'll replace the whole attribute with all values
6852 */
6857 LDB_CHANGETYPE_MODIFY,
6858 msg);
6861 }
6863 /* prepare the ldb_modify() request */
6865 ldb,
6866 ar,
6867 msg,
6869 ar,
6870 replmd_replicated_uptodate_modify_callback,
6876 }
6880 {
6887 LDB_ERR_OPERATIONS_ERROR);
6888 }
6893 }
6901 /* we ignore referrals */
6908 }
6909 }
6913 }
6917 {
6927 NULL
6928 };
6933 /*
6934 * Let the caller know that we did an originating updates
6935 */
6939 ldb,
6940 ar,
6942 LDB_SCOPE_BASE,
6944 attrs,
6945 NULL,
6946 ar,
6947 replmd_replicated_uptodate_search_callback,
6953 }
6957 static int replmd_extended_replicated_objects(struct ldb_module *module, struct ldb_request *req)
6958 {
6971 ldb_debug(ldb, LDB_DEBUG_FATAL, "replmd_extended_replicated_objects: invalid extended data\n");
6973 }
6976 ldb_debug(ldb, LDB_DEBUG_FATAL, "replmd_extended_replicated_objects: extended data invalid version [%u != %u]\n",
6979 }
6985 /* Set the flags to have the replmd_op_callback run over the full set of objects */
6994 }
7002 }
7007 }
7009 /* If this change contained linked attributes in the body
7010 * (rather than in the links section) we need to update
7011 * backlinks in linked_attributes */
7015 }
7021 }
7023 /**
7024 * Checks how to handle an missing target - either we need to fail the
7025 * replication and retry with GET_TGT, ignore the link and continue, or try to
7026 * add a partial link to an unknown target.
7027 */
7037 {
7041 /*
7042 * we may not be able to resolve link targets properly when
7043 * dealing with subsets of objects, e.g. the source is a
7044 * critical object and the target isn't
7045 *
7046 * TODO:
7047 * When we implement Trusted Domains we need to consider
7048 * whether they get treated as an incomplete replica here or not
7049 */
7052 /*
7053 * Ignore the link. We don't increase the highwater-mark in
7054 * the object subset cases, so subsequent replications should
7055 * resolve any missing links
7056 */
7062 }
7066 /*
7067 * target should already be up-to-date so there's no point in
7068 * retrying. This could be due to bad timing, or if a target
7069 * on a one-way link was deleted. We ignore the link rather
7070 * than failing the replication cycle completely
7071 */
7077 }
7080 mem_ctx,
7081 source_dn,
7082 target_dn);
7084 /* fail the replication and retry with GET_TGT */
7086 missing_str,
7091 }
7093 /*
7094 * The target of the cross-partition link is missing. Continue
7095 * and try to at least add the forward-link. This isn't great,
7096 * but a partial link can be fixed by dbcheck, so it's better
7097 * than dropping the link completely.
7098 */
7103 /*
7104 * Only log this when we're actually committing the objects.
7105 * This avoids spurious logs, i.e. if we're just verifying the
7106 * received link during a join.
7107 */
7111 }
7114 }
7116 /**
7117 * Checks that the target object for a linked attribute exists.
7118 * @param guid returns the target object's GUID (is returned)if it exists)
7119 * @param ignore_link set to true if the linked attribute should be ignored
7120 * (i.e. the target doesn't exist, but that it's OK to skip the link)
7121 */
7129 {
7135 NTSTATUS ntstatus;
7145 /*
7146 * This strange behaviour (allowing a NULL/missing
7147 * GUID) originally comes from:
7148 *
7149 * commit e3054ce0fe0f8f62d2f5b2a77893e7a1479128bd
7150 * Author: Andrew Tridgell <tridge@samba.org>
7151 * Date: Mon Dec 21 21:21:55 2009 +1100
7152 *
7153 * s4-drs: cope better with NULL GUIDS from DRS
7154 *
7155 * It is valid to get a NULL GUID over DRS for a deleted forward link. We
7156 * need to match by DN if possible when seeing if we should update an
7157 * existing link.
7158 *
7159 * Pair-Programmed-With: Andrew Bartlett <abartlet@samba.org>
7160 */
7163 DSDB_FLAG_NEXT_MODULE |
7164 DSDB_SEARCH_SHOW_RECYCLED |
7165 DSDB_SEARCH_SEARCH_ALL_PARTITIONS |
7166 DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT,
7167 NULL);
7169 ldb_asprintf_errstring(ldb, "Failed to find GUID in linked attribute 0x%x blob for %s from %s",
7178 attrs,
7179 DSDB_FLAG_NEXT_MODULE |
7180 DSDB_SEARCH_SHOW_RECYCLED |
7181 DSDB_SEARCH_SEARCH_ALL_PARTITIONS |
7182 DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT,
7183 NULL,
7186 }
7194 }
7198 /*
7199 * target object is unknown. Check whether to ignore the link,
7200 * fail the replication, or add a partial link
7201 */
7216 /* Get the object's state (i.e. Not Deleted, Tombstone, etc) */
7220 /*
7221 * Check for deleted objects as per MS-DRSR 4.1.10.6.14
7222 * ProcessLinkValue(). Link updates should not be sent for
7223 * recycled and tombstone objects (deleting the links should
7224 * happen when we delete the object). This probably means our
7225 * copy of the target object isn't up to date.
7226 */
7229 /*
7230 * target object is deleted. Check whether to ignore the
7231 * link, fail the replication, or add a partial link
7232 */
7238 }
7239 }
7243 }
7245 /**
7246 * Extracts the key details about the source/target object for a
7247 * linked-attribute entry.
7248 * This returns the following details:
7249 * @param ret_attr the schema details for the linked attribute
7250 * @param source_msg the search result for the source object
7251 * @param target_dsdb_dn the unpacked DN info for the target object
7252 */
7259 {
7265 WERROR status;
7269 /*
7270 linked_attributes[0]:
7271 &objs->linked_attributes[i]: struct drsuapi_DsReplicaLinkedAttribute
7272 identifier : *
7273 identifier: struct drsuapi_DsReplicaObjectIdentifier
7274 __ndr_size : 0x0000003a (58)
7275 __ndr_size_sid : 0x00000000 (0)
7276 guid : 8e95b6a9-13dd-4158-89db-3220a5be5cc7
7277 sid : S-0-0
7278 __ndr_size_dn : 0x00000000 (0)
7279 dn : ''
7280 attid : DRSUAPI_ATTID_member (0x1F)
7281 value: struct drsuapi_DsAttributeValue
7282 __ndr_size : 0x0000007e (126)
7283 blob : *
7284 blob : DATA_BLOB length=126
7285 flags : 0x00000001 (1)
7286 1: DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE
7287 originating_add_time : Wed Sep 2 22:20:01 2009 EST
7288 meta_data: struct drsuapi_DsReplicaMetaData
7289 version : 0x00000015 (21)
7290 originating_change_time : Wed Sep 2 23:39:07 2009 EST
7291 originating_invocation_id: 794640f3-18cf-40ee-a211-a93992b67a64
7292 originating_usn : 0x000000000001e19c (123292)
7294 (for cases where the link is to a normal DN)
7295 &target: struct drsuapi_DsReplicaObjectIdentifier3
7296 __ndr_size : 0x0000007e (126)
7297 __ndr_size_sid : 0x0000001c (28)
7298 guid : 7639e594-db75-4086-b0d4-67890ae46031
7299 sid : S-1-5-21-2848215498-2472035911-1947525656-19924
7300 __ndr_size_dn : 0x00000022 (34)
7301 dn : 'CN=UOne,OU=TestOU,DC=vsofs8,DC=com'
7302 */
7304 /* find the attribute being modified */
7313 }
7315 /*
7316 * All attributes listed here must be dealt with in some way
7317 * by replmd_process_linked_attribute() otherwise in the case
7318 * of isDeleted: FALSE the modify will fail with:
7319 *
7320 * Failed to apply linked attribute change 'attribute 'isDeleted':
7321 * invalid modify flags on
7322 * 'CN=g1_1527570609273,CN=Users,DC=samba,DC=example,DC=com':
7323 * 0x0'
7324 *
7325 * This is becaue isDeleted is a Boolean, so FALSE is a
7326 * legitimate value (set by Samba's deletetest.py)
7327 */
7333 /*
7334 * get the existing message from the db for the object with
7335 * this GUID, returning attribute being modified. We will then
7336 * use this msg as the basis for a modify call
7337 */
7339 DSDB_FLAG_NEXT_MODULE |
7340 DSDB_SEARCH_SEARCH_ALL_PARTITIONS |
7341 DSDB_SEARCH_SHOW_RECYCLED |
7342 DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT |
7343 DSDB_SEARCH_REVEAL_INTERNALS,
7344 NULL,
7348 }
7353 }
7357 /* the value blob for the attribute holds the target object DN */
7365 }
7370 }
7372 /**
7373 * Verifies the source and target objects are known for a linked attribute
7374 */
7377 {
7390 /*
7391 * When we fail to find the source object, the error code we pass
7392 * back here is really important. It flags back to the callers to
7393 * retry this request with DRSUAPI_DRS_GET_ANC. This case should
7394 * never happen if we're replicating from a Samba DC, but it is
7395 * needed to talk to a Windows DC
7396 */
7399 }
7404 }
7406 /*
7407 * We can skip the target object checks if we're only syncing critical
7408 * objects, or we know the target is up-to-date. If either case, we
7409 * still continue even if the target doesn't exist
7410 */
7417 }
7419 /*
7420 * When we fail to find the target object, the error code we pass
7421 * back here is really important. It flags back to the callers to
7422 * retry this request with DRSUAPI_DRS_GET_TGT
7423 */
7426 }
7430 }
7432 /**
7433 * Finds the current active Parsed-DN value for a single-valued linked
7434 * attribute, if one exists.
7435 * @param ret_pdn assigned the active Parsed-DN, or NULL if none was found
7436 * @returns LDB_SUCCESS (regardless of whether a match was found), unless
7437 * an error occurred
7438 */
7445 {
7452 /* nothing to do for multi-valued linked attributes */
7454 }
7460 /* skip any inactive links */
7463 }
7465 /* we've found an active value for this attribute */
7473 }
7476 }
7478 /* no active link found */
7480 }
7482 /**
7483 * @returns true if the replication linked attribute info is newer than we
7484 * already have in our DB
7485 * @param pdn the existing linked attribute info in our DB
7486 * @param la the new linked attribute info received during replication
7487 */
7490 {
7491 /* see if this update is newer than what we have already */
7498 /* no existing info so update is newer */
7500 }
7508 version,
7510 change_time,
7512 }
7514 /**
7515 * Marks an existing linked attribute value as deleted in the DB
7516 * @param pdn the parsed-DN of the target-value to delete
7517 */
7529 {
7532 NTTIME now;
7542 }
7544 /* if the existing link is active, remove its backlink */
7552 }
7553 }
7555 /* mark the existing value as deleted */
7560 }
7562 /**
7563 * Checks for a conflict in single-valued link attributes, and tries to
7564 * resolve the problem if possible.
7565 *
7566 * Single-valued links should only ever have one active value. If we already
7567 * have an active link value, and during replication we receive an active link
7568 * value for a different target DN, then we need to resolve this inconsistency
7569 * and determine which value should be active. If the received info is better/
7570 * newer than the existing link attribute, then we need to set our existing
7571 * link as deleted. If the received info is worse/older, then we should continue
7572 * to add it, but set it as an inactive link.
7573 *
7574 * Note that this is a corner-case that is unlikely to happen (but if it does
7575 * happen, we don't want it to break replication completely).
7576 *
7577 * @param pdn_being_modified the parsed DN corresponding to the received link
7578 * target (note this is NULL if the link does not already exist in our DB)
7579 * @param pdn_list all the source object's Parsed-DNs for this attribute, i.e.
7580 * any existing active or inactive values for the attribute in our DB.
7581 * @param dsdb_dn the target DN for the received link attribute
7582 * @param add_as_inactive gets set to true if the received link is worse than
7583 * the existing link - it should still be added, but as an inactive link.
7584 */
7598 {
7603 /*
7604 * check if there's a conflict for single-valued links, i.e. an active
7605 * linked attribute already exists, but it has a different target value
7606 */
7613 }
7615 /*
7616 * If no active value exists (or the received info is for the currently
7617 * active value), then no conflict exists
7618 */
7621 }
7626 /* Work out how to resolve the conflict based on which info is better */
7634 /*
7635 * Delete our existing active link. The received info will then
7636 * be added (through normal link processing) as the active value
7637 */
7646 }
7652 /*
7653 * we want to keep our existing active link and add the
7654 * received link as inactive
7655 */
7657 }
7660 }
7662 /*
7663 process one linked attribute structure
7664 */
7669 {
7690 /*
7691 * get the attribute being modified, the search result for the source object,
7692 * and the target object's DN details
7693 */
7700 }
7702 /*
7703 * Check for deleted objects per MS-DRSR 4.1.10.6.14
7704 * ProcessLinkValue, because link updates are not applied to
7705 * recycled and tombstone objects. We don't have to delete
7706 * any existing link, that should have happened when the
7707 * object deletion was replicated or initiated.
7708 *
7709 * This needs isDeleted and isRecycled to be included as
7710 * attributes in the search and so in msg if set.
7711 */
7717 }
7719 /*
7720 * Now that we know the deletion_state, remove the extra
7721 * attributes added for that purpose. We need to do this
7722 * otherwise in the case of isDeleted: FALSE the modify will
7723 * fail with:
7724 *
7725 * Failed to apply linked attribute change 'attribute 'isDeleted':
7726 * invalid modify flags on
7727 * 'CN=g1_1527570609273,CN=Users,DC=samba,DC=example,DC=com':
7728 * 0x0'
7729 *
7730 * This is becaue isDeleted is a Boolean, so FALSE is a
7731 * legitimate value (set by Samba's deletetest.py)
7732 */
7744 }
7747 }
7749 /* parse the existing links */
7756 }
7764 }
7766 /*
7767 * there are some cases where the target object doesn't exist, but it's
7768 * OK to ignore the linked attribute
7769 */
7773 }
7775 /* see if this link already exists */
7786 }
7794 }
7796 /* get a seq_num for this change */
7801 }
7803 /*
7804 * check for single-valued link conflicts, i.e. an active linked
7805 * attribute already exists, but it has a different target value
7806 */
7812 seq_num,
7817 }
7818 }
7824 /* remove the existing backlink */
7826 schema,
7829 parent);
7833 }
7834 }
7842 /*
7843 * We know where the new one needs to be, from the *next
7844 * pointer into pdn_list.
7845 */
7854 }
7855 }
7860 }
7861 }
7868 }
7873 }
7879 }
7881 /* set the link attribute's value to the info that was received */
7891 }
7895 /* Set the new link as inactive/deleted to avoid conflicts */
7899 val_to_update);
7904 }
7908 /* if the new link is active, then add the new backlink */
7910 schema,
7913 parent);
7917 }
7918 }
7920 /* we only change whenChanged and uSNChanged if the seq_num
7921 has changed */
7927 }
7934 }
7940 }
7946 }
7955 tmp_ctx,
7956 LDB_CHANGETYPE_MODIFY,
7957 msg));
7960 }
7965 }
7968 {
7971 }
7974 }
7977 /*
7978 we hook into the transaction operations to allow us to
7979 perform the linked attribute updates at the end of the whole
7980 transaction. This allows a forward linked attribute to be created
7981 before the object is created. During a vampire, w2k8 sends us linked
7982 attributes before the objects they are part of.
7983 */
7985 {
7986 /* create our private structure for this transaction */
7991 /* free any leftover mod_usn records from cancelled
7992 transactions */
7997 }
8002 }
8004 /*
8005 on prepare commit we loop over our queued la_context structures and
8006 apply each of them
8007 */
8009 {
8015 /*
8016 * Walk the list of linked attributes from DRS replication.
8017 *
8018 * We walk backwards, to do the first entry first, as we
8019 * added the entries with DLIST_ADD() which puts them at the
8020 * start of the list
8021 */
8030 }
8031 }
8035 /* possibly change @REPLCHANGED */
8039 }
8042 }
8045 {
8051 }
8065 };
8068 {
8071 }