2 Unix SMB/CIFS implementation.
4 DRS Replica Information
6 Copyright (C) Erick Nogueira do Nascimento 2009
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "dsdb/samdb/samdb.h"
25 #include "auth/auth.h"
26 #include "smbd/service.h"
27 #include "lib/events/events.h"
28 #include "lib/messaging/irpc.h"
29 #include "dsdb/kcc/kcc_service.h"
30 #include "lib/ldb/include/ldb_errors.h"
31 #include "../lib/util/dlinklist.h"
32 #include "librpc/gen_ndr/ndr_misc.h"
33 #include "librpc/gen_ndr/ndr_drsuapi.h"
34 #include "librpc/gen_ndr/ndr_drsblobs.h"
35 #include "param/param.h"
39 get cursors info for a specified DN
41 static WERROR kccdrs_replica_get_info_cursors(TALLOC_CTX *mem_ctx,
42 struct ldb_context *samdb,
43 struct drsuapi_DsReplicaGetInfo *r,
44 union drsuapi_DsReplicaInfo *reply,
49 if (!ldb_dn_validate(dn)) {
50 return WERR_INVALID_PARAMETER;
52 reply->cursors = talloc(mem_ctx, struct drsuapi_DsReplicaCursorCtr);
53 W_ERROR_HAVE_NO_MEMORY(reply->cursors);
55 reply->cursors->reserved = 0;
57 ret = dsdb_load_udv_v1(samdb, dn, reply->cursors, &reply->cursors->array, &reply->cursors->count);
58 if (ret != LDB_SUCCESS) {
59 return WERR_DS_DRA_BAD_NC;
65 get cursors2 info for a specified DN
67 static WERROR kccdrs_replica_get_info_cursors2(TALLOC_CTX *mem_ctx,
68 struct ldb_context *samdb,
69 struct drsuapi_DsReplicaGetInfo *r,
70 union drsuapi_DsReplicaInfo *reply,
75 if (!ldb_dn_validate(dn)) {
76 return WERR_INVALID_PARAMETER;
78 reply->cursors2 = talloc(mem_ctx, struct drsuapi_DsReplicaCursor2Ctr);
79 W_ERROR_HAVE_NO_MEMORY(reply->cursors2);
81 ret = dsdb_load_udv_v2(samdb, dn, reply->cursors2, &reply->cursors2->array, &reply->cursors2->count);
82 if (ret != LDB_SUCCESS) {
83 return WERR_DS_DRA_BAD_NC;
86 reply->cursors2->enumeration_context = reply->cursors2->count;
91 get pending ops info for a specified DN
93 static WERROR kccdrs_replica_get_info_pending_ops(TALLOC_CTX *mem_ctx,
94 struct ldb_context *samdb,
95 struct drsuapi_DsReplicaGetInfo *r,
96 union drsuapi_DsReplicaInfo *reply,
99 struct timeval now = timeval_current();
101 if (!ldb_dn_validate(dn)) {
102 return WERR_INVALID_PARAMETER;
104 reply->pendingops = talloc(mem_ctx, struct drsuapi_DsReplicaOpCtr);
105 W_ERROR_HAVE_NO_MEMORY(reply->pendingops);
107 /* claim no pending ops for now */
108 reply->pendingops->time = timeval_to_nttime(&now);
109 reply->pendingops->count = 0;
110 reply->pendingops->array = NULL;
118 struct ncList *prev, *next;
122 struct drsuapi_DsReplicaNeighbour *neigh;
123 struct neighList *prev, *next;
126 static WERROR copy_repsfrom_1_to_2(TALLOC_CTX *mem_ctx,
127 struct repsFromTo2 **reps2,
128 struct repsFromTo1 *reps1)
130 struct repsFromTo2* reps;
132 reps = talloc_zero(mem_ctx, struct repsFromTo2);
133 W_ERROR_HAVE_NO_MEMORY(reps);
135 reps->blobsize = reps1->blobsize;
136 reps->consecutive_sync_failures = reps1->consecutive_sync_failures;
137 reps->last_attempt = reps1->last_attempt;
138 reps->last_success = reps1->last_success;
139 reps->other_info = talloc_zero(mem_ctx, struct repsFromTo2OtherInfo);
140 W_ERROR_HAVE_NO_MEMORY(reps->other_info);
141 reps->other_info->dns_name1 = reps1->other_info->dns_name;
142 reps->replica_flags = reps1->replica_flags;
143 memcpy(reps->schedule, reps1->schedule, sizeof(reps1->schedule));
144 reps->reserved = reps1->reserved;
145 reps->highwatermark = reps1->highwatermark;
146 reps->source_dsa_obj_guid = reps1->source_dsa_obj_guid;
147 reps->source_dsa_invocation_id = reps1->source_dsa_invocation_id;
148 reps->transport_guid = reps1->transport_guid;
154 static WERROR fill_neighbor_from_repsFrom(TALLOC_CTX *mem_ctx,
155 struct ldb_context *samdb,
156 struct ldb_dn *nc_dn,
157 struct drsuapi_DsReplicaNeighbour *neigh,
158 struct repsFromTo2 *reps_from)
161 struct ldb_dn *source_dsa_dn;
164 struct ldb_dn *transport_obj_dn = NULL;
166 neigh->source_dsa_address = reps_from->other_info->dns_name1;
167 neigh->replica_flags = reps_from->replica_flags;
168 neigh->last_attempt = reps_from->last_attempt;
169 neigh->source_dsa_obj_guid = reps_from->source_dsa_obj_guid;
171 dsa_guid_str = GUID_string(mem_ctx, &reps_from->source_dsa_obj_guid);
172 W_ERROR_HAVE_NO_MEMORY(dsa_guid_str);
173 ret = dsdb_find_dn_by_guid(samdb, mem_ctx, dsa_guid_str, &source_dsa_dn);
175 if (ret != LDB_SUCCESS) {
176 DEBUG(0,(__location__ ": Failed to find DN for neighbor GUID %s\n",
178 status = WERR_DS_DRA_INTERNAL_ERROR;
182 neigh->source_dsa_obj_dn = ldb_dn_get_linearized(source_dsa_dn);
183 neigh->naming_context_dn = ldb_dn_get_linearized(nc_dn);
185 if (dsdb_find_guid_by_dn(samdb, nc_dn, &neigh->naming_context_obj_guid)
187 status = WERR_DS_DRA_INTERNAL_ERROR;
191 if (!GUID_all_zero(&reps_from->transport_guid)) {
192 char *transp_guid_str = GUID_string(mem_ctx, &reps_from->transport_guid);
193 W_ERROR_HAVE_NO_MEMORY(transp_guid_str);
194 if (dsdb_find_dn_by_guid(samdb, mem_ctx, transp_guid_str,
195 &transport_obj_dn) != LDB_SUCCESS)
197 status = WERR_DS_DRA_INTERNAL_ERROR;
202 neigh->transport_obj_dn = ldb_dn_get_linearized(transport_obj_dn);
203 neigh->source_dsa_invocation_id = reps_from->source_dsa_invocation_id;
204 neigh->transport_obj_guid = reps_from->transport_guid;
205 neigh->highest_usn = reps_from->highwatermark.highest_usn;
206 neigh->tmp_highest_usn = reps_from->highwatermark.tmp_highest_usn;
207 neigh->last_success = reps_from->last_success;
208 neigh->result_last_attempt = reps_from->result_last_attempt;
209 neigh->consecutive_sync_failures = reps_from->consecutive_sync_failures;
210 neigh->reserved = 0; /* Unused. MUST be 0. */
212 /* If everything went fine so far, set the status to OK */
219 * See details on MS-DRSR 4.1.13.3, for infoType DS_REPL_INFO_NEIGHBORS
221 static WERROR kccdrs_replica_get_info_neighbours(TALLOC_CTX *mem_ctx,
222 struct ldb_context *samdb,
223 struct drsuapi_DsReplicaGetInfo *r,
224 union drsuapi_DsReplicaInfo *reply,
226 struct GUID req_src_dsa_guid,
227 struct ncList *nc_list)
232 struct ldb_dn *nc_dn = NULL;
233 struct ncList *p_nc_list = NULL;
235 struct repsFromToBlob *reps_from_blob = NULL;
236 struct repsFromTo2 *reps_from = NULL;
237 uint32_t c_reps_from;
241 struct neighList *neigh_list = NULL;
242 struct neighList *neigh_elem = NULL;
244 struct drsuapi_DsReplicaNeighbour *neigh = NULL;
249 /* foreach nc in ncs */
250 for (p_nc_list = nc_list; p_nc_list != NULL; p_nc_list = p_nc_list->next) {
252 nc_dn = p_nc_list->dn;
254 /* load the nc's repsFromTo blob */
255 status = dsdb_loadreps(samdb, mem_ctx, nc_dn, "repsFrom",
256 &reps_from_blob, &c_reps_from);
257 if (!W_ERROR_IS_OK(status)) {
258 status = WERR_DS_DRA_INTERNAL_ERROR;
262 /* foreach r in nc!repsFrom */
263 for (i_rep = 0; i_rep < c_reps_from; i_rep++) {
265 /* put all info on reps_from */
266 if (reps_from_blob[i_rep].version == 1) {
267 status = copy_repsfrom_1_to_2(mem_ctx, &reps_from,
268 &reps_from_blob[i_rep].ctr.ctr1);
269 if (!W_ERROR_IS_OK(status)) {
272 } else { /* reps_from->version == 2 */
273 reps_from = &reps_from_blob[i_rep].ctr.ctr2;
276 if (GUID_all_zero(&req_src_dsa_guid) ||
277 GUID_compare(&req_src_dsa_guid, &reps_from->source_dsa_obj_guid) == 0)
280 if (i >= base_index) {
281 neigh = talloc_zero(mem_ctx, struct drsuapi_DsReplicaNeighbour);
282 W_ERROR_HAVE_NO_MEMORY(neigh);
284 status = fill_neighbor_from_repsFrom(mem_ctx, samdb,
287 if (!W_ERROR_IS_OK(status)) {
291 /* append the neighbor to neigh_list */
292 neigh_elem = talloc_zero(mem_ctx, struct neighList);
293 W_ERROR_HAVE_NO_MEMORY(neigh_elem);
294 neigh_elem->neigh = neigh;
295 DLIST_ADD_END(neigh_list, neigh_elem, struct neighList*);
305 /* put all neighbours on neigh_list on reply->neighbours->array */
306 reply->neighbours = talloc_zero(mem_ctx, struct drsuapi_DsReplicaNeighbourCtr);
307 W_ERROR_HAVE_NO_MEMORY(reply->neighbours);
309 reply->neighbours->count = j;
310 reply->neighbours->reserved = 0;
311 reply->neighbours->array = talloc_array(mem_ctx, struct drsuapi_DsReplicaNeighbour, j);
312 W_ERROR_HAVE_NO_MEMORY(reply->neighbours->array);
314 for (k = 0; neigh_list != NULL; neigh_list = neigh_list->next, k++) {
315 reply->neighbours->array[k] = *neigh_list->neigh;
318 /* If everything went fine so far, set the status to OK */
324 static WERROR fill_neighbor_from_repsTo(TALLOC_CTX *mem_ctx,
325 struct ldb_context *samdb, struct ldb_dn *nc_dn,
326 struct drsuapi_DsReplicaNeighbour *neigh,
327 struct repsFromTo2 *reps_to)
332 struct ldb_dn *source_dsa_dn;
334 neigh->source_dsa_address = reps_to->other_info->dns_name1;
335 neigh->replica_flags = reps_to->replica_flags;
336 neigh->last_attempt = reps_to->last_attempt;
337 neigh->source_dsa_obj_guid = reps_to->source_dsa_obj_guid;
339 dsa_guid_str = GUID_string(mem_ctx, &reps_to->source_dsa_obj_guid);
340 W_ERROR_HAVE_NO_MEMORY(dsa_guid_str);
342 ret = dsdb_find_dn_by_guid(samdb, mem_ctx, dsa_guid_str, &source_dsa_dn);
343 if (ret != LDB_SUCCESS) {
344 DEBUG(0,(__location__ ": Failed to find DN for neighbor GUID %s\n",
346 status = WERR_DS_DRA_INTERNAL_ERROR;
350 neigh->source_dsa_obj_dn = ldb_dn_get_linearized(source_dsa_dn);
351 neigh->naming_context_dn = ldb_dn_get_linearized(nc_dn);
353 ret = dsdb_find_guid_by_dn(samdb, nc_dn,
354 &neigh->naming_context_obj_guid);
355 if (ret != LDB_SUCCESS) {
356 DEBUG(0,(__location__ ": Failed to find GUID for DN %s\n",
357 ldb_dn_get_linearized(nc_dn)));
358 status = WERR_DS_DRA_INTERNAL_ERROR;
362 /* If everything went fine so far, set the status to OK */
367 static WERROR kccdrs_replica_get_info_repsto(TALLOC_CTX *mem_ctx,
368 struct ldb_context *samdb, struct drsuapi_DsReplicaGetInfo *r,
369 union drsuapi_DsReplicaInfo *reply, int base_index,
370 struct GUID req_src_dsa_guid, struct ncList *nc_list)
374 struct ncList *p_nc_list = NULL;
375 struct ldb_dn *nc_dn = NULL;
376 struct repsFromToBlob *reps_to_blob;
377 struct repsFromTo2 *reps_to;
380 struct drsuapi_DsReplicaNeighbour *neigh;
381 struct neighList *neigh_list = NULL;
382 struct neighList *neigh_elem = NULL;
386 /* foreach nc in ncs */
387 for (p_nc_list = nc_list; p_nc_list != NULL; p_nc_list = p_nc_list->next) {
389 nc_dn = p_nc_list->dn;
391 status = dsdb_loadreps(samdb, mem_ctx, nc_dn, "repsTo",
392 &reps_to_blob, &c_reps_to);
393 if (!W_ERROR_IS_OK(status)) {
394 status = WERR_DS_DRA_INTERNAL_ERROR;
398 /* foreach r in nc!repsTo */
399 for (i_rep = 0; i_rep < c_reps_to; i_rep++) {
401 /* put all info on reps_from */
402 if (reps_to_blob[i_rep].version == 1) {
403 status = copy_repsfrom_1_to_2(mem_ctx,
405 &reps_to_blob[i_rep].ctr.ctr1);
406 if (!W_ERROR_IS_OK(status)) {
409 } else { /* reps_from->version == 2 */
410 reps_to = &reps_to_blob[i_rep].ctr.ctr2;
413 if (i >= base_index) {
414 neigh = talloc_zero(mem_ctx, struct drsuapi_DsReplicaNeighbour);
415 W_ERROR_HAVE_NO_MEMORY(neigh);
417 status = fill_neighbor_from_repsTo(mem_ctx,
420 if (!W_ERROR_IS_OK(status)) {
424 /* append the neighbor to neigh_list */
425 neigh_elem = talloc_zero(mem_ctx, struct neighList);
426 W_ERROR_HAVE_NO_MEMORY(neigh_elem);
427 neigh_elem->neigh = neigh;
428 DLIST_ADD_END(neigh_list, neigh_elem, struct neighList*);
437 /* put all neighbours on neigh_list on reply->neighbours->array */
438 reply->neighbours = talloc_zero(mem_ctx, struct drsuapi_DsReplicaNeighbourCtr);
439 W_ERROR_HAVE_NO_MEMORY(reply->neighbours);
441 reply->neighbours->count = j;
442 reply->neighbours->reserved = 0;
443 reply->neighbours->array = talloc_array(mem_ctx, struct drsuapi_DsReplicaNeighbour, j);
444 W_ERROR_HAVE_NO_MEMORY(reply->neighbours->array);
446 for (k = 0; neigh_list != NULL; neigh_list = neigh_list->next, k++) {
447 reply->neighbours->array[k] = *neigh_list->neigh;
450 /* If everything went fine so far, set the status to OK */
455 static WERROR get_master_ncs(TALLOC_CTX *mem_ctx, struct ldb_context *samdb,
456 const char *ntds_guid_str, struct ncList **master_nc_list)
459 const char *attrs[] = { "hasMasterNCs", NULL };
460 struct ldb_result *res;
461 struct ncList *nc_list = NULL;
462 struct ncList *nc_list_elem;
467 ret = ldb_search(samdb, mem_ctx, &res, ldb_get_config_basedn(samdb),
468 LDB_SCOPE_DEFAULT, attrs, "(objectguid=%s)", ntds_guid_str);
470 if (ret != LDB_SUCCESS) {
471 DEBUG(0,(__location__ ": Failed objectguid search - %s\n", ldb_errstring(samdb)));
472 status = WERR_INTERNAL_ERROR;
476 if (res->count == 0) {
477 DEBUG(0,(__location__ ": Failed: objectguid=%s not found\n", ntds_guid_str));
478 status = WERR_INTERNAL_ERROR;
482 for (i = 0; i < res->count; i++) {
484 struct ldb_message_element *msg_elem = ldb_msg_find_element(
485 res->msgs[i], "hasMasterNCs");
488 if (!msg_elem || msg_elem->num_values == 0) {
489 DEBUG(0,(__location__ ": Failed: Attribute hasMasterNCs not found - %s\n",
490 ldb_errstring(samdb)));
491 status = WERR_INTERNAL_ERROR;
495 for (k = 0; k < msg_elem->num_values; k++) {
496 int len = msg_elem->values[k].length;
498 /* copy the string on msg_elem->values[k]->data to nc_str */
499 nc_str = talloc_array(mem_ctx, char, len);
500 W_ERROR_HAVE_NO_MEMORY(nc_str);
501 memcpy(nc_str, msg_elem->values[k].data, len);
504 nc_list_elem = talloc_zero(mem_ctx, struct ncList);
505 W_ERROR_HAVE_NO_MEMORY(nc_list_elem);
506 nc_list_elem->dn = ldb_dn_new(mem_ctx, samdb, nc_str);
507 W_ERROR_HAVE_NO_MEMORY(nc_list_elem);
508 DLIST_ADD(nc_list, nc_list_elem);
513 *master_nc_list = nc_list;
514 /* If everything went fine so far, set the status to OK */
520 NTSTATUS kccdrs_replica_get_info(struct irpc_message *msg,
521 struct drsuapi_DsReplicaGetInfo *req)
525 struct drsuapi_DsReplicaGetInfoRequest1 *req1;
526 struct drsuapi_DsReplicaGetInfoRequest2 *req2;
527 enum drsuapi_DsReplicaInfoType info_type, *tmp_p_info_type;
530 union drsuapi_DsReplicaInfo *reply;
532 struct GUID req_src_dsa_guid;
533 const char *object_dn = NULL;
534 struct ldb_dn *nc_dn = NULL;
535 struct ncList *nc_list = NULL, *nc_list_elem = NULL;
537 struct kccsrv_service *service;
538 struct ldb_context *samdb;
541 service = talloc_get_type(msg->private_data, struct kccsrv_service);
542 samdb = service->samdb;
543 mem_ctx = talloc_new(msg);
544 NT_STATUS_HAVE_NO_MEMORY(mem_ctx);
546 NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaGetInfo, req);
548 /* check request version */
549 if (req->in.level != DRSUAPI_DS_REPLICA_GET_INFO &&
550 req->in.level != DRSUAPI_DS_REPLICA_GET_INFO2)
552 DEBUG(1,(__location__ ": Unsupported DsReplicaGetInfo level %u\n",
554 status = WERR_REVISION_MISMATCH;
558 if (req->in.level == DRSUAPI_DS_REPLICA_GET_INFO) {
559 req1 = &req->in.req->req1;
561 info_type = req1->info_type;
562 object_dn = req1->object_dn;
563 req_src_dsa_guid = req1->guid1;
565 } else { /* r->in.level == DRSUAPI_DS_REPLICA_GET_INFO2 */
566 req2 = &req->in.req->req2;
567 if (req2->enumeration_context == 0xffffffff) {
568 /* no more data is available */
569 status = WERR_NO_MORE_ITEMS; /* on MS-DRSR it is ERROR_NO_MORE_ITEMS */
573 base_index = req2->enumeration_context;
574 info_type = req2->info_type;
575 object_dn = req2->object_dn;
576 req_src_dsa_guid = req2->guid1;
579 /* TODO: Perform the necessary access permission checking here according to the infoType requested */
581 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
582 case DRSUAPI_DS_REPLICA_INFO_CURSORS:
583 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
584 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
585 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
586 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
587 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
588 case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
589 case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
590 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
591 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
592 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
593 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
594 case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
595 case DRSUAPI_DS_REPLICA_INFO_06:
598 DEBUG(0,(__location__ ": infoType %u requested is invalid.", (unsigned)info_type));
599 status = WERR_INVALID_PARAMETER; /* infoType is invalid */
603 /* allocate the reply and fill in some fields */
604 reply = talloc_zero(mem_ctx, union drsuapi_DsReplicaInfo);
605 NT_STATUS_HAVE_NO_MEMORY(reply);
606 req->out.info = reply;
607 tmp_p_info_type = talloc(mem_ctx, enum drsuapi_DsReplicaInfoType);
608 NT_STATUS_HAVE_NO_MEMORY(tmp_p_info_type);
609 *tmp_p_info_type = info_type;
610 req->out.info_type = tmp_p_info_type;
612 /* Based on the infoType requested, retrieve the corresponding
613 * information and construct the response message */
616 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
617 case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: /* On MS-DRSR it is DS_REPL_INFO_REPSTO */
618 if (object_dn != NULL) { /* ncs := { object_dn } */
620 nc_dn = ldb_dn_new(mem_ctx, samdb, object_dn);
621 nc_list_elem = talloc_zero(mem_ctx, struct ncList);
622 NT_STATUS_HAVE_NO_MEMORY(nc_list_elem);
623 nc_list_elem->dn = nc_dn;
624 DLIST_ADD_END(nc_list, nc_list_elem, struct ncList*);
627 /* ncs := getNCs() from ldb database.
628 * getNCs() must return an array containing
629 * the DSNames of all NCs hosted by this
632 char *ntds_guid_str = GUID_string(mem_ctx, &service->ntds_guid);
633 NT_STATUS_HAVE_NO_MEMORY(ntds_guid_str);
634 status = get_master_ncs(mem_ctx, samdb, ntds_guid_str, &nc_list);
635 if (!W_ERROR_IS_OK(status)) {
640 if (info_type == DRSUAPI_DS_REPLICA_INFO_NEIGHBORS) {
641 status = kccdrs_replica_get_info_neighbours(mem_ctx, samdb, req,
643 req_src_dsa_guid, nc_list);
644 } else { /* info_type == DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02 */
645 status = kccdrs_replica_get_info_repsto(mem_ctx, samdb, req,
647 req_src_dsa_guid, nc_list);
652 case DRSUAPI_DS_REPLICA_INFO_CURSORS: /* On MS-DRSR it is DS_REPL_INFO_CURSORS_FOR_NC */
653 status = kccdrs_replica_get_info_cursors(mem_ctx, samdb, req, reply,
654 ldb_dn_new(mem_ctx, samdb, object_dn));
656 case DRSUAPI_DS_REPLICA_INFO_CURSORS2: /* On MS-DRSR it is DS_REPL_INFO_CURSORS_2_FOR_NC */
657 status = kccdrs_replica_get_info_cursors2(mem_ctx, samdb, req, reply,
658 ldb_dn_new(mem_ctx, samdb, object_dn));
660 case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: /* On MS-DRSR it is DS_REPL_INFO_PENDING_OPS */
661 status = kccdrs_replica_get_info_pending_ops(mem_ctx, samdb, req, reply,
662 ldb_dn_new(mem_ctx, samdb, object_dn));
665 case DRSUAPI_DS_REPLICA_INFO_CURSORS3: /* On MS-DRSR it is DS_REPL_INFO_CURSORS_3_FOR_NC */
666 case DRSUAPI_DS_REPLICA_INFO_CURSORS05: /* On MS-DRSR it is DS_REPL_INFO_UPTODATE_VECTOR_V1 */
667 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: /* On MS-DRSR it is DS_REPL_INFO_METADATA_FOR_OBJ */
668 case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: /* On MS-DRSR it is DS_REPL_INFO_METADATA_FOR_OBJ */
669 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: /* On MS-DRSR it is DS_REPL_INFO_METADATA_FOR_ATTR_VALUE */
670 case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: /* On MS-DRSR it is DS_REPL_INFO_METADATA_2_FOR_ATTR_VALUE */
671 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: /* On MS-DRSR it is DS_REPL_INFO_KCC_DSA_CONNECT_FAILURES */
672 case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: /* On MS-DRSR it is DS_REPL_INFO_KCC_LINK_FAILURES */
673 case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: /* On MS-DRSR it is DS_REPL_INFO_CLIENT_CONTEXTS */
674 case DRSUAPI_DS_REPLICA_INFO_06: /* On MS-DRSR it is DS_REPL_INFO_SERVER_OUTGOING_CALLS */
676 DEBUG(1,(__location__ ": Unsupported DsReplicaGetInfo info_type %u\n",
678 status = WERR_INVALID_LEVEL;
683 /* put the status on the result field of the reply */
684 req->out.result = status;
685 NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaGetInfo, req);