2 * Copyright (C) 2004-2006 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 2000-2003 Internet Software Consortium.
5 * Permission to use, copy, modify, and 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.
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.
18 /* $Id: nsupdate.c,v 1.103.2.15.2.23 2006/06/09 07:29:24 marka Exp $ */
29 #include <isc/base64.h>
30 #include <isc/buffer.h>
31 #include <isc/commandline.h>
32 #include <isc/entropy.h>
33 #include <isc/event.h>
37 #include <isc/parseint.h>
38 #include <isc/region.h>
39 #include <isc/sockaddr.h>
40 #include <isc/socket.h>
41 #include <isc/stdio.h>
42 #include <isc/string.h>
44 #include <isc/timer.h>
45 #include <isc/types.h>
48 #include <dns/callbacks.h>
49 #include <dns/dispatch.h>
50 #include <dns/dnssec.h>
51 #include <dns/events.h>
52 #include <dns/fixedname.h>
53 #include <dns/masterdump.h>
54 #include <dns/message.h>
56 #include <dns/rcode.h>
57 #include <dns/rdata.h>
58 #include <dns/rdataclass.h>
59 #include <dns/rdatalist.h>
60 #include <dns/rdataset.h>
61 #include <dns/rdatastruct.h>
62 #include <dns/rdatatype.h>
63 #include <dns/request.h>
64 #include <dns/result.h>
69 #include <lwres/lwres.h>
70 #include <lwres/net.h>
72 #include <bind9/getaddresses.h>
75 #ifdef HAVE_GETADDRINFO
76 #ifdef HAVE_GAISTRERROR
77 #define USE_GETADDRINFO
82 #ifndef USE_GETADDRINFO
83 #ifndef ISC_PLATFORM_NONSTDHERRNO
88 #define MAXCMD (4 * 1024)
89 #define MAXWIRE (64 * 1024)
90 #define PACKETSIZE ((64 * 1024) - 1)
91 #define INITTEXT (2 * 1024)
92 #define MAXTEXT (128 * 1024)
93 #define FIND_TIMEOUT 5
94 #define TTL_MAX 2147483647U /* Maximum signed 32 bit integer. */
96 #define DNSDEFAULTPORT 53
99 #define RESOLV_CONF "/etc/resolv.conf"
102 static isc_boolean_t debugging = ISC_FALSE, ddebugging = ISC_FALSE;
103 static isc_boolean_t memdebugging = ISC_FALSE;
104 static isc_boolean_t have_ipv4 = ISC_FALSE;
105 static isc_boolean_t have_ipv6 = ISC_FALSE;
106 static isc_boolean_t is_dst_up = ISC_FALSE;
107 static isc_boolean_t usevc = ISC_FALSE;
108 static isc_taskmgr_t *taskmgr = NULL;
109 static isc_task_t *global_task = NULL;
110 static isc_event_t *global_event = NULL;
111 static isc_mem_t *mctx = NULL;
112 static dns_dispatchmgr_t *dispatchmgr = NULL;
113 static dns_requestmgr_t *requestmgr = NULL;
114 static isc_socketmgr_t *socketmgr = NULL;
115 static isc_timermgr_t *timermgr = NULL;
116 static dns_dispatch_t *dispatchv4 = NULL;
117 static dns_dispatch_t *dispatchv6 = NULL;
118 static dns_message_t *updatemsg = NULL;
119 static dns_fixedname_t fuserzone;
120 static dns_name_t *userzone = NULL;
121 static dns_tsigkey_t *tsigkey = NULL;
122 static dst_key_t *sig0key;
123 static lwres_context_t *lwctx = NULL;
124 static lwres_conf_t *lwconf;
125 static isc_sockaddr_t *servers;
126 static int ns_inuse = 0;
127 static int ns_total = 0;
128 static isc_sockaddr_t *userserver = NULL;
129 static isc_sockaddr_t *localaddr = NULL;
130 static char *keystr = NULL, *keyfile = NULL;
131 static isc_entropy_t *entp = NULL;
132 static isc_boolean_t shuttingdown = ISC_FALSE;
134 static isc_boolean_t interactive = ISC_TRUE;
135 static isc_boolean_t seenerror = ISC_FALSE;
136 static const dns_master_style_t *style;
137 static int requests = 0;
138 static unsigned int timeout = 300;
139 static unsigned int udp_timeout = 3;
140 static unsigned int udp_retries = 3;
141 static dns_rdataclass_t defaultclass = dns_rdataclass_in;
142 static dns_rdataclass_t zoneclass = dns_rdataclass_none;
143 static dns_message_t *answer = NULL;
145 typedef struct nsu_requestinfo {
147 isc_sockaddr_t *addr;
151 sendrequest(isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
152 dns_message_t *msg, dns_request_t **request);
154 fatal(const char *format, ...) ISC_FORMAT_PRINTF(1, 2);
157 debug(const char *format, ...) ISC_FORMAT_PRINTF(1, 2);
160 ddebug(const char *format, ...) ISC_FORMAT_PRINTF(1, 2);
162 #define STATUS_MORE (isc_uint16_t)0
163 #define STATUS_SEND (isc_uint16_t)1
164 #define STATUS_QUIT (isc_uint16_t)2
165 #define STATUS_SYNTAX (isc_uint16_t)3
167 static dns_rdataclass_t
169 if (zoneclass == dns_rdataclass_none)
170 zoneclass = defaultclass;
175 setzoneclass(dns_rdataclass_t rdclass) {
176 if (zoneclass == dns_rdataclass_none ||
177 rdclass == dns_rdataclass_none)
179 if (zoneclass != rdclass)
185 fatal(const char *format, ...) {
188 va_start(args, format);
189 vfprintf(stderr, format, args);
191 fprintf(stderr, "\n");
196 debug(const char *format, ...) {
200 va_start(args, format);
201 vfprintf(stderr, format, args);
203 fprintf(stderr, "\n");
208 ddebug(const char *format, ...) {
212 va_start(args, format);
213 vfprintf(stderr, format, args);
215 fprintf(stderr, "\n");
220 check_result(isc_result_t result, const char *msg) {
221 if (result != ISC_R_SUCCESS)
222 fatal("%s: %s", msg, isc_result_totext(result));
226 mem_alloc(void *arg, size_t size) {
227 return (isc_mem_get(arg, size));
231 mem_free(void *arg, void *mem, size_t size) {
232 isc_mem_put(arg, mem, size);
236 nsu_strsep(char **stringp, const char *delim) {
237 char *string = *stringp;
245 for (; *string != '\0'; string++) {
247 for (d = delim; (dc = *d) != '\0'; d++) {
255 for (s = string; *s != '\0'; s++) {
257 for (d = delim; (dc = *d) != '\0'; d++) {
273 ddebug("reset_system()");
274 /* If the update message is still around, destroy it */
275 if (updatemsg != NULL)
276 dns_message_reset(updatemsg, DNS_MESSAGE_INTENTRENDER);
278 result = dns_message_create(mctx, DNS_MESSAGE_INTENTRENDER,
280 check_result(result, "dns_message_create");
282 updatemsg->opcode = dns_opcode_update;
287 unsigned char *secret = NULL;
289 isc_buffer_t secretbuf;
291 isc_buffer_t keynamesrc;
294 dns_fixedname_t fkeyname;
297 dns_fixedname_init(&fkeyname);
298 keyname = dns_fixedname_name(&fkeyname);
300 debug("Creating key...");
302 s = strchr(keystr, ':');
303 if (s == NULL || s == keystr || *s == 0)
304 fatal("key option must specify keyname:secret");
307 isc_buffer_init(&keynamesrc, keystr, s - keystr);
308 isc_buffer_add(&keynamesrc, s - keystr);
310 debug("namefromtext");
311 result = dns_name_fromtext(keyname, &keynamesrc, dns_rootname,
313 check_result(result, "dns_name_fromtext");
315 secretlen = strlen(secretstr) * 3 / 4;
316 secret = isc_mem_allocate(mctx, secretlen);
318 fatal("out of memory");
320 isc_buffer_init(&secretbuf, secret, secretlen);
321 result = isc_base64_decodestring(secretstr, &secretbuf);
322 if (result != ISC_R_SUCCESS) {
323 fprintf(stderr, "could not create key from %s: %s\n",
324 keystr, isc_result_totext(result));
328 secretlen = isc_buffer_usedlength(&secretbuf);
331 result = dns_tsigkey_create(keyname, dns_tsig_hmacmd5_name,
332 secret, secretlen, ISC_TRUE, NULL,
333 0, 0, mctx, NULL, &tsigkey);
334 if (result != ISC_R_SUCCESS)
335 fprintf(stderr, "could not create key from %s: %s\n",
336 keystr, dns_result_totext(result));
339 isc_mem_free(mctx, secret);
343 setup_keyfile(void) {
344 dst_key_t *dstkey = NULL;
347 debug("Creating key...");
349 result = dst_key_fromnamedfile(keyfile,
350 DST_TYPE_PRIVATE | DST_TYPE_KEY, mctx,
352 if (result != ISC_R_SUCCESS) {
353 fprintf(stderr, "could not read key from %s: %s\n",
354 keyfile, isc_result_totext(result));
357 if (dst_key_alg(dstkey) == DST_ALG_HMACMD5) {
358 result = dns_tsigkey_createfromkey(dst_key_name(dstkey),
359 dns_tsig_hmacmd5_name,
360 dstkey, ISC_FALSE, NULL,
361 0, 0, mctx, NULL, &tsigkey);
362 if (result != ISC_R_SUCCESS) {
363 fprintf(stderr, "could not create key from %s: %s\n",
364 keyfile, isc_result_totext(result));
365 dst_key_free(&dstkey);
374 isc_task_detach(&global_task);
376 if (userserver != NULL)
377 isc_mem_put(mctx, userserver, sizeof(isc_sockaddr_t));
379 if (localaddr != NULL)
380 isc_mem_put(mctx, localaddr, sizeof(isc_sockaddr_t));
382 if (tsigkey != NULL) {
383 ddebug("Freeing TSIG key");
384 dns_tsigkey_detach(&tsigkey);
387 if (sig0key != NULL) {
388 ddebug("Freeing SIG(0) key");
389 dst_key_free(&sig0key);
392 if (updatemsg != NULL)
393 dns_message_destroy(&updatemsg);
396 ddebug("Destroy DST lib");
398 is_dst_up = ISC_FALSE;
402 ddebug("Detach from entropy");
403 isc_entropy_detach(&entp);
406 lwres_conf_clear(lwctx);
407 lwres_context_destroy(&lwctx);
409 isc_mem_put(mctx, servers, ns_total * sizeof(isc_sockaddr_t));
411 ddebug("Destroying request manager");
412 dns_requestmgr_detach(&requestmgr);
414 ddebug("Freeing the dispatchers");
416 dns_dispatch_detach(&dispatchv4);
418 dns_dispatch_detach(&dispatchv6);
420 ddebug("Shutting down dispatch manager");
421 dns_dispatchmgr_destroy(&dispatchmgr);
426 maybeshutdown(void) {
427 ddebug("Shutting down request manager");
428 dns_requestmgr_shutdown(requestmgr);
437 shutdown_program(isc_task_t *task, isc_event_t *event) {
438 REQUIRE(task == global_task);
441 ddebug("shutdown_program()");
442 isc_event_free(&event);
444 shuttingdown = ISC_TRUE;
451 isc_sockaddr_t bind_any, bind_any6;
452 lwres_result_t lwresult;
453 unsigned int attrs, attrmask;
456 ddebug("setup_system()");
458 dns_result_register();
460 result = isc_net_probeipv4();
461 if (result == ISC_R_SUCCESS)
462 have_ipv4 = ISC_TRUE;
464 result = isc_net_probeipv6();
465 if (result == ISC_R_SUCCESS)
466 have_ipv6 = ISC_TRUE;
468 if (!have_ipv4 && !have_ipv6)
469 fatal("could not find either IPv4 or IPv6");
471 result = isc_mem_create(0, 0, &mctx);
472 check_result(result, "isc_mem_create");
474 lwresult = lwres_context_create(&lwctx, mctx, mem_alloc, mem_free, 1);
475 if (lwresult != LWRES_R_SUCCESS)
476 fatal("lwres_context_create failed");
478 (void)lwres_conf_parse(lwctx, RESOLV_CONF);
479 lwconf = lwres_conf_get(lwctx);
481 ns_total = lwconf->nsnext;
483 /* No name servers in resolv.conf; default to loopback. */
484 struct in_addr localhost;
486 servers = isc_mem_get(mctx, ns_total * sizeof(isc_sockaddr_t));
488 fatal("out of memory");
489 localhost.s_addr = htonl(INADDR_LOOPBACK);
490 isc_sockaddr_fromin(&servers[0], &localhost, DNSDEFAULTPORT);
492 servers = isc_mem_get(mctx, ns_total * sizeof(isc_sockaddr_t));
494 fatal("out of memory");
495 for (i = 0; i < ns_total; i++) {
496 if (lwconf->nameservers[i].family == LWRES_ADDRTYPE_V4) {
498 memcpy(&in4, lwconf->nameservers[i].address, 4);
499 isc_sockaddr_fromin(&servers[i], &in4, DNSDEFAULTPORT);
502 memcpy(&in6, lwconf->nameservers[i].address, 16);
503 isc_sockaddr_fromin6(&servers[i], &in6,
509 result = isc_entropy_create(mctx, &entp);
510 check_result(result, "isc_entropy_create");
512 result = isc_hash_create(mctx, entp, DNS_NAME_MAXWIRE);
513 check_result(result, "isc_hash_create");
516 result = dns_dispatchmgr_create(mctx, entp, &dispatchmgr);
517 check_result(result, "dns_dispatchmgr_create");
519 result = isc_socketmgr_create(mctx, &socketmgr);
520 check_result(result, "dns_socketmgr_create");
522 result = isc_timermgr_create(mctx, &timermgr);
523 check_result(result, "dns_timermgr_create");
525 result = isc_taskmgr_create(mctx, 1, 0, &taskmgr);
526 check_result(result, "isc_taskmgr_create");
528 result = isc_task_create(taskmgr, 0, &global_task);
529 check_result(result, "isc_task_create");
531 result = isc_task_onshutdown(global_task, shutdown_program, NULL);
532 check_result(result, "isc_task_onshutdown");
534 result = dst_lib_init(mctx, entp, 0);
535 check_result(result, "dst_lib_init");
536 is_dst_up = ISC_TRUE;
538 attrmask = DNS_DISPATCHATTR_UDP | DNS_DISPATCHATTR_TCP;
539 attrmask |= DNS_DISPATCHATTR_IPV4 | DNS_DISPATCHATTR_IPV6;
542 attrs = DNS_DISPATCHATTR_UDP;
543 attrs |= DNS_DISPATCHATTR_MAKEQUERY;
544 attrs |= DNS_DISPATCHATTR_IPV6;
545 isc_sockaddr_any6(&bind_any6);
546 result = dns_dispatch_getudp(dispatchmgr, socketmgr, taskmgr,
547 &bind_any6, PACKETSIZE,
549 attrs, attrmask, &dispatchv6);
550 check_result(result, "dns_dispatch_getudp (v6)");
554 attrs = DNS_DISPATCHATTR_UDP;
555 attrs |= DNS_DISPATCHATTR_MAKEQUERY;
556 attrs |= DNS_DISPATCHATTR_IPV4;
557 isc_sockaddr_any(&bind_any);
558 result = dns_dispatch_getudp(dispatchmgr, socketmgr, taskmgr,
559 &bind_any, PACKETSIZE,
561 attrs, attrmask, &dispatchv4);
562 check_result(result, "dns_dispatch_getudp (v4)");
565 result = dns_requestmgr_create(mctx, timermgr,
566 socketmgr, taskmgr, dispatchmgr,
567 dispatchv4, dispatchv6, &requestmgr);
568 check_result(result, "dns_requestmgr_create");
572 else if (keyfile != NULL)
577 get_address(char *host, in_port_t port, isc_sockaddr_t *sockaddr) {
582 result = bind9_getaddresses(host, port, sockaddr, 1, &count);
584 if (result != ISC_R_SUCCESS)
585 fatal("couldn't get address for '%s': %s",
586 host, isc_result_totext(result));
591 parse_args(int argc, char **argv) {
596 while ((ch = isc_commandline_parse(argc, argv, "dDMy:vk:r:t:u:")) != -1)
600 debugging = ISC_TRUE;
602 case 'D': /* was -dd */
603 debugging = ISC_TRUE;
604 ddebugging = ISC_TRUE;
606 case 'M': /* was -dm */
607 debugging = ISC_TRUE;
608 ddebugging = ISC_TRUE;
609 memdebugging = ISC_TRUE;
610 isc_mem_debugging = ISC_MEM_DEBUGTRACE |
614 keystr = isc_commandline_argument;
620 keyfile = isc_commandline_argument;
623 result = isc_parse_uint32(&timeout,
624 isc_commandline_argument, 10);
625 if (result != ISC_R_SUCCESS) {
626 fprintf(stderr, "bad timeout '%s'\n", isc_commandline_argument);
633 result = isc_parse_uint32(&udp_timeout,
634 isc_commandline_argument, 10);
635 if (result != ISC_R_SUCCESS) {
636 fprintf(stderr, "bad udp timeout '%s'\n", isc_commandline_argument);
639 if (udp_timeout == 0)
640 udp_timeout = UINT_MAX;
643 result = isc_parse_uint32(&udp_retries,
644 isc_commandline_argument, 10);
645 if (result != ISC_R_SUCCESS) {
646 fprintf(stderr, "bad udp retries '%s'\n", isc_commandline_argument);
651 fprintf(stderr, "%s: invalid argument -%c\n",
653 fprintf(stderr, "usage: nsupdate [-d] "
654 "[-y keyname:secret | -k keyfile] [-v] "
659 if (keyfile != NULL && keystr != NULL) {
660 fprintf(stderr, "%s: cannot specify both -k and -y\n",
665 if (argv[isc_commandline_index] != NULL) {
666 if (strcmp(argv[isc_commandline_index], "-") == 0) {
669 result = isc_stdio_open(argv[isc_commandline_index],
671 if (result != ISC_R_SUCCESS) {
672 fprintf(stderr, "could not open '%s': %s\n",
673 argv[isc_commandline_index],
674 isc_result_totext(result));
678 interactive = ISC_FALSE;
683 parse_name(char **cmdlinep, dns_message_t *msg, dns_name_t **namep) {
686 isc_buffer_t *namebuf = NULL;
689 word = nsu_strsep(cmdlinep, " \t\r\n");
691 fprintf(stderr, "could not read owner name\n");
692 return (STATUS_SYNTAX);
695 result = dns_message_gettempname(msg, namep);
696 check_result(result, "dns_message_gettempname");
697 result = isc_buffer_allocate(mctx, &namebuf, DNS_NAME_MAXWIRE);
698 check_result(result, "isc_buffer_allocate");
699 dns_name_init(*namep, NULL);
700 dns_name_setbuffer(*namep, namebuf);
701 dns_message_takebuffer(msg, &namebuf);
702 isc_buffer_init(&source, word, strlen(word));
703 isc_buffer_add(&source, strlen(word));
704 result = dns_name_fromtext(*namep, &source, dns_rootname,
706 check_result(result, "dns_name_fromtext");
707 isc_buffer_invalidate(&source);
708 return (STATUS_MORE);
712 parse_rdata(char **cmdlinep, dns_rdataclass_t rdataclass,
713 dns_rdatatype_t rdatatype, dns_message_t *msg,
716 char *cmdline = *cmdlinep;
717 isc_buffer_t source, *buf = NULL, *newbuf = NULL;
719 isc_lex_t *lex = NULL;
720 dns_rdatacallbacks_t callbacks;
723 while (*cmdline != 0 && isspace((unsigned char)*cmdline))
727 dns_rdatacallbacks_init(&callbacks);
728 result = isc_lex_create(mctx, strlen(cmdline), &lex);
729 check_result(result, "isc_lex_create");
730 isc_buffer_init(&source, cmdline, strlen(cmdline));
731 isc_buffer_add(&source, strlen(cmdline));
732 result = isc_lex_openbuffer(lex, &source);
733 check_result(result, "isc_lex_openbuffer");
734 result = isc_buffer_allocate(mctx, &buf, MAXWIRE);
735 check_result(result, "isc_buffer_allocate");
736 result = dns_rdata_fromtext(rdata, rdataclass, rdatatype, lex,
737 dns_rootname, 0, mctx, buf,
739 isc_lex_destroy(&lex);
740 if (result == ISC_R_SUCCESS) {
741 isc_buffer_usedregion(buf, &r);
742 result = isc_buffer_allocate(mctx, &newbuf, r.length);
743 check_result(result, "isc_buffer_allocate");
744 isc_buffer_putmem(newbuf, r.base, r.length);
745 isc_buffer_usedregion(newbuf, &r);
746 dns_rdata_fromregion(rdata, rdataclass, rdatatype, &r);
747 isc_buffer_free(&buf);
748 dns_message_takebuffer(msg, &newbuf);
750 fprintf(stderr, "invalid rdata format: %s\n",
751 isc_result_totext(result));
752 isc_buffer_free(&buf);
753 return (STATUS_SYNTAX);
756 rdata->flags = DNS_RDATA_UPDATE;
759 return (STATUS_MORE);
763 make_prereq(char *cmdline, isc_boolean_t ispositive, isc_boolean_t isrrset) {
766 dns_name_t *name = NULL;
767 isc_textregion_t region;
768 dns_rdataset_t *rdataset = NULL;
769 dns_rdatalist_t *rdatalist = NULL;
770 dns_rdataclass_t rdataclass;
771 dns_rdatatype_t rdatatype;
772 dns_rdata_t *rdata = NULL;
775 ddebug("make_prereq()");
778 * Read the owner name
780 retval = parse_name(&cmdline, updatemsg, &name);
781 if (retval != STATUS_MORE)
785 * If this is an rrset prereq, read the class or type.
788 word = nsu_strsep(&cmdline, " \t\r\n");
790 fprintf(stderr, "could not read class or type\n");
794 region.length = strlen(word);
795 result = dns_rdataclass_fromtext(&rdataclass, ®ion);
796 if (result == ISC_R_SUCCESS) {
797 if (!setzoneclass(rdataclass)) {
798 fprintf(stderr, "class mismatch: %s\n", word);
804 word = nsu_strsep(&cmdline, " \t\r\n");
806 fprintf(stderr, "could not read type\n");
810 region.length = strlen(word);
811 result = dns_rdatatype_fromtext(&rdatatype, ®ion);
812 if (result != ISC_R_SUCCESS) {
813 fprintf(stderr, "invalid type: %s\n", word);
817 rdataclass = getzoneclass();
818 result = dns_rdatatype_fromtext(&rdatatype, ®ion);
819 if (result != ISC_R_SUCCESS) {
820 fprintf(stderr, "invalid type: %s\n", word);
825 rdatatype = dns_rdatatype_any;
827 result = dns_message_gettemprdata(updatemsg, &rdata);
828 check_result(result, "dns_message_gettemprdata");
833 if (isrrset && ispositive) {
834 retval = parse_rdata(&cmdline, rdataclass, rdatatype,
836 if (retval != STATUS_MORE)
839 rdata->flags = DNS_RDATA_UPDATE;
841 result = dns_message_gettemprdatalist(updatemsg, &rdatalist);
842 check_result(result, "dns_message_gettemprdatalist");
843 result = dns_message_gettemprdataset(updatemsg, &rdataset);
844 check_result(result, "dns_message_gettemprdataset");
845 dns_rdatalist_init(rdatalist);
846 rdatalist->type = rdatatype;
848 if (isrrset && rdata->data != NULL)
849 rdatalist->rdclass = rdataclass;
851 rdatalist->rdclass = dns_rdataclass_any;
853 rdatalist->rdclass = dns_rdataclass_none;
854 rdatalist->covers = 0;
856 rdata->rdclass = rdatalist->rdclass;
857 rdata->type = rdatatype;
858 ISC_LIST_INIT(rdatalist->rdata);
859 ISC_LIST_APPEND(rdatalist->rdata, rdata, link);
860 dns_rdataset_init(rdataset);
861 dns_rdatalist_tordataset(rdatalist, rdataset);
862 ISC_LIST_INIT(name->list);
863 ISC_LIST_APPEND(name->list, rdataset, link);
864 dns_message_addname(updatemsg, name, DNS_SECTION_PREREQUISITE);
865 return (STATUS_MORE);
869 dns_message_puttempname(updatemsg, &name);
870 return (STATUS_SYNTAX);
874 evaluate_prereq(char *cmdline) {
876 isc_boolean_t ispositive, isrrset;
878 ddebug("evaluate_prereq()");
879 word = nsu_strsep(&cmdline, " \t\r\n");
881 fprintf(stderr, "could not read operation code\n");
882 return (STATUS_SYNTAX);
884 if (strcasecmp(word, "nxdomain") == 0) {
885 ispositive = ISC_FALSE;
887 } else if (strcasecmp(word, "yxdomain") == 0) {
888 ispositive = ISC_TRUE;
890 } else if (strcasecmp(word, "nxrrset") == 0) {
891 ispositive = ISC_FALSE;
893 } else if (strcasecmp(word, "yxrrset") == 0) {
894 ispositive = ISC_TRUE;
897 fprintf(stderr, "incorrect operation code: %s\n", word);
898 return (STATUS_SYNTAX);
900 return (make_prereq(cmdline, ispositive, isrrset));
904 evaluate_server(char *cmdline) {
908 word = nsu_strsep(&cmdline, " \t\r\n");
910 fprintf(stderr, "could not read server name\n");
911 return (STATUS_SYNTAX);
915 word = nsu_strsep(&cmdline, " \t\r\n");
917 port = DNSDEFAULTPORT;
920 port = strtol(word, &endp, 10);
922 fprintf(stderr, "port '%s' is not numeric\n", word);
923 return (STATUS_SYNTAX);
924 } else if (port < 1 || port > 65535) {
925 fprintf(stderr, "port '%s' is out of range "
926 "(1 to 65535)\n", word);
927 return (STATUS_SYNTAX);
931 if (userserver == NULL) {
932 userserver = isc_mem_get(mctx, sizeof(isc_sockaddr_t));
933 if (userserver == NULL)
934 fatal("out of memory");
937 get_address(server, (in_port_t)port, userserver);
939 return (STATUS_MORE);
943 evaluate_local(char *cmdline) {
949 word = nsu_strsep(&cmdline, " \t\r\n");
951 fprintf(stderr, "could not read server name\n");
952 return (STATUS_SYNTAX);
956 word = nsu_strsep(&cmdline, " \t\r\n");
961 port = strtol(word, &endp, 10);
963 fprintf(stderr, "port '%s' is not numeric\n", word);
964 return (STATUS_SYNTAX);
965 } else if (port < 1 || port > 65535) {
966 fprintf(stderr, "port '%s' is out of range "
967 "(1 to 65535)\n", word);
968 return (STATUS_SYNTAX);
972 if (localaddr == NULL) {
973 localaddr = isc_mem_get(mctx, sizeof(isc_sockaddr_t));
974 if (localaddr == NULL)
975 fatal("out of memory");
978 if (have_ipv6 && inet_pton(AF_INET6, local, &in6) == 1)
979 isc_sockaddr_fromin6(localaddr, &in6, (in_port_t)port);
980 else if (have_ipv4 && inet_pton(AF_INET, local, &in4) == 1)
981 isc_sockaddr_fromin(localaddr, &in4, (in_port_t)port);
983 fprintf(stderr, "invalid address %s", local);
984 return (STATUS_SYNTAX);
987 return (STATUS_MORE);
991 evaluate_key(char *cmdline) {
996 dns_fixedname_t fkeyname;
999 unsigned char *secret = NULL;
1000 isc_buffer_t secretbuf;
1002 namestr = nsu_strsep(&cmdline, " \t\r\n");
1003 if (*namestr == 0) {
1004 fprintf(stderr, "could not read key name\n");
1005 return (STATUS_SYNTAX);
1008 dns_fixedname_init(&fkeyname);
1009 keyname = dns_fixedname_name(&fkeyname);
1011 isc_buffer_init(&b, namestr, strlen(namestr));
1012 isc_buffer_add(&b, strlen(namestr));
1013 result = dns_name_fromtext(keyname, &b, dns_rootname, ISC_FALSE, NULL);
1014 if (result != ISC_R_SUCCESS) {
1015 fprintf(stderr, "could not parse key name\n");
1016 return (STATUS_SYNTAX);
1019 secretstr = nsu_strsep(&cmdline, "\r\n");
1020 if (*secretstr == 0) {
1021 fprintf(stderr, "could not read key secret\n");
1022 return (STATUS_SYNTAX);
1024 secretlen = strlen(secretstr) * 3 / 4;
1025 secret = isc_mem_allocate(mctx, secretlen);
1027 fatal("out of memory");
1029 isc_buffer_init(&secretbuf, secret, secretlen);
1030 result = isc_base64_decodestring(secretstr, &secretbuf);
1031 if (result != ISC_R_SUCCESS) {
1032 fprintf(stderr, "could not create key from %s: %s\n",
1033 secretstr, isc_result_totext(result));
1034 isc_mem_free(mctx, secret);
1035 return (STATUS_SYNTAX);
1037 secretlen = isc_buffer_usedlength(&secretbuf);
1039 if (tsigkey != NULL)
1040 dns_tsigkey_detach(&tsigkey);
1041 result = dns_tsigkey_create(keyname, dns_tsig_hmacmd5_name,
1042 secret, secretlen, ISC_TRUE, NULL, 0, 0,
1043 mctx, NULL, &tsigkey);
1044 isc_mem_free(mctx, secret);
1045 if (result != ISC_R_SUCCESS) {
1046 fprintf(stderr, "could not create key from %s %s: %s\n",
1047 namestr, secretstr, dns_result_totext(result));
1048 return (STATUS_SYNTAX);
1050 return (STATUS_MORE);
1054 evaluate_zone(char *cmdline) {
1057 isc_result_t result;
1059 word = nsu_strsep(&cmdline, " \t\r\n");
1061 fprintf(stderr, "could not read zone name\n");
1062 return (STATUS_SYNTAX);
1065 dns_fixedname_init(&fuserzone);
1066 userzone = dns_fixedname_name(&fuserzone);
1067 isc_buffer_init(&b, word, strlen(word));
1068 isc_buffer_add(&b, strlen(word));
1069 result = dns_name_fromtext(userzone, &b, dns_rootname, ISC_FALSE,
1071 if (result != ISC_R_SUCCESS) {
1072 userzone = NULL; /* Lest it point to an invalid name */
1073 fprintf(stderr, "could not parse zone name\n");
1074 return (STATUS_SYNTAX);
1077 return (STATUS_MORE);
1081 evaluate_class(char *cmdline) {
1084 isc_result_t result;
1085 dns_rdataclass_t rdclass;
1087 word = nsu_strsep(&cmdline, " \t\r\n");
1089 fprintf(stderr, "could not read class name\n");
1090 return (STATUS_SYNTAX);
1094 r.length = strlen(word);
1095 result = dns_rdataclass_fromtext(&rdclass, &r);
1096 if (result != ISC_R_SUCCESS) {
1097 fprintf(stderr, "could not parse class name: %s\n", word);
1098 return (STATUS_SYNTAX);
1101 case dns_rdataclass_none:
1102 case dns_rdataclass_any:
1103 case dns_rdataclass_reserved0:
1104 fprintf(stderr, "bad default class: %s\n", word);
1105 return (STATUS_SYNTAX);
1107 defaultclass = rdclass;
1110 return (STATUS_MORE);
1114 update_addordelete(char *cmdline, isc_boolean_t isdelete) {
1115 isc_result_t result;
1116 dns_name_t *name = NULL;
1119 dns_rdataclass_t rdataclass;
1120 dns_rdatatype_t rdatatype;
1121 dns_rdata_t *rdata = NULL;
1122 dns_rdatalist_t *rdatalist = NULL;
1123 dns_rdataset_t *rdataset = NULL;
1124 isc_textregion_t region;
1125 isc_uint16_t retval;
1127 ddebug("update_addordelete()");
1130 * Read the owner name.
1132 retval = parse_name(&cmdline, updatemsg, &name);
1133 if (retval != STATUS_MORE)
1136 result = dns_message_gettemprdata(updatemsg, &rdata);
1137 check_result(result, "dns_message_gettemprdata");
1145 * If this is an add, read the TTL and verify that it's in range.
1146 * If it's a delete, ignore a TTL if present (for compatibility).
1148 word = nsu_strsep(&cmdline, " \t\r\n");
1151 fprintf(stderr, "could not read owner ttl\n");
1156 rdataclass = dns_rdataclass_any;
1157 rdatatype = dns_rdatatype_any;
1158 rdata->flags = DNS_RDATA_UPDATE;
1162 result = isc_parse_uint32(&ttl, word, 10);
1163 if (result != ISC_R_SUCCESS) {
1168 fprintf(stderr, "ttl '%s': %s\n", word,
1169 isc_result_totext(result));
1176 else if (ttl > TTL_MAX) {
1177 fprintf(stderr, "ttl '%s' is out of range (0 to %u)\n",
1183 * Read the class or type.
1185 word = nsu_strsep(&cmdline, " \t\r\n");
1189 rdataclass = dns_rdataclass_any;
1190 rdatatype = dns_rdatatype_any;
1191 rdata->flags = DNS_RDATA_UPDATE;
1194 fprintf(stderr, "could not read class or type\n");
1199 region.length = strlen(word);
1200 result = dns_rdataclass_fromtext(&rdataclass, ®ion);
1201 if (result == ISC_R_SUCCESS) {
1202 if (!setzoneclass(rdataclass)) {
1203 fprintf(stderr, "class mismatch: %s\n", word);
1207 * Now read the type.
1209 word = nsu_strsep(&cmdline, " \t\r\n");
1212 rdataclass = dns_rdataclass_any;
1213 rdatatype = dns_rdatatype_any;
1214 rdata->flags = DNS_RDATA_UPDATE;
1217 fprintf(stderr, "could not read type\n");
1222 region.length = strlen(word);
1223 result = dns_rdatatype_fromtext(&rdatatype, ®ion);
1224 if (result != ISC_R_SUCCESS) {
1225 fprintf(stderr, "'%s' is not a valid type: %s\n",
1226 word, isc_result_totext(result));
1230 rdataclass = getzoneclass();
1231 result = dns_rdatatype_fromtext(&rdatatype, ®ion);
1232 if (result != ISC_R_SUCCESS) {
1233 fprintf(stderr, "'%s' is not a valid class or type: "
1234 "%s\n", word, isc_result_totext(result));
1239 retval = parse_rdata(&cmdline, rdataclass, rdatatype, updatemsg,
1241 if (retval != STATUS_MORE)
1245 if ((rdata->flags & DNS_RDATA_UPDATE) != 0)
1246 rdataclass = dns_rdataclass_any;
1248 rdataclass = dns_rdataclass_none;
1250 if ((rdata->flags & DNS_RDATA_UPDATE) != 0) {
1251 fprintf(stderr, "could not read rdata\n");
1258 result = dns_message_gettemprdatalist(updatemsg, &rdatalist);
1259 check_result(result, "dns_message_gettemprdatalist");
1260 result = dns_message_gettemprdataset(updatemsg, &rdataset);
1261 check_result(result, "dns_message_gettemprdataset");
1262 dns_rdatalist_init(rdatalist);
1263 rdatalist->type = rdatatype;
1264 rdatalist->rdclass = rdataclass;
1265 rdatalist->covers = rdatatype;
1266 rdatalist->ttl = (dns_ttl_t)ttl;
1267 ISC_LIST_INIT(rdatalist->rdata);
1268 ISC_LIST_APPEND(rdatalist->rdata, rdata, link);
1269 dns_rdataset_init(rdataset);
1270 dns_rdatalist_tordataset(rdatalist, rdataset);
1271 ISC_LIST_INIT(name->list);
1272 ISC_LIST_APPEND(name->list, rdataset, link);
1273 dns_message_addname(updatemsg, name, DNS_SECTION_UPDATE);
1274 return (STATUS_MORE);
1278 dns_message_puttempname(updatemsg, &name);
1280 dns_message_puttemprdata(updatemsg, &rdata);
1281 return (STATUS_SYNTAX);
1285 evaluate_update(char *cmdline) {
1287 isc_boolean_t isdelete;
1289 ddebug("evaluate_update()");
1290 word = nsu_strsep(&cmdline, " \t\r\n");
1292 fprintf(stderr, "could not read operation code\n");
1293 return (STATUS_SYNTAX);
1295 if (strcasecmp(word, "delete") == 0)
1296 isdelete = ISC_TRUE;
1297 else if (strcasecmp(word, "add") == 0)
1298 isdelete = ISC_FALSE;
1300 fprintf(stderr, "incorrect operation code: %s\n", word);
1301 return (STATUS_SYNTAX);
1303 return (update_addordelete(cmdline, isdelete));
1307 show_message(dns_message_t *msg) {
1308 isc_result_t result;
1309 isc_buffer_t *buf = NULL;
1312 ddebug("show_message()");
1315 if (bufsz > MAXTEXT) {
1316 fprintf(stderr, "could not allocate large enough "
1317 "buffer to display message\n");
1321 isc_buffer_free(&buf);
1322 result = isc_buffer_allocate(mctx, &buf, bufsz);
1323 check_result(result, "isc_buffer_allocate");
1324 result = dns_message_totext(msg, style, 0, buf);
1326 } while (result == ISC_R_NOSPACE);
1327 if (result != ISC_R_SUCCESS) {
1328 fprintf(stderr, "could not convert message to text format.\n");
1329 isc_buffer_free(&buf);
1332 printf("Outgoing update query:\n%.*s",
1333 (int)isc_buffer_usedlength(buf),
1334 (char*)isc_buffer_base(buf));
1335 isc_buffer_free(&buf);
1340 get_next_command(void) {
1341 char cmdlinebuf[MAXCMD];
1345 ddebug("get_next_command()");
1347 fprintf(stdout, "> ");
1351 cmdline = fgets(cmdlinebuf, MAXCMD, input);
1353 if (cmdline == NULL)
1354 return (STATUS_QUIT);
1355 word = nsu_strsep(&cmdline, " \t\r\n");
1358 return (STATUS_QUIT);
1360 return (STATUS_SEND);
1362 return (STATUS_MORE);
1363 if (strcasecmp(word, "quit") == 0)
1364 return (STATUS_QUIT);
1365 if (strcasecmp(word, "prereq") == 0)
1366 return (evaluate_prereq(cmdline));
1367 if (strcasecmp(word, "update") == 0)
1368 return (evaluate_update(cmdline));
1369 if (strcasecmp(word, "server") == 0)
1370 return (evaluate_server(cmdline));
1371 if (strcasecmp(word, "local") == 0)
1372 return (evaluate_local(cmdline));
1373 if (strcasecmp(word, "zone") == 0)
1374 return (evaluate_zone(cmdline));
1375 if (strcasecmp(word, "class") == 0)
1376 return (evaluate_class(cmdline));
1377 if (strcasecmp(word, "send") == 0)
1378 return (STATUS_SEND);
1379 if (strcasecmp(word, "show") == 0) {
1380 show_message(updatemsg);
1381 return (STATUS_MORE);
1383 if (strcasecmp(word, "answer") == 0) {
1385 show_message(answer);
1386 return (STATUS_MORE);
1388 if (strcasecmp(word, "key") == 0)
1389 return (evaluate_key(cmdline));
1390 fprintf(stderr, "incorrect section name: %s\n", word);
1391 return (STATUS_SYNTAX);
1394 static isc_boolean_t
1395 user_interaction(void) {
1396 isc_uint16_t result = STATUS_MORE;
1398 ddebug("user_interaction()");
1399 while ((result == STATUS_MORE) || (result == STATUS_SYNTAX))
1400 result = get_next_command();
1401 if (result == STATUS_SEND)
1409 isc_event_t *event = global_event;
1410 ddebug("done_update()");
1411 isc_task_send(global_task, &event);
1415 check_tsig_error(dns_rdataset_t *rdataset, isc_buffer_t *b) {
1416 isc_result_t result;
1417 dns_rdata_t rdata = DNS_RDATA_INIT;
1418 dns_rdata_any_tsig_t tsig;
1420 result = dns_rdataset_first(rdataset);
1421 check_result(result, "dns_rdataset_first");
1422 dns_rdataset_current(rdataset, &rdata);
1423 result = dns_rdata_tostruct(&rdata, &tsig, NULL);
1424 check_result(result, "dns_rdata_tostruct");
1425 if (tsig.error != 0) {
1426 if (isc_buffer_remaininglength(b) < 1)
1427 check_result(ISC_R_NOSPACE, "isc_buffer_remaininglength");
1428 isc__buffer_putstr(b, "(" /*)*/);
1429 result = dns_tsigrcode_totext(tsig.error, b);
1430 check_result(result, "dns_tsigrcode_totext");
1431 if (isc_buffer_remaininglength(b) < 1)
1432 check_result(ISC_R_NOSPACE, "isc_buffer_remaininglength");
1433 isc__buffer_putstr(b, /*(*/ ")");
1438 update_completed(isc_task_t *task, isc_event_t *event) {
1439 dns_requestevent_t *reqev = NULL;
1440 isc_result_t result;
1441 dns_request_t *request;
1445 ddebug("update_completed()");
1449 REQUIRE(event->ev_type == DNS_EVENT_REQUESTDONE);
1450 reqev = (dns_requestevent_t *)event;
1451 request = reqev->request;
1454 dns_request_destroy(&request);
1455 isc_event_free(&event);
1460 if (reqev->result != ISC_R_SUCCESS) {
1461 fprintf(stderr, "; Communication with server failed: %s\n",
1462 isc_result_totext(reqev->result));
1463 seenerror = ISC_TRUE;
1467 result = dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &answer);
1468 check_result(result, "dns_message_create");
1469 result = dns_request_getresponse(request, answer,
1470 DNS_MESSAGEPARSE_PRESERVEORDER);
1474 case DNS_R_CLOCKSKEW:
1475 case DNS_R_EXPECTEDTSIG:
1476 case DNS_R_TSIGERRORSET:
1477 case DNS_R_TSIGVERIFYFAILURE:
1478 case DNS_R_UNEXPECTEDTSIG:
1479 fprintf(stderr, "; TSIG error with server: %s\n",
1480 isc_result_totext(result));
1481 seenerror = ISC_TRUE;
1484 check_result(result, "dns_request_getresponse");
1487 if (answer->rcode != dns_rcode_noerror) {
1488 seenerror = ISC_TRUE;
1492 dns_rdataset_t *rds;
1494 isc_buffer_init(&b, buf, sizeof(buf) - 1);
1495 result = dns_rcode_totext(answer->rcode, &b);
1496 check_result(result, "dns_rcode_totext");
1497 rds = dns_message_gettsig(answer, NULL);
1499 check_tsig_error(rds, &b);
1500 fprintf(stderr, "update failed: %.*s\n",
1501 (int)isc_buffer_usedlength(&b), buf);
1505 isc_buffer_t *buf = NULL;
1510 if (bufsz > MAXTEXT) {
1511 fprintf(stderr, "could not allocate large "
1512 "enough buffer to display message\n");
1516 isc_buffer_free(&buf);
1517 result = isc_buffer_allocate(mctx, &buf, bufsz);
1518 check_result(result, "isc_buffer_allocate");
1519 result = dns_message_totext(answer, style, 0, buf);
1521 } while (result == ISC_R_NOSPACE);
1522 check_result(result, "dns_message_totext");
1523 fprintf(stderr, "\nReply from update query:\n%.*s\n",
1524 (int)isc_buffer_usedlength(buf),
1525 (char*)isc_buffer_base(buf));
1526 isc_buffer_free(&buf);
1529 dns_request_destroy(&request);
1530 isc_event_free(&event);
1535 send_update(dns_name_t *zonename, isc_sockaddr_t *master,
1536 isc_sockaddr_t *srcaddr)
1538 isc_result_t result;
1539 dns_request_t *request = NULL;
1540 dns_name_t *name = NULL;
1541 dns_rdataset_t *rdataset = NULL;
1542 unsigned int options = 0;
1544 ddebug("send_update()");
1546 result = dns_message_gettempname(updatemsg, &name);
1547 check_result(result, "dns_message_gettempname");
1548 dns_name_init(name, NULL);
1549 dns_name_clone(zonename, name);
1550 result = dns_message_gettemprdataset(updatemsg, &rdataset);
1551 check_result(result, "dns_message_gettemprdataset");
1552 dns_rdataset_makequestion(rdataset, getzoneclass(), dns_rdatatype_soa);
1553 ISC_LIST_INIT(name->list);
1554 ISC_LIST_APPEND(name->list, rdataset, link);
1555 dns_message_addname(updatemsg, name, DNS_SECTION_ZONE);
1558 options |= DNS_REQUESTOPT_TCP;
1559 if (tsigkey == NULL && sig0key != NULL) {
1560 result = dns_message_setsig0key(updatemsg, sig0key);
1561 check_result(result, "dns_message_setsig0key");
1564 char addrbuf[ISC_SOCKADDR_FORMATSIZE];
1566 isc_sockaddr_format(master, addrbuf, sizeof(addrbuf));
1567 fprintf(stderr, "Sending update to %s\n", addrbuf);
1569 result = dns_request_createvia3(requestmgr, updatemsg, srcaddr,
1570 master, options, tsigkey, timeout,
1571 udp_timeout, udp_retries, global_task,
1572 update_completed, NULL, &request);
1573 check_result(result, "dns_request_createvia3");
1576 show_message(updatemsg);
1582 recvsoa(isc_task_t *task, isc_event_t *event) {
1583 dns_requestevent_t *reqev = NULL;
1584 dns_request_t *request = NULL;
1585 isc_result_t result, eresult;
1586 dns_message_t *rcvmsg = NULL;
1587 dns_section_t section;
1588 dns_name_t *name = NULL;
1589 dns_rdataset_t *soaset = NULL;
1590 dns_rdata_soa_t soa;
1591 dns_rdata_t soarr = DNS_RDATA_INIT;
1594 isc_sockaddr_t *serveraddr, tempaddr;
1595 dns_name_t *zonename;
1596 nsu_requestinfo_t *reqinfo;
1597 dns_message_t *soaquery = NULL;
1598 isc_sockaddr_t *addr;
1599 isc_boolean_t seencname = ISC_FALSE;
1601 unsigned int nlabels;
1605 ddebug("recvsoa()");
1609 REQUIRE(event->ev_type == DNS_EVENT_REQUESTDONE);
1610 reqev = (dns_requestevent_t *)event;
1611 request = reqev->request;
1612 eresult = reqev->result;
1613 reqinfo = reqev->ev_arg;
1614 soaquery = reqinfo->msg;
1615 addr = reqinfo->addr;
1618 dns_request_destroy(&request);
1619 dns_message_destroy(&soaquery);
1620 isc_mem_put(mctx, reqinfo, sizeof(nsu_requestinfo_t));
1621 isc_event_free(&event);
1626 if (eresult != ISC_R_SUCCESS) {
1627 char addrbuf[ISC_SOCKADDR_FORMATSIZE];
1629 isc_sockaddr_format(addr, addrbuf, sizeof(addrbuf));
1630 fprintf(stderr, "; Communication with %s failed: %s\n",
1631 addrbuf, isc_result_totext(eresult));
1632 if (userserver != NULL)
1633 fatal("could not talk to specified name server");
1634 else if (++ns_inuse >= lwconf->nsnext)
1635 fatal("could not talk to any default name server");
1636 ddebug("Destroying request [%p]", request);
1637 dns_request_destroy(&request);
1638 dns_message_renderreset(soaquery);
1639 dns_message_settsigkey(soaquery, NULL);
1640 sendrequest(localaddr, &servers[ns_inuse], soaquery, &request);
1641 isc_mem_put(mctx, reqinfo, sizeof(nsu_requestinfo_t));
1642 isc_event_free(&event);
1643 setzoneclass(dns_rdataclass_none);
1646 isc_mem_put(mctx, reqinfo, sizeof(nsu_requestinfo_t));
1648 isc_event_free(&event);
1651 ddebug("About to create rcvmsg");
1652 result = dns_message_create(mctx, DNS_MESSAGE_INTENTPARSE, &rcvmsg);
1653 check_result(result, "dns_message_create");
1654 result = dns_request_getresponse(request, rcvmsg,
1655 DNS_MESSAGEPARSE_PRESERVEORDER);
1656 if (result == DNS_R_TSIGERRORSET && userserver != NULL) {
1657 dns_message_destroy(&rcvmsg);
1658 ddebug("Destroying request [%p]", request);
1659 dns_request_destroy(&request);
1660 reqinfo = isc_mem_get(mctx, sizeof(nsu_requestinfo_t));
1661 if (reqinfo == NULL)
1662 fatal("out of memory");
1663 reqinfo->msg = soaquery;
1664 reqinfo->addr = addr;
1665 dns_message_renderreset(soaquery);
1666 ddebug("retrying soa request without TSIG");
1667 result = dns_request_createvia3(requestmgr, soaquery,
1668 localaddr, addr, 0, NULL,
1671 global_task, recvsoa, reqinfo,
1673 check_result(result, "dns_request_createvia");
1677 check_result(result, "dns_request_getresponse");
1678 section = DNS_SECTION_ANSWER;
1680 isc_buffer_t *buf = NULL;
1685 isc_buffer_free(&buf);
1686 if (bufsz > MAXTEXT) {
1687 fprintf(stderr, "could not allocate enough "
1688 "space for debugging message\n");
1691 result = isc_buffer_allocate(mctx, &buf, bufsz);
1692 check_result(result, "isc_buffer_allocate");
1693 result = dns_message_totext(rcvmsg, style, 0, buf);
1694 } while (result == ISC_R_NOSPACE);
1695 check_result(result, "dns_message_totext");
1696 fprintf(stderr, "Reply from SOA query:\n%.*s\n",
1697 (int)isc_buffer_usedlength(buf),
1698 (char*)isc_buffer_base(buf));
1699 isc_buffer_free(&buf);
1702 if (rcvmsg->rcode != dns_rcode_noerror &&
1703 rcvmsg->rcode != dns_rcode_nxdomain)
1704 fatal("response to SOA query was unsuccessful");
1708 section = DNS_SECTION_ANSWER;
1710 section = DNS_SECTION_AUTHORITY;
1714 result = dns_message_firstname(rcvmsg, section);
1715 if (result != ISC_R_SUCCESS) {
1719 while (result == ISC_R_SUCCESS) {
1721 dns_message_currentname(rcvmsg, section, &name);
1723 result = dns_message_findtype(name, dns_rdatatype_soa, 0,
1725 if (result == ISC_R_SUCCESS)
1727 if (section == DNS_SECTION_ANSWER) {
1728 dns_rdataset_t *tset = NULL;
1729 if (dns_message_findtype(name, dns_rdatatype_cname, 0,
1730 &tset) == ISC_R_SUCCESS
1732 dns_message_findtype(name, dns_rdatatype_dname, 0,
1733 &tset) == ISC_R_SUCCESS
1736 seencname = ISC_TRUE;
1741 result = dns_message_nextname(rcvmsg, section);
1744 if (soaset == NULL && !seencname) {
1753 char namestr[DNS_NAME_FORMATSIZE];
1754 dns_name_format(name, namestr, sizeof(namestr));
1755 fprintf(stderr, "Found zone name: %s\n", namestr);
1758 result = dns_rdataset_first(soaset);
1759 check_result(result, "dns_rdataset_first");
1761 dns_rdata_init(&soarr);
1762 dns_rdataset_current(soaset, &soarr);
1763 result = dns_rdata_tostruct(&soarr, &soa, NULL);
1764 check_result(result, "dns_rdata_tostruct");
1766 dns_name_init(&master, NULL);
1767 dns_name_clone(&soa.origin, &master);
1769 if (userzone != NULL)
1770 zonename = userzone;
1775 char namestr[DNS_NAME_FORMATSIZE];
1776 dns_name_format(&master, namestr, sizeof(namestr));
1777 fprintf(stderr, "The master is: %s\n", namestr);
1780 if (userserver != NULL)
1781 serveraddr = userserver;
1783 char serverstr[DNS_NAME_MAXTEXT+1];
1786 isc_buffer_init(&buf, serverstr, sizeof(serverstr));
1787 result = dns_name_totext(&master, ISC_TRUE, &buf);
1788 check_result(result, "dns_name_totext");
1789 serverstr[isc_buffer_usedlength(&buf)] = 0;
1790 get_address(serverstr, DNSDEFAULTPORT, &tempaddr);
1791 serveraddr = &tempaddr;
1793 dns_rdata_freestruct(&soa);
1795 send_update(zonename, serveraddr, localaddr);
1796 setzoneclass(dns_rdataclass_none);
1798 dns_message_destroy(&soaquery);
1799 dns_request_destroy(&request);
1802 dns_message_destroy(&rcvmsg);
1803 ddebug("Out of recvsoa");
1807 result = dns_message_firstname(soaquery, DNS_SECTION_QUESTION);
1808 INSIST(result == ISC_R_SUCCESS);
1810 dns_message_currentname(soaquery, DNS_SECTION_QUESTION, &name);
1811 nlabels = dns_name_countlabels(name);
1813 fatal("could not find enclosing zone");
1814 dns_name_init(&tname, NULL);
1815 dns_name_getlabelsequence(name, 1, nlabels - 1, &tname);
1816 dns_name_clone(&tname, name);
1817 dns_request_destroy(&request);
1818 dns_message_renderreset(soaquery);
1819 dns_message_settsigkey(soaquery, NULL);
1820 if (userserver != NULL)
1821 sendrequest(localaddr, userserver, soaquery, &request);
1823 sendrequest(localaddr, &servers[ns_inuse], soaquery,
1829 sendrequest(isc_sockaddr_t *srcaddr, isc_sockaddr_t *destaddr,
1830 dns_message_t *msg, dns_request_t **request)
1832 isc_result_t result;
1833 nsu_requestinfo_t *reqinfo;
1835 reqinfo = isc_mem_get(mctx, sizeof(nsu_requestinfo_t));
1836 if (reqinfo == NULL)
1837 fatal("out of memory");
1839 reqinfo->addr = destaddr;
1840 result = dns_request_createvia3(requestmgr, msg, srcaddr, destaddr, 0,
1841 (userserver != NULL) ? tsigkey : NULL,
1842 FIND_TIMEOUT * 20, FIND_TIMEOUT, 3,
1843 global_task, recvsoa, reqinfo, request);
1844 check_result(result, "dns_request_createvia");
1849 start_update(void) {
1850 isc_result_t result;
1851 dns_rdataset_t *rdataset = NULL;
1852 dns_name_t *name = NULL;
1853 dns_request_t *request = NULL;
1854 dns_message_t *soaquery = NULL;
1855 dns_name_t *firstname;
1856 dns_section_t section = DNS_SECTION_UPDATE;
1858 ddebug("start_update()");
1861 dns_message_destroy(&answer);
1862 result = dns_message_firstname(updatemsg, section);
1863 if (result == ISC_R_NOMORE) {
1864 section = DNS_SECTION_PREREQUISITE;
1865 result = dns_message_firstname(updatemsg, section);
1867 if (result != ISC_R_SUCCESS) {
1872 if (userzone != NULL && userserver != NULL) {
1873 send_update(userzone, userserver, localaddr);
1874 setzoneclass(dns_rdataclass_none);
1878 result = dns_message_create(mctx, DNS_MESSAGE_INTENTRENDER,
1880 check_result(result, "dns_message_create");
1882 soaquery->flags |= DNS_MESSAGEFLAG_RD;
1884 result = dns_message_gettempname(soaquery, &name);
1885 check_result(result, "dns_message_gettempname");
1887 result = dns_message_gettemprdataset(soaquery, &rdataset);
1888 check_result(result, "dns_message_gettemprdataset");
1890 dns_rdataset_makequestion(rdataset, getzoneclass(), dns_rdatatype_soa);
1893 dns_message_currentname(updatemsg, section, &firstname);
1894 dns_name_init(name, NULL);
1895 dns_name_clone(firstname, name);
1897 ISC_LIST_INIT(name->list);
1898 ISC_LIST_APPEND(name->list, rdataset, link);
1899 dns_message_addname(soaquery, name, DNS_SECTION_QUESTION);
1901 if (userserver != NULL)
1902 sendrequest(localaddr, userserver, soaquery, &request);
1905 sendrequest(localaddr, &servers[ns_inuse], soaquery, &request);
1911 ddebug("cleanup()");
1914 dns_message_destroy(&answer);
1915 ddebug("Shutting down task manager");
1916 isc_taskmgr_destroy(&taskmgr);
1918 ddebug("Destroying event");
1919 isc_event_free(&global_event);
1921 ddebug("Shutting down socket manager");
1922 isc_socketmgr_destroy(&socketmgr);
1924 ddebug("Shutting down timer manager");
1925 isc_timermgr_destroy(&timermgr);
1927 ddebug("Destroying hash context");
1930 ddebug("Destroying memory context");
1932 isc_mem_stats(mctx, stderr);
1933 isc_mem_destroy(&mctx);
1937 getinput(isc_task_t *task, isc_event_t *event) {
1947 if (global_event == NULL)
1948 global_event = event;
1951 more = user_interaction();
1961 main(int argc, char **argv) {
1962 isc_result_t result;
1963 style = &dns_master_style_debug;
1967 interactive = ISC_TF(isatty(0));
1971 parse_args(argc, argv);
1975 result = isc_app_onrun(mctx, global_task, getinput, NULL);
1976 check_result(result, "isc_app_onrun");
1978 (void)isc_app_run();