import-axfr.c

此dns服务器是在mydns基础上改写

		Errx("%s: %s: %s", hostname, _("error reading name from answer section"), name);

	DNS_GET16(type, src);
	DNS_GET16(class, src);
	DNS_GET32(ttl, src);
	DNS_GET16(rdlen, src);
	rv = src + rdlen;

	if (!got_soa && type != DNS_QTYPE_SOA)
		Errx(_("got non-SOA RR before SOA"));

	switch (type)
	{
		case DNS_QTYPE_SOA:
			if (got_soa)
				return (NULL);
			process_axfr_soa(name, reply, replylen, src, ttl);
			break;

		case DNS_QTYPE_A:
			{
				struct in_addr addr;
				memcpy(&addr.s_addr, src, SIZE32);
				import_rr(shortname(name, 1), "A", inet_ntoa(addr), 0, ttl);
			}
			break;

		case DNS_QTYPE_AAAA:
			{
				uint8_t addr[16];

				memcpy(&addr, src, sizeof(uint8_t) * 16);
				if (inet_ntop(AF_INET6, &addr, data, sizeof(data)-1))
					import_rr(shortname(name, 1), "AAAA", data, 0, ttl);
				else
					Notice("%s IN AAAA: %s", name, strerror(errno));
			}
			break;

		case DNS_QTYPE_CNAME:
			if (!(src = name_unencode(reply, replylen, src, data, sizeof(data))))
				Errx("%s CNAME: %s: %s", name, _("error reading data"), data);
			import_rr(shortname(name, 1), "CNAME", shortname(data, 0), 0, ttl);
			break;

		case DNS_QTYPE_HINFO:
			{
				size_t len;
				int	quote1, quote2;
				char	*c, data2[DNS_MAXNAMELEN+1];
				char	insdata[DNS_MAXNAMELEN * 2 + 2];

				len = *src++;
				memcpy(data, src, len);
				data[len] = '\0';
				src += len;
				for (c = data, quote1 = 0; *c; c++)
					if (!isalnum(*c))
						quote1++;

				len = *src++;
				memcpy(data2, src, len);
				data2[len] = '\0';
				src += len;
				for (c = data2, quote2 = 0; *c; c++)
					if (!isalnum(*c))
						quote2++;

				snprintf(insdata, sizeof(insdata), "%s%s%s %s%s%s",
					quote1 ? "\"" : "", data, quote1 ? "\"" : "",
					quote2 ? "\"" : "", data2, quote2 ? "\"" : "");

				import_rr(shortname(name, 1), "HINFO", insdata, 0, ttl);
			}
			break;

		case DNS_QTYPE_MX:
			{
				uint16_t pref;
				DNS_GET16(pref, src);
				if (!(src = name_unencode(reply, replylen, src, data, sizeof(data))))
					Errx("%s MX: %s: %s", name, _("error reading data"), data);
				import_rr(shortname(name, 1), "MX", shortname(data, 0), pref, ttl);
			}
			break;

		case DNS_QTYPE_NS:
			if (!(src = name_unencode(reply, replylen, src, data, sizeof(data))))
				Errx("%s NS: %s: %s", name, _("error reading data"), data);
			import_rr(shortname(name, 1), "NS", shortname(data, 0), 0, ttl);
			break;

		case DNS_QTYPE_PTR:
			{
				struct in_addr addr;
				addr.s_addr = mydns_revstr_ip4(name);
				if (!(src = name_unencode(reply, replylen, src, data, sizeof(data))))
					Errx("%s PTR: %s: %s", name, _("error reading data"), data);
				import_rr(shortname(name, 1), "PTR", shortname(data, 0), 0, ttl);
			}
			break;

		case DNS_QTYPE_RP:
			{
				char txtref[DNS_MAXNAMELEN+1];
				char insdata[DNS_MAXNAMELEN * 2 + 2];

				/* Get mbox in 'data' */
				if (!(src = name_unencode(reply, replylen, src, data, sizeof(data))))
					Errx("%s RP: %s: %s", name, _("error reading mbox"), data);

				/* Get txt in 'txtref' */
				if (!(src = name_unencode(reply, replylen, src, txtref, sizeof(txtref))))
					Errx("%s RP: %s: %s", name, _("error reading txt"), txtref);

				/* Construct data to insert */
				snprintf(insdata, sizeof(insdata), "%s %s", shortname(data, 0), shortname(txtref, 0));

				import_rr(shortname(name, 1), "RP", insdata, 0, ttl);
			}
			break;

		case DNS_QTYPE_SRV:
		{
			uint16_t priority, weight, port;
			char		 databuf[DNS_MAXNAMELEN + 40];

			DNS_GET16(priority, src);
			DNS_GET16(weight, src);
			DNS_GET16(port, src);
			if (!(src = name_unencode(reply, replylen, src, data, sizeof(data))))
				Errx("%s SRV: %s: %s", name, _("error reading data"), data);
			snprintf(databuf, sizeof(databuf), "%u %u %s", weight, port, shortname(data, 0));
			import_rr(shortname(name, 1), "SRV", databuf, priority, ttl);
		}
		break;

		case DNS_QTYPE_TXT:
			{
				size_t len = *src++;

				memcpy(data, src, len);
				data[len] = '\0';
				src += len;
				import_rr(shortname(name, 1), "TXT", data, 0, ttl);
			}
			break;


		default:
			Warnx("%s %s: %s", name, mydns_qtype_str(type), _("discarding unsupported RR type"));
			break;
	}
	return (rv);
}
/*--- process_axfr_answer() ---------------------------------------------------------------------*/


/**************************************************************************************************
	PROCESS_AXFR_REPLY
**************************************************************************************************/
static int
process_axfr_reply(char *reply, size_t replylen)
{
	char *src = reply, name[DNS_MAXNAMELEN+1];
	uint16_t n, qdcount, ancount;
	DNS_HEADER	hdr;

	/* Read packet header */
	src += SIZE16;					/* ID */
	memcpy(&hdr, src, SIZE16); src += SIZE16;
	DNS_GET16(qdcount, src);
	DNS_GET16(ancount, src);
	src += SIZE16 * 2;
	if (hdr.rcode != DNS_RCODE_NOERROR)
		Errx("%s: %s: %s", hostname, _("server responded to our request with error"),
			  mydns_rcode_str(hdr.rcode));

#if DEBUG_ENABLED
	Debug("%d byte REPLY: qr=%u opcode=%s aa=%u tc=%u rd=%u ra=%u z=%u rcode=%u qd=%u an=%u",
			replylen, hdr.qr, mydns_opcode_str(hdr.opcode),
			hdr.aa, hdr.tc, hdr.rd, hdr.ra, hdr.z, hdr.rcode, qdcount, ancount);
#endif

	/* Read question section(s) */
	for (n = 0; n < qdcount; n++)
	{
		if (!(src = name_unencode(reply, replylen, src, name, sizeof(name))))
			Errx("%s: %s: %s", hostname, _("error reading name from question section"), name);
		src += (SIZE16 * 2);
	}

	/* Process all RRs in the answer section */
	for (n = 0; n < ancount; n++)
		if (!(src = process_axfr_answer(reply, replylen, src)))
			return (-1);

	return (0);
}
/*--- process_axfr_reply() ----------------------------------------------------------------------*/


/**************************************************************************************************
	IMPORT_AXFR
**************************************************************************************************/
void
import_axfr(char *hostport, char *import_zone)
{
	unsigned char *reply, len[2];
	int fd;
	size_t replylen;

#if DEBUG_ENABLED
	Debug("STARTING AXFR of \"%s\" from %s", import_zone, hostport);
#endif

	hostname = zone = NULL;
	got_soa = 0;

	zone = import_zone;

	/* Connect to remote host */
	if ((fd = axfr_connect(hostport, &hostname)) < 0)
		Errx("%s: %s", hostport, _("failed to connect"));
#if DEBUG_ENABLED
	Debug("connected to %s", hostport);
#endif

	/* Send AXFR request */
	request_axfr(fd, hostname, zone);

	/* Read packets from server and process them */
	while (recv(fd, len, 2, MSG_WAITALL) == 2)
	{
		if ((replylen = ((len[0] << 8) | (len[1]))) < 12)
			Errx(_("message too short"));
		if (!(reply = malloc(replylen)))
			Err("malloc");
		if (recv(fd, reply, replylen, MSG_WAITALL) != replylen)
			Errx(_("short message from server"));
		if (process_axfr_reply(reply, replylen))
			break;
		Free(reply);
	}
	close(fd);

#if DEBUG_ENABLED
	Debug("COMPLETED AXFR of \"%s\" from %s", import_zone, hostport);
#endif
}
/*--- import_axfr() -----------------------------------------------------------------------------*/

/* vi:set ts=3: */
/* NEED_PO */