| blob | e3bf0324d7cf5ef022dff5742009f55467bf1f31 |
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 */
53 /*
54 * It's 29/12/9999 at 23:59:59 UTC as specified in MS-ADTS 7.1.1.4.2
55 * Deleted Objects Container
56 */
73 };
78 };
87 /* the controls we pass down */
90 /* details for the mode where we apply a bunch of inbound replication meessages */
102 };
108 };
111 static int replmd_delete_internals(struct ldb_module *module, struct ldb_request *req, bool re_delete);
121 };
129 };
135 {
143 }
145 }
150 }
157 }
159 }
165 }
167 }
172 }
174 }
179 }
185 }
186 }
199 };
201 /* Attributes looked for when updating or deleting, to check for a urgent replication needed */
206 NULL
207 };
212 {
218 }
224 }
225 }
226 }
228 }
231 {
234 }
236 }
241 /*
242 initialise the module
243 allocate the private structure and build the list
244 of partition DNs for use by replmd_notify()
245 */
247 {
260 }
269 }
274 replmd_private->sorted_links
276 SAMBA_COMPATIBLE_FEATURES_ATTR,
277 SAMBA_SORTED_LINKS_FEATURE);
278 }
282 }
284 /*
285 cleanup our per-transaction contexts
286 */
288 {
296 }
304 };
306 /*
307 a ldb_modify request operating on modules below the
308 current module
309 */
313 {
324 }
327 message,
328 NULL,
329 res,
330 ldb_modify_default_callback,
331 parent);
336 }
342 }
344 /* Run the new request */
349 }
353 }
355 /*
356 process a backlinks we accumulated during a transaction, adding and
357 deleting the backlinks from the target objects
358 */
359 static int replmd_process_backlink(struct ldb_module *module, struct la_backlink *bl, struct ldb_request *parent)
360 {
368 /*
369 - find DN of target
370 - find DN of source
371 - construct ldb_message
372 - either an add or a delete
373 */
376 DEBUG(2,(__location__ ": WARNING: Failed to find target DN for linked attribute with GUID %s\n",
379 }
387 }
394 }
396 /* construct a ldb_message for adding/deleting the backlink */
403 }
408 }
411 /* a backlink should never be single valued. Unfortunately the
412 exchange schema has a attribute
413 msExchBridgeheadedLocalConnectorsDNBL which is single
414 valued and a backlink. We need to cope with that by
415 ignoring the single value flag */
420 /* we allow LDB_ERR_NO_SUCH_ATTRIBUTE as success to
421 cope with possible corruption where the backlink has
422 already been removed */
436 }
439 }
441 /*
442 add a backlink to the list of backlinks to add/delete in the prepare
443 commit
444 */
452 {
458 /*
459 * windows 2003 has a broken schema where the
460 * definition of msDS-IsDomainFor is missing (which is
461 * supposed to be the backlink of the
462 * msDS-HasDomainNCs attribute
463 */
465 }
467 /* see if its already in the list */
474 }
475 }
478 /* we found an existing one */
481 }
485 }
492 }
493 }
495 /* its a new one */
500 }
502 /* Ensure the schema does not go away before the bl->attr_name is used */
507 }
514 /* the caller may ask for this backlink to be processed
515 immediately */
520 }
525 }
528 /*
529 * Callback for most write operations in this module:
530 *
531 * notify the repl task that a object has changed. The notifies are
532 * gathered up in the replmd_private structure then written to the
533 * @REPLCHANGED object in each partition during the prepare_commit
534 */
536 {
553 /*
554 * Remove the current partition control from what we pass up
555 * the chain if it hasn't been requested manually.
556 */
558 partition_ctrl);
559 }
565 }
571 }
577 }
587 }
588 }
596 }
602 }
604 }
610 }
611 }
614 }
615 }
621 }
624 /* free the partition control container here, for the
625 * common path. Other cases will have it cleaned up
626 * eventually with the ares */
630 }
631 }
634 /*
635 * update a @REPLCHANGED record in each partition if there have been
636 * any writes of replicated data in the partition
637 */
639 {
654 }
662 DSDB_EXTENDED_SCHEMA_UPDATE_NOW_OID,
663 ext_res,
664 DSDB_FLAG_NEXT_MODULE,
665 parent);
668 }
670 }
674 }
677 }
680 /*
681 created a replmd_replicated_request context
682 */
685 {
696 }
708 }
710 /* get our invocationId */
717 }
721 }
723 /*
724 add a time element to a record
725 */
727 {
734 }
739 }
744 }
747 /* always set as replace. This works because on add ops, the flag
748 is ignored */
752 }
754 /*
755 add a uint64_t element to a record
756 */
759 {
765 }
770 }
773 /* always set as replace. This works because on add ops, the flag
774 is ignored */
778 }
783 {
784 /*
785 * This assignment seems inoccous, but it is critical for the
786 * system, as we need to do the comparisons as a unsigned
787 * quantity, not signed (enums are signed integers)
788 */
794 }
796 /*
797 * See above regarding this being an unsigned comparison.
798 * Otherwise when the high bit is set on non-standard
799 * attributes, they would end up first, before objectClass
800 * (0).
801 */
803 }
808 {
814 }
816 /* the objectClass attribute is value 0x00000000, so must be first */
822 }
825 }
830 {
831 /* Note this is O(n^2) for the almost-sorted case, which this is */
833 replmd_replPropertyMetaData1_attid_sort);
835 }
840 {
844 /*
845 * TODO: make this faster by caching the dsdb_attribute pointer
846 * on the ldb_messag_element
847 */
852 /*
853 * TODO: remove this check, we should rely on e1 and e2 having valid attribute names
854 * in the schema
855 */
858 }
861 }
863 }
867 {
868 LDB_TYPESAFE_QSORT(msg->elements, msg->num_elements, schema, replmd_ldb_message_element_attid_sort);
869 }
879 /*
880 fix up linked attributes in replmd_add.
881 This involves setting up the right meta-data in extended DN
882 components, and creating backlinks to the object
883 */
890 {
895 /* We will take a reference to the schema in replmd_add_backlink */
904 }
911 }
916 invocationId,
921 }
923 /* This is the only place we are doing deferred back-links */
930 }
933 }
938 }
941 /*
942 intercept add requests
943 */
945 {
957 /*
958 * The use of a time_t here seems odd, but as the NTTIME
959 * elements are actually declared as NTTIME_1sec in the IDL,
960 * getting a higher resolution timestamp is not required.
961 */
963 NTTIME now;
977 /* check if there's a show relax control (used by provision to say 'I know what I'm doing') */
981 }
983 /* do not manipulate our control entries */
986 }
1004 }
1005 /* we remove this attribute as it can be a string and
1006 * will not be treated correctly and then we will re-add
1007 * it later on in the good format */
1009 }
1011 /* a new GUID */
1013 }
1018 }
1022 /* Get a sequence number from the backend */
1027 }
1029 /* we have to copy the message as the caller might have it as a const */
1035 }
1037 /* generated times */
1044 }
1047 }
1049 /*
1050 * remove autogenerated attributes
1051 */
1058 /*
1059 * readd replicated attributes
1060 */
1066 }
1068 /* build the replication meta_data */
1079 }
1089 i++;
1091 }
1100 }
1102 if ((sa->systemFlags & DS_FLAG_ATTR_NOT_REPLICATED) || (sa->systemFlags & DS_FLAG_ATTR_IS_CONSTRUCTED)) {
1103 /* if the attribute is not replicated (0x00000001)
1104 * or constructed (0x00000004) it has no metadata
1105 */
1106 i++;
1108 }
1119 }
1120 /* linked attributes are not stored in
1121 replPropertyMetaData in FL above w2k */
1122 i++;
1124 }
1136 }
1140 /*
1141 * Set the originating_change_time to 29/12/9999 at 23:59:59
1142 * as specified in MS-ADTS 7.1.1.4.2 Deleted Objects Container
1143 */
1147 }
1150 }
1154 ni++;
1157 i++;
1159 }
1164 i++;
1166 }
1169 }
1171 /* fix meta data count */
1174 /*
1175 * sort meta data array
1176 */
1182 }
1184 /* generated NDR encoded values */
1192 }
1194 /*
1195 * add the autogenerated values
1196 */
1202 }
1208 }
1214 }
1220 }
1226 }
1228 /*
1229 * sort the attributes by attid before storing the object
1230 */
1233 /*
1234 * Assert that we do have an objectClass
1235 */
1243 }
1245 REPL_URGENT_ON_CREATE);
1249 msg,
1252 req);
1258 }
1260 /* current partition control is needed by "replmd_op_callback" */
1263 DSDB_CONTROL_CURRENT_PARTITION_OID,
1268 }
1269 }
1276 }
1277 }
1279 /* mark the control done */
1282 }
1283 /* go on with the call chain */
1285 }
1288 /*
1289 * update the replPropertyMetaData for one element
1290 */
1299 NTTIME now,
1302 {
1312 /* allow this to make it possible for dbcheck
1313 to remove bad attributes */
1315 }
1320 }
1324 if ((a->systemFlags & DS_FLAG_ATTR_NOT_REPLICATED) || (a->systemFlags & DS_FLAG_ATTR_IS_CONSTRUCTED)) {
1326 }
1328 /*
1329 * if the attribute's value haven't changed, and this isn't
1330 * just a delete of everything then return LDB_SUCCESS Unless
1331 * we have the provision control or if the attribute is
1332 * interSiteTopologyGenerator as this page explain:
1333 * http://support.microsoft.com/kb/224815 this attribute is
1334 * periodicaly written by the DC responsible for the intersite
1335 * generation in a given site
1336 *
1337 * Unchanged could be deleting or replacing an already-gone
1338 * thing with an unconstrained delete/empty replace or a
1339 * replace with the same value, but not an add with the same
1340 * value because that could be about adding a duplicate (which
1341 * is for someone else to error out on).
1342 */
1346 }
1352 }
1355 /*
1356 * We intentionally skip the version bump when attempting to
1357 * vanish links.
1358 *
1359 * The control is set by dbcheck and expunge-tombstones which
1360 * both attempt to be non-replicating. Otherwise, making an
1361 * alteration to the replication state would trigger a
1362 * broadcast of all expunged objects.
1363 */
1365 }
1370 }
1375 /*
1376 * allow this to make it possible for dbcheck
1377 * to rebuild broken metadata
1378 */
1380 }
1381 }
1384 /*
1385 * First check if we find it under the msDS-IntID,
1386 * then check if we find it under the OID and
1387 * prefixMap ID.
1388 *
1389 * This allows the administrator to simply re-write
1390 * the attributes and so restore replication, which is
1391 * likely what they will try to do.
1392 */
1395 }
1399 }
1400 }
1403 /* linked attributes are not stored in
1404 replPropertyMetaData in FL above w2k, but we do
1405 raise the seqnum for the object */
1409 }
1411 }
1414 /* we need to add a new one */
1420 }
1423 }
1425 /* Get a new sequence number from the backend. We only do this
1426 * if we have a change that requires a new
1427 * replPropertyMetaData element
1428 */
1433 }
1434 }
1446 }
1450 /*
1451 * Set the originating_change_time to 29/12/9999 at 23:59:59
1452 * as specified in MS-ADTS 7.1.1.4.2 Deleted Objects Container
1453 */
1457 }
1460 }
1466 }
1468 /*
1469 * Bump the replPropertyMetaData version on an attribute, and if it
1470 * has changed (or forced by leaving rdn_old NULL), update the value
1471 * in the entry.
1472 *
1473 * This is important, as calling a modify operation may not change the
1474 * version number if the values appear unchanged, but a rename between
1475 * parents bumps this value.
1476 *
1477 */
1484 NTTIME now,
1486 {
1492 rdn_name;
1498 };
1504 };
1510 }
1511 }
1518 }
1521 {
1529 }
1530 }
1532 }
1534 /*
1535 * update the replPropertyMetaData object each time we modify an
1536 * object. This is needed for DRS replication, as the merge on the
1537 * client is based on this object
1538 */
1546 {
1551 NTTIME now;
1569 }
1575 }
1581 /* this happens during an initial vampire while
1582 updating the schema */
1585 }
1593 }
1596 }
1598 /* if isDeleted is present and is TRUE, then we consider we are deleting,
1599 * otherwise we consider we are updating */
1606 }
1609 /* In this case the change_replmetadata control was supplied */
1610 /* We check that it's the only attribute that is provided
1611 * (it's a rare case so it's better to keep the code simplier)
1612 * We also check that the highest local_usn is bigger or the same as
1613 * uSNChanged. */
1621 }
1623 DEBUG(0,(__location__ ": changereplmetada control can't be called when deleting an object\n"));
1625 }
1631 }
1638 }
1641 DSDB_FLAG_NEXT_MODULE |
1642 DSDB_SEARCH_SHOW_RECYCLED |
1643 DSDB_SEARCH_SHOW_EXTENDED_DN |
1644 DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT |
1649 }
1656 /*
1657 * The test here now allows for a new
1658 * replPropertyMetaData with no change, if was
1659 * just dbcheck re-sorting the values.
1660 */
1666 }
1667 }
1670 /* search for the existing replPropertyMetaDataBlob. We need
1671 * to use REVEAL and ask for DNs in storage format to support
1672 * the check for values being the same in
1673 * replmd_update_rpmd_element()
1674 */
1676 DSDB_FLAG_NEXT_MODULE |
1677 DSDB_SEARCH_SHOW_RECYCLED |
1678 DSDB_SEARCH_SHOW_EXTENDED_DN |
1679 DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT |
1683 }
1690 }
1698 }
1704 }
1713 our_invocation_id,
1715 req);
1718 }
1722 }
1725 i++;
1727 }
1732 i++;
1734 }
1737 }
1738 }
1740 /*
1741 * Assert that we have an objectClass attribute - this is major
1742 * corruption if we don't have this!
1743 */
1746 /*
1747 * Now check if this objectClass means we need to do urgent replication
1748 */
1750 situation)) {
1752 }
1758 }
1760 /*
1761 * replmd_update_rpmd_element has done an update if the
1762 * seq_num is set
1763 */
1768 /*if we are RODC and this is a DRSR update then its ok*/
1779 }
1785 }
1786 }
1792 }
1798 }
1806 }
1813 }
1817 }
1820 }
1829 };
1831 /* When a parsed_dn comes from the database, sometimes it is not really parsed. */
1835 {
1836 NTSTATUS status;
1838 ldap_oid);
1841 }
1846 }
1849 }
1851 /*
1852 * We choose, as the sort order, the same order as is used in DRS replication,
1853 * which is the memcmp() order of the NDR GUID, not that obtained from
1854 * GUID_compare().
1855 *
1856 * This means that sorted links will be in the same order as a new DC would
1857 * see them.
1858 */
1860 {
1866 /* This can't fail */
1869 /* This can't fail */
1873 }
1876 {
1878 }
1882 {
1883 /*
1884 * This works like a standard compare function in its return values,
1885 * but has an extra trick to deal with errors: zero is returned and
1886 * ctx->err is set to the ldb error code.
1887 *
1888 * That is, if (as is expected in most cases) you get a non-zero
1889 * result, you don't need to check for errors.
1890 *
1891 * We assume the second argument refers to a DN is from the database
1892 * and has a GUID -- but this GUID might not have been parsed out yet.
1893 */
1900 }
1901 }
1903 }
1914 {
1921 }
1924 /*
1925 * When updating a link using DRS, we sometimes get a NULL
1926 * GUID when a forward link has been deleted and its GUID has
1927 * for some reason been forgotten. The best we can do is try
1928 * and match by DN via a linear search. Note that this
1929 * probably only happens in the ADD case, in which we only
1930 * allow modification of link if it is already deleted, so
1931 * this seems very close to an elaborate NO-OP, but we are not
1932 * quite prepared to declare it so.
1933 *
1934 * If the DN is not in our list, we have to add it to the
1935 * beginning of the list, where it would naturally sort.
1936 */
1939 /* We don't know the target DN, so we can't search for DN */
1941 "attribute but we don't have a DN to compare "
1944 }
1959 }
1960 }
1966 }
1967 }
1968 /*
1969 * Here we have a null guid which doesn't match any existing
1970 * link. This is a bit unexpected because null guids occur
1971 * when a forward link has been deleted and we are replicating
1972 * that deletion.
1973 *
1974 * The best thing to do is weep into the logs and add the
1975 * offending link to the beginning of the list which is
1976 * at least the correct sort position.
1977 */
1983 }
1996 }
1998 }
2000 /*
2001 get a series of message element values as an array of DNs and GUIDs
2002 the result is sorted by GUID
2003 */
2007 {
2015 }
2021 }
2025 NTSTATUS status;
2034 }
2041 /* we got a DN without a GUID - go find the GUID */
2050 }
2052 }
2056 }
2059 }
2064 }
2065 }
2066 /* keep a pointer to the original ldb_val */
2068 }
2071 }
2073 }
2075 /*
2076 * Get a series of trusted message element values. The result is sorted by
2077 * GUID, even though the GUIDs might not be known. That works because we trust
2078 * the database to give us the elements like that if the
2079 * replmd_private->sorted_links flag is set.
2080 *
2081 * We also ensure that the links are in the Functional Level 2003
2082 * linked attributes format.
2083 */
2091 {
2097 }
2100 /* We need to sort the list. This is the slow old path we want
2101 to avoid.
2102 */
2104 parent);
2107 }
2109 /* Here we get a list of 'struct parsed_dns' without the parsing */
2115 }
2119 }
2120 }
2122 /*
2123 * This upgrades links to FL2003 style, and sorts the result
2124 * if that was needed.
2125 *
2126 * TODO: Add a database feature that asserts we have no FL2000
2127 * style links to avoid this check or add a feature that
2128 * uses a similar check to find sorted/unsorted links
2129 * for an on-the-fly upgrade.
2130 */
2134 el,
2135 ldap_oid);
2138 }
2141 }
2143 /*
2144 build a new extended DN, including all meta data fields
2146 RMD_FLAGS = DSDB_RMD_FLAG_* bits
2147 RMD_ADDTIME = originating_add_time
2148 RMD_INVOCID = originating_invocation_id
2149 RMD_CHANGETIME = originating_change_time
2150 RMD_ORIGINATING_USN = originating_usn
2151 RMD_LOCAL_USN = local_usn
2152 RMD_VERSION = version
2153 */
2154 static int replmd_build_la_val(TALLOC_CTX *mem_ctx, struct ldb_val *v, struct dsdb_dn *dsdb_dn,
2157 {
2164 NTSTATUS status;
2173 }
2179 }
2185 }
2191 }
2197 }
2202 }
2223 }
2227 }
2229 static int replmd_update_la_val(TALLOC_CTX *mem_ctx, struct ldb_val *v, struct dsdb_dn *dsdb_dn,
2234 /*
2235 check if any links need upgrading from w2k format
2236 */
2241 {
2245 NTSTATUS status;
2250 ldap_oid);
2253 }
2254 }
2259 /*
2260 * We optimistically assume they are all the same; if
2261 * the first one is fixed, they are all fixed.
2262 *
2263 * If the first one was *not* fixed and we find a
2264 * later one that is, that is an occasion to shout
2265 * with DEBUG(0).
2266 */
2269 }
2273 }
2279 }
2280 }
2283 /* it's an old one that needs upgrading */
2289 }
2290 }
2292 /*
2293 * This sort() is critical for the operation of
2294 * get_parsed_dns_trusted() because callers of this function
2295 * expect a sorted list, and FL2000 style links are not
2296 * sorted. In particular, as well as the upgrade case,
2297 * get_parsed_dns_trusted() is called from
2298 * replmd_delete_remove_link() even in FL2000 mode
2299 *
2300 * We do not normally pay the cost of the qsort() due to the
2301 * early return in the RMD_VERSION found case.
2302 */
2305 }
2307 /*
2308 update an extended DN, including all meta data fields
2310 see replmd_build_la_val for value names
2311 */
2312 static int replmd_update_la_val(TALLOC_CTX *mem_ctx, struct ldb_val *v, struct dsdb_dn *dsdb_dn,
2316 {
2325 NTSTATUS status;
2334 }
2340 }
2346 }
2352 }
2357 }
2363 /* get the ADDTIME from the original */
2367 }
2372 }
2374 /* use our invocation id */
2378 /* changetime is the current time */
2382 /* update the USN */
2389 /* increase the version by 1 */
2393 }
2402 }
2406 }
2408 /*
2409 handle adding a linked attribute
2410 */
2422 {
2433 NTTIME now;
2440 }
2442 /* get the DNs to be added, fully parsed.
2443 *
2444 * We need full parsing because they came off the wire and we don't
2445 * trust them, besides which we need their details to know where to put
2446 * them.
2447 */
2453 }
2455 /* get the existing DNs, lazily parsed */
2463 }
2472 }
2480 }
2482 /*
2483 * For each new value, find where it would go in the list. If there is
2484 * a matching GUID there, we update the existing value; otherwise we
2485 * put it in place.
2486 */
2500 }
2503 /*
2504 * We are trying to add one that exists, which is only
2505 * allowed if it was previously deleted.
2506 *
2507 * When we do undelete a link we change it in place.
2508 * It will be copied across into the right spot in due
2509 * course.
2510 */
2517 "Attribute %s already "
2523 /* error codes for 'member' need to be
2524 special cased */
2529 }
2530 }
2540 }
2549 }
2551 }
2552 /*
2553 * Here we don't have an exact match.
2554 *
2555 * If next is NULL, this one goes beyond the end of the
2556 * existing list, so we need to add all of those ones first.
2557 *
2558 * If next is not NULL, we need to add all the ones before
2559 * next.
2560 */
2564 /* next should have been parsed, but let's make sure */
2570 }
2571 }
2573 }
2575 /* put all the old ones before next on the list */
2578 num_values++;
2579 }
2584 /* Make the new linked attribute ldb_val. */
2592 }
2593 num_values++;
2597 }
2598 }
2599 /* copy the rest of the old ones (if any) */
2602 num_values++;
2603 }
2608 }
2614 /* we now tell the backend to replace all existing values
2615 with the one we have constructed */
2619 }
2622 /*
2623 handle deleting all active linked attributes
2624 */
2636 {
2647 NTTIME now;
2654 }
2657 /* there is nothing to delete... */
2659 /* and we're deleting nothing, so that's OK */
2661 }
2663 }
2668 }
2675 }
2684 }
2691 }
2692 }
2694 /* we empty out el->values here to avoid damage if we return early. */
2698 /*
2699 * If vanish links is set, we are actually removing members of
2700 * old_el->values; otherwise we are just marking them deleted.
2701 *
2702 * There is a special case when no values are given: we remove them
2703 * all. When we have the vanish_links control we just have to remove
2704 * the backlinks and change our element to replace the existing values
2705 * with the empty list.
2706 */
2716 }
2717 }
2724 }
2727 }
2732 }
2741 }
2742 }
2748 }
2749 }
2758 NULL,
2764 }
2777 }
2778 }
2788 "attribute %s to %s, because "
2791 }
2792 }
2794 /* remove the backlink */
2796 replmd_private,
2804 }
2806 /* We flag the deletion and tidy it up later. */
2809 }
2825 }
2826 }
2835 }
2842 }
2843 }
2850 j++;
2851 }
2852 }
2854 }
2861 /* we now tell the backend to replace all existing values
2862 with the one we have constructed */
2866 }
2868 /*
2869 handle replacing a linked attribute
2870 */
2882 {
2894 NTTIME now;
2901 }
2903 /*
2904 * The replace operation is unlike the replace and delete cases in that
2905 * we need to look at every existing link to see whether it is being
2906 * retained or deleted. In other words, we can't avoid parsing the GUIDs.
2907 *
2908 * As we are trying to combine two sorted lists, the algorithm we use
2909 * is akin to the merge phase of a merge sort. We interleave the two
2910 * lists, doing different things depending on which side the current
2911 * item came from.
2912 *
2913 * There are three main cases, with some sub-cases.
2914 *
2915 * - a DN is in the old list but not the new one. It needs to be
2916 * marked as deleted (but left in the list).
2917 * - maybe it is already deleted, and we have less to do.
2918 *
2919 * - a DN is in both lists. The old data gets replaced by the new,
2920 * and the list doesn't grow. The old link may have been marked as
2921 * deleted, in which case we undelete it.
2922 *
2923 * - a DN is in the new list only. We add it in the right place.
2924 */
2931 /* There is nothing to do! */
2933 }
2939 }
2946 }
2953 }
2960 }
2972 /* the new list is empty, read the old list */
2977 /* the old list is empty, read new list */
2983 }
2986 /*
2987 * An old ones that come before the next replacement
2988 * (if any). We mark it as deleted and add it to the
2989 * final list.
2990 */
2996 invocation_id,
3002 }
3011 }
3012 }
3014 old_i++;
3016 /*
3017 * We are overwriting one. If it was previously
3018 * deleted, we need to add a backlink.
3019 *
3020 * Note that if any RMD_FLAGs in an extended new DN
3021 * will be ignored.
3022 */
3028 invocation_id,
3034 }
3045 }
3046 }
3049 old_i++;
3050 new_i++;
3052 /*
3053 * Replacements that don't match an existing one. We
3054 * just add them to the final list.
3055 */
3059 invocation_id,
3065 }
3073 }
3075 new_i++;
3076 }
3077 }
3080 }
3088 }
3091 /*
3092 handle linked attributes in modify requests
3093 */
3099 {
3110 /*
3111 * Nothing special is required for modifying or vanishing links
3112 * in fl2000 since they are just strings in a multi-valued
3113 * attribute.
3114 */
3116 DSDB_CONTROL_REPLMD_VANISH_LINKS);
3119 }
3121 }
3123 /*
3124 * TODO:
3125 *
3126 * We should restrict this to the intersection of the list of
3127 * linked attributes in the schema and the list of attributes
3128 * being modified.
3129 *
3130 * This will help performance a little, as otherwise we have
3131 * to allocate the entire object value-by-value.
3132 */
3134 DSDB_FLAG_NEXT_MODULE |
3135 DSDB_SEARCH_SHOW_RECYCLED |
3136 DSDB_SEARCH_REVEAL_INTERNALS |
3137 DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT,
3138 parent);
3141 }
3145 }
3161 }
3164 }
3168 }
3169 /* Odd is for the target. Illegal to modify */
3173 }
3199 }
3207 }
3213 }
3216 }
3221 /* TODO: this relises a bit too heavily on the exact
3222 behaviour of ldb_msg_find_element and
3223 ldb_msg_remove_element */
3227 i--;
3228 }
3229 }
3233 }
3238 {
3253 /* do not manipulate our control entries */
3256 }
3259 DSDB_CONTROL_SEC_DESC_PROPAGATION_OID);
3263 }
3268 }
3271 }
3282 }
3287 }
3291 /* we have to copy the message as the caller might have it as a const */
3297 }
3321 }
3326 }
3333 }
3335 /* TODO:
3336 * - replace the old object with the newly constructed one
3337 */
3342 msg,
3345 req);
3350 }
3352 /* current partition control is needed by "replmd_op_callback" */
3355 DSDB_CONTROL_CURRENT_PARTITION_OID,
3360 }
3361 }
3363 /* If we are in functional level 2000, then
3364 * replmd_modify_handle_linked_attribs will have done
3365 * nothing */
3371 }
3372 }
3376 /* we only change whenChanged and uSNChanged if the seq_num
3377 has changed */
3384 }
3391 }
3392 }
3394 /* go on with the call chain */
3396 }
3400 /*
3401 handle a rename request
3403 On a rename we need to do an extra ldb_modify which sets the
3404 whenChanged and uSNChanged attributes. We do this in a callback after the success.
3405 */
3407 {
3413 /* do not manipulate our control entries */
3416 }
3425 }
3437 }
3439 /* go on with the call chain */
3441 }
3443 /* After the rename is compleated, update the whenchanged etc */
3445 {
3468 }
3475 LDB_ERR_OPERATIONS_ERROR);
3476 }
3478 /* TODO:
3479 * - replace the old object with the newly constructed one
3480 */
3486 }
3497 }
3499 /* normalize the rdn attribute name */
3505 }
3513 }
3519 }
3524 }
3529 }
3534 }
3536 /*
3537 * here we let replmd_update_rpmd() only search for
3538 * the existing "replPropertyMetaData" and rdn_name attributes.
3539 *
3540 * We do not want the existing "name" attribute as
3541 * the "name" attribute needs to get the version
3542 * updated on rename even if the rdn value hasn't changed.
3543 *
3544 * This is the diff of the meta data, for a moved user
3545 * on a w2k8r2 server:
3546 *
3547 * # record 1
3548 * -dn: CN=sdf df,CN=Users,DC=bla,DC=base
3549 * +dn: CN=sdf df,OU=TestOU,DC=bla,DC=base
3550 * replPropertyMetaData: NDR: struct replPropertyMetaDataBlob
3551 * version : 0x00000001 (1)
3552 * reserved : 0x00000000 (0)
3553 * @@ -66,11 +66,11 @@ replPropertyMetaData: NDR: struct re
3554 * local_usn : 0x00000000000037a5 (14245)
3555 * array: struct replPropertyMetaData1
3556 * attid : DRSUAPI_ATTID_name (0x90001)
3557 * - version : 0x00000001 (1)
3558 * - originating_change_time : Wed Feb 9 17:20:49 2011 CET
3559 * + version : 0x00000002 (2)
3560 * + originating_change_time : Wed Apr 6 15:21:01 2011 CEST
3561 * originating_invocation_id: 0d36ca05-5507-4e62-aca3-354bab0d39e1
3562 * - originating_usn : 0x00000000000037a5 (14245)
3563 * - local_usn : 0x00000000000037a5 (14245)
3564 * + originating_usn : 0x0000000000003834 (14388)
3565 * + local_usn : 0x0000000000003834 (14388)
3566 * array: struct replPropertyMetaData1
3567 * attid : DRSUAPI_ATTID_userAccountControl (0x90008)
3568 * version : 0x00000004 (4)
3569 */
3594 }
3599 }
3606 }
3610 msg,
3613 req);
3618 }
3620 /* current partition control is needed by "replmd_op_callback" */
3623 DSDB_CONTROL_CURRENT_PARTITION_OID,
3628 }
3629 }
3638 }
3645 }
3647 /* go on with the call chain - do the modify after the rename */
3649 }
3651 /*
3652 * remove links from objects that point at this object when an object
3653 * is deleted. We remove it from the NEXT module per MS-DRSR 5.160
3654 * RemoveObj which states that link removal due to the object being
3655 * deleted is NOT an originating update - they just go away!
3656 *
3657 */
3666 {
3689 }
3695 }
3697 /* remove the link */
3703 }
3711 }
3720 }
3724 DSDB_FLAG_NEXT_MODULE |
3725 DSDB_SEARCH_SHOW_EXTENDED_DN,
3726 parent);
3731 }
3739 }
3741 /*
3742 * This call 'upgrades' the links in link_dns, but we
3743 * do not commit the result back into the database, so
3744 * this is safe to call in FL2000 or on databases that
3745 * have been run at that level in the past.
3746 */
3753 }
3761 }
3765 "Failed to find forward link on %s "
3773 }
3776 /* This needs to get the Binary DN, by first searching */
3783 /*
3784 * Ensure that we tell the modification to vanish any linked
3785 * attributes (not simply mark them as isDeleted = TRUE)
3786 */
3793 }
3794 }
3797 }
3800 /*
3801 handle update of replication meta data for deletion of objects
3803 This also handles the mapping of delete to a rename operation
3804 to allow deletes to be replicated.
3806 It also handles the incoming deleted objects, to ensure they are
3807 fully deleted here. In that case re_delete is true, and we do not
3808 use this as a signal to change the deleted state, just reinforce it.
3810 */
3811 static int replmd_delete_internals(struct ldb_module *module, struct ldb_request *req, bool re_delete)
3812 {
3826 /* yes, this really is a hard coded list. See MS-ADTS
3827 section 3.1.1.5.5.1.1 */
3869 NULL
3870 };
3872 DSDB_SECRET_ATTRIBUTES,
3874 NULL
3875 };
3883 }
3885 /*
3886 * We have to allow dbcheck to remove an object that
3887 * is beyond repair, and to do so totally. This could
3888 * mean we we can get a partial object from the other
3889 * DC, causing havoc, so dbcheck suggests
3890 * re-replication first. dbcheck sets both DBCHECK
3891 * and RELAX in this situation.
3892 */
3895 /* really, really remove it */
3897 }
3903 }
3909 }
3913 /* we need the complete msg off disk, so we can work out which
3914 attributes need to be removed */
3916 DSDB_FLAG_NEXT_MODULE |
3917 DSDB_SEARCH_SHOW_RECYCLED |
3918 DSDB_SEARCH_REVEAL_INTERNALS |
3928 }
3935 /* This supports us noticing an incoming isDeleted and acting on it */
3939 }
3942 /*
3943 * We have to prevent objects being deleted, even if
3944 * the administrator really wants them gone, as
3945 * without the tombstone, we can get a partial object
3946 * from the other DC, causing havoc.
3947 *
3948 * The only other valid case is when the 180 day
3949 * timeout has expired, when relax is specified.
3950 */
3952 /* it is already deleted - really remove it this time */
3955 }
3961 }
3968 }
3975 }
3979 /* consider the SYSTEM_FLAG_DISALLOW_MOVE_ON_DELETE flag */
3980 disallow_move_on_delete =
3984 /* work out where we will be renaming this object to */
3990 /*
3991 * We should not move objects if we can't find the
3992 * deleted objects DN. Not moving (or otherwise
3993 * harming) the Deleted Objects DN itself is handled
3994 * in the caller.
3995 */
4002 }
4004 /* this is probably an attempted delete on a partition
4005 * that doesn't allow delete operations, such as the
4006 * schema partition */
4013 }
4020 }
4021 }
4023 /* get the objects GUID from the search we just did */
4027 /* Add a formatted child */
4029 rdn_name,
4038 }
4046 }
4049 /*
4050 * No matter what has happened with other renames etc, try again to
4051 * get this to be under the deleted DN. See MS-DRSR 5.160 RemoveObj
4052 */
4062 }
4073 }
4074 }
4076 /*
4077 now we need to modify the object in the following ways:
4079 - add isDeleted=TRUE
4080 - update rDN and name, with new rDN
4081 - remove linked attributes
4082 - remove objectCategory and sAMAccountType
4083 - remove attribs not on the preserved list
4084 - preserved if in above list, or is rDN
4085 - remove all linked attribs from this object
4086 - remove all links from other objects to this object
4087 - add lastKnownParent
4088 - update replPropertyMetaData?
4090 see MS-ADTS "Tombstone Requirements" section 3.1.1.5.5.1.1
4091 */
4097 /* we need the storage form of the parent GUID */
4100 DSDB_FLAG_NEXT_MODULE |
4101 DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT |
4102 DSDB_SEARCH_REVEAL_INTERNALS|
4106 "repmd_delete: Failed to %s %s, "
4114 }
4116 /*
4117 * Now we can use the DB version,
4118 * it will have the extended DN info in it
4119 */
4122 parent_dn,
4127 }
4130 parent_dn_str);
4133 ": Failed to add lastKnownParent "
4138 }
4145 ": Failed to add msDS-LastKnownRDN "
4150 }
4152 }
4153 }
4160 /*
4161 * MS-ADTS 3.1.1.5.5.1.1 Tombstone Requirements
4162 * describes what must be removed from a tombstone
4163 * object
4164 *
4165 * MS-ADTS 3.1.1.5.5.1.3 Recycled-Object Requirements
4166 * describes what must be removed from a recycled
4167 * object
4168 *
4169 */
4171 /*
4172 * we also mark it as recycled, meaning this object can't be
4173 * recovered (we are stripping its attributes).
4174 * This is done only if we have this schema object of course ...
4175 * This behavior is identical to the one of Windows 2008R2 which
4176 * always set the isRecycled attribute, even if the recycle-bin is
4177 * not activated and what ever the forest level is.
4178 */
4186 }
4188 }
4192 /* work out which of the old attributes we will be removing */
4200 }
4202 /* don't remove the rDN */
4204 }
4206 /*
4207 we have a backlink in this object
4208 that needs to be removed. We're not
4209 allowed to remove it directly
4210 however, so we instead setup a
4211 modify to delete the corresponding
4212 forward link
4213 */
4215 replmd_private,
4222 __location__
4223 ": Failed to remove backlink of "
4226 old_dn_str,
4230 }
4231 /* now we continue, which means we
4232 won't remove this backlink
4233 directly
4234 */
4239 }
4242 }
4244 /*
4245 * Ensure that we tell the modification to vanish any linked
4246 * attributes (not simply mark them as isDeleted = TRUE)
4247 */
4249 }
4255 }
4256 }
4261 /*
4262 * MS-ADTS 3.1.1.5.5.1.2 Deleted-Object Requirements
4263 * describes what must be removed from a deleted
4264 * object
4265 */
4272 }
4279 }
4285 }
4290 /* work out what the new rdn value is, for updating the
4291 rDN and name fields */
4296 }
4302 }
4309 }
4318 }
4320 }
4321 }
4323 /*
4324 * TODO: Per MS-DRSR 5.160 RemoveObj we should remove links directly, not as an originating update!
4325 *
4326 */
4328 /*
4329 * No matter what has happned with other renames, try again to
4330 * get this to be under the deleted DN.
4331 */
4333 /* now rename onto the new DN */
4342 }
4344 }
4352 }
4357 }
4360 {
4362 }
4366 {
4368 }
4370 static int replmd_replicated_request_werror(struct replmd_replicated_request *ar, WERROR status)
4371 {
4373 /* TODO: do some error mapping */
4375 /* Let the caller know the full WERROR */
4379 }
4385 {
4392 }
4393 }
4395 }
4398 /*
4399 return true if an update is newer than an existing entry
4400 see section 5.11 of MS-ADTS
4401 */
4406 NTTIME current_change_time,
4407 NTTIME update_change_time)
4408 {
4411 }
4414 }
4416 }
4420 {
4427 }
4432 {
4435 /*
4436 * If the new replPropertyMetaData entry for this attribute is
4437 * not provided (this happens in the case where we look for
4438 * ATTID_name, but the name was not changed), then the local
4439 * state is clearly still current, as the remote
4440 * server didn't send it due to being older the high watermark
4441 * USN we sent.
4442 */
4445 }
4448 /*
4449 * if we compare equal then do an
4450 * update. This is used when a client
4451 * asks for a FULL_SYNC, and can be
4452 * used to recover a corrupt
4453 * replica.
4454 *
4455 * This call is a bit tricky, what we
4456 * are doing it turning the 'is_newer'
4457 * call into a 'not is older' by
4458 * swapping cur_m and new_m, and negating the
4459 * outcome.
4460 */
4462 cur_m);
4465 new_m);
4466 }
4468 }
4471 /*
4472 form a conflict DN
4473 */
4474 static struct ldb_dn *replmd_conflict_dn(TALLOC_CTX *mem_ctx, struct ldb_dn *dn, struct GUID *guid)
4475 {
4484 }
4489 }
4493 }
4496 rdn_name,
4500 }
4503 }
4506 /*
4507 perform a modify operation which sets the rDN and name attributes to
4508 their current values. This has the effect of changing these
4509 attributes to have been last updated by the current DC. This is
4510 needed to ensure that renames performed as part of conflict
4511 resolution are propogated to other DCs
4512 */
4515 {
4525 }
4531 }
4533 /* normalize the rdn attribute name */
4537 }
4543 }
4547 }
4550 }
4553 }
4556 }
4564 }
4570 failed:
4575 }
4578 /*
4579 callback for conflict DN handling where we have renamed the incoming
4580 record. After renaming it, we need to ensure the change of name and
4581 rDN for the incoming record is seen as an originating update by this DC.
4583 This also handles updating lastKnownParent for entries sent to lostAndFound
4584 */
4586 {
4593 /* call the normal callback for everything except success */
4595 }
4606 }
4608 /* perform a modify of the rDN and name of the record */
4613 }
4620 }
4625 ldb_dn_get_extended_linearized(msg, ar->objs->objects[ar->index_current].last_known_parent, 1));
4630 }
4639 }
4641 }
4644 }
4646 /*
4647 callback for replmd_replicated_apply_add()
4648 This copes with the creation of conflict records in the case where
4649 the DN exists, but with a different objectGUID
4650 */
4651 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))
4652 {
4667 /* call the normal callback for success */
4670 }
4672 /*
4673 * we have a conflict, and need to decide if we will keep the
4674 * new record or the old record
4675 */
4680 /* For failures other than conflicts, fail the whole operation here */
4682 ldb_asprintf_errstring(ldb_module_get_ctx(ar->module), "Failed to locally apply remote add of %s: %s",
4687 LDB_ERR_OPERATIONS_ERROR);
4688 }
4692 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)));
4694 LDB_ERR_OPERATIONS_ERROR);
4696 }
4699 /*
4700 * We are on an RODC, or were a GC for this
4701 * partition, so we have to fail this until
4702 * someone who owns the partition sorts it
4703 * out
4704 */
4706 "Conflict adding object '%s' from incoming replication as we are read only for the partition. \n"
4710 }
4712 /*
4713 * first we need the replPropertyMetaData attribute from the
4714 * local, conflicting record
4715 */
4717 attrs,
4718 DSDB_FLAG_NEXT_MODULE |
4719 DSDB_SEARCH_SHOW_DELETED |
4725 }
4732 }
4740 }
4744 /*
4745 * we decide which is newer based on the RPMD on the name
4746 * attribute. See [MS-DRSR] ResolveNameConflict.
4747 *
4748 * We expect omd_name to be present, as this is from a local
4749 * search, but while rmd_name should have been given to us by
4750 * the remote server, if it is missing we just prefer the
4751 * local name in
4752 * replmd_replPropertyMetaData1_new_should_be_taken()
4753 */
4757 DEBUG(0,(__location__ ": Failed to find name attribute in local LDB replPropertyMetaData for %s\n",
4760 }
4762 /*
4763 * Should we preserve the current record, and so rename the
4764 * incoming record to be a conflict?
4765 */
4766 rename_incoming_record
4767 = !replmd_replPropertyMetaData1_new_should_be_taken(ar->objs->dsdb_repl_flags & DSDB_REPL_FLAG_PRIORITISE_INCOMING,
4779 }
4785 }
4790 /* re-submit the request, but with the new DN */
4794 /* we are renaming the existing record */
4803 }
4810 }
4823 }
4825 /*
4826 * now we need to ensure that the rename is seen as an
4827 * originating update. We do that with a modify.
4828 */
4832 }
4834 DEBUG(2,(__location__ ": With conflicting record renamed, re-apply replicated creation of '%s'\n",
4836 }
4840 req,
4841 msg,
4843 ar,
4844 callback,
4845 req);
4848 }
4851 /* current partition control needed by "repmd_op_callback" */
4853 DSDB_CONTROL_CURRENT_PARTITION_OID,
4857 }
4860 /* this tells the partition module to make it a
4861 partial replica if creating an NC */
4863 DSDB_CONTROL_PARTIAL_REPLICA,
4867 }
4868 }
4870 /*
4871 * Finally we re-run the add, otherwise the new record won't
4872 * exist, as we are here because of that exact failure!
4873 */
4875 failed:
4877 /* on failure make the caller get the error. This means
4878 * replication will stop with an error, but there is not much
4879 * else we can do.
4880 */
4882 ret);
4883 }
4885 /*
4886 callback for replmd_replicated_apply_add()
4887 This copes with the creation of conflict records in the case where
4888 the DN exists, but with a different objectGUID
4889 */
4891 {
4896 /* This is like a conflict DN, where we put the object in LostAndFound
4897 see MS-DRSR 4.1.10.6.10 FindBestParentObject */
4899 }
4902 }
4904 /*
4905 this is called when a new object comes in over DRS
4906 */
4908 {
4919 NTTIME now;
4935 }
4942 }
4944 ret = ldb_msg_add_string(msg, "whenChanged", ar->objs->objects[ar->index_current].when_changed);
4947 }
4952 }
4957 }
4959 /* remove any message elements that have zero values */
4969 }
4975 i--;
4977 }
4978 }
4986 s));
4988 }
4993 /*
4994 * the meta data array is already sorted by the caller, except
4995 * for the RDN, which needs to be added.
4996 */
5003 ldb_asprintf_errstring(ldb, "%s: error during DRS repl ADD: %s", __func__, ldb_errstring(ldb));
5005 }
5009 ldb_asprintf_errstring(ldb, "%s: error during DRS repl ADD: %s", __func__, ldb_errstring(ldb));
5011 }
5015 }
5021 }
5025 }
5035 }
5036 }
5041 ldb,
5042 ar,
5043 msg,
5045 ar,
5046 replmd_op_add_callback,
5051 /* current partition control needed by "repmd_op_callback" */
5053 DSDB_CONTROL_CURRENT_PARTITION_OID,
5058 /* this tells the partition module to make it a
5059 partial replica if creating an NC */
5061 DSDB_CONTROL_PARTIAL_REPLICA,
5064 }
5067 }
5071 {
5078 LDB_ERR_OPERATIONS_ERROR);
5079 }
5081 /*
5082 * The error NO_SUCH_OBJECT is not expected, unless the search
5083 * base is the partition DN, and that case doesn't happen here
5084 * because then we wouldn't get a parent_guid_value in any
5085 * case.
5086 */
5090 }
5094 {
5102 /* Per MS-DRSR 4.1.10.6.10
5103 * FindBestParentObject we need to move this
5104 * new object under a deleted object to
5105 * lost-and-found */
5111 "No suitable NC root found for %s. "
5112 "We need to move this object because parent object %s "
5119 "Unable to find NC root for %s: %s. "
5120 "We need to move this object because parent object %s "
5126 }
5129 nc_root,
5130 DS_GUID_LOSTANDFOUND_CONTAINER,
5134 "Unable to find LostAndFound Container for %s "
5135 "in partition %s: %s. "
5136 "We need to move this object because parent object %s "
5142 }
5147 parent_dn
5150 }
5158 }
5159 }
5163 }
5165 }
5167 /* we ignore referrals */
5184 }
5186 /*
5187 * This error code is really important, as it
5188 * is the flag back to the callers to retry
5189 * this with DRSUAPI_DRS_GET_ANC, and so get
5190 * the parent objects before the child
5191 * objects
5192 */
5195 }
5201 }
5204 }
5205 }
5209 }
5211 /*
5212 * Look for the parent object, so we put the new object in the right
5213 * place This is akin to NameObject in MS-DRSR - this routine and the
5214 * callbacks find the right parent name, and correct name for this
5215 * object
5216 */
5219 {
5235 }
5236 }
5245 ldb,
5246 ar,
5248 LDB_SCOPE_SUBTREE,
5249 filter,
5250 attrs,
5251 NULL,
5252 ar,
5253 replmd_replicated_apply_search_for_parent_callback,
5258 DSDB_SEARCH_SHOW_RECYCLED|
5259 DSDB_SEARCH_SHOW_DELETED|
5260 DSDB_SEARCH_SHOW_EXTENDED_DN);
5263 }
5266 }
5268 /*
5269 handle renames that come in over DRS replication
5270 */
5275 {
5300 }
5304 ldb_asprintf_errstring(ldb_module_get_ctx(ar->module), "Failed to locally apply remote rename from %s to %s: %s",
5309 }
5317 }
5318 /*
5319 * we have a conflict, and need to decide if we will keep the
5320 * new record or the old record
5321 */
5326 /*
5327 * We are on an RODC, or were a GC for this
5328 * partition, so we have to fail this until
5329 * someone who owns the partition sorts it
5330 * out
5331 */
5333 "Conflict adding object '%s' from incoming replication but we are read only for the partition. \n"
5337 }
5339 /*
5340 * first we need the replPropertyMetaData attribute from the
5341 * old record
5342 */
5344 attrs,
5345 DSDB_FLAG_NEXT_MODULE |
5346 DSDB_SEARCH_SHOW_DELETED |
5352 }
5359 }
5367 }
5371 /*
5372 * we decide which is newer based on the RPMD on the name
5373 * attribute. See [MS-DRSR] ResolveNameConflict.
5374 *
5375 * We expect omd_name to be present, as this is from a local
5376 * search, but while rmd_name should have been given to us by
5377 * the remote server, if it is missing we just prefer the
5378 * local name in
5379 * replmd_replPropertyMetaData1_new_should_be_taken()
5380 */
5384 DEBUG(0,(__location__ ": Failed to find name attribute in local LDB replPropertyMetaData for %s\n",
5387 }
5389 /*
5390 * Should we preserve the current record, and so rename the
5391 * incoming record to be a conflict?
5392 */
5393 rename_incoming_record =
5408 }
5420 }
5425 }
5427 /* we are renaming the existing record */
5434 }
5441 }
5454 }
5456 /*
5457 * now we need to ensure that the rename is seen as an
5458 * originating update. We do that with a modify.
5459 */
5463 }
5465 DEBUG(2,(__location__ ": With conflicting record renamed, re-apply replicated rename '%s' -> '%s'\n",
5478 }
5479 failed:
5481 /*
5482 * On failure make the caller get the error
5483 * This means replication will stop with an error,
5484 * but there is not much else we can do. In the
5485 * LDB_ERR_ENTRY_ALREADY_EXISTS case this is exactly what is
5486 * needed.
5487 */
5491 }
5495 {
5518 NTSTATUS nt_status;
5523 NTTIME now;
5536 /* find existing meta data */
5544 }
5548 }
5549 }
5559 s,
5567 rmd)));
5569 }
5576 /*
5577 * Fill in the remote_parent_guid with the GUID or an all-zero
5578 * GUID.
5579 */
5584 }
5586 /*
5587 * To ensure we follow a complex rename chain around, we have
5588 * to confirm that the DN is the same (mostly to confirm the
5589 * RDN) and the parentGUID is the same.
5590 *
5591 * This ensures we keep things under the correct parent, which
5592 * replmd_replicated_handle_rename() will do.
5593 */
5599 /*
5600 * handle renames, even just by case that come in over
5601 * DRS. Changes in the parent DN don't hit us here,
5602 * because the search for a parent will clean up those
5603 * components.
5604 *
5605 * We also have already filtered out the case where
5606 * the peer has an older name to what we have (see
5607 * replmd_replicated_apply_search_callback())
5608 */
5610 }
5619 }
5622 /*
5623 * Set the callback to one that will fix up the name
5624 * metadata on the new conflict DN
5625 */
5627 }
5637 /* first copy the old meta data */
5640 ni++;
5641 }
5644 /* now merge in the new meta data */
5653 }
5660 /* replace the entry */
5666 }
5667 }
5678 }
5681 }
5688 }
5690 /* we don't want to apply this change so remove the attribute */
5692 removed_attrs++;
5696 }
5705 }
5706 }
5717 }
5718 ni++;
5719 }
5721 /*
5722 * finally correct the size of the meta_data array
5723 */
5733 ldb_asprintf_errstring(ldb, "%s: error during DRS repl merge: %s", __func__, ldb_errstring(ldb));
5735 }
5736 }
5737 /*
5738 * sort the new meta data array
5739 */
5742 ldb_asprintf_errstring(ldb, "%s: error during DRS repl merge: %s", __func__, ldb_errstring(ldb));
5744 }
5746 /*
5747 * Work out if this object is deleted, so we can prune any extra attributes. See MS-DRSR 4.1.10.6.9
5748 * UpdateObject.
5749 *
5750 * This also controls SD propagation below
5751 */
5756 }
5760 /*
5761 * check if some replicated attributes left, otherwise skip the ldb_modify() call
5762 */
5768 }
5775 }
5783 }
5784 }
5786 /* create the meta data value */
5792 }
5794 /*
5795 * when we know that we'll modify the record, add the whenChanged, uSNChanged
5796 * and replPopertyMetaData attributes
5797 */
5798 ret = ldb_msg_add_string(msg, "whenChanged", ar->objs->objects[ar->index_current].when_changed);
5801 }
5805 }
5809 }
5813 /* we want to replace the old values */
5822 }
5823 }
5824 }
5832 s));
5834 }
5837 ldb,
5838 ar,
5839 msg,
5841 ar,
5842 callback,
5847 /* current partition control needed by "repmd_op_callback" */
5849 DSDB_CONTROL_CURRENT_PARTITION_OID,
5854 }
5858 {
5865 LDB_ERR_OPERATIONS_ERROR);
5866 }
5871 }
5879 /* we ignore referrals */
5883 {
5895 /*
5896 * This is the ADD case, find the appropriate parent,
5897 * as this object doesn't exist locally:
5898 */
5903 }
5906 }
5908 /*
5909 * Otherwise, in the MERGE case, work out if we are
5910 * attempting a rename, and if so find the parent the
5911 * newly renamed object wants to belong under (which
5912 * may not be the parent in it's attached string DN
5913 */
5918 /* find existing meta data */
5927 }
5931 }
5932 }
5940 "as local object has an all-zero parentGUID attribute, "
5944 }
5946 /*
5947 * now we need to check for double renames. We could have a
5948 * local rename pending which our replication partner hasn't
5949 * received yet. We choose which one wins by looking at the
5950 * attribute stamps on the two objects, the newer one wins.
5951 *
5952 * This also simply applies the correct algorithms for
5953 * determining if a change was made to name at all, or
5954 * if the object has just been renamed under the same
5955 * parent.
5956 */
5960 DEBUG(0,(__location__ ": Failed to find name attribute in local LDB replPropertyMetaData for %s\n",
5963 }
5965 /*
5966 * if there is no name attribute given then we have to assume the
5967 * object we've received has the older name
5968 */
5976 /* Merge on the existing object, with rename */
5991 /*
5992 * Merge on the existing object, force no
5993 * rename (code below just to explain why in
5994 * the DEBUG() logs)
5995 */
6009 }
6018 }
6019 /*
6020 * This assignment ensures that the strcmp()
6021 * and GUID_equal() calls in
6022 * replmd_replicated_apply_merge() avoids the
6023 * rename call
6024 */
6030 }
6033 }
6034 }
6035 }
6039 }
6044 {
6057 /* done with it, go to next stage */
6059 }
6072 ldb,
6073 ar,
6075 LDB_SCOPE_SUBTREE,
6076 filter,
6077 attrs,
6078 NULL,
6079 ar,
6080 replmd_replicated_apply_search_callback,
6088 }
6091 }
6093 /*
6094 * This is essentially a wrapper for replmd_replicated_apply_next()
6095 *
6096 * This is needed to ensure that both codepaths call this handler.
6097 */
6099 {
6104 if (ar->isDeleted && (ret != LDB_SUCCESS || ldb_dn_compare(msg->dn, deleted_objects_dn) != 0)) {
6105 /*
6106 * Do a delete here again, so that if there is
6107 * anything local that conflicts with this
6108 * object being deleted, it is removed. This
6109 * includes links. See MS-DRSR 4.1.10.6.9
6110 * UpdateObject.
6111 *
6112 * If the object is already deleted, and there
6113 * is no more work required, it doesn't do
6114 * anything.
6115 */
6117 /* This has been updated to point to the DN we eventually did the modify on */
6126 }
6133 }
6135 /* Build a delete request, which hopefully will artually turn into nothing */
6138 NULL,
6139 res,
6140 ldb_modify_default_callback,
6146 }
6148 /*
6149 * This is the guts of the call, call back
6150 * into our delete code, but setting the
6151 * re_delete flag so we delete anything that
6152 * shouldn't be there on a deleted or recycled
6153 * object
6154 */
6158 }
6163 }
6164 }
6168 }
6172 {
6180 LDB_ERR_OPERATIONS_ERROR);
6181 }
6185 }
6190 LDB_ERR_OPERATIONS_ERROR);
6191 }
6196 }
6199 {
6218 NTTIME now;
6232 /* this happens for a REPL_OBJ call where we are
6233 creating the target object by replicating it. The
6234 subdomain join code does this for the partition DN
6235 */
6238 }
6245 }
6247 /*
6248 * first create the new replUpToDateVector
6249 */
6257 }
6261 }
6262 }
6264 /*
6265 * the new uptodateness vector will at least
6266 * contain 1 entry, one for the source_dsa
6267 *
6268 * plus optional values from our old vector and the one from the source_dsa
6269 */
6275 if (!nuv.ctr.ctr2.cursors) return replmd_replicated_request_werror(ar, WERR_NOT_ENOUGH_MEMORY);
6277 /* first copy the old vector */
6280 ni++;
6281 }
6283 /* merge in the source_dsa vector is available */
6290 }
6296 }
6302 }
6304 }
6308 /* if it's not there yet, add it */
6310 ni++;
6311 }
6313 /*
6314 * finally correct the size of the cursors array
6315 */
6318 /*
6319 * sort the cursors
6320 */
6323 /*
6324 * create the change ldb_message
6325 */
6335 }
6339 }
6342 /*
6343 * now create the new repsFrom value from the given repsFromTo1 structure
6344 */
6352 /*
6353 * first see if we already have a repsFrom value for the current source dsa
6354 * if so we'll later replace this value
6355 */
6369 }
6373 }
6375 /*
6376 * we compare the source dsa objectGUID not the invocation_id
6377 * because we want only one repsFrom value per source dsa
6378 * and when the invocation_id of the source dsa has changed we don't need
6379 * the old repsFrom with the old invocation_id
6380 */
6385 }
6390 }
6392 /*
6393 * copy over all old values to the new ldb_message
6394 */
6398 }
6400 /*
6401 * if we haven't found an old repsFrom value for the current source dsa
6402 * we'll add a new value
6403 */
6411 }
6413 /* we now fill the value which is already attached to ldb_message */
6420 }
6422 /*
6423 * the ldb_message_element for the attribute, has all the old values and the new one
6424 * so we'll replace the whole attribute with all values
6425 */
6432 }
6434 /* prepare the ldb_modify() request */
6436 ldb,
6437 ar,
6438 msg,
6440 ar,
6441 replmd_replicated_uptodate_modify_callback,
6447 }
6451 {
6458 LDB_ERR_OPERATIONS_ERROR);
6459 }
6464 }
6472 /* we ignore referrals */
6479 }
6480 }
6484 }
6488 {
6498 NULL
6499 };
6504 /*
6505 * Let the caller know that we did an originating updates
6506 */
6510 ldb,
6511 ar,
6513 LDB_SCOPE_BASE,
6515 attrs,
6516 NULL,
6517 ar,
6518 replmd_replicated_uptodate_search_callback,
6524 }
6528 static int replmd_extended_replicated_objects(struct ldb_module *module, struct ldb_request *req)
6529 {
6545 ldb_debug(ldb, LDB_DEBUG_FATAL, "replmd_extended_replicated_objects: invalid extended data\n");
6547 }
6550 ldb_debug(ldb, LDB_DEBUG_FATAL, "replmd_extended_replicated_objects: extended data invalid version [%u != %u]\n",
6553 }
6559 /* Set the flags to have the replmd_op_callback run over the full set of objects */
6568 }
6576 }
6581 }
6583 /* If this change contained linked attributes in the body
6584 * (rather than in the links section) we need to update
6585 * backlinks in linked_attributes */
6589 }
6596 /* save away the linked attributes for the end of the
6597 transaction */
6603 }
6608 }
6614 }
6617 /* we need to steal the non-scalars so they stay
6618 around until the end of the transaction */
6623 }
6626 }
6628 /*
6629 process one linked attribute structure
6630 */
6635 {
6647 WERROR status;
6655 NTSTATUS ntstatus;
6661 /*
6662 linked_attributes[0]:
6663 &objs->linked_attributes[i]: struct drsuapi_DsReplicaLinkedAttribute
6664 identifier : *
6665 identifier: struct drsuapi_DsReplicaObjectIdentifier
6666 __ndr_size : 0x0000003a (58)
6667 __ndr_size_sid : 0x00000000 (0)
6668 guid : 8e95b6a9-13dd-4158-89db-3220a5be5cc7
6669 sid : S-0-0
6670 __ndr_size_dn : 0x00000000 (0)
6671 dn : ''
6672 attid : DRSUAPI_ATTID_member (0x1F)
6673 value: struct drsuapi_DsAttributeValue
6674 __ndr_size : 0x0000007e (126)
6675 blob : *
6676 blob : DATA_BLOB length=126
6677 flags : 0x00000001 (1)
6678 1: DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE
6679 originating_add_time : Wed Sep 2 22:20:01 2009 EST
6680 meta_data: struct drsuapi_DsReplicaMetaData
6681 version : 0x00000015 (21)
6682 originating_change_time : Wed Sep 2 23:39:07 2009 EST
6683 originating_invocation_id: 794640f3-18cf-40ee-a211-a93992b67a64
6684 originating_usn : 0x000000000001e19c (123292)
6686 (for cases where the link is to a normal DN)
6687 &target: struct drsuapi_DsReplicaObjectIdentifier3
6688 __ndr_size : 0x0000007e (126)
6689 __ndr_size_sid : 0x0000001c (28)
6690 guid : 7639e594-db75-4086-b0d4-67890ae46031
6691 sid : S-1-5-21-2848215498-2472035911-1947525656-19924
6692 __ndr_size_dn : 0x00000022 (34)
6693 dn : 'CN=UOne,OU=TestOU,DC=vsofs8,DC=com'
6694 */
6696 /* find the attribute being modified */
6706 }
6713 /* get the existing message from the db for the object with
6714 this GUID, returning attribute being modified. We will then
6715 use this msg as the basis for a modify call */
6717 DSDB_FLAG_NEXT_MODULE |
6718 DSDB_SEARCH_SEARCH_ALL_PARTITIONS |
6719 DSDB_SEARCH_SHOW_RECYCLED |
6720 DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT |
6721 DSDB_SEARCH_REVEAL_INTERNALS,
6722 parent,
6727 }
6733 }
6736 /*
6737 * Check for deleted objects per MS-DRSR 4.1.10.6.13
6738 * ProcessLinkValue, because link updates are not applied to
6739 * recycled and tombstone objects. We don't have to delete
6740 * any existing link, that should have happened when the
6741 * object deletion was replicated or initiated.
6742 */
6749 }
6758 }
6761 }
6763 /* parse the existing links */
6770 }
6778 }
6782 /*
6783 * This strange behaviour (allowing a NULL/missing
6784 * GUID) originally comes from:
6785 *
6786 * commit e3054ce0fe0f8f62d2f5b2a77893e7a1479128bd
6787 * Author: Andrew Tridgell <tridge@samba.org>
6788 * Date: Mon Dec 21 21:21:55 2009 +1100
6789 *
6790 * s4-drs: cope better with NULL GUIDS from DRS
6791 *
6792 * It is valid to get a NULL GUID over DRS for a deleted forward link. We
6793 * need to match by DN if possible when seeing if we should update an
6794 * existing link.
6795 *
6796 * Pair-Programmed-With: Andrew Bartlett <abartlet@samba.org>
6797 */
6801 DSDB_FLAG_NEXT_MODULE |
6802 DSDB_SEARCH_SHOW_RECYCLED |
6803 DSDB_SEARCH_SEARCH_ALL_PARTITIONS |
6804 DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT,
6805 parent);
6807 ldb_asprintf_errstring(ldb, "Failed to find GUID in linked attribute blob for %s on %s from %s",
6816 attrs2,
6817 DSDB_FLAG_NEXT_MODULE |
6818 DSDB_SEARCH_SHOW_RECYCLED |
6819 DSDB_SEARCH_SEARCH_ALL_PARTITIONS |
6820 DSDB_SEARCH_SHOW_DN_IN_STORAGE_FORMAT,
6821 parent,
6824 }
6832 }
6839 ldb_asprintf_errstring(ldb_module_get_ctx(module), "More than one object found matching objectGUID %s\n",
6846 }
6848 /*
6849 * Check for deleted objects per MS-DRSR 4.1.10.6.13
6850 * ProcessLinkValue, because link updates are not applied to
6851 * recycled and tombstone objects. We don't have to delete
6852 * any existing link, that should have happened when the
6853 * object deletion was replicated or initiated.
6854 */
6861 }
6863 /* see if this link already exists */
6872 }
6876 /* see if this update is newer than what we have already */
6890 version,
6892 change_time,
6899 }
6901 /* get a seq_num for this change */
6906 }
6909 /* remove the existing backlink */
6916 }
6917 }
6928 }
6931 /* add the new backlink */
6938 }
6939 }
6942 /* get a seq_num for this change */
6947 }
6948 /*
6949 * We know where the new one needs to be, from the *next
6950 * pointer into pdn_list.
6951 */
6960 }
6961 }
6966 }
6967 }
6974 }
6979 }
6992 }
7001 }
7002 }
7003 }
7005 /* we only change whenChanged and uSNChanged if the seq_num
7006 has changed */
7012 }
7019 }
7025 }
7031 }
7042 }
7047 }
7050 {
7053 }
7056 }
7059 /*
7060 we hook into the transaction operations to allow us to
7061 perform the linked attribute updates at the end of the whole
7062 transaction. This allows a forward linked attribute to be created
7063 before the object is created. During a vampire, w2k8 sends us linked
7064 attributes before the objects they are part of.
7065 */
7067 {
7068 /* create our private structure for this transaction */
7073 /* free any leftover mod_usn records from cancelled
7074 transactions */
7079 }
7084 }
7086 /*
7087 on prepare commit we loop over our queued la_context structures and
7088 apply each of them
7089 */
7091 {
7098 /* walk the list backwards, to do the first entry first, as we
7099 * added the entries with DLIST_ADD() which puts them at the
7100 * start of the list */
7109 }
7110 }
7112 /* process our backlink list, creating and deleting backlinks
7113 as necessary */
7119 }
7120 }
7124 /* possibly change @REPLCHANGED */
7128 }
7131 }
7134 {
7140 }
7154 };
7157 {
7160 }