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