src/slirp/slirp.c

#include "slirp.h"

/* host address */
struct in_addr our_addr;
/* host dns address */
struct in_addr dns_addr;
/* host loopback address */
struct in_addr loopback_addr;

/* address for slirp virtual addresses */
struct in_addr special_addr;

const uint8_t special_ethaddr[6] = { 
    0x52, 0x54, 0x00, 0x12, 0x35, 0x00
};

uint8_t client_ethaddr[6];

int do_slowtimo;
int link_up;
struct timeval tt;
FILE *lfd;
struct ex_list *exec_list;

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

#ifdef _WIN32

static int get_dns_addr(struct in_addr *pdns_addr)
{
    FIXED_INFO *FixedInfo=NULL;
    ULONG    BufLen;
    DWORD    ret;
    IP_ADDR_STRING *pIPAddr;
    struct in_addr tmp_addr;
    
    FixedInfo = (FIXED_INFO *)GlobalAlloc(GPTR, sizeof(FIXED_INFO));
    BufLen = sizeof(FIXED_INFO);
   
    if (ERROR_BUFFER_OVERFLOW == GetNetworkParams(FixedInfo, &BufLen)) {
        if (FixedInfo) {
            GlobalFree(FixedInfo);
            FixedInfo = NULL;
        }
        FixedInfo = GlobalAlloc(GPTR, BufLen);
    }
        
    if ((ret = GetNetworkParams(FixedInfo, &BufLen)) != ERROR_SUCCESS) {
        printf("GetNetworkParams failed. ret = %08x\n", (u_int)ret );
        if (FixedInfo) {
            GlobalFree(FixedInfo);
            FixedInfo = NULL;
        }
        return -1;
    }
     
    pIPAddr = &(FixedInfo->DnsServerList);
    inet_aton(pIPAddr->IpAddress.String, &tmp_addr);
    *pdns_addr = tmp_addr;
#if 0
    printf( "DNS Servers:\n" );
    printf( "DNS Addr:%s\n", pIPAddr->IpAddress.String );
    
    pIPAddr = FixedInfo -> DnsServerList.Next;
    while ( pIPAddr ) {
            printf( "DNS Addr:%s\n", pIPAddr ->IpAddress.String );
            pIPAddr = pIPAddr ->Next;
    }
#endif
    if (FixedInfo) {
        GlobalFree(FixedInfo);
        FixedInfo = NULL;
    }
    return 0;
}

#else

static int get_dns_addr(struct in_addr *pdns_addr)
{
    char buff[512];
    char buff2[256];
    FILE *f;
    int found = 0;
    struct in_addr tmp_addr;
    
    f = fopen("/etc/resolv.conf", "r");
    if (!f)
        return -1;

    lprint("IP address of your DNS(s): ");
    while (fgets(buff, 512, f) != NULL) {
        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 (!found)
                *pdns_addr = tmp_addr;
            else
                lprint(", ");
            if (++found > 3) {
                lprint("(more)");
                break;
            } else
                lprint("%s", inet_ntoa(tmp_addr));
        }
    }
    fclose(f);
    if (!found)
        return -1;
    return 0;
}

#endif

#ifdef _WIN32
void slirp_cleanup(void)
{
    WSACleanup();
}
#endif

void slirp_init(void)
{
    //    debug_init("/tmp/slirp.log", DEBUG_DEFAULT);
    
#ifdef _WIN32
    {
        WSADATA Data;
        WSAStartup(MAKEWORD(2,0), &Data);
        atexit(slirp_cleanup);
    }
#endif

    link_up = 1;

    if_init();
    ip_init();

    /* Initialise mbufs *after* setting the MTU */
    m_init();

    /* set default addresses */
    getouraddr();
    inet_aton("127.0.0.1", &loopback_addr);

    if (get_dns_addr(&dns_addr) < 0) {
        fprintf(stderr, "Could not get DNS address\n");
        exit(1);
    }

    inet_aton(CTL_SPECIAL, &special_addr);
}

#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 kept to an accuracy of 1ms
 */
#ifdef _WIN32
static void updtime(void)
{
    struct _timeb tb;

    _ftime(&tb);
    curtime = (u_int)tb.time * (u_int)1000;
    curtime += (u_int)tb.millitm;
}
#else
static void updtime(void)
{
        gettimeofday(&tt, 0);
        
        curtime = (u_int)tt.tv_sec * (u_int)1000;
        curtime += (u_int)tt.tv_usec / (u_int)1000;
        
        if ((tt.tv_usec % 1000) >= 500)
           curtime++;
}
#endif

void slirp_select_fill(int *pnfds, 
                       fd_set *readfds, fd_set *writefds, fd_set *xfds)
{
    struct socket *so, *so_next;
    struct timeval timeout;
    int nfds;
    int tmp_time;

    /* fail safe */
    global_readfds = NULL;
    global_writefds = NULL;
    global_xfds = NULL;
    
    nfds = *pnfds;
        /*
         * First, TCP sockets
         */
        do_slowtimo = 0;
        if (link_up) {
                /* 
                 * *_slowtimo needs calling if there are IP fragments
                 * in the fragment queue, or there are TCP connections active
                 */
                do_slowtimo = ((tcb.so_next != &tcb) ||
                               ((struct ipasfrag *)&ipq != (struct ipasfrag *)ipq.next));
                
                for (so = tcb.so_next; so != &tcb; so = so_next) {
                        so_next = so->so_next;
                        
                        /*
                         * See if we need a tcp_fasttimo
                         */
                        if (time_fasttimo == 0 && so->so_tcpcb->t_flags & TF_DELACK)
                           time_fasttimo = curtime; /* Flag when we want a fasttimo */
                        
                        /*
                         * NOFDREF can include still connecting to local-host,
                         * newly socreated() sockets etc. Don't want to select these.
                         */
                        if (so->so_state & SS_NOFDREF || so->s == -1)
                           continue;
                        
                        /*
                         * Set for reading sockets which are accepting
                         */
                        if (so->so_state & SS_FACCEPTCONN) {
                                FD_SET(so->s, readfds);
                                UPD_NFDS(so->s);
                                continue;
                        }
                        
                        /*
                         * Set for writing sockets which are connecting
                         */
                        if (so->so_state & SS_ISFCONNECTING) {
                                FD_SET(so->s, writefds);
                                UPD_NFDS(so->s);
                                continue;
                        }
                        
                        /*
                         * Set for writing if we are connected, can send more, and
                         * we have something to send
                         */
                        if (CONN_CANFSEND(so) && so->so_rcv.sb_cc) {
                                FD_SET(so->s, writefds);
                                UPD_NFDS(so->s);
                        }
                        
                        /*
                         * Set for reading (and urgent data) if we are connected, can
                         * receive more, and we have room for it XXX /2 ?
                         */
                        if (CONN_CANFRCV(so) && (so->so_snd.sb_cc < (so->so_snd.sb_datalen/2))) {
                                FD_SET(so->s, readfds);
                                FD_SET(so->s, xfds);
                                UPD_NFDS(so->s);
                        }
                }
                
                /*
                 * UDP sockets
                 */
                for (so = udb.so_next; so != &udb; so = so_next) {
                        so_next = so->so_next;
                        
                        /*
                         * See if it's timed out
                         */
                        if (so->so_expire) {
                                if (so->so_expire <= curtime) {
                                        udp_detach(so);
                                        continue;
                                } else
                                        do_slowtimo = 1; /* Let socket expire */
                        }
                        
                        /*
                         * When UDP packets are received from over the
                         * link, they're sendto()'d straight away, so
                         * no need for setting for writing
                         * Limit the number of packets queued by this session
                         * to 4.  Note that even though we try and limit this
                         * to 4 packets, the session could have more queued
                         * if the packets needed to be fragmented
                         * (XXX <= 4 ?)
                         */
                        if ((so->so_state & SS_ISFCONNECTED) && so->so_queued <= 4) {
                                FD_SET(so->s, readfds);
                                UPD_NFDS(so->s);
                        }
                }
        }
        
        /*
         * Setup timeout to use minimum CPU usage, especially when idle
         */
        
        /* 
         * First, see the timeout needed by *timo
         */
        timeout.tv_sec = 0;
        timeout.tv_usec = -1;
        /*
         * If a slowtimo is needed, set timeout to 500ms from the last
         * slow timeout. If a fast timeout is needed, set timeout within
         * 200ms of when it was requested.
         */
        if (do_slowtimo) {
                /* XXX + 10000 because some select()'s aren't that accurate */
                timeout.tv_usec = ((500 - (curtime - last_slowtimo)) * 1000) + 10000;
                if (timeout.tv_usec < 0)
                   timeout.tv_usec = 0;
                else if (timeout.tv_usec > 510000)
                   timeout.tv_usec = 510000;
                
                /* Can only fasttimo if we also slowtimo */
                if (time_fasttimo) {
                        tmp_time = (200 - (curtime - time_fasttimo)) * 1000;
                        if (tmp_time < 0)
                           tmp_time = 0;
                        
                        /* Choose the smallest of the 2 */
                        if (tmp_time < timeout.tv_usec)
                           timeout.tv_usec = (u_int)tmp_time;
                }
        }
        *pnfds = nfds;
}       

void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds)
{
    struct socket *so, *so_next;
    int ret;

    global_readfds = readfds;
    global_writefds = writefds;
    global_xfds = xfds;

        /* Update time */
        updtime();
        
        /*
         * See if anything has timed out 
         */
        if (link_up) {
                if (time_fasttimo && ((curtime - time_fasttimo) >= 199)) {
                        tcp_fasttimo();
                        time_fasttimo = 0;
                }
                if (do_slowtimo && ((curtime - last_slowtimo) >= 499)) {
                        ip_slowtimo();
                        tcp_slowtimo();
                        last_slowtimo = curtime;
                }
        }
        
        /*
         * Check sockets
         */
        if (link_up) {
                /*
                 * Check TCP sockets
                 */
                for (so = tcb.so_next; so != &tcb; so = so_next) {
                        so_next = so->so_next;
                        
                        /*
                         * FD_ISSET is meaningless on these sockets
                         * (and they can crash the program)
                         */
                        if (so->so_state & SS_NOFDREF || so->s == -1)
                           continue;
                        
                        /*
                         * Check for URG data
                         * This will soread as well, so no need to
                         * test for readfds below if this succeeds
                         */
                        if (FD_ISSET(so->s, xfds))
                           sorecvoob(so);
                        /*
                         * Check sockets for reading
                         */
                        else if (FD_ISSET(so->s, readfds)) {
                                /*
                                 * Check for incoming connections
                                 */
                                if (so->so_state & SS_FACCEPTCONN) {
                                        tcp_connect(so);
                                        continue;
                                } /* else */
                                ret = soread(so);
                                
                                /* Output it if we read something */
                                if (ret > 0)
                                   tcp_output(sototcpcb(so));
                        }
                        
                        /*
                         * Check sockets for writing
                         */
                        if (FD_ISSET(so->s, writefds)) {
                          /*
                           * Check for non-blocking, still-connecting sockets
                           */
                          if (so->so_state & SS_ISFCONNECTING) {
                            /* Connected */
                            so->so_state &= ~SS_ISFCONNECTING;
                            
                            ret = send(so->s, &ret, 0, 0);
                            if (ret < 0) {
                              /* XXXXX Must fix, zero bytes is a NOP */
                              if (errno == EAGAIN || errno == EWOULDBLOCK ||
                                  errno == EINPROGRESS || errno == ENOTCONN)
                                continue;
                              
                              /* else failed */
                              so->so_state = SS_NOFDREF;
                            }
                            /* else so->so_state &= ~SS_ISFCONNECTING; */
                            
                            /*
                             * Continue tcp_input
                             */
                            tcp_input((struct mbuf *)NULL, sizeof(struct ip), so);
                            /* continue; */
                          } else
                            ret = sowrite(so);
                          /*
                           * XXXXX If we wrote something (a lot), there 
                           * could be a need for a window update.
                           * In the worst case, the remote will send
                           * a window probe to get things going again
                           */
                        }
                        
                        /*
                         * Probe a still-connecting, non-blocking socket
                         * to check if it's still alive
                         */
#ifdef PROBE_CONN
                        if (so->so_state & SS_ISFCONNECTING) {
                          ret = recv(so->s, (char *)&ret, 0,0);
                          
                          if (ret < 0) {
                            /* XXX */
                            if (errno == EAGAIN || errno == EWOULDBLOCK ||
                                errno == EINPROGRESS || errno == ENOTCONN)
                              continue; /* Still connecting, continue */
                            
                            /* else failed */
                            so->so_state = SS_NOFDREF;
                            
                            /* tcp_input will take care of it */
                          } else {
                            ret = send(so->s, &ret, 0,0);
                            if (ret < 0) {
                              /* XXX */
                              if (errno == EAGAIN || errno == EWOULDBLOCK ||
                                  errno == EINPROGRESS || errno == ENOTCONN)
                                continue;
                              /* else failed */
                              so->so_state = SS_NOFDREF;
                            } else
                              so->so_state &= ~SS_ISFCONNECTING;
                            
                          }
                          tcp_input((struct mbuf *)NULL, sizeof(struct ip),so);
                        } /* SS_ISFCONNECTING */
#endif
                }
                
                /*
                 * Now UDP sockets.
                 * Incoming packets are sent straight away, they're not buffered.
                 * Incoming UDP data isn't buffered either.
                 */
                for (so = udb.so_next; so != &udb; so = so_next) {
                        so_next = so->so_next;
                        
                        if (so->s != -1 && FD_ISSET(so->s, readfds)) {
                            sorecvfrom(so);
                        }
                }
        }
        
        /*
         * See if we can start outputting
         */
        if (if_queued && link_up)
           if_start();

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

#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      */
        unsigned char           ar_sip[4];              /* sender IP address            */
        unsigned char           ar_tha[ETH_ALEN];       /* target hardware address      */
        unsigned char           ar_tip[4];              /* target IP address            */
};

void arp_input(const uint8_t *pkt, int pkt_len)
{
    struct ethhdr *eh = (struct ethhdr *)pkt;
    struct arphdr *ah = (struct arphdr *)(pkt + ETH_HLEN);
    uint8_t arp_reply[ETH_HLEN + sizeof(struct arphdr)];
    struct ethhdr *reh = (struct ethhdr *)arp_reply;
    struct arphdr *rah = (struct arphdr *)(arp_reply + ETH_HLEN);
    int ar_op;
    struct ex_list *ex_ptr;

    ar_op = ntohs(ah->ar_op);
    switch(ar_op) {
    case ARPOP_REQUEST:
        if (!memcmp(ah->ar_tip, &special_addr, 3)) {
            if (ah->ar_tip[3] == CTL_DNS || ah->ar_tip[3] == CTL_ALIAS) 
                goto arp_ok;
            for (ex_ptr = exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
                if (ex_ptr->ex_addr == ah->ar_tip[3])
                    goto arp_ok;
            }
            return;
        arp_ok:
            /* XXX: make an ARP request to have the client address */
            memcpy(client_ethaddr, eh->h_source, ETH_ALEN);

            /* ARP request for alias/dns mac address */
            memcpy(reh->h_dest, pkt + ETH_ALEN, ETH_ALEN);
            memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 1);
            reh->h_source[5] = ah->ar_tip[3];
            reh->h_proto = htons(ETH_P_ARP);

            rah->ar_hrd = htons(1);
            rah->ar_pro = htons(ETH_P_IP);
            rah->ar_hln = ETH_ALEN;
            rah->ar_pln = 4;
            rah->ar_op = htons(ARPOP_REPLY);
            memcpy(rah->ar_sha, reh->h_source, ETH_ALEN);
            memcpy(rah->ar_sip, ah->ar_tip, 4);
            memcpy(rah->ar_tha, ah->ar_sha, ETH_ALEN);
            memcpy(rah->ar_tip, ah->ar_sip, 4);
            slirp_output(arp_reply, sizeof(arp_reply));
        }
        break;
    default:
        break;
    }
}

void slirp_input(const uint8_t *pkt, int pkt_len)
{
    struct mbuf *m;
    int proto;

    if (pkt_len < ETH_HLEN)
        return;
    
    proto = ntohs(*(uint16_t *)(pkt + 12));
    switch(proto) {
    case ETH_P_ARP:
        arp_input(pkt, pkt_len);
        break;
    case ETH_P_IP:
        m = m_get();
        if (!m)
            return;
        m->m_len = pkt_len;
        memcpy(m->m_data, pkt, pkt_len);

        m->m_data += ETH_HLEN;
        m->m_len -= ETH_HLEN;

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

/* output the IP packet to the ethernet device */
void if_encap(const uint8_t *ip_data, int ip_data_len)
{
    uint8_t buf[1600];
    struct ethhdr *eh = (struct ethhdr *)buf;

    if (ip_data_len + ETH_HLEN > sizeof(buf))
        return;

    memcpy(eh->h_dest, client_ethaddr, ETH_ALEN);
    memcpy(eh->h_source, special_ethaddr, ETH_ALEN - 1);
    /* XXX: not correct */
    eh->h_source[5] = CTL_ALIAS;
    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);
}

int slirp_redir(int is_udp, int host_port, 
                struct in_addr guest_addr, int guest_port)
{
    if (is_udp) {
        if (!udp_listen(htons(host_port), guest_addr.s_addr, 
                        htons(guest_port), 0))
            return -1;
    } else {
        if (!solisten(htons(host_port), guest_addr.s_addr, 
                      htons(guest_port), 0))
            return -1;
    }
    return 0;
}

int slirp_add_exec(int do_pty, const char *args, int addr_low_byte, 
                  int guest_port)
{
    return add_exec(&exec_list, do_pty, (char *)args, 
                    addr_low_byte, htons(guest_port));
}
Revision:	1.1
Committed:	2005-05-13T09:00:59Z (19 years, 4 months ago) by gbeauche
Content type:	text/plain
Branch:	MAIN
Log Message:	slirp user mode network emulation code from qemu
#	User	Rev	Content
1	gbeauche	1.1	#include "slirp.h"
2
3			/* host address */
4			struct in_addr our_addr;
5			/* host dns address */
6			struct in_addr dns_addr;
7			/* host loopback address */
8			struct in_addr loopback_addr;
9
10			/* address for slirp virtual addresses */
11			struct in_addr special_addr;
12
13			const uint8_t special_ethaddr[6] = {
14			0x52, 0x54, 0x00, 0x12, 0x35, 0x00
15			};
16
17			uint8_t client_ethaddr[6];
18
19			int do_slowtimo;
20			int link_up;
21			struct timeval tt;
22			FILE *lfd;
23			struct ex_list *exec_list;
24
25			/* XXX: suppress those select globals */
26			fd_set global_readfds, global_writefds, *global_xfds;
27
28			#ifdef _WIN32
29
30			static int get_dns_addr(struct in_addr *pdns_addr)
31			{
32			FIXED_INFO *FixedInfo=NULL;
33			ULONG BufLen;
34			DWORD ret;
35			IP_ADDR_STRING *pIPAddr;
36			struct in_addr tmp_addr;
37
38			FixedInfo = (FIXED_INFO *)GlobalAlloc(GPTR, sizeof(FIXED_INFO));
39			BufLen = sizeof(FIXED_INFO);
40
41			if (ERROR_BUFFER_OVERFLOW == GetNetworkParams(FixedInfo, &BufLen)) {
42			if (FixedInfo) {
43			GlobalFree(FixedInfo);
44			FixedInfo = NULL;
45			}
46			FixedInfo = GlobalAlloc(GPTR, BufLen);
47			}
48
49			if ((ret = GetNetworkParams(FixedInfo, &BufLen)) != ERROR_SUCCESS) {
50			printf("GetNetworkParams failed. ret = %08x\n", (u_int)ret );
51			if (FixedInfo) {
52			GlobalFree(FixedInfo);
53			FixedInfo = NULL;
54			}
55			return -1;
56			}
57
58			pIPAddr = &(FixedInfo->DnsServerList);
59			inet_aton(pIPAddr->IpAddress.String, &tmp_addr);
60			*pdns_addr = tmp_addr;
61			#if 0
62			printf( "DNS Servers:\n" );
63			printf( "DNS Addr:%s\n", pIPAddr->IpAddress.String );
64
65			pIPAddr = FixedInfo -> DnsServerList.Next;
66			while ( pIPAddr ) {
67			printf( "DNS Addr:%s\n", pIPAddr ->IpAddress.String );
68			pIPAddr = pIPAddr ->Next;
69			}
70			#endif
71			if (FixedInfo) {
72			GlobalFree(FixedInfo);
73			FixedInfo = NULL;
74			}
75			return 0;
76			}
77
78			#else
79
80			static int get_dns_addr(struct in_addr *pdns_addr)
81			{
82			char buff[512];
83			char buff2[256];
84			FILE *f;
85			int found = 0;
86			struct in_addr tmp_addr;
87
88			f = fopen("/etc/resolv.conf", "r");
89			if (!f)
90			return -1;
91
92			lprint("IP address of your DNS(s): ");
93			while (fgets(buff, 512, f) != NULL) {
94			if (sscanf(buff, "nameserver%*[ \t]%256s", buff2) == 1) {
95			if (!inet_aton(buff2, &tmp_addr))
96			continue;
97			if (tmp_addr.s_addr == loopback_addr.s_addr)
98			tmp_addr = our_addr;
99			/* If it's the first one, set it to dns_addr */
100			if (!found)
101			*pdns_addr = tmp_addr;
102			else
103			lprint(", ");
104			if (++found > 3) {
105			lprint("(more)");
106			break;
107			} else
108			lprint("%s", inet_ntoa(tmp_addr));
109			}
110			}
111			fclose(f);
112			if (!found)
113			return -1;
114			return 0;
115			}
116
117			#endif
118
119			#ifdef _WIN32
120			void slirp_cleanup(void)
121			{
122			WSACleanup();
123			}
124			#endif
125
126			void slirp_init(void)
127			{
128			// debug_init("/tmp/slirp.log", DEBUG_DEFAULT);
129
130			#ifdef _WIN32
131			{
132			WSADATA Data;
133			WSAStartup(MAKEWORD(2,0), &Data);
134			atexit(slirp_cleanup);
135			}
136			#endif
137
138			link_up = 1;
139
140			if_init();
141			ip_init();
142
143			/* Initialise mbufs after setting the MTU */
144			m_init();
145
146			/* set default addresses */
147			getouraddr();
148			inet_aton("127.0.0.1", &loopback_addr);
149
150			if (get_dns_addr(&dns_addr) < 0) {
151			fprintf(stderr, "Could not get DNS address\n");
152			exit(1);
153			}
154
155			inet_aton(CTL_SPECIAL, &special_addr);
156			}
157
158			#define CONN_CANFSEND(so) (((so)->so_state & (SS_FCANTSENDMORE\|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
159			#define CONN_CANFRCV(so) (((so)->so_state & (SS_FCANTRCVMORE\|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
160			#define UPD_NFDS(x) if (nfds < (x)) nfds = (x)
161
162			/*
163			* curtime kept to an accuracy of 1ms
164			*/
165			#ifdef _WIN32
166			static void updtime(void)
167			{
168			struct _timeb tb;
169
170			_ftime(&tb);
171			curtime = (u_int)tb.time * (u_int)1000;
172			curtime += (u_int)tb.millitm;
173			}
174			#else
175			static void updtime(void)
176			{
177			gettimeofday(&tt, 0);
178
179			curtime = (u_int)tt.tv_sec * (u_int)1000;
180			curtime += (u_int)tt.tv_usec / (u_int)1000;
181
182			if ((tt.tv_usec % 1000) >= 500)
183			curtime++;
184			}
185			#endif
186
187			void slirp_select_fill(int *pnfds,
188			fd_set readfds, fd_set writefds, fd_set *xfds)
189			{
190			struct socket so, so_next;
191			struct timeval timeout;
192			int nfds;
193			int tmp_time;
194
195			/* fail safe */
196			global_readfds = NULL;
197			global_writefds = NULL;
198			global_xfds = NULL;
199
200			nfds = *pnfds;
201			/*
202			* First, TCP sockets
203			*/
204			do_slowtimo = 0;
205			if (link_up) {
206			/*
207			* *_slowtimo needs calling if there are IP fragments
208			* in the fragment queue, or there are TCP connections active
209			*/
210			do_slowtimo = ((tcb.so_next != &tcb) \|\|
211			((struct ipasfrag )&ipq != (struct ipasfrag )ipq.next));
212
213			for (so = tcb.so_next; so != &tcb; so = so_next) {
214			so_next = so->so_next;
215
216			/*
217			* See if we need a tcp_fasttimo
218			*/
219			if (time_fasttimo == 0 && so->so_tcpcb->t_flags & TF_DELACK)
220			time_fasttimo = curtime; /* Flag when we want a fasttimo */
221
222			/*
223			* NOFDREF can include still connecting to local-host,
224			* newly socreated() sockets etc. Don't want to select these.
225			*/
226			if (so->so_state & SS_NOFDREF \|\| so->s == -1)
227			continue;
228
229			/*
230			* Set for reading sockets which are accepting
231			*/
232			if (so->so_state & SS_FACCEPTCONN) {
233			FD_SET(so->s, readfds);
234			UPD_NFDS(so->s);
235			continue;
236			}
237
238			/*
239			* Set for writing sockets which are connecting
240			*/
241			if (so->so_state & SS_ISFCONNECTING) {
242			FD_SET(so->s, writefds);
243			UPD_NFDS(so->s);
244			continue;
245			}
246
247			/*
248			* Set for writing if we are connected, can send more, and
249			* we have something to send
250			*/
251			if (CONN_CANFSEND(so) && so->so_rcv.sb_cc) {
252			FD_SET(so->s, writefds);
253			UPD_NFDS(so->s);
254			}
255
256			/*
257			* Set for reading (and urgent data) if we are connected, can
258			* receive more, and we have room for it XXX /2 ?
259			*/
260			if (CONN_CANFRCV(so) && (so->so_snd.sb_cc < (so->so_snd.sb_datalen/2))) {
261			FD_SET(so->s, readfds);
262			FD_SET(so->s, xfds);
263			UPD_NFDS(so->s);
264			}
265			}
266
267			/*
268			* UDP sockets
269			*/
270			for (so = udb.so_next; so != &udb; so = so_next) {
271			so_next = so->so_next;
272
273			/*
274			* See if it's timed out
275			*/
276			if (so->so_expire) {
277			if (so->so_expire <= curtime) {
278			udp_detach(so);
279			continue;
280			} else
281			do_slowtimo = 1; /* Let socket expire */
282			}
283
284			/*
285			* When UDP packets are received from over the
286			* link, they're sendto()'d straight away, so
287			* no need for setting for writing
288			* Limit the number of packets queued by this session
289			* to 4. Note that even though we try and limit this
290			* to 4 packets, the session could have more queued
291			* if the packets needed to be fragmented
292			* (XXX <= 4 ?)
293			*/
294			if ((so->so_state & SS_ISFCONNECTED) && so->so_queued <= 4) {
295			FD_SET(so->s, readfds);
296			UPD_NFDS(so->s);
297			}
298			}
299			}
300
301			/*
302			* Setup timeout to use minimum CPU usage, especially when idle
303			*/
304
305			/*
306			* First, see the timeout needed by *timo
307			*/
308			timeout.tv_sec = 0;
309			timeout.tv_usec = -1;
310			/*
311			* If a slowtimo is needed, set timeout to 500ms from the last
312			* slow timeout. If a fast timeout is needed, set timeout within
313			* 200ms of when it was requested.
314			*/
315			if (do_slowtimo) {
316			/* XXX + 10000 because some select()'s aren't that accurate */
317			timeout.tv_usec = ((500 - (curtime - last_slowtimo)) * 1000) + 10000;
318			if (timeout.tv_usec < 0)
319			timeout.tv_usec = 0;
320			else if (timeout.tv_usec > 510000)
321			timeout.tv_usec = 510000;
322
323			/* Can only fasttimo if we also slowtimo */
324			if (time_fasttimo) {
325			tmp_time = (200 - (curtime - time_fasttimo)) * 1000;
326			if (tmp_time < 0)
327			tmp_time = 0;
328
329			/* Choose the smallest of the 2 */
330			if (tmp_time < timeout.tv_usec)
331			timeout.tv_usec = (u_int)tmp_time;
332			}
333			}
334			*pnfds = nfds;
335			}
336
337			void slirp_select_poll(fd_set readfds, fd_set writefds, fd_set *xfds)
338			{
339			struct socket so, so_next;
340			int ret;
341
342			global_readfds = readfds;
343			global_writefds = writefds;
344			global_xfds = xfds;
345
346			/* Update time */
347			updtime();
348
349			/*
350			* See if anything has timed out
351			*/
352			if (link_up) {
353			if (time_fasttimo && ((curtime - time_fasttimo) >= 199)) {
354			tcp_fasttimo();
355			time_fasttimo = 0;
356			}
357			if (do_slowtimo && ((curtime - last_slowtimo) >= 499)) {
358			ip_slowtimo();
359			tcp_slowtimo();
360			last_slowtimo = curtime;
361			}
362			}
363
364			/*
365			* Check sockets
366			*/
367			if (link_up) {
368			/*
369			* Check TCP sockets
370			*/
371			for (so = tcb.so_next; so != &tcb; so = so_next) {
372			so_next = so->so_next;
373
374			/*
375			* FD_ISSET is meaningless on these sockets
376			* (and they can crash the program)
377			*/
378			if (so->so_state & SS_NOFDREF \|\| so->s == -1)
379			continue;
380
381			/*
382			* Check for URG data
383			* This will soread as well, so no need to
384			* test for readfds below if this succeeds
385			*/
386			if (FD_ISSET(so->s, xfds))
387			sorecvoob(so);
388			/*
389			* Check sockets for reading
390			*/
391			else if (FD_ISSET(so->s, readfds)) {
392			/*
393			* Check for incoming connections
394			*/
395			if (so->so_state & SS_FACCEPTCONN) {
396			tcp_connect(so);
397			continue;
398			} /* else */
399			ret = soread(so);
400
401			/* Output it if we read something */
402			if (ret > 0)
403			tcp_output(sototcpcb(so));
404			}
405
406			/*
407			* Check sockets for writing
408			*/
409			if (FD_ISSET(so->s, writefds)) {
410			/*
411			* Check for non-blocking, still-connecting sockets
412			*/
413			if (so->so_state & SS_ISFCONNECTING) {
414			/* Connected */
415			so->so_state &= ~SS_ISFCONNECTING;
416
417			ret = send(so->s, &ret, 0, 0);
418			if (ret < 0) {
419			/* XXXXX Must fix, zero bytes is a NOP */
420			if (errno == EAGAIN \|\| errno == EWOULDBLOCK \|\|
421			errno == EINPROGRESS \|\| errno == ENOTCONN)
422			continue;
423
424			/* else failed */
425			so->so_state = SS_NOFDREF;
426			}
427			/* else so->so_state &= ~SS_ISFCONNECTING; */
428
429			/*
430			* Continue tcp_input
431			*/
432			tcp_input((struct mbuf *)NULL, sizeof(struct ip), so);
433			/* continue; */
434			} else
435			ret = sowrite(so);
436			/*
437			* XXXXX If we wrote something (a lot), there
438			* could be a need for a window update.
439			* In the worst case, the remote will send
440			* a window probe to get things going again
441			*/
442			}
443
444			/*
445			* Probe a still-connecting, non-blocking socket
446			* to check if it's still alive
447			*/
448			#ifdef PROBE_CONN
449			if (so->so_state & SS_ISFCONNECTING) {
450			ret = recv(so->s, (char *)&ret, 0,0);
451
452			if (ret < 0) {
453			/* XXX */
454			if (errno == EAGAIN \|\| errno == EWOULDBLOCK \|\|
455			errno == EINPROGRESS \|\| errno == ENOTCONN)
456			continue; /* Still connecting, continue */
457
458			/* else failed */
459			so->so_state = SS_NOFDREF;
460
461			/* tcp_input will take care of it */
462			} else {
463			ret = send(so->s, &ret, 0,0);
464			if (ret < 0) {
465			/* XXX */
466			if (errno == EAGAIN \|\| errno == EWOULDBLOCK \|\|
467			errno == EINPROGRESS \|\| errno == ENOTCONN)
468			continue;
469			/* else failed */
470			so->so_state = SS_NOFDREF;
471			} else
472			so->so_state &= ~SS_ISFCONNECTING;
473
474			}
475			tcp_input((struct mbuf *)NULL, sizeof(struct ip),so);
476			} /* SS_ISFCONNECTING */
477			#endif
478			}
479
480			/*
481			* Now UDP sockets.
482			* Incoming packets are sent straight away, they're not buffered.
483			* Incoming UDP data isn't buffered either.
484			*/
485			for (so = udb.so_next; so != &udb; so = so_next) {
486			so_next = so->so_next;
487
488			if (so->s != -1 && FD_ISSET(so->s, readfds)) {
489			sorecvfrom(so);
490			}
491			}
492			}
493
494			/*
495			* See if we can start outputting
496			*/
497			if (if_queued && link_up)
498			if_start();
499
500			/* clear global file descriptor sets.
501			* these reside on the stack in vl.c
502			* so they're unusable if we're not in
503			* slirp_select_fill or slirp_select_poll.
504			*/
505			global_readfds = NULL;
506			global_writefds = NULL;
507			global_xfds = NULL;
508			}
509
510			#define ETH_ALEN 6
511			#define ETH_HLEN 14
512
513			#define ETH_P_IP 0x0800 /* Internet Protocol packet */
514			#define ETH_P_ARP 0x0806 /* Address Resolution packet */
515
516			#define ARPOP_REQUEST 1 /* ARP request */
517			#define ARPOP_REPLY 2 /* ARP reply */
518
519			struct ethhdr
520			{
521			unsigned char h_dest[ETH_ALEN]; /* destination eth addr */
522			unsigned char h_source[ETH_ALEN]; /* source ether addr */
523			unsigned short h_proto; /* packet type ID field */
524			};
525
526			struct arphdr
527			{
528			unsigned short ar_hrd; /* format of hardware address */
529			unsigned short ar_pro; /* format of protocol address */
530			unsigned char ar_hln; /* length of hardware address */
531			unsigned char ar_pln; /* length of protocol address */
532			unsigned short ar_op; /* ARP opcode (command) */
533
534			/*
535			* Ethernet looks like this : This bit is variable sized however...
536			*/
537			unsigned char ar_sha[ETH_ALEN]; /* sender hardware address */
538			unsigned char ar_sip[4]; /* sender IP address */
539			unsigned char ar_tha[ETH_ALEN]; /* target hardware address */
540			unsigned char ar_tip[4]; /* target IP address */
541			};
542
543			void arp_input(const uint8_t *pkt, int pkt_len)
544			{
545			struct ethhdr eh = (struct ethhdr )pkt;
546			struct arphdr ah = (struct arphdr )(pkt + ETH_HLEN);
547			uint8_t arp_reply[ETH_HLEN + sizeof(struct arphdr)];
548			struct ethhdr reh = (struct ethhdr )arp_reply;
549			struct arphdr rah = (struct arphdr )(arp_reply + ETH_HLEN);
550			int ar_op;
551			struct ex_list *ex_ptr;
552
553			ar_op = ntohs(ah->ar_op);
554			switch(ar_op) {
555			case ARPOP_REQUEST:
556			if (!memcmp(ah->ar_tip, &special_addr, 3)) {
557			if (ah->ar_tip[3] == CTL_DNS \|\| ah->ar_tip[3] == CTL_ALIAS)
558			goto arp_ok;
559			for (ex_ptr = exec_list; ex_ptr; ex_ptr = ex_ptr->ex_next) {
560			if (ex_ptr->ex_addr == ah->ar_tip[3])
561			goto arp_ok;
562			}
563			return;
564			arp_ok:
565			/* XXX: make an ARP request to have the client address */
566			memcpy(client_ethaddr, eh->h_source, ETH_ALEN);
567
568			/* ARP request for alias/dns mac address */
569			memcpy(reh->h_dest, pkt + ETH_ALEN, ETH_ALEN);
570			memcpy(reh->h_source, special_ethaddr, ETH_ALEN - 1);
571			reh->h_source[5] = ah->ar_tip[3];
572			reh->h_proto = htons(ETH_P_ARP);
573
574			rah->ar_hrd = htons(1);
575			rah->ar_pro = htons(ETH_P_IP);
576			rah->ar_hln = ETH_ALEN;
577			rah->ar_pln = 4;
578			rah->ar_op = htons(ARPOP_REPLY);
579			memcpy(rah->ar_sha, reh->h_source, ETH_ALEN);
580			memcpy(rah->ar_sip, ah->ar_tip, 4);
581			memcpy(rah->ar_tha, ah->ar_sha, ETH_ALEN);
582			memcpy(rah->ar_tip, ah->ar_sip, 4);
583			slirp_output(arp_reply, sizeof(arp_reply));
584			}
585			break;
586			default:
587			break;
588			}
589			}
590
591			void slirp_input(const uint8_t *pkt, int pkt_len)
592			{
593			struct mbuf *m;
594			int proto;
595
596			if (pkt_len < ETH_HLEN)
597			return;
598
599			proto = ntohs((uint16_t )(pkt + 12));
600			switch(proto) {
601			case ETH_P_ARP:
602			arp_input(pkt, pkt_len);
603			break;
604			case ETH_P_IP:
605			m = m_get();
606			if (!m)
607			return;
608			m->m_len = pkt_len;
609			memcpy(m->m_data, pkt, pkt_len);
610
611			m->m_data += ETH_HLEN;
612			m->m_len -= ETH_HLEN;
613
614			ip_input(m);
615			break;
616			default:
617			break;
618			}
619			}
620
621			/* output the IP packet to the ethernet device */
622			void if_encap(const uint8_t *ip_data, int ip_data_len)
623			{
624			uint8_t buf[1600];
625			struct ethhdr eh = (struct ethhdr )buf;
626
627			if (ip_data_len + ETH_HLEN > sizeof(buf))
628			return;
629
630			memcpy(eh->h_dest, client_ethaddr, ETH_ALEN);
631			memcpy(eh->h_source, special_ethaddr, ETH_ALEN - 1);
632			/* XXX: not correct */
633			eh->h_source[5] = CTL_ALIAS;
634			eh->h_proto = htons(ETH_P_IP);
635			memcpy(buf + sizeof(struct ethhdr), ip_data, ip_data_len);
636			slirp_output(buf, ip_data_len + ETH_HLEN);
637			}
638
639			int slirp_redir(int is_udp, int host_port,
640			struct in_addr guest_addr, int guest_port)
641			{
642			if (is_udp) {
643			if (!udp_listen(htons(host_port), guest_addr.s_addr,
644			htons(guest_port), 0))
645			return -1;
646			} else {
647			if (!solisten(htons(host_port), guest_addr.s_addr,
648			htons(guest_port), 0))
649			return -1;
650			}
651			return 0;
652			}
653
654			int slirp_add_exec(int do_pty, const char *args, int addr_low_byte,
655			int guest_port)
656			{
657			return add_exec(&exec_list, do_pty, (char *)args,
658			addr_low_byte, htons(guest_port));
659			}