35 #include <dns/result.h> 155 #if defined (NSUPDATE) 156 #if defined (DNS_ZONE_LOOKUP) 170 typedef struct dhcp_ddns_ns {
171 struct dhcp_ddns_ns *next;
175 dns_clientresevent_t *eventp;
180 dns_rdatatype_t rdtype;
182 struct in_addr addrs[DHCP_MAXNS];
183 struct in6_addr addrs6[DHCP_MAXNS];
206 dhcp_ddns_ns_t *dns_outstanding_ns = NULL;
224 add_to_ns_queue(dhcp_ddns_ns_t *ns_cb)
226 ns_cb->next = dns_outstanding_ns;
227 dns_outstanding_ns = ns_cb;
232 remove_from_ns_queue(dhcp_ddns_ns_t *ns_cb)
234 dhcp_ddns_ns_t **foo;
236 foo = &dns_outstanding_ns;
242 foo = &((*foo)->next);
248 find_in_ns_queue(dhcp_ddns_ns_t *ns_cb)
250 dhcp_ddns_ns_t *temp_cb;
251 int in_len, temp_len;
253 in_len = strlen(ns_cb->zname);
255 for(temp_cb = dns_outstanding_ns;
257 temp_cb = temp_cb->next) {
258 temp_len = strlen(temp_cb->zname);
259 if (temp_len > in_len)
261 if (strcmp(temp_cb->zname,
262 ns_cb->zname + (in_len - temp_len)) == 0)
263 return(ISC_R_SUCCESS);
265 return(ISC_R_NOTFOUND);
268 void cache_found_zone (dhcp_ddns_ns_t *);
271 void ddns_interlude(isc_task_t *, isc_event_t *);
273 #if defined (TRACING) 309 #define TRACE_PTR_LEN 8 311 typedef struct dhcp_ddns_map {
312 char old_pointer[TRACE_PTR_LEN];
314 struct dhcp_ddns_map *next;
318 static dhcp_ddns_map_t *ddns_map;
330 trace_ddns_input_write(
dhcp_ddns_cb_t *ddns_cb, isc_result_t result)
333 u_int32_t old_result;
334 char old_pointer[TRACE_PTR_LEN];
336 old_result = htonl((u_int32_t)result);
337 memset(old_pointer, 0, TRACE_PTR_LEN);
338 memcpy(old_pointer, &ddns_cb,
sizeof(ddns_cb));
340 iov[0].
len =
sizeof(old_result);
341 iov[0].
buf = (
char *)&old_result;
342 iov[1].
len = TRACE_PTR_LEN;
343 iov[1].
buf = old_pointer;
354 trace_ddns_input_read(
trace_type_t *ttype,
unsigned length,
357 u_int32_t old_result;
358 char old_pointer[TRACE_PTR_LEN];
359 dns_clientupdateevent_t *eventp;
361 dhcp_ddns_map_t *ddns_map_ptr;
363 if (length < (
sizeof(old_result) + TRACE_PTR_LEN)) {
364 log_error(
"trace_ddns_input_read: data too short");
368 memcpy(&old_result, buf,
sizeof(old_result));
369 memcpy(old_pointer, buf +
sizeof(old_result), TRACE_PTR_LEN);
372 for (ddns_map_ptr = ddns_map;
373 ddns_map_ptr != NULL;
374 ddns_map_ptr = ddns_map_ptr->next) {
375 if ((ddns_map_ptr->new_pointer != NULL) &&
376 memcmp(ddns_map_ptr->old_pointer,
377 old_pointer, TRACE_PTR_LEN) == 0) {
378 new_pointer = ddns_map_ptr->new_pointer;
379 ddns_map_ptr->new_pointer = NULL;
380 memset(ddns_map_ptr->old_pointer, 0, TRACE_PTR_LEN);
384 if (ddns_map_ptr == NULL) {
385 log_error(
"trace_dns_input_read: unable to map cb pointer");
389 eventp = (dns_clientupdateevent_t *)
395 sizeof(dns_clientupdateevent_t));
396 if (eventp == NULL) {
397 log_error(
"trace_ddns_input_read: unable to allocate event");
400 eventp->result = ntohl(old_result);
431 trace_ddns_output_write(dns_client_t *client, dns_rdataclass_t rdclass,
432 dns_name_t *zonename, dns_namelist_t *prerequisites,
433 dns_namelist_t *updates, isc_sockaddrlist_t *
servers,
434 dns_tsec_t *tsec,
unsigned int options,
435 isc_task_t *task, isc_taskaction_t action,
void *arg,
436 dns_clientupdatetrans_t **transp)
439 u_int32_t old_result;
440 char old_pointer[TRACE_PTR_LEN];
441 dhcp_ddns_map_t *ddns_map_ptr;
450 if (result != ISC_R_SUCCESS) {
451 log_error(
"trace_ddns_output_write: no input found");
452 return (ISC_R_FAILURE);
454 if (buflen < (
sizeof(old_result) + TRACE_PTR_LEN)) {
455 log_error(
"trace_ddns_output_write: data too short");
457 return (ISC_R_FAILURE);
459 memcpy(&old_result, inbuf,
sizeof(old_result));
460 result = ntohl(old_result);
461 memcpy(old_pointer, inbuf +
sizeof(old_result), TRACE_PTR_LEN);
465 for (ddns_map_ptr = ddns_map;
466 ddns_map_ptr != NULL;
467 ddns_map_ptr = ddns_map_ptr->next) {
468 if (ddns_map_ptr->new_pointer == NULL) {
477 if (ddns_map_ptr == NULL) {
478 ddns_map_ptr =
dmalloc(
sizeof(*ddns_map_ptr),
MDL);
479 if (ddns_map_ptr == NULL) {
481 "unable to allocate map entry");
482 return(ISC_R_FAILURE);
484 ddns_map_ptr->next = ddns_map;
485 ddns_map = ddns_map_ptr;
488 memcpy(ddns_map_ptr->old_pointer, old_pointer, TRACE_PTR_LEN);
489 ddns_map_ptr->new_pointer = arg;
493 result = dns_client_startupdate(client, rdclass, zonename,
494 prerequisites, updates,
496 task, action, arg, transp);
502 old_result = htonl((u_int32_t)result);
503 memset(old_pointer, 0, TRACE_PTR_LEN);
504 memcpy(old_pointer, &arg,
sizeof(arg));
505 iov[0].
len =
sizeof(old_result);
506 iov[0].
buf = (
char *)&old_result;
507 iov[1].
len = TRACE_PTR_LEN;
508 iov[1].
buf = old_pointer;
512 iov[2].
buf = (
char *)arg;
521 trace_ddns_output_read(
trace_type_t *ttype,
unsigned length,
524 log_error(
"unaccounted for ddns output.");
536 trace_ddns_output_read,
537 trace_ddns_output_stop,
MDL);
539 trace_ddns_input_read,
540 trace_ddns_input_stop,
MDL);
544 #define ddns_update trace_ddns_output_write 546 #define ddns_update dns_client_startupdate 549 #define zone_resolve dns_client_startresolve 562 if (ddns_cb != NULL) {
569 #if defined (DEBUG_DNS_UPDATES) 570 log_info(
"%s(%d): Allocating ddns_cb=%p",
file, line, ddns_cb);
579 #if defined (DEBUG_DNS_UPDATES) 580 log_info(
"%s(%d): freeing ddns_cb=%p",
file, line, ddns_cb);
587 if (ddns_cb->
zone != NULL) {
593 log_error(
"Impossible memory leak at %s:%d (attempt to free " 594 "DDNS Control Block before transaction).",
MDL);
618 dns_zone_hash_lookup(&tz, dns_zone_hash, zone->
name, 0,
MDL);
620 dns_zone_hash_delete(dns_zone_hash, tz->
name, 0,
MDL);
625 return (ISC_R_SUCCESS);
633 dns_zone_hash_lookup (&tz,
634 dns_zone_hash, zone ->
name, 0,
MDL);
637 return ISC_R_SUCCESS;
640 dns_zone_hash_delete (dns_zone_hash,
646 return ISC_R_NOMEMORY;
649 dns_zone_hash_add (dns_zone_hash, zone ->
name, 0, zone,
MDL);
650 return ISC_R_SUCCESS;
656 char *tname = (
char *)0;
660 return ISC_R_NOTFOUND;
663 if (name [len - 1] !=
'.') {
666 return ISC_R_NOMEMORY;
667 strcpy (tname, name);
672 if (!dns_zone_hash_lookup (zone, dns_zone_hash, name, 0,
MDL))
673 status = ISC_R_NOTFOUND;
674 else if ((*zone)->timeout && (*zone)->timeout <
cur_time) {
675 dns_zone_hash_delete(dns_zone_hash, (*zone)->name, 0,
MDL);
677 status = ISC_R_NOTFOUND;
679 status = ISC_R_SUCCESS;
693 if ((ptr == NULL) || (*ptr == NULL)) {
694 log_error(
"%s(%d): null pointer", file, line);
695 #if defined (POINTER_DEBUG) 709 if (dns_zone->
refcnt < 0) {
710 log_error(
"%s(%d): negative refcnt!", file, line);
711 #if defined (DEBUG_RC_HISTORY) 712 dump_rc_history(dns_zone);
714 #if defined (POINTER_DEBUG) 724 omapi_auth_key_dereference(&dns_zone->
key, file, line);
733 dfree(dns_zone, file, line);
737 #if defined (NSUPDATE) 738 #if defined (DNS_ZONE_LOOKUP) 745 zone_addr_to_ns(dhcp_ddns_ns_t *ns_cb,
750 dns_rdata_in_aaaa_t aaaa;
752 dns_rdata_init(&rdata);
753 dns_rdataset_current(rdataset, &rdata);
754 switch (rdataset->type) {
755 case dns_rdatatype_a:
756 (void) dns_rdata_tostruct(&rdata, &a, NULL);
757 memcpy(&ns_cb->addrs[ns_cb->num_addrs], &a.in_addr, 4);
759 dns_rdata_freestruct(&a);
761 case dns_rdatatype_aaaa:
762 (void) dns_rdata_tostruct(&rdata, &aaaa, NULL);
763 memcpy(&ns_cb->addrs6[ns_cb->num_addrs6], &aaaa.in6_addr, 16);
765 dns_rdata_freestruct(&aaaa);
771 if ((ns_cb->ttl == 0) || (ns_cb->ttl > rdataset->ttl))
772 ns_cb->ttl = rdataset->ttl;
807 find_zone_addrs(isc_task_t *taskp,
810 dns_clientresevent_t *ddns_event = (dns_clientresevent_t *)eventp;
811 dhcp_ddns_ns_t *ns_cb = (dhcp_ddns_ns_t *)eventp->ev_arg;
812 dns_name_t *ns_name = NULL;
816 dns_rdata_t
rdata = DNS_RDATA_INIT;
821 dns_client_destroyrestrans(&ns_cb->transaction);
828 if (ddns_event->result == ISC_R_SUCCESS) {
830 for (
name = ISC_LIST_HEAD(ddns_event->answerlist);
838 for (result = dns_rdataset_first(
rdataset);
839 result == ISC_R_SUCCESS;
840 result = dns_rdataset_next(
rdataset)) {
848 if (ns_cb->num_addrs +
860 for (ns_name = ns_cb->ns_name;
862 ns_name = ISC_LIST_NEXT(ns_name, link)) {
864 if (ns_name == ns_cb->ns_name) {
868 rdataset = ISC_LIST_HEAD(ns_name->list);
875 if (
rdataset->type != dns_rdatatype_ns)
877 dns_rdata_init(&
rdata);
881 if (ns_cb->rdtype == dns_rdatatype_a) {
882 ns_cb->rdtype = dns_rdatatype_aaaa;
884 ns_cb->rdtype = dns_rdatatype_a;
890 if ((!dns_rdataset_isassociated(
rdataset)) ||
897 if (dns_rdata_tostruct(&
rdata, &ns, NULL) !=
902 ns_cb->ns_name = ns_name;
909 DNS_CLIENTRESOPT_NODNSSEC,
913 &ns_cb->transaction);
916 dns_rdata_freestruct(&ns);
918 if (result == ISC_R_SUCCESS)
925 log_error(
"find_zone_ns: unable to continue " 928 isc_result_totext(result));
945 if ((ns_cb->num_addrs != 0) ||
946 (ns_cb->num_addrs6 != 0))
947 cache_found_zone(ns_cb);
950 &ns_cb->eventp->answerlist);
951 isc_event_free((isc_event_t **)&ns_cb->eventp);
953 remove_from_ns_queue(ns_cb);
961 &ddns_event->answerlist);
962 isc_event_free(&eventp);
975 find_zone_ns(isc_task_t *taskp,
978 dns_clientresevent_t *ddns_event = (dns_clientresevent_t *)eventp;
979 dhcp_ddns_ns_t *ns_cb = (dhcp_ddns_ns_t *)eventp->ev_arg;
980 dns_fixedname_t zname0;
981 dns_name_t *zname = NULL, *ns_name = NULL;
984 dns_rdata_t
rdata = DNS_RDATA_INIT;
988 dns_client_destroyrestrans(&ns_cb->transaction);
990 if (ddns_event->result != ISC_R_SUCCESS) {
994 ns_cb->zname = strchr(ns_cb->zname,
'.');
995 if ((ns_cb->zname == NULL) ||
996 (ns_cb->zname[1] == 0)) {
1006 != ISC_R_SUCCESS) ||
1008 zname, dns_rdataclass_in,
1010 DNS_CLIENTRESOPT_NODNSSEC,
1014 &ns_cb->transaction))
1015 != ISC_R_SUCCESS)) {
1016 log_error(
"find_zone_ns: Unable to build " 1017 "name or start resolve: %s %s",
1019 isc_result_totext(result));
1026 &ddns_event->answerlist);
1027 isc_event_free(&eventp);
1034 ns_cb->eventp = ddns_event;
1035 for (ns_name = ISC_LIST_HEAD(ddns_event->answerlist);
1037 ns_name = ISC_LIST_NEXT(ns_name, link)) {
1039 for (
rdataset = ISC_LIST_HEAD(ns_name->list);
1043 if (
rdataset->type != dns_rdatatype_ns)
1046 if ((!dns_rdataset_isassociated(
rdataset)) ||
1052 if (dns_rdata_tostruct(&
rdata, &ns, NULL) !=
1057 ns_cb->ns_name = ns_name;
1061 result = zone_resolve(
dhcp_gbl_ctx.dnsclient, &ns.name,
1064 DNS_CLIENTRESOPT_NODNSSEC,
1068 &ns_cb->transaction);
1071 dns_rdata_freestruct(&ns);
1073 if (result == ISC_R_SUCCESS)
1080 log_error(
"find_zone_ns: unable to continue " 1083 isc_result_totext(result));
1099 &ddns_event->answerlist);
1100 isc_event_free(&eventp);
1102 remove_from_ns_queue(ns_cb);
1121 isc_result_t status = ISC_R_NOTFOUND;
1122 dhcp_ddns_ns_t *ns_cb;
1123 dns_fixedname_t zname0;
1124 dns_name_t *zname = NULL;
1132 if (ns_cb == NULL) {
1133 log_error(
"find_zone_start: unable to allocate cb");
1134 return(ISC_R_FAILURE);
1136 ns_cb->rdtype = dns_rdatatype_a;
1144 ns_cb->zname = (
char *)ns_cb->oname.data;
1150 if (find_in_ns_queue(ns_cb) == ISC_R_SUCCESS) {
1153 return (ISC_R_SUCCESS);
1160 != ISC_R_SUCCESS) ||
1162 zname, dns_rdataclass_in,
1164 DNS_CLIENTRESOPT_NODNSSEC,
1168 &ns_cb->transaction))
1169 != ISC_R_SUCCESS)) {
1170 log_error(
"find_zone_start: Unable to build " 1171 "name or start resolve: %s %s",
1173 isc_result_totext(status));
1181 add_to_ns_queue(ns_cb);
1191 isc_result_t status = ISC_R_NOTFOUND;
1195 struct in_addr zone_addr;
1196 struct in6_addr zone_addr6;
1206 if ((np == NULL) || (*np ==
'\0')) {
1215 if (status == ISC_R_SUCCESS)
1218 np = strchr(np,
'.');
1224 if (status != ISC_R_SUCCESS)
1233 return (ISC_R_FAILURE);
1239 return (ISC_R_NOSPACE);
1243 memset (&nsaddrs, 0,
sizeof nsaddrs);
1252 if (ip + 4 > nsaddrs.
len)
1254 memcpy(&zone_addr, &nsaddrs.
data[ip], 4);
1255 isc_sockaddr_fromin(&ddns_cb->
zone_addrs[ix],
1274 if (ip + 16 > nsaddrs.
len)
1276 memcpy(&zone_addr6, &nsaddrs.
data[ip], 16);
1277 isc_sockaddr_fromin6(&ddns_cb->
zone_addrs[ix],
1296 if (ip + 4 > nsaddrs.
len)
1298 memcpy(&zone_addr, &nsaddrs.
data[ip], 4);
1299 isc_sockaddr_fromin(&ddns_cb->
zone_addrs[ix],
1318 if (ip + 16 > nsaddrs.
len)
1320 memcpy(&zone_addr6, &nsaddrs.
data[ip], 16);
1321 isc_sockaddr_fromin6(&ddns_cb->
zone_addrs[ix],
1336 return ISC_R_SUCCESS;
1347 if ((zone == NULL) || (*zone == NULL)) {
1348 log_info(
"Null argument to repudiate zone");
1356 #if defined (DNS_ZONE_LOOKUP) 1357 void cache_found_zone(dhcp_ddns_ns_t *ns_cb)
1360 int len, remove_zone = 0;
1385 len = strlen(ns_cb->zname);
1387 if (zone->
name == NULL) {
1392 strcpy(zone->
name, ns_cb->zname);
1393 if (zone->
name[len-1] !=
'.') {
1394 zone->
name[len] =
'.';
1395 zone->
name[len+1] = 0;
1401 if (ns_cb->num_addrs != 0) {
1402 len = ns_cb->num_addrs *
sizeof(
struct in_addr);
1406 if (remove_zone == 1)
1415 if (ns_cb->num_addrs6 != 0) {
1416 len = ns_cb->num_addrs6 *
sizeof(
struct in6_addr);
1420 if (remove_zone == 1)
1464 const u_int8_t *identifier,
1468 isc_sha256_t sha256;
1469 unsigned char buf[ISC_SHA256_DIGESTLENGTH];
1470 unsigned char fwd_buf[256];
1471 unsigned fwd_buflen = 0;
1474 if (type < 0 || type > 65535)
1480 while(fwd_buf[fwd_buflen] != 0) {
1481 fwd_buflen += fwd_buf[fwd_buflen] + 1;
1486 ISC_SHA256_DIGESTLENGTH + 2 + 1,
1489 id->
data =
id->buffer->data;
1498 isc_sha256_init(&sha256);
1499 isc_sha256_update(&sha256, identifier, id_len);
1500 isc_sha256_update(&sha256, fwd_buf, fwd_buflen);
1501 isc_sha256_final(buf, &sha256);
1503 memcpy(id->
buffer->
data + 3, &buf, ISC_SHA256_DIGESTLENGTH);
1505 id->len = ISC_SHA256_DIGESTLENGTH + 2 + 1;
1533 const u_int8_t *
data,
1537 unsigned char buf[ISC_MD5_DIGESTLENGTH];
1542 if (type < 0 || type > 65535)
1550 (ISC_MD5_DIGESTLENGTH * 2) + 4,
MDL))
1552 id->
data =
id->buffer->data;
1559 id->buffer->data[0] = ISC_MD5_DIGESTLENGTH * 2 + 2;
1562 id->buffer->data[1] =
"0123456789abcdef"[(type >> 4) & 0xf];
1567 id->buffer->data[2] =
"0123456789abcdef"[type % 15];
1571 isc_md5_update(&md5,
data, len);
1572 isc_md5_final(&md5, buf);
1575 for (i = 0; i < ISC_MD5_DIGESTLENGTH; i++) {
1576 id->buffer->data[i * 2 + 3] =
1577 "0123456789abcdef"[(buf[i] >> 4) & 0xf];
1578 id->buffer->data[i * 2 + 4] =
1579 "0123456789abcdef"[buf[i] & 0xf];
1582 id->len = ISC_MD5_DIGESTLENGTH * 2 + 3;
1583 id->buffer->data[
id->len] = 0;
1591 const u_int8_t *identifier,
1595 return get_std_dhcid(ddns_cb, type, identifier, id_len);
1597 return get_int_dhcid(ddns_cb, type, identifier, id_len);
1626 return(ISC_R_FAILURE);
1633 dhcid->
len = leaseid->
len + 1;
1639 return(ISC_R_SUCCESS);
1651 make_dns_dataset(dns_rdataclass_t dataclass,
1652 dns_rdatatype_t datatype,
1654 unsigned char *
data,
1662 isc_region_t region;
1665 dns_rdata_init(rdata);
1669 rdata->flags = DNS_RDATA_UPDATE;
1670 rdata->type = datatype;
1671 rdata->rdclass = dataclass;
1674 case dns_rdatatype_a:
1675 case dns_rdatatype_aaaa:
1676 case dns_rdatatype_txt:
1677 case dns_rdatatype_dhcid:
1678 case dns_rdatatype_ptr:
1682 region.length = datalen;
1683 dns_rdata_fromregion(rdata, dataclass, datatype,
1693 dns_rdatalist_init(rdatalist);
1694 rdatalist->type = datatype;
1695 rdatalist->rdclass = dataclass;
1696 rdatalist->ttl = ttl;
1697 ISC_LIST_APPEND(rdatalist->rdata, rdata, link);
1700 dns_rdataset_init(rdataset);
1701 dns_rdatalist_tordataset(rdatalist, rdataset);
1703 return(ISC_R_SUCCESS);
1733 isc_result_t result;
1738 result = make_dns_dataset(dns_rdataclass_none,
1740 dataspace, NULL, 0, 0);
1743 result = make_dns_dataset(dns_rdataclass_none,
1745 dataspace, NULL, 0, 0);
1747 if (result != ISC_R_SUCCESS) {
1750 ISC_LIST_APPEND(pname->list, &dataspace->
rdataset, link);
1755 result = make_dns_dataset(dns_rdataclass_in, ddns_cb->
address_type,
1759 if (result != ISC_R_SUCCESS) {
1762 ISC_LIST_APPEND(uname->list, &dataspace->
rdataset, link);
1766 result = make_dns_dataset(dns_rdataclass_in, ddns_cb->
dhcid_class,
1770 if (result != ISC_R_SUCCESS) {
1773 ISC_LIST_APPEND(uname->list, &dataspace->
rdataset, link);
1775 return(ISC_R_SUCCESS);
1812 isc_result_t result = ISC_R_SUCCESS;
1821 result = make_dns_dataset(dns_rdataclass_in, ddns_cb->
dhcid_class,
1825 if (result != ISC_R_SUCCESS) {
1828 ISC_LIST_APPEND(pname->list, &dataspace->
rdataset, link);
1833 result = make_dns_dataset(dns_rdataclass_any,
1835 dataspace, NULL, 0, 0);
1836 if (result != ISC_R_SUCCESS) {
1839 ISC_LIST_APPEND(uname->list, &dataspace->
rdataset, link);
1843 result = make_dns_dataset(dns_rdataclass_in, ddns_cb->
dhcid_class,
1847 if (result != ISC_R_SUCCESS) {
1850 ISC_LIST_APPEND(uname->list, &dataspace->
rdataset, link);
1856 result = make_dns_dataset(dns_rdataclass_any, ddns_cb->
address_type,
1857 dataspace, NULL, 0, 0);
1858 if (result != ISC_R_SUCCESS) {
1861 ISC_LIST_APPEND(uname->list, &dataspace->
rdataset, link);
1865 result = make_dns_dataset(dns_rdataclass_in, ddns_cb->
address_type,
1869 if (result != ISC_R_SUCCESS) {
1872 ISC_LIST_APPEND(uname->list, &dataspace->
rdataset, link);
1874 return(ISC_R_SUCCESS);
1905 isc_result_t result = ISC_R_SUCCESS;
1909 result = make_dns_dataset(dns_rdataclass_in, ddns_cb->
dhcid_class,
1913 if (result != ISC_R_SUCCESS) {
1916 ISC_LIST_APPEND(pname->list, &dataspace->
rdataset, link);
1921 result = make_dns_dataset(dns_rdataclass_none, ddns_cb->
address_type,
1925 if (result != ISC_R_SUCCESS) {
1928 ISC_LIST_APPEND(uname->list, &dataspace->
rdataset, link);
1930 return(ISC_R_SUCCESS);
1952 isc_result_t result;
1956 result = make_dns_dataset(dns_rdataclass_none, dns_rdatatype_a,
1957 dataspace, NULL, 0, 0);
1958 if (result != ISC_R_SUCCESS) {
1961 ISC_LIST_APPEND(pname->list, &dataspace->
rdataset, link);
1965 result = make_dns_dataset(dns_rdataclass_none, dns_rdatatype_aaaa,
1966 dataspace, NULL, 0, 0);
1967 if (result != ISC_R_SUCCESS) {
1970 ISC_LIST_APPEND(pname->list, &dataspace->
rdataset, link);
1975 result = make_dns_dataset(dns_rdataclass_none, ddns_cb->
dhcid_class,
1979 if (result != ISC_R_SUCCESS) {
1982 ISC_LIST_APPEND(uname->list, &dataspace->
rdataset, link);
1984 return(ISC_R_SUCCESS);
1992 void ddns_interlude(isc_task_t *taskp,
1993 isc_event_t *eventp)
1996 dns_clientupdateevent_t *ddns_event = (dns_clientupdateevent_t *)eventp;
1997 isc_result_t eresult = ddns_event->result;
1998 isc_result_t result;
2002 isc_event_free(&eventp);
2004 #if defined (TRACING) 2006 trace_ddns_input_write(ddns_cb, eresult);
2010 #if defined (DEBUG_DNS_UPDATES) 2015 dns_client_destroyupdatetrans(&ddns_cb->
transaction);
2019 if ((eresult == ISC_R_CANCELED) ||
2021 #if defined (DEBUG_DNS_UPDATES) 2022 log_info(
"DDNS: completeing transaction cancellation cb=%p, " 2024 ddns_cb, ddns_cb->
flags, isc_result_totext(eresult));
2027 log_info(
"DDNS: cleaning up lease pointer for a cancel " 2035 ddns_cb->
cur_func(ddns_cb, eresult);
2039 if (ddns_cb->
next_op != NULL) {
2048 if ((eresult == DNS_R_NOTAUTH) ||
2049 (eresult == DNS_R_NOTZONE)) {
2053 log_error(
"DDNS: bad zone information, repudiating zone %s",
2059 ISC_LINK_INIT(&ddns_cb->
zone_addrs[i], link);
2069 if (result != ISC_R_SUCCESS) {
2072 log_info(
"DDNS: Failed to retry after zone failure");
2073 ddns_cb->
cur_func(ddns_cb, result);
2078 ddns_cb->
cur_func(ddns_cb, eresult);
2093 isc_result_t result;
2094 dns_tsec_t *tsec_key = NULL;
2096 unsigned char *clientname;
2098 dns_namelist_t prereqlist, updatelist;
2099 dns_fixedname_t zname0, pname0, uname0;
2100 dns_name_t *zname = NULL, *pname, *uname;
2102 isc_sockaddrlist_t *zlist = NULL;
2106 if (result != ISC_R_SUCCESS) {
2130 if (ddns_cb->
zone == NULL) {
2132 #if defined (DNS_ZONE_LOOKUP) 2133 if (result == ISC_R_NOTFOUND) {
2152 if (result != ISC_R_SUCCESS)
2161 if (ddns_cb->
zone) {
2164 if (result != ISC_R_SUCCESS) {
2165 log_error(
"Unable to build name for zone for " 2166 "fwd update: %s %s",
2168 isc_result_totext(result));
2178 if (ddns_cb->
zone->
key != NULL) {
2186 if (tsec_key == NULL) {
2187 log_error(
"No tsec for use with key %s",
2195 != ISC_R_SUCCESS) ||
2197 != ISC_R_SUCCESS)) {
2198 log_error(
"Unable to build name for fwd update: %s %s",
2199 clientname, isc_result_totext(result));
2205 if (dataspace == NULL) {
2206 log_error(
"Unable to allocate memory for fwd update");
2207 result = ISC_R_NOMEMORY;
2211 ISC_LIST_INIT(prereqlist);
2212 ISC_LIST_INIT(updatelist);
2214 switch(ddns_cb->
state) {
2216 result = ddns_modify_fwd_add1(ddns_cb, dataspace,
2218 if (result != ISC_R_SUCCESS) {
2221 ISC_LIST_APPEND(prereqlist, pname, link);
2224 result = ddns_modify_fwd_add2(ddns_cb, dataspace,
2226 if (result != ISC_R_SUCCESS) {
2235 ISC_LIST_APPEND(prereqlist, pname, link);
2240 result = ddns_modify_fwd_rem1(ddns_cb, dataspace,
2242 if (result != ISC_R_SUCCESS) {
2245 ISC_LIST_APPEND(prereqlist, pname, link);
2248 result = ddns_modify_fwd_rem2(ddns_cb, dataspace,
2250 if (result != ISC_R_SUCCESS) {
2253 ISC_LIST_APPEND(prereqlist, pname, link);
2257 log_error(
"Invalid operation in ddns code.");
2267 ISC_LIST_APPEND(updatelist, uname, link);
2271 dns_rdataclass_in, zname,
2272 &prereqlist, &updatelist,
2274 DNS_CLIENTRESOPT_ALLOWRUN,
2279 if (result == ISC_R_FAMILYNOSUPPORT) {
2280 log_info(
"Unable to perform DDNS update, " 2281 "address family not supported");
2284 #if defined (DEBUG_DNS_UPDATES) 2289 #if defined (DEBUG_DNS_UPDATES) 2290 if (result != ISC_R_SUCCESS) {
2291 log_info(
"DDNS: %s(%d): error in ddns_modify_fwd %s for %p",
2292 file, line, isc_result_totext(result), ddns_cb);
2296 if (dataspace != NULL) {
2298 sizeof(*dataspace) * 4);
2307 isc_result_t result;
2308 dns_tsec_t *tsec_key = NULL;
2309 unsigned char *ptrname;
2311 dns_namelist_t updatelist;
2312 dns_fixedname_t zname0, uname0;
2313 dns_name_t *zname = NULL, *uname;
2314 isc_sockaddrlist_t *zlist = NULL;
2315 unsigned char buf[256];
2320 if (result != ISC_R_SUCCESS) {
2333 #if defined (DNS_ZONE_LOOKUP) 2334 if (result == ISC_R_NOTFOUND) {
2339 if (find_zone_start(ddns_cb,
FIND_REVERSE) == ISC_R_SUCCESS) {
2352 if (result != ISC_R_SUCCESS)
2356 if ((result == ISC_R_SUCCESS) &&
2360 if (result != ISC_R_SUCCESS) {
2361 log_error(
"Unable to build name for zone for " 2362 "fwd update: %s %s",
2364 isc_result_totext(result));
2378 if ((ddns_cb->
zone != NULL) && (ddns_cb->
zone->
key != NULL)) {
2380 if (tsec_key == NULL) {
2381 log_error(
"No tsec for use with key %s",
2393 log_error(
"Unable to build name for fwd update: %s %s",
2394 ptrname, isc_result_totext(result));
2404 if (dataspace == NULL) {
2405 log_error(
"Unable to allocate memory for fwd update");
2406 result = ISC_R_NOMEMORY;
2410 ISC_LIST_INIT(updatelist);
2417 result = make_dns_dataset(dns_rdataclass_any, dns_rdatatype_ptr,
2418 &dataspace[0], NULL, 0, 0);
2419 if (result != ISC_R_SUCCESS) {
2422 ISC_LIST_APPEND(uname->list, &dataspace[0].
rdataset, link);
2473 while (buf[buflen] != 0) {
2474 buflen += buf[buflen] + 1;
2478 result = make_dns_dataset(dns_rdataclass_in,
2481 buf, buflen, ddns_cb->
ttl);
2482 if (result != ISC_R_SUCCESS) {
2485 ISC_LIST_APPEND(uname->list, &dataspace[1].
rdataset, link);
2488 ISC_LIST_APPEND(updatelist, uname, link);
2497 result = ddns_update((dns_client_t *)
dhcp_gbl_ctx.dnsclient,
2498 dns_rdataclass_in, zname,
2501 DNS_CLIENTRESOPT_ALLOWRUN,
2503 ddns_interlude, (
void *)ddns_cb,
2505 if (result == ISC_R_FAMILYNOSUPPORT) {
2506 log_info(
"Unable to perform DDNS update, " 2507 "address family not supported");
2510 #if defined (DEBUG_DNS_UPDATES) 2515 #if defined (DEBUG_DNS_UPDATES) 2516 if (result != ISC_R_SUCCESS) {
2517 log_info(
"DDNS: %s(%d): error in ddns_modify_ptr %s for %p",
2518 file, line, isc_result_totext(result), ddns_cb);
2522 if (dataspace != NULL) {
2524 sizeof(*dataspace) * 2);
2533 dns_client_cancelupdate((dns_clientupdatetrans_t *)
2536 ddns_cb->
lease = NULL;
2538 #if defined (DEBUG_DNS_UPDATES) 2539 log_info(
"DDNS: %s(%d): cancelling transaction for %p",
2540 file, line, ddns_cb);
#define rc_register(file, line, reference, addr, refcnt, d, f)
dns_rdatalist_t rdatalist
#define DDNS_PRINT_INBOUND
struct binding_scope * global_scope
unsigned char zone_name[DHCP_MAXDNS_WIRE]
#define DDNS_STATE_ADD_FW_NXDOMAIN
#define DDNS_PRINT_OUTBOUND
int get_dhcid(dhcp_ddns_cb_t *, int, const u_int8_t *, unsigned)
isc_result_t dhcp_isc_name(unsigned char *namestr, dns_fixedname_t *namefix, dns_name_t **name)
int option_cache_dereference(struct option_cache **ptr, const char *file, int line)
isc_result_t ddns_modify_ptr(dhcp_ddns_cb_t *ddns_cb, const char *file, int line)
dhcp_context_t dhcp_gbl_ctx
#define DDNS_STATE_REM_PTR
#define DHCP_R_INVALIDARG
isc_sockaddr_t zone_addrs[DHCP_MAXNS]
#define HASH_FUNCTIONS(name, bufarg, type, hashtype, ref, deref, hasher)
dhcp_ddns_cb_t * ddns_cb_alloc(const char *file, int line)
void data_string_forget(struct data_string *data, const char *file, int line)
void print_dns_status(int, struct dhcp_ddns_cb *, isc_result_t)
int log_error(const char *,...) __attribute__((__format__(__printf__
int dns_zone_reference(struct dns_zone **ptr, struct dns_zone *bp, const char *file, int line)
#define DDNS_INCLUDE_RRSET
struct option_cache * secondary6
#define DDNS_STATE_REM_FW_YXDHCID
isc_result_t enter_dns_zone(struct dns_zone *zone)
struct data_string fwd_name
void forget_zone(struct dns_zone **)
void ddns_cb_free(dhcp_ddns_cb_t *ddns_cb, const char *file, int line)
void dhcid_tolease(struct data_string *, struct data_string *)
int option_cache_allocate(struct option_cache **cptr, const char *file, int line)
struct data_string rev_name
int evaluate_option_cache(struct data_string *result, struct packet *packet, struct lease *lease, struct client_state *client_state, struct option_state *in_options, struct option_state *cfg_options, struct binding_scope **scope, struct option_cache *oc, const char *file, int line)
isc_result_t dns_client_init()
dns_rdataclass_t dhcid_class
#define DDNS_STATE_ADD_PTR
int buffer_allocate(struct buffer **ptr, unsigned len, const char *file, int line)
struct dhcp_ddns_cb * next_op
trace_type_t * trace_type_register(const char *, void *, void(*)(trace_type_t *, unsigned, char *), void(*)(trace_type_t *), const char *, int)
#define DDNS_CONFLICT_OVERRIDE
isc_result_t trace_write_packet_iov(trace_type_t *, int, trace_iov_t *, const char *, int)
void dfree(void *, const char *, int)
isc_result_t dhcid_fromlease(struct data_string *, struct data_string *)
struct dhcp_ddns_cb dhcp_ddns_cb_t
void ddns_cancel(dhcp_ddns_cb_t *ddns_cb, const char *file, int line)
isc_sockaddrlist_t zone_server_list
void repudiate_zone(struct dns_zone **)
int int log_info(const char *,...) __attribute__((__format__(__printf__
void * dmalloc(size_t, const char *, int)
#define DNS_ZONE_INACTIVE
void putUChar(unsigned char *, u_int32_t)
struct option_cache * secondary
void trace_ddns_init(void)
isc_result_t remove_dns_zone(struct dns_zone *zone)
int MRns_name_pton(const char *src, u_char *dst, size_t dstsiz)
struct option_cache * primary6
dns_zone_hash_t * dns_zone_hash
isc_result_t trace_get_packet(trace_type_t **, unsigned *, char **)
#define DDNS_STATE_ADD_FW_YXDHCID
struct server_list * servers
void ddns_cb_forget_zone(dhcp_ddns_cb_t *ddns_cb)
int dns_zone_allocate(struct dns_zone **ptr, const char *file, int line)
struct dhcp_ddns_rdata dhcp_ddns_data_t
isc_result_t find_cached_zone(dhcp_ddns_cb_t *, int)
void putUShort(unsigned char *, u_int32_t)
const unsigned char * data
void data_string_copy(struct data_string *dest, const struct data_string *src, const char *file, int line)
unsigned do_case_hash(const void *, unsigned, unsigned)
isc_result_t dns_zone_lookup(struct dns_zone **zone, const char *name)
#define DDNS_STATE_REM_FW_NXRR
int dns_zone_dereference(struct dns_zone **ptr, const char *file, int line)
struct option_cache * primary
isc_result_t ddns_modify_fwd(dhcp_ddns_cb_t *ddns_cb, const char *file, int line)