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