![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tp_driver.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_driver.c CVS log | Up to [Net/2] / Net2 / netiso |
1.1 root 1: /* $Header$ */
2: /* $Source$ */
3: #ifndef lint
4: static char *rcsid = "$Header/**/$";
5: #endif lint
6: #define _XEBEC_PG static
7:
8: #include "tp_states.h"
9:
10: static struct act_ent {
11: int a_newstate;
12: int a_action;
13: } statetable[] = { {0,0},
14: #include "tp_states.init"
15: };
16:
17: /* %W% (Berkeley) %G% */
18: #include "param.h"
19: #include "socket.h"
20: #include "socketvar.h"
21: #include "protosw.h"
22: #include "mbuf.h"
23: #include "time.h"
24: #include "errno.h"
25: #include "../netiso/tp_param.h"
26: #include "../netiso/tp_stat.h"
27: #include "../netiso/tp_pcb.h"
28: #include "../netiso/tp_tpdu.h"
29: #include "../netiso/argo_debug.h"
30: #include "../netiso/tp_trace.h"
31: #include "../netiso/iso_errno.h"
32: #include "../netiso/tp_seq.h"
33: #include "../netiso/cons.h"
34:
35: #define DRIVERTRACE TPPTdriver
36: #define sbwakeup(sb) sowakeup(p->tp_sock, sb);
37: #define MCPY(d, w) (d ? m_copym(d, 0, (int)M_COPYALL, w): 0)
38:
39: static trick_hc = 1;
40:
41: int tp_emit(),
42: tp_goodack(), tp_goodXack(),
43: tp_stash()
44: ;
45: void tp_indicate(), tp_getoptions(),
46: tp_soisdisconnecting(), tp_soisdisconnected(),
47: tp_recycle_tsuffix(),
48: tp_etimeout(), tp_euntimeout(),
49: tp_euntimeout_lss(), tp_ctimeout(),
50: tp_cuntimeout(), tp_ctimeout_MIN(),
51: tp_freeref(), tp_detach(),
52: tp0_stash(), tp0_send(),
53: tp_netcmd(), tp_send()
54: ;
55:
56: typedef struct tp_pcb tpcb_struct;
57:
58:
59:
60: typedef tpcb_struct tp_PCB_;
61:
62: #include "tp_events.h"
63:
64: _XEBEC_PG int _Xebec_action(a,e,p)
65: int a;
66: struct tp_event *e;
67: tp_PCB_ *p;
68: {
69: switch(a) {
70: case -1: return tp_protocol_error(e,p);
71: case 0x1:
72: {
73: (void) tp_emit(DC_TPDU_type, p, 0, 0, MNULL);
74: }
75: break;
76: case 0x2:
77: {
78: # ifdef TP_DEBUG
79: if( e->ev_number != AK_TPDU )
80: printf("TPDU 0x%x in REFWAIT!!!!\n", e->ev_number);
81: # endif TP_DEBUG
82: }
83: break;
84: case 0x3:
85: {
86: /* oh, man is this grotesque or what? */
87: (void) tp_goodack(p, e->ev_union.EV_AK_TPDU.e_cdt, e->ev_union.EV_AK_TPDU.e_seq, e->ev_union.EV_AK_TPDU.e_subseq);
88: /* but it's necessary because this pseudo-ack may happen
89: * before the CC arrives, but we HAVE to adjust the
90: * snduna as a result of the ack, WHENEVER it arrives
91: */
92: }
93: break;
94: case 0x4:
95: {
96: tp_detach(p);
97: }
98: break;
99: case 0x5:
100: {
101: p->tp_refp->tpr_state = REF_OPEN; /* has timers ??? */
102: }
103: break;
104: case 0x6:
105: {
106: IFTRACE(D_CONN)
107: tptrace(TPPTmisc, "CR datalen data", e->ev_union.EV_CR_TPDU.e_datalen, e->ev_union.EV_CR_TPDU.e_data,0,0);
108: ENDTRACE
109: IFDEBUG(D_CONN)
110: printf("CR datalen 0x%x data 0x%x", e->ev_union.EV_CR_TPDU.e_datalen, e->ev_union.EV_CR_TPDU.e_data);
111: ENDDEBUG
112: p->tp_refp->tpr_state = REF_OPEN; /* has timers */
113: p->tp_fcredit = e->ev_union.EV_CR_TPDU.e_cdt;
114:
115: if (e->ev_union.EV_CR_TPDU.e_datalen > 0) {
116: /* n/a for class 0 */
117: ASSERT(p->tp_Xrcv.sb_cc == 0);
118: sbappendrecord(&p->tp_Xrcv, e->ev_union.EV_CR_TPDU.e_data);
119: e->ev_union.EV_CR_TPDU.e_data = MNULL;
120: }
121: }
122: break;
123: case 0x7:
124: {
125: IncStat(ts_tp0_conn);
126: IFTRACE(D_CONN)
127: tptrace(TPPTmisc, "Confiming", p, 0,0,0);
128: ENDTRACE
129: IFDEBUG(D_CONN)
130: printf("Confirming connection: p" );
131: ENDDEBUG
132: soisconnected(p->tp_sock);
133: (void) tp_emit(CC_TPDU_type, p, 0,0, MNULL) ;
134: p->tp_fcredit = 1;
135: }
136: break;
137: case 0x8:
138: {
139: IncStat(ts_tp4_conn); /* even though not quite open */
140: IFTRACE(D_CONN)
141: tptrace(TPPTmisc, "Confiming", p, 0,0,0);
142: ENDTRACE
143: IFDEBUG(D_CONN)
144: printf("Confirming connection: p" );
145: ENDDEBUG
146: soisconnecting(p->tp_sock);
147: if ((p->tp_rx_strat & TPRX_FASTSTART) && (p->tp_fcredit > 0))
148: p->tp_cong_win = p->tp_fcredit;
149: p->tp_retrans = p->tp_Nretrans;
150: tp_ctimeout(p->tp_refp, TM_retrans, (int)p->tp_cc_ticks);
151: }
152: break;
153: case 0x9:
154: {
155: register struct tp_ref *r = p->tp_refp;
156:
157: IFDEBUG(D_CONN)
158: printf("event: CR_TPDU emit CC failed done " );
159: ENDDEBUG
160: soisdisconnected(p->tp_sock);
161: tp_recycle_tsuffix( p );
162: tp_freeref(r);
163: tp_detach(p);
164: }
165: break;
166: case 0xa:
167: {
168: int error;
169: struct mbuf *data = MNULL;
170:
171: IFTRACE(D_CONN)
172: tptrace(TPPTmisc, "T_CONN_req flags ucddata", (int)p->tp_flags,
173: p->tp_ucddata, 0, 0);
174: ENDTRACE
175: data = MCPY(p->tp_ucddata, M_WAIT);
176: if (data) {
177: IFDEBUG(D_CONN)
178: printf("T_CONN_req.trans m_copy cc 0x%x\n",
179: p->tp_ucddata);
180: dump_mbuf(data, "sosnd @ T_CONN_req");
181: ENDDEBUG
182: }
183:
184: if (error = tp_emit(CR_TPDU_type, p, 0, 0, data) )
185: return error; /* driver WON'T change state; will return error */
186:
187: p->tp_refp->tpr_state = REF_OPEN; /* has timers */
188: if(p->tp_class != TP_CLASS_0) {
189: p->tp_retrans = p->tp_Nretrans;
190: tp_ctimeout(p->tp_refp, TM_retrans, (int)p->tp_cr_ticks);
191: }
192: }
193: break;
194: case 0xb:
195: {
196: sbflush(&p->tp_Xrcv); /* purge non-delivered data data */
197: if (e->ev_union.EV_DR_TPDU.e_datalen > 0) {
198: sbappendrecord(&p->tp_Xrcv, e->ev_union.EV_DR_TPDU.e_data);
199: e->ev_union.EV_DR_TPDU.e_data = MNULL;
200: }
201: /* must return no error, or disc data and reason can't be read */
202: tp_indicate(T_DISCONNECT, p, 0);
203: tp_soisdisconnected(p);
204: if (p->tp_class != TP_CLASS_0) {
205: if (p->tp_state == TP_OPEN ) {
206: tp_euntimeout(p->tp_refp, TM_data_retrans); /* all */
207: tp_cuntimeout(p->tp_refp, TM_retrans);
208: tp_cuntimeout(p->tp_refp, TM_inact);
209: tp_cuntimeout(p->tp_refp, TM_sendack);
210: }
211: tp_cuntimeout(p->tp_refp, TM_retrans);
212: if( e->ev_union.EV_DR_TPDU.e_sref != 0 )
213: (void) tp_emit(DC_TPDU_type, p, 0, 0, MNULL);
214: }
215: }
216: break;
217: case 0xc:
218: {
219: if( e->ev_union.EV_DR_TPDU.e_sref != 0 )
220: (void) tp_emit(DC_TPDU_type, p, 0, 0, MNULL);
221: /* reference timer already set - reset it to be safe (???) */
222: tp_euntimeout(p->tp_refp, TM_reference); /* all */
223: tp_etimeout(p->tp_refp, TM_reference, 0, 0, 0, (int)p->tp_refer_ticks);
224: }
225: break;
226: case 0xd:
227: {
228: tp_cuntimeout(p->tp_refp, TM_retrans);
229: tp_indicate(ER_TPDU, p, e->ev_union.EV_ER_TPDU.e_reason);
230: tp_soisdisconnected(p);
231: }
232: break;
233: case 0xe:
234: {
235: tp_cuntimeout(p->tp_refp, TM_retrans);
236: tp_soisdisconnected(p);
237: }
238: break;
239: case 0xf:
240: {
241: tp_indicate(ER_TPDU, p, e->ev_union.EV_ER_TPDU.e_reason);
242: tp_cuntimeout(p->tp_refp, TM_retrans);
243: tp_soisdisconnected(p);
244: }
245: break;
246: case 0x10:
247: {
248: tp_cuntimeout(p->tp_refp, TM_retrans);
249: tp_soisdisconnected(p);
250: }
251: break;
252: case 0x11:
253: { /* don't ask me why we have to do this - spec says so */
254: (void) tp_emit(DR_TPDU_type, p, 0, E_TP_NO_SESSION, MNULL);
255: /* don't bother with retransmissions of the DR */
256: }
257: break;
258: case 0x12:
259: {
260: tp_soisdisconnecting(p->tp_sock);
261: tp_indicate(ER_TPDU, p, e->ev_union.EV_ER_TPDU.e_reason);
262: tp_soisdisconnected(p);
263: tp_netcmd( p, CONN_CLOSE );
264: }
265: break;
266: case 0x13:
267: {
268: if (p->tp_state == TP_OPEN) {
269: tp_euntimeout(p->tp_refp, TM_data_retrans); /* all */
270: tp_cuntimeout(p->tp_refp, TM_inact);
271: tp_cuntimeout(p->tp_refp, TM_sendack);
272: }
273: tp_soisdisconnecting(p->tp_sock);
274: tp_indicate(ER_TPDU, p, e->ev_union.EV_ER_TPDU.e_reason);
275: p->tp_retrans = p->tp_Nretrans;
276: tp_ctimeout(p->tp_refp, TM_retrans, (int)p->tp_dr_ticks);
277: (void) tp_emit(DR_TPDU_type, p, 0, E_TP_PROTO_ERR, MNULL);
278: }
279: break;
280: case 0x14:
281: {
282: tp_cuntimeout(p->tp_refp, TM_retrans);
283: IncStat(ts_tp0_conn);
284: p->tp_fcredit = 1;
285: soisconnected(p->tp_sock);
286: }
287: break;
288: case 0x15:
289: {
290: IFDEBUG(D_CONN)
291: printf("trans: CC_TPDU in CRSENT state flags 0x%x\n",
292: (int)p->tp_flags);
293: ENDDEBUG
294: IncStat(ts_tp4_conn);
295: p->tp_fref = e->ev_union.EV_CC_TPDU.e_sref;
296: p->tp_fcredit = e->ev_union.EV_CC_TPDU.e_cdt;
297: p->tp_ackrcvd = 0;
298: if ((p->tp_rx_strat & TPRX_FASTSTART) && (e->ev_union.EV_CC_TPDU.e_cdt > 0))
299: p->tp_cong_win = e->ev_union.EV_CC_TPDU.e_cdt;
300: tp_getoptions(p);
301: tp_cuntimeout(p->tp_refp, TM_retrans);
302: if (p->tp_ucddata) {
303: IFDEBUG(D_CONN)
304: printf("dropping user connect data cc 0x%x\n",
305: p->tp_ucddata->m_len);
306: ENDDEBUG
307: m_freem(p->tp_ucddata);
308: p->tp_ucddata = 0;
309: }
310: soisconnected(p->tp_sock);
311: if (e->ev_union.EV_CC_TPDU.e_datalen > 0) {
312: ASSERT(p->tp_Xrcv.sb_cc == 0); /* should be empty */
313: sbappendrecord(&p->tp_Xrcv, e->ev_union.EV_CC_TPDU.e_data);
314: e->ev_union.EV_CC_TPDU.e_data = MNULL;
315: }
316:
317: (void) tp_emit(AK_TPDU_type, p, p->tp_rcvnxt, 0, MNULL);
318: tp_ctimeout(p->tp_refp, TM_inact, (int)p->tp_inact_ticks);
319: }
320: break;
321: case 0x16:
322: {
323: struct mbuf *data = MNULL;
324: int error;
325:
326: IncStat(ts_retrans_cr);
327: p->tp_cong_win = 1;
328: p->tp_ackrcvd = 0;
329: data = MCPY(p->tp_ucddata, M_NOWAIT);
330: if(p->tp_ucddata) {
331: IFDEBUG(D_CONN)
332: printf("TM_retrans.trans m_copy cc 0x%x\n", data);
333: dump_mbuf(p->tp_ucddata, "sosnd @ TM_retrans");
334: ENDDEBUG
335: if( data == MNULL )
336: return ENOBUFS;
337: }
338:
339: p->tp_retrans --;
340: if( error = tp_emit(CR_TPDU_type, p, 0, 0, data) ) {
341: p->tp_sock->so_error = error;
342: }
343: tp_ctimeout(p->tp_refp, TM_retrans, (int)p->tp_cr_ticks);
344: }
345: break;
346: case 0x17:
347: {
348: IncStat(ts_conn_gaveup);
349: p->tp_sock->so_error = ETIMEDOUT;
350: tp_indicate(T_DISCONNECT, p, ETIMEDOUT);
351: tp_soisdisconnected(p);
352: }
353: break;
354: case 0x18:
355: {
356: int error;
357: struct mbuf *data = MCPY(p->tp_ucddata, M_WAIT);
358:
359: if( error = tp_emit(CC_TPDU_type, p, 0, 0, data) ) {
360: p->tp_sock->so_error = error;
361: }
362: p->tp_retrans = p->tp_Nretrans;
363: tp_ctimeout(p->tp_refp, TM_retrans, (int)p->tp_cc_ticks);
364: }
365: break;
366: case 0x19:
367: {
368: int doack;
369:
370: /*
371: * Get rid of any confirm or connect data, so that if we
372: * crash or close, it isn't thought of as disconnect data.
373: */
374: if (p->tp_ucddata) {
375: m_freem(p->tp_ucddata);
376: p->tp_ucddata = 0;
377: }
378: tp_ctimeout(p->tp_refp, TM_inact, (int)p->tp_inact_ticks);
379: tp_cuntimeout(p->tp_refp, TM_retrans);
380: soisconnected(p->tp_sock);
381: tp_getoptions(p);
382: tp_ctimeout(p->tp_refp, TM_inact, (int)p->tp_inact_ticks);
383:
384: /* see also next 2 transitions, if you make any changes */
385:
386: doack = tp_stash(p, e);
387: IFDEBUG(D_DATA)
388: printf("tp_stash returns %d\n",doack);
389: ENDDEBUG
390:
391: if(doack) {
392: (void) tp_emit(AK_TPDU_type, p, p->tp_rcvnxt, 0, MNULL );
393: tp_ctimeout(p->tp_refp, TM_sendack, (int)p->tp_keepalive_ticks);
394: } else
395: tp_ctimeout( p->tp_refp, TM_sendack, (int)p->tp_sendack_ticks);
396:
397: IFDEBUG(D_DATA)
398: printf("after stash calling sbwakeup\n");
399: ENDDEBUG
400: }
401: break;
402: case 0x1a:
403: {
404: tp0_stash(p, e);
405: sbwakeup( &p->tp_sock->so_rcv );
406:
407: IFDEBUG(D_DATA)
408: printf("after stash calling sbwakeup\n");
409: ENDDEBUG
410: }
411: break;
412: case 0x1b:
413: {
414: int doack; /* tells if we must ack immediately */
415:
416: tp_ctimeout(p->tp_refp, TM_inact, (int)p->tp_inact_ticks);
417: sbwakeup( &p->tp_sock->so_rcv );
418:
419: doack = tp_stash(p, e);
420: IFDEBUG(D_DATA)
421: printf("tp_stash returns %d\n",doack);
422: ENDDEBUG
423:
424: if(doack)
425: (void) tp_emit(AK_TPDU_type, p, p->tp_rcvnxt, 0, MNULL );
426: else
427: tp_ctimeout_MIN( p->tp_refp, TM_sendack, (int)p->tp_sendack_ticks);
428:
429: IFDEBUG(D_DATA)
430: printf("after stash calling sbwakeup\n");
431: ENDDEBUG
432: }
433: break;
434: case 0x1c:
435: {
436: IFTRACE(D_DATA)
437: tptrace(TPPTmisc, "NIW seq rcvnxt lcredit ",
438: e->ev_union.EV_DT_TPDU.e_seq, p->tp_rcvnxt, p->tp_lcredit, 0);
439: ENDTRACE
440: IncStat(ts_dt_niw);
441: m_freem(e->ev_union.EV_DT_TPDU.e_data);
442: tp_ctimeout(p->tp_refp, TM_inact, (int)p->tp_inact_ticks);
443: (void) tp_emit(AK_TPDU_type, p, p->tp_rcvnxt, 0, MNULL );
444: }
445: break;
446: case 0x1d:
447: {
448: if (p->tp_ucddata) {
449: m_freem(p->tp_ucddata);
450: p->tp_ucddata = 0;
451: }
452: (void) tp_goodack(p, e->ev_union.EV_AK_TPDU.e_cdt, e->ev_union.EV_AK_TPDU.e_seq, e->ev_union.EV_AK_TPDU.e_subseq);
453: tp_cuntimeout(p->tp_refp, TM_retrans);
454:
455: tp_getoptions(p);
456: soisconnected(p->tp_sock);
457: IFTRACE(D_CONN)
458: struct socket *so = p->tp_sock;
459: tptrace(TPPTmisc,
460: "called sosiconn: so so_state rcv.sb_sel rcv.sb_flags",
461: so, so->so_state, so->so_rcv.sb_sel, so->so_rcv.sb_flags);
462: tptrace(TPPTmisc,
463: "called sosiconn 2: so_qlen so_error so_rcv.sb_cc so_head",
464: so->so_qlen, so->so_error, so->so_rcv.sb_cc, so->so_head);
465: ENDTRACE
466:
467: tp_ctimeout(p->tp_refp, TM_sendack, (int)p->tp_keepalive_ticks);
468: tp_ctimeout(p->tp_refp, TM_inact, (int)p->tp_inact_ticks);
469: }
470: break;
471: case 0x1e:
472: {
473: if( p->tp_state == TP_AKWAIT ) {
474: if (p->tp_ucddata) {
475: m_freem(p->tp_ucddata);
476: p->tp_ucddata = 0;
477: }
478: tp_cuntimeout(p->tp_refp, TM_retrans);
479: tp_getoptions(p);
480: soisconnected(p->tp_sock);
481: tp_ctimeout(p->tp_refp, TM_sendack, (int)p->tp_keepalive_ticks);
482: tp_ctimeout(p->tp_refp, TM_inact, (int)p->tp_inact_ticks);
483: }
484: IFTRACE(D_XPD)
485: tptrace(TPPTmisc, "XPD tpdu accepted Xrcvnxt, e_seq datalen m_len\n",
486: p->tp_Xrcvnxt,e->ev_union.EV_XPD_TPDU.e_seq, e->ev_union.EV_XPD_TPDU.e_datalen, e->ev_union.EV_XPD_TPDU.e_data->m_len);
487: ENDTRACE
488:
489: p->tp_sock->so_state |= SS_RCVATMARK;
490: e->ev_union.EV_XPD_TPDU.e_data->m_flags |= M_EOR;
491: sbinsertoob(&p->tp_Xrcv, e->ev_union.EV_XPD_TPDU.e_data);
492: IFDEBUG(D_XPD)
493: dump_mbuf(e->ev_union.EV_XPD_TPDU.e_data, "XPD TPDU: tp_Xrcv");
494: ENDDEBUG
495: tp_indicate(T_XDATA, p, 0);
496: sbwakeup( &p->tp_Xrcv );
497:
498: (void) tp_emit(XAK_TPDU_type, p, p->tp_Xrcvnxt, 0, MNULL);
499: SEQ_INC(p, p->tp_Xrcvnxt);
500: }
501: break;
502: case 0x1f:
503: {
504: if( p->tp_Xrcv.sb_cc == 0 ) {
505: /* kludge for select(): */
506: /* p->tp_sock->so_state &= ~SS_OOBAVAIL; */
507: }
508: }
509: break;
510: case 0x20:
511: {
512: IFTRACE(D_XPD)
513: tptrace(TPPTmisc, "XPD tpdu niw (Xrcvnxt, e_seq) or not cdt (cc)\n",
514: p->tp_Xrcvnxt, e->ev_union.EV_XPD_TPDU.e_seq, p->tp_Xrcv.sb_cc , 0);
515: ENDTRACE
516: if( p->tp_Xrcvnxt != e->ev_union.EV_XPD_TPDU.e_seq )
517: IncStat(ts_xpd_niw);
518: if( p->tp_Xrcv.sb_cc ) {
519: /* might as well kick 'em again */
520: tp_indicate(T_XDATA, p, 0);
521: IncStat(ts_xpd_dup);
522: }
523: m_freem(e->ev_union.EV_XPD_TPDU.e_data);
524: tp_ctimeout(p->tp_refp, TM_inact, (int)p->tp_inact_ticks);
525: /* don't send an xack because the xak gives "last one received", not
526: * "next one i expect" (dumb)
527: */
528: }
529: break;
530: case 0x21:
531: {
532: struct socket *so = p->tp_sock;
533:
534: /* detach from parent socket so it can finish closing */
535: if (so->so_head) {
536: if (!soqremque(so, 0) && !soqremque(so, 1))
537: panic("tp: T_DETACH");
538: so->so_head = 0;
539: }
540: tp_soisdisconnecting(p->tp_sock);
541: tp_netcmd( p, CONN_CLOSE);
542: tp_soisdisconnected(p);
543: }
544: break;
545: case 0x22:
546: {
547: struct socket *so = p->tp_sock;
548: struct mbuf *data = MNULL;
549:
550: /* detach from parent socket so it can finish closing */
551: if (so->so_head) {
552: if (!soqremque(so, 0) && !soqremque(so, 1))
553: panic("tp: T_DETACH");
554: so->so_head = 0;
555: }
556: if (p->tp_state != TP_CLOSING) {
557: tp_soisdisconnecting(p->tp_sock);
558: data = MCPY(p->tp_ucddata, M_NOWAIT);
559: (void) tp_emit(DR_TPDU_type, p, 0, E_TP_NORMAL_DISC, data);
560: p->tp_retrans = p->tp_Nretrans;
561: tp_ctimeout(p->tp_refp, TM_retrans, (int)p->tp_dr_ticks);
562: }
563: }
564: break;
565: case 0x23:
566: {
567: tp_soisdisconnecting(p->tp_sock);
568: tp_netcmd( p, CONN_CLOSE);
569: tp_soisdisconnected(p);
570: }
571: break;
572: case 0x24:
573: {
574: struct mbuf *data = MCPY(p->tp_ucddata, M_WAIT);
575:
576: if(p->tp_state == TP_OPEN) {
577: tp_euntimeout(p->tp_refp, TM_data_retrans); /* all */
578: tp_cuntimeout(p->tp_refp, TM_inact);
579: tp_cuntimeout(p->tp_refp, TM_sendack);
580: }
581: if (data) {
582: IFDEBUG(D_CONN)
583: printf("T_DISC_req.trans tp_ucddata 0x%x\n",
584: p->tp_ucddata);
585: dump_mbuf(data, "ucddata @ T_DISC_req");
586: ENDDEBUG
587: }
588: tp_soisdisconnecting(p->tp_sock);
589: p->tp_retrans = p->tp_Nretrans;
590: tp_ctimeout(p->tp_refp, TM_retrans, (int)p->tp_dr_ticks);
591:
592: if( trick_hc )
593: return tp_emit(DR_TPDU_type, p, 0, e->ev_union.EV_T_DISC_req.e_reason, data);
594: }
595: break;
596: case 0x25:
597: {
598: int error;
599: struct mbuf *data = MCPY(p->tp_ucddata, M_WAIT);
600:
601: IncStat(ts_retrans_cc);
602: p->tp_retrans --;
603: p->tp_cong_win = 1;
604: p->tp_ackrcvd = 0;
605:
606: if( error = tp_emit(CC_TPDU_type, p, 0, 0, data) )
607: p->tp_sock->so_error = error;
608: tp_ctimeout(p->tp_refp, TM_retrans, (int)p->tp_cc_ticks);
609: }
610: break;
611: case 0x26:
612: {
613: IncStat(ts_conn_gaveup);
614: tp_soisdisconnecting(p->tp_sock);
615: p->tp_sock->so_error = ETIMEDOUT;
616: tp_indicate(T_DISCONNECT, p, ETIMEDOUT);
617: (void) tp_emit(DR_TPDU_type, p, 0, E_TP_CONGEST, MNULL);
618: p->tp_retrans = p->tp_Nretrans;
619: tp_ctimeout(p->tp_refp, TM_retrans, (int)p->tp_dr_ticks);
620: }
621: break;
622: case 0x27:
623: {
624: tp_euntimeout(p->tp_refp, TM_data_retrans); /* all */
625: tp_cuntimeout(p->tp_refp, TM_inact);
626: tp_cuntimeout(p->tp_refp, TM_sendack);
627:
628: IncStat(ts_conn_gaveup);
629: tp_soisdisconnecting(p->tp_sock);
630: p->tp_sock->so_error = ETIMEDOUT;
631: tp_indicate(T_DISCONNECT, p, ETIMEDOUT);
632: (void) tp_emit(DR_TPDU_type, p, 0, E_TP_CONGEST_2, MNULL);
633: p->tp_retrans = p->tp_Nretrans;
634: tp_ctimeout(p->tp_refp, TM_retrans, (int)p->tp_dr_ticks);
635: }
636: break;
637: case 0x28:
638: {
639: p->tp_cong_win = 1;
640: p->tp_ackrcvd = 0;
641: /* resume XPD */
642: if ( p->tp_Xsnd.sb_mb ) {
643: struct mbuf *m = m_copy(p->tp_Xsnd.sb_mb, 0, (int)p->tp_Xsnd.sb_cc);
644: /* m_copy doesn't preserve the m_xlink field, but at this pt.
645: * that doesn't matter
646: */
647:
648: IFTRACE(D_XPD)
649: tptrace(TPPTmisc, "XPD retrans: Xuna Xsndnxt sndhiwat snduna",
650: p->tp_Xuna, p->tp_Xsndnxt, p->tp_sndhiwat,
651: p->tp_snduna);
652: ENDTRACE
653: IFDEBUG(D_XPD)
654: dump_mbuf(m, "XPD retrans emitting M");
655: ENDDEBUG
656: IncStat(ts_retrans_xpd);
657: p->tp_retrans --;
658: (void) tp_emit(XPD_TPDU_type, p, p->tp_Xuna, 1, m);
659: tp_ctimeout(p->tp_refp, TM_retrans, (int)p->tp_xpd_ticks);
660: }
661: }
662: break;
663: case 0x29:
664: {
665: register SeqNum low, lowsave = 0;
666: register struct tp_rtc *r = p->tp_snduna_rtc;
667: register struct mbuf *m;
668: register SeqNum high = e->ev_union.EV_TM_data_retrans.e_high;
669:
670: low = p->tp_snduna;
671: lowsave = high = low;
672:
673: tp_euntimeout_lss(p->tp_refp, TM_data_retrans,
674: SEQ_ADD(p, p->tp_sndhiwat, 1));
675: p->tp_retrans_hiwat = p->tp_sndhiwat;
676:
677: if ((p->tp_rx_strat & TPRX_EACH) == 0)
678: high = (high>low)?low:high;
679:
680: if( p->tp_rx_strat & TPRX_USE_CW ) {
681: register int i;
682:
683: p->tp_cong_win = 1;
684: p->tp_ackrcvd = 0;
685: i = SEQ_ADD(p, low, p->tp_cong_win);
686:
687: high = SEQ_MIN(p, high, p->tp_sndhiwat);
688:
689: }
690:
691: while( SEQ_LEQ(p, low, high) ){
692: if ( r == (struct tp_rtc *)0 ){
693: IFDEBUG(D_RTC)
694: printf( "tp: retrans rtc list is GONE!\n");
695: ENDDEBUG
696: break;
697: }
698: if ( r->tprt_seq == low ){
699: if(( m = m_copy(r->tprt_data, 0, r->tprt_octets ))== MNULL)
700: break;
701: (void) tp_emit(DT_TPDU_type, p, low, r->tprt_eot, m);
702: IncStat(ts_retrans_dt);
703: SEQ_INC(p, low );
704: }
705: r = r->tprt_next;
706: }
707: /* CE_BIT
708: if ( SEQ_LEQ(p, lowsave, high) ){
709: */
710: e->ev_union.EV_TM_data_retrans.e_retrans --;
711: tp_etimeout(p->tp_refp, TM_data_retrans, (caddr_t)lowsave,
712: (caddr_t)high, e->ev_union.EV_TM_data_retrans.e_retrans,
713: (p->tp_Nretrans - e->ev_union.EV_TM_data_retrans.e_retrans) * (int)p->tp_dt_ticks);
714: /* CE_BIT
715: }
716: */
717: }
718: break;
719: case 0x2a:
720: {
721: p->tp_retrans --;
722: (void) tp_emit(DR_TPDU_type, p, 0, E_TP_DR_NO_REAS, MNULL);
723: IncStat(ts_retrans_dr);
724: tp_ctimeout(p->tp_refp, TM_retrans, (int)p->tp_dr_ticks);
725: }
726: break;
727: case 0x2b:
728: {
729: p->tp_sock->so_error = ETIMEDOUT;
730: p->tp_refp->tpr_state = REF_FROZEN;
731: tp_recycle_tsuffix( p );
732: tp_etimeout(p->tp_refp, TM_reference, 0,0,0, (int)p->tp_refer_ticks);
733: }
734: break;
735: case 0x2c:
736: {
737: tp_freeref(p->tp_refp);
738: tp_detach(p);
739: }
740: break;
741: case 0x2d:
742: {
743: if( p->tp_class != TP_CLASS_0) {
744: tp_ctimeout(p->tp_refp, TM_inact, (int)p->tp_inact_ticks);
745: if ( e->ev_number == CC_TPDU )
746: (void) tp_emit(AK_TPDU_type, p, p->tp_rcvnxt, 0, MNULL);
747: }
748: /* ignore it if class 0 - state tables are blank for this */
749: }
750: break;
751: case 0x2e:
752: {
753: IFTRACE(D_DATA)
754: tptrace(TPPTmisc, "T_DATA_req sndhiwat snduna fcredit, tpcb",
755: p->tp_sndhiwat, p->tp_snduna, p->tp_fcredit, p);
756: ENDTRACE
757:
758: tp_send(p);
759: }
760: break;
761: case 0x2f:
762: {
763: int error = 0;
764:
765: /* resume XPD */
766: if ( p->tp_Xsnd.sb_mb ) {
767: struct mbuf *m = m_copy(p->tp_Xsnd.sb_mb, 0, (int)p->tp_Xsnd.sb_cc);
768: /* m_copy doesn't preserve the m_xlink field, but at this pt.
769: * that doesn't matter
770: */
771:
772: IFTRACE(D_XPD)
773: tptrace(TPPTmisc, "XPD req: Xuna Xsndnxt sndhiwat snduna",
774: p->tp_Xuna, p->tp_Xsndnxt, p->tp_sndhiwat,
775: p->tp_snduna);
776: ENDTRACE
777: IFDEBUG(D_XPD)
778: printf("T_XPD_req: sb_cc 0x%x\n", p->tp_Xsnd.sb_cc);
779: dump_mbuf(m, "XPD req emitting M");
780: ENDDEBUG
781: error =
782: tp_emit(XPD_TPDU_type, p, p->tp_Xuna, 1, m);
783: p->tp_retrans = p->tp_Nretrans;
784: tp_ctimeout(p->tp_refp, TM_retrans, (int)p->tp_xpd_ticks);
785: SEQ_INC(p, p->tp_Xsndnxt);
786: }
787: if(trick_hc)
788: return error;
789: }
790: break;
791: case 0x30:
792: {
793: IFDEBUG(D_ACKRECV)
794: printf("GOOD ACK seq 0x%x cdt 0x%x\n", e->ev_union.EV_AK_TPDU.e_seq, e->ev_union.EV_AK_TPDU.e_cdt);
795: ENDDEBUG
796: if( p->tp_class != TP_CLASS_0) {
797: tp_ctimeout(p->tp_refp, TM_inact, (int)p->tp_inact_ticks);
798: tp_euntimeout_lss(p->tp_refp, TM_data_retrans, e->ev_union.EV_AK_TPDU.e_seq);
799: }
800: sbwakeup( &p->tp_sock->so_snd );
801:
802: if (p->tp_sndhiwat <= p->tp_retrans_hiwat &&
803: p->tp_snduna <= p->tp_retrans_hiwat) {
804:
805: register struct mbuf *m;
806: /* extern struct mbuf *m_copy(); */
807: register struct tp_rtc *r;
808: SeqNum high, retrans, low_save;
809:
810: high = SEQ_MIN(p, SEQ_ADD(p, p->tp_snduna,
811: MIN(p->tp_cong_win, p->tp_fcredit)) - 1,
812: p->tp_sndhiwat);
813: low_save = retrans = SEQ_MAX(p, SEQ_ADD(p, p->tp_last_retrans, 1),
814: p->tp_snduna);
815: for (; SEQ_LEQ(p, retrans, high); SEQ_INC(p, retrans)) {
816:
817: for (r = p->tp_snduna_rtc; r; r = r->tprt_next){
818: if ( r->tprt_seq == retrans ){
819: if(( m = m_copy(r->tprt_data, 0, r->tprt_octets ))
820: == MNULL)
821: break;
822: (void) tp_emit(DT_TPDU_type, p, retrans,
823: r->tprt_eot, m);
824: p->tp_last_retrans = retrans;
825: IncStat(ts_retrans_dt);
826: break;
827: }
828: }
829: if ( r == (struct tp_rtc *)0 ){
830: IFDEBUG(D_RTC)
831: printf( "tp: retrans rtc list is GONE!\n");
832: ENDDEBUG
833: break;
834: }
835: }
836: tp_etimeout(p->tp_refp, TM_data_retrans, (caddr_t)low_save,
837: (caddr_t)high, p->tp_retrans, (int)p->tp_dt_ticks);
838: if (SEQ_DEC(p, retrans) == p->tp_retrans_hiwat)
839: tp_send(p);
840: }
841: else {
842: tp_send(p);
843: }
844: IFDEBUG(D_ACKRECV)
845: printf("GOOD ACK new sndhiwat 0x%x\n", p->tp_sndhiwat);
846: ENDDEBUG
847: }
848: break;
849: case 0x31:
850: {
851: IFTRACE(D_ACKRECV)
852: tptrace(TPPTmisc, "BOGUS ACK fcc_present, tp_r_subseq e_subseq",
853: e->ev_union.EV_AK_TPDU.e_fcc_present, p->tp_r_subseq, e->ev_union.EV_AK_TPDU.e_subseq, 0);
854: ENDTRACE
855: if( p->tp_class != TP_CLASS_0 ) {
856:
857: if ( !e->ev_union.EV_AK_TPDU.e_fcc_present ) {
858: /* send ACK with FCC */
859: IncStat( ts_ackreason[_ACK_FCC_] );
860: (void) tp_emit(AK_TPDU_type, p, p->tp_rcvnxt, 1, MNULL);
861: }
862: tp_ctimeout(p->tp_refp, TM_inact, (int)p->tp_inact_ticks);
863: }
864: }
865: break;
866: case 0x32:
867: {
868: tp_ctimeout(p->tp_refp, TM_inact, (int)p->tp_inact_ticks);
869: tp_cuntimeout(p->tp_refp, TM_retrans);
870:
871: sbwakeup( &p->tp_sock->so_snd );
872:
873: /* resume normal data */
874: tp_send(p);
875: }
876: break;
877: case 0x33:
878: {
879: IFTRACE(D_ACKRECV)
880: tptrace(TPPTmisc, "BOGUS XACK eventtype ", e->ev_number, 0, 0,0);
881: ENDTRACE
882: if( p->tp_class != TP_CLASS_0 ) {
883: tp_ctimeout(p->tp_refp, TM_inact, (int)p->tp_inact_ticks);
884: }
885: }
886: break;
887: case 0x34:
888: {
889: IFTRACE(D_TIMER)
890: tptrace(TPPTsendack, -1, p->tp_lcredit, p->tp_sent_uwe,
891: p->tp_sent_lcdt, 0);
892: ENDTRACE
893: IncPStat(p, tps_n_TMsendack);
894: (void) tp_emit(AK_TPDU_type, p, p->tp_rcvnxt, 0, MNULL);
895: }
896: break;
897: case 0x35:
898: {
899: if (sbspace(&p->tp_sock->so_rcv) > 0)
900: tp0_openflow(p);
901: }
902: break;
903: case 0x36:
904: {
905: if( trick_hc ) {
906: IncStat(ts_ackreason[_ACK_USRRCV_]);
907:
908: /* send an ACK only if there's new information */
909: LOCAL_CREDIT( p );
910: if ((p->tp_rcvnxt != p->tp_sent_rcvnxt) ||
911: (p->tp_lcredit != p->tp_sent_lcdt))
912:
913: return tp_emit(AK_TPDU_type, p, p->tp_rcvnxt, 0, MNULL);
914: }
915: }
916: break;
917: case 0x37:
918: {
919: if(trick_hc)
920: return ECONNABORTED;
921: }
922: break;
923: case 0x38:
924: {
925: ASSERT( p->tp_state != TP_LISTENING );
926: tp_indicate(T_DISCONNECT, p, ECONNRESET);
927: tp_soisdisconnected(p);
928: }
929: break;
930: }
931: return 0;
932: }
933:
934: _XEBEC_PG int
935: _Xebec_index( e,p )
936: struct tp_event *e;
937: tp_PCB_ *p;
938: {
939: switch( (e->ev_number<<4)+(p->tp_state) ) {
940: case 0x12:
941: if ( p->tp_retrans > 0 ) return 0x1e;
942: else return 0x1f;
943: case 0x13:
944: if ( p->tp_retrans > 0 ) return 0x2f;
945: else return 0x30;
946: case 0x14:
947: if ( p->tp_retrans > 0 ) return 0x32;
948: else return 0x31;
949: case 0x15:
950: if ( p->tp_retrans > 0 ) return 0x34;
951: else return 0x35;
952: case 0x54:
953: if ( e->ev_union.EV_TM_data_retrans.e_retrans > 0 ) return 0x33;
954: else return 0x31;
955: case 0x64:
956: if (p->tp_class == TP_CLASS_0) return 0x1a;
957: else return 0x1b;
958: case 0x77:
959: if ( p->tp_class == TP_CLASS_0) return 0xd;
960: else return 0xe;
961: case 0x86:
962: if ( e->ev_union.EV_DR_TPDU.e_sref != 0 ) return 0x2;
963: else return 0x3;
964: case 0xa2:
965: if (p->tp_class == TP_CLASS_0) return 0x1c;
966: else return 0x1d;
967: case 0xb2:
968: if (p->tp_class == TP_CLASS_0) return 0x5;
969: else return 0x0;
970: case 0xb4:
971: if ( tp_goodack(p, e->ev_union.EV_AK_TPDU.e_cdt, e->ev_union.EV_AK_TPDU.e_seq, e->ev_union.EV_AK_TPDU.e_subseq) ) return 0x3a;
972: else return 0x3b;
973: case 0xc3:
974: if ( IN_RWINDOW( p, e->ev_union.EV_DT_TPDU.e_seq,
975: p->tp_rcvnxt, SEQ(p, p->tp_rcvnxt + p->tp_lcredit)) ) return 0x21;
976: else return 0x24;
977: case 0xc4:
978: if ( p->tp_class == TP_CLASS_0 ) return 0x22;
979: else if ( IN_RWINDOW( p, e->ev_union.EV_DT_TPDU.e_seq,
980: p->tp_rcvnxt, SEQ(p, p->tp_rcvnxt + p->tp_lcredit)) ) return 0x23;
981: else return 0x25;
982: case 0xd3:
983: if (p->tp_Xrcvnxt == e->ev_union.EV_XPD_TPDU.e_seq) return 0x27;
984: else return 0x2a;
985: case 0xd4:
986: if (p->tp_Xrcvnxt == e->ev_union.EV_XPD_TPDU.e_seq) return 0x27;
987: else return 0x29;
988: case 0xe4:
989: if ( tp_goodXack(p, e->ev_union.EV_XAK_TPDU.e_seq) ) return 0x3c;
990: else return 0x3d;
991: case 0x102:
992: if ( p->tp_class == TP_CLASS_0 ) return 0x2d;
993: else return 0x2e;
994: case 0x104:
995: if ( p->tp_class == TP_CLASS_0 ) return 0x2d;
996: else return 0x2e;
997: case 0x144:
998: if (p->tp_class == TP_CLASS_0) return 0x3f;
999: else return 0x40;
1000: case 0x162:
1001: if (p->tp_class == TP_CLASS_0) return 0x2b;
1002: else return 0x2c;
1003: case 0x172:
1004: if ( p->tp_class != TP_CLASS_4 ) return 0x42;
1005: else return 0x46;
1006: case 0x174:
1007: if ( p->tp_class != TP_CLASS_4 ) return 0x42;
1008: else return 0x47;
1009: case 0x177:
1010: if ( p->tp_class != TP_CLASS_4 ) return 0x42;
1011: else return 0x43;
1012: case 0x188:
1013: if ( p->tp_class == TP_CLASS_0 ) return 0xf;
1014: else if (tp_emit(CC_TPDU_type, p, 0,0, MCPY(p->tp_ucddata, M_NOWAIT)) == 0) return 0x10;
1015: else return 0x11;
1016: default: return 0;
1017: } /* end switch */
1018: } /* _Xebec_index() */
1019: static int inx[26][9] = { {0,0,0,0,0,0,0,0,0,},
1020: {0x0,0x0,0x0,0x0,0x31,0x0,0x0,0x0,0x0, },
1021: {0x0,0x0,-1,-1,-1,-1,0x0,0x0,0x0, },
1022: {0x0,0x0,0x0,0x0,0x3e,0x0,0x0,0x0,0x0, },
1023: {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0, },
1024: {0x0,0x0,0x0,0x0,0x0,0x0,0x36,0x0,0x0, },
1025: {0x0,0x0,0x0,0x0,-1,0x0,0x0,0x0,0x0, },
1026: {0x0,0x7,0x15,0x1b,-1,0x17,0x3,0xa,0x0, },
1027: {0x0,0x19,0x6,0x20,0x37,0x8,0x3,-1,0x0, },
1028: {0x0,0x14,0x13,0x13,0x13,0x16,-1,0xa,0x0, },
1029: {0x0,0x7,0x6,0x1,0x9,0x18,0x3,0xa,0x0, },
1030: {0x0,0x19,-1,0x1,0x37,0x8,0x3,0xa,0x0, },
1031: {0x0,0x7,-1,0x26,-1,0x8,0x3,0xa,0x0, },
1032: {0x0,0x7,0x6,-1,-1,0x8,0x3,0xa,0x0, },
1033: {0x0,0x7,0x6,-1,-1,0x8,0x3,0xa,0x0, },
1034: {0x0,0x7,0x6,0x1,-1,0x8,0x3,0xa,0x0, },
1035: {0x0,0x12,0x0,0x0,0x0,0x0,0x0,0x0,0x0, },
1036: {0x0,0x0,-1,0x2e,-1,0x0,0x4,0x0,0x2e, },
1037: {0x0,0xb,0x0,0x0,0x0,0x0,0x0,0x0,0x0, },
1038: {0x0,0x0,0x0,0x0,0x38,0x0,0x0,0x0,0x0, },
1039: {0x0,0x0,0x0,0x0,0x39,0x0,0x0,0x0,0x0, },
1040: {0x0,0x0,0x0,0x0,-1,0x0,0x41,0x0,0x0, },
1041: {0x0,0x0,0x0,0x0,0x28,0x0,0x41,0x0,0x0, },
1042: {0x0,0xc,-1,0x2c,0x0,0x2c,0x4,0xc,0x2c, },
1043: {0x0,0x49,-1,0x45,-1,0x44,0x48,-1,0x0, },
1044: {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,-1, },
1045: };
1046: tp_driver(p, e)
1047: register tp_PCB_ *p;
1048: register struct tp_event *e;
1049: {
1050: register int index, error=0;
1051: struct act_ent *a;
1052: static struct act_ent erroraction = {0,-1};
1053:
1054: index = inx[1 + e->ev_number][p->tp_state];
1055: if(index<0) index=_Xebec_index(e, p);
1056: if (index==0) {
1057: a = &erroraction;
1058: } else
1059: a = &statetable[index];
1060:
1061: if(a->a_action)
1062: error = _Xebec_action( a->a_action, e, p );
1063: IFTRACE(D_DRIVER)
1064: tptrace(DRIVERTRACE, a->a_newstate, p->tp_state, e->ev_number, a->a_action, 0);
1065:
1066: ENDTRACE
1067: if(error==0)
1068: p->tp_state = a->a_newstate;
1069: return error;
1070: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.