Return to input.c CVS log

Up to [CSRG BSD Unix] / 43BSD / etc / XNSrouted

Annotation of 43BSD/etc/XNSrouted/input.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1985 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  *
        !             6:  * Includes material written at Cornell University by Bill Nesheim,
        !             7:  * by permission of the author.
        !             8:  */
        !             9: 
        !            10: 
        !            11: #ifndef lint
        !            12: static char sccsid[] = "@(#)input.c    5.6 (Berkeley) 2/14/86";
        !            13: #endif not lint
        !            14: 
        !            15: /*
        !            16:  * XNS Routing Table Management Daemon
        !            17:  */
        !            18: #include "defs.h"
        !            19: 
        !            20: struct sockaddr *
        !            21: xns_nettosa(net)
        !            22: union ns_net net;
        !            23: {
        !            24:        static struct sockaddr_ns sxn;
        !            25:        extern char ether_broadcast_addr[6];
        !            26:        
        !            27:        bzero(&sxn, sizeof (struct sockaddr_ns));
        !            28:        sxn.sns_family = AF_NS;
        !            29:        sxn.sns_addr.x_net = net;
        !            30:        sxn.sns_addr.x_host = *(union ns_host *)ether_broadcast_addr;
        !            31:        return( (struct sockaddr *)&sxn);
        !            32:        
        !            33: }
        !            34: 
        !            35: /*
        !            36:  * Process a newly received packet.
        !            37:  */
        !            38: rip_input(from, size)
        !            39:        struct sockaddr *from;
        !            40:        int size;
        !            41: {
        !            42:        struct rt_entry *rt;
        !            43:        struct netinfo *n;
        !            44:        struct interface *ifp;
        !            45:        int newsize;
        !            46:        struct afswitch *afp;
        !            47: 
        !            48:        
        !            49:        ifp = 0;
        !            50:        TRACE_INPUT(ifp, from, size);
        !            51:        if (from->sa_family >= AF_MAX)
        !            52:                return;
        !            53:        afp = &afswitch[from->sa_family];
        !            54:        
        !            55:        size -= sizeof (u_short)        /* command */;
        !            56:        n = msg->rip_nets;
        !            57: 
        !            58:        switch (ntohs(msg->rip_cmd)) {
        !            59: 
        !            60:        case RIPCMD_REQUEST:
        !            61:                newsize = 0;
        !            62:                while (size > 0) {
        !            63:                        if (size < sizeof (struct netinfo))
        !            64:                                break;
        !            65:                        size -= sizeof (struct netinfo);
        !            66: 
        !            67:                        /* 
        !            68:                         * A single entry with rip_dst == DSTNETS_ALL and
        !            69:                         * metric ``infinity'' means ``all routes''.
        !            70:                         */
        !            71:                        if (ns_neteqnn(n->rip_dst, ns_anynet) &&
        !            72:                            ntohs(n->rip_metric) == HOPCNT_INFINITY &&
        !            73:                            size == 0) {
        !            74:                                ifp = if_ifwithnet(from);
        !            75:                                supply(from, 0, ifp);
        !            76:                                return;
        !            77:                        }
        !            78:                        /*
        !            79:                         * request for specific nets
        !            80:                         */
        !            81:                        rt = rtlookup(xns_nettosa(n->rip_dst));
        !            82:                        if (ftrace) {
        !            83:                                fprintf(ftrace,
        !            84:                                        "specific request for %s",
        !            85:                                        xns_nettoa(n->rip_dst));
        !            86:                                fprintf(ftrace,
        !            87:                                        " yields route %x\n",
        !            88:                                        rt);
        !            89:                        }
        !            90:                        n->rip_metric = htons( rt == 0 ? HOPCNT_INFINITY :
        !            91:                                min(rt->rt_metric+1, HOPCNT_INFINITY));
        !            92:                        n++;
        !            93:                        newsize += sizeof (struct netinfo);
        !            94:                }
        !            95:                if (newsize > 0) {
        !            96:                        msg->rip_cmd = htons(RIPCMD_RESPONSE);
        !            97:                        newsize += sizeof (u_short);
        !            98:                        /* should check for if with dstaddr(from) first */
        !            99:                        (*afp->af_output)(0, from, newsize);
        !           100:                        ifp = if_ifwithnet(from);
        !           101:                        TRACE_OUTPUT(ifp, from, newsize);
        !           102:                        if (ftrace) {
        !           103:                                fprintf(ftrace,
        !           104:                                        "request arrived on interface %s\n",
        !           105:                                        ifp->int_name);
        !           106:                        }
        !           107:                }
        !           108:                return;
        !           109: 
        !           110:        case RIPCMD_RESPONSE:
        !           111:                /* verify message came from a router */
        !           112:                if ((*afp->af_portmatch)(from) == 0)
        !           113:                        return;
        !           114:                (*afp->af_canon)(from);
        !           115:                /* are we talking to ourselves? */
        !           116:                if (ifp = if_ifwithaddr(from)) {
        !           117:                        rt = rtfind(from);
        !           118:                        if (rt == 0 || (rt->rt_state & RTS_INTERFACE) == 0)
        !           119:                                addrouteforif(ifp);
        !           120:                        else
        !           121:                                rt->rt_timer = 0;
        !           122:                        return;
        !           123:                }
        !           124:                /* Update timer for interface on which the packet arrived.
        !           125:                 * If from other end of a point-to-point link that isn't
        !           126:                 * in the routing tables, (re-)add the route.
        !           127:                 */
        !           128:                if ((rt = rtfind(from)) && (rt->rt_state & RTS_INTERFACE)) {
        !           129:                        if(ftrace) fprintf(ftrace, "Got route\n");
        !           130:                        rt->rt_timer = 0;
        !           131:                } else if (ifp = if_ifwithdstaddr(from)) {
        !           132:                        if(ftrace) fprintf(ftrace, "Got partner\n");
        !           133:                        addrouteforif(ifp);
        !           134:                }
        !           135:                for (; size > 0; size -= sizeof (struct netinfo), n++) {
        !           136:                        struct sockaddr *sa;
        !           137:                        if (size < sizeof (struct netinfo))
        !           138:                                break;
        !           139:                        if ((unsigned) ntohs(n->rip_metric) >= HOPCNT_INFINITY)
        !           140:                                continue;
        !           141:                        rt = rtfind(sa = xns_nettosa(n->rip_dst));
        !           142:                        if (rt == 0) {
        !           143:                                rtadd(sa, from, ntohs(n->rip_metric), 0);
        !           144:                                continue;
        !           145:                        }
        !           146: 
        !           147:                        /*
        !           148:                         * Update if from gateway and different,
        !           149:                         * from anywhere and shorter, or getting stale and equivalent.
        !           150:                         */
        !           151:                        if ((equal(from, &rt->rt_router) &&
        !           152:                            ntohs(n->rip_metric) != rt->rt_metric ) ||
        !           153:                            (unsigned) ntohs(n->rip_metric) < rt->rt_metric ||
        !           154:                            (rt->rt_timer > (EXPIRE_TIME/2) &&
        !           155:                            rt->rt_metric == ntohs(n->rip_metric))) {
        !           156:                                rtchange(rt, from, ntohs(n->rip_metric));
        !           157:                                rt->rt_timer = 0;
        !           158:                        }
        !           159:                }
        !           160:                return;
        !           161:        }
        !           162: }

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