These changes are a raw update to a vanilla kernel 4.1.10, with the
[kvmfornfv.git] / qemu / slirp / slirp.c
1 /*
2  * libslirp glue
3  *
4  * Copyright (c) 2004-2008 Fabrice Bellard
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  */
24 #include "qemu-common.h"
25 #include "qemu/timer.h"
26 #include "sysemu/char.h"
27 #include "slirp.h"
28 #include "hw/hw.h"
29
30 /* host loopback address */
31 struct in_addr loopback_addr;
32 /* host loopback network mask */
33 unsigned long loopback_mask;
34
35 /* emulated hosts use the MAC addr 52:55:IP:IP:IP:IP */
36 static const uint8_t special_ethaddr[ETH_ALEN] = {
37     0x52, 0x55, 0x00, 0x00, 0x00, 0x00
38 };
39
40 u_int curtime;
41
42 static QTAILQ_HEAD(slirp_instances, Slirp) slirp_instances =
43     QTAILQ_HEAD_INITIALIZER(slirp_instances);
44
45 static struct in_addr dns_addr;
46 static u_int dns_addr_time;
47
48 #define TIMEOUT_FAST 2  /* milliseconds */
49 #define TIMEOUT_SLOW 499  /* milliseconds */
50 /* for the aging of certain requests like DNS */
51 #define TIMEOUT_DEFAULT 1000  /* milliseconds */
52
53 #ifdef _WIN32
54
55 int get_dns_addr(struct in_addr *pdns_addr)
56 {
57     FIXED_INFO *FixedInfo=NULL;
58     ULONG    BufLen;
59     DWORD    ret;
60     IP_ADDR_STRING *pIPAddr;
61     struct in_addr tmp_addr;
62
63     if (dns_addr.s_addr != 0 && (curtime - dns_addr_time) < TIMEOUT_DEFAULT) {
64         *pdns_addr = dns_addr;
65         return 0;
66     }
67
68     FixedInfo = (FIXED_INFO *)GlobalAlloc(GPTR, sizeof(FIXED_INFO));
69     BufLen = sizeof(FIXED_INFO);
70
71     if (ERROR_BUFFER_OVERFLOW == GetNetworkParams(FixedInfo, &BufLen)) {
72         if (FixedInfo) {
73             GlobalFree(FixedInfo);
74             FixedInfo = NULL;
75         }
76         FixedInfo = GlobalAlloc(GPTR, BufLen);
77     }
78
79     if ((ret = GetNetworkParams(FixedInfo, &BufLen)) != ERROR_SUCCESS) {
80         printf("GetNetworkParams failed. ret = %08x\n", (u_int)ret );
81         if (FixedInfo) {
82             GlobalFree(FixedInfo);
83             FixedInfo = NULL;
84         }
85         return -1;
86     }
87
88     pIPAddr = &(FixedInfo->DnsServerList);
89     inet_aton(pIPAddr->IpAddress.String, &tmp_addr);
90     *pdns_addr = tmp_addr;
91     dns_addr = tmp_addr;
92     dns_addr_time = curtime;
93     if (FixedInfo) {
94         GlobalFree(FixedInfo);
95         FixedInfo = NULL;
96     }
97     return 0;
98 }
99
100 static void winsock_cleanup(void)
101 {
102     WSACleanup();
103 }
104
105 #else
106
107 static struct stat dns_addr_stat;
108
109 int get_dns_addr(struct in_addr *pdns_addr)
110 {
111     char buff[512];
112     char buff2[257];
113     FILE *f;
114     int found = 0;
115     struct in_addr tmp_addr;
116
117     if (dns_addr.s_addr != 0) {
118         struct stat old_stat;
119         if ((curtime - dns_addr_time) < TIMEOUT_DEFAULT) {
120             *pdns_addr = dns_addr;
121             return 0;
122         }
123         old_stat = dns_addr_stat;
124         if (stat("/etc/resolv.conf", &dns_addr_stat) != 0)
125             return -1;
126         if ((dns_addr_stat.st_dev == old_stat.st_dev)
127             && (dns_addr_stat.st_ino == old_stat.st_ino)
128             && (dns_addr_stat.st_size == old_stat.st_size)
129             && (dns_addr_stat.st_mtime == old_stat.st_mtime)) {
130             *pdns_addr = dns_addr;
131             return 0;
132         }
133     }
134
135     f = fopen("/etc/resolv.conf", "r");
136     if (!f)
137         return -1;
138
139 #ifdef DEBUG
140     fprintf(stderr, "IP address of your DNS(s): ");
141 #endif
142     while (fgets(buff, 512, f) != NULL) {
143         if (sscanf(buff, "nameserver%*[ \t]%256s", buff2) == 1) {
144             if (!inet_aton(buff2, &tmp_addr))
145                 continue;
146             /* If it's the first one, set it to dns_addr */
147             if (!found) {
148                 *pdns_addr = tmp_addr;
149                 dns_addr = tmp_addr;
150                 dns_addr_time = curtime;
151             }
152 #ifdef DEBUG
153             else
154                 fprintf(stderr, ", ");
155 #endif
156             if (++found > 3) {
157 #ifdef DEBUG
158                 fprintf(stderr, "(more)");
159 #endif
160                 break;
161             }
162 #ifdef DEBUG
163             else
164                 fprintf(stderr, "%s", inet_ntoa(tmp_addr));
165 #endif
166         }
167     }
168     fclose(f);
169     if (!found)
170         return -1;
171     return 0;
172 }
173
174 #endif
175
176 static void slirp_init_once(void)
177 {
178     static int initialized;
179 #ifdef _WIN32
180     WSADATA Data;
181 #endif
182
183     if (initialized) {
184         return;
185     }
186     initialized = 1;
187
188 #ifdef _WIN32
189     WSAStartup(MAKEWORD(2,0), &Data);
190     atexit(winsock_cleanup);
191 #endif
192
193     loopback_addr.s_addr = htonl(INADDR_LOOPBACK);
194     loopback_mask = htonl(IN_CLASSA_NET);
195 }
196
197 static void slirp_state_save(QEMUFile *f, void *opaque);
198 static int slirp_state_load(QEMUFile *f, void *opaque, int version_id);
199
200 Slirp *slirp_init(int restricted, struct in_addr vnetwork,
201                   struct in_addr vnetmask, struct in_addr vhost,
202                   const char *vhostname, const char *tftp_path,
203                   const char *bootfile, struct in_addr vdhcp_start,
204                   struct in_addr vnameserver, const char **vdnssearch,
205                   void *opaque)
206 {
207     Slirp *slirp = g_malloc0(sizeof(Slirp));
208
209     slirp_init_once();
210
211     slirp->restricted = restricted;
212
213     if_init(slirp);
214     ip_init(slirp);
215
216     /* Initialise mbufs *after* setting the MTU */
217     m_init(slirp);
218
219     slirp->vnetwork_addr = vnetwork;
220     slirp->vnetwork_mask = vnetmask;
221     slirp->vhost_addr = vhost;
222     if (vhostname) {
223         pstrcpy(slirp->client_hostname, sizeof(slirp->client_hostname),
224                 vhostname);
225     }
226     slirp->tftp_prefix = g_strdup(tftp_path);
227     slirp->bootp_filename = g_strdup(bootfile);
228     slirp->vdhcp_startaddr = vdhcp_start;
229     slirp->vnameserver_addr = vnameserver;
230
231     if (vdnssearch) {
232         translate_dnssearch(slirp, vdnssearch);
233     }
234
235     slirp->opaque = opaque;
236
237     register_savevm(NULL, "slirp", 0, 3,
238                     slirp_state_save, slirp_state_load, slirp);
239
240     QTAILQ_INSERT_TAIL(&slirp_instances, slirp, entry);
241
242     return slirp;
243 }
244
245 void slirp_cleanup(Slirp *slirp)
246 {
247     QTAILQ_REMOVE(&slirp_instances, slirp, entry);
248
249     unregister_savevm(NULL, "slirp", slirp);
250
251     ip_cleanup(slirp);
252     m_cleanup(slirp);
253
254     g_free(slirp->vdnssearch);
255     g_free(slirp->tftp_prefix);
256     g_free(slirp->bootp_filename);
257     g_free(slirp);
258 }
259
260 #define CONN_CANFSEND(so) (((so)->so_state & (SS_FCANTSENDMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
261 #define CONN_CANFRCV(so) (((so)->so_state & (SS_FCANTRCVMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
262
263 static void slirp_update_timeout(uint32_t *timeout)
264 {
265     Slirp *slirp;
266     uint32_t t;
267
268     if (*timeout <= TIMEOUT_FAST) {
269         return;
270     }
271
272     t = MIN(1000, *timeout);
273
274     /* If we have tcp timeout with slirp, then we will fill @timeout with
275      * more precise value.
276      */
277     QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
278         if (slirp->time_fasttimo) {
279             *timeout = TIMEOUT_FAST;
280             return;
281         }
282         if (slirp->do_slowtimo) {
283             t = MIN(TIMEOUT_SLOW, t);
284         }
285     }
286     *timeout = t;
287 }
288
289 void slirp_pollfds_fill(GArray *pollfds, uint32_t *timeout)
290 {
291     Slirp *slirp;
292     struct socket *so, *so_next;
293
294     if (QTAILQ_EMPTY(&slirp_instances)) {
295         return;
296     }
297
298     /*
299      * First, TCP sockets
300      */
301
302     QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
303         /*
304          * *_slowtimo needs calling if there are IP fragments
305          * in the fragment queue, or there are TCP connections active
306          */
307         slirp->do_slowtimo = ((slirp->tcb.so_next != &slirp->tcb) ||
308                 (&slirp->ipq.ip_link != slirp->ipq.ip_link.next));
309
310         for (so = slirp->tcb.so_next; so != &slirp->tcb;
311                 so = so_next) {
312             int events = 0;
313
314             so_next = so->so_next;
315
316             so->pollfds_idx = -1;
317
318             /*
319              * See if we need a tcp_fasttimo
320              */
321             if (slirp->time_fasttimo == 0 &&
322                 so->so_tcpcb->t_flags & TF_DELACK) {
323                 slirp->time_fasttimo = curtime; /* Flag when want a fasttimo */
324             }
325
326             /*
327              * NOFDREF can include still connecting to local-host,
328              * newly socreated() sockets etc. Don't want to select these.
329              */
330             if (so->so_state & SS_NOFDREF || so->s == -1) {
331                 continue;
332             }
333
334             /*
335              * Set for reading sockets which are accepting
336              */
337             if (so->so_state & SS_FACCEPTCONN) {
338                 GPollFD pfd = {
339                     .fd = so->s,
340                     .events = G_IO_IN | G_IO_HUP | G_IO_ERR,
341                 };
342                 so->pollfds_idx = pollfds->len;
343                 g_array_append_val(pollfds, pfd);
344                 continue;
345             }
346
347             /*
348              * Set for writing sockets which are connecting
349              */
350             if (so->so_state & SS_ISFCONNECTING) {
351                 GPollFD pfd = {
352                     .fd = so->s,
353                     .events = G_IO_OUT | G_IO_ERR,
354                 };
355                 so->pollfds_idx = pollfds->len;
356                 g_array_append_val(pollfds, pfd);
357                 continue;
358             }
359
360             /*
361              * Set for writing if we are connected, can send more, and
362              * we have something to send
363              */
364             if (CONN_CANFSEND(so) && so->so_rcv.sb_cc) {
365                 events |= G_IO_OUT | G_IO_ERR;
366             }
367
368             /*
369              * Set for reading (and urgent data) if we are connected, can
370              * receive more, and we have room for it XXX /2 ?
371              */
372             if (CONN_CANFRCV(so) &&
373                 (so->so_snd.sb_cc < (so->so_snd.sb_datalen/2))) {
374                 events |= G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_PRI;
375             }
376
377             if (events) {
378                 GPollFD pfd = {
379                     .fd = so->s,
380                     .events = events,
381                 };
382                 so->pollfds_idx = pollfds->len;
383                 g_array_append_val(pollfds, pfd);
384             }
385         }
386
387         /*
388          * UDP sockets
389          */
390         for (so = slirp->udb.so_next; so != &slirp->udb;
391                 so = so_next) {
392             so_next = so->so_next;
393
394             so->pollfds_idx = -1;
395
396             /*
397              * See if it's timed out
398              */
399             if (so->so_expire) {
400                 if (so->so_expire <= curtime) {
401                     udp_detach(so);
402                     continue;
403                 } else {
404                     slirp->do_slowtimo = true; /* Let socket expire */
405                 }
406             }
407
408             /*
409              * When UDP packets are received from over the
410              * link, they're sendto()'d straight away, so
411              * no need for setting for writing
412              * Limit the number of packets queued by this session
413              * to 4.  Note that even though we try and limit this
414              * to 4 packets, the session could have more queued
415              * if the packets needed to be fragmented
416              * (XXX <= 4 ?)
417              */
418             if ((so->so_state & SS_ISFCONNECTED) && so->so_queued <= 4) {
419                 GPollFD pfd = {
420                     .fd = so->s,
421                     .events = G_IO_IN | G_IO_HUP | G_IO_ERR,
422                 };
423                 so->pollfds_idx = pollfds->len;
424                 g_array_append_val(pollfds, pfd);
425             }
426         }
427
428         /*
429          * ICMP sockets
430          */
431         for (so = slirp->icmp.so_next; so != &slirp->icmp;
432                 so = so_next) {
433             so_next = so->so_next;
434
435             so->pollfds_idx = -1;
436
437             /*
438              * See if it's timed out
439              */
440             if (so->so_expire) {
441                 if (so->so_expire <= curtime) {
442                     icmp_detach(so);
443                     continue;
444                 } else {
445                     slirp->do_slowtimo = true; /* Let socket expire */
446                 }
447             }
448
449             if (so->so_state & SS_ISFCONNECTED) {
450                 GPollFD pfd = {
451                     .fd = so->s,
452                     .events = G_IO_IN | G_IO_HUP | G_IO_ERR,
453                 };
454                 so->pollfds_idx = pollfds->len;
455                 g_array_append_val(pollfds, pfd);
456             }
457         }
458     }
459     slirp_update_timeout(timeout);
460 }
461
462 void slirp_pollfds_poll(GArray *pollfds, int select_error)
463 {
464     Slirp *slirp;
465     struct socket *so, *so_next;
466     int ret;
467
468     if (QTAILQ_EMPTY(&slirp_instances)) {
469         return;
470     }
471
472     curtime = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
473
474     QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
475         /*
476          * See if anything has timed out
477          */
478         if (slirp->time_fasttimo &&
479             ((curtime - slirp->time_fasttimo) >= TIMEOUT_FAST)) {
480             tcp_fasttimo(slirp);
481             slirp->time_fasttimo = 0;
482         }
483         if (slirp->do_slowtimo &&
484             ((curtime - slirp->last_slowtimo) >= TIMEOUT_SLOW)) {
485             ip_slowtimo(slirp);
486             tcp_slowtimo(slirp);
487             slirp->last_slowtimo = curtime;
488         }
489
490         /*
491          * Check sockets
492          */
493         if (!select_error) {
494             /*
495              * Check TCP sockets
496              */
497             for (so = slirp->tcb.so_next; so != &slirp->tcb;
498                     so = so_next) {
499                 int revents;
500
501                 so_next = so->so_next;
502
503                 revents = 0;
504                 if (so->pollfds_idx != -1) {
505                     revents = g_array_index(pollfds, GPollFD,
506                                             so->pollfds_idx).revents;
507                 }
508
509                 if (so->so_state & SS_NOFDREF || so->s == -1) {
510                     continue;
511                 }
512
513                 /*
514                  * Check for URG data
515                  * This will soread as well, so no need to
516                  * test for G_IO_IN below if this succeeds
517                  */
518                 if (revents & G_IO_PRI) {
519                     sorecvoob(so);
520                 }
521                 /*
522                  * Check sockets for reading
523                  */
524                 else if (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR)) {
525                     /*
526                      * Check for incoming connections
527                      */
528                     if (so->so_state & SS_FACCEPTCONN) {
529                         tcp_connect(so);
530                         continue;
531                     } /* else */
532                     ret = soread(so);
533
534                     /* Output it if we read something */
535                     if (ret > 0) {
536                         tcp_output(sototcpcb(so));
537                     }
538                 }
539
540                 /*
541                  * Check sockets for writing
542                  */
543                 if (!(so->so_state & SS_NOFDREF) &&
544                         (revents & (G_IO_OUT | G_IO_ERR))) {
545                     /*
546                      * Check for non-blocking, still-connecting sockets
547                      */
548                     if (so->so_state & SS_ISFCONNECTING) {
549                         /* Connected */
550                         so->so_state &= ~SS_ISFCONNECTING;
551
552                         ret = send(so->s, (const void *) &ret, 0, 0);
553                         if (ret < 0) {
554                             /* XXXXX Must fix, zero bytes is a NOP */
555                             if (errno == EAGAIN || errno == EWOULDBLOCK ||
556                                 errno == EINPROGRESS || errno == ENOTCONN) {
557                                 continue;
558                             }
559
560                             /* else failed */
561                             so->so_state &= SS_PERSISTENT_MASK;
562                             so->so_state |= SS_NOFDREF;
563                         }
564                         /* else so->so_state &= ~SS_ISFCONNECTING; */
565
566                         /*
567                          * Continue tcp_input
568                          */
569                         tcp_input((struct mbuf *)NULL, sizeof(struct ip), so);
570                         /* continue; */
571                     } else {
572                         ret = sowrite(so);
573                     }
574                     /*
575                      * XXXXX If we wrote something (a lot), there
576                      * could be a need for a window update.
577                      * In the worst case, the remote will send
578                      * a window probe to get things going again
579                      */
580                 }
581
582                 /*
583                  * Probe a still-connecting, non-blocking socket
584                  * to check if it's still alive
585                  */
586 #ifdef PROBE_CONN
587                 if (so->so_state & SS_ISFCONNECTING) {
588                     ret = qemu_recv(so->s, &ret, 0, 0);
589
590                     if (ret < 0) {
591                         /* XXX */
592                         if (errno == EAGAIN || errno == EWOULDBLOCK ||
593                             errno == EINPROGRESS || errno == ENOTCONN) {
594                             continue; /* Still connecting, continue */
595                         }
596
597                         /* else failed */
598                         so->so_state &= SS_PERSISTENT_MASK;
599                         so->so_state |= SS_NOFDREF;
600
601                         /* tcp_input will take care of it */
602                     } else {
603                         ret = send(so->s, &ret, 0, 0);
604                         if (ret < 0) {
605                             /* XXX */
606                             if (errno == EAGAIN || errno == EWOULDBLOCK ||
607                                 errno == EINPROGRESS || errno == ENOTCONN) {
608                                 continue;
609                             }
610                             /* else failed */
611                             so->so_state &= SS_PERSISTENT_MASK;
612                             so->so_state |= SS_NOFDREF;
613                         } else {
614                             so->so_state &= ~SS_ISFCONNECTING;
615                         }
616
617                     }
618                     tcp_input((struct mbuf *)NULL, sizeof(struct ip), so);
619                 } /* SS_ISFCONNECTING */
620 #endif
621             }
622
623             /*
624              * Now UDP sockets.
625              * Incoming packets are sent straight away, they're not buffered.
626              * Incoming UDP data isn't buffered either.
627              */
628             for (so = slirp->udb.so_next; so != &slirp->udb;
629                     so = so_next) {
630                 int revents;
631
632                 so_next = so->so_next;
633
634                 revents = 0;
635                 if (so->pollfds_idx != -1) {
636                     revents = g_array_index(pollfds, GPollFD,
637                             so->pollfds_idx).revents;
638                 }
639
640                 if (so->s != -1 &&
641                     (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR))) {
642                     sorecvfrom(so);
643                 }
644             }
645
646             /*
647              * Check incoming ICMP relies.
648              */
649             for (so = slirp->icmp.so_next; so != &slirp->icmp;
650                     so = so_next) {
651                     int revents;
652
653                     so_next = so->so_next;
654
655                     revents = 0;
656                     if (so->pollfds_idx != -1) {
657                         revents = g_array_index(pollfds, GPollFD,
658                                                 so->pollfds_idx).revents;
659                     }
660
661                     if (so->s != -1 &&
662                         (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR))) {
663                     icmp_receive(so);
664                 }
665             }
666         }
667
668         if_start(slirp);
669     }
670 }
671
672 static void arp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
673 {
674     struct arphdr *ah = (struct arphdr *)(pkt + ETH_HLEN);
675     uint8_t arp_reply[max(ETH_HLEN + sizeof(struct arphdr), 64)];
676     struct ethhdr *reh = (struct ethhdr *)arp_reply;
677     struct arphdr *rah = (struct arphdr *)(arp_reply + ETH_HLEN);
678     int ar_op;
679     struct ex_list *ex_ptr;
680
681     ar_op = ntohs(ah->ar_op);
682     switch(ar_op) {
683     case ARPOP_REQUEST:
684         if (ah->ar_tip == ah->ar_sip) {
685             /* Gratuitous ARP */
686             arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
687             return;
688         }
689
690         if ((ah->ar_tip & slirp->vnetwork_mask.s_addr) ==
691             slirp->vnetwork_addr.s_addr) {
692             if (ah->ar_tip == slirp->vnameserver_addr.s_addr ||
693                 ah->ar_tip == slirp->vhost_addr.s_addr)
694                 goto arp_ok;
695             for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
696                 if (ex_ptr->ex_addr.s_addr == ah->ar_tip)
697                     goto arp_ok;
698             }
699             return;
700         arp_ok:
701             memset(arp_reply, 0, sizeof(arp_reply));
702
703             arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
704
705             /* ARP request for alias/dns mac address */
706             memcpy(reh->h_dest, pkt + ETH_ALEN, ETH_ALEN);
707             memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4);
708             memcpy(&reh->h_source[2], &ah->ar_tip, 4);
709             reh->h_proto = htons(ETH_P_ARP);
710
711             rah->ar_hrd = htons(1);
712             rah->ar_pro = htons(ETH_P_IP);
713             rah->ar_hln = ETH_ALEN;
714             rah->ar_pln = 4;
715             rah->ar_op = htons(ARPOP_REPLY);
716             memcpy(rah->ar_sha, reh->h_source, ETH_ALEN);
717             rah->ar_sip = ah->ar_tip;
718             memcpy(rah->ar_tha, ah->ar_sha, ETH_ALEN);
719             rah->ar_tip = ah->ar_sip;
720             slirp_output(slirp->opaque, arp_reply, sizeof(arp_reply));
721         }
722         break;
723     case ARPOP_REPLY:
724         arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
725         break;
726     default:
727         break;
728     }
729 }
730
731 void slirp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
732 {
733     struct mbuf *m;
734     int proto;
735
736     if (pkt_len < ETH_HLEN)
737         return;
738
739     proto = ntohs(*(uint16_t *)(pkt + 12));
740     switch(proto) {
741     case ETH_P_ARP:
742         arp_input(slirp, pkt, pkt_len);
743         break;
744     case ETH_P_IP:
745         m = m_get(slirp);
746         if (!m)
747             return;
748         /* Note: we add to align the IP header */
749         if (M_FREEROOM(m) < pkt_len + 2) {
750             m_inc(m, pkt_len + 2);
751         }
752         m->m_len = pkt_len + 2;
753         memcpy(m->m_data + 2, pkt, pkt_len);
754
755         m->m_data += 2 + ETH_HLEN;
756         m->m_len -= 2 + ETH_HLEN;
757
758         ip_input(m);
759         break;
760     default:
761         break;
762     }
763 }
764
765 /* Output the IP packet to the ethernet device. Returns 0 if the packet must be
766  * re-queued.
767  */
768 int if_encap(Slirp *slirp, struct mbuf *ifm)
769 {
770     uint8_t buf[1600];
771     struct ethhdr *eh = (struct ethhdr *)buf;
772     uint8_t ethaddr[ETH_ALEN];
773     const struct ip *iph = (const struct ip *)ifm->m_data;
774
775     if (ifm->m_len + ETH_HLEN > sizeof(buf)) {
776         return 1;
777     }
778
779     if (iph->ip_dst.s_addr == 0) {
780         /* 0.0.0.0 can not be a destination address, something went wrong,
781          * avoid making it worse */
782         return 1;
783     }
784     if (!arp_table_search(slirp, iph->ip_dst.s_addr, ethaddr)) {
785         uint8_t arp_req[ETH_HLEN + sizeof(struct arphdr)];
786         struct ethhdr *reh = (struct ethhdr *)arp_req;
787         struct arphdr *rah = (struct arphdr *)(arp_req + ETH_HLEN);
788
789         if (!ifm->arp_requested) {
790             /* If the client addr is not known, send an ARP request */
791             memset(reh->h_dest, 0xff, ETH_ALEN);
792             memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4);
793             memcpy(&reh->h_source[2], &slirp->vhost_addr, 4);
794             reh->h_proto = htons(ETH_P_ARP);
795             rah->ar_hrd = htons(1);
796             rah->ar_pro = htons(ETH_P_IP);
797             rah->ar_hln = ETH_ALEN;
798             rah->ar_pln = 4;
799             rah->ar_op = htons(ARPOP_REQUEST);
800
801             /* source hw addr */
802             memcpy(rah->ar_sha, special_ethaddr, ETH_ALEN - 4);
803             memcpy(&rah->ar_sha[2], &slirp->vhost_addr, 4);
804
805             /* source IP */
806             rah->ar_sip = slirp->vhost_addr.s_addr;
807
808             /* target hw addr (none) */
809             memset(rah->ar_tha, 0, ETH_ALEN);
810
811             /* target IP */
812             rah->ar_tip = iph->ip_dst.s_addr;
813             slirp->client_ipaddr = iph->ip_dst;
814             slirp_output(slirp->opaque, arp_req, sizeof(arp_req));
815             ifm->arp_requested = true;
816
817             /* Expire request and drop outgoing packet after 1 second */
818             ifm->expiration_date = qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + 1000000000ULL;
819         }
820         return 0;
821     } else {
822         memcpy(eh->h_dest, ethaddr, ETH_ALEN);
823         memcpy(eh->h_source, special_ethaddr, ETH_ALEN - 4);
824         /* XXX: not correct */
825         memcpy(&eh->h_source[2], &slirp->vhost_addr, 4);
826         eh->h_proto = htons(ETH_P_IP);
827         memcpy(buf + sizeof(struct ethhdr), ifm->m_data, ifm->m_len);
828         slirp_output(slirp->opaque, buf, ifm->m_len + ETH_HLEN);
829         return 1;
830     }
831 }
832
833 /* Drop host forwarding rule, return 0 if found. */
834 int slirp_remove_hostfwd(Slirp *slirp, int is_udp, struct in_addr host_addr,
835                          int host_port)
836 {
837     struct socket *so;
838     struct socket *head = (is_udp ? &slirp->udb : &slirp->tcb);
839     struct sockaddr_in addr;
840     int port = htons(host_port);
841     socklen_t addr_len;
842
843     for (so = head->so_next; so != head; so = so->so_next) {
844         addr_len = sizeof(addr);
845         if ((so->so_state & SS_HOSTFWD) &&
846             getsockname(so->s, (struct sockaddr *)&addr, &addr_len) == 0 &&
847             addr.sin_addr.s_addr == host_addr.s_addr &&
848             addr.sin_port == port) {
849             close(so->s);
850             sofree(so);
851             return 0;
852         }
853     }
854
855     return -1;
856 }
857
858 int slirp_add_hostfwd(Slirp *slirp, int is_udp, struct in_addr host_addr,
859                       int host_port, struct in_addr guest_addr, int guest_port)
860 {
861     if (!guest_addr.s_addr) {
862         guest_addr = slirp->vdhcp_startaddr;
863     }
864     if (is_udp) {
865         if (!udp_listen(slirp, host_addr.s_addr, htons(host_port),
866                         guest_addr.s_addr, htons(guest_port), SS_HOSTFWD))
867             return -1;
868     } else {
869         if (!tcp_listen(slirp, host_addr.s_addr, htons(host_port),
870                         guest_addr.s_addr, htons(guest_port), SS_HOSTFWD))
871             return -1;
872     }
873     return 0;
874 }
875
876 int slirp_add_exec(Slirp *slirp, int do_pty, const void *args,
877                    struct in_addr *guest_addr, int guest_port)
878 {
879     if (!guest_addr->s_addr) {
880         guest_addr->s_addr = slirp->vnetwork_addr.s_addr |
881             (htonl(0x0204) & ~slirp->vnetwork_mask.s_addr);
882     }
883     if ((guest_addr->s_addr & slirp->vnetwork_mask.s_addr) !=
884         slirp->vnetwork_addr.s_addr ||
885         guest_addr->s_addr == slirp->vhost_addr.s_addr ||
886         guest_addr->s_addr == slirp->vnameserver_addr.s_addr) {
887         return -1;
888     }
889     return add_exec(&slirp->exec_list, do_pty, (char *)args, *guest_addr,
890                     htons(guest_port));
891 }
892
893 ssize_t slirp_send(struct socket *so, const void *buf, size_t len, int flags)
894 {
895     if (so->s == -1 && so->extra) {
896         qemu_chr_fe_write(so->extra, buf, len);
897         return len;
898     }
899
900     return send(so->s, buf, len, flags);
901 }
902
903 static struct socket *
904 slirp_find_ctl_socket(Slirp *slirp, struct in_addr guest_addr, int guest_port)
905 {
906     struct socket *so;
907
908     for (so = slirp->tcb.so_next; so != &slirp->tcb; so = so->so_next) {
909         if (so->so_faddr.s_addr == guest_addr.s_addr &&
910             htons(so->so_fport) == guest_port) {
911             return so;
912         }
913     }
914     return NULL;
915 }
916
917 size_t slirp_socket_can_recv(Slirp *slirp, struct in_addr guest_addr,
918                              int guest_port)
919 {
920     struct iovec iov[2];
921     struct socket *so;
922
923     so = slirp_find_ctl_socket(slirp, guest_addr, guest_port);
924
925     if (!so || so->so_state & SS_NOFDREF) {
926         return 0;
927     }
928
929     if (!CONN_CANFRCV(so) || so->so_snd.sb_cc >= (so->so_snd.sb_datalen/2)) {
930         return 0;
931     }
932
933     return sopreprbuf(so, iov, NULL);
934 }
935
936 void slirp_socket_recv(Slirp *slirp, struct in_addr guest_addr, int guest_port,
937                        const uint8_t *buf, int size)
938 {
939     int ret;
940     struct socket *so = slirp_find_ctl_socket(slirp, guest_addr, guest_port);
941
942     if (!so)
943         return;
944
945     ret = soreadbuf(so, (const char *)buf, size);
946
947     if (ret > 0)
948         tcp_output(sototcpcb(so));
949 }
950
951 static void slirp_tcp_save(QEMUFile *f, struct tcpcb *tp)
952 {
953     int i;
954
955     qemu_put_sbe16(f, tp->t_state);
956     for (i = 0; i < TCPT_NTIMERS; i++)
957         qemu_put_sbe16(f, tp->t_timer[i]);
958     qemu_put_sbe16(f, tp->t_rxtshift);
959     qemu_put_sbe16(f, tp->t_rxtcur);
960     qemu_put_sbe16(f, tp->t_dupacks);
961     qemu_put_be16(f, tp->t_maxseg);
962     qemu_put_sbyte(f, tp->t_force);
963     qemu_put_be16(f, tp->t_flags);
964     qemu_put_be32(f, tp->snd_una);
965     qemu_put_be32(f, tp->snd_nxt);
966     qemu_put_be32(f, tp->snd_up);
967     qemu_put_be32(f, tp->snd_wl1);
968     qemu_put_be32(f, tp->snd_wl2);
969     qemu_put_be32(f, tp->iss);
970     qemu_put_be32(f, tp->snd_wnd);
971     qemu_put_be32(f, tp->rcv_wnd);
972     qemu_put_be32(f, tp->rcv_nxt);
973     qemu_put_be32(f, tp->rcv_up);
974     qemu_put_be32(f, tp->irs);
975     qemu_put_be32(f, tp->rcv_adv);
976     qemu_put_be32(f, tp->snd_max);
977     qemu_put_be32(f, tp->snd_cwnd);
978     qemu_put_be32(f, tp->snd_ssthresh);
979     qemu_put_sbe16(f, tp->t_idle);
980     qemu_put_sbe16(f, tp->t_rtt);
981     qemu_put_be32(f, tp->t_rtseq);
982     qemu_put_sbe16(f, tp->t_srtt);
983     qemu_put_sbe16(f, tp->t_rttvar);
984     qemu_put_be16(f, tp->t_rttmin);
985     qemu_put_be32(f, tp->max_sndwnd);
986     qemu_put_byte(f, tp->t_oobflags);
987     qemu_put_byte(f, tp->t_iobc);
988     qemu_put_sbe16(f, tp->t_softerror);
989     qemu_put_byte(f, tp->snd_scale);
990     qemu_put_byte(f, tp->rcv_scale);
991     qemu_put_byte(f, tp->request_r_scale);
992     qemu_put_byte(f, tp->requested_s_scale);
993     qemu_put_be32(f, tp->ts_recent);
994     qemu_put_be32(f, tp->ts_recent_age);
995     qemu_put_be32(f, tp->last_ack_sent);
996 }
997
998 static void slirp_sbuf_save(QEMUFile *f, struct sbuf *sbuf)
999 {
1000     uint32_t off;
1001
1002     qemu_put_be32(f, sbuf->sb_cc);
1003     qemu_put_be32(f, sbuf->sb_datalen);
1004     off = (uint32_t)(sbuf->sb_wptr - sbuf->sb_data);
1005     qemu_put_sbe32(f, off);
1006     off = (uint32_t)(sbuf->sb_rptr - sbuf->sb_data);
1007     qemu_put_sbe32(f, off);
1008     qemu_put_buffer(f, (unsigned char*)sbuf->sb_data, sbuf->sb_datalen);
1009 }
1010
1011 static void slirp_socket_save(QEMUFile *f, struct socket *so)
1012 {
1013     qemu_put_be32(f, so->so_urgc);
1014     qemu_put_be32(f, so->so_faddr.s_addr);
1015     qemu_put_be32(f, so->so_laddr.s_addr);
1016     qemu_put_be16(f, so->so_fport);
1017     qemu_put_be16(f, so->so_lport);
1018     qemu_put_byte(f, so->so_iptos);
1019     qemu_put_byte(f, so->so_emu);
1020     qemu_put_byte(f, so->so_type);
1021     qemu_put_be32(f, so->so_state);
1022     slirp_sbuf_save(f, &so->so_rcv);
1023     slirp_sbuf_save(f, &so->so_snd);
1024     slirp_tcp_save(f, so->so_tcpcb);
1025 }
1026
1027 static void slirp_bootp_save(QEMUFile *f, Slirp *slirp)
1028 {
1029     int i;
1030
1031     for (i = 0; i < NB_BOOTP_CLIENTS; i++) {
1032         qemu_put_be16(f, slirp->bootp_clients[i].allocated);
1033         qemu_put_buffer(f, slirp->bootp_clients[i].macaddr, 6);
1034     }
1035 }
1036
1037 static void slirp_state_save(QEMUFile *f, void *opaque)
1038 {
1039     Slirp *slirp = opaque;
1040     struct ex_list *ex_ptr;
1041
1042     for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next)
1043         if (ex_ptr->ex_pty == 3) {
1044             struct socket *so;
1045             so = slirp_find_ctl_socket(slirp, ex_ptr->ex_addr,
1046                                        ntohs(ex_ptr->ex_fport));
1047             if (!so)
1048                 continue;
1049
1050             qemu_put_byte(f, 42);
1051             slirp_socket_save(f, so);
1052         }
1053     qemu_put_byte(f, 0);
1054
1055     qemu_put_be16(f, slirp->ip_id);
1056
1057     slirp_bootp_save(f, slirp);
1058 }
1059
1060 static void slirp_tcp_load(QEMUFile *f, struct tcpcb *tp)
1061 {
1062     int i;
1063
1064     tp->t_state = qemu_get_sbe16(f);
1065     for (i = 0; i < TCPT_NTIMERS; i++)
1066         tp->t_timer[i] = qemu_get_sbe16(f);
1067     tp->t_rxtshift = qemu_get_sbe16(f);
1068     tp->t_rxtcur = qemu_get_sbe16(f);
1069     tp->t_dupacks = qemu_get_sbe16(f);
1070     tp->t_maxseg = qemu_get_be16(f);
1071     tp->t_force = qemu_get_sbyte(f);
1072     tp->t_flags = qemu_get_be16(f);
1073     tp->snd_una = qemu_get_be32(f);
1074     tp->snd_nxt = qemu_get_be32(f);
1075     tp->snd_up = qemu_get_be32(f);
1076     tp->snd_wl1 = qemu_get_be32(f);
1077     tp->snd_wl2 = qemu_get_be32(f);
1078     tp->iss = qemu_get_be32(f);
1079     tp->snd_wnd = qemu_get_be32(f);
1080     tp->rcv_wnd = qemu_get_be32(f);
1081     tp->rcv_nxt = qemu_get_be32(f);
1082     tp->rcv_up = qemu_get_be32(f);
1083     tp->irs = qemu_get_be32(f);
1084     tp->rcv_adv = qemu_get_be32(f);
1085     tp->snd_max = qemu_get_be32(f);
1086     tp->snd_cwnd = qemu_get_be32(f);
1087     tp->snd_ssthresh = qemu_get_be32(f);
1088     tp->t_idle = qemu_get_sbe16(f);
1089     tp->t_rtt = qemu_get_sbe16(f);
1090     tp->t_rtseq = qemu_get_be32(f);
1091     tp->t_srtt = qemu_get_sbe16(f);
1092     tp->t_rttvar = qemu_get_sbe16(f);
1093     tp->t_rttmin = qemu_get_be16(f);
1094     tp->max_sndwnd = qemu_get_be32(f);
1095     tp->t_oobflags = qemu_get_byte(f);
1096     tp->t_iobc = qemu_get_byte(f);
1097     tp->t_softerror = qemu_get_sbe16(f);
1098     tp->snd_scale = qemu_get_byte(f);
1099     tp->rcv_scale = qemu_get_byte(f);
1100     tp->request_r_scale = qemu_get_byte(f);
1101     tp->requested_s_scale = qemu_get_byte(f);
1102     tp->ts_recent = qemu_get_be32(f);
1103     tp->ts_recent_age = qemu_get_be32(f);
1104     tp->last_ack_sent = qemu_get_be32(f);
1105     tcp_template(tp);
1106 }
1107
1108 static int slirp_sbuf_load(QEMUFile *f, struct sbuf *sbuf)
1109 {
1110     uint32_t off, sb_cc, sb_datalen;
1111
1112     sb_cc = qemu_get_be32(f);
1113     sb_datalen = qemu_get_be32(f);
1114
1115     sbreserve(sbuf, sb_datalen);
1116
1117     if (sbuf->sb_datalen != sb_datalen)
1118         return -ENOMEM;
1119
1120     sbuf->sb_cc = sb_cc;
1121
1122     off = qemu_get_sbe32(f);
1123     sbuf->sb_wptr = sbuf->sb_data + off;
1124     off = qemu_get_sbe32(f);
1125     sbuf->sb_rptr = sbuf->sb_data + off;
1126     qemu_get_buffer(f, (unsigned char*)sbuf->sb_data, sbuf->sb_datalen);
1127
1128     return 0;
1129 }
1130
1131 static int slirp_socket_load(QEMUFile *f, struct socket *so)
1132 {
1133     if (tcp_attach(so) < 0)
1134         return -ENOMEM;
1135
1136     so->so_urgc = qemu_get_be32(f);
1137     so->so_faddr.s_addr = qemu_get_be32(f);
1138     so->so_laddr.s_addr = qemu_get_be32(f);
1139     so->so_fport = qemu_get_be16(f);
1140     so->so_lport = qemu_get_be16(f);
1141     so->so_iptos = qemu_get_byte(f);
1142     so->so_emu = qemu_get_byte(f);
1143     so->so_type = qemu_get_byte(f);
1144     so->so_state = qemu_get_be32(f);
1145     if (slirp_sbuf_load(f, &so->so_rcv) < 0)
1146         return -ENOMEM;
1147     if (slirp_sbuf_load(f, &so->so_snd) < 0)
1148         return -ENOMEM;
1149     slirp_tcp_load(f, so->so_tcpcb);
1150
1151     return 0;
1152 }
1153
1154 static void slirp_bootp_load(QEMUFile *f, Slirp *slirp)
1155 {
1156     int i;
1157
1158     for (i = 0; i < NB_BOOTP_CLIENTS; i++) {
1159         slirp->bootp_clients[i].allocated = qemu_get_be16(f);
1160         qemu_get_buffer(f, slirp->bootp_clients[i].macaddr, 6);
1161     }
1162 }
1163
1164 static int slirp_state_load(QEMUFile *f, void *opaque, int version_id)
1165 {
1166     Slirp *slirp = opaque;
1167     struct ex_list *ex_ptr;
1168
1169     while (qemu_get_byte(f)) {
1170         int ret;
1171         struct socket *so = socreate(slirp);
1172
1173         if (!so)
1174             return -ENOMEM;
1175
1176         ret = slirp_socket_load(f, so);
1177
1178         if (ret < 0)
1179             return ret;
1180
1181         if ((so->so_faddr.s_addr & slirp->vnetwork_mask.s_addr) !=
1182             slirp->vnetwork_addr.s_addr) {
1183             return -EINVAL;
1184         }
1185         for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
1186             if (ex_ptr->ex_pty == 3 &&
1187                 so->so_faddr.s_addr == ex_ptr->ex_addr.s_addr &&
1188                 so->so_fport == ex_ptr->ex_fport) {
1189                 break;
1190             }
1191         }
1192         if (!ex_ptr)
1193             return -EINVAL;
1194
1195         so->extra = (void *)ex_ptr->ex_exec;
1196     }
1197
1198     if (version_id >= 2) {
1199         slirp->ip_id = qemu_get_be16(f);
1200     }
1201
1202     if (version_id >= 3) {
1203         slirp_bootp_load(f, slirp);
1204     }
1205
1206     return 0;
1207 }