/**
* @note This function will free m!
*/
int udp_output(PNATState pData, struct socket *so, struct mbuf *m,
struct sockaddr_in *addr)
{
struct sockaddr_in saddr, daddr;
Assert(so->so_type == IPPROTO_UDP);
LogFlowFunc(("ENTER: so = %R[natsock], m = %p, saddr = %RTnaipv4\n", so, m, addr->sin_addr.s_addr));
if (so->so_laddr.s_addr == INADDR_ANY)
{
if (pData->guest_addr_guess.s_addr != INADDR_ANY)
{
LogRel2(("NAT: port-forward: using %RTnaipv4 for %R[natsock]\n",
pData->guest_addr_guess.s_addr, so));
so->so_laddr = pData->guest_addr_guess;
}
else
{
LogRel2(("NAT: port-forward: guest address unknown for %R[natsock]\n", so));
m_freem(pData, m);
return 0;
}
}
saddr = *addr;
if ((so->so_faddr.s_addr & RT_H2N_U32(pData->netmask)) == pData->special_addr.s_addr)
{
saddr.sin_addr.s_addr = so->so_faddr.s_addr;
if (slirpIsWideCasting(pData, so->so_faddr.s_addr))
{
/**
* We haven't got real firewall but have got its submodule libalias.
*/
m->m_flags |= M_SKIP_FIREWALL;
/**
* udp/137 port is Name Service in NetBIOS protocol. for some reasons Windows guest rejects
* accept data from non-aliased server.
*/
if ( (so->so_fport == so->so_lport)
&& (so->so_fport == RT_H2N_U16(137)))
saddr.sin_addr.s_addr = alias_addr.s_addr;
else
saddr.sin_addr.s_addr = addr->sin_addr.s_addr;
so->so_faddr.s_addr = addr->sin_addr.s_addr;
}
}
/* Any UDP packet to the loopback address must be translated to be from
* the forwarding address, i.e. 10.0.2.2. */
if ( (saddr.sin_addr.s_addr & RT_H2N_U32_C(IN_CLASSA_NET))
== RT_H2N_U32_C(INADDR_LOOPBACK & IN_CLASSA_NET))
saddr.sin_addr.s_addr = alias_addr.s_addr;
daddr.sin_addr = so->so_laddr;
daddr.sin_port = so->so_lport;
return udp_output2(pData, so, m, &saddr, &daddr, so->so_iptos);
}
/**
* @note This function will free m!
*/
int udp_output(PNATState pData, struct socket *so, struct mbuf *m,
struct sockaddr_in *addr)
{
struct sockaddr_in saddr, daddr;
#ifdef VBOX_WITH_NAT_UDP_SOCKET_CLONE
struct socket *pSocketClone = NULL;
#endif
Assert(so->so_type == IPPROTO_UDP);
LogFlowFunc(("ENTER: so = %R[natsock], m = %p, saddr = %RTnaipv4\n",
so, (long)m, addr->sin_addr.s_addr));
saddr = *addr;
if ((so->so_faddr.s_addr & RT_H2N_U32(pData->netmask)) == pData->special_addr.s_addr)
{
saddr.sin_addr.s_addr = so->so_faddr.s_addr;
if (slirpIsWideCasting(pData, so->so_faddr.s_addr))
{
/**
* We haven't got real firewall but have got its submodule libalias.
*/
m->m_flags |= M_SKIP_FIREWALL;
/**
* udp/137 port is Name Service in NetBIOS protocol. for some reasons Windows guest rejects
* accept data from non-aliased server.
*/
if ( (so->so_fport == so->so_lport)
&& (so->so_fport == RT_H2N_U16(137)))
saddr.sin_addr.s_addr = alias_addr.s_addr;
else
saddr.sin_addr.s_addr = addr->sin_addr.s_addr;
/* we shouldn't override initial socket */
#ifdef VBOX_WITH_NAT_UDP_SOCKET_CLONE
if (so->so_cCloneCounter)
pSocketClone = soLookUpClonedUDPSocket(pData, so, addr->sin_addr.s_addr);
if (!pSocketClone)
pSocketClone = soCloneUDPSocketWithForegnAddr(pData, false, so, addr->sin_addr.s_addr);
Assert((pSocketClone));
so = pSocketClone;
#else
so->so_faddr.s_addr = addr->sin_addr.s_addr;
#endif
}
}
/* Any UDP packet to the loopback address must be translated to be from
* the forwarding address, i.e. 10.0.2.2. */
if ( (saddr.sin_addr.s_addr & RT_H2N_U32_C(IN_CLASSA_NET))
== RT_H2N_U32_C(INADDR_LOOPBACK & IN_CLASSA_NET))
saddr.sin_addr.s_addr = alias_addr.s_addr;
daddr.sin_addr = so->so_laddr;
daddr.sin_port = so->so_lport;
return udp_output2(pData, so, m, &saddr, &daddr, so->so_iptos);
}
/**
* Construct a DHCP server with a default configuration.
*/
VBoxNetDhcp::VBoxNetDhcp():VBoxNetBaseService("VBoxNetDhcp", "VBoxNetDhcp")
{
/* m_enmTrunkType = kIntNetTrunkType_WhateverNone; */
RTMAC mac;
mac.au8[0] = 0x08;
mac.au8[1] = 0x00;
mac.au8[2] = 0x27;
mac.au8[3] = 0x40;
mac.au8[4] = 0x41;
mac.au8[5] = 0x42;
setMacAddress(mac);
RTNETADDRIPV4 address;
address.u = RT_H2N_U32_C(RT_BSWAP_U32_C(RT_MAKE_U32_FROM_U8( 10, 0, 2, 5)));
setIpv4Address(address);
setSendBufSize(8 * _1K);
setRecvBufSize(50 * _1K);
m_uCurMsgType = UINT8_MAX;
m_cbCurMsg = 0;
m_pCurMsg = NULL;
memset(&m_CurHdrs, '\0', sizeof(m_CurHdrs));
m_fIgnoreCmdLineParameters = true;
for(unsigned int i = 0; i < RT_ELEMENTS(g_aOptionDefs); ++i)
addCommandLineOption(&g_aOptionDefs[i]);
}
int NetworkManager::prepareReplyPacket4Client(const Client& client, uint32_t u32Xid)
{
RT_ZERO(m->BootPReplyMsg);
m->BootPReplyMsg.BootPHeader.bp_op = RTNETBOOTP_OP_REPLY;
m->BootPReplyMsg.BootPHeader.bp_htype = RTNET_ARP_ETHER;
m->BootPReplyMsg.BootPHeader.bp_hlen = sizeof(RTMAC);
m->BootPReplyMsg.BootPHeader.bp_hops = 0;
m->BootPReplyMsg.BootPHeader.bp_xid = u32Xid;
m->BootPReplyMsg.BootPHeader.bp_secs = 0;
/* XXX: bp_flags should be processed specially */
m->BootPReplyMsg.BootPHeader.bp_flags = 0;
m->BootPReplyMsg.BootPHeader.bp_ciaddr.u = 0;
m->BootPReplyMsg.BootPHeader.bp_giaddr.u = 0;
m->BootPReplyMsg.BootPHeader.bp_chaddr.Mac = client.getMacAddress();
const Lease l = client.lease();
m->BootPReplyMsg.BootPHeader.bp_yiaddr = l.getAddress();
m->BootPReplyMsg.BootPHeader.bp_siaddr.u = 0;
m->BootPReplyMsg.BootPHeader.bp_vend.Dhcp.dhcp_cookie = RT_H2N_U32_C(RTNET_DHCP_COOKIE);
memset(&m->BootPReplyMsg.BootPHeader.bp_vend.Dhcp.dhcp_opts[0],
'\0',
RTNET_DHCP_OPT_SIZE);
return VINF_SUCCESS;
}
int VBoxNetDhcp::hostDnsServers(const ComHostPtr& host,
const RTNETADDRIPV4& networkid,
const AddressToOffsetMapping& mapping,
AddressList& servers)
{
ComBstrArray strs;
HRESULT hrc = host->COMGETTER(NameServers)(ComSafeArrayAsOutParam(strs));
if (FAILED(hrc))
return VERR_NOT_FOUND;
/*
* Recent fashion is to run dnsmasq on 127.0.1.1 which we
* currently can't map. If that's the only nameserver we've got,
* we need to use DNS proxy for VMs to reach it.
*/
bool fUnmappedLoopback = false;
for (size_t i = 0; i < strs.size(); ++i)
{
RTNETADDRIPV4 addr;
int rc;
rc = RTNetStrToIPv4Addr(com::Utf8Str(strs[i]).c_str(), &addr);
if (RT_FAILURE(rc))
continue;
if (addr.au8[0] == 127)
{
AddressToOffsetMapping::const_iterator remap(mapping.find(addr));
if (remap != mapping.end())
{
int offset = remap->second;
addr.u = RT_H2N_U32(RT_N2H_U32(networkid.u) + offset);
}
else
{
fUnmappedLoopback = true;
continue;
}
}
servers.push_back(addr);
}
if (servers.empty() && fUnmappedLoopback)
{
RTNETADDRIPV4 proxy;
proxy.u = networkid.u | RT_H2N_U32_C(1U);
servers.push_back(proxy);
}
return VINF_SUCCESS;
}
/**
* Finds an option.
*
* @returns On success, a pointer to the first byte in the option data (no none
* then it'll be the byte following the 0 size field) and *pcbOpt set
* to the option length.
* On failure, NULL is returned and *pcbOpt unchanged.
*
* @param uOption The option to search for.
* @param pDhcpMsg The DHCP message.
* that this is adjusted if the option length is larger
* than the message buffer.
*/
int
ConfigurationManager::findOption(uint8_t uOption, PCRTNETBOOTP pDhcpMsg, size_t cbDhcpMsg, RawOption& opt)
{
Assert(uOption != RTNET_DHCP_OPT_PAD);
/*
* Validate the DHCP bits and figure the max size of the options in the vendor field.
*/
if (cbDhcpMsg <= RT_UOFFSETOF(RTNETBOOTP, bp_vend.Dhcp.dhcp_opts))
return VERR_INVALID_PARAMETER;
if (pDhcpMsg->bp_vend.Dhcp.dhcp_cookie != RT_H2N_U32_C(RTNET_DHCP_COOKIE))
return VERR_INVALID_PARAMETER;
size_t cbLeft = cbDhcpMsg - RT_UOFFSETOF(RTNETBOOTP, bp_vend.Dhcp.dhcp_opts);
if (cbLeft > RTNET_DHCP_OPT_SIZE)
cbLeft = RTNET_DHCP_OPT_SIZE;
/*
* Search the vendor field.
*/
bool fExtended = false;
uint8_t const *pb = &pDhcpMsg->bp_vend.Dhcp.dhcp_opts[0];
while (pb && cbLeft > 0)
{
uint8_t uCur = *pb;
if (uCur == RTNET_DHCP_OPT_PAD)
{
cbLeft--;
pb++;
}
else if (cbLeft <= 1)
break;
else
{
size_t cbCur = pb[1];
if (cbCur > cbLeft - 2)
cbCur = cbLeft - 2;
if (uCur == uOption)
{
opt.u8OptId = uCur;
memcpy(opt.au8RawOpt, pb+2, cbCur);
opt.cbRawOpt = cbCur;
return VINF_SUCCESS;
}
pb += cbCur + 2;
cbLeft -= cbCur - 2;
}
}
/** @todo search extended dhcp option field(s) when present */
return VERR_NOT_FOUND;
}
VBoxNetLwipNAT::VBoxNetLwipNAT(SOCKET icmpsock4, SOCKET icmpsock6) : VBoxNetBaseService("VBoxNetNAT", "nat-network")
{
LogFlowFuncEnter();
m_ProxyOptions.ipv6_enabled = 0;
m_ProxyOptions.ipv6_defroute = 0;
m_ProxyOptions.icmpsock4 = icmpsock4;
m_ProxyOptions.icmpsock6 = icmpsock6;
m_ProxyOptions.tftp_root = NULL;
m_ProxyOptions.src4 = NULL;
m_ProxyOptions.src6 = NULL;
RT_ZERO(m_src4);
RT_ZERO(m_src6);
m_src4.sin_family = AF_INET;
m_src6.sin6_family = AF_INET6;
#if HAVE_SA_LEN
m_src4.sin_len = sizeof(m_src4);
m_src6.sin6_len = sizeof(m_src6);
#endif
m_ProxyOptions.nameservers = NULL;
m_LwipNetIf.name[0] = 'N';
m_LwipNetIf.name[1] = 'T';
RTMAC mac;
mac.au8[0] = 0x52;
mac.au8[1] = 0x54;
mac.au8[2] = 0;
mac.au8[3] = 0x12;
mac.au8[4] = 0x35;
mac.au8[5] = 0;
setMacAddress(mac);
RTNETADDRIPV4 address;
address.u = RT_MAKE_U32_FROM_U8( 10, 0, 2, 2); // NB: big-endian
setIpv4Address(address);
address.u = RT_H2N_U32_C(0xffffff00);
setIpv4Netmask(address);
fDontLoadRulesOnStartup = false;
for(unsigned int i = 0; i < RT_ELEMENTS(g_aGetOptDef); ++i)
addCommandLineOption(&g_aGetOptDef[i]);
LogFlowFuncLeave();
}
int main()
{
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTStrFormat", &hTest);
if (rc)
return rc;
RTTestBanner(hTest);
uint32_t u32 = 0x010;
uint64_t u64 = 0x100;
#define BUF_SIZE 120
char *pszBuf = (char *)RTTestGuardedAllocHead(hTest, BUF_SIZE);
char *pszBuf2 = (char *)RTTestGuardedAllocHead(hTest, BUF_SIZE);
RTTestSub(hTest, "Basics");
/* simple */
size_t cch = RTStrPrintf(pszBuf, BUF_SIZE, "u32=%d u64=%lld u64=%#llx", u32, u64, u64);
if (strcmp(pszBuf, "u32=16 u64=256 u64=0x100"))
{
RTTestIFailed("error: '%s'\n"
"wanted 'u32=16 u64=256 u64=0x100'\n", pszBuf);
}
/* just big. */
u64 = UINT64_C(0x7070605040302010);
cch = RTStrPrintf(pszBuf, BUF_SIZE, "u64=%#llx 42=%d u64=%lld 42=%d", u64, 42, u64, 42);
if (strcmp(pszBuf, "u64=0x7070605040302010 42=42 u64=8102081627430068240 42=42"))
{
RTTestIFailed("error: '%s'\n"
"wanted 'u64=0x8070605040302010 42=42 u64=8102081627430068240 42=42'\n", pszBuf);
RTTestIPrintf(RTTESTLVL_FAILURE, "%d\n", (int)(u64 % 10));
}
/* huge and negative. */
u64 = UINT64_C(0x8070605040302010);
cch = RTStrPrintf(pszBuf, BUF_SIZE, "u64=%#llx 42=%d u64=%llu 42=%d u64=%lld 42=%d", u64, 42, u64, 42, u64, 42);
/* Not sure if this is the correct decimal representation... But both */
if (strcmp(pszBuf, "u64=0x8070605040302010 42=42 u64=9255003132036915216 42=42 u64=-9191740941672636400 42=42"))
{
RTTestIFailed("error: '%s'\n"
"wanted 'u64=0x8070605040302010 42=42 u64=9255003132036915216 42=42 u64=-9191740941672636400 42=42'\n", pszBuf);
RTTestIPrintf(RTTESTLVL_FAILURE, "%d\n", (int)(u64 % 10));
}
/* 64-bit value bug. */
u64 = 0xa0000000;
cch = RTStrPrintf(pszBuf, BUF_SIZE, "u64=%#llx 42=%d u64=%lld 42=%d", u64, 42, u64, 42);
if (strcmp(pszBuf, "u64=0xa0000000 42=42 u64=2684354560 42=42"))
RTTestIFailed("error: '%s'\n"
"wanted 'u64=0xa0000000 42=42 u64=2684354560 42=42'\n", pszBuf);
/* uuid */
RTUUID Uuid;
RTUuidCreate(&Uuid);
char szCorrect[RTUUID_STR_LENGTH];
RTUuidToStr(&Uuid, szCorrect, sizeof(szCorrect));
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%RTuuid", &Uuid);
if (strcmp(pszBuf, szCorrect))
RTTestIFailed("error: '%s'\n"
"expected: '%s'\n",
pszBuf, szCorrect);
/*
* Nested
*/
RTTestSub(hTest, "Nested (%N)");
testNested(__LINE__, "42 2684354560 42 asdf 42", "42 %u 42 %s 42", 2684354560U, "asdf");
testNested(__LINE__, "", "");
/*
* allocation
*/
RTTestSub(hTest, "RTStrAPrintf");
char *psz = (char *)~0;
int cch2 = RTStrAPrintf(&psz, "Hey there! %s%s", "This is a test", "!");
if (cch2 < 0)
RTTestIFailed("RTStrAPrintf failed, cch2=%d\n", cch2);
else if (strcmp(psz, "Hey there! This is a test!"))
RTTestIFailed("RTStrAPrintf failed\n"
"got : '%s'\n"
"wanted: 'Hey there! This is a test!'\n",
psz);
else if ((int)strlen(psz) != cch2)
RTTestIFailed("RTStrAPrintf failed, cch2 == %d expected %u\n", cch2, strlen(psz));
RTStrFree(psz);
#define CHECK42(fmt, arg, out) \
do { \
cch = RTStrPrintf(pszBuf, BUF_SIZE, fmt " 42=%d " fmt " 42=%d", arg, 42, arg, 42); \
if (strcmp(pszBuf, out " 42=42 " out " 42=42")) \
RTTestIFailed("at line %d: format '%s'\n" \
" output: '%s'\n" \
" wanted: '%s'\n", \
__LINE__, fmt, pszBuf, out " 42=42 " out " 42=42"); \
else if (cch != sizeof(out " 42=42 " out " 42=42") - 1) \
RTTestIFailed("at line %d: Invalid length %d returned, expected %u!\n", \
__LINE__, cch, sizeof(out " 42=42 " out " 42=42") - 1); \
} while (0)
#define CHECKSTR(Correct) \
if (strcmp(pszBuf, Correct)) \
RTTestIFailed("error: '%s'\n" \
"expected: '%s'\n", pszBuf, Correct); \
/*
* Runtime extensions.
*/
RTTestSub(hTest, "Runtime format types (%R*)");
CHECK42("%RGi", (RTGCINT)127, "127");
CHECK42("%RGi", (RTGCINT)-586589, "-586589");
CHECK42("%RGp", (RTGCPHYS)0x0000000044505045, "0000000044505045");
CHECK42("%RGp", ~(RTGCPHYS)0, "ffffffffffffffff");
CHECK42("%RGu", (RTGCUINT)586589, "586589");
CHECK42("%RGu", (RTGCUINT)1, "1");
CHECK42("%RGu", (RTGCUINT)3000000000U, "3000000000");
#if GC_ARCH_BITS == 32
CHECK42("%RGv", (RTGCUINTPTR)0, "00000000");
CHECK42("%RGv", ~(RTGCUINTPTR)0, "ffffffff");
CHECK42("%RGv", (RTGCUINTPTR)0x84342134, "84342134");
#else
CHECK42("%RGv", (RTGCUINTPTR)0, "0000000000000000");
CHECK42("%RGv", ~(RTGCUINTPTR)0, "ffffffffffffffff");
CHECK42("%RGv", (RTGCUINTPTR)0x84342134, "0000000084342134");
#endif
CHECK42("%RGx", (RTGCUINT)0x234, "234");
CHECK42("%RGx", (RTGCUINT)0xffffffff, "ffffffff");
CHECK42("%RRv", (RTRCUINTPTR)0, "00000000");
CHECK42("%RRv", ~(RTRCUINTPTR)0, "ffffffff");
CHECK42("%RRv", (RTRCUINTPTR)0x84342134, "84342134");
CHECK42("%RHi", (RTHCINT)127, "127");
CHECK42("%RHi", (RTHCINT)-586589, "-586589");
CHECK42("%RHp", (RTHCPHYS)0x0000000044505045, "0000000044505045");
CHECK42("%RHp", ~(RTHCPHYS)0, "ffffffffffffffff");
CHECK42("%RHu", (RTHCUINT)586589, "586589");
CHECK42("%RHu", (RTHCUINT)1, "1");
CHECK42("%RHu", (RTHCUINT)3000000000U, "3000000000");
if (sizeof(void*) == 8)
{
CHECK42("%RHv", (RTHCUINTPTR)0, "0000000000000000");
CHECK42("%RHv", ~(RTHCUINTPTR)0, "ffffffffffffffff");
CHECK42("%RHv", (RTHCUINTPTR)0x84342134, "0000000084342134");
}
else
{
CHECK42("%RHv", (RTHCUINTPTR)0, "00000000");
CHECK42("%RHv", ~(RTHCUINTPTR)0, "ffffffff");
CHECK42("%RHv", (RTHCUINTPTR)0x84342134, "84342134");
}
CHECK42("%RHx", (RTHCUINT)0x234, "234");
CHECK42("%RHx", (RTHCUINT)0xffffffff, "ffffffff");
CHECK42("%RI16", (int16_t)1, "1");
CHECK42("%RI16", (int16_t)-16384, "-16384");
CHECK42("%RI32", (int32_t)1123, "1123");
CHECK42("%RI32", (int32_t)-86596, "-86596");
CHECK42("%RI64", (int64_t)112345987345LL, "112345987345");
CHECK42("%RI64", (int64_t)-8659643985723459LL, "-8659643985723459");
CHECK42("%RI8", (int8_t)1, "1");
CHECK42("%RI8", (int8_t)-128, "-128");
CHECK42("%Rbn", "file.c", "file.c");
CHECK42("%Rbn", "foo/file.c", "file.c");
CHECK42("%Rbn", "/foo/file.c", "file.c");
CHECK42("%Rbn", "/dir/subdir/", "subdir/");
CHECK42("%Rfn", "function", "function");
CHECK42("%Rfn", "void function(void)", "function");
CHECK42("%RTfile", (RTFILE)127, "127");
CHECK42("%RTfile", (RTFILE)12341234, "12341234");
CHECK42("%RTfmode", (RTFMODE)0x123403, "00123403");
CHECK42("%RTfoff", (RTFOFF)12342312, "12342312");
CHECK42("%RTfoff", (RTFOFF)-123123123, "-123123123");
CHECK42("%RTfoff", (RTFOFF)858694596874568LL, "858694596874568");
RTFAR16 fp16;
fp16.off = 0x34ff;
fp16.sel = 0x0160;
CHECK42("%RTfp16", fp16, "0160:34ff");
RTFAR32 fp32;
fp32.off = 0xff094030;
fp32.sel = 0x0168;
CHECK42("%RTfp32", fp32, "0168:ff094030");
RTFAR64 fp64;
fp64.off = 0xffff003401293487ULL;
fp64.sel = 0x0ff8;
CHECK42("%RTfp64", fp64, "0ff8:ffff003401293487");
fp64.off = 0x0;
fp64.sel = 0x0;
CHECK42("%RTfp64", fp64, "0000:0000000000000000");
CHECK42("%RTgid", (RTGID)-1, "-1");
CHECK42("%RTgid", (RTGID)1004, "1004");
CHECK42("%RTino", (RTINODE)0, "0000000000000000");
CHECK42("%RTino", (RTINODE)0x123412341324ULL, "0000123412341324");
CHECK42("%RTint", (RTINT)127, "127");
CHECK42("%RTint", (RTINT)-586589, "-586589");
CHECK42("%RTint", (RTINT)-23498723, "-23498723");
CHECK42("%RTiop", (RTIOPORT)0x3c4, "03c4");
CHECK42("%RTiop", (RTIOPORT)0xffff, "ffff");
RTMAC Mac;
Mac.au8[0] = 0;
Mac.au8[1] = 0x1b;
Mac.au8[2] = 0x21;
Mac.au8[3] = 0x0a;
Mac.au8[4] = 0x1d;
Mac.au8[5] = 0xd9;
CHECK42("%RTmac", &Mac, "00:1b:21:0a:1d:d9");
Mac.au16[0] = 0xffff;
Mac.au16[1] = 0xffff;
Mac.au16[2] = 0xffff;
CHECK42("%RTmac", &Mac, "ff:ff:ff:ff:ff:ff");
RTNETADDRIPV4 Ipv4Addr;
Ipv4Addr.u = RT_H2N_U32_C(0xf040d003);
CHECK42("%RTnaipv4", Ipv4Addr.u, "240.64.208.3");
Ipv4Addr.u = RT_H2N_U32_C(0xffffffff);
CHECK42("%RTnaipv4", Ipv4Addr.u, "255.255.255.255");
RTNETADDRIPV6 Ipv6Addr;
/* any */
memset(&Ipv6Addr, 0, sizeof(Ipv6Addr));
CHECK42("%RTnaipv6", &Ipv6Addr, "::");
/* loopback */
Ipv6Addr.au8[15] = 1;
CHECK42("%RTnaipv6", &Ipv6Addr, "::1");
/* IPv4-compatible */
Ipv6Addr.au8[12] = 1;
Ipv6Addr.au8[13] = 1;
Ipv6Addr.au8[14] = 1;
Ipv6Addr.au8[15] = 1;
CHECK42("%RTnaipv6", &Ipv6Addr, "::1.1.1.1");
/* IPv4-mapped */
Ipv6Addr.au16[5] = RT_H2N_U16_C(0xffff);
CHECK42("%RTnaipv6", &Ipv6Addr, "::ffff:1.1.1.1");
/* IPv4-translated */
Ipv6Addr.au16[4] = RT_H2N_U16_C(0xffff);
Ipv6Addr.au16[5] = RT_H2N_U16_C(0x0000);
CHECK42("%RTnaipv6", &Ipv6Addr, "::ffff:0:1.1.1.1");
/* single zero word is not abbreviated, leading zeroes are not printed */
Ipv6Addr.au16[0] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[1] = RT_H2N_U16_C(0x0001);
Ipv6Addr.au16[2] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[3] = RT_H2N_U16_C(0x0001);
Ipv6Addr.au16[4] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[5] = RT_H2N_U16_C(0x0001);
Ipv6Addr.au16[6] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[7] = RT_H2N_U16_C(0x0001);
CHECK42("%RTnaipv6", &Ipv6Addr, "0:1:0:1:0:1:0:1");
/* longest run is abbreviated (here: at the beginning) */
Ipv6Addr.au16[0] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[1] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[2] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[3] = RT_H2N_U16_C(0x0001);
Ipv6Addr.au16[4] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[5] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[6] = RT_H2N_U16_C(0x0001);
Ipv6Addr.au16[7] = RT_H2N_U16_C(0x0000);
CHECK42("%RTnaipv6", &Ipv6Addr, "::1:0:0:1:0");
/* longest run is abbreviated (here: first) */
Ipv6Addr.au16[0] = RT_H2N_U16_C(0x0001);
Ipv6Addr.au16[1] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[2] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[3] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[4] = RT_H2N_U16_C(0x0001);
Ipv6Addr.au16[5] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[6] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[7] = RT_H2N_U16_C(0x0001);
CHECK42("%RTnaipv6", &Ipv6Addr, "1::1:0:0:1");
/* longest run is abbreviated (here: second) */
Ipv6Addr.au16[0] = RT_H2N_U16_C(0x0001);
Ipv6Addr.au16[1] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[2] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[3] = RT_H2N_U16_C(0x0001);
Ipv6Addr.au16[4] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[5] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[6] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[7] = RT_H2N_U16_C(0x0001);
CHECK42("%RTnaipv6", &Ipv6Addr, "1:0:0:1::1");
/* longest run is abbreviated (here: at the end) */
Ipv6Addr.au16[0] = RT_H2N_U16_C(0x0001);
Ipv6Addr.au16[1] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[2] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[3] = RT_H2N_U16_C(0x0001);
Ipv6Addr.au16[4] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[5] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[6] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[7] = RT_H2N_U16_C(0x0000);
CHECK42("%RTnaipv6", &Ipv6Addr, "1:0:0:1::");
/* first of the two runs of equal length is abbreviated */
Ipv6Addr.au16[0] = RT_H2N_U16_C(0x2001);
Ipv6Addr.au16[1] = RT_H2N_U16_C(0x0db8);
Ipv6Addr.au16[2] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[3] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[4] = RT_H2N_U16_C(0x0001);
Ipv6Addr.au16[5] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[6] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[7] = RT_H2N_U16_C(0x0001);
CHECK42("%RTnaipv6", &Ipv6Addr, "2001:db8::1:0:0:1");
Ipv6Addr.au16[0] = RT_H2N_U16_C(0x2001);
Ipv6Addr.au16[1] = RT_H2N_U16_C(0x0db8);
Ipv6Addr.au16[2] = RT_H2N_U16_C(0x85a3);
Ipv6Addr.au16[3] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[4] = RT_H2N_U16_C(0x0000);
Ipv6Addr.au16[5] = RT_H2N_U16_C(0x8a2e);
Ipv6Addr.au16[6] = RT_H2N_U16_C(0x0370);
Ipv6Addr.au16[7] = RT_H2N_U16_C(0x7334);
CHECK42("%RTnaipv6", &Ipv6Addr, "2001:db8:85a3::8a2e:370:7334");
Ipv6Addr.au64[0] = UINT64_MAX;
Ipv6Addr.au64[1] = UINT64_MAX;
CHECK42("%RTnaipv6", &Ipv6Addr, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff");
RTNETADDR NetAddr;
memset(&NetAddr, 0, sizeof(NetAddr));
/* plain IPv6 address if port is not specified */
NetAddr.enmType = RTNETADDRTYPE_IPV6;
NetAddr.uAddr.au16[0] = RT_H2N_U16_C(0x0001);
NetAddr.uAddr.au16[7] = RT_H2N_U16_C(0x0001);
NetAddr.uPort = RTNETADDR_PORT_NA;
CHECK42("%RTnaddr", &NetAddr, "1::1");
/* square brackets around IPv6 address if port is specified */
NetAddr.uPort = 1;
CHECK42("%RTnaddr", &NetAddr, "[1::1]:1");
CHECK42("%RTproc", (RTPROCESS)0xffffff, "00ffffff");
CHECK42("%RTproc", (RTPROCESS)0x43455443, "43455443");
if (sizeof(RTUINTPTR) == 8)
{
CHECK42("%RTptr", (RTUINTPTR)0, "0000000000000000");
CHECK42("%RTptr", ~(RTUINTPTR)0, "ffffffffffffffff");
CHECK42("%RTptr", (RTUINTPTR)0x84342134, "0000000084342134");
}
else
{
CHECK42("%RTptr", (RTUINTPTR)0, "00000000");
CHECK42("%RTptr", ~(RTUINTPTR)0, "ffffffff");
CHECK42("%RTptr", (RTUINTPTR)0x84342134, "84342134");
}
if (sizeof(RTCCUINTREG) == 8)
{
CHECK42("%RTreg", (RTCCUINTREG)0, "0000000000000000");
CHECK42("%RTreg", ~(RTCCUINTREG)0, "ffffffffffffffff");
CHECK42("%RTreg", (RTCCUINTREG)0x84342134, "0000000084342134");
CHECK42("%RTreg", (RTCCUINTREG)0x23484342134ULL, "0000023484342134");
}
else
{
CHECK42("%RTreg", (RTCCUINTREG)0, "00000000");
CHECK42("%RTreg", ~(RTCCUINTREG)0, "ffffffff");
CHECK42("%RTreg", (RTCCUINTREG)0x84342134, "84342134");
}
CHECK42("%RTsel", (RTSEL)0x543, "0543");
CHECK42("%RTsel", (RTSEL)0xf8f8, "f8f8");
if (sizeof(RTSEMEVENT) == 8)
{
CHECK42("%RTsem", (RTSEMEVENT)0, "0000000000000000");
CHECK42("%RTsem", (RTSEMEVENT)0x23484342134ULL, "0000023484342134");
}
else
{
CHECK42("%RTsem", (RTSEMEVENT)0, "00000000");
CHECK42("%RTsem", (RTSEMEVENT)0x84342134, "84342134");
}
CHECK42("%RTsock", (RTSOCKET)12234, "12234");
CHECK42("%RTsock", (RTSOCKET)584854543, "584854543");
if (sizeof(RTTHREAD) == 8)
{
CHECK42("%RTthrd", (RTTHREAD)0, "0000000000000000");
CHECK42("%RTthrd", (RTTHREAD)~(uintptr_t)0, "ffffffffffffffff");
CHECK42("%RTthrd", (RTTHREAD)0x63484342134ULL, "0000063484342134");
}
else
{
CHECK42("%RTthrd", (RTTHREAD)0, "00000000");
CHECK42("%RTthrd", (RTTHREAD)~(uintptr_t)0, "ffffffff");
CHECK42("%RTthrd", (RTTHREAD)0x54342134, "54342134");
}
CHECK42("%RTuid", (RTUID)-2, "-2");
CHECK42("%RTuid", (RTUID)90344, "90344");
CHECK42("%RTuint", (RTUINT)584589, "584589");
CHECK42("%RTuint", (RTUINT)3, "3");
CHECK42("%RTuint", (RTUINT)2400000000U, "2400000000");
RTUuidCreate(&Uuid);
RTUuidToStr(&Uuid, szCorrect, sizeof(szCorrect));
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%RTuuid", &Uuid);
if (strcmp(pszBuf, szCorrect))
RTTestIFailed("error: '%s'\n"
"expected: '%s'\n",
pszBuf, szCorrect);
CHECK42("%RTxint", (RTUINT)0x2345, "2345");
CHECK42("%RTxint", (RTUINT)0xffff8fff, "ffff8fff");
CHECK42("%RU16", (uint16_t)7, "7");
CHECK42("%RU16", (uint16_t)46384, "46384");
CHECK42("%RU32", (uint32_t)1123, "1123");
CHECK42("%RU32", (uint32_t)86596, "86596");
CHECK42("%4RU32", (uint32_t)42, " 42");
CHECK42("%04RU32", (uint32_t)42, "0042");
CHECK42("%.4RU32", (uint32_t)42, "0042");
CHECK42("%RU64", (uint64_t)112345987345ULL, "112345987345");
CHECK42("%RU64", (uint64_t)8659643985723459ULL, "8659643985723459");
CHECK42("%14RU64", (uint64_t)4, " 4");
CHECK42("%014RU64", (uint64_t)4, "00000000000004");
CHECK42("%.14RU64", (uint64_t)4, "00000000000004");
CHECK42("%RU8", (uint8_t)1, "1");
CHECK42("%RU8", (uint8_t)254, "254");
CHECK42("%RU8", 256, "0");
CHECK42("%RX16", (uint16_t)0x7, "7");
CHECK42("%RX16", 0x46384, "6384");
CHECK42("%RX32", (uint32_t)0x1123, "1123");
CHECK42("%RX32", (uint32_t)0x49939493, "49939493");
CHECK42("%RX64", UINT64_C(0x348734), "348734");
CHECK42("%RX64", UINT64_C(0x12312312312343f), "12312312312343f");
CHECK42("%5RX64", UINT64_C(0x42), " 42");
CHECK42("%05RX64", UINT64_C(0x42), "00042");
CHECK42("%.5RX64", UINT64_C(0x42), "00042");
CHECK42("%.05RX64", UINT64_C(0x42), "00042"); /* '0' is ignored */
CHECK42("%RX8", (uint8_t)1, "1");
CHECK42("%RX8", (uint8_t)0xff, "ff");
CHECK42("%RX8", 0x100, "0");
/*
* Thousand separators.
*/
RTTestSub(hTest, "Thousand Separators (%'*)");
RTStrFormatNumber(pszBuf, 1, 10, 0, 0, RTSTR_F_THOUSAND_SEP); CHECKSTR("1"); memset(pszBuf, '!', BUF_SIZE);
RTStrFormatNumber(pszBuf, 10, 10, 0, 0, RTSTR_F_THOUSAND_SEP); CHECKSTR("10"); memset(pszBuf, '!', BUF_SIZE);
RTStrFormatNumber(pszBuf, 100, 10, 0, 0, RTSTR_F_THOUSAND_SEP); CHECKSTR("100"); memset(pszBuf, '!', BUF_SIZE);
RTStrFormatNumber(pszBuf, 1000, 10, 0, 0, RTSTR_F_THOUSAND_SEP); CHECKSTR("1 000"); memset(pszBuf, '!', BUF_SIZE);
RTStrFormatNumber(pszBuf, 10000, 10, 0, 0, RTSTR_F_THOUSAND_SEP); CHECKSTR("10 000"); memset(pszBuf, '!', BUF_SIZE);
RTStrFormatNumber(pszBuf, 100000, 10, 0, 0, RTSTR_F_THOUSAND_SEP); CHECKSTR("100 000"); memset(pszBuf, '!', BUF_SIZE);
RTStrFormatNumber(pszBuf, 1000000, 10, 0, 0, RTSTR_F_THOUSAND_SEP); CHECKSTR("1 000 000"); memset(pszBuf, '!', BUF_SIZE);
CHECK42("%'u", 1, "1");
CHECK42("%'u", 10, "10");
CHECK42("%'u", 100, "100");
CHECK42("%'u", 1000, "1 000");
CHECK42("%'u", 10000, "10 000");
CHECK42("%'u", 100000, "100 000");
CHECK42("%'u", 1000000, "1 000 000");
CHECK42("%'RU64", _1T, "1 099 511 627 776");
CHECK42("%'RU64", _1E, "1 152 921 504 606 846 976");
/*
* String formatting.
*/
RTTestSub(hTest, "String formatting (%s)");
// 0 1 2 3 4 5 6 7
// 0....5....0....5....0....5....0....5....0....5....0....5....0....5....0
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%-10s %-30s %s", "cmd", "args", "description");
CHECKSTR("cmd args description");
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%-10s %-30s %s", "cmd", "", "description");
CHECKSTR("cmd description");
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%*s", 0, "");
CHECKSTR("");
/* automatic conversions. */
static RTUNICP s_usz1[] = { 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', 0 }; //assumes ascii.
static RTUTF16 s_wsz1[] = { 'h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', 0 }; //assumes ascii.
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%ls", s_wsz1);
CHECKSTR("hello world");
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%Ls", s_usz1);
CHECKSTR("hello world");
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%.5ls", s_wsz1);
CHECKSTR("hello");
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%.5Ls", s_usz1);
CHECKSTR("hello");
/*
* Unicode string formatting.
*/
RTTestSub(hTest, "Unicode string formatting (%ls)");
static RTUTF16 s_wszEmpty[] = { 0 }; //assumes ascii.
static RTUTF16 s_wszCmd[] = { 'c', 'm', 'd', 0 }; //assumes ascii.
static RTUTF16 s_wszArgs[] = { 'a', 'r', 'g', 's', 0 }; //assumes ascii.
static RTUTF16 s_wszDesc[] = { 'd', 'e', 's', 'c', 'r', 'i', 'p', 't', 'i', 'o', 'n', 0 }; //assumes ascii.
// 0 1 2 3 4 5 6 7
// 0....5....0....5....0....5....0....5....0....5....0....5....0....5....0
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%-10ls %-30ls %ls", s_wszCmd, s_wszArgs, s_wszDesc);
CHECKSTR("cmd args description");
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%-10ls %-30ls %ls", s_wszCmd, s_wszEmpty, s_wszDesc);
CHECKSTR("cmd description");
#if 0
static RTUNICP s_usz2[] = { 0xc5, 0xc6, 0xf8, 0 };
static RTUTF16 s_wsz2[] = { 0xc5, 0xc6, 0xf8, 0 };
static char s_sz2[] = { 0xc5, 0xc6, 0xf8, 0 };///@todo multibyte tests.
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%ls", s_wsz2);
CHECKSTR(s_sz2);
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%Ls", s_usz2);
CHECKSTR(s_sz2);
#endif
/*
* Hex formatting.
*/
RTTestSub(hTest, "Hex dump formatting (%Rhx*)");
static uint8_t const s_abHex1[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 };
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%.1Rhxs", s_abHex1);
CHECKSTR("00");
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%.2Rhxs", s_abHex1);
CHECKSTR("00 01");
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%Rhxs", s_abHex1);
CHECKSTR("00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f");
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%.*Rhxs", sizeof(s_abHex1), s_abHex1);
CHECKSTR("00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14");
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%4.*Rhxs", sizeof(s_abHex1), s_abHex1);
CHECKSTR("00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14");
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%1.*Rhxs", sizeof(s_abHex1), s_abHex1);
CHECKSTR("00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14");
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%256.*Rhxs", sizeof(s_abHex1), s_abHex1);
CHECKSTR("00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14");
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%4.8Rhxd", s_abHex1);
RTStrPrintf(pszBuf2, BUF_SIZE,
"%p 0000: 00 01 02 03 ....\n"
"%p 0004: 04 05 06 07 ....",
&s_abHex1[0], &s_abHex1[4]);
CHECKSTR(pszBuf2);
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%4.6Rhxd", s_abHex1);
RTStrPrintf(pszBuf2, BUF_SIZE,
"%p 0000: 00 01 02 03 ....\n"
"%p 0004: 04 05 ..",
&s_abHex1[0], &s_abHex1[4]);
CHECKSTR(pszBuf2);
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%.*Rhxd", sizeof(s_abHex1), s_abHex1);
RTStrPrintf(pszBuf2, BUF_SIZE,
"%p 0000: 00 01 02 03 04 05 06 07-08 09 0a 0b 0c 0d 0e 0f ................\n"
"%p 0010: 10 11 12 13 14 ....."
,
&s_abHex1[0], &s_abHex1[0x10]);
CHECKSTR(pszBuf2);
/*
* x86 register formatting.
*/
RTTestSub(hTest, "x86 register format types (%RAx86[*])");
CHECK42("%RAx86[cr0]", UINT64_C(0x80000011), "80000011{PE,ET,PG}");
CHECK42("%RAx86[cr0]", UINT64_C(0x80000001), "80000001{PE,PG}");
CHECK42("%RAx86[cr0]", UINT64_C(0x00000001), "00000001{PE}");
CHECK42("%RAx86[cr0]", UINT64_C(0x80000000), "80000000{PG}");
CHECK42("%RAx86[cr4]", UINT64_C(0x80000001), "80000001{VME,unkn=80000000}");
CHECK42("%#RAx86[cr4]", UINT64_C(0x80000001), "0x80000001{VME,unkn=0x80000000}");
/*
* Custom types.
*/
RTTestSub(hTest, "Custom format types (%R[*])");
RTTESTI_CHECK_RC(RTStrFormatTypeRegister("type3", TstType, (void *)((uintptr_t)TstType)), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTStrFormatTypeSetUser("type3", (void *)((uintptr_t)TstType + 3)), VINF_SUCCESS);
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%R[type3]", (void *)1);
CHECKSTR("type3=1");
RTTESTI_CHECK_RC(RTStrFormatTypeRegister("type1", TstType, (void *)((uintptr_t)TstType)), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTStrFormatTypeSetUser("type1", (void *)((uintptr_t)TstType + 1)), VINF_SUCCESS);
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%R[type3] %R[type1]", (void *)1, (void *)2);
CHECKSTR("type3=1 type1=2");
RTTESTI_CHECK_RC(RTStrFormatTypeRegister("type4", TstType, (void *)((uintptr_t)TstType)), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTStrFormatTypeSetUser("type4", (void *)((uintptr_t)TstType + 4)), VINF_SUCCESS);
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%R[type3] %R[type1] %R[type4]", (void *)1, (void *)2, (void *)3);
CHECKSTR("type3=1 type1=2 type4=3");
RTTESTI_CHECK_RC(RTStrFormatTypeRegister("type2", TstType, (void *)((uintptr_t)TstType)), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTStrFormatTypeSetUser("type2", (void *)((uintptr_t)TstType + 2)), VINF_SUCCESS);
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%R[type3] %R[type1] %R[type4] %R[type2]", (void *)1, (void *)2, (void *)3, (void *)4);
CHECKSTR("type3=1 type1=2 type4=3 type2=4");
RTTESTI_CHECK_RC(RTStrFormatTypeRegister("type5", TstType, (void *)((uintptr_t)TstType)), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTStrFormatTypeSetUser("type5", (void *)((uintptr_t)TstType + 5)), VINF_SUCCESS);
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%R[type3] %R[type1] %R[type4] %R[type2] %R[type5]", (void *)1, (void *)2, (void *)3, (void *)4, (void *)5);
CHECKSTR("type3=1 type1=2 type4=3 type2=4 type5=5");
RTTESTI_CHECK_RC(RTStrFormatTypeSetUser("type1", (void *)((uintptr_t)TstType + 1)), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTStrFormatTypeSetUser("type2", (void *)((uintptr_t)TstType + 2)), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTStrFormatTypeSetUser("type3", (void *)((uintptr_t)TstType + 3)), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTStrFormatTypeSetUser("type4", (void *)((uintptr_t)TstType + 4)), VINF_SUCCESS);
RTTESTI_CHECK_RC(RTStrFormatTypeSetUser("type5", (void *)((uintptr_t)TstType + 5)), VINF_SUCCESS);
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%R[type3] %R[type1] %R[type4] %R[type2] %R[type5]", (void *)10, (void *)20, (void *)30, (void *)40, (void *)50);
CHECKSTR("type3=10 type1=20 type4=30 type2=40 type5=50");
RTTESTI_CHECK_RC(RTStrFormatTypeDeregister("type2"), VINF_SUCCESS);
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%R[type3] %R[type1] %R[type4] %R[type5]", (void *)10, (void *)20, (void *)30, (void *)40);
CHECKSTR("type3=10 type1=20 type4=30 type5=40");
RTTESTI_CHECK_RC(RTStrFormatTypeDeregister("type5"), VINF_SUCCESS);
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%R[type3] %R[type1] %R[type4]", (void *)10, (void *)20, (void *)30);
CHECKSTR("type3=10 type1=20 type4=30");
RTTESTI_CHECK_RC(RTStrFormatTypeDeregister("type4"), VINF_SUCCESS);
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%R[type3] %R[type1]", (void *)10, (void *)20);
CHECKSTR("type3=10 type1=20");
RTTESTI_CHECK_RC(RTStrFormatTypeDeregister("type1"), VINF_SUCCESS);
cch = RTStrPrintf(pszBuf, BUF_SIZE, "%R[type3]", (void *)10);
CHECKSTR("type3=10");
RTTESTI_CHECK_RC(RTStrFormatTypeDeregister("type3"), VINF_SUCCESS);
/*
* Summarize and exit.
*/
return RTTestSummaryAndDestroy(hTest);
}
int main()
{
RTTEST hTest;
int rc = RTTestInitAndCreate("tstRTGetOpt", &hTest);
if (rc)
return rc;
RTGETOPTSTATE GetState;
RTGETOPTUNION Val;
#define CHECK(expr) do { if (!(expr)) { RTTestIFailed("error line %d (iNext=%d): %s\n", __LINE__, GetState.iNext, #expr); } } while (0)
#define CHECK2(expr, fmt) \
do { \
if (!(expr)) { \
RTTestIFailed("error line %d (iNext=%d): %s\n", __LINE__, GetState.iNext, #expr); \
RTTestIFailureDetails fmt; \
} \
} while (0)
#define CHECK_pDef(paOpts, i) \
CHECK2(Val.pDef == &(paOpts)[(i)], ("Got #%d (%p) expected #%d\n", (int)(Val.pDef - &(paOpts)[0]), Val.pDef, i));
#define CHECK_GETOPT(expr, chRet, iInc) \
do { \
const int iPrev = GetState.iNext; \
const int rcGetOpt = (expr); \
CHECK2(rcGetOpt == (chRet), ("got %d, expected %d\n", rcGetOpt, (chRet))); \
CHECK2(GetState.iNext == (iInc) + iPrev, ("iNext=%d expected %d\n", GetState.iNext, (iInc) + iPrev)); \
GetState.iNext = (iInc) + iPrev; \
} while (0)
#define CHECK_GETOPT_STR(expr, chRet, iInc, str) \
do { \
const int iPrev = GetState.iNext; \
const int rcGetOpt = (expr); \
CHECK2(rcGetOpt == (chRet), ("got %d, expected %d\n", rcGetOpt, (chRet))); \
CHECK2(GetState.iNext == (iInc) + iPrev, ("iNext=%d expected %d\n", GetState.iNext, (iInc) + iPrev)); \
CHECK2(VALID_PTR(Val.psz) && !strcmp(Val.psz, (str)), ("got %s, expected %s\n", Val.psz, (str))); \
GetState.iNext = (iInc) + iPrev; \
} while (0)
/*
* The basics.
*/
RTTestSub(hTest, "Basics");
static const RTGETOPTDEF s_aOpts2[] =
{
{ "--optwithstring", 's', RTGETOPT_REQ_STRING },
{ "--optwithint", 'i', RTGETOPT_REQ_INT32 },
{ "--verbose", 'v', RTGETOPT_REQ_NOTHING },
{ NULL, 'q', RTGETOPT_REQ_NOTHING },
{ "--quiet", 384, RTGETOPT_REQ_NOTHING },
{ "-novalue", 385, RTGETOPT_REQ_NOTHING },
{ "-startvm", 386, RTGETOPT_REQ_STRING },
{ "nodash", 387, RTGETOPT_REQ_NOTHING },
{ "nodashval", 388, RTGETOPT_REQ_STRING },
{ "--gateway", 'g', RTGETOPT_REQ_IPV4ADDR },
{ "--mac", 'm', RTGETOPT_REQ_MACADDR },
{ "--strindex", 400, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
{ "strindex", 400, RTGETOPT_REQ_STRING | RTGETOPT_FLAG_INDEX },
{ "--intindex", 401, RTGETOPT_REQ_INT32 | RTGETOPT_FLAG_INDEX },
{ "--macindex", 402, RTGETOPT_REQ_MACADDR | RTGETOPT_FLAG_INDEX },
{ "--indexnovalue", 403, RTGETOPT_REQ_NOTHING | RTGETOPT_FLAG_INDEX },
{ "--macindexnegative", 404, RTGETOPT_REQ_NOTHING },
{ "--twovalues", 405, RTGETOPT_REQ_STRING },
{ "--twovaluesindex", 406, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_INDEX },
{ "--threevalues", 407, RTGETOPT_REQ_UINT32 },
{ "--boolean", 408, RTGETOPT_REQ_BOOL_ONOFF },
{ "--booleanindex", 409, RTGETOPT_REQ_BOOL_ONOFF | RTGETOPT_FLAG_INDEX },
};
const char *argv2[] =
{
"-s", "string1",
"-sstring2",
"-s:string3",
"-s=string4",
"-s:",
"-s=",
"--optwithstring", "string5",
"--optwithstring:string6",
"--optwithstring=string7",
"--optwithstring:",
"--optwithstring=",
"-i", "-42",
"-i:-42",
"-i=-42",
"--optwithint", "42",
"--optwithint:42",
"--optwithint=42",
"-v",
"--verbose",
"-q",
"--quiet",
"-novalue",
"-startvm", "myvm",
"nodash",
"nodashval", "string9",
"filename1",
"-q",
"filename2",
"-vqi999",
"-g192.168.1.1",
"-m08:0:27:00:ab:f3",
"--mac:1:::::c",
"--strindex786", "string10",
"--strindex786:string11",
"--strindex786=string12",
"strindex687", "string13",
"strindex687:string14",
"strindex687=string15",
"strindex688:",
"strindex689=",
"--intindex137", "1000",
"--macindex138", "08:0:27:00:ab:f3",
"--indexnovalue1",
"--macindexnegative",
"--twovalues", "firstvalue", "secondvalue",
"--twovalues:firstvalue", "secondvalue",
"--twovaluesindex4", "1", "0xA",
"--twovaluesindex5=2", "0xB",
"--threevalues", "1", "0xC", "thirdvalue",
/* bool on/off */
"--boolean", "on",
"--boolean", "off",
"--boolean", "invalid",
"--booleanindex2", "on",
"--booleanindex7", "off",
"--booleanindex9", "invalid",
/* standard options */
"--help",
"-help",
"-?",
"-h",
"--version",
"-version",
"-V",
/* done */
NULL
};
int argc2 = (int)RT_ELEMENTS(argv2) - 1;
CHECK(RT_SUCCESS(RTGetOptInit(&GetState, argc2, (char **)argv2, &s_aOpts2[0], RT_ELEMENTS(s_aOpts2), 0, 0 /* fFlags */)));
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 2);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string1"));
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string2"));
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string3"));
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string4"));
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, ""));
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, ""));
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 2);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string5"));
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string6"));
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string7"));
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, ""));
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 's', 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, ""));
CHECK(GetState.uIndex == UINT32_MAX);
/* -i */
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'i', 2);
CHECK(Val.i32 == -42);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'i', 1);
CHECK(Val.i32 == -42);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'i', 1);
CHECK(Val.i32 == -42);
/* --optwithint */
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'i', 2);
CHECK(Val.i32 == 42);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'i', 1);
CHECK(Val.i32 == 42);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'i', 1);
CHECK(Val.i32 == 42);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'v', 1);
CHECK_pDef(s_aOpts2, 2);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'v', 1);
CHECK_pDef(s_aOpts2, 2);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'q', 1);
CHECK_pDef(s_aOpts2, 3);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 384, 1);
CHECK_pDef(s_aOpts2, 4);
/* -novalue / -startvm (single dash long options) */
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 385, 1);
CHECK_pDef(s_aOpts2, 5);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 386, 2);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "myvm"));
/* no-dash options */
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 387, 1);
CHECK_pDef(s_aOpts2, 7);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 388, 2);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string9"));
/* non-option, option, non-option */
CHECK_GETOPT(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1);
CHECK(Val.psz && !strcmp(Val.psz, "filename1"));
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'q', 1);
CHECK_pDef(s_aOpts2, 3);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1);
CHECK(Val.psz && !strcmp(Val.psz, "filename2"));
/* compress short options */
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'v', 0);
CHECK_pDef(s_aOpts2, 2);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'q', 0);
CHECK_pDef(s_aOpts2, 3);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'i', 1);
CHECK(Val.i32 == 999);
/* IPv4 */
RTTestSub(hTest, "RTGetOpt - IPv4");
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'g', 1);
CHECK(Val.IPv4Addr.u == RT_H2N_U32_C(RT_BSWAP_U32_C(RT_MAKE_U32_FROM_U8(192,168,1,1))));
/* Ethernet MAC address. */
RTTestSub(hTest, "RTGetOpt - MAC Address");
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'm', 1);
CHECK( Val.MacAddr.au8[0] == 0x08
&& Val.MacAddr.au8[1] == 0x00
&& Val.MacAddr.au8[2] == 0x27
&& Val.MacAddr.au8[3] == 0x00
&& Val.MacAddr.au8[4] == 0xab
&& Val.MacAddr.au8[5] == 0xf3);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'm', 1);
CHECK( Val.MacAddr.au8[0] == 0x01
&& Val.MacAddr.au8[1] == 0x00
&& Val.MacAddr.au8[2] == 0x00
&& Val.MacAddr.au8[3] == 0x00
&& Val.MacAddr.au8[4] == 0x00
&& Val.MacAddr.au8[5] == 0x0c);
/* string with indexed argument */
RTTestSub(hTest, "RTGetOpt - Option w/ Index");
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 400, 2);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string10"));
CHECK(GetState.uIndex == 786);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 400, 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string11"));
CHECK(GetState.uIndex == 786);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 400, 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string12"));
CHECK(GetState.uIndex == 786);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 400, 2);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string13"));
CHECK(GetState.uIndex == 687);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 400, 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string14"));
CHECK(GetState.uIndex == 687);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 400, 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "string15"));
CHECK(GetState.uIndex == 687);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 400, 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, ""));
CHECK(GetState.uIndex == 688);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 400, 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, ""));
CHECK(GetState.uIndex == 689);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 401, 2);
CHECK(Val.i32 == 1000);
CHECK(GetState.uIndex == 137);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 402, 2);
CHECK( Val.MacAddr.au8[0] == 0x08
&& Val.MacAddr.au8[1] == 0x00
&& Val.MacAddr.au8[2] == 0x27
&& Val.MacAddr.au8[3] == 0x00
&& Val.MacAddr.au8[4] == 0xab
&& Val.MacAddr.au8[5] == 0xf3);
CHECK(GetState.uIndex == 138);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 403, 1);
CHECK(GetState.uIndex == 1);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 404, 1);
CHECK(GetState.uIndex == UINT32_MAX);
/* RTGetOptFetchValue tests */
RTTestSub(hTest, "RTGetOptFetchValue");
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 405, 2);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "firstvalue"));
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT(RTGetOptFetchValue(&GetState, &Val, RTGETOPT_REQ_STRING), VINF_SUCCESS, 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "secondvalue"));
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 405, 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "firstvalue"));
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT(RTGetOptFetchValue(&GetState, &Val, RTGETOPT_REQ_STRING), VINF_SUCCESS, 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "secondvalue"));
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 406, 2);
CHECK(Val.u32 == 1);
CHECK(GetState.uIndex == 4);
CHECK_GETOPT(RTGetOptFetchValue(&GetState, &Val, RTGETOPT_REQ_UINT32), VINF_SUCCESS, 1);
CHECK(Val.u32 == 10);
CHECK(GetState.uIndex == 4);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 406, 1);
CHECK(Val.u32 == 2);
CHECK(GetState.uIndex == 5);
CHECK_GETOPT(RTGetOptFetchValue(&GetState, &Val, RTGETOPT_REQ_UINT32), VINF_SUCCESS, 1);
CHECK(Val.u32 == 11);
CHECK(GetState.uIndex == 5);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 407, 2);
CHECK(Val.u32 == 1);
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT(RTGetOptFetchValue(&GetState, &Val, RTGETOPT_REQ_UINT32), VINF_SUCCESS, 1);
CHECK(Val.u32 == 12);
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT(RTGetOptFetchValue(&GetState, &Val, RTGETOPT_REQ_STRING), VINF_SUCCESS, 1);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "thirdvalue"));
CHECK(GetState.uIndex == UINT32_MAX);
/* bool on/off tests */
RTTestSub(hTest, "RTGetOpt - bool on/off");
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 408, 2);
CHECK(Val.f);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 408, 2);
CHECK(!Val.f);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), VERR_GETOPT_UNKNOWN_OPTION, 2);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "invalid"));
/* bool on/off with indexed argument */
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 409, 2);
CHECK(Val.f);
CHECK(GetState.uIndex == 2);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 409, 2);
CHECK(!Val.f);
CHECK(GetState.uIndex == 7);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), VERR_GETOPT_UNKNOWN_OPTION, 2);
CHECK(VALID_PTR(Val.psz) && !strcmp(Val.psz, "invalid"));
/* standard options. */
RTTestSub(hTest, "Standard options");
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'h', 1);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'h', 1);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'h', 1);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'h', 1);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'V', 1);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'V', 1);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'V', 1);
/* the end */
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 0, 0);
CHECK(Val.pDef == NULL);
CHECK(argc2 == GetState.iNext);
/*
* Options first.
*/
RTTestSub(hTest, "Options first");
const char *argv3[] =
{
"foo1",
"-s", "string1",
"foo2",
"--optwithstring", "string2",
"foo3",
"-i", "-42",
"foo4",
"-i:-42",
"-i=-42",
"foo5",
"foo6",
"foo7",
"-i:-42",
"-i=-42",
"foo8",
"--twovalues", "firstvalue", "secondvalue",
"foo9",
"--twovalues:firstvalue", "secondvalue",
"foo10",
"--",
"--optwithstring",
"foo11",
"foo12",
/* done */
NULL
};
int argc3 = (int)RT_ELEMENTS(argv3) - 1;
CHECK(RT_SUCCESS(RTGetOptInit(&GetState, argc3, (char **)argv3, &s_aOpts2[0], RT_ELEMENTS(s_aOpts2), 0,
RTGETOPTINIT_FLAGS_OPTS_FIRST)));
/* -s */
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), 's', 2, "string1");
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), 's', 2, "string2");
CHECK(GetState.uIndex == UINT32_MAX);
/* -i */
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'i', 2);
CHECK(Val.i32 == -42);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'i', 1);
CHECK(Val.i32 == -42);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'i', 1);
CHECK(Val.i32 == -42);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'i', 1);
CHECK(Val.i32 == -42);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'i', 1);
CHECK(Val.i32 == -42);
/* --twovalues */
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), 405, 2, "firstvalue");
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT_STR(RTGetOptFetchValue(&GetState, &Val, RTGETOPT_REQ_STRING), VINF_SUCCESS, 1, "secondvalue");
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), 405, 1, "firstvalue");
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT_STR(RTGetOptFetchValue(&GetState, &Val, RTGETOPT_REQ_STRING), VINF_SUCCESS, 1, "secondvalue");
CHECK(GetState.uIndex == UINT32_MAX);
/* -- */
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 2, "foo1");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo2");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo3");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo4");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo5");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo6");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo7");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo8");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo9");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo10");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "--optwithstring");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo11");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo12");
/* the end */
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 0, 0);
CHECK(Val.pDef == NULL);
CHECK(argc3 == GetState.iNext);
/*
* Options first, part 2: No dash-dash.
*/
const char *argv4[] =
{
"foo1",
"-s", "string1",
"foo2",
"--optwithstring", "string2",
"foo3",
"-i", "-42",
"foo4",
"-i:-42",
"-i=-42",
"foo5",
"foo6",
"foo7",
"-i:-42",
"-i=-42",
"foo8",
"--twovalues", "firstvalue", "secondvalue",
"foo9",
"--twovalues:firstvalue", "secondvalue",
"foo10",
"foo11",
"foo12",
/* done */
NULL
};
int argc4 = (int)RT_ELEMENTS(argv4) - 1;
CHECK(RT_SUCCESS(RTGetOptInit(&GetState, argc4, (char **)argv4, &s_aOpts2[0], RT_ELEMENTS(s_aOpts2), 0,
RTGETOPTINIT_FLAGS_OPTS_FIRST)));
/* -s */
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), 's', 2, "string1");
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), 's', 2, "string2");
CHECK(GetState.uIndex == UINT32_MAX);
/* -i */
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'i', 2);
CHECK(Val.i32 == -42);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'i', 1);
CHECK(Val.i32 == -42);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'i', 1);
CHECK(Val.i32 == -42);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'i', 1);
CHECK(Val.i32 == -42);
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 'i', 1);
CHECK(Val.i32 == -42);
/* --twovalues */
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), 405, 2, "firstvalue");
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT_STR(RTGetOptFetchValue(&GetState, &Val, RTGETOPT_REQ_STRING), VINF_SUCCESS, 1, "secondvalue");
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), 405, 1, "firstvalue");
CHECK(GetState.uIndex == UINT32_MAX);
CHECK_GETOPT_STR(RTGetOptFetchValue(&GetState, &Val, RTGETOPT_REQ_STRING), VINF_SUCCESS, 1, "secondvalue");
CHECK(GetState.uIndex == UINT32_MAX);
/* -- */
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo1");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo2");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo3");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo4");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo5");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo6");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo7");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo8");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo9");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo10");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo11");
CHECK_GETOPT_STR(RTGetOpt(&GetState, &Val), VINF_GETOPT_NOT_OPTION, 1, "foo12");
/* the end */
CHECK_GETOPT(RTGetOpt(&GetState, &Val), 0, 0);
CHECK(Val.pDef == NULL);
CHECK(argc4 == GetState.iNext);
/*
* Summary.
*/
return RTTestSummaryAndDestroy(hTest);
}
/*
* Tcp output routine: figure out what should be sent and send it.
*/
int
tcp_output(PNATState pData, register struct tcpcb *tp)
{
register struct socket *so = tp->t_socket;
register long len, win;
int off, flags, error;
register struct mbuf *m = NULL;
register struct tcpiphdr *ti;
u_char opt[MAX_TCPOPTLEN];
unsigned optlen, hdrlen;
int idle, sendalot;
int size = 0;
LogFlowFunc(("ENTER: tcp_output: tp = %R[tcpcb793]\n", tp));
/*
* Determine length of data that should be transmitted,
* and flags that will be used.
* If there is some data or critical controls (SYN, RST)
* to send, then transmit; otherwise, investigate further.
*/
idle = (tp->snd_max == tp->snd_una);
if (idle && tp->t_idle >= tp->t_rxtcur)
/*
* We have been idle for "a while" and no acks are
* expected to clock out any data we send --
* slow start to get ack "clock" running again.
*/
tp->snd_cwnd = tp->t_maxseg;
again:
sendalot = 0;
off = tp->snd_nxt - tp->snd_una;
win = min(tp->snd_wnd, tp->snd_cwnd);
flags = tcp_outflags[tp->t_state];
Log2((" --- tcp_output flags = 0x%x\n", flags));
/*
* If in persist timeout with window of 0, send 1 byte.
* Otherwise, if window is small but nonzero
* and timer expired, we will send what we can
* and go to transmit state.
*/
if (tp->t_force)
{
if (win == 0)
{
/*
* If we still have some data to send, then
* clear the FIN bit. Usually this would
* happen below when it realizes that we
* aren't sending all the data. However,
* if we have exactly 1 byte of unset data,
* then it won't clear the FIN bit below,
* and if we are in persist state, we wind
* up sending the packet without recording
* that we sent the FIN bit.
*
* We can't just blindly clear the FIN bit,
* because if we don't have any more data
* to send then the probe will be the FIN
* itself.
*/
if (off < SBUF_LEN(&so->so_snd))
flags &= ~TH_FIN;
win = 1;
}
else
{
tp->t_timer[TCPT_PERSIST] = 0;
tp->t_rxtshift = 0;
}
}
len = min(SBUF_LEN(&so->so_snd), win) - off;
if (len < 0)
{
/*
* If FIN has been sent but not acked,
* but we haven't been called to retransmit,
* len will be -1. Otherwise, window shrank
* after we sent into it. If window shrank to 0,
* cancel pending retransmit and pull snd_nxt
* back to (closed) window. We will enter persist
* state below. If the window didn't close completely,
* just wait for an ACK.
*/
len = 0;
if (win == 0)
{
tp->t_timer[TCPT_REXMT] = 0;
tp->snd_nxt = tp->snd_una;
}
}
if (len > tp->t_maxseg)
{
len = tp->t_maxseg;
sendalot = 1;
}
if (SEQ_LT(tp->snd_nxt + len, tp->snd_una + SBUF_LEN(&so->so_snd)))
flags &= ~TH_FIN;
win = sbspace(&so->so_rcv);
/*
* Sender silly window avoidance. If connection is idle
* and can send all data, a maximum segment,
* at least a maximum default-size segment do it,
* or are forced, do it; otherwise don't bother.
* If peer's buffer is tiny, then send
* when window is at least half open.
* If retransmitting (possibly after persist timer forced us
* to send into a small window), then must resend.
*/
if (len)
{
if (len == tp->t_maxseg)
goto send;
if ((1 || idle || tp->t_flags & TF_NODELAY) &&
len + off >= SBUF_LEN(&so->so_snd))
goto send;
if (tp->t_force)
goto send;
if (len >= tp->max_sndwnd / 2 && tp->max_sndwnd > 0)
goto send;
if (SEQ_LT(tp->snd_nxt, tp->snd_max))
goto send;
}
/*
* Compare available window to amount of window
* known to peer (as advertised window less
* next expected input). If the difference is at least two
* max size segments, or at least 50% of the maximum possible
* window, then want to send a window update to peer.
*/
if (win > 0)
{
/*
* "adv" is the amount we can increase the window,
* taking into account that we are limited by
* TCP_MAXWIN << tp->rcv_scale.
*/
long adv = min(win, (long)TCP_MAXWIN << tp->rcv_scale);
if (SEQ_GT(tp->rcv_adv, tp->rcv_nxt))
adv -= tp->rcv_adv - tp->rcv_nxt;
if (adv >= (long) (2 * tp->t_maxseg))
goto send;
if (2 * adv >= (long) SBUF_SIZE(&so->so_rcv))
goto send;
}
/*
* Send if we owe peer an ACK.
*/
if (tp->t_flags & TF_ACKNOW)
goto send;
if (flags & (TH_SYN|TH_RST))
goto send;
if (SEQ_GT(tp->snd_up, tp->snd_una))
goto send;
/*
* If our state indicates that FIN should be sent
* and we have not yet done so, or we're retransmitting the FIN,
* then we need to send.
*/
if ( flags & TH_FIN
&& ((tp->t_flags & TF_SENTFIN) == 0 || tp->snd_nxt == tp->snd_una))
goto send;
/*
* TCP window updates are not reliable, rather a polling protocol
* using ``persist'' packets is used to insure receipt of window
* updates. The three ``states'' for the output side are:
* idle not doing retransmits or persists
* persisting to move a small or zero window
* (re)transmitting and thereby not persisting
*
* tp->t_timer[TCPT_PERSIST]
* is set when we are in persist state.
* tp->t_force
* is set when we are called to send a persist packet.
* tp->t_timer[TCPT_REXMT]
* is set when we are retransmitting
* The output side is idle when both timers are zero.
*
* If send window is too small, there is data to transmit, and no
* retransmit or persist is pending, then go to persist state.
* If nothing happens soon, send when timer expires:
* if window is nonzero, transmit what we can,
* otherwise force out a byte.
*/
if ( SBUF_LEN(&so->so_snd)
&& tp->t_timer[TCPT_REXMT] == 0
&& tp->t_timer[TCPT_PERSIST] == 0)
{
tp->t_rxtshift = 0;
tcp_setpersist(tp);
}
/*
* No reason to send a segment, just return.
*/
tcpstat.tcps_didnuttin++;
LogFlowFuncLeave();
return (0);
send:
LogFlowFunc(("send\n"));
/*
* Before ESTABLISHED, force sending of initial options
* unless TCP set not to do any options.
* NOTE: we assume that the IP/TCP header plus TCP options
* always fit in a single mbuf, leaving room for a maximum
* link header, i.e.
* max_linkhdr + sizeof (struct tcpiphdr) + optlen <= MHLEN
*/
optlen = 0;
hdrlen = sizeof (struct tcpiphdr);
if (flags & TH_SYN)
{
tp->snd_nxt = tp->iss;
if ((tp->t_flags & TF_NOOPT) == 0)
{
u_int16_t mss;
opt[0] = TCPOPT_MAXSEG;
opt[1] = 4;
mss = RT_H2N_U16((u_int16_t) tcp_mss(pData, tp, 0));
memcpy((caddr_t)(opt + 2), (caddr_t)&mss, sizeof(mss));
optlen = 4;
#if 0
if ( (tp->t_flags & TF_REQ_SCALE)
&& ( (flags & TH_ACK) == 0
|| (tp->t_flags & TF_RCVD_SCALE)))
{
*((u_int32_t *) (opt + optlen)) = RT_H2N_U32( TCPOPT_NOP << 24
| TCPOPT_WINDOW << 16
| TCPOLEN_WINDOW << 8
| tp->request_r_scale);
optlen += 4;
}
#endif
}
}
/*
* Send a timestamp and echo-reply if this is a SYN and our side
* wants to use timestamps (TF_REQ_TSTMP is set) or both our side
* and our peer have sent timestamps in our SYN's.
*/
#if 0
if ( (tp->t_flags & (TF_REQ_TSTMP|TF_NOOPT)) == TF_REQ_TSTMP
&& (flags & TH_RST) == 0
&& ( (flags & (TH_SYN|TH_ACK)) == TH_SYN
|| (tp->t_flags & TF_RCVD_TSTMP)))
{
u_int32_t *lp = (u_int32_t *)(opt + optlen);
/* Form timestamp option as shown in appendix A of RFC 1323. */
*lp++ = RT_H2N_U32_C(TCPOPT_TSTAMP_HDR);
*lp++ = RT_H2N_U32(tcp_now);
*lp = RT_H2N_U32(tp->ts_recent);
optlen += TCPOLEN_TSTAMP_APPA;
}
#endif
hdrlen += optlen;
/*
* Adjust data length if insertion of options will
* bump the packet length beyond the t_maxseg length.
*/
if (len > tp->t_maxseg - optlen)
{
len = tp->t_maxseg - optlen;
sendalot = 1;
}
/*
* Grab a header mbuf, attaching a copy of data to
* be transmitted, and initialize the header from
* the template for sends on this connection.
*/
if (len)
{
if (tp->t_force && len == 1)
tcpstat.tcps_sndprobe++;
else if (SEQ_LT(tp->snd_nxt, tp->snd_max))
{
tcpstat.tcps_sndrexmitpack++;
tcpstat.tcps_sndrexmitbyte += len;
}
else
{
tcpstat.tcps_sndpack++;
tcpstat.tcps_sndbyte += len;
}
size = MCLBYTES;
if ((len + hdrlen + ETH_HLEN) < MSIZE)
size = MCLBYTES;
else if ((len + hdrlen + ETH_HLEN) < MCLBYTES)
size = MCLBYTES;
else if((len + hdrlen + ETH_HLEN) < MJUM9BYTES)
size = MJUM9BYTES;
else if ((len + hdrlen + ETH_HLEN) < MJUM16BYTES)
size = MJUM16BYTES;
else
AssertMsgFailed(("Unsupported size"));
m = m_getjcl(pData, M_NOWAIT, MT_HEADER, M_PKTHDR, size);
if (m == NULL)
{
/* error = ENOBUFS; */
error = 1;
goto out;
}
m->m_data += if_maxlinkhdr;
m->m_pkthdr.header = mtod(m, void *);
m->m_len = hdrlen;
/*
* This will always succeed, since we make sure our mbufs
* are big enough to hold one MSS packet + header + ... etc.
*/
#if 0
if (len <= MHLEN - hdrlen - max_linkhdr)
{
#endif
sbcopy(&so->so_snd, off, (int) len, mtod(m, caddr_t) + hdrlen);
m->m_len += len;
#if 0
}
else
{
m->m_next = m_copy(so->so_snd.sb_mb, off, (int) len);
if (m->m_next == 0)
len = 0;
}
#endif
/*
* If we're sending everything we've got, set PUSH.
* (This will keep happy those implementations which only
* give data to the user when a buffer fills or
* a PUSH comes in.)
*/
if (off + len == SBUF_LEN(&so->so_snd))
flags |= TH_PUSH;
}
else
{
void
dnsproxy_query(PNATState pData, struct socket *so, struct mbuf *m, int iphlen)
#endif
{
#ifndef VBOX
char buf[MAX_BUFSPACE];
unsigned int fromlen = sizeof(fromaddr);
struct timeval tv;
#else
struct ip *ip;
char *buf;
int retransmit;
struct udphdr *udp;
#endif
struct sockaddr_in addr;
struct request *req = NULL;
#ifndef VBOX
struct sockaddr_in fromaddr;
#else
struct sockaddr_in fromaddr = { 0, };
#endif
int byte = 0;
++all_queries;
#ifndef VBOX
/* Reschedule event */
event_add((struct event *)arg, NULL);
/* read packet from socket */
if ((byte = recvfrom(fd, buf, sizeof(buf), 0,
(struct sockaddr *)&fromaddr, &fromlen)) == -1) {
LogRel(("recvfrom failed: %s\n", strerror(errno)));
++dropped_queries;
return;
}
/* check for minimum dns packet length */
if (byte < 12) {
LogRel(("query too short from %s\n", inet_ntoa(fromaddr.sin_addr)));
++dropped_queries;
return;
}
/* allocate new request */
if ((req = calloc(1, sizeof(struct request))) == NULL) {
LogRel(("calloc failed\n"));
++dropped_queries;
return;
}
req->id = QUERYID;
memcpy(&req->client, &fromaddr, sizeof(struct sockaddr_in));
memcpy(&req->clientid, &buf[0], 2);
/* where is this query coming from? */
if (is_internal(pData, fromaddr.sin_addr)) {
req->recursion = RD(buf);
DPRINTF(("Internal query RD=%d\n", req->recursion));
} else {
/* no recursion for foreigners */
req->recursion = 0;
DPRINTF(("External query RD=%d\n", RD(buf)));
}
/* insert it into the hash table */
hash_add_request(pData, req);
/* overwrite the original query id */
memcpy(&buf[0], &req->id, 2);
if (req->recursion) {
/* recursive queries timeout in 90s */
event_set(&req->timeout, -1, 0, timeout, req);
tv.tv_sec=recursive_timeout; tv.tv_usec=0;
event_add(&req->timeout, &tv);
/* send it to our recursive server */
if ((byte = sendto(sock_answer, buf, (unsigned int)byte, 0,
(struct sockaddr *)&recursive_addr,
sizeof(struct sockaddr_in))) == -1) {
LogRel(("sendto failed: %s\n", strerror(errno)));
++dropped_queries;
return;
}
++recursive_queries;
} else {
/* authoritative queries timeout in 10s */
event_set(&req->timeout, -1, 0, timeout, req);
tv.tv_sec=authoritative_timeout; tv.tv_usec=0;
event_add(&req->timeout, &tv);
/* send it to our authoritative server */
if ((byte = sendto(sock_answer, buf, (unsigned int)byte, 0,
(struct sockaddr *)&authoritative_addr,
sizeof(struct sockaddr_in))) == -1) {
LogRel(("sendto failed: %s\n", strerror(errno)));
++dropped_queries;
return;
}
++authoritative_queries;
}
#else /* VBOX */
AssertPtr(pData);
/* m->m_data points to IP header */
#if 0
/* XXX: for some reason it make gdb ill,
* it good to have this assert here with assumption above.
*/
M_ASSERTPKTHDR(m);
#endif
ip = mtod(m, struct ip *);
udp = (struct udphdr *)(m->m_data + iphlen);
fromaddr.sin_addr.s_addr = ip->ip_src.s_addr;
fromaddr.sin_port = udp->uh_sport;
fromaddr.sin_family = AF_INET;
/* iphlen equals to lenght of ip header */
Assert(iphlen == sizeof(struct ip));
iphlen += sizeof (struct udphdr);
byte = m->m_len - iphlen;
buf = m->m_data + iphlen;
/* check for minimum dns packet length */
if (byte < 12) {
LogRel(("NAT: Query too short from %RTnaipv4\n", fromaddr.sin_addr));
++dropped_queries;
return;
}
req = so->so_timeout_arg;
if (!req)
{
Assert(!so->so_timeout_arg);
if ((req = RTMemAllocZ(sizeof(struct request) + byte)) == NULL)
{
LogRel(("NAT: calloc failed\n"));
++dropped_queries;
return;
}
req->id = QUERYID;
memcpy(&req->client, &fromaddr, sizeof(struct sockaddr_in));
memcpy(&req->clientid, &buf[0], 2);
req->dns_server = TAILQ_LAST(&pData->pDnsList, dns_list_head);
req->dnsgen = pData->dnsgen;
if (req->dns_server == NULL)
{
RTMemFree(req);
return;
}
retransmit = 0;
so->so_timeout = timeout;
so->so_timeout_arg = req;
req->nbyte = byte;
memcpy(req->byte, buf, byte); /* copying original request */
}
else
{
if (req->dnsgen != pData->dnsgen)
{
/* XXX: Log2 */
LogRel(("NAT: dnsproxy: query: req %p dnsgen %u != %u on %R[natsock]\n",
req, req->dnsgen, pData->dnsgen, so));
/*
* XXX: TODO: this probably requires more cleanup.
* Cf. XXX comment for sendto() failure below, but that
* error leg is probably untested since ~never taken.
*/
++dropped_queries;
return;
}
retransmit = 1;
}
req->recursion = 0;
DPRINTF(("External query RD=%d\n", RD(buf)));
if (retransmit == 0)
hash_add_request(pData, req);
/* overwrite the original query id */
memcpy(&buf[0], &req->id, 2);
/* let's slirp to care about expiration */
so->so_expire = curtime + recursive_timeout * 1000;
memset(&addr, 0, sizeof(struct sockaddr_in));
addr.sin_family = AF_INET;
if (req->dns_server->de_addr.s_addr == (pData->special_addr.s_addr | RT_H2N_U32_C(CTL_ALIAS))) {
/* undo loopback remapping done in get_dns_addr_domain() */
addr.sin_addr.s_addr = RT_N2H_U32_C(INADDR_LOOPBACK);
}
else {
addr.sin_addr.s_addr = req->dns_server->de_addr.s_addr;
}
addr.sin_port = htons(53);
/* send it to our authoritative server */
Log2(("NAT: request will be %ssent to %RTnaipv4 on %R[natsock]\n",
retransmit ? "re" : "", addr.sin_addr, so));
byte = sendto(so->s, buf, (unsigned int)byte, 0,
(struct sockaddr *)&addr,
sizeof(struct sockaddr_in));
if (byte == -1)
{
/* XXX: is it really enough? */
LogRel(("NAT: sendto failed: %s\n", strerror(errno)));
++dropped_queries;
return;
}
so->so_state = SS_ISFCONNECTED; /* now it's selected */
Log2(("NAT: request was %ssent to %RTnaipv4 on %R[natsock]\n",
retransmit ? "re" : "", addr.sin_addr, so));
++authoritative_queries;
# if 0
/* XXX: this stuff for _debugging_ only,
* first enforce guest to send next request
* and second for faster getting timeout callback
* other option is adding couple entries in resolv.conf with
* invalid nameservers.
*
* For testing purposes could be used
* namebench -S -q 10000 -m random or -m chunk
*/
/* RTThreadSleep(3000); */
/* curtime += 300; */
# endif
#endif /* VBOX */
}
