![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pk_usrreq.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 pk_usrreq.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) University of British Columbia, 1984 ! 27: * Copyright (C) Computer Science Department IV, ! 28: * University of Erlangen-Nuremberg, Germany, 1992 ! 29: * Copyright (c) 1991, 1992, 1993 ! 30: * The Regents of the University of California. All rights reserved. ! 31: * ! 32: * This code is derived from software contributed to Berkeley by the ! 33: * Laboratory for Computation Vision and the Computer Science Department ! 34: * of the the University of British Columbia and the Computer Science ! 35: * Department (IV) of the University of Erlangen-Nuremberg, Germany. ! 36: * ! 37: * Redistribution and use in source and binary forms, with or without ! 38: * modification, are permitted provided that the following conditions ! 39: * are met: ! 40: * 1. Redistributions of source code must retain the above copyright ! 41: * notice, this list of conditions and the following disclaimer. ! 42: * 2. Redistributions in binary form must reproduce the above copyright ! 43: * notice, this list of conditions and the following disclaimer in the ! 44: * documentation and/or other materials provided with the distribution. ! 45: * 3. All advertising materials mentioning features or use of this software ! 46: * must display the following acknowledgement: ! 47: * This product includes software developed by the University of ! 48: * California, Berkeley and its contributors. ! 49: * 4. Neither the name of the University nor the names of its contributors ! 50: * may be used to endorse or promote products derived from this software ! 51: * without specific prior written permission. ! 52: * ! 53: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 54: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 55: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 56: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 57: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 58: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 59: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 60: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 61: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 62: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 63: * SUCH DAMAGE. ! 64: * ! 65: * @(#)pk_usrreq.c 8.1 (Berkeley) 6/10/93 ! 66: */ ! 67: ! 68: #include <sys/param.h> ! 69: #include <sys/systm.h> ! 70: #include <sys/mbuf.h> ! 71: #include <sys/socket.h> ! 72: #include <sys/socketvar.h> ! 73: #include <sys/protosw.h> ! 74: #include <sys/errno.h> ! 75: #include <sys/ioctl.h> ! 76: #include <sys/stat.h> ! 77: #include <sys/malloc.h> ! 78: ! 79: #include <net/if.h> ! 80: #include <net/if_types.h> ! 81: #include <net/route.h> ! 82: ! 83: #include <netccitt/x25.h> ! 84: #include <netccitt/pk.h> ! 85: #include <netccitt/pk_var.h> ! 86: ! 87: static old_to_new(); ! 88: static new_to_old(); ! 89: /* ! 90: * ! 91: * X.25 Packet level protocol interface to socket abstraction. ! 92: * ! 93: * Process an X.25 user request on a logical channel. If this is a send ! 94: * request then m is the mbuf chain of the send data. If this is a timer ! 95: * expiration (called from the software clock routine) them timertype is ! 96: * the particular timer. ! 97: * ! 98: */ ! 99: ! 100: pk_usrreq (so, req, m, nam, control) ! 101: struct socket *so; ! 102: int req; ! 103: register struct mbuf *m, *nam; ! 104: struct mbuf *control; ! 105: { ! 106: register struct pklcd *lcp = (struct pklcd *) so -> so_pcb; ! 107: register int error = 0; ! 108: ! 109: if (req == PRU_CONTROL) ! 110: return (pk_control (so, (int)m, (caddr_t)nam, ! 111: (struct ifnet *)control)); ! 112: if (control && control -> m_len) { ! 113: error = EINVAL; ! 114: goto release; ! 115: } ! 116: if (lcp == NULL && req != PRU_ATTACH) { ! 117: error = EINVAL; ! 118: goto release; ! 119: } ! 120: ! 121: /* ! 122: pk_trace (pkcbhead, TR_USER, (struct pklcd *)0, ! 123: req, (struct x25_packet *)0); ! 124: */ ! 125: ! 126: switch (req) { ! 127: /* ! 128: * X.25 attaches to socket via PRU_ATTACH and allocates a logical ! 129: * channel descriptor. If the socket is to receive connections, ! 130: * then the LISTEN state is entered. ! 131: */ ! 132: case PRU_ATTACH: ! 133: if (lcp) { ! 134: error = EISCONN; ! 135: /* Socket already connected. */ ! 136: break; ! 137: } ! 138: lcp = pk_attach (so); ! 139: if (lcp == 0) ! 140: error = ENOBUFS; ! 141: break; ! 142: ! 143: /* ! 144: * Detach a logical channel from the socket. If the state of the ! 145: * channel is embryonic, simply discard it. Otherwise we have to ! 146: * initiate a PRU_DISCONNECT which will finish later. ! 147: */ ! 148: case PRU_DETACH: ! 149: pk_disconnect (lcp); ! 150: break; ! 151: ! 152: /* ! 153: * Give the socket an address. ! 154: */ ! 155: case PRU_BIND: ! 156: if (nam -> m_len == sizeof (struct x25_sockaddr)) ! 157: old_to_new (nam); ! 158: error = pk_bind (lcp, nam); ! 159: break; ! 160: ! 161: /* ! 162: * Prepare to accept connections. ! 163: */ ! 164: case PRU_LISTEN: ! 165: error = pk_listen (lcp); ! 166: break; ! 167: ! 168: /* ! 169: * Initiate a CALL REQUEST to peer entity. Enter state SENT_CALL ! 170: * and mark the socket as connecting. Set timer waiting for ! 171: * CALL ACCEPT or CLEAR. ! 172: */ ! 173: case PRU_CONNECT: ! 174: if (nam -> m_len == sizeof (struct x25_sockaddr)) ! 175: old_to_new (nam); ! 176: if (pk_checksockaddr (nam)) ! 177: return (EINVAL); ! 178: error = pk_connect (lcp, mtod (nam, struct sockaddr_x25 *)); ! 179: break; ! 180: ! 181: /* ! 182: * Initiate a disconnect to peer entity via a CLEAR REQUEST packet. ! 183: * The socket will be disconnected when we receive a confirmation ! 184: * or a clear collision. ! 185: */ ! 186: case PRU_DISCONNECT: ! 187: pk_disconnect (lcp); ! 188: break; ! 189: ! 190: /* ! 191: * Accept an INCOMING CALL. Most of the work has already been done ! 192: * by pk_input. Just return the callers address to the user. ! 193: */ ! 194: case PRU_ACCEPT: ! 195: if (lcp -> lcd_craddr == NULL) ! 196: break; ! 197: bcopy ((caddr_t)lcp -> lcd_craddr, mtod (nam, caddr_t), ! 198: sizeof (struct sockaddr_x25)); ! 199: nam -> m_len = sizeof (struct sockaddr_x25); ! 200: if (lcp -> lcd_flags & X25_OLDSOCKADDR) ! 201: new_to_old (nam); ! 202: break; ! 203: ! 204: /* ! 205: * After a receive, we should send a RR. ! 206: */ ! 207: case PRU_RCVD: ! 208: pk_flowcontrol (lcp, /*sbspace (&so -> so_rcv) <= */ 0, 1); ! 209: break; ! 210: ! 211: /* ! 212: * Send INTERRUPT packet. ! 213: */ ! 214: case PRU_SENDOOB: ! 215: if (m == 0) { ! 216: MGETHDR(m, M_WAITOK, MT_OOBDATA); ! 217: m -> m_pkthdr.len = m -> m_len = 1; ! 218: *mtod (m, octet *) = 0; ! 219: } ! 220: if (m -> m_pkthdr.len > 32) { ! 221: m_freem (m); ! 222: error = EMSGSIZE; ! 223: break; ! 224: } ! 225: MCHTYPE(m, MT_OOBDATA); ! 226: /* FALLTHROUGH */ ! 227: ! 228: /* ! 229: * Do send by placing data on the socket output queue. ! 230: */ ! 231: case PRU_SEND: ! 232: if (control) { ! 233: register struct cmsghdr *ch = mtod (m, struct cmsghdr *); ! 234: control -> m_len -= sizeof (*ch); ! 235: control -> m_data += sizeof (*ch); ! 236: error = pk_ctloutput (PRCO_SETOPT, so, ch -> cmsg_level, ! 237: ch -> cmsg_type, &control); ! 238: } ! 239: if (error == 0 && m) ! 240: error = pk_send (lcp, m); ! 241: break; ! 242: ! 243: /* ! 244: * Abort a virtual circuit. For example all completed calls ! 245: * waiting acceptance. ! 246: */ ! 247: case PRU_ABORT: ! 248: pk_disconnect (lcp); ! 249: break; ! 250: ! 251: /* Begin unimplemented hooks. */ ! 252: ! 253: case PRU_SHUTDOWN: ! 254: error = EOPNOTSUPP; ! 255: break; ! 256: ! 257: case PRU_CONTROL: ! 258: error = EOPNOTSUPP; ! 259: break; ! 260: ! 261: case PRU_SENSE: ! 262: #ifdef BSD4_3 ! 263: ((struct stat *)m) -> st_blksize = so -> so_snd.sb_hiwat; ! 264: #else ! 265: error = EOPNOTSUPP; ! 266: #endif ! 267: break; ! 268: ! 269: /* End unimplemented hooks. */ ! 270: ! 271: case PRU_SOCKADDR: ! 272: if (lcp -> lcd_ceaddr == 0) ! 273: return (EADDRNOTAVAIL); ! 274: nam -> m_len = sizeof (struct sockaddr_x25); ! 275: bcopy ((caddr_t)lcp -> lcd_ceaddr, mtod (nam, caddr_t), ! 276: sizeof (struct sockaddr_x25)); ! 277: if (lcp -> lcd_flags & X25_OLDSOCKADDR) ! 278: new_to_old (nam); ! 279: break; ! 280: ! 281: case PRU_PEERADDR: ! 282: if (lcp -> lcd_state != DATA_TRANSFER) ! 283: return (ENOTCONN); ! 284: nam -> m_len = sizeof (struct sockaddr_x25); ! 285: bcopy (lcp -> lcd_craddr ? (caddr_t)lcp -> lcd_craddr : ! 286: (caddr_t)lcp -> lcd_ceaddr, ! 287: mtod (nam, caddr_t), sizeof (struct sockaddr_x25)); ! 288: if (lcp -> lcd_flags & X25_OLDSOCKADDR) ! 289: new_to_old (nam); ! 290: break; ! 291: ! 292: /* ! 293: * Receive INTERRUPT packet. ! 294: */ ! 295: case PRU_RCVOOB: ! 296: if (so -> so_options & SO_OOBINLINE) { ! 297: register struct mbuf *n = so -> so_rcv.sb_mb; ! 298: if (n && n -> m_type == MT_OOBDATA) { ! 299: unsigned len = n -> m_pkthdr.len; ! 300: so -> so_rcv.sb_mb = n -> m_nextpkt; ! 301: if (len != n -> m_len && ! 302: (n = m_pullup (n, len)) == 0) ! 303: break; ! 304: m -> m_len = len; ! 305: bcopy (mtod (m, caddr_t), mtod (n, caddr_t), len); ! 306: m_freem (n); ! 307: } ! 308: break; ! 309: } ! 310: m -> m_len = 1; ! 311: *mtod (m, char *) = lcp -> lcd_intrdata; ! 312: break; ! 313: ! 314: default: ! 315: panic ("pk_usrreq"); ! 316: } ! 317: release: ! 318: if (control != NULL) ! 319: m_freem (control); ! 320: return (error); ! 321: } ! 322: ! 323: /* ! 324: * If you want to use UBC X.25 level 3 in conjunction with some ! 325: * other X.25 level 2 driver, have the ifp -> if_ioctl routine ! 326: * assign pk_start to ia -> ia_start when called with SIOCSIFCONF_X25. ! 327: */ ! 328: /* ARGSUSED */ ! 329: pk_start (lcp) ! 330: register struct pklcd *lcp; ! 331: { ! 332: pk_output (lcp); ! 333: return (0); /* XXX pk_output should return a value */ ! 334: } ! 335: ! 336: #ifndef _offsetof ! 337: #define _offsetof(t, m) ((int)((caddr_t)&((t *)0)->m)) ! 338: #endif ! 339: struct sockaddr_x25 pk_sockmask = { ! 340: _offsetof(struct sockaddr_x25, x25_addr[0]), /* x25_len */ ! 341: 0, /* x25_family */ ! 342: -1, /* x25_net id */ ! 343: }; ! 344: ! 345: /*ARGSUSED*/ ! 346: pk_control (so, cmd, data, ifp) ! 347: struct socket *so; ! 348: int cmd; ! 349: caddr_t data; ! 350: register struct ifnet *ifp; ! 351: { ! 352: register struct ifreq_x25 *ifr = (struct ifreq_x25 *)data; ! 353: register struct ifaddr *ifa = 0; ! 354: register struct x25_ifaddr *ia = 0; ! 355: struct pklcd *dev_lcp = 0; ! 356: int error, s, old_maxlcn; ! 357: unsigned n; ! 358: ! 359: /* ! 360: * Find address for this interface, if it exists. ! 361: */ ! 362: if (ifp) ! 363: for (ifa = ifp -> if_addrlist; ifa; ifa = ifa -> ifa_next) ! 364: if (ifa -> ifa_addr -> sa_family == AF_CCITT) ! 365: break; ! 366: ! 367: ia = (struct x25_ifaddr *)ifa; ! 368: switch (cmd) { ! 369: case SIOCGIFCONF_X25: ! 370: if (ifa == 0) ! 371: return (EADDRNOTAVAIL); ! 372: ifr -> ifr_xc = ia -> ia_xc; ! 373: return (0); ! 374: ! 375: case SIOCSIFCONF_X25: ! 376: if ((so->so_state & SS_PRIV) == 0) ! 377: return (EPERM); ! 378: if (ifp == 0) ! 379: panic ("pk_control"); ! 380: if (ifa == (struct ifaddr *)0) { ! 381: register struct mbuf *m; ! 382: ! 383: MALLOC(ia, struct x25_ifaddr *, sizeof (*ia), ! 384: M_IFADDR, M_WAITOK); ! 385: if (ia == 0) ! 386: return (ENOBUFS); ! 387: bzero ((caddr_t)ia, sizeof (*ia)); ! 388: if (ifa = ifp -> if_addrlist) { ! 389: for ( ; ifa -> ifa_next; ifa = ifa -> ifa_next) ! 390: ; ! 391: ifa -> ifa_next = &ia -> ia_ifa; ! 392: } else ! 393: ifp -> if_addrlist = &ia -> ia_ifa; ! 394: ifa = &ia -> ia_ifa; ! 395: ifa -> ifa_netmask = (struct sockaddr *)&pk_sockmask; ! 396: ifa -> ifa_addr = (struct sockaddr *)&ia -> ia_xc.xc_addr; ! 397: ifa -> ifa_dstaddr = (struct sockaddr *)&ia -> ia_dstaddr; /* XXX */ ! 398: ia -> ia_ifp = ifp; ! 399: ia -> ia_dstaddr.x25_family = AF_CCITT; ! 400: ia -> ia_dstaddr.x25_len = pk_sockmask.x25_len; ! 401: } else if (ISISO8802(ifp) == 0) { ! 402: rtinit (ifa, (int)RTM_DELETE, 0); ! 403: } ! 404: old_maxlcn = ia -> ia_maxlcn; ! 405: ia -> ia_xc = ifr -> ifr_xc; ! 406: ia -> ia_dstaddr.x25_net = ia -> ia_xc.xc_addr.x25_net; ! 407: if (ia -> ia_maxlcn != old_maxlcn && old_maxlcn != 0) { ! 408: /* VERY messy XXX */ ! 409: register struct pkcb *pkp; ! 410: FOR_ALL_PKCBS(pkp) ! 411: if (pkp -> pk_ia == ia) ! 412: pk_resize (pkp); ! 413: } ! 414: /* ! 415: * Give the interface a chance to initialize if this ! 416: p * is its first address, and to validate the address. ! 417: */ ! 418: ia -> ia_start = pk_start; ! 419: s = splimp(); ! 420: if (ifp -> if_ioctl) ! 421: error = (*ifp -> if_ioctl)(ifp, SIOCSIFCONF_X25, ! 422: (caddr_t) ifa); ! 423: if (error) ! 424: ifp -> if_flags &= ~IFF_UP; ! 425: else if (ISISO8802(ifp) == 0) ! 426: error = rtinit (ifa, (int)RTM_ADD, RTF_UP); ! 427: splx (s); ! 428: return (error); ! 429: ! 430: default: ! 431: if (ifp == 0 || ifp -> if_ioctl == 0) ! 432: return (EOPNOTSUPP); ! 433: return ((*ifp -> if_ioctl)(ifp, cmd, data)); ! 434: } ! 435: } ! 436: ! 437: pk_ctloutput (cmd, so, level, optname, mp) ! 438: struct socket *so; ! 439: struct mbuf **mp; ! 440: int cmd, level, optname; ! 441: { ! 442: register struct mbuf *m = *mp; ! 443: register struct pklcd *lcp = (struct pklcd *) so -> so_pcb; ! 444: int error = EOPNOTSUPP; ! 445: ! 446: if (m == 0) ! 447: return (EINVAL); ! 448: if (cmd == PRCO_SETOPT) switch (optname) { ! 449: case PK_FACILITIES: ! 450: if (m == 0) ! 451: return (EINVAL); ! 452: lcp -> lcd_facilities = m; ! 453: *mp = 0; ! 454: return (0); ! 455: ! 456: case PK_ACCTFILE: ! 457: if ((so->so_state & SS_PRIV) == 0) ! 458: error = EPERM; ! 459: else if (m -> m_len) ! 460: error = pk_accton (mtod (m, char *)); ! 461: else ! 462: error = pk_accton ((char *)0); ! 463: break; ! 464: ! 465: case PK_RTATTACH: ! 466: error = pk_rtattach (so, m); ! 467: break; ! 468: ! 469: case PK_PRLISTEN: ! 470: error = pk_user_protolisten (mtod (m, u_char *)); ! 471: } ! 472: if (*mp) { ! 473: (void) m_freem (*mp); ! 474: *mp = 0; ! 475: } ! 476: return (error); ! 477: ! 478: } ! 479: ! 480: ! 481: /* ! 482: * Do an in-place conversion of an "old style" ! 483: * socket address to the new style ! 484: */ ! 485: ! 486: static ! 487: old_to_new (m) ! 488: register struct mbuf *m; ! 489: { ! 490: register struct x25_sockaddr *oldp; ! 491: register struct sockaddr_x25 *newp; ! 492: register char *ocp, *ncp; ! 493: struct sockaddr_x25 new; ! 494: ! 495: oldp = mtod (m, struct x25_sockaddr *); ! 496: newp = &new; ! 497: bzero ((caddr_t)newp, sizeof (*newp)); ! 498: ! 499: newp -> x25_family = AF_CCITT; ! 500: newp -> x25_len = sizeof(*newp); ! 501: newp -> x25_opts.op_flags = (oldp -> xaddr_facilities & X25_REVERSE_CHARGE) ! 502: | X25_MQBIT | X25_OLDSOCKADDR; ! 503: if (oldp -> xaddr_facilities & XS_HIPRIO) /* Datapac specific */ ! 504: newp -> x25_opts.op_psize = X25_PS128; ! 505: bcopy ((caddr_t)oldp -> xaddr_addr, newp -> x25_addr, ! 506: (unsigned)min (oldp -> xaddr_len, sizeof (newp -> x25_addr) - 1)); ! 507: if (bcmp ((caddr_t)oldp -> xaddr_proto, newp -> x25_udata, 4) != 0) { ! 508: bcopy ((caddr_t)oldp -> xaddr_proto, newp -> x25_udata, 4); ! 509: newp -> x25_udlen = 4; ! 510: } ! 511: ocp = (caddr_t)oldp -> xaddr_userdata; ! 512: ncp = newp -> x25_udata + 4; ! 513: while (*ocp && ocp < (caddr_t)oldp -> xaddr_userdata + 12) { ! 514: if (newp -> x25_udlen == 0) ! 515: newp -> x25_udlen = 4; ! 516: *ncp++ = *ocp++; ! 517: newp -> x25_udlen++; ! 518: } ! 519: bcopy ((caddr_t)newp, mtod (m, char *), sizeof (*newp)); ! 520: m -> m_len = sizeof (*newp); ! 521: } ! 522: ! 523: /* ! 524: * Do an in-place conversion of a new style ! 525: * socket address to the old style ! 526: */ ! 527: ! 528: static ! 529: new_to_old (m) ! 530: register struct mbuf *m; ! 531: { ! 532: register struct x25_sockaddr *oldp; ! 533: register struct sockaddr_x25 *newp; ! 534: register char *ocp, *ncp; ! 535: struct x25_sockaddr old; ! 536: ! 537: oldp = &old; ! 538: newp = mtod (m, struct sockaddr_x25 *); ! 539: bzero ((caddr_t)oldp, sizeof (*oldp)); ! 540: ! 541: oldp -> xaddr_facilities = newp -> x25_opts.op_flags & X25_REVERSE_CHARGE; ! 542: if (newp -> x25_opts.op_psize == X25_PS128) ! 543: oldp -> xaddr_facilities |= XS_HIPRIO; /* Datapac specific */ ! 544: ocp = (char *)oldp -> xaddr_addr; ! 545: ncp = newp -> x25_addr; ! 546: while (*ncp) { ! 547: *ocp++ = *ncp++; ! 548: oldp -> xaddr_len++; ! 549: } ! 550: ! 551: bcopy (newp -> x25_udata, (caddr_t)oldp -> xaddr_proto, 4); ! 552: if (newp -> x25_udlen > 4) ! 553: bcopy (newp -> x25_udata + 4, (caddr_t)oldp -> xaddr_userdata, ! 554: (unsigned)(newp -> x25_udlen - 4)); ! 555: ! 556: bcopy ((caddr_t)oldp, mtod (m, char *), sizeof (*oldp)); ! 557: m -> m_len = sizeof (*oldp); ! 558: } ! 559: ! 560: ! 561: pk_checksockaddr (m) ! 562: struct mbuf *m; ! 563: { ! 564: register struct sockaddr_x25 *sa = mtod (m, struct sockaddr_x25 *); ! 565: register char *cp; ! 566: ! 567: if (m -> m_len != sizeof (struct sockaddr_x25)) ! 568: return (1); ! 569: if (sa -> x25_family != AF_CCITT || ! 570: sa -> x25_udlen > sizeof (sa -> x25_udata)) ! 571: return (1); ! 572: for (cp = sa -> x25_addr; *cp; cp++) { ! 573: if (*cp < '0' || *cp > '9' || ! 574: cp >= &sa -> x25_addr[sizeof (sa -> x25_addr) - 1]) ! 575: return (1); ! 576: } ! 577: return (0); ! 578: } ! 579: ! 580: pk_send (lcp, m) ! 581: struct pklcd *lcp; ! 582: register struct mbuf *m; ! 583: { ! 584: int mqbit = 0, error = 0; ! 585: register struct x25_packet *xp; ! 586: register struct socket *so; ! 587: ! 588: if (m -> m_type == MT_OOBDATA) { ! 589: if (lcp -> lcd_intrconf_pending) ! 590: error = ETOOMANYREFS; ! 591: if (m -> m_pkthdr.len > 32) ! 592: error = EMSGSIZE; ! 593: M_PREPEND(m, PKHEADERLN, M_WAITOK); ! 594: if (m == 0 || error) ! 595: goto bad; ! 596: *(mtod (m, octet *)) = 0; ! 597: xp = mtod (m, struct x25_packet *); ! 598: X25SBITS(xp -> bits, fmt_identifier, 1); ! 599: xp -> packet_type = X25_INTERRUPT; ! 600: SET_LCN(xp, lcp -> lcd_lcn); ! 601: sbinsertoob ( (so = lcp -> lcd_so) ? ! 602: &so -> so_snd : &lcp -> lcd_sb, m); ! 603: goto send; ! 604: } ! 605: /* ! 606: * Application has elected (at call setup time) to prepend ! 607: * a control byte to each packet written indicating m-bit ! 608: * and q-bit status. Examine and then discard this byte. ! 609: */ ! 610: if (lcp -> lcd_flags & X25_MQBIT) { ! 611: if (m -> m_len < 1) { ! 612: m_freem (m); ! 613: return (EMSGSIZE); ! 614: } ! 615: mqbit = *(mtod (m, u_char *)); ! 616: m -> m_len--; ! 617: m -> m_data++; ! 618: m -> m_pkthdr.len--; ! 619: } ! 620: error = pk_fragment (lcp, m, mqbit & 0x80, mqbit & 0x40, 1); ! 621: send: ! 622: if (error == 0 && lcp -> lcd_state == DATA_TRANSFER) ! 623: lcp -> lcd_send (lcp); /* XXXXXXXXX fix pk_output!!! */ ! 624: return (error); ! 625: bad: ! 626: if (m) ! 627: m_freem (m); ! 628: return (error); ! 629: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.