blob: 38e0a2193ae63282fc4ce96f687ba7bc49a2f9c1 [file] [log] [blame]
bellardd75a0b92008-10-17 17:31:57 +00001/*
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 */
aliguorie1c5a2b2009-01-08 19:18:21 +000024#include "qemu-common.h"
Ed Swierkaaf10d92009-07-23 14:13:34 -070025#include "qemu-timer.h"
blueswir10580ac92009-01-12 17:51:06 +000026#include "qemu-char.h"
bellardf0cbd3e2004-04-22 00:10:48 +000027#include "slirp.h"
aliguori062e5522009-01-08 19:27:07 +000028#include "hw/hw.h"
bellardf0cbd3e2004-04-22 00:10:48 +000029
bellardf0cbd3e2004-04-22 00:10:48 +000030/* host loopback address */
31struct in_addr loopback_addr;
Anders Waldenborg648cd332012-07-13 22:54:17 +020032/* host loopback network mask */
Anthony Liguori0b8db8f2012-08-06 19:31:55 -050033unsigned long loopback_mask;
bellardf0cbd3e2004-04-22 00:10:48 +000034
Jan Kiszkaa13a4122009-06-24 14:42:28 +020035/* emulated hosts use the MAC addr 52:55:IP:IP:IP:IP */
Fabien Chouteau1a0ca1e2011-08-03 12:52:54 +020036static const uint8_t special_ethaddr[ETH_ALEN] = {
Jan Kiszkaa13a4122009-06-24 14:42:28 +020037 0x52, 0x55, 0x00, 0x00, 0x00, 0x00
bellardf0cbd3e2004-04-22 00:10:48 +000038};
39
Fabien Chouteau1a0ca1e2011-08-03 12:52:54 +020040static const uint8_t zero_ethaddr[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
bellardf0cbd3e2004-04-22 00:10:48 +000041
bellardf0cbd3e2004-04-22 00:10:48 +000042/* XXX: suppress those select globals */
43fd_set *global_readfds, *global_writefds, *global_xfds;
44
Jan Kiszkaf1d99bb2009-06-24 14:42:30 +020045u_int curtime;
46static u_int time_fasttimo, last_slowtimo;
47static int do_slowtimo;
48
Blue Swirl72cf2d42009-09-12 07:36:22 +000049static QTAILQ_HEAD(slirp_instances, Slirp) slirp_instances =
50 QTAILQ_HEAD_INITIALIZER(slirp_instances);
pbrook115defd2006-04-16 11:06:58 +000051
Stefan Weil9e3a95e2009-08-31 16:29:34 +020052static struct in_addr dns_addr;
53static u_int dns_addr_time;
Ed Swierkdf7a86e2009-08-20 19:00:31 -070054
bellardf0cbd3e2004-04-22 00:10:48 +000055#ifdef _WIN32
56
Ed Swierkdf7a86e2009-08-20 19:00:31 -070057int get_dns_addr(struct in_addr *pdns_addr)
bellardf0cbd3e2004-04-22 00:10:48 +000058{
bellard379ff532004-07-12 22:33:07 +000059 FIXED_INFO *FixedInfo=NULL;
60 ULONG BufLen;
61 DWORD ret;
62 IP_ADDR_STRING *pIPAddr;
63 struct in_addr tmp_addr;
ths3b46e622007-09-17 08:09:54 +000064
Ed Swierkdf7a86e2009-08-20 19:00:31 -070065 if (dns_addr.s_addr != 0 && (curtime - dns_addr_time) < 1000) {
66 *pdns_addr = dns_addr;
67 return 0;
68 }
69
bellard379ff532004-07-12 22:33:07 +000070 FixedInfo = (FIXED_INFO *)GlobalAlloc(GPTR, sizeof(FIXED_INFO));
71 BufLen = sizeof(FIXED_INFO);
ths3b46e622007-09-17 08:09:54 +000072
bellard379ff532004-07-12 22:33:07 +000073 if (ERROR_BUFFER_OVERFLOW == GetNetworkParams(FixedInfo, &BufLen)) {
74 if (FixedInfo) {
75 GlobalFree(FixedInfo);
76 FixedInfo = NULL;
77 }
78 FixedInfo = GlobalAlloc(GPTR, BufLen);
79 }
ths5fafdf22007-09-16 21:08:06 +000080
bellard379ff532004-07-12 22:33:07 +000081 if ((ret = GetNetworkParams(FixedInfo, &BufLen)) != ERROR_SUCCESS) {
82 printf("GetNetworkParams failed. ret = %08x\n", (u_int)ret );
83 if (FixedInfo) {
84 GlobalFree(FixedInfo);
85 FixedInfo = NULL;
86 }
87 return -1;
88 }
ths3b46e622007-09-17 08:09:54 +000089
bellard379ff532004-07-12 22:33:07 +000090 pIPAddr = &(FixedInfo->DnsServerList);
91 inet_aton(pIPAddr->IpAddress.String, &tmp_addr);
92 *pdns_addr = tmp_addr;
Ed Swierkdf7a86e2009-08-20 19:00:31 -070093 dns_addr = tmp_addr;
94 dns_addr_time = curtime;
bellard379ff532004-07-12 22:33:07 +000095 if (FixedInfo) {
96 GlobalFree(FixedInfo);
97 FixedInfo = NULL;
98 }
99 return 0;
bellardf0cbd3e2004-04-22 00:10:48 +0000100}
101
Jan Kiszkadf461892009-06-24 14:42:30 +0200102static void winsock_cleanup(void)
103{
104 WSACleanup();
105}
106
bellardf0cbd3e2004-04-22 00:10:48 +0000107#else
108
Blue Swirl1e6eec82009-09-05 10:14:07 +0000109static struct stat dns_addr_stat;
Ed Swierkdf7a86e2009-08-20 19:00:31 -0700110
111int get_dns_addr(struct in_addr *pdns_addr)
bellardf0cbd3e2004-04-22 00:10:48 +0000112{
113 char buff[512];
blueswir1363a37d2008-08-21 17:58:08 +0000114 char buff2[257];
bellardf0cbd3e2004-04-22 00:10:48 +0000115 FILE *f;
116 int found = 0;
117 struct in_addr tmp_addr;
ths3b46e622007-09-17 08:09:54 +0000118
Ed Swierkdf7a86e2009-08-20 19:00:31 -0700119 if (dns_addr.s_addr != 0) {
120 struct stat old_stat;
121 if ((curtime - dns_addr_time) < 1000) {
122 *pdns_addr = dns_addr;
123 return 0;
124 }
125 old_stat = dns_addr_stat;
126 if (stat("/etc/resolv.conf", &dns_addr_stat) != 0)
127 return -1;
128 if ((dns_addr_stat.st_dev == old_stat.st_dev)
129 && (dns_addr_stat.st_ino == old_stat.st_ino)
130 && (dns_addr_stat.st_size == old_stat.st_size)
131 && (dns_addr_stat.st_mtime == old_stat.st_mtime)) {
132 *pdns_addr = dns_addr;
133 return 0;
134 }
135 }
136
bellardf0cbd3e2004-04-22 00:10:48 +0000137 f = fopen("/etc/resolv.conf", "r");
138 if (!f)
139 return -1;
140
blueswir131a60e22007-10-26 18:42:59 +0000141#ifdef DEBUG
bellardf0cbd3e2004-04-22 00:10:48 +0000142 lprint("IP address of your DNS(s): ");
blueswir131a60e22007-10-26 18:42:59 +0000143#endif
bellardf0cbd3e2004-04-22 00:10:48 +0000144 while (fgets(buff, 512, f) != NULL) {
145 if (sscanf(buff, "nameserver%*[ \t]%256s", buff2) == 1) {
146 if (!inet_aton(buff2, &tmp_addr))
147 continue;
bellardf0cbd3e2004-04-22 00:10:48 +0000148 /* If it's the first one, set it to dns_addr */
Ed Swierkdf7a86e2009-08-20 19:00:31 -0700149 if (!found) {
bellardf0cbd3e2004-04-22 00:10:48 +0000150 *pdns_addr = tmp_addr;
Ed Swierkdf7a86e2009-08-20 19:00:31 -0700151 dns_addr = tmp_addr;
152 dns_addr_time = curtime;
153 }
blueswir131a60e22007-10-26 18:42:59 +0000154#ifdef DEBUG
bellardf0cbd3e2004-04-22 00:10:48 +0000155 else
156 lprint(", ");
blueswir131a60e22007-10-26 18:42:59 +0000157#endif
bellardf0cbd3e2004-04-22 00:10:48 +0000158 if (++found > 3) {
blueswir131a60e22007-10-26 18:42:59 +0000159#ifdef DEBUG
bellardf0cbd3e2004-04-22 00:10:48 +0000160 lprint("(more)");
blueswir131a60e22007-10-26 18:42:59 +0000161#endif
bellardf0cbd3e2004-04-22 00:10:48 +0000162 break;
blueswir131a60e22007-10-26 18:42:59 +0000163 }
164#ifdef DEBUG
165 else
bellardf0cbd3e2004-04-22 00:10:48 +0000166 lprint("%s", inet_ntoa(tmp_addr));
blueswir131a60e22007-10-26 18:42:59 +0000167#endif
bellardf0cbd3e2004-04-22 00:10:48 +0000168 }
169 }
bellard1d43a712004-07-05 21:18:42 +0000170 fclose(f);
bellardf0cbd3e2004-04-22 00:10:48 +0000171 if (!found)
172 return -1;
173 return 0;
174}
175
176#endif
177
Jan Kiszkadf461892009-06-24 14:42:30 +0200178static void slirp_init_once(void)
bellard379ff532004-07-12 22:33:07 +0000179{
Jan Kiszkadf461892009-06-24 14:42:30 +0200180 static int initialized;
Jan Kiszkadf461892009-06-24 14:42:30 +0200181#ifdef _WIN32
182 WSADATA Data;
bellard379ff532004-07-12 22:33:07 +0000183#endif
184
Jan Kiszkadf461892009-06-24 14:42:30 +0200185 if (initialized) {
186 return;
187 }
188 initialized = 1;
189
190#ifdef _WIN32
191 WSAStartup(MAKEWORD(2,0), &Data);
192 atexit(winsock_cleanup);
193#endif
194
195 loopback_addr.s_addr = htonl(INADDR_LOOPBACK);
Anders Waldenborg648cd332012-07-13 22:54:17 +0200196 loopback_mask = htonl(IN_CLASSA_NET);
Jan Kiszkadf461892009-06-24 14:42:30 +0200197}
198
aliguori062e5522009-01-08 19:27:07 +0000199static void slirp_state_save(QEMUFile *f, void *opaque);
200static int slirp_state_load(QEMUFile *f, void *opaque, int version_id);
201
Jan Kiszka9f8bd042009-06-24 14:42:31 +0200202Slirp *slirp_init(int restricted, struct in_addr vnetwork,
203 struct in_addr vnetmask, struct in_addr vhost,
204 const char *vhostname, const char *tftp_path,
205 const char *bootfile, struct in_addr vdhcp_start,
206 struct in_addr vnameserver, void *opaque)
bellardf0cbd3e2004-04-22 00:10:48 +0000207{
Anthony Liguori7267c092011-08-20 22:09:37 -0500208 Slirp *slirp = g_malloc0(sizeof(Slirp));
Jan Kiszka460fec62009-06-24 14:42:31 +0200209
Jan Kiszkadf461892009-06-24 14:42:30 +0200210 slirp_init_once();
bellard379ff532004-07-12 22:33:07 +0000211
Jan Kiszka460fec62009-06-24 14:42:31 +0200212 slirp->restricted = restricted;
bellardf0cbd3e2004-04-22 00:10:48 +0000213
Jan Kiszka460fec62009-06-24 14:42:31 +0200214 if_init(slirp);
215 ip_init(slirp);
bellardf0cbd3e2004-04-22 00:10:48 +0000216
217 /* Initialise mbufs *after* setting the MTU */
Jan Kiszka460fec62009-06-24 14:42:31 +0200218 m_init(slirp);
bellardf0cbd3e2004-04-22 00:10:48 +0000219
Jan Kiszka460fec62009-06-24 14:42:31 +0200220 slirp->vnetwork_addr = vnetwork;
221 slirp->vnetwork_mask = vnetmask;
222 slirp->vhost_addr = vhost;
Jan Kiszkac92ef6a2009-06-24 14:42:28 +0200223 if (vhostname) {
Jan Kiszka460fec62009-06-24 14:42:31 +0200224 pstrcpy(slirp->client_hostname, sizeof(slirp->client_hostname),
225 vhostname);
Jan Kiszkaa13a4122009-06-24 14:42:28 +0200226 }
Jan Kiszkaad196a92009-06-24 14:42:28 +0200227 if (tftp_path) {
Anthony Liguori7267c092011-08-20 22:09:37 -0500228 slirp->tftp_prefix = g_strdup(tftp_path);
Jan Kiszkaad196a92009-06-24 14:42:28 +0200229 }
Jan Kiszkaad196a92009-06-24 14:42:28 +0200230 if (bootfile) {
Anthony Liguori7267c092011-08-20 22:09:37 -0500231 slirp->bootp_filename = g_strdup(bootfile);
Jan Kiszkaad196a92009-06-24 14:42:28 +0200232 }
Jan Kiszka460fec62009-06-24 14:42:31 +0200233 slirp->vdhcp_startaddr = vdhcp_start;
234 slirp->vnameserver_addr = vnameserver;
Jan Kiszkaad196a92009-06-24 14:42:28 +0200235
Jan Kiszka9f8bd042009-06-24 14:42:31 +0200236 slirp->opaque = opaque;
237
Alex Williamson0be71e32010-06-25 11:09:07 -0600238 register_savevm(NULL, "slirp", 0, 3,
239 slirp_state_save, slirp_state_load, slirp);
Jan Kiszka9f8bd042009-06-24 14:42:31 +0200240
Blue Swirl72cf2d42009-09-12 07:36:22 +0000241 QTAILQ_INSERT_TAIL(&slirp_instances, slirp, entry);
Jan Kiszkaad0d8c42009-06-24 14:42:31 +0200242
Jan Kiszka9f8bd042009-06-24 14:42:31 +0200243 return slirp;
bellardf0cbd3e2004-04-22 00:10:48 +0000244}
245
Jan Kiszkaad0d8c42009-06-24 14:42:31 +0200246void slirp_cleanup(Slirp *slirp)
247{
Blue Swirl72cf2d42009-09-12 07:36:22 +0000248 QTAILQ_REMOVE(&slirp_instances, slirp, entry);
Jan Kiszkab1c99fc2009-06-24 14:42:31 +0200249
Alex Williamson0be71e32010-06-25 11:09:07 -0600250 unregister_savevm(NULL, "slirp", slirp);
Jan Kiszkaad0d8c42009-06-24 14:42:31 +0200251
Jan Kiszkaa68adc22012-02-29 19:14:23 +0100252 ip_cleanup(slirp);
253 m_cleanup(slirp);
254
Anthony Liguori7267c092011-08-20 22:09:37 -0500255 g_free(slirp->tftp_prefix);
256 g_free(slirp->bootp_filename);
257 g_free(slirp);
Jan Kiszkaad0d8c42009-06-24 14:42:31 +0200258}
259
bellardf0cbd3e2004-04-22 00:10:48 +0000260#define CONN_CANFSEND(so) (((so)->so_state & (SS_FCANTSENDMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
261#define CONN_CANFRCV(so) (((so)->so_state & (SS_FCANTRCVMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
262#define UPD_NFDS(x) if (nfds < (x)) nfds = (x)
263
Stefano Stabellini7c7db752012-04-13 19:35:04 +0100264void slirp_update_timeout(uint32_t *timeout)
265{
266 if (!QTAILQ_EMPTY(&slirp_instances)) {
267 *timeout = MIN(1000, *timeout);
268 }
269}
270
ths5fafdf22007-09-16 21:08:06 +0000271void slirp_select_fill(int *pnfds,
bellardf0cbd3e2004-04-22 00:10:48 +0000272 fd_set *readfds, fd_set *writefds, fd_set *xfds)
273{
Jan Kiszkab1c99fc2009-06-24 14:42:31 +0200274 Slirp *slirp;
bellardf0cbd3e2004-04-22 00:10:48 +0000275 struct socket *so, *so_next;
bellardf0cbd3e2004-04-22 00:10:48 +0000276 int nfds;
bellardf0cbd3e2004-04-22 00:10:48 +0000277
Blue Swirl72cf2d42009-09-12 07:36:22 +0000278 if (QTAILQ_EMPTY(&slirp_instances)) {
Jan Kiszkad918f232009-06-24 14:42:30 +0200279 return;
280 }
281
bellardf0cbd3e2004-04-22 00:10:48 +0000282 /* fail safe */
283 global_readfds = NULL;
284 global_writefds = NULL;
285 global_xfds = NULL;
ths3b46e622007-09-17 08:09:54 +0000286
bellardf0cbd3e2004-04-22 00:10:48 +0000287 nfds = *pnfds;
288 /*
289 * First, TCP sockets
290 */
291 do_slowtimo = 0;
Jan Kiszkad918f232009-06-24 14:42:30 +0200292
Blue Swirl72cf2d42009-09-12 07:36:22 +0000293 QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
ths5fafdf22007-09-16 21:08:06 +0000294 /*
bellardf0cbd3e2004-04-22 00:10:48 +0000295 * *_slowtimo needs calling if there are IP fragments
296 * in the fragment queue, or there are TCP connections active
297 */
Jan Kiszkab1c99fc2009-06-24 14:42:31 +0200298 do_slowtimo |= ((slirp->tcb.so_next != &slirp->tcb) ||
Jan Kiszka460fec62009-06-24 14:42:31 +0200299 (&slirp->ipq.ip_link != slirp->ipq.ip_link.next));
ths3b46e622007-09-17 08:09:54 +0000300
Jan Kiszka460fec62009-06-24 14:42:31 +0200301 for (so = slirp->tcb.so_next; so != &slirp->tcb;
302 so = so_next) {
bellardf0cbd3e2004-04-22 00:10:48 +0000303 so_next = so->so_next;
ths3b46e622007-09-17 08:09:54 +0000304
bellardf0cbd3e2004-04-22 00:10:48 +0000305 /*
306 * See if we need a tcp_fasttimo
307 */
308 if (time_fasttimo == 0 && so->so_tcpcb->t_flags & TF_DELACK)
309 time_fasttimo = curtime; /* Flag when we want a fasttimo */
ths3b46e622007-09-17 08:09:54 +0000310
bellardf0cbd3e2004-04-22 00:10:48 +0000311 /*
312 * NOFDREF can include still connecting to local-host,
313 * newly socreated() sockets etc. Don't want to select these.
314 */
315 if (so->so_state & SS_NOFDREF || so->s == -1)
316 continue;
ths3b46e622007-09-17 08:09:54 +0000317
bellardf0cbd3e2004-04-22 00:10:48 +0000318 /*
319 * Set for reading sockets which are accepting
320 */
321 if (so->so_state & SS_FACCEPTCONN) {
322 FD_SET(so->s, readfds);
323 UPD_NFDS(so->s);
324 continue;
325 }
ths3b46e622007-09-17 08:09:54 +0000326
bellardf0cbd3e2004-04-22 00:10:48 +0000327 /*
328 * Set for writing sockets which are connecting
329 */
330 if (so->so_state & SS_ISFCONNECTING) {
331 FD_SET(so->s, writefds);
332 UPD_NFDS(so->s);
333 continue;
334 }
ths3b46e622007-09-17 08:09:54 +0000335
bellardf0cbd3e2004-04-22 00:10:48 +0000336 /*
337 * Set for writing if we are connected, can send more, and
338 * we have something to send
339 */
340 if (CONN_CANFSEND(so) && so->so_rcv.sb_cc) {
341 FD_SET(so->s, writefds);
342 UPD_NFDS(so->s);
343 }
ths3b46e622007-09-17 08:09:54 +0000344
bellardf0cbd3e2004-04-22 00:10:48 +0000345 /*
346 * Set for reading (and urgent data) if we are connected, can
347 * receive more, and we have room for it XXX /2 ?
348 */
349 if (CONN_CANFRCV(so) && (so->so_snd.sb_cc < (so->so_snd.sb_datalen/2))) {
350 FD_SET(so->s, readfds);
351 FD_SET(so->s, xfds);
352 UPD_NFDS(so->s);
353 }
354 }
ths3b46e622007-09-17 08:09:54 +0000355
bellardf0cbd3e2004-04-22 00:10:48 +0000356 /*
357 * UDP sockets
358 */
Jan Kiszka460fec62009-06-24 14:42:31 +0200359 for (so = slirp->udb.so_next; so != &slirp->udb;
360 so = so_next) {
bellardf0cbd3e2004-04-22 00:10:48 +0000361 so_next = so->so_next;
ths3b46e622007-09-17 08:09:54 +0000362
bellardf0cbd3e2004-04-22 00:10:48 +0000363 /*
364 * See if it's timed out
365 */
366 if (so->so_expire) {
367 if (so->so_expire <= curtime) {
368 udp_detach(so);
369 continue;
370 } else
371 do_slowtimo = 1; /* Let socket expire */
372 }
ths3b46e622007-09-17 08:09:54 +0000373
bellardf0cbd3e2004-04-22 00:10:48 +0000374 /*
375 * When UDP packets are received from over the
376 * link, they're sendto()'d straight away, so
377 * no need for setting for writing
378 * Limit the number of packets queued by this session
379 * to 4. Note that even though we try and limit this
380 * to 4 packets, the session could have more queued
381 * if the packets needed to be fragmented
382 * (XXX <= 4 ?)
383 */
384 if ((so->so_state & SS_ISFCONNECTED) && so->so_queued <= 4) {
385 FD_SET(so->s, readfds);
386 UPD_NFDS(so->s);
387 }
388 }
Jan Kiszkae6d43cf2011-07-20 12:20:18 +0200389
390 /*
391 * ICMP sockets
392 */
393 for (so = slirp->icmp.so_next; so != &slirp->icmp;
394 so = so_next) {
395 so_next = so->so_next;
396
397 /*
398 * See if it's timed out
399 */
400 if (so->so_expire) {
401 if (so->so_expire <= curtime) {
402 icmp_detach(so);
403 continue;
404 } else {
405 do_slowtimo = 1; /* Let socket expire */
406 }
407 }
408
409 if (so->so_state & SS_ISFCONNECTED) {
410 FD_SET(so->s, readfds);
411 UPD_NFDS(so->s);
412 }
413 }
Jan Kiszkab1c99fc2009-06-24 14:42:31 +0200414 }
ths5fafdf22007-09-16 21:08:06 +0000415
bellardf0cbd3e2004-04-22 00:10:48 +0000416 *pnfds = nfds;
ths5fafdf22007-09-16 21:08:06 +0000417}
bellardf0cbd3e2004-04-22 00:10:48 +0000418
Jan Kiszkad918f232009-06-24 14:42:30 +0200419void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds,
420 int select_error)
bellardf0cbd3e2004-04-22 00:10:48 +0000421{
Jan Kiszkab1c99fc2009-06-24 14:42:31 +0200422 Slirp *slirp;
bellardf0cbd3e2004-04-22 00:10:48 +0000423 struct socket *so, *so_next;
424 int ret;
425
Blue Swirl72cf2d42009-09-12 07:36:22 +0000426 if (QTAILQ_EMPTY(&slirp_instances)) {
Jan Kiszkad918f232009-06-24 14:42:30 +0200427 return;
428 }
429
bellardf0cbd3e2004-04-22 00:10:48 +0000430 global_readfds = readfds;
431 global_writefds = writefds;
432 global_xfds = xfds;
433
Paolo Bonzini7bd427d2011-03-11 16:47:48 +0100434 curtime = qemu_get_clock_ms(rt_clock);
ths5fafdf22007-09-16 21:08:06 +0000435
Blue Swirl72cf2d42009-09-12 07:36:22 +0000436 QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
bellardf0cbd3e2004-04-22 00:10:48 +0000437 /*
ths5fafdf22007-09-16 21:08:06 +0000438 * See if anything has timed out
bellardf0cbd3e2004-04-22 00:10:48 +0000439 */
bellarddf5f8952005-09-03 10:45:09 +0000440 if (time_fasttimo && ((curtime - time_fasttimo) >= 2)) {
Jan Kiszka460fec62009-06-24 14:42:31 +0200441 tcp_fasttimo(slirp);
bellardf0cbd3e2004-04-22 00:10:48 +0000442 time_fasttimo = 0;
443 }
444 if (do_slowtimo && ((curtime - last_slowtimo) >= 499)) {
Jan Kiszka460fec62009-06-24 14:42:31 +0200445 ip_slowtimo(slirp);
446 tcp_slowtimo(slirp);
bellardf0cbd3e2004-04-22 00:10:48 +0000447 last_slowtimo = curtime;
448 }
ths5fafdf22007-09-16 21:08:06 +0000449
bellardf0cbd3e2004-04-22 00:10:48 +0000450 /*
451 * Check sockets
452 */
Jan Kiszkad918f232009-06-24 14:42:30 +0200453 if (!select_error) {
bellardf0cbd3e2004-04-22 00:10:48 +0000454 /*
455 * Check TCP sockets
456 */
Jan Kiszka460fec62009-06-24 14:42:31 +0200457 for (so = slirp->tcb.so_next; so != &slirp->tcb;
458 so = so_next) {
bellardf0cbd3e2004-04-22 00:10:48 +0000459 so_next = so->so_next;
ths3b46e622007-09-17 08:09:54 +0000460
bellardf0cbd3e2004-04-22 00:10:48 +0000461 /*
462 * FD_ISSET is meaningless on these sockets
463 * (and they can crash the program)
464 */
465 if (so->so_state & SS_NOFDREF || so->s == -1)
466 continue;
ths3b46e622007-09-17 08:09:54 +0000467
bellardf0cbd3e2004-04-22 00:10:48 +0000468 /*
469 * Check for URG data
470 * This will soread as well, so no need to
471 * test for readfds below if this succeeds
472 */
473 if (FD_ISSET(so->s, xfds))
474 sorecvoob(so);
475 /*
476 * Check sockets for reading
477 */
478 else if (FD_ISSET(so->s, readfds)) {
479 /*
480 * Check for incoming connections
481 */
482 if (so->so_state & SS_FACCEPTCONN) {
483 tcp_connect(so);
484 continue;
485 } /* else */
486 ret = soread(so);
ths3b46e622007-09-17 08:09:54 +0000487
bellardf0cbd3e2004-04-22 00:10:48 +0000488 /* Output it if we read something */
489 if (ret > 0)
490 tcp_output(sototcpcb(so));
491 }
ths3b46e622007-09-17 08:09:54 +0000492
bellardf0cbd3e2004-04-22 00:10:48 +0000493 /*
494 * Check sockets for writing
495 */
496 if (FD_ISSET(so->s, writefds)) {
497 /*
498 * Check for non-blocking, still-connecting sockets
499 */
500 if (so->so_state & SS_ISFCONNECTING) {
501 /* Connected */
502 so->so_state &= ~SS_ISFCONNECTING;
ths3b46e622007-09-17 08:09:54 +0000503
malc0a656f52009-05-21 05:26:23 +0400504 ret = send(so->s, (const void *) &ret, 0, 0);
bellardf0cbd3e2004-04-22 00:10:48 +0000505 if (ret < 0) {
506 /* XXXXX Must fix, zero bytes is a NOP */
507 if (errno == EAGAIN || errno == EWOULDBLOCK ||
508 errno == EINPROGRESS || errno == ENOTCONN)
509 continue;
ths3b46e622007-09-17 08:09:54 +0000510
bellardf0cbd3e2004-04-22 00:10:48 +0000511 /* else failed */
Jan Kiszkaf932b6c2009-06-24 14:42:29 +0200512 so->so_state &= SS_PERSISTENT_MASK;
513 so->so_state |= SS_NOFDREF;
bellardf0cbd3e2004-04-22 00:10:48 +0000514 }
515 /* else so->so_state &= ~SS_ISFCONNECTING; */
ths3b46e622007-09-17 08:09:54 +0000516
bellardf0cbd3e2004-04-22 00:10:48 +0000517 /*
518 * Continue tcp_input
519 */
520 tcp_input((struct mbuf *)NULL, sizeof(struct ip), so);
521 /* continue; */
522 } else
523 ret = sowrite(so);
524 /*
ths5fafdf22007-09-16 21:08:06 +0000525 * XXXXX If we wrote something (a lot), there
bellardf0cbd3e2004-04-22 00:10:48 +0000526 * could be a need for a window update.
527 * In the worst case, the remote will send
528 * a window probe to get things going again
529 */
530 }
ths3b46e622007-09-17 08:09:54 +0000531
bellardf0cbd3e2004-04-22 00:10:48 +0000532 /*
533 * Probe a still-connecting, non-blocking socket
534 * to check if it's still alive
535 */
536#ifdef PROBE_CONN
537 if (so->so_state & SS_ISFCONNECTING) {
Blue Swirl00aa0042011-07-23 20:04:29 +0000538 ret = qemu_recv(so->s, &ret, 0,0);
ths3b46e622007-09-17 08:09:54 +0000539
bellardf0cbd3e2004-04-22 00:10:48 +0000540 if (ret < 0) {
541 /* XXX */
542 if (errno == EAGAIN || errno == EWOULDBLOCK ||
543 errno == EINPROGRESS || errno == ENOTCONN)
544 continue; /* Still connecting, continue */
ths3b46e622007-09-17 08:09:54 +0000545
bellardf0cbd3e2004-04-22 00:10:48 +0000546 /* else failed */
Jan Kiszkaf932b6c2009-06-24 14:42:29 +0200547 so->so_state &= SS_PERSISTENT_MASK;
548 so->so_state |= SS_NOFDREF;
ths3b46e622007-09-17 08:09:54 +0000549
bellardf0cbd3e2004-04-22 00:10:48 +0000550 /* tcp_input will take care of it */
551 } else {
bellard02d2c542004-10-07 23:27:35 +0000552 ret = send(so->s, &ret, 0,0);
bellardf0cbd3e2004-04-22 00:10:48 +0000553 if (ret < 0) {
554 /* XXX */
555 if (errno == EAGAIN || errno == EWOULDBLOCK ||
556 errno == EINPROGRESS || errno == ENOTCONN)
557 continue;
558 /* else failed */
Jan Kiszkaf932b6c2009-06-24 14:42:29 +0200559 so->so_state &= SS_PERSISTENT_MASK;
560 so->so_state |= SS_NOFDREF;
bellardf0cbd3e2004-04-22 00:10:48 +0000561 } else
562 so->so_state &= ~SS_ISFCONNECTING;
ths3b46e622007-09-17 08:09:54 +0000563
bellardf0cbd3e2004-04-22 00:10:48 +0000564 }
565 tcp_input((struct mbuf *)NULL, sizeof(struct ip),so);
566 } /* SS_ISFCONNECTING */
567#endif
568 }
ths3b46e622007-09-17 08:09:54 +0000569
bellardf0cbd3e2004-04-22 00:10:48 +0000570 /*
571 * Now UDP sockets.
572 * Incoming packets are sent straight away, they're not buffered.
573 * Incoming UDP data isn't buffered either.
574 */
Jan Kiszka460fec62009-06-24 14:42:31 +0200575 for (so = slirp->udb.so_next; so != &slirp->udb;
576 so = so_next) {
bellardf0cbd3e2004-04-22 00:10:48 +0000577 so_next = so->so_next;
ths3b46e622007-09-17 08:09:54 +0000578
bellardf0cbd3e2004-04-22 00:10:48 +0000579 if (so->s != -1 && FD_ISSET(so->s, readfds)) {
580 sorecvfrom(so);
581 }
582 }
Jan Kiszkae6d43cf2011-07-20 12:20:18 +0200583
584 /*
585 * Check incoming ICMP relies.
586 */
587 for (so = slirp->icmp.so_next; so != &slirp->icmp;
588 so = so_next) {
589 so_next = so->so_next;
590
591 if (so->s != -1 && FD_ISSET(so->s, readfds)) {
592 icmp_receive(so);
593 }
594 }
bellardf0cbd3e2004-04-22 00:10:48 +0000595 }
ths5fafdf22007-09-16 21:08:06 +0000596
Jan Kiszkaf3734312012-03-06 00:02:23 +0100597 if_start(slirp);
Jan Kiszkab1c99fc2009-06-24 14:42:31 +0200598 }
bellard02d2c542004-10-07 23:27:35 +0000599
600 /* clear global file descriptor sets.
601 * these reside on the stack in vl.c
602 * so they're unusable if we're not in
603 * slirp_select_fill or slirp_select_poll.
604 */
605 global_readfds = NULL;
606 global_writefds = NULL;
607 global_xfds = NULL;
bellardf0cbd3e2004-04-22 00:10:48 +0000608}
609
Jan Kiszka460fec62009-06-24 14:42:31 +0200610static void arp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
bellardf0cbd3e2004-04-22 00:10:48 +0000611{
bellardf0cbd3e2004-04-22 00:10:48 +0000612 struct arphdr *ah = (struct arphdr *)(pkt + ETH_HLEN);
Hervé Poussineaudbf3c4b2010-09-15 22:33:26 +0200613 uint8_t arp_reply[max(ETH_HLEN + sizeof(struct arphdr), 64)];
bellardf0cbd3e2004-04-22 00:10:48 +0000614 struct ethhdr *reh = (struct ethhdr *)arp_reply;
615 struct arphdr *rah = (struct arphdr *)(arp_reply + ETH_HLEN);
616 int ar_op;
bellarda3d4af02004-09-05 23:10:26 +0000617 struct ex_list *ex_ptr;
bellardf0cbd3e2004-04-22 00:10:48 +0000618
619 ar_op = ntohs(ah->ar_op);
620 switch(ar_op) {
621 case ARPOP_REQUEST:
Fabien Chouteau1a0ca1e2011-08-03 12:52:54 +0200622 if (ah->ar_tip == ah->ar_sip) {
623 /* Gratuitous ARP */
624 arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
625 return;
626 }
627
Jan Kiszka460fec62009-06-24 14:42:31 +0200628 if ((ah->ar_tip & slirp->vnetwork_mask.s_addr) ==
629 slirp->vnetwork_addr.s_addr) {
630 if (ah->ar_tip == slirp->vnameserver_addr.s_addr ||
631 ah->ar_tip == slirp->vhost_addr.s_addr)
bellarda3d4af02004-09-05 23:10:26 +0000632 goto arp_ok;
Jan Kiszka460fec62009-06-24 14:42:31 +0200633 for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
Jan Kiszkaa13a4122009-06-24 14:42:28 +0200634 if (ex_ptr->ex_addr.s_addr == ah->ar_tip)
bellarda3d4af02004-09-05 23:10:26 +0000635 goto arp_ok;
636 }
637 return;
638 arp_ok:
Hervé Poussineaudbf3c4b2010-09-15 22:33:26 +0200639 memset(arp_reply, 0, sizeof(arp_reply));
Fabien Chouteau1a0ca1e2011-08-03 12:52:54 +0200640
641 arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
bellardf0cbd3e2004-04-22 00:10:48 +0000642
643 /* ARP request for alias/dns mac address */
644 memcpy(reh->h_dest, pkt + ETH_ALEN, ETH_ALEN);
Jan Kiszkaa13a4122009-06-24 14:42:28 +0200645 memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4);
646 memcpy(&reh->h_source[2], &ah->ar_tip, 4);
bellardf0cbd3e2004-04-22 00:10:48 +0000647 reh->h_proto = htons(ETH_P_ARP);
648
649 rah->ar_hrd = htons(1);
650 rah->ar_pro = htons(ETH_P_IP);
651 rah->ar_hln = ETH_ALEN;
652 rah->ar_pln = 4;
653 rah->ar_op = htons(ARPOP_REPLY);
654 memcpy(rah->ar_sha, reh->h_source, ETH_ALEN);
Jan Kiszkaa13a4122009-06-24 14:42:28 +0200655 rah->ar_sip = ah->ar_tip;
bellardf0cbd3e2004-04-22 00:10:48 +0000656 memcpy(rah->ar_tha, ah->ar_sha, ETH_ALEN);
Jan Kiszkaa13a4122009-06-24 14:42:28 +0200657 rah->ar_tip = ah->ar_sip;
Jan Kiszka9f8bd042009-06-24 14:42:31 +0200658 slirp_output(slirp->opaque, arp_reply, sizeof(arp_reply));
bellardf0cbd3e2004-04-22 00:10:48 +0000659 }
660 break;
bellardde806f02008-10-17 17:28:58 +0000661 case ARPOP_REPLY:
Fabien Chouteau1a0ca1e2011-08-03 12:52:54 +0200662 arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
bellardde806f02008-10-17 17:28:58 +0000663 break;
bellardf0cbd3e2004-04-22 00:10:48 +0000664 default:
665 break;
666 }
667}
668
Jan Kiszka9f8bd042009-06-24 14:42:31 +0200669void slirp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
bellardf0cbd3e2004-04-22 00:10:48 +0000670{
671 struct mbuf *m;
672 int proto;
673
674 if (pkt_len < ETH_HLEN)
675 return;
ths3b46e622007-09-17 08:09:54 +0000676
bellardf0cbd3e2004-04-22 00:10:48 +0000677 proto = ntohs(*(uint16_t *)(pkt + 12));
678 switch(proto) {
679 case ETH_P_ARP:
Jan Kiszka460fec62009-06-24 14:42:31 +0200680 arp_input(slirp, pkt, pkt_len);
bellardf0cbd3e2004-04-22 00:10:48 +0000681 break;
682 case ETH_P_IP:
Jan Kiszka460fec62009-06-24 14:42:31 +0200683 m = m_get(slirp);
bellardf0cbd3e2004-04-22 00:10:48 +0000684 if (!m)
685 return;
bellard38f3e7c2006-05-10 19:21:58 +0000686 /* Note: we add to align the IP header */
aurel32e8e880a2008-12-07 18:15:23 +0000687 if (M_FREEROOM(m) < pkt_len + 2) {
688 m_inc(m, pkt_len + 2);
689 }
bellard38f3e7c2006-05-10 19:21:58 +0000690 m->m_len = pkt_len + 2;
691 memcpy(m->m_data + 2, pkt, pkt_len);
bellardf0cbd3e2004-04-22 00:10:48 +0000692
bellard38f3e7c2006-05-10 19:21:58 +0000693 m->m_data += 2 + ETH_HLEN;
694 m->m_len -= 2 + ETH_HLEN;
bellardf0cbd3e2004-04-22 00:10:48 +0000695
696 ip_input(m);
697 break;
698 default:
699 break;
700 }
701}
702
Fabien Chouteau1ab74ce2011-08-01 18:18:37 +0200703/* Output the IP packet to the ethernet device. Returns 0 if the packet must be
704 * re-queued.
705 */
706int if_encap(Slirp *slirp, struct mbuf *ifm)
bellardf0cbd3e2004-04-22 00:10:48 +0000707{
708 uint8_t buf[1600];
709 struct ethhdr *eh = (struct ethhdr *)buf;
Fabien Chouteau1a0ca1e2011-08-03 12:52:54 +0200710 uint8_t ethaddr[ETH_ALEN];
Fabien Chouteau1ab74ce2011-08-01 18:18:37 +0200711 const struct ip *iph = (const struct ip *)ifm->m_data;
bellardf0cbd3e2004-04-22 00:10:48 +0000712
Fabien Chouteau1ab74ce2011-08-01 18:18:37 +0200713 if (ifm->m_len + ETH_HLEN > sizeof(buf)) {
714 return 1;
715 }
Fabien Chouteau1a0ca1e2011-08-03 12:52:54 +0200716
717 if (!arp_table_search(slirp, iph->ip_dst.s_addr, ethaddr)) {
bellardde806f02008-10-17 17:28:58 +0000718 uint8_t arp_req[ETH_HLEN + sizeof(struct arphdr)];
719 struct ethhdr *reh = (struct ethhdr *)arp_req;
720 struct arphdr *rah = (struct arphdr *)(arp_req + ETH_HLEN);
bellardf0cbd3e2004-04-22 00:10:48 +0000721
Fabien Chouteau1ab74ce2011-08-01 18:18:37 +0200722 if (!ifm->arp_requested) {
723 /* If the client addr is not known, send an ARP request */
724 memset(reh->h_dest, 0xff, ETH_ALEN);
725 memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4);
726 memcpy(&reh->h_source[2], &slirp->vhost_addr, 4);
727 reh->h_proto = htons(ETH_P_ARP);
728 rah->ar_hrd = htons(1);
729 rah->ar_pro = htons(ETH_P_IP);
730 rah->ar_hln = ETH_ALEN;
731 rah->ar_pln = 4;
732 rah->ar_op = htons(ARPOP_REQUEST);
733
734 /* source hw addr */
735 memcpy(rah->ar_sha, special_ethaddr, ETH_ALEN - 4);
736 memcpy(&rah->ar_sha[2], &slirp->vhost_addr, 4);
737
738 /* source IP */
739 rah->ar_sip = slirp->vhost_addr.s_addr;
740
741 /* target hw addr (none) */
742 memset(rah->ar_tha, 0, ETH_ALEN);
743
744 /* target IP */
745 rah->ar_tip = iph->ip_dst.s_addr;
746 slirp->client_ipaddr = iph->ip_dst;
747 slirp_output(slirp->opaque, arp_req, sizeof(arp_req));
748 ifm->arp_requested = true;
Jan Kiszkae3a110b2011-08-05 14:05:53 +0200749
750 /* Expire request and drop outgoing packet after 1 second */
751 ifm->expiration_date = qemu_get_clock_ns(rt_clock) + 1000000000ULL;
Fabien Chouteau1ab74ce2011-08-01 18:18:37 +0200752 }
753 return 0;
bellardde806f02008-10-17 17:28:58 +0000754 } else {
Fabien Chouteau1a0ca1e2011-08-03 12:52:54 +0200755 memcpy(eh->h_dest, ethaddr, ETH_ALEN);
Jan Kiszkaa13a4122009-06-24 14:42:28 +0200756 memcpy(eh->h_source, special_ethaddr, ETH_ALEN - 4);
bellardde806f02008-10-17 17:28:58 +0000757 /* XXX: not correct */
Jan Kiszka460fec62009-06-24 14:42:31 +0200758 memcpy(&eh->h_source[2], &slirp->vhost_addr, 4);
bellardde806f02008-10-17 17:28:58 +0000759 eh->h_proto = htons(ETH_P_IP);
Fabien Chouteau1ab74ce2011-08-01 18:18:37 +0200760 memcpy(buf + sizeof(struct ethhdr), ifm->m_data, ifm->m_len);
761 slirp_output(slirp->opaque, buf, ifm->m_len + ETH_HLEN);
762 return 1;
bellardde806f02008-10-17 17:28:58 +0000763 }
bellardf0cbd3e2004-04-22 00:10:48 +0000764}
bellard9bf05442004-08-25 22:12:49 +0000765
Jan Kiszka9c12a6f2009-06-24 14:42:29 +0200766/* Drop host forwarding rule, return 0 if found. */
Jan Kiszka9f8bd042009-06-24 14:42:31 +0200767int slirp_remove_hostfwd(Slirp *slirp, int is_udp, struct in_addr host_addr,
768 int host_port)
Alexander Grafc1261d82009-05-26 13:03:26 +0200769{
770 struct socket *so;
Jan Kiszka460fec62009-06-24 14:42:31 +0200771 struct socket *head = (is_udp ? &slirp->udb : &slirp->tcb);
Jan Kiszka2ad82cf2009-06-24 14:42:28 +0200772 struct sockaddr_in addr;
773 int port = htons(host_port);
774 socklen_t addr_len;
Alexander Grafc1261d82009-05-26 13:03:26 +0200775
Alexander Grafc1261d82009-05-26 13:03:26 +0200776 for (so = head->so_next; so != head; so = so->so_next) {
Jan Kiszka2ad82cf2009-06-24 14:42:28 +0200777 addr_len = sizeof(addr);
Jan Kiszka9c12a6f2009-06-24 14:42:29 +0200778 if ((so->so_state & SS_HOSTFWD) &&
779 getsockname(so->s, (struct sockaddr *)&addr, &addr_len) == 0 &&
Jan Kiszka3c6a0582009-06-24 14:42:28 +0200780 addr.sin_addr.s_addr == host_addr.s_addr &&
Jan Kiszka2ad82cf2009-06-24 14:42:28 +0200781 addr.sin_port == port) {
Alexander Grafc1261d82009-05-26 13:03:26 +0200782 close(so->s);
783 sofree(so);
Jan Kiszka9c12a6f2009-06-24 14:42:29 +0200784 return 0;
Alexander Grafc1261d82009-05-26 13:03:26 +0200785 }
786 }
787
Jan Kiszka9c12a6f2009-06-24 14:42:29 +0200788 return -1;
Alexander Grafc1261d82009-05-26 13:03:26 +0200789}
790
Jan Kiszka9f8bd042009-06-24 14:42:31 +0200791int slirp_add_hostfwd(Slirp *slirp, int is_udp, struct in_addr host_addr,
792 int host_port, struct in_addr guest_addr, int guest_port)
bellard9bf05442004-08-25 22:12:49 +0000793{
Jan Kiszkaa13a4122009-06-24 14:42:28 +0200794 if (!guest_addr.s_addr) {
Jan Kiszka460fec62009-06-24 14:42:31 +0200795 guest_addr = slirp->vdhcp_startaddr;
Jan Kiszkaa13a4122009-06-24 14:42:28 +0200796 }
bellard9bf05442004-08-25 22:12:49 +0000797 if (is_udp) {
Jan Kiszka460fec62009-06-24 14:42:31 +0200798 if (!udp_listen(slirp, host_addr.s_addr, htons(host_port),
799 guest_addr.s_addr, htons(guest_port), SS_HOSTFWD))
bellard9bf05442004-08-25 22:12:49 +0000800 return -1;
801 } else {
Jan Kiszka460fec62009-06-24 14:42:31 +0200802 if (!tcp_listen(slirp, host_addr.s_addr, htons(host_port),
803 guest_addr.s_addr, htons(guest_port), SS_HOSTFWD))
bellard9bf05442004-08-25 22:12:49 +0000804 return -1;
805 }
806 return 0;
807}
bellarda3d4af02004-09-05 23:10:26 +0000808
Jan Kiszka9f8bd042009-06-24 14:42:31 +0200809int slirp_add_exec(Slirp *slirp, int do_pty, const void *args,
Jan Kiszkabb53fc52009-07-22 17:03:52 +0200810 struct in_addr *guest_addr, int guest_port)
bellarda3d4af02004-09-05 23:10:26 +0000811{
Jan Kiszkabb53fc52009-07-22 17:03:52 +0200812 if (!guest_addr->s_addr) {
813 guest_addr->s_addr = slirp->vnetwork_addr.s_addr |
Jan Kiszka460fec62009-06-24 14:42:31 +0200814 (htonl(0x0204) & ~slirp->vnetwork_mask.s_addr);
Jan Kiszkac92ef6a2009-06-24 14:42:28 +0200815 }
Jan Kiszkabb53fc52009-07-22 17:03:52 +0200816 if ((guest_addr->s_addr & slirp->vnetwork_mask.s_addr) !=
Jan Kiszka460fec62009-06-24 14:42:31 +0200817 slirp->vnetwork_addr.s_addr ||
Jan Kiszkabb53fc52009-07-22 17:03:52 +0200818 guest_addr->s_addr == slirp->vhost_addr.s_addr ||
819 guest_addr->s_addr == slirp->vnameserver_addr.s_addr) {
Jan Kiszkaa13a4122009-06-24 14:42:28 +0200820 return -1;
821 }
Jan Kiszkabb53fc52009-07-22 17:03:52 +0200822 return add_exec(&slirp->exec_list, do_pty, (char *)args, *guest_addr,
Jan Kiszkaa13a4122009-06-24 14:42:28 +0200823 htons(guest_port));
bellarda3d4af02004-09-05 23:10:26 +0000824}
aliguorie1c5a2b2009-01-08 19:18:21 +0000825
826ssize_t slirp_send(struct socket *so, const void *buf, size_t len, int flags)
827{
828 if (so->s == -1 && so->extra) {
Anthony Liguori2cc6e0a2011-08-15 11:17:28 -0500829 qemu_chr_fe_write(so->extra, buf, len);
aliguorie1c5a2b2009-01-08 19:18:21 +0000830 return len;
831 }
832
833 return send(so->s, buf, len, flags);
834}
835
Jan Kiszkaa13a4122009-06-24 14:42:28 +0200836static struct socket *
Jan Kiszka460fec62009-06-24 14:42:31 +0200837slirp_find_ctl_socket(Slirp *slirp, struct in_addr guest_addr, int guest_port)
aliguorie1c5a2b2009-01-08 19:18:21 +0000838{
Jan Kiszkaa13a4122009-06-24 14:42:28 +0200839 struct socket *so;
aliguorie1c5a2b2009-01-08 19:18:21 +0000840
Jan Kiszka460fec62009-06-24 14:42:31 +0200841 for (so = slirp->tcb.so_next; so != &slirp->tcb; so = so->so_next) {
Jan Kiszkaa13a4122009-06-24 14:42:28 +0200842 if (so->so_faddr.s_addr == guest_addr.s_addr &&
843 htons(so->so_fport) == guest_port) {
844 return so;
845 }
846 }
847 return NULL;
aliguorie1c5a2b2009-01-08 19:18:21 +0000848}
849
Jan Kiszka9f8bd042009-06-24 14:42:31 +0200850size_t slirp_socket_can_recv(Slirp *slirp, struct in_addr guest_addr,
851 int guest_port)
aliguorie1c5a2b2009-01-08 19:18:21 +0000852{
853 struct iovec iov[2];
854 struct socket *so;
855
Jan Kiszka460fec62009-06-24 14:42:31 +0200856 so = slirp_find_ctl_socket(slirp, guest_addr, guest_port);
aliguorie1c5a2b2009-01-08 19:18:21 +0000857
858 if (!so || so->so_state & SS_NOFDREF)
859 return 0;
860
861 if (!CONN_CANFRCV(so) || so->so_snd.sb_cc >= (so->so_snd.sb_datalen/2))
862 return 0;
863
864 return sopreprbuf(so, iov, NULL);
865}
866
Jan Kiszka9f8bd042009-06-24 14:42:31 +0200867void slirp_socket_recv(Slirp *slirp, struct in_addr guest_addr, int guest_port,
Jan Kiszkac92ef6a2009-06-24 14:42:28 +0200868 const uint8_t *buf, int size)
aliguorie1c5a2b2009-01-08 19:18:21 +0000869{
870 int ret;
Jan Kiszka460fec62009-06-24 14:42:31 +0200871 struct socket *so = slirp_find_ctl_socket(slirp, guest_addr, guest_port);
Jan Kiszkaa13a4122009-06-24 14:42:28 +0200872
aliguorie1c5a2b2009-01-08 19:18:21 +0000873 if (!so)
874 return;
875
blueswir10580ac92009-01-12 17:51:06 +0000876 ret = soreadbuf(so, (const char *)buf, size);
aliguorie1c5a2b2009-01-08 19:18:21 +0000877
878 if (ret > 0)
879 tcp_output(sototcpcb(so));
880}
aliguori062e5522009-01-08 19:27:07 +0000881
882static void slirp_tcp_save(QEMUFile *f, struct tcpcb *tp)
883{
884 int i;
885
886 qemu_put_sbe16(f, tp->t_state);
887 for (i = 0; i < TCPT_NTIMERS; i++)
888 qemu_put_sbe16(f, tp->t_timer[i]);
889 qemu_put_sbe16(f, tp->t_rxtshift);
890 qemu_put_sbe16(f, tp->t_rxtcur);
891 qemu_put_sbe16(f, tp->t_dupacks);
892 qemu_put_be16(f, tp->t_maxseg);
893 qemu_put_sbyte(f, tp->t_force);
894 qemu_put_be16(f, tp->t_flags);
895 qemu_put_be32(f, tp->snd_una);
896 qemu_put_be32(f, tp->snd_nxt);
897 qemu_put_be32(f, tp->snd_up);
898 qemu_put_be32(f, tp->snd_wl1);
899 qemu_put_be32(f, tp->snd_wl2);
900 qemu_put_be32(f, tp->iss);
901 qemu_put_be32(f, tp->snd_wnd);
902 qemu_put_be32(f, tp->rcv_wnd);
903 qemu_put_be32(f, tp->rcv_nxt);
904 qemu_put_be32(f, tp->rcv_up);
905 qemu_put_be32(f, tp->irs);
906 qemu_put_be32(f, tp->rcv_adv);
907 qemu_put_be32(f, tp->snd_max);
908 qemu_put_be32(f, tp->snd_cwnd);
909 qemu_put_be32(f, tp->snd_ssthresh);
910 qemu_put_sbe16(f, tp->t_idle);
911 qemu_put_sbe16(f, tp->t_rtt);
912 qemu_put_be32(f, tp->t_rtseq);
913 qemu_put_sbe16(f, tp->t_srtt);
914 qemu_put_sbe16(f, tp->t_rttvar);
915 qemu_put_be16(f, tp->t_rttmin);
916 qemu_put_be32(f, tp->max_sndwnd);
917 qemu_put_byte(f, tp->t_oobflags);
918 qemu_put_byte(f, tp->t_iobc);
919 qemu_put_sbe16(f, tp->t_softerror);
920 qemu_put_byte(f, tp->snd_scale);
921 qemu_put_byte(f, tp->rcv_scale);
922 qemu_put_byte(f, tp->request_r_scale);
923 qemu_put_byte(f, tp->requested_s_scale);
924 qemu_put_be32(f, tp->ts_recent);
925 qemu_put_be32(f, tp->ts_recent_age);
926 qemu_put_be32(f, tp->last_ack_sent);
927}
928
929static void slirp_sbuf_save(QEMUFile *f, struct sbuf *sbuf)
930{
931 uint32_t off;
932
933 qemu_put_be32(f, sbuf->sb_cc);
934 qemu_put_be32(f, sbuf->sb_datalen);
935 off = (uint32_t)(sbuf->sb_wptr - sbuf->sb_data);
936 qemu_put_sbe32(f, off);
937 off = (uint32_t)(sbuf->sb_rptr - sbuf->sb_data);
938 qemu_put_sbe32(f, off);
939 qemu_put_buffer(f, (unsigned char*)sbuf->sb_data, sbuf->sb_datalen);
940}
941
942static void slirp_socket_save(QEMUFile *f, struct socket *so)
943{
944 qemu_put_be32(f, so->so_urgc);
945 qemu_put_be32(f, so->so_faddr.s_addr);
946 qemu_put_be32(f, so->so_laddr.s_addr);
947 qemu_put_be16(f, so->so_fport);
948 qemu_put_be16(f, so->so_lport);
949 qemu_put_byte(f, so->so_iptos);
950 qemu_put_byte(f, so->so_emu);
951 qemu_put_byte(f, so->so_type);
952 qemu_put_be32(f, so->so_state);
953 slirp_sbuf_save(f, &so->so_rcv);
954 slirp_sbuf_save(f, &so->so_snd);
955 slirp_tcp_save(f, so->so_tcpcb);
956}
957
Jan Kiszka0a1f8512009-06-24 14:42:31 +0200958static void slirp_bootp_save(QEMUFile *f, Slirp *slirp)
959{
960 int i;
961
962 for (i = 0; i < NB_BOOTP_CLIENTS; i++) {
963 qemu_put_be16(f, slirp->bootp_clients[i].allocated);
964 qemu_put_buffer(f, slirp->bootp_clients[i].macaddr, 6);
965 }
966}
967
aliguori062e5522009-01-08 19:27:07 +0000968static void slirp_state_save(QEMUFile *f, void *opaque)
969{
Jan Kiszka460fec62009-06-24 14:42:31 +0200970 Slirp *slirp = opaque;
aliguori062e5522009-01-08 19:27:07 +0000971 struct ex_list *ex_ptr;
972
Jan Kiszka460fec62009-06-24 14:42:31 +0200973 for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next)
aliguori062e5522009-01-08 19:27:07 +0000974 if (ex_ptr->ex_pty == 3) {
975 struct socket *so;
Jan Kiszka460fec62009-06-24 14:42:31 +0200976 so = slirp_find_ctl_socket(slirp, ex_ptr->ex_addr,
977 ntohs(ex_ptr->ex_fport));
aliguori062e5522009-01-08 19:27:07 +0000978 if (!so)
979 continue;
980
981 qemu_put_byte(f, 42);
982 slirp_socket_save(f, so);
983 }
984 qemu_put_byte(f, 0);
Jan Kiszka285f7a62009-06-24 14:42:30 +0200985
Jan Kiszka460fec62009-06-24 14:42:31 +0200986 qemu_put_be16(f, slirp->ip_id);
Jan Kiszka0a1f8512009-06-24 14:42:31 +0200987
988 slirp_bootp_save(f, slirp);
aliguori062e5522009-01-08 19:27:07 +0000989}
990
991static void slirp_tcp_load(QEMUFile *f, struct tcpcb *tp)
992{
993 int i;
994
995 tp->t_state = qemu_get_sbe16(f);
996 for (i = 0; i < TCPT_NTIMERS; i++)
997 tp->t_timer[i] = qemu_get_sbe16(f);
998 tp->t_rxtshift = qemu_get_sbe16(f);
999 tp->t_rxtcur = qemu_get_sbe16(f);
1000 tp->t_dupacks = qemu_get_sbe16(f);
1001 tp->t_maxseg = qemu_get_be16(f);
1002 tp->t_force = qemu_get_sbyte(f);
1003 tp->t_flags = qemu_get_be16(f);
1004 tp->snd_una = qemu_get_be32(f);
1005 tp->snd_nxt = qemu_get_be32(f);
1006 tp->snd_up = qemu_get_be32(f);
1007 tp->snd_wl1 = qemu_get_be32(f);
1008 tp->snd_wl2 = qemu_get_be32(f);
1009 tp->iss = qemu_get_be32(f);
1010 tp->snd_wnd = qemu_get_be32(f);
1011 tp->rcv_wnd = qemu_get_be32(f);
1012 tp->rcv_nxt = qemu_get_be32(f);
1013 tp->rcv_up = qemu_get_be32(f);
1014 tp->irs = qemu_get_be32(f);
1015 tp->rcv_adv = qemu_get_be32(f);
1016 tp->snd_max = qemu_get_be32(f);
1017 tp->snd_cwnd = qemu_get_be32(f);
1018 tp->snd_ssthresh = qemu_get_be32(f);
1019 tp->t_idle = qemu_get_sbe16(f);
1020 tp->t_rtt = qemu_get_sbe16(f);
1021 tp->t_rtseq = qemu_get_be32(f);
1022 tp->t_srtt = qemu_get_sbe16(f);
1023 tp->t_rttvar = qemu_get_sbe16(f);
1024 tp->t_rttmin = qemu_get_be16(f);
1025 tp->max_sndwnd = qemu_get_be32(f);
1026 tp->t_oobflags = qemu_get_byte(f);
1027 tp->t_iobc = qemu_get_byte(f);
1028 tp->t_softerror = qemu_get_sbe16(f);
1029 tp->snd_scale = qemu_get_byte(f);
1030 tp->rcv_scale = qemu_get_byte(f);
1031 tp->request_r_scale = qemu_get_byte(f);
1032 tp->requested_s_scale = qemu_get_byte(f);
1033 tp->ts_recent = qemu_get_be32(f);
1034 tp->ts_recent_age = qemu_get_be32(f);
1035 tp->last_ack_sent = qemu_get_be32(f);
1036 tcp_template(tp);
1037}
1038
1039static int slirp_sbuf_load(QEMUFile *f, struct sbuf *sbuf)
1040{
1041 uint32_t off, sb_cc, sb_datalen;
1042
1043 sb_cc = qemu_get_be32(f);
1044 sb_datalen = qemu_get_be32(f);
1045
1046 sbreserve(sbuf, sb_datalen);
1047
1048 if (sbuf->sb_datalen != sb_datalen)
1049 return -ENOMEM;
1050
1051 sbuf->sb_cc = sb_cc;
1052
1053 off = qemu_get_sbe32(f);
1054 sbuf->sb_wptr = sbuf->sb_data + off;
1055 off = qemu_get_sbe32(f);
1056 sbuf->sb_rptr = sbuf->sb_data + off;
1057 qemu_get_buffer(f, (unsigned char*)sbuf->sb_data, sbuf->sb_datalen);
1058
1059 return 0;
1060}
1061
1062static int slirp_socket_load(QEMUFile *f, struct socket *so)
1063{
1064 if (tcp_attach(so) < 0)
1065 return -ENOMEM;
1066
1067 so->so_urgc = qemu_get_be32(f);
1068 so->so_faddr.s_addr = qemu_get_be32(f);
1069 so->so_laddr.s_addr = qemu_get_be32(f);
1070 so->so_fport = qemu_get_be16(f);
1071 so->so_lport = qemu_get_be16(f);
1072 so->so_iptos = qemu_get_byte(f);
1073 so->so_emu = qemu_get_byte(f);
1074 so->so_type = qemu_get_byte(f);
1075 so->so_state = qemu_get_be32(f);
1076 if (slirp_sbuf_load(f, &so->so_rcv) < 0)
1077 return -ENOMEM;
1078 if (slirp_sbuf_load(f, &so->so_snd) < 0)
1079 return -ENOMEM;
1080 slirp_tcp_load(f, so->so_tcpcb);
1081
1082 return 0;
1083}
1084
Jan Kiszka0a1f8512009-06-24 14:42:31 +02001085static void slirp_bootp_load(QEMUFile *f, Slirp *slirp)
1086{
1087 int i;
1088
1089 for (i = 0; i < NB_BOOTP_CLIENTS; i++) {
1090 slirp->bootp_clients[i].allocated = qemu_get_be16(f);
1091 qemu_get_buffer(f, slirp->bootp_clients[i].macaddr, 6);
1092 }
1093}
1094
aliguori062e5522009-01-08 19:27:07 +00001095static int slirp_state_load(QEMUFile *f, void *opaque, int version_id)
1096{
Jan Kiszka460fec62009-06-24 14:42:31 +02001097 Slirp *slirp = opaque;
aliguori062e5522009-01-08 19:27:07 +00001098 struct ex_list *ex_ptr;
aliguori062e5522009-01-08 19:27:07 +00001099
Blue Swirlb0e04862010-03-07 13:45:38 +00001100 while (qemu_get_byte(f)) {
aliguori062e5522009-01-08 19:27:07 +00001101 int ret;
Jan Kiszka460fec62009-06-24 14:42:31 +02001102 struct socket *so = socreate(slirp);
aliguori062e5522009-01-08 19:27:07 +00001103
1104 if (!so)
1105 return -ENOMEM;
1106
1107 ret = slirp_socket_load(f, so);
1108
1109 if (ret < 0)
1110 return ret;
1111
Jan Kiszka460fec62009-06-24 14:42:31 +02001112 if ((so->so_faddr.s_addr & slirp->vnetwork_mask.s_addr) !=
1113 slirp->vnetwork_addr.s_addr) {
aliguori062e5522009-01-08 19:27:07 +00001114 return -EINVAL;
Jan Kiszkaa13a4122009-06-24 14:42:28 +02001115 }
Jan Kiszka460fec62009-06-24 14:42:31 +02001116 for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
aliguori062e5522009-01-08 19:27:07 +00001117 if (ex_ptr->ex_pty == 3 &&
Jan Kiszkaa13a4122009-06-24 14:42:28 +02001118 so->so_faddr.s_addr == ex_ptr->ex_addr.s_addr &&
1119 so->so_fport == ex_ptr->ex_fport) {
aliguori062e5522009-01-08 19:27:07 +00001120 break;
Jan Kiszkaa13a4122009-06-24 14:42:28 +02001121 }
1122 }
aliguori062e5522009-01-08 19:27:07 +00001123 if (!ex_ptr)
1124 return -EINVAL;
1125
blueswir10580ac92009-01-12 17:51:06 +00001126 so->extra = (void *)ex_ptr->ex_exec;
aliguori062e5522009-01-08 19:27:07 +00001127 }
1128
Jan Kiszka285f7a62009-06-24 14:42:30 +02001129 if (version_id >= 2) {
Jan Kiszka460fec62009-06-24 14:42:31 +02001130 slirp->ip_id = qemu_get_be16(f);
Jan Kiszka285f7a62009-06-24 14:42:30 +02001131 }
1132
Jan Kiszka0a1f8512009-06-24 14:42:31 +02001133 if (version_id >= 3) {
1134 slirp_bootp_load(f, slirp);
1135 }
1136
aliguori062e5522009-01-08 19:27:07 +00001137 return 0;
1138}