slirp.c 31.1 KB
Newer Older
bellard's avatar
bellard committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 * libslirp glue
 *
 * Copyright (c) 2004-2008 Fabrice Bellard
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
24
#include "qemu-common.h"
25
#include "qemu/timer.h"
26
#include "char/char.h"
bellard's avatar
bellard committed
27
#include "slirp.h"
28
#include "hw/hw.h"
bellard's avatar
bellard committed
29 30 31

/* host loopback address */
struct in_addr loopback_addr;
32
/* host loopback network mask */
33
unsigned long loopback_mask;
bellard's avatar
bellard committed
34

35
/* emulated hosts use the MAC addr 52:55:IP:IP:IP:IP */
Fabien Chouteau's avatar
Fabien Chouteau committed
36
static const uint8_t special_ethaddr[ETH_ALEN] = {
37
    0x52, 0x55, 0x00, 0x00, 0x00, 0x00
bellard's avatar
bellard committed
38 39
};

Fabien Chouteau's avatar
Fabien Chouteau committed
40
static const uint8_t zero_ethaddr[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
bellard's avatar
bellard committed
41 42 43 44

/* XXX: suppress those select globals */
fd_set *global_readfds, *global_writefds, *global_xfds;

45 46 47 48
u_int curtime;
static u_int time_fasttimo, last_slowtimo;
static int do_slowtimo;

49 50
static QTAILQ_HEAD(slirp_instances, Slirp) slirp_instances =
    QTAILQ_HEAD_INITIALIZER(slirp_instances);
pbrook's avatar
pbrook committed
51

Stefan Weil's avatar
Stefan Weil committed
52 53
static struct in_addr dns_addr;
static u_int dns_addr_time;
54

bellard's avatar
bellard committed
55 56
#ifdef _WIN32

57
int get_dns_addr(struct in_addr *pdns_addr)
bellard's avatar
bellard committed
58
{
bellard's avatar
bellard committed
59 60 61 62 63
    FIXED_INFO *FixedInfo=NULL;
    ULONG    BufLen;
    DWORD    ret;
    IP_ADDR_STRING *pIPAddr;
    struct in_addr tmp_addr;
64

65 66 67 68 69
    if (dns_addr.s_addr != 0 && (curtime - dns_addr_time) < 1000) {
        *pdns_addr = dns_addr;
        return 0;
    }

bellard's avatar
bellard committed
70 71
    FixedInfo = (FIXED_INFO *)GlobalAlloc(GPTR, sizeof(FIXED_INFO));
    BufLen = sizeof(FIXED_INFO);
72

bellard's avatar
bellard committed
73 74 75 76 77 78 79
    if (ERROR_BUFFER_OVERFLOW == GetNetworkParams(FixedInfo, &BufLen)) {
        if (FixedInfo) {
            GlobalFree(FixedInfo);
            FixedInfo = NULL;
        }
        FixedInfo = GlobalAlloc(GPTR, BufLen);
    }
80

bellard's avatar
bellard committed
81 82 83 84 85 86 87 88
    if ((ret = GetNetworkParams(FixedInfo, &BufLen)) != ERROR_SUCCESS) {
        printf("GetNetworkParams failed. ret = %08x\n", (u_int)ret );
        if (FixedInfo) {
            GlobalFree(FixedInfo);
            FixedInfo = NULL;
        }
        return -1;
    }
89

bellard's avatar
bellard committed
90 91 92
    pIPAddr = &(FixedInfo->DnsServerList);
    inet_aton(pIPAddr->IpAddress.String, &tmp_addr);
    *pdns_addr = tmp_addr;
93 94
    dns_addr = tmp_addr;
    dns_addr_time = curtime;
bellard's avatar
bellard committed
95 96 97 98 99
    if (FixedInfo) {
        GlobalFree(FixedInfo);
        FixedInfo = NULL;
    }
    return 0;
bellard's avatar
bellard committed
100 101
}

102 103 104 105 106
static void winsock_cleanup(void)
{
    WSACleanup();
}

bellard's avatar
bellard committed
107 108
#else

109
static struct stat dns_addr_stat;
110 111

int get_dns_addr(struct in_addr *pdns_addr)
bellard's avatar
bellard committed
112 113
{
    char buff[512];
blueswir1's avatar
blueswir1 committed
114
    char buff2[257];
bellard's avatar
bellard committed
115 116 117
    FILE *f;
    int found = 0;
    struct in_addr tmp_addr;
118

119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
    if (dns_addr.s_addr != 0) {
        struct stat old_stat;
        if ((curtime - dns_addr_time) < 1000) {
            *pdns_addr = dns_addr;
            return 0;
        }
        old_stat = dns_addr_stat;
        if (stat("/etc/resolv.conf", &dns_addr_stat) != 0)
            return -1;
        if ((dns_addr_stat.st_dev == old_stat.st_dev)
            && (dns_addr_stat.st_ino == old_stat.st_ino)
            && (dns_addr_stat.st_size == old_stat.st_size)
            && (dns_addr_stat.st_mtime == old_stat.st_mtime)) {
            *pdns_addr = dns_addr;
            return 0;
        }
    }

bellard's avatar
bellard committed
137 138 139 140
    f = fopen("/etc/resolv.conf", "r");
    if (!f)
        return -1;

141
#ifdef DEBUG
bellard's avatar
bellard committed
142
    lprint("IP address of your DNS(s): ");
143
#endif
bellard's avatar
bellard committed
144 145 146 147 148
    while (fgets(buff, 512, f) != NULL) {
        if (sscanf(buff, "nameserver%*[ \t]%256s", buff2) == 1) {
            if (!inet_aton(buff2, &tmp_addr))
                continue;
            /* If it's the first one, set it to dns_addr */
149
            if (!found) {
bellard's avatar
bellard committed
150
                *pdns_addr = tmp_addr;
151 152 153
                dns_addr = tmp_addr;
                dns_addr_time = curtime;
            }
154
#ifdef DEBUG
bellard's avatar
bellard committed
155 156
            else
                lprint(", ");
157
#endif
bellard's avatar
bellard committed
158
            if (++found > 3) {
159
#ifdef DEBUG
bellard's avatar
bellard committed
160
                lprint("(more)");
161
#endif
bellard's avatar
bellard committed
162
                break;
163 164 165
            }
#ifdef DEBUG
            else
bellard's avatar
bellard committed
166
                lprint("%s", inet_ntoa(tmp_addr));
167
#endif
bellard's avatar
bellard committed
168 169
        }
    }
bellard's avatar
bellard committed
170
    fclose(f);
bellard's avatar
bellard committed
171 172 173 174 175 176 177
    if (!found)
        return -1;
    return 0;
}

#endif

178
static void slirp_init_once(void)
bellard's avatar
bellard committed
179
{
180 181 182
    static int initialized;
#ifdef _WIN32
    WSADATA Data;
bellard's avatar
bellard committed
183 184
#endif

185 186 187 188 189 190 191 192 193 194 195
    if (initialized) {
        return;
    }
    initialized = 1;

#ifdef _WIN32
    WSAStartup(MAKEWORD(2,0), &Data);
    atexit(winsock_cleanup);
#endif

    loopback_addr.s_addr = htonl(INADDR_LOOPBACK);
196
    loopback_mask = htonl(IN_CLASSA_NET);
197 198
}

199 200 201
static void slirp_state_save(QEMUFile *f, void *opaque);
static int slirp_state_load(QEMUFile *f, void *opaque, int version_id);

202 203 204 205
Slirp *slirp_init(int restricted, struct in_addr vnetwork,
                  struct in_addr vnetmask, struct in_addr vhost,
                  const char *vhostname, const char *tftp_path,
                  const char *bootfile, struct in_addr vdhcp_start,
206 207
                  struct in_addr vnameserver, const char **vdnssearch,
                  void *opaque)
bellard's avatar
bellard committed
208
{
209
    Slirp *slirp = g_malloc0(sizeof(Slirp));
210

211
    slirp_init_once();
bellard's avatar
bellard committed
212

213
    slirp->restricted = restricted;
bellard's avatar
bellard committed
214

215 216
    if_init(slirp);
    ip_init(slirp);
bellard's avatar
bellard committed
217 218

    /* Initialise mbufs *after* setting the MTU */
219
    m_init(slirp);
bellard's avatar
bellard committed
220

221 222 223
    slirp->vnetwork_addr = vnetwork;
    slirp->vnetwork_mask = vnetmask;
    slirp->vhost_addr = vhost;
224
    if (vhostname) {
225 226
        pstrcpy(slirp->client_hostname, sizeof(slirp->client_hostname),
                vhostname);
227
    }
228
    if (tftp_path) {
229
        slirp->tftp_prefix = g_strdup(tftp_path);
230 231
    }
    if (bootfile) {
232
        slirp->bootp_filename = g_strdup(bootfile);
233
    }
234 235
    slirp->vdhcp_startaddr = vdhcp_start;
    slirp->vnameserver_addr = vnameserver;
236

237 238 239 240
    if (vdnssearch) {
        translate_dnssearch(slirp, vdnssearch);
    }

241 242
    slirp->opaque = opaque;

243 244
    register_savevm(NULL, "slirp", 0, 3,
                    slirp_state_save, slirp_state_load, slirp);
245

246
    QTAILQ_INSERT_TAIL(&slirp_instances, slirp, entry);
247

248
    return slirp;
bellard's avatar
bellard committed
249 250
}

251 252
void slirp_cleanup(Slirp *slirp)
{
253
    QTAILQ_REMOVE(&slirp_instances, slirp, entry);
254

255
    unregister_savevm(NULL, "slirp", slirp);
256

257 258 259
    ip_cleanup(slirp);
    m_cleanup(slirp);

260
    g_free(slirp->vdnssearch);
261 262 263
    g_free(slirp->tftp_prefix);
    g_free(slirp->bootp_filename);
    g_free(slirp);
264 265
}

bellard's avatar
bellard committed
266 267 268 269
#define CONN_CANFSEND(so) (((so)->so_state & (SS_FCANTSENDMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
#define CONN_CANFRCV(so) (((so)->so_state & (SS_FCANTRCVMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
#define UPD_NFDS(x) if (nfds < (x)) nfds = (x)

270 271 272 273 274 275 276
void slirp_update_timeout(uint32_t *timeout)
{
    if (!QTAILQ_EMPTY(&slirp_instances)) {
        *timeout = MIN(1000, *timeout);
    }
}

277
void slirp_select_fill(int *pnfds,
bellard's avatar
bellard committed
278 279
                       fd_set *readfds, fd_set *writefds, fd_set *xfds)
{
280
    Slirp *slirp;
bellard's avatar
bellard committed
281 282 283
    struct socket *so, *so_next;
    int nfds;

284
    if (QTAILQ_EMPTY(&slirp_instances)) {
Jan Kiszka's avatar
Jan Kiszka committed
285 286 287
        return;
    }

bellard's avatar
bellard committed
288 289 290 291
    /* fail safe */
    global_readfds = NULL;
    global_writefds = NULL;
    global_xfds = NULL;
292

bellard's avatar
bellard committed
293 294 295 296 297
    nfds = *pnfds;
	/*
	 * First, TCP sockets
	 */
	do_slowtimo = 0;
Jan Kiszka's avatar
Jan Kiszka committed
298

299
	QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
300
		/*
bellard's avatar
bellard committed
301 302 303
		 * *_slowtimo needs calling if there are IP fragments
		 * in the fragment queue, or there are TCP connections active
		 */
304
		do_slowtimo |= ((slirp->tcb.so_next != &slirp->tcb) ||
305
		    (&slirp->ipq.ip_link != slirp->ipq.ip_link.next));
306

307 308
		for (so = slirp->tcb.so_next; so != &slirp->tcb;
		     so = so_next) {
bellard's avatar
bellard committed
309
			so_next = so->so_next;
310

bellard's avatar
bellard committed
311 312 313 314 315
			/*
			 * See if we need a tcp_fasttimo
			 */
			if (time_fasttimo == 0 && so->so_tcpcb->t_flags & TF_DELACK)
			   time_fasttimo = curtime; /* Flag when we want a fasttimo */
316

bellard's avatar
bellard committed
317 318 319 320 321 322
			/*
			 * NOFDREF can include still connecting to local-host,
			 * newly socreated() sockets etc. Don't want to select these.
	 		 */
			if (so->so_state & SS_NOFDREF || so->s == -1)
			   continue;
323

bellard's avatar
bellard committed
324 325 326 327 328 329 330 331
			/*
			 * Set for reading sockets which are accepting
			 */
			if (so->so_state & SS_FACCEPTCONN) {
                                FD_SET(so->s, readfds);
				UPD_NFDS(so->s);
				continue;
			}
332

bellard's avatar
bellard committed
333 334 335 336 337 338 339 340
			/*
			 * Set for writing sockets which are connecting
			 */
			if (so->so_state & SS_ISFCONNECTING) {
				FD_SET(so->s, writefds);
				UPD_NFDS(so->s);
				continue;
			}
341

bellard's avatar
bellard committed
342 343 344 345 346 347 348 349
			/*
			 * Set for writing if we are connected, can send more, and
			 * we have something to send
			 */
			if (CONN_CANFSEND(so) && so->so_rcv.sb_cc) {
				FD_SET(so->s, writefds);
				UPD_NFDS(so->s);
			}
350

bellard's avatar
bellard committed
351 352 353 354 355 356 357 358 359 360
			/*
			 * Set for reading (and urgent data) if we are connected, can
			 * receive more, and we have room for it XXX /2 ?
			 */
			if (CONN_CANFRCV(so) && (so->so_snd.sb_cc < (so->so_snd.sb_datalen/2))) {
				FD_SET(so->s, readfds);
				FD_SET(so->s, xfds);
				UPD_NFDS(so->s);
			}
		}
361

bellard's avatar
bellard committed
362 363 364
		/*
		 * UDP sockets
		 */
365 366
		for (so = slirp->udb.so_next; so != &slirp->udb;
		     so = so_next) {
bellard's avatar
bellard committed
367
			so_next = so->so_next;
368

bellard's avatar
bellard committed
369 370 371 372 373 374 375 376 377 378
			/*
			 * See if it's timed out
			 */
			if (so->so_expire) {
				if (so->so_expire <= curtime) {
					udp_detach(so);
					continue;
				} else
					do_slowtimo = 1; /* Let socket expire */
			}
379

bellard's avatar
bellard committed
380 381 382 383 384 385 386 387 388 389 390 391 392 393 394
			/*
			 * When UDP packets are received from over the
			 * link, they're sendto()'d straight away, so
			 * no need for setting for writing
			 * Limit the number of packets queued by this session
			 * to 4.  Note that even though we try and limit this
			 * to 4 packets, the session could have more queued
			 * if the packets needed to be fragmented
			 * (XXX <= 4 ?)
			 */
			if ((so->so_state & SS_ISFCONNECTED) && so->so_queued <= 4) {
				FD_SET(so->s, readfds);
				UPD_NFDS(so->s);
			}
		}
395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419

                /*
                 * ICMP sockets
                 */
                for (so = slirp->icmp.so_next; so != &slirp->icmp;
                     so = so_next) {
                    so_next = so->so_next;

                    /*
                     * See if it's timed out
                     */
                    if (so->so_expire) {
                        if (so->so_expire <= curtime) {
                            icmp_detach(so);
                            continue;
                        } else {
                            do_slowtimo = 1; /* Let socket expire */
                        }
                    }

                    if (so->so_state & SS_ISFCONNECTED) {
                        FD_SET(so->s, readfds);
                        UPD_NFDS(so->s);
                    }
                }
420
	}
421

bellard's avatar
bellard committed
422
        *pnfds = nfds;
423
}
bellard's avatar
bellard committed
424

Jan Kiszka's avatar
Jan Kiszka committed
425 426
void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds,
                       int select_error)
bellard's avatar
bellard committed
427
{
428
    Slirp *slirp;
bellard's avatar
bellard committed
429 430 431
    struct socket *so, *so_next;
    int ret;

432
    if (QTAILQ_EMPTY(&slirp_instances)) {
Jan Kiszka's avatar
Jan Kiszka committed
433 434 435
        return;
    }

bellard's avatar
bellard committed
436 437 438 439
    global_readfds = readfds;
    global_writefds = writefds;
    global_xfds = xfds;

440
    curtime = qemu_get_clock_ms(rt_clock);
441

442
    QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
bellard's avatar
bellard committed
443
	/*
444
	 * See if anything has timed out
bellard's avatar
bellard committed
445
	 */
bellard's avatar
bellard committed
446
		if (time_fasttimo && ((curtime - time_fasttimo) >= 2)) {
447
			tcp_fasttimo(slirp);
bellard's avatar
bellard committed
448 449 450
			time_fasttimo = 0;
		}
		if (do_slowtimo && ((curtime - last_slowtimo) >= 499)) {
451 452
			ip_slowtimo(slirp);
			tcp_slowtimo(slirp);
bellard's avatar
bellard committed
453 454
			last_slowtimo = curtime;
		}
455

bellard's avatar
bellard committed
456 457 458
	/*
	 * Check sockets
	 */
Jan Kiszka's avatar
Jan Kiszka committed
459
	if (!select_error) {
bellard's avatar
bellard committed
460 461 462
		/*
		 * Check TCP sockets
		 */
463 464
		for (so = slirp->tcb.so_next; so != &slirp->tcb;
		     so = so_next) {
bellard's avatar
bellard committed
465
			so_next = so->so_next;
466

bellard's avatar
bellard committed
467 468 469 470 471 472
			/*
			 * FD_ISSET is meaningless on these sockets
			 * (and they can crash the program)
			 */
			if (so->so_state & SS_NOFDREF || so->s == -1)
			   continue;
473

bellard's avatar
bellard committed
474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492
			/*
			 * Check for URG data
			 * This will soread as well, so no need to
			 * test for readfds below if this succeeds
			 */
			if (FD_ISSET(so->s, xfds))
			   sorecvoob(so);
			/*
			 * Check sockets for reading
			 */
			else if (FD_ISSET(so->s, readfds)) {
				/*
				 * Check for incoming connections
				 */
				if (so->so_state & SS_FACCEPTCONN) {
					tcp_connect(so);
					continue;
				} /* else */
				ret = soread(so);
493

bellard's avatar
bellard committed
494 495 496 497
				/* Output it if we read something */
				if (ret > 0)
				   tcp_output(sototcpcb(so));
			}
498

bellard's avatar
bellard committed
499 500 501 502 503 504 505 506 507 508
			/*
			 * Check sockets for writing
			 */
			if (FD_ISSET(so->s, writefds)) {
			  /*
			   * Check for non-blocking, still-connecting sockets
			   */
			  if (so->so_state & SS_ISFCONNECTING) {
			    /* Connected */
			    so->so_state &= ~SS_ISFCONNECTING;
509

510
			    ret = send(so->s, (const void *) &ret, 0, 0);
bellard's avatar
bellard committed
511 512 513 514 515
			    if (ret < 0) {
			      /* XXXXX Must fix, zero bytes is a NOP */
			      if (errno == EAGAIN || errno == EWOULDBLOCK ||
				  errno == EINPROGRESS || errno == ENOTCONN)
				continue;
516

bellard's avatar
bellard committed
517
			      /* else failed */
518 519
			      so->so_state &= SS_PERSISTENT_MASK;
			      so->so_state |= SS_NOFDREF;
bellard's avatar
bellard committed
520 521
			    }
			    /* else so->so_state &= ~SS_ISFCONNECTING; */
522

bellard's avatar
bellard committed
523 524 525 526 527 528 529 530
			    /*
			     * Continue tcp_input
			     */
			    tcp_input((struct mbuf *)NULL, sizeof(struct ip), so);
			    /* continue; */
			  } else
			    ret = sowrite(so);
			  /*
531
			   * XXXXX If we wrote something (a lot), there
bellard's avatar
bellard committed
532 533 534 535 536
			   * could be a need for a window update.
			   * In the worst case, the remote will send
			   * a window probe to get things going again
			   */
			}
537

bellard's avatar
bellard committed
538 539 540 541 542 543
			/*
			 * Probe a still-connecting, non-blocking socket
			 * to check if it's still alive
	 	 	 */
#ifdef PROBE_CONN
			if (so->so_state & SS_ISFCONNECTING) {
Blue Swirl's avatar
Blue Swirl committed
544
                          ret = qemu_recv(so->s, &ret, 0,0);
545

bellard's avatar
bellard committed
546 547 548 549 550
			  if (ret < 0) {
			    /* XXX */
			    if (errno == EAGAIN || errno == EWOULDBLOCK ||
				errno == EINPROGRESS || errno == ENOTCONN)
			      continue; /* Still connecting, continue */
551

bellard's avatar
bellard committed
552
			    /* else failed */
553 554
			    so->so_state &= SS_PERSISTENT_MASK;
			    so->so_state |= SS_NOFDREF;
555

bellard's avatar
bellard committed
556 557
			    /* tcp_input will take care of it */
			  } else {
bellard's avatar
bellard committed
558
			    ret = send(so->s, &ret, 0,0);
bellard's avatar
bellard committed
559 560 561 562 563 564
			    if (ret < 0) {
			      /* XXX */
			      if (errno == EAGAIN || errno == EWOULDBLOCK ||
				  errno == EINPROGRESS || errno == ENOTCONN)
				continue;
			      /* else failed */
565 566
			      so->so_state &= SS_PERSISTENT_MASK;
			      so->so_state |= SS_NOFDREF;
bellard's avatar
bellard committed
567 568
			    } else
			      so->so_state &= ~SS_ISFCONNECTING;
569

bellard's avatar
bellard committed
570 571 572 573 574
			  }
			  tcp_input((struct mbuf *)NULL, sizeof(struct ip),so);
			} /* SS_ISFCONNECTING */
#endif
		}
575

bellard's avatar
bellard committed
576 577 578 579 580
		/*
		 * Now UDP sockets.
		 * Incoming packets are sent straight away, they're not buffered.
		 * Incoming UDP data isn't buffered either.
		 */
581 582
		for (so = slirp->udb.so_next; so != &slirp->udb;
		     so = so_next) {
bellard's avatar
bellard committed
583
			so_next = so->so_next;
584

bellard's avatar
bellard committed
585 586 587 588
			if (so->s != -1 && FD_ISSET(so->s, readfds)) {
                            sorecvfrom(so);
                        }
		}
589 590 591 592 593 594 595 596 597 598 599 600

                /*
                 * Check incoming ICMP relies.
                 */
                for (so = slirp->icmp.so_next; so != &slirp->icmp;
                     so = so_next) {
                     so_next = so->so_next;

                    if (so->s != -1 && FD_ISSET(so->s, readfds)) {
                        icmp_receive(so);
                    }
                }
bellard's avatar
bellard committed
601
	}
602

603
        if_start(slirp);
604
    }
bellard's avatar
bellard committed
605 606 607 608 609 610 611 612 613

	/* clear global file descriptor sets.
	 * these reside on the stack in vl.c
	 * so they're unusable if we're not in
	 * slirp_select_fill or slirp_select_poll.
	 */
	 global_readfds = NULL;
	 global_writefds = NULL;
	 global_xfds = NULL;
bellard's avatar
bellard committed
614 615
}

616
static void arp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
bellard's avatar
bellard committed
617 618
{
    struct arphdr *ah = (struct arphdr *)(pkt + ETH_HLEN);
619
    uint8_t arp_reply[max(ETH_HLEN + sizeof(struct arphdr), 64)];
bellard's avatar
bellard committed
620 621 622
    struct ethhdr *reh = (struct ethhdr *)arp_reply;
    struct arphdr *rah = (struct arphdr *)(arp_reply + ETH_HLEN);
    int ar_op;
bellard's avatar
bellard committed
623
    struct ex_list *ex_ptr;
bellard's avatar
bellard committed
624 625 626 627

    ar_op = ntohs(ah->ar_op);
    switch(ar_op) {
    case ARPOP_REQUEST:
Fabien Chouteau's avatar
Fabien Chouteau committed
628 629 630 631 632 633
        if (ah->ar_tip == ah->ar_sip) {
            /* Gratuitous ARP */
            arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
            return;
        }

634 635 636 637
        if ((ah->ar_tip & slirp->vnetwork_mask.s_addr) ==
            slirp->vnetwork_addr.s_addr) {
            if (ah->ar_tip == slirp->vnameserver_addr.s_addr ||
                ah->ar_tip == slirp->vhost_addr.s_addr)
bellard's avatar
bellard committed
638
                goto arp_ok;
639
            for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
640
                if (ex_ptr->ex_addr.s_addr == ah->ar_tip)
bellard's avatar
bellard committed
641 642 643 644
                    goto arp_ok;
            }
            return;
        arp_ok:
645
            memset(arp_reply, 0, sizeof(arp_reply));
Fabien Chouteau's avatar
Fabien Chouteau committed
646 647

            arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
bellard's avatar
bellard committed
648 649 650

            /* ARP request for alias/dns mac address */
            memcpy(reh->h_dest, pkt + ETH_ALEN, ETH_ALEN);
651 652
            memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4);
            memcpy(&reh->h_source[2], &ah->ar_tip, 4);
bellard's avatar
bellard committed
653 654 655 656 657 658 659 660
            reh->h_proto = htons(ETH_P_ARP);

            rah->ar_hrd = htons(1);
            rah->ar_pro = htons(ETH_P_IP);
            rah->ar_hln = ETH_ALEN;
            rah->ar_pln = 4;
            rah->ar_op = htons(ARPOP_REPLY);
            memcpy(rah->ar_sha, reh->h_source, ETH_ALEN);
661
            rah->ar_sip = ah->ar_tip;
bellard's avatar
bellard committed
662
            memcpy(rah->ar_tha, ah->ar_sha, ETH_ALEN);
663
            rah->ar_tip = ah->ar_sip;
664
            slirp_output(slirp->opaque, arp_reply, sizeof(arp_reply));
bellard's avatar
bellard committed
665 666
        }
        break;
667
    case ARPOP_REPLY:
Fabien Chouteau's avatar
Fabien Chouteau committed
668
        arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
669
        break;
bellard's avatar
bellard committed
670 671 672 673 674
    default:
        break;
    }
}

675
void slirp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
bellard's avatar
bellard committed
676 677 678 679 680 681
{
    struct mbuf *m;
    int proto;

    if (pkt_len < ETH_HLEN)
        return;
682

bellard's avatar
bellard committed
683 684 685
    proto = ntohs(*(uint16_t *)(pkt + 12));
    switch(proto) {
    case ETH_P_ARP:
686
        arp_input(slirp, pkt, pkt_len);
bellard's avatar
bellard committed
687 688
        break;
    case ETH_P_IP:
689
        m = m_get(slirp);
bellard's avatar
bellard committed
690 691
        if (!m)
            return;
bellard's avatar
bellard committed
692
        /* Note: we add to align the IP header */
aurel32's avatar
aurel32 committed
693 694 695
        if (M_FREEROOM(m) < pkt_len + 2) {
            m_inc(m, pkt_len + 2);
        }
bellard's avatar
bellard committed
696 697
        m->m_len = pkt_len + 2;
        memcpy(m->m_data + 2, pkt, pkt_len);
bellard's avatar
bellard committed
698

bellard's avatar
bellard committed
699 700
        m->m_data += 2 + ETH_HLEN;
        m->m_len -= 2 + ETH_HLEN;
bellard's avatar
bellard committed
701 702 703 704 705 706 707 708

        ip_input(m);
        break;
    default:
        break;
    }
}

Fabien Chouteau's avatar
Fabien Chouteau committed
709 710 711 712
/* Output the IP packet to the ethernet device. Returns 0 if the packet must be
 * re-queued.
 */
int if_encap(Slirp *slirp, struct mbuf *ifm)
bellard's avatar
bellard committed
713 714 715
{
    uint8_t buf[1600];
    struct ethhdr *eh = (struct ethhdr *)buf;
Fabien Chouteau's avatar
Fabien Chouteau committed
716
    uint8_t ethaddr[ETH_ALEN];
Fabien Chouteau's avatar
Fabien Chouteau committed
717
    const struct ip *iph = (const struct ip *)ifm->m_data;
bellard's avatar
bellard committed
718

Fabien Chouteau's avatar
Fabien Chouteau committed
719 720 721
    if (ifm->m_len + ETH_HLEN > sizeof(buf)) {
        return 1;
    }
Fabien Chouteau's avatar
Fabien Chouteau committed
722 723

    if (!arp_table_search(slirp, iph->ip_dst.s_addr, ethaddr)) {
724 725 726 727
        uint8_t arp_req[ETH_HLEN + sizeof(struct arphdr)];
        struct ethhdr *reh = (struct ethhdr *)arp_req;
        struct arphdr *rah = (struct arphdr *)(arp_req + ETH_HLEN);

Fabien Chouteau's avatar
Fabien Chouteau committed
728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754
        if (!ifm->arp_requested) {
            /* If the client addr is not known, send an ARP request */
            memset(reh->h_dest, 0xff, ETH_ALEN);
            memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4);
            memcpy(&reh->h_source[2], &slirp->vhost_addr, 4);
            reh->h_proto = htons(ETH_P_ARP);
            rah->ar_hrd = htons(1);
            rah->ar_pro = htons(ETH_P_IP);
            rah->ar_hln = ETH_ALEN;
            rah->ar_pln = 4;
            rah->ar_op = htons(ARPOP_REQUEST);

            /* source hw addr */
            memcpy(rah->ar_sha, special_ethaddr, ETH_ALEN - 4);
            memcpy(&rah->ar_sha[2], &slirp->vhost_addr, 4);

            /* source IP */
            rah->ar_sip = slirp->vhost_addr.s_addr;

            /* target hw addr (none) */
            memset(rah->ar_tha, 0, ETH_ALEN);

            /* target IP */
            rah->ar_tip = iph->ip_dst.s_addr;
            slirp->client_ipaddr = iph->ip_dst;
            slirp_output(slirp->opaque, arp_req, sizeof(arp_req));
            ifm->arp_requested = true;
755 756 757

            /* Expire request and drop outgoing packet after 1 second */
            ifm->expiration_date = qemu_get_clock_ns(rt_clock) + 1000000000ULL;
Fabien Chouteau's avatar
Fabien Chouteau committed
758 759
        }
        return 0;
760
    } else {
Fabien Chouteau's avatar
Fabien Chouteau committed
761
        memcpy(eh->h_dest, ethaddr, ETH_ALEN);
762
        memcpy(eh->h_source, special_ethaddr, ETH_ALEN - 4);
763
        /* XXX: not correct */
764
        memcpy(&eh->h_source[2], &slirp->vhost_addr, 4);
765
        eh->h_proto = htons(ETH_P_IP);
Fabien Chouteau's avatar
Fabien Chouteau committed
766 767 768
        memcpy(buf + sizeof(struct ethhdr), ifm->m_data, ifm->m_len);
        slirp_output(slirp->opaque, buf, ifm->m_len + ETH_HLEN);
        return 1;
769
    }
bellard's avatar
bellard committed
770
}
bellard's avatar
bellard committed
771

772
/* Drop host forwarding rule, return 0 if found. */
773 774
int slirp_remove_hostfwd(Slirp *slirp, int is_udp, struct in_addr host_addr,
                         int host_port)
775 776
{
    struct socket *so;
777
    struct socket *head = (is_udp ? &slirp->udb : &slirp->tcb);
778 779 780
    struct sockaddr_in addr;
    int port = htons(host_port);
    socklen_t addr_len;
781 782

    for (so = head->so_next; so != head; so = so->so_next) {
783
        addr_len = sizeof(addr);
784 785
        if ((so->so_state & SS_HOSTFWD) &&
            getsockname(so->s, (struct sockaddr *)&addr, &addr_len) == 0 &&
786
            addr.sin_addr.s_addr == host_addr.s_addr &&
787
            addr.sin_port == port) {
788 789
            close(so->s);
            sofree(so);
790
            return 0;
791 792 793
        }
    }

794
    return -1;
795 796
}

797 798
int slirp_add_hostfwd(Slirp *slirp, int is_udp, struct in_addr host_addr,
                      int host_port, struct in_addr guest_addr, int guest_port)
bellard's avatar
bellard committed
799
{
800
    if (!guest_addr.s_addr) {
801
        guest_addr = slirp->vdhcp_startaddr;
802
    }
bellard's avatar
bellard committed
803
    if (is_udp) {
804 805
        if (!udp_listen(slirp, host_addr.s_addr, htons(host_port),
                        guest_addr.s_addr, htons(guest_port), SS_HOSTFWD))
bellard's avatar
bellard committed
806 807
            return -1;
    } else {
808 809
        if (!tcp_listen(slirp, host_addr.s_addr, htons(host_port),
                        guest_addr.s_addr, htons(guest_port), SS_HOSTFWD))
bellard's avatar
bellard committed
810 811 812 813
            return -1;
    }
    return 0;
}
bellard's avatar
bellard committed
814

815
int slirp_add_exec(Slirp *slirp, int do_pty, const void *args,
816
                   struct in_addr *guest_addr, int guest_port)
bellard's avatar
bellard committed
817
{
818 819
    if (!guest_addr->s_addr) {
        guest_addr->s_addr = slirp->vnetwork_addr.s_addr |
820
            (htonl(0x0204) & ~slirp->vnetwork_mask.s_addr);
821
    }
822
    if ((guest_addr->s_addr & slirp->vnetwork_mask.s_addr) !=
823
        slirp->vnetwork_addr.s_addr ||
824 825
        guest_addr->s_addr == slirp->vhost_addr.s_addr ||
        guest_addr->s_addr == slirp->vnameserver_addr.s_addr) {
826 827
        return -1;
    }
828
    return add_exec(&slirp->exec_list, do_pty, (char *)args, *guest_addr,
829
                    htons(guest_port));
bellard's avatar
bellard committed
830
}
831 832 833 834

ssize_t slirp_send(struct socket *so, const void *buf, size_t len, int flags)
{
	if (so->s == -1 && so->extra) {
835
		qemu_chr_fe_write(so->extra, buf, len);
836 837 838 839 840 841
		return len;
	}

	return send(so->s, buf, len, flags);
}

842
static struct socket *
843
slirp_find_ctl_socket(Slirp *slirp, struct in_addr guest_addr, int guest_port)
844
{
845
    struct socket *so;
846

847
    for (so = slirp->tcb.so_next; so != &slirp->tcb; so = so->so_next) {
848 849 850 851 852 853
        if (so->so_faddr.s_addr == guest_addr.s_addr &&
            htons(so->so_fport) == guest_port) {
            return so;
        }
    }
    return NULL;
854 855
}

856 857
size_t slirp_socket_can_recv(Slirp *slirp, struct in_addr guest_addr,
                             int guest_port)
858 859 860 861
{
	struct iovec iov[2];
	struct socket *so;

862
	so = slirp_find_ctl_socket(slirp, guest_addr, guest_port);
863 864 865 866 867 868 869 870 871 872

	if (!so || so->so_state & SS_NOFDREF)
		return 0;

	if (!CONN_CANFRCV(so) || so->so_snd.sb_cc >= (so->so_snd.sb_datalen/2))
		return 0;

	return sopreprbuf(so, iov, NULL);
}

873
void slirp_socket_recv(Slirp *slirp, struct in_addr guest_addr, int guest_port,
874
                       const uint8_t *buf, int size)
875 876
{
    int ret;
877
    struct socket *so = slirp_find_ctl_socket(slirp, guest_addr, guest_port);
878

879 880 881
    if (!so)
        return;

blueswir1's avatar
blueswir1 committed
882
    ret = soreadbuf(so, (const char *)buf, size);
883 884 885 886

    if (ret > 0)
        tcp_output(sototcpcb(so));
}
887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963

static void slirp_tcp_save(QEMUFile *f, struct tcpcb *tp)
{
    int i;

    qemu_put_sbe16(f, tp->t_state);
    for (i = 0; i < TCPT_NTIMERS; i++)
        qemu_put_sbe16(f, tp->t_timer[i]);
    qemu_put_sbe16(f, tp->t_rxtshift);
    qemu_put_sbe16(f, tp->t_rxtcur);
    qemu_put_sbe16(f, tp->t_dupacks);
    qemu_put_be16(f, tp->t_maxseg);
    qemu_put_sbyte(f, tp->t_force);
    qemu_put_be16(f, tp->t_flags);
    qemu_put_be32(f, tp->snd_una);
    qemu_put_be32(f, tp->snd_nxt);
    qemu_put_be32(f, tp->snd_up);
    qemu_put_be32(f, tp->snd_wl1);
    qemu_put_be32(f, tp->snd_wl2);
    qemu_put_be32(f, tp->iss);
    qemu_put_be32(f, tp->snd_wnd);
    qemu_put_be32(f, tp->rcv_wnd);
    qemu_put_be32(f, tp->rcv_nxt);
    qemu_put_be32(f, tp->rcv_up);
    qemu_put_be32(f, tp->irs);
    qemu_put_be32(f, tp->rcv_adv);
    qemu_put_be32(f, tp->snd_max);
    qemu_put_be32(f, tp->snd_cwnd);
    qemu_put_be32(f, tp->snd_ssthresh);
    qemu_put_sbe16(f, tp->t_idle);
    qemu_put_sbe16(f, tp->t_rtt);
    qemu_put_be32(f, tp->t_rtseq);
    qemu_put_sbe16(f, tp->t_srtt);
    qemu_put_sbe16(f, tp->t_rttvar);
    qemu_put_be16(f, tp->t_rttmin);
    qemu_put_be32(f, tp->max_sndwnd);
    qemu_put_byte(f, tp->t_oobflags);
    qemu_put_byte(f, tp->t_iobc);
    qemu_put_sbe16(f, tp->t_softerror);
    qemu_put_byte(f, tp->snd_scale);
    qemu_put_byte(f, tp->rcv_scale);
    qemu_put_byte(f, tp->request_r_scale);
    qemu_put_byte(f, tp->requested_s_scale);
    qemu_put_be32(f, tp->ts_recent);
    qemu_put_be32(f, tp->ts_recent_age);
    qemu_put_be32(f, tp->last_ack_sent);
}

static void slirp_sbuf_save(QEMUFile *f, struct sbuf *sbuf)
{
    uint32_t off;

    qemu_put_be32(f, sbuf->sb_cc);
    qemu_put_be32(f, sbuf->sb_datalen);
    off = (uint32_t)(sbuf->sb_wptr - sbuf->sb_data);
    qemu_put_sbe32(f, off);
    off = (uint32_t)(sbuf->sb_rptr - sbuf->sb_data);
    qemu_put_sbe32(f, off);
    qemu_put_buffer(f, (unsigned char*)sbuf->sb_data, sbuf->sb_datalen);
}

static void slirp_socket_save(QEMUFile *f, struct socket *so)
{
    qemu_put_be32(f, so->so_urgc);
    qemu_put_be32(f, so->so_faddr.s_addr);
    qemu_put_be32(f, so->so_laddr.s_addr);
    qemu_put_be16(f, so->so_fport);
    qemu_put_be16(f, so->so_lport);
    qemu_put_byte(f, so->so_iptos);
    qemu_put_byte(f, so->so_emu);
    qemu_put_byte(f, so->so_type);
    qemu_put_be32(f, so->so_state);
    slirp_sbuf_save(f, &so->so_rcv);
    slirp_sbuf_save(f, &so->so_snd);
    slirp_tcp_save(f, so->so_tcpcb);
}

964 965 966 967 968 969 970 971 972 973
static void slirp_bootp_save(QEMUFile *f, Slirp *slirp)
{
    int i;

    for (i = 0; i < NB_BOOTP_CLIENTS; i++) {
        qemu_put_be16(f, slirp->bootp_clients[i].allocated);
        qemu_put_buffer(f, slirp->bootp_clients[i].macaddr, 6);
    }
}

974 975
static void slirp_state_save(QEMUFile *f, void *opaque)
{
976
    Slirp *slirp = opaque;
977 978
    struct ex_list *ex_ptr;

979
    for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next)
980 981
        if (ex_ptr->ex_pty == 3) {
            struct socket *so;
982 983
            so = slirp_find_ctl_socket(slirp, ex_ptr->ex_addr,
                                       ntohs(ex_ptr->ex_fport));
984 985 986 987 988 989 990
            if (!so)
                continue;

            qemu_put_byte(f, 42);
            slirp_socket_save(f, so);
        }
    qemu_put_byte(f, 0);
991

992
    qemu_put_be16(f, slirp->ip_id);
993 994

    slirp_bootp_save(f, slirp);
995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
}

static void slirp_tcp_load(QEMUFile *f, struct tcpcb *tp)
{
    int i;

    tp->t_state = qemu_get_sbe16(f);
    for (i = 0; i < TCPT_NTIMERS; i++)
        tp->t_timer[i] = qemu_get_sbe16(f);
    tp->t_rxtshift = qemu_get_sbe16(f);
    tp->t_rxtcur = qemu_get_sbe16(f);
    tp->t_dupacks = qemu_get_sbe16(f);
    tp->t_maxseg = qemu_get_be16(f);
    tp->t_force = qemu_get_sbyte(f);
    tp->t_flags = qemu_get_be16(f);
    tp->snd_una = qemu_get_be32(f);
    tp->snd_nxt = qemu_get_be32(f);
    tp->snd_up = qemu_get_be32(f);
    tp->snd_wl1 = qemu_get_be32(f);
    tp->snd_wl2 = qemu_get_be32(f);
    tp->iss = qemu_get_be32(f);
    tp->snd_wnd = qemu_get_be32(f);
    tp->rcv_wnd = qemu_get_be32(f);
    tp->rcv_nxt = qemu_get_be32(f);
    tp->rcv_up = qemu_get_be32(f);
    tp->irs = qemu_get_be32(f);
    tp->rcv_adv = qemu_get_be32(f);
    tp->snd_max = qemu_get_be32(f);
    tp->snd_cwnd = qemu_get_be32(f);
    tp->snd_ssthresh = qemu_get_be32(f);
    tp->t_idle = qemu_get_sbe16(f);
    tp->t_rtt = qemu_get_sbe16(f);
    tp->t_rtseq = qemu_get_be32(f);
    tp->t_srtt = qemu_get_sbe16(f);
    tp->t_rttvar = qemu_get_sbe16(f);
    tp->t_rttmin = qemu_get_be16(f);
    tp->max_sndwnd = qemu_get_be32(f);
    tp->t_oobflags = qemu_get_byte(f);
    tp->t_iobc = qemu_get_byte(f);
    tp->t_softerror = qemu_get_sbe16(f);
    tp->snd_scale = qemu_get_byte(f);
    tp->rcv_scale = qemu_get_byte(f);
    tp->request_r_scale = qemu_get_byte(f);
    tp->requested_s_scale = qemu_get_byte(f);
    tp->ts_recent = qemu_get_be32(f);
    tp->ts_recent_age = qemu_get_be32(f);
    tp->last_ack_sent = qemu_get_be32(f);
    tcp_template(tp);
}

static int slirp_sbuf_load(QEMUFile *f, struct sbuf *sbuf)
{
    uint32_t off, sb_cc, sb_datalen;

    sb_cc = qemu_get_be32(f);
    sb_datalen = qemu_get_be32(f);

    sbreserve(sbuf, sb_datalen);

    if (sbuf->sb_datalen != sb_datalen)
        return -ENOMEM;

    sbuf->sb_cc = sb_cc;

    off = qemu_get_sbe32(f);
    sbuf->sb_wptr = sbuf->sb_data + off;
    off = qemu_get_sbe32(f);
    sbuf->sb_rptr = sbuf->sb_data + off;
    qemu_get_buffer(f, (unsigned char*)sbuf->sb_data, sbuf->sb_datalen);

    return 0;
}

static int slirp_socket_load(QEMUFile *f, struct socket *so)
{
    if (tcp_attach(so) < 0)
        return -ENOMEM;

    so->so_urgc = qemu_get_be32(f);
    so->so_faddr.s_addr = qemu_get_be32(f);
    so->so_laddr.s_addr = qemu_get_be32(f);
    so->so_fport = qemu_get_be16(f);
    so->so_lport = qemu_get_be16(f);
    so->so_iptos = qemu_get_byte(f);
    so->so_emu = qemu_get_byte(f);
    so->so_type = qemu_get_byte(f);
    so->so_state = qemu_get_be32(f);
    if (slirp_sbuf_load(f, &so->so_rcv) < 0)
        return -ENOMEM;
    if (slirp_sbuf_load(f, &so->so_snd) < 0)
        return -ENOMEM;
    slirp_tcp_load(f, so->so_tcpcb);

    return 0;
}

1091 1092 1093 1094 1095 1096 1097 1098 1099 1100
static void slirp_bootp_load(QEMUFile *f, Slirp *slirp)
{
    int i;

    for (i = 0; i < NB_BOOTP_CLIENTS; i++) {
        slirp->bootp_clients[i].allocated = qemu_get_be16(f);
        qemu_get_buffer(f, slirp->bootp_clients[i].macaddr, 6);
    }
}

1101 1102
static int slirp_state_load(QEMUFile *f, void *opaque, int version_id)
{
1103
    Slirp *slirp = opaque;
1104 1105
    struct ex_list *ex_ptr;

1106
    while (qemu_get_byte(f)) {
1107
        int ret;
1108
        struct socket *so = socreate(slirp);
1109 1110 1111 1112 1113 1114 1115 1116 1117

        if (!so)
            return -ENOMEM;

        ret = slirp_socket_load(f, so);

        if (ret < 0)
            return ret;

1118 1119
        if ((so->so_faddr.s_addr & slirp->vnetwork_mask.s_addr) !=
            slirp->vnetwork_addr.s_addr) {
1120
            return -EINVAL;
1121
        }
1122
        for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
1123
            if (ex_ptr->ex_pty == 3 &&
1124 1125
                so->so_faddr.s_addr == ex_ptr->ex_addr.s_addr &&
                so->so_fport == ex_ptr->ex_fport) {
1126
                break;
1127 1128
            }
        }
1129 1130 1131
        if (!ex_ptr)
            return -EINVAL;

blueswir1's avatar
blueswir1 committed
1132
        so->extra = (void *)ex_ptr->ex_exec;
1133 1134
    }

1135
    if (version_id >= 2) {
1136
        slirp->ip_id = qemu_get_be16(f);
1137 1138
    }

1139 1140 1141 1142
    if (version_id >= 3) {
        slirp_bootp_load(f, slirp);
    }

1143 1144
    return 0;
}