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