/* xfr-inspect - list the contents and inspect an zone transfer XFR file
* By W.C.A. Wijngaards
* Copyright 2017, NLnet Labs.
* BSD, see LICENSE.
*/

#include "config.h"
#include "util.h"
#include "buffer.h"
#include "packet.h"
#include "rdata.h"
#include "namedb.h"
#include "difffile.h"
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>

/** verbosity for inspect */
static int v = 0;
/** shorthand for ease */
#ifdef ULL
#undef ULL
#endif
#define ULL (unsigned long long)

/** print usage text */
static void
usage(void)
{
       printf("usage:  xfr-inspect [options] file\n");
       printf(" -h             this help\n");
       printf(" -v             increase verbosity: "
              "with -v(list chunks), -vv(inside chunks)\n");
       printf(" -l             list contents of transfer\n");
}

static int
xi_diff_read_64(FILE *in, uint64_t* result)
{
       if (fread(result, sizeof(*result), 1, in) == 1) {
               return 1;
       } else {
               return 0;
       }
}

static int
xi_diff_read_32(FILE *in, uint32_t* result)
{
       if (fread(result, sizeof(*result), 1, in) == 1) {
               *result = ntohl(*result);
               return 1;
       } else {
               return 0;
       }
}

static int
xi_diff_read_8(FILE *in, uint8_t* result)
{
       if (fread(result, sizeof(*result), 1, in) == 1) {
               return 1;
       } else {
               return 0;
       }
}

static int
xi_diff_read_str(FILE* in, char* buf, size_t len)
{
       uint32_t disklen;
       if(!xi_diff_read_32(in, &disklen))
               return 0;
       if(disklen >= len)
               return 0;
       if(fread(buf, disklen, 1, in) != 1)
               return 0;
       buf[disklen] = 0;
       return 1;
}


/** inspect header of xfr file, return num_parts */
static int
inspect_header(FILE* in)
{
       char zone_buf[3072];
       char patname_buf[2048];

       uint32_t old_serial, new_serial, num_parts, type;
       uint64_t time_end_0, time_start_0;
       uint32_t time_end_1, time_start_1;
       uint8_t committed;

       time_t time_end, time_start;

       if(!xi_diff_read_32(in, &type)) {
               printf("could not read type, file short\n");
               fclose(in);
               exit(1);
       }
       if(type != DIFF_PART_XFRF) {
               printf("type:   %x (BAD FILE TYPE)\n", type);
               fclose(in);
               exit(1);
       }
       if(!xi_diff_read_8(in, &committed) ||
               !xi_diff_read_32(in, &num_parts) ||
               !xi_diff_read_64(in, &time_end_0) ||
               !xi_diff_read_32(in, &time_end_1) ||
               !xi_diff_read_32(in, &old_serial) ||
               !xi_diff_read_32(in, &new_serial) ||
               !xi_diff_read_64(in, &time_start_0) ||
               !xi_diff_read_32(in, &time_start_1) ||
               !xi_diff_read_str(in, zone_buf, sizeof(zone_buf)) ||
               !xi_diff_read_str(in, patname_buf, sizeof(patname_buf))) {
               printf("diff file bad commit part, file too short");
               fclose(in);
               exit(1);
       }
       time_end = (time_t)time_end_0;
       time_start = (time_t)time_start_0;

       /* printf("type:                %x\n", (int)type); */
       printf("committed:      %d (%s)\n", (int)committed,
               committed?"yes":"no");
       printf("num_parts:      %d\n", (int)num_parts);
       printf("time_end:       %d.%6.6d %s", (int)time_end_0,
               (int)time_end_1, ctime(&time_end));
       printf("old_serial:     %u\n", (unsigned)old_serial);
       printf("new_serial:     %u\n", (unsigned)new_serial);
       printf("time_start:     %d.%6.6d %s", (int)time_start_0,
               (int)time_start_1, ctime(&time_start));
       printf("zone:           %s\n", zone_buf);
       printf("patname:        %s\n", patname_buf);

       return num_parts;
}

/** print records in packet */
static void
print_records(region_type* region, buffer_type* pkt, int num, int qsection)
{
       domain_table_type* table;
       int i;
       rr_type* rr;
       region_type* tmpregion = region_create(xalloc, free);
       buffer_type* tmpbuf;
       if(!tmpregion) {
               printf("out of memory\n");
               return;
       }
       tmpbuf = buffer_create(region, QIOBUFSZ);
       if(!tmpbuf) {
               printf("out of memory\n");
               return;
       }
       table = domain_table_create(tmpregion);
       if(!table) {
               printf("out of memory\n");
               return;
       }

       for(i=0; i<num; ++i) {
               rr = packet_read_rr(region, table, pkt, qsection);
               if(!rr) {
                       printf("; cannot read rr %d\n", i);
                       return;
               }
               if(qsection) {
                       printf("%s", dname_to_string(domain_dname(rr->owner),
                               NULL));
                       printf("\t%s", rrclass_to_string(rr->klass));
                       if(rr->type == TYPE_IXFR)
                               printf("\tIXFR\n");
                       else if(rr->type == TYPE_AXFR)
                               printf("\tAXFR\n");
                       else printf("\t%s\n", rrtype_to_string(rr->type));
               } else {
                       if(!print_rr(stdout, NULL, rr, tmpregion, tmpbuf)) {
                               printf("; cannot print rr %d\n", i);
                       }
               }
       }
       region_destroy(tmpregion);
}

/** inspect packet (IXFR or AXFR) */
static void
inspect_packet(region_type* region, buffer_type* pkt)
{
       printf("\n");
       if(buffer_limit(pkt) < QHEADERSZ) {
               printf("packet too short\n");
               return;
       }
       printf("; id=%4.4x ; flags%s%s%s%s%s%s%s%s ; rcode %s ; opcode %d\n",
               ID(pkt), QR(pkt)?" QR":"", AA(pkt)?" AA":"", TC(pkt)?" TC":"",
               RD(pkt)?" RD":"", RA(pkt)?" RA":"", Z(pkt)?" Z":"",
               AD(pkt)?" AD":"", CD(pkt)?" CD":"", rcode2str(RCODE(pkt)),
               OPCODE(pkt));
       printf("; qdcount %d ; ancount %d ; nscount %d ; arcount %d\n",
               QDCOUNT(pkt), ANCOUNT(pkt), NSCOUNT(pkt), ARCOUNT(pkt));
       buffer_skip(pkt, QHEADERSZ);

       if(QDCOUNT(pkt) != 0) {
               printf("; QUESTION SECTION\n");
               print_records(region, pkt, QDCOUNT(pkt), 1);
       }
       if(ANCOUNT(pkt) != 0) {
               printf("; ANSWER SECTION\n");
               print_records(region, pkt, ANCOUNT(pkt), 0);
       }
       if(NSCOUNT(pkt) != 0) {
               printf("; AUTHORITY SECTION\n");
               print_records(region, pkt, NSCOUNT(pkt), 0);
       }
       if(ARCOUNT(pkt) != 0) {
               printf("; ADDITIONAL SECTION\n");
               print_records(region, pkt, ARCOUNT(pkt), 0);
       }
}

/** inspect part of xfr file */
static void
inspect_part(FILE* in, int partnum)
{
       uint32_t pkttype, msglen, msglen2;
       region_type* region;
       buffer_type* packet;
       region = region_create(xalloc, free);
       if(!region) {
               printf("out of memory\n");
               fclose(in);
               exit(1);
       }
       packet = buffer_create(region, QIOBUFSZ);
       if(!xi_diff_read_32(in, &pkttype)) {
               printf("cannot read part %d\n", partnum);
               fclose(in);
               exit(1);
       }
       if(pkttype != DIFF_PART_XXFR) {
               printf("bad part %d: not type XXFR\n", partnum);
               fclose(in);
               exit(1);
       }
       if(!xi_diff_read_32(in, &msglen)) {
               printf("bad part %d: not msglen, file too short\n", partnum);
               fclose(in);
               exit(1);
       }
       if(msglen < QHEADERSZ || msglen > QIOBUFSZ) {
               printf("bad part %d: msglen %u (too short or too long)\n",
                       partnum, (unsigned)msglen);
               fclose(in);
               exit(1);
       }
       if(fread(buffer_begin(packet), msglen, 1, in) != 1) {
               printf("bad part %d: short packet, file too short, %s\n",
                       partnum, strerror(errno));
               fclose(in);
               exit(1);
       }
       if(!xi_diff_read_32(in, &msglen2)) {
               printf("bad part %d: cannot read msglen2, file too short\n", partnum);
               fclose(in);
               exit(1);
       }
       if(v==0) {
               region_destroy(region);
               return;
       }

       printf("\n");
       /* printf("type : %x\n", pkttype); */
       printf("part    : %d\n", partnum);
       printf("msglen  : %u\n", (unsigned)msglen);
       printf("msglen2 : %u (%s)\n", (unsigned)msglen2,
               (msglen==msglen2)?"ok":"wrong");

       if(v>=2) {
               buffer_set_limit(packet, msglen);
               inspect_packet(region, packet);
       }

       region_destroy(region);
}

/** inspect parts of xfr file */
static void
inspect_parts(FILE* in, int num)
{
       int i;
       for(i=0; i<num; i++) {
               inspect_part(in, i);
       }
}

/** inspect trail of xfr file */
static void
inspect_trail(FILE* in)
{
       char log_buf[5120];
       if(!xi_diff_read_str(in, log_buf, sizeof(log_buf))) {
               printf("bad trail: cannot read log string\n");
               fclose(in);
               exit(1);
       }
       printf("\n");
       printf("log:    %s\n", log_buf);
}

/** inspect contents of xfr file */
static void
inspect_file(char* fname)
{
       FILE* in;
       int num;
       log_init("udb-inspect");
       if(!(in=fopen(fname, "r"))) {
               printf("cannot open %s: %s\n", fname, strerror(errno));
               exit(1);
       }
       printf("file:   %s\n", fname);
       num = inspect_header(in);
       inspect_parts(in, num);
       inspect_trail(in);
       fclose(in);
}

/** list header of xfr file, return num_parts */
static int
list_header(FILE* in)
{
       char zone_buf[3072];
       char patname_buf[2048];

       uint32_t old_serial, new_serial, num_parts, type;
       uint64_t time_end_0, time_start_0;
       uint32_t time_end_1, time_start_1;
       uint8_t committed;

       time_t time_end, time_start;

       if(!xi_diff_read_32(in, &type)) {
               printf("could not read type, file short\n");
               fclose(in);
               exit(1);
       }
       if(type != DIFF_PART_XFRF) {
               printf("type:   %x (BAD FILE TYPE)\n", type);
               fclose(in);
               exit(1);
       }
       if(!xi_diff_read_8(in, &committed) ||
               !xi_diff_read_32(in, &num_parts) ||
               !xi_diff_read_64(in, &time_end_0) ||
               !xi_diff_read_32(in, &time_end_1) ||
               !xi_diff_read_32(in, &old_serial) ||
               !xi_diff_read_32(in, &new_serial) ||
               !xi_diff_read_64(in, &time_start_0) ||
               !xi_diff_read_32(in, &time_start_1) ||
               !xi_diff_read_str(in, zone_buf, sizeof(zone_buf)) ||
               !xi_diff_read_str(in, patname_buf, sizeof(patname_buf))) {
               printf("diff file bad commit part, file too short");
               fclose(in);
               exit(1);
       }
       time_end = (time_t)time_end_0;
       time_start = (time_t)time_start_0;

       /* printf("; type:              %x\n", (int)type); */
       printf("; committed:    %d (%s)\n", (int)committed,
               committed?"yes":"no");
       printf("; num_parts:    %d\n", (int)num_parts);
       printf("; time_end:     %d.%6.6d %s", (int)time_end_0,
               (int)time_end_1, ctime(&time_end));
       printf("; old_serial:   %u\n", (unsigned)old_serial);
       printf("; new_serial:   %u\n", (unsigned)new_serial);
       printf("; time_start:   %d.%6.6d %s", (int)time_start_0,
               (int)time_start_1, ctime(&time_start));
       printf("; zone:         %s\n", zone_buf);
       printf("; patname:      %s\n", patname_buf);

       return num_parts;
}

/** list packet (IXFR or AXFR) */
static void
list_packet(region_type* region, buffer_type* pkt, int partnum)
{
       if(buffer_limit(pkt) < QHEADERSZ) {
               printf("packet too short\n");
               return;
       }
       buffer_skip(pkt, QHEADERSZ);

       if(partnum == 0 && QDCOUNT(pkt) == 1) {
               /* print query AXFR or IXFR */
               printf("; ");
               print_records(region, pkt, QDCOUNT(pkt), 1);
       }
       if(ANCOUNT(pkt) != 0) {
               print_records(region, pkt, ANCOUNT(pkt), 0);
       }
}

/** list part of xfr file */
static void
list_part(FILE* in, int partnum)
{
       uint32_t pkttype, msglen, msglen2;
       region_type* region;
       buffer_type* packet;
       region = region_create(xalloc, free);
       if(!region) {
               printf("out of memory\n");
               fclose(in);
               exit(1);
       }
       packet = buffer_create(region, QIOBUFSZ);
       if(!xi_diff_read_32(in, &pkttype)) {
               printf("cannot read part %d\n", partnum);
               fclose(in);
               exit(1);
       }
       if(pkttype != DIFF_PART_XXFR) {
               printf("bad part %d: not type XXFR\n", partnum);
               fclose(in);
               exit(1);
       }
       if(!xi_diff_read_32(in, &msglen)) {
               printf("bad part %d: not msglen, file too short\n", partnum);
               fclose(in);
               exit(1);
       }
       if(msglen < QHEADERSZ || msglen > QIOBUFSZ) {
               printf("bad part %d: msglen %u (too short or too long)\n",
                       partnum, (unsigned)msglen);
               fclose(in);
               exit(1);
       }
       if(fread(buffer_begin(packet), msglen, 1, in) != 1) {
               printf("bad part %d: short packet, file too short, %s\n",
                       partnum, strerror(errno));
               fclose(in);
               exit(1);
       }
       if(!xi_diff_read_32(in, &msglen2)) {
               printf("bad part %d: cannot read msglen2, file too short\n", partnum);
               fclose(in);
               exit(1);
       }

       buffer_set_limit(packet, msglen);
       list_packet(region, packet, partnum);
       region_destroy(region);
}

/** list parts of xfr file */
static void
list_parts(FILE* in, int num)
{
       int i;
       for(i=0; i<num; i++) {
               list_part(in, i);
       }
}

/** list contents of xfr file */
static void
list_file(char* fname)
{
       FILE* in;
       int num;
       log_init("udb-inspect");
       if(!(in=fopen(fname, "r"))) {
               printf("cannot open %s: %s\n", fname, strerror(errno));
               exit(1);
       }
       num = list_header(in);
       list_parts(in, num);

       fclose(in);
}

/** getopt global, in case header files fail to declare it. */
extern int optind;
/** getopt global, in case header files fail to declare it. */
extern char* optarg;

/**
* main program. Set options given commandline arguments.
* @param argc: number of commandline arguments.
* @param argv: array of commandline arguments.
* @return: exit status of the program.
*/
int
main(int argc, char* argv[])
{
       int c, list=0;
       while( (c=getopt(argc, argv, "hlv")) != -1) {
               switch(c) {
               case 'l':
                       list=1;
                       break;
               case 'v':
                       v++;
                       break;
               default:
               case 'h':
                       usage();
                       return 1;
               }
       }
       argc -= optind;
       argv += optind;
       if(argc != 1) {
               usage();
               return 1;
       }
       if(list) list_file(argv[0]);
       else    inspect_file(argv[0]);

       return 0;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.