slirp.c revision 8c2d9d7577b4de8ac96614f700b1ec83e0745336
#include "slirp.h"
#ifdef RT_OS_OS2
# include <paths.h>
#endif
#ifndef RT_OS_WINDOWS
# include <poll.h>
#else
# include <Winnls.h>
# define _WINSOCK2API_
# include <IPHlpApi.h>
#endif
#include <alias.h>
#ifndef RT_OS_WINDOWS
do { \
{ \
break; \
} \
poll_index++; \
} while (0)
do { \
{ \
break; \
} \
poll_index++; \
} while (0)
/* specific for Unix API */
/* specific for Windows Winsock API */
# ifndef RT_OS_LINUX
# define readfds_poll (POLLRDNORM)
# define writefds_poll (POLLWRNORM)
# else
# define readfds_poll (POLLIN)
# define writefds_poll (POLLOUT)
# endif
# define closefds_poll (POLLHUP)
# define rderr_poll (POLLERR)
# define rdhup_poll (POLLHUP)
do { \
} while (0)
#else /* RT_OS_WINDOWS */
/*
* On Windows, we will be notified by IcmpSendEcho2() when the response arrives.
* So no call to WSAEventSelect necessary.
*/
/*
* On Windows we use FD_ALL_EVENTS to ensure that we don't miss any event.
*/
do { \
if (rc == SOCKET_ERROR) \
{ \
/* This should not happen */ \
error = WSAGetLastError(); \
} \
} while (0); \
if ((rc) == SOCKET_ERROR) \
{ \
(error) = WSAGetLastError(); \
}
# define acceptds_win FD_ACCEPT
# define acceptds_win_bit FD_ACCEPT_BIT
# define readfds_win FD_READ
# define readfds_win_bit FD_READ_BIT
# define writefds_win FD_WRITE
# define writefds_win_bit FD_WRITE_BIT
# define xfds_win_bit FD_OOB_BIT
# define closefds_win FD_CLOSE
# define closefds_win_bit FD_CLOSE_BIT
#endif /* RT_OS_WINDOWS */
/*
* Loging macros
*/
# if defined(RT_OS_WINDOWS)
do { \
} while (0)
# else /* !RT_OS_WINDOWS */
do { \
} while (0)
# endif /* !RT_OS_WINDOWS */
#else /* !VBOX_WITH_DEBUG_NAT_SOCKETS */
#endif /* !VBOX_WITH_DEBUG_NAT_SOCKETS */
{
0x52, 0x54, 0x00, 0x12, 0x35, 0x00
};
{
0xff, 0xff, 0xff, 0xff, 0xff, 0xff
};
{
0x0, 0x0, 0x0, 0x0, 0x0, 0x0
};
#ifdef RT_OS_WINDOWS
const char **ppszDomain)
{
ULONG flags = GAA_FLAG_INCLUDE_PREFIX; /*GAA_FLAG_INCLUDE_ALL_INTERFACES;*/ /* all interfaces registered in NDIS */
int wlen = 0;
char *pszSuffix;
/* @todo add SKIPing flags to get only required information */
/* determine size of buffer */
size = 0;
if (ret != ERROR_BUFFER_OVERFLOW)
{
return -1;
}
if (size == 0)
{
LogRel(("NAT: Win socket API returns non capacity\n"));
return -1;
}
if (!pAdapterAddr)
{
LogRel(("NAT: No memory available \n"));
return -1;
}
if (ret != ERROR_SUCCESS)
{
return -1;
}
{
int found;
continue;
{
continue;
/* add dns server to list */
if (!pDns)
{
LogRel(("NAT: Can't allocate buffer for DNS entry\n"));
return VERR_NO_MEMORY;
}
else
continue;
/* uniq */
{
continue;
}
found = 0;
{
{
found = 1;
break;
}
}
if (!found)
{
if (!pDomain)
{
LogRel(("NAT: not enough memory\n"));
return VERR_NO_MEMORY;
}
}
}
}
return 0;
}
#else /* !RT_OS_WINDOWS */
{
char bTest;
int rc = VERR_NO_MEMORY;
*pcbRead = 0;
{
if (cbRead == 0)
return VERR_EOF;
{
*pu8Buf = 0;
return VINF_SUCCESS;
}
pu8Buf++;
(*pcbRead)++;
}
return rc;
}
const char **ppszDomain)
{
char buff[512];
char buff2[256];
RTFILE f;
int fFoundNameserver = 0;
int rc;
# ifdef RT_OS_OS2
/* Try various locations. */
if (etc)
{
}
if (RT_FAILURE(rc))
{
}
if (RT_FAILURE(rc))
{
}
# else /* !RT_OS_OS2 */
# ifndef DEBUG_vvl
# else
if (RT_SUCCESS(rc))
{
}
else
{
}
# endif
# endif /* !RT_OS_OS2 */
if (RT_FAILURE(rc))
return -1;
if (ppszDomain)
*ppszDomain = NULL;
Log(("NAT: DNS Servers:\n"));
{
{
continue;
/* localhost mask */
if (!pDns)
{
LogRel(("can't alloc memory for DNS entry\n"));
return -1;
}
/* check */
if ((pDns->de_addr.s_addr & RT_H2N_U32_C(IN_CLASSA_NET)) == RT_N2H_U32_C(INADDR_LOOPBACK & IN_CLASSA_NET))
{
}
}
{
char *tok;
char *saveptr;
int fFoundDomain = 0;
{
{
fFoundDomain = 1;
break;
}
}
{
if (!pDomain)
{
LogRel(("NAT: not enought memory to add domain list\n"));
return VERR_NO_MEMORY;
}
}
}
}
RTFileClose(f);
if (!fFoundNameserver)
return -1;
return 0;
}
#endif /* !RT_OS_WINDOWS */
{
}
{
{
}
{
}
}
{
}
#ifndef VBOX_WITH_NAT_SERVICE
#else
bool fPassDomain, void *pvUser)
#endif
{
int fNATfailed = 0;
int rc;
if (!pData)
return VERR_NO_MEMORY;
if (u32Netmask & 0x1f)
/* CTL is x.x.x.15, bootp passes up to 16 IPs (15..31) */
return VERR_INVALID_PARAMETER;
/* sockets & TCP defaults */
#ifdef RT_OS_WINDOWS
{
}
#endif
#ifdef VBOX_WITH_SLIRP_MT
#endif
link_up = 1;
if (rc != 0)
{
LogRel(("NAT: DHCP server initialization was failed\n"));
return VINF_NAT_DNS;
}
debug_init();
/* Initialise mbufs *after* setting the MTU */
#ifndef VBOX_WITH_SLIRP_BSD_MBUF
#else
#endif
#ifndef VBOX_WITH_NAT_SERVICE
#else
#endif
/* @todo: add ability to configure this staff */
/* set default addresses */
if (!pData->use_host_resolver)
{
if (slirp_init_dns_list(pData) < 0)
fNATfailed = 1;
}
{
int flags = 0;
struct in_addr proxy_addr;
{
LogRel(("NAT: LibAlias default rule wasn't initialized\n"));
AssertMsgFailed(("NAT: LibAlias default rule wasn't initialized\n"));
}
#ifndef NO_FW_PUNCH
#endif
if (pData->use_host_resolver)
}
}
/**
* Register statistics.
*/
{
#ifdef VBOX_WITH_STATISTICS
# define PROFILE_COUNTER(name, dsc) REGISTER_COUNTER(name, pData, STAMTYPE_PROFILE, STAMUNIT_TICKS_PER_CALL, dsc)
# define COUNTING_COUNTER(name, dsc) REGISTER_COUNTER(name, pData, STAMTYPE_COUNTER, STAMUNIT_COUNT, dsc)
# include "counters.h"
/** @todo register statistics for the variables dumped by:
* ipstats(pData); tcpstats(pData); udpstats(pData); icmpstats(pData);
* mbufstats(pData); sockstats(pData); */
#endif /* VBOX_WITH_STATISTICS */
}
/**
* Deregister statistics.
*/
{
#ifdef VBOX_WITH_STATISTICS
# include "counters.h"
#endif /* VBOX_WITH_STATISTICS */
}
/**
* Marks the link as up, making it possible to establish new connections.
*/
{
struct arp_cache_entry *ac;
link_up = 1;
return;
{
}
}
/**
* Marks the link as down and cleans up the current connections.
*/
{
struct port_forward_rule *rule;
{
else
}
/*
* Clear the active state of port-forwarding rules to force
* re-setup on restoration of communications.
*/
{
}
pData->cRedirectionsActive = 0;
link_up = 0;
}
/**
* Terminates the slirp component.
*/
{
#ifdef RT_OS_WINDOWS
#else
#endif
if (pData->use_host_resolver)
while (!LIST_EMPTY(&instancehead))
{
/* libalias do all clean up */
}
{
}
#ifdef RT_OS_WINDOWS
WSACleanup();
#endif
#ifdef LOG_ENABLED
Log(("\n"
"NAT statistics\n"
"--------------\n"
"\n"));
Log(("\n"
"\n"
"\n"));
#endif
}
#define CONN_CANFSEND(so) (((so)->so_state & (SS_FCANTSENDMORE|SS_ISFCONNECTED)) == SS_ISFCONNECTED)
/*
* curtime kept to an accuracy of 1ms
*/
{
#ifdef RT_OS_WINDOWS
#else
gettimeofday(&tt, 0);
curtime++;
#endif
}
#ifdef RT_OS_WINDOWS
#else /* RT_OS_WINDOWS */
#endif /* !RT_OS_WINDOWS */
{
int nfds;
#if defined(RT_OS_WINDOWS)
int rc;
int error;
#else
int poll_index = 0;
#endif
int i;
/*
* First, TCP sockets
*/
do_slowtimo = 0;
if (!link_up)
goto done;
/*
* *_slowtimo needs calling if there are IP fragments
* in the fragment queue, or there are TCP connections active
*/
/* XXX:
* triggering of fragment expiration should be the same but use new macroses
*/
if (!do_slowtimo)
{
for (i = 0; i < IPREASS_NHASH; i++)
{
if (!TAILQ_EMPTY(&ipq[i]))
{
do_slowtimo = 1;
break;
}
}
}
/* { */
#if !defined(RT_OS_WINDOWS)
#endif
{
{
pData->fmbuf_water_warn_sent = 0;
pData->fmbuf_water_line = 0;
}
#ifndef RT_OS_WINDOWS
poll_index = 0;
#endif
goto done;
}
/*
* See if we need a tcp_fasttimo
*/
if ( time_fasttimo == 0
{
}
/*
* NOFDREF can include still connecting to local-host,
* newly socreated() sockets etc. Don't want to select these.
*/
/*
* Set for reading sockets which are accepting
*/
{
}
/*
* Set for writing sockets which are connecting
*/
{
}
/*
* Set for writing if we are connected, can send more, and
* we have something to send
*/
{
}
/*
* Set for reading (and urgent data) if we are connected, can
* receive more, and we have room for it XXX /2 ?
*/
{
}
}
/*
* UDP sockets
*/
/* { */
{
{
pData->fmbuf_water_line = 0;
pData->fmbuf_water_warn_sent = 0;
}
#ifndef RT_OS_WINDOWS
poll_index = 0;
#endif
goto done;
}
#if !defined(RT_OS_WINDOWS)
#endif
/*
* See if it's timed out
*/
{
{
{
}
#ifdef VBOX_WITH_SLIRP_MT
/* we need so_next for continue our cycle*/
#endif
}
else
{
}
}
/*
* 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 ?)
*/
{
}
}
done:
#if defined(RT_OS_WINDOWS)
#else /* RT_OS_WINDOWS */
*pnfds = poll_index;
#endif /* !RT_OS_WINDOWS */
}
#if defined(RT_OS_WINDOWS)
#else /* RT_OS_WINDOWS */
#endif /* !RT_OS_WINDOWS */
{
int ret;
#if defined(RT_OS_WINDOWS)
int rc;
int error;
#else
int poll_index = 0;
#endif
/* Update time */
/*
* See if anything has timed out
*/
if (link_up)
{
{
time_fasttimo = 0;
}
{
}
}
#if defined(RT_OS_WINDOWS)
if (fTimeout)
return; /* only timer update */
#endif
/*
* Check sockets
*/
if (!link_up)
goto done;
#if defined(RT_OS_WINDOWS)
/*XXX: before renaming please make see define
* fIcmp in slirp_state.h
*/
if (fIcmp)
#else
#endif
/*
* Check TCP sockets
*/
/* { */
{
{
pData->fmbuf_water_line = 0;
pData->fmbuf_water_warn_sent = 0;
}
goto done;
}
#ifdef VBOX_WITH_SLIRP_MT
{
{
}
{
}
NSOCK_DEC();
}
#endif
/*
* FD_ISSET is meaningless on these sockets
* (and they can crash the program)
*/
/*
* Check for URG data
* This will soread as well, so no need to
* test for readfds below if this succeeds
*/
/* out-of-band data */
{
}
/*
* Check sockets for reading
*/
{
/*
* Check for incoming connections
*/
{
#if defined(RT_OS_WINDOWS)
#endif
}
/* Output it if we read something */
}
#if defined(RT_OS_WINDOWS)
/*
* Check for FD_CLOSE events.
* in some cases once FD_CLOSE engaged on socket it could be flashed latter (for some reasons)
*/
{
/*
* drain the socket
*/
for (;;)
{
if (ret > 0)
else
break;
}
}
#endif
/*
* Check sockets for writing
*/
{
/*
* Check for non-blocking, still-connecting sockets
*/
{
/* Connected */
/*
* This should be probably guarded by PROBE_CONN too. Anyway,
* we disable it on OS/2 because the below send call returns
* EFAULT which causes the opened TCP socket to close right
* after it has been opened and connected.
*/
#ifndef RT_OS_OS2
if (ret < 0)
{
/* XXXXX Must fix, zero bytes is a NOP */
|| errno == EWOULDBLOCK
|| errno == EINPROGRESS
/* else failed */
}
/* else so->so_state &= ~SS_ISFCONNECTING; */
#endif
/*
* Continue tcp_input
*/
/* continue; */
}
else
/*
* XXX If we wrote something (a lot), there could be the 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 (ret < 0)
{
/* XXX */
|| errno == EWOULDBLOCK
|| errno == EINPROGRESS
{
}
/* else failed */
/* tcp_input will take care of it */
}
else
{
if (ret < 0)
{
/* XXX */
|| errno == EWOULDBLOCK
|| errno == EINPROGRESS
{
}
/* else failed */
}
else
}
} /* SS_ISFCONNECTING */
#endif
#ifndef RT_OS_WINDOWS
{
int err;
int status;
if (status != 0)
#ifndef RT_OS_SOLARIS
{
/* EINVAL returned if socket in listen state tcp(7)*/
}
if (status != 0)
#else
/*
* Solaris has bit different ioctl commands and its handlings
* hint: streamio(7) I_NREAD
*/
#endif
{
/**
* Check if we need here take care about gracefull connection
* @todo try with proxy server
*/
{
/*
* Never meet inq != 0 or outq != 0, anyway let it stay for a while
* in case it happens we'll able to detect it.
*/
Log(("NAT: %R[natsock] err(%d:%s) s(in:%d,out:%d)happens on read I/O, "
}
goto tcp_input_close;
}
{
Log(("NAT: system expires the socket %R[natsock] err(%d:%s) s(in:%d,out:%d) happens on non-I/O. ",
goto tcp_input_close;
}
Log(("NAT: %R[natsock] we've met(%d:%s) s(in:%d, out:%d) unhandled combination hup (%d) "
"rederr(%d) on (r:%d, w:%d, x:%d)\n",
/*
*/
so->so_state = SS_NOFDREF; /*cause connection valid tcp connection termination and socket closing */
}
#endif
}
/*
* Now UDP sockets.
* Incoming packets are sent straight away, they're not buffered.
* Incoming UDP data isn't buffered either.
*/
/* { */
{
{
pData->fmbuf_water_line = 0;
pData->fmbuf_water_warn_sent = 0;
}
goto done;
}
#ifdef VBOX_WITH_SLIRP_MT
{
{
}
{
}
NSOCK_DEC();
}
#endif
{
}
}
done:
#if 0
/*
* See if we can start outputting
*/
#endif
}
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...
*/
};
{
int ar_op;
switch (ar_op)
{
case ARPOP_REQUEST:
#ifndef VBOX_WITH_SLIRP_BSD_MBUF
Log4(("NAT: arp:%R[ether]->%R[ether]\n",
#else
#endif
#ifdef VBOX_WITH_NAT_SERVICE
goto arp_ok;
#endif
{
goto arp_ok;
{
{
goto arp_ok;
}
}
return;
{
case CTL_DNS:
case CTL_ALIAS:
break;
default:;
}
}
/* Gratuitous ARP */
{
/* we've received anounce about address asignment
* Let's do ARP cache update
*/
{
break;
}
}
break;
case ARPOP_REPLY:
{
break;
}
break;
default:
break;
}
}
#ifdef VBOX_WITH_SLIRP_BSD_MBUF
#else
#endif
{
struct mbuf *m;
int proto;
static bool fWarnedIpv6;
#ifdef VBOX_WITH_SLIRP_BSD_MBUF
int size = 0;
#else
#endif
#ifndef VBOX_WITH_SLIRP_BSD_MBUF
{
return;
}
#else
{
return;
}
{
/* @todo vasily: add ether logging routine in debug.c */
Log(("NAT: packet was addressed to other MAC\n"));
return;
}
else if (pkt_len < MJUM9BYTES)
size = MJUM9BYTES;
else if (pkt_len < MJUM16BYTES)
size = MJUM16BYTES;
else
AssertMsgFailed(("Unsupported size"));
if (!m)
{
LogRel(("NAT: can't allocate new mbuf\n"));
return;
}
#endif
/* Note: we add to align the IP header */
switch(proto)
{
case ETH_P_ARP:
break;
case ETH_P_IP:
/* Update time. Important if the network is very quiet, as otherwise
* the first outgoing connection gets an incorrect timestamp. */
#ifdef VBOX_WITH_SLIRP_BSD_MBUF
M_ASSERTPKTHDR(m);
#endif
#if 1
if ( pData->fmbuf_water_line
&& pData->fmbuf_water_warn_sent == 0
{
}
#endif
break;
case ETH_P_IPV6:
if (!fWarnedIpv6)
{
LogRel(("NAT: IPv6 not supported\n"));
fWarnedIpv6 = true;
}
break;
default:
break;
}
#ifdef VBOX_WITH_SLIRP_BSD_MBUF
#endif
}
/* output the IP packet to the ethernet device */
{
#ifndef VBOX_WITH_SLIRP_BSD_MBUF
m->m_data -= if_maxlinkhdr;
{
LogRel(("NAT: ethernet detects corruption of the packet"));
AssertMsgFailed(("!!Ethernet frame corrupted!!"));
}
#else
M_ASSERTPKTHDR(m);
#endif
{
{
/* don't do anything */
goto done;
}
}
#ifndef VBOX_WITH_SLIRP_BSD_MBUF
#else
{
LogRel(("NAT: Can't alloc memory for outgoing buffer\n"));
goto done;
}
#endif
#ifdef VBOX_WITH_SLIRP_BSD_MBUF
#else
if (flags & ETH_ENCAP_URG)
else
#endif
done:
#ifdef VBOX_WITH_SLIRP_BSD_MBUF
#endif
}
/**
* Still we're using dhcp server leasing to map ether to IP
* @todo see rt_lookup_in_cache
*/
{
int rc;
return INADDR_ANY;
return INADDR_ANY;
if (RT_SUCCESS(rc))
return ip;
/* ignore return code, ip will be set to INADDR_ANY on error */
return ip;
}
/**
* We need check if we've activated port forwarding
* for specific machine ... that of course relates to
* service mode
* @todo finish this for service case
*/
{
struct port_forward_rule *rule;
/* check mac here */
{
struct alias_link *alias_link;
int flags;
struct sockaddr_in *psin;
int rc;
continue;
#ifdef VBOX_WITH_NAT_SERVICE
continue; /*not right mac, @todo: it'd be better do the list port forwarding per mac */
#else
#if 0
continue;
#endif
#endif
if (guest_addr == INADDR_ANY)
{
/* the address wasn't granted */
return;
}
#if !defined(VBOX_WITH_NAT_SERVICE)
continue;
#endif
LogRel(("NAT: set redirect %s host port %d => guest port %d @ %R[IP4]\n",
else
goto remove_port_forwarding;
goto remove_port_forwarding;
if (!alias_link)
goto remove_port_forwarding;
continue;
LogRel(("NAT: failed to redirect %s %d => %d\n",
}
}
/**
* Changes in 3.1 instead of opening new socket do the following:
* gain more information:
* 1. bind IP
* 2. host port
* 3. guest port
* 4. proto
* 5. guest MAC address
* the guest's MAC address is rather important for service, but we easily
* could get it from VM configuration in DrvNAT or Service, the idea is activating
* corresponding port-forwarding
*/
{
return 1;
#ifndef VBOX_WITH_NAT_SERVICE
#endif
/* @todo add mac address */
return 0;
}
int guest_port)
{
}
void slirp_set_ethaddr_and_activate_port_forwarding(PNATState pData, const uint8_t *ethaddr, uint32_t GuestIP)
{
#ifndef VBOX_WITH_NAT_SERVICE
#endif
if (GuestIP != INADDR_ANY)
{
}
}
#if defined(RT_OS_WINDOWS)
{
}
{
}
#endif
{
if (link_up)
{
if (time_fasttimo)
return 2;
if (do_slowtimo)
return 500; /* see PR_SLOWHZ */
}
return 0;
}
#ifndef RT_OS_WINDOWS
{
}
#endif
/*
* this function called from NAT thread
*/
{
}
#ifdef VBOX_WITH_SLIRP_MT
{
}
{
}
#endif
{
}
{
}
{
if (next_server == NULL)
else
}
{
{
return 1;
}
return 0;
}
{
if (!pData->use_host_resolver)
{
}
else
LogRel(("NAT: Host Resolver conflicts with DNS proxy, the last one was forcely ignored\n"));
}
do { \
{ \
return; \
} \
else \
} while (0)
/* don't allow user set less 8kB and more than 1M values */
{
}
{
}
{
}
{
}
/*
* Looking for Ether by ip in ARP-cache
* Note: it´s responsible of caller to allocate buffer for result
* @returns iprt status code
*/
{
struct arp_cache_entry *ac;
return VERR_INVALID_PARAMETER;
return VERR_NOT_FOUND;
{
{
return VINF_SUCCESS;
}
}
return VERR_NOT_FOUND;
}
/*
* Looking for IP by Ether in ARP-cache
* Note: it´s responsible of caller to allocate buffer for result
* @returns 0 - if found, 1 - otherwise
*/
{
struct arp_cache_entry *ac;
*ip = INADDR_ANY;
return VERR_NOT_FOUND;
{
{
return VINF_SUCCESS;
}
}
return VERR_NOT_FOUND;
}
{
struct mbuf *m;
#ifndef VBOX_WITH_SLIRP_BSD_MBUF
#else
#endif
if (m == NULL)
{
LogRel(("NAT: Can't alloc mbuf for ARP request\n"));
return;
}
#ifndef VBOX_WITH_SLIRP_BSD_MBUF
m->m_data += if_maxlinkhdr;
#else
/* warn!!! should falls in mbuf minimal size */
#endif
}
{
return 0;
}
/* updates the arp cache
* @returns 0 - if has found and updated
* 1 - if hasn't found.
*/
{
struct arp_cache_entry *ac;
{
{
return 0;
}
}
return 1;
}
{
{
LogRel(("NAT: Can't allocate arp cache entry\n"));
return;
}
}
#ifdef VBOX_WITH_SLIRP_BSD_MBUF
{
{
mtu = 1500;
}
if_mtu =
}
#endif