Return to query.c CVS log

Up to [CSRG BSD Unix] / 42BSD / etc / routed / tools

Annotation of 42BSD/etc/routed/tools/query.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char sccsid[] = "@(#)query.c    4.5 10/7/82";
        !             3: #endif
        !             4: 
        !             5: #include <sys/param.h>
        !             6: #include <sys/protosw.h>
        !             7: #include <sys/socket.h>
        !             8: #include <net/in.h>
        !             9: #include <errno.h>
        !            10: #include <stdio.h>
        !            11: #include <netdb.h>
        !            12: #include "rip.h"
        !            13: 
        !            14: int    s;
        !            15: char   packet[MAXPACKETSIZE];
        !            16: 
        !            17: main(argc, argv)
        !            18:        int argc;
        !            19:        char *argv[];
        !            20: {
        !            21:        int cc, count;
        !            22:        struct sockaddr from;
        !            23:        
        !            24:        if (argc < 2) {
        !            25:                printf("usage: query hosts...\n");
        !            26:                exit(1);
        !            27:        }
        !            28:        s = socket(SOCK_DGRAM, 0, 0, 0);
        !            29:        if (s < 0) {
        !            30:                perror("socket");
        !            31:                exit(2);
        !            32:        }
        !            33:        argv++, argc--;
        !            34:        count = argc;
        !            35:        while (argc > 0) {
        !            36:                query(*argv);
        !            37:                argv++, argc--;
        !            38:        }
        !            39: 
        !            40:        /*
        !            41:         * Listen for returning packets
        !            42:         */
        !            43:        while (count > 0) {
        !            44:                cc = receive(s, &from, packet, sizeof (packet));
        !            45:                if (cc <= 0) {
        !            46:                        if (cc < 0) {
        !            47:                                perror("receive");
        !            48:                                (void) close(s);
        !            49:                                exit(1);
        !            50:                        }
        !            51:                        continue;
        !            52:                }
        !            53:                rip_input(&from, cc);
        !            54:                count--;
        !            55:        }
        !            56: }
        !            57: 
        !            58: query(host)
        !            59:        char *host;
        !            60: {
        !            61:        struct sockaddr_in router;
        !            62:        register struct rip *msg = (struct rip *)packet;
        !            63:        struct hostent *hp;
        !            64:        struct servent *sp;
        !            65: 
        !            66:        bzero((char *)&router, sizeof (router));
        !            67:        hp = gethostbyname(host);
        !            68:        if (hp == 0) {
        !            69:                printf("%s: unknown\n", host);
        !            70:                exit(1);
        !            71:        }
        !            72:        bcopy(hp->h_addr, &router.sin_addr, hp->h_length);
        !            73:        router.sin_family = AF_INET;
        !            74:        sp = getservbyname("router", "udp");
        !            75:        if (sp == 0) {
        !            76:                printf("udp/router: service unknown\n");
        !            77:                exit(1);
        !            78:        }
        !            79:        router.sin_port = htons(sp->s_port);
        !            80:        msg->rip_cmd = RIPCMD_REQUEST;
        !            81:        msg->rip_nets[0].rip_dst.sa_family = AF_UNSPEC;
        !            82:        msg->rip_nets[0].rip_metric = HOPCNT_INFINITY;
        !            83:        if (send(s, &router, packet, sizeof (struct rip)) < 0)
        !            84:                perror(host);
        !            85: }
        !            86: 
        !            87: /*
        !            88:  * Handle an incoming routing packet.
        !            89:  */
        !            90: rip_input(from, size)
        !            91:        struct sockaddr_in *from;
        !            92:        int size;
        !            93: {
        !            94:        register struct rip *msg = (struct rip *)packet;
        !            95:        struct netinfo *n;
        !            96:        char *name;
        !            97:        struct hostent *hp;
        !            98:        struct netent *np;
        !            99: 
        !           100:        if (msg->rip_cmd != RIPCMD_RESPONSE)
        !           101:                return;
        !           102:        hp = gethostbyaddr(&from->sin_addr, sizeof (struct in_addr), AF_INET);
        !           103:        name = hp == 0 ? "???" : hp->h_name;
        !           104:        printf("from %s(%x):\n", name, from->sin_addr);
        !           105:        size -= sizeof (int);
        !           106:        n = msg->rip_nets;
        !           107:        while (size > 0) {
        !           108:                register struct sockaddr_in *sin;
        !           109: 
        !           110:                if (size < sizeof (struct netinfo))
        !           111:                        break;
        !           112:                sin = (struct sockaddr_in *)&n->rip_dst;
        !           113:                if (inet_lnaof(sin->sin_addr) == INADDR_ANY) {
        !           114:                        np = getnetbyaddr(inet_netof(sin->sin_addr), AF_INET);
        !           115:                        name = np ? np->n_name : "???";
        !           116:                } else {
        !           117:                        hp = gethostbyaddr(&sin->sin_addr,
        !           118:                                sizeof (struct in_addr), AF_INET);
        !           119:                        name = hp ? hp->h_name : "???";
        !           120:                }
        !           121:                printf("\t%s(%x), metric %d\n", name,
        !           122:                        sin->sin_addr, n->rip_metric);
        !           123:                size -= sizeof (struct netinfo), n++;
        !           124:        }
        !           125: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.