Return to route.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / net

Annotation of cci/sys/net/route.c, revision 1.1

1.1     ! root        1: /*     route.c 6.1     83/07/29        */
        !             2: 
        !             3: #include "../h/param.h"
        !             4: #include "../h/systm.h"
        !             5: #include "../h/mbuf.h"
        !             6: #include "../h/protosw.h"
        !             7: #include "../h/socket.h"
        !             8: #include "../h/dir.h"
        !             9: #include "../h/user.h"
        !            10: #include "../h/ioctl.h"
        !            11: #include "../h/errno.h"
        !            12: 
        !            13: #include "../net/if.h"
        !            14: #include "../net/af.h"
        !            15: #include "../net/route.h"
        !            16: 
        !            17: int    rttrash;                /* routes not in table but not freed */
        !            18: struct sockaddr wildcard;      /* zero valued cookie for wildcard searches */
        !            19: 
        !            20: /*
        !            21:  * Packet routing routines.
        !            22:  */
        !            23: rtalloc(ro)
        !            24:        register struct route *ro;
        !            25: {
        !            26:        register struct rtentry *rt;
        !            27:        register struct mbuf *m;
        !            28:        register unsigned hash;
        !            29:        struct sockaddr *dst = &ro->ro_dst;
        !            30:        int (*match)(), doinghost;
        !            31:        struct afhash h;
        !            32:        u_int af = dst->sa_family;
        !            33:        struct rtentry *rtmin;
        !            34:        struct mbuf **table;
        !            35: 
        !            36:        if (ro->ro_rt && ro->ro_rt->rt_ifp)                     /* XXX */
        !            37:                return;
        !            38:        if (af >= AF_MAX)
        !            39:                return;
        !            40:        (*afswitch[af].af_hash)(dst, &h);
        !            41:        rtmin = 0;
        !            42:        match = afswitch[af].af_netmatch;
        !            43:        hash = h.afh_hosthash, table = rthost, doinghost = 1;
        !            44: again:
        !            45:        for (m = table[hash % RTHASHSIZ]; m; m = m->m_next) {
        !            46:                rt = mtod(m, struct rtentry *);
        !            47:                if (rt->rt_hash != hash)
        !            48:                        continue;
        !            49:                if ((rt->rt_flags & RTF_UP) == 0 ||
        !            50:                    (rt->rt_ifp->if_flags & IFF_UP) == 0)
        !            51:                        continue;
        !            52:                if (doinghost) {
        !            53:                        if (bcmp((caddr_t)&rt->rt_dst, (caddr_t)dst,
        !            54:                            sizeof (*dst)))
        !            55:                                continue;
        !            56:                } else {
        !            57:                        if (rt->rt_dst.sa_family != af ||
        !            58:                            !(*match)(&rt->rt_dst, dst))
        !            59:                                continue;
        !            60:                }
        !            61:                if (rtmin == 0 || rt->rt_use < rtmin->rt_use)
        !            62:                        rtmin = rt;
        !            63:        }
        !            64:        if (rtmin == 0 && doinghost) {
        !            65:                doinghost = 0;
        !            66:                hash = h.afh_nethash, table = rtnet;
        !            67:                goto again;
        !            68:        }
        !            69:        /*
        !            70:         * Check for wildcard gateway, by convention network 0.
        !            71:         */
        !            72:        if (rtmin == 0 && dst != &wildcard) {
        !            73:                dst = &wildcard, hash = 0;
        !            74:                goto again;
        !            75:        }
        !            76:        ro->ro_rt = rtmin;
        !            77:        if (rtmin == 0) {
        !            78:                rtstat.rts_unreach++;
        !            79:                return;
        !            80:        }
        !            81:        rtmin->rt_refcnt++;
        !            82:        if (dst == &wildcard)
        !            83:                rtstat.rts_wildcard++;
        !            84: }
        !            85: 
        !            86: rtfree(rt)
        !            87:        register struct rtentry *rt;
        !            88: {
        !            89: 
        !            90:        if (rt == 0)
        !            91:                panic("rtfree");
        !            92:        rt->rt_refcnt--;
        !            93:        if (rt->rt_refcnt == 0 && (rt->rt_flags&RTF_UP) == 0) {
        !            94:                rttrash--;
        !            95:                (void) m_free(dtom(rt));
        !            96:        }
        !            97: }
        !            98: 
        !            99: /*
        !           100:  * Force a routing table entry to the specified
        !           101:  * destination to go through the given gateway.
        !           102:  * Normally called as a result of a routing redirect
        !           103:  * message from the network layer.
        !           104:  *
        !           105:  * N.B.: must be called at splnet or higher
        !           106:  *
        !           107:  * Should notify all parties with a reference to
        !           108:  * the route that it's changed (so, for instance,
        !           109:  * current round trip time estimates could be flushed),
        !           110:  * but we have no back pointers at the moment.
        !           111:  */
        !           112: rtredirect(dst, gateway, flags)
        !           113:        struct sockaddr *dst, *gateway;
        !           114:        int     flags;
        !           115: {
        !           116:        struct route ro;
        !           117:        register struct rtentry *rt;
        !           118: 
        !           119:        /* verify the gateway is directly reachable */
        !           120:        if (if_ifwithnet(gateway) == 0) {
        !           121:                rtstat.rts_badredirect++;
        !           122:                return;
        !           123:        }
        !           124:        ro.ro_dst = *dst;
        !           125:        ro.ro_rt = 0;
        !           126:        rtalloc(&ro);
        !           127:        rt = ro.ro_rt;
        !           128:        /*
        !           129:         * Create a new entry if we just got back a wildcard entry
        !           130:         * or the the lookup failed.  This is necessary for hosts
        !           131:         * which use routing redirects generated by smart gateways
        !           132:         * to dynamically build the routing tables.
        !           133:         */
        !           134:        if (rt &&
        !           135:            (*afswitch[dst->sa_family].af_netmatch)(&wildcard, &rt->rt_dst)) {
        !           136:                rtfree(rt);
        !           137:                rt = 0;
        !           138:        }
        !           139:        if (rt == 0) {
        !           140:                rtinit(dst, gateway, RTF_GATEWAY);
        !           141:                rtstat.rts_dynamic++;
        !           142:                return;
        !           143:        }
        !           144:        /*
        !           145:         * Don't listen to the redirect if it's
        !           146:         * for a route to an interface. 
        !           147:         */
        !           148:        if ((rt->rt_flags & (RTF_GATEWAY|RTF_HOST)) != flags) {
        !           149:                rtfree(rt);
        !           150:                if (flags & RTF_HOST) {
        !           151:                        rtinit(dst, gateway, flags);
        !           152:                        rtstat.rts_newgateway++;
        !           153:                }
        !           154:                return;
        !           155:        }
        !           156:        /*
        !           157:         * Smash the current notion of the gateway to
        !           158:         * this destination.  This is probably not right,
        !           159:         * as it's conceivable a flurry of redirects could
        !           160:         * cause the gateway value to fluctuate wildly during
        !           161:         * dynamic routing reconfiguration.
        !           162:         */
        !           163:        rt->rt_gateway = *gateway;
        !           164:        rtfree(rt);
        !           165:        rtstat.rts_newgateway++;
        !           166:        return;
        !           167: }
        !           168: 
        !           169: /*
        !           170:  * Routing table ioctl interface.
        !           171:  */
        !           172: rtioctl(cmd, data)
        !           173:        int cmd;
        !           174:        caddr_t data;
        !           175: {
        !           176: 
        !           177:        if (cmd != SIOCADDRT && cmd != SIOCDELRT)
        !           178:                return (EINVAL);
        !           179:        if (!suser())
        !           180:                return (u.u_error);
        !           181:        return (rtrequest(cmd, (struct rtentry *)data));
        !           182: }
        !           183: 
        !           184: /*
        !           185:  * Carry out a request to change the routing table.  Called by
        !           186:  * interfaces at boot time to make their ``local routes'' known,
        !           187:  * for ioctl's, and as the result of routing redirects.
        !           188:  */
        !           189: rtrequest(req, entry)
        !           190:        int req;
        !           191:        register struct rtentry *entry;
        !           192: {
        !           193:        register struct mbuf *m, **mprev;
        !           194:        register struct rtentry *rt;
        !           195:        struct afhash h;
        !           196:        int s, error = 0, (*match)();
        !           197:        u_int af;
        !           198:        struct ifnet *ifp;
        !           199:        register unsigned hash;
        !           200: 
        !           201:        af = entry->rt_dst.sa_family;
        !           202:        if (af >= AF_MAX)
        !           203:                return (EAFNOSUPPORT);
        !           204:        (*afswitch[af].af_hash)(&entry->rt_dst, &h);
        !           205:        if (entry->rt_flags & RTF_HOST) {
        !           206:                hash = h.afh_hosthash;
        !           207:                mprev = &rthost[hash % RTHASHSIZ];
        !           208:        } else {
        !           209:                hash = h.afh_nethash;
        !           210:                mprev = &rtnet[hash % RTHASHSIZ];
        !           211:        }
        !           212:        match = afswitch[af].af_netmatch;
        !           213:        s = splimp();
        !           214:        for (; m = *mprev; mprev = &m->m_next) {
        !           215:                rt = mtod(m, struct rtentry *);
        !           216:                if (rt->rt_hash != hash)
        !           217:                        continue;
        !           218:                if (entry->rt_flags & RTF_HOST) {
        !           219: #define        equal(a1, a2) \
        !           220:        (bcmp((caddr_t)(a1), (caddr_t)(a2), sizeof (struct sockaddr)) == 0)
        !           221:                        if (!equal(&rt->rt_dst, &entry->rt_dst))
        !           222:                                continue;
        !           223:                } else {
        !           224:                        if (rt->rt_dst.sa_family != entry->rt_dst.sa_family ||
        !           225:                            (*match)(&rt->rt_dst, &entry->rt_dst) == 0)
        !           226:                                continue;
        !           227:                }
        !           228:                if (equal(&rt->rt_gateway, &entry->rt_gateway))
        !           229:                        break;
        !           230:        }
        !           231:        switch (req) {
        !           232: 
        !           233:        case SIOCDELRT:
        !           234:                if (m == 0) {
        !           235:                        error = ESRCH;
        !           236:                        goto bad;
        !           237:                }
        !           238:                *mprev = m->m_next;
        !           239:                if (rt->rt_refcnt > 0) {
        !           240:                        rt->rt_flags &= ~RTF_UP;
        !           241:                        rttrash++;
        !           242:                        m->m_next = 0;
        !           243:                } else
        !           244:                        (void) m_free(m);
        !           245:                break;
        !           246: 
        !           247:        case SIOCADDRT:
        !           248:                if (m) {
        !           249:                        error = EEXIST;
        !           250:                        goto bad;
        !           251:                }
        !           252:                ifp = if_ifwithaddr(&entry->rt_gateway);
        !           253:                if (ifp == 0) {
        !           254:                        ifp = if_ifwithnet(&entry->rt_gateway);
        !           255:                        if (ifp == 0) {
        !           256:                                error = ENETUNREACH;
        !           257:                                goto bad;
        !           258:                        }
        !           259:                }
        !           260:                m = m_get(M_DONTWAIT, MT_RTABLE);
        !           261:                MBUFNULL(2, m);                 /* for debugging */
        !           262:                if (m == 0) {
        !           263:                        error = ENOBUFS;
        !           264:                        goto bad;
        !           265:                }
        !           266:                *mprev = m;
        !           267:                m->m_off = MMINOFF;
        !           268:                m->m_len = sizeof (struct rtentry);
        !           269:                rt = mtod(m, struct rtentry *);
        !           270:                rt->rt_hash = hash;
        !           271:                rt->rt_dst = entry->rt_dst;
        !           272:                rt->rt_gateway = entry->rt_gateway;
        !           273:                rt->rt_flags =
        !           274:                    RTF_UP | (entry->rt_flags & (RTF_HOST|RTF_GATEWAY));
        !           275:                rt->rt_refcnt = 0;
        !           276:                rt->rt_use = 0;
        !           277:                rt->rt_ifp = ifp;
        !           278:                break;
        !           279:        }
        !           280: bad:
        !           281:        splx(s);
        !           282:        return (error);
        !           283: }
        !           284: 
        !           285: /*
        !           286:  * Set up a routing table entry, normally
        !           287:  * for an interface.
        !           288:  */
        !           289: rtinit(dst, gateway, flags)
        !           290:        struct sockaddr *dst, *gateway;
        !           291:        int flags;
        !           292: {
        !           293:        struct rtentry route;
        !           294:        int cmd;
        !           295: 
        !           296:        if (flags == -1) {
        !           297:                cmd = (int)SIOCDELRT;
        !           298:                flags = 0;
        !           299:        } else {
        !           300:                cmd = (int)SIOCADDRT;
        !           301:        }
        !           302:        bzero((caddr_t)&route, sizeof (route));
        !           303:        route.rt_dst = *dst;
        !           304:        route.rt_gateway = *gateway;
        !           305:        route.rt_flags = flags;
        !           306:        (void) rtrequest(cmd, &route);
        !           307: }

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