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