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