![[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 [Apple XNU] / XNU / bsd / netiso|
Return to iso_pcb.c CVS log | Up to [Apple XNU] / XNU / bsd / netiso |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*-
23: * Copyright (c) 1991, 1993
24: * The Regents of the University of California. All rights reserved.
25: *
26: * Redistribution and use in source and binary forms, with or without
27: * modification, are permitted provided that the following conditions
28: * are met:
29: * 1. Redistributions of source code must retain the above copyright
30: * notice, this list of conditions and the following disclaimer.
31: * 2. Redistributions in binary form must reproduce the above copyright
32: * notice, this list of conditions and the following disclaimer in the
33: * documentation and/or other materials provided with the distribution.
34: * 3. All advertising materials mentioning features or use of this software
35: * must display the following acknowledgement:
36: * This product includes software developed by the University of
37: * California, Berkeley and its contributors.
38: * 4. Neither the name of the University nor the names of its contributors
39: * may be used to endorse or promote products derived from this software
40: * without specific prior written permission.
41: *
42: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
43: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
44: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
45: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
46: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
47: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
48: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
49: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
50: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
51: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
52: * SUCH DAMAGE.
53: *
54: * @(#)iso_pcb.c 8.1 (Berkeley) 6/10/93
55: */
56:
57: /***********************************************************
58: Copyright IBM Corporation 1987
59:
60: All Rights Reserved
61:
62: Permission to use, copy, modify, and distribute this software and its
63: documentation for any purpose and without fee is hereby granted,
64: provided that the above copyright notice appear in all copies and that
65: both that copyright notice and this permission notice appear in
66: supporting documentation, and that the name of IBM not be
67: used in advertising or publicity pertaining to distribution of the
68: software without specific, written prior permission.
69:
70: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
71: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
72: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
73: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
74: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
75: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
76: SOFTWARE.
77:
78: ******************************************************************/
79:
80: /*
81: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison
82: */
83: /*
84: * Iso address family net-layer(s) pcb stuff. NEH 1/29/87
85: */
86:
87: #if ISO
88:
89: #include <sys/param.h>
90: #include <sys/systm.h>
91: #include <sys/mbuf.h>
92: #include <sys/socket.h>
93: #include <sys/socketvar.h>
94: #include <sys/errno.h>
95:
96: #include <netiso/argo_debug.h>
97: #include <netiso/iso.h>
98: #include <netiso/clnp.h>
99: #include <netinet/in_systm.h>
100: #include <net/if.h>
101: #include <net/route.h>
102: #include <netiso/iso_pcb.h>
103: #include <netiso/iso_var.h>
104: #include <sys/protosw.h>
105:
106: #if TPCONS
107: #include <netccitt/x25.h>
108: #include <netccitt/pk.h>
109: #include <netccitt/pk_var.h>
110: #endif
111:
112: #define PCBNULL (struct isopcb *)0
113: struct iso_addr zeroiso_addr = {
114: 0
115: };
116:
117:
118: /*
119: * FUNCTION: iso_pcballoc
120: *
121: * PURPOSE: creates an isopcb structure in an mbuf,
122: * with socket (so), and
123: * puts it in the queue with head (head)
124: *
125: * RETURNS: 0 if OK, ENOBUFS if can't alloc the necessary mbuf
126: */
127: int
128: iso_pcballoc(so, head)
129: struct socket *so;
130: struct isopcb *head;
131: {
132: register struct isopcb *isop;
133:
134: IFDEBUG(D_ISO)
135: printf("iso_pcballoc(so 0x%x)\n", so);
136: ENDDEBUG
137: MALLOC(isop, struct isopcb *, sizeof(*isop), M_PCB, M_NOWAIT);
138: if (isop == NULL)
139: return ENOBUFS;
140: bzero((caddr_t)isop, sizeof(*isop));
141: isop->isop_head = head;
142: isop->isop_socket = so;
143: insque(isop, head);
144: if (so)
145: so->so_pcb = (caddr_t)isop;
146: return 0;
147: }
148:
149: /*
150: * FUNCTION: iso_pcbbind
151: *
152: * PURPOSE: binds the address given in *(nam) to the socket
153: * specified by the isopcb in *(isop)
154: * If the given address is zero, it makes sure the
155: * address isn't already in use and if it's got a network
156: * portion, we look for an interface with that network
157: * address. If the address given is zero, we allocate
158: * a port and stuff it in the (nam) structure.
159: *
160: * RETURNS: errno E* or 0 if ok.
161: *
162: * SIDE EFFECTS: increments head->isop_lport if it allocates a port #
163: *
164: * NOTES:
165: */
166: #define satosiso(sa) ((struct sockaddr_iso *)(sa))
167: int
168: iso_pcbbind(isop, nam)
169: register struct isopcb *isop;
170: struct mbuf *nam;
171: {
172: register struct isopcb *head = isop->isop_head;
173: register struct sockaddr_iso *siso;
174: struct iso_ifaddr *ia;
175: union {
176: char data[2];
177: u_short s;
178: } suf;
179:
180: IFDEBUG(D_ISO)
181: printf("iso_pcbbind(isop 0x%x, nam 0x%x)\n", isop, nam);
182: ENDDEBUG
183: suf.s = 0;
184: if (iso_ifaddr == 0) /* any interfaces attached? */
185: return EADDRNOTAVAIL;
186: if (isop->isop_laddr) /* already bound */
187: return EADDRINUSE;
188: if(nam == (struct mbuf *)0) {
189: isop->isop_laddr = &isop->isop_sladdr;
190: isop->isop_sladdr.siso_len = sizeof(struct sockaddr_iso);
191: isop->isop_sladdr.siso_family = AF_ISO;
192: isop->isop_sladdr.siso_tlen = 2;
193: isop->isop_sladdr.siso_nlen = 0;
194: isop->isop_sladdr.siso_slen = 0;
195: isop->isop_sladdr.siso_plen = 0;
196: goto noname;
197: }
198: siso = mtod(nam, struct sockaddr_iso *);
199: IFDEBUG(D_ISO)
200: printf("iso_pcbbind(name len 0x%x)\n", nam->m_len);
201: printf("The address is %s\n", clnp_iso_addrp(&siso->siso_addr));
202: ENDDEBUG
203: /*
204: * We would like sort of length check but since some OSI addrs
205: * do not have fixed length, we can't really do much.
206: * The ONLY thing we can say is that an osi addr has to have
207: * at LEAST an afi and one more byte and had better fit into
208: * a struct iso_addr.
209: * However, in fact the size of the whole thing is a struct
210: * sockaddr_iso, so probably this is what we should check for.
211: */
212: if( (nam->m_len < 2) || (nam->m_len < siso->siso_len)) {
213: return ENAMETOOLONG;
214: }
215: if (siso->siso_nlen) {
216: /* non-zero net addr- better match one of our interfaces */
217: IFDEBUG(D_ISO)
218: printf("iso_pcbbind: bind to NOT zeroisoaddr\n");
219: ENDDEBUG
220: for (ia = iso_ifaddr; ia; ia = ia->ia_next)
221: if (SAME_ISOADDR(siso, &ia->ia_addr))
222: break;
223: if (ia == 0)
224: return EADDRNOTAVAIL;
225: }
226: if (siso->siso_len <= sizeof (isop->isop_sladdr)) {
227: isop->isop_laddr = &isop->isop_sladdr;
228: } else {
229: if ((nam = m_copy(nam, 0, (int)M_COPYALL)) == 0)
230: return ENOBUFS;
231: isop->isop_laddr = mtod(nam, struct sockaddr_iso *);
232: }
233: bcopy((caddr_t)siso, (caddr_t)isop->isop_laddr, siso->siso_len);
234: if (siso->siso_tlen == 0)
235: goto noname;
236: if ((isop->isop_socket->so_options & SO_REUSEADDR) == 0 &&
237: iso_pcblookup(head, 0, (caddr_t)0, isop->isop_laddr))
238: return EADDRINUSE;
239: if (siso->siso_tlen <= 2) {
240: bcopy(TSEL(siso), suf.data, sizeof(suf.data));
241: suf.s = ntohs(suf.s);
242: if((suf.s < ISO_PORT_RESERVED) &&
243: (isop->isop_socket->so_state && SS_PRIV) == 0)
244: return EACCES;
245: } else {
246: register char *cp;
247: noname:
248: cp = TSEL(isop->isop_laddr);
249: IFDEBUG(D_ISO)
250: printf("iso_pcbbind noname\n");
251: ENDDEBUG
252: do {
253: if (head->isop_lport++ < ISO_PORT_RESERVED ||
254: head->isop_lport > ISO_PORT_USERRESERVED)
255: head->isop_lport = ISO_PORT_RESERVED;
256: suf.s = htons(head->isop_lport);
257: cp[0] = suf.data[0];
258: cp[1] = suf.data[1];
259: } while (iso_pcblookup(head, 0, (caddr_t)0, isop->isop_laddr));
260: }
261: IFDEBUG(D_ISO)
262: printf("iso_pcbbind returns 0, suf 0x%x\n", suf);
263: ENDDEBUG
264: return 0;
265: }
266: /*
267: * FUNCTION: iso_pcbconnect
268: *
269: * PURPOSE: Make the isopcb (isop) look like it's connected.
270: * In other words, give it the peer address given in
271: * the mbuf * (nam). Make sure such a combination
272: * of local, peer addresses doesn't already exist
273: * for this protocol. Internet mentality prevails here,
274: * wherein a src,dst pair uniquely identifies a connection.
275: * Both net address and port must be specified in argument
276: * (nam).
277: * If we don't have a local address for this socket yet,
278: * we pick one by calling iso_pcbbind().
279: *
280: * RETURNS: errno E* or 0 if ok.
281: *
282: * SIDE EFFECTS: Looks up a route, which may cause one to be left
283: * in the isopcb.
284: *
285: * NOTES:
286: */
287: int
288: iso_pcbconnect(isop, nam)
289: register struct isopcb *isop;
290: struct mbuf *nam;
291: {
292: register struct sockaddr_iso *siso = mtod(nam, struct sockaddr_iso *);
293: int local_zero, error = 0;
294: struct iso_ifaddr *ia;
295:
296: IFDEBUG(D_ISO)
297: printf("iso_pcbconnect(isop 0x%x sock 0x%x nam 0x%x",
298: isop, isop->isop_socket, nam);
299: printf("nam->m_len 0x%x), addr:\n", nam->m_len);
300: dump_isoaddr(siso);
301: ENDDEBUG
302: if (nam->m_len < siso->siso_len)
303: return EINVAL;
304: if (siso->siso_family != AF_ISO)
305: return EAFNOSUPPORT;
306: if (siso->siso_nlen == 0) {
307: if (ia = iso_ifaddr) {
308: int nlen = ia->ia_addr.siso_nlen;
309: ovbcopy(TSEL(siso), nlen + TSEL(siso),
310: siso->siso_plen + siso->siso_tlen + siso->siso_slen);
311: bcopy((caddr_t)&ia->ia_addr.siso_addr,
312: (caddr_t)&siso->siso_addr, nlen + 1);
313: /* includes siso->siso_nlen = nlen; */
314: } else
315: return EADDRNOTAVAIL;
316: }
317: /*
318: * Local zero means either not bound, or bound to a TSEL, but no
319: * particular local interface. So, if we want to send somebody
320: * we need to choose a return address.
321: */
322: local_zero =
323: ((isop->isop_laddr == 0) || (isop->isop_laddr->siso_nlen == 0));
324: if (local_zero) {
325: int flags;
326:
327: IFDEBUG(D_ISO)
328: printf("iso_pcbconnect localzero 1\n");
329: ENDDEBUG
330: /*
331: * If route is known or can be allocated now,
332: * our src addr is taken from the i/f, else punt.
333: */
334: flags = isop->isop_socket->so_options & SO_DONTROUTE;
335: if (error = clnp_route(&siso->siso_addr, &isop->isop_route, flags,
336: (struct sockaddr **)0, &ia))
337: return error;
338: IFDEBUG(D_ISO)
339: printf("iso_pcbconnect localzero 2, ro->ro_rt 0x%x",
340: isop->isop_route.ro_rt);
341: printf(" ia 0x%x\n", ia);
342: ENDDEBUG
343: }
344: IFDEBUG(D_ISO)
345: printf("in iso_pcbconnect before lookup isop 0x%x isop->sock 0x%x\n",
346: isop, isop->isop_socket);
347: ENDDEBUG
348: if (local_zero) {
349: int nlen, tlen, totlen; caddr_t oldtsel, newtsel;
350: siso = isop->isop_laddr;
351: if (siso == 0 || siso->siso_tlen == 0)
352: (void)iso_pcbbind(isop, (struct mbuf *)0);
353: /*
354: * Here we have problem of squezeing in a definite network address
355: * into an existing sockaddr_iso, which in fact may not have room
356: * for it. This gets messy.
357: */
358: siso = isop->isop_laddr;
359: oldtsel = TSEL(siso);
360: tlen = siso->siso_tlen;
361: nlen = ia->ia_addr.siso_nlen;
362: totlen = tlen + nlen + _offsetof(struct sockaddr_iso, siso_data[0]);
363: if ((siso == &isop->isop_sladdr) &&
364: (totlen > sizeof(isop->isop_sladdr))) {
365: struct mbuf *m = m_get(MT_SONAME, M_DONTWAIT);
366: if (m == 0)
367: return ENOBUFS;
368: m->m_len = totlen;
369: isop->isop_laddr = siso = mtod(m, struct sockaddr_iso *);
370: }
371: siso->siso_nlen = ia->ia_addr.siso_nlen;
372: newtsel = TSEL(siso);
373: ovbcopy(oldtsel, newtsel, tlen);
374: bcopy(ia->ia_addr.siso_data, siso->siso_data, nlen);
375: siso->siso_tlen = tlen;
376: siso->siso_family = AF_ISO;
377: siso->siso_len = totlen;
378: siso = mtod(nam, struct sockaddr_iso *);
379: }
380: IFDEBUG(D_ISO)
381: printf("in iso_pcbconnect before bcopy isop 0x%x isop->sock 0x%x\n",
382: isop, isop->isop_socket);
383: ENDDEBUG
384: /*
385: * If we had to allocate space to a previous big foreign address,
386: * and for some reason we didn't free it, we reuse it knowing
387: * that is going to be big enough, as sockaddrs are delivered in
388: * 128 byte mbufs.
389: * If the foreign address is small enough, we use default space;
390: * otherwise, we grab an mbuf to copy into.
391: */
392: if (isop->isop_faddr == 0 || isop->isop_faddr == &isop->isop_sfaddr) {
393: if (siso->siso_len <= sizeof(isop->isop_sfaddr))
394: isop->isop_faddr = &isop->isop_sfaddr;
395: else {
396: struct mbuf *m = m_get(MT_SONAME, M_DONTWAIT);
397: if (m == 0)
398: return ENOBUFS;
399: isop->isop_faddr = mtod(m, struct sockaddr_iso *);
400: }
401: }
402: bcopy((caddr_t)siso, (caddr_t)isop->isop_faddr, siso->siso_len);
403: IFDEBUG(D_ISO)
404: printf("in iso_pcbconnect after bcopy isop 0x%x isop->sock 0x%x\n",
405: isop, isop->isop_socket);
406: printf("iso_pcbconnect connected to addr:\n");
407: dump_isoaddr(isop->isop_faddr);
408: printf("iso_pcbconnect end: src addr:\n");
409: dump_isoaddr(isop->isop_laddr);
410: ENDDEBUG
411: return 0;
412: }
413:
414: /*
415: * FUNCTION: iso_pcbdisconnect()
416: *
417: * PURPOSE: washes away the peer address info so the socket
418: * appears to be disconnected.
419: * If there's no file descriptor associated with the socket
420: * it detaches the pcb.
421: *
422: * RETURNS: Nada.
423: *
424: * SIDE EFFECTS: May detach the pcb.
425: *
426: * NOTES:
427: */
428: void
429: iso_pcbdisconnect(isop)
430: struct isopcb *isop;
431: {
432: void iso_pcbdetach();
433: register struct sockaddr_iso *siso;
434:
435: IFDEBUG(D_ISO)
436: printf("iso_pcbdisconnect(isop 0x%x)\n", isop);
437: ENDDEBUG
438: /*
439: * Preserver binding infnormation if already bound.
440: */
441: if ((siso = isop->isop_laddr) && siso->siso_nlen && siso->siso_tlen) {
442: caddr_t otsel = TSEL(siso);
443: siso->siso_nlen = 0;
444: ovbcopy(otsel, TSEL(siso), siso->siso_tlen);
445: }
446: if (isop->isop_faddr && isop->isop_faddr != &isop->isop_sfaddr)
447: m_freem(dtom(isop->isop_faddr));
448: isop->isop_faddr = 0;
449: if (isop->isop_socket->so_state & SS_NOFDREF)
450: iso_pcbdetach(isop);
451: }
452:
453: /*
454: * FUNCTION: iso_pcbdetach
455: *
456: * PURPOSE: detach the pcb at *(isop) from it's socket and free
457: * the mbufs associated with the pcb..
458: * Dequeues (isop) from its head.
459: *
460: * RETURNS: Nada.
461: *
462: * SIDE EFFECTS:
463: *
464: * NOTES:
465: */
466: void
467: iso_pcbdetach(isop)
468: struct isopcb *isop;
469: {
470: struct socket *so = isop->isop_socket;
471:
472: IFDEBUG(D_ISO)
473: printf("iso_pcbdetach(isop 0x%x socket 0x%x so 0x%x)\n",
474: isop, isop->isop_socket, so);
475: ENDDEBUG
476: #if TPCONS
477: if (isop->isop_chan) {
478: register struct pklcd *lcp = (struct pklcd *)isop->isop_chan;
479: if (--isop->isop_refcnt > 0)
480: return;
481: if (lcp && lcp->lcd_state == DATA_TRANSFER) {
482: lcp->lcd_upper = 0;
483: lcp->lcd_upnext = 0;
484: pk_disconnect(lcp);
485: }
486: isop->isop_chan = 0;
487: }
488: #endif
489: if (so) { /* in the x.25 domain, we sometimes have no socket */
490: so->so_pcb = 0;
491: sofree(so);
492: }
493: IFDEBUG(D_ISO)
494: printf("iso_pcbdetach 2 \n");
495: ENDDEBUG
496: if (isop->isop_options)
497: (void)m_free(isop->isop_options);
498: IFDEBUG(D_ISO)
499: printf("iso_pcbdetach 3 \n");
500: ENDDEBUG
501: if (isop->isop_route.ro_rt)
502: rtfree(isop->isop_route.ro_rt);
503: IFDEBUG(D_ISO)
504: printf("iso_pcbdetach 3.1\n");
505: ENDDEBUG
506: if (isop->isop_clnpcache != NULL) {
507: struct clnp_cache *clcp =
508: mtod(isop->isop_clnpcache, struct clnp_cache *);
509: IFDEBUG(D_ISO)
510: printf("iso_pcbdetach 3.2: clcp 0x%x freeing clc_hdr x%x\n",
511: clcp, clcp->clc_hdr);
512: ENDDEBUG
513: if (clcp->clc_hdr != NULL)
514: m_free(clcp->clc_hdr);
515: IFDEBUG(D_ISO)
516: printf("iso_pcbdetach 3.3: freeing cache x%x\n",
517: isop->isop_clnpcache);
518: ENDDEBUG
519: m_free(isop->isop_clnpcache);
520: }
521: IFDEBUG(D_ISO)
522: printf("iso_pcbdetach 4 \n");
523: ENDDEBUG
524: remque(isop);
525: IFDEBUG(D_ISO)
526: printf("iso_pcbdetach 5 \n");
527: ENDDEBUG
528: if (isop->isop_laddr && (isop->isop_laddr != &isop->isop_sladdr))
529: m_freem(dtom(isop->isop_laddr));
530: FREE((caddr_t)isop, M_PCB);
531: }
532:
533:
534: /*
535: * FUNCTION: iso_pcbnotify
536: *
537: * PURPOSE: notify all connections in this protocol's queue (head)
538: * that have peer address (dst) of the problem (errno)
539: * by calling (notify) on the connections' isopcbs.
540: *
541: * RETURNS: Rien.
542: *
543: * SIDE EFFECTS:
544: *
545: * NOTES: (notify) is called at splimp!
546: */
547: void
548: iso_pcbnotify(head, siso, errno, notify)
549: struct isopcb *head;
550: register struct sockaddr_iso *siso;
551: int errno, (*notify)();
552: {
553: register struct isopcb *isop;
554: int s = splimp();
555:
556: IFDEBUG(D_ISO)
557: printf("iso_pcbnotify(head 0x%x, notify 0x%x) dst:\n", head, notify);
558: ENDDEBUG
559: for (isop = head->isop_next; isop != head; isop = isop->isop_next) {
560: if (isop->isop_socket == 0 || isop->isop_faddr == 0 ||
561: !SAME_ISOADDR(siso, isop->isop_faddr)) {
562: IFDEBUG(D_ISO)
563: printf("iso_pcbnotify: CONTINUE isop 0x%x, sock 0x%x\n" ,
564: isop, isop->isop_socket);
565: printf("addrmatch cmp'd with (0x%x):\n", isop->isop_faddr);
566: dump_isoaddr(isop->isop_faddr);
567: ENDDEBUG
568: continue;
569: }
570: if (errno)
571: isop->isop_socket->so_error = errno;
572: if (notify)
573: (*notify)(isop);
574: }
575: splx(s);
576: IFDEBUG(D_ISO)
577: printf("END OF iso_pcbnotify\n" );
578: ENDDEBUG
579: }
580:
581:
582: /*
583: * FUNCTION: iso_pcblookup
584: *
585: * PURPOSE: looks for a given combination of (faddr), (fport),
586: * (lport), (laddr) in the queue named by (head).
587: * Argument (flags) is ignored.
588: *
589: * RETURNS: ptr to the isopcb if it finds a connection matching
590: * these arguments, o.w. returns zero.
591: *
592: * SIDE EFFECTS:
593: *
594: * NOTES:
595: */
596: struct isopcb *
597: iso_pcblookup(head, fportlen, fport, laddr)
598: struct isopcb *head;
599: register struct sockaddr_iso *laddr;
600: caddr_t fport;
601: int fportlen;
602: {
603: register struct isopcb *isop;
604: register caddr_t lp = TSEL(laddr);
605: unsigned int llen = laddr->siso_tlen;
606:
607: IFDEBUG(D_ISO)
608: printf("iso_pcblookup(head 0x%x laddr 0x%x fport 0x%x)\n",
609: head, laddr, fport);
610: ENDDEBUG
611: for (isop = head->isop_next; isop != head; isop = isop->isop_next) {
612: if (isop->isop_laddr == 0 || isop->isop_laddr == laddr)
613: continue;
614: if (isop->isop_laddr->siso_tlen != llen)
615: continue;
616: if (bcmp(lp, TSEL(isop->isop_laddr), llen))
617: continue;
618: if (fportlen && isop->isop_faddr &&
619: bcmp(fport, TSEL(isop->isop_faddr), (unsigned)fportlen))
620: continue;
621: /* PHASE2
622: * addrmatch1 should be iso_addrmatch(a, b, mask)
623: * where mask is taken from isop->isop_laddrmask (new field)
624: * isop_lnetmask will also be available in isop
625: if (laddr != &zeroiso_addr &&
626: !iso_addrmatch1(laddr, &(isop->isop_laddr.siso_addr)))
627: continue;
628: */
629: if (laddr->siso_nlen && (!SAME_ISOADDR(laddr, isop->isop_laddr)))
630: continue;
631: return (isop);
632: }
633: return (struct isopcb *)0;
634: }
635: #endif /* ISO */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.