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