?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tcg: consistently access cpu->tb_jmp_cache atomically
[qemu/ar7.git] / slirp / slirp.c
blob1d6756821c0ded5ec18b4a52f99f89273b08e78d
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/osdep.h"
25 #include "qemu-common.h"
26 #include "qemu/timer.h"
27 #include "qemu/error-report.h"
28 #include "chardev/char-fe.h"
29 #include "migration/register.h"
30 #include "slirp.h"
31 #include "hw/hw.h"
32 #include "qemu/cutils.h"
33
34 #ifndef _WIN32
35 #include <net/if.h>
36 #endif
37
38 /* host loopback address */
39 struct in_addr loopback_addr;
40 /* host loopback network mask */
41 unsigned long loopback_mask;
42
43 /* emulated hosts use the MAC addr 52:55:IP:IP:IP:IP */
44 static const uint8_t special_ethaddr[ETH_ALEN] = {
45 0x52, 0x55, 0x00, 0x00, 0x00, 0x00
46 };
47
48 u_int curtime;
49
50 static QTAILQ_HEAD(slirp_instances, Slirp) slirp_instances =
51 QTAILQ_HEAD_INITIALIZER(slirp_instances);
52
53 static struct in_addr dns_addr;
54 #ifndef _WIN32
55 static struct in6_addr dns6_addr;
56 #endif
57 static u_int dns_addr_time;
58 #ifndef _WIN32
59 static u_int dns6_addr_time;
60 #endif
61
62 #define TIMEOUT_FAST 2 /* milliseconds */
63 #define TIMEOUT_SLOW 499 /* milliseconds */
64 /* for the aging of certain requests like DNS */
65 #define TIMEOUT_DEFAULT 1000 /* milliseconds */
66
67 #ifdef _WIN32
68
69 int get_dns_addr(struct in_addr *pdns_addr)
70 {
71 FIXED_INFO *FixedInfo=NULL;
72 ULONG BufLen;
73 DWORD ret;
74 IP_ADDR_STRING *pIPAddr;
75 struct in_addr tmp_addr;
76
77 if (dns_addr.s_addr != 0 && (curtime - dns_addr_time) < TIMEOUT_DEFAULT) {
78 *pdns_addr = dns_addr;
79 return 0;
80 }
81
82 FixedInfo = (FIXED_INFO *)GlobalAlloc(GPTR, sizeof(FIXED_INFO));
83 BufLen = sizeof(FIXED_INFO);
84
85 if (ERROR_BUFFER_OVERFLOW == GetNetworkParams(FixedInfo, &BufLen)) {
86 if (FixedInfo) {
87 GlobalFree(FixedInfo);
88 FixedInfo = NULL;
89 }
90 FixedInfo = GlobalAlloc(GPTR, BufLen);
91 }
92
93 if ((ret = GetNetworkParams(FixedInfo, &BufLen)) != ERROR_SUCCESS) {
94 printf("GetNetworkParams failed. ret = %08x\n", (u_int)ret );
95 if (FixedInfo) {
96 GlobalFree(FixedInfo);
97 FixedInfo = NULL;
98 }
99 return -1;
100 }
101
102 pIPAddr = &(FixedInfo->DnsServerList);
103 inet_aton(pIPAddr->IpAddress.String, &tmp_addr);
104 *pdns_addr = tmp_addr;
105 dns_addr = tmp_addr;
106 dns_addr_time = curtime;
107 if (FixedInfo) {
108 GlobalFree(FixedInfo);
109 FixedInfo = NULL;
110 }
111 return 0;
112 }
113
114 int get_dns6_addr(struct in6_addr *pdns6_addr, uint32_t *scope_id)
115 {
116 return -1;
117 }
118
119 static void winsock_cleanup(void)
120 {
121 WSACleanup();
122 }
123
124 #else
125
126 static int get_dns_addr_cached(void *pdns_addr, void *cached_addr,
127 socklen_t addrlen,
128 struct stat *cached_stat, u_int *cached_time)
129 {
130 struct stat old_stat;
131 if (curtime - *cached_time < TIMEOUT_DEFAULT) {
132 memcpy(pdns_addr, cached_addr, addrlen);
133 return 0;
134 }
135 old_stat = *cached_stat;
136 if (stat("/etc/resolv.conf", cached_stat) != 0) {
137 return -1;
138 }
139 if (cached_stat->st_dev == old_stat.st_dev
140 && cached_stat->st_ino == old_stat.st_ino
141 && cached_stat->st_size == old_stat.st_size
142 && cached_stat->st_mtime == old_stat.st_mtime) {
143 memcpy(pdns_addr, cached_addr, addrlen);
144 return 0;
145 }
146 return 1;
147 }
148
149 static int get_dns_addr_resolv_conf(int af, void *pdns_addr, void *cached_addr,
150 socklen_t addrlen, uint32_t *scope_id,
151 u_int *cached_time)
152 {
153 char buff[512];
154 char buff2[257];
155 FILE *f;
156 int found = 0;
157 void *tmp_addr = alloca(addrlen);
158 unsigned if_index;
159
160 f = fopen("/etc/resolv.conf", "r");
161 if (!f)
162 return -1;
163
164 #ifdef DEBUG
165 fprintf(stderr, "IP address of your DNS(s): ");
166 #endif
167 while (fgets(buff, 512, f) != NULL) {
168 if (sscanf(buff, "nameserver%*[ \t]%256s", buff2) == 1) {
169 char *c = strchr(buff2, '%');
170 if (c) {
171 if_index = if_nametoindex(c + 1);
172 *c = '\0';
173 } else {
174 if_index = 0;
175 }
176
177 if (!inet_pton(af, buff2, tmp_addr)) {
178 continue;
179 }
180 /* If it's the first one, set it to dns_addr */
181 if (!found) {
182 memcpy(pdns_addr, tmp_addr, addrlen);
183 memcpy(cached_addr, tmp_addr, addrlen);
184 if (scope_id) {
185 *scope_id = if_index;
186 }
187 *cached_time = curtime;
188 }
189 #ifdef DEBUG
190 else
191 fprintf(stderr, ", ");
192 #endif
193 if (++found > 3) {
194 #ifdef DEBUG
195 fprintf(stderr, "(more)");
196 #endif
197 break;
198 }
199 #ifdef DEBUG
200 else {
201 char s[INET6_ADDRSTRLEN];
202 const char *res = inet_ntop(af, tmp_addr, s, sizeof(s));
203 if (!res) {
204 res = "(string conversion error)";
205 }
206 fprintf(stderr, "%s", res);
207 }
208 #endif
209 }
210 }
211 fclose(f);
212 if (!found)
213 return -1;
214 return 0;
215 }
216
217 int get_dns_addr(struct in_addr *pdns_addr)
218 {
219 static struct stat dns_addr_stat;
220
221 if (dns_addr.s_addr != 0) {
222 int ret;
223 ret = get_dns_addr_cached(pdns_addr, &dns_addr, sizeof(dns_addr),
224 &dns_addr_stat, &dns_addr_time);
225 if (ret <= 0) {
226 return ret;
227 }
228 }
229 return get_dns_addr_resolv_conf(AF_INET, pdns_addr, &dns_addr,
230 sizeof(dns_addr), NULL, &dns_addr_time);
231 }
232
233 int get_dns6_addr(struct in6_addr *pdns6_addr, uint32_t *scope_id)
234 {
235 static struct stat dns6_addr_stat;
236
237 if (!in6_zero(&dns6_addr)) {
238 int ret;
239 ret = get_dns_addr_cached(pdns6_addr, &dns6_addr, sizeof(dns6_addr),
240 &dns6_addr_stat, &dns6_addr_time);
241 if (ret <= 0) {
242 return ret;
243 }
244 }
245 return get_dns_addr_resolv_conf(AF_INET6, pdns6_addr, &dns6_addr,
246 sizeof(dns6_addr),
247 scope_id, &dns6_addr_time);
248 }
249
250 #endif
251
252 static void slirp_init_once(void)
253 {
254 static int initialized;
255 #ifdef _WIN32
256 WSADATA Data;
257 #endif
258
259 if (initialized) {
260 return;
261 }
262 initialized = 1;
263
264 #ifdef _WIN32
265 WSAStartup(MAKEWORD(2,0), &Data);
266 atexit(winsock_cleanup);
267 #endif
268
269 loopback_addr.s_addr = htonl(INADDR_LOOPBACK);
270 loopback_mask = htonl(IN_CLASSA_NET);
271 }
272
273 static void slirp_state_save(QEMUFile *f, void *opaque);
274 static int slirp_state_load(QEMUFile *f, void *opaque, int version_id);
275
276 static SaveVMHandlers savevm_slirp_state = {
277 .save_state = slirp_state_save,
278 .load_state = slirp_state_load,
279 };
280
281 Slirp *slirp_init(int restricted, bool in_enabled, struct in_addr vnetwork,
282 struct in_addr vnetmask, struct in_addr vhost,
283 bool in6_enabled,
284 struct in6_addr vprefix_addr6, uint8_t vprefix_len,
285 struct in6_addr vhost6, const char *vhostname,
286 const char *tftp_path, const char *bootfile,
287 struct in_addr vdhcp_start, struct in_addr vnameserver,
288 struct in6_addr vnameserver6, const char **vdnssearch,
289 void *opaque)
290 {
291 Slirp *slirp = g_malloc0(sizeof(Slirp));
292
293 slirp_init_once();
294
295 slirp->grand = g_rand_new();
296 slirp->restricted = restricted;
297
298 slirp->in_enabled = in_enabled;
299 slirp->in6_enabled = in6_enabled;
300
301 if_init(slirp);
302 ip_init(slirp);
303 ip6_init(slirp);
304
305 /* Initialise mbufs *after* setting the MTU */
306 m_init(slirp);
307
308 slirp->vnetwork_addr = vnetwork;
309 slirp->vnetwork_mask = vnetmask;
310 slirp->vhost_addr = vhost;
311 slirp->vprefix_addr6 = vprefix_addr6;
312 slirp->vprefix_len = vprefix_len;
313 slirp->vhost_addr6 = vhost6;
314 if (vhostname) {
315 pstrcpy(slirp->client_hostname, sizeof(slirp->client_hostname),
316 vhostname);
317 }
318 slirp->tftp_prefix = g_strdup(tftp_path);
319 slirp->bootp_filename = g_strdup(bootfile);
320 slirp->vdhcp_startaddr = vdhcp_start;
321 slirp->vnameserver_addr = vnameserver;
322 slirp->vnameserver_addr6 = vnameserver6;
323
324 if (vdnssearch) {
325 translate_dnssearch(slirp, vdnssearch);
326 }
327
328 slirp->opaque = opaque;
329
330 register_savevm_live(NULL, "slirp", 0, 4, &savevm_slirp_state, slirp);
331
332 QTAILQ_INSERT_TAIL(&slirp_instances, slirp, entry);
333
334 return slirp;
335 }
336
337 void slirp_cleanup(Slirp *slirp)
338 {
339 QTAILQ_REMOVE(&slirp_instances, slirp, entry);
340
341 unregister_savevm(NULL, "slirp", slirp);
342
343 ip_cleanup(slirp);
344 ip6_cleanup(slirp);
345 m_cleanup(slirp);
346
347 g_rand_free(slirp->grand);
348
349 g_free(slirp->vdnssearch);
350 g_free(slirp->tftp_prefix);
351 g_free(slirp->bootp_filename);
352 g_free(slirp);
353 }
354
355 #define CONN_CANFSEND(so) (((so)->so_state & (SS_FCANTSENDMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
356 #define CONN_CANFRCV(so) (((so)->so_state & (SS_FCANTRCVMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
357
358 static void slirp_update_timeout(uint32_t *timeout)
359 {
360 Slirp *slirp;
361 uint32_t t;
362
363 if (*timeout <= TIMEOUT_FAST) {
364 return;
365 }
366
367 t = MIN(1000, *timeout);
368
369 /* If we have tcp timeout with slirp, then we will fill @timeout with
370 * more precise value.
371 */
372 QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
373 if (slirp->time_fasttimo) {
374 *timeout = TIMEOUT_FAST;
375 return;
376 }
377 if (slirp->do_slowtimo) {
378 t = MIN(TIMEOUT_SLOW, t);
379 }
380 }
381 *timeout = t;
382 }
383
384 void slirp_pollfds_fill(GArray *pollfds, uint32_t *timeout)
385 {
386 Slirp *slirp;
387 struct socket *so, *so_next;
388
389 if (QTAILQ_EMPTY(&slirp_instances)) {
390 return;
391 }
392
393 /*
394 * First, TCP sockets
395 */
396
397 QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
398 /*
399 * *_slowtimo needs calling if there are IP fragments
400 * in the fragment queue, or there are TCP connections active
401 */
402 slirp->do_slowtimo = ((slirp->tcb.so_next != &slirp->tcb) ||
403 (&slirp->ipq.ip_link != slirp->ipq.ip_link.next));
404
405 for (so = slirp->tcb.so_next; so != &slirp->tcb;
406 so = so_next) {
407 int events = 0;
408
409 so_next = so->so_next;
410
411 so->pollfds_idx = -1;
412
413 /*
414 * See if we need a tcp_fasttimo
415 */
416 if (slirp->time_fasttimo == 0 &&
417 so->so_tcpcb->t_flags & TF_DELACK) {
418 slirp->time_fasttimo = curtime; /* Flag when want a fasttimo */
419 }
420
421 /*
422 * NOFDREF can include still connecting to local-host,
423 * newly socreated() sockets etc. Don't want to select these.
424 */
425 if (so->so_state & SS_NOFDREF || so->s == -1) {
426 continue;
427 }
428
429 /*
430 * Set for reading sockets which are accepting
431 */
432 if (so->so_state & SS_FACCEPTCONN) {
433 GPollFD pfd = {
434 .fd = so->s,
435 .events = G_IO_IN | G_IO_HUP | G_IO_ERR,
436 };
437 so->pollfds_idx = pollfds->len;
438 g_array_append_val(pollfds, pfd);
439 continue;
440 }
441
442 /*
443 * Set for writing sockets which are connecting
444 */
445 if (so->so_state & SS_ISFCONNECTING) {
446 GPollFD pfd = {
447 .fd = so->s,
448 .events = G_IO_OUT | G_IO_ERR,
449 };
450 so->pollfds_idx = pollfds->len;
451 g_array_append_val(pollfds, pfd);
452 continue;
453 }
454
455 /*
456 * Set for writing if we are connected, can send more, and
457 * we have something to send
458 */
459 if (CONN_CANFSEND(so) && so->so_rcv.sb_cc) {
460 events |= G_IO_OUT | G_IO_ERR;
461 }
462
463 /*
464 * Set for reading (and urgent data) if we are connected, can
465 * receive more, and we have room for it XXX /2 ?
466 */
467 if (CONN_CANFRCV(so) &&
468 (so->so_snd.sb_cc < (so->so_snd.sb_datalen/2))) {
469 events |= G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_PRI;
470 }
471
472 if (events) {
473 GPollFD pfd = {
474 .fd = so->s,
475 .events = events,
476 };
477 so->pollfds_idx = pollfds->len;
478 g_array_append_val(pollfds, pfd);
479 }
480 }
481
482 /*
483 * UDP sockets
484 */
485 for (so = slirp->udb.so_next; so != &slirp->udb;
486 so = so_next) {
487 so_next = so->so_next;
488
489 so->pollfds_idx = -1;
490
491 /*
492 * See if it's timed out
493 */
494 if (so->so_expire) {
495 if (so->so_expire <= curtime) {
496 udp_detach(so);
497 continue;
498 } else {
499 slirp->do_slowtimo = true; /* Let socket expire */
500 }
501 }
502
503 /*
504 * When UDP packets are received from over the
505 * link, they're sendto()'d straight away, so
506 * no need for setting for writing
507 * Limit the number of packets queued by this session
508 * to 4. Note that even though we try and limit this
509 * to 4 packets, the session could have more queued
510 * if the packets needed to be fragmented
511 * (XXX <= 4 ?)
512 */
513 if ((so->so_state & SS_ISFCONNECTED) && so->so_queued <= 4) {
514 GPollFD pfd = {
515 .fd = so->s,
516 .events = G_IO_IN | G_IO_HUP | G_IO_ERR,
517 };
518 so->pollfds_idx = pollfds->len;
519 g_array_append_val(pollfds, pfd);
520 }
521 }
522
523 /*
524 * ICMP sockets
525 */
526 for (so = slirp->icmp.so_next; so != &slirp->icmp;
527 so = so_next) {
528 so_next = so->so_next;
529
530 so->pollfds_idx = -1;
531
532 /*
533 * See if it's timed out
534 */
535 if (so->so_expire) {
536 if (so->so_expire <= curtime) {
537 icmp_detach(so);
538 continue;
539 } else {
540 slirp->do_slowtimo = true; /* Let socket expire */
541 }
542 }
543
544 if (so->so_state & SS_ISFCONNECTED) {
545 GPollFD pfd = {
546 .fd = so->s,
547 .events = G_IO_IN | G_IO_HUP | G_IO_ERR,
548 };
549 so->pollfds_idx = pollfds->len;
550 g_array_append_val(pollfds, pfd);
551 }
552 }
553 }
554 slirp_update_timeout(timeout);
555 }
556
557 void slirp_pollfds_poll(GArray *pollfds, int select_error)
558 {
559 Slirp *slirp;
560 struct socket *so, *so_next;
561 int ret;
562
563 if (QTAILQ_EMPTY(&slirp_instances)) {
564 return;
565 }
566
567 curtime = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
568
569 QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
570 /*
571 * See if anything has timed out
572 */
573 if (slirp->time_fasttimo &&
574 ((curtime - slirp->time_fasttimo) >= TIMEOUT_FAST)) {
575 tcp_fasttimo(slirp);
576 slirp->time_fasttimo = 0;
577 }
578 if (slirp->do_slowtimo &&
579 ((curtime - slirp->last_slowtimo) >= TIMEOUT_SLOW)) {
580 ip_slowtimo(slirp);
581 tcp_slowtimo(slirp);
582 slirp->last_slowtimo = curtime;
583 }
584
585 /*
586 * Check sockets
587 */
588 if (!select_error) {
589 /*
590 * Check TCP sockets
591 */
592 for (so = slirp->tcb.so_next; so != &slirp->tcb;
593 so = so_next) {
594 int revents;
595
596 so_next = so->so_next;
597
598 revents = 0;
599 if (so->pollfds_idx != -1) {
600 revents = g_array_index(pollfds, GPollFD,
601 so->pollfds_idx).revents;
602 }
603
604 if (so->so_state & SS_NOFDREF || so->s == -1) {
605 continue;
606 }
607
608 /*
609 * Check for URG data
610 * This will soread as well, so no need to
611 * test for G_IO_IN below if this succeeds
612 */
613 if (revents & G_IO_PRI) {
614 ret = sorecvoob(so);
615 if (ret < 0) {
616 /* Socket error might have resulted in the socket being
617 * removed, do not try to do anything more with it. */
618 continue;
619 }
620 }
621 /*
622 * Check sockets for reading
623 */
624 else if (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR)) {
625 /*
626 * Check for incoming connections
627 */
628 if (so->so_state & SS_FACCEPTCONN) {
629 tcp_connect(so);
630 continue;
631 } /* else */
632 ret = soread(so);
633
634 /* Output it if we read something */
635 if (ret > 0) {
636 tcp_output(sototcpcb(so));
637 }
638 if (ret < 0) {
639 /* Socket error might have resulted in the socket being
640 * removed, do not try to do anything more with it. */
641 continue;
642 }
643 }
644
645 /*
646 * Check sockets for writing
647 */
648 if (!(so->so_state & SS_NOFDREF) &&
649 (revents & (G_IO_OUT | G_IO_ERR))) {
650 /*
651 * Check for non-blocking, still-connecting sockets
652 */
653 if (so->so_state & SS_ISFCONNECTING) {
654 /* Connected */
655 so->so_state &= ~SS_ISFCONNECTING;
656
657 ret = send(so->s, (const void *) &ret, 0, 0);
658 if (ret < 0) {
659 /* XXXXX Must fix, zero bytes is a NOP */
660 if (errno == EAGAIN || errno == EWOULDBLOCK ||
661 errno == EINPROGRESS || errno == ENOTCONN) {
662 continue;
663 }
664
665 /* else failed */
666 so->so_state &= SS_PERSISTENT_MASK;
667 so->so_state |= SS_NOFDREF;
668 }
669 /* else so->so_state &= ~SS_ISFCONNECTING; */
670
671 /*
672 * Continue tcp_input
673 */
674 tcp_input((struct mbuf *)NULL, sizeof(struct ip), so,
675 so->so_ffamily);
676 /* continue; */
677 } else {
678 ret = sowrite(so);
679 }
680 /*
681 * XXXXX If we wrote something (a lot), there
682 * could be a need for a window update.
683 * In the worst case, the remote will send
684 * a window probe to get things going again
685 */
686 }
687
688 /*
689 * Probe a still-connecting, non-blocking socket
690 * to check if it's still alive
691 */
692 #ifdef PROBE_CONN
693 if (so->so_state & SS_ISFCONNECTING) {
694 ret = qemu_recv(so->s, &ret, 0, 0);
695
696 if (ret < 0) {
697 /* XXX */
698 if (errno == EAGAIN || errno == EWOULDBLOCK ||
699 errno == EINPROGRESS || errno == ENOTCONN) {
700 continue; /* Still connecting, continue */
701 }
702
703 /* else failed */
704 so->so_state &= SS_PERSISTENT_MASK;
705 so->so_state |= SS_NOFDREF;
706
707 /* tcp_input will take care of it */
708 } else {
709 ret = send(so->s, &ret, 0, 0);
710 if (ret < 0) {
711 /* XXX */
712 if (errno == EAGAIN || errno == EWOULDBLOCK ||
713 errno == EINPROGRESS || errno == ENOTCONN) {
714 continue;
715 }
716 /* else failed */
717 so->so_state &= SS_PERSISTENT_MASK;
718 so->so_state |= SS_NOFDREF;
719 } else {
720 so->so_state &= ~SS_ISFCONNECTING;
721 }
722
723 }
724 tcp_input((struct mbuf *)NULL, sizeof(struct ip), so,
725 so->so_ffamily);
726 } /* SS_ISFCONNECTING */
727 #endif
728 }
729
730 /*
731 * Now UDP sockets.
732 * Incoming packets are sent straight away, they're not buffered.
733 * Incoming UDP data isn't buffered either.
734 */
735 for (so = slirp->udb.so_next; so != &slirp->udb;
736 so = so_next) {
737 int revents;
738
739 so_next = so->so_next;
740
741 revents = 0;
742 if (so->pollfds_idx != -1) {
743 revents = g_array_index(pollfds, GPollFD,
744 so->pollfds_idx).revents;
745 }
746
747 if (so->s != -1 &&
748 (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR))) {
749 sorecvfrom(so);
750 }
751 }
752
753 /*
754 * Check incoming ICMP relies.
755 */
756 for (so = slirp->icmp.so_next; so != &slirp->icmp;
757 so = so_next) {
758 int revents;
759
760 so_next = so->so_next;
761
762 revents = 0;
763 if (so->pollfds_idx != -1) {
764 revents = g_array_index(pollfds, GPollFD,
765 so->pollfds_idx).revents;
766 }
767
768 if (so->s != -1 &&
769 (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR))) {
770 icmp_receive(so);
771 }
772 }
773 }
774
775 if_start(slirp);
776 }
777 }
778
779 static void arp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
780 {
781 struct slirp_arphdr *ah = (struct slirp_arphdr *)(pkt + ETH_HLEN);
782 uint8_t arp_reply[MAX(ETH_HLEN + sizeof(struct slirp_arphdr), 64)];
783 struct ethhdr *reh = (struct ethhdr *)arp_reply;
784 struct slirp_arphdr *rah = (struct slirp_arphdr *)(arp_reply + ETH_HLEN);
785 int ar_op;
786 struct ex_list *ex_ptr;
787
788 if (!slirp->in_enabled) {
789 return;
790 }
791
792 ar_op = ntohs(ah->ar_op);
793 switch(ar_op) {
794 case ARPOP_REQUEST:
795 if (ah->ar_tip == ah->ar_sip) {
796 /* Gratuitous ARP */
797 arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
798 return;
799 }
800
801 if ((ah->ar_tip & slirp->vnetwork_mask.s_addr) ==
802 slirp->vnetwork_addr.s_addr) {
803 if (ah->ar_tip == slirp->vnameserver_addr.s_addr ||
804 ah->ar_tip == slirp->vhost_addr.s_addr)
805 goto arp_ok;
806 for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
807 if (ex_ptr->ex_addr.s_addr == ah->ar_tip)
808 goto arp_ok;
809 }
810 return;
811 arp_ok:
812 memset(arp_reply, 0, sizeof(arp_reply));
813
814 arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
815
816 /* ARP request for alias/dns mac address */
817 memcpy(reh->h_dest, pkt + ETH_ALEN, ETH_ALEN);
818 memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4);
819 memcpy(&reh->h_source[2], &ah->ar_tip, 4);
820 reh->h_proto = htons(ETH_P_ARP);
821
822 rah->ar_hrd = htons(1);
823 rah->ar_pro = htons(ETH_P_IP);
824 rah->ar_hln = ETH_ALEN;
825 rah->ar_pln = 4;
826 rah->ar_op = htons(ARPOP_REPLY);
827 memcpy(rah->ar_sha, reh->h_source, ETH_ALEN);
828 rah->ar_sip = ah->ar_tip;
829 memcpy(rah->ar_tha, ah->ar_sha, ETH_ALEN);
830 rah->ar_tip = ah->ar_sip;
831 slirp_output(slirp->opaque, arp_reply, sizeof(arp_reply));
832 }
833 break;
834 case ARPOP_REPLY:
835 arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
836 break;
837 default:
838 break;
839 }
840 }
841
842 void slirp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
843 {
844 struct mbuf *m;
845 int proto;
846
847 if (pkt_len < ETH_HLEN)
848 return;
849
850 proto = ntohs(*(uint16_t *)(pkt + 12));
851 switch(proto) {
852 case ETH_P_ARP:
853 arp_input(slirp, pkt, pkt_len);
854 break;
855 case ETH_P_IP:
856 case ETH_P_IPV6:
857 m = m_get(slirp);
858 if (!m)
859 return;
860 /* Note: we add 2 to align the IP header on 4 bytes,
861 * and add the margin for the tcpiphdr overhead */
862 if (M_FREEROOM(m) < pkt_len + TCPIPHDR_DELTA + 2) {
863 m_inc(m, pkt_len + TCPIPHDR_DELTA + 2);
864 }
865 m->m_len = pkt_len + TCPIPHDR_DELTA + 2;
866 memcpy(m->m_data + TCPIPHDR_DELTA + 2, pkt, pkt_len);
867
868 m->m_data += TCPIPHDR_DELTA + 2 + ETH_HLEN;
869 m->m_len -= TCPIPHDR_DELTA + 2 + ETH_HLEN;
870
871 if (proto == ETH_P_IP) {
872 ip_input(m);
873 } else if (proto == ETH_P_IPV6) {
874 ip6_input(m);
875 }
876 break;
877
878 case ETH_P_NCSI:
879 ncsi_input(slirp, pkt, pkt_len);
880 break;
881
882 default:
883 break;
884 }
885 }
886
887 /* Prepare the IPv4 packet to be sent to the ethernet device. Returns 1 if no
888 * packet should be sent, 0 if the packet must be re-queued, 2 if the packet
889 * is ready to go.
890 */
891 static int if_encap4(Slirp *slirp, struct mbuf *ifm, struct ethhdr *eh,
892 uint8_t ethaddr[ETH_ALEN])
893 {
894 const struct ip *iph = (const struct ip *)ifm->m_data;
895
896 if (iph->ip_dst.s_addr == 0) {
897 /* 0.0.0.0 can not be a destination address, something went wrong,
898 * avoid making it worse */
899 return 1;
900 }
901 if (!arp_table_search(slirp, iph->ip_dst.s_addr, ethaddr)) {
902 uint8_t arp_req[ETH_HLEN + sizeof(struct slirp_arphdr)];
903 struct ethhdr *reh = (struct ethhdr *)arp_req;
904 struct slirp_arphdr *rah = (struct slirp_arphdr *)(arp_req + ETH_HLEN);
905
906 if (!ifm->resolution_requested) {
907 /* If the client addr is not known, send an ARP request */
908 memset(reh->h_dest, 0xff, ETH_ALEN);
909 memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4);
910 memcpy(&reh->h_source[2], &slirp->vhost_addr, 4);
911 reh->h_proto = htons(ETH_P_ARP);
912 rah->ar_hrd = htons(1);
913 rah->ar_pro = htons(ETH_P_IP);
914 rah->ar_hln = ETH_ALEN;
915 rah->ar_pln = 4;
916 rah->ar_op = htons(ARPOP_REQUEST);
917
918 /* source hw addr */
919 memcpy(rah->ar_sha, special_ethaddr, ETH_ALEN - 4);
920 memcpy(&rah->ar_sha[2], &slirp->vhost_addr, 4);
921
922 /* source IP */
923 rah->ar_sip = slirp->vhost_addr.s_addr;
924
925 /* target hw addr (none) */
926 memset(rah->ar_tha, 0, ETH_ALEN);
927
928 /* target IP */
929 rah->ar_tip = iph->ip_dst.s_addr;
930 slirp->client_ipaddr = iph->ip_dst;
931 slirp_output(slirp->opaque, arp_req, sizeof(arp_req));
932 ifm->resolution_requested = true;
933
934 /* Expire request and drop outgoing packet after 1 second */
935 ifm->expiration_date = qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + 1000000000ULL;
936 }
937 return 0;
938 } else {
939 memcpy(eh->h_source, special_ethaddr, ETH_ALEN - 4);
940 /* XXX: not correct */
941 memcpy(&eh->h_source[2], &slirp->vhost_addr, 4);
942 eh->h_proto = htons(ETH_P_IP);
943
944 /* Send this */
945 return 2;
946 }
947 }
948
949 /* Prepare the IPv6 packet to be sent to the ethernet device. Returns 1 if no
950 * packet should be sent, 0 if the packet must be re-queued, 2 if the packet
951 * is ready to go.
952 */
953 static int if_encap6(Slirp *slirp, struct mbuf *ifm, struct ethhdr *eh,
954 uint8_t ethaddr[ETH_ALEN])
955 {
956 const struct ip6 *ip6h = mtod(ifm, const struct ip6 *);
957 if (!ndp_table_search(slirp, ip6h->ip_dst, ethaddr)) {
958 if (!ifm->resolution_requested) {
959 ndp_send_ns(slirp, ip6h->ip_dst);
960 ifm->resolution_requested = true;
961 ifm->expiration_date =
962 qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + 1000000000ULL;
963 }
964 return 0;
965 } else {
966 eh->h_proto = htons(ETH_P_IPV6);
967 in6_compute_ethaddr(ip6h->ip_src, eh->h_source);
968
969 /* Send this */
970 return 2;
971 }
972 }
973
974 /* Output the IP packet to the ethernet device. Returns 0 if the packet must be
975 * re-queued.
976 */
977 int if_encap(Slirp *slirp, struct mbuf *ifm)
978 {
979 uint8_t buf[1600];
980 struct ethhdr *eh = (struct ethhdr *)buf;
981 uint8_t ethaddr[ETH_ALEN];
982 const struct ip *iph = (const struct ip *)ifm->m_data;
983 int ret;
984
985 if (ifm->m_len + ETH_HLEN > sizeof(buf)) {
986 return 1;
987 }
988
989 switch (iph->ip_v) {
990 case IPVERSION:
991 ret = if_encap4(slirp, ifm, eh, ethaddr);
992 if (ret < 2) {
993 return ret;
994 }
995 break;
996
997 case IP6VERSION:
998 ret = if_encap6(slirp, ifm, eh, ethaddr);
999 if (ret < 2) {
1000 return ret;
1001 }
1002 break;
1003
1004 default:
1005 g_assert_not_reached();
1006 break;
1007 }
1008
1009 memcpy(eh->h_dest, ethaddr, ETH_ALEN);
1010 DEBUG_ARGS((dfd, " src = %02x:%02x:%02x:%02x:%02x:%02x\n",
1011 eh->h_source[0], eh->h_source[1], eh->h_source[2],
1012 eh->h_source[3], eh->h_source[4], eh->h_source[5]));
1013 DEBUG_ARGS((dfd, " dst = %02x:%02x:%02x:%02x:%02x:%02x\n",
1014 eh->h_dest[0], eh->h_dest[1], eh->h_dest[2],
1015 eh->h_dest[3], eh->h_dest[4], eh->h_dest[5]));
1016 memcpy(buf + sizeof(struct ethhdr), ifm->m_data, ifm->m_len);
1017 slirp_output(slirp->opaque, buf, ifm->m_len + ETH_HLEN);
1018 return 1;
1019 }
1020
1021 /* Drop host forwarding rule, return 0 if found. */
1022 int slirp_remove_hostfwd(Slirp *slirp, int is_udp, struct in_addr host_addr,
1023 int host_port)
1024 {
1025 struct socket *so;
1026 struct socket *head = (is_udp ? &slirp->udb : &slirp->tcb);
1027 struct sockaddr_in addr;
1028 int port = htons(host_port);
1029 socklen_t addr_len;
1030
1031 for (so = head->so_next; so != head; so = so->so_next) {
1032 addr_len = sizeof(addr);
1033 if ((so->so_state & SS_HOSTFWD) &&
1034 getsockname(so->s, (struct sockaddr *)&addr, &addr_len) == 0 &&
1035 addr.sin_addr.s_addr == host_addr.s_addr &&
1036 addr.sin_port == port) {
1037 close(so->s);
1038 sofree(so);
1039 return 0;
1040 }
1041 }
1042
1043 return -1;
1044 }
1045
1046 int slirp_add_hostfwd(Slirp *slirp, int is_udp, struct in_addr host_addr,
1047 int host_port, struct in_addr guest_addr, int guest_port)
1048 {
1049 if (!guest_addr.s_addr) {
1050 guest_addr = slirp->vdhcp_startaddr;
1051 }
1052 if (is_udp) {
1053 if (!udp_listen(slirp, host_addr.s_addr, htons(host_port),
1054 guest_addr.s_addr, htons(guest_port), SS_HOSTFWD))
1055 return -1;
1056 } else {
1057 if (!tcp_listen(slirp, host_addr.s_addr, htons(host_port),
1058 guest_addr.s_addr, htons(guest_port), SS_HOSTFWD))
1059 return -1;
1060 }
1061 return 0;
1062 }
1063
1064 int slirp_add_exec(Slirp *slirp, int do_pty, const void *args,
1065 struct in_addr *guest_addr, int guest_port)
1066 {
1067 if (!guest_addr->s_addr) {
1068 guest_addr->s_addr = slirp->vnetwork_addr.s_addr |
1069 (htonl(0x0204) & ~slirp->vnetwork_mask.s_addr);
1070 }
1071 if ((guest_addr->s_addr & slirp->vnetwork_mask.s_addr) !=
1072 slirp->vnetwork_addr.s_addr ||
1073 guest_addr->s_addr == slirp->vhost_addr.s_addr ||
1074 guest_addr->s_addr == slirp->vnameserver_addr.s_addr) {
1075 return -1;
1076 }
1077 return add_exec(&slirp->exec_list, do_pty, (char *)args, *guest_addr,
1078 htons(guest_port));
1079 }
1080
1081 ssize_t slirp_send(struct socket *so, const void *buf, size_t len, int flags)
1082 {
1083 if (so->s == -1 && so->extra) {
1084 /* XXX this blocks entire thread. Rewrite to use
1085 * qemu_chr_fe_write and background I/O callbacks */
1086 qemu_chr_fe_write_all(so->extra, buf, len);
1087 return len;
1088 }
1089
1090 return send(so->s, buf, len, flags);
1091 }
1092
1093 static struct socket *
1094 slirp_find_ctl_socket(Slirp *slirp, struct in_addr guest_addr, int guest_port)
1095 {
1096 struct socket *so;
1097
1098 for (so = slirp->tcb.so_next; so != &slirp->tcb; so = so->so_next) {
1099 if (so->so_faddr.s_addr == guest_addr.s_addr &&
1100 htons(so->so_fport) == guest_port) {
1101 return so;
1102 }
1103 }
1104 return NULL;
1105 }
1106
1107 size_t slirp_socket_can_recv(Slirp *slirp, struct in_addr guest_addr,
1108 int guest_port)
1109 {
1110 struct iovec iov[2];
1111 struct socket *so;
1112
1113 so = slirp_find_ctl_socket(slirp, guest_addr, guest_port);
1114
1115 if (!so || so->so_state & SS_NOFDREF) {
1116 return 0;
1117 }
1118
1119 if (!CONN_CANFRCV(so) || so->so_snd.sb_cc >= (so->so_snd.sb_datalen/2)) {
1120 return 0;
1121 }
1122
1123 return sopreprbuf(so, iov, NULL);
1124 }
1125
1126 void slirp_socket_recv(Slirp *slirp, struct in_addr guest_addr, int guest_port,
1127 const uint8_t *buf, int size)
1128 {
1129 int ret;
1130 struct socket *so = slirp_find_ctl_socket(slirp, guest_addr, guest_port);
1131
1132 if (!so)
1133 return;
1134
1135 ret = soreadbuf(so, (const char *)buf, size);
1136
1137 if (ret > 0)
1138 tcp_output(sototcpcb(so));
1139 }
1140
1141 static int slirp_tcp_post_load(void *opaque, int version)
1142 {
1143 tcp_template((struct tcpcb *)opaque);
1144
1145 return 0;
1146 }
1147
1148 static const VMStateDescription vmstate_slirp_tcp = {
1149 .name = "slirp-tcp",
1150 .version_id = 0,
1151 .post_load = slirp_tcp_post_load,
1152 .fields = (VMStateField[]) {
1153 VMSTATE_INT16(t_state, struct tcpcb),
1154 VMSTATE_INT16_ARRAY(t_timer, struct tcpcb, TCPT_NTIMERS),
1155 VMSTATE_INT16(t_rxtshift, struct tcpcb),
1156 VMSTATE_INT16(t_rxtcur, struct tcpcb),
1157 VMSTATE_INT16(t_dupacks, struct tcpcb),
1158 VMSTATE_UINT16(t_maxseg, struct tcpcb),
1159 VMSTATE_UINT8(t_force, struct tcpcb),
1160 VMSTATE_UINT16(t_flags, struct tcpcb),
1161 VMSTATE_UINT32(snd_una, struct tcpcb),
1162 VMSTATE_UINT32(snd_nxt, struct tcpcb),
1163 VMSTATE_UINT32(snd_up, struct tcpcb),
1164 VMSTATE_UINT32(snd_wl1, struct tcpcb),
1165 VMSTATE_UINT32(snd_wl2, struct tcpcb),
1166 VMSTATE_UINT32(iss, struct tcpcb),
1167 VMSTATE_UINT32(snd_wnd, struct tcpcb),
1168 VMSTATE_UINT32(rcv_wnd, struct tcpcb),
1169 VMSTATE_UINT32(rcv_nxt, struct tcpcb),
1170 VMSTATE_UINT32(rcv_up, struct tcpcb),
1171 VMSTATE_UINT32(irs, struct tcpcb),
1172 VMSTATE_UINT32(rcv_adv, struct tcpcb),
1173 VMSTATE_UINT32(snd_max, struct tcpcb),
1174 VMSTATE_UINT32(snd_cwnd, struct tcpcb),
1175 VMSTATE_UINT32(snd_ssthresh, struct tcpcb),
1176 VMSTATE_INT16(t_idle, struct tcpcb),
1177 VMSTATE_INT16(t_rtt, struct tcpcb),
1178 VMSTATE_UINT32(t_rtseq, struct tcpcb),
1179 VMSTATE_INT16(t_srtt, struct tcpcb),
1180 VMSTATE_INT16(t_rttvar, struct tcpcb),
1181 VMSTATE_UINT16(t_rttmin, struct tcpcb),
1182 VMSTATE_UINT32(max_sndwnd, struct tcpcb),
1183 VMSTATE_UINT8(t_oobflags, struct tcpcb),
1184 VMSTATE_UINT8(t_iobc, struct tcpcb),
1185 VMSTATE_INT16(t_softerror, struct tcpcb),
1186 VMSTATE_UINT8(snd_scale, struct tcpcb),
1187 VMSTATE_UINT8(rcv_scale, struct tcpcb),
1188 VMSTATE_UINT8(request_r_scale, struct tcpcb),
1189 VMSTATE_UINT8(requested_s_scale, struct tcpcb),
1190 VMSTATE_UINT32(ts_recent, struct tcpcb),
1191 VMSTATE_UINT32(ts_recent_age, struct tcpcb),
1192 VMSTATE_UINT32(last_ack_sent, struct tcpcb),
1193 VMSTATE_END_OF_LIST()
1194 }
1195 };
1196
1197 /* The sbuf has a pair of pointers that are migrated as offsets;
1198 * we calculate the offsets and restore the pointers using
1199 * pre_save/post_load on a tmp structure.
1200 */
1201 struct sbuf_tmp {
1202 struct sbuf *parent;
1203 uint32_t roff, woff;
1204 };
1205
1206 static void sbuf_tmp_pre_save(void *opaque)
1207 {
1208 struct sbuf_tmp *tmp = opaque;
1209 tmp->woff = tmp->parent->sb_wptr - tmp->parent->sb_data;
1210 tmp->roff = tmp->parent->sb_rptr - tmp->parent->sb_data;
1211 }
1212
1213 static int sbuf_tmp_post_load(void *opaque, int version)
1214 {
1215 struct sbuf_tmp *tmp = opaque;
1216 uint32_t requested_len = tmp->parent->sb_datalen;
1217
1218 /* Allocate the buffer space used by the field after the tmp */
1219 sbreserve(tmp->parent, tmp->parent->sb_datalen);
1220
1221 if (tmp->parent->sb_datalen != requested_len) {
1222 return -ENOMEM;
1223 }
1224 if (tmp->woff >= requested_len ||
1225 tmp->roff >= requested_len) {
1226 error_report("invalid sbuf offsets r/w=%u/%u len=%u",
1227 tmp->roff, tmp->woff, requested_len);
1228 return -EINVAL;
1229 }
1230
1231 tmp->parent->sb_wptr = tmp->parent->sb_data + tmp->woff;
1232 tmp->parent->sb_rptr = tmp->parent->sb_data + tmp->roff;
1233
1234 return 0;
1235 }
1236
1237
1238 static const VMStateDescription vmstate_slirp_sbuf_tmp = {
1239 .name = "slirp-sbuf-tmp",
1240 .post_load = sbuf_tmp_post_load,
1241 .pre_save = sbuf_tmp_pre_save,
1242 .version_id = 0,
1243 .fields = (VMStateField[]) {
1244 VMSTATE_UINT32(woff, struct sbuf_tmp),
1245 VMSTATE_UINT32(roff, struct sbuf_tmp),
1246 VMSTATE_END_OF_LIST()
1247 }
1248 };
1249
1250 static const VMStateDescription vmstate_slirp_sbuf = {
1251 .name = "slirp-sbuf",
1252 .version_id = 0,
1253 .fields = (VMStateField[]) {
1254 VMSTATE_UINT32(sb_cc, struct sbuf),
1255 VMSTATE_UINT32(sb_datalen, struct sbuf),
1256 VMSTATE_WITH_TMP(struct sbuf, struct sbuf_tmp, vmstate_slirp_sbuf_tmp),
1257 VMSTATE_VBUFFER_UINT32(sb_data, struct sbuf, 0, NULL, sb_datalen),
1258 VMSTATE_END_OF_LIST()
1259 }
1260 };
1261
1262 static bool slirp_older_than_v4(void *opaque, int version_id)
1263 {
1264 return version_id < 4;
1265 }
1266
1267 static bool slirp_family_inet(void *opaque, int version_id)
1268 {
1269 union slirp_sockaddr *ssa = (union slirp_sockaddr *)opaque;
1270 return ssa->ss.ss_family == AF_INET;
1271 }
1272
1273 static int slirp_socket_pre_load(void *opaque)
1274 {
1275 struct socket *so = opaque;
1276 if (tcp_attach(so) < 0) {
1277 return -ENOMEM;
1278 }
1279 /* Older versions don't load these fields */
1280 so->so_ffamily = AF_INET;
1281 so->so_lfamily = AF_INET;
1282 return 0;
1283 }
1284
1285 #ifndef _WIN32
1286 #define VMSTATE_SIN4_ADDR(f, s, t) VMSTATE_UINT32_TEST(f, s, t)
1287 #else
1288 /* Win uses u_long rather than uint32_t - but it's still 32bits long */
1289 #define VMSTATE_SIN4_ADDR(f, s, t) VMSTATE_SINGLE_TEST(f, s, t, 0, \
1290 vmstate_info_uint32, u_long)
1291 #endif
1292
1293 /* The OS provided ss_family field isn't that portable; it's size
1294 * and type varies (16/8 bit, signed, unsigned)
1295 * and the values it contains aren't fully portable.
1296 */
1297 typedef struct SS_FamilyTmpStruct {
1298 union slirp_sockaddr *parent;
1299 uint16_t portable_family;
1300 } SS_FamilyTmpStruct;
1301
1302 #define SS_FAMILY_MIG_IPV4 2 /* Linux, BSD, Win... */
1303 #define SS_FAMILY_MIG_IPV6 10 /* Linux */
1304 #define SS_FAMILY_MIG_OTHER 0xffff
1305
1306 static void ss_family_pre_save(void *opaque)
1307 {
1308 SS_FamilyTmpStruct *tss = opaque;
1309
1310 tss->portable_family = SS_FAMILY_MIG_OTHER;
1311
1312 if (tss->parent->ss.ss_family == AF_INET) {
1313 tss->portable_family = SS_FAMILY_MIG_IPV4;
1314 } else if (tss->parent->ss.ss_family == AF_INET6) {
1315 tss->portable_family = SS_FAMILY_MIG_IPV6;
1316 }
1317 }
1318
1319 static int ss_family_post_load(void *opaque, int version_id)
1320 {
1321 SS_FamilyTmpStruct *tss = opaque;
1322
1323 switch (tss->portable_family) {
1324 case SS_FAMILY_MIG_IPV4:
1325 tss->parent->ss.ss_family = AF_INET;
1326 break;
1327 case SS_FAMILY_MIG_IPV6:
1328 case 23: /* compatibility: AF_INET6 from mingw */
1329 case 28: /* compatibility: AF_INET6 from FreeBSD sys/socket.h */
1330 tss->parent->ss.ss_family = AF_INET6;
1331 break;
1332 default:
1333 error_report("invalid ss_family type %x", tss->portable_family);
1334 return -EINVAL;
1335 }
1336
1337 return 0;
1338 }
1339
1340 static const VMStateDescription vmstate_slirp_ss_family = {
1341 .name = "slirp-socket-addr/ss_family",
1342 .pre_save = ss_family_pre_save,
1343 .post_load = ss_family_post_load,
1344 .fields = (VMStateField[]) {
1345 VMSTATE_UINT16(portable_family, SS_FamilyTmpStruct),
1346 VMSTATE_END_OF_LIST()
1347 }
1348 };
1349
1350 static const VMStateDescription vmstate_slirp_socket_addr = {
1351 .name = "slirp-socket-addr",
1352 .version_id = 4,
1353 .fields = (VMStateField[]) {
1354 VMSTATE_WITH_TMP(union slirp_sockaddr, SS_FamilyTmpStruct,
1355 vmstate_slirp_ss_family),
1356 VMSTATE_SIN4_ADDR(sin.sin_addr.s_addr, union slirp_sockaddr,
1357 slirp_family_inet),
1358 VMSTATE_UINT16_TEST(sin.sin_port, union slirp_sockaddr,
1359 slirp_family_inet),
1360
1361 #if 0
1362 /* Untested: Needs checking by someone with IPv6 test */
1363 VMSTATE_BUFFER_TEST(sin6.sin6_addr, union slirp_sockaddr,
1364 slirp_family_inet6),
1365 VMSTATE_UINT16_TEST(sin6.sin6_port, union slirp_sockaddr,
1366 slirp_family_inet6),
1367 VMSTATE_UINT32_TEST(sin6.sin6_flowinfo, union slirp_sockaddr,
1368 slirp_family_inet6),
1369 VMSTATE_UINT32_TEST(sin6.sin6_scope_id, union slirp_sockaddr,
1370 slirp_family_inet6),
1371 #endif
1372
1373 VMSTATE_END_OF_LIST()
1374 }
1375 };
1376
1377 static const VMStateDescription vmstate_slirp_socket = {
1378 .name = "slirp-socket",
1379 .version_id = 4,
1380 .pre_load = slirp_socket_pre_load,
1381 .fields = (VMStateField[]) {
1382 VMSTATE_UINT32(so_urgc, struct socket),
1383 /* Pre-v4 versions */
1384 VMSTATE_SIN4_ADDR(so_faddr.s_addr, struct socket,
1385 slirp_older_than_v4),
1386 VMSTATE_SIN4_ADDR(so_laddr.s_addr, struct socket,
1387 slirp_older_than_v4),
1388 VMSTATE_UINT16_TEST(so_fport, struct socket, slirp_older_than_v4),
1389 VMSTATE_UINT16_TEST(so_lport, struct socket, slirp_older_than_v4),
1390 /* v4 and newer */
1391 VMSTATE_STRUCT(fhost, struct socket, 4, vmstate_slirp_socket_addr,
1392 union slirp_sockaddr),
1393 VMSTATE_STRUCT(lhost, struct socket, 4, vmstate_slirp_socket_addr,
1394 union slirp_sockaddr),
1395
1396 VMSTATE_UINT8(so_iptos, struct socket),
1397 VMSTATE_UINT8(so_emu, struct socket),
1398 VMSTATE_UINT8(so_type, struct socket),
1399 VMSTATE_INT32(so_state, struct socket),
1400 VMSTATE_STRUCT(so_rcv, struct socket, 0, vmstate_slirp_sbuf,
1401 struct sbuf),
1402 VMSTATE_STRUCT(so_snd, struct socket, 0, vmstate_slirp_sbuf,
1403 struct sbuf),
1404 VMSTATE_STRUCT_POINTER(so_tcpcb, struct socket, vmstate_slirp_tcp,
1405 struct tcpcb),
1406 VMSTATE_END_OF_LIST()
1407 }
1408 };
1409
1410 static const VMStateDescription vmstate_slirp_bootp_client = {
1411 .name = "slirp_bootpclient",
1412 .fields = (VMStateField[]) {
1413 VMSTATE_UINT16(allocated, BOOTPClient),
1414 VMSTATE_BUFFER(macaddr, BOOTPClient),
1415 VMSTATE_END_OF_LIST()
1416 }
1417 };
1418
1419 static const VMStateDescription vmstate_slirp = {
1420 .name = "slirp",
1421 .version_id = 4,
1422 .fields = (VMStateField[]) {
1423 VMSTATE_UINT16_V(ip_id, Slirp, 2),
1424 VMSTATE_STRUCT_ARRAY(bootp_clients, Slirp, NB_BOOTP_CLIENTS, 3,
1425 vmstate_slirp_bootp_client, BOOTPClient),
1426 VMSTATE_END_OF_LIST()
1427 }
1428 };
1429
1430 static void slirp_state_save(QEMUFile *f, void *opaque)
1431 {
1432 Slirp *slirp = opaque;
1433 struct ex_list *ex_ptr;
1434
1435 for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next)
1436 if (ex_ptr->ex_pty == 3) {
1437 struct socket *so;
1438 so = slirp_find_ctl_socket(slirp, ex_ptr->ex_addr,
1439 ntohs(ex_ptr->ex_fport));
1440 if (!so)
1441 continue;
1442
1443 qemu_put_byte(f, 42);
1444 vmstate_save_state(f, &vmstate_slirp_socket, so, NULL);
1445 }
1446 qemu_put_byte(f, 0);
1447
1448 vmstate_save_state(f, &vmstate_slirp, slirp, NULL);
1449 }
1450
1451
1452 static int slirp_state_load(QEMUFile *f, void *opaque, int version_id)
1453 {
1454 Slirp *slirp = opaque;
1455 struct ex_list *ex_ptr;
1456
1457 while (qemu_get_byte(f)) {
1458 int ret;
1459 struct socket *so = socreate(slirp);
1460
1461 if (!so)
1462 return -ENOMEM;
1463
1464 ret = vmstate_load_state(f, &vmstate_slirp_socket, so, version_id);
1465
1466 if (ret < 0)
1467 return ret;
1468
1469 if ((so->so_faddr.s_addr & slirp->vnetwork_mask.s_addr) !=
1470 slirp->vnetwork_addr.s_addr) {
1471 return -EINVAL;
1472 }
1473 for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
1474 if (ex_ptr->ex_pty == 3 &&
1475 so->so_faddr.s_addr == ex_ptr->ex_addr.s_addr &&
1476 so->so_fport == ex_ptr->ex_fport) {
1477 break;
1478 }
1479 }
1480 if (!ex_ptr)
1481 return -EINVAL;
1482
1483 so->extra = (void *)ex_ptr->ex_exec;
1484 }
1485
1486 return vmstate_load_state(f, &vmstate_slirp, slirp, version_id);
1487 }
AR7 emulation for QEMU