![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tp_input.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_input.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_input.c,v 5.6 88/11/18 17:27:38 nhall Exp $
31: * $Source: /usr/argo/sys/netiso/RCS/tp_input.c,v $
32: * @(#)tp_input.c 7.14 (Berkeley) 7/24/90 *
33: *
34: * tp_input() gets an mbuf chain from ip. Actually, not directly
35: * from ip, because ip calls a net-level routine that strips off
36: * the net header and then calls tp_input(), passing the proper type
37: * of addresses for the address family in use (how it figures out
38: * which AF is not yet determined.
39: *
40: * Decomposing the tpdu is some of the most laughable code. The variable-length
41: * parameters and the problem of non-aligned memory references
42: * necessitates such abominations as the macros WHILE_OPTIONS (q.v. below)
43: * to loop through the header and decompose it.
44: *
45: * The routine tp_newsocket() is called when a CR comes in for a listening
46: * socket. tp_input calls sonewconn() and tp_newsocket() to set up the
47: * "child" socket. Most tpcb values are copied from the parent tpcb into
48: * the child.
49: *
50: * Also in here is tp_headersize() (grot) which tells the expected size
51: * of a tp header, to be used by other layers. It's in here because it
52: * uses the static structure tpdu_info.
53: */
54:
55: #ifndef lint
56: static char *rcsid = "$Header: tp_input.c,v 5.6 88/11/18 17:27:38 nhall Exp $";
57: #endif lint
58:
59: #include "argoxtwentyfive.h"
60: #include "param.h"
61: #include "systm.h"
62: #include "mbuf.h"
63: #include "socket.h"
64: #include "socketvar.h"
65: #include "domain.h"
66: #include "protosw.h"
67: #include "errno.h"
68: #include "time.h"
69: #include "kernel.h"
70: #include "types.h"
71: #include "iso_errno.h"
72: #include "tp_param.h"
73: #include "tp_timer.h"
74: #include "tp_stat.h"
75: #include "tp_pcb.h"
76: #include "argo_debug.h"
77: #include "tp_trace.h"
78: #include "tp_tpdu.h"
79: #include "iso.h"
80: #include "cons.h"
81:
82: int iso_check_csum(), tp_driver(), tp_headersize(), tp_error_emit();
83:
84: /*
85: #ifdef lint
86: #undef ATTR
87: #define ATTR(X)ev_number
88: #endif lint
89: */
90:
91: struct mbuf *
92: tp_inputprep(m)
93: register struct mbuf *m;
94: {
95: int hdrlen;
96:
97: IFDEBUG(D_TPINPUT)
98: printf("tp_inputprep: m 0x%x\n", m) ;
99: ENDDEBUG
100:
101: while( m->m_len < 1 ) {
102: if( (m = m_free(m)) == MNULL ) {
103: return (struct mbuf *)0;
104: }
105: }
106: if(((int)m->m_data) & 0x3) {
107: /* If we are not 4-byte aligned, we have to be
108: * above the beginning of the mbuf, and it is ok just
109: * to slide it back.
110: */
111: caddr_t ocp = m->m_data;
112:
113: m->m_data = (caddr_t)(((int)m->m_data) & ~0x3);
114: ovbcopy(ocp, m->m_data, (unsigned)m->m_len);
115: }
116: CHANGE_MTYPE(m, TPMT_DATA);
117:
118: /* we KNOW that there is at least 1 byte in this mbuf
119: and that it is hdr->tpdu_li XXXXXXX! */
120:
121: hdrlen = 1 + *mtod( m, u_char *);
122:
123: /*
124: * now pull up the whole tp header
125: */
126: if ( m->m_len < hdrlen) {
127: if ((m = m_pullup(m, hdrlen)) == MNULL ) {
128: IncStat(ts_recv_drop);
129: return (struct mbuf *)0;
130: }
131: }
132: IFDEBUG(D_INPUT)
133: printf(
134: " at end: m 0x%x hdr->tpdu_li 0x%x m_len 0x%x\n",m,
135: hdrlen, m->m_len);
136: ENDDEBUG
137: return m;
138: }
139:
140: /* begin groan
141: * -- this array and the following macros allow you to step through the
142: * parameters of the variable part of a header
143: * note that if for any reason the values of the **_TPDU macros (in tp_events.h)
144: * should change, this array has to be rearranged
145: */
146:
147: #define TP_LEN_CLASS_0_INDEX 2
148: #define TP_MAX_DATA_INDEX 3
149:
150: static u_char tpdu_info[][4] =
151: {
152: /* length max data len */
153: /* reg fmt xtd fmt class 0 */
154: /* UNUSED 0x0 */ 0x0 , 0x0, 0x0, 0x0,
155: /* XPD_TPDU_type 0x1 */ 0x5, 0x8, 0x0, TP_MAX_XPD_DATA,
156: /* XAK_TPDU_type 0x2 */ 0x5 , 0x8, 0x0, 0x0,
157: /* GR_TPDU_type 0x3 */ 0x0 , 0x0, 0x0, 0x0,
158: /* UNUSED 0x4 */ 0x0 , 0x0, 0x0, 0x0,
159: /* UNUSED 0x5 */ 0x0 , 0x0, 0x0, 0x0,
160: /* AK_TPDU_type 0x6 */ 0x5, 0xa, 0x0, 0x0,
161: /* ER_TPDU_type 0x7 */ 0x5, 0x5, 0x0, 0x0,
162: /* DR_TPDU_type 0x8 */ 0x7, 0x7, 0x7, TP_MAX_DR_DATA,
163: /* UNUSED 0x9 */ 0x0 , 0x0, 0x0, 0x0,
164: /* UNUSED 0xa */ 0x0 , 0x0, 0x0, 0x0,
165: /* UNUSED 0xb */ 0x0 , 0x0, 0x0, 0x0,
166: /* DC_TPDU_type 0xc */ 0x6, 0x6, 0x0, 0x0,
167: /* CC_TPDU_type 0xd */ 0x7, 0x7, 0x7, TP_MAX_CC_DATA,
168: /* CR_TPDU_type 0xe */ 0x7, 0x7, 0x7, TP_MAX_CR_DATA,
169: /* DT_TPDU_type 0xf */ 0x5, 0x8, 0x3, 0x0,
170: };
171:
172: #define CHECK(Phrase, Erval, Stat, Whattodo, Loc)\
173: if (Phrase) {error = (Erval); errlen = (int)(Loc); IncStat(Stat); tpibrk();\
174: goto Whattodo; }
175:
176: tpibrk() {}
177:
178: /*
179: * WHENEVER YOU USE THE FOLLOWING MACRO,
180: * BE SURE THE TPDUTYPE IS A LEGIT VALUE FIRST!
181: */
182:
183: #define WHILE_OPTIONS(P, hdr, format)\
184: { register caddr_t P = tpdu_info[(hdr)->tpdu_type][(format)] + (caddr_t)hdr;\
185: caddr_t PLIM = 1 + hdr->tpdu_li + (caddr_t)hdr;\
186: for (;; P += 2 + ((struct tp_vbp *)P)->tpv_len) {\
187: CHECK((P > PLIM), E_TP_LENGTH_INVAL, ts_inv_length,\
188: respond, P - (caddr_t)hdr);\
189: if (P == PLIM) break;
190:
191: #define END_WHILE_OPTIONS(P) } }
192:
193: /* end groan */
194:
195: /*
196: * NAME: tp_newsocket()
197: *
198: * CALLED FROM:
199: * tp_input() on incoming CR, when a socket w/ the called suffix
200: * is awaiting a connection request
201: *
202: * FUNCTION and ARGUMENTS:
203: * Create a new socket structure, attach to it a new transport pcb,
204: * using a copy of the net level pcb for the parent socket.
205: * (so) is the parent socket.
206: * (fname) is the foreign address (all that's used is the nsap portion)
207: *
208: * RETURN VALUE:
209: * a new socket structure, being this end of the newly formed connection.
210: *
211: * SIDE EFFECTS:
212: * Sets a few things in the tpcb and net level pcb
213: *
214: * NOTES:
215: */
216: static struct socket *
217: tp_newsocket(so, fname, cons_channel, class_to_use, netservice)
218: struct socket *so;
219: struct sockaddr *fname;
220: u_int cons_channel;
221: u_char class_to_use;
222: u_int netservice;
223: {
224: register struct tp_pcb *tpcb = sototpcb(so); /* old tpcb, needed below */
225: struct tp_pcb * newtpcb;
226:
227: /*
228: * sonewconn() gets a new socket structure,
229: * a new lower layer pcb and a new tpcb,
230: * but the pcbs are unnamed (not bound)
231: */
232: IFTRACE(D_NEWSOCK)
233: tptraceTPCB(TPPTmisc, "newsock: listg_so, _tpcb, so_head",
234: so, tpcb, so->so_head, 0);
235: ENDTRACE
236:
237: if ((so = sonewconn(so, SS_ISCONFIRMING)) == (struct socket *)0)
238: return so;
239: IFTRACE(D_NEWSOCK)
240: tptraceTPCB(TPPTmisc, "newsock: after newconn so, so_head",
241: so, so->so_head, 0, 0);
242: ENDTRACE
243:
244: IFDEBUG(D_NEWSOCK)
245: printf("tp_newsocket(channel 0x%x) after sonewconn so 0x%x \n",
246: cons_channel, so);
247: dump_addr(fname);
248: {
249: struct socket *t, *head ;
250:
251: head = so->so_head;
252: t = so;
253: printf("so 0x%x so_head 0x%x so_q0 0x%x, q0len %d\n",
254: t, t->so_head, t->so_q0, t->so_q0len);
255: while( (t=t->so_q0) && t!= so && t!= head)
256: printf("so 0x%x so_head 0x%x so_q0 0x%x, q0len %d\n",
257: t, t->so_head, t->so_q0, t->so_q0len);
258: }
259: ENDDEBUG
260:
261: /*
262: * before we clobber the old tpcb ptr, get these items from the parent pcb
263: */
264: newtpcb = sototpcb(so);
265: newtpcb->_tp_param = tpcb->_tp_param;
266: newtpcb->tp_flags = tpcb->tp_flags;
267: newtpcb->tp_lcredit = tpcb->tp_lcredit;
268: newtpcb->tp_l_tpdusize = tpcb->tp_l_tpdusize;
269: newtpcb->tp_lsuffixlen = tpcb->tp_lsuffixlen;
270: bcopy( tpcb->tp_lsuffix, newtpcb->tp_lsuffix, newtpcb->tp_lsuffixlen);
271: soreserve(so, (u_long)tpcb->tp_winsize, (u_long)tpcb->tp_winsize);
272:
273: if( /* old */ tpcb->tp_ucddata) {
274: /*
275: * These data are the connect- , confirm- or disconnect- data.
276: */
277: struct mbuf *conndata;
278:
279: conndata = m_copy(tpcb->tp_ucddata, 0, (int)M_COPYALL);
280: IFDEBUG(D_CONN)
281: dump_mbuf(conndata, "conndata after mcopy");
282: ENDDEBUG
283: newtpcb->tp_ucddata = conndata;
284: }
285:
286: tpcb = newtpcb;
287: tpcb->tp_state = TP_LISTENING;
288: tpcb->tp_class = class_to_use;
289: tpcb->tp_netservice = netservice;
290:
291:
292: ASSERT( fname != 0 ) ; /* just checking */
293: if ( fname ) {
294: /*
295: * tp_route_to takes its address argument in the form of an mbuf.
296: */
297: struct mbuf *m;
298: int err;
299:
300: MGET(m, M_DONTWAIT, MT_SONAME); /* mbuf type used is confusing */
301: if (m) {
302: /*
303: * this seems a bit grotesque, but tp_route_to expects
304: * an mbuf * instead of simply a sockaddr; it calls the ll
305: * pcb_connect, which expects the name/addr in an mbuf as well.
306: * sigh.
307: */
308: bcopy((caddr_t)fname, mtod(m, caddr_t), fname->sa_len);
309: m->m_len = fname->sa_len;
310:
311: /* grot : have to say the kernel can override params in
312: * the passive open case
313: */
314: tpcb->tp_dont_change_params = 0;
315: err = tp_route_to( m, tpcb, cons_channel);
316: m_free(m);
317:
318: if (!err)
319: goto ok;
320: }
321: IFDEBUG(D_CONN)
322: printf("tp_route_to FAILED! detaching tpcb 0x%x, so 0x%x\n",
323: tpcb, so);
324: ENDDEBUG
325: (void) tp_detach(tpcb);
326: return 0;
327: }
328: ok:
329: IFDEBUG(D_TPINPUT)
330: printf("tp_newsocket returning so 0x%x, sototpcb(so) 0x%x\n",
331: so, sototpcb(so));
332: ENDDEBUG
333: return so;
334: }
335:
336: #ifndef CONS
337: tpcons_output()
338: {
339: return(0);
340: }
341: #endif !CONS
342:
343: /*
344: * NAME: tp_input()
345: *
346: * CALLED FROM:
347: * net layer input routine
348: *
349: * FUNCTION and ARGUMENTS:
350: * Process an incoming TPDU (m), finding the associated tpcb if there
351: * is one. Create the appropriate type of event and call the driver.
352: * (faddr) and (laddr) are the foreign and local addresses.
353: *
354: * When tp_input() is called we KNOW that the ENTIRE TP HEADER
355: * has been m_pullup-ed.
356: *
357: * RETURN VALUE: Nada
358: *
359: * SIDE EFFECTS:
360: * When using COSNS it may affect the state of the net-level pcb
361: *
362: * NOTE:
363: * The initial value of acktime is 2 so that we will never
364: * have a 0 value for tp_peer_acktime. It gets used in the
365: * computation of the retransmission timer value, and so it
366: * mustn't be zero.
367: * 2 seems like a reasonable minimum.
368: */
369: ProtoHook
370: tp_input(m, faddr, laddr, cons_channel, dgout_routine, ce_bit)
371: register struct mbuf *m;
372: struct sockaddr *faddr, *laddr; /* NSAP addresses */
373: u_int cons_channel;
374: int (*dgout_routine)();
375: int ce_bit;
376:
377: {
378: register struct tp_pcb *tpcb = (struct tp_pcb *)0;
379: register struct tpdu *hdr;
380: struct socket *so;
381: struct tp_event e;
382: int error = 0;
383: unsigned dutype;
384: u_short dref, sref = 0, acktime = 2, subseq = 0; /*VAX*/
385: u_char preferred_class = 0, class_to_use = 0;
386: u_char opt, dusize = TP_DFL_TPDUSIZE, addlopt = 0, version;
387: #ifdef TP_PERF_MEAS
388: u_char perf_meas;
389: #endif TP_PERF_MEAS
390: u_char fsufxlen = 0, lsufxlen = 0, intercepted = 0;
391: caddr_t fsufxloc = 0, lsufxloc = 0;
392: int tpdu_len = 0;
393: u_int takes_data = FALSE;
394: u_int fcc_present = FALSE;
395: int errlen = 0;
396: struct tp_conn_param tpp;
397: int tpcons_output();
398:
399: again:
400: hdr = mtod(m, struct tpdu *);
401: #ifdef TP_PERF_MEAS
402: GET_CUR_TIME( &e.e_time ); perf_meas = 0;
403: #endif TP_PERF_MEAS
404:
405: IFDEBUG(D_TPINPUT)
406: printf("tp_input(0x%x, ... 0x%x)\n", m, cons_channel);
407: ENDDEBUG
408:
409:
410: /*
411: * get the actual tpdu length - necessary for monitoring
412: * and for checksumming
413: *
414: * Also, maybe measure the mbuf chain lengths and sizes.
415: */
416:
417: { register struct mbuf *n=m;
418: # ifdef ARGO_DEBUG
419: int chain_length = 0;
420: # endif ARGO_DEBUG
421:
422: for(;;) {
423: tpdu_len += n->m_len;
424: IFDEBUG(D_MBUF_MEAS)
425: if( n->m_flags & M_EXT) {
426: IncStat(ts_mb_cluster);
427: } else {
428: IncStat(ts_mb_small);
429: }
430: chain_length ++;
431: ENDDEBUG
432: if (n->m_next == MNULL ) {
433: break;
434: }
435: n = n->m_next;
436: }
437: IFDEBUG(D_MBUF_MEAS)
438: if(chain_length > 16)
439: chain_length = 0; /* zero used for anything > 16 */
440: tp_stat.ts_mb_len_distr[chain_length] ++;
441: ENDDEBUG
442: }
443: IFTRACE(D_TPINPUT)
444: tptraceTPCB(TPPTtpduin, hdr->tpdu_type, hdr, hdr->tpdu_li+1, tpdu_len,
445: 0);
446: ENDTRACE
447:
448: dref = ntohs((short)hdr->tpdu_dref);
449: sref = ntohs((short)hdr->tpdu_sref);
450: dutype = (int)hdr->tpdu_type;
451:
452: IFDEBUG(D_TPINPUT)
453: printf("input: dutype 0x%x cons_channel 0x%x dref 0x%x\n", dutype,
454: cons_channel, dref);
455: printf("input: dref 0x%x sref 0x%x\n", dref, sref);
456: ENDDEBUG
457: IFTRACE(D_TPINPUT)
458: tptrace(TPPTmisc, "channel dutype dref ",
459: cons_channel, dutype, dref, 0);
460: ENDTRACE
461:
462:
463: #ifdef ARGO_DEBUG
464: if( (dutype < TP_MIN_TPDUTYPE) || (dutype > TP_MAX_TPDUTYPE)) {
465: printf("BAD dutype! 0x%x, channel 0x%x dref 0x%x\n",
466: dutype, cons_channel, dref);
467: dump_buf (m, sizeof( struct mbuf ));
468:
469: IncStat(ts_inv_dutype);
470: goto discard;
471: }
472: #endif ARGO_DEBUG
473:
474: CHECK( (dutype < TP_MIN_TPDUTYPE || dutype > TP_MAX_TPDUTYPE),
475: E_TP_INV_TPDU, ts_inv_dutype, respond,
476: 2 );
477: /* unfortunately we can't take the address of the tpdu_type field,
478: * since it's a bit field - so we just use the constant offset 2
479: */
480:
481: /* Now this isn't very neat but since you locate a pcb one way
482: * at the beginning of connection establishment, and by
483: * the dref for each tpdu after that, we have to treat CRs differently
484: */
485: if ( dutype == CR_TPDU_type ) {
486: u_char alt_classes = 0;
487:
488: preferred_class = 1 << hdr->tpdu_CRclass;
489: opt = hdr->tpdu_CRoptions;
490:
491: WHILE_OPTIONS(P, hdr, 1 ) /* { */
492:
493: switch( vbptr(P)->tpv_code ) {
494:
495: case TPP_tpdu_size:
496: vb_getval(P, u_char, dusize);
497: IFDEBUG(D_TPINPUT)
498: printf("CR dusize 0x%x\n", dusize);
499: ENDDEBUG
500: /* COS tests: NBS IA (Dec. 1987) Sec. 4.5.2.1 */
501: if (dusize < TP_MIN_TPDUSIZE || dusize > TP_MAX_TPDUSIZE)
502: dusize = TP_DFL_TPDUSIZE;
503: break;
504: case TPP_addl_opt:
505: vb_getval(P, u_char, addlopt);
506: break;
507: case TPP_calling_sufx:
508: /* could use vb_getval, but we want to save the loc & len
509: * for later use
510: */
511: fsufxloc = (caddr_t) &vbptr(P)->tpv_val;
512: fsufxlen = vbptr(P)->tpv_len;
513: IFDEBUG(D_TPINPUT)
514: printf("CR fsufx:");
515: { register int j;
516: for(j=0; j<fsufxlen; j++ ) {
517: printf(" 0x%x. ", *((caddr_t)(fsufxloc+j)) );
518: }
519: printf("\n");
520: }
521: ENDDEBUG
522: break;
523: case TPP_called_sufx:
524: /* could use vb_getval, but we want to save the loc & len
525: * for later use
526: */
527: lsufxloc = (caddr_t) &vbptr(P)->tpv_val;
528: lsufxlen = vbptr(P)->tpv_len;
529: IFDEBUG(D_TPINPUT)
530: printf("CR lsufx:");
531: { register int j;
532: for(j=0; j<lsufxlen; j++ ) {
533: printf(" 0x%x. ", *((u_char *)(lsufxloc+j)) );
534: }
535: printf("\n");
536: }
537: ENDDEBUG
538: break;
539:
540: #ifdef TP_PERF_MEAS
541: case TPP_perf_meas:
542: vb_getval(P, u_char, perf_meas);
543: break;
544: #endif TP_PERF_MEAS
545:
546: case TPP_vers:
547: /* not in class 0; 1 octet; in CR_TPDU only */
548: /* COS tests says if version wrong, use default version!?XXX */
549: CHECK( (vbval(P, u_char) != TP_VERSION ),
550: E_TP_INV_PVAL, ts_inv_pval, setversion,
551: (1 + (caddr_t)&vbptr(P)->tpv_val - (caddr_t)hdr) );
552: setversion:
553: version = vbval(P, u_char);
554: break;
555: case TPP_acktime:
556: vb_getval(P, u_short, acktime);
557: acktime = ntohs(acktime);
558: acktime = acktime/500; /* convert to slowtimo ticks */
559: if((short)acktime <=0 )
560: acktime = 2; /* don't allow a bad peer to screw us up */
561: IFDEBUG(D_TPINPUT)
562: printf("CR acktime 0x%x\n", acktime);
563: ENDDEBUG
564: break;
565:
566: case TPP_alt_class:
567: {
568: u_char *aclass = 0;
569: register int i;
570: static u_char bad_alt_classes[5] =
571: { ~0, ~3, ~5, ~0xf, ~0x1f};
572:
573: aclass =
574: (u_char *) &(((struct tp_vbp *)P)->tpv_val);
575: for (i = ((struct tp_vbp *)P)->tpv_len; i>0; i--) {
576: alt_classes |= (1<<((*aclass++)>>4));
577: }
578: CHECK( (bad_alt_classes[hdr->tpdu_CRclass] & alt_classes),
579: E_TP_INV_PVAL, ts_inv_aclass, respond,
580: ((caddr_t)aclass) - (caddr_t)hdr);
581: IFDEBUG(D_TPINPUT)
582: printf("alt_classes 0x%x\n", alt_classes);
583: ENDDEBUG
584: }
585: break;
586:
587: case TPP_security:
588: case TPP_residER:
589: case TPP_priority:
590: case TPP_transdelay:
591: case TPP_throughput:
592: case TPP_addl_info:
593: case TPP_subseq:
594: default:
595: IFDEBUG(D_TPINPUT)
596: printf("param ignored CR_TPDU code= 0x%x\n",
597: vbptr(P)->tpv_code);
598: ENDDEBUG
599: IncStat(ts_param_ignored);
600: break;
601:
602: case TPP_checksum:
603: IFDEBUG(D_TPINPUT)
604: printf("CR before cksum\n");
605: ENDDEBUG
606:
607: CHECK( iso_check_csum(m, tpdu_len),
608: E_TP_INV_PVAL, ts_bad_csum, discard, 0)
609:
610: IFDEBUG(D_TPINPUT)
611: printf("CR before cksum\n");
612: ENDDEBUG
613: break;
614: }
615:
616: /* } */ END_WHILE_OPTIONS(P)
617:
618: if (lsufxlen == 0) {
619: /* can't look for a tpcb w/o any called sufx */
620: error = E_TP_LENGTH_INVAL;
621: IncStat(ts_inv_sufx);
622: goto respond;
623: } else {
624: register struct tp_pcb *t;
625:
626: for (t = tp_intercepts; t ; t = t->tp_nextlisten) {
627: if (laddr->sa_family != t->tp_nlproto->nlp_afamily)
628: continue;
629: if ((*t->tp_nlproto->nlp_cmpnetaddr)(
630: t->tp_npcb, laddr, TP_LOCAL)) {
631: intercepted = 1;
632: goto check_duplicate_cr;
633: }
634: }
635: for (t = tp_listeners; t ; t = t->tp_nextlisten)
636: if (bcmp(lsufxloc, t->tp_lsuffix, lsufxlen) == 0 &&
637: laddr->sa_family == t->tp_nlproto->nlp_afamily)
638: break;
639: CHECK(t == 0, E_TP_NO_SESSION, ts_inv_sufx, respond,
640: (1 + 2 + (caddr_t)&hdr->_tpduf - (caddr_t)hdr))
641: /* _tpduf is the fixed part; add 2 to get the dref bits of
642: * the fixed part (can't take the address of a bit field)
643: */
644: IFDEBUG(D_TPINPUT)
645: printf("checking if dup CR\n");
646: ENDDEBUG
647: check_duplicate_cr:
648: tpcb = t;
649: for (t = tpcb->tp_next; t != tpcb; t = t->tp_next) {
650: if (sref != t->tp_fref)
651: continue;
652: if ((*tpcb->tp_nlproto->nlp_cmpnetaddr)(
653: t->tp_npcb, faddr, TP_FOREIGN)) {
654: IFDEBUG(D_TPINPUT)
655: printf("duplicate CR discarded\n");
656: ENDDEBUG
657: goto discard;
658: }
659: }
660: IFTRACE(D_TPINPUT)
661: tptrace(TPPTmisc, "tp_input: tpcb *lsufxloc tpstate",
662: tpcb, *lsufxloc, tpcb->tp_state, 0);
663: ENDTRACE
664: }
665:
666: /*
667: * WE HAVE A TPCB
668: * already know that the classes in the CR match at least
669: * one class implemented, but we don't know yet if they
670: * include any classes permitted by this server.
671: */
672:
673: IFDEBUG(D_TPINPUT)
674: printf("HAVE A TPCB 1: 0x%x\n", tpcb);
675: ENDDEBUG
676: IFDEBUG(D_CONN)
677: printf(
678: "CR: bef CHKS: flags 0x%x class_to_use 0x%x alt 0x%x opt 0x%x tp_class 0x%x\n",
679: tpcb->tp_flags, class_to_use, alt_classes, opt, tpcb->tp_class);
680: ENDDEBUG
681: /* tpcb->tp_class doesn't include any classes not implemented */
682: class_to_use = (preferred_class & tpcb->tp_class);
683: if( (class_to_use = preferred_class & tpcb->tp_class) == 0 )
684: class_to_use = alt_classes & tpcb->tp_class;
685:
686: class_to_use = 1 << tp_mask_to_num(class_to_use);
687:
688: {
689: tpp = tpcb->_tp_param;
690: tpp.p_class = class_to_use;
691: tpp.p_tpdusize = dusize;
692: tpp.p_xtd_format = (opt & TPO_XTD_FMT) == TPO_XTD_FMT;
693: tpp.p_xpd_service = (addlopt & TPAO_USE_TXPD) == TPAO_USE_TXPD;
694: tpp.p_use_checksum = (tpp.p_class == TP_CLASS_0)?0:
695: (addlopt & TPAO_NO_CSUM) == 0;
696: tpp.p_version = version;
697: #ifdef notdef
698: tpp.p_use_efc = (opt & TPO_USE_EFC) == TPO_USE_EFC;
699: tpp.p_use_nxpd = (addlopt & TPAO_USE_NXPD) == TPAO_USE_NXPD;
700: tpp.p_use_rcc = (addlopt & TPAO_USE_RCC) == TPAO_USE_RCC;
701: #endif notdef
702:
703: CHECK(
704: tp_consistency(tpcb, 0 /* not force or strict */, &tpp) != 0,
705: E_TP_NEGOT_FAILED, ts_negotfailed, respond,
706: (1 + 2 + (caddr_t)&hdr->_tpdufr.CRCC - (caddr_t)hdr)
707: /* ^ more or less the location of class */
708: )
709: }
710: IFTRACE(D_CONN)
711: tptrace(TPPTmisc,
712: "after 1 consist class_to_use class, out, tpconsout",
713: class_to_use,
714: tpcb->tp_class, dgout_routine, tpcons_output
715: );
716: ENDTRACE
717: CHECK(
718: ((class_to_use == TP_CLASS_0)&&(dgout_routine != tpcons_output)),
719: E_TP_NEGOT_FAILED, ts_negotfailed, respond,
720: (1 + 2 + (caddr_t)&hdr->_tpdufr.CRCC - (caddr_t)hdr)
721: /* ^ more or less the location of class */
722: )
723: IFDEBUG(D_CONN)
724: printf("CR: after CRCCCHECKS: tpcb 0x%x, flags 0x%x\n",
725: tpcb, tpcb->tp_flags);
726: ENDDEBUG
727: takes_data = TRUE;
728: e.ATTR(CR_TPDU).e_cdt = hdr->tpdu_CRcdt;
729: e.ev_number = CR_TPDU;
730:
731: so = tpcb->tp_sock;
732: if (so->so_options & SO_ACCEPTCONN) {
733: struct tp_pcb *parent_tpcb = tpcb;
734: /*
735: * Create a socket, tpcb, ll pcb, etc.
736: * for this newborn connection, and fill in all the values.
737: */
738: IFDEBUG(D_CONN)
739: printf("abt to call tp_newsocket(0x%x, 0x%x, 0x%x, 0x%x)\n",
740: so, laddr, faddr, cons_channel);
741: ENDDEBUG
742: if( (so =
743: tp_newsocket(so, faddr, cons_channel,
744: class_to_use,
745: ((tpcb->tp_netservice == IN_CLNS) ? IN_CLNS :
746: (dgout_routine == tpcons_output)?ISO_CONS:ISO_CLNS))
747: ) == (struct socket *)0 ) {
748: /* note - even if netservice is IN_CLNS, as far as
749: * the tp entity is concerned, the only differences
750: * are CO vs CL
751: */
752: IFDEBUG(D_CONN)
753: printf("tp_newsocket returns 0\n");
754: ENDDEBUG
755: goto discard;
756: }
757: tpcb = sototpcb(so);
758: insque(tpcb, parent_tpcb);
759:
760: /*
761: * Stash the addresses in the net level pcb
762: * kind of like a pcbconnect() but don't need
763: * or want all those checks.
764: */
765: (tpcb->tp_nlproto->nlp_putnetaddr)(so->so_pcb, faddr, TP_FOREIGN);
766: (tpcb->tp_nlproto->nlp_putnetaddr)(so->so_pcb, laddr, TP_LOCAL);
767:
768: /* stash the f suffix in the new tpcb */
769: bcopy(fsufxloc, tpcb->tp_fsuffix, fsufxlen);
770: /* l suffix is already there, unless this is an intercept case */
771: if (intercepted)
772: bcopy(lsufxloc, tpcb->tp_lsuffix, lsufxlen);
773: (tpcb->tp_nlproto->nlp_putsufx)
774: (so->so_pcb, fsufxloc, fsufxlen, TP_FOREIGN);
775: (tpcb->tp_nlproto->nlp_putsufx)
776: (so->so_pcb, lsufxloc, lsufxlen, TP_LOCAL);
777: #ifdef TP_PERF_MEAS
778: if( tpcb->tp_perf_on = perf_meas ) { /* assignment */
779: /* ok, let's create an mbuf for stashing the
780: * statistics if one doesn't already exist
781: */
782: (void) tp_setup_perf(tpcb);
783: }
784: #endif TP_PERF_MEAS
785: tpcb->tp_fref = sref;
786:
787: /* We've already checked for consistency with the options
788: * set in tpp, but we couldn't set them earlier because
789: * we didn't want to change options in the LISTENING tpcb.
790: * Now we set the options in the new socket's tpcb.
791: */
792: (void) tp_consistency( tpcb, TP_FORCE, &tpp);
793:
794: if(!tpcb->tp_use_checksum)
795: IncStat(ts_csum_off);
796: if(tpcb->tp_xpd_service)
797: IncStat(ts_use_txpd);
798: if(tpcb->tp_xtd_format)
799: IncStat(ts_xtd_fmt);
800:
801: /*
802: * Get the maximum transmission unit from the lower layer(s)
803: * so we can negotiate a reasonable max TPDU size.
804: */
805: (tpcb->tp_nlproto->nlp_mtu)(so, so->so_pcb,
806: &tpcb->tp_l_tpdusize, &tpcb->tp_tpdusize, 0);
807: tpcb->tp_peer_acktime = acktime;
808:
809: /*
810: * The following kludge is used to test retransmissions and
811: * timeout during connection establishment.
812: */
813: IFDEBUG(D_ZDREF)
814: IncStat(ts_zdebug);
815: /*tpcb->tp_fref = 0;*/
816: ENDDEBUG
817: }
818: IncStat(ts_CR_rcvd);
819: if (!tpcb->tp_cebit_off) {
820: tpcb->tp_win_recv = tp_start_win << 8;
821: tpcb->tp_cong_sample.cs_size = 0;
822: LOCAL_CREDIT(tpcb);
823: CONG_INIT_SAMPLE(tpcb);
824: CONG_UPDATE_SAMPLE(tpcb, ce_bit);
825: }
826: tpcb->tp_ackrcvd = 0;
827: } else if ( dutype == ER_TPDU_type ) {
828: /*
829: * ER TPDUs have to be recognized separately
830: * because they don't necessarily have a tpcb
831: * with them and we don't want err out looking for such
832: * a beast.
833: * We could put a bunch of little kludges in the
834: * next section of code so it would avoid references to tpcb
835: * if dutype == ER_TPDU_type but we don't want code for ERs to
836: * mess up code for data transfer.
837: */
838: IncStat(ts_ER_rcvd);
839: e.ev_number = ER_TPDU;
840: e.ATTR(ER_TPDU).e_reason = (u_char)hdr->tpdu_ERreason;
841: takes_data = 1;
842: } else {
843: /* tpdu type is CC, XPD, XAK, GR, AK, DR, DC, or DT */
844:
845: /* In the next 4 checks,
846: * _tpduf is the fixed part; add 2 to get the dref bits of
847: * the fixed part (can't take the address of a bit field)
848: */
849: if(cons_channel) {
850: #if NARGOXTWENTYFIVE > 0
851: extern struct tp_pcb *cons_chan_to_tpcb();
852:
853: tpcb = cons_chan_to_tpcb( cons_channel );
854: /* Problem: We may have a legit
855: * error situation yet we may or may not have
856: * a correspondence between the tpcb and the vc,
857: * e.g., TP4cr--> <no dice, respond w/ DR on vc>
858: * <--- DR
859: * Now it's up to TP to look at the tpdu and do one of:
860: * confirm(dgm)(cr), confirm(circuit)(cr), reject(cr), or
861: * nothing, if the circuit is already open (any other tpdu).
862: * Sigh.
863: */
864:
865: /* I don't know about this error value */
866: CHECK( (tpcb == (struct tp_pcb *)0) ,
867: E_TP_NO_CR_ON_NC, ts_inv_dref, respond,
868: (1 + 2 + (caddr_t)&hdr->_tpduf - (caddr_t)hdr))
869: #else
870: printf("tp_input(): X25 NOT CONFIGURED!!\n");
871: #endif NARGOXTWENTYFIVE > 0
872:
873: } else {
874:
875: CHECK( ((int)dref <= 0 || dref >= N_TPREF) ,
876: E_TP_MISM_REFS,ts_inv_dref, nonx_dref,
877: (1 + 2 + (caddr_t)&hdr->_tpduf - (caddr_t)hdr))
878: CHECK( ((tpcb = tp_ref[dref].tpr_pcb ) == (struct tp_pcb *) 0 ),
879: E_TP_MISM_REFS,ts_inv_dref, nonx_dref,
880: (1 + 2 + (caddr_t)&hdr->_tpduf - (caddr_t)hdr))
881: CHECK( (tpcb->tp_refp->tpr_state == REF_FREE),
882: E_TP_MISM_REFS,ts_inv_dref, nonx_dref,
883: (1 + 2 + (caddr_t)&hdr->_tpduf - (caddr_t)hdr))
884: }
885:
886: IFDEBUG(D_TPINPUT)
887: printf("HAVE A TPCB 2: 0x%x\n", tpcb);
888: ENDDEBUG
889:
890: /* causes a DR to be sent for CC; ER for all else */
891: CHECK( (tpcb->tp_refp->tpr_state == REF_FROZEN),
892: (dutype == CC_TPDU_type?E_TP_NO_SESSION:E_TP_MISM_REFS),
893: ts_inv_dref, respond,
894: (1 + 2 + (caddr_t)&hdr->_tpduf - (caddr_t)hdr))
895:
896: IFDEBUG(D_TPINPUT)
897: printf("state of dref %d ok, tpcb 0x%x\n", dref,tpcb);
898: ENDDEBUG
899: /*
900: * At this point the state of the dref could be
901: * FROZEN: tpr_pcb == NULL, has ( reference only) timers
902: * for example, DC may arrive after the close() has detached
903: * the tpcb (e.g., if user turned off SO_LISTEN option)
904: * OPENING : a tpcb exists but no timers yet
905: * OPEN : tpcb exists & timers are outstanding
906: */
907:
908: if (!tpcb->tp_cebit_off)
909: CONG_UPDATE_SAMPLE(tpcb, ce_bit);
910:
911: dusize = tpcb->tp_tpdusize;
912:
913: dutype = hdr->tpdu_type << 8; /* for the switch below */
914:
915: WHILE_OPTIONS(P, hdr, tpcb->tp_xtd_format) /* { */
916:
917: #define caseof(x,y) case (((x)<<8)+(y))
918: switch( dutype | vbptr(P)->tpv_code ) {
919:
920: caseof( CC_TPDU_type, TPP_addl_opt ):
921: /* not in class 0; 1 octet */
922: vb_getval(P, u_char, addlopt);
923: break;
924: caseof( CC_TPDU_type, TPP_tpdu_size ):
925: {
926: u_char odusize = dusize;
927: vb_getval(P, u_char, dusize);
928: CHECK( (dusize < TP_MIN_TPDUSIZE ||
929: dusize > TP_MAX_TPDUSIZE || dusize > odusize),
930: E_TP_INV_PVAL, ts_inv_pval, respond,
931: (1 + (caddr_t)&vbptr(P)->tpv_val - (caddr_t)hdr) )
932: IFDEBUG(D_TPINPUT)
933: printf("CC dusize 0x%x\n", dusize);
934: ENDDEBUG
935: }
936: break;
937: caseof( CC_TPDU_type, TPP_calling_sufx):
938: IFDEBUG(D_TPINPUT)
939: printf("CC calling (local) sufxlen 0x%x\n", lsufxlen);
940: ENDDEBUG
941: lsufxloc = (caddr_t) &vbptr(P)->tpv_val;
942: lsufxlen = vbptr(P)->tpv_len;
943: break;
944: caseof( CC_TPDU_type, TPP_acktime ):
945: /* class 4 only, 2 octets */
946: vb_getval(P, u_short, acktime);
947: acktime = ntohs(acktime);
948: acktime = acktime/500; /* convert to slowtimo ticks */
949: if( (short)acktime <=0 )
950: acktime = 2;
951: break;
952: caseof( CC_TPDU_type, TPP_called_sufx):
953: fsufxloc = (caddr_t) &vbptr(P)->tpv_val;
954: fsufxlen = vbptr(P)->tpv_len;
955: IFDEBUG(D_TPINPUT)
956: printf("CC called (foreign) sufx len %d\n", fsufxlen);
957: ENDDEBUG
958: break;
959:
960: caseof( CC_TPDU_type, TPP_checksum):
961: caseof( DR_TPDU_type, TPP_checksum):
962: caseof( DT_TPDU_type, TPP_checksum):
963: caseof( XPD_TPDU_type, TPP_checksum):
964: if( tpcb->tp_use_checksum ) {
965: CHECK( iso_check_csum(m, tpdu_len),
966: E_TP_INV_PVAL, ts_bad_csum, discard, 0)
967: }
968: break;
969:
970: /* this is different from the above because in the context
971: * of concat/ sep tpdu_len might not be the same as hdr len
972: */
973: caseof( AK_TPDU_type, TPP_checksum):
974: caseof( XAK_TPDU_type, TPP_checksum):
975: caseof( DC_TPDU_type, TPP_checksum):
976: if( tpcb->tp_use_checksum ) {
977: CHECK( iso_check_csum(m, (int)hdr->tpdu_li + 1),
978: E_TP_INV_PVAL, ts_bad_csum, discard, 0)
979: }
980: break;
981: #ifdef notdef
982: caseof( DR_TPDU_type, TPP_addl_info ):
983: /* ignore - its length and meaning are
984: * user defined and there's no way
985: * to pass this info to the user anyway
986: */
987: break;
988: #endif notdef
989:
990: caseof( AK_TPDU_type, TPP_subseq ):
991: /* used after reduction of window */
992: vb_getval(P, u_short, subseq);
993: subseq = ntohs(subseq);
994: IFDEBUG(D_ACKRECV)
995: printf("AK Subsequence # 0x%x\n", subseq);
996: ENDDEBUG
997: break;
998:
999: caseof( AK_TPDU_type, TPP_flow_cntl_conf ):
1000: {
1001: u_int ylwe;
1002: u_short ysubseq, ycredit;
1003:
1004: fcc_present = TRUE;
1005: vb_getval(P, u_int, ylwe);
1006: vb_getval(P, u_short, ysubseq);
1007: vb_getval(P, u_short, ycredit);
1008: ylwe = ntohl(ylwe);
1009: ysubseq = ntohs(ysubseq);
1010: ycredit = ntohs(ycredit);
1011: IFDEBUG(D_ACKRECV)
1012: printf("AK FCC lwe 0x%x, subseq 0x%x, cdt 0x%x\n",
1013: ylwe, ysubseq, ycredit);
1014: ENDDEBUG
1015: }
1016: break;
1017:
1018: default:
1019: IFDEBUG(D_TPINPUT)
1020: printf("param ignored dutype 0x%x, code 0x%x\n",
1021: dutype, vbptr(P)->tpv_code);
1022: ENDDEBUG
1023: IFTRACE(D_TPINPUT)
1024: tptrace(TPPTmisc, "param ignored dutype code ",
1025: dutype, vbptr(P)->tpv_code ,0,0);
1026: ENDTRACE
1027: IncStat(ts_param_ignored);
1028: break;
1029: #undef caseof
1030: }
1031: /* } */ END_WHILE_OPTIONS(P)
1032:
1033: /* NOTE: the variable dutype has been shifted left! */
1034:
1035: switch( hdr->tpdu_type ) {
1036: case CC_TPDU_type:
1037: /* If CC comes back with an unacceptable class
1038: * respond with a DR or ER
1039: */
1040:
1041: opt = hdr->tpdu_CCoptions; /* 1 byte */
1042:
1043: {
1044: tpp = tpcb->_tp_param;
1045: tpp.p_class = (1<<hdr->tpdu_CCclass);
1046: tpp.p_tpdusize = dusize;
1047: tpp.p_dont_change_params = 0;
1048: tpp.p_xtd_format = (opt & TPO_XTD_FMT) == TPO_XTD_FMT;
1049: tpp.p_xpd_service = (addlopt & TPAO_USE_TXPD) == TPAO_USE_TXPD;
1050: tpp.p_use_checksum = (addlopt & TPAO_NO_CSUM) == 0;
1051: #ifdef notdef
1052: tpp.p_use_efc = (opt & TPO_USE_EFC) == TPO_USE_EFC;
1053: tpp.p_use_nxpd = (addlopt & TPAO_USE_NXPD) == TPAO_USE_NXPD;
1054: tpp.p_use_rcc = (addlopt & TPAO_USE_RCC) == TPAO_USE_RCC;
1055: #endif notdef
1056:
1057: CHECK(
1058: tp_consistency(tpcb, TP_FORCE, &tpp) != 0,
1059: E_TP_NEGOT_FAILED, ts_negotfailed, respond,
1060: (1 + 2 + (caddr_t)&hdr->_tpdufr.CRCC - (caddr_t)hdr)
1061: /* ^ more or less the location of class */
1062: )
1063: IFTRACE(D_CONN)
1064: tptrace(TPPTmisc,
1065: "after 1 consist class, out, tpconsout",
1066: tpcb->tp_class, dgout_routine, tpcons_output, 0
1067: );
1068: ENDTRACE
1069: CHECK(
1070: ((class_to_use == TP_CLASS_0)&&
1071: (dgout_routine != tpcons_output)),
1072: E_TP_NEGOT_FAILED, ts_negotfailed, respond,
1073: (1 + 2 + (caddr_t)&hdr->_tpdufr.CRCC - (caddr_t)hdr)
1074: /* ^ more or less the location of class */
1075: )
1076: }
1077: if( ! tpcb->tp_use_checksum)
1078: IncStat(ts_csum_off);
1079: if(tpcb->tp_xpd_service)
1080: IncStat(ts_use_txpd);
1081: if(tpcb->tp_xtd_format)
1082: IncStat(ts_xtd_fmt);
1083:
1084: IFTRACE(D_CONN)
1085: tptrace(TPPTmisc, "after CC class flags dusize CCclass",
1086: tpcb->tp_class, tpcb->tp_flags, tpcb->tp_tpdusize,
1087: hdr->tpdu_CCclass);
1088: ENDTRACE
1089:
1090: /*
1091: * Get the maximum transmission unit from the lower layer(s)
1092: * so we can decide how large a TPDU size to negotiate.
1093: * It would be nice if the arguments to this
1094: * were more reasonable.
1095: */
1096: (tpcb->tp_nlproto->nlp_mtu)(tpcb->tp_sock, tpcb->tp_sock->so_pcb,
1097: &tpcb->tp_l_tpdusize, &tpcb->tp_tpdusize, 0);
1098:
1099: #ifdef CONS
1100: /* Could be that this CC came in on a NEW vc, in which case
1101: * we have to confirm it.
1102: */
1103: if( cons_channel )
1104: cons_netcmd( CONN_CONFIRM, tpcb->tp_npcb, cons_channel,
1105: tpcb->tp_class == TP_CLASS_4);
1106: #endif CONS
1107:
1108: tpcb->tp_peer_acktime = acktime;
1109:
1110: /* if called or calling suffices appeared on the CC,
1111: * they'd better jive with what's in the pcb
1112: */
1113: if( fsufxlen ) {
1114: CHECK( ((tpcb->tp_fsuffixlen != fsufxlen) ||
1115: bcmp(fsufxloc, tpcb->tp_fsuffix, fsufxlen)),
1116: E_TP_INV_PVAL,ts_inv_sufx, respond,
1117: (1+fsufxloc - (caddr_t)hdr))
1118: }
1119: if( lsufxlen ) {
1120: CHECK( ((tpcb->tp_lsuffixlen != lsufxlen) ||
1121: bcmp(lsufxloc, tpcb->tp_lsuffix, lsufxlen)),
1122: E_TP_INV_PVAL,ts_inv_sufx, respond,
1123: (1+lsufxloc - (caddr_t)hdr))
1124: }
1125:
1126: e.ATTR(CC_TPDU).e_sref = sref;
1127: e.ATTR(CC_TPDU).e_cdt = hdr->tpdu_CCcdt;
1128: takes_data = TRUE;
1129: e.ev_number = CC_TPDU;
1130: IncStat(ts_CC_rcvd);
1131: break;
1132:
1133: case DC_TPDU_type:
1134: if (sref != tpcb->tp_fref)
1135: printf("INPUT: inv sufx DCsref 0x%x, tp_fref 0x%x\n",
1136: sref, tpcb->tp_fref);
1137:
1138: CHECK( (sref != tpcb->tp_fref),
1139: E_TP_MISM_REFS, ts_inv_sufx, discard,
1140: (1 + (caddr_t)&hdr->tpdu_DCsref - (caddr_t)hdr))
1141:
1142: e.ev_number = DC_TPDU;
1143: IncStat(ts_DC_rcvd);
1144: break;
1145:
1146: case DR_TPDU_type:
1147: IFTRACE(D_TPINPUT)
1148: tptrace(TPPTmisc, "DR recvd", hdr->tpdu_DRreason, 0, 0, 0);
1149: ENDTRACE
1150: if (sref != tpcb->tp_fref) {
1151: printf("INPUT: inv sufx DRsref 0x%x tp_fref 0x%x\n",
1152: sref, tpcb->tp_fref);
1153: }
1154:
1155: CHECK( (sref != 0 && sref != tpcb->tp_fref &&
1156: tpcb->tp_state != TP_CRSENT),
1157: (TP_ERROR_SNDC | E_TP_MISM_REFS),ts_inv_sufx, respond,
1158: (1 + (caddr_t)&hdr->tpdu_DRsref - (caddr_t)hdr))
1159:
1160: e.ATTR(DR_TPDU).e_reason = hdr->tpdu_DRreason;
1161: e.ATTR(DR_TPDU).e_sref = (u_short)sref;
1162: takes_data = TRUE;
1163: e.ev_number = DR_TPDU;
1164: IncStat(ts_DR_rcvd);
1165: break;
1166:
1167: case ER_TPDU_type:
1168: IFTRACE(D_TPINPUT)
1169: tptrace(TPPTmisc, "ER recvd", hdr->tpdu_ERreason,0,0,0);
1170: ENDTRACE
1171: e.ev_number = ER_TPDU;
1172: e.ATTR(ER_TPDU).e_reason = hdr->tpdu_ERreason;
1173: IncStat(ts_ER_rcvd);
1174: break;
1175:
1176: case AK_TPDU_type:
1177:
1178: e.ATTR(AK_TPDU).e_subseq = subseq;
1179: e.ATTR(AK_TPDU).e_fcc_present = fcc_present;
1180:
1181: if (tpcb->tp_xtd_format) {
1182: #ifdef BYTE_ORDER
1183: union seq_type seqeotX;
1184:
1185: seqeotX.s_seqeot = ntohl(hdr->tpdu_seqeotX);
1186: e.ATTR(AK_TPDU).e_seq = seqeotX.s_seq;
1187: e.ATTR(AK_TPDU).e_cdt = ntohs(hdr->tpdu_AKcdtX);
1188: #else
1189: e.ATTR(AK_TPDU).e_cdt = hdr->tpdu_AKcdtX;
1190: e.ATTR(AK_TPDU).e_seq = hdr->tpdu_AKseqX;
1191: #endif BYTE_ORDER
1192: } else {
1193: e.ATTR(AK_TPDU).e_cdt = hdr->tpdu_AKcdt;
1194: e.ATTR(AK_TPDU).e_seq = hdr->tpdu_AKseq;
1195: }
1196: IFTRACE(D_TPINPUT)
1197: tptrace(TPPTmisc, "AK recvd seq cdt subseq fcc_pres",
1198: e.ATTR(AK_TPDU).e_seq, e.ATTR(AK_TPDU).e_cdt,
1199: subseq, fcc_present);
1200: ENDTRACE
1201:
1202: e.ev_number = AK_TPDU;
1203: IncStat(ts_AK_rcvd);
1204: IncPStat(tpcb, tps_AK_rcvd);
1205: break;
1206:
1207: case XAK_TPDU_type:
1208: if (tpcb->tp_xtd_format) {
1209: #ifdef BYTE_ORDER
1210: union seq_type seqeotX;
1211:
1212: seqeotX.s_seqeot = ntohl(hdr->tpdu_seqeotX);
1213: e.ATTR(XAK_TPDU).e_seq = seqeotX.s_seq;
1214: #else
1215: e.ATTR(XAK_TPDU).e_seq = hdr->tpdu_XAKseqX;
1216: #endif BYTE_ORDER
1217: } else {
1218: e.ATTR(XAK_TPDU).e_seq = hdr->tpdu_XAKseq;
1219: }
1220: e.ev_number = XAK_TPDU;
1221: IncStat(ts_XAK_rcvd);
1222: IncPStat(tpcb, tps_XAK_rcvd);
1223: break;
1224:
1225: case XPD_TPDU_type:
1226: if (tpcb->tp_xtd_format) {
1227: #ifdef BYTE_ORDER
1228: union seq_type seqeotX;
1229:
1230: seqeotX.s_seqeot = ntohl(hdr->tpdu_seqeotX);
1231: e.ATTR(XPD_TPDU).e_seq = seqeotX.s_seq;
1232: #else
1233: e.ATTR(XPD_TPDU).e_seq = hdr->tpdu_XPDseqX;
1234: #endif BYTE_ORDER
1235: } else {
1236: e.ATTR(XPD_TPDU).e_seq = hdr->tpdu_XPDseq;
1237: }
1238: takes_data = TRUE;
1239: e.ev_number = XPD_TPDU;
1240: IncStat(ts_XPD_rcvd);
1241: IncPStat(tpcb, tps_XPD_rcvd);
1242: break;
1243:
1244: case DT_TPDU_type:
1245: { /* the y option will cause occasional packets to be dropped.
1246: * A little crude but it works.
1247: */
1248:
1249: IFDEBUG(D_DROP)
1250: if(time.tv_usec & 0x4 && hdr->tpdu_DTseq & 0x1) {
1251: IncStat(ts_ydebug);
1252: goto discard;
1253: }
1254: ENDDEBUG
1255: }
1256: if (tpcb->tp_class == TP_CLASS_0) {
1257: e.ATTR(DT_TPDU).e_seq = 0; /* actually don't care */
1258: e.ATTR(DT_TPDU).e_eot = (((struct tp0du *)hdr)->tp0du_eot);
1259: } else if (tpcb->tp_xtd_format) {
1260: #ifdef BYTE_ORDER
1261: union seq_type seqeotX;
1262:
1263: seqeotX.s_seqeot = ntohl(hdr->tpdu_seqeotX);
1264: e.ATTR(DT_TPDU).e_seq = seqeotX.s_seq;
1265: e.ATTR(DT_TPDU).e_eot = seqeotX.s_eot;
1266: #else
1267: e.ATTR(DT_TPDU).e_seq = hdr->tpdu_DTseqX;
1268: e.ATTR(DT_TPDU).e_eot = hdr->tpdu_DTeotX;
1269: #endif BYTE_ORDER
1270: } else {
1271: e.ATTR(DT_TPDU).e_seq = hdr->tpdu_DTseq;
1272: e.ATTR(DT_TPDU).e_eot = hdr->tpdu_DTeot;
1273: }
1274: if(e.ATTR(DT_TPDU).e_eot)
1275: IncStat(ts_eot_input);
1276: takes_data = TRUE;
1277: e.ev_number = DT_TPDU;
1278: IncStat(ts_DT_rcvd);
1279: IncPStat(tpcb, tps_DT_rcvd);
1280: break;
1281:
1282: case GR_TPDU_type:
1283: tp_indicate(T_DISCONNECT, tpcb, ECONNABORTED);
1284: /* drop through */
1285: default:
1286: /* this should NEVER happen because there is a
1287: * check for dutype well above here
1288: */
1289: error = E_TP_INV_TPDU; /* causes an ER */
1290: IFDEBUG(D_TPINPUT)
1291: printf("INVALID dutype 0x%x\n", hdr->tpdu_type);
1292: ENDDEBUG
1293: IncStat(ts_inv_dutype);
1294: goto respond;
1295: }
1296: }
1297: /* peel off the tp header;
1298: * remember that the du_li doesn't count itself.
1299: * This may leave us w/ an empty mbuf at the front of a chain.
1300: * We can't just throw away the empty mbuf because hdr still points
1301: * into the mbuf's data area and we're still using hdr (the tpdu header)
1302: */
1303: m->m_len -= ((int)hdr->tpdu_li + 1);
1304: m->m_data += ((int)hdr->tpdu_li + 1);
1305:
1306: if (takes_data) {
1307: int max = tpdu_info[ hdr->tpdu_type ] [TP_MAX_DATA_INDEX];
1308: int datalen = tpdu_len - hdr->tpdu_li - 1, mbtype = MT_DATA;
1309: struct cmsghdr c_hdr;
1310: struct mbuf *n;
1311:
1312: CHECK( (max && datalen > max), E_TP_LENGTH_INVAL,
1313: ts_inv_length, respond, (max + hdr->tpdu_li + 1) );
1314: switch( hdr->tpdu_type ) {
1315:
1316: case CR_TPDU_type:
1317: c_hdr.cmsg_type = TPOPT_CONN_DATA;
1318: goto make_control_msg;
1319:
1320: case CC_TPDU_type:
1321: c_hdr.cmsg_type = TPOPT_CFRM_DATA;
1322: goto make_control_msg;
1323:
1324: case DR_TPDU_type:
1325: c_hdr.cmsg_type = TPOPT_DISC_DATA;
1326: make_control_msg:
1327: c_hdr.cmsg_level = SOL_TRANSPORT;
1328: mbtype = MT_CONTROL;
1329: MGET(n, M_DONTWAIT, MT_DATA);
1330: if (n) {
1331: datalen += sizeof(c_hdr);
1332: n->m_len = sizeof(c_hdr);
1333: c_hdr.cmsg_len = datalen;
1334: *mtod(n, struct cmsghdr *) = c_hdr;
1335: n->m_next = m;
1336: m = n;
1337: } else {m_freem(m); m = 0; goto invoke;}
1338: /* FALLTHROUGH */
1339:
1340: case XPD_TPDU_type:
1341: if (mbtype != MT_CONTROL)
1342: mbtype = MT_OOBDATA;
1343: m->m_flags |= M_EOR;
1344: /* FALLTHROUGH */
1345:
1346: case DT_TPDU_type:
1347: for (n = m; n; n = n->m_next) {
1348: MCHTYPE(n, mbtype);
1349: }
1350: invoke:
1351: e.ATTR(DT_TPDU).e_datalen = datalen;
1352: e.ATTR(DT_TPDU).e_data = m;
1353: break;
1354:
1355: default:
1356: printf(
1357: "ERROR in tp_input! hdr->tpdu_type 0x%x takes_data 0x%x m 0x%x\n",
1358: hdr->tpdu_type, takes_data, m);
1359: break;
1360: }
1361: /* prevent m_freem() after tp_driver() from throwing it all away */
1362: m = MNULL;
1363: }
1364:
1365: IncStat(ts_tpdu_rcvd);
1366:
1367: IFDEBUG(D_TPINPUT)
1368: printf( "tp_input: before driver, state 0x%x event 0x%x m 0x%x",
1369: tpcb->tp_state, e.ev_number, m );
1370: printf(" e.e_data 0x%x\n", e.ATTR(DT_TPDU).e_data);
1371: printf("takes_data 0x%x m_len 0x%x, tpdu_len 0x%x\n",
1372: takes_data, (m==MNULL)?0:m->m_len, tpdu_len);
1373: ENDDEBUG
1374:
1375: error = tp_driver(tpcb, &e);
1376:
1377: ASSERT(tpcb != (struct tp_pcb *)0);
1378: ASSERT(tpcb->tp_sock != (struct socket *)0);
1379: if( tpcb->tp_sock->so_error == 0 )
1380: tpcb->tp_sock->so_error = error;
1381:
1382: /* Kludge to keep the state tables under control (adding
1383: * data on connect & disconnect & freeing the mbuf containing
1384: * the data would have exploded the tables and made a big mess ).
1385: */
1386: switch(e.ev_number) {
1387: case CC_TPDU:
1388: case DR_TPDU:
1389: case CR_TPDU:
1390: m = e.ATTR(CC_TPDU).e_data; /* same field for all three dutypes */
1391: IFDEBUG(D_TPINPUT)
1392: printf("after driver, restoring m to 0x%x, takes_data 0x%x\n",
1393: m, takes_data);
1394: ENDDEBUG
1395: break;
1396: default:
1397: break;
1398: }
1399: /* Concatenated sequences are terminated by any tpdu that
1400: * carries data: CR, CC, DT, XPD, DR.
1401: * All other tpdu types may be concatenated: AK, XAK, DC, ER.
1402: */
1403:
1404: separate:
1405: if ( takes_data == 0 ) {
1406: ASSERT( m != MNULL );
1407: /*
1408: * we already peeled off the prev. tp header so
1409: * we can just pull up some more and repeat
1410: */
1411:
1412: if( m = tp_inputprep(m) ) {
1413: IFDEBUG(D_TPINPUT)
1414: hdr = mtod(m, struct tpdu *);
1415: printf("tp_input @ separate: hdr 0x%x size %d m 0x%x\n",
1416: hdr, (int) hdr->tpdu_li + 1, m);
1417: dump_mbuf(m, "tp_input after driver, at separate");
1418: ENDDEBUG
1419:
1420: IncStat(ts_concat_rcvd);
1421: goto again;
1422: }
1423: }
1424: if ( m != MNULL ) {
1425: IFDEBUG(D_TPINPUT)
1426: printf("tp_input : m_freem(0x%x)\n", m);
1427: ENDDEBUG
1428: m_freem(m);
1429: IFDEBUG(D_TPINPUT)
1430: printf("tp_input : after m_freem 0x%x\n", m);
1431: ENDDEBUG
1432: }
1433: return (ProtoHook) tpcb;
1434:
1435: discard:
1436: /* class 4: drop the tpdu */
1437: /* class 2,0: Should drop the net connection, if you can figure out
1438: * to which connection it applies
1439: */
1440: IFDEBUG(D_TPINPUT)
1441: printf("tp_input DISCARD\n");
1442: ENDDEBUG
1443: IFTRACE(D_TPINPUT)
1444: tptrace(TPPTmisc, "tp_input DISCARD m", m,0,0,0);
1445: ENDTRACE
1446: m_freem(m);
1447: IncStat(ts_recv_drop);
1448: return (ProtoHook)0;
1449:
1450: nonx_dref:
1451: switch (dutype) {
1452: default:
1453: goto discard;
1454: case CC_TPDU_type:
1455: /* error = E_TP_MISM_REFS; */
1456: break;
1457: case DR_TPDU_type:
1458: error |= TP_ERROR_SNDC;
1459: }
1460: respond:
1461: IFDEBUG(D_TPINPUT)
1462: printf("RESPOND: error 0x%x, errlen 0x%x\n", error, errlen);
1463: ENDDEBUG
1464: IFTRACE(D_TPINPUT)
1465: tptrace(TPPTmisc, "tp_input RESPOND m error sref", m, error, sref, 0);
1466: ENDTRACE
1467: if (sref == 0)
1468: goto discard;
1469: (void) tp_error_emit(error, (u_long)sref, (struct sockaddr_iso *)faddr,
1470: (struct sockaddr_iso *)laddr, m, errlen, tpcb,
1471: (int)cons_channel, dgout_routine);
1472: IFDEBUG(D_ERROR_EMIT)
1473: printf("tp_input after error_emit\n");
1474: ENDDEBUG
1475:
1476: #ifdef lint
1477: printf("",sref,opt);
1478: #endif lint
1479: IncStat(ts_recv_drop);
1480: return (ProtoHook)0;
1481: }
1482:
1483:
1484: /*
1485: * NAME: tp_headersize()
1486: *
1487: * CALLED FROM:
1488: * tp_emit() and tp_sbsend()
1489: * TP needs to know the header size so it can figure out how
1490: * much data to put in each tpdu.
1491: *
1492: * FUNCTION, ARGUMENTS, and RETURN VALUE:
1493: * For a given connection, represented by (tpcb), and
1494: * tpdu type (dutype), return the size of a tp header.
1495: *
1496: * RETURNS: the expected size of the heade in bytesr
1497: *
1498: * SIDE EFFECTS:
1499: *
1500: * NOTES: It would be nice if it got the network header size as well.
1501: */
1502: int
1503: tp_headersize(dutype, tpcb)
1504: int dutype;
1505: struct tp_pcb *tpcb;
1506: {
1507: register int size = 0;
1508:
1509: IFTRACE(D_CONN)
1510: tptrace(TPPTmisc, "tp_headersize dutype class xtd_format",
1511: dutype, tpcb->tp_class, tpcb->tp_xtd_format, 0);
1512: ENDTRACE
1513: if( !( (tpcb->tp_class == TP_CLASS_0) ||
1514: (tpcb->tp_class == TP_CLASS_4) ||
1515: (dutype == DR_TPDU_type) ||
1516: (dutype == CR_TPDU_type) )) {
1517: printf("tp_headersize:dutype 0x%x, class 0x%x",
1518: dutype, tpcb->tp_class);
1519: /* TODO: identify this and GET RID OF IT */
1520: }
1521: ASSERT( (tpcb->tp_class == TP_CLASS_0) ||
1522: (tpcb->tp_class == TP_CLASS_4) ||
1523: (dutype == DR_TPDU_type) ||
1524: (dutype == CR_TPDU_type) );
1525:
1526: if( tpcb->tp_class == TP_CLASS_0 ) {
1527: size = tpdu_info[ dutype ] [TP_LEN_CLASS_0_INDEX];
1528: } else {
1529: size = tpdu_info[ dutype ] [tpcb->tp_xtd_format];
1530: }
1531: return size;
1532: /* caller must get network level header size separately */
1533: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.