![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ip_input.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / sys / netinet|
Return to ip_input.c CVS log | Up to [CSRG BSD Unix] / 42BSD / sys / netinet |
1.1 root 1: /* ip_input.c 6.1 83/08/16 */
2:
3: #include "../h/param.h"
4: #include "../h/systm.h"
5: #include "../h/mbuf.h"
6: #include "../h/domain.h"
7: #include "../h/protosw.h"
8: #include "../h/socket.h"
9: #include "../h/errno.h"
10: #include "../h/time.h"
11: #include "../h/kernel.h"
12:
13: #include "../net/if.h"
14: #include "../net/route.h"
15:
16: #include "../netinet/in.h"
17: #include "../netinet/in_pcb.h"
18: #include "../netinet/in_systm.h"
19: #include "../netinet/ip.h"
20: #include "../netinet/ip_var.h"
21: #include "../netinet/ip_icmp.h"
22: #include "../netinet/tcp.h"
23:
24: u_char ip_protox[IPPROTO_MAX];
25: int ipqmaxlen = IFQ_MAXLEN;
26: struct ifnet *ifinet; /* first inet interface */
27:
28: /*
29: * IP initialization: fill in IP protocol switch table.
30: * All protocols not implemented in kernel go to raw IP protocol handler.
31: */
32: ip_init()
33: {
34: register struct protosw *pr;
35: register int i;
36:
37: pr = pffindproto(PF_INET, IPPROTO_RAW);
38: if (pr == 0)
39: panic("ip_init");
40: for (i = 0; i < IPPROTO_MAX; i++)
41: ip_protox[i] = pr - inetsw;
42: for (pr = inetdomain.dom_protosw;
43: pr <= inetdomain.dom_protoswNPROTOSW; pr++)
44: if (pr->pr_family == PF_INET &&
45: pr->pr_protocol && pr->pr_protocol != IPPROTO_RAW)
46: ip_protox[pr->pr_protocol] = pr - inetsw;
47: ipq.next = ipq.prev = &ipq;
48: ip_id = time.tv_sec & 0xffff;
49: ipintrq.ifq_maxlen = ipqmaxlen;
50: ifinet = if_ifwithaf(AF_INET);
51: }
52:
53: u_char ipcksum = 1;
54: struct ip *ip_reass();
55: struct sockaddr_in ipaddr = { AF_INET };
56:
57: /*
58: * Ip input routine. Checksum and byte swap header. If fragmented
59: * try to reassamble. If complete and fragment queue exists, discard.
60: * Process options. Pass to next level.
61: */
62: ipintr()
63: {
64: register struct ip *ip;
65: register struct mbuf *m;
66: struct mbuf *m0;
67: register int i;
68: register struct ipq *fp;
69: int hlen, s;
70:
71: next:
72: /*
73: * Get next datagram off input queue and get IP header
74: * in first mbuf.
75: */
76: s = splimp();
77: IF_DEQUEUE(&ipintrq, m);
78: splx(s);
79: if (m == 0)
80: return;
81: if ((m->m_off > MMAXOFF || m->m_len < sizeof (struct ip)) &&
82: (m = m_pullup(m, sizeof (struct ip))) == 0) {
83: ipstat.ips_toosmall++;
84: goto next;
85: }
86: ip = mtod(m, struct ip *);
87: if ((hlen = ip->ip_hl << 2) > m->m_len) {
88: if ((m = m_pullup(m, hlen)) == 0) {
89: ipstat.ips_badhlen++;
90: goto next;
91: }
92: ip = mtod(m, struct ip *);
93: }
94: if (ipcksum)
95: if (ip->ip_sum = in_cksum(m, hlen)) {
96: ipstat.ips_badsum++;
97: goto bad;
98: }
99:
100: /*
101: * Convert fields to host representation.
102: */
103: ip->ip_len = ntohs((u_short)ip->ip_len);
104: if (ip->ip_len < hlen) {
105: ipstat.ips_badlen++;
106: goto bad;
107: }
108: ip->ip_id = ntohs(ip->ip_id);
109: ip->ip_off = ntohs((u_short)ip->ip_off);
110:
111: /*
112: * Check that the amount of data in the buffers
113: * is as at least much as the IP header would have us expect.
114: * Trim mbufs if longer than we expect.
115: * Drop packet if shorter than we expect.
116: */
117: i = -ip->ip_len;
118: m0 = m;
119: for (;;) {
120: i += m->m_len;
121: if (m->m_next == 0)
122: break;
123: m = m->m_next;
124: }
125: if (i != 0) {
126: if (i < 0) {
127: ipstat.ips_tooshort++;
128: goto bad;
129: }
130: if (i <= m->m_len)
131: m->m_len -= i;
132: else
133: m_adj(m0, -i);
134: }
135: m = m0;
136:
137: /*
138: * Process options and, if not destined for us,
139: * ship it on. ip_dooptions returns 1 when an
140: * error was detected (causing an icmp message
141: * to be sent).
142: */
143: if (hlen > sizeof (struct ip) && ip_dooptions(ip))
144: goto next;
145:
146: /*
147: * Fast check on the first internet
148: * interface in the list.
149: */
150: if (ifinet) {
151: struct sockaddr_in *sin;
152:
153: sin = (struct sockaddr_in *)&ifinet->if_addr;
154: if (sin->sin_addr.s_addr == ip->ip_dst.s_addr)
155: goto ours;
156: sin = (struct sockaddr_in *)&ifinet->if_broadaddr;
157: if ((ifinet->if_flags & IFF_BROADCAST) &&
158: sin->sin_addr.s_addr == ip->ip_dst.s_addr)
159: goto ours;
160: }
161: /* BEGIN GROT */
162: #include "nd.h"
163: #if NND > 0
164: /*
165: * Diskless machines don't initially know
166: * their address, so take packets from them
167: * if we're acting as a network disk server.
168: */
169: if (in_netof(ip->ip_dst) == INADDR_ANY &&
170: (in_netof(ip->ip_src) == INADDR_ANY &&
171: in_lnaof(ip->ip_src) != INADDR_ANY))
172: goto ours;
173: #endif
174: /* END GROT */
175: ipaddr.sin_addr = ip->ip_dst;
176: if (if_ifwithaddr((struct sockaddr *)&ipaddr) == 0) {
177: ip_forward(ip);
178: goto next;
179: }
180:
181: ours:
182: /*
183: * Look for queue of fragments
184: * of this datagram.
185: */
186: for (fp = ipq.next; fp != &ipq; fp = fp->next)
187: if (ip->ip_id == fp->ipq_id &&
188: ip->ip_src.s_addr == fp->ipq_src.s_addr &&
189: ip->ip_dst.s_addr == fp->ipq_dst.s_addr &&
190: ip->ip_p == fp->ipq_p)
191: goto found;
192: fp = 0;
193: found:
194:
195: /*
196: * Adjust ip_len to not reflect header,
197: * set ip_mff if more fragments are expected,
198: * convert offset of this to bytes.
199: */
200: ip->ip_len -= hlen;
201: ((struct ipasfrag *)ip)->ipf_mff = 0;
202: if (ip->ip_off & IP_MF)
203: ((struct ipasfrag *)ip)->ipf_mff = 1;
204: ip->ip_off <<= 3;
205:
206: /*
207: * If datagram marked as having more fragments
208: * or if this is not the first fragment,
209: * attempt reassembly; if it succeeds, proceed.
210: */
211: if (((struct ipasfrag *)ip)->ipf_mff || ip->ip_off) {
212: ip = ip_reass((struct ipasfrag *)ip, fp);
213: if (ip == 0)
214: goto next;
215: hlen = ip->ip_hl << 2;
216: m = dtom(ip);
217: } else
218: if (fp)
219: ip_freef(fp);
220:
221: /*
222: * Switch out to protocol's input routine.
223: */
224: (*inetsw[ip_protox[ip->ip_p]].pr_input)(m);
225: goto next;
226: bad:
227: m_freem(m);
228: goto next;
229: }
230:
231: /*
232: * Take incoming datagram fragment and try to
233: * reassemble it into whole datagram. If a chain for
234: * reassembly of this datagram already exists, then it
235: * is given as fp; otherwise have to make a chain.
236: */
237: struct ip *
238: ip_reass(ip, fp)
239: register struct ipasfrag *ip;
240: register struct ipq *fp;
241: {
242: register struct mbuf *m = dtom(ip);
243: register struct ipasfrag *q;
244: struct mbuf *t;
245: int hlen = ip->ip_hl << 2;
246: int i, next;
247:
248: /*
249: * Presence of header sizes in mbufs
250: * would confuse code below.
251: */
252: m->m_off += hlen;
253: m->m_len -= hlen;
254:
255: /*
256: * If first fragment to arrive, create a reassembly queue.
257: */
258: if (fp == 0) {
259: if ((t = m_get(M_WAIT, MT_FTABLE)) == NULL)
260: goto dropfrag;
261: fp = mtod(t, struct ipq *);
262: insque(fp, &ipq);
263: fp->ipq_ttl = IPFRAGTTL;
264: fp->ipq_p = ip->ip_p;
265: fp->ipq_id = ip->ip_id;
266: fp->ipq_next = fp->ipq_prev = (struct ipasfrag *)fp;
267: fp->ipq_src = ((struct ip *)ip)->ip_src;
268: fp->ipq_dst = ((struct ip *)ip)->ip_dst;
269: q = (struct ipasfrag *)fp;
270: goto insert;
271: }
272:
273: /*
274: * Find a segment which begins after this one does.
275: */
276: for (q = fp->ipq_next; q != (struct ipasfrag *)fp; q = q->ipf_next)
277: if (q->ip_off > ip->ip_off)
278: break;
279:
280: /*
281: * If there is a preceding segment, it may provide some of
282: * our data already. If so, drop the data from the incoming
283: * segment. If it provides all of our data, drop us.
284: */
285: if (q->ipf_prev != (struct ipasfrag *)fp) {
286: i = q->ipf_prev->ip_off + q->ipf_prev->ip_len - ip->ip_off;
287: if (i > 0) {
288: if (i >= ip->ip_len)
289: goto dropfrag;
290: m_adj(dtom(ip), i);
291: ip->ip_off += i;
292: ip->ip_len -= i;
293: }
294: }
295:
296: /*
297: * While we overlap succeeding segments trim them or,
298: * if they are completely covered, dequeue them.
299: */
300: while (q != (struct ipasfrag *)fp && ip->ip_off + ip->ip_len > q->ip_off) {
301: i = (ip->ip_off + ip->ip_len) - q->ip_off;
302: if (i < q->ip_len) {
303: q->ip_len -= i;
304: q->ip_off += i;
305: m_adj(dtom(q), i);
306: break;
307: }
308: q = q->ipf_next;
309: m_freem(dtom(q->ipf_prev));
310: ip_deq(q->ipf_prev);
311: }
312:
313: insert:
314: /*
315: * Stick new segment in its place;
316: * check for complete reassembly.
317: */
318: ip_enq(ip, q->ipf_prev);
319: next = 0;
320: for (q = fp->ipq_next; q != (struct ipasfrag *)fp; q = q->ipf_next) {
321: if (q->ip_off != next)
322: return (0);
323: next += q->ip_len;
324: }
325: if (q->ipf_prev->ipf_mff)
326: return (0);
327:
328: /*
329: * Reassembly is complete; concatenate fragments.
330: */
331: q = fp->ipq_next;
332: m = dtom(q);
333: t = m->m_next;
334: m->m_next = 0;
335: m_cat(m, t);
336: q = q->ipf_next;
337: while (q != (struct ipasfrag *)fp) {
338: t = dtom(q);
339: q = q->ipf_next;
340: m_cat(m, t);
341: }
342:
343: /*
344: * Create header for new ip packet by
345: * modifying header of first packet;
346: * dequeue and discard fragment reassembly header.
347: * Make header visible.
348: */
349: ip = fp->ipq_next;
350: ip->ip_len = next;
351: ((struct ip *)ip)->ip_src = fp->ipq_src;
352: ((struct ip *)ip)->ip_dst = fp->ipq_dst;
353: remque(fp);
354: (void) m_free(dtom(fp));
355: m = dtom(ip);
356: m->m_len += sizeof (struct ipasfrag);
357: m->m_off -= sizeof (struct ipasfrag);
358: return ((struct ip *)ip);
359:
360: dropfrag:
361: m_freem(m);
362: return (0);
363: }
364:
365: /*
366: * Free a fragment reassembly header and all
367: * associated datagrams.
368: */
369: ip_freef(fp)
370: struct ipq *fp;
371: {
372: register struct ipasfrag *q, *p;
373:
374: for (q = fp->ipq_next; q != (struct ipasfrag *)fp; q = p) {
375: p = q->ipf_next;
376: ip_deq(q);
377: m_freem(dtom(q));
378: }
379: remque(fp);
380: (void) m_free(dtom(fp));
381: }
382:
383: /*
384: * Put an ip fragment on a reassembly chain.
385: * Like insque, but pointers in middle of structure.
386: */
387: ip_enq(p, prev)
388: register struct ipasfrag *p, *prev;
389: {
390:
391: p->ipf_prev = prev;
392: p->ipf_next = prev->ipf_next;
393: prev->ipf_next->ipf_prev = p;
394: prev->ipf_next = p;
395: }
396:
397: /*
398: * To ip_enq as remque is to insque.
399: */
400: ip_deq(p)
401: register struct ipasfrag *p;
402: {
403:
404: p->ipf_prev->ipf_next = p->ipf_next;
405: p->ipf_next->ipf_prev = p->ipf_prev;
406: }
407:
408: /*
409: * IP timer processing;
410: * if a timer expires on a reassembly
411: * queue, discard it.
412: */
413: ip_slowtimo()
414: {
415: register struct ipq *fp;
416: int s = splnet();
417:
418: fp = ipq.next;
419: if (fp == 0) {
420: splx(s);
421: return;
422: }
423: while (fp != &ipq) {
424: --fp->ipq_ttl;
425: fp = fp->next;
426: if (fp->prev->ipq_ttl == 0)
427: ip_freef(fp->prev);
428: }
429: splx(s);
430: }
431:
432: /*
433: * Drain off all datagram fragments.
434: */
435: ip_drain()
436: {
437:
438: while (ipq.next != &ipq)
439: ip_freef(ipq.next);
440: }
441:
442: /*
443: * Do option processing on a datagram,
444: * possibly discarding it if bad options
445: * are encountered.
446: */
447: ip_dooptions(ip)
448: struct ip *ip;
449: {
450: register u_char *cp;
451: int opt, optlen, cnt, code, type;
452: struct in_addr *sin;
453: register struct ip_timestamp *ipt;
454: register struct ifnet *ifp;
455: struct in_addr t;
456:
457: cp = (u_char *)(ip + 1);
458: cnt = (ip->ip_hl << 2) - sizeof (struct ip);
459: for (; cnt > 0; cnt -= optlen, cp += optlen) {
460: opt = cp[0];
461: if (opt == IPOPT_EOL)
462: break;
463: if (opt == IPOPT_NOP)
464: optlen = 1;
465: else
466: optlen = cp[1];
467: switch (opt) {
468:
469: default:
470: break;
471:
472: /*
473: * Source routing with record.
474: * Find interface with current destination address.
475: * If none on this machine then drop if strictly routed,
476: * or do nothing if loosely routed.
477: * Record interface address and bring up next address
478: * component. If strictly routed make sure next
479: * address on directly accessible net.
480: */
481: case IPOPT_LSRR:
482: case IPOPT_SSRR:
483: if (cp[2] < 4 || cp[2] > optlen - (sizeof (long) - 1))
484: break;
485: sin = (struct in_addr *)(cp + cp[2]);
486: ipaddr.sin_addr = *sin;
487: ifp = if_ifwithaddr((struct sockaddr *)&ipaddr);
488: type = ICMP_UNREACH, code = ICMP_UNREACH_SRCFAIL;
489: if (ifp == 0) {
490: if (opt == IPOPT_SSRR)
491: goto bad;
492: break;
493: }
494: t = ip->ip_dst; ip->ip_dst = *sin; *sin = t;
495: cp[2] += 4;
496: if (cp[2] > optlen - (sizeof (long) - 1))
497: break;
498: ip->ip_dst = sin[1];
499: if (opt == IPOPT_SSRR &&
500: if_ifonnetof(in_netof(ip->ip_dst)) == 0)
501: goto bad;
502: break;
503:
504: case IPOPT_TS:
505: code = cp - (u_char *)ip;
506: type = ICMP_PARAMPROB;
507: ipt = (struct ip_timestamp *)cp;
508: if (ipt->ipt_len < 5)
509: goto bad;
510: if (ipt->ipt_ptr > ipt->ipt_len - sizeof (long)) {
511: if (++ipt->ipt_oflw == 0)
512: goto bad;
513: break;
514: }
515: sin = (struct in_addr *)(cp+cp[2]);
516: switch (ipt->ipt_flg) {
517:
518: case IPOPT_TS_TSONLY:
519: break;
520:
521: case IPOPT_TS_TSANDADDR:
522: if (ipt->ipt_ptr + 8 > ipt->ipt_len)
523: goto bad;
524: if (ifinet == 0)
525: goto bad; /* ??? */
526: *sin++ = ((struct sockaddr_in *)&ifinet->if_addr)->sin_addr;
527: break;
528:
529: case IPOPT_TS_PRESPEC:
530: ipaddr.sin_addr = *sin;
531: if (if_ifwithaddr((struct sockaddr *)&ipaddr) == 0)
532: continue;
533: if (ipt->ipt_ptr + 8 > ipt->ipt_len)
534: goto bad;
535: ipt->ipt_ptr += 4;
536: break;
537:
538: default:
539: goto bad;
540: }
541: *(n_time *)sin = iptime();
542: ipt->ipt_ptr += 4;
543: }
544: }
545: return (0);
546: bad:
547: icmp_error(ip, type, code);
548: return (1);
549: }
550:
551: /*
552: * Strip out IP options, at higher
553: * level protocol in the kernel.
554: * Second argument is buffer to which options
555: * will be moved, and return value is their length.
556: */
557: ip_stripoptions(ip, mopt)
558: struct ip *ip;
559: struct mbuf *mopt;
560: {
561: register int i;
562: register struct mbuf *m;
563: int olen;
564:
565: olen = (ip->ip_hl<<2) - sizeof (struct ip);
566: m = dtom(ip);
567: ip++;
568: if (mopt) {
569: mopt->m_len = olen;
570: mopt->m_off = MMINOFF;
571: bcopy((caddr_t)ip, mtod(m, caddr_t), (unsigned)olen);
572: }
573: i = m->m_len - (sizeof (struct ip) + olen);
574: bcopy((caddr_t)ip+olen, (caddr_t)ip, (unsigned)i);
575: m->m_len -= olen;
576: }
577:
578: u_char inetctlerrmap[PRC_NCMDS] = {
579: ECONNABORTED, ECONNABORTED, 0, 0,
580: 0, 0, EHOSTDOWN, EHOSTUNREACH,
581: ENETUNREACH, EHOSTUNREACH, ECONNREFUSED, ECONNREFUSED,
582: EMSGSIZE, 0, 0, 0,
583: 0, 0, 0, 0
584: };
585:
586: ip_ctlinput(cmd, arg)
587: int cmd;
588: caddr_t arg;
589: {
590: struct in_addr *in;
591: int tcp_abort(), udp_abort();
592: extern struct inpcb tcb, udb;
593:
594: if (cmd < 0 || cmd > PRC_NCMDS)
595: return;
596: if (inetctlerrmap[cmd] == 0)
597: return; /* XXX */
598: if (cmd == PRC_IFDOWN)
599: in = &((struct sockaddr_in *)arg)->sin_addr;
600: else if (cmd == PRC_HOSTDEAD || cmd == PRC_HOSTUNREACH)
601: in = (struct in_addr *)arg;
602: else
603: in = &((struct icmp *)arg)->icmp_ip.ip_dst;
604: /* THIS IS VERY QUESTIONABLE, SHOULD HIT ALL PROTOCOLS */
605: in_pcbnotify(&tcb, in, (int)inetctlerrmap[cmd], tcp_abort);
606: in_pcbnotify(&udb, in, (int)inetctlerrmap[cmd], udp_abort);
607: }
608:
609: int ipprintfs = 0;
610: int ipforwarding = 1;
611: /*
612: * Forward a packet. If some error occurs return the sender
613: * and icmp packet. Note we can't always generate a meaningful
614: * icmp message because icmp doesn't have a large enough repetoire
615: * of codes and types.
616: */
617: ip_forward(ip)
618: register struct ip *ip;
619: {
620: register int error, type, code;
621: struct mbuf *mopt, *mcopy;
622:
623: if (ipprintfs)
624: printf("forward: src %x dst %x ttl %x\n", ip->ip_src,
625: ip->ip_dst, ip->ip_ttl);
626: if (ipforwarding == 0) {
627: /* can't tell difference between net and host */
628: type = ICMP_UNREACH, code = ICMP_UNREACH_NET;
629: goto sendicmp;
630: }
631: if (ip->ip_ttl < IPTTLDEC) {
632: type = ICMP_TIMXCEED, code = ICMP_TIMXCEED_INTRANS;
633: goto sendicmp;
634: }
635: ip->ip_ttl -= IPTTLDEC;
636: mopt = m_get(M_DONTWAIT, MT_DATA);
637: if (mopt == NULL) {
638: m_freem(dtom(ip));
639: return;
640: }
641:
642: /*
643: * Save at most 64 bytes of the packet in case
644: * we need to generate an ICMP message to the src.
645: */
646: mcopy = m_copy(dtom(ip), 0, imin(ip->ip_len, 64));
647: ip_stripoptions(ip, mopt);
648:
649: error = ip_output(dtom(ip), mopt, (struct route *)0, IP_FORWARDING);
650: if (error == 0) {
651: if (mcopy)
652: m_freem(mcopy);
653: return;
654: }
655: if (mcopy == NULL)
656: return;
657: ip = mtod(mcopy, struct ip *);
658: type = ICMP_UNREACH, code = 0; /* need ``undefined'' */
659: switch (error) {
660:
661: case ENETUNREACH:
662: case ENETDOWN:
663: code = ICMP_UNREACH_NET;
664: break;
665:
666: case EMSGSIZE:
667: code = ICMP_UNREACH_NEEDFRAG;
668: break;
669:
670: case EPERM:
671: code = ICMP_UNREACH_PORT;
672: break;
673:
674: case ENOBUFS:
675: type = ICMP_SOURCEQUENCH;
676: break;
677:
678: case EHOSTDOWN:
679: case EHOSTUNREACH:
680: code = ICMP_UNREACH_HOST;
681: break;
682: }
683: sendicmp:
684: icmp_error(ip, type, code);
685: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.