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