![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to iso.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / netiso|
Return to iso.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netiso |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*-
26: * Copyright (c) 1991, 1993
27: * The Regents of the University of California. All rights reserved.
28: *
29: * Redistribution and use in source and binary forms, with or without
30: * modification, are permitted provided that the following conditions
31: * are met:
32: * 1. Redistributions of source code must retain the above copyright
33: * notice, this list of conditions and the following disclaimer.
34: * 2. Redistributions in binary form must reproduce the above copyright
35: * notice, this list of conditions and the following disclaimer in the
36: * documentation and/or other materials provided with the distribution.
37: * 3. All advertising materials mentioning features or use of this software
38: * must display the following acknowledgement:
39: * This product includes software developed by the University of
40: * California, Berkeley and its contributors.
41: * 4. Neither the name of the University nor the names of its contributors
42: * may be used to endorse or promote products derived from this software
43: * without specific prior written permission.
44: *
45: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
46: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
48: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
49: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
50: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
51: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
52: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
53: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
54: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
55: * SUCH DAMAGE.
56: *
57: * @(#)iso.c 8.2 (Berkeley) 11/15/93
58: */
59:
60: /***********************************************************
61: Copyright IBM Corporation 1987
62:
63: All Rights Reserved
64:
65: Permission to use, copy, modify, and distribute this software and its
66: documentation for any purpose and without fee is hereby granted,
67: provided that the above copyright notice appear in all copies and that
68: both that copyright notice and this permission notice appear in
69: supporting documentation, and that the name of IBM not be
70: used in advertising or publicity pertaining to distribution of the
71: software without specific, written prior permission.
72:
73: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
74: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
75: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
76: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
77: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
78: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
79: SOFTWARE.
80:
81: ******************************************************************/
82:
83: /*
84: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison
85: */
86: /*
87: * iso.c: miscellaneous routines to support the iso address family
88: */
89:
90: #include <sys/param.h>
91: #include <sys/systm.h>
92: #include <sys/ioctl.h>
93: #include <sys/mbuf.h>
94: #include <sys/domain.h>
95: #include <sys/protosw.h>
96: #include <sys/socket.h>
97: #include <sys/socketvar.h>
98: #include <sys/errno.h>
99: #include <sys/malloc.h>
100:
101: #include <net/if.h>
102: #include <net/route.h>
103:
104: #include <netiso/iso.h>
105: #include <netiso/iso_var.h>
106: #include <netiso/iso_snpac.h>
107: #include <netiso/iso_pcb.h>
108: #include <netiso/clnp.h>
109: #include <netiso/argo_debug.h>
110: #if TUBA
111: #include <netiso/tuba_table.h>
112: #endif
113:
114: #if ISO
115:
116: int iso_interfaces = 0; /* number of external interfaces */
117: extern struct ifnet loif; /* loopback interface */
118: int ether_output();
119: void llc_rtrequest();
120:
121: /*
122: * FUNCTION: iso_addrmatch1
123: *
124: * PURPOSE: decide if the two iso_addrs passed are equal
125: *
126: * RETURNS: true if the addrs match, false if they do not
127: *
128: * SIDE EFFECTS:
129: *
130: * NOTES:
131: */
132: iso_addrmatch1(isoaa, isoab)
133: register struct iso_addr *isoaa, *isoab; /* addresses to check */
134: {
135: u_int compare_len;
136:
137: IFDEBUG(D_ROUTE)
138: printf("iso_addrmatch1: comparing lengths: %d to %d\n", isoaa->isoa_len,
139: isoab->isoa_len);
140: printf("a:\n");
141: dump_buf(isoaa->isoa_genaddr, isoaa->isoa_len);
142: printf("b:\n");
143: dump_buf(isoab->isoa_genaddr, isoab->isoa_len);
144: ENDDEBUG
145:
146: if ((compare_len = isoaa->isoa_len) != isoab->isoa_len) {
147: IFDEBUG(D_ROUTE)
148: printf("iso_addrmatch1: returning false because of lengths\n");
149: ENDDEBUG
150: return 0;
151: }
152:
153: #ifdef notdef
154: /* TODO : generalize this to all afis with masks */
155: if( isoaa->isoa_afi == AFI_37 ) {
156: /* must not compare 2 least significant digits, or for
157: * that matter, the DSP
158: */
159: compare_len = ADDR37_IDI_LEN - 1;
160: }
161: #endif
162:
163: IFDEBUG(D_ROUTE)
164: int i;
165: char *a, *b;
166:
167: a = isoaa->isoa_genaddr;
168: b = isoab->isoa_genaddr;
169:
170: for (i=0; i<compare_len; i++) {
171: printf("<%x=%x>", a[i]&0xff, b[i]&0xff);
172: if (a[i] != b[i]) {
173: printf("\naddrs are not equal at byte %d\n", i);
174: return(0);
175: }
176: }
177: printf("\n");
178: printf("addrs are equal\n");
179: return (1);
180: ENDDEBUG
181: return (!bcmp(isoaa->isoa_genaddr, isoab->isoa_genaddr, compare_len));
182: }
183:
184: /*
185: * FUNCTION: iso_addrmatch
186: *
187: * PURPOSE: decide if the two sockadrr_isos passed are equal
188: *
189: * RETURNS: true if the addrs match, false if they do not
190: *
191: * SIDE EFFECTS:
192: *
193: * NOTES:
194: */
195: iso_addrmatch(sisoa, sisob)
196: struct sockaddr_iso *sisoa, *sisob; /* addresses to check */
197: {
198: return(iso_addrmatch1(&sisoa->siso_addr, &sisob->siso_addr));
199: }
200: #ifdef notdef
201: /*
202: * FUNCTION: iso_netmatch
203: *
204: * PURPOSE: similar to iso_addrmatch but takes sockaddr_iso
205: * as argument.
206: *
207: * RETURNS: true if same net, false if not
208: *
209: * SIDE EFFECTS:
210: *
211: * NOTES:
212: */
213: iso_netmatch(sisoa, sisob)
214: struct sockaddr_iso *sisoa, *sisob;
215: {
216: u_char bufa[sizeof(struct sockaddr_iso)];
217: u_char bufb[sizeof(struct sockaddr_iso)];
218: register int lena, lenb;
219:
220: lena = iso_netof(&sisoa->siso_addr, bufa);
221: lenb = iso_netof(&sisob->siso_addr, bufb);
222:
223: IFDEBUG(D_ROUTE)
224: printf("iso_netmatch: comparing lengths: %d to %d\n", lena, lenb);
225: printf("a:\n");
226: dump_buf(bufa, lena);
227: printf("b:\n");
228: dump_buf(bufb, lenb);
229: ENDDEBUG
230:
231: return ((lena == lenb) && (!bcmp(bufa, bufb, lena)));
232: }
233: #endif /* notdef */
234:
235: /*
236: * FUNCTION: iso_hashchar
237: *
238: * PURPOSE: Hash all character in the buffer specified into
239: * a long. Return the long.
240: *
241: * RETURNS: The hash value.
242: *
243: * SIDE EFFECTS:
244: *
245: * NOTES: The hash is achieved by exclusive ORing 4 byte
246: * quantities.
247: */
248: u_long
249: iso_hashchar(buf, len)
250: register caddr_t buf; /* buffer to pack from */
251: register int len; /* length of buffer */
252: {
253: register u_long h = 0;
254: register int i;
255:
256: for (i=0; i<len; i+=4) {
257: register u_long l = 0;
258:
259: if ((len - i) < 4) {
260: /* buffer not multiple of 4 */
261: switch (len - i) {
262: case 3:
263: l |= buf[i+2] << 8;
264: case 2:
265: l |= buf[i+1] << 16;
266: case 1:
267: l |= buf[i] << 24;
268: break;
269: default:
270: printf("iso_hashchar: unexpected value x%x\n", len - i);
271: break;
272: }
273: } else {
274: l |= buf[i] << 24;
275: l |= buf[i+1] << 16;
276: l |= buf[i+2] << 8;
277: l |= buf[i+3];
278: }
279:
280: h ^= l;
281: }
282:
283: h ^= (u_long) (len % 4);
284:
285: return(h);
286: }
287: #ifdef notdef
288: /*
289: * FUNCTION: iso_hash
290: *
291: * PURPOSE: Fill in fields of afhash structure based upon addr passed.
292: *
293: * RETURNS: none
294: *
295: * SIDE EFFECTS:
296: *
297: * NOTES:
298: */
299: iso_hash(siso, hp)
300: struct sockaddr_iso *siso; /* address to perform hash on */
301: struct afhash *hp; /* RETURN: hash info here */
302: {
303: u_long buf[sizeof(struct sockaddr_iso)+1/4];
304: register int bufsize;
305:
306:
307: bzero(buf, sizeof(buf));
308:
309: bufsize = iso_netof(&siso->siso_addr, buf);
310: hp->afh_nethash = iso_hashchar((caddr_t)buf, bufsize);
311:
312: IFDEBUG(D_ROUTE)
313: printf("iso_hash: iso_netof: bufsize = %d\n", bufsize);
314: ENDDEBUG
315:
316: hp->afh_hosthash = iso_hashchar((caddr_t)&siso->siso_addr,
317: siso->siso_addr.isoa_len);
318:
319: IFDEBUG(D_ROUTE)
320: printf("iso_hash: %s: nethash = x%x, hosthash = x%x\n",
321: clnp_iso_addrp(&siso->siso_addr), hp->afh_nethash,
322: hp->afh_hosthash);
323: ENDDEBUG
324: }
325: /*
326: * FUNCTION: iso_netof
327: *
328: * PURPOSE: Extract the network portion of the iso address.
329: * The network portion of the iso address varies depending
330: * on the type of address. The network portion of the
331: * address will include the IDP. The network portion is:
332: *
333: * TYPE DESC
334: * t37 The AFI and x.121 (IDI)
335: * osinet The AFI, orgid, snetid
336: * rfc986 The AFI, vers and network part of
337: * internet address.
338: *
339: * RETURNS: number of bytes placed into buf.
340: *
341: * SIDE EFFECTS:
342: *
343: * NOTES: Buf is assumed to be big enough
344: */
345: iso_netof(isoa, buf)
346: struct iso_addr *isoa; /* address */
347: caddr_t buf; /* RESULT: network portion of address here */
348: {
349: u_int len = 1; /* length of afi */
350:
351: switch (isoa->isoa_afi) {
352: case AFI_37:
353: /*
354: * Due to classic x.25 tunnel vision, there is no
355: * net portion of an x.121 address. For our purposes
356: * the AFI will do, so that all x.25 -type addresses
357: * map to the single x.25 SNPA. (Cannot have more than
358: * one, obviously).
359: */
360:
361: break;
362:
363: /* case AFI_OSINET:*/
364: case AFI_RFC986: {
365: u_short idi; /* value of idi */
366:
367: /* osinet and rfc986 have idi in the same place */
368: CTOH(isoa->rfc986_idi[0], isoa->rfc986_idi[1], idi);
369:
370: if (idi == IDI_OSINET)
371: /*
372: * Network portion of OSINET address can only be the IDI. Clearly,
373: * with one x25 interface, one could get to several orgids, and
374: * several snetids.
375: len += (ADDROSINET_IDI_LEN + OVLOSINET_ORGID_LEN +
376: OVLOSINET_SNETID_LEN);
377: */
378: len += ADDROSINET_IDI_LEN;
379: else if (idi == IDI_RFC986) {
380: u_long inetaddr;
381: struct ovl_rfc986 *o986 = (struct ovl_rfc986 *)isoa;
382:
383: /* bump len to include idi and version (1 byte) */
384: len += ADDRRFC986_IDI_LEN + 1;
385:
386: /* get inet addr long aligned */
387: bcopy(o986->o986_inetaddr, &inetaddr, sizeof(inetaddr));
388: inetaddr = ntohl(inetaddr); /* convert to host byte order */
389:
390: IFDEBUG(D_ROUTE)
391: printf("iso_netof: isoa ");
392: dump_buf(isoa, sizeof(*isoa));
393: printf("iso_netof: inetaddr 0x%x ", inetaddr);
394: ENDDEBUG
395:
396: /* bump len by size of network portion of inet address */
397: if (IN_CLASSA(inetaddr)) {
398: len += 4-IN_CLASSA_NSHIFT/8;
399: IFDEBUG(D_ROUTE)
400: printf("iso_netof: class A net len is now %d\n", len);
401: ENDDEBUG
402: } else if (IN_CLASSB(inetaddr)) {
403: len += 4-IN_CLASSB_NSHIFT/8;
404: IFDEBUG(D_ROUTE)
405: printf("iso_netof: class B net len is now %d\n", len);
406: ENDDEBUG
407: } else {
408: len += 4-IN_CLASSC_NSHIFT/8;
409: IFDEBUG(D_ROUTE)
410: printf("iso_netof: class C net len is now %d\n", len);
411: ENDDEBUG
412: }
413: } else
414: len = 0;
415: } break;
416:
417: default:
418: len = 0;
419: }
420:
421: bcopy((caddr_t)isoa, buf, len);
422: IFDEBUG(D_ROUTE)
423: printf("iso_netof: isoa ");
424: dump_buf(isoa, len);
425: printf("iso_netof: net ");
426: dump_buf(buf, len);
427: ENDDEBUG
428: return len;
429: }
430: #endif /* notdef */
431: /*
432: * Generic iso control operations (ioctl's).
433: * Ifp is 0 if not an interface-specific ioctl.
434: */
435: /* ARGSUSED */
436: iso_control(so, cmd, data, ifp)
437: struct socket *so;
438: int cmd;
439: caddr_t data;
440: register struct ifnet *ifp;
441: {
442: register struct iso_ifreq *ifr = (struct iso_ifreq *)data;
443: register struct iso_ifaddr *ia = 0;
444: register struct ifaddr *ifa;
445: struct iso_ifaddr *oia;
446: struct iso_aliasreq *ifra = (struct iso_aliasreq *)data;
447: int error, hostIsNew, maskIsNew;
448:
449: /*
450: * Find address for this interface, if it exists.
451: */
452: if (ifp)
453: for (ia = iso_ifaddr; ia; ia = ia->ia_next)
454: if (ia->ia_ifp == ifp)
455: break;
456:
457: switch (cmd) {
458:
459: case SIOCAIFADDR_ISO:
460: case SIOCDIFADDR_ISO:
461: if (ifra->ifra_addr.siso_family == AF_ISO)
462: for (oia = ia; ia; ia = ia->ia_next) {
463: if (ia->ia_ifp == ifp &&
464: SAME_ISOADDR(&ia->ia_addr, &ifra->ifra_addr))
465: break;
466: }
467: if ((so->so_state & SS_PRIV) == 0)
468: return (EPERM);
469: if (ifp == 0)
470: panic("iso_control");
471: if (ia == (struct iso_ifaddr *)0) {
472: struct iso_ifaddr *nia;
473: if (cmd == SIOCDIFADDR_ISO)
474: return (EADDRNOTAVAIL);
475: #if TUBA
476: /* XXXXXX can't be done in the proto init routines */
477: if (tuba_tree == 0)
478: tuba_table_init();
479: #endif
480: MALLOC(nia, struct iso_ifaddr *, sizeof(*nia),
481: M_IFADDR, M_WAITOK);
482: if (nia == (struct iso_ifaddr *)0)
483: return (ENOBUFS);
484: bzero((caddr_t)nia, sizeof(*nia));
485: if (ia = iso_ifaddr) {
486: for ( ; ia->ia_next; ia = ia->ia_next)
487: ;
488: ia->ia_next = nia;
489: } else
490: iso_ifaddr = nia;
491: ia = nia;
492: if (ifa = ifp->if_addrlist) {
493: for ( ; ifa->ifa_next; ifa = ifa->ifa_next)
494: ;
495: ifa->ifa_next = (struct ifaddr *) ia;
496: } else
497: ifp->if_addrlist = (struct ifaddr *) ia;
498: ia->ia_ifa.ifa_addr = (struct sockaddr *)&ia->ia_addr;
499: ia->ia_ifa.ifa_dstaddr
500: = (struct sockaddr *)&ia->ia_dstaddr;
501: ia->ia_ifa.ifa_netmask
502: = (struct sockaddr *)&ia->ia_sockmask;
503: ia->ia_ifp = ifp;
504: if (ifp != &loif)
505: iso_interfaces++;
506: }
507: break;
508:
509: #define cmdbyte(x) (((x) >> 8) & 0xff)
510: default:
511: if (cmdbyte(cmd) == 'a')
512: return (snpac_ioctl(so, cmd, data));
513: if (ia == (struct iso_ifaddr *)0)
514: return (EADDRNOTAVAIL);
515: break;
516: }
517: switch (cmd) {
518:
519: case SIOCGIFADDR_ISO:
520: ifr->ifr_Addr = ia->ia_addr;
521: break;
522:
523: case SIOCGIFDSTADDR_ISO:
524: if ((ifp->if_flags & IFF_POINTOPOINT) == 0)
525: return (EINVAL);
526: ifr->ifr_Addr = ia->ia_dstaddr;
527: break;
528:
529: case SIOCGIFNETMASK_ISO:
530: ifr->ifr_Addr = ia->ia_sockmask;
531: break;
532:
533: case SIOCAIFADDR_ISO:
534: maskIsNew = 0; hostIsNew = 1; error = 0;
535: if (ia->ia_addr.siso_family == AF_ISO) {
536: if (ifra->ifra_addr.siso_len == 0) {
537: ifra->ifra_addr = ia->ia_addr;
538: hostIsNew = 0;
539: } else if (SAME_ISOADDR(&ia->ia_addr, &ifra->ifra_addr))
540: hostIsNew = 0;
541: }
542: if (ifra->ifra_mask.siso_len) {
543: iso_ifscrub(ifp, ia);
544: ia->ia_sockmask = ifra->ifra_mask;
545: maskIsNew = 1;
546: }
547: if ((ifp->if_flags & IFF_POINTOPOINT) &&
548: (ifra->ifra_dstaddr.siso_family == AF_ISO)) {
549: iso_ifscrub(ifp, ia);
550: ia->ia_dstaddr = ifra->ifra_dstaddr;
551: maskIsNew = 1; /* We lie; but the effect's the same */
552: }
553: if (ifra->ifra_addr.siso_family == AF_ISO &&
554: (hostIsNew || maskIsNew)) {
555: error = iso_ifinit(ifp, ia, &ifra->ifra_addr, 0);
556: }
557: if (ifra->ifra_snpaoffset)
558: ia->ia_snpaoffset = ifra->ifra_snpaoffset;
559: return (error);
560:
561: case SIOCDIFADDR_ISO:
562: iso_ifscrub(ifp, ia);
563: if ((ifa = ifp->if_addrlist) == (struct ifaddr *)ia)
564: ifp->if_addrlist = ifa->ifa_next;
565: else {
566: while (ifa->ifa_next &&
567: (ifa->ifa_next != (struct ifaddr *)ia))
568: ifa = ifa->ifa_next;
569: if (ifa->ifa_next)
570: ifa->ifa_next = ((struct ifaddr *)ia)->ifa_next;
571: else
572: printf("Couldn't unlink isoifaddr from ifp\n");
573: }
574: oia = ia;
575: if (oia == (ia = iso_ifaddr)) {
576: iso_ifaddr = ia->ia_next;
577: } else {
578: while (ia->ia_next && (ia->ia_next != oia)) {
579: ia = ia->ia_next;
580: }
581: if (ia->ia_next)
582: ia->ia_next = oia->ia_next;
583: else
584: printf("Didn't unlink isoifadr from list\n");
585: }
586: IFAFREE((&oia->ia_ifa));
587: break;
588:
589: default:
590: if (ifp == 0 || ifp->if_ioctl == 0)
591: return (EOPNOTSUPP);
592: return ((*ifp->if_ioctl)(ifp, cmd, data));
593: }
594: return (0);
595: }
596:
597: /*
598: * Delete any existing route for an interface.
599: */
600: iso_ifscrub(ifp, ia)
601: register struct ifnet *ifp;
602: register struct iso_ifaddr *ia;
603: {
604: int nsellength = ia->ia_addr.siso_tlen;
605: if ((ia->ia_flags & IFA_ROUTE) == 0)
606: return;
607: ia->ia_addr.siso_tlen = 0;
608: if (ifp->if_flags & IFF_LOOPBACK)
609: rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST);
610: else if (ifp->if_flags & IFF_POINTOPOINT)
611: rtinit(&(ia->ia_ifa), (int)RTM_DELETE, RTF_HOST);
612: else {
613: rtinit(&(ia->ia_ifa), (int)RTM_DELETE, 0);
614: }
615: ia->ia_addr.siso_tlen = nsellength;
616: ia->ia_flags &= ~IFA_ROUTE;
617: }
618:
619: /*
620: * Initialize an interface's internet address
621: * and routing table entry.
622: */
623: iso_ifinit(ifp, ia, siso, scrub)
624: register struct ifnet *ifp;
625: register struct iso_ifaddr *ia;
626: struct sockaddr_iso *siso;
627: {
628: struct sockaddr_iso oldaddr;
629: int s = splimp(), error, nsellength;
630:
631: oldaddr = ia->ia_addr;
632: ia->ia_addr = *siso;
633: /*
634: * Give the interface a chance to initialize
635: * if this is its first address,
636: * and to validate the address if necessary.
637: */
638: if (ifp->if_ioctl &&
639: (error = (*ifp->if_ioctl)(ifp, SIOCSIFADDR, (caddr_t)ia))) {
640: splx(s);
641: ia->ia_addr = oldaddr;
642: return (error);
643: }
644: if (scrub) {
645: ia->ia_ifa.ifa_addr = (struct sockaddr *)&oldaddr;
646: iso_ifscrub(ifp, ia);
647: ia->ia_ifa.ifa_addr = (struct sockaddr *)&ia->ia_addr;
648: }
649: /* XXX -- The following is here temporarily out of laziness
650: in not changing every ethernet driver's if_ioctl routine */
651: if (ifp->if_output == ether_output) {
652: ia->ia_ifa.ifa_rtrequest = llc_rtrequest;
653: ia->ia_ifa.ifa_flags |= RTF_CLONING;
654: }
655: /*
656: * Add route for the network.
657: */
658: nsellength = ia->ia_addr.siso_tlen;
659: ia->ia_addr.siso_tlen = 0;
660: if (ifp->if_flags & IFF_LOOPBACK) {
661: ia->ia_ifa.ifa_dstaddr = ia->ia_ifa.ifa_addr;
662: error = rtinit(&(ia->ia_ifa), (int)RTM_ADD, RTF_HOST|RTF_UP);
663: } else if (ifp->if_flags & IFF_POINTOPOINT &&
664: ia->ia_dstaddr.siso_family == AF_ISO)
665: error = rtinit(&(ia->ia_ifa), (int)RTM_ADD, RTF_HOST|RTF_UP);
666: else {
667: rt_maskedcopy(ia->ia_ifa.ifa_addr, ia->ia_ifa.ifa_dstaddr,
668: ia->ia_ifa.ifa_netmask);
669: ia->ia_dstaddr.siso_nlen =
670: min(ia->ia_addr.siso_nlen, (ia->ia_sockmask.siso_len - 6));
671: error = rtinit(&(ia->ia_ifa), (int)RTM_ADD, RTF_UP);
672: }
673: ia->ia_addr.siso_tlen = nsellength;
674: ia->ia_flags |= IFA_ROUTE;
675: splx(s);
676: return (error);
677: }
678: #ifdef notdef
679:
680: struct ifaddr *
681: iso_ifwithidi(addr)
682: register struct sockaddr *addr;
683: {
684: register struct ifnet *ifp;
685: register struct ifaddr *ifa;
686: register u_int af = addr->sa_family;
687:
688: if (af != AF_ISO)
689: return (0);
690: IFDEBUG(D_ROUTE)
691: printf(">>> iso_ifwithidi addr\n");
692: dump_isoaddr( (struct sockaddr_iso *)(addr));
693: printf("\n");
694: ENDDEBUG
695: for (ifp = ifnet; ifp; ifp = ifp->if_next) {
696: IFDEBUG(D_ROUTE)
697: printf("iso_ifwithidi ifnet %s\n", ifp->if_name);
698: ENDDEBUG
699: for (ifa = ifp->if_addrlist; ifa; ifa = ifa->ifa_next) {
700: IFDEBUG(D_ROUTE)
701: printf("iso_ifwithidi address ");
702: dump_isoaddr( (struct sockaddr_iso *)(ifa->ifa_addr));
703: ENDDEBUG
704: if (ifa->ifa_addr->sa_family != addr->sa_family)
705: continue;
706:
707: #define IFA_SIS(ifa)\
708: ((struct sockaddr_iso *)((ifa)->ifa_addr))
709:
710: IFDEBUG(D_ROUTE)
711: printf(" af same, args to iso_eqtype:\n");
712: printf("0x%x ", IFA_SIS(ifa)->siso_addr);
713: printf(" 0x%x\n",
714: &(((struct sockaddr_iso *)addr)->siso_addr));
715: ENDDEBUG
716:
717: if (iso_eqtype(&(IFA_SIS(ifa)->siso_addr),
718: &(((struct sockaddr_iso *)addr)->siso_addr))) {
719: IFDEBUG(D_ROUTE)
720: printf("ifa_ifwithidi: ifa found\n");
721: ENDDEBUG
722: return (ifa);
723: }
724: IFDEBUG(D_ROUTE)
725: printf(" iso_eqtype failed\n");
726: ENDDEBUG
727: }
728: }
729: return ((struct ifaddr *)0);
730: }
731:
732: #endif /* notdef */
733: /*
734: * FUNCTION: iso_ck_addr
735: *
736: * PURPOSE: return true if the iso_addr passed is
737: * within the legal size limit for an iso address.
738: *
739: * RETURNS: true or false
740: *
741: * SIDE EFFECTS:
742: *
743: */
744: iso_ck_addr(isoa)
745: struct iso_addr *isoa; /* address to check */
746: {
747: return (isoa->isoa_len <= 20);
748:
749: }
750:
751: #ifdef notdef
752: /*
753: * FUNCTION: iso_eqtype
754: *
755: * PURPOSE: Determine if two iso addresses are of the same type.
756: * This is flaky. Really we should consider all type 47 addrs to be the
757: * same - but there do exist different structures for 47 addrs.
758: * Gosip adds a 3rd.
759: *
760: * RETURNS: true if the addresses are the same type
761: *
762: * SIDE EFFECTS:
763: *
764: * NOTES: By type, I mean rfc986, t37, or osinet
765: *
766: * This will first compare afis. If they match, then
767: * if the addr is not t37, the idis must be compared.
768: */
769: iso_eqtype(isoaa, isoab)
770: struct iso_addr *isoaa; /* first addr to check */
771: struct iso_addr *isoab; /* other addr to check */
772: {
773: if (isoaa->isoa_afi == isoab->isoa_afi) {
774: if (isoaa->isoa_afi == AFI_37)
775: return(1);
776: else
777: return (!bcmp(&isoaa->isoa_u, &isoab->isoa_u, 2));
778: }
779: return(0);
780: }
781: #endif /* notdef */
782: /*
783: * FUNCTION: iso_localifa()
784: *
785: * PURPOSE: Find an interface addresss having a given destination
786: * or at least matching the net.
787: *
788: * RETURNS: ptr to an interface address
789: *
790: * SIDE EFFECTS:
791: *
792: * NOTES:
793: */
794: struct iso_ifaddr *
795: iso_localifa(siso)
796: register struct sockaddr_iso *siso;
797: {
798: register struct iso_ifaddr *ia;
799: register char *cp1, *cp2, *cp3;
800: register struct ifnet *ifp;
801: struct iso_ifaddr *ia_maybe = 0;
802: /*
803: * We make one pass looking for both net matches and an exact
804: * dst addr.
805: */
806: for (ia = iso_ifaddr; ia; ia = ia->ia_next) {
807: if ((ifp = ia->ia_ifp) == 0 || ((ifp->if_flags & IFF_UP) == 0))
808: continue;
809: if (ifp->if_flags & IFF_POINTOPOINT) {
810: if ((ia->ia_dstaddr.siso_family == AF_ISO) &&
811: SAME_ISOADDR(&ia->ia_dstaddr, siso))
812: return (ia);
813: else
814: if (SAME_ISOADDR(&ia->ia_addr, siso))
815: ia_maybe = ia;
816: continue;
817: }
818: if (ia->ia_sockmask.siso_len) {
819: char *cplim = ia->ia_sockmask.siso_len + (char *)&ia->ia_sockmask;
820: cp1 = ia->ia_sockmask.siso_data;
821: cp2 = siso->siso_data;
822: cp3 = ia->ia_addr.siso_data;
823: while (cp1 < cplim)
824: if (*cp1++ & (*cp2++ ^ *cp3++))
825: goto next;
826: ia_maybe = ia;
827: }
828: if (SAME_ISOADDR(&ia->ia_addr, siso))
829: return ia;
830: next:;
831: }
832: return ia_maybe;
833: }
834:
835: #if TPCONS
836: #include <netiso/cons.h>
837: #endif /* TPCONS */
838: /*
839: * FUNCTION: iso_nlctloutput
840: *
841: * PURPOSE: Set options at the network level
842: *
843: * RETURNS: E*
844: *
845: * SIDE EFFECTS:
846: *
847: * NOTES: This could embody some of the functions of
848: * rclnp_ctloutput and cons_ctloutput.
849: */
850: iso_nlctloutput(cmd, optname, pcb, m)
851: int cmd; /* command:set or get */
852: int optname; /* option of interest */
853: caddr_t pcb; /* nl pcb */
854: struct mbuf *m; /* data for set, buffer for get */
855: {
856: struct isopcb *isop = (struct isopcb *)pcb;
857: int error = 0; /* return value */
858: caddr_t data; /* data for option */
859: int data_len; /* data's length */
860:
861: IFDEBUG(D_ISO)
862: printf("iso_nlctloutput: cmd %x, opt %x, pcb %x, m %x\n",
863: cmd, optname, pcb, m);
864: ENDDEBUG
865:
866: if ((cmd != PRCO_GETOPT) && (cmd != PRCO_SETOPT))
867: return(EOPNOTSUPP);
868:
869: data = mtod(m, caddr_t);
870: data_len = (m)->m_len;
871:
872: IFDEBUG(D_ISO)
873: printf("iso_nlctloutput: data is:\n");
874: dump_buf(data, data_len);
875: ENDDEBUG
876:
877: switch (optname) {
878:
879: #if TPCONS
880: case CONSOPT_X25CRUD:
881: if (cmd == PRCO_GETOPT) {
882: error = EOPNOTSUPP;
883: break;
884: }
885:
886: if (data_len > MAXX25CRUDLEN) {
887: error = EINVAL;
888: break;
889: }
890:
891: IFDEBUG(D_ISO)
892: printf("iso_nlctloutput: setting x25 crud\n");
893: ENDDEBUG
894:
895: bcopy(data, (caddr_t)isop->isop_x25crud, (unsigned)data_len);
896: isop->isop_x25crud_len = data_len;
897: break;
898: #endif /* TPCONS */
899:
900: default:
901: error = EOPNOTSUPP;
902: }
903: if (cmd == PRCO_SETOPT)
904: m_freem(m);
905: return error;
906: }
907: #endif /* ISO */
908:
909: #ifdef ARGO_DEBUG
910:
911: /*
912: * FUNCTION: dump_isoaddr
913: *
914: * PURPOSE: debugging
915: *
916: * RETURNS: nada
917: *
918: */
919: dump_isoaddr(s)
920: struct sockaddr_iso *s;
921: {
922: char *clnp_saddr_isop();
923: register int i;
924:
925: if( s->siso_family == AF_ISO) {
926: printf("ISO address: suffixlen %d, %s\n",
927: s->siso_tlen, clnp_saddr_isop(s));
928: } else if( s->siso_family == AF_INET) {
929: /* hack */
930: struct sockaddr_in *sin = (struct sockaddr_in *)s;
931:
932: printf("%d.%d.%d.%d: %d",
933: (sin->sin_addr.s_addr>>24)&0xff,
934: (sin->sin_addr.s_addr>>16)&0xff,
935: (sin->sin_addr.s_addr>>8)&0xff,
936: (sin->sin_addr.s_addr)&0xff,
937: sin->sin_port);
938: }
939: }
940:
941: #endif /* ARGO_DEBUG */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.