| /** @file | |
| Copyright (c) 1999 - 2014, Intel Corporation. All rights reserved.<BR> | |
| This program and the accompanying materials are licensed and made available | |
| under the terms and conditions of the BSD License which accompanies this | |
| distribution. The full text of the license may be found at | |
| http://opensource.org/licenses/bsd-license.php. | |
| THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, | |
| WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. | |
| **/ | |
| /* | |
| * Copyright (c) 1996 by Internet Software Consortium. | |
| * | |
| * Permission to use, copy, modify, and distribute this software for any | |
| * purpose with or without fee is hereby granted, provided that the above | |
| * copyright notice and this permission notice appear in all copies. | |
| * | |
| * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS | |
| * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES | |
| * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE | |
| * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL | |
| * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR | |
| * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS | |
| * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS | |
| * SOFTWARE. | |
| */ | |
| /* | |
| * Portions copyright (c) 1999, 2000 | |
| * Intel Corporation. | |
| * All rights reserved. | |
| * | |
| * Redistribution and use in source and binary forms, with or without | |
| * modification, are permitted provided that the following conditions | |
| * are met: | |
| * | |
| * 1. Redistributions of source code must retain the above copyright | |
| * notice, this list of conditions and the following disclaimer. | |
| * | |
| * 2. Redistributions in binary form must reproduce the above copyright | |
| * notice, this list of conditions and the following disclaimer in the | |
| * documentation and/or other materials provided with the distribution. | |
| * | |
| * 3. All advertising materials mentioning features or use of this software | |
| * must display the following acknowledgement: | |
| * | |
| * This product includes software developed by Intel Corporation and | |
| * its contributors. | |
| * | |
| * 4. Neither the name of Intel Corporation or its contributors may be | |
| * used to endorse or promote products derived from this software | |
| * without specific prior written permission. | |
| * | |
| * THIS SOFTWARE IS PROVIDED BY INTEL CORPORATION AND CONTRIBUTORS ``AS IS'' | |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
| * ARE DISCLAIMED. IN NO EVENT SHALL INTEL CORPORATION OR CONTRIBUTORS BE | |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF | |
| * THE POSSIBILITY OF SUCH DAMAGE. | |
| * | |
| */ | |
| /* | |
| * Based on the Dynamic DNS reference implementation by Viraj Bais | |
| * <viraj_bais@ccm.fm.intel.com> | |
| */ | |
| #include <sys/param.h> | |
| #include <sys/socket.h> | |
| #include <sys/time.h> | |
| #include <netinet/in.h> | |
| #include <arpa/inet.h> | |
| #include <arpa/nameser.h> | |
| #include <errno.h> | |
| #include <limits.h> | |
| #include <netdb.h> | |
| #include <resolv.h> | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| /* | |
| * Separate a linked list of records into groups so that all records | |
| * in a group will belong to a single zone on the nameserver. | |
| * Create a dynamic update packet for each zone and send it to the | |
| * nameservers for that zone, and await answer. | |
| * Abort if error occurs in updating any zone. | |
| * Return the number of zones updated on success, < 0 on error. | |
| * | |
| * On error, caller must deal with the unsynchronized zones | |
| * eg. an A record might have been successfully added to the forward | |
| * zone but the corresponding PTR record would be missing if error | |
| * was encountered while updating the reverse zone. | |
| */ | |
| #define NSMAX 16 | |
| struct ns1 { | |
| char nsname[MAXDNAME]; | |
| struct in_addr nsaddr1; | |
| }; | |
| struct zonegrp { | |
| char z_origin[MAXDNAME]; | |
| int16_t z_class; | |
| char z_soardata[MAXDNAME + 5 * INT32SZ]; | |
| struct ns1 z_ns[NSMAX]; | |
| int z_nscount; | |
| ns_updrec * z_rr; | |
| struct zonegrp *z_next; | |
| }; | |
| int | |
| res_update(ns_updrec *rrecp_in) { | |
| ns_updrec *rrecp, *tmprrecp; | |
| u_char buf[PACKETSZ], answer[PACKETSZ], packet[2*PACKETSZ]; | |
| char name[MAXDNAME], zname[MAXDNAME], primary[MAXDNAME], | |
| mailaddr[MAXDNAME]; | |
| u_char soardata[2*MAXCDNAME+5*INT32SZ]; | |
| char *dname, *svdname, *cp1, *target; | |
| u_char *cp, *eom; | |
| HEADER *hp = (HEADER *) answer; | |
| struct zonegrp *zptr = NULL, *tmpzptr, *prevzptr, *zgrp_start = NULL; | |
| int i, j, k = 0, n, ancount, nscount, arcount, rcode, rdatasize, | |
| newgroup, done, myzone, seen_before, numzones = 0; | |
| u_int16_t dlen, class, qclass, type, qtype; | |
| u_int32_t ttl; | |
| if ((_res.options & RES_INIT) == 0 && res_init() == -1) { | |
| h_errno = NETDB_INTERNAL; | |
| return (-1); | |
| } | |
| for (rrecp = rrecp_in; rrecp; rrecp = rrecp->r_next) { | |
| dname = rrecp->r_dname; | |
| n = (int)strlen(dname); | |
| if (dname[n-1] == '.') | |
| dname[n-1] = '\0'; | |
| qtype = T_SOA; | |
| qclass = rrecp->r_class; | |
| done = 0; | |
| seen_before = 0; | |
| while (!done && dname) { | |
| if (qtype == T_SOA) { | |
| for (tmpzptr = zgrp_start; | |
| tmpzptr && !seen_before; | |
| tmpzptr = tmpzptr->z_next) { | |
| if (strcasecmp(dname, | |
| tmpzptr->z_origin) == 0 && | |
| tmpzptr->z_class == qclass) | |
| seen_before++; | |
| for (tmprrecp = tmpzptr->z_rr; | |
| tmprrecp && !seen_before; | |
| tmprrecp = tmprrecp->r_grpnext) | |
| if (strcasecmp(dname, tmprrecp->r_dname) == 0 | |
| && tmprrecp->r_class == qclass) { | |
| seen_before++; | |
| break; | |
| } | |
| if (seen_before) { | |
| /* | |
| * Append to the end of | |
| * current group. | |
| */ | |
| for (tmprrecp = tmpzptr->z_rr; | |
| tmprrecp->r_grpnext; | |
| tmprrecp = tmprrecp->r_grpnext) | |
| (void)NULL; | |
| tmprrecp->r_grpnext = rrecp; | |
| rrecp->r_grpnext = NULL; | |
| done = 1; | |
| break; | |
| } | |
| } | |
| } else if (qtype == T_A) { | |
| for (tmpzptr = zgrp_start; | |
| tmpzptr && !done; | |
| tmpzptr = tmpzptr->z_next) | |
| for (i = 0; i < tmpzptr->z_nscount; i++) | |
| if (tmpzptr->z_class == qclass && | |
| strcasecmp(tmpzptr->z_ns[i].nsname, | |
| dname) == 0 && | |
| tmpzptr->z_ns[i].nsaddr1.s_addr != 0) { | |
| zptr->z_ns[k].nsaddr1.s_addr = | |
| tmpzptr->z_ns[i].nsaddr1.s_addr; | |
| done = 1; | |
| break; | |
| } | |
| } | |
| if (done) | |
| break; | |
| n = res_mkquery(QUERY, dname, qclass, qtype, NULL, | |
| 0, NULL, buf, sizeof buf); | |
| if (n <= 0) { | |
| fprintf(stderr, "res_update: mkquery failed\n"); | |
| return (n); | |
| } | |
| n = res_send(buf, n, answer, sizeof answer); | |
| if (n < 0) { | |
| fprintf(stderr, "res_update: send error for %s\n", | |
| rrecp->r_dname); | |
| return (n); | |
| } | |
| if (n < HFIXEDSZ) | |
| return (-1); | |
| ancount = ntohs(hp->ancount); | |
| nscount = ntohs(hp->nscount); | |
| arcount = ntohs(hp->arcount); | |
| rcode = hp->rcode; | |
| cp = answer + HFIXEDSZ; | |
| eom = answer + n; | |
| /* skip the question section */ | |
| n = dn_skipname(cp, eom); | |
| if (n < 0 || cp + n + 2 * INT16SZ > eom) | |
| return (-1); | |
| cp += n + 2 * INT16SZ; | |
| if (qtype == T_SOA) { | |
| if (ancount == 0 && nscount == 0 && arcount == 0) { | |
| /* | |
| * if (rcode == NOERROR) then the dname exists but | |
| * has no soa record associated with it. | |
| * if (rcode == NXDOMAIN) then the dname does not | |
| * exist and the server is replying out of NCACHE. | |
| * in either case, proceed with the next try | |
| */ | |
| dname = strchr(dname, '.'); | |
| if (dname != NULL) | |
| dname++; | |
| continue; | |
| } else if ((rcode == NOERROR || rcode == NXDOMAIN) && | |
| ancount == 0 && | |
| nscount == 1 && arcount == 0) { | |
| /* | |
| * name/data does not exist, soa record supplied in the | |
| * authority section | |
| */ | |
| /* authority section must contain the soa record */ | |
| if ((n = dn_expand(answer, eom, cp, zname, | |
| sizeof zname)) < 0) | |
| return (n); | |
| cp += n; | |
| if (cp + 2 * INT16SZ > eom) | |
| return (-1); | |
| GETSHORT(type, cp); | |
| GETSHORT(class, cp); | |
| if (type != T_SOA || class != qclass) { | |
| fprintf(stderr, "unknown answer\n"); | |
| return (-1); | |
| } | |
| myzone = 0; | |
| svdname = dname; | |
| while (dname) | |
| if (strcasecmp(dname, zname) == 0) { | |
| myzone = 1; | |
| break; | |
| } else if ((dname = strchr(dname, '.')) != NULL) | |
| dname++; | |
| if (!myzone) { | |
| dname = strchr(svdname, '.'); | |
| if (dname != NULL) | |
| dname++; | |
| continue; | |
| } | |
| nscount = 0; | |
| /* fallthrough */ | |
| } else if (rcode == NOERROR && ancount == 1) { | |
| /* | |
| * found the zone name | |
| * new servers will supply NS records for the zone | |
| * in authority section and A records for those | |
| * nameservers in the additional section | |
| * older servers have to be explicitly queried for | |
| * NS records for the zone | |
| */ | |
| /* answer section must contain the soa record */ | |
| if ((n = dn_expand(answer, eom, cp, zname, | |
| sizeof zname)) < 0) | |
| return (n); | |
| else | |
| cp += n; | |
| if (cp + 2 * INT16SZ > eom) | |
| return (-1); | |
| GETSHORT(type, cp); | |
| GETSHORT(class, cp); | |
| if (type == T_CNAME) { | |
| dname = strchr(dname, '.'); | |
| if (dname != NULL) | |
| dname++; | |
| continue; | |
| } | |
| if (strcasecmp(dname, zname) != 0 || | |
| type != T_SOA || | |
| class != rrecp->r_class) { | |
| fprintf(stderr, "unknown answer\n"); | |
| return (-1); | |
| } | |
| /* FALLTHROUGH */ | |
| } else { | |
| fprintf(stderr, | |
| "unknown response: ans=%d, auth=%d, add=%d, rcode=%d\n", | |
| ancount, nscount, arcount, hp->rcode); | |
| return (-1); | |
| } | |
| if (cp + INT32SZ + INT16SZ > eom) | |
| return (-1); | |
| /* continue processing the soa record */ | |
| GETLONG(ttl, cp); | |
| GETSHORT(dlen, cp); | |
| if (cp + dlen > eom) | |
| return (-1); | |
| newgroup = 1; | |
| zptr = zgrp_start; | |
| prevzptr = NULL; | |
| while (zptr) { | |
| if (strcasecmp(zname, zptr->z_origin) == 0 && | |
| type == T_SOA && class == qclass) { | |
| newgroup = 0; | |
| break; | |
| } | |
| prevzptr = zptr; | |
| zptr = zptr->z_next; | |
| } | |
| if (!newgroup) { | |
| for (tmprrecp = zptr->z_rr; | |
| tmprrecp->r_grpnext; | |
| tmprrecp = tmprrecp->r_grpnext) | |
| ; | |
| tmprrecp->r_grpnext = rrecp; | |
| rrecp->r_grpnext = NULL; | |
| done = 1; | |
| cp += dlen; | |
| break; | |
| } else { | |
| if ((n = dn_expand(answer, eom, cp, primary, | |
| sizeof primary)) < 0) | |
| return (n); | |
| cp += n; | |
| /* | |
| * We don't have to bounds check here because the | |
| * next use of 'cp' is in dn_expand(). | |
| */ | |
| cp1 = (char *)soardata; | |
| strcpy(cp1, primary); | |
| cp1 += strlen(cp1) + 1; | |
| if ((n = dn_expand(answer, eom, cp, mailaddr, | |
| sizeof mailaddr)) < 0) | |
| return (n); | |
| cp += n; | |
| strcpy(cp1, mailaddr); | |
| cp1 += strlen(cp1) + 1; | |
| if (cp + 5*INT32SZ > eom) | |
| return (-1); | |
| memcpy(cp1, cp, 5*INT32SZ); | |
| cp += 5*INT32SZ; | |
| cp1 += 5*INT32SZ; | |
| rdatasize = (int)((u_char *)cp1 - soardata); | |
| zptr = calloc(1, sizeof(struct zonegrp)); | |
| if (zptr == NULL) | |
| return (-1); | |
| if (zgrp_start == NULL) | |
| zgrp_start = zptr; | |
| else | |
| prevzptr->z_next = zptr; | |
| zptr->z_rr = rrecp; | |
| rrecp->r_grpnext = NULL; | |
| strcpy(zptr->z_origin, zname); | |
| zptr->z_class = class; | |
| memcpy(zptr->z_soardata, soardata, rdatasize); | |
| /* fallthrough to process NS and A records */ | |
| } | |
| } else if (qtype == T_NS) { | |
| if (rcode == NOERROR && ancount > 0) { | |
| strcpy(zname, dname); | |
| for (zptr = zgrp_start; zptr; zptr = zptr->z_next) { | |
| if (strcasecmp(zname, zptr->z_origin) == 0) | |
| break; | |
| } | |
| if (zptr == NULL) | |
| /* should not happen */ | |
| return (-1); | |
| if (nscount > 0) { | |
| /* | |
| * answer and authority sections contain | |
| * the same information, skip answer section | |
| */ | |
| for (j = 0; j < ancount; j++) { | |
| n = dn_skipname(cp, eom); | |
| if (n < 0) | |
| return (-1); | |
| n += 2*INT16SZ + INT32SZ; | |
| if (cp + n + INT16SZ > eom) | |
| return (-1); | |
| cp += n; | |
| GETSHORT(dlen, cp); | |
| cp += dlen; | |
| } | |
| } else | |
| nscount = ancount; | |
| /* fallthrough to process NS and A records */ | |
| } else { | |
| fprintf(stderr, "cannot determine nameservers for %s:\ | |
| ans=%d, auth=%d, add=%d, rcode=%d\n", | |
| dname, ancount, nscount, arcount, hp->rcode); | |
| return (-1); | |
| } | |
| } else if (qtype == T_A) { | |
| if (rcode == NOERROR && ancount > 0) { | |
| arcount = ancount; | |
| ancount = nscount = 0; | |
| /* fallthrough to process A records */ | |
| } else { | |
| fprintf(stderr, "cannot determine address for %s:\ | |
| ans=%d, auth=%d, add=%d, rcode=%d\n", | |
| dname, ancount, nscount, arcount, hp->rcode); | |
| return (-1); | |
| } | |
| } | |
| /* process NS records for the zone */ | |
| j = 0; | |
| for (i = 0; i < nscount; i++) { | |
| if ((n = dn_expand(answer, eom, cp, name, | |
| sizeof name)) < 0) | |
| return (n); | |
| cp += n; | |
| if (cp + 3 * INT16SZ + INT32SZ > eom) | |
| return (-1); | |
| GETSHORT(type, cp); | |
| GETSHORT(class, cp); | |
| GETLONG(ttl, cp); | |
| GETSHORT(dlen, cp); | |
| if (cp + dlen > eom) | |
| return (-1); | |
| if (strcasecmp(name, zname) == 0 && | |
| type == T_NS && class == qclass) { | |
| if ((n = dn_expand(answer, eom, cp, | |
| name, sizeof name)) < 0) | |
| return (n); | |
| target = zptr->z_ns[j++].nsname; | |
| strcpy(target, name); | |
| } | |
| cp += dlen; | |
| } | |
| if (zptr->z_nscount == 0) | |
| zptr->z_nscount = j; | |
| /* get addresses for the nameservers */ | |
| for (i = 0; i < arcount; i++) { | |
| if ((n = dn_expand(answer, eom, cp, name, | |
| sizeof name)) < 0) | |
| return (n); | |
| cp += n; | |
| if (cp + 3 * INT16SZ + INT32SZ > eom) | |
| return (-1); | |
| GETSHORT(type, cp); | |
| GETSHORT(class, cp); | |
| GETLONG(ttl, cp); | |
| GETSHORT(dlen, cp); | |
| if (cp + dlen > eom) | |
| return (-1); | |
| if (type == T_A && dlen == INT32SZ && class == qclass) { | |
| for (j = 0; j < zptr->z_nscount; j++) | |
| if (strcasecmp(name, zptr->z_ns[j].nsname) == 0) { | |
| memcpy(&zptr->z_ns[j].nsaddr1.s_addr, cp, | |
| INT32SZ); | |
| break; | |
| } | |
| } | |
| cp += dlen; | |
| } | |
| if (zptr->z_nscount == 0) { | |
| dname = zname; | |
| qtype = T_NS; | |
| continue; | |
| } | |
| done = 1; | |
| for (k = 0; k < zptr->z_nscount; k++) | |
| if (zptr->z_ns[k].nsaddr1.s_addr == 0) { | |
| done = 0; | |
| dname = zptr->z_ns[k].nsname; | |
| qtype = T_A; | |
| } | |
| } /* while */ | |
| } | |
| --ttl; // Suppress the "Set but not used" warning/error for ttl. | |
| _res.options |= RES_DEBUG; | |
| for (zptr = zgrp_start; zptr; zptr = zptr->z_next) { | |
| /* append zone section */ | |
| rrecp = res_mkupdrec(ns_s_zn, zptr->z_origin, | |
| zptr->z_class, ns_t_soa, 0); | |
| if (rrecp == NULL) { | |
| fprintf(stderr, "saverrec error\n"); | |
| fflush(stderr); | |
| return (-1); | |
| } | |
| rrecp->r_grpnext = zptr->z_rr; | |
| zptr->z_rr = rrecp; | |
| n = res_mkupdate(zptr->z_rr, packet, sizeof packet); | |
| if (n < 0) { | |
| fprintf(stderr, "res_mkupdate error\n"); | |
| fflush(stderr); | |
| return (-1); | |
| } else | |
| fprintf(stdout, "res_mkupdate: packet size = %d\n", n); | |
| /* Override the list of NS records from res_init() with | |
| * the authoritative nameservers for the zone being updated. | |
| * Sort primary to be the first in the list of nameservers. | |
| */ | |
| for (i = 0; i < zptr->z_nscount; i++) { | |
| if (strcasecmp(zptr->z_ns[i].nsname, | |
| zptr->z_soardata) == 0) { | |
| struct in_addr tmpaddr; | |
| if (i != 0) { | |
| strcpy(zptr->z_ns[i].nsname, | |
| zptr->z_ns[0].nsname); | |
| strcpy(zptr->z_ns[0].nsname, | |
| zptr->z_soardata); | |
| tmpaddr = zptr->z_ns[i].nsaddr1; | |
| zptr->z_ns[i].nsaddr1 = | |
| zptr->z_ns[0].nsaddr1; | |
| zptr->z_ns[0].nsaddr1 = tmpaddr; | |
| } | |
| break; | |
| } | |
| } | |
| for (i = 0; i < MAXNS; i++) { | |
| _res.nsaddr_list[i].sin_addr = zptr->z_ns[i].nsaddr1; | |
| _res.nsaddr_list[i].sin_family = AF_INET; | |
| _res.nsaddr_list[i].sin_port = htons(NAMESERVER_PORT); | |
| } | |
| _res.nscount = (zptr->z_nscount < MAXNS) ? | |
| zptr->z_nscount : MAXNS; | |
| n = res_send(packet, n, answer, sizeof(answer)); | |
| if (n < 0) { | |
| fprintf(stderr, "res_send: send error, n=%d\n", n); | |
| break; | |
| } else | |
| numzones++; | |
| } | |
| /* free malloc'ed memory */ | |
| while(zgrp_start) { | |
| zptr = zgrp_start; | |
| zgrp_start = zgrp_start->z_next; | |
| res_freeupdrec(zptr->z_rr); /* Zone section we allocated. */ | |
| free((char *)zptr); | |
| } | |
| return (numzones); | |
| } |