Statistics
| Branch: | Revision:

root / slirp / ip_input.c @ cf2846b5

History | View | Annotate | Download (16.4 kB)

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. Neither the name of the University nor the names of its contributors
14
 *    may be used to endorse or promote products derived from this software
15
 *    without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27
 * SUCH DAMAGE.
28
 *
29
 *        @(#)ip_input.c        8.2 (Berkeley) 1/4/94
30
 * ip_input.c,v 1.11 1994/11/16 10:17:08 jkh Exp
31
 */
32

    
33
/*
34
 * Changes and additions relating to SLiRP are
35
 * Copyright (c) 1995 Danny Gasparovski.
36
 *
37
 * Please read the file COPYRIGHT for the
38
 * terms and conditions of the copyright.
39
 */
40

    
41
#include <slirp.h>
42
#include <osdep.h>
43
#include "ip_icmp.h"
44

    
45
static struct ip *ip_reass(Slirp *slirp, struct ip *ip, struct ipq *fp);
46
static void ip_freef(Slirp *slirp, struct ipq *fp);
47
static void ip_enq(register struct ipasfrag *p,
48
                   register struct ipasfrag *prev);
49
static void ip_deq(register struct ipasfrag *p);
50

    
51
/*
52
 * IP initialization: fill in IP protocol switch table.
53
 * All protocols not implemented in kernel go to raw IP protocol handler.
54
 */
55
void
56
ip_init(Slirp *slirp)
57
{
58
    slirp->ipq.ip_link.next = slirp->ipq.ip_link.prev = &slirp->ipq.ip_link;
59
    udp_init(slirp);
60
    tcp_init(slirp);
61
    icmp_init(slirp);
62
}
63

    
64
/*
65
 * Ip input routine.  Checksum and byte swap header.  If fragmented
66
 * try to reassemble.  Process options.  Pass to next level.
67
 */
68
void
69
ip_input(struct mbuf *m)
70
{
71
        Slirp *slirp = m->slirp;
72
        register struct ip *ip;
73
        int hlen;
74

    
75
        DEBUG_CALL("ip_input");
76
        DEBUG_ARG("m = %lx", (long)m);
77
        DEBUG_ARG("m_len = %d", m->m_len);
78

    
79
        if (m->m_len < sizeof (struct ip)) {
80
                return;
81
        }
82

    
83
        ip = mtod(m, struct ip *);
84

    
85
        if (ip->ip_v != IPVERSION) {
86
                goto bad;
87
        }
88

    
89
        hlen = ip->ip_hl << 2;
90
        if (hlen<sizeof(struct ip ) || hlen>m->m_len) {/* min header length */
91
          goto bad;                                  /* or packet too short */
92
        }
93

    
94
        /* keep ip header intact for ICMP reply
95
         * ip->ip_sum = cksum(m, hlen);
96
         * if (ip->ip_sum) {
97
         */
98
        if(cksum(m,hlen)) {
99
          goto bad;
100
        }
101

    
102
        /*
103
         * Convert fields to host representation.
104
         */
105
        NTOHS(ip->ip_len);
106
        if (ip->ip_len < hlen) {
107
                goto bad;
108
        }
109
        NTOHS(ip->ip_id);
110
        NTOHS(ip->ip_off);
111

    
112
        /*
113
         * Check that the amount of data in the buffers
114
         * is as at least much as the IP header would have us expect.
115
         * Trim mbufs if longer than we expect.
116
         * Drop packet if shorter than we expect.
117
         */
118
        if (m->m_len < ip->ip_len) {
119
                goto bad;
120
        }
121

    
122
        /* Should drop packet if mbuf too long? hmmm... */
123
        if (m->m_len > ip->ip_len)
124
           m_adj(m, ip->ip_len - m->m_len);
125

    
126
        /* check ip_ttl for a correct ICMP reply */
127
        if(ip->ip_ttl==0) {
128
          icmp_error(m, ICMP_TIMXCEED,ICMP_TIMXCEED_INTRANS, 0,"ttl");
129
          goto bad;
130
        }
131

    
132
        /*
133
         * If offset or IP_MF are set, must reassemble.
134
         * Otherwise, nothing need be done.
135
         * (We could look in the reassembly queue to see
136
         * if the packet was previously fragmented,
137
         * but it's not worth the time; just let them time out.)
138
         *
139
         * XXX This should fail, don't fragment yet
140
         */
141
        if (ip->ip_off &~ IP_DF) {
142
          register struct ipq *fp;
143
      struct qlink *l;
144
                /*
145
                 * Look for queue of fragments
146
                 * of this datagram.
147
                 */
148
                for (l = slirp->ipq.ip_link.next; l != &slirp->ipq.ip_link;
149
                     l = l->next) {
150
            fp = container_of(l, struct ipq, ip_link);
151
            if (ip->ip_id == fp->ipq_id &&
152
                    ip->ip_src.s_addr == fp->ipq_src.s_addr &&
153
                    ip->ip_dst.s_addr == fp->ipq_dst.s_addr &&
154
                    ip->ip_p == fp->ipq_p)
155
                    goto found;
156
        }
157
        fp = NULL;
158
        found:
159

    
160
                /*
161
                 * Adjust ip_len to not reflect header,
162
                 * set ip_mff if more fragments are expected,
163
                 * convert offset of this to bytes.
164
                 */
165
                ip->ip_len -= hlen;
166
                if (ip->ip_off & IP_MF)
167
                  ip->ip_tos |= 1;
168
                else
169
                  ip->ip_tos &= ~1;
170

    
171
                ip->ip_off <<= 3;
172

    
173
                /*
174
                 * If datagram marked as having more fragments
175
                 * or if this is not the first fragment,
176
                 * attempt reassembly; if it succeeds, proceed.
177
                 */
178
                if (ip->ip_tos & 1 || ip->ip_off) {
179
                        ip = ip_reass(slirp, ip, fp);
180
                        if (ip == NULL)
181
                                return;
182
                        m = dtom(slirp, ip);
183
                } else
184
                        if (fp)
185
                              ip_freef(slirp, fp);
186

    
187
        } else
188
                ip->ip_len -= hlen;
189

    
190
        /*
191
         * Switch out to protocol's input routine.
192
         */
193
        switch (ip->ip_p) {
194
         case IPPROTO_TCP:
195
                tcp_input(m, hlen, (struct socket *)NULL);
196
                break;
197
         case IPPROTO_UDP:
198
                udp_input(m, hlen);
199
                break;
200
         case IPPROTO_ICMP:
201
                icmp_input(m, hlen);
202
                break;
203
         default:
204
                m_free(m);
205
        }
206
        return;
207
bad:
208
        m_free(m);
209
        return;
210
}
211

    
212
#define iptofrag(P) ((struct ipasfrag *)(((char*)(P)) - sizeof(struct qlink)))
213
#define fragtoip(P) ((struct ip*)(((char*)(P)) + sizeof(struct qlink)))
214
/*
215
 * Take incoming datagram fragment and try to
216
 * reassemble it into whole datagram.  If a chain for
217
 * reassembly of this datagram already exists, then it
218
 * is given as fp; otherwise have to make a chain.
219
 */
220
static struct ip *
221
ip_reass(Slirp *slirp, struct ip *ip, struct ipq *fp)
222
{
223
        register struct mbuf *m = dtom(slirp, ip);
224
        register struct ipasfrag *q;
225
        int hlen = ip->ip_hl << 2;
226
        int i, next;
227

    
228
        DEBUG_CALL("ip_reass");
229
        DEBUG_ARG("ip = %lx", (long)ip);
230
        DEBUG_ARG("fp = %lx", (long)fp);
231
        DEBUG_ARG("m = %lx", (long)m);
232

    
233
        /*
234
         * Presence of header sizes in mbufs
235
         * would confuse code below.
236
         * Fragment m_data is concatenated.
237
         */
238
        m->m_data += hlen;
239
        m->m_len -= hlen;
240

    
241
        /*
242
         * If first fragment to arrive, create a reassembly queue.
243
         */
244
        if (fp == NULL) {
245
          struct mbuf *t = m_get(slirp);
246

    
247
          if (t == NULL) {
248
              goto dropfrag;
249
          }
250
          fp = mtod(t, struct ipq *);
251
          insque(&fp->ip_link, &slirp->ipq.ip_link);
252
          fp->ipq_ttl = IPFRAGTTL;
253
          fp->ipq_p = ip->ip_p;
254
          fp->ipq_id = ip->ip_id;
255
          fp->frag_link.next = fp->frag_link.prev = &fp->frag_link;
256
          fp->ipq_src = ip->ip_src;
257
          fp->ipq_dst = ip->ip_dst;
258
          q = (struct ipasfrag *)fp;
259
          goto insert;
260
        }
261

    
262
        /*
263
         * Find a segment which begins after this one does.
264
         */
265
        for (q = fp->frag_link.next; q != (struct ipasfrag *)&fp->frag_link;
266
            q = q->ipf_next)
267
                if (q->ipf_off > ip->ip_off)
268
                        break;
269

    
270
        /*
271
         * If there is a preceding segment, it may provide some of
272
         * our data already.  If so, drop the data from the incoming
273
         * segment.  If it provides all of our data, drop us.
274
         */
275
        if (q->ipf_prev != &fp->frag_link) {
276
        struct ipasfrag *pq = q->ipf_prev;
277
                i = pq->ipf_off + pq->ipf_len - ip->ip_off;
278
                if (i > 0) {
279
                        if (i >= ip->ip_len)
280
                                goto dropfrag;
281
                        m_adj(dtom(slirp, ip), i);
282
                        ip->ip_off += i;
283
                        ip->ip_len -= i;
284
                }
285
        }
286

    
287
        /*
288
         * While we overlap succeeding segments trim them or,
289
         * if they are completely covered, dequeue them.
290
         */
291
        while (q != (struct ipasfrag*)&fp->frag_link &&
292
            ip->ip_off + ip->ip_len > q->ipf_off) {
293
                i = (ip->ip_off + ip->ip_len) - q->ipf_off;
294
                if (i < q->ipf_len) {
295
                        q->ipf_len -= i;
296
                        q->ipf_off += i;
297
                        m_adj(dtom(slirp, q), i);
298
                        break;
299
                }
300
                q = q->ipf_next;
301
                m_free(dtom(slirp, q->ipf_prev));
302
                ip_deq(q->ipf_prev);
303
        }
304

    
305
insert:
306
        /*
307
         * Stick new segment in its place;
308
         * check for complete reassembly.
309
         */
310
        ip_enq(iptofrag(ip), q->ipf_prev);
311
        next = 0;
312
        for (q = fp->frag_link.next; q != (struct ipasfrag*)&fp->frag_link;
313
            q = q->ipf_next) {
314
                if (q->ipf_off != next)
315
                        return NULL;
316
                next += q->ipf_len;
317
        }
318
        if (((struct ipasfrag *)(q->ipf_prev))->ipf_tos & 1)
319
                return NULL;
320

    
321
        /*
322
         * Reassembly is complete; concatenate fragments.
323
         */
324
    q = fp->frag_link.next;
325
        m = dtom(slirp, q);
326

    
327
        q = (struct ipasfrag *) q->ipf_next;
328
        while (q != (struct ipasfrag*)&fp->frag_link) {
329
          struct mbuf *t = dtom(slirp, q);
330
          q = (struct ipasfrag *) q->ipf_next;
331
          m_cat(m, t);
332
        }
333

    
334
        /*
335
         * Create header for new ip packet by
336
         * modifying header of first packet;
337
         * dequeue and discard fragment reassembly header.
338
         * Make header visible.
339
         */
340
        q = fp->frag_link.next;
341

    
342
        /*
343
         * If the fragments concatenated to an mbuf that's
344
         * bigger than the total size of the fragment, then and
345
         * m_ext buffer was alloced. But fp->ipq_next points to
346
         * the old buffer (in the mbuf), so we must point ip
347
         * into the new buffer.
348
         */
349
        if (m->m_flags & M_EXT) {
350
          int delta = (char *)q - m->m_dat;
351
          q = (struct ipasfrag *)(m->m_ext + delta);
352
        }
353

    
354
    ip = fragtoip(q);
355
        ip->ip_len = next;
356
        ip->ip_tos &= ~1;
357
        ip->ip_src = fp->ipq_src;
358
        ip->ip_dst = fp->ipq_dst;
359
        remque(&fp->ip_link);
360
        (void) m_free(dtom(slirp, fp));
361
        m->m_len += (ip->ip_hl << 2);
362
        m->m_data -= (ip->ip_hl << 2);
363

    
364
        return ip;
365

    
366
dropfrag:
367
        m_free(m);
368
        return NULL;
369
}
370

    
371
/*
372
 * Free a fragment reassembly header and all
373
 * associated datagrams.
374
 */
375
static void
376
ip_freef(Slirp *slirp, struct ipq *fp)
377
{
378
        register struct ipasfrag *q, *p;
379

    
380
        for (q = fp->frag_link.next; q != (struct ipasfrag*)&fp->frag_link; q = p) {
381
                p = q->ipf_next;
382
                ip_deq(q);
383
                m_free(dtom(slirp, q));
384
        }
385
        remque(&fp->ip_link);
386
        (void) m_free(dtom(slirp, fp));
387
}
388

    
389
/*
390
 * Put an ip fragment on a reassembly chain.
391
 * Like insque, but pointers in middle of structure.
392
 */
393
static void
394
ip_enq(register struct ipasfrag *p, register struct ipasfrag *prev)
395
{
396
        DEBUG_CALL("ip_enq");
397
        DEBUG_ARG("prev = %lx", (long)prev);
398
        p->ipf_prev =  prev;
399
        p->ipf_next = prev->ipf_next;
400
        ((struct ipasfrag *)(prev->ipf_next))->ipf_prev = p;
401
        prev->ipf_next = p;
402
}
403

    
404
/*
405
 * To ip_enq as remque is to insque.
406
 */
407
static void
408
ip_deq(register struct ipasfrag *p)
409
{
410
        ((struct ipasfrag *)(p->ipf_prev))->ipf_next = p->ipf_next;
411
        ((struct ipasfrag *)(p->ipf_next))->ipf_prev = p->ipf_prev;
412
}
413

    
414
/*
415
 * IP timer processing;
416
 * if a timer expires on a reassembly
417
 * queue, discard it.
418
 */
419
void
420
ip_slowtimo(Slirp *slirp)
421
{
422
    struct qlink *l;
423

    
424
        DEBUG_CALL("ip_slowtimo");
425

    
426
    l = slirp->ipq.ip_link.next;
427

    
428
        if (l == NULL)
429
           return;
430

    
431
    while (l != &slirp->ipq.ip_link) {
432
        struct ipq *fp = container_of(l, struct ipq, ip_link);
433
        l = l->next;
434
                if (--fp->ipq_ttl == 0) {
435
                        ip_freef(slirp, fp);
436
                }
437
    }
438
}
439

    
440
/*
441
 * Do option processing on a datagram,
442
 * possibly discarding it if bad options are encountered,
443
 * or forwarding it if source-routed.
444
 * Returns 1 if packet has been forwarded/freed,
445
 * 0 if the packet should be processed further.
446
 */
447

    
448
#ifdef notdef
449

    
450
int
451
ip_dooptions(m)
452
        struct mbuf *m;
453
{
454
        register struct ip *ip = mtod(m, struct ip *);
455
        register u_char *cp;
456
        register struct ip_timestamp *ipt;
457
        register struct in_ifaddr *ia;
458
        int opt, optlen, cnt, off, code, type, forward = 0;
459
        struct in_addr *sin, dst;
460
typedef uint32_t n_time;
461
        n_time ntime;
462

    
463
        dst = ip->ip_dst;
464
        cp = (u_char *)(ip + 1);
465
        cnt = (ip->ip_hl << 2) - sizeof (struct ip);
466
        for (; cnt > 0; cnt -= optlen, cp += optlen) {
467
                opt = cp[IPOPT_OPTVAL];
468
                if (opt == IPOPT_EOL)
469
                        break;
470
                if (opt == IPOPT_NOP)
471
                        optlen = 1;
472
                else {
473
                        optlen = cp[IPOPT_OLEN];
474
                        if (optlen <= 0 || optlen > cnt) {
475
                                code = &cp[IPOPT_OLEN] - (u_char *)ip;
476
                                goto bad;
477
                        }
478
                }
479
                switch (opt) {
480

    
481
                default:
482
                        break;
483

    
484
                /*
485
                 * Source routing with record.
486
                 * Find interface with current destination address.
487
                 * If none on this machine then drop if strictly routed,
488
                 * or do nothing if loosely routed.
489
                 * Record interface address and bring up next address
490
                 * component.  If strictly routed make sure next
491
                 * address is on directly accessible net.
492
                 */
493
                case IPOPT_LSRR:
494
                case IPOPT_SSRR:
495
                        if ((off = cp[IPOPT_OFFSET]) < IPOPT_MINOFF) {
496
                                code = &cp[IPOPT_OFFSET] - (u_char *)ip;
497
                                goto bad;
498
                        }
499
                        ipaddr.sin_addr = ip->ip_dst;
500
                        ia = (struct in_ifaddr *)
501
                                ifa_ifwithaddr((struct sockaddr *)&ipaddr);
502
                        if (ia == 0) {
503
                                if (opt == IPOPT_SSRR) {
504
                                        type = ICMP_UNREACH;
505
                                        code = ICMP_UNREACH_SRCFAIL;
506
                                        goto bad;
507
                                }
508
                                /*
509
                                 * Loose routing, and not at next destination
510
                                 * yet; nothing to do except forward.
511
                                 */
512
                                break;
513
                        }
514
                        off--; /* 0 origin */
515
                        if (off > optlen - sizeof(struct in_addr)) {
516
                                /*
517
                                 * End of source route.  Should be for us.
518
                                 */
519
                                save_rte(cp, ip->ip_src);
520
                                break;
521
                        }
522
                        /*
523
                         * locate outgoing interface
524
                         */
525
                        bcopy((caddr_t)(cp + off), (caddr_t)&ipaddr.sin_addr,
526
                            sizeof(ipaddr.sin_addr));
527
                        if (opt == IPOPT_SSRR) {
528
#define        INA        struct in_ifaddr *
529
#define        SA        struct sockaddr *
530
                             if ((ia = (INA)ifa_ifwithdstaddr((SA)&ipaddr)) == 0)
531
                                ia = (INA)ifa_ifwithnet((SA)&ipaddr);
532
                        } else
533
                                ia = ip_rtaddr(ipaddr.sin_addr);
534
                        if (ia == 0) {
535
                                type = ICMP_UNREACH;
536
                                code = ICMP_UNREACH_SRCFAIL;
537
                                goto bad;
538
                        }
539
                        ip->ip_dst = ipaddr.sin_addr;
540
                        bcopy((caddr_t)&(IA_SIN(ia)->sin_addr),
541
                            (caddr_t)(cp + off), sizeof(struct in_addr));
542
                        cp[IPOPT_OFFSET] += sizeof(struct in_addr);
543
                        /*
544
                         * Let ip_intr's mcast routing check handle mcast pkts
545
                         */
546
                        forward = !IN_MULTICAST(ntohl(ip->ip_dst.s_addr));
547
                        break;
548

    
549
                case IPOPT_RR:
550
                        if ((off = cp[IPOPT_OFFSET]) < IPOPT_MINOFF) {
551
                                code = &cp[IPOPT_OFFSET] - (u_char *)ip;
552
                                goto bad;
553
                        }
554
                        /*
555
                         * If no space remains, ignore.
556
                         */
557
                        off--; /* 0 origin */
558
                        if (off > optlen - sizeof(struct in_addr))
559
                                break;
560
                        bcopy((caddr_t)(&ip->ip_dst), (caddr_t)&ipaddr.sin_addr,
561
                            sizeof(ipaddr.sin_addr));
562
                        /*
563
                         * locate outgoing interface; if we're the destination,
564
                         * use the incoming interface (should be same).
565
                         */
566
                        if ((ia = (INA)ifa_ifwithaddr((SA)&ipaddr)) == 0 &&
567
                            (ia = ip_rtaddr(ipaddr.sin_addr)) == 0) {
568
                                type = ICMP_UNREACH;
569
                                code = ICMP_UNREACH_HOST;
570
                                goto bad;
571
                        }
572
                        bcopy((caddr_t)&(IA_SIN(ia)->sin_addr),
573
                            (caddr_t)(cp + off), sizeof(struct in_addr));
574
                        cp[IPOPT_OFFSET] += sizeof(struct in_addr);
575
                        break;
576

    
577
                case IPOPT_TS:
578
                        code = cp - (u_char *)ip;
579
                        ipt = (struct ip_timestamp *)cp;
580
                        if (ipt->ipt_len < 5)
581
                                goto bad;
582
                        if (ipt->ipt_ptr > ipt->ipt_len - sizeof (int32_t)) {
583
                                if (++ipt->ipt_oflw == 0)
584
                                        goto bad;
585
                                break;
586
                        }
587
                        sin = (struct in_addr *)(cp + ipt->ipt_ptr - 1);
588
                        switch (ipt->ipt_flg) {
589

    
590
                        case IPOPT_TS_TSONLY:
591
                                break;
592

    
593
                        case IPOPT_TS_TSANDADDR:
594
                                if (ipt->ipt_ptr + sizeof(n_time) +
595
                                    sizeof(struct in_addr) > ipt->ipt_len)
596
                                        goto bad;
597
                                ipaddr.sin_addr = dst;
598
                                ia = (INA)ifaof_ i f p foraddr((SA)&ipaddr,
599
                                                            m->m_pkthdr.rcvif);
600
                                if (ia == 0)
601
                                        continue;
602
                                bcopy((caddr_t)&IA_SIN(ia)->sin_addr,
603
                                    (caddr_t)sin, sizeof(struct in_addr));
604
                                ipt->ipt_ptr += sizeof(struct in_addr);
605
                                break;
606

    
607
                        case IPOPT_TS_PRESPEC:
608
                                if (ipt->ipt_ptr + sizeof(n_time) +
609
                                    sizeof(struct in_addr) > ipt->ipt_len)
610
                                        goto bad;
611
                                bcopy((caddr_t)sin, (caddr_t)&ipaddr.sin_addr,
612
                                    sizeof(struct in_addr));
613
                                if (ifa_ifwithaddr((SA)&ipaddr) == 0)
614
                                        continue;
615
                                ipt->ipt_ptr += sizeof(struct in_addr);
616
                                break;
617

    
618
                        default:
619
                                goto bad;
620
                        }
621
                        ntime = iptime();
622
                        bcopy((caddr_t)&ntime, (caddr_t)cp + ipt->ipt_ptr - 1,
623
                            sizeof(n_time));
624
                        ipt->ipt_ptr += sizeof(n_time);
625
                }
626
        }
627
        if (forward) {
628
                ip_forward(m, 1);
629
                return (1);
630
        }
631
        return (0);
632
bad:
633
         icmp_error(m, type, code, 0, 0);
634

    
635
        return (1);
636
}
637

    
638
#endif /* notdef */
639

    
640
/*
641
 * Strip out IP options, at higher
642
 * level protocol in the kernel.
643
 * Second argument is buffer to which options
644
 * will be moved, and return value is their length.
645
 * (XXX) should be deleted; last arg currently ignored.
646
 */
647
void
648
ip_stripoptions(register struct mbuf *m, struct mbuf *mopt)
649
{
650
        register int i;
651
        struct ip *ip = mtod(m, struct ip *);
652
        register caddr_t opts;
653
        int olen;
654

    
655
        olen = (ip->ip_hl<<2) - sizeof (struct ip);
656
        opts = (caddr_t)(ip + 1);
657
        i = m->m_len - (sizeof (struct ip) + olen);
658
        memcpy(opts, opts  + olen, (unsigned)i);
659
        m->m_len -= olen;
660

    
661
        ip->ip_hl = sizeof(struct ip) >> 2;
662
}