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