Return to input.c CVS log

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

Annotation of 42BSD/etc/routed/input.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char sccsid[] = "@(#)input.c    4.5 (Berkeley) 6/1/83";
                      3: #endif
                      4: 
                      5: /*
                      6:  * Routing Table Management Daemon
                      7:  */
                      8: #include "defs.h"
                      9: 
                     10: /*
                     11:  * Process a newly received packet.
                     12:  */
                     13: rip_input(from, size)
                     14:        struct sockaddr *from;
                     15:        int size;
                     16: {
                     17:        struct rt_entry *rt;
                     18:        struct netinfo *n;
                     19:        struct interface *ifp;
                     20:        int newsize;
                     21:        struct afswitch *afp;
                     22: 
                     23:        ifp = 0;
                     24:        TRACE_INPUT(ifp, from, size);
                     25:        if (from->sa_family >= AF_MAX)
                     26:                return;
                     27:        afp = &afswitch[from->sa_family];
                     28:        switch (msg->rip_cmd) {
                     29: 
                     30:        case RIPCMD_REQUEST:
                     31:                newsize = 0;
                     32:                size -= 4 * sizeof (char);
                     33:                n = msg->rip_nets;
                     34:                while (size > 0) {
                     35:                        if (size < sizeof (struct netinfo))
                     36:                                break;
                     37:                        size -= sizeof (struct netinfo);
                     38: 
                     39:                        if (msg->rip_vers > 0) {
                     40:                                n->rip_dst.sa_family =
                     41:                                        ntohs(n->rip_dst.sa_family);
                     42:                                n->rip_metric = ntohl(n->rip_metric);
                     43:                        }
                     44:                        /* 
                     45:                         * A single entry with sa_family == AF_UNSPEC and
                     46:                         * metric ``infinity'' means ``all routes''.
                     47:                         */
                     48:                        if (n->rip_dst.sa_family == AF_UNSPEC &&
                     49:                            n->rip_metric == HOPCNT_INFINITY && size == 0) {
                     50:                                supply(from, 0, ifp);
                     51:                                return;
                     52:                        }
                     53:                        rt = rtlookup(&n->rip_dst);
                     54:                        n->rip_metric = rt == 0 ? HOPCNT_INFINITY :
                     55:                                min(rt->rt_metric+1, HOPCNT_INFINITY);
                     56:                        if (msg->rip_vers > 0) {
                     57:                                n->rip_dst.sa_family =
                     58:                                        htons(n->rip_dst.sa_family);
                     59:                                n->rip_metric = htonl(n->rip_metric);
                     60:                        }
                     61:                        n++, newsize += sizeof (struct netinfo);
                     62:                }
                     63:                if (newsize > 0) {
                     64:                        msg->rip_cmd = RIPCMD_RESPONSE;
                     65:                        newsize += sizeof (int);
                     66:                        (*afp->af_output)(s, 0, from, newsize);
                     67:                }
                     68:                return;
                     69: 
                     70:        case RIPCMD_TRACEON:
                     71:        case RIPCMD_TRACEOFF:
                     72:                /* verify message came from a priviledged port */
                     73:                if ((*afp->af_portcheck)(from) == 0)
                     74:                        return;
                     75:                packet[size] = '\0';
                     76:                if (msg->rip_cmd == RIPCMD_TRACEON)
                     77:                        traceon(msg->rip_tracefile);
                     78:                else
                     79:                        traceoff();
                     80:                return;
                     81: 
                     82:        case RIPCMD_RESPONSE:
                     83:                /* verify message came from a router */
                     84:                if ((*afp->af_portmatch)(from) == 0)
                     85:                        return;
                     86:                (*afp->af_canon)(from);
                     87:                /* are we talking to ourselves? */
                     88:                ifp = if_ifwithaddr(from);
                     89:                if (ifp) {
                     90:                        rt = rtfind(from);
                     91:                        if (rt == 0)
                     92:                                addrouteforif(ifp);
                     93:                        else
                     94:                                rt->rt_timer = 0;
                     95:                        return;
                     96:                }
                     97:                size -= 4 * sizeof (char);
                     98:                n = msg->rip_nets;
                     99:                for (; size > 0; size -= sizeof (struct netinfo), n++) {
                    100:                        if (size < sizeof (struct netinfo))
                    101:                                break;
                    102:                        if (msg->rip_vers > 0) {
                    103:                                n->rip_dst.sa_family =
                    104:                                        ntohs(n->rip_dst.sa_family);
                    105:                                n->rip_metric = ntohl(n->rip_metric);
                    106:                        }
                    107:                        if (n->rip_metric >= HOPCNT_INFINITY)
                    108:                                continue;
                    109:                        rt = rtlookup(&n->rip_dst);
                    110:                        if (rt == 0) {
                    111:                                rtadd(&n->rip_dst, from, n->rip_metric, 0);
                    112:                                continue;
                    113:                        }
                    114: 
                    115:                        /*
                    116:                         * Update if from gateway, shorter, or getting
                    117:                         * stale and equivalent.
                    118:                         */
                    119:                        if (equal(from, &rt->rt_router) ||
                    120:                            n->rip_metric < rt->rt_metric ||
                    121:                            (rt->rt_timer > (EXPIRE_TIME/2) &&
                    122:                            rt->rt_metric == n->rip_metric)) {
                    123:                                rtchange(rt, from, n->rip_metric);
                    124:                                rt->rt_timer = 0;
                    125:                        }
                    126:                }
                    127:                return;
                    128:        }
                    129: }

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