![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tp_usrreq.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / netiso|
Return to tp_usrreq.c CVS log | Up to [Net/2] / Net2 / netiso |
1.1 ! root 1: /*- ! 2: * Copyright (c) 1991 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms, with or without ! 6: * modification, are permitted provided that the following conditions ! 7: * are met: ! 8: * 1. Redistributions of source code must retain the above copyright ! 9: * notice, this list of conditions and the following disclaimer. ! 10: * 2. Redistributions in binary form must reproduce the above copyright ! 11: * notice, this list of conditions and the following disclaimer in the ! 12: * documentation and/or other materials provided with the distribution. ! 13: * 3. All advertising materials mentioning features or use of this software ! 14: * must display the following acknowledgement: ! 15: * This product includes software developed by the University of ! 16: * California, Berkeley and its contributors. ! 17: * 4. Neither the name of the University nor the names of its contributors ! 18: * may be used to endorse or promote products derived from this software ! 19: * without specific prior written permission. ! 20: * ! 21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 31: * SUCH DAMAGE. ! 32: * ! 33: * @(#)tp_usrreq.c 7.17 (Berkeley) 6/27/91 ! 34: */ ! 35: ! 36: /*********************************************************** ! 37: Copyright IBM Corporation 1987 ! 38: ! 39: All Rights Reserved ! 40: ! 41: Permission to use, copy, modify, and distribute this software and its ! 42: documentation for any purpose and without fee is hereby granted, ! 43: provided that the above copyright notice appear in all copies and that ! 44: both that copyright notice and this permission notice appear in ! 45: supporting documentation, and that the name of IBM not be ! 46: used in advertising or publicity pertaining to distribution of the ! 47: software without specific, written prior permission. ! 48: ! 49: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ! 50: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ! 51: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ! 52: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ! 53: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ! 54: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ! 55: SOFTWARE. ! 56: ! 57: ******************************************************************/ ! 58: ! 59: /* ! 60: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison ! 61: */ ! 62: /* ! 63: * ARGO TP ! 64: * ! 65: * $Header: tp_usrreq.c,v 5.4 88/11/18 17:29:18 nhall Exp $ ! 66: * $Source: /usr/argo/sys/netiso/RCS/tp_usrreq.c,v $ ! 67: * ! 68: * tp_usrreq(), the fellow that gets called from most of the socket code. ! 69: * Pretty straighforward. ! 70: * THe only really awful stuff here is the OOB processing, which is done ! 71: * wholly here. ! 72: * tp_rcvoob() and tp_sendoob() are contained here and called by tp_usrreq(). ! 73: */ ! 74: ! 75: #include "param.h" ! 76: #include "systm.h" ! 77: #include "mbuf.h" ! 78: #include "socket.h" ! 79: #include "socketvar.h" ! 80: #include "domain.h" ! 81: #include "protosw.h" ! 82: #include "errno.h" ! 83: #include "time.h" ! 84: ! 85: #include "tp_param.h" ! 86: #include "tp_timer.h" ! 87: #include "tp_stat.h" ! 88: #include "tp_seq.h" ! 89: #include "tp_ip.h" ! 90: #include "tp_pcb.h" ! 91: #include "argo_debug.h" ! 92: #include "tp_trace.h" ! 93: #include "tp_meas.h" ! 94: #include "iso.h" ! 95: #include "iso_errno.h" ! 96: ! 97: int tp_attach(), tp_driver(); ! 98: int TNew; ! 99: int TPNagle1, TPNagle2; ! 100: struct tp_pcb *tp_listeners, *tp_intercepts; ! 101: ! 102: #ifdef ARGO_DEBUG ! 103: /* ! 104: * CALLED FROM: ! 105: * anywhere you want to debug... ! 106: * FUNCTION and ARGUMENTS: ! 107: * print (str) followed by the control info in the mbufs of an mbuf chain (n) ! 108: */ ! 109: void ! 110: dump_mbuf(n, str) ! 111: struct mbuf *n; ! 112: char *str; ! 113: { ! 114: struct mbuf *nextrecord; ! 115: ! 116: printf("dump %s\n", str); ! 117: ! 118: if (n == MNULL) { ! 119: printf("EMPTY:\n"); ! 120: return; ! 121: } ! 122: ! 123: while (n) { ! 124: nextrecord = n->m_act; ! 125: printf("RECORD:\n"); ! 126: while (n) { ! 127: printf("%x : Len %x Data %x A %x Nx %x Tp %x\n", ! 128: n, n->m_len, n->m_data, n->m_act, n->m_next, n->m_type); ! 129: #ifdef notdef ! 130: { ! 131: register char *p = mtod(n, char *); ! 132: register int i; ! 133: ! 134: printf("data: "); ! 135: for (i = 0; i < n->m_len; i++) { ! 136: if (i%8 == 0) ! 137: printf("\n"); ! 138: printf("0x%x ", *(p+i)); ! 139: } ! 140: printf("\n"); ! 141: } ! 142: #endif notdef ! 143: if (n->m_next == n) { ! 144: printf("LOOP!\n"); ! 145: return; ! 146: } ! 147: n = n->m_next; ! 148: } ! 149: n = nextrecord; ! 150: } ! 151: printf("\n"); ! 152: } ! 153: ! 154: #endif ARGO_DEBUG ! 155: ! 156: /* ! 157: * CALLED FROM: ! 158: * tp_usrreq(), PRU_RCVOOB ! 159: * FUNCTION and ARGUMENTS: ! 160: * Copy data from the expedited data socket buffer into ! 161: * the pre-allocated mbuf m. ! 162: * There is an isomorphism between XPD TPDUs and expedited data TSDUs. ! 163: * XPD tpdus are limited to 16 bytes of data so they fit in one mbuf. ! 164: * RETURN VALUE: ! 165: * EINVAL if debugging is on and a disaster has occurred ! 166: * ENOTCONN if the socket isn't connected ! 167: * EWOULDBLOCK if the socket is in non-blocking mode and there's no ! 168: * xpd data in the buffer ! 169: * E* whatever is returned from the fsm. ! 170: */ ! 171: tp_rcvoob(tpcb, so, m, outflags, inflags) ! 172: struct tp_pcb *tpcb; ! 173: register struct socket *so; ! 174: register struct mbuf *m; ! 175: int *outflags; ! 176: int inflags; ! 177: { ! 178: register struct mbuf *n; ! 179: register struct sockbuf *sb = &so->so_rcv; ! 180: struct tp_event E; ! 181: int error = 0; ! 182: register struct mbuf **nn; ! 183: ! 184: IFDEBUG(D_XPD) ! 185: printf("PRU_RCVOOB, sostate 0x%x\n", so->so_state); ! 186: ENDDEBUG ! 187: ! 188: /* if you use soreceive */ ! 189: if (m == MNULL) ! 190: return ENOBUFS; ! 191: ! 192: restart: ! 193: if ((((so->so_state & SS_ISCONNECTED) == 0) ! 194: || (so->so_state & SS_ISDISCONNECTING) != 0) && ! 195: (so->so_proto->pr_flags & PR_CONNREQUIRED)) { ! 196: return ENOTCONN; ! 197: } ! 198: ! 199: /* Take the first mbuf off the chain. ! 200: * Each XPD TPDU gives you a complete TSDU so the chains don't get ! 201: * coalesced, but one TSDU may span several mbufs. ! 202: * Nevertheless, since n should have a most 16 bytes, it ! 203: * will fit into m. (size was checked in tp_input() ) ! 204: */ ! 205: ! 206: /* ! 207: * Code for excision of OOB data should be added to ! 208: * uipc_socket2.c (like sbappend). ! 209: */ ! 210: ! 211: sblock(sb); ! 212: for (nn = &sb->sb_mb; n = *nn; nn = &n->m_act) ! 213: if (n->m_type == MT_OOBDATA) ! 214: break; ! 215: ! 216: if (n == 0) { ! 217: IFDEBUG(D_XPD) ! 218: printf("RCVOOB: empty queue!\n"); ! 219: ENDDEBUG ! 220: sbunlock(sb); ! 221: if (so->so_state & SS_NBIO) { ! 222: return EWOULDBLOCK; ! 223: } ! 224: sbwait(sb); ! 225: goto restart; ! 226: } ! 227: m->m_len = 0; ! 228: ! 229: /* Assuming at most one xpd tpdu is in the buffer at once */ ! 230: while (n != MNULL) { ! 231: m->m_len += n->m_len; ! 232: bcopy(mtod(n, caddr_t), mtod(m, caddr_t), (unsigned)n->m_len); ! 233: m->m_data += n->m_len; /* so mtod() in bcopy() above gives right addr */ ! 234: n = n->m_next; ! 235: } ! 236: m->m_data = m->m_dat; ! 237: m->m_flags |= M_EOR; ! 238: ! 239: IFDEBUG(D_XPD) ! 240: printf("tp_rcvoob: xpdlen 0x%x\n", m->m_len); ! 241: dump_mbuf(so->so_rcv.sb_mb, "RCVOOB: Rcv socketbuf"); ! 242: dump_mbuf(sb->sb_mb, "RCVOOB: Xrcv socketbuf"); ! 243: ENDDEBUG ! 244: ! 245: if ((inflags & MSG_PEEK) == 0) { ! 246: n = *nn; ! 247: *nn = n->m_act; ! 248: sb->sb_cc -= m->m_len; ! 249: } ! 250: ! 251: release: ! 252: sbunlock(sb); ! 253: ! 254: IFTRACE(D_XPD) ! 255: tptraceTPCB(TPPTmisc, "PRU_RCVOOB @ release sb_cc m_len", ! 256: tpcb->tp_Xrcv.sb_cc, m->m_len, 0, 0); ! 257: ENDTRACE ! 258: if (error == 0) ! 259: error = DoEvent(T_USR_Xrcvd); ! 260: return error; ! 261: } ! 262: ! 263: /* ! 264: * CALLED FROM: ! 265: * tp_usrreq(), PRU_SENDOOB ! 266: * FUNCTION and ARGUMENTS: ! 267: * Send what's in the mbuf chain (m) as an XPD TPDU. ! 268: * The mbuf may not contain more then 16 bytes of data. ! 269: * XPD TSDUs aren't segmented, so they translate into ! 270: * exactly one XPD TPDU, with EOT bit set. ! 271: * RETURN VALUE: ! 272: * EWOULDBLOCK if socket is in non-blocking mode and the previous ! 273: * xpd data haven't been acked yet. ! 274: * EMSGSIZE if trying to send > max-xpd bytes (16) ! 275: * ENOBUFS if ran out of mbufs ! 276: */ ! 277: tp_sendoob(tpcb, so, xdata, outflags) ! 278: struct tp_pcb *tpcb; ! 279: register struct socket *so; ! 280: register struct mbuf *xdata; ! 281: int *outflags; /* not used */ ! 282: { ! 283: /* ! 284: * Each mbuf chain represents a sequence # in the XPD seq space. ! 285: * The first one in the queue has sequence # tp_Xuna. ! 286: * When we add to the XPD queue, we stuff a zero-length ! 287: * mbuf (mark) into the DATA queue, with its sequence number in m_next ! 288: * to be assigned to this XPD tpdu, so data xfer can stop ! 289: * when it reaches the zero-length mbuf if this XPD TPDU hasn't ! 290: * yet been acknowledged. ! 291: */ ! 292: register struct sockbuf *sb = &(tpcb->tp_Xsnd); ! 293: register struct mbuf *xmark; ! 294: register int len=0; ! 295: struct tp_event E; ! 296: ! 297: IFDEBUG(D_XPD) ! 298: printf("tp_sendoob:"); ! 299: if (xdata) ! 300: printf("xdata len 0x%x\n", xdata->m_len); ! 301: ENDDEBUG ! 302: /* DO NOT LOCK the Xsnd buffer!!!! You can have at MOST one ! 303: * socket buf locked at any time!!! (otherwise you might ! 304: * sleep() in sblock() w/ a signal pending and cause the ! 305: * system call to be aborted w/ a locked socketbuf, which ! 306: * is a problem. So the so_snd buffer lock ! 307: * (done in sosend()) serves as the lock for Xpd. ! 308: */ ! 309: if (sb->sb_mb) { /* Anything already in eXpedited data sockbuf? */ ! 310: if (so->so_state & SS_NBIO) { ! 311: return EWOULDBLOCK; ! 312: } ! 313: while (sb->sb_mb) { ! 314: sbunlock(&so->so_snd); /* already locked by sosend */ ! 315: sbwait(&so->so_snd); ! 316: sblock(&so->so_snd); /* sosend will unlock on return */ ! 317: } ! 318: } ! 319: ! 320: if (xdata == (struct mbuf *)0) { ! 321: /* empty xpd packet */ ! 322: MGETHDR(xdata, M_WAIT, MT_OOBDATA); ! 323: if (xdata == NULL) { ! 324: return ENOBUFS; ! 325: } ! 326: xdata->m_len = 0; ! 327: xdata->m_pkthdr.len = 0; ! 328: } ! 329: IFDEBUG(D_XPD) ! 330: printf("tp_sendoob 1:"); ! 331: if (xdata) ! 332: printf("xdata len 0x%x\n", xdata->m_len); ! 333: ENDDEBUG ! 334: xmark = xdata; /* temporary use of variable xmark */ ! 335: while (xmark) { ! 336: len += xmark->m_len; ! 337: xmark = xmark->m_next; ! 338: } ! 339: if (len > TP_MAX_XPD_DATA) { ! 340: return EMSGSIZE; ! 341: } ! 342: IFDEBUG(D_XPD) ! 343: printf("tp_sendoob 2:"); ! 344: if (xdata) ! 345: printf("xdata len 0x%x\n", len); ! 346: ENDDEBUG ! 347: ! 348: ! 349: IFTRACE(D_XPD) ! 350: tptraceTPCB(TPPTmisc, "XPD mark m_next ", xdata->m_next, 0, 0, 0); ! 351: ENDTRACE ! 352: ! 353: sbappendrecord(sb, xdata); ! 354: ! 355: IFDEBUG(D_XPD) ! 356: printf("tp_sendoob len 0x%x\n", len); ! 357: dump_mbuf(so->so_snd.sb_mb, "XPD request Regular sndbuf:"); ! 358: dump_mbuf(tpcb->tp_Xsnd.sb_mb, "XPD request Xsndbuf:"); ! 359: ENDDEBUG ! 360: return DoEvent(T_XPD_req); ! 361: } ! 362: ! 363: /* ! 364: * CALLED FROM: ! 365: * the socket routines ! 366: * FUNCTION and ARGUMENTS: ! 367: * Handles all "user requests" except the [gs]ockopts() requests. ! 368: * The argument (req) is the request type (PRU*), ! 369: * (m) is an mbuf chain, generally used for send and ! 370: * receive type requests only. ! 371: * (nam) is used for addresses usually, in particular for the bind request. ! 372: * ! 373: */ ! 374: /*ARGSUSED*/ ! 375: ProtoHook ! 376: tp_usrreq(so, req, m, nam, controlp) ! 377: struct socket *so; ! 378: u_int req; ! 379: struct mbuf *m, *nam, *controlp; ! 380: { ! 381: register struct tp_pcb *tpcb = sototpcb(so); ! 382: int s = splnet(); ! 383: int error = 0; ! 384: int flags, *outflags = &flags; ! 385: u_long eotsdu = 0; ! 386: struct tp_event E; ! 387: ! 388: IFDEBUG(D_REQUEST) ! 389: printf("usrreq(0x%x,%d,0x%x,0x%x,0x%x)\n",so,req,m,nam,outflags); ! 390: if (so->so_error) ! 391: printf("WARNING!!! so->so_error is 0x%x\n", so->so_error); ! 392: ENDDEBUG ! 393: IFTRACE(D_REQUEST) ! 394: tptraceTPCB(TPPTusrreq, "req so m state [", req, so, m, ! 395: tpcb?tpcb->tp_state:0); ! 396: ENDTRACE ! 397: ! 398: if ((u_int)tpcb == 0 && req != PRU_ATTACH) { ! 399: IFTRACE(D_REQUEST) ! 400: tptraceTPCB(TPPTusrreq, "req failed NO TPCB[", 0, 0, 0, 0); ! 401: ENDTRACE ! 402: splx(s); ! 403: return ENOTCONN; ! 404: } ! 405: ! 406: switch (req) { ! 407: ! 408: case PRU_ATTACH: ! 409: if (tpcb) { ! 410: error = EISCONN; ! 411: break; ! 412: } ! 413: if (error = tp_attach(so, so->so_proto->pr_domain->dom_family)) ! 414: break; ! 415: tpcb = sototpcb(so); ! 416: break; ! 417: ! 418: case PRU_ABORT: /* called from close() */ ! 419: /* called for each incoming connect queued on the ! 420: * parent (accepting) socket ! 421: */ ! 422: if (tpcb->tp_state == TP_OPEN) { ! 423: E.ATTR(T_DISC_req).e_reason = E_TP_NO_SESSION; ! 424: error = DoEvent(T_DISC_req); /* pretend it was a close() */ ! 425: break; ! 426: } /* else DROP THROUGH */ ! 427: ! 428: case PRU_DETACH: /* called from close() */ ! 429: /* called only after disconnect was called */ ! 430: if (tpcb->tp_state == TP_LISTENING) { ! 431: register struct tp_pcb **tt; ! 432: for (tt = &tp_listeners; *tt; tt = &((*tt)->tp_nextlisten)) ! 433: if (*tt == tpcb) ! 434: break; ! 435: if (*tt) ! 436: *tt = tpcb->tp_nextlisten; ! 437: else { ! 438: for (tt = &tp_intercepts; *tt; tt = &((*tt)->tp_nextlisten)) ! 439: if (*tt == tpcb) ! 440: break; ! 441: if (*tt) ! 442: *tt = tpcb->tp_nextlisten; ! 443: else ! 444: printf("tp_usrreq - detach: should panic\n"); ! 445: } ! 446: } ! 447: if (tpcb->tp_next) ! 448: remque(tpcb); ! 449: error = DoEvent(T_DETACH); ! 450: if (tpcb->tp_state == TP_CLOSED) { ! 451: free((caddr_t)tpcb, M_PCB); ! 452: tpcb = 0; ! 453: } ! 454: break; ! 455: ! 456: case PRU_SHUTDOWN: ! 457: /* recv end may have been released; local credit might be zero */ ! 458: case PRU_DISCONNECT: ! 459: E.ATTR(T_DISC_req).e_reason = E_TP_NORMAL_DISC; ! 460: error = DoEvent(T_DISC_req); ! 461: break; ! 462: ! 463: case PRU_BIND: ! 464: error = (tpcb->tp_nlproto->nlp_pcbbind)(so->so_pcb, nam); ! 465: if (error == 0) { ! 466: (tpcb->tp_nlproto->nlp_getsufx)(so->so_pcb, &tpcb->tp_lsuffixlen, ! 467: tpcb->tp_lsuffix, TP_LOCAL); ! 468: } ! 469: break; ! 470: ! 471: case PRU_LISTEN: ! 472: if (tpcb->tp_lsuffixlen == 0) { ! 473: if (error = (tpcb->tp_nlproto->nlp_pcbbind)(so->so_pcb, MNULL)) ! 474: break; ! 475: (tpcb->tp_nlproto->nlp_getsufx)(so->so_pcb, &tpcb->tp_lsuffixlen, ! 476: tpcb->tp_lsuffix, TP_LOCAL); ! 477: } ! 478: if (tpcb->tp_next == 0) { ! 479: tpcb->tp_next = tpcb->tp_prev = tpcb; ! 480: tpcb->tp_nextlisten = tp_listeners; ! 481: tp_listeners = tpcb; ! 482: } ! 483: IFDEBUG(D_TPISO) ! 484: if (tpcb->tp_state != TP_CLOSED) ! 485: printf("LISTEN ERROR: state 0x%x\n", tpcb->tp_state); ! 486: ENDDEBUG ! 487: error = DoEvent(T_LISTEN_req); ! 488: break; ! 489: ! 490: case PRU_CONNECT2: ! 491: error = EOPNOTSUPP; /* for unix domain sockets */ ! 492: break; ! 493: ! 494: case PRU_CONNECT: ! 495: IFTRACE(D_CONN) ! 496: tptraceTPCB(TPPTmisc, ! 497: "PRU_CONNECT: so 0x%x *SHORT_LSUFXP(tpcb) 0x%x lsuflen 0x%x, class 0x%x", ! 498: tpcb->tp_sock, *SHORT_LSUFXP(tpcb), tpcb->tp_lsuffixlen, ! 499: tpcb->tp_class); ! 500: ENDTRACE ! 501: IFDEBUG(D_CONN) ! 502: printf("PRU_CONNECT: so *SHORT_LSUFXP(tpcb) 0x%x lsuflen 0x%x, class 0x%x", ! 503: tpcb->tp_sock, *SHORT_LSUFXP(tpcb), tpcb->tp_lsuffixlen, ! 504: tpcb->tp_class); ! 505: ENDDEBUG ! 506: if (tpcb->tp_lsuffixlen == 0) { ! 507: if (error = (tpcb->tp_nlproto->nlp_pcbbind)(so->so_pcb, MNULL)) { ! 508: IFDEBUG(D_CONN) ! 509: printf("pcbbind returns error 0x%x\n", error); ! 510: ENDDEBUG ! 511: break; ! 512: } ! 513: (tpcb->tp_nlproto->nlp_getsufx)(so->so_pcb, &tpcb->tp_lsuffixlen, ! 514: tpcb->tp_lsuffix, TP_LOCAL); ! 515: } ! 516: ! 517: IFDEBUG(D_CONN) ! 518: printf("isop 0x%x isop->isop_socket offset 12 :\n", tpcb->tp_npcb); ! 519: dump_buf(tpcb->tp_npcb, 16); ! 520: ENDDEBUG ! 521: if (error = tp_route_to(nam, tpcb, /* channel */0)) ! 522: break; ! 523: IFDEBUG(D_CONN) ! 524: printf( ! 525: "PRU_CONNECT after tpcb 0x%x so 0x%x npcb 0x%x flags 0x%x\n", ! 526: tpcb, so, tpcb->tp_npcb, tpcb->tp_flags); ! 527: printf("isop 0x%x isop->isop_socket offset 12 :\n", tpcb->tp_npcb); ! 528: dump_buf(tpcb->tp_npcb, 16); ! 529: ENDDEBUG ! 530: if (tpcb->tp_fsuffixlen == 0) { ! 531: /* didn't set peer extended suffix */ ! 532: (tpcb->tp_nlproto->nlp_getsufx)(so->so_pcb, &tpcb->tp_fsuffixlen, ! 533: tpcb->tp_fsuffix, TP_FOREIGN); ! 534: } ! 535: (void) (tpcb->tp_nlproto->nlp_mtu)(so, so->so_pcb, ! 536: &tpcb->tp_l_tpdusize, &tpcb->tp_tpdusize, 0); ! 537: if (tpcb->tp_state == TP_CLOSED) { ! 538: soisconnecting(so); ! 539: error = DoEvent(T_CONN_req); ! 540: } else { ! 541: (tpcb->tp_nlproto->nlp_pcbdisc)(so->so_pcb); ! 542: error = EISCONN; ! 543: } ! 544: IFPERF(tpcb) ! 545: u_int lsufx, fsufx; ! 546: lsufx = *(u_short *)(tpcb->tp_lsuffix); ! 547: fsufx = *(u_short *)(tpcb->tp_fsuffix); ! 548: ! 549: tpmeas(tpcb->tp_lref, ! 550: TPtime_open | (tpcb->tp_xtd_format << 4), ! 551: &time, lsufx, fsufx, tpcb->tp_fref); ! 552: ENDPERF ! 553: break; ! 554: ! 555: case PRU_ACCEPT: ! 556: (tpcb->tp_nlproto->nlp_getnetaddr)(so->so_pcb, nam, TP_FOREIGN); ! 557: IFDEBUG(D_REQUEST) ! 558: printf("ACCEPT PEERADDDR:"); ! 559: dump_buf(mtod(nam, char *), nam->m_len); ! 560: ENDDEBUG ! 561: IFPERF(tpcb) ! 562: u_int lsufx, fsufx; ! 563: lsufx = *(u_short *)(tpcb->tp_lsuffix); ! 564: fsufx = *(u_short *)(tpcb->tp_fsuffix); ! 565: ! 566: tpmeas(tpcb->tp_lref, TPtime_open, ! 567: &time, lsufx, fsufx, tpcb->tp_fref); ! 568: ENDPERF ! 569: break; ! 570: ! 571: case PRU_RCVD: ! 572: if (so->so_state & SS_ISCONFIRMING) { ! 573: if (tpcb->tp_state == TP_CONFIRMING) ! 574: error = tp_confirm(tpcb); ! 575: break; ! 576: } ! 577: IFTRACE(D_DATA) ! 578: tptraceTPCB(TPPTmisc, ! 579: "RCVD BF: lcredit sent_lcdt cc hiwat \n", ! 580: tpcb->tp_lcredit, tpcb->tp_sent_lcdt, ! 581: so->so_rcv.sb_cc, so->so_rcv.sb_hiwat); ! 582: LOCAL_CREDIT(tpcb); ! 583: tptraceTPCB(TPPTmisc, ! 584: "PRU_RCVD AF sbspace lcredit hiwat cc", ! 585: sbspace(&so->so_rcv), tpcb->tp_lcredit, ! 586: so->so_rcv.sb_cc, so->so_rcv.sb_hiwat); ! 587: ENDTRACE ! 588: IFDEBUG(D_REQUEST) ! 589: printf("RCVD: cc %d space %d hiwat %d\n", ! 590: so->so_rcv.sb_cc, sbspace(&so->so_rcv), ! 591: so->so_rcv.sb_hiwat); ! 592: ENDDEBUG ! 593: if (((int)nam) & MSG_OOB) ! 594: error = DoEvent(T_USR_Xrcvd); ! 595: else ! 596: error = DoEvent(T_USR_rcvd); ! 597: break; ! 598: ! 599: case PRU_RCVOOB: ! 600: if ((so->so_state & SS_ISCONNECTED) == 0) { ! 601: error = ENOTCONN; ! 602: break; ! 603: } ! 604: if (! tpcb->tp_xpd_service) { ! 605: error = EOPNOTSUPP; ! 606: break; ! 607: } ! 608: /* kludge - nam is really flags here */ ! 609: error = tp_rcvoob(tpcb, so, m, outflags, (int)nam); ! 610: break; ! 611: ! 612: case PRU_SEND: ! 613: case PRU_SENDOOB: ! 614: if (controlp) { ! 615: error = tp_snd_control(controlp, so, &m); ! 616: controlp = NULL; ! 617: if (error) ! 618: break; ! 619: } ! 620: if ((so->so_state & SS_ISCONFIRMING) && ! 621: (tpcb->tp_state == TP_CONFIRMING) && ! 622: (error = tp_confirm(tpcb))) ! 623: break; ! 624: if (req == PRU_SENDOOB) { ! 625: error = (tpcb->tp_xpd_service == 0) ? ! 626: EOPNOTSUPP : tp_sendoob(tpcb, so, m, outflags); ! 627: break; ! 628: } ! 629: if (m == 0) ! 630: break; ! 631: if (m->m_flags & M_EOR) { ! 632: eotsdu = 1; ! 633: m->m_flags &= ~M_EOR; ! 634: } ! 635: if (eotsdu == 0 && m->m_pkthdr.len == 0) ! 636: break; ! 637: if (tpcb->tp_state != TP_AKWAIT && tpcb->tp_state != TP_OPEN) { ! 638: error = ENOTCONN; ! 639: break; ! 640: } ! 641: /* ! 642: * The protocol machine copies mbuf chains, ! 643: * prepends headers, assigns seq numbers, and ! 644: * puts the packets on the device. ! 645: * When they are acked they are removed from the socket buf. ! 646: * ! 647: * sosend calls this up until sbspace goes negative. ! 648: * Sbspace may be made negative by appending this mbuf chain, ! 649: * possibly by a whole cluster. ! 650: */ ! 651: { ! 652: register struct mbuf *n = m; ! 653: register struct sockbuf *sb = &so->so_snd; ! 654: int maxsize = tpcb->tp_l_tpdusize ! 655: - tp_headersize(DT_TPDU_type, tpcb) ! 656: - (tpcb->tp_use_checksum?4:0) ; ! 657: int totlen = n->m_pkthdr.len; ! 658: int mbufcnt = 0; ! 659: struct mbuf *nn; ! 660: ! 661: /* ! 662: * Could have eotsdu and no data.(presently MUST have ! 663: * an mbuf though, even if its length == 0) ! 664: */ ! 665: IFPERF(tpcb) ! 666: PStat(tpcb, Nb_from_sess) += totlen; ! 667: tpmeas(tpcb->tp_lref, TPtime_from_session, 0, 0, ! 668: PStat(tpcb, Nb_from_sess), totlen); ! 669: ENDPERF ! 670: IFDEBUG(D_SYSCALL) ! 671: printf( ! 672: "PRU_SEND: eot %d before sbappend 0x%x len 0x%x to sb @ 0x%x\n", ! 673: eotsdu, m, totlen, sb); ! 674: dump_mbuf(sb->sb_mb, "so_snd.sb_mb"); ! 675: dump_mbuf(m, "m : to be added"); ! 676: ENDDEBUG ! 677: /* ! 678: * Pre-packetize the data in the sockbuf ! 679: * according to negotiated mtu. Do it here ! 680: * where we can safely wait for mbufs. ! 681: * ! 682: * This presumes knowledge of sockbuf conventions. ! 683: */ ! 684: if (n = sb->sb_mb) ! 685: while (n->m_act) ! 686: n = n->m_act; ! 687: if ((nn = n) && n->m_pkthdr.len < maxsize) { ! 688: u_int space = maxsize - n->m_pkthdr.len; ! 689: ! 690: do { ! 691: if (n->m_flags & M_EOR) ! 692: goto on1; ! 693: } while (n->m_next && (n = n->m_next)); ! 694: if (totlen <= space) { ! 695: TPNagle1++; ! 696: n->m_next = m; ! 697: nn->m_pkthdr.len += totlen; ! 698: while (n = n->m_next) ! 699: sballoc(sb, n); ! 700: if (eotsdu) ! 701: nn->m_flags |= M_EOR; ! 702: goto on2; ! 703: } else { ! 704: /* ! 705: * Can't sleep here, because when you wake up ! 706: * packet you want to attach to may be gone! ! 707: */ ! 708: if (TNew && (n->m_next = m_copym(m, 0, space, M_NOWAIT))) { ! 709: nn->m_pkthdr.len += space; ! 710: TPNagle2++; ! 711: while (n = n->m_next) ! 712: sballoc(sb, n); ! 713: m_adj(m, space); ! 714: } ! 715: } ! 716: } ! 717: on1: mbufcnt++; ! 718: for (n = m; n->m_pkthdr.len > maxsize;) { ! 719: nn = m_copym(n, 0, maxsize, M_WAIT); ! 720: sbappendrecord(sb, nn); ! 721: m_adj(n, maxsize); ! 722: mbufcnt++; ! 723: } ! 724: if (eotsdu) ! 725: n->m_flags |= M_EOR; ! 726: sbappendrecord(sb, n); ! 727: on2: ! 728: IFTRACE(D_DATA) ! 729: tptraceTPCB(TPPTmisc, ! 730: "SEND BF: maxsize totlen mbufcnt eotsdu", ! 731: maxsize, totlen, mbufcnt, eotsdu); ! 732: ENDTRACE ! 733: IFDEBUG(D_SYSCALL) ! 734: printf("PRU_SEND: eot %d after sbappend 0x%x mbufcnt 0x%x\n", ! 735: eotsdu, n, mbufcnt); ! 736: dump_mbuf(sb->sb_mb, "so_snd.sb_mb"); ! 737: ENDDEBUG ! 738: if (tpcb->tp_state == TP_OPEN) ! 739: error = DoEvent(T_DATA_req); ! 740: IFDEBUG(D_SYSCALL) ! 741: printf("PRU_SEND: after driver error 0x%x \n",error); ! 742: printf("so_snd 0x%x cc 0t%d mbcnt 0t%d\n", ! 743: sb, sb->sb_cc, sb->sb_mbcnt); ! 744: dump_mbuf(sb->sb_mb, "so_snd.sb_mb after driver"); ! 745: ENDDEBUG ! 746: } ! 747: break; ! 748: ! 749: case PRU_SOCKADDR: ! 750: (tpcb->tp_nlproto->nlp_getnetaddr)(so->so_pcb, nam, TP_LOCAL); ! 751: break; ! 752: ! 753: case PRU_PEERADDR: ! 754: (tpcb->tp_nlproto->nlp_getnetaddr)(so->so_pcb, nam, TP_FOREIGN); ! 755: break; ! 756: ! 757: case PRU_CONTROL: ! 758: error = EOPNOTSUPP; ! 759: break; ! 760: ! 761: case PRU_PROTOSEND: ! 762: case PRU_PROTORCV: ! 763: case PRU_SENSE: ! 764: case PRU_SLOWTIMO: ! 765: case PRU_FASTTIMO: ! 766: error = EOPNOTSUPP; ! 767: break; ! 768: ! 769: default: ! 770: #ifdef ARGO_DEBUG ! 771: printf("tp_usrreq UNKNOWN PRU %d\n", req); ! 772: #endif ARGO_DEBUG ! 773: error = EOPNOTSUPP; ! 774: } ! 775: ! 776: IFDEBUG(D_REQUEST) ! 777: printf("%s, so 0x%x, tpcb 0x%x, error %d, state %d\n", ! 778: "returning from tp_usrreq", so, tpcb, error, ! 779: tpcb ? 0 : tpcb->tp_state); ! 780: ENDDEBUG ! 781: IFTRACE(D_REQUEST) ! 782: tptraceTPCB(TPPTusrreq, "END req so m state [", req, so, m, ! 783: tpcb?0:tpcb->tp_state); ! 784: ENDTRACE ! 785: if (controlp) { ! 786: m_freem(controlp); ! 787: printf("control data unexpectedly retained in tp_usrreq()"); ! 788: } ! 789: splx(s); ! 790: return error; ! 791: } ! 792: tp_ltrace(so, uio) ! 793: struct socket *so; ! 794: struct uio *uio; ! 795: { ! 796: IFTRACE(D_DATA) ! 797: register struct tp_pcb *tpcb = sototpcb(so); ! 798: if (tpcb) { ! 799: tptraceTPCB(TPPTmisc, "sosend so resid iovcnt", so, ! 800: uio->uio_resid, uio->uio_iovcnt, 0); ! 801: } ! 802: ENDTRACE ! 803: } ! 804: ! 805: tp_confirm(tpcb) ! 806: register struct tp_pcb *tpcb; ! 807: { ! 808: struct tp_event E; ! 809: if (tpcb->tp_state == TP_CONFIRMING) ! 810: return DoEvent(T_ACPT_req); ! 811: printf("Tp confirm called when not confirming; tpcb 0x%x, state 0x%x\n", ! 812: tpcb, tpcb->tp_state); ! 813: return 0; ! 814: } ! 815: ! 816: /* ! 817: * Process control data sent with sendmsg() ! 818: */ ! 819: tp_snd_control(m, so, data) ! 820: struct mbuf *m; ! 821: struct socket *so; ! 822: register struct mbuf **data; ! 823: { ! 824: register struct cmsghdr *ch; ! 825: int error = 0; ! 826: ! 827: if (m && m->m_len) { ! 828: ch = mtod(m, struct cmsghdr *); ! 829: m->m_len -= sizeof (*ch); ! 830: m->m_data += sizeof (*ch); ! 831: error = tp_ctloutput(PRCO_SETOPT, ! 832: so, ch->cmsg_level, ch->cmsg_type, &m); ! 833: if (ch->cmsg_type == TPOPT_DISC_DATA) { ! 834: if (data && *data) { ! 835: m_freem(*data); ! 836: *data = 0; ! 837: } ! 838: error = tp_usrreq(so, PRU_DISCONNECT, (struct mbuf *)0, ! 839: (caddr_t)0, (struct mbuf *)0); ! 840: } ! 841: } ! 842: if (m) ! 843: m_freem(m); ! 844: return error; ! 845: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.