DrvNAT.cpp revision e74eef731a813e4e06680c587a6759b9974b29c9
/* $Id$ */
/** @file
* DrvNAT - NAT network transport driver.
*/
/*
* Copyright (C) 2006-2010 Sun Microsystems, Inc.
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
* Clara, CA 95054 USA or visit http://www.sun.com if you need
* additional information or have any questions.
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
#define LOG_GROUP LOG_GROUP_DRV_NAT
#define __STDC_LIMIT_MACROS
#define __STDC_CONSTANT_MACROS
#include "slirp/libslirp.h"
#include <iprt/critsect.h>
#include "Builtins.h"
#ifndef RT_OS_WINDOWS
# include <unistd.h>
# include <fcntl.h>
# include <poll.h>
# include <errno.h>
#endif
#ifdef RT_OS_FREEBSD
#endif
#include <iprt/semaphore.h>
#define COUNTERS_INIT
#include "counters.h"
/*******************************************************************************
* Defined Constants And Macros *
*******************************************************************************/
do { \
return PDMDrvHlpVMSetError((pthis)->pDrvIns, (rc), RT_SRC_POS, N_("NAT#%d: configuration query for \""name"\" " #type_name " failed"), \
} while (0)
do { \
if (RT_FAILURE((rc))) \
return PDMDrvHlpVMSetError((pthis)->pDrvIns, (rc), RT_SRC_POS, N_("NAT#%d: configuration query for \""name"\" " #type_name " failed"), \
} while (0)
do { \
return PDMDrvHlpVMSetError((pthis)->pDrvIns, (rc), RT_SRC_POS, N_("NAT#%d: configuration query for \""name"\" " #type_name " failed"), \
} while (0)
do { \
char sz##x[32]; \
if (rc != VERR_CFGM_VALUE_NOT_FOUND) \
} while (0)
do \
{ \
int status = 0; \
} while (0)
/*******************************************************************************
* Structures and Typedefs *
*******************************************************************************/
/**
* NAT network transport driver instance data.
*
* @implements PDMINETWORKCONNECTOR
*/
typedef struct DRVNAT
{
/** The network interface. */
/** The port we're attached to. */
/** The network config of the port we're attached to. */
/** Pointer to the driver instance. */
/** Link state */
/** NAT state for this instance. */
/** TFTP directory prefix. */
char *pszTFTPPrefix;
/** Boot file name to provide in the DHCP server response. */
char *pszBootFile;
/** tftp server name to provide in the DHCP server response. */
char *pszNextServer;
/* polling thread */
/** Queue for NAT-thread-external events. */
/** The guest IP for port-forwarding. */
#ifdef VBOX_WITH_SLIRP_MT
#endif
#ifndef RT_OS_WINDOWS
/** The write end of the control pipe. */
/** The read end of the control pipe. */
# if HC_ARCH_BITS == 32
/** Alignment padding. */
# endif
#else
/** for external notification */
#endif
#include "counters.h"
/** thread delivering packets for receiving by the guest */
/** thread delivering urg packets for receiving by the guest */
/** event to wakeup the guest receive thread */
/** event to wakeup the guest urgent receive thread */
/** Receive Req queue (deliver packets to the guest) */
/** Receive Urgent Req queue (deliver packets to the guest) */
/* makes access to device func RecvAvail and Recv atomical */
} DRVNAT;
/** Pointer the NAT driver instance data. */
/**
* NAT queue item.
*/
typedef struct DRVNATQUEUITEM
{
/** The core part owned by the queue manager. */
/** The buffer for output to guest. */
/* size of buffer */
void *mbuf;
/** Pointer to a NAT queue item. */
typedef DRVNATQUEUITEM *PDRVNATQUEUITEM;
/** Converts a pointer to NAT::INetworkConnector to a PRDVNAT. */
#define PDMINETWORKCONNECTOR_2_DRVNAT(pInterface) ( (PDRVNAT)((uintptr_t)pInterface - RT_OFFSETOF(DRVNAT, INetworkConnector)) )
{
}
{
}
{
return VINF_SUCCESS;
{
}
return VINF_SUCCESS;
}
{
int rc;
return VINF_SUCCESS;
}
{
return VINF_SUCCESS;
{
{
}
}
return VINF_SUCCESS;
}
{
return VINF_SUCCESS;
}
{
if (RT_SUCCESS(rc))
{
}
else if ( RT_FAILURE(rc)
&& ( rc == VERR_TIMEOUT
&& rc == VERR_INTERRUPTED))
{
}
{
}
}
{
int rc;
{
if ( RT_FAILURE(rc)
&& ( rc == VERR_TIMEOUT
|| rc == VERR_INTERRUPTED))
goto done_unlocked;
}
if (RT_SUCCESS(rc))
{
}
else if ( RT_FAILURE(rc)
&& ( rc != VERR_TIMEOUT
&& rc != VERR_INTERRUPTED))
{
}
}
/**
* Worker function for drvNATSend().
* @thread "NAT" thread.
*/
{
}
/**
* Called by the guest to send data to the network.
*
* @returns VBox status code.
* @param pInterface Pointer to the interface structure containing the called function pointer.
* @param pvBuf Data to send.
* @param cb Number of bytes to send.
* @thread EMT
*/
{
int rc;
void *buf;
/* don't queue new requests when the NAT thread is about to stop */
return VINF_SUCCESS;
#ifndef VBOX_WITH_SLIRP_MT
#else
#endif
/* @todo: Here we should get mbuf instead temporal buffer */
#if 0
{
LogRel(("NAT: Can't allocate send buffer\n"));
return VERR_NO_MEMORY;
}
#else
#endif
LogFlow(("drvNATSend: end\n"));
return VINF_SUCCESS;
}
/**
* Get the NAT thread out of poll/WSAWaitForMultipleEvents
*/
{
int rc;
#ifndef RT_OS_WINDOWS
/* kick select() */
#else
/* kick WSAWaitForMultipleEvents */
#endif
}
/**
* Set promiscuous mode.
*
* This is called when the promiscuous mode is set. This means that there doesn't have
* to be a mode change when it's called.
*
* @param pInterface Pointer to the interface structure containing the called function pointer.
* @param fPromiscuous Set if the adaptor is now in promiscuous mode. Clear if it is not.
* @thread EMT
*/
static DECLCALLBACK(void) drvNATSetPromiscuousMode(PPDMINETWORKCONNECTOR pInterface, bool fPromiscuous)
{
/* nothing to do */
}
/**
* Worker function for drvNATNotifyLinkChanged().
* @thread "NAT" thread.
*/
{
switch (enmLinkState)
{
case PDMNETWORKLINKSTATE_UP:
LogRel(("NAT: link up\n"));
break;
case PDMNETWORKLINKSTATE_DOWN:
LogRel(("NAT: link down\n"));
break;
default:
}
}
/**
* Notification on link status changes.
*
* @param pInterface Pointer to the interface structure containing the called function pointer.
* @param enmLinkState The new link state.
* @thread EMT
*/
static DECLCALLBACK(void) drvNATNotifyLinkChanged(PPDMINETWORKCONNECTOR pInterface, PDMNETWORKLINKSTATE enmLinkState)
{
/* don't queue new requests when the NAT thread is about to stop */
return;
{
}
else
}
/**
* NAT thread handling the slirp stuff. The slirp implementation is single-threaded
* so we execute this enginre in a dedicated thread. We take care that this thread
* does not become the bottleneck: If the guest wants to send, a request is enqueued
* into the pSlirpReqQueue and handled asynchronously by this thread. If this thread
* wants to deliver packets to the guest, it enqueues a request into pRecvReqQueue
* which is later handled by the Recv thread.
*/
{
int nFDs = -1;
unsigned int ms;
#ifdef RT_OS_WINDOWS
unsigned int cBreak = 0;
#else /* RT_OS_WINDOWS */
unsigned int cPollNegRet = 0;
#endif /* !RT_OS_WINDOWS */
return VINF_SUCCESS;
#ifdef RT_OS_WINDOWS
#endif /* RT_OS_WINDOWS */
/*
* Polling loop.
*/
{
nFDs = -1;
/*
*/
#ifndef RT_OS_WINDOWS
/* allocation for all sockets + Management pipe */
return VERR_NO_MEMORY;
/* don't pass the managemant pipe */
#if 0
#else
ms = 0;
#endif
/* POLLRDBAND usually doesn't used on Linux but seems used on Solaris */
if (cChangedFDs < 0)
{
{
Log2(("NAT: signal was caught while sleep on poll\n"));
/* No error, just process all outstanding requests but don't wait */
cChangedFDs = 0;
}
else if (cPollNegRet++ > 128)
{
cPollNegRet = 0;
}
}
if (cChangedFDs >= 0)
{
{
/* drain the pipe */
char ch[1];
int counter = 0;
/*
* drvNATSend decoupled so we don't know how many times
* device's thread sends before we've entered multiplex,
* so to avoid false alarm drain pipe here to the very end
*
* @todo: Probably we should counter drvNATSend to count how
* deep pipe has been filed before drain.
*
* XXX:Make it reading exactly we need to drain the pipe.
*/
}
}
/* process _all_ outstanding requests but don't wait */
#else /* RT_OS_WINDOWS */
#if 0
#else
ms = 0;
#endif
&& event != WSA_WAIT_TIMEOUT)
{
int error = WSAGetLastError();
}
if (event == WSA_WAIT_TIMEOUT)
{
continue;
}
/* poll the sockets in any case */
/* process _all_ outstanding requests but don't wait */
# ifdef VBOX_NAT_DELAY_HACK
if (cBreak++ > 128)
{
cBreak = 0;
RTThreadSleep(2);
}
# endif
#endif /* RT_OS_WINDOWS */
}
return VINF_SUCCESS;
}
/**
* Unblock the send thread so it can respond to a state change.
*
* @returns VBox status code.
* @param pDevIns The pcnet device instance.
* @param pThread The send thread.
*/
{
return VINF_SUCCESS;
}
#ifdef VBOX_WITH_SLIRP_MT
{
return VINF_SUCCESS;
return VINF_SUCCESS;
}
{
return VINF_SUCCESS;
}
#endif /* VBOX_WITH_SLIRP_MT */
void slirp_arm_fast_timer(void *pvUser)
{
}
void slirp_arm_slow_timer(void *pvUser)
{
}
/**
* Function called by slirp to check if it's possible to feed incoming data to the network port.
* @returns 1 if possible.
* @returns 0 if not possible.
*/
int slirp_can_output(void *pvUser)
{
return 1;
}
void slirp_push_recv_thread(void *pvUser)
{
}
{
/* don't queue new requests when the NAT thread is about to stop */
return;
}
/**
* Function called by slirp to feed incoming data to the network port.
*/
{
/* don't queue new requests when the NAT thread is about to stop */
return;
}
/**
* @interface_method_impl{PDMIBASE,pfnQueryInterface}
*/
{
return NULL;
}
/**
* Get the MAC address into the slirp stack.
*
* Called by drvNATLoadDone and drvNATPowerOn.
*/
{
{
/* Re-activate the port forwarding. If */
}
}
/**
* After loading we have to pass the MAC address of the ethernet device to the slirp stack.
* Otherwise the guest is not reachable until it performs a DHCP request or an ARP request
* (usually done during guest boot).
*/
{
return VINF_SUCCESS;
}
/**
* Some guests might not use DHCP to retrieve an IP but use a static IP.
*/
{
}
/**
* Sets up the redirectors.
*
* @returns VBox status code.
* @param pCfgHandle The drivers configuration handle.
*/
static int drvNATConstructRedir(unsigned iInstance, PDRVNAT pThis, PCFGMNODE pCfgHandle, RTIPV4ADDR Network)
{
/*
* Enumerate redirections.
*/
{
/*
* Validate the port forwarding config.
*/
return PDMDRV_SET_ERROR(pThis->pDrvIns, VERR_PDM_DRVINS_UNKNOWN_CFG_VALUES, N_("Unknown configuration in port forwarding"));
/* protocol type */
bool fUDP;
char szProtocol[32];
int rc;
if (rc == VERR_CFGM_VALUE_NOT_FOUND)
{
fUDP = false;
}
else if (RT_SUCCESS(rc))
{
fUDP = false;
fUDP = true;
else
N_("NAT#%d: Invalid configuration value for \"Protocol\": \"%s\""),
}
/* host port */
/* guest port */
/* guest address */
/* @todo (vvl) use CTL_* */
/* Store the guest IP for re-establishing the port-forwarding rules. Note that GuestIP
* is not documented. Without */
/*
* Call slirp about it.
*/
N_("NAT#%d: configuration error: failed to set up "
"redirection of %d to %d. Probably a conflict with "
} /* for each redir rule */
return VINF_SUCCESS;
}
/**
* Destruct a driver instance.
*
* Most VM resources are freed by the VM. This callback is provided so that any non-VM
* resources can be freed correctly.
*
* @param pDrvIns The driver instance data.
*/
{
LogFlow(("drvNATDestruct:\n"));
#ifdef VBOX_WITH_STATISTICS
# include "counters.h"
#endif
}
/**
* Construct a NAT network transport driver instance.
*
* @copydoc FNPDMDRVCONSTRUCT
*/
{
LogFlow(("drvNATConstruct:\n"));
/*
* Validate the config.
*/
"PassDomain\0TFTPPrefix\0BootFile\0Network"
"\0NextServer\0DNSProxy\0BindIP\0UseHostResolver\0"
#ifdef VBOX_WITH_SLIRP_BSD_MBUF
"SlirpMTU\0"
#endif
"SocketRcvBuf\0SocketSndBuf\0TcpRcvSpace\0TcpSndSpace\0"))
N_("Unknown NAT configuration option, only supports PassDomain,"
" TFTPPrefix, BootFile and Network"));
/*
* Init the static parts.
*/
/* IBase */
/* INetwork */
/*
* Get the configuration settings.
*/
int rc;
bool fPassDomain = true;
int fDNSProxy = 0;
int fUseHostResolver = 0;
#ifdef VBOX_WITH_SLIRP_BSD_MBUF
int MTU = 1500;
#endif
/*
* Query the network port interface.
*/
"export the network port interface"));
"export the network config interface"));
/* Generate a network address for this network card. */
if (rc == VERR_CFGM_VALUE_NOT_FOUND)
if (RT_FAILURE(rc))
"network '%s' describes not a valid IPv4 network"),
char szNetAddr[16];
/*
* Initialize slirp.
*/
if (RT_SUCCESS(rc))
{
#ifdef VBOX_WITH_SLIRP_BSD_MBUF
#endif
if (rc != 0)
LogRel(("NAT: value of BindIP has been ignored\n"));
do \
{ \
int len = 0; \
if (RT_SUCCESS(rc)) \
} while(0)
#ifdef VBOX_WITH_STATISTICS
# define DRV_PROFILE_COUNTER(name, dsc) REGISTER_COUNTER(name, pThis, STAMTYPE_PROFILE, STAMUNIT_TICKS_PER_CALL, dsc)
# define DRV_COUNTING_COUNTER(name, dsc) REGISTER_COUNTER(name, pThis, STAMTYPE_COUNTER, STAMUNIT_COUNT, dsc)
# include "counters.h"
#endif
if (RT_SUCCESS(rc2))
{
/*
* Register a load done notification to get the MAC address into the slirp
* engine after we loaded a guest state.
*/
if (RT_FAILURE(rc))
{
LogRel(("NAT: Can't create request queue\n"));
return rc;
}
if (RT_FAILURE(rc))
{
LogRel(("NAT: Can't create request queue\n"));
return rc;
}
if (RT_FAILURE(rc))
{
LogRel(("NAT: Can't create request queue\n"));
return rc;
}
#ifndef RT_OS_WINDOWS
/*
* Create the control pipe.
*/
int fds[2];
{
return rc;
}
#else
#endif
#ifdef VBOX_WITH_SLIRP_MT
#endif
/* might return VINF_NAT_DNS */
return rc;
}
/* failure path */
}
else
{
}
return rc;
}
/**
* NAT network transport driver registration record.
*/
{
/* u32Version */
/* szDriverName */
"NAT",
/* szRCMod */
"",
/* szR0Mod */
"",
/* pszDescription */
"NAT Network Transport Driver",
/* fFlags */
/* fClass. */
/* cMaxInstances */
16,
/* cbInstance */
sizeof(DRVNAT),
/* pfnConstruct */
/* pfnDestruct */
/* pfnRelocate */
NULL,
/* pfnIOCtl */
NULL,
/* pfnPowerOn */
/* pfnReset */
NULL,
/* pfnSuspend */
NULL,
/* pfnResume */
NULL,
/* pfnAttach */
NULL,
/* pfnDetach */
NULL,
/* pfnPowerOff */
NULL,
/* pfnSoftReset */
NULL,
/* u32EndVersion */
};