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