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