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