target-sparc: Revert setting cpu_dst to gen_dest_gpr

[qemu.git] / slirp / slirp.c

diff --git a/slirp/slirp.c b/slirp/slirp.c
index 25bc8a4c57fca9da75c20f9ad8a531bcbd653a0e..38e0a2193ae63282fc4ce96f687ba7bc49a2f9c1 100644 (file)
--- a/slirp/slirp.c
+++ b/slirp/slirp.c
@@ -22,25 +22,22 @@
  * THE SOFTWARE.
  */
 #include "qemu-common.h"
  * THE SOFTWARE.
  */
 #include "qemu-common.h"

+#include "qemu-timer.h"

 #include "qemu-char.h"
 #include "slirp.h"
 #include "hw/hw.h"
 
 #include "qemu-char.h"
 #include "slirp.h"
 #include "hw/hw.h"
 

-/* host address */
-struct in_addr our_addr;
-/* host dns address */
-struct in_addr dns_addr;

 /* host loopback address */
 struct in_addr loopback_addr;
 /* host loopback address */
 struct in_addr loopback_addr;

+/* host loopback network mask */
+unsigned long loopback_mask;

 
 /* emulated hosts use the MAC addr 52:55:IP:IP:IP:IP */
 
 /* emulated hosts use the MAC addr 52:55:IP:IP:IP:IP */

-static const uint8_t special_ethaddr[6] = {
+static const uint8_t special_ethaddr[ETH_ALEN] = {

     0x52, 0x55, 0x00, 0x00, 0x00, 0x00
 };
 
     0x52, 0x55, 0x00, 0x00, 0x00, 0x00
 };
 

-static const uint8_t zero_ethaddr[6] = { 0, 0, 0, 0, 0, 0 };
-
-int link_up; // FIXME: kill this
+static const uint8_t zero_ethaddr[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };

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


@@ -49,11 +46,15 @@ u_int curtime;
 static u_int time_fasttimo, last_slowtimo;
 static int do_slowtimo;
 
 static u_int time_fasttimo, last_slowtimo;
 static int do_slowtimo;
 

-Slirp slirp_instance;
+static QTAILQ_HEAD(slirp_instances, Slirp) slirp_instances =
+    QTAILQ_HEAD_INITIALIZER(slirp_instances);
+
+static struct in_addr dns_addr;
+static u_int dns_addr_time;

 
 #ifdef _WIN32
 
 
 #ifdef _WIN32
 

-static int get_dns_addr(struct in_addr *pdns_addr)
+int get_dns_addr(struct in_addr *pdns_addr)

 {
     FIXED_INFO *FixedInfo=NULL;
     ULONG    BufLen;
 {
     FIXED_INFO *FixedInfo=NULL;
     ULONG    BufLen;


@@ -61,6 +62,11 @@ static int get_dns_addr(struct in_addr *pdns_addr)
     IP_ADDR_STRING *pIPAddr;
     struct in_addr tmp_addr;
 
     IP_ADDR_STRING *pIPAddr;
     struct in_addr tmp_addr;
 

+    if (dns_addr.s_addr != 0 && (curtime - dns_addr_time) < 1000) {
+        *pdns_addr = dns_addr;
+        return 0;
+    }
+

     FixedInfo = (FIXED_INFO *)GlobalAlloc(GPTR, sizeof(FIXED_INFO));
     BufLen = sizeof(FIXED_INFO);
 
     FixedInfo = (FIXED_INFO *)GlobalAlloc(GPTR, sizeof(FIXED_INFO));
     BufLen = sizeof(FIXED_INFO);
 


@@ -84,6 +90,8 @@ static int get_dns_addr(struct in_addr *pdns_addr)
     pIPAddr = &(FixedInfo->DnsServerList);
     inet_aton(pIPAddr->IpAddress.String, &tmp_addr);
     *pdns_addr = tmp_addr;
     pIPAddr = &(FixedInfo->DnsServerList);
     inet_aton(pIPAddr->IpAddress.String, &tmp_addr);
     *pdns_addr = tmp_addr;

+    dns_addr = tmp_addr;
+    dns_addr_time = curtime;

     if (FixedInfo) {
         GlobalFree(FixedInfo);
         FixedInfo = NULL;
     if (FixedInfo) {
         GlobalFree(FixedInfo);
         FixedInfo = NULL;


@@ -98,7 +106,9 @@ static void winsock_cleanup(void)
 
 #else
 
 
 #else
 

-static int get_dns_addr(struct in_addr *pdns_addr)
+static struct stat dns_addr_stat;
+
+int get_dns_addr(struct in_addr *pdns_addr)

 {
     char buff[512];
     char buff2[257];
 {
     char buff[512];
     char buff2[257];


@@ -106,6 +116,24 @@ static int get_dns_addr(struct in_addr *pdns_addr)
     int found = 0;
     struct in_addr tmp_addr;
 
     int found = 0;
     struct in_addr tmp_addr;
 

+    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;
+        }
+    }
+

     f = fopen("/etc/resolv.conf", "r");
     if (!f)
         return -1;
     f = fopen("/etc/resolv.conf", "r");
     if (!f)
         return -1;


@@ -117,11 +145,12 @@ static int get_dns_addr(struct in_addr *pdns_addr)
         if (sscanf(buff, "nameserver%*[ \t]%256s", buff2) == 1) {
             if (!inet_aton(buff2, &tmp_addr))
                 continue;
         if (sscanf(buff, "nameserver%*[ \t]%256s", buff2) == 1) {
             if (!inet_aton(buff2, &tmp_addr))
                 continue;

-            if (tmp_addr.s_addr == loopback_addr.s_addr)
-                tmp_addr = our_addr;

             /* If it's the first one, set it to dns_addr */
             /* If it's the first one, set it to dns_addr */

-            if (!found)
+            if (!found) {

                 *pdns_addr = tmp_addr;
                 *pdns_addr = tmp_addr;

+                dns_addr = tmp_addr;
+                dns_addr_time = curtime;
+            }

 #ifdef DEBUG
             else
                 lprint(", ");
 #ifdef DEBUG
             else
                 lprint(", ");


@@ -149,8 +178,6 @@ static int get_dns_addr(struct in_addr *pdns_addr)
 static void slirp_init_once(void)
 {
     static int initialized;
 static void slirp_init_once(void)
 {
     static int initialized;

-    struct hostent *he;
-    char our_name[256];

 #ifdef _WIN32
     WSADATA Data;
 #endif
 #ifdef _WIN32
     WSADATA Data;
 #endif


@@ -166,38 +193,22 @@ static void slirp_init_once(void)
 #endif
 
     loopback_addr.s_addr = htonl(INADDR_LOOPBACK);
 #endif
 
     loopback_addr.s_addr = htonl(INADDR_LOOPBACK);

-
-    /* FIXME: This address may change during runtime */
-    if (gethostname(our_name, sizeof(our_name)) == 0) {
-        he = gethostbyname(our_name);
-        if (he) {
-            our_addr = *(struct in_addr *)he->h_addr;
-        }
-    }
-    if (our_addr.s_addr == 0) {
-        our_addr = loopback_addr;
-    }
-
-    /* FIXME: This address may change during runtime */
-    if (get_dns_addr(&dns_addr) < 0) {
-        dns_addr = loopback_addr;
-    }
+    loopback_mask = htonl(IN_CLASSA_NET);

 }
 
 static void slirp_state_save(QEMUFile *f, void *opaque);
 static int slirp_state_load(QEMUFile *f, void *opaque, int version_id);
 
 }
 
 static void slirp_state_save(QEMUFile *f, void *opaque);
 static int slirp_state_load(QEMUFile *f, void *opaque, int version_id);
 

-void 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,
-                struct in_addr vnameserver)
+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,
+                  struct in_addr vnameserver, void *opaque)

 {
 {

-    Slirp *slirp = &slirp_instance;
+    Slirp *slirp = g_malloc0(sizeof(Slirp));

 
     slirp_init_once();
 
 
     slirp_init_once();
 

-    link_up = 1;

     slirp->restricted = restricted;
 
     if_init(slirp);
     slirp->restricted = restricted;
 
     if_init(slirp);


@@ -213,57 +224,58 @@ void slirp_init(int restricted, struct in_addr vnetwork,
         pstrcpy(slirp->client_hostname, sizeof(slirp->client_hostname),
                 vhostname);
     }
         pstrcpy(slirp->client_hostname, sizeof(slirp->client_hostname),
                 vhostname);
     }

-    qemu_free(slirp->tftp_prefix);
-    slirp->tftp_prefix = NULL;

     if (tftp_path) {
     if (tftp_path) {

-        slirp->tftp_prefix = qemu_strdup(tftp_path);
+        slirp->tftp_prefix = g_strdup(tftp_path);

     }
     }

-    qemu_free(slirp->bootp_filename);
-    slirp->bootp_filename = NULL;

     if (bootfile) {
     if (bootfile) {

-        slirp->bootp_filename = qemu_strdup(bootfile);
+        slirp->bootp_filename = g_strdup(bootfile);

     }
     slirp->vdhcp_startaddr = vdhcp_start;
     slirp->vnameserver_addr = vnameserver;
 
     }
     slirp->vdhcp_startaddr = vdhcp_start;
     slirp->vnameserver_addr = vnameserver;
 

-    register_savevm("slirp", 0, 2, slirp_state_save, slirp_state_load, slirp);
-}
+    slirp->opaque = opaque;

 
 

-#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)
+    register_savevm(NULL, "slirp", 0, 3,
+                    slirp_state_save, slirp_state_load, slirp);

 
 

-/*
- * curtime kept to an accuracy of 1ms
- */
-#ifdef _WIN32
-static void updtime(void)
+    QTAILQ_INSERT_TAIL(&slirp_instances, slirp, entry);
+
+    return slirp;
+}
+
+void slirp_cleanup(Slirp *slirp)

 {
 {

-    struct _timeb tb;
+    QTAILQ_REMOVE(&slirp_instances, slirp, entry);
+
+    unregister_savevm(NULL, "slirp", slirp);

 
 

-    _ftime(&tb);
+    ip_cleanup(slirp);
+    m_cleanup(slirp);

 
 

-    curtime = tb.time * 1000 + tb.millitm;
+    g_free(slirp->tftp_prefix);
+    g_free(slirp->bootp_filename);
+    g_free(slirp);

 }
 }

-#else
-static void updtime(void)
-{
-    struct timeval tv;

 
 

-    gettimeofday(&tv, NULL);
+#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)

 
 

-    curtime = tv.tv_sec * 1000 + tv.tv_usec / 1000;
+void slirp_update_timeout(uint32_t *timeout)
+{
+    if (!QTAILQ_EMPTY(&slirp_instances)) {
+        *timeout = MIN(1000, *timeout);
+    }

 }
 }

-#endif

 
 void slirp_select_fill(int *pnfds,
                        fd_set *readfds, fd_set *writefds, fd_set *xfds)
 {
 
 void slirp_select_fill(int *pnfds,
                        fd_set *readfds, fd_set *writefds, fd_set *xfds)
 {

-    Slirp *slirp = &slirp_instance;
+    Slirp *slirp;

     struct socket *so, *so_next;
     int nfds;
 
     struct socket *so, *so_next;
     int nfds;
 

-    if (!link_up) {
+    if (QTAILQ_EMPTY(&slirp_instances)) {

         return;
     }
 
         return;
     }
 


@@ -278,11 +290,12 @@ void slirp_select_fill(int *pnfds,
         */
        do_slowtimo = 0;
 
         */
        do_slowtimo = 0;
 

+       QTAILQ_FOREACH(slirp, &slirp_instances, entry) {

                /*
                 * *_slowtimo needs calling if there are IP fragments
                 * in the fragment queue, or there are TCP connections active
                 */
                /*
                 * *_slowtimo needs calling if there are IP fragments
                 * in the fragment queue, or there are TCP connections active
                 */

-               do_slowtimo = ((slirp->tcb.so_next != &slirp->tcb) ||
+               do_slowtimo |= ((slirp->tcb.so_next != &slirp->tcb) ||

                    (&slirp->ipq.ip_link != slirp->ipq.ip_link.next));
 
                for (so = slirp->tcb.so_next; so != &slirp->tcb;
                    (&slirp->ipq.ip_link != slirp->ipq.ip_link.next));
 
                for (so = slirp->tcb.so_next; so != &slirp->tcb;


@@ -374,17 +387,43 @@ void slirp_select_fill(int *pnfds,
                        }
                }
 
                        }
                }
 

+                /*
+                 * 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);
+                    }
+                }
+       }
+

         *pnfds = nfds;
 }
 
 void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds,
                        int select_error)
 {
         *pnfds = nfds;
 }
 
 void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds,
                        int select_error)
 {

-    Slirp *slirp = &slirp_instance;
+    Slirp *slirp;

     struct socket *so, *so_next;
     int ret;
 
     struct socket *so, *so_next;
     int ret;
 

-    if (!link_up) {
+    if (QTAILQ_EMPTY(&slirp_instances)) {

         return;
     }
 
         return;
     }
 


@@ -392,9 +431,9 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds,
     global_writefds = writefds;
     global_xfds = xfds;
 
     global_writefds = writefds;
     global_xfds = xfds;
 

-       /* Update time */
-       updtime();
+    curtime = qemu_get_clock_ms(rt_clock);

 
 

+    QTAILQ_FOREACH(slirp, &slirp_instances, entry) {

        /*
         * See if anything has timed out
         */
        /*
         * See if anything has timed out
         */


@@ -496,7 +535,7 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds,
                         */
 #ifdef PROBE_CONN
                        if (so->so_state & SS_ISFCONNECTING) {
                         */
 #ifdef PROBE_CONN
                        if (so->so_state & SS_ISFCONNECTING) {

-                         ret = recv(so->s, (char *)&ret, 0,0);
+                          ret = qemu_recv(so->s, &ret, 0,0);

 
                          if (ret < 0) {
                            /* XXX */
 
                          if (ret < 0) {
                            /* XXX */


@@ -541,15 +580,23 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds,
                             sorecvfrom(so);
                         }
                }
                             sorecvfrom(so);
                         }
                }

-       }

 
 

-       /*
-        * See if we can start outputting
-        */
-       if (slirp->if_queued) {
-           if_start(slirp);
+                /*
+                 * 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);
+                    }
+                }

        }
 
        }
 

+        if_start(slirp);
+    }
+

        /* clear global file descriptor sets.
         * these reside on the stack in vl.c
         * so they're unusable if we're not in
        /* clear global file descriptor sets.
         * these reside on the stack in vl.c
         * so they're unusable if we're not in


@@ -560,44 +607,10 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds,
         global_xfds = NULL;
 }
 
         global_xfds = NULL;
 }
 

-#define ETH_ALEN 6
-#define ETH_HLEN 14
-
-#define ETH_P_IP       0x0800          /* Internet Protocol packet     */
-#define ETH_P_ARP      0x0806          /* Address Resolution packet    */
-
-#define        ARPOP_REQUEST   1               /* ARP request                  */
-#define        ARPOP_REPLY     2               /* ARP reply                    */
-
-struct ethhdr
-{
-       unsigned char   h_dest[ETH_ALEN];       /* destination eth addr */
-       unsigned char   h_source[ETH_ALEN];     /* source ether addr    */
-       unsigned short  h_proto;                /* packet type ID field */
-};
-
-struct arphdr
-{
-       unsigned short  ar_hrd;         /* format of hardware address   */
-       unsigned short  ar_pro;         /* format of protocol address   */
-       unsigned char   ar_hln;         /* length of hardware address   */
-       unsigned char   ar_pln;         /* length of protocol address   */
-       unsigned short  ar_op;          /* ARP opcode (command)         */
-
-        /*
-         *      Ethernet looks like this : This bit is variable sized however...
-         */
-       unsigned char           ar_sha[ETH_ALEN];       /* sender hardware address      */
-       uint32_t                ar_sip;                 /* sender IP address            */
-       unsigned char           ar_tha[ETH_ALEN];       /* target hardware address      */
-       uint32_t                ar_tip  ;               /* target IP address            */
-} __attribute__((packed));
-

 static void arp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
 {
 static void arp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
 {

-    struct ethhdr *eh = (struct ethhdr *)pkt;

     struct arphdr *ah = (struct arphdr *)(pkt + ETH_HLEN);
     struct arphdr *ah = (struct arphdr *)(pkt + ETH_HLEN);

-    uint8_t arp_reply[ETH_HLEN + sizeof(struct arphdr)];
+    uint8_t arp_reply[max(ETH_HLEN + sizeof(struct arphdr), 64)];

     struct ethhdr *reh = (struct ethhdr *)arp_reply;
     struct arphdr *rah = (struct arphdr *)(arp_reply + ETH_HLEN);
     int ar_op;
     struct ethhdr *reh = (struct ethhdr *)arp_reply;
     struct arphdr *rah = (struct arphdr *)(arp_reply + ETH_HLEN);
     int ar_op;


@@ -606,6 +619,12 @@ static void arp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
     ar_op = ntohs(ah->ar_op);
     switch(ar_op) {
     case ARPOP_REQUEST:
     ar_op = ntohs(ah->ar_op);
     switch(ar_op) {
     case ARPOP_REQUEST:

+        if (ah->ar_tip == ah->ar_sip) {
+            /* Gratuitous ARP */
+            arp_table_add(slirp, ah->ar_sip, ah->ar_sha);
+            return;
+        }
+

         if ((ah->ar_tip & slirp->vnetwork_mask.s_addr) ==
             slirp->vnetwork_addr.s_addr) {
             if (ah->ar_tip == slirp->vnameserver_addr.s_addr ||
         if ((ah->ar_tip & slirp->vnetwork_mask.s_addr) ==
             slirp->vnetwork_addr.s_addr) {
             if (ah->ar_tip == slirp->vnameserver_addr.s_addr ||


@@ -617,8 +636,9 @@ static void arp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
             }
             return;
         arp_ok:
             }
             return;
         arp_ok:

-            /* XXX: make an ARP request to have the client address */
-            memcpy(slirp->client_ethaddr, eh->h_source, ETH_ALEN);
+            memset(arp_reply, 0, sizeof(arp_reply));
+
+            arp_table_add(slirp, ah->ar_sip, ah->ar_sha);

 
             /* ARP request for alias/dns mac address */
             memcpy(reh->h_dest, pkt + ETH_ALEN, ETH_ALEN);
 
             /* ARP request for alias/dns mac address */
             memcpy(reh->h_dest, pkt + ETH_ALEN, ETH_ALEN);


@@ -635,24 +655,19 @@ static void arp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)
             rah->ar_sip = ah->ar_tip;
             memcpy(rah->ar_tha, ah->ar_sha, ETH_ALEN);
             rah->ar_tip = ah->ar_sip;
             rah->ar_sip = ah->ar_tip;
             memcpy(rah->ar_tha, ah->ar_sha, ETH_ALEN);
             rah->ar_tip = ah->ar_sip;

-            slirp_output(arp_reply, sizeof(arp_reply));
+            slirp_output(slirp->opaque, arp_reply, sizeof(arp_reply));

         }
         break;
     case ARPOP_REPLY:
         }
         break;
     case ARPOP_REPLY:

-        /* reply to request of client mac address ? */
-        if (!memcmp(slirp->client_ethaddr, zero_ethaddr, ETH_ALEN) &&
-            ah->ar_sip == slirp->client_ipaddr.s_addr) {
-            memcpy(slirp->client_ethaddr, ah->ar_sha, ETH_ALEN);
-        }
+        arp_table_add(slirp, ah->ar_sip, ah->ar_sha);

         break;
     default:
         break;
     }
 }
 
         break;
     default:
         break;
     }
 }
 

-void slirp_input(const uint8_t *pkt, int pkt_len)
+void slirp_input(Slirp *slirp, const uint8_t *pkt, int pkt_len)

 {
 {

-    Slirp *slirp = &slirp_instance;

     struct mbuf *m;
     int proto;
 
     struct mbuf *m;
     int proto;
 


@@ -685,61 +700,73 @@ void slirp_input(const uint8_t *pkt, int pkt_len)
     }
 }
 
     }
 }
 

-/* output the IP packet to the ethernet device */
-void if_encap(Slirp *slirp, const uint8_t *ip_data, int ip_data_len)
+/* 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)

 {
     uint8_t buf[1600];
     struct ethhdr *eh = (struct ethhdr *)buf;
 {
     uint8_t buf[1600];
     struct ethhdr *eh = (struct ethhdr *)buf;

+    uint8_t ethaddr[ETH_ALEN];
+    const struct ip *iph = (const struct ip *)ifm->m_data;

 
 

-    if (ip_data_len + ETH_HLEN > sizeof(buf))
-        return;
-    
-    if (!memcmp(slirp->client_ethaddr, zero_ethaddr, ETH_ALEN)) {
+    if (ifm->m_len + ETH_HLEN > sizeof(buf)) {
+        return 1;
+    }
+
+    if (!arp_table_search(slirp, iph->ip_dst.s_addr, ethaddr)) {

         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);
         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);

-        const struct ip *iph = (const struct ip *)ip_data;
-
-        /* If the client addr is not known, there is no point in
-           sending the packet to it. Normally the sender should have
-           done an ARP request to get its MAC address. Here we do it
-           in place of sending the packet and we hope that the sender
-           will retry sending its packet. */
-        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(arp_req, sizeof(arp_req));
+
+        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;
+
+            /* Expire request and drop outgoing packet after 1 second */
+            ifm->expiration_date = qemu_get_clock_ns(rt_clock) + 1000000000ULL;
+        }
+        return 0;

     } else {
     } else {

-        memcpy(eh->h_dest, slirp->client_ethaddr, ETH_ALEN);
+        memcpy(eh->h_dest, ethaddr, ETH_ALEN);

         memcpy(eh->h_source, special_ethaddr, ETH_ALEN - 4);
         /* XXX: not correct */
         memcpy(&eh->h_source[2], &slirp->vhost_addr, 4);
         eh->h_proto = htons(ETH_P_IP);
         memcpy(eh->h_source, special_ethaddr, ETH_ALEN - 4);
         /* XXX: not correct */
         memcpy(&eh->h_source[2], &slirp->vhost_addr, 4);
         eh->h_proto = htons(ETH_P_IP);

-        memcpy(buf + sizeof(struct ethhdr), ip_data, ip_data_len);
-        slirp_output(buf, ip_data_len + ETH_HLEN);
+        memcpy(buf + sizeof(struct ethhdr), ifm->m_data, ifm->m_len);
+        slirp_output(slirp->opaque, buf, ifm->m_len + ETH_HLEN);
+        return 1;

     }
 }
 
 /* Drop host forwarding rule, return 0 if found. */
     }
 }
 
 /* Drop host forwarding rule, return 0 if found. */

-int slirp_remove_hostfwd(int is_udp, struct in_addr host_addr, int host_port)
+int slirp_remove_hostfwd(Slirp *slirp, int is_udp, struct in_addr host_addr,
+                         int host_port)

 {
 {

-    Slirp *slirp = &slirp_instance;

     struct socket *so;
     struct socket *head = (is_udp ? &slirp->udb : &slirp->tcb);
     struct sockaddr_in addr;
     struct socket *so;
     struct socket *head = (is_udp ? &slirp->udb : &slirp->tcb);
     struct sockaddr_in addr;


@@ -761,11 +788,9 @@ int slirp_remove_hostfwd(int is_udp, struct in_addr host_addr, int host_port)
     return -1;
 }
 
     return -1;
 }
 

-int slirp_add_hostfwd(int is_udp, struct in_addr host_addr, int host_port,
-                      struct in_addr guest_addr, int guest_port)
+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)

 {
 {

-    Slirp *slirp = &slirp_instance;
-

     if (!guest_addr.s_addr) {
         guest_addr = slirp->vdhcp_startaddr;
     }
     if (!guest_addr.s_addr) {
         guest_addr = slirp->vdhcp_startaddr;
     }


@@ -781,29 +806,27 @@ int slirp_add_hostfwd(int is_udp, struct in_addr host_addr, int host_port,
     return 0;
 }
 
     return 0;
 }
 

-int slirp_add_exec(int do_pty, const void *args, struct in_addr guest_addr,
-                   int guest_port)
+int slirp_add_exec(Slirp *slirp, int do_pty, const void *args,
+                   struct in_addr *guest_addr, int guest_port)

 {
 {

-    Slirp *slirp = &slirp_instance;
-
-    if (!guest_addr.s_addr) {
-        guest_addr.s_addr = slirp->vnetwork_addr.s_addr |
+    if (!guest_addr->s_addr) {
+        guest_addr->s_addr = slirp->vnetwork_addr.s_addr |

             (htonl(0x0204) & ~slirp->vnetwork_mask.s_addr);
     }
             (htonl(0x0204) & ~slirp->vnetwork_mask.s_addr);
     }

-    if ((guest_addr.s_addr & slirp->vnetwork_mask.s_addr) !=
+    if ((guest_addr->s_addr & slirp->vnetwork_mask.s_addr) !=

         slirp->vnetwork_addr.s_addr ||
         slirp->vnetwork_addr.s_addr ||

-        guest_addr.s_addr == slirp->vhost_addr.s_addr ||
-        guest_addr.s_addr == slirp->vnameserver_addr.s_addr) {
+        guest_addr->s_addr == slirp->vhost_addr.s_addr ||
+        guest_addr->s_addr == slirp->vnameserver_addr.s_addr) {

         return -1;
     }
         return -1;
     }

-    return add_exec(&slirp->exec_list, do_pty, (char *)args, guest_addr,
+    return add_exec(&slirp->exec_list, do_pty, (char *)args, *guest_addr,

                     htons(guest_port));
 }
 
 ssize_t slirp_send(struct socket *so, const void *buf, size_t len, int flags)
 {
        if (so->s == -1 && so->extra) {
                     htons(guest_port));
 }
 
 ssize_t slirp_send(struct socket *so, const void *buf, size_t len, int flags)
 {
        if (so->s == -1 && so->extra) {

-               qemu_chr_write(so->extra, buf, len);
+               qemu_chr_fe_write(so->extra, buf, len);

                return len;
        }
 
                return len;
        }
 


@@ -824,9 +847,9 @@ slirp_find_ctl_socket(Slirp *slirp, struct in_addr guest_addr, int guest_port)
     return NULL;
 }
 
     return NULL;
 }
 

-size_t slirp_socket_can_recv(struct in_addr guest_addr, int guest_port)
+size_t slirp_socket_can_recv(Slirp *slirp, struct in_addr guest_addr,
+                             int guest_port)

 {
 {

-       Slirp *slirp = &slirp_instance;

        struct iovec iov[2];
        struct socket *so;
 
        struct iovec iov[2];
        struct socket *so;
 


@@ -841,10 +864,9 @@ size_t slirp_socket_can_recv(struct in_addr guest_addr, int guest_port)
        return sopreprbuf(so, iov, NULL);
 }
 
        return sopreprbuf(so, iov, NULL);
 }
 

-void slirp_socket_recv(struct in_addr guest_addr, int guest_port,
+void slirp_socket_recv(Slirp *slirp, struct in_addr guest_addr, int guest_port,

                        const uint8_t *buf, int size)
 {
                        const uint8_t *buf, int size)
 {

-    Slirp *slirp = &slirp_instance;

     int ret;
     struct socket *so = slirp_find_ctl_socket(slirp, guest_addr, guest_port);
 
     int ret;
     struct socket *so = slirp_find_ctl_socket(slirp, guest_addr, guest_port);
 


@@ -933,6 +955,16 @@ static void slirp_socket_save(QEMUFile *f, struct socket *so)
     slirp_tcp_save(f, so->so_tcpcb);
 }
 
     slirp_tcp_save(f, so->so_tcpcb);
 }
 

+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);
+    }
+}
+

 static void slirp_state_save(QEMUFile *f, void *opaque)
 {
     Slirp *slirp = opaque;
 static void slirp_state_save(QEMUFile *f, void *opaque)
 {
     Slirp *slirp = opaque;


@@ -952,6 +984,8 @@ static void slirp_state_save(QEMUFile *f, void *opaque)
     qemu_put_byte(f, 0);
 
     qemu_put_be16(f, slirp->ip_id);
     qemu_put_byte(f, 0);
 
     qemu_put_be16(f, slirp->ip_id);

+
+    slirp_bootp_save(f, slirp);

 }
 
 static void slirp_tcp_load(QEMUFile *f, struct tcpcb *tp)
 }
 
 static void slirp_tcp_load(QEMUFile *f, struct tcpcb *tp)


@@ -1048,13 +1082,22 @@ static int slirp_socket_load(QEMUFile *f, struct socket *so)
     return 0;
 }
 
     return 0;
 }
 

+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);
+    }
+}
+

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

-    int r;

 
 

-    while ((r = qemu_get_byte(f))) {
+    while (qemu_get_byte(f)) {

         int ret;
         struct socket *so = socreate(slirp);
 
         int ret;
         struct socket *so = socreate(slirp);
 


@@ -1087,5 +1130,9 @@ static int slirp_state_load(QEMUFile *f, void *opaque, int version_id)
         slirp->ip_id = qemu_get_be16(f);
     }
 
         slirp->ip_id = qemu_get_be16(f);
     }
 

+    if (version_id >= 3) {
+        slirp_bootp_load(f, slirp);
+    }
+

     return 0;
 }
     return 0;
 }