![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tp_emit.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / netiso|
Return to tp_emit.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netiso |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*-
26: * Copyright (c) 1991, 1993
27: * The Regents of the University of California. All rights reserved.
28: *
29: * Redistribution and use in source and binary forms, with or without
30: * modification, are permitted provided that the following conditions
31: * are met:
32: * 1. Redistributions of source code must retain the above copyright
33: * notice, this list of conditions and the following disclaimer.
34: * 2. Redistributions in binary form must reproduce the above copyright
35: * notice, this list of conditions and the following disclaimer in the
36: * documentation and/or other materials provided with the distribution.
37: * 3. All advertising materials mentioning features or use of this software
38: * must display the following acknowledgement:
39: * This product includes software developed by the University of
40: * California, Berkeley and its contributors.
41: * 4. Neither the name of the University nor the names of its contributors
42: * may be used to endorse or promote products derived from this software
43: * without specific prior written permission.
44: *
45: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
46: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
48: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
49: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
50: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
51: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
52: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
53: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
54: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
55: * SUCH DAMAGE.
56: *
57: * @(#)tp_emit.c 8.1 (Berkeley) 6/10/93
58: */
59:
60: /***********************************************************
61: Copyright IBM Corporation 1987
62:
63: All Rights Reserved
64:
65: Permission to use, copy, modify, and distribute this software and its
66: documentation for any purpose and without fee is hereby granted,
67: provided that the above copyright notice appear in all copies and that
68: both that copyright notice and this permission notice appear in
69: supporting documentation, and that the name of IBM not be
70: used in advertising or publicity pertaining to distribution of the
71: software without specific, written prior permission.
72:
73: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
74: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
75: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
76: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
77: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
78: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
79: SOFTWARE.
80:
81: ******************************************************************/
82:
83: /*
84: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison
85: */
86: /*
87: * ARGO TP
88: *
89: * This file contains tp_emit() and tp_error_emit(), which
90: * form TPDUs and hand them to ip.
91: * They take data in the form of mbuf chain, allocate mbufs as
92: * necessary for headers, and set the fields as appropriate from
93: * information found in the tpcb and net-level pcb.
94: *
95: * The worst thing about this code is adding the variable-length
96: * options on a machine that requires alignment for any memory access
97: * that isn't of size 1. See the macro ADDOPTION() below.
98: *
99: * We don't do any concatenation. (There's a kludge to test the
100: * basic mechanism of separation under the 'w' tpdebug option, that's all.)
101: */
102:
103: #include <sys/param.h>
104: #include <sys/systm.h>
105: #include <sys/mbuf.h>
106: #include <sys/socket.h>
107: #include <sys/socketvar.h>
108: #include <sys/protosw.h>
109: #include <sys/errno.h>
110: #include <sys/time.h>
111:
112: #include <netiso/iso.h>
113: #include <netiso/iso_pcb.h>
114: #include <netiso/argo_debug.h>
115: #include <netiso/tp_timer.h>
116: #include <netiso/tp_param.h>
117: #include <netiso/tp_stat.h>
118: #include <netiso/tp_pcb.h>
119: #include <netiso/tp_tpdu.h>
120: #include <netiso/tp_trace.h>
121: #include <netiso/tp_meas.h>
122: #include <netiso/tp_seq.h>
123: #include <netiso/iso_errno.h>
124:
125: #include <net/if.h>
126: #ifdef TRUE
127: #undef FALSE
128: #undef TRUE
129: #endif
130: #include <netccitt/x25.h>
131: #include <netccitt/pk.h>
132: #include <netccitt/pk_var.h>
133:
134: void iso_gen_csum();
135:
136:
137: /* Here is a mighty kludge. The token ring misorders packets if you
138: * fire them at it too fast, and TP sans checksum is "too fast", so
139: * we have introduced a delay when checksumming isn't used.
140: */
141: char tp_delay = 0x00; /* delay to keep token ring from blowing it */
142:
143: /*
144: * NAME: tp_emit()
145: *
146: * CALLED FROM: tp.trans and from tp_sbsend()
147: *
148: * FUNCTION and ARGUMENTS:
149: * Emits one tpdu of the type (dutype), of the format appropriate
150: * to the connection described by the pcb (tpcb), with sequence
151: * number (seq) (where appropriate), end-of-tsdu bit (eot) where
152: * appropriate, and with the data in the mbuf chain (data).
153: * For DR and ER tpdus, the argument (eot) is
154: * the reason for issuing the tpdu rather than an end-of-tsdu indicator.
155: *
156: * RETURNS:
157: * 0 OK
158: * ENOBUFS
159: * E* returned from net layer output rtn
160: *
161: * SIDE EFFECTS:
162: *
163: * NOTES:
164: *
165: * WE ASSUME that the tp header + all options will fit in ONE mbuf.
166: * If mbufs are 256 this will most likely be true, but if they are 128 it's
167: * possible that they won't.
168: * If you used every option on the CR + max. user data you'd overrun
169: * 112 but unless you used > 115 bytes for the security
170: * parameter, it would fit in a 256-byte mbuf (240 bytes for the header)
171: * We don't support the security parameter, so this isn't a problem.
172: * If security is added, we ought to remove this assumption.
173: *
174: * We do not implement the flow control confirmation "element of procedure".
175: * A) it should not affect interoperability,
176: * B) it should not be necessary - the protocol will eventually
177: * straighten things out w/o FCC, as long as we don't have severely
178: * mismatched keepalive and inactivity timers, and
179: * C) it appears not to be REQUIRED, and
180: * D) it's incredibly grotesque, and no doubt will lengthen a few
181: * critical paths.
182: * HOWEVER, we're thinking about putting it in anyway, for
183: * completeness, just like we did with ack subsequencing.
184: */
185:
186: int
187: tp_emit(dutype, tpcb, seq, eot, data)
188: int dutype;
189: struct tp_pcb *tpcb;
190: SeqNum seq;
191: u_int eot;
192: struct mbuf *data;
193: {
194: register struct tpdu *hdr;
195: register struct mbuf *m;
196: int csum_offset=0;
197: int datalen = 0;
198: int error = 0;
199: SeqNum olduwe;
200: int acking_ooo;
201:
202: /* NOTE:
203: * here we treat tpdu_li as if it DID include the li field, up until
204: * the end, at which time we subtract 1
205: * THis is because if we subtract 1 right away, we end up adding
206: * one every time we add an option.
207: */
208: IFDEBUG(D_EMIT)
209: printf(
210: "tp_emit dutype 0x%x, tpcb 0x%x, eot 0x%x, seq 0x%x, data 0x%x",
211: dutype, tpcb, eot, seq, data);
212: ENDDEBUG
213:
214: if (dutype == CR_TPDU || dutype == CC_TPDU) {
215: // m = (struct mbuf *) malloc((u_long)256, M_MBUF, M_DONTWAIT);
216: MALLOC(m, struct mbuf *, 256, M_MBUF, M_NOWAIT);
217: if (m) {
218: m->m_type = TPMT_TPHDR;
219: mbstat.m_mtypes[TPMT_TPHDR]++;
220: m->m_next = MNULL;
221: m->m_nextpkt = MNULL;
222: m->m_data = m->m_pktdat;
223: m->m_flags = M_PKTHDR;
224: }
225: } else {
226: MGETHDR(m, M_DONTWAIT, TPMT_TPHDR);
227: }
228: m->m_data += max_hdr;
229: if (m == NULL) {
230: if(data != (struct mbuf *)0)
231: m_freem(data);
232: error = ENOBUFS;
233: goto done;
234: }
235: m->m_len = sizeof(struct tpdu);
236: m->m_act = MNULL;
237:
238: hdr = mtod(m, struct tpdu *);
239: bzero((caddr_t)hdr, sizeof(struct tpdu));
240:
241: {
242: int tp_headersize();
243:
244: hdr->tpdu_type = dutype;
245: hdr->tpdu_li = tp_headersize(dutype, tpcb);
246: /*
247: * class 0 doesn't use this for DT
248: * it'll just get overwritten below
249: */
250: hdr->tpdu_dref = htons(tpcb->tp_fref);
251: if( tpcb->tp_use_checksum ||
252: (dutype == CR_TPDU_type && (tpcb->tp_class & TP_CLASS_4) )) {
253: csum_offset = hdr->tpdu_li + 2; /* DOESN'T include csum */
254: ADDOPTION(TPP_checksum, hdr, 2, eot /* dummy arg */);
255: IFDEBUG(D_CHKSUM)
256: printf(
257: "tp_emit: csum_offset 0x%x, hdr->tpdu_li 0x%x\n",
258: csum_offset, hdr->tpdu_li);
259: ENDDEBUG
260: }
261: /*
262: * VARIABLE PARTS...
263: */
264: switch( dutype ) {
265:
266: case CR_TPDU_type:
267: hdr->tpdu_CRdref_0 = 0; /* must be zero */
268: case CC_TPDU_type:
269: if (!tpcb->tp_cebit_off) {
270: tpcb->tp_win_recv = tp_start_win << 8;
271: LOCAL_CREDIT(tpcb);
272: CONG_INIT_SAMPLE(tpcb);
273: } else
274: LOCAL_CREDIT(tpcb);
275:
276: /* Case CC_TPDU_type used to be here */
277: {
278: u_char x;
279:
280: hdr->tpdu_CCsref = htons(tpcb->tp_lref); /* same as CRsref */
281:
282: if( tpcb->tp_class > TP_CLASS_1 ) {
283: tpcb->tp_sent_uwe = tpcb->tp_lcredit -1;
284: tpcb->tp_sent_rcvnxt = 1;
285: tpcb->tp_sent_lcdt = tpcb->tp_lcredit;
286: hdr->tpdu_cdt = tpcb->tp_lcredit;
287: } else {
288: #if TPCONS
289: if (tpcb->tp_netservice == ISO_CONS) {
290: struct isopcb *isop = (struct isopcb *)tpcb->tp_npcb;
291: struct pklcd *lcp = (struct pklcd *)(isop->isop_chan);
292: lcp->lcd_flags &= ~X25_DG_CIRCUIT;
293: }
294: #endif
295: hdr->tpdu_cdt = 0;
296: }
297: hdr->tpdu_CCclass = tp_mask_to_num(tpcb->tp_class);
298: hdr->tpdu_CCoptions =
299: (tpcb->tp_xtd_format? TPO_XTD_FMT:0) |
300: (tpcb->tp_use_efc? TPO_USE_EFC:0);
301:
302: IFPERF(tpcb)
303: u_char perf_meas = tpcb->tp_perf_on;
304: ADDOPTION(TPP_perf_meas, hdr, sizeof(perf_meas), perf_meas);
305: ENDPERF
306:
307: if( dutype == CR_TPDU_type ) {
308: IncStat(ts_CR_sent);
309:
310: ASSERT( tpcb->tp_lsuffixlen > 0 );
311: ASSERT( tpcb->tp_fsuffixlen > 0 );
312:
313: ADDOPTION(TPP_calling_sufx, hdr,
314: tpcb->tp_lsuffixlen, tpcb->tp_lsuffix[0]);
315: ADDOPTION(TPP_called_sufx, hdr,
316: tpcb->tp_fsuffixlen, tpcb->tp_fsuffix[0]);
317: } else {
318: IncStat(ts_CC_sent);
319: }
320:
321: ADDOPTION(TPP_tpdu_size, hdr,
322: sizeof(tpcb->tp_tpdusize), tpcb->tp_tpdusize);
323:
324: if (tpcb->tp_class != TP_CLASS_0) {
325: short millisec = 500*(tpcb->tp_sendack_ticks);
326:
327: millisec = htons(millisec);
328: ADDOPTION(TPP_acktime, hdr, sizeof(short), millisec);
329:
330: x = (tpcb->tp_use_nxpd? TPAO_USE_NXPD: 0)
331: | (tpcb->tp_use_rcc? TPAO_USE_RCC : 0)
332: | (tpcb->tp_use_checksum?0: TPAO_NO_CSUM)
333: | (tpcb->tp_xpd_service? TPAO_USE_TXPD: 0);
334: ADDOPTION(TPP_addl_opt, hdr, 1, x);
335:
336: if ((tpcb->tp_l_tpdusize ^ (1 << tpcb->tp_tpdusize)) != 0) {
337: u_short size_s = tpcb->tp_l_tpdusize >> 7;
338: u_char size_c = size_s;
339: ASSERT(tpcb->tp_l_tpdusize < 65536 * 128);
340: if (dutype == CR_TPDU_type)
341: tpcb->tp_ptpdusize = size_s;
342: if (size_s < 256) {
343: ADDOPTION(TPP_ptpdu_size, hdr, 1, size_c);
344: } else {
345: size_s = htons(size_s);
346: ADDOPTION(TPP_ptpdu_size, hdr, 2, size_s);
347: }
348: }
349: }
350:
351: if( (dutype == CR_TPDU_type) && (tpcb->tp_class != TP_CLASS_0)){
352:
353: ASSERT( 1 == sizeof(tpcb->tp_vers) );
354: ADDOPTION(TPP_vers, hdr, 1, tpcb->tp_vers);
355:
356: /* for each alt protocol class x,
357: * x = x<<4;
358: * option = concat(option, x);
359: * Well, for now we only have TP0 for an
360: * alternative so... this is easy.
361: *
362: * HOWEVER... There should be NO alt protocol
363: * class over CLNS. Need to see if the route suggests
364: * CONS, and iff so add alt class.
365: */
366: x = 0;
367: ADDOPTION(TPP_alt_class, hdr, 1, x);
368: }
369:
370: if( hdr->tpdu_li > MLEN)
371: panic("tp_emit CR/CC");
372: }
373: break;
374:
375: case DR_TPDU_type:
376: if( hdr->tpdu_DRdref == 0 ) {
377: /* don't issue the DR */
378: goto done;
379: }
380: hdr->tpdu_cdt = 0;
381: hdr->tpdu_DRsref = htons(tpcb->tp_lref);
382: hdr->tpdu_DRreason = (u_char)eot; /* WHICH BYTE OF THIS??? */
383:
384: /* forget the add'l information variable part */
385: IncStat(ts_DR_sent);
386: break;
387:
388: case DC_TPDU_type: /* not used in class 0 */
389: ASSERT( tpcb->tp_class != TP_CLASS_0);
390: hdr->tpdu_DCsref = htons(tpcb->tp_lref);
391: hdr->tpdu_cdt = 0;
392: data = (struct mbuf *)0;
393: IncStat(ts_DC_sent);
394: break;
395:
396: case XAK_TPDU_type: /* xak not used in class 0 */
397: ASSERT( tpcb->tp_class != TP_CLASS_0); /* fall through */
398: hdr->tpdu_cdt = 0;
399:
400: IFTRACE(D_XPD)
401: tptraceTPCB(TPPTXack, seq, 0, 0, 0, 0);
402: ENDTRACE
403: data = (struct mbuf *)0;
404: if (tpcb->tp_xtd_format) {
405: #ifdef BYTE_ORDER
406: union seq_type seqeotX;
407:
408: seqeotX.s_seq = seq;
409: seqeotX.s_eot = 1;
410: hdr->tpdu_seqeotX = htonl(seqeotX.s_seqeot);
411: #else
412: hdr->tpdu_XAKseqX = seq;
413: #endif /* BYTE_ORDER */
414: } else {
415: hdr->tpdu_XAKseq = seq;
416: }
417: IncStat(ts_XAK_sent);
418: IncPStat(tpcb, tps_XAK_sent);
419: break;
420:
421: case XPD_TPDU_type: /* xpd not used in class 0 */
422: ASSERT( tpcb->tp_class != TP_CLASS_0); /* fall through */
423: hdr->tpdu_cdt = 0;
424: if (tpcb->tp_xtd_format) {
425: #ifdef BYTE_ORDER
426: union seq_type seqeotX;
427:
428: seqeotX.s_seq = seq;
429: seqeotX.s_eot = 1;
430: hdr->tpdu_seqeotX = htonl(seqeotX.s_seqeot);
431: #else
432: hdr->tpdu_XPDseqX = seq;
433: hdr->tpdu_XPDeotX = 1; /* always 1 for XPD tpdu */
434: #endif /* BYTE_ORDER */
435: } else {
436: hdr->tpdu_XPDseq = seq;
437: hdr->tpdu_XPDeot = 1; /* always 1 for XPD tpdu */
438: }
439: IncStat(ts_XPD_sent);
440: IncPStat(tpcb, tps_XPD_sent);
441:
442: /* kludge to test the input size checking */
443: IFDEBUG(D_SIZE_CHECK)
444: /*if(data->m_len <= 16 && data->m_off < (MLEN-18) ) {
445: printf("Sending too much data on XPD: 18 bytes\n");
446: data->m_len = 18;
447: }*/
448: ENDDEBUG
449: break;
450:
451: case DT_TPDU_type:
452: hdr->tpdu_cdt = 0;
453: IFTRACE(D_DATA)
454: tptraceTPCB(TPPTmisc, "emit DT: eot seq tpdu_li", eot, seq,
455: hdr->tpdu_li, 0);
456: ENDTRACE
457: if (tpcb->tp_xtd_format) {
458: #ifdef BYTE_ORDER
459: union seq_type seqeotX;
460:
461: seqeotX.s_seq = seq;
462: seqeotX.s_eot = eot;
463: hdr->tpdu_seqeotX = htonl(seqeotX.s_seqeot);
464: #else
465: hdr->tpdu_DTseqX = seq;
466: hdr->tpdu_DTeotX = eot;
467: #endif /* BYTE_ORDER */
468: } else if (tpcb->tp_class == TP_CLASS_0) {
469: IFDEBUG(D_EMIT)
470: printf("DT tpdu: class 0 m 0x%x hdr 0x%x\n", m, hdr);
471: dump_buf( hdr, hdr->tpdu_li + 1 );
472: ENDDEBUG
473: ((struct tp0du *)hdr)->tp0du_eot = eot;
474: ((struct tp0du *)hdr)->tp0du_mbz = 0;
475: IFDEBUG(D_EMIT)
476: printf("DT 2 tpdu: class 0 m 0x%x hdr 0x%x\n", m, hdr);
477: dump_buf( hdr, hdr->tpdu_li + 1 );
478: ENDDEBUG
479: } else {
480: hdr->tpdu_DTseq = seq;
481: hdr->tpdu_DTeot = eot;
482: }
483: if(eot) {
484: IncStat(ts_EOT_sent);
485: }
486: IncStat(ts_DT_sent);
487: IncPStat(tpcb, tps_DT_sent);
488: break;
489:
490: case AK_TPDU_type:/* ak not used in class 0 */
491: ASSERT( tpcb->tp_class != TP_CLASS_0);
492: data = (struct mbuf *)0;
493: olduwe = tpcb->tp_sent_uwe;
494:
495: if (seq != tpcb->tp_sent_rcvnxt || tpcb->tp_rsycnt == 0) {
496: LOCAL_CREDIT( tpcb );
497: tpcb->tp_sent_uwe =
498: SEQ(tpcb,tpcb->tp_rcvnxt + tpcb->tp_lcredit -1);
499: tpcb->tp_sent_lcdt = tpcb->tp_lcredit;
500: acking_ooo = 0;
501: } else
502: acking_ooo = 1;
503:
504: IFDEBUG(D_RENEG)
505: /* occasionally fake a reneging so
506: you can test subsequencing */
507: if( olduwe & 0x1 ) {
508: tpcb->tp_reneged = 1;
509: IncStat(ts_ldebug);
510: }
511: ENDDEBUG
512: /* Are we about to reneg on credit?
513: * When might we do so?
514: * a) when using optimistic credit (which we no longer do).
515: * b) when drain() gets implemented (not in the plans).
516: * c) when D_RENEG is on.
517: * d) when DEC BIT response is implemented.
518: * (not- when we do this, we'll need to implement flow control
519: * confirmation)
520: */
521: if( SEQ_LT(tpcb, tpcb->tp_sent_uwe, olduwe) ) {
522: tpcb->tp_reneged = 1;
523: IncStat(ts_lcdt_reduced);
524: IFTRACE(D_CREDIT)
525: tptraceTPCB(TPPTmisc,
526: "RENEG: olduwe newuwe lcredit rcvnxt",
527: olduwe,
528: tpcb->tp_sent_uwe, tpcb->tp_lcredit,
529: tpcb->tp_rcvnxt);
530: ENDTRACE
531: }
532: IFPERF(tpcb)
533: /* new lwe is less than old uwe means we're
534: * acking before we received a whole window full
535: */
536: if( SEQ_LT( tpcb, tpcb->tp_rcvnxt, olduwe) ) {
537: /* tmp1 = number of pkts fewer than the full window */
538: register int tmp1 =
539: (int) SEQ_SUB( tpcb, olduwe, tpcb->tp_rcvnxt);
540:
541: if(tmp1 > TP_PM_MAX)
542: tmp1 = TP_PM_MAX;
543: IncPStat( tpcb, tps_ack_early[tmp1] );
544:
545: /* tmp1 = amt of new cdt we're advertising */
546: tmp1 = SEQ_SUB( tpcb, seq, tpcb->tp_sent_rcvnxt);
547: if(tmp1 > TP_PM_MAX )
548: tmp1 = TP_PM_MAX;
549:
550: IncPStat( tpcb,
551: tps_cdt_acked [ tmp1 ]
552: [ ((tpcb->tp_lcredit > TP_PM_MAX)?
553: TP_PM_MAX:tpcb->tp_lcredit) ] );
554:
555: }
556: ENDPERF
557:
558: IFTRACE(D_ACKSEND)
559: tptraceTPCB(TPPTack, seq, tpcb->tp_lcredit, tpcb->tp_sent_uwe,
560: tpcb->tp_r_subseq, 0);
561: ENDTRACE
562: if (tpcb->tp_xtd_format) {
563: #ifdef BYTE_ORDER
564: union seq_type seqeotX;
565:
566: seqeotX.s_seq = seq;
567: seqeotX.s_eot = 0;
568: hdr->tpdu_seqeotX = htonl(seqeotX.s_seqeot);
569: hdr->tpdu_AKcdtX = htons(tpcb->tp_lcredit);
570: #else
571: hdr->tpdu_cdt = 0;
572: hdr->tpdu_AKseqX = seq;
573: hdr->tpdu_AKcdtX = tpcb->tp_lcredit;
574: #endif /* BYTE_ORDER */
575: } else {
576: hdr->tpdu_AKseq = seq;
577: hdr->tpdu_AKcdt = tpcb->tp_lcredit;
578: }
579: if ((tpcb->tp_class == TP_CLASS_4) &&
580: (tpcb->tp_reneged || acking_ooo)) {
581: /*
582: * Ack subsequence parameter req'd if WE reneged on
583: * credit offered. (ISO 8073, 12.2.3.8.2, p. 74)
584: */
585: IFDEBUG(D_RENEG)
586: printf("Adding subseq 0x%x\n", tpcb->tp_s_subseq);
587: ENDDEBUG
588: tpcb->tp_s_subseq++;
589: /*
590: * add tmp subseq and do a htons on it.
591: */
592: ADDOPTION(TPP_subseq, hdr,
593: sizeof(tpcb->tp_s_subseq), tpcb->tp_s_subseq);
594: } else
595: tpcb->tp_s_subseq = 0;
596:
597: if ( tpcb->tp_sendfcc || eot ) /* overloaded to mean SEND FCC */ {
598: /*
599: * Rules for sending FCC ("should" send when) :
600: * %a) received an ack from peer with NO NEWS whatsoever,
601: * and it did not contain an FCC
602: * b) received an ack from peer that opens its closed window.
603: * c) received an ack from peer after it reneged on its
604: * offered credit, AND this ack raises UWE but LWE is same
605: * and below UWE at time of reneging (reduction)
606: * Now, ISO 8073 12.2.3.8.3 says
607: * that a retransmitted AK shall not contain the FCC
608: * parameter. Now, how the hell you tell the difference
609: * between a retransmitted ack and an ack that's sent in
610: * response to a received ack, I don't know, because without
611: * any local activity, and w/o any received DTs, they
612: * will contain exactly the same credit/seq# information.
613: * Anyway, given that the "retransmission of acks"
614: * procedure (ISO 8073 12.2.3.8.3) is optional, and we
615: * don't do it (although the peer can't tell that), we
616: * ignore this last rule.
617: *
618: * We send FCC for reasons a) and b) only.
619: * To add reason c) would require a ridiculous amount of state.
620: *
621: */
622: u_short bogus[4]; /* lwe(32), subseq(16), cdt(16) */
623: SeqNum lwe;
624: u_short subseq, fcredit;
625:
626: tpcb->tp_sendfcc = 0;
627:
628: lwe = (SeqNum) htonl(tpcb->tp_snduna);
629: subseq = htons(tpcb->tp_r_subseq);
630: fcredit = htons(tpcb->tp_fcredit);
631:
632: bcopy((caddr_t) &lwe, (caddr_t)&bogus[0], sizeof(SeqNum));
633: bcopy((caddr_t) &subseq, (caddr_t)&bogus[2], sizeof(u_short));
634: bcopy((caddr_t) &fcredit, (caddr_t)&bogus[3], sizeof(u_short));
635:
636: IFTRACE(D_ACKSEND)
637: tptraceTPCB(TPPTmisc,
638: "emit w/FCC: snduna r_subseq fcredit",
639: tpcb->tp_snduna, tpcb->tp_r_subseq,
640: tpcb->tp_fcredit, 0);
641: ENDTRACE
642:
643: IFDEBUG(D_ACKSEND)
644: printf("Calling ADDOPTION 0x%x, 0x%x, 0x%x,0x%x\n",
645: TPP_flow_cntl_conf,
646: hdr, sizeof(bogus), bogus[0]);
647: ENDDEBUG
648: ADDOPTION(TPP_flow_cntl_conf, hdr, sizeof(bogus), bogus[0]);
649: IFDEBUG(D_ACKSEND)
650: printf("after ADDOPTION hdr 0x%x hdr->tpdu_li 0x%x\n",
651: hdr, hdr->tpdu_li);
652: printf(
653: "after ADDOPTION csum_offset 0x%x, hdr->tpdu_li 0x%x\n",
654: csum_offset, hdr->tpdu_li);
655: ENDDEBUG
656:
657: }
658: tpcb->tp_reneged = 0;
659: tpcb->tp_sent_rcvnxt = seq;
660: if (tpcb->tp_fcredit == 0) {
661: int timo = tpcb->tp_keepalive_ticks;
662: if (tpcb->tp_rxtshift < TP_MAXRXTSHIFT)
663: tpcb->tp_rxtshift++;
664: timo = min(timo, ((int)tpcb->tp_dt_ticks) << tpcb->tp_rxtshift);
665: tp_ctimeout(tpcb, TM_sendack, timo);
666: } else
667: tp_ctimeout(tpcb, TM_sendack, tpcb->tp_keepalive_ticks);
668: IncStat(ts_AK_sent);
669: IncPStat(tpcb, tps_AK_sent);
670: IFDEBUG(D_ACKSEND)
671: printf(
672: "2 after rADDOPTION csum_offset 0x%x, hdr->tpdu_li 0x%x\n",
673: csum_offset, hdr->tpdu_li);
674: ENDDEBUG
675: break;
676:
677: case ER_TPDU_type:
678: hdr->tpdu_ERreason = eot;
679: hdr->tpdu_cdt = 0;
680: /* no user data */
681: data = (struct mbuf *)0;
682: IncStat(ts_ER_sent);
683: break;
684: }
685:
686: }
687: ASSERT( ((int)hdr->tpdu_li > 0) && ((int)hdr->tpdu_li < MLEN) );
688:
689: m->m_next = data;
690:
691: ASSERT( hdr->tpdu_li < MLEN ); /* leave this in */
692: ASSERT( hdr->tpdu_li != 0 ); /* leave this in */
693:
694: m->m_len = hdr->tpdu_li ;
695: hdr->tpdu_li --; /* doesn't include the li field */
696:
697: datalen = m_datalen( m ); /* total len */
698:
699: ASSERT( datalen <= tpcb->tp_l_tpdusize ); /* may become a problem
700: when CLNP is used; leave in here for the time being */
701: IFDEBUG(D_ACKSEND)
702: printf(
703: "4 after rADDOPTION csum_offset 0x%x, hdr->tpdu_li 0x%x\n",
704: csum_offset, hdr->tpdu_li);
705: ENDDEBUG
706: if( datalen > tpcb->tp_l_tpdusize ) {
707: printf("data len 0x%x tpcb->tp_l_tpdusize 0x%x\n",
708: datalen, tpcb->tp_l_tpdusize);
709: }
710: IFDEBUG(D_EMIT)
711: printf(
712: "tp_emit before gen_csum m_len 0x%x, csum_offset 0x%x, datalen 0x%x\n",
713: m->m_len, csum_offset, datalen);
714: ENDDEBUG
715: if( tpcb->tp_use_checksum ||
716: (dutype == CR_TPDU_type && (tpcb->tp_class & TP_CLASS_4)) ) {
717: iso_gen_csum(m, csum_offset, datalen);
718: }
719:
720: IFDEBUG(D_EMIT)
721: printf("tp_emit before tpxxx_output tpcb 0x%x, dutype 0x%x, datalen 0x%x\n",
722: tpcb, dutype, datalen);
723: dump_buf(mtod(m, caddr_t), datalen);
724: ENDDEBUG
725:
726: IFPERF(tpcb)
727: if( dutype == DT_TPDU_type ) {
728: PStat(tpcb, Nb_to_ll) += (datalen - m->m_len);
729: tpmeas( tpcb->tp_lref, TPtime_to_ll, (struct timeval *)0,
730: seq, PStat(tpcb, Nb_to_ll), (datalen - m->m_len));
731: }
732: ENDPERF
733:
734: IFTRACE(D_EMIT)
735: tptraceTPCB(TPPTtpduout, dutype, hdr, hdr->tpdu_li+1, datalen, 0);
736: ENDTRACE
737: IFDEBUG(D_EMIT)
738: printf("OUTPUT: tpcb 0x%x, isop 0x%x, so 0x%x\n",
739: tpcb, tpcb->tp_npcb, tpcb->tp_sock);
740: ENDDEBUG
741:
742: { extern char tp_delay;
743:
744: if( tp_delay )
745: if( tpcb->tp_use_checksum == 0 ) {
746: register u_int i = tp_delay;
747: for (; i!= 0; i--)
748: (void) iso_check_csum(m, datalen);
749: }
750: }
751: ASSERT( m->m_len > 0 );
752: error = (tpcb->tp_nlproto->nlp_output)(tpcb->tp_npcb, m, datalen,
753: !tpcb->tp_use_checksum);
754: IFDEBUG(D_EMIT)
755: printf("OUTPUT: returned 0x%x\n", error);
756: ENDDEBUG
757: IFTRACE(D_EMIT)
758: tptraceTPCB(TPPTmisc,
759: "tp_emit nlproto->output netservice returns datalen",
760: tpcb->tp_nlproto->nlp_output, tpcb->tp_netservice, error, datalen);
761: ENDTRACE
762: done:
763: if (error) {
764: if (dutype == AK_TPDU_type)
765: tp_ctimeout(tpcb, TM_sendack, 1);
766: if (error == E_CO_QFULL) {
767: tp_quench(tpcb, PRC_QUENCH);
768: return 0;
769: }
770: }
771: return error;
772: }
773: /*
774: * NAME: tp_error_emit()
775: * CALLED FROM: tp_input() when a DR or ER is to be issued in
776: * response to an input error.
777: * FUNCTION and ARGUMENTS:
778: * The error type is the first argument.
779: * The argument (sref) is the source reference on the bad incoming tpdu,
780: * and is used for a destination reference on the outgoing packet.
781: * (faddr) and (laddr) are the foreign and local addresses for this
782: * connection.
783: * (erdata) is a ptr to the errant incoming tpdu, and is copied into the
784: * outgoing ER, if an ER is to be issued.
785: * (erlen) is the number of octets of the errant tpdu that we should
786: * try to copy.
787: * (tpcb) is the pcb that describes the connection for which the bad tpdu
788: * arrived.
789: * RETURN VALUES:
790: * 0 OK
791: * ENOBUFS
792: * E* from net layer datagram output routine
793: * SIDE EFFECTS:
794: *
795: * NOTES:
796: */
797:
798: int
799: tp_error_emit(error, sref, faddr, laddr, erdata, erlen, tpcb, cons_channel,
800: dgout_routine)
801: int error;
802: u_long sref;
803: struct sockaddr_iso *faddr, *laddr;
804: struct mbuf *erdata;
805: int erlen;
806: struct tp_pcb *tpcb;
807: caddr_t cons_channel;
808: int (*dgout_routine)();
809: {
810: int dutype;
811: int datalen = 0;
812: register struct tpdu *hdr;
813: register struct mbuf *m;
814: int csum_offset;
815:
816: IFTRACE(D_ERROR_EMIT)
817: tptrace(TPPTmisc, "tp_error_emit error sref tpcb erlen",
818: error, sref, tpcb, erlen);
819: ENDTRACE
820: IFDEBUG(D_ERROR_EMIT)
821: printf(
822: "tp_error_emit error 0x%x sref 0x%x tpcb 0x%x erlen 0x%x chan 0x%x\n",
823: error, sref, tpcb, erlen, cons_channel);
824: ENDDEBUG
825:
826: MGET(m, M_DONTWAIT, TPMT_TPHDR);
827: if (m == NULL) {
828: return ENOBUFS;
829: }
830: m->m_len = sizeof(struct tpdu);
831: m->m_act = MNULL;
832:
833: hdr = mtod(m, struct tpdu *);
834:
835: IFDEBUG(D_ERROR_EMIT)
836: printf("[error 0x%x] [error&0xff 0x%x] [(char)error 0x%x]\n",
837: error, error&0xff, (char)error);
838: ENDDEBUG
839:
840:
841: if (error & TP_ERROR_SNDC)
842: dutype = DC_TPDU_type;
843: else if (error & 0x40) {
844: error &= ~0x40;
845: dutype = ER_TPDU_type;
846: } else
847: dutype = DR_TPDU_type;
848: error &= 0xff;
849:
850: hdr->tpdu_type = dutype;
851: hdr->tpdu_cdt = 0;
852:
853: switch( dutype ) {
854:
855: case DC_TPDU_type:
856: IncStat(ts_DC_sent);
857: hdr->tpdu_li = 6;
858: hdr->tpdu_DCdref = htons(sref);
859: hdr->tpdu_DCsref = tpcb ? htons(tpcb->tp_lref) : 0;
860: IFDEBUG(D_ERROR_EMIT)
861: printf("DC case:\n");
862: dump_buf( hdr, 6);
863: ENDDEBUG
864: /* forget the add'l information variable part */
865: break;
866:
867: case DR_TPDU_type:
868: IncStat(ts_DR_sent);
869: hdr->tpdu_li = 7;
870: hdr->tpdu_DRdref = htons(sref);
871: hdr->tpdu_DRsref = 0;
872: hdr->tpdu_DRreason = (char)error;
873: IFDEBUG(D_ERROR_EMIT)
874: printf("DR case:\n");
875: dump_buf( hdr, 7);
876: ENDDEBUG
877: /* forget the add'l information variable part */
878: break;
879:
880: case ER_TPDU_type:
881: IncStat(ts_ER_sent);
882: hdr->tpdu_li = 5;
883: hdr->tpdu_ERreason = (char)error;
884: hdr->tpdu_ERdref = htons(sref);
885: break;
886:
887: default:
888: ASSERT(0);
889: printf("TP PANIC: bad dutype 0x%x\n", dutype);
890: }
891:
892: if(tpcb)
893: if( tpcb->tp_use_checksum ) {
894: ADDOPTION(TPP_checksum, hdr, 2, csum_offset /* dummy argument */);
895: csum_offset = hdr->tpdu_li - 2;
896: }
897:
898: ASSERT( hdr->tpdu_li < MLEN );
899:
900: if (dutype == ER_TPDU_type) {
901: /* copy the errant tpdu into another 'variable part' */
902: register caddr_t P;
903:
904: IFTRACE(D_ERROR_EMIT)
905: tptrace(TPPTmisc, "error_emit ER len tpduli", erlen, hdr->tpdu_li,
906: 0,0);
907: ENDTRACE
908: IFDEBUG(D_ERROR_EMIT)
909: printf("error_emit ER len 0x%x tpduli 0x%x\n", erlen, hdr->tpdu_li);
910: ENDDEBUG
911:
912: /* copy at most as many octets for which you have room */
913: if (erlen + hdr->tpdu_li + 2 > TP_MAX_HEADER_LEN)
914: erlen = TP_MAX_HEADER_LEN - hdr->tpdu_li - 2;
915:
916: /* add the "invalid tpdu" parameter : required in class 0 */
917: P = (caddr_t)hdr + (int)(hdr->tpdu_li);
918: vbptr(P)->tpv_code = TPP_invalid_tpdu; /* parameter code */
919: vbptr(P)->tpv_len = erlen; /* parameter length */
920: m->m_len = hdr->tpdu_li + 2; /* 1 for code, 1 for length */
921:
922: /* tp_input very likely handed us an mbuf chain w/ nothing in
923: * the first mbuf and the data following the empty mbuf
924: */
925: if(erdata->m_len == 0) {
926: erdata = m_free(erdata); /* returns the next mbuf on the chain */
927: }
928: /*
929: * copy only up to the bad octet
930: * (or max that will fit in a header
931: */
932: m->m_next = m_copy(erdata, 0, erlen);
933: hdr->tpdu_li += erlen + 2;
934: m_freem(erdata);
935: } else {
936: IFDEBUG(D_ERROR_EMIT)
937: printf("error_emit DR error tpduli 0x%x\n", error, hdr->tpdu_li);
938: dump_buf( (char *)hdr, hdr->tpdu_li );
939: ENDDEBUG
940: m->m_len = hdr->tpdu_li ;
941: m_freem(erdata);
942: }
943:
944: hdr->tpdu_li --;
945: IFTRACE(D_ERROR_EMIT)
946: tptrace(TPPTtpduout, 2, hdr, hdr->tpdu_li+1, 0, 0);
947: ENDTRACE
948:
949: datalen = m_datalen( m);
950: if (tpcb) {
951: if( tpcb->tp_use_checksum ) {
952: IFTRACE(D_ERROR_EMIT)
953: tptrace(TPPTmisc, "before gen csum datalen", datalen,0,0,0);
954: ENDTRACE
955: IFDEBUG(D_ERROR_EMIT)
956: printf("before gen csum datalen 0x%x, csum_offset 0x%x\n",
957: datalen, csum_offset);
958: ENDDEBUG
959:
960: iso_gen_csum(m, csum_offset, datalen);
961: }
962:
963: IFDEBUG(D_ERROR_EMIT)
964: printf("OUTPUT: tpcb 0x%x, isop 0x%x, so 0x%x\n",
965: tpcb, tpcb->tp_npcb, tpcb->tp_sock);
966: ENDDEBUG
967: }
968: if (cons_channel) {
969: #if TPCONS
970: struct pklcd *lcp = (struct pklcd *)cons_channel;
971: struct isopcb *isop = (struct isopcb *)lcp->lcd_upnext;
972:
973: tpcons_dg_output(cons_channel, m, datalen);
974: /* was if (tpcb == 0) iso_pcbdetach(isop); */
975: /* but other side may want to try again over same VC,
976: so, we'll depend on him closing it, but in case it gets forgotten
977: we'll mark it for garbage collection */
978: lcp->lcd_flags |= X25_DG_CIRCUIT;
979: IFDEBUG(D_ERROR_EMIT)
980: printf("OUTPUT: dutype 0x%x channel 0x%x\n",
981: dutype, cons_channel);
982: ENDDEBUG
983: #else
984: printf("TP panic! cons channel 0x%x but not cons configured\n",
985: cons_channel);
986: #endif
987: } else if (tpcb) {
988:
989: IFDEBUG(D_ERROR_EMIT)
990: printf("tp_error_emit 1 sending DG: Laddr\n");
991: dump_addr((struct sockaddr *)laddr);
992: printf("Faddr\n");
993: dump_addr((struct sockaddr *)faddr);
994: ENDDEBUG
995: return (tpcb->tp_nlproto->nlp_dgoutput)(
996: &laddr->siso_addr,
997: &faddr->siso_addr,
998: m, datalen,
999: /* no route */ (caddr_t)0, !tpcb->tp_use_checksum);
1000: } else if (dgout_routine) {
1001: IFDEBUG(D_ERROR_EMIT)
1002: printf("tp_error_emit sending DG: Laddr\n");
1003: dump_addr((struct sockaddr *)laddr);
1004: printf("Faddr\n");
1005: dump_addr((struct sockaddr *)faddr);
1006: ENDDEBUG
1007: return (*dgout_routine)( &laddr->siso_addr, &faddr->siso_addr,
1008: m, datalen, /* no route */
1009: (caddr_t)0, /* nochecksum==false */0);
1010: } else {
1011: IFDEBUG(D_ERROR_EMIT)
1012: printf("tp_error_emit DROPPING \n", m);
1013: ENDDEBUG
1014: IncStat(ts_send_drop);
1015: m_freem(m);
1016: return 0;
1017: }
1018: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.