82cb7155ac597e027c6641573aed3f612b4823f6
[ira/wip.git] / source4 / dsdb / dns / dns_update.c
1 /*
2    Unix SMB/CIFS mplementation.
3
4    DNS udpate service
5
6    Copyright (C) Andrew Tridgell 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 /*
24   this module auto-creates the named.conf.update file, which tells
25   bind9 what KRB5 principals it should accept for updates to our zone
26
27   It also uses the samba_dnsupdate script to auto-create the right DNS
28   names for ourselves as a DC in the domain, using TSIG-GSS
29  */
30
31 #include "includes.h"
32 #include "dsdb/samdb/samdb.h"
33 #include "auth/auth.h"
34 #include "smbd/service.h"
35 #include "lib/messaging/irpc.h"
36 #include "param/param.h"
37 #include "system/filesys.h"
38 #include "libcli/composite/composite.h"
39
40 struct dnsupdate_service {
41         struct task_server *task;
42         struct auth_session_info *system_session_info;
43         struct ldb_context *samdb;
44
45         /* status for periodic config file update */
46         struct {
47                 uint32_t interval;
48                 struct tevent_timer *te;
49                 struct composite_context *c;
50                 NTSTATUS status;
51         } confupdate;
52
53         /* status for periodic DNS name check */
54         struct {
55                 uint32_t interval;
56                 struct tevent_timer *te;
57                 struct composite_context *c;
58                 NTSTATUS status;
59         } nameupdate;
60 };
61
62 /*
63   called when rndc reload has finished
64  */
65 static void dnsupdate_rndc_done(struct composite_context *c)
66 {
67         struct dnsupdate_service *service = talloc_get_type_abort(c->async.private_data,
68                                                                   struct dnsupdate_service);
69         service->confupdate.status = composite_wait(c);
70         talloc_free(c);
71         service->confupdate.c = NULL;
72         if (!NT_STATUS_IS_OK(service->confupdate.status)) {
73                 DEBUG(0,(__location__ ": Failed rndc update - %s\n",
74                          nt_errstr(service->confupdate.status)));
75         } else {
76                 DEBUG(3,("Completed rndc reload OK\n"));
77         }
78 }
79
80 /*
81   called every 'dnsupdate:conf interval' seconds
82  */
83 static void dnsupdate_rebuild(struct dnsupdate_service *service)
84 {
85         int ret;
86         struct ldb_result *res;
87         const char *tmp_path, *path;
88         int fd;
89         unsigned int i;
90         const char *attrs[] = { "sAMAccountName", NULL };
91         const char *realm = lp_realm(service->task->lp_ctx);
92         TALLOC_CTX *tmp_ctx = talloc_new(service);
93
94         ret = ldb_search(service->samdb, tmp_ctx, &res, NULL, LDB_SCOPE_SUBTREE,
95                          attrs, "(&(primaryGroupID=%u)(objectClass=computer))",
96                          DOMAIN_RID_DCS);
97         if (ret != LDB_SUCCESS) {
98                 DEBUG(0,(__location__ ": Unable to find DCs list - %s", ldb_errstring(service->samdb)));
99                 talloc_free(tmp_ctx);
100                 return;
101         }
102
103         path = lp_parm_string(service->task->lp_ctx, NULL, "dnsupdate", "path");
104         if (path == NULL) {
105                 path = private_path(tmp_ctx, service->task->lp_ctx, "named.conf.update");
106         }
107
108         tmp_path = talloc_asprintf(tmp_ctx, "%s.tmp", path);
109         if (path == NULL || tmp_path == NULL) {
110                 DEBUG(0,(__location__ ": Unable to get paths"));
111                 talloc_free(tmp_ctx);
112                 return;
113         }
114
115         unlink(tmp_path);
116         fd = open(tmp_path, O_CREAT|O_TRUNC|O_WRONLY, 0444);
117         if (fd == -1) {
118                 DEBUG(1,(__location__ ": Unable to open %s - %s\n", tmp_path, strerror(errno)));
119                 talloc_free(tmp_ctx);
120                 return;
121         }
122
123         dprintf(fd, "/* this file is auto-generated - do not edit */\n");
124         dprintf(fd, "update-policy {\n");
125         dprintf(fd, "\tgrant %s ms-self * A AAAA;\n", realm);
126         dprintf(fd, "\tgrant administrator@%s wildcard * A AAAA SRV CNAME TXT;\n", realm);
127
128         for (i=0; i<res->count; i++) {
129                 const char *acctname;
130                 acctname = ldb_msg_find_attr_as_string(res->msgs[i],
131                                                        "sAMAccountName", NULL);
132                 if (!acctname) continue;
133                 dprintf(fd, "\tgrant %s@%s wildcard * A AAAA SRV CNAME;\n",
134                         acctname, realm);
135         }
136         dprintf(fd, "};\n");
137         close(fd);
138
139         if (service->confupdate.c != NULL) {
140                 talloc_free(service->confupdate.c);
141                 service->confupdate.c = NULL;
142         }
143
144         if (NT_STATUS_IS_OK(service->confupdate.status) &&
145             file_compare(tmp_path, path) == true) {
146                 unlink(tmp_path);
147                 talloc_free(tmp_ctx);
148                 return;
149         }
150
151         if (rename(tmp_path, path) != 0) {
152                 DEBUG(0,(__location__ ": Failed to rename %s to %s - %s\n",
153                          tmp_path, path, strerror(errno)));
154                 talloc_free(tmp_ctx);
155                 return;
156         }
157
158         DEBUG(2,("Loading new DNS update grant rules\n"));
159         service->confupdate.c = samba_runcmd(service->task->event_ctx, service,
160                                            timeval_current_ofs(10, 0),
161                                            2, 0,
162                                            lp_rndc_command(service->task->lp_ctx),
163                                            "reload", NULL);
164         service->confupdate.c->async.fn = dnsupdate_rndc_done;
165         service->confupdate.c->async.private_data = service;
166
167         talloc_free(tmp_ctx);
168 }
169
170 static NTSTATUS dnsupdate_confupdate_schedule(struct dnsupdate_service *service);
171
172 /*
173   called every 'dnsupdate:conf interval' seconds
174  */
175 static void dnsupdate_confupdate_handler_te(struct tevent_context *ev, struct tevent_timer *te,
176                                           struct timeval t, void *ptr)
177 {
178         struct dnsupdate_service *service = talloc_get_type(ptr, struct dnsupdate_service);
179
180         dnsupdate_rebuild(service);
181         dnsupdate_confupdate_schedule(service);
182 }
183
184
185 static NTSTATUS dnsupdate_confupdate_schedule(struct dnsupdate_service *service)
186 {
187         service->confupdate.te = tevent_add_timer(service->task->event_ctx, service,
188                                                 timeval_current_ofs(service->confupdate.interval, 0),
189                                                 dnsupdate_confupdate_handler_te, service);
190         NT_STATUS_HAVE_NO_MEMORY(service->confupdate.te);
191         return NT_STATUS_OK;
192 }
193
194
195 /*
196   called when dns update script has finished
197  */
198 static void dnsupdate_nameupdate_done(struct composite_context *c)
199 {
200         struct dnsupdate_service *service = talloc_get_type_abort(c->async.private_data,
201                                                                   struct dnsupdate_service);
202         service->nameupdate.status = composite_wait(c);
203         talloc_free(c);
204         service->nameupdate.c = NULL;
205         if (!NT_STATUS_IS_OK(service->nameupdate.status)) {
206                 DEBUG(0,(__location__ ": Failed DNS update - %s\n",
207                          nt_errstr(service->nameupdate.status)));
208         } else {
209                 DEBUG(3,("Completed DNS update check OK\n"));
210         }
211 }
212
213 /*
214   called every 'dnsupdate:name interval' seconds
215  */
216 static void dnsupdate_check_names(struct dnsupdate_service *service)
217 {
218         /* kill any existing child */
219         if (service->nameupdate.c != NULL) {
220                 talloc_free(service->nameupdate.c);
221                 service->nameupdate.c = NULL;
222         }
223
224         DEBUG(3,("Calling DNS name update script\n"));
225         service->nameupdate.c = samba_runcmd(service->task->event_ctx, service,
226                                              timeval_current_ofs(10, 0),
227                                              2, 0,
228                                              lp_dns_update_command(service->task->lp_ctx),
229                                              NULL);
230         service->nameupdate.c->async.fn = dnsupdate_nameupdate_done;
231         service->nameupdate.c->async.private_data = service;
232 }
233
234 static NTSTATUS dnsupdate_nameupdate_schedule(struct dnsupdate_service *service);
235
236 /*
237   called every 'dnsupdate:name interval' seconds
238  */
239 static void dnsupdate_nameupdate_handler_te(struct tevent_context *ev, struct tevent_timer *te,
240                                             struct timeval t, void *ptr)
241 {
242         struct dnsupdate_service *service = talloc_get_type(ptr, struct dnsupdate_service);
243
244         dnsupdate_check_names(service);
245         dnsupdate_nameupdate_schedule(service);
246 }
247
248
249 static NTSTATUS dnsupdate_nameupdate_schedule(struct dnsupdate_service *service)
250 {
251         service->nameupdate.te = tevent_add_timer(service->task->event_ctx, service,
252                                                   timeval_current_ofs(service->nameupdate.interval, 0),
253                                                   dnsupdate_nameupdate_handler_te, service);
254         NT_STATUS_HAVE_NO_MEMORY(service->nameupdate.te);
255         return NT_STATUS_OK;
256 }
257
258 /*
259   startup the dns update task
260 */
261 static void dnsupdate_task_init(struct task_server *task)
262 {
263         NTSTATUS status;
264         struct dnsupdate_service *service;
265
266         if (lp_server_role(task->lp_ctx) != ROLE_DOMAIN_CONTROLLER) {
267                 /* not useful for non-DC */
268                 return;
269         }
270
271         task_server_set_title(task, "task[dnsupdate]");
272
273         service = talloc_zero(task, struct dnsupdate_service);
274         if (!service) {
275                 task_server_terminate(task, "dnsupdate_task_init: out of memory", true);
276                 return;
277         }
278         service->task           = task;
279         task->private_data      = service;
280
281         service->system_session_info = system_session(service->task->lp_ctx);
282         if (!service->system_session_info) {
283                 task_server_terminate(task,
284                                       "dnsupdate: Failed to obtain server credentials\n",
285                                       true);
286                 return;
287         }
288
289         service->samdb = samdb_connect(service, service->task->event_ctx, task->lp_ctx,
290                                        service->system_session_info);
291         if (!service->samdb) {
292                 task_server_terminate(task, "dnsupdate: Failed to connect to local samdb\n",
293                                       true);
294                 return;
295         }
296
297         service->confupdate.interval    = lp_parm_int(task->lp_ctx, NULL,
298                                                       "dnsupdate", "config interval", 60); /* in seconds */
299
300         service->nameupdate.interval    = lp_parm_int(task->lp_ctx, NULL,
301                                                       "dnsupdate", "name interval", 600); /* in seconds */
302
303         dnsupdate_rebuild(service);
304         status = dnsupdate_confupdate_schedule(service);
305         if (!NT_STATUS_IS_OK(status)) {
306                 task_server_terminate(task, talloc_asprintf(task,
307                                       "dnsupdate: Failed to confupdate schedule: %s\n",
308                                                             nt_errstr(status)), true);
309                 return;
310         }
311
312         dnsupdate_check_names(service);
313         status = dnsupdate_nameupdate_schedule(service);
314         if (!NT_STATUS_IS_OK(status)) {
315                 task_server_terminate(task, talloc_asprintf(task,
316                                       "dnsupdate: Failed to nameupdate schedule: %s\n",
317                                                             nt_errstr(status)), true);
318                 return;
319         }
320
321         irpc_add_name(task->msg_ctx, "dnsupdate");
322
323         /* create the intial file */
324         dnsupdate_rebuild(service);
325
326 }
327
328 /*
329   register ourselves as a available server
330 */
331 NTSTATUS server_service_dnsupdate_init(void)
332 {
333         return register_server_service("dnsupdate", dnsupdate_task_init);
334 }