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