s4-kcc: we should only add to the repsFrom if it doesn't already exist
[ira/wip.git] / source4 / dsdb / kcc / kcc_periodic.c
1 /* 
2    Unix SMB/CIFS mplementation.
3    KCC service periodic handling
4    
5    Copyright (C) Andrew Tridgell 2009
6    based on repl service code
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 "lib/events/events.h"
25 #include "dsdb/samdb/samdb.h"
26 #include "auth/auth.h"
27 #include "smbd/service.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  * see if a repsFromToBlob is in a list
39  */
40 static bool reps_in_list(struct repsFromToBlob *r, struct repsFromToBlob *reps, uint32_t count)
41 {
42         int i;
43         for (i=0; i<count; i++) {
44                 if (strcmp(r->ctr.ctr1.other_info->dns_name, 
45                            reps[i].ctr.ctr1.other_info->dns_name) == 0 &&
46                     GUID_compare(&r->ctr.ctr1.source_dsa_obj_guid, 
47                                  &reps[i].ctr.ctr1.source_dsa_obj_guid) == 0) {
48                         return true;
49                 }
50         }
51         return false;
52 }
53
54
55 /*
56  * add any missing repsFrom structures to our partitions
57  */
58 static NTSTATUS kccsrv_add_repsFrom(struct kccsrv_service *s, TALLOC_CTX *mem_ctx,
59                                     struct repsFromToBlob *reps, uint32_t count)
60 {
61         struct kccsrv_partition *p;
62
63         /* update the repsFrom on all partitions */
64         for (p=s->partitions; p; p=p->next) {
65                 struct repsFromToBlob *old_reps;
66                 uint32_t old_count;
67                 WERROR werr;
68                 int i;
69                 bool modified = false;
70
71                 werr = dsdb_loadreps(s->samdb, mem_ctx, p->dn, "repsFrom", &old_reps, &old_count);
72                 if (!W_ERROR_IS_OK(werr)) {
73                         DEBUG(0,(__location__ ": Failed to load repsFrom from %s - %s\n", 
74                                  ldb_dn_get_linearized(p->dn), ldb_errstring(s->samdb)));
75                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
76                 }
77
78                 for (i=0; i<count; i++) {
79                         if (!reps_in_list(&reps[i], old_reps, old_count)) {
80                                 old_reps = talloc_realloc(mem_ctx, old_reps, struct repsFromToBlob, old_count+1);
81                                 NT_STATUS_HAVE_NO_MEMORY(old_reps);
82                                 old_reps[old_count] = reps[i];
83                                 old_count++;
84                                 modified = true;
85                         }
86                 }
87                 
88                 if (modified) {
89                         werr = dsdb_savereps(s->samdb, mem_ctx, p->dn, "repsFrom", old_reps, old_count);
90                         if (!W_ERROR_IS_OK(werr)) {
91                                 DEBUG(0,(__location__ ": Failed to save repsFrom to %s - %s\n", 
92                                          ldb_dn_get_linearized(p->dn), ldb_errstring(s->samdb)));
93                                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
94                         }
95                 }
96         }
97
98         return NT_STATUS_OK;
99
100 }
101
102 /*
103   this is the core of our initial simple KCC
104   We just add a repsFrom entry for all DCs we find that have nTDSDSA
105   objects, except for ourselves
106  */
107 static NTSTATUS kccsrv_simple_update(struct kccsrv_service *s, TALLOC_CTX *mem_ctx)
108 {
109         struct ldb_result *res;
110         int ret, i;
111         const char *attrs[] = { "objectGUID", "invocationID", NULL };
112         struct repsFromToBlob *reps = NULL;
113         uint32_t count = 0;
114
115         ret = ldb_search(s->samdb, mem_ctx, &res, s->config_dn, LDB_SCOPE_SUBTREE, 
116                          attrs, "objectClass=nTDSDSA");
117         if (ret != LDB_SUCCESS) {
118                 DEBUG(0,(__location__ ": Failed nTDSDSA search - %s\n", ldb_errstring(s->samdb)));
119                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
120         }
121
122         for (i=0; i<res->count; i++) {
123                 struct repsFromTo1 *r1;
124                 struct repsFromTo1OtherInfo oi;
125                 struct GUID ntds_guid, invocation_id;
126
127                 ntds_guid = samdb_result_guid(res->msgs[i], "objectGUID");
128                 if (GUID_compare(&ntds_guid, &s->ntds_guid) == 0) {
129                         /* don't replicate with ourselves */
130                         continue;
131                 }
132
133                 invocation_id = samdb_result_guid(res->msgs[i], "invocationID");
134
135                 reps = talloc_realloc(mem_ctx, reps, struct repsFromToBlob, count+1);
136                 NT_STATUS_HAVE_NO_MEMORY(reps);
137
138                 ZERO_STRUCT(reps[count]);
139                 ZERO_STRUCT(oi);
140                 reps[count].version = 1;
141                 r1 = &reps[count].ctr.ctr1;
142
143                 oi.dns_name                  = talloc_asprintf(mem_ctx, "%s._msdcs.%s",
144                                                                GUID_string(mem_ctx, &ntds_guid),
145                                                                lp_realm(s->task->lp_ctx));
146                 r1->other_info               = &oi;
147                 r1->source_dsa_obj_guid      = ntds_guid;
148                 r1->source_dsa_invocation_id = invocation_id;
149                 r1->replica_flags            = 
150                         DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE | 
151                         DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP | 
152                         DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS;
153                 memset(r1->schedule, 0x11, sizeof(r1->schedule));
154                 count++;
155         }
156
157         return kccsrv_add_repsFrom(s, mem_ctx, reps, count);
158 }
159
160
161 static void kccsrv_periodic_run(struct kccsrv_service *service);
162
163 static void kccsrv_periodic_handler_te(struct tevent_context *ev, struct tevent_timer *te,
164                                          struct timeval t, void *ptr)
165 {
166         struct kccsrv_service *service = talloc_get_type(ptr, struct kccsrv_service);
167         WERROR status;
168
169         service->periodic.te = NULL;
170
171         kccsrv_periodic_run(service);
172
173         status = kccsrv_periodic_schedule(service, service->periodic.interval);
174         if (!W_ERROR_IS_OK(status)) {
175                 task_server_terminate(service->task, win_errstr(status));
176                 return;
177         }
178 }
179
180 WERROR kccsrv_periodic_schedule(struct kccsrv_service *service, uint32_t next_interval)
181 {
182         TALLOC_CTX *tmp_mem;
183         struct tevent_timer *new_te;
184         struct timeval next_time;
185
186         /* prevent looping */
187         if (next_interval == 0) next_interval = 1;
188
189         next_time = timeval_current_ofs(next_interval, 50);
190
191         if (service->periodic.te) {
192                 /*
193                  * if the timestamp of the new event is higher,
194                  * as current next we don't need to reschedule
195                  */
196                 if (timeval_compare(&next_time, &service->periodic.next_event) > 0) {
197                         return WERR_OK;
198                 }
199         }
200
201         /* reset the next scheduled timestamp */
202         service->periodic.next_event = next_time;
203
204         new_te = event_add_timed(service->task->event_ctx, service,
205                                  service->periodic.next_event,
206                                  kccsrv_periodic_handler_te, service);
207         W_ERROR_HAVE_NO_MEMORY(new_te);
208
209         tmp_mem = talloc_new(service);
210         DEBUG(2,("kccsrv_periodic_schedule(%u) %sscheduled for: %s\n",
211                 next_interval,
212                 (service->periodic.te?"re":""),
213                 nt_time_string(tmp_mem, timeval_to_nttime(&next_time))));
214         talloc_free(tmp_mem);
215
216         talloc_free(service->periodic.te);
217         service->periodic.te = new_te;
218
219         return WERR_OK;
220 }
221
222 static void kccsrv_periodic_run(struct kccsrv_service *service)
223 {
224         TALLOC_CTX *mem_ctx;
225         NTSTATUS status;
226
227         DEBUG(2,("kccsrv_periodic_run(): simple update\n"));
228
229         mem_ctx = talloc_new(service);
230         status = kccsrv_simple_update(service, mem_ctx);
231         if (!NT_STATUS_IS_OK(status)) {
232                 DEBUG(0,("kccsrv_simple_update failed - %s\n", nt_errstr(status)));
233         }
234         talloc_free(mem_ctx);
235 }