![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_x25subr.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 / netccitt|
Return to if_x25subr.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netccitt |
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) 1990, 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: * @(#)if_x25subr.c 8.1 (Berkeley) 6/10/93 ! 58: */ ! 59: ! 60: #include <sys/param.h> ! 61: #include <sys/systm.h> ! 62: #include <sys/malloc.h> ! 63: #include <sys/mbuf.h> ! 64: #include <sys/protosw.h> ! 65: #include <sys/socket.h> ! 66: #include <sys/socketvar.h> ! 67: #include <sys/ioctl.h> ! 68: #include <sys/errno.h> ! 69: #include <sys/syslog.h> ! 70: ! 71: #include <net/if.h> ! 72: #include <net/if_types.h> ! 73: #include <net/netisr.h> ! 74: #include <net/route.h> ! 75: ! 76: #include <netccitt/x25.h> ! 77: #include <netccitt/x25err.h> ! 78: #include <netccitt/pk.h> ! 79: #include <netccitt/pk_var.h> ! 80: ! 81: #if INET ! 82: #include <netinet/in.h> ! 83: #include <netinet/in_var.h> ! 84: #endif ! 85: ! 86: #if NS ! 87: #include <netns/ns.h> ! 88: #include <netns/ns_if.h> ! 89: #endif ! 90: ! 91: #if ISO ! 92: int tp_incoming(); ! 93: #include <netiso/argo_debug.h> ! 94: #include <netiso/iso.h> ! 95: #include <netiso/iso_var.h> ! 96: #endif ! 97: ! 98: extern struct ifnet loif; ! 99: struct llinfo_x25 llinfo_x25 = {&llinfo_x25, &llinfo_x25}; ! 100: #ifndef _offsetof ! 101: #define _offsetof(t, m) ((int)((caddr_t)&((t *)0)->m)) ! 102: #endif ! 103: struct sockaddr *x25_dgram_sockmask; ! 104: struct sockaddr_x25 x25_dgmask = { ! 105: _offsetof(struct sockaddr_x25, x25_udata[1]), /* _len */ ! 106: 0, /* _family */ ! 107: 0, /* _net */ ! 108: { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, /* _addr */ ! 109: {0}, /* opts */ ! 110: -1, /* _udlen */ ! 111: {-1} /* _udata */ ! 112: }; ! 113: ! 114: struct if_x25stats { ! 115: int ifx_wrongplen; ! 116: int ifx_nophdr; ! 117: } if_x25stats; ! 118: int x25_autoconnect = 0; ! 119: ! 120: #define senderr(x) {error = x; goto bad;} ! 121: /* ! 122: * Ancillary routines ! 123: */ ! 124: static struct llinfo_x25 * ! 125: x25_lxalloc(rt) ! 126: register struct rtentry *rt; ! 127: { ! 128: register struct llinfo_x25 *lx; ! 129: register struct sockaddr *dst = rt_key(rt); ! 130: register struct ifaddr *ifa; ! 131: ! 132: MALLOC(lx, struct llinfo_x25 *, sizeof (*lx), M_PCB, M_NOWAIT); ! 133: if (lx == 0) ! 134: return lx; ! 135: Bzero(lx, sizeof(*lx)); ! 136: lx->lx_rt = rt; ! 137: lx->lx_family = dst->sa_family; ! 138: rt->rt_refcnt++; ! 139: if (rt->rt_llinfo) ! 140: insque(lx, (struct llinfo_x25 *)rt->rt_llinfo); ! 141: else { ! 142: rt->rt_llinfo = (caddr_t)lx; ! 143: insque(lx, &llinfo_x25); ! 144: } ! 145: for (ifa = rt->rt_ifp->if_addrlist; ifa; ifa = ifa->ifa_next) { ! 146: if (ifa->ifa_addr->sa_family == AF_CCITT) ! 147: lx->lx_ia = (struct x25_ifaddr *)ifa; ! 148: } ! 149: return lx; ! 150: } ! 151: x25_lxfree(lx) ! 152: register struct llinfo_x25 *lx; ! 153: { ! 154: register struct rtentry *rt = lx->lx_rt; ! 155: register struct pklcd *lcp = lx->lx_lcd; ! 156: ! 157: if (lcp) { ! 158: lcp->lcd_upper = 0; ! 159: pk_disconnect(lcp); ! 160: } ! 161: if ((rt->rt_llinfo == (caddr_t)lx) && (lx->lx_next->lx_rt == rt)) ! 162: rt->rt_llinfo = (caddr_t)lx->lx_next; ! 163: else ! 164: rt->rt_llinfo = 0; ! 165: RTFREE(rt); ! 166: remque(lx); ! 167: FREE(lx, M_PCB); ! 168: } ! 169: /* ! 170: * Process a x25 packet as datagram; ! 171: */ ! 172: x25_ifinput(lcp, m) ! 173: struct pklcd *lcp; ! 174: register struct mbuf *m; ! 175: { ! 176: struct llinfo_x25 *lx = (struct llinfo_x25 *)lcp->lcd_upnext; ! 177: register struct ifnet *ifp; ! 178: struct ifqueue *inq; ! 179: extern struct timeval time; ! 180: int s, len, isr; ! 181: ! 182: if (m == 0 || lcp->lcd_state != DATA_TRANSFER) { ! 183: x25_connect_callback(lcp, 0); ! 184: return; ! 185: } ! 186: pk_flowcontrol(lcp, 0, 1); /* Generate RR */ ! 187: ifp = m->m_pkthdr.rcvif; ! 188: ifp->if_lastchange = time; ! 189: switch (m->m_type) { ! 190: default: ! 191: if (m) ! 192: m_freem(m); ! 193: return; ! 194: ! 195: case MT_DATA: ! 196: /* FALLTHROUGH */; ! 197: } ! 198: switch (lx->lx_family) { ! 199: #if INET ! 200: case AF_INET: ! 201: isr = NETISR_IP; ! 202: inq = &ipintrq; ! 203: break; ! 204: ! 205: #endif ! 206: #if NS ! 207: case AF_NS: ! 208: isr = NETISR_NS; ! 209: inq = &nsintrq; ! 210: break; ! 211: ! 212: #endif ! 213: #if ISO ! 214: case AF_ISO: ! 215: isr = NETISR_ISO; ! 216: inq = &clnlintrq; ! 217: break; ! 218: #endif ! 219: default: ! 220: m_freem(m); ! 221: ifp->if_noproto++; ! 222: return; ! 223: } ! 224: s = splimp(); ! 225: schednetisr(isr); ! 226: if (IF_QFULL(inq)) { ! 227: IF_DROP(inq); ! 228: m_freem(m); ! 229: } else { ! 230: IF_ENQUEUE(inq, m); ! 231: ifp->if_ibytes += m->m_pkthdr.len; ! 232: } ! 233: splx(s); ! 234: } ! 235: x25_connect_callback(lcp, m) ! 236: register struct pklcd *lcp; ! 237: register struct mbuf *m; ! 238: { ! 239: register struct llinfo_x25 *lx = (struct llinfo_x25 *)lcp->lcd_upnext; ! 240: int do_clear = 1; ! 241: if (m == 0) ! 242: goto refused; ! 243: if (m->m_type != MT_CONTROL) { ! 244: printf("x25_connect_callback: should panic\n"); ! 245: goto refused; ! 246: } ! 247: switch (pk_decode(mtod(m, struct x25_packet *))) { ! 248: case CALL_ACCEPTED: ! 249: lcp->lcd_upper = x25_ifinput; ! 250: if (lcp->lcd_sb.sb_mb) ! 251: lcp->lcd_send(lcp); /* XXX start queued packets */ ! 252: return; ! 253: default: ! 254: do_clear = 0; ! 255: refused: ! 256: lcp->lcd_upper = 0; ! 257: lx->lx_lcd = 0; ! 258: if (do_clear) ! 259: pk_disconnect(lcp); ! 260: return; ! 261: } ! 262: } ! 263: #define SA(p) ((struct sockaddr *)(p)) ! 264: #define RT(p) ((struct rtentry *)(p)) ! 265: ! 266: x25_dgram_incoming(lcp, m0) ! 267: register struct pklcd *lcp; ! 268: struct mbuf *m0; ! 269: { ! 270: register struct rtentry *rt, *nrt; ! 271: register struct mbuf *m = m0->m_next; /* m0 has calling sockaddr_x25 */ ! 272: void x25_rtrequest(); ! 273: ! 274: rt = rtalloc1(SA(&lcp->lcd_faddr), 0); ! 275: if (rt == 0) { ! 276: refuse: lcp->lcd_upper = 0; ! 277: pk_close(lcp); ! 278: return; ! 279: } ! 280: rt->rt_refcnt--; ! 281: if ((nrt = RT(rt->rt_llinfo)) == 0 || rt_mask(rt) != x25_dgram_sockmask) ! 282: goto refuse; ! 283: if ((nrt->rt_flags & RTF_UP) == 0) { ! 284: rt->rt_llinfo = (caddr_t)rtalloc1(rt->rt_gateway, 0); ! 285: rtfree(nrt); ! 286: if ((nrt = RT(rt->rt_llinfo)) == 0) ! 287: goto refuse; ! 288: nrt->rt_refcnt--; ! 289: } ! 290: if (nrt->rt_ifa == 0 || nrt->rt_ifa->ifa_rtrequest != x25_rtrequest) ! 291: goto refuse; ! 292: lcp->lcd_send(lcp); /* confirm call */ ! 293: x25_rtattach(lcp, nrt); ! 294: m_freem(m); ! 295: } ! 296: ! 297: /* ! 298: * X.25 output routine. ! 299: */ ! 300: x25_ifoutput(ifp, m0, dst, rt) ! 301: struct ifnet *ifp; ! 302: struct mbuf *m0; ! 303: struct sockaddr *dst; ! 304: register struct rtentry *rt; ! 305: { ! 306: register struct mbuf *m = m0; ! 307: register struct llinfo_x25 *lx; ! 308: struct pklcd *lcp; ! 309: int s, error = 0; ! 310: ! 311: int plen; ! 312: for (plen = 0; m; m = m->m_next) ! 313: plen += m->m_len; ! 314: m = m0; ! 315: ! 316: if ((ifp->if_flags & IFF_UP) == 0) ! 317: senderr(ENETDOWN); ! 318: while (rt == 0 || (rt->rt_flags & RTF_GATEWAY)) { ! 319: if (rt) { ! 320: if (rt->rt_llinfo) { ! 321: rt = (struct rtentry *)rt->rt_llinfo; ! 322: continue; ! 323: } ! 324: dst = rt->rt_gateway; ! 325: } ! 326: if ((rt = rtalloc1(dst, 1)) == 0) ! 327: senderr(EHOSTUNREACH); ! 328: rt->rt_refcnt--; ! 329: } ! 330: /* ! 331: * Sanity checks. ! 332: */ ! 333: if ((rt->rt_ifp != ifp) || ! 334: (rt->rt_flags & (RTF_CLONING | RTF_GATEWAY)) || ! 335: ((lx = (struct llinfo_x25 *)rt->rt_llinfo) == 0)) { ! 336: senderr(ENETUNREACH); ! 337: } ! 338: if ((m->m_flags & M_PKTHDR) == 0) { ! 339: if_x25stats.ifx_nophdr++; ! 340: m = m_gethdr(M_NOWAIT, MT_HEADER); ! 341: if (m == 0) ! 342: senderr(ENOBUFS); ! 343: m->m_pkthdr.len = plen; ! 344: m->m_next = m0; ! 345: } ! 346: if (plen != m->m_pkthdr.len) { ! 347: if_x25stats.ifx_wrongplen++; ! 348: m->m_pkthdr.len = plen; ! 349: } ! 350: next_circuit: ! 351: lcp = lx->lx_lcd; ! 352: if (lcp == 0) { ! 353: lx->lx_lcd = lcp = pk_attach((struct socket *)0); ! 354: if (lcp == 0) ! 355: senderr(ENOBUFS); ! 356: lcp->lcd_upper = x25_connect_callback; ! 357: lcp->lcd_upnext = (caddr_t)lx; ! 358: lcp->lcd_packetsize = lx->lx_ia->ia_xc.xc_psize; ! 359: lcp->lcd_flags = X25_MBS_HOLD; ! 360: } ! 361: switch (lcp->lcd_state) { ! 362: case READY: ! 363: if (dst->sa_family == AF_INET && ! 364: ifp->if_type == IFT_X25DDN && ! 365: rt->rt_gateway->sa_family != AF_CCITT) ! 366: x25_ddnip_to_ccitt(dst, rt); ! 367: if (rt->rt_gateway->sa_family != AF_CCITT) { ! 368: if ((rt->rt_flags & RTF_XRESOLVE) == 0) ! 369: senderr(EHOSTUNREACH); ! 370: } else if (x25_autoconnect) ! 371: error = pk_connect(lcp, ! 372: (struct sockaddr_x25 *)rt->rt_gateway); ! 373: if (error) ! 374: senderr(error); ! 375: /* FALLTHROUGH */ ! 376: case SENT_CALL: ! 377: case DATA_TRANSFER: ! 378: if (sbspace(&lcp->lcd_sb) < 0) { ! 379: lx = lx->lx_next; ! 380: if (lx->lx_rt != rt) ! 381: senderr(ENOSPC); ! 382: goto next_circuit; ! 383: } ! 384: if (lx->lx_ia) ! 385: lcp->lcd_dg_timer = ! 386: lx->lx_ia->ia_xc.xc_dg_idletimo; ! 387: pk_send(lcp, m); ! 388: break; ! 389: default: ! 390: /* ! 391: * We count on the timer routine to close idle ! 392: * connections, if there are not enough circuits to go ! 393: * around. ! 394: * ! 395: * So throw away data for now. ! 396: * After we get it all working, we'll rewrite to handle ! 397: * actively closing connections (other than by timers), ! 398: * when circuits get tight. ! 399: * ! 400: * In the DDN case, the imp itself closes connections ! 401: * under heavy load. ! 402: */ ! 403: error = ENOBUFS; ! 404: bad: ! 405: if (m) ! 406: m_freem(m); ! 407: } ! 408: return (error); ! 409: } ! 410: ! 411: /* ! 412: * Simpleminded timer routine. ! 413: */ ! 414: x25_iftimeout(ifp) ! 415: struct ifnet *ifp; ! 416: { ! 417: register struct pkcb *pkcb = 0; ! 418: register struct pklcd **lcpp, *lcp; ! 419: int s = splimp(); ! 420: ! 421: FOR_ALL_PKCBS(pkcb) ! 422: if (pkcb->pk_ia->ia_ifp == ifp) ! 423: for (lcpp = pkcb->pk_chan + pkcb->pk_maxlcn; ! 424: --lcpp > pkcb->pk_chan;) ! 425: if ((lcp = *lcpp) && ! 426: lcp->lcd_state == DATA_TRANSFER && ! 427: (lcp->lcd_flags & X25_DG_CIRCUIT) && ! 428: (lcp->lcd_dg_timer && --lcp->lcd_dg_timer == 0)) { ! 429: lcp->lcd_upper(lcp, 0); ! 430: } ! 431: splx(s); ! 432: } ! 433: /* ! 434: * This routine gets called when validating additions of new routes ! 435: * or deletions of old ones. ! 436: */ ! 437: x25_rtrequest(cmd, rt, dst) ! 438: register struct rtentry *rt; ! 439: struct sockaddr *dst; ! 440: { ! 441: register struct llinfo_x25 *lx = (struct llinfo_x25 *)rt->rt_llinfo; ! 442: register struct sockaddr_x25 *sa =(struct sockaddr_x25 *)rt->rt_gateway; ! 443: register struct pklcd *lcp; ! 444: ! 445: /* would put this pk_init, except routing table doesn't ! 446: exist yet. */ ! 447: if (x25_dgram_sockmask == 0) { ! 448: struct radix_node *rn_addmask(); ! 449: x25_dgram_sockmask = ! 450: SA(rn_addmask((caddr_t)&x25_dgmask, 0, 4)->rn_key); ! 451: } ! 452: if (rt->rt_flags & RTF_GATEWAY) { ! 453: if (rt->rt_llinfo) ! 454: RTFREE((struct rtentry *)rt->rt_llinfo); ! 455: rt->rt_llinfo = (cmd == RTM_ADD) ? ! 456: (caddr_t)rtalloc1(rt->rt_gateway, 1) : 0; ! 457: return; ! 458: } ! 459: if ((rt->rt_flags & RTF_HOST) == 0) ! 460: return; ! 461: if (cmd == RTM_DELETE) { ! 462: while (rt->rt_llinfo) ! 463: x25_lxfree((struct llinfo *)rt->rt_llinfo); ! 464: x25_rtinvert(RTM_DELETE, rt->rt_gateway, rt); ! 465: return; ! 466: } ! 467: if (lx == 0 && (lx = x25_lxalloc(rt)) == 0) ! 468: return; ! 469: if ((lcp = lx->lx_lcd) && lcp->lcd_state != READY) { ! 470: /* ! 471: * This can only happen on a RTM_CHANGE operation ! 472: * though cmd will be RTM_ADD. ! 473: */ ! 474: if (lcp->lcd_ceaddr && ! 475: Bcmp(rt->rt_gateway, lcp->lcd_ceaddr, ! 476: lcp->lcd_ceaddr->x25_len) != 0) { ! 477: x25_rtinvert(RTM_DELETE, lcp->lcd_ceaddr, rt); ! 478: lcp->lcd_upper = 0; ! 479: pk_disconnect(lcp); ! 480: } ! 481: lcp = 0; ! 482: } ! 483: x25_rtinvert(RTM_ADD, rt->rt_gateway, rt); ! 484: } ! 485: ! 486: int x25_dont_rtinvert = 0; ! 487: ! 488: x25_rtinvert(cmd, sa, rt) ! 489: register struct sockaddr *sa; ! 490: register struct rtentry *rt; ! 491: { ! 492: struct rtentry *rt2 = 0; ! 493: /* ! 494: * rt_gateway contains PID indicating which proto ! 495: * family on the other end, so will be different ! 496: * from general host route via X.25. ! 497: */ ! 498: if (rt->rt_ifp->if_type == IFT_X25DDN || x25_dont_rtinvert) ! 499: return; ! 500: if (sa->sa_family != AF_CCITT) ! 501: return; ! 502: if (cmd != RTM_DELETE) { ! 503: rtrequest(RTM_ADD, sa, rt_key(rt), x25_dgram_sockmask, ! 504: RTF_PROTO2, &rt2); ! 505: if (rt2) { ! 506: rt2->rt_llinfo = (caddr_t) rt; ! 507: rt->rt_refcnt++; ! 508: } ! 509: return; ! 510: } ! 511: rt2 = rt; ! 512: if ((rt = rtalloc1(sa, 0)) == 0 || ! 513: (rt->rt_flags & RTF_PROTO2) == 0 || ! 514: rt->rt_llinfo != (caddr_t)rt2) { ! 515: printf("x25_rtchange: inverse route screwup\n"); ! 516: return; ! 517: } else ! 518: rt2->rt_refcnt--; ! 519: rtrequest(RTM_DELETE, sa, rt_key(rt2), x25_dgram_sockmask, ! 520: 0, (struct rtentry **) 0); ! 521: } ! 522: ! 523: static struct sockaddr_x25 blank_x25 = {sizeof blank_x25, AF_CCITT}; ! 524: /* ! 525: * IP to X25 address routine copyright ACC, used by permission. ! 526: */ ! 527: union imp_addr { ! 528: struct in_addr ip; ! 529: struct imp { ! 530: u_char s_net; ! 531: u_char s_host; ! 532: u_char s_lh; ! 533: u_char s_impno; ! 534: } imp; ! 535: }; ! 536: ! 537: /* ! 538: * The following is totally bogus and here only to preserve ! 539: * the IP to X.25 translation. ! 540: */ ! 541: x25_ddnip_to_ccitt(src, rt) ! 542: struct sockaddr_in *src; ! 543: register struct rtentry *rt; ! 544: { ! 545: register struct sockaddr_x25 *dst = (struct sockaddr_x25 *)rt->rt_gateway; ! 546: union imp_addr imp_addr; ! 547: int imp_no, imp_port, temp; ! 548: char *x25addr = dst->x25_addr; ! 549: ! 550: ! 551: imp_addr.ip = src->sin_addr; ! 552: *dst = blank_x25; ! 553: if ((imp_addr.imp.s_net & 0x80) == 0x00) { /* class A */ ! 554: imp_no = imp_addr.imp.s_impno; ! 555: imp_port = imp_addr.imp.s_host; ! 556: } else if ((imp_addr.imp.s_net & 0xc0) == 0x80) { /* class B */ ! 557: imp_no = imp_addr.imp.s_impno; ! 558: imp_port = imp_addr.imp.s_lh; ! 559: } else { /* class C */ ! 560: imp_no = imp_addr.imp.s_impno / 32; ! 561: imp_port = imp_addr.imp.s_impno % 32; ! 562: } ! 563: ! 564: x25addr[0] = 12; /* length */ ! 565: /* DNIC is cleared by struct copy above */ ! 566: ! 567: if (imp_port < 64) { /* Physical: 0000 0 IIIHH00 [SS] *//* s_impno ! 568: * -> III, s_host -> HH */ ! 569: x25addr[5] = 0; /* set flag bit */ ! 570: x25addr[6] = imp_no / 100; ! 571: x25addr[7] = (imp_no % 100) / 10; ! 572: x25addr[8] = imp_no % 10; ! 573: x25addr[9] = imp_port / 10; ! 574: x25addr[10] = imp_port % 10; ! 575: } else { /* Logical: 0000 1 RRRRR00 [SS] *//* s ! 576: * _host * 256 + s_impno -> RRRRR */ ! 577: temp = (imp_port << 8) + imp_no; ! 578: x25addr[5] = 1; ! 579: x25addr[6] = temp / 10000; ! 580: x25addr[7] = (temp % 10000) / 1000; ! 581: x25addr[8] = (temp % 1000) / 100; ! 582: x25addr[9] = (temp % 100) / 10; ! 583: x25addr[10] = temp % 10; ! 584: } ! 585: } ! 586: ! 587: /* ! 588: * This routine is a sketch and is not to be believed!!!!! ! 589: * ! 590: * This is a utility routine to be called by x25 devices when a ! 591: * call request is honored with the intent of starting datagram forwarding. ! 592: */ ! 593: x25_dg_rtinit(dst, ia, af) ! 594: struct sockaddr_x25 *dst; ! 595: register struct x25_ifaddr *ia; ! 596: { ! 597: struct sockaddr *sa = 0; ! 598: struct rtentry *rt; ! 599: struct in_addr my_addr; ! 600: static struct sockaddr_in sin = {sizeof(sin), AF_INET}; ! 601: ! 602: if (ia->ia_ifp->if_type == IFT_X25DDN && af == AF_INET) { ! 603: /* ! 604: * Inverse X25 to IP mapping copyright and courtesy ACC. ! 605: */ ! 606: int imp_no, imp_port, temp; ! 607: union imp_addr imp_addr; ! 608: { ! 609: /* ! 610: * First determine our IP addr for network ! 611: */ ! 612: register struct in_ifaddr *ina; ! 613: extern struct in_ifaddr *in_ifaddr; ! 614: ! 615: for (ina = in_ifaddr; ina; ina = ina->ia_next) ! 616: if (ina->ia_ifp == ia->ia_ifp) { ! 617: my_addr = ina->ia_addr.sin_addr; ! 618: break; ! 619: } ! 620: } ! 621: { ! 622: ! 623: register char *x25addr = dst->x25_addr; ! 624: ! 625: switch (x25addr[5] & 0x0f) { ! 626: case 0: /* Physical: 0000 0 IIIHH00 [SS] */ ! 627: imp_no = ! 628: ((int) (x25addr[6] & 0x0f) * 100) + ! 629: ((int) (x25addr[7] & 0x0f) * 10) + ! 630: ((int) (x25addr[8] & 0x0f)); ! 631: ! 632: ! 633: imp_port = ! 634: ((int) (x25addr[9] & 0x0f) * 10) + ! 635: ((int) (x25addr[10] & 0x0f)); ! 636: break; ! 637: case 1: /* Logical: 0000 1 RRRRR00 [SS] */ ! 638: temp = ((int) (x25addr[6] & 0x0f) * 10000) ! 639: + ((int) (x25addr[7] & 0x0f) * 1000) ! 640: + ((int) (x25addr[8] & 0x0f) * 100) ! 641: + ((int) (x25addr[9] & 0x0f) * 10) ! 642: + ((int) (x25addr[10] & 0x0f)); ! 643: ! 644: imp_port = temp >> 8; ! 645: imp_no = temp & 0xff; ! 646: break; ! 647: default: ! 648: return (0L); ! 649: } ! 650: imp_addr.ip = my_addr; ! 651: if ((imp_addr.imp.s_net & 0x80) == 0x00) { ! 652: /* class A */ ! 653: imp_addr.imp.s_host = imp_port; ! 654: imp_addr.imp.s_impno = imp_no; ! 655: imp_addr.imp.s_lh = 0; ! 656: } else if ((imp_addr.imp.s_net & 0xc0) == 0x80) { ! 657: /* class B */ ! 658: imp_addr.imp.s_lh = imp_port; ! 659: imp_addr.imp.s_impno = imp_no; ! 660: } else { ! 661: /* class C */ ! 662: imp_addr.imp.s_impno = (imp_no << 5) + imp_port; ! 663: } ! 664: } ! 665: sin.sin_addr = imp_addr.ip; ! 666: sa = (struct sockaddr *)&sin; ! 667: } else { ! 668: /* ! 669: * This uses the X25 routing table to do inverse ! 670: * lookup of x25 address to sockaddr. ! 671: */ ! 672: if (rt = rtalloc1(SA(dst), 0)) { ! 673: sa = rt->rt_gateway; ! 674: rt->rt_refcnt--; ! 675: } ! 676: } ! 677: /* ! 678: * Call to rtalloc1 will create rtentry for reverse path ! 679: * to callee by virtue of cloning magic and will allocate ! 680: * space for local control block. ! 681: */ ! 682: if (sa && (rt = rtalloc1(sa, 1))) ! 683: rt->rt_refcnt--; ! 684: } ! 685: int x25_startproto = 1; ! 686: ! 687: pk_init() ! 688: { ! 689: /* ! 690: * warning, sizeof (struct sockaddr_x25) > 32, ! 691: * but contains no data of interest beyond 32 ! 692: */ ! 693: if (x25_startproto) { ! 694: pk_protolisten(0xcc, 1, x25_dgram_incoming); ! 695: pk_protolisten(0x81, 1, x25_dgram_incoming); ! 696: } ! 697: } ! 698: ! 699: struct x25_dgproto { ! 700: u_char spi; ! 701: u_char spilen; ! 702: int (*f)(); ! 703: } x25_dgprototab[] = { ! 704: #if (ISO) && (TPCONS) ! 705: { 0x0, 0, tp_incoming}, ! 706: #endif ! 707: { 0xcc, 1, x25_dgram_incoming}, ! 708: { 0xcd, 1, x25_dgram_incoming}, ! 709: { 0x81, 1, x25_dgram_incoming}, ! 710: }; ! 711: ! 712: pk_user_protolisten(info) ! 713: register u_char *info; ! 714: { ! 715: register struct x25_dgproto *dp = x25_dgprototab ! 716: + ((sizeof x25_dgprototab) / (sizeof *dp)); ! 717: register struct pklcd *lcp; ! 718: ! 719: while (dp > x25_dgprototab) ! 720: if ((--dp)->spi == info[0]) ! 721: goto gotspi; ! 722: return ESRCH; ! 723: ! 724: gotspi: if (info[1]) ! 725: return pk_protolisten(dp->spi, dp->spilen, dp->f); ! 726: for (lcp = pk_listenhead; lcp; lcp = lcp->lcd_listen) ! 727: if (lcp->lcd_laddr.x25_udlen == dp->spilen && ! 728: Bcmp(&dp->spi, lcp->lcd_laddr.x25_udata, dp->spilen) == 0) { ! 729: pk_disconnect(lcp); ! 730: return 0; ! 731: } ! 732: return ESRCH; ! 733: } ! 734: ! 735: /* ! 736: * This routine transfers an X.25 circuit to or from a routing entry. ! 737: * If the supplied circuit is * in DATA_TRANSFER state, it is added to the ! 738: * routing entry. If freshly allocated, it glues back the vc from ! 739: * the rtentry to the socket. ! 740: */ ! 741: pk_rtattach(so, m0) ! 742: register struct socket *so; ! 743: struct mbuf *m0; ! 744: { ! 745: register struct pklcd *lcp = (struct pklcd *)so->so_pcb; ! 746: register struct mbuf *m = m0; ! 747: struct sockaddr *dst = mtod(m, struct sockaddr *); ! 748: register struct rtentry *rt = rtalloc1(dst, 0); ! 749: register struct llinfo_x25 *lx; ! 750: caddr_t cp; ! 751: #define ROUNDUP(a) \ ! 752: ((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long)) ! 753: #define transfer_sockbuf(s, f, l) \ ! 754: while (m = (s)->sb_mb)\ ! 755: {(s)->sb_mb = m->m_act; m->m_act = 0; sbfree((s), m); f(l, m);} ! 756: ! 757: if (rt) ! 758: rt->rt_refcnt--; ! 759: cp = (dst->sa_len < m->m_len) ? ROUNDUP(dst->sa_len) + (caddr_t)dst : 0; ! 760: while (rt && ! 761: ((cp == 0 && rt_mask(rt) != 0) || ! 762: (cp != 0 && (rt_mask(rt) == 0 || ! 763: Bcmp(cp, rt_mask(rt), rt_mask(rt)->sa_len)) != 0))) ! 764: rt = (struct rtentry *)rt->rt_nodes->rn_dupedkey; ! 765: if (rt == 0 || (rt->rt_flags & RTF_GATEWAY) || ! 766: (lx = (struct llinfo_x25 *)rt->rt_llinfo) == 0) ! 767: return ESRCH; ! 768: if (lcp == 0) ! 769: return ENOTCONN; ! 770: switch (lcp->lcd_state) { ! 771: default: ! 772: return ENOTCONN; ! 773: ! 774: case READY: ! 775: /* Detach VC from rtentry */ ! 776: if (lx->lx_lcd == 0) ! 777: return ENOTCONN; ! 778: lcp->lcd_so = 0; ! 779: pk_close(lcp); ! 780: lcp = lx->lx_lcd; ! 781: if (lx->lx_next->lx_rt == rt) ! 782: x25_lxfree(lx); ! 783: lcp->lcd_so = so; ! 784: lcp->lcd_upper = 0; ! 785: lcp->lcd_upnext = 0; ! 786: transfer_sockbuf(&lcp->lcd_sb, sbappendrecord, &so->so_snd); ! 787: soisconnected(so); ! 788: return 0; ! 789: ! 790: case DATA_TRANSFER: ! 791: /* Add VC to rtentry */ ! 792: lcp->lcd_so = 0; ! 793: lcp->lcd_sb = so->so_snd; /* structure copy */ ! 794: bzero((caddr_t)&so->so_snd, sizeof(so->so_snd)); /* XXXXXX */ ! 795: so->so_pcb = 0; ! 796: x25_rtattach(lcp, rt); ! 797: transfer_sockbuf(&so->so_rcv, x25_ifinput, lcp); ! 798: soisdisconnected(so); ! 799: } ! 800: return 0; ! 801: } ! 802: x25_rtattach(lcp0, rt) ! 803: register struct pklcd *lcp0; ! 804: struct rtentry *rt; ! 805: { ! 806: register struct llinfo_x25 *lx = (struct llinfo_x25 *)rt->rt_llinfo; ! 807: register struct pklcd *lcp; ! 808: register struct mbuf *m; ! 809: if (lcp = lx->lx_lcd) { /* adding an additional VC */ ! 810: if (lcp->lcd_state == READY) { ! 811: transfer_sockbuf(&lcp->lcd_sb, pk_output, lcp0); ! 812: lcp->lcd_upper = 0; ! 813: pk_close(lcp); ! 814: } else { ! 815: lx = x25_lxalloc(rt); ! 816: if (lx == 0) ! 817: return ENOBUFS; ! 818: } ! 819: } ! 820: lx->lx_lcd = lcp = lcp0; ! 821: lcp->lcd_upper = x25_ifinput; ! 822: lcp->lcd_upnext = (caddr_t)lx; ! 823: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.