idl: switched to using the WSPP names for the 'neighbour' DRS options
[abartlet/samba.git/.git] / source4 / dsdb / kcc / kcc_periodic.c
index 649efd51caab2fde4815592582de9456b5fc70f9..8d12e05178be982cfb76ad42796f280a0a77699a 100644 (file)
@@ -26,6 +26,7 @@
 #include "auth/auth.h"
 #include "smbd/service.h"
 #include "lib/messaging/irpc.h"
+#include "dsdb/kcc/kcc_connection.h"
 #include "dsdb/kcc/kcc_service.h"
 #include "lib/ldb/include/ldb_errors.h"
 #include "../lib/util/dlinklist.h"
 #include "param/param.h"
 
 /*
- * add a repsFrom to all our partitions
+ * see if a repsFromToBlob is in a list
  */
+static bool reps_in_list(struct repsFromToBlob *r, struct repsFromToBlob *reps, uint32_t count)
+{
+       int i;
+       for (i=0; i<count; i++) {
+               if (strcmp(r->ctr.ctr1.other_info->dns_name, 
+                          reps[i].ctr.ctr1.other_info->dns_name) == 0 &&
+                   GUID_compare(&r->ctr.ctr1.source_dsa_obj_guid, 
+                                &reps[i].ctr.ctr1.source_dsa_obj_guid) == 0) {
+                       return true;
+               }
+       }
+       return false;
+}
 
 
+/*
+ * add any missing repsFrom structures to our partitions
+ */
+static NTSTATUS kccsrv_add_repsFrom(struct kccsrv_service *s, TALLOC_CTX *mem_ctx,
+                                   struct repsFromToBlob *reps, uint32_t count)
+{
+       struct kccsrv_partition *p;
+
+       /* update the repsFrom on all partitions */
+       for (p=s->partitions; p; p=p->next) {
+               struct repsFromToBlob *old_reps;
+               uint32_t old_count;
+               WERROR werr;
+               int i;
+               bool modified = false;
+
+               werr = dsdb_loadreps(s->samdb, mem_ctx, p->dn, "repsFrom", &old_reps, &old_count);
+               if (!W_ERROR_IS_OK(werr)) {
+                       DEBUG(0,(__location__ ": Failed to load repsFrom from %s - %s\n", 
+                                ldb_dn_get_linearized(p->dn), ldb_errstring(s->samdb)));
+                       return NT_STATUS_INTERNAL_DB_CORRUPTION;
+               }
+
+               /* add any new ones */
+               for (i=0; i<count; i++) {
+                       if (!reps_in_list(&reps[i], old_reps, old_count)) {
+                               old_reps = talloc_realloc(mem_ctx, old_reps, struct repsFromToBlob, old_count+1);
+                               NT_STATUS_HAVE_NO_MEMORY(old_reps);
+                               old_reps[old_count] = reps[i];
+                               old_count++;
+                               modified = true;
+                       }
+               }
+
+               /* remove any stale ones */
+               for (i=0; i<old_count; i++) {
+                       if (!reps_in_list(&old_reps[i], reps, count)) {
+                               memmove(&old_reps[i], &old_reps[i+1], (old_count-(i+1))*sizeof(old_reps[0]));
+                               old_count--;
+                               i--;
+                               modified = true;
+                       }
+               }
+               
+               if (modified) {
+                       werr = dsdb_savereps(s->samdb, mem_ctx, p->dn, "repsFrom", old_reps, old_count);
+                       if (!W_ERROR_IS_OK(werr)) {
+                               DEBUG(0,(__location__ ": Failed to save repsFrom to %s - %s\n", 
+                                        ldb_dn_get_linearized(p->dn), ldb_errstring(s->samdb)));
+                               return NT_STATUS_INTERNAL_DB_CORRUPTION;
+                       }
+               }
+       }
+
+       return NT_STATUS_OK;
+
+}
+
 /*
   this is the core of our initial simple KCC
   We just add a repsFrom entry for all DCs we find that have nTDSDSA
   objects, except for ourselves
  */
-static NTSTATUS kccsrv_simple_update(struct kccsrv_service *s, TALLOC_CTX *mem_ctx)
+NTSTATUS kccsrv_simple_update(struct kccsrv_service *s, TALLOC_CTX *mem_ctx)
 {
        struct ldb_result *res;
        int ret, i;
        const char *attrs[] = { "objectGUID", "invocationID", NULL };
-       struct ldb_message *msg;
-       struct ldb_message_element *el;
-       struct kccsrv_partition *p;
+       struct repsFromToBlob *reps = NULL;
+       uint32_t count = 0;
+       struct kcc_connection_list *ntds_conn, *dsa_conn;
 
        ret = ldb_search(s->samdb, mem_ctx, &res, s->config_dn, LDB_SCOPE_SUBTREE, 
                         attrs, "objectClass=nTDSDSA");
@@ -60,21 +132,14 @@ static NTSTATUS kccsrv_simple_update(struct kccsrv_service *s, TALLOC_CTX *mem_c
                return NT_STATUS_INTERNAL_DB_CORRUPTION;
        }
 
-       msg = ldb_msg_new(mem_ctx);
-       NT_STATUS_HAVE_NO_MEMORY(msg);
+       /* get the current list of connections */
+       ntds_conn = kccsrv_find_connections(s, mem_ctx);
 
-       ret = ldb_msg_add_empty(msg, "repsFrom", LDB_FLAG_MOD_REPLACE, &el);
-       if (ret != LDB_SUCCESS) {
-               return NT_STATUS_NO_MEMORY;
-       }
+       dsa_conn = talloc_zero(mem_ctx, struct kcc_connection_list);
 
        for (i=0; i<res->count; i++) {
-               struct repsFromToBlob r;
                struct repsFromTo1 *r1;
-               struct repsFromTo1OtherInfo oi;
                struct GUID ntds_guid, invocation_id;
-               struct ldb_val v;
-               enum ndr_err_code ndr_err;
 
                ntds_guid = samdb_result_guid(res->msgs[i], "objectGUID");
                if (GUID_compare(&ntds_guid, &s->ntds_guid) == 0) {
@@ -84,51 +149,38 @@ static NTSTATUS kccsrv_simple_update(struct kccsrv_service *s, TALLOC_CTX *mem_c
 
                invocation_id = samdb_result_guid(res->msgs[i], "invocationID");
 
-               ZERO_STRUCT(r);
-               ZERO_STRUCT(oi);
-               r.version = 1;
-               r1 = &r.ctr.ctr1;
+               reps = talloc_realloc(mem_ctx, reps, struct repsFromToBlob, count+1);
+               NT_STATUS_HAVE_NO_MEMORY(reps);
 
-               oi.dns_name                  = talloc_asprintf(mem_ctx, "%s._msdcs.%s",
+               ZERO_STRUCT(reps[count]);
+               reps[count].version = 1;
+               r1 = &reps[count].ctr.ctr1;
+
+               r1->other_info               = talloc_zero(reps, struct repsFromTo1OtherInfo);
+               r1->other_info->dns_name     = talloc_asprintf(r1->other_info, "%s._msdcs.%s",
                                                               GUID_string(mem_ctx, &ntds_guid),
-                                                              lp_realm(s->task->lp_ctx));
-               r1->other_info               = &oi;
+                                                              lp_dnsdomain(s->task->lp_ctx));
                r1->source_dsa_obj_guid      = ntds_guid;
                r1->source_dsa_invocation_id = invocation_id;
                r1->replica_flags            = 
-                       DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE | 
-                       DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP | 
-                       DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS;
+                       DRSUAPI_DRS_WRIT_REP |
+                       DRSUAPI_DRS_INIT_SYNC |
+                       DRSUAPI_DRS_PER_SYNC;
                memset(r1->schedule, 0x11, sizeof(r1->schedule));
 
+               dsa_conn->servers = talloc_realloc(dsa_conn, dsa_conn->servers,
+                                                 struct kcc_connection,
+                                                 dsa_conn->count + 1);
+               NT_STATUS_HAVE_NO_MEMORY(dsa_conn->servers);
+               dsa_conn->servers[dsa_conn->count].dsa_guid = r1->source_dsa_obj_guid;
+               dsa_conn->count++;
 
-               ndr_err = ndr_push_struct_blob(&v, mem_ctx, 
-                                              lp_iconv_convenience(s->task->lp_ctx),
-                                              &r,
-                                              (ndr_push_flags_fn_t)ndr_push_repsFromToBlob);
-               if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                       DEBUG(0,(__location__ ": Failed tp push repsFrom blob\n"));
-                       return NT_STATUS_INTERNAL_ERROR;
-               }
-
-               el->values = talloc_realloc(msg, el->values, struct ldb_val, el->num_values+1);
-               NT_STATUS_HAVE_NO_MEMORY(el->values);
-               el->values[el->num_values] = v;
-               el->num_values++;
+               count++;
        }
 
-       /* replace the repsFrom on all partitions */
-       for (p=s->partitions; p; p=p->next) {
-               msg->dn = p->dn;
-               ret = ldb_modify(s->samdb, msg);
-               if (ret != LDB_SUCCESS) {
-                       DEBUG(0,(__location__ ": Failed to store repsFrom for %s - %s\n",
-                                ldb_dn_get_linearized(msg->dn), ldb_errstring(s->samdb)));
-                       return NT_STATUS_INTERNAL_ERROR;
-               }
-       }
+       kccsrv_apply_connections(s, ntds_conn, dsa_conn);
 
-       return NT_STATUS_OK;
+       return kccsrv_add_repsFrom(s, mem_ctx, reps, count);
 }
 
 
@@ -146,7 +198,7 @@ static void kccsrv_periodic_handler_te(struct tevent_context *ev, struct tevent_
 
        status = kccsrv_periodic_schedule(service, service->periodic.interval);
        if (!W_ERROR_IS_OK(status)) {
-               task_server_terminate(service->task, win_errstr(status));
+               task_server_terminate(service->task, win_errstr(status), true);
                return;
        }
 }
@@ -205,5 +257,10 @@ static void kccsrv_periodic_run(struct kccsrv_service *service)
        if (!NT_STATUS_IS_OK(status)) {
                DEBUG(0,("kccsrv_simple_update failed - %s\n", nt_errstr(status)));
        }
+
+       status = kccsrv_check_deleted(service, mem_ctx);
+       if (!NT_STATUS_IS_OK(status)) {
+               DEBUG(0,("kccsrv_check_deleted failed - %s\n", nt_errstr(status)));
+       }
        talloc_free(mem_ctx);
 }