linux-user: stack_base is now mandatory on all targets
[qemu.git] / slirp / ip_input.c
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 }