source: trunk/third/sendmail/contrib/bitdomain.c @ 19204

/*
 * By John G. Myers, jgm+@cmu.edu
 * Version 1.2
 *
 * Process a BITNET "internet.listing" file, producing output
 * suitable for input to makemap.
 *
 * The input file can be obtained via anonymous FTP to bitnic.educom.edu.
 * Change directory to "netinfo" and get the file internet.listing
 * The file is updated monthly.
 *
 * Feed the output of this program to "makemap hash /etc/mail/bitdomain.db"
 * to create the table used by the "FEATURE(bitdomain)" config file macro.
 * If your sendmail does not have the db library compiled in, you can instead
 * use "makemap dbm /etc/mail/bitdomain" and
 * "FEATURE(bitdomain,`dbm -o /etc/mail/bitdomain')"
 *
 * The bitdomain table should be rebuilt monthly.
 */

#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/nameser.h>
#include <resolv.h>
#include <netdb.h>
#include <ctype.h>
#include <string.h>

/* don't use sizeof because sizeof(long) is different on 64-bit machines */
#define SHORTSIZE       2       /* size of a short (really, must be 2) */
#define LONGSIZE        4       /* size of a long (really, must be 4) */

typedef union
{
        HEADER  qb1;
        char    qb2[PACKETSZ];
} querybuf;

extern int h_errno;
extern char *malloc();
extern char *optarg;
extern int optind;

char *lookup();

main(argc, argv)
int argc;
char **argv;
{
    int opt;

    while ((opt = getopt(argc, argv, "o:")) != -1) {
        switch (opt) {
        case 'o':
            if (!freopen(optarg, "w", stdout)) {
                perror(optarg);
                exit(1);
            }
            break;

        default:
            fprintf(stderr, "usage: %s [-o outfile] [internet.listing]\n",
                    argv[0]);
            exit(1);
        }
    }

    if (optind < argc) {
        if (!freopen(argv[optind], "r", stdin)) {
            perror(argv[optind]);
            exit(1);
        }
    }
    readfile(stdin);
    finish();
    exit(0);
}

/*
 * Parse and process an input file
 */
readfile(infile)
FILE *infile;
{
    int skippingheader = 1;
    char buf[1024], *node, *hostname, *p;

    while (fgets(buf, sizeof(buf), infile)) {
        for (p = buf; *p && isspace(*p); p++);
        if (!*p) {
            skippingheader = 0;
            continue;
        }
        if (skippingheader) continue;

        node = p;
        for (; *p && !isspace(*p); p++) {
            if (isupper(*p)) *p = tolower(*p);
        }
        if (!*p) {
            fprintf(stderr, "%-8s: no domain name in input file\n", node);
            continue;
        }
        *p++ = '\0';

        for (; *p && isspace(*p); p++) ;
        if (!*p) {
            fprintf(stderr, "%-8s no domain name in input file\n", node);
            continue;
        }

        hostname = p;
        for (; *p && !isspace(*p); p++) {
            if (isupper(*p)) *p = tolower(*p);
        }
        *p = '\0';

        /* Chop off any trailing .bitnet */
        if (strlen(hostname) > 7 &&
            !strcmp(hostname+strlen(hostname)-7, ".bitnet")) {
            hostname[strlen(hostname)-7] = '\0';
        }
        entry(node, hostname, sizeof(buf)-(hostname - buf));
    }
}

/*
 * Process a single entry in the input file.
 * The entry tells us that "node" expands to "domain".
 * "domain" can either be a domain name or a bitnet node name
 * The buffer pointed to by "domain" may be overwritten--it
 * is of size "domainlen".
 */
entry(node, domain, domainlen)
char *node;
char *domain;
char *domainlen;
{
    char *otherdomain, *p, *err;

    /* See if we have any remembered information about this node */
    otherdomain = lookup(node);

    if (otherdomain && strchr(otherdomain, '.')) {
        /* We already have a domain for this node */
        if (!strchr(domain, '.')) {
            /*
             * This entry is an Eric Thomas FOO.BITNET kludge.
             * He doesn't want LISTSERV to do transitive closures, so we
             * do them instead.  Give the the domain expansion for "node"
             * (which is in "otherdomian") to FOO (which is in "domain")
             * if "domain" doesn't have a domain expansion already.
             */
            p = lookup(domain);
            if (!p || !strchr(p, '.')) remember(domain, otherdomain);
        }
    }
    else {
        if (!strchr(domain, '.') || valhost(domain, domainlen)) {
            remember(node, domain);
            if (otherdomain) {
                /*
                 * We previously mapped the node "node" to the node
                 * "otherdomain".  If "otherdomain" doesn't already
                 * have a domain expansion, give it the expansion "domain".
                 */
                p = lookup(otherdomain);
                if (!p || !strchr(p, '.')) remember(otherdomain, domain);
            }
        }
        else {
            switch (h_errno) {
            case HOST_NOT_FOUND:
                err = "not registered in DNS";
                break;

            case TRY_AGAIN:
                err = "temporary DNS lookup failure";
                break;

            case NO_RECOVERY:
                err = "non-recoverable nameserver error";
                break;

            case NO_DATA:
                err = "registered in DNS, but not mailable";
                break;

            default:
                err = "unknown nameserver error";
                break;
            }

            fprintf(stderr, "%-8s %s %s\n", node, domain, err);
        }
    }
}

/*
 * Validate whether the mail domain "host" is registered in the DNS.
 * If "host" is a CNAME, it is expanded in-place if the expansion fits
 * into the buffer of size "hbsize".  Returns nonzero if it is, zero
 * if it is not.  A BIND error code is left in h_errno.
 */
int
valhost(host, hbsize)
        char *host;
        int hbsize;
{
        register u_char *eom, *ap;
        register int n;
        HEADER *hp;
        querybuf answer;
        int ancount, qdcount;
        int ret;
        int type;
        int qtype;
        char nbuf[1024];

        if ((_res.options & RES_INIT) == 0 && res_init() == -1)
                return (0);

        _res.options &= ~(RES_DNSRCH|RES_DEFNAMES);
        _res.retrans = 30;
        _res.retry = 10;

        qtype = T_ANY;

        for (;;) {
                h_errno = NO_DATA;
                ret = res_querydomain(host, "", C_IN, qtype,
                                      &answer, sizeof(answer));
                if (ret <= 0)
                {
                        if (errno == ECONNREFUSED || h_errno == TRY_AGAIN)
                        {
                                /* the name server seems to be down */
                                h_errno = TRY_AGAIN;
                                return 0;
                        }

                        if (h_errno != HOST_NOT_FOUND)
                        {
                                /* might have another type of interest */
                                if (qtype == T_ANY)
                                {
                                        qtype = T_A;
                                        continue;
                                }
                                else if (qtype == T_A)
                                {
                                        qtype = T_MX;
                                        continue;
                                }
                        }

                        /* otherwise, no record */
                        return 0;
                }

                /*
                **  This might be a bogus match.  Search for A, MX, or
                **  CNAME records.
                */

                hp = (HEADER *) &answer;
                ap = (u_char *) &answer + sizeof(HEADER);
                eom = (u_char *) &answer + ret;

                /* skip question part of response -- we know what we asked */
                for (qdcount = ntohs(hp->qdcount); qdcount--; ap += ret + QFIXEDSZ)
                {
                        if ((ret = dn_skipname(ap, eom)) < 0)
                        {
                                return 0;               /* ???XXX??? */
                        }
                }

                for (ancount = ntohs(hp->ancount); --ancount >= 0 && ap < eom; ap += n)
                {
                        n = dn_expand((u_char *) &answer, eom, ap,
                                      (u_char *) nbuf, sizeof nbuf);
                        if (n < 0)
                                break;
                        ap += n;
                        GETSHORT(type, ap);
                        ap += SHORTSIZE + LONGSIZE;
                        GETSHORT(n, ap);
                        switch (type)
                        {
                          case T_MX:
                          case T_A:
                                return 1;

                          case T_CNAME:
                                /* value points at name */
                                if ((ret = dn_expand((u_char *)&answer,
                                    eom, ap, (u_char *)nbuf, sizeof(nbuf))) < 0)
                                        break;
                                if (strlen(nbuf) < hbsize) {
                                    (void)strcpy(host, nbuf);
                                }
                                return 1;

                          default:
                                /* not a record of interest */
                                continue;
                        }
                }

                /*
                **  If this was a T_ANY query, we may have the info but
                **  need an explicit query.  Try T_A, then T_MX.
                */

                if (qtype == T_ANY)
                        qtype = T_A;
                else if (qtype == T_A)
                        qtype = T_MX;
                else
                        return 0;
        }
}

struct entry {
    struct entry *next;
    char *node;
    char *domain;
};
struct entry *firstentry;

/*
 * Find any remembered information about "node"
 */
char *lookup(node)
char *node;
{
    struct entry *p;

    for (p = firstentry; p; p = p->next) {
        if (!strcmp(node, p->node)) {
            return p->domain;
        }
    }
    return 0;
}

/*
 * Mark the node "node" as equivalent to "domain".  "domain" can either
 * be a bitnet node or a domain name--if it is the latter, the mapping
 * will be written to stdout.
 */
remember(node, domain)
char *node;
char *domain;
{
    struct entry *p;

    if (strchr(domain, '.')) {
        fprintf(stdout, "%-8s %s\n", node, domain);
    }

    for (p = firstentry; p; p = p->next) {
        if (!strcmp(node, p->node)) {
            p->domain = malloc(strlen(domain)+1);
            if (!p->domain) {
                goto outofmemory;
            }
            strcpy(p->domain, domain);
            return;
        }
    }

    p = (struct entry *)malloc(sizeof(struct entry));
    if (!p) goto outofmemory;

    p->next = firstentry;
    firstentry = p;
    p->node = malloc(strlen(node)+1);
    p->domain = malloc(strlen(domain)+1);
    if (!p->node || !p->domain) goto outofmemory;
    strcpy(p->node, node);
    strcpy(p->domain, domain);
    return;

  outofmemory:
    fprintf(stderr, "Out of memory\n");
    exit(1);
}

/*
 * Walk through the database, looking for any cases where we know
 * node FOO is equivalent to node BAR and node BAR has a domain name.
 * For those cases, give FOO the same domain name as BAR.
 */
finish()
{
    struct entry *p;
    char *domain;

    for (p = firstentry; p; p = p->next) {
        if (!strchr(p->domain, '.') && (domain = lookup(p->domain))) {
            remember(p->node, domain);
        }
    }
}