s4-kcc: added DsReplicaGetInfo pending ops call
[samba.git] / source4 / dsdb / kcc / kcc_drs_replica_info.c
1 /*
2  Unix SMB/CIFS implementation.
3
4  DRS Replica Information
5
6  Copyright (C) Erick Nogueira do Nascimento 2009
7
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.
12
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.
17
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/>.
20
21  */
22
23 #include "includes.h"
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"
36
37
38 /*
39   get cursors info for a specified DN
40 */
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,
45                                               struct ldb_dn *dn)
46 {
47         int ret;
48
49         if (!ldb_dn_validate(dn)) {
50                 return WERR_INVALID_PARAMETER;
51         }
52         reply->cursors = talloc(mem_ctx, struct drsuapi_DsReplicaCursorCtr);
53         W_ERROR_HAVE_NO_MEMORY(reply->cursors);
54
55         reply->cursors->reserved = 0;
56
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;
60         }
61         return WERR_OK;
62 }
63
64 /*
65   get cursors2 info for a specified DN
66 */
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,
71                                                struct ldb_dn *dn)
72 {
73         int ret;
74
75         if (!ldb_dn_validate(dn)) {
76                 return WERR_INVALID_PARAMETER;
77         }
78         reply->cursors2 = talloc(mem_ctx, struct drsuapi_DsReplicaCursor2Ctr);
79         W_ERROR_HAVE_NO_MEMORY(reply->cursors2);
80
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;
84         }
85
86         reply->cursors2->enumeration_context = reply->cursors2->count;
87         return WERR_OK;
88 }
89
90 /*
91   get pending ops info for a specified DN
92 */
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,
97                                                   struct ldb_dn *dn)
98 {
99         struct timeval now = timeval_current();
100
101         if (!ldb_dn_validate(dn)) {
102                 return WERR_INVALID_PARAMETER;
103         }
104         reply->pendingops = talloc(mem_ctx, struct drsuapi_DsReplicaOpCtr);
105         W_ERROR_HAVE_NO_MEMORY(reply->pendingops);
106
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;
111
112         return WERR_OK;
113 }
114
115
116 struct ncList {
117         struct ldb_dn *dn;
118         struct ncList *prev, *next;
119 };
120
121 struct neighList {
122         struct drsuapi_DsReplicaNeighbour *neigh;
123         struct neighList *prev, *next;
124 };
125
126 static WERROR copy_repsfrom_1_to_2(TALLOC_CTX *mem_ctx,
127                                  struct repsFromTo2 **reps2,
128                                  struct repsFromTo1 *reps1)
129 {
130         struct repsFromTo2* reps;
131
132         reps = talloc_zero(mem_ctx, struct repsFromTo2);
133         W_ERROR_HAVE_NO_MEMORY(reps);
134
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;
149
150         *reps2 = reps;
151         return WERR_OK;
152 }
153
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)
159 {
160         WERROR status;
161         struct ldb_dn *source_dsa_dn;
162         int ret;
163         char *dsa_guid_str;
164         struct ldb_dn *transport_obj_dn = NULL;
165
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;
170
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);
174
175         if (ret != LDB_SUCCESS) {
176                 DEBUG(0,(__location__ ": Failed to find DN for neighbor GUID %s\n",
177                       dsa_guid_str));
178                 status = WERR_DS_DRA_INTERNAL_ERROR;
179                 goto DONE;
180         }
181
182         neigh->source_dsa_obj_dn = ldb_dn_get_linearized(source_dsa_dn);
183         neigh->naming_context_dn = ldb_dn_get_linearized(nc_dn);
184
185         if (dsdb_find_guid_by_dn(samdb, nc_dn, &neigh->naming_context_obj_guid)
186                         != LDB_SUCCESS) {
187                 status = WERR_DS_DRA_INTERNAL_ERROR;
188                 goto DONE;
189         }
190
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)
196                 {
197                         status = WERR_DS_DRA_INTERNAL_ERROR;
198                         goto DONE;
199                 }
200         }
201
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. */
211
212         /* If everything went fine so far, set the status to OK */
213         status = WERR_OK;
214 DONE:
215         return status;
216 }
217
218 /*
219  * See details on MS-DRSR 4.1.13.3, for infoType DS_REPL_INFO_NEIGHBORS
220  * */
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,
225                                                  int base_index,
226                                                  struct GUID req_src_dsa_guid,
227                                                  struct ncList *nc_list)
228 {
229         WERROR status;
230
231         int i, j, k;
232         struct ldb_dn *nc_dn = NULL;
233         struct ncList *p_nc_list = NULL;
234
235         struct repsFromToBlob *reps_from_blob = NULL;
236         struct repsFromTo2 *reps_from = NULL;
237         uint32_t c_reps_from;
238
239         int i_rep;
240
241         struct neighList *neigh_list = NULL;
242         struct neighList *neigh_elem = NULL;
243
244         struct drsuapi_DsReplicaNeighbour *neigh = NULL;
245
246         i = j = 0;
247         neigh_list = NULL;
248
249         /* foreach nc in ncs */
250         for (p_nc_list = nc_list; p_nc_list != NULL; p_nc_list = p_nc_list->next) {
251
252                 nc_dn = p_nc_list->dn;
253
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;
259                         goto DONE;
260                 }
261
262                 /* foreach r in nc!repsFrom */
263                 for (i_rep = 0; i_rep < c_reps_from; i_rep++) {
264
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)) {
270                                         goto DONE;
271                                 }
272                         } else { /* reps_from->version == 2 */
273                                 reps_from = &reps_from_blob[i_rep].ctr.ctr2;
274                         }
275
276                         if (GUID_all_zero(&req_src_dsa_guid) ||
277                             GUID_compare(&req_src_dsa_guid, &reps_from->source_dsa_obj_guid) == 0)
278                         {
279
280                                 if (i >= base_index) {
281                                         neigh = talloc_zero(mem_ctx, struct drsuapi_DsReplicaNeighbour);
282                                         W_ERROR_HAVE_NO_MEMORY(neigh);
283
284                                         status = fill_neighbor_from_repsFrom(mem_ctx, samdb,
285                                                                              nc_dn, neigh,
286                                                                              reps_from);
287                                         if (!W_ERROR_IS_OK(status)) {
288                                                 goto DONE;
289                                         }
290
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*);
296
297                                         j++;
298                                 }
299
300                                 i++;
301                         }
302                 }
303         }
304
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);
308
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);
313
314         for (k = 0; neigh_list != NULL; neigh_list = neigh_list->next, k++) {
315                 reply->neighbours->array[k] = *neigh_list->neigh;
316         }
317
318         /* If everything went fine so far, set the status to OK */
319         status = WERR_OK;
320 DONE:
321         return status;
322 }
323
324 static WERROR get_master_ncs(TALLOC_CTX *mem_ctx, struct ldb_context *samdb,
325                              const char *ntds_guid_str, struct ncList **master_nc_list)
326 {
327         WERROR status;
328         const char *attrs[] = { "hasMasterNCs", NULL };
329         struct ldb_result *res;
330         struct ncList *nc_list = NULL;
331         struct ncList *nc_list_elem;
332         int ret;
333         int i;
334         char *nc_str;
335
336         ret = ldb_search(samdb, mem_ctx, &res, ldb_get_config_basedn(samdb),
337                         LDB_SCOPE_DEFAULT, attrs, "(objectguid=%s)", ntds_guid_str);
338
339         if (ret != LDB_SUCCESS) {
340                 DEBUG(0,(__location__ ": Failed objectguid search - %s\n", ldb_errstring(samdb)));
341                 status = WERR_INTERNAL_ERROR;
342                 goto DONE;
343         }
344
345         if (res->count == 0) {
346                 DEBUG(0,(__location__ ": Failed: objectguid=%s not found\n", ntds_guid_str));
347                 status = WERR_INTERNAL_ERROR;
348                 goto DONE;
349         }
350
351         for (i = 0; i < res->count; i++) {
352
353                 struct ldb_message_element *msg_elem = ldb_msg_find_element(
354                                 res->msgs[i], "hasMasterNCs");
355                 int k;
356
357                 if (!msg_elem || msg_elem->num_values == 0) {
358                         DEBUG(0,(__location__ ": Failed: Attribute hasMasterNCs not found - %s\n",
359                               ldb_errstring(samdb)));
360                         status = WERR_INTERNAL_ERROR;
361                         goto DONE;
362                 }
363
364                 for (k = 0; k < msg_elem->num_values; k++) {
365                         int len = msg_elem->values[k].length;
366
367                         /* copy the string on msg_elem->values[k]->data to nc_str */
368                         nc_str = talloc_array(mem_ctx, char, len);
369                         W_ERROR_HAVE_NO_MEMORY(nc_str);
370                         memcpy(nc_str, msg_elem->values[k].data, len);
371                         nc_str[len] = '\0';
372
373                         nc_list_elem = talloc_zero(mem_ctx, struct ncList);
374                         W_ERROR_HAVE_NO_MEMORY(nc_list_elem);
375                         nc_list_elem->dn = ldb_dn_new(mem_ctx, samdb, nc_str);
376                         W_ERROR_HAVE_NO_MEMORY(nc_list_elem);
377                         DLIST_ADD(nc_list, nc_list_elem);
378                 }
379
380         }
381
382         *master_nc_list = nc_list;
383         /* If everything went fine so far, set the status to OK */
384         status = WERR_OK;
385 DONE:
386         return status;
387 }
388
389 NTSTATUS kccdrs_replica_get_info(struct irpc_message *msg,
390                                  struct drsuapi_DsReplicaGetInfo *req)
391 {
392         WERROR status;
393
394         struct drsuapi_DsReplicaGetInfoRequest1 *req1;
395         struct drsuapi_DsReplicaGetInfoRequest2 *req2;
396         enum drsuapi_DsReplicaInfoType info_type, *tmp_p_info_type;
397
398         int base_index;
399         union drsuapi_DsReplicaInfo *reply;
400
401         struct GUID req_src_dsa_guid;
402         const char *object_dn = NULL;
403         struct ldb_dn *nc_dn = NULL;
404         struct ncList *nc_list = NULL, *nc_list_elem = NULL;
405
406         struct kccsrv_service *service;
407         struct ldb_context *samdb;
408         TALLOC_CTX *mem_ctx;
409
410         service = talloc_get_type(msg->private_data, struct kccsrv_service);
411         samdb = service->samdb;
412         mem_ctx = talloc_new(msg);
413         NT_STATUS_HAVE_NO_MEMORY(mem_ctx);
414
415         NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaGetInfo, req);
416
417         /* check request version */
418         if (req->in.level != DRSUAPI_DS_REPLICA_GET_INFO &&
419             req->in.level != DRSUAPI_DS_REPLICA_GET_INFO2)
420         {
421                 DEBUG(1,(__location__ ": Unsupported DsReplicaGetInfo level %u\n",
422                          req->in.level));
423                 status = WERR_REVISION_MISMATCH;
424                 goto DONE;
425         }
426
427         if (req->in.level == DRSUAPI_DS_REPLICA_GET_INFO) {
428                 req1 = &req->in.req->req1;
429                 base_index = 0;
430                 info_type = req1->info_type;
431                 object_dn = req1->object_dn;
432                 req_src_dsa_guid = req1->guid1;
433
434         } else { /* r->in.level == DRSUAPI_DS_REPLICA_GET_INFO2 */
435                 req2 = &req->in.req->req2;
436                 if (req2->enumeration_context == 0xffffffff) {
437                         /* no more data is available */
438                         status = WERR_NO_MORE_ITEMS; /* on MS-DRSR it is ERROR_NO_MORE_ITEMS */
439                         goto DONE;
440                 }
441
442                 base_index = req2->enumeration_context;
443                 info_type = req2->info_type;
444                 object_dn = req2->object_dn;
445                 req_src_dsa_guid = req2->guid1;
446         }
447
448         /* TODO: Perform the necessary access permission checking here according to the infoType requested */
449         switch (info_type) {
450         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
451         case DRSUAPI_DS_REPLICA_INFO_CURSORS:
452         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA:
453         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES:
454         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES:
455         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS:
456         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA:
457         case DRSUAPI_DS_REPLICA_INFO_CURSORS2:
458         case DRSUAPI_DS_REPLICA_INFO_CURSORS3:
459         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2:
460         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2:
461         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02:
462         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04:
463         case DRSUAPI_DS_REPLICA_INFO_CURSORS05:
464         case DRSUAPI_DS_REPLICA_INFO_06:
465                 break;
466         default:
467                 DEBUG(0,(__location__ ": infoType %u requested is invalid.", (unsigned)info_type));
468                 status = WERR_INVALID_PARAMETER; /* infoType is invalid */
469                 goto DONE;
470         }
471
472         /* allocate the reply and fill in some fields */
473         reply = talloc_zero(mem_ctx, union drsuapi_DsReplicaInfo);
474         NT_STATUS_HAVE_NO_MEMORY(reply);
475         req->out.info = reply;
476         tmp_p_info_type = talloc(mem_ctx, enum drsuapi_DsReplicaInfoType);
477         NT_STATUS_HAVE_NO_MEMORY(tmp_p_info_type);
478         *tmp_p_info_type = info_type;
479         req->out.info_type = tmp_p_info_type;
480
481         /* Based on the infoType requested, retrieve the corresponding
482          * information and construct the response message */
483         switch (info_type) {
484
485         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS:
486                 if (object_dn != NULL) { /* ncs := { object_dn } */
487                         nc_list = NULL;
488                         nc_dn = ldb_dn_new(mem_ctx, samdb, object_dn);
489                         nc_list_elem = talloc_zero(mem_ctx, struct ncList);
490                         NT_STATUS_HAVE_NO_MEMORY(nc_list_elem);
491                         nc_list_elem->dn = nc_dn;
492                         DLIST_ADD_END(nc_list, nc_list_elem, struct ncList*);
493
494                 } else {
495                         /* ncs := getNCs() from ldb database.
496                          * getNCs() must return an array containing
497                          * the DSNames of all NCs hosted by this
498                          * server.
499                          */
500                         char *ntds_guid_str = GUID_string(mem_ctx, &service->ntds_guid);
501                         NT_STATUS_HAVE_NO_MEMORY(ntds_guid_str);
502                         status = get_master_ncs(mem_ctx, samdb, ntds_guid_str, &nc_list);
503                         if (!W_ERROR_IS_OK(status)) {
504                                 goto DONE;
505                         }
506                 }
507
508                 status = kccdrs_replica_get_info_neighbours(mem_ctx, samdb, req,
509                                                             reply, base_index,
510                                                             req_src_dsa_guid, nc_list);
511                 break;
512
513         case DRSUAPI_DS_REPLICA_INFO_CURSORS: /* On MS-DRSR it is DS_REPL_INFO_CURSORS_FOR_NC */
514                 status = kccdrs_replica_get_info_cursors(mem_ctx, samdb, req, reply,
515                                                          ldb_dn_new(mem_ctx, samdb, object_dn));
516                 break;
517         case DRSUAPI_DS_REPLICA_INFO_CURSORS2: /* On MS-DRSR it is DS_REPL_INFO_CURSORS_2_FOR_NC */
518                 status = kccdrs_replica_get_info_cursors2(mem_ctx, samdb, req, reply,
519                                                           ldb_dn_new(mem_ctx, samdb, object_dn));
520                 break;
521         case DRSUAPI_DS_REPLICA_INFO_PENDING_OPS: /* On MS-DRSR it is DS_REPL_INFO_PENDING_OPS */
522                 status = kccdrs_replica_get_info_pending_ops(mem_ctx, samdb, req, reply,
523                                                              ldb_dn_new(mem_ctx, samdb, object_dn));
524                 break;
525
526         case DRSUAPI_DS_REPLICA_INFO_CURSORS3: /* On MS-DRSR it is DS_REPL_INFO_CURSORS_3_FOR_NC */
527         case DRSUAPI_DS_REPLICA_INFO_CURSORS05: /* On MS-DRSR it is DS_REPL_INFO_UPTODATE_VECTOR_V1 */
528         case DRSUAPI_DS_REPLICA_INFO_NEIGHBORS02: /* DS_REPL_INFO_REPSTO */
529         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA: /* On MS-DRSR it is DS_REPL_INFO_METADATA_FOR_OBJ */
530         case DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2: /* On MS-DRSR it is DS_REPL_INFO_METADATA_FOR_OBJ */
531         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA: /* On MS-DRSR it is DS_REPL_INFO_METADATA_FOR_ATTR_VALUE */
532         case DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2: /* On MS-DRSR it is DS_REPL_INFO_METADATA_2_FOR_ATTR_VALUE */
533         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES: /* On MS-DRSR it is DS_REPL_INFO_KCC_DSA_CONNECT_FAILURES */
534         case DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES: /* On MS-DRSR it is DS_REPL_INFO_KCC_LINK_FAILURES */
535         case DRSUAPI_DS_REPLICA_INFO_CONNECTIONS04: /* On MS-DRSR it is DS_REPL_INFO_CLIENT_CONTEXTS */
536         case DRSUAPI_DS_REPLICA_INFO_06: /* On MS-DRSR it is DS_REPL_INFO_SERVER_OUTGOING_CALLS */
537         default:
538                 DEBUG(1,(__location__ ": Unsupported DsReplicaGetInfo info_type %u\n",
539                          info_type));
540                 status = WERR_INVALID_LEVEL;
541                 break;
542         }
543
544 DONE:
545         /* put the status on the result field of the reply */
546         req->out.result = status;
547         NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaGetInfo, req);
548         return NT_STATUS_OK;
549 }