?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Ignore machine-check MSRs
[freebsd-src/fkvm-freebsd.git] / contrib / bind9 / bin / rndc / rndc.c
blobb916aea88bd063f496cc79ec6324e9acfeb4dde2
1 /*
2 * Copyright (C) 2004-2006, 2008 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 2000-2003 Internet Software Consortium.
4 *
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 * PERFORMANCE OF THIS SOFTWARE.
16 */
17
18 /* $Id: rndc.c,v 1.96.18.17.42.3 2008/07/23 23:16:43 marka Exp $ */
19
20 /*! \file */
21
22 /*
23 * Principal Author: DCL
24 */
25
26 #include <config.h>
27
28 #include <stdlib.h>
29
30 #include <isc/app.h>
31 #include <isc/buffer.h>
32 #include <isc/commandline.h>
33 #include <isc/file.h>
34 #include <isc/log.h>
35 #include <isc/net.h>
36 #include <isc/mem.h>
37 #include <isc/random.h>
38 #include <isc/socket.h>
39 #include <isc/stdtime.h>
40 #include <isc/string.h>
41 #include <isc/task.h>
42 #include <isc/thread.h>
43 #include <isc/util.h>
44
45 #include <isccfg/namedconf.h>
46
47 #include <isccc/alist.h>
48 #include <isccc/base64.h>
49 #include <isccc/cc.h>
50 #include <isccc/ccmsg.h>
51 #include <isccc/result.h>
52 #include <isccc/sexpr.h>
53 #include <isccc/types.h>
54 #include <isccc/util.h>
55
56 #include <dns/name.h>
57
58 #include <bind9/getaddresses.h>
59
60 #include "util.h"
61
62 #define SERVERADDRS 10
63
64 char *progname;
65 isc_boolean_t verbose;
66
67 static const char *admin_conffile;
68 static const char *admin_keyfile;
69 static const char *version = VERSION;
70 static const char *servername = NULL;
71 static isc_sockaddr_t serveraddrs[SERVERADDRS];
72 static isc_sockaddr_t local4, local6;
73 static isc_boolean_t local4set = ISC_FALSE, local6set = ISC_FALSE;
74 static int nserveraddrs;
75 static int currentaddr = 0;
76 static unsigned int remoteport = 0;
77 static isc_socketmgr_t *socketmgr = NULL;
78 static unsigned char databuf[2048];
79 static isccc_ccmsg_t ccmsg;
80 static isccc_region_t secret;
81 static isc_boolean_t failed = ISC_FALSE;
82 static isc_mem_t *mctx;
83 static int sends, recvs, connects;
84 static char *command;
85 static char *args;
86 static char program[256];
87 static isc_socket_t *sock = NULL;
88 static isc_uint32_t serial;
89
90 static void rndc_startconnect(isc_sockaddr_t *addr, isc_task_t *task);
91
92 static void
93 usage(int status) {
94 fprintf(stderr, "\
95 Usage: %s [-c config] [-s server] [-p port]\n\
96 [-k key-file ] [-y key] [-V] command\n\
97 \n\
98 command is one of the following:\n\
99 \n\
100 reload Reload configuration file and zones.\n\
101 reload zone [class [view]]\n\
102 Reload a single zone.\n\
103 refresh zone [class [view]]\n\
104 Schedule immediate maintenance for a zone.\n\
105 retransfer zone [class [view]]\n\
106 Retransfer a single zone without checking serial number.\n\
107 freeze Suspend updates to all dynamic zones.\n\
108 freeze zone [class [view]]\n\
109 Suspend updates to a dynamic zone.\n\
110 thaw Enable updates to all dynamic zones and reload them.\n\
111 thaw zone [class [view]]\n\
112 Enable updates to a frozen dynamic zone and reload it.\n\
113 notify zone [class [view]]\n\
114 Resend NOTIFY messages for the zone.\n\
115 reconfig Reload configuration file and new zones only.\n\
116 stats Write server statistics to the statistics file.\n\
117 querylog Toggle query logging.\n\
118 dumpdb [-all|-cache|-zones] [view ...]\n\
119 Dump cache(s) to the dump file (named_dump.db).\n\
120 stop Save pending updates to master files and stop the server.\n\
121 stop -p Save pending updates to master files and stop the server\n\
122 reporting process id.\n\
123 halt Stop the server without saving pending updates.\n\
124 halt -p Stop the server without saving pending updates reporting\n\
125 process id.\n\
126 trace Increment debugging level by one.\n\
127 trace level Change the debugging level.\n\
128 notrace Set debugging level to 0.\n\
129 flush Flushes all of the server's caches.\n\
130 flush [view] Flushes the server's cache for a view.\n\
131 flushname name [view]\n\
132 Flush the given name from the server's cache(s)\n\
133 status Display status of the server.\n\
134 recursing Dump the queries that are currently recursing (named.recursing)\n\
135 validation newstate [view]\n\
136 Enable / disable DNSSEC validation.\n\
137 *restart Restart the server.\n\
138 \n\
139 * == not yet implemented\n\
140 Version: %s\n",
141 progname, version);
142
143 exit(status);
144 }
145
146 static void
147 get_addresses(const char *host, in_port_t port) {
148 isc_result_t result;
149 int found = 0, count;
150
151 if (*host == '/') {
152 result = isc_sockaddr_frompath(&serveraddrs[nserveraddrs],
153 host);
154 if (result == ISC_R_SUCCESS)
155 nserveraddrs++;
156 } else {
157 count = SERVERADDRS - nserveraddrs;
158 result = bind9_getaddresses(host, port,
159 &serveraddrs[nserveraddrs],
160 count, &found);
161 nserveraddrs += found;
162 }
163 if (result != ISC_R_SUCCESS)
164 fatal("couldn't get address for '%s': %s",
165 host, isc_result_totext(result));
166 INSIST(nserveraddrs > 0);
167 }
168
169 static void
170 rndc_senddone(isc_task_t *task, isc_event_t *event) {
171 isc_socketevent_t *sevent = (isc_socketevent_t *)event;
172
173 UNUSED(task);
174
175 sends--;
176 if (sevent->result != ISC_R_SUCCESS)
177 fatal("send failed: %s", isc_result_totext(sevent->result));
178 isc_event_free(&event);
179 if (sends == 0 && recvs == 0) {
180 isc_socket_detach(&sock);
181 isc_task_shutdown(task);
182 RUNTIME_CHECK(isc_app_shutdown() == ISC_R_SUCCESS);
183 }
184 }
185
186 static void
187 rndc_recvdone(isc_task_t *task, isc_event_t *event) {
188 isccc_sexpr_t *response = NULL;
189 isccc_sexpr_t *data;
190 isccc_region_t source;
191 char *errormsg = NULL;
192 char *textmsg = NULL;
193 isc_result_t result;
194
195 recvs--;
196
197 if (ccmsg.result == ISC_R_EOF)
198 fatal("connection to remote host closed\n"
199 "This may indicate that\n"
200 "* the remote server is using an older version of"
201 " the command protocol,\n"
202 "* this host is not authorized to connect,\n"
203 "* the clocks are not syncronized, or\n"
204 "* the key is invalid.");
205
206 if (ccmsg.result != ISC_R_SUCCESS)
207 fatal("recv failed: %s", isc_result_totext(ccmsg.result));
208
209 source.rstart = isc_buffer_base(&ccmsg.buffer);
210 source.rend = isc_buffer_used(&ccmsg.buffer);
211
212 DO("parse message", isccc_cc_fromwire(&source, &response, &secret));
213
214 data = isccc_alist_lookup(response, "_data");
215 if (data == NULL)
216 fatal("no data section in response");
217 result = isccc_cc_lookupstring(data, "err", &errormsg);
218 if (result == ISC_R_SUCCESS) {
219 failed = ISC_TRUE;
220 fprintf(stderr, "%s: '%s' failed: %s\n",
221 progname, command, errormsg);
222 }
223 else if (result != ISC_R_NOTFOUND)
224 fprintf(stderr, "%s: parsing response failed: %s\n",
225 progname, isc_result_totext(result));
226
227 result = isccc_cc_lookupstring(data, "text", &textmsg);
228 if (result == ISC_R_SUCCESS)
229 printf("%s\n", textmsg);
230 else if (result != ISC_R_NOTFOUND)
231 fprintf(stderr, "%s: parsing response failed: %s\n",
232 progname, isc_result_totext(result));
233
234 isc_event_free(&event);
235 isccc_sexpr_free(&response);
236 if (sends == 0 && recvs == 0) {
237 isc_socket_detach(&sock);
238 isc_task_shutdown(task);
239 RUNTIME_CHECK(isc_app_shutdown() == ISC_R_SUCCESS);
240 }
241 }
242
243 static void
244 rndc_recvnonce(isc_task_t *task, isc_event_t *event) {
245 isccc_sexpr_t *response = NULL;
246 isccc_sexpr_t *_ctrl;
247 isccc_region_t source;
248 isc_result_t result;
249 isc_uint32_t nonce;
250 isccc_sexpr_t *request = NULL;
251 isccc_time_t now;
252 isc_region_t r;
253 isccc_sexpr_t *data;
254 isccc_region_t message;
255 isc_uint32_t len;
256 isc_buffer_t b;
257
258 recvs--;
259
260 if (ccmsg.result == ISC_R_EOF)
261 fatal("connection to remote host closed\n"
262 "This may indicate that\n"
263 "* the remote server is using an older version of"
264 " the command protocol,\n"
265 "* this host is not authorized to connect,\n"
266 "* the clocks are not syncronized, or\n"
267 "* the key is invalid.");
268
269 if (ccmsg.result != ISC_R_SUCCESS)
270 fatal("recv failed: %s", isc_result_totext(ccmsg.result));
271
272 source.rstart = isc_buffer_base(&ccmsg.buffer);
273 source.rend = isc_buffer_used(&ccmsg.buffer);
274
275 DO("parse message", isccc_cc_fromwire(&source, &response, &secret));
276
277 _ctrl = isccc_alist_lookup(response, "_ctrl");
278 if (_ctrl == NULL)
279 fatal("_ctrl section missing");
280 nonce = 0;
281 if (isccc_cc_lookupuint32(_ctrl, "_nonce", &nonce) != ISC_R_SUCCESS)
282 nonce = 0;
283
284 isc_stdtime_get(&now);
285
286 DO("create message", isccc_cc_createmessage(1, NULL, NULL, ++serial,
287 now, now + 60, &request));
288 data = isccc_alist_lookup(request, "_data");
289 if (data == NULL)
290 fatal("_data section missing");
291 if (isccc_cc_definestring(data, "type", args) == NULL)
292 fatal("out of memory");
293 if (nonce != 0) {
294 _ctrl = isccc_alist_lookup(request, "_ctrl");
295 if (_ctrl == NULL)
296 fatal("_ctrl section missing");
297 if (isccc_cc_defineuint32(_ctrl, "_nonce", nonce) == NULL)
298 fatal("out of memory");
299 }
300 message.rstart = databuf + 4;
301 message.rend = databuf + sizeof(databuf);
302 DO("render message", isccc_cc_towire(request, &message, &secret));
303 len = sizeof(databuf) - REGION_SIZE(message);
304 isc_buffer_init(&b, databuf, 4);
305 isc_buffer_putuint32(&b, len - 4);
306 r.length = len;
307 r.base = databuf;
308
309 isccc_ccmsg_cancelread(&ccmsg);
310 DO("schedule recv", isccc_ccmsg_readmessage(&ccmsg, task,
311 rndc_recvdone, NULL));
312 recvs++;
313 DO("send message", isc_socket_send(sock, &r, task, rndc_senddone,
314 NULL));
315 sends++;
316
317 isc_event_free(&event);
318 isccc_sexpr_free(&response);
319 return;
320 }
321
322 static void
323 rndc_connected(isc_task_t *task, isc_event_t *event) {
324 char socktext[ISC_SOCKADDR_FORMATSIZE];
325 isc_socketevent_t *sevent = (isc_socketevent_t *)event;
326 isccc_sexpr_t *request = NULL;
327 isccc_sexpr_t *data;
328 isccc_time_t now;
329 isccc_region_t message;
330 isc_region_t r;
331 isc_uint32_t len;
332 isc_buffer_t b;
333 isc_result_t result;
334
335 connects--;
336
337 if (sevent->result != ISC_R_SUCCESS) {
338 isc_sockaddr_format(&serveraddrs[currentaddr], socktext,
339 sizeof(socktext));
340 if (sevent->result != ISC_R_CANCELED &&
341 ++currentaddr < nserveraddrs)
342 {
343 notify("connection failed: %s: %s", socktext,
344 isc_result_totext(sevent->result));
345 isc_socket_detach(&sock);
346 isc_event_free(&event);
347 rndc_startconnect(&serveraddrs[currentaddr], task);
348 return;
349 } else
350 fatal("connect failed: %s: %s", socktext,
351 isc_result_totext(sevent->result));
352 }
353
354 isc_stdtime_get(&now);
355 DO("create message", isccc_cc_createmessage(1, NULL, NULL, ++serial,
356 now, now + 60, &request));
357 data = isccc_alist_lookup(request, "_data");
358 if (data == NULL)
359 fatal("_data section missing");
360 if (isccc_cc_definestring(data, "type", "null") == NULL)
361 fatal("out of memory");
362 message.rstart = databuf + 4;
363 message.rend = databuf + sizeof(databuf);
364 DO("render message", isccc_cc_towire(request, &message, &secret));
365 len = sizeof(databuf) - REGION_SIZE(message);
366 isc_buffer_init(&b, databuf, 4);
367 isc_buffer_putuint32(&b, len - 4);
368 r.length = len;
369 r.base = databuf;
370
371 isccc_ccmsg_init(mctx, sock, &ccmsg);
372 isccc_ccmsg_setmaxsize(&ccmsg, 1024);
373
374 DO("schedule recv", isccc_ccmsg_readmessage(&ccmsg, task,
375 rndc_recvnonce, NULL));
376 recvs++;
377 DO("send message", isc_socket_send(sock, &r, task, rndc_senddone,
378 NULL));
379 sends++;
380 isc_event_free(&event);
381 }
382
383 static void
384 rndc_startconnect(isc_sockaddr_t *addr, isc_task_t *task) {
385 isc_result_t result;
386 int pf;
387 isc_sockettype_t type;
388
389 char socktext[ISC_SOCKADDR_FORMATSIZE];
390
391 isc_sockaddr_format(addr, socktext, sizeof(socktext));
392
393 notify("using server %s (%s)", servername, socktext);
394
395 pf = isc_sockaddr_pf(addr);
396 if (pf == AF_INET || pf == AF_INET6)
397 type = isc_sockettype_tcp;
398 else
399 type = isc_sockettype_unix;
400 DO("create socket", isc_socket_create(socketmgr, pf, type, &sock));
401 switch (isc_sockaddr_pf(addr)) {
402 case AF_INET:
403 DO("bind socket", isc_socket_bind(sock, &local4, 0));
404 break;
405 case AF_INET6:
406 DO("bind socket", isc_socket_bind(sock, &local6, 0));
407 break;
408 default:
409 break;
410 }
411 DO("connect", isc_socket_connect(sock, addr, task, rndc_connected,
412 NULL));
413 connects++;
414 }
415
416 static void
417 rndc_start(isc_task_t *task, isc_event_t *event) {
418 isc_event_free(&event);
419
420 currentaddr = 0;
421 rndc_startconnect(&serveraddrs[currentaddr], task);
422 }
423
424 static void
425 parse_config(isc_mem_t *mctx, isc_log_t *log, const char *keyname,
426 cfg_parser_t **pctxp, cfg_obj_t **configp)
427 {
428 isc_result_t result;
429 const char *conffile = admin_conffile;
430 const cfg_obj_t *addresses = NULL;
431 const cfg_obj_t *defkey = NULL;
432 const cfg_obj_t *options = NULL;
433 const cfg_obj_t *servers = NULL;
434 const cfg_obj_t *server = NULL;
435 const cfg_obj_t *keys = NULL;
436 const cfg_obj_t *key = NULL;
437 const cfg_obj_t *defport = NULL;
438 const cfg_obj_t *secretobj = NULL;
439 const cfg_obj_t *algorithmobj = NULL;
440 cfg_obj_t *config = NULL;
441 const cfg_obj_t *address = NULL;
442 const cfg_listelt_t *elt;
443 const char *secretstr;
444 const char *algorithm;
445 static char secretarray[1024];
446 const cfg_type_t *conftype = &cfg_type_rndcconf;
447 isc_boolean_t key_only = ISC_FALSE;
448 const cfg_listelt_t *element;
449
450 if (! isc_file_exists(conffile)) {
451 conffile = admin_keyfile;
452 conftype = &cfg_type_rndckey;
453
454 if (! isc_file_exists(conffile))
455 fatal("neither %s nor %s was found",
456 admin_conffile, admin_keyfile);
457 key_only = ISC_TRUE;
458 }
459
460 DO("create parser", cfg_parser_create(mctx, log, pctxp));
461
462 /*
463 * The parser will output its own errors, so DO() is not used.
464 */
465 result = cfg_parse_file(*pctxp, conffile, conftype, &config);
466 if (result != ISC_R_SUCCESS)
467 fatal("could not load rndc configuration");
468
469 if (!key_only)
470 (void)cfg_map_get(config, "options", &options);
471
472 if (key_only && servername == NULL)
473 servername = "127.0.0.1";
474 else if (servername == NULL && options != NULL) {
475 const cfg_obj_t *defserverobj = NULL;
476 (void)cfg_map_get(options, "default-server", &defserverobj);
477 if (defserverobj != NULL)
478 servername = cfg_obj_asstring(defserverobj);
479 }
480
481 if (servername == NULL)
482 fatal("no server specified and no default");
483
484 if (!key_only) {
485 (void)cfg_map_get(config, "server", &servers);
486 if (servers != NULL) {
487 for (elt = cfg_list_first(servers);
488 elt != NULL;
489 elt = cfg_list_next(elt))
490 {
491 const char *name;
492 server = cfg_listelt_value(elt);
493 name = cfg_obj_asstring(cfg_map_getname(server));
494 if (strcasecmp(name, servername) == 0)
495 break;
496 server = NULL;
497 }
498 }
499 }
500
501 /*
502 * Look for the name of the key to use.
503 */
504 if (keyname != NULL)
505 ; /* Was set on command line, do nothing. */
506 else if (server != NULL) {
507 DO("get key for server", cfg_map_get(server, "key", &defkey));
508 keyname = cfg_obj_asstring(defkey);
509 } else if (options != NULL) {
510 DO("get default key", cfg_map_get(options, "default-key",
511 &defkey));
512 keyname = cfg_obj_asstring(defkey);
513 } else if (!key_only)
514 fatal("no key for server and no default");
515
516 /*
517 * Get the key's definition.
518 */
519 if (key_only)
520 DO("get key", cfg_map_get(config, "key", &key));
521 else {
522 DO("get config key list", cfg_map_get(config, "key", &keys));
523 for (elt = cfg_list_first(keys);
524 elt != NULL;
525 elt = cfg_list_next(elt))
526 {
527 key = cfg_listelt_value(elt);
528 if (strcasecmp(cfg_obj_asstring(cfg_map_getname(key)),
529 keyname) == 0)
530 break;
531 }
532 if (elt == NULL)
533 fatal("no key definition for name %s", keyname);
534 }
535 (void)cfg_map_get(key, "secret", &secretobj);
536 (void)cfg_map_get(key, "algorithm", &algorithmobj);
537 if (secretobj == NULL || algorithmobj == NULL)
538 fatal("key must have algorithm and secret");
539
540 secretstr = cfg_obj_asstring(secretobj);
541 algorithm = cfg_obj_asstring(algorithmobj);
542
543 if (strcasecmp(algorithm, "hmac-md5") != 0)
544 fatal("unsupported algorithm: %s", algorithm);
545
546 secret.rstart = (unsigned char *)secretarray;
547 secret.rend = (unsigned char *)secretarray + sizeof(secretarray);
548 DO("decode base64 secret", isccc_base64_decode(secretstr, &secret));
549 secret.rend = secret.rstart;
550 secret.rstart = (unsigned char *)secretarray;
551
552 /*
553 * Find the port to connect to.
554 */
555 if (remoteport != 0)
556 ; /* Was set on command line, do nothing. */
557 else {
558 if (server != NULL)
559 (void)cfg_map_get(server, "port", &defport);
560 if (defport == NULL && options != NULL)
561 (void)cfg_map_get(options, "default-port", &defport);
562 }
563 if (defport != NULL) {
564 remoteport = cfg_obj_asuint32(defport);
565 if (remoteport > 65535 || remoteport == 0)
566 fatal("port %u out of range", remoteport);
567 } else if (remoteport == 0)
568 remoteport = NS_CONTROL_PORT;
569
570 if (server != NULL)
571 result = cfg_map_get(server, "addresses", &addresses);
572 else
573 result = ISC_R_NOTFOUND;
574 if (result == ISC_R_SUCCESS) {
575 for (element = cfg_list_first(addresses);
576 element != NULL;
577 element = cfg_list_next(element))
578 {
579 isc_sockaddr_t sa;
580
581 address = cfg_listelt_value(element);
582 if (!cfg_obj_issockaddr(address)) {
583 unsigned int myport;
584 const char *name;
585 const cfg_obj_t *obj;
586
587 obj = cfg_tuple_get(address, "name");
588 name = cfg_obj_asstring(obj);
589 obj = cfg_tuple_get(address, "port");
590 if (cfg_obj_isuint32(obj)) {
591 myport = cfg_obj_asuint32(obj);
592 if (myport > ISC_UINT16_MAX ||
593 myport == 0)
594 fatal("port %u out of range",
595 myport);
596 } else
597 myport = remoteport;
598 if (nserveraddrs < SERVERADDRS)
599 get_addresses(name, (in_port_t) myport);
600 else
601 fprintf(stderr, "too many address: "
602 "%s: dropped\n", name);
603 continue;
604 }
605 sa = *cfg_obj_assockaddr(address);
606 if (isc_sockaddr_getport(&sa) == 0)
607 isc_sockaddr_setport(&sa, remoteport);
608 if (nserveraddrs < SERVERADDRS)
609 serveraddrs[nserveraddrs++] = sa;
610 else {
611 char socktext[ISC_SOCKADDR_FORMATSIZE];
612
613 isc_sockaddr_format(&sa, socktext,
614 sizeof(socktext));
615 fprintf(stderr,
616 "too many address: %s: dropped\n",
617 socktext);
618 }
619 }
620 }
621
622 if (!local4set && server != NULL) {
623 address = NULL;
624 cfg_map_get(server, "source-address", &address);
625 if (address != NULL) {
626 local4 = *cfg_obj_assockaddr(address);
627 local4set = ISC_TRUE;
628 }
629 }
630 if (!local4set && options != NULL) {
631 address = NULL;
632 cfg_map_get(options, "default-source-address", &address);
633 if (address != NULL) {
634 local4 = *cfg_obj_assockaddr(address);
635 local4set = ISC_TRUE;
636 }
637 }
638
639 if (!local6set && server != NULL) {
640 address = NULL;
641 cfg_map_get(server, "source-address-v6", &address);
642 if (address != NULL) {
643 local6 = *cfg_obj_assockaddr(address);
644 local6set = ISC_TRUE;
645 }
646 }
647 if (!local6set && options != NULL) {
648 address = NULL;
649 cfg_map_get(options, "default-source-address-v6", &address);
650 if (address != NULL) {
651 local6 = *cfg_obj_assockaddr(address);
652 local6set = ISC_TRUE;
653 }
654 }
655
656 *configp = config;
657 }
658
659 int
660 main(int argc, char **argv) {
661 isc_boolean_t show_final_mem = ISC_FALSE;
662 isc_result_t result = ISC_R_SUCCESS;
663 isc_taskmgr_t *taskmgr = NULL;
664 isc_task_t *task = NULL;
665 isc_log_t *log = NULL;
666 isc_logconfig_t *logconfig = NULL;
667 isc_logdestination_t logdest;
668 cfg_parser_t *pctx = NULL;
669 cfg_obj_t *config = NULL;
670 const char *keyname = NULL;
671 struct in_addr in;
672 struct in6_addr in6;
673 char *p;
674 size_t argslen;
675 int ch;
676 int i;
677
678 result = isc_file_progname(*argv, program, sizeof(program));
679 if (result != ISC_R_SUCCESS)
680 memcpy(program, "rndc", 5);
681 progname = program;
682
683 admin_conffile = RNDC_CONFFILE;
684 admin_keyfile = RNDC_KEYFILE;
685
686 isc_sockaddr_any(&local4);
687 isc_sockaddr_any6(&local6);
688
689 result = isc_app_start();
690 if (result != ISC_R_SUCCESS)
691 fatal("isc_app_start() failed: %s", isc_result_totext(result));
692
693 while ((ch = isc_commandline_parse(argc, argv, "b:c:k:Mmp:s:Vy:"))
694 != -1) {
695 switch (ch) {
696 case 'b':
697 if (inet_pton(AF_INET, isc_commandline_argument,
698 &in) == 1) {
699 isc_sockaddr_fromin(&local4, &in, 0);
700 local4set = ISC_TRUE;
701 } else if (inet_pton(AF_INET6, isc_commandline_argument,
702 &in6) == 1) {
703 isc_sockaddr_fromin6(&local6, &in6, 0);
704 local6set = ISC_TRUE;
705 }
706 break;
707
708 case 'c':
709 admin_conffile = isc_commandline_argument;
710 break;
711
712 case 'k':
713 admin_keyfile = isc_commandline_argument;
714 break;
715
716 case 'M':
717 isc_mem_debugging = ISC_MEM_DEBUGTRACE;
718 break;
719
720 case 'm':
721 show_final_mem = ISC_TRUE;
722 break;
723
724 case 'p':
725 remoteport = atoi(isc_commandline_argument);
726 if (remoteport > 65535 || remoteport == 0)
727 fatal("port '%s' out of range",
728 isc_commandline_argument);
729 break;
730
731 case 's':
732 servername = isc_commandline_argument;
733 break;
734
735 case 'V':
736 verbose = ISC_TRUE;
737 break;
738
739 case 'y':
740 keyname = isc_commandline_argument;
741 break;
742
743 case '?':
744 usage(0);
745 break;
746
747 default:
748 fatal("unexpected error parsing command arguments: "
749 "got %c\n", ch);
750 break;
751 }
752 }
753
754 argc -= isc_commandline_index;
755 argv += isc_commandline_index;
756
757 if (argc < 1)
758 usage(1);
759
760 isc_random_get(&serial);
761
762 DO("create memory context", isc_mem_create(0, 0, &mctx));
763 DO("create socket manager", isc_socketmgr_create(mctx, &socketmgr));
764 DO("create task manager", isc_taskmgr_create(mctx, 1, 0, &taskmgr));
765 DO("create task", isc_task_create(taskmgr, 0, &task));
766
767 DO("create logging context", isc_log_create(mctx, &log, &logconfig));
768 isc_log_setcontext(log);
769 DO("setting log tag", isc_log_settag(logconfig, progname));
770 logdest.file.stream = stderr;
771 logdest.file.name = NULL;
772 logdest.file.versions = ISC_LOG_ROLLNEVER;
773 logdest.file.maximum_size = 0;
774 DO("creating log channel",
775 isc_log_createchannel(logconfig, "stderr",
776 ISC_LOG_TOFILEDESC, ISC_LOG_INFO, &logdest,
777 ISC_LOG_PRINTTAG|ISC_LOG_PRINTLEVEL));
778 DO("enabling log channel", isc_log_usechannel(logconfig, "stderr",
779 NULL, NULL));
780
781 parse_config(mctx, log, keyname, &pctx, &config);
782
783 isccc_result_register();
784
785 command = *argv;
786
787 /*
788 * Convert argc/argv into a space-delimited command string
789 * similar to what the user might enter in interactive mode
790 * (if that were implemented).
791 */
792 argslen = 0;
793 for (i = 0; i < argc; i++)
794 argslen += strlen(argv[i]) + 1;
795
796 args = isc_mem_get(mctx, argslen);
797 if (args == NULL)
798 DO("isc_mem_get", ISC_R_NOMEMORY);
799
800 p = args;
801 for (i = 0; i < argc; i++) {
802 size_t len = strlen(argv[i]);
803 memcpy(p, argv[i], len);
804 p += len;
805 *p++ = ' ';
806 }
807
808 p--;
809 *p++ = '\0';
810 INSIST(p == args + argslen);
811
812 notify("%s", command);
813
814 if (strcmp(command, "restart") == 0)
815 fatal("'%s' is not implemented", command);
816
817 if (nserveraddrs == 0)
818 get_addresses(servername, (in_port_t) remoteport);
819
820 DO("post event", isc_app_onrun(mctx, task, rndc_start, NULL));
821
822 result = isc_app_run();
823 if (result != ISC_R_SUCCESS)
824 fatal("isc_app_run() failed: %s", isc_result_totext(result));
825
826 if (connects > 0 || sends > 0 || recvs > 0)
827 isc_socket_cancel(sock, task, ISC_SOCKCANCEL_ALL);
828
829 isc_task_detach(&task);
830 isc_taskmgr_destroy(&taskmgr);
831 isc_socketmgr_destroy(&socketmgr);
832 isc_log_destroy(&log);
833 isc_log_setcontext(NULL);
834
835 cfg_obj_destroy(pctx, &config);
836 cfg_parser_destroy(&pctx);
837
838 isc_mem_put(mctx, args, argslen);
839 isccc_ccmsg_invalidate(&ccmsg);
840
841 dns_name_destroy();
842
843 if (show_final_mem)
844 isc_mem_stats(mctx, stderr);
845
846 isc_mem_destroy(&mctx);
847
848 if (failed)
849 return (1);
850
851 return (0);
852 }
FreeBSD kvm: FreeBSD sources