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