![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to iso_snpac.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / netiso|
Return to iso_snpac.c CVS log | Up to [Net/2] / Net2 / netiso |
1.1 root 1: /*-
2: * Copyright (c) 1991 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. All advertising materials mentioning features or use of this software
14: * must display the following acknowledgement:
15: * This product includes software developed by the University of
16: * California, Berkeley and its contributors.
17: * 4. Neither the name of the University nor the names of its contributors
18: * may be used to endorse or promote products derived from this software
19: * without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31: * SUCH DAMAGE.
32: *
33: * @(#)iso_snpac.c 7.14 (Berkeley) 6/27/91
34: */
35:
36: /***********************************************************
37: Copyright IBM Corporation 1987
38:
39: All Rights Reserved
40:
41: Permission to use, copy, modify, and distribute this software and its
42: documentation for any purpose and without fee is hereby granted,
43: provided that the above copyright notice appear in all copies and that
44: both that copyright notice and this permission notice appear in
45: supporting documentation, and that the name of IBM not be
46: used in advertising or publicity pertaining to distribution of the
47: software without specific, written prior permission.
48:
49: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
50: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
51: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
52: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
53: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
54: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
55: SOFTWARE.
56:
57: ******************************************************************/
58:
59: /*
60: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison
61: */
62: /* $Header: iso_snpac.c,v 1.8 88/09/19 13:51:36 hagens Exp $ */
63: /* $Source: /usr/argo/sys/netiso/RCS/iso_snpac.c,v $ */
64:
65: #ifdef ISO
66:
67: #include "types.h"
68: #include "param.h"
69: #include "systm.h"
70: #include "mbuf.h"
71: #include "domain.h"
72: #include "protosw.h"
73: #include "socket.h"
74: #include "socketvar.h"
75: #include "errno.h"
76: #include "ioctl.h"
77: #include "syslog.h"
78:
79: #include "../net/if.h"
80: #include "../net/if_dl.h"
81: #include "../net/route.h"
82:
83: #include "iso.h"
84: #include "iso_var.h"
85: #include "iso_snpac.h"
86: #include "clnp.h"
87: #include "clnp_stat.h"
88: #include "esis.h"
89: #include "argo_debug.h"
90:
91: int iso_systype = SNPA_ES; /* default to be an ES */
92: extern short esis_holding_time, esis_config_time, esis_esconfig_time;
93: extern struct timeval time;
94: extern int esis_config(), hz;
95: static void snpac_fixdstandmask();
96:
97: struct sockaddr_iso blank_siso = {sizeof(blank_siso), AF_ISO};
98: extern u_long iso_hashchar();
99: static struct sockaddr_iso
100: dst = {sizeof(dst), AF_ISO},
101: gte = {sizeof(dst), AF_ISO},
102: src = {sizeof(dst), AF_ISO},
103: msk = {sizeof(dst), AF_ISO},
104: zmk = {1};
105: #define zsi blank_siso
106: #define zero_isoa zsi.siso_addr
107: #define zap_isoaddr(a, b) {Bzero(&a.siso_addr, sizeof(*r)); r = b; \
108: Bcopy(r, &a.siso_addr, 1 + (r)->isoa_len);}
109: #define S(x) ((struct sockaddr *)&(x))
110:
111: static struct sockaddr_dl blank_dl = {sizeof(blank_dl), AF_LINK};
112: static struct sockaddr_dl gte_dl;
113: #define zap_linkaddr(a, b, c, i) \
114: (*a = blank_dl, bcopy(b, a->sdl_data, a->sdl_alen = c), a->sdl_index = i)
115:
116: /*
117: * We only keep track of a single IS at a time.
118: */
119: struct rtentry *known_is;
120:
121: /*
122: * Addresses taken from NBS agreements, December 1987.
123: *
124: * These addresses assume on-the-wire transmission of least significant
125: * bit first. This is the method used by 802.3. When these
126: * addresses are passed to the token ring driver, (802.5), they
127: * must be bit-swaped because 802.5 transmission order is MSb first.
128: *
129: * Furthermore, according to IBM Austin, these addresses are not
130: * true token ring multicast addresses. More work is necessary
131: * to get multicast to work right on token ring.
132: *
133: * Currently, the token ring driver does not handle multicast, so
134: * these addresses are converted into the broadcast address in
135: * lan_output() That means that if these multicast addresses change
136: * the token ring driver must be altered.
137: */
138: char all_es_snpa[] = { 0x09, 0x00, 0x2b, 0x00, 0x00, 0x04 };
139: char all_is_snpa[] = { 0x09, 0x00, 0x2b, 0x00, 0x00, 0x05 };
140: char all_l1is_snpa[] = {0x01, 0x80, 0xc2, 0x00, 0x00, 0x14};
141: char all_l2is_snpa[] = {0x01, 0x80, 0xc2, 0x00, 0x00, 0x15};
142:
143: union sockunion {
144: struct sockaddr_iso siso;
145: struct sockaddr_dl sdl;
146: struct sockaddr sa;
147: };
148:
149: /*
150: * FUNCTION: llc_rtrequest
151: *
152: * PURPOSE: Manage routing table entries specific to LLC for ISO.
153: *
154: * NOTES: This does a lot of obscure magic;
155: */
156: llc_rtrequest(req, rt, sa)
157: int req;
158: register struct rtentry *rt;
159: struct sockaddr *sa;
160: {
161: register union sockunion *gate = (union sockunion *)rt->rt_gateway;
162: register struct llinfo_llc *lc = (struct llinfo_llc *)rt->rt_llinfo, *lc2;
163: struct rtentry *rt2;
164: struct ifnet *ifp = rt->rt_ifp;
165: int addrlen = ifp->if_addrlen;
166: static struct rtentry *recursing = 0;
167: #define LLC_SIZE 3 /* XXXXXX do this right later */
168:
169: IFDEBUG (D_SNPA)
170: printf("llc_rtrequest(%d, %x, %x)\n", req, rt, sa);
171: ENDDEBUG
172: if (rt->rt_flags & RTF_GATEWAY) {
173: if (recursing) {
174: log(LOG_DEBUG, "llc_rtrequest: gateway route points to same type %x %x\n",
175: recursing, rt);
176: } else switch (req) {
177: case RTM_RESOLVE:
178: case RTM_ADD:
179: recursing = rt;
180: rt->rt_llinfo = (caddr_t)rtalloc1(&gate->sa, 1);
181: recursing = 0;
182: if (rt->rt_rmx.rmx_mtu == 0) {
183: rt->rt_rmx.rmx_mtu =
184: ((rt2 = (struct rtentry *)rt->rt_llinfo) &&
185: (rt2->rt_rmx.rmx_mtu)) ?
186: rt2->rt_rmx.rmx_mtu :
187: rt->rt_ifp->if_mtu - LLC_SIZE;
188: }
189: return;
190:
191: case RTM_DELETE:
192: if (lc)
193: RTFREE((struct rtentry *)lc);
194: rt->rt_llinfo = 0;
195: }
196: } else switch (req) {
197: case RTM_ADD:
198: /*
199: * Case 1: This route may come from a route to iface with mask
200: * or from a default route.
201: */
202: if (rt->rt_flags & RTF_CLONING) {
203: register struct ifaddr *ifa;
204: register struct sockaddr *sa;
205: for (ifa = ifp->if_addrlist; ifa; ifa->ifa_next)
206: if ((sa = ifa->ifa_addr)->sa_family == AF_LINK) {
207: if (sa->sa_len > gate->sa.sa_len)
208: log(LOG_DEBUG, "llc_rtrequest: cloning address too small\n");
209: else {
210: Bcopy(sa, gate, gate->sa.sa_len);
211: gate->sdl.sdl_alen = 0;
212: }
213: break;
214: }
215: if (ifa == 0)
216: log(LOG_DEBUG, "llc_rtrequest: can't find LL ifaddr for iface\n");
217: break;
218: }
219: /* FALLTHROUGH */
220: case RTM_RESOLVE:
221: /*
222: * Case 2: This route may come from cloning, or a manual route
223: * add with a LL address.
224: */
225: if (gate->sdl.sdl_family != AF_LINK) {
226: log(LOG_DEBUG, "llc_rtrequest: got non-link non-gateway route\n");
227: break;
228: }
229: if (lc != 0)
230: return; /* happens on a route change */
231: R_Malloc(lc, struct llinfo_llc *, sizeof (*lc));
232: rt->rt_llinfo = (caddr_t)lc;
233: if (lc == 0) {
234: log(LOG_DEBUG, "llc_rtrequest: malloc failed\n");
235: break;
236: }
237: Bzero(lc, sizeof(*lc));
238: lc->lc_rt = rt;
239: rt->rt_flags |= RTF_LLINFO;
240: insque(lc, &llinfo_llc);
241: if (gate->sdl.sdl_alen == sizeof(struct esis_req) + addrlen) {
242: gate->sdl.sdl_alen -= sizeof(struct esis_req);
243: bcopy(addrlen + LLADDR(&gate->sdl),
244: (caddr_t)&lc->lc_er, sizeof(lc->lc_er));
245: } else if (gate->sdl.sdl_alen == addrlen)
246: lc->lc_flags = (SNPA_ES | SNPA_VALID | SNPA_PERM);
247: break;
248: case RTM_DELETE:
249: if (lc == 0 || (rt->rt_flags & RTF_CLONING))
250: return;
251: remque(lc);
252: Free(lc);
253: rt->rt_llinfo = 0;
254: rt->rt_flags &= ~RTF_LLINFO;
255: break;
256: }
257: if (rt->rt_rmx.rmx_mtu == 0) {
258: rt->rt_rmx.rmx_mtu = rt->rt_ifp->if_mtu - LLC_SIZE;
259: }
260: }
261: /*
262: * FUNCTION: iso_snparesolve
263: *
264: * PURPOSE: Resolve an iso address into snpa address
265: *
266: * RETURNS: 0 if addr is resolved
267: * errno if addr is unknown
268: *
269: * SIDE EFFECTS:
270: *
271: * NOTES: Now that we have folded the snpa cache into the routing
272: * table, we know there is no snpa address known for this
273: * destination. If we know of a default IS, then the address
274: * of the IS is returned. If no IS is known, then return the
275: * multi-cast address for "all ES" for this interface.
276: *
277: * NB: the last case described above constitutes the
278: * query configuration function 9542, sec 6.5
279: * A mechanism is needed to prevent this function from
280: * being invoked if the system is an IS.
281: */
282: iso_snparesolve(ifp, dest, snpa, snpa_len)
283: struct ifnet *ifp; /* outgoing interface */
284: struct sockaddr_iso *dest; /* destination */
285: caddr_t snpa; /* RESULT: snpa to be used */
286: int *snpa_len; /* RESULT: length of snpa */
287: {
288: struct llinfo_llc *sc; /* ptr to snpa table entry */
289: caddr_t found_snpa;
290: int addrlen;
291:
292: /*
293: * This hack allows us to send esis packets that have the destination snpa
294: * addresss embedded in the destination nsap address
295: */
296: if (dest->siso_data[0] == AFI_SNA) {
297: /*
298: * This is a subnetwork address. Return it immediately
299: */
300: IFDEBUG(D_SNPA)
301: printf("iso_snparesolve: return SN address\n");
302: ENDDEBUG
303: addrlen = dest->siso_nlen - 1; /* subtract size of AFI */
304: found_snpa = (caddr_t) dest->siso_data + 1;
305: /*
306: * If we are an IS, we can't do much with the packet;
307: * Check if we know about an IS.
308: */
309: } else if (iso_systype != SNPA_IS && known_is != 0 &&
310: (sc = (struct llinfo_llc *)known_is->rt_llinfo) &&
311: (sc->lc_flags & SNPA_VALID)) {
312: register struct sockaddr_dl *sdl =
313: (struct sockaddr_dl *)(known_is->rt_gateway);
314: found_snpa = LLADDR(sdl);
315: addrlen = sdl->sdl_alen;
316: } else if (ifp->if_flags & IFF_BROADCAST) {
317: /*
318: * no IS, no match. Return "all es" multicast address for this
319: * interface, as per Query Configuration Function (9542 sec 6.5)
320: *
321: * Note: there is a potential problem here. If the destination
322: * is on the subnet and it does not respond with a ESH, but
323: * does send back a TP CC, a connection could be established
324: * where we always transmit the CLNP packet to "all es"
325: */
326: addrlen = ifp->if_addrlen;
327: found_snpa = (caddr_t)all_es_snpa;
328: } else
329: return (ENETUNREACH);
330: bcopy(found_snpa, snpa, *snpa_len = addrlen);
331: return (0);
332: }
333:
334:
335: /*
336: * FUNCTION: snpac_free
337: *
338: * PURPOSE: free an entry in the iso address map table
339: *
340: * RETURNS: nothing
341: *
342: * SIDE EFFECTS:
343: *
344: * NOTES: If there is a route entry associated with cache
345: * entry, then delete that as well
346: */
347: snpac_free(lc)
348: register struct llinfo_llc *lc; /* entry to free */
349: {
350: register struct rtentry *rt = lc->lc_rt;
351: register struct iso_addr *r;
352:
353: if (known_is == rt)
354: known_is = 0;
355: if (rt && (rt->rt_flags & RTF_UP) &&
356: (rt->rt_flags & (RTF_DYNAMIC | RTF_MODIFIED))) {
357: RTFREE(rt);
358: rtrequest(RTM_DELETE, rt_key(rt), rt->rt_gateway, rt_mask(rt),
359: rt->rt_flags, (struct rtentry **)0);
360: RTFREE(rt);
361: }
362: }
363:
364: /*
365: * FUNCTION: snpac_add
366: *
367: * PURPOSE: Add an entry to the snpa cache
368: *
369: * RETURNS:
370: *
371: * SIDE EFFECTS:
372: *
373: * NOTES: If entry already exists, then update holding time.
374: */
375: snpac_add(ifp, nsap, snpa, type, ht, nsellength)
376: struct ifnet *ifp; /* interface info is related to */
377: struct iso_addr *nsap; /* nsap to add */
378: caddr_t snpa; /* translation */
379: char type; /* SNPA_IS or SNPA_ES */
380: u_short ht; /* holding time (in seconds) */
381: int nsellength; /* nsaps may differ only in trailing bytes */
382: {
383: register struct llinfo_llc *lc;
384: register struct rtentry *rt;
385: struct rtentry *mrt = 0;
386: register struct iso_addr *r; /* for zap_isoaddr macro */
387: int snpalen = min(ifp->if_addrlen, MAX_SNPALEN);
388: int new_entry = 0, index = ifp->if_index;
389:
390: IFDEBUG(D_SNPA)
391: printf("snpac_add(%x, %x, %x, %x, %x, %x)\n",
392: ifp, nsap, snpa, type, ht, nsellength);
393: ENDDEBUG
394: zap_isoaddr(dst, nsap);
395: rt = rtalloc1(S(dst), 0);
396: IFDEBUG(D_SNPA)
397: printf("snpac_add: rtalloc1 returns %x\n", rt);
398: ENDDEBUG
399: if (rt == 0) {
400: struct sockaddr *netmask;
401: int flags;
402: add:
403: if (nsellength) {
404: netmask = S(msk); flags = RTF_UP;
405: snpac_fixdstandmask(nsellength);
406: } else {
407: netmask = 0; flags = RTF_UP | RTF_HOST;
408: }
409: new_entry = 1;
410: zap_linkaddr((>e_dl), snpa, snpalen, index);
411: if (rtrequest(RTM_ADD, S(dst), S(gte_dl), netmask, flags, &mrt) ||
412: mrt == 0)
413: return (0);
414: rt = mrt;
415: rt->rt_refcnt--;
416: } else {
417: register struct sockaddr_dl *sdl = (struct sockaddr_dl *)rt->rt_gateway;
418: rt->rt_refcnt--;
419: if ((rt->rt_flags & RTF_LLINFO) == 0)
420: goto add;
421: if (nsellength && (rt->rt_flags & RTF_HOST)) {
422: if (rt->rt_refcnt == 0) {
423: rtrequest(RTM_DELETE, S(dst), (struct sockaddr *)0,
424: (struct sockaddr *)0, 0, (struct rtentry *)0);
425: rt = 0;
426: goto add;
427: } else {
428: static struct iso_addr nsap2; register char *cp;
429: nsap2 = *nsap;
430: cp = nsap2.isoa_genaddr + nsap->isoa_len - nsellength;
431: while (cp < (char *)(1 + &nsap2))
432: *cp++ = 0;
433: (void) snpac_add(ifp, &nsap2, snpa, type, ht, nsellength);
434: }
435: }
436: if (sdl->sdl_family != AF_LINK || sdl->sdl_alen == 0) {
437: int old_sdl_len = sdl->sdl_len;
438: if (old_sdl_len < sizeof(*sdl)) {
439: log(LOG_DEBUG, "snpac_add: cant make room for lladdr\n");
440: return (0);
441: }
442: zap_linkaddr(sdl, snpa, snpalen, index);
443: sdl->sdl_len = old_sdl_len;
444: new_entry = 1;
445: }
446: }
447: if ((lc = (struct llinfo_llc *)rt->rt_llinfo) == 0)
448: panic("snpac_rtrequest");
449: rt->rt_rmx.rmx_expire = ht + time.tv_sec;
450: lc->lc_flags = SNPA_VALID | type;
451: if (type & SNPA_IS)
452: snpac_logdefis(rt);
453: return (new_entry);
454: }
455:
456: static void
457: snpac_fixdstandmask(nsellength)
458: {
459: register char *cp = msk.siso_data, *cplim;
460:
461: cplim = cp + (dst.siso_nlen -= nsellength);
462: msk.siso_len = cplim - (char *)&msk;
463: msk.siso_nlen = 0;
464: while (cp < cplim)
465: *cp++ = -1;
466: while (cp < (char *)msk.siso_pad)
467: *cp++ = 0;
468: for (cp = dst.siso_data + dst.siso_nlen; cp < (char *)dst.siso_pad; )
469: *cp++ = 0;
470: }
471:
472: /*
473: * FUNCTION: snpac_ioctl
474: *
475: * PURPOSE: Set/Get the system type and esis parameters
476: *
477: * RETURNS: 0 on success, or unix error code
478: *
479: * SIDE EFFECTS:
480: *
481: * NOTES:
482: */
483: snpac_ioctl (so, cmd, data)
484: struct socket *so;
485: int cmd; /* ioctl to process */
486: caddr_t data; /* data for the cmd */
487: {
488: register struct systype_req *rq = (struct systype_req *)data;
489:
490: IFDEBUG(D_IOCTL)
491: if (cmd == SIOCSSTYPE)
492: printf("snpac_ioctl: cmd set, type x%x, ht %d, ct %d\n",
493: rq->sr_type, rq->sr_holdt, rq->sr_configt);
494: else
495: printf("snpac_ioctl: cmd get\n");
496: ENDDEBUG
497:
498: if (cmd == SIOCSSTYPE) {
499: if ((so->so_state & SS_PRIV) == 0)
500: return (EPERM);
501: if ((rq->sr_type & (SNPA_ES|SNPA_IS)) == (SNPA_ES|SNPA_IS))
502: return(EINVAL);
503: if (rq->sr_type & SNPA_ES) {
504: iso_systype = SNPA_ES;
505: } else if (rq->sr_type & SNPA_IS) {
506: iso_systype = SNPA_IS;
507: } else {
508: return(EINVAL);
509: }
510: esis_holding_time = rq->sr_holdt;
511: esis_config_time = rq->sr_configt;
512: if (esis_esconfig_time != rq->sr_esconfigt) {
513: untimeout(esis_config, (caddr_t)0);
514: esis_esconfig_time = rq->sr_esconfigt;
515: esis_config();
516: }
517: } else if (cmd == SIOCGSTYPE) {
518: rq->sr_type = iso_systype;
519: rq->sr_holdt = esis_holding_time;
520: rq->sr_configt = esis_config_time;
521: rq->sr_esconfigt = esis_esconfig_time;
522: } else {
523: return (EINVAL);
524: }
525: return (0);
526: }
527:
528: /*
529: * FUNCTION: snpac_logdefis
530: *
531: * PURPOSE: Mark the IS passed as the default IS
532: *
533: * RETURNS: nothing
534: *
535: * SIDE EFFECTS:
536: *
537: * NOTES:
538: */
539: snpac_logdefis(sc)
540: register struct rtentry *sc;
541: {
542: register struct iso_addr *r;
543: register struct sockaddr_dl *sdl = (struct sockaddr_dl *)sc->rt_gateway;
544: register struct rtentry *rt = rtalloc1((struct sockaddr *)&zsi, 0);
545:
546: zap_linkaddr((>e_dl), LLADDR(sdl), sdl->sdl_alen, sdl->sdl_index);
547: if (known_is == 0)
548: known_is = sc;
549: if (known_is != sc) {
550: rtfree(known_is);
551: known_is = sc;
552: }
553: if (rt == 0) {
554: rtrequest(RTM_ADD, S(zsi), S(gte_dl), S(zmk),
555: RTF_DYNAMIC|RTF_GATEWAY|RTF_CLONING, 0);
556: return;
557: }
558: rt->rt_refcnt--;
559: if (rt->rt_flags & (RTF_DYNAMIC | RTF_MODIFIED)) {
560: *((struct sockaddr_dl *)rt->rt_gateway) = gte_dl;
561: }
562: }
563:
564: /*
565: * FUNCTION: snpac_age
566: *
567: * PURPOSE: Time out snpac entries
568: *
569: * RETURNS:
570: *
571: * SIDE EFFECTS:
572: *
573: * NOTES: When encountering an entry for the first time, snpac_age
574: * may delete up to SNPAC_AGE too many seconds. Ie.
575: * if the entry is added a moment before snpac_age is
576: * called, the entry will immediately have SNPAC_AGE
577: * seconds taken off the holding time, even though
578: * it has only been held a brief moment.
579: *
580: * The proper way to do this is set an expiry timeval
581: * equal to current time + holding time. Then snpac_age
582: * would time out entries where expiry date is older
583: * than the current time.
584: */
585: snpac_age()
586: {
587: register struct llinfo_llc *lc, *nlc;
588: register struct rtentry *rt;
589:
590: timeout(snpac_age, (caddr_t)0, SNPAC_AGE * hz);
591:
592: for (lc = llinfo_llc.lc_next; lc != & llinfo_llc; lc = nlc) {
593: nlc = lc->lc_next;
594: if (((lc->lc_flags & SNPA_PERM) == 0) && (lc->lc_flags & SNPA_VALID)) {
595: rt = lc->lc_rt;
596: if (rt->rt_rmx.rmx_expire && rt->rt_rmx.rmx_expire < time.tv_sec)
597: snpac_free(lc);
598: else
599: continue;
600: }
601: }
602: }
603:
604: /*
605: * FUNCTION: snpac_ownmulti
606: *
607: * PURPOSE: Determine if the snpa address is a multicast address
608: * of the same type as the system.
609: *
610: * RETURNS: true or false
611: *
612: * SIDE EFFECTS:
613: *
614: * NOTES: Used by interface drivers when not in eavesdrop mode
615: * as interm kludge until
616: * real multicast addresses can be configured
617: */
618: snpac_ownmulti(snpa, len)
619: caddr_t snpa;
620: u_int len;
621: {
622: return (((iso_systype & SNPA_ES) &&
623: (!bcmp(snpa, (caddr_t)all_es_snpa, len))) ||
624: ((iso_systype & SNPA_IS) &&
625: (!bcmp(snpa, (caddr_t)all_is_snpa, len))));
626: }
627:
628: /*
629: * FUNCTION: snpac_flushifp
630: *
631: * PURPOSE: Flush entries associated with specific ifp
632: *
633: * RETURNS: nothing
634: *
635: * SIDE EFFECTS:
636: *
637: * NOTES:
638: */
639: snpac_flushifp(ifp)
640: struct ifnet *ifp;
641: {
642: register struct llinfo_llc *lc;
643:
644: for (lc = llinfo_llc.lc_next; lc != & llinfo_llc; lc = lc->lc_next) {
645: if (lc->lc_rt->rt_ifp == ifp && (lc->lc_flags & SNPA_VALID))
646: snpac_free(lc);
647: }
648: }
649:
650: /*
651: * FUNCTION: snpac_rtrequest
652: *
653: * PURPOSE: Make a routing request
654: *
655: * RETURNS: nothing
656: *
657: * SIDE EFFECTS:
658: *
659: * NOTES: In the future, this should make a request of a user
660: * level routing daemon.
661: */
662: snpac_rtrequest(req, host, gateway, netmask, flags, ret_nrt)
663: int req;
664: struct iso_addr *host;
665: struct iso_addr *gateway;
666: struct iso_addr *netmask;
667: short flags;
668: struct rtentry **ret_nrt;
669: {
670: register struct iso_addr *r;
671:
672: IFDEBUG(D_SNPA)
673: printf("snpac_rtrequest: ");
674: if (req == RTM_ADD)
675: printf("add");
676: else if (req == RTM_DELETE)
677: printf("delete");
678: else
679: printf("unknown command");
680: printf(" dst: %s\n", clnp_iso_addrp(host));
681: printf("\tgateway: %s\n", clnp_iso_addrp(gateway));
682: ENDDEBUG
683:
684:
685: zap_isoaddr(dst, host);
686: zap_isoaddr(gte, gateway);
687: if (netmask) {
688: zap_isoaddr(msk, netmask);
689: msk.siso_nlen = 0;
690: msk.siso_len = msk.siso_pad - (u_char *)&msk;
691: }
692:
693: rtrequest(req, S(dst), S(gte), (netmask ? S(msk) : (struct sockaddr *)0),
694: flags, ret_nrt);
695: }
696:
697: /*
698: * FUNCTION: snpac_addrt
699: *
700: * PURPOSE: Associate a routing entry with an snpac entry
701: *
702: * RETURNS: nothing
703: *
704: * SIDE EFFECTS:
705: *
706: * NOTES: If a cache entry exists for gateway, then
707: * make a routing entry (host, gateway) and associate
708: * with gateway.
709: *
710: * If a route already exists and is different, first delete
711: * it.
712: *
713: * This could be made more efficient by checking
714: * the existing route before adding a new one.
715: */
716: snpac_addrt(ifp, host, gateway, netmask)
717: struct ifnet *ifp;
718: struct iso_addr *host, *gateway, *netmask;
719: {
720: register struct iso_addr *r;
721:
722: zap_isoaddr(dst, host);
723: zap_isoaddr(gte, gateway);
724: if (netmask) {
725: zap_isoaddr(msk, netmask);
726: msk.siso_nlen = 0;
727: msk.siso_len = msk.siso_pad - (u_char *)&msk;
728: rtredirect(S(dst), S(gte), S(msk), RTF_DONE, S(gte), 0);
729: } else
730: rtredirect(S(dst), S(gte), (struct sockaddr *)0,
731: RTF_DONE | RTF_HOST, S(gte), 0);
732: }
733: #endif ISO
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.