?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
scsi-disk: Complete failed requests in scsi_disk_emulate_command
[qemu.git] / slirp / slirp.c
blob332d83b64d054750a0f25114a5b81cbed4095d60
1 /*
2 * libslirp glue
3 *
4 * Copyright (c) 2004-2008 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include "qemu-common.h"
25 #include "qemu-timer.h"
26 #include "qemu-char.h"
27 #include "slirp.h"
28 #include "hw/hw.h"
29
30 /* host loopback address */
31 struct in_addr loopback_addr;
32
33 /* emulated hosts use the MAC addr 52:55:IP:IP:IP:IP */
34 static const uint8_t special_ethaddr[6] = {
35 0x52, 0x55, 0x00, 0x00, 0x00, 0x00
36 };
37
38 static const uint8_t zero_ethaddr[6] = { 0, 0, 0, 0, 0, 0 };
39
40 /* XXX: suppress those select globals */
41 fd_set *global_readfds, *global_writefds, *global_xfds;
42
43 u_int curtime;
44 static u_int time_fasttimo, last_slowtimo;
45 static int do_slowtimo;
46
47 static QTAILQ_HEAD(slirp_instances, Slirp) slirp_instances =
48 QTAILQ_HEAD_INITIALIZER(slirp_instances);
49
50 static struct in_addr dns_addr;
51 static u_int dns_addr_time;
52
53 #ifdef _WIN32
54
55 int get_dns_addr(struct in_addr *pdns_addr)
56 {
57 FIXED_INFO *FixedInfo=NULL;
58 ULONG BufLen;
59 DWORD ret;
60 IP_ADDR_STRING *pIPAddr;
61 struct in_addr tmp_addr;
62
63 if (dns_addr.s_addr != 0 && (curtime - dns_addr_time) < 1000) {
64 *pdns_addr = dns_addr;
65 return 0;
66 }
67
68 FixedInfo = (FIXED_INFO *)GlobalAlloc(GPTR, sizeof(FIXED_INFO));
69 BufLen = sizeof(FIXED_INFO);
70
71 if (ERROR_BUFFER_OVERFLOW == GetNetworkParams(FixedInfo, &BufLen)) {
72 if (FixedInfo) {
73 GlobalFree(FixedInfo);
74 FixedInfo = NULL;
75 }
76 FixedInfo = GlobalAlloc(GPTR, BufLen);
77 }
78
79 if ((ret = GetNetworkParams(FixedInfo, &BufLen)) != ERROR_SUCCESS) {
80 printf("GetNetworkParams failed. ret = %08x\n", (u_int)ret );
81 if (FixedInfo) {
82 GlobalFree(FixedInfo);
83 FixedInfo = NULL;
84 }
85 return -1;
86 }
87
88 pIPAddr = &(FixedInfo->DnsServerList);
89 inet_aton(pIPAddr->IpAddress.String, &tmp_addr);
90 *pdns_addr = tmp_addr;
91 dns_addr = tmp_addr;
92 dns_addr_time = curtime;
93 if (FixedInfo) {
94 GlobalFree(FixedInfo);
95 FixedInfo = NULL;
96 }
97 return 0;
98 }
99
100 static void winsock_cleanup(void)
101 {
102 WSACleanup();
103 }
104
105 #else
106
107 static struct stat dns_addr_stat;
108
109 int get_dns_addr(struct in_addr *pdns_addr)
110 {
111 char buff[512];
112 char buff2[257];
113 FILE *f;
114 int found = 0;
115 struct in_addr tmp_addr;
116
117 if (dns_addr.s_addr != 0) {
118 struct stat old_stat;
119 if ((curtime - dns_addr_time) < 1000) {
120 *pdns_addr = dns_addr;
121 return 0;
122 }
123 old_stat = dns_addr_stat;
124 if (stat("/etc/resolv.conf", &dns_addr_stat) != 0)
125 return -1;
126 if ((dns_addr_stat.st_dev == old_stat.st_dev)
127 && (dns_addr_stat.st_ino == old_stat.st_ino)
128 && (dns_addr_stat.st_size == old_stat.st_size)
129 && (dns_addr_stat.st_mtime == old_stat.st_mtime)) {
130 *pdns_addr = dns_addr;
131 return 0;
132 }
133 }
134
135 f = fopen("/etc/resolv.conf", "r");
136 if (!f)
137 return -1;
138
139 #ifdef DEBUG
140 lprint("IP address of your DNS(s): ");
141 #endif
142 while (fgets(buff, 512, f) != NULL) {
143 if (sscanf(buff, "nameserver%*[ \t]%256s", buff2) == 1) {
144 if (!inet_aton(buff2, &tmp_addr))
145 continue;
146 /* If it's the first one, set it to dns_addr */
147 if (!found) {
148 *pdns_addr = tmp_addr;
149 dns_addr = tmp_addr;
150 dns_addr_time = curtime;
151 }
152 #ifdef DEBUG
153 else
154 lprint(", ");
155 #endif
156 if (++found > 3) {
157 #ifdef DEBUG
158 lprint("(more)");
159 #endif
160 break;
161 }
162 #ifdef DEBUG
163 else
164 lprint("%s", inet_ntoa(tmp_addr));
165 #endif
166 }
167 }
168 fclose(f);
169 if (!found)
170 return -1;
171 return 0;
172 }
173
174 #endif
175
176 static void slirp_init_once(void)
177 {
178 static int initialized;
179 #ifdef _WIN32
180 WSADATA Data;
181 #endif
182
183 if (initialized) {
184 return;
185 }
186 initialized = 1;
187
188 #ifdef _WIN32
189 WSAStartup(MAKEWORD(2,0), &Data);
190 atexit(winsock_cleanup);
191 #endif
192
193 loopback_addr.s_addr = htonl(INADDR_LOOPBACK);
194 }
195
196 static void slirp_state_save(QEMUFile *f, void *opaque);
197 static int slirp_state_load(QEMUFile *f, void *opaque, int version_id);
198
199 Slirp *slirp_init(int restricted, struct in_addr vnetwork,
200 struct in_addr vnetmask, struct in_addr vhost,
201 const char *vhostname, const char *tftp_path,
202 const char *bootfile, struct in_addr vdhcp_start,
203 struct in_addr vnameserver, void *opaque)
204 {
205 Slirp *slirp = qemu_mallocz(sizeof(Slirp));
206
207 slirp_init_once();
208
209 slirp->restricted = restricted;
210
211 if_init(slirp);
212 ip_init(slirp);
213
214 /* Initialise mbufs *after* setting the MTU */
215 m_init(slirp);
216
217 slirp->vnetwork_addr = vnetwork;
218 slirp->vnetwork_mask = vnetmask;
219 slirp->vhost_addr = vhost;
220 if (vhostname) {
221 pstrcpy(slirp->client_hostname, sizeof(slirp->client_hostname),
222 vhostname);
223 }
224 if (tftp_path) {
225 slirp->tftp_prefix = qemu_strdup(tftp_path);
226 }
227 if (bootfile) {
228 slirp->bootp_filename = qemu_strdup(bootfile);
229 }
230 slirp->vdhcp_startaddr = vdhcp_start;
231 slirp->vnameserver_addr = vnameserver;
232
233 slirp->opaque = opaque;
234
235 register_savevm(NULL, "slirp", 0, 3,
236 slirp_state_save, slirp_state_load, slirp);
237
238 QTAILQ_INSERT_TAIL(&slirp_instances, slirp, entry);
239
240 return slirp;
241 }
242
243 void slirp_cleanup(Slirp *slirp)
244 {
245 QTAILQ_REMOVE(&slirp_instances, slirp, entry);
246
247 unregister_savevm(NULL, "slirp", slirp);
248
249 qemu_free(slirp->tftp_prefix);
250 qemu_free(slirp->bootp_filename);
251 qemu_free(slirp);
252 }
253
254 #define CONN_CANFSEND(so) (((so)->so_state & (SS_FCANTSENDMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
255 #define CONN_CANFRCV(so) (((so)->so_state & (SS_FCANTRCVMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
256 #define UPD_NFDS(x) if (nfds < (x)) nfds = (x)
257
258 void slirp_select_fill(int *pnfds,
259 fd_set *readfds, fd_set *writefds, fd_set *xfds)
260 {
261 Slirp *slirp;
262 struct socket *so, *so_next;
263 int nfds;
264
265 if (QTAILQ_EMPTY(&slirp_instances)) {
266 return;
267 }
268
269 /* fail safe */
270 global_readfds = NULL;
271 global_writefds = NULL;
272 global_xfds = NULL;
273
274 nfds = *pnfds;
275 /*
276 * First, TCP sockets
277 */
278 do_slowtimo = 0;
279
280 QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
281 /*
282 * *_slowtimo needs calling if there are IP fragments
283 * in the fragment queue, or there are TCP connections active
284 */
285 do_slowtimo |= ((slirp->tcb.so_next != &slirp->tcb) ||
286 (&slirp->ipq.ip_link != slirp->ipq.ip_link.next));
287
288 for (so = slirp->tcb.so_next; so != &slirp->tcb;
289 so = so_next) {
290 so_next = so->so_next;
291
292 /*
293 * See if we need a tcp_fasttimo
294 */
295 if (time_fasttimo == 0 && so->so_tcpcb->t_flags & TF_DELACK)
296 time_fasttimo = curtime; /* Flag when we want a fasttimo */
297
298 /*
299 * NOFDREF can include still connecting to local-host,
300 * newly socreated() sockets etc. Don't want to select these.
301 */
302 if (so->so_state & SS_NOFDREF || so->s == -1)
303 continue;
304
305 /*
306 * Set for reading sockets which are accepting
307 */
308 if (so->so_state & SS_FACCEPTCONN) {
309 FD_SET(so->s, readfds);
310 UPD_NFDS(so->s);
311 continue;
312 }
313
314 /*
315 * Set for writing sockets which are connecting
316 */
317 if (so->so_state & SS_ISFCONNECTING) {
318 FD_SET(so->s, writefds);
319 UPD_NFDS(so->s);
320 continue;
321 }
322
323 /*
324 * Set for writing if we are connected, can send more, and
325 * we have something to send
326 */
327 if (CONN_CANFSEND(so) && so->so_rcv.sb_cc) {
328 FD_SET(so->s, writefds);
329 UPD_NFDS(so->s);
330 }
331
332 /*
333 * Set for reading (and urgent data) if we are connected, can
334 * receive more, and we have room for it XXX /2 ?
335 */
336 if (CONN_CANFRCV(so) && (so->so_snd.sb_cc < (so->so_snd.sb_datalen/2))) {
337 FD_SET(so->s, readfds);
338 FD_SET(so->s, xfds);
339 UPD_NFDS(so->s);
340 }
341 }
342
343 /*
344 * UDP sockets
345 */
346 for (so = slirp->udb.so_next; so != &slirp->udb;
347 so = so_next) {
348 so_next = so->so_next;
349
350 /*
351 * See if it's timed out
352 */
353 if (so->so_expire) {
354 if (so->so_expire <= curtime) {
355 udp_detach(so);
356 continue;
357 } else
358 do_slowtimo = 1; /* Let socket expire */
359 }
360
361 /*
362 * When UDP packets are received from over the
363 * link, they're sendto()'d straight away, so
364 * no need for setting for writing
365 * Limit the number of packets queued by this session
366 * to 4. Note that even though we try and limit this
367 * to 4 packets, the session could have more queued
368 * if the packets needed to be fragmented
369 * (XXX <= 4 ?)
370 */
371 if ((so->so_state & SS_ISFCONNECTED) && so->so_queued <= 4) {
372 FD_SET(so->s, readfds);
373 UPD_NFDS(so->s);
374 }
375 }
376 }
377
378 *pnfds = nfds;
379 }
380
381 void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds,
382 int select_error)
383 {
384 Slirp *slirp;
385 struct socket *so, *so_next;
386 int ret;
387
388 if (QTAILQ_EMPTY(&slirp_instances)) {
389 return;
390 }
391
392 global_readfds = readfds;
393 global_writefds = writefds;
394 global_xfds = xfds;
395
396 curtime = qemu_get_clock(rt_clock);
397
398 QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
399 /*
400 * See if anything has timed out
401 */
402 if (time_fasttimo && ((curtime - time_fasttimo) >= 2)) {
403 tcp_fasttimo(slirp);
404 time_fasttimo = 0;
405 }
406 if (do_slowtimo && ((curtime - last_slowtimo) >= 499)) {
407 ip_slowtimo(slirp);
408 tcp_slowtimo(slirp);
409 last_slowtimo = curtime;
410 }
411
412 /*
413 * Check sockets
414 */
415 if (!select_error) {
416 /*
417 * Check TCP sockets
418 */
419 for (so = slirp->tcb.so_next; so != &slirp->tcb;
420 so = so_next) {
421 so_next = so->so_next;
422
423 /*
424 * FD_ISSET is meaningless on these sockets
425 * (and they can crash the program)
426 */
427 if (so->so_state & SS_NOFDREF || so->s == -1)
428 continue;
429
430 /*
431 * Check for URG data
432 * This will soread as well, so no need to
433 * test for readfds below if this succeeds
434 */
435 if (FD_ISSET(so->s, xfds))
436 sorecvoob(so);
437 /*
438 * Check sockets for reading
439 */
440 else if (FD_ISSET(so->s, readfds)) {
441 /*
442 * Check for incoming connections
443 */
444 if (so->so_state & SS_FACCEPTCONN) {
445 tcp_connect(so);
446 continue;
447 } /* else */
448 ret = soread(so);
449
450 /* Output it if we read something */
451 if (ret > 0)
452 tcp_output(sototcpcb(so));
453 }
454
455 /*
456 * Check sockets for writing
457 */
458 if (FD_ISSET(so->s, writefds)) {
459 /*
460 * Check for non-blocking, still-connecting sockets
461 */
462 if (so->so_state & SS_ISFCONNECTING) {
463 /* Connected */
464 so->so_state &= ~SS_ISFCONNECTING;
465
466 ret = send(so->s, (const void *) &ret, 0, 0);
467 if (ret < 0) {
468 /* XXXXX Must fix, zero bytes is a NOP */
469 if (errno == EAGAIN || errno == EWOULDBLOCK ||
470 errno == EINPROGRESS || errno == ENOTCONN)
471 continue;
472
473 /* else failed */
474 so->so_state &= SS_PERSISTENT_MASK;
475 so->so_state |= SS_NOFDREF;
476 }
477 /* else so->so_state &= ~SS_ISFCONNECTING; */
478
479 /*
480 * Continue tcp_input
481 */
482 tcp_input((struct mbuf *)NULL, sizeof(struct ip), so);
483 /* continue; */
484 } else
485 ret = sowrite(so);
486 /*
487 * XXXXX If we wrote something (a lot), there
488 * could be a need for a window update.
489 * In the worst case, the remote will send
490 * a window probe to get things going again
491 */
492 }
493
494 /*
495 * Probe a still-connecting, non-blocking socket
496 * to check if it's still alive
497 */
498 #ifdef PROBE_CONN
499 if (so->so_state & SS_ISFCONNECTING) {
500 ret = recv(so->s, (char *)&ret, 0,0);
501
502 if (ret < 0) {
503 /* XXX */
504 if (errno == EAGAIN || errno == EWOULDBLOCK ||
505 errno == EINPROGRESS || errno == ENOTCONN)
506 continue; /* Still connecting, continue */
507
508 /* else failed */
509 so->so_state &= SS_PERSISTENT_MASK;
510 so->so_state |= SS_NOFDREF;
511
512 /* tcp_input will take care of it */
513 } else {
514 ret = send(so->s, &ret, 0,0);
515 if (ret < 0) {
516 /* XXX */
517 if (errno == EAGAIN || errno == EWOULDBLOCK ||
518 errno == EINPROGRESS || errno == ENOTCONN)
519 continue;
520 /* else failed */
521 so->so_state &= SS_PERSISTENT_MASK;
522 so->so_state |= SS_NOFDREF;
523 } else
524 so->so_state &= ~SS_ISFCONNECTING;
525
526 }
527 tcp_input((struct mbuf *)NULL, sizeof(struct ip),so);
528 } /* SS_ISFCONNECTING */
529 #endif
530 }
531
532 /*
533 * Now UDP sockets.
534 * Incoming packets are sent straight away, they're not buffered.
535 * Incoming UDP data isn't buffered either.
536 */
537 for (so = slirp->udb.so_next; so != &slirp->udb;
538 so = so_next) {
539 so_next = so->so_next;
540
541 if (so->s != -1 && FD_ISSET(so->s, readfds)) {
542 sorecvfrom(so);
543 }
544 }
545 }
546
547 /*
548 * See if we can start outputting
549 */
550 if (slirp->if_queued) {
551 if_start(slirp);
552 }
553 }
554
555 /* clear global file descriptor sets.
556 * these reside on the stack in vl.c
557 * so they're unusable if we're not in
558 * slirp_select_fill or slirp_select_poll.
559 */
560 global_readfds = NULL;
561 global_writefds = NULL;
562 global_xfds = NULL;
563 }
564
565 #define ETH_ALEN 6
566 #define ETH_HLEN 14
567
568 #define ETH_P_IP 0x0800 /* Internet Protocol packet */
569 #define ETH_P_ARP 0x0806 /* Address Resolution packet */
570
571 #define ARPOP_REQUEST 1 /* ARP request */
572 #define ARPOP_REPLY 2 /* ARP reply */
573
574 struct ethhdr
575 {
576 unsigned char h_dest[ETH_ALEN]; /* destination eth addr */
577 unsigned char h_source[ETH_ALEN]; /* source ether addr */
578 unsigned short h_proto; /* packet type ID field */
579 };
580
581 struct arphdr
582 {
583 unsigned short ar_hrd; /* format of hardware address */
584 unsigned short ar_pro; /* format of protocol address */
585 unsigned char ar_hln; /* length of hardware address */
586 unsigned char ar_pln; /* length of protocol address */
587 unsigned short ar_op; /* ARP opcode (command) */
588
589 /*
590 * Ethernet looks like this : This bit is variable sized however...
591 */
592 unsigned char ar_sha[ETH_ALEN]; /* sender hardware address */
593 uint32_t ar_sip; /* sender IP address */
594 unsigned char ar_tha[ETH_ALEN]; /* target hardware address */
595 uint32_t ar_tip ; /* target IP address */
596 } __attribute__((packed));
597
598 static void arp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
599 {
600 struct ethhdr *eh = (struct ethhdr *)pkt;
601 struct arphdr *ah = (struct arphdr *)(pkt + ETH_HLEN);
602 uint8_t arp_reply[max(ETH_HLEN + sizeof(struct arphdr), 64)];
603 struct ethhdr *reh = (struct ethhdr *)arp_reply;
604 struct arphdr *rah = (struct arphdr *)(arp_reply + ETH_HLEN);
605 int ar_op;
606 struct ex_list *ex_ptr;
607
608 ar_op = ntohs(ah->ar_op);
609 switch(ar_op) {
610 case ARPOP_REQUEST:
611 if ((ah->ar_tip & slirp->vnetwork_mask.s_addr) ==
612 slirp->vnetwork_addr.s_addr) {
613 if (ah->ar_tip == slirp->vnameserver_addr.s_addr ||
614 ah->ar_tip == slirp->vhost_addr.s_addr)
615 goto arp_ok;
616 for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
617 if (ex_ptr->ex_addr.s_addr == ah->ar_tip)
618 goto arp_ok;
619 }
620 return;
621 arp_ok:
622 memset(arp_reply, 0, sizeof(arp_reply));
623 /* XXX: make an ARP request to have the client address */
624 memcpy(slirp->client_ethaddr, eh->h_source, ETH_ALEN);
625
626 /* ARP request for alias/dns mac address */
627 memcpy(reh->h_dest, pkt + ETH_ALEN, ETH_ALEN);
628 memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4);
629 memcpy(&reh->h_source[2], &ah->ar_tip, 4);
630 reh->h_proto = htons(ETH_P_ARP);
631
632 rah->ar_hrd = htons(1);
633 rah->ar_pro = htons(ETH_P_IP);
634 rah->ar_hln = ETH_ALEN;
635 rah->ar_pln = 4;
636 rah->ar_op = htons(ARPOP_REPLY);
637 memcpy(rah->ar_sha, reh->h_source, ETH_ALEN);
638 rah->ar_sip = ah->ar_tip;
639 memcpy(rah->ar_tha, ah->ar_sha, ETH_ALEN);
640 rah->ar_tip = ah->ar_sip;
641 slirp_output(slirp->opaque, arp_reply, sizeof(arp_reply));
642 }
643 break;
644 case ARPOP_REPLY:
645 /* reply to request of client mac address ? */
646 if (!memcmp(slirp->client_ethaddr, zero_ethaddr, ETH_ALEN) &&
647 ah->ar_sip == slirp->client_ipaddr.s_addr) {
648 memcpy(slirp->client_ethaddr, ah->ar_sha, ETH_ALEN);
649 }
650 break;
651 default:
652 break;
653 }
654 }
655
656 void slirp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
657 {
658 struct mbuf *m;
659 int proto;
660
661 if (pkt_len < ETH_HLEN)
662 return;
663
664 proto = ntohs(*(uint16_t *)(pkt + 12));
665 switch(proto) {
666 case ETH_P_ARP:
667 arp_input(slirp, pkt, pkt_len);
668 break;
669 case ETH_P_IP:
670 m = m_get(slirp);
671 if (!m)
672 return;
673 /* Note: we add to align the IP header */
674 if (M_FREEROOM(m) < pkt_len + 2) {
675 m_inc(m, pkt_len + 2);
676 }
677 m->m_len = pkt_len + 2;
678 memcpy(m->m_data + 2, pkt, pkt_len);
679
680 m->m_data += 2 + ETH_HLEN;
681 m->m_len -= 2 + ETH_HLEN;
682
683 ip_input(m);
684 break;
685 default:
686 break;
687 }
688 }
689
690 /* output the IP packet to the ethernet device */
691 void if_encap(Slirp *slirp, const uint8_t *ip_data, int ip_data_len)
692 {
693 uint8_t buf[1600];
694 struct ethhdr *eh = (struct ethhdr *)buf;
695
696 if (ip_data_len + ETH_HLEN > sizeof(buf))
697 return;
698
699 if (!memcmp(slirp->client_ethaddr, zero_ethaddr, ETH_ALEN)) {
700 uint8_t arp_req[ETH_HLEN + sizeof(struct arphdr)];
701 struct ethhdr *reh = (struct ethhdr *)arp_req;
702 struct arphdr *rah = (struct arphdr *)(arp_req + ETH_HLEN);
703 const struct ip *iph = (const struct ip *)ip_data;
704
705 /* If the client addr is not known, there is no point in
706 sending the packet to it. Normally the sender should have
707 done an ARP request to get its MAC address. Here we do it
708 in place of sending the packet and we hope that the sender
709 will retry sending its packet. */
710 memset(reh->h_dest, 0xff, ETH_ALEN);
711 memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 4);
712 memcpy(&reh->h_source[2], &slirp->vhost_addr, 4);
713 reh->h_proto = htons(ETH_P_ARP);
714 rah->ar_hrd = htons(1);
715 rah->ar_pro = htons(ETH_P_IP);
716 rah->ar_hln = ETH_ALEN;
717 rah->ar_pln = 4;
718 rah->ar_op = htons(ARPOP_REQUEST);
719 /* source hw addr */
720 memcpy(rah->ar_sha, special_ethaddr, ETH_ALEN - 4);
721 memcpy(&rah->ar_sha[2], &slirp->vhost_addr, 4);
722 /* source IP */
723 rah->ar_sip = slirp->vhost_addr.s_addr;
724 /* target hw addr (none) */
725 memset(rah->ar_tha, 0, ETH_ALEN);
726 /* target IP */
727 rah->ar_tip = iph->ip_dst.s_addr;
728 slirp->client_ipaddr = iph->ip_dst;
729 slirp_output(slirp->opaque, arp_req, sizeof(arp_req));
730 } else {
731 memcpy(eh->h_dest, slirp->client_ethaddr, ETH_ALEN);
732 memcpy(eh->h_source, special_ethaddr, ETH_ALEN - 4);
733 /* XXX: not correct */
734 memcpy(&eh->h_source[2], &slirp->vhost_addr, 4);
735 eh->h_proto = htons(ETH_P_IP);
736 memcpy(buf + sizeof(struct ethhdr), ip_data, ip_data_len);
737 slirp_output(slirp->opaque, buf, ip_data_len + ETH_HLEN);
738 }
739 }
740
741 /* Drop host forwarding rule, return 0 if found. */
742 int slirp_remove_hostfwd(Slirp *slirp, int is_udp, struct in_addr host_addr,
743 int host_port)
744 {
745 struct socket *so;
746 struct socket *head = (is_udp ? &slirp->udb : &slirp->tcb);
747 struct sockaddr_in addr;
748 int port = htons(host_port);
749 socklen_t addr_len;
750
751 for (so = head->so_next; so != head; so = so->so_next) {
752 addr_len = sizeof(addr);
753 if ((so->so_state & SS_HOSTFWD) &&
754 getsockname(so->s, (struct sockaddr *)&addr, &addr_len) == 0 &&
755 addr.sin_addr.s_addr == host_addr.s_addr &&
756 addr.sin_port == port) {
757 close(so->s);
758 sofree(so);
759 return 0;
760 }
761 }
762
763 return -1;
764 }
765
766 int slirp_add_hostfwd(Slirp *slirp, int is_udp, struct in_addr host_addr,
767 int host_port, struct in_addr guest_addr, int guest_port)
768 {
769 if (!guest_addr.s_addr) {
770 guest_addr = slirp->vdhcp_startaddr;
771 }
772 if (is_udp) {
773 if (!udp_listen(slirp, host_addr.s_addr, htons(host_port),
774 guest_addr.s_addr, htons(guest_port), SS_HOSTFWD))
775 return -1;
776 } else {
777 if (!tcp_listen(slirp, host_addr.s_addr, htons(host_port),
778 guest_addr.s_addr, htons(guest_port), SS_HOSTFWD))
779 return -1;
780 }
781 return 0;
782 }
783
784 int slirp_add_exec(Slirp *slirp, int do_pty, const void *args,
785 struct in_addr *guest_addr, int guest_port)
786 {
787 if (!guest_addr->s_addr) {
788 guest_addr->s_addr = slirp->vnetwork_addr.s_addr |
789 (htonl(0x0204) & ~slirp->vnetwork_mask.s_addr);
790 }
791 if ((guest_addr->s_addr & slirp->vnetwork_mask.s_addr) !=
792 slirp->vnetwork_addr.s_addr ||
793 guest_addr->s_addr == slirp->vhost_addr.s_addr ||
794 guest_addr->s_addr == slirp->vnameserver_addr.s_addr) {
795 return -1;
796 }
797 return add_exec(&slirp->exec_list, do_pty, (char *)args, *guest_addr,
798 htons(guest_port));
799 }
800
801 ssize_t slirp_send(struct socket *so, const void *buf, size_t len, int flags)
802 {
803 if (so->s == -1 && so->extra) {
804 qemu_chr_write(so->extra, buf, len);
805 return len;
806 }
807
808 return send(so->s, buf, len, flags);
809 }
810
811 static struct socket *
812 slirp_find_ctl_socket(Slirp *slirp, struct in_addr guest_addr, int guest_port)
813 {
814 struct socket *so;
815
816 for (so = slirp->tcb.so_next; so != &slirp->tcb; so = so->so_next) {
817 if (so->so_faddr.s_addr == guest_addr.s_addr &&
818 htons(so->so_fport) == guest_port) {
819 return so;
820 }
821 }
822 return NULL;
823 }
824
825 size_t slirp_socket_can_recv(Slirp *slirp, struct in_addr guest_addr,
826 int guest_port)
827 {
828 struct iovec iov[2];
829 struct socket *so;
830
831 so = slirp_find_ctl_socket(slirp, guest_addr, guest_port);
832
833 if (!so || so->so_state & SS_NOFDREF)
834 return 0;
835
836 if (!CONN_CANFRCV(so) || so->so_snd.sb_cc >= (so->so_snd.sb_datalen/2))
837 return 0;
838
839 return sopreprbuf(so, iov, NULL);
840 }
841
842 void slirp_socket_recv(Slirp *slirp, struct in_addr guest_addr, int guest_port,
843 const uint8_t *buf, int size)
844 {
845 int ret;
846 struct socket *so = slirp_find_ctl_socket(slirp, guest_addr, guest_port);
847
848 if (!so)
849 return;
850
851 ret = soreadbuf(so, (const char *)buf, size);
852
853 if (ret > 0)
854 tcp_output(sototcpcb(so));
855 }
856
857 static void slirp_tcp_save(QEMUFile *f, struct tcpcb *tp)
858 {
859 int i;
860
861 qemu_put_sbe16(f, tp->t_state);
862 for (i = 0; i < TCPT_NTIMERS; i++)
863 qemu_put_sbe16(f, tp->t_timer[i]);
864 qemu_put_sbe16(f, tp->t_rxtshift);
865 qemu_put_sbe16(f, tp->t_rxtcur);
866 qemu_put_sbe16(f, tp->t_dupacks);
867 qemu_put_be16(f, tp->t_maxseg);
868 qemu_put_sbyte(f, tp->t_force);
869 qemu_put_be16(f, tp->t_flags);
870 qemu_put_be32(f, tp->snd_una);
871 qemu_put_be32(f, tp->snd_nxt);
872 qemu_put_be32(f, tp->snd_up);
873 qemu_put_be32(f, tp->snd_wl1);
874 qemu_put_be32(f, tp->snd_wl2);
875 qemu_put_be32(f, tp->iss);
876 qemu_put_be32(f, tp->snd_wnd);
877 qemu_put_be32(f, tp->rcv_wnd);
878 qemu_put_be32(f, tp->rcv_nxt);
879 qemu_put_be32(f, tp->rcv_up);
880 qemu_put_be32(f, tp->irs);
881 qemu_put_be32(f, tp->rcv_adv);
882 qemu_put_be32(f, tp->snd_max);
883 qemu_put_be32(f, tp->snd_cwnd);
884 qemu_put_be32(f, tp->snd_ssthresh);
885 qemu_put_sbe16(f, tp->t_idle);
886 qemu_put_sbe16(f, tp->t_rtt);
887 qemu_put_be32(f, tp->t_rtseq);
888 qemu_put_sbe16(f, tp->t_srtt);
889 qemu_put_sbe16(f, tp->t_rttvar);
890 qemu_put_be16(f, tp->t_rttmin);
891 qemu_put_be32(f, tp->max_sndwnd);
892 qemu_put_byte(f, tp->t_oobflags);
893 qemu_put_byte(f, tp->t_iobc);
894 qemu_put_sbe16(f, tp->t_softerror);
895 qemu_put_byte(f, tp->snd_scale);
896 qemu_put_byte(f, tp->rcv_scale);
897 qemu_put_byte(f, tp->request_r_scale);
898 qemu_put_byte(f, tp->requested_s_scale);
899 qemu_put_be32(f, tp->ts_recent);
900 qemu_put_be32(f, tp->ts_recent_age);
901 qemu_put_be32(f, tp->last_ack_sent);
902 }
903
904 static void slirp_sbuf_save(QEMUFile *f, struct sbuf *sbuf)
905 {
906 uint32_t off;
907
908 qemu_put_be32(f, sbuf->sb_cc);
909 qemu_put_be32(f, sbuf->sb_datalen);
910 off = (uint32_t)(sbuf->sb_wptr - sbuf->sb_data);
911 qemu_put_sbe32(f, off);
912 off = (uint32_t)(sbuf->sb_rptr - sbuf->sb_data);
913 qemu_put_sbe32(f, off);
914 qemu_put_buffer(f, (unsigned char*)sbuf->sb_data, sbuf->sb_datalen);
915 }
916
917 static void slirp_socket_save(QEMUFile *f, struct socket *so)
918 {
919 qemu_put_be32(f, so->so_urgc);
920 qemu_put_be32(f, so->so_faddr.s_addr);
921 qemu_put_be32(f, so->so_laddr.s_addr);
922 qemu_put_be16(f, so->so_fport);
923 qemu_put_be16(f, so->so_lport);
924 qemu_put_byte(f, so->so_iptos);
925 qemu_put_byte(f, so->so_emu);
926 qemu_put_byte(f, so->so_type);
927 qemu_put_be32(f, so->so_state);
928 slirp_sbuf_save(f, &so->so_rcv);
929 slirp_sbuf_save(f, &so->so_snd);
930 slirp_tcp_save(f, so->so_tcpcb);
931 }
932
933 static void slirp_bootp_save(QEMUFile *f, Slirp *slirp)
934 {
935 int i;
936
937 for (i = 0; i < NB_BOOTP_CLIENTS; i++) {
938 qemu_put_be16(f, slirp->bootp_clients[i].allocated);
939 qemu_put_buffer(f, slirp->bootp_clients[i].macaddr, 6);
940 }
941 }
942
943 static void slirp_state_save(QEMUFile *f, void *opaque)
944 {
945 Slirp *slirp = opaque;
946 struct ex_list *ex_ptr;
947
948 for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next)
949 if (ex_ptr->ex_pty == 3) {
950 struct socket *so;
951 so = slirp_find_ctl_socket(slirp, ex_ptr->ex_addr,
952 ntohs(ex_ptr->ex_fport));
953 if (!so)
954 continue;
955
956 qemu_put_byte(f, 42);
957 slirp_socket_save(f, so);
958 }
959 qemu_put_byte(f, 0);
960
961 qemu_put_be16(f, slirp->ip_id);
962
963 slirp_bootp_save(f, slirp);
964 }
965
966 static void slirp_tcp_load(QEMUFile *f, struct tcpcb *tp)
967 {
968 int i;
969
970 tp->t_state = qemu_get_sbe16(f);
971 for (i = 0; i < TCPT_NTIMERS; i++)
972 tp->t_timer[i] = qemu_get_sbe16(f);
973 tp->t_rxtshift = qemu_get_sbe16(f);
974 tp->t_rxtcur = qemu_get_sbe16(f);
975 tp->t_dupacks = qemu_get_sbe16(f);
976 tp->t_maxseg = qemu_get_be16(f);
977 tp->t_force = qemu_get_sbyte(f);
978 tp->t_flags = qemu_get_be16(f);
979 tp->snd_una = qemu_get_be32(f);
980 tp->snd_nxt = qemu_get_be32(f);
981 tp->snd_up = qemu_get_be32(f);
982 tp->snd_wl1 = qemu_get_be32(f);
983 tp->snd_wl2 = qemu_get_be32(f);
984 tp->iss = qemu_get_be32(f);
985 tp->snd_wnd = qemu_get_be32(f);
986 tp->rcv_wnd = qemu_get_be32(f);
987 tp->rcv_nxt = qemu_get_be32(f);
988 tp->rcv_up = qemu_get_be32(f);
989 tp->irs = qemu_get_be32(f);
990 tp->rcv_adv = qemu_get_be32(f);
991 tp->snd_max = qemu_get_be32(f);
992 tp->snd_cwnd = qemu_get_be32(f);
993 tp->snd_ssthresh = qemu_get_be32(f);
994 tp->t_idle = qemu_get_sbe16(f);
995 tp->t_rtt = qemu_get_sbe16(f);
996 tp->t_rtseq = qemu_get_be32(f);
997 tp->t_srtt = qemu_get_sbe16(f);
998 tp->t_rttvar = qemu_get_sbe16(f);
999 tp->t_rttmin = qemu_get_be16(f);
1000 tp->max_sndwnd = qemu_get_be32(f);
1001 tp->t_oobflags = qemu_get_byte(f);
1002 tp->t_iobc = qemu_get_byte(f);
1003 tp->t_softerror = qemu_get_sbe16(f);
1004 tp->snd_scale = qemu_get_byte(f);
1005 tp->rcv_scale = qemu_get_byte(f);
1006 tp->request_r_scale = qemu_get_byte(f);
1007 tp->requested_s_scale = qemu_get_byte(f);
1008 tp->ts_recent = qemu_get_be32(f);
1009 tp->ts_recent_age = qemu_get_be32(f);
1010 tp->last_ack_sent = qemu_get_be32(f);
1011 tcp_template(tp);
1012 }
1013
1014 static int slirp_sbuf_load(QEMUFile *f, struct sbuf *sbuf)
1015 {
1016 uint32_t off, sb_cc, sb_datalen;
1017
1018 sb_cc = qemu_get_be32(f);
1019 sb_datalen = qemu_get_be32(f);
1020
1021 sbreserve(sbuf, sb_datalen);
1022
1023 if (sbuf->sb_datalen != sb_datalen)
1024 return -ENOMEM;
1025
1026 sbuf->sb_cc = sb_cc;
1027
1028 off = qemu_get_sbe32(f);
1029 sbuf->sb_wptr = sbuf->sb_data + off;
1030 off = qemu_get_sbe32(f);
1031 sbuf->sb_rptr = sbuf->sb_data + off;
1032 qemu_get_buffer(f, (unsigned char*)sbuf->sb_data, sbuf->sb_datalen);
1033
1034 return 0;
1035 }
1036
1037 static int slirp_socket_load(QEMUFile *f, struct socket *so)
1038 {
1039 if (tcp_attach(so) < 0)
1040 return -ENOMEM;
1041
1042 so->so_urgc = qemu_get_be32(f);
1043 so->so_faddr.s_addr = qemu_get_be32(f);
1044 so->so_laddr.s_addr = qemu_get_be32(f);
1045 so->so_fport = qemu_get_be16(f);
1046 so->so_lport = qemu_get_be16(f);
1047 so->so_iptos = qemu_get_byte(f);
1048 so->so_emu = qemu_get_byte(f);
1049 so->so_type = qemu_get_byte(f);
1050 so->so_state = qemu_get_be32(f);
1051 if (slirp_sbuf_load(f, &so->so_rcv) < 0)
1052 return -ENOMEM;
1053 if (slirp_sbuf_load(f, &so->so_snd) < 0)
1054 return -ENOMEM;
1055 slirp_tcp_load(f, so->so_tcpcb);
1056
1057 return 0;
1058 }
1059
1060 static void slirp_bootp_load(QEMUFile *f, Slirp *slirp)
1061 {
1062 int i;
1063
1064 for (i = 0; i < NB_BOOTP_CLIENTS; i++) {
1065 slirp->bootp_clients[i].allocated = qemu_get_be16(f);
1066 qemu_get_buffer(f, slirp->bootp_clients[i].macaddr, 6);
1067 }
1068 }
1069
1070 static int slirp_state_load(QEMUFile *f, void *opaque, int version_id)
1071 {
1072 Slirp *slirp = opaque;
1073 struct ex_list *ex_ptr;
1074
1075 while (qemu_get_byte(f)) {
1076 int ret;
1077 struct socket *so = socreate(slirp);
1078
1079 if (!so)
1080 return -ENOMEM;
1081
1082 ret = slirp_socket_load(f, so);
1083
1084 if (ret < 0)
1085 return ret;
1086
1087 if ((so->so_faddr.s_addr & slirp->vnetwork_mask.s_addr) !=
1088 slirp->vnetwork_addr.s_addr) {
1089 return -EINVAL;
1090 }
1091 for (ex_ptr = slirp->exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
1092 if (ex_ptr->ex_pty == 3 &&
1093 so->so_faddr.s_addr == ex_ptr->ex_addr.s_addr &&
1094 so->so_fport == ex_ptr->ex_fport) {
1095 break;
1096 }
1097 }
1098 if (!ex_ptr)
1099 return -EINVAL;
1100
1101 so->extra = (void *)ex_ptr->ex_exec;
1102 }
1103
1104 if (version_id >= 2) {
1105 slirp->ip_id = qemu_get_be16(f);
1106 }
1107
1108 if (version_id >= 3) {
1109 slirp_bootp_load(f, slirp);
1110 }
1111
1112 return 0;
1113 }
QEmu