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