![[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 [Qemu by Fabrice Bellard] / qemu / slirp|
Return to ip_input.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / slirp |
1.1 root 1: /*
2: * Copyright (c) 1982, 1986, 1988, 1993
3: * The Regents of the University of California. 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_input.c 8.2 (Berkeley) 1/4/94
34: * ip_input.c,v 1.11 1994/11/16 10:17:08 jkh Exp
35: */
36:
37: /*
38: * Changes and additions relating to SLiRP are
39: * Copyright (c) 1995 Danny Gasparovski.
40: *
41: * Please read the file COPYRIGHT for the
42: * terms and conditions of the copyright.
43: */
44:
45: #include <slirp.h>
46: #include "ip_icmp.h"
47:
48: int ip_defttl;
49: struct ipstat ipstat;
50: struct ipq ipq;
51:
52: /*
53: * IP initialization: fill in IP protocol switch table.
54: * All protocols not implemented in kernel go to raw IP protocol handler.
55: */
56: void
57: ip_init()
58: {
59: ipq.next = ipq.prev = (ipqp_32)&ipq;
60: ip_id = tt.tv_sec & 0xffff;
61: udp_init();
62: tcp_init();
63: ip_defttl = IPDEFTTL;
64: }
65:
66: /*
67: * Ip input routine. Checksum and byte swap header. If fragmented
68: * try to reassemble. Process options. Pass to next level.
69: */
70: void
71: ip_input(m)
72: struct mbuf *m;
73: {
74: register struct ip *ip;
75: int hlen;
76:
77: DEBUG_CALL("ip_input");
78: DEBUG_ARG("m = %lx", (long)m);
79: DEBUG_ARG("m_len = %d", m->m_len);
80:
81: ipstat.ips_total++;
82:
83: if (m->m_len < sizeof (struct ip)) {
84: ipstat.ips_toosmall++;
85: return;
86: }
87:
88: ip = mtod(m, struct ip *);
89:
90: if (ip->ip_v != IPVERSION) {
91: ipstat.ips_badvers++;
92: goto bad;
93: }
94:
95: hlen = ip->ip_hl << 2;
96: if (hlen<sizeof(struct ip ) || hlen>m->m_len) {/* min header length */
97: ipstat.ips_badhlen++; /* or packet too short */
98: goto bad;
99: }
100:
101: /* keep ip header intact for ICMP reply
102: * ip->ip_sum = cksum(m, hlen);
103: * if (ip->ip_sum) {
104: */
105: if(cksum(m,hlen)) {
106: ipstat.ips_badsum++;
107: goto bad;
108: }
109:
110: /*
111: * Convert fields to host representation.
112: */
113: NTOHS(ip->ip_len);
114: if (ip->ip_len < hlen) {
115: ipstat.ips_badlen++;
116: goto bad;
117: }
118: NTOHS(ip->ip_id);
119: NTOHS(ip->ip_off);
120:
121: /*
122: * Check that the amount of data in the buffers
123: * is as at least much as the IP header would have us expect.
124: * Trim mbufs if longer than we expect.
125: * Drop packet if shorter than we expect.
126: */
127: if (m->m_len < ip->ip_len) {
128: ipstat.ips_tooshort++;
129: goto bad;
130: }
131: /* Should drop packet if mbuf too long? hmmm... */
132: if (m->m_len > ip->ip_len)
133: m_adj(m, ip->ip_len - m->m_len);
134:
135: /* check ip_ttl for a correct ICMP reply */
136: if(ip->ip_ttl==0 || ip->ip_ttl==1) {
137: icmp_error(m, ICMP_TIMXCEED,ICMP_TIMXCEED_INTRANS, 0,"ttl");
138: goto bad;
139: }
140:
141: /*
142: * Process options and, if not destined for us,
143: * ship it on. ip_dooptions returns 1 when an
144: * error was detected (causing an icmp message
145: * to be sent and the original packet to be freed).
146: */
147: /* We do no IP options */
148: /* if (hlen > sizeof (struct ip) && ip_dooptions(m))
149: * goto next;
150: */
151: /*
152: * If offset or IP_MF are set, must reassemble.
153: * Otherwise, nothing need be done.
154: * (We could look in the reassembly queue to see
155: * if the packet was previously fragmented,
156: * but it's not worth the time; just let them time out.)
157: *
158: * XXX This should fail, don't fragment yet
159: */
160: if (ip->ip_off &~ IP_DF) {
161: register struct ipq *fp;
162: /*
163: * Look for queue of fragments
164: * of this datagram.
165: */
166: for (fp = (struct ipq *) ipq.next; fp != &ipq;
167: fp = (struct ipq *) fp->next)
168: if (ip->ip_id == fp->ipq_id &&
169: ip->ip_src.s_addr == fp->ipq_src.s_addr &&
170: ip->ip_dst.s_addr == fp->ipq_dst.s_addr &&
171: ip->ip_p == fp->ipq_p)
172: goto found;
173: fp = 0;
174: found:
175:
176: /*
177: * Adjust ip_len to not reflect header,
178: * set ip_mff if more fragments are expected,
179: * convert offset of this to bytes.
180: */
181: ip->ip_len -= hlen;
182: if (ip->ip_off & IP_MF)
183: ((struct ipasfrag *)ip)->ipf_mff |= 1;
184: else
185: ((struct ipasfrag *)ip)->ipf_mff &= ~1;
186:
187: ip->ip_off <<= 3;
188:
189: /*
190: * If datagram marked as having more fragments
191: * or if this is not the first fragment,
192: * attempt reassembly; if it succeeds, proceed.
193: */
194: if (((struct ipasfrag *)ip)->ipf_mff & 1 || ip->ip_off) {
195: ipstat.ips_fragments++;
196: ip = ip_reass((struct ipasfrag *)ip, fp);
197: if (ip == 0)
198: return;
199: ipstat.ips_reassembled++;
200: m = dtom(ip);
201: } else
202: if (fp)
203: ip_freef(fp);
204:
205: } else
206: ip->ip_len -= hlen;
207:
208: /*
209: * Switch out to protocol's input routine.
210: */
211: ipstat.ips_delivered++;
212: switch (ip->ip_p) {
213: case IPPROTO_TCP:
214: tcp_input(m, hlen, (struct socket *)NULL);
215: break;
216: case IPPROTO_UDP:
217: udp_input(m, hlen);
218: break;
219: case IPPROTO_ICMP:
220: icmp_input(m, hlen);
221: break;
222: default:
223: ipstat.ips_noproto++;
224: m_free(m);
225: }
226: return;
227: bad:
228: m_freem(m);
229: return;
230: }
231:
232: /*
233: * Take incoming datagram fragment and try to
234: * reassemble it into whole datagram. If a chain for
235: * reassembly of this datagram already exists, then it
236: * is given as fp; otherwise have to make a chain.
237: */
238: struct ip *
239: ip_reass(ip, fp)
240: register struct ipasfrag *ip;
241: register struct ipq *fp;
242: {
243: register struct mbuf *m = dtom(ip);
244: register struct ipasfrag *q;
245: int hlen = ip->ip_hl << 2;
246: int i, next;
247:
248: DEBUG_CALL("ip_reass");
249: DEBUG_ARG("ip = %lx", (long)ip);
250: DEBUG_ARG("fp = %lx", (long)fp);
251: DEBUG_ARG("m = %lx", (long)m);
252:
253: /*
254: * Presence of header sizes in mbufs
255: * would confuse code below.
256: * Fragment m_data is concatenated.
257: */
258: m->m_data += hlen;
259: m->m_len -= hlen;
260:
261: /*
262: * If first fragment to arrive, create a reassembly queue.
263: */
264: if (fp == 0) {
265: struct mbuf *t;
266: if ((t = m_get()) == NULL) goto dropfrag;
267: fp = mtod(t, struct ipq *);
268: insque_32(fp, &ipq);
269: fp->ipq_ttl = IPFRAGTTL;
270: fp->ipq_p = ip->ip_p;
271: fp->ipq_id = ip->ip_id;
272: fp->ipq_next = fp->ipq_prev = (ipasfragp_32)fp;
273: fp->ipq_src = ((struct ip *)ip)->ip_src;
274: fp->ipq_dst = ((struct ip *)ip)->ip_dst;
275: q = (struct ipasfrag *)fp;
276: goto insert;
277: }
278:
279: /*
280: * Find a segment which begins after this one does.
281: */
282: for (q = (struct ipasfrag *)fp->ipq_next; q != (struct ipasfrag *)fp;
283: q = (struct ipasfrag *)q->ipf_next)
284: if (q->ip_off > ip->ip_off)
285: break;
286:
287: /*
288: * If there is a preceding segment, it may provide some of
289: * our data already. If so, drop the data from the incoming
290: * segment. If it provides all of our data, drop us.
291: */
292: if (q->ipf_prev != (ipasfragp_32)fp) {
293: i = ((struct ipasfrag *)(q->ipf_prev))->ip_off +
294: ((struct ipasfrag *)(q->ipf_prev))->ip_len - ip->ip_off;
295: if (i > 0) {
296: if (i >= ip->ip_len)
297: goto dropfrag;
298: m_adj(dtom(ip), i);
299: ip->ip_off += i;
300: ip->ip_len -= i;
301: }
302: }
303:
304: /*
305: * While we overlap succeeding segments trim them or,
306: * if they are completely covered, dequeue them.
307: */
308: while (q != (struct ipasfrag *)fp && ip->ip_off + ip->ip_len > q->ip_off) {
309: i = (ip->ip_off + ip->ip_len) - q->ip_off;
310: if (i < q->ip_len) {
311: q->ip_len -= i;
312: q->ip_off += i;
313: m_adj(dtom(q), i);
314: break;
315: }
316: q = (struct ipasfrag *) q->ipf_next;
317: m_freem(dtom((struct ipasfrag *) q->ipf_prev));
318: ip_deq((struct ipasfrag *) q->ipf_prev);
319: }
320:
321: insert:
322: /*
323: * Stick new segment in its place;
324: * check for complete reassembly.
325: */
326: ip_enq(ip, (struct ipasfrag *) q->ipf_prev);
327: next = 0;
328: for (q = (struct ipasfrag *) fp->ipq_next; q != (struct ipasfrag *)fp;
329: q = (struct ipasfrag *) q->ipf_next) {
330: if (q->ip_off != next)
331: return (0);
332: next += q->ip_len;
333: }
334: if (((struct ipasfrag *)(q->ipf_prev))->ipf_mff & 1)
335: return (0);
336:
337: /*
338: * Reassembly is complete; concatenate fragments.
339: */
340: q = (struct ipasfrag *) fp->ipq_next;
341: m = dtom(q);
342:
343: q = (struct ipasfrag *) q->ipf_next;
344: while (q != (struct ipasfrag *)fp) {
345: struct mbuf *t;
346: t = dtom(q);
347: q = (struct ipasfrag *) q->ipf_next;
1.1.1.2 ! root 348: m_cat(m, t);
1.1 root 349: }
350:
351: /*
352: * Create header for new ip packet by
353: * modifying header of first packet;
354: * dequeue and discard fragment reassembly header.
355: * Make header visible.
356: */
357: ip = (struct ipasfrag *) fp->ipq_next;
358:
359: /*
360: * If the fragments concatenated to an mbuf that's
361: * bigger than the total size of the fragment, then and
362: * m_ext buffer was alloced. But fp->ipq_next points to
363: * the old buffer (in the mbuf), so we must point ip
364: * into the new buffer.
365: */
366: if (m->m_flags & M_EXT) {
367: int delta;
368: delta = (char *)ip - m->m_dat;
369: ip = (struct ipasfrag *)(m->m_ext + delta);
370: }
371:
372: /* DEBUG_ARG("ip = %lx", (long)ip);
373: * ip=(struct ipasfrag *)m->m_data; */
374:
375: ip->ip_len = next;
376: ip->ipf_mff &= ~1;
377: ((struct ip *)ip)->ip_src = fp->ipq_src;
378: ((struct ip *)ip)->ip_dst = fp->ipq_dst;
379: remque_32(fp);
380: (void) m_free(dtom(fp));
381: m = dtom(ip);
382: m->m_len += (ip->ip_hl << 2);
383: m->m_data -= (ip->ip_hl << 2);
384:
385: return ((struct ip *)ip);
386:
387: dropfrag:
388: ipstat.ips_fragdropped++;
389: m_freem(m);
390: return (0);
391: }
392:
393: /*
394: * Free a fragment reassembly header and all
395: * associated datagrams.
396: */
397: void
398: ip_freef(fp)
399: struct ipq *fp;
400: {
401: register struct ipasfrag *q, *p;
402:
403: for (q = (struct ipasfrag *) fp->ipq_next; q != (struct ipasfrag *)fp;
404: q = p) {
405: p = (struct ipasfrag *) q->ipf_next;
406: ip_deq(q);
407: m_freem(dtom(q));
408: }
409: remque_32(fp);
410: (void) m_free(dtom(fp));
411: }
412:
413: /*
414: * Put an ip fragment on a reassembly chain.
415: * Like insque, but pointers in middle of structure.
416: */
417: void
418: ip_enq(p, prev)
419: register struct ipasfrag *p, *prev;
420: {
421: DEBUG_CALL("ip_enq");
422: DEBUG_ARG("prev = %lx", (long)prev);
423: p->ipf_prev = (ipasfragp_32) prev;
424: p->ipf_next = prev->ipf_next;
425: ((struct ipasfrag *)(prev->ipf_next))->ipf_prev = (ipasfragp_32) p;
426: prev->ipf_next = (ipasfragp_32) p;
427: }
428:
429: /*
430: * To ip_enq as remque is to insque.
431: */
432: void
433: ip_deq(p)
434: register struct ipasfrag *p;
435: {
436: ((struct ipasfrag *)(p->ipf_prev))->ipf_next = p->ipf_next;
437: ((struct ipasfrag *)(p->ipf_next))->ipf_prev = p->ipf_prev;
438: }
439:
440: /*
441: * IP timer processing;
442: * if a timer expires on a reassembly
443: * queue, discard it.
444: */
445: void
446: ip_slowtimo()
447: {
448: register struct ipq *fp;
449:
450: DEBUG_CALL("ip_slowtimo");
451:
452: fp = (struct ipq *) ipq.next;
453: if (fp == 0)
454: return;
455:
456: while (fp != &ipq) {
457: --fp->ipq_ttl;
458: fp = (struct ipq *) fp->next;
459: if (((struct ipq *)(fp->prev))->ipq_ttl == 0) {
460: ipstat.ips_fragtimeout++;
461: ip_freef((struct ipq *) fp->prev);
462: }
463: }
464: }
465:
466: /*
467: * Do option processing on a datagram,
468: * possibly discarding it if bad options are encountered,
469: * or forwarding it if source-routed.
470: * Returns 1 if packet has been forwarded/freed,
471: * 0 if the packet should be processed further.
472: */
473:
474: #ifdef notdef
475:
476: int
477: ip_dooptions(m)
478: struct mbuf *m;
479: {
480: register struct ip *ip = mtod(m, struct ip *);
481: register u_char *cp;
482: register struct ip_timestamp *ipt;
483: register struct in_ifaddr *ia;
484: /* int opt, optlen, cnt, off, code, type = ICMP_PARAMPROB, forward = 0; */
485: int opt, optlen, cnt, off, code, type, forward = 0;
486: struct in_addr *sin, dst;
487: typedef u_int32_t n_time;
488: n_time ntime;
489:
490: dst = ip->ip_dst;
491: cp = (u_char *)(ip + 1);
492: cnt = (ip->ip_hl << 2) - sizeof (struct ip);
493: for (; cnt > 0; cnt -= optlen, cp += optlen) {
494: opt = cp[IPOPT_OPTVAL];
495: if (opt == IPOPT_EOL)
496: break;
497: if (opt == IPOPT_NOP)
498: optlen = 1;
499: else {
500: optlen = cp[IPOPT_OLEN];
501: if (optlen <= 0 || optlen > cnt) {
502: code = &cp[IPOPT_OLEN] - (u_char *)ip;
503: goto bad;
504: }
505: }
506: switch (opt) {
507:
508: default:
509: break;
510:
511: /*
512: * Source routing with record.
513: * Find interface with current destination address.
514: * If none on this machine then drop if strictly routed,
515: * or do nothing if loosely routed.
516: * Record interface address and bring up next address
517: * component. If strictly routed make sure next
518: * address is on directly accessible net.
519: */
520: case IPOPT_LSRR:
521: case IPOPT_SSRR:
522: if ((off = cp[IPOPT_OFFSET]) < IPOPT_MINOFF) {
523: code = &cp[IPOPT_OFFSET] - (u_char *)ip;
524: goto bad;
525: }
526: ipaddr.sin_addr = ip->ip_dst;
527: ia = (struct in_ifaddr *)
528: ifa_ifwithaddr((struct sockaddr *)&ipaddr);
529: if (ia == 0) {
530: if (opt == IPOPT_SSRR) {
531: type = ICMP_UNREACH;
532: code = ICMP_UNREACH_SRCFAIL;
533: goto bad;
534: }
535: /*
536: * Loose routing, and not at next destination
537: * yet; nothing to do except forward.
538: */
539: break;
540: }
541: off--; / * 0 origin * /
542: if (off > optlen - sizeof(struct in_addr)) {
543: /*
544: * End of source route. Should be for us.
545: */
546: save_rte(cp, ip->ip_src);
547: break;
548: }
549: /*
550: * locate outgoing interface
551: */
552: bcopy((caddr_t)(cp + off), (caddr_t)&ipaddr.sin_addr,
553: sizeof(ipaddr.sin_addr));
554: if (opt == IPOPT_SSRR) {
555: #define INA struct in_ifaddr *
556: #define SA struct sockaddr *
557: if ((ia = (INA)ifa_ifwithdstaddr((SA)&ipaddr)) == 0)
558: ia = (INA)ifa_ifwithnet((SA)&ipaddr);
559: } else
560: ia = ip_rtaddr(ipaddr.sin_addr);
561: if (ia == 0) {
562: type = ICMP_UNREACH;
563: code = ICMP_UNREACH_SRCFAIL;
564: goto bad;
565: }
566: ip->ip_dst = ipaddr.sin_addr;
567: bcopy((caddr_t)&(IA_SIN(ia)->sin_addr),
568: (caddr_t)(cp + off), sizeof(struct in_addr));
569: cp[IPOPT_OFFSET] += sizeof(struct in_addr);
570: /*
571: * Let ip_intr's mcast routing check handle mcast pkts
572: */
573: forward = !IN_MULTICAST(ntohl(ip->ip_dst.s_addr));
574: break;
575:
576: case IPOPT_RR:
577: if ((off = cp[IPOPT_OFFSET]) < IPOPT_MINOFF) {
578: code = &cp[IPOPT_OFFSET] - (u_char *)ip;
579: goto bad;
580: }
581: /*
582: * If no space remains, ignore.
583: */
584: off--; * 0 origin *
585: if (off > optlen - sizeof(struct in_addr))
586: break;
587: bcopy((caddr_t)(&ip->ip_dst), (caddr_t)&ipaddr.sin_addr,
588: sizeof(ipaddr.sin_addr));
589: /*
590: * locate outgoing interface; if we're the destination,
591: * use the incoming interface (should be same).
592: */
593: if ((ia = (INA)ifa_ifwithaddr((SA)&ipaddr)) == 0 &&
594: (ia = ip_rtaddr(ipaddr.sin_addr)) == 0) {
595: type = ICMP_UNREACH;
596: code = ICMP_UNREACH_HOST;
597: goto bad;
598: }
599: bcopy((caddr_t)&(IA_SIN(ia)->sin_addr),
600: (caddr_t)(cp + off), sizeof(struct in_addr));
601: cp[IPOPT_OFFSET] += sizeof(struct in_addr);
602: break;
603:
604: case IPOPT_TS:
605: code = cp - (u_char *)ip;
606: ipt = (struct ip_timestamp *)cp;
607: if (ipt->ipt_len < 5)
608: goto bad;
609: if (ipt->ipt_ptr > ipt->ipt_len - sizeof (int32_t)) {
610: if (++ipt->ipt_oflw == 0)
611: goto bad;
612: break;
613: }
614: sin = (struct in_addr *)(cp + ipt->ipt_ptr - 1);
615: switch (ipt->ipt_flg) {
616:
617: case IPOPT_TS_TSONLY:
618: break;
619:
620: case IPOPT_TS_TSANDADDR:
621: if (ipt->ipt_ptr + sizeof(n_time) +
622: sizeof(struct in_addr) > ipt->ipt_len)
623: goto bad;
624: ipaddr.sin_addr = dst;
625: ia = (INA)ifaof_ i f p foraddr((SA)&ipaddr,
626: m->m_pkthdr.rcvif);
627: if (ia == 0)
628: continue;
629: bcopy((caddr_t)&IA_SIN(ia)->sin_addr,
630: (caddr_t)sin, sizeof(struct in_addr));
631: ipt->ipt_ptr += sizeof(struct in_addr);
632: break;
633:
634: case IPOPT_TS_PRESPEC:
635: if (ipt->ipt_ptr + sizeof(n_time) +
636: sizeof(struct in_addr) > ipt->ipt_len)
637: goto bad;
638: bcopy((caddr_t)sin, (caddr_t)&ipaddr.sin_addr,
639: sizeof(struct in_addr));
640: if (ifa_ifwithaddr((SA)&ipaddr) == 0)
641: continue;
642: ipt->ipt_ptr += sizeof(struct in_addr);
643: break;
644:
645: default:
646: goto bad;
647: }
648: ntime = iptime();
649: bcopy((caddr_t)&ntime, (caddr_t)cp + ipt->ipt_ptr - 1,
650: sizeof(n_time));
651: ipt->ipt_ptr += sizeof(n_time);
652: }
653: }
654: if (forward) {
655: ip_forward(m, 1);
656: return (1);
657: }
658: }
659: }
660: return (0);
661: bad:
662: /* ip->ip_len -= ip->ip_hl << 2; XXX icmp_error adds in hdr length */
663:
664: /* Not yet */
665: icmp_error(m, type, code, 0, 0);
666:
667: ipstat.ips_badoptions++;
668: return (1);
669: }
670:
671: #endif /* notdef */
672:
673: /*
674: * Strip out IP options, at higher
675: * level protocol in the kernel.
676: * Second argument is buffer to which options
677: * will be moved, and return value is their length.
678: * (XXX) should be deleted; last arg currently ignored.
679: */
680: void
681: ip_stripoptions(m, mopt)
682: register struct mbuf *m;
683: struct mbuf *mopt;
684: {
685: register int i;
686: struct ip *ip = mtod(m, struct ip *);
687: register caddr_t opts;
688: int olen;
689:
690: olen = (ip->ip_hl<<2) - sizeof (struct ip);
691: opts = (caddr_t)(ip + 1);
692: i = m->m_len - (sizeof (struct ip) + olen);
693: memcpy(opts, opts + olen, (unsigned)i);
694: m->m_len -= olen;
695:
696: ip->ip_hl = sizeof(struct ip) >> 2;
697: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.