Archipelago » qemu

/* virtual address alias for host */

struct in_addr alias_addr;

    0x52, 0x54, 0x00, 0x12, 0x35, 0x00

};

    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 = GlobalAlloc(GPTR, BufLen);

    }

    if ((ret = GetNetworkParams(FixedInfo, &BufLen)) != ERROR_SUCCESS) {

        printf("GetNetworkParams failed. ret = %08x\n", (u_int)ret );

        if (FixedInfo) {

        }

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

    FILE *f;

    int found = 0;

    struct in_addr tmp_addr;

    f = fopen("/etc/resolv.conf", "r");

    if (!f)

        return -1;

void slirp_init(void)

{

    //    debug_init("/tmp/slirp.log", DEBUG_DEFAULT);

#ifdef _WIN32

    {

        WSADATA Data;

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

                       fd_set *readfds, fd_set *writefds, fd_set *xfds)

{

    struct socket *so, *so_next;

    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

			 */

				UPD_NFDS(so->s);

				continue;

			}

			/*

			 * Set for writing sockets which are connecting

			 */

				UPD_NFDS(so->s);

				continue;

			}

			/*

			 * Set for writing if we are connected, can send more, and

			 * we have something to send

				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 ?

				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

			 */

				} else

					do_slowtimo = 1; /* Let socket expire */

			}

			/*

			 * When UDP packets are received from over the

			 * link, they're sendto()'d straight away, so

			}

		}

	}

	/*

	 * Setup timeout to use minimum CPU usage, especially when idle

	 */

	 * First, see the timeout needed by *timo

	 */

	timeout.tv_sec = 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)

{

	/* Update time */

	updtime();

	/*

	 */

	if (link_up) {

		if (time_fasttimo && ((curtime - time_fasttimo) >= 2)) {

			last_slowtimo = curtime;

		}

	}

	/*

	 * Check 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

					continue;

				} /* else */

				ret = soread(so);

				/* Output it if we read something */

				if (ret > 0)

				   tcp_output(sototcpcb(so));

			}

			/*

			 * Check sockets for writing

			 */

			  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

			     */

			  } else

			    ret = sowrite(so);

			  /*

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

			      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.

		 */

		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

	 */

#define	ARPOP_REQUEST	1		/* ARP request			*/

#define	ARPOP_REPLY	2		/* ARP reply			*/

{

	unsigned char	h_dest[ETH_ALEN];	/* destination eth addr	*/

	unsigned char	h_source[ETH_ALEN];	/* source ether addr	*/

    switch(ar_op) {

    case ARPOP_REQUEST:

        if (!memcmp(ah->ar_tip, &special_addr, 3)) {

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

    if (pkt_len < ETH_HLEN)

        return;

    proto = ntohs(*(uint16_t *)(pkt + 12));

    switch(proto) {

    case ETH_P_ARP:

    slirp_output(buf, ip_data_len + ETH_HLEN);

}

                struct in_addr guest_addr, int guest_port)

{

    if (is_udp) {

                        htons(guest_port), 0))

            return -1;

    } else {

                      htons(guest_port), 0))

            return -1;

    }

    return 0;

}

                  int guest_port)

{

                    addr_low_byte, htons(guest_port));

}