![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_ether.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 if_ether.c CVS log | Up to [Net/2] / Net2 / netinet |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986, 1988 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: * @(#)if_ether.c 7.13 (Berkeley) 10/31/90
34: */
35:
36: /*
37: * Ethernet address resolution protocol.
38: * TODO:
39: * run at splnet (add ARP protocol intr.)
40: * link entries onto hash chains, keep free list
41: * add "inuse/lock" bit (or ref. count) along with valid bit
42: */
43:
44: #include "param.h"
45: #include "systm.h"
46: #include "malloc.h"
47: #include "mbuf.h"
48: #include "socket.h"
49: #include "time.h"
50: #include "kernel.h"
51: #include "errno.h"
52: #include "ioctl.h"
53: #include "syslog.h"
54:
55: #include "../net/if.h"
56: #include "in.h"
57: #include "in_systm.h"
58: #include "in_var.h"
59: #include "ip.h"
60: #include "if_ether.h"
61:
62: #ifdef GATEWAY
63: #define ARPTAB_BSIZ 16 /* bucket size */
64: #define ARPTAB_NB 37 /* number of buckets */
65: #else
66: #define ARPTAB_BSIZ 9 /* bucket size */
67: #define ARPTAB_NB 19 /* number of buckets */
68: #endif
69: #define ARPTAB_SIZE (ARPTAB_BSIZ * ARPTAB_NB)
70: struct arptab arptab[ARPTAB_SIZE];
71: int arptab_size = ARPTAB_SIZE; /* for arp command */
72:
73: /*
74: * ARP trailer negotiation. Trailer protocol is not IP specific,
75: * but ARP request/response use IP addresses.
76: */
77: #define ETHERTYPE_IPTRAILERS ETHERTYPE_TRAIL
78:
79: #define ARPTAB_HASH(a) \
80: ((u_long)(a) % ARPTAB_NB)
81:
82: #define ARPTAB_LOOK(at,addr) { \
83: register n; \
84: at = &arptab[ARPTAB_HASH(addr) * ARPTAB_BSIZ]; \
85: for (n = 0 ; n < ARPTAB_BSIZ ; n++,at++) \
86: if (at->at_iaddr.s_addr == addr) \
87: break; \
88: if (n >= ARPTAB_BSIZ) \
89: at = 0; \
90: }
91:
92: /* timer values */
93: #define ARPT_AGE (60*1) /* aging timer, 1 min. */
94: #define ARPT_KILLC 20 /* kill completed entry in 20 mins. */
95: #define ARPT_KILLI 3 /* kill incomplete entry in 3 minutes */
96:
97: extern struct ifnet loif;
98:
99: /*
100: * Timeout routine. Age arp_tab entries once a minute.
101: */
102: arptimer()
103: {
104: register struct arptab *at;
105: register i;
106:
107: timeout(arptimer, (caddr_t)0, ARPT_AGE * hz);
108: at = &arptab[0];
109: for (i = 0; i < ARPTAB_SIZE; i++, at++) {
110: if (at->at_flags == 0 || (at->at_flags & ATF_PERM))
111: continue;
112: if (++at->at_timer < ((at->at_flags&ATF_COM) ?
113: ARPT_KILLC : ARPT_KILLI))
114: continue;
115: /* timer has expired, clear entry */
116: arptfree(at);
117: }
118: }
119:
120: /*
121: * Broadcast an ARP packet, asking who has addr on interface ac.
122: */
123: arpwhohas(ac, addr)
124: register struct arpcom *ac;
125: struct in_addr *addr;
126: {
127: register struct mbuf *m;
128: register struct ether_header *eh;
129: register struct ether_arp *ea;
130: struct sockaddr sa;
131:
132: if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL)
133: return;
134: m->m_len = sizeof(*ea);
135: m->m_pkthdr.len = sizeof(*ea);
136: MH_ALIGN(m, sizeof(*ea));
137: ea = mtod(m, struct ether_arp *);
138: eh = (struct ether_header *)sa.sa_data;
139: bzero((caddr_t)ea, sizeof (*ea));
140: bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
141: sizeof(eh->ether_dhost));
142: eh->ether_type = ETHERTYPE_ARP; /* if_output will swap */
143: ea->arp_hrd = htons(ARPHRD_ETHER);
144: ea->arp_pro = htons(ETHERTYPE_IP);
145: ea->arp_hln = sizeof(ea->arp_sha); /* hardware address length */
146: ea->arp_pln = sizeof(ea->arp_spa); /* protocol address length */
147: ea->arp_op = htons(ARPOP_REQUEST);
148: bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha,
149: sizeof(ea->arp_sha));
150: bcopy((caddr_t)&ac->ac_ipaddr, (caddr_t)ea->arp_spa,
151: sizeof(ea->arp_spa));
152: bcopy((caddr_t)addr, (caddr_t)ea->arp_tpa, sizeof(ea->arp_tpa));
153: sa.sa_family = AF_UNSPEC;
154: sa.sa_len = sizeof(sa);
155: (*ac->ac_if.if_output)(&ac->ac_if, m, &sa, (struct rtentry *)0);
156: }
157:
158: int useloopback = 1; /* use loopback interface for local traffic */
159:
160: /*
161: * Resolve an IP address into an ethernet address. If success,
162: * desten is filled in. If there is no entry in arptab,
163: * set one up and broadcast a request for the IP address.
164: * Hold onto this mbuf and resend it once the address
165: * is finally resolved. A return value of 1 indicates
166: * that desten has been filled in and the packet should be sent
167: * normally; a 0 return indicates that the packet has been
168: * taken over here, either now or for later transmission.
169: *
170: * We do some (conservative) locking here at splimp, since
171: * arptab is also altered from input interrupt service (ecintr/ilintr
172: * calls arpinput when ETHERTYPE_ARP packets come in).
173: */
174: arpresolve(ac, m, destip, desten, usetrailers)
175: register struct arpcom *ac;
176: struct mbuf *m;
177: register struct in_addr *destip;
178: register u_char *desten;
179: int *usetrailers;
180: {
181: register struct arptab *at;
182: struct sockaddr_in sin;
183: register struct in_ifaddr *ia;
184: u_long lna;
185: int s;
186:
187: *usetrailers = 0;
188: if (m->m_flags & M_BCAST) { /* broadcast */
189: bcopy((caddr_t)etherbroadcastaddr, (caddr_t)desten,
190: sizeof(etherbroadcastaddr));
191: return (1);
192: }
193: lna = in_lnaof(*destip);
194: /* if for us, use software loopback driver if up */
195: for (ia = in_ifaddr; ia; ia = ia->ia_next)
196: if ((ia->ia_ifp == &ac->ac_if) &&
197: (destip->s_addr == ia->ia_addr.sin_addr.s_addr)) {
198: /*
199: * This test used to be
200: * if (loif.if_flags & IFF_UP)
201: * It allowed local traffic to be forced
202: * through the hardware by configuring the loopback down.
203: * However, it causes problems during network configuration
204: * for boards that can't receive packets they send.
205: * It is now necessary to clear "useloopback"
206: * to force traffic out to the hardware.
207: */
208: if (useloopback) {
209: sin.sin_family = AF_INET;
210: sin.sin_addr = *destip;
211: (void) looutput(&loif, m, (struct sockaddr *)&sin, 0);
212: /*
213: * The packet has already been sent and freed.
214: */
215: return (0);
216: } else {
217: bcopy((caddr_t)ac->ac_enaddr, (caddr_t)desten,
218: sizeof(ac->ac_enaddr));
219: return (1);
220: }
221: }
222: s = splimp();
223: ARPTAB_LOOK(at, destip->s_addr);
224: if (at == 0) { /* not found */
225: if (ac->ac_if.if_flags & IFF_NOARP) {
226: bcopy((caddr_t)ac->ac_enaddr, (caddr_t)desten, 3);
227: desten[3] = (lna >> 16) & 0x7f;
228: desten[4] = (lna >> 8) & 0xff;
229: desten[5] = lna & 0xff;
230: splx(s);
231: return (1);
232: } else {
233: at = arptnew(destip);
234: if (at == 0)
235: panic("arpresolve: no free entry");
236: at->at_hold = m;
237: arpwhohas(ac, destip);
238: splx(s);
239: return (0);
240: }
241: }
242: at->at_timer = 0; /* restart the timer */
243: if (at->at_flags & ATF_COM) { /* entry IS complete */
244: bcopy((caddr_t)at->at_enaddr, (caddr_t)desten,
245: sizeof(at->at_enaddr));
246: if (at->at_flags & ATF_USETRAILERS)
247: *usetrailers = 1;
248: splx(s);
249: return (1);
250: }
251: /*
252: * There is an arptab entry, but no ethernet address
253: * response yet. Replace the held mbuf with this
254: * latest one.
255: */
256: if (at->at_hold)
257: m_freem(at->at_hold);
258: at->at_hold = m;
259: arpwhohas(ac, destip); /* ask again */
260: splx(s);
261: return (0);
262: }
263:
264: /*
265: * Called from 10 Mb/s Ethernet interrupt handlers
266: * when ether packet type ETHERTYPE_ARP
267: * is received. Common length and type checks are done here,
268: * then the protocol-specific routine is called.
269: */
270: arpinput(ac, m)
271: struct arpcom *ac;
272: struct mbuf *m;
273: {
274: register struct arphdr *ar;
275:
276: if (ac->ac_if.if_flags & IFF_NOARP)
277: goto out;
278: if (m->m_len < sizeof(struct arphdr))
279: goto out;
280: ar = mtod(m, struct arphdr *);
281: if (ntohs(ar->ar_hrd) != ARPHRD_ETHER)
282: goto out;
283: if (m->m_len < sizeof(struct arphdr) + 2 * ar->ar_hln + 2 * ar->ar_pln)
284: goto out;
285:
286: switch (ntohs(ar->ar_pro)) {
287:
288: case ETHERTYPE_IP:
289: case ETHERTYPE_IPTRAILERS:
290: in_arpinput(ac, m);
291: return;
292:
293: default:
294: break;
295: }
296: out:
297: m_freem(m);
298: }
299:
300: /*
301: * ARP for Internet protocols on 10 Mb/s Ethernet.
302: * Algorithm is that given in RFC 826.
303: * In addition, a sanity check is performed on the sender
304: * protocol address, to catch impersonators.
305: * We also handle negotiations for use of trailer protocol:
306: * ARP replies for protocol type ETHERTYPE_TRAIL are sent
307: * along with IP replies if we want trailers sent to us,
308: * and also send them in response to IP replies.
309: * This allows either end to announce the desire to receive
310: * trailer packets.
311: * We reply to requests for ETHERTYPE_TRAIL protocol as well,
312: * but don't normally send requests.
313: */
314: in_arpinput(ac, m)
315: register struct arpcom *ac;
316: struct mbuf *m;
317: {
318: register struct ether_arp *ea;
319: struct ether_header *eh;
320: register struct arptab *at; /* same as "merge" flag */
321: register struct in_ifaddr *ia;
322: struct in_ifaddr *maybe_ia = 0;
323: struct mbuf *mcopy = 0;
324: struct sockaddr_in sin;
325: struct sockaddr sa;
326: struct in_addr isaddr, itaddr, myaddr;
327: int proto, op, s, completed = 0;
328:
329: ea = mtod(m, struct ether_arp *);
330: proto = ntohs(ea->arp_pro);
331: op = ntohs(ea->arp_op);
332: bcopy((caddr_t)ea->arp_spa, (caddr_t)&isaddr, sizeof (isaddr));
333: bcopy((caddr_t)ea->arp_tpa, (caddr_t)&itaddr, sizeof (itaddr));
334: for (ia = in_ifaddr; ia; ia = ia->ia_next)
335: if (ia->ia_ifp == &ac->ac_if) {
336: maybe_ia = ia;
337: if ((itaddr.s_addr == ia->ia_addr.sin_addr.s_addr) ||
338: (isaddr.s_addr == ia->ia_addr.sin_addr.s_addr))
339: break;
340: }
341: if (maybe_ia == 0)
342: goto out;
343: myaddr = ia ? ia->ia_addr.sin_addr : maybe_ia->ia_addr.sin_addr;
344: if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)ac->ac_enaddr,
345: sizeof (ea->arp_sha)))
346: goto out; /* it's from me, ignore it. */
347: if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)etherbroadcastaddr,
348: sizeof (ea->arp_sha))) {
349: log(LOG_ERR,
350: "arp: ether address is broadcast for IP address %x!\n",
351: ntohl(isaddr.s_addr));
352: goto out;
353: }
354: if (isaddr.s_addr == myaddr.s_addr) {
355: log(LOG_ERR,
356: "duplicate IP address %x!! sent from ethernet address: %s\n",
357: ntohl(isaddr.s_addr), ether_sprintf(ea->arp_sha));
358: itaddr = myaddr;
359: if (op == ARPOP_REQUEST)
360: goto reply;
361: goto out;
362: }
363: s = splimp();
364: ARPTAB_LOOK(at, isaddr.s_addr);
365: if (at) {
366: bcopy((caddr_t)ea->arp_sha, (caddr_t)at->at_enaddr,
367: sizeof(ea->arp_sha));
368: if ((at->at_flags & ATF_COM) == 0)
369: completed = 1;
370: at->at_flags |= ATF_COM;
371: if (at->at_hold) {
372: sin.sin_family = AF_INET;
373: sin.sin_addr = isaddr;
374: (*ac->ac_if.if_output)(&ac->ac_if, at->at_hold,
375: (struct sockaddr *)&sin, (struct rtentry *)0);
376: at->at_hold = 0;
377: }
378: }
379: if (at == 0 && itaddr.s_addr == myaddr.s_addr) {
380: /* ensure we have a table entry */
381: if (at = arptnew(&isaddr)) {
382: bcopy((caddr_t)ea->arp_sha, (caddr_t)at->at_enaddr,
383: sizeof(ea->arp_sha));
384: completed = 1;
385: at->at_flags |= ATF_COM;
386: }
387: }
388: splx(s);
389: reply:
390: switch (proto) {
391:
392: case ETHERTYPE_IPTRAILERS:
393: /* partner says trailers are OK */
394: if (at)
395: at->at_flags |= ATF_USETRAILERS;
396: /*
397: * Reply to request iff we want trailers.
398: */
399: if (op != ARPOP_REQUEST || ac->ac_if.if_flags & IFF_NOTRAILERS)
400: goto out;
401: break;
402:
403: case ETHERTYPE_IP:
404: /*
405: * Reply if this is an IP request,
406: * or if we want to send a trailer response.
407: * Send the latter only to the IP response
408: * that completes the current ARP entry.
409: */
410: if (op != ARPOP_REQUEST &&
411: (completed == 0 || ac->ac_if.if_flags & IFF_NOTRAILERS))
412: goto out;
413: }
414: if (itaddr.s_addr == myaddr.s_addr) {
415: /* I am the target */
416: bcopy((caddr_t)ea->arp_sha, (caddr_t)ea->arp_tha,
417: sizeof(ea->arp_sha));
418: bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha,
419: sizeof(ea->arp_sha));
420: } else {
421: ARPTAB_LOOK(at, itaddr.s_addr);
422: if (at == NULL || (at->at_flags & ATF_PUBL) == 0)
423: goto out;
424: bcopy((caddr_t)ea->arp_sha, (caddr_t)ea->arp_tha,
425: sizeof(ea->arp_sha));
426: bcopy((caddr_t)at->at_enaddr, (caddr_t)ea->arp_sha,
427: sizeof(ea->arp_sha));
428: }
429:
430: bcopy((caddr_t)ea->arp_spa, (caddr_t)ea->arp_tpa,
431: sizeof(ea->arp_spa));
432: bcopy((caddr_t)&itaddr, (caddr_t)ea->arp_spa,
433: sizeof(ea->arp_spa));
434: ea->arp_op = htons(ARPOP_REPLY);
435: /*
436: * If incoming packet was an IP reply,
437: * we are sending a reply for type IPTRAILERS.
438: * If we are sending a reply for type IP
439: * and we want to receive trailers,
440: * send a trailer reply as well.
441: */
442: if (op == ARPOP_REPLY)
443: ea->arp_pro = htons(ETHERTYPE_IPTRAILERS);
444: else if (proto == ETHERTYPE_IP &&
445: (ac->ac_if.if_flags & IFF_NOTRAILERS) == 0)
446: mcopy = m_copy(m, 0, (int)M_COPYALL);
447: eh = (struct ether_header *)sa.sa_data;
448: bcopy((caddr_t)ea->arp_tha, (caddr_t)eh->ether_dhost,
449: sizeof(eh->ether_dhost));
450: eh->ether_type = ETHERTYPE_ARP;
451: sa.sa_family = AF_UNSPEC;
452: sa.sa_len = sizeof(sa);
453: (*ac->ac_if.if_output)(&ac->ac_if, m, &sa, (struct rtentry *)0);
454: if (mcopy) {
455: ea = mtod(mcopy, struct ether_arp *);
456: ea->arp_pro = htons(ETHERTYPE_IPTRAILERS);
457: (*ac->ac_if.if_output)(&ac->ac_if,
458: mcopy, &sa, (struct rtentry *)0);
459: }
460: return;
461: out:
462: m_freem(m);
463: return;
464: }
465:
466: /*
467: * Free an arptab entry.
468: */
469: arptfree(at)
470: register struct arptab *at;
471: {
472: int s = splimp();
473:
474: if (at->at_hold)
475: m_freem(at->at_hold);
476: at->at_hold = 0;
477: at->at_timer = at->at_flags = 0;
478: at->at_iaddr.s_addr = 0;
479: splx(s);
480: }
481:
482: /*
483: * Enter a new address in arptab, pushing out the oldest entry
484: * from the bucket if there is no room.
485: * This always succeeds since no bucket can be completely filled
486: * with permanent entries (except from arpioctl when testing whether
487: * another permanent entry will fit).
488: * MUST BE CALLED AT SPLIMP.
489: */
490: struct arptab *
491: arptnew(addr)
492: struct in_addr *addr;
493: {
494: register n;
495: int oldest = -1;
496: register struct arptab *at, *ato = NULL;
497: static int first = 1;
498:
499: if (first) {
500: first = 0;
501: timeout(arptimer, (caddr_t)0, hz);
502: }
503: at = &arptab[ARPTAB_HASH(addr->s_addr) * ARPTAB_BSIZ];
504: for (n = 0; n < ARPTAB_BSIZ; n++,at++) {
505: if (at->at_flags == 0)
506: goto out; /* found an empty entry */
507: if (at->at_flags & ATF_PERM)
508: continue;
509: if ((int) at->at_timer > oldest) {
510: oldest = at->at_timer;
511: ato = at;
512: }
513: }
514: if (ato == NULL)
515: return (NULL);
516: at = ato;
517: arptfree(at);
518: out:
519: at->at_iaddr = *addr;
520: at->at_flags = ATF_INUSE;
521: return (at);
522: }
523:
524: arpioctl(cmd, data)
525: int cmd;
526: caddr_t data;
527: {
528: register struct arpreq *ar = (struct arpreq *)data;
529: register struct arptab *at;
530: register struct sockaddr_in *sin;
531: int s;
532:
533: sin = (struct sockaddr_in *)&ar->arp_ha;
534: #if defined(COMPAT_43) && BYTE_ORDER != BIG_ENDIAN
535: if (sin->sin_family == 0 && sin->sin_len < 16)
536: sin->sin_family = sin->sin_len;
537: #endif
538: sin->sin_len = sizeof(ar->arp_ha);
539: sin = (struct sockaddr_in *)&ar->arp_pa;
540: #if defined(COMPAT_43) && BYTE_ORDER != BIG_ENDIAN
541: if (sin->sin_family == 0 && sin->sin_len < 16)
542: sin->sin_family = sin->sin_len;
543: #endif
544: sin->sin_len = sizeof(ar->arp_pa);
545: if (ar->arp_pa.sa_family != AF_INET ||
546: ar->arp_ha.sa_family != AF_UNSPEC)
547: return (EAFNOSUPPORT);
548: s = splimp();
549: ARPTAB_LOOK(at, sin->sin_addr.s_addr);
550: if (at == NULL) { /* not found */
551: if (cmd != SIOCSARP) {
552: splx(s);
553: return (ENXIO);
554: }
555: if (ifa_ifwithnet(&ar->arp_pa) == NULL) {
556: splx(s);
557: return (ENETUNREACH);
558: }
559: }
560: switch (cmd) {
561:
562: case SIOCSARP: /* set entry */
563: if (at == NULL) {
564: at = arptnew(&sin->sin_addr);
565: if (at == NULL) {
566: splx(s);
567: return (EADDRNOTAVAIL);
568: }
569: if (ar->arp_flags & ATF_PERM) {
570: /* never make all entries in a bucket permanent */
571: register struct arptab *tat;
572:
573: /* try to re-allocate */
574: tat = arptnew(&sin->sin_addr);
575: if (tat == NULL) {
576: arptfree(at);
577: splx(s);
578: return (EADDRNOTAVAIL);
579: }
580: arptfree(tat);
581: }
582: }
583: bcopy((caddr_t)ar->arp_ha.sa_data, (caddr_t)at->at_enaddr,
584: sizeof(at->at_enaddr));
585: at->at_flags = ATF_COM | ATF_INUSE |
586: (ar->arp_flags & (ATF_PERM|ATF_PUBL|ATF_USETRAILERS));
587: at->at_timer = 0;
588: break;
589:
590: case SIOCDARP: /* delete entry */
591: arptfree(at);
592: break;
593:
594: case SIOCGARP: /* get entry */
595: case OSIOCGARP:
596: bcopy((caddr_t)at->at_enaddr, (caddr_t)ar->arp_ha.sa_data,
597: sizeof(at->at_enaddr));
598: #ifdef COMPAT_43
599: if (cmd == OSIOCGARP)
600: *(u_short *)&ar->arp_ha = ar->arp_ha.sa_family;
601: #endif
602: ar->arp_flags = at->at_flags;
603: break;
604: }
605: splx(s);
606: return (0);
607: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.