![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ip_output.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / netinet|
Return to ip_output.c CVS log | Up to [Net/2] / Net2 / netinet |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986, 1988, 1990 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: * @(#)ip_output.c 7.23 (Berkeley) 11/12/90 ! 34: */ ! 35: ! 36: #include "param.h" ! 37: #include "malloc.h" ! 38: #include "mbuf.h" ! 39: #include "errno.h" ! 40: #include "protosw.h" ! 41: #include "socket.h" ! 42: #include "socketvar.h" ! 43: ! 44: #include "../net/if.h" ! 45: #include "../net/route.h" ! 46: ! 47: #include "in.h" ! 48: #include "in_systm.h" ! 49: #include "ip.h" ! 50: #include "in_pcb.h" ! 51: #include "in_var.h" ! 52: #include "ip_var.h" ! 53: ! 54: #ifdef vax ! 55: #include "machine/mtpr.h" ! 56: #endif ! 57: ! 58: struct mbuf *ip_insertoptions(); ! 59: ! 60: /* ! 61: * IP output. The packet in mbuf chain m contains a skeletal IP ! 62: * header (with len, off, ttl, proto, tos, src, dst). ! 63: * The mbuf chain containing the packet will be freed. ! 64: * The mbuf opt, if present, will not be freed. ! 65: */ ! 66: ip_output(m0, opt, ro, flags) ! 67: struct mbuf *m0; ! 68: struct mbuf *opt; ! 69: struct route *ro; ! 70: int flags; ! 71: { ! 72: register struct ip *ip, *mhip; ! 73: register struct ifnet *ifp; ! 74: register struct mbuf *m = m0; ! 75: register int hlen = sizeof (struct ip); ! 76: int len, off, error = 0; ! 77: struct route iproute; ! 78: struct sockaddr_in *dst; ! 79: struct in_ifaddr *ia; ! 80: ! 81: #ifdef DIAGNOSTIC ! 82: if ((m->m_flags & M_PKTHDR) == 0) ! 83: panic("ip_output no HDR"); ! 84: #endif ! 85: if (opt) { ! 86: m = ip_insertoptions(m, opt, &len); ! 87: hlen = len; ! 88: } ! 89: ip = mtod(m, struct ip *); ! 90: /* ! 91: * Fill in IP header. ! 92: */ ! 93: if ((flags & IP_FORWARDING) == 0) { ! 94: ip->ip_v = IPVERSION; ! 95: ip->ip_off &= IP_DF; ! 96: ip->ip_id = htons(ip_id++); ! 97: ip->ip_hl = hlen >> 2; ! 98: } else { ! 99: hlen = ip->ip_hl << 2; ! 100: ipstat.ips_localout++; ! 101: } ! 102: /* ! 103: * Route packet. ! 104: */ ! 105: if (ro == 0) { ! 106: ro = &iproute; ! 107: bzero((caddr_t)ro, sizeof (*ro)); ! 108: } ! 109: dst = (struct sockaddr_in *)&ro->ro_dst; ! 110: /* ! 111: * If there is a cached route, ! 112: * check that it is to the same destination ! 113: * and is still up. If not, free it and try again. ! 114: */ ! 115: if (ro->ro_rt && ((ro->ro_rt->rt_flags & RTF_UP) == 0 || ! 116: dst->sin_addr.s_addr != ip->ip_dst.s_addr)) { ! 117: RTFREE(ro->ro_rt); ! 118: ro->ro_rt = (struct rtentry *)0; ! 119: } ! 120: if (ro->ro_rt == 0) { ! 121: dst->sin_family = AF_INET; ! 122: dst->sin_len = sizeof(*dst); ! 123: dst->sin_addr = ip->ip_dst; ! 124: } ! 125: /* ! 126: * If routing to interface only, ! 127: * short circuit routing lookup. ! 128: */ ! 129: if (flags & IP_ROUTETOIF) { ! 130: ! 131: ia = (struct in_ifaddr *)ifa_ifwithdstaddr((struct sockaddr *)dst); ! 132: if (ia == 0) ! 133: ia = in_iaonnetof(in_netof(ip->ip_dst)); ! 134: if (ia == 0) { ! 135: error = ENETUNREACH; ! 136: goto bad; ! 137: } ! 138: ifp = ia->ia_ifp; ! 139: } else { ! 140: if (ro->ro_rt == 0) ! 141: rtalloc(ro); ! 142: if (ro->ro_rt == 0) { ! 143: error = EHOSTUNREACH; ! 144: goto bad; ! 145: } ! 146: ia = (struct in_ifaddr *)ro->ro_rt->rt_ifa; ! 147: ifp = ro->ro_rt->rt_ifp; ! 148: ro->ro_rt->rt_use++; ! 149: if (ro->ro_rt->rt_flags & RTF_GATEWAY) ! 150: dst = (struct sockaddr_in *)ro->ro_rt->rt_gateway; ! 151: } ! 152: #ifndef notdef ! 153: /* ! 154: * If source address not specified yet, use address ! 155: * of outgoing interface. ! 156: */ ! 157: if (ip->ip_src.s_addr == INADDR_ANY) ! 158: ip->ip_src = IA_SIN(ia)->sin_addr; ! 159: #endif ! 160: /* ! 161: * Look for broadcast address and ! 162: * and verify user is allowed to send ! 163: * such a packet. ! 164: */ ! 165: if (in_broadcast(dst->sin_addr)) { ! 166: if ((ifp->if_flags & IFF_BROADCAST) == 0) { ! 167: error = EADDRNOTAVAIL; ! 168: goto bad; ! 169: } ! 170: if ((flags & IP_ALLOWBROADCAST) == 0) { ! 171: error = EACCES; ! 172: goto bad; ! 173: } ! 174: /* don't allow broadcast messages to be fragmented */ ! 175: if ((u_short)ip->ip_len > ifp->if_mtu) { ! 176: error = EMSGSIZE; ! 177: goto bad; ! 178: } ! 179: m->m_flags |= M_BCAST; ! 180: } ! 181: ! 182: /* ! 183: * If small enough for interface, can just send directly. ! 184: */ ! 185: if ((u_short)ip->ip_len <= ifp->if_mtu) { ! 186: ip->ip_len = htons((u_short)ip->ip_len); ! 187: ip->ip_off = htons((u_short)ip->ip_off); ! 188: ip->ip_sum = 0; ! 189: ip->ip_sum = in_cksum(m, hlen); ! 190: error = (*ifp->if_output)(ifp, m, ! 191: (struct sockaddr *)dst, ro->ro_rt); ! 192: goto done; ! 193: } ! 194: ipstat.ips_fragmented++; ! 195: /* ! 196: * Too large for interface; fragment if possible. ! 197: * Must be able to put at least 8 bytes per fragment. ! 198: */ ! 199: if (ip->ip_off & IP_DF) { ! 200: error = EMSGSIZE; ! 201: goto bad; ! 202: } ! 203: len = (ifp->if_mtu - hlen) &~ 7; ! 204: if (len < 8) { ! 205: error = EMSGSIZE; ! 206: goto bad; ! 207: } ! 208: ! 209: { ! 210: int mhlen, firstlen = len; ! 211: struct mbuf **mnext = &m->m_nextpkt; ! 212: ! 213: /* ! 214: * Loop through length of segment after first fragment, ! 215: * make new header and copy data of each part and link onto chain. ! 216: */ ! 217: m0 = m; ! 218: mhlen = sizeof (struct ip); ! 219: for (off = hlen + len; off < (u_short)ip->ip_len; off += len) { ! 220: MGETHDR(m, M_DONTWAIT, MT_HEADER); ! 221: if (m == 0) { ! 222: error = ENOBUFS; ! 223: goto sendorfree; ! 224: } ! 225: m->m_data += max_linkhdr; ! 226: mhip = mtod(m, struct ip *); ! 227: *mhip = *ip; ! 228: if (hlen > sizeof (struct ip)) { ! 229: mhlen = ip_optcopy(ip, mhip) + sizeof (struct ip); ! 230: mhip->ip_hl = mhlen >> 2; ! 231: } ! 232: m->m_len = mhlen; ! 233: mhip->ip_off = ((off - hlen) >> 3) + (ip->ip_off & ~IP_MF); ! 234: if (ip->ip_off & IP_MF) ! 235: mhip->ip_off |= IP_MF; ! 236: if (off + len >= (u_short)ip->ip_len) ! 237: len = (u_short)ip->ip_len - off; ! 238: else ! 239: mhip->ip_off |= IP_MF; ! 240: mhip->ip_len = htons((u_short)(len + mhlen)); ! 241: m->m_next = m_copy(m0, off, len); ! 242: if (m->m_next == 0) { ! 243: error = ENOBUFS; /* ??? */ ! 244: goto sendorfree; ! 245: } ! 246: m->m_pkthdr.len = mhlen + len; ! 247: m->m_pkthdr.rcvif = (struct ifnet *)0; ! 248: mhip->ip_off = htons((u_short)mhip->ip_off); ! 249: mhip->ip_sum = 0; ! 250: mhip->ip_sum = in_cksum(m, mhlen); ! 251: *mnext = m; ! 252: mnext = &m->m_nextpkt; ! 253: ipstat.ips_ofragments++; ! 254: } ! 255: /* ! 256: * Update first fragment by trimming what's been copied out ! 257: * and updating header, then send each fragment (in order). ! 258: */ ! 259: m = m0; ! 260: m_adj(m, hlen + firstlen - (u_short)ip->ip_len); ! 261: m->m_pkthdr.len = hlen + firstlen; ! 262: ip->ip_len = htons((u_short)m->m_pkthdr.len); ! 263: ip->ip_off = htons((u_short)(ip->ip_off | IP_MF)); ! 264: ip->ip_sum = 0; ! 265: ip->ip_sum = in_cksum(m, hlen); ! 266: sendorfree: ! 267: for (m = m0; m; m = m0) { ! 268: m0 = m->m_nextpkt; ! 269: m->m_nextpkt = 0; ! 270: if (error == 0) ! 271: error = (*ifp->if_output)(ifp, m, ! 272: (struct sockaddr *)dst, ro->ro_rt); ! 273: else ! 274: m_freem(m); ! 275: } ! 276: } ! 277: done: ! 278: if (ro == &iproute && (flags & IP_ROUTETOIF) == 0 && ro->ro_rt) ! 279: RTFREE(ro->ro_rt); ! 280: return (error); ! 281: bad: ! 282: m_freem(m0); ! 283: goto done; ! 284: } ! 285: ! 286: /* ! 287: * Insert IP options into preformed packet. ! 288: * Adjust IP destination as required for IP source routing, ! 289: * as indicated by a non-zero in_addr at the start of the options. ! 290: */ ! 291: struct mbuf * ! 292: ip_insertoptions(m, opt, phlen) ! 293: register struct mbuf *m; ! 294: struct mbuf *opt; ! 295: int *phlen; ! 296: { ! 297: register struct ipoption *p = mtod(opt, struct ipoption *); ! 298: struct mbuf *n; ! 299: register struct ip *ip = mtod(m, struct ip *); ! 300: unsigned optlen; ! 301: ! 302: optlen = opt->m_len - sizeof(p->ipopt_dst); ! 303: if (optlen + (u_short)ip->ip_len > IP_MAXPACKET) ! 304: return (m); /* XXX should fail */ ! 305: if (p->ipopt_dst.s_addr) ! 306: ip->ip_dst = p->ipopt_dst; ! 307: if (m->m_flags & M_EXT || m->m_data - optlen < m->m_pktdat) { ! 308: MGETHDR(n, M_DONTWAIT, MT_HEADER); ! 309: if (n == 0) ! 310: return (m); ! 311: n->m_pkthdr.len = m->m_pkthdr.len + optlen; ! 312: m->m_len -= sizeof(struct ip); ! 313: m->m_data += sizeof(struct ip); ! 314: n->m_next = m; ! 315: m = n; ! 316: m->m_len = optlen + sizeof(struct ip); ! 317: m->m_data += max_linkhdr; ! 318: bcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip)); ! 319: } else { ! 320: m->m_data -= optlen; ! 321: m->m_len += optlen; ! 322: m->m_pkthdr.len += optlen; ! 323: ovbcopy((caddr_t)ip, mtod(m, caddr_t), sizeof(struct ip)); ! 324: } ! 325: ip = mtod(m, struct ip *); ! 326: bcopy((caddr_t)p->ipopt_list, (caddr_t)(ip + 1), (unsigned)optlen); ! 327: *phlen = sizeof(struct ip) + optlen; ! 328: ip->ip_len += optlen; ! 329: return (m); ! 330: } ! 331: ! 332: /* ! 333: * Copy options from ip to jp, ! 334: * omitting those not copied during fragmentation. ! 335: */ ! 336: ip_optcopy(ip, jp) ! 337: struct ip *ip, *jp; ! 338: { ! 339: register u_char *cp, *dp; ! 340: int opt, optlen, cnt; ! 341: ! 342: cp = (u_char *)(ip + 1); ! 343: dp = (u_char *)(jp + 1); ! 344: cnt = (ip->ip_hl << 2) - sizeof (struct ip); ! 345: for (; cnt > 0; cnt -= optlen, cp += optlen) { ! 346: opt = cp[0]; ! 347: if (opt == IPOPT_EOL) ! 348: break; ! 349: if (opt == IPOPT_NOP) ! 350: optlen = 1; ! 351: else ! 352: optlen = cp[IPOPT_OLEN]; ! 353: /* bogus lengths should have been caught by ip_dooptions */ ! 354: if (optlen > cnt) ! 355: optlen = cnt; ! 356: if (IPOPT_COPIED(opt)) { ! 357: bcopy((caddr_t)cp, (caddr_t)dp, (unsigned)optlen); ! 358: dp += optlen; ! 359: } ! 360: } ! 361: for (optlen = dp - (u_char *)(jp+1); optlen & 0x3; optlen++) ! 362: *dp++ = IPOPT_EOL; ! 363: return (optlen); ! 364: } ! 365: ! 366: /* ! 367: * IP socket option processing. ! 368: */ ! 369: ip_ctloutput(op, so, level, optname, mp) ! 370: int op; ! 371: struct socket *so; ! 372: int level, optname; ! 373: struct mbuf **mp; ! 374: { ! 375: register struct inpcb *inp = sotoinpcb(so); ! 376: register struct mbuf *m = *mp; ! 377: register int optval; ! 378: int error = 0; ! 379: ! 380: if (level != IPPROTO_IP) ! 381: error = EINVAL; ! 382: else switch (op) { ! 383: ! 384: case PRCO_SETOPT: ! 385: switch (optname) { ! 386: case IP_OPTIONS: ! 387: #ifdef notyet ! 388: case IP_RETOPTS: ! 389: return (ip_pcbopts(optname, &inp->inp_options, m)); ! 390: #else ! 391: return (ip_pcbopts(&inp->inp_options, m)); ! 392: #endif ! 393: ! 394: case IP_TOS: ! 395: case IP_TTL: ! 396: case IP_RECVOPTS: ! 397: case IP_RECVRETOPTS: ! 398: case IP_RECVDSTADDR: ! 399: if (m->m_len != sizeof(int)) ! 400: error = EINVAL; ! 401: else { ! 402: optval = *mtod(m, int *); ! 403: switch (optname) { ! 404: ! 405: case IP_TOS: ! 406: inp->inp_ip.ip_tos = optval; ! 407: break; ! 408: ! 409: case IP_TTL: ! 410: inp->inp_ip.ip_ttl = optval; ! 411: break; ! 412: #define OPTSET(bit) \ ! 413: if (optval) \ ! 414: inp->inp_flags |= bit; \ ! 415: else \ ! 416: inp->inp_flags &= ~bit; ! 417: ! 418: case IP_RECVOPTS: ! 419: OPTSET(INP_RECVOPTS); ! 420: break; ! 421: ! 422: case IP_RECVRETOPTS: ! 423: OPTSET(INP_RECVRETOPTS); ! 424: break; ! 425: ! 426: case IP_RECVDSTADDR: ! 427: OPTSET(INP_RECVDSTADDR); ! 428: break; ! 429: } ! 430: } ! 431: break; ! 432: #undef OPTSET ! 433: ! 434: default: ! 435: error = EINVAL; ! 436: break; ! 437: } ! 438: if (m) ! 439: (void)m_free(m); ! 440: break; ! 441: ! 442: case PRCO_GETOPT: ! 443: switch (optname) { ! 444: case IP_OPTIONS: ! 445: case IP_RETOPTS: ! 446: *mp = m = m_get(M_WAIT, MT_SOOPTS); ! 447: if (inp->inp_options) { ! 448: m->m_len = inp->inp_options->m_len; ! 449: bcopy(mtod(inp->inp_options, caddr_t), ! 450: mtod(m, caddr_t), (unsigned)m->m_len); ! 451: } else ! 452: m->m_len = 0; ! 453: break; ! 454: ! 455: case IP_TOS: ! 456: case IP_TTL: ! 457: case IP_RECVOPTS: ! 458: case IP_RECVRETOPTS: ! 459: case IP_RECVDSTADDR: ! 460: *mp = m = m_get(M_WAIT, MT_SOOPTS); ! 461: m->m_len = sizeof(int); ! 462: switch (optname) { ! 463: ! 464: case IP_TOS: ! 465: optval = inp->inp_ip.ip_tos; ! 466: break; ! 467: ! 468: case IP_TTL: ! 469: optval = inp->inp_ip.ip_ttl; ! 470: break; ! 471: ! 472: #define OPTBIT(bit) (inp->inp_flags & bit ? 1 : 0) ! 473: ! 474: case IP_RECVOPTS: ! 475: optval = OPTBIT(INP_RECVOPTS); ! 476: break; ! 477: ! 478: case IP_RECVRETOPTS: ! 479: optval = OPTBIT(INP_RECVRETOPTS); ! 480: break; ! 481: ! 482: case IP_RECVDSTADDR: ! 483: optval = OPTBIT(INP_RECVDSTADDR); ! 484: break; ! 485: } ! 486: *mtod(m, int *) = optval; ! 487: break; ! 488: ! 489: default: ! 490: error = EINVAL; ! 491: break; ! 492: } ! 493: break; ! 494: } ! 495: return (error); ! 496: } ! 497: ! 498: /* ! 499: * Set up IP options in pcb for insertion in output packets. ! 500: * Store in mbuf with pointer in pcbopt, adding pseudo-option ! 501: * with destination address if source routed. ! 502: */ ! 503: #ifdef notyet ! 504: ip_pcbopts(optname, pcbopt, m) ! 505: int optname; ! 506: #else ! 507: ip_pcbopts(pcbopt, m) ! 508: #endif ! 509: struct mbuf **pcbopt; ! 510: register struct mbuf *m; ! 511: { ! 512: register cnt, optlen; ! 513: register u_char *cp; ! 514: u_char opt; ! 515: ! 516: /* turn off any old options */ ! 517: if (*pcbopt) ! 518: (void)m_free(*pcbopt); ! 519: *pcbopt = 0; ! 520: if (m == (struct mbuf *)0 || m->m_len == 0) { ! 521: /* ! 522: * Only turning off any previous options. ! 523: */ ! 524: if (m) ! 525: (void)m_free(m); ! 526: return (0); ! 527: } ! 528: ! 529: #ifndef vax ! 530: if (m->m_len % sizeof(long)) ! 531: goto bad; ! 532: #endif ! 533: /* ! 534: * IP first-hop destination address will be stored before ! 535: * actual options; move other options back ! 536: * and clear it when none present. ! 537: */ ! 538: if (m->m_data + m->m_len + sizeof(struct in_addr) >= &m->m_dat[MLEN]) ! 539: goto bad; ! 540: cnt = m->m_len; ! 541: m->m_len += sizeof(struct in_addr); ! 542: cp = mtod(m, u_char *) + sizeof(struct in_addr); ! 543: ovbcopy(mtod(m, caddr_t), (caddr_t)cp, (unsigned)cnt); ! 544: bzero(mtod(m, caddr_t), sizeof(struct in_addr)); ! 545: ! 546: for (; cnt > 0; cnt -= optlen, cp += optlen) { ! 547: opt = cp[IPOPT_OPTVAL]; ! 548: if (opt == IPOPT_EOL) ! 549: break; ! 550: if (opt == IPOPT_NOP) ! 551: optlen = 1; ! 552: else { ! 553: optlen = cp[IPOPT_OLEN]; ! 554: if (optlen <= IPOPT_OLEN || optlen > cnt) ! 555: goto bad; ! 556: } ! 557: switch (opt) { ! 558: ! 559: default: ! 560: break; ! 561: ! 562: case IPOPT_LSRR: ! 563: case IPOPT_SSRR: ! 564: /* ! 565: * user process specifies route as: ! 566: * ->A->B->C->D ! 567: * D must be our final destination (but we can't ! 568: * check that since we may not have connected yet). ! 569: * A is first hop destination, which doesn't appear in ! 570: * actual IP option, but is stored before the options. ! 571: */ ! 572: if (optlen < IPOPT_MINOFF - 1 + sizeof(struct in_addr)) ! 573: goto bad; ! 574: m->m_len -= sizeof(struct in_addr); ! 575: cnt -= sizeof(struct in_addr); ! 576: optlen -= sizeof(struct in_addr); ! 577: cp[IPOPT_OLEN] = optlen; ! 578: /* ! 579: * Move first hop before start of options. ! 580: */ ! 581: bcopy((caddr_t)&cp[IPOPT_OFFSET+1], mtod(m, caddr_t), ! 582: sizeof(struct in_addr)); ! 583: /* ! 584: * Then copy rest of options back ! 585: * to close up the deleted entry. ! 586: */ ! 587: ovbcopy((caddr_t)(&cp[IPOPT_OFFSET+1] + ! 588: sizeof(struct in_addr)), ! 589: (caddr_t)&cp[IPOPT_OFFSET+1], ! 590: (unsigned)cnt + sizeof(struct in_addr)); ! 591: break; ! 592: } ! 593: } ! 594: if (m->m_len > MAX_IPOPTLEN + sizeof(struct in_addr)) ! 595: goto bad; ! 596: *pcbopt = m; ! 597: return (0); ! 598: ! 599: bad: ! 600: (void)m_free(m); ! 601: return (EINVAL); ! 602: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.