![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to iso_pcb.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_pcb.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_pcb.c 7.10 (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: /*
63: * $Header: iso_pcb.c,v 4.5 88/06/29 14:59:56 hagens Exp $
64: * $Source: /usr/argo/sys/netiso/RCS/iso_pcb.c,v $
65: *
66: * Iso address family net-layer(s) pcb stuff. NEH 1/29/87
67: */
68:
69: #ifdef ISO
70:
71: #include "param.h"
72: #include "systm.h"
73: #include "mbuf.h"
74: #include "socket.h"
75: #include "socketvar.h"
76: #include "errno.h"
77:
78: #include "argo_debug.h"
79: #include "iso.h"
80: #include "clnp.h"
81: #include "../netinet/in_systm.h"
82: #include "../net/if.h"
83: #include "../net/route.h"
84: #include "iso_pcb.h"
85: #include "iso_var.h"
86: #include "protosw.h"
87:
88: #ifdef TPCONS
89: #include "../netccitt/x25.h"
90: #include "../netccitt/pk.h"
91: #include "../netccitt/pk_var.h"
92: #endif
93:
94: #define PCBNULL (struct isopcb *)0
95: struct iso_addr zeroiso_addr = {
96: 0
97: };
98:
99:
100: /*
101: * FUNCTION: iso_pcballoc
102: *
103: * PURPOSE: creates an isopcb structure in an mbuf,
104: * with socket (so), and
105: * puts it in the queue with head (head)
106: *
107: * RETURNS: 0 if OK, ENOBUFS if can't alloc the necessary mbuf
108: */
109: int
110: iso_pcballoc(so, head)
111: struct socket *so;
112: struct isopcb *head;
113: {
114: register struct isopcb *isop;
115:
116: IFDEBUG(D_ISO)
117: printf("iso_pcballoc(so 0x%x)\n", so);
118: ENDDEBUG
119: MALLOC(isop, struct isopcb *, sizeof(*isop), M_PCB, M_NOWAIT);
120: if (isop == NULL)
121: return ENOBUFS;
122: bzero((caddr_t)isop, sizeof(*isop));
123: isop->isop_head = head;
124: isop->isop_socket = so;
125: insque(isop, head);
126: if (so)
127: so->so_pcb = (caddr_t)isop;
128: return 0;
129: }
130:
131: /*
132: * FUNCTION: iso_pcbbind
133: *
134: * PURPOSE: binds the address given in *(nam) to the socket
135: * specified by the isopcb in *(isop)
136: * If the given address is zero, it makes sure the
137: * address isn't already in use and if it's got a network
138: * portion, we look for an interface with that network
139: * address. If the address given is zero, we allocate
140: * a port and stuff it in the (nam) structure.
141: *
142: * RETURNS: errno E* or 0 if ok.
143: *
144: * SIDE EFFECTS: increments head->isop_lport if it allocates a port #
145: *
146: * NOTES:
147: */
148: #define satosiso(sa) ((struct sockaddr_iso *)(sa))
149: int
150: iso_pcbbind(isop, nam)
151: register struct isopcb *isop;
152: struct mbuf *nam;
153: {
154: register struct isopcb *head = isop->isop_head;
155: register struct sockaddr_iso *siso;
156: struct iso_ifaddr *ia;
157: union {
158: char data[2];
159: u_short s;
160: } suf;
161:
162: IFDEBUG(D_ISO)
163: printf("iso_pcbbind(isop 0x%x, nam 0x%x)\n", isop, nam);
164: ENDDEBUG
165: suf.s = 0;
166: if (iso_ifaddr == 0) /* any interfaces attached? */
167: return EADDRNOTAVAIL;
168: if (isop->isop_laddr) /* already bound */
169: return EADDRINUSE;
170: if(nam == (struct mbuf *)0) {
171: isop->isop_laddr = &isop->isop_sladdr;
172: isop->isop_sladdr.siso_len = sizeof(struct sockaddr_iso);
173: isop->isop_sladdr.siso_family = AF_ISO;
174: isop->isop_sladdr.siso_tlen = 2;
175: isop->isop_sladdr.siso_nlen = 0;
176: isop->isop_sladdr.siso_slen = 0;
177: isop->isop_sladdr.siso_plen = 0;
178: goto noname;
179: }
180: siso = mtod(nam, struct sockaddr_iso *);
181: IFDEBUG(D_ISO)
182: printf("iso_pcbbind(name len 0x%x)\n", nam->m_len);
183: printf("The address is %s\n", clnp_iso_addrp(&siso->siso_addr));
184: ENDDEBUG
185: /*
186: * We would like sort of length check but since some OSI addrs
187: * do not have fixed length, we can't really do much.
188: * The ONLY thing we can say is that an osi addr has to have
189: * at LEAST an afi and one more byte and had better fit into
190: * a struct iso_addr.
191: * However, in fact the size of the whole thing is a struct
192: * sockaddr_iso, so probably this is what we should check for.
193: */
194: if( (nam->m_len < 2) || (nam->m_len < siso->siso_len)) {
195: return ENAMETOOLONG;
196: }
197: if (siso->siso_tlen) {
198: register char *cp = TSEL(siso);
199: suf.data[0] = cp[0];
200: suf.data[1] = cp[1];
201: }
202: if (siso->siso_nlen) {
203: /* non-zero net addr- better match one of our interfaces */
204: IFDEBUG(D_ISO)
205: printf("iso_pcbbind: bind to NOT zeroisoaddr\n");
206: ENDDEBUG
207: for (ia = iso_ifaddr; ia; ia = ia->ia_next)
208: if (SAME_ISOADDR(siso, &ia->ia_addr))
209: break;
210: if (ia == 0)
211: return EADDRNOTAVAIL;
212: }
213: if (siso->siso_len <= sizeof (isop->isop_sladdr)) {
214: isop->isop_laddr = &isop->isop_sladdr;
215: } else {
216: if ((nam = m_copy(nam, 0, (int)M_COPYALL)) == 0)
217: return ENOBUFS;
218: isop->isop_laddr = mtod(nam, struct sockaddr_iso *);
219: }
220: bcopy((caddr_t)siso, (caddr_t)isop->isop_laddr, siso->siso_len);
221: if (suf.s || siso->siso_tlen != 2) {
222: if((suf.s < ISO_PORT_RESERVED) && (siso->siso_tlen <= 2) &&
223: (isop->isop_socket->so_state && SS_PRIV) == 0)
224: return EACCES;
225: if ((isop->isop_socket->so_options & SO_REUSEADDR) == 0 &&
226: iso_pcblookup(head, 0, (caddr_t)0, isop->isop_laddr))
227: return EADDRINUSE;
228: } else {
229: register char *cp;
230: noname:
231: cp = TSEL(isop->isop_laddr);
232: IFDEBUG(D_ISO)
233: printf("iso_pcbbind noname\n");
234: ENDDEBUG
235: do {
236: if (head->isop_lport++ < ISO_PORT_RESERVED ||
237: head->isop_lport > ISO_PORT_USERRESERVED)
238: head->isop_lport = ISO_PORT_RESERVED;
239: suf.s = head->isop_lport;
240: cp[0] = suf.data[0];
241: cp[1] = suf.data[1];
242: } while (iso_pcblookup(head, 0, (caddr_t)0, isop->isop_laddr));
243: }
244: IFDEBUG(D_ISO)
245: printf("iso_pcbbind returns 0, suf 0x%x\n", suf);
246: ENDDEBUG
247: return 0;
248: }
249: /*
250: * FUNCTION: iso_pcbconnect
251: *
252: * PURPOSE: Make the isopcb (isop) look like it's connected.
253: * In other words, give it the peer address given in
254: * the mbuf * (nam). Make sure such a combination
255: * of local, peer addresses doesn't already exist
256: * for this protocol. Internet mentality prevails here,
257: * wherein a src,dst pair uniquely identifies a connection.
258: * Both net address and port must be specified in argument
259: * (nam).
260: * If we don't have a local address for this socket yet,
261: * we pick one by calling iso_pcbbind().
262: *
263: * RETURNS: errno E* or 0 if ok.
264: *
265: * SIDE EFFECTS: Looks up a route, which may cause one to be left
266: * in the isopcb.
267: *
268: * NOTES:
269: */
270: int
271: iso_pcbconnect(isop, nam)
272: register struct isopcb *isop;
273: struct mbuf *nam;
274: {
275: register struct sockaddr_iso *siso = mtod(nam, struct sockaddr_iso *);
276: int local_zero, error = 0;
277: struct iso_ifaddr *ia;
278:
279: IFDEBUG(D_ISO)
280: printf("iso_pcbconnect(isop 0x%x sock 0x%x nam 0x%x",
281: isop, isop->isop_socket, nam);
282: printf("nam->m_len 0x%x), addr:\n", nam->m_len);
283: dump_isoaddr(siso);
284: ENDDEBUG
285: if (nam->m_len < siso->siso_len)
286: return EINVAL;
287: if (siso->siso_family != AF_ISO)
288: return EAFNOSUPPORT;
289: if (siso->siso_nlen == 0) {
290: if (ia = iso_ifaddr) {
291: int nlen = ia->ia_addr.siso_nlen;
292: ovbcopy(TSEL(siso), nlen + TSEL(siso),
293: siso->siso_plen + siso->siso_tlen + siso->siso_slen);
294: bcopy((caddr_t)&ia->ia_addr.siso_addr,
295: (caddr_t)&siso->siso_addr, nlen + 1);
296: /* includes siso->siso_nlen = nlen; */
297: } else
298: return EADDRNOTAVAIL;
299: }
300: /*
301: * Local zero means either not bound, or bound to a TSEL, but no
302: * particular local interface. So, if we want to send somebody
303: * we need to choose a return address.
304: */
305: local_zero =
306: ((isop->isop_laddr == 0) || (isop->isop_laddr->siso_nlen == 0));
307: if (local_zero) {
308: int flags;
309:
310: IFDEBUG(D_ISO)
311: printf("iso_pcbconnect localzero 1\n");
312: ENDDEBUG
313: /*
314: * If route is known or can be allocated now,
315: * our src addr is taken from the i/f, else punt.
316: */
317: flags = isop->isop_socket->so_options & SO_DONTROUTE;
318: if (error = clnp_route(&siso->siso_addr, &isop->isop_route, flags,
319: (struct sockaddr **)0, &ia))
320: return error;
321: IFDEBUG(D_ISO)
322: printf("iso_pcbconnect localzero 2, ro->ro_rt 0x%x",
323: isop->isop_route.ro_rt);
324: printf(" ia 0x%x\n", ia);
325: ENDDEBUG
326: }
327: IFDEBUG(D_ISO)
328: printf("in iso_pcbconnect before lookup isop 0x%x isop->sock 0x%x\n",
329: isop, isop->isop_socket);
330: ENDDEBUG
331: if (local_zero) {
332: int nlen, tlen, totlen; caddr_t oldtsel, newtsel;
333: siso = isop->isop_laddr;
334: if (siso == 0 || siso->siso_tlen == 0)
335: (void)iso_pcbbind(isop, (struct mbuf *)0);
336: /*
337: * Here we have problem of squezeing in a definite network address
338: * into an existing sockaddr_iso, which in fact may not have room
339: * for it. This gets messy.
340: */
341: siso = isop->isop_laddr;
342: oldtsel = TSEL(siso);
343: tlen = siso->siso_tlen;
344: nlen = ia->ia_addr.siso_nlen;
345: totlen = tlen + nlen + _offsetof(struct sockaddr_iso, siso_data[0]);
346: if ((siso == &isop->isop_sladdr) &&
347: (totlen > sizeof(isop->isop_sladdr))) {
348: struct mbuf *m = m_get(MT_SONAME, M_DONTWAIT);
349: if (m == 0)
350: return ENOBUFS;
351: m->m_len = totlen;
352: isop->isop_laddr = siso = mtod(m, struct sockaddr_iso *);
353: }
354: siso->siso_nlen = ia->ia_addr.siso_nlen;
355: newtsel = TSEL(siso);
356: ovbcopy(oldtsel, newtsel, tlen);
357: bcopy(ia->ia_addr.siso_data, siso->siso_data, nlen);
358: siso->siso_tlen = tlen;
359: siso->siso_family = AF_ISO;
360: siso->siso_len = totlen;
361: siso = mtod(nam, struct sockaddr_iso *);
362: }
363: IFDEBUG(D_ISO)
364: printf("in iso_pcbconnect before bcopy isop 0x%x isop->sock 0x%x\n",
365: isop, isop->isop_socket);
366: ENDDEBUG
367: /*
368: * If we had to allocate space to a previous big foreign address,
369: * and for some reason we didn't free it, we reuse it knowing
370: * that is going to be big enough, as sockaddrs are delivered in
371: * 128 byte mbufs.
372: * If the foreign address is small enough, we use default space;
373: * otherwise, we grab an mbuf to copy into.
374: */
375: if (isop->isop_faddr == 0 || isop->isop_faddr == &isop->isop_sfaddr) {
376: if (siso->siso_len <= sizeof(isop->isop_sfaddr))
377: isop->isop_faddr = &isop->isop_sfaddr;
378: else {
379: struct mbuf *m = m_get(MT_SONAME, M_DONTWAIT);
380: if (m == 0)
381: return ENOBUFS;
382: isop->isop_faddr = mtod(m, struct sockaddr_iso *);
383: }
384: }
385: bcopy((caddr_t)siso, (caddr_t)isop->isop_faddr, siso->siso_len);
386: IFDEBUG(D_ISO)
387: printf("in iso_pcbconnect after bcopy isop 0x%x isop->sock 0x%x\n",
388: isop, isop->isop_socket);
389: printf("iso_pcbconnect connected to addr:\n");
390: dump_isoaddr(isop->isop_faddr);
391: printf("iso_pcbconnect end: src addr:\n");
392: dump_isoaddr(isop->isop_laddr);
393: ENDDEBUG
394: return 0;
395: }
396:
397: /*
398: * FUNCTION: iso_pcbdisconnect()
399: *
400: * PURPOSE: washes away the peer address info so the socket
401: * appears to be disconnected.
402: * If there's no file descriptor associated with the socket
403: * it detaches the pcb.
404: *
405: * RETURNS: Nada.
406: *
407: * SIDE EFFECTS: May detach the pcb.
408: *
409: * NOTES:
410: */
411: void
412: iso_pcbdisconnect(isop)
413: struct isopcb *isop;
414: {
415: void iso_pcbdetach();
416: register struct sockaddr_iso *siso;
417:
418: IFDEBUG(D_ISO)
419: printf("iso_pcbdisconnect(isop 0x%x)\n", isop);
420: ENDDEBUG
421: /*
422: * Preserver binding infnormation if already bound.
423: */
424: if ((siso = isop->isop_laddr) && siso->siso_nlen && siso->siso_tlen) {
425: caddr_t otsel = TSEL(siso);
426: siso->siso_nlen = 0;
427: ovbcopy(otsel, TSEL(siso), siso->siso_tlen);
428: }
429: if (isop->isop_faddr && isop->isop_faddr != &isop->isop_sfaddr)
430: m_freem(dtom(isop->isop_faddr));
431: isop->isop_faddr = 0;
432: if (isop->isop_socket->so_state & SS_NOFDREF)
433: iso_pcbdetach(isop);
434: }
435:
436: /*
437: * FUNCTION: iso_pcbdetach
438: *
439: * PURPOSE: detach the pcb at *(isop) from it's socket and free
440: * the mbufs associated with the pcb..
441: * Dequeues (isop) from its head.
442: *
443: * RETURNS: Nada.
444: *
445: * SIDE EFFECTS:
446: *
447: * NOTES:
448: */
449: void
450: iso_pcbdetach(isop)
451: struct isopcb *isop;
452: {
453: struct socket *so = isop->isop_socket;
454:
455: IFDEBUG(D_ISO)
456: printf("iso_pcbdetach(isop 0x%x socket 0x%x so 0x%x)\n",
457: isop, isop->isop_socket, so);
458: ENDDEBUG
459: #ifdef TPCONS
460: if (isop->isop_refcnt) {
461: register struct pklcd *lcp = (struct pklcd *)isop->isop_chan;
462: if (--isop->isop_refcnt > 0)
463: return;
464: if (lcp && lcp->lcd_state == DATA_TRANSFER)
465: pk_disconnect(lcp);
466: isop->isop_chan = 0;
467: }
468: #endif
469: if (so) { /* in the x.25 domain, we sometimes have no socket */
470: so->so_pcb = 0;
471: sofree(so);
472: }
473: IFDEBUG(D_ISO)
474: printf("iso_pcbdetach 2 \n");
475: ENDDEBUG
476: if (isop->isop_options)
477: (void)m_free(isop->isop_options);
478: IFDEBUG(D_ISO)
479: printf("iso_pcbdetach 3 \n");
480: ENDDEBUG
481: if (isop->isop_route.ro_rt)
482: rtfree(isop->isop_route.ro_rt);
483: IFDEBUG(D_ISO)
484: printf("iso_pcbdetach 3.1\n");
485: ENDDEBUG
486: if (isop->isop_clnpcache != NULL) {
487: struct clnp_cache *clcp =
488: mtod(isop->isop_clnpcache, struct clnp_cache *);
489: IFDEBUG(D_ISO)
490: printf("iso_pcbdetach 3.2: clcp 0x%x freeing clc_hdr x%x\n",
491: clcp, clcp->clc_hdr);
492: ENDDEBUG
493: if (clcp->clc_hdr != NULL)
494: m_free(clcp->clc_hdr);
495: IFDEBUG(D_ISO)
496: printf("iso_pcbdetach 3.3: freeing cache x%x\n",
497: isop->isop_clnpcache);
498: ENDDEBUG
499: m_free(isop->isop_clnpcache);
500: }
501: IFDEBUG(D_ISO)
502: printf("iso_pcbdetach 4 \n");
503: ENDDEBUG
504: remque(isop);
505: IFDEBUG(D_ISO)
506: printf("iso_pcbdetach 5 \n");
507: ENDDEBUG
508: if (isop->isop_laddr && (isop->isop_laddr != &isop->isop_sladdr))
509: m_freem(dtom(isop->isop_laddr));
510: free((caddr_t)isop, M_PCB);
511: }
512:
513:
514: /*
515: * FUNCTION: iso_pcbnotify
516: *
517: * PURPOSE: notify all connections in this protocol's queue (head)
518: * that have peer address (dst) of the problem (errno)
519: * by calling (notify) on the connections' isopcbs.
520: *
521: * RETURNS: Rien.
522: *
523: * SIDE EFFECTS:
524: *
525: * NOTES: (notify) is called at splimp!
526: */
527: void
528: iso_pcbnotify(head, siso, errno, notify)
529: struct isopcb *head;
530: register struct sockaddr_iso *siso;
531: int errno, (*notify)();
532: {
533: register struct isopcb *isop;
534: int s = splimp();
535:
536: IFDEBUG(D_ISO)
537: printf("iso_pcbnotify(head 0x%x, notify 0x%x) dst:\n", head, notify);
538: ENDDEBUG
539: for (isop = head->isop_next; isop != head; isop = isop->isop_next) {
540: if (isop->isop_socket == 0 || isop->isop_faddr == 0 ||
541: !SAME_ISOADDR(siso, isop->isop_faddr)) {
542: IFDEBUG(D_ISO)
543: printf("iso_pcbnotify: CONTINUE isop 0x%x, sock 0x%x\n" ,
544: isop, isop->isop_socket);
545: printf("addrmatch cmp'd with (0x%x):\n", isop->isop_faddr);
546: dump_isoaddr(isop->isop_faddr);
547: ENDDEBUG
548: continue;
549: }
550: if (errno)
551: isop->isop_socket->so_error = errno;
552: if (notify)
553: (*notify)(isop);
554: }
555: splx(s);
556: IFDEBUG(D_ISO)
557: printf("END OF iso_pcbnotify\n" );
558: ENDDEBUG
559: }
560:
561:
562: /*
563: * FUNCTION: iso_pcblookup
564: *
565: * PURPOSE: looks for a given combination of (faddr), (fport),
566: * (lport), (laddr) in the queue named by (head).
567: * Argument (flags) is ignored.
568: *
569: * RETURNS: ptr to the isopcb if it finds a connection matching
570: * these arguments, o.w. returns zero.
571: *
572: * SIDE EFFECTS:
573: *
574: * NOTES:
575: */
576: struct isopcb *
577: iso_pcblookup(head, fportlen, fport, laddr)
578: struct isopcb *head;
579: register struct sockaddr_iso *laddr;
580: caddr_t fport;
581: int fportlen;
582: {
583: register struct isopcb *isop;
584: register caddr_t lp = TSEL(laddr);
585: unsigned int llen = laddr->siso_tlen;
586:
587: IFDEBUG(D_ISO)
588: printf("iso_pcblookup(head 0x%x laddr 0x%x fport 0x%x)\n",
589: head, laddr, fport);
590: ENDDEBUG
591: for (isop = head->isop_next; isop != head; isop = isop->isop_next) {
592: if (isop->isop_laddr == 0 || isop->isop_laddr == laddr)
593: continue;
594: if (isop->isop_laddr->siso_tlen != llen)
595: continue;
596: if (bcmp(lp, TSEL(isop->isop_laddr), llen))
597: continue;
598: if (fportlen && isop->isop_faddr &&
599: bcmp(fport, TSEL(isop->isop_faddr), (unsigned)fportlen))
600: continue;
601: /* PHASE2
602: * addrmatch1 should be iso_addrmatch(a, b, mask)
603: * where mask is taken from isop->isop_laddrmask (new field)
604: * isop_lnetmask will also be available in isop
605: if (laddr != &zeroiso_addr &&
606: !iso_addrmatch1(laddr, &(isop->isop_laddr.siso_addr)))
607: continue;
608: */
609: if (laddr->siso_nlen && (!SAME_ISOADDR(laddr, isop->isop_laddr)))
610: continue;
611: return (isop);
612: }
613: return (struct isopcb *)0;
614: }
615: #endif ISO
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.