/**
* Initiates a new List Exported Devices request.
*
* @returns VBox status code.
*/
int USBProxyBackendUsbIp::startListExportedDevicesReq()
{
int rc = VINF_SUCCESS;
/*
* Reset the current state and reconnect in case we were called in the middle
* of another transfer (which should not happen).
*/
Assert(m->enmRecvState == kUsbIpRecvState_None);
if (m->enmRecvState != kUsbIpRecvState_None)
rc = reconnect();
if (RT_SUCCESS(rc))
{
/* Send of the request. */
UsbIpReqDevList ReqDevList;
ReqDevList.u16Version = RT_H2N_U16(USBIP_VERSION);
ReqDevList.u16Cmd = RT_H2N_U16(USBIP_INDICATOR_REQ | USBIP_REQ_RET_DEVLIST);
ReqDevList.u32Status = RT_H2N_U32(0);
rc = RTTcpWrite(m->hSocket, &ReqDevList, sizeof(ReqDevList));
if (RT_SUCCESS(rc))
advanceState(kUsbIpRecvState_Hdr);
}
return rc;
}
/**
* @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);
}
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;
}
/**
* @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);
}
/**
* Network manager creates DHCPACK
*/
int NetworkManager::ack(const Client& client, uint32_t u32Xid,
uint8_t *pu8ReqList, int cReqList)
{
RTNETADDRIPV4 address;
prepareReplyPacket4Client(client, u32Xid);
Lease l = client.lease();
address = l.getAddress();
m->BootPReplyMsg.BootPHeader.bp_ciaddr = address;
/* rfc2131 4.3.1 is about DHCPDISCOVER and this value is equal to ciaddr from
* DHCPREQUEST or 0 ...
* XXX: Using addressHint is not correct way to initialize [cy]iaddress...
*/
m->BootPReplyMsg.BootPHeader.bp_ciaddr = address;
m->BootPReplyMsg.BootPHeader.bp_yiaddr = address;
Assert(m->BootPReplyMsg.BootPHeader.bp_yiaddr.u);
/* options:
* - IP address lease time (if DHCPREQUEST)
* - message type
* - server identifier
*/
RawOption opt;
RT_ZERO(opt);
std::vector<RawOption> extra;
opt.u8OptId = RTNET_DHCP_OPT_MSG_TYPE;
opt.au8RawOpt[0] = RTNET_DHCP_MT_ACK;
opt.cbRawOpt = 1;
extra.push_back(opt);
/*
* XXX: lease time should be conditional. If on dhcprequest then tim should be provided,
* else on dhcpinform it mustn't.
*/
opt.u8OptId = RTNET_DHCP_OPT_LEASE_TIME;
*(uint32_t *)opt.au8RawOpt = RT_H2N_U32(l.getExpiration());
opt.cbRawOpt = sizeof(RTNETADDRIPV4);
extra.push_back(opt);
processParameterReqList(client, pu8ReqList, cReqList, extra);
return doReply(client, extra);
}
int VBoxNetDhcp::initNoMain()
{
CmdParameterIterator it;
RTNETADDRIPV4 address = getIpv4Address();
RTNETADDRIPV4 netmask = getIpv4Netmask();
RTNETADDRIPV4 networkId;
networkId.u = address.u & netmask.u;
RTNETADDRIPV4 UpperAddress;
RTNETADDRIPV4 LowerAddress = networkId;
UpperAddress.u = RT_H2N_U32(RT_N2H_U32(LowerAddress.u) | RT_N2H_U32(netmask.u));
for (it = CmdParameterll.begin(); it != CmdParameterll.end(); ++it)
{
switch(it->Key)
{
case 'l':
RTNetStrToIPv4Addr(it->strValue.c_str(), &LowerAddress);
break;
case 'u':
RTNetStrToIPv4Addr(it->strValue.c_str(), &UpperAddress);
break;
case 'b':
break;
}
}
ConfigurationManager *confManager = ConfigurationManager::getConfigurationManager();
AssertPtrReturn(confManager, VERR_INTERNAL_ERROR);
confManager->addNetwork(unconst(g_RootConfig),
networkId,
netmask,
LowerAddress,
UpperAddress);
return VINF_SUCCESS;
}
/**
* Network manager creates DHCPOFFER datagramm
*/
int NetworkManager::offer4Client(const Client& client, uint32_t u32Xid,
uint8_t *pu8ReqList, int cReqList)
{
Lease l(client); /* XXX: oh, it looks badly, but now we have lease */
prepareReplyPacket4Client(client, u32Xid);
RTNETADDRIPV4 address = l.getAddress();
m->BootPReplyMsg.BootPHeader.bp_yiaddr = address;
/* Ubuntu ???*/
m->BootPReplyMsg.BootPHeader.bp_ciaddr = address;
/* options:
* - IP lease time
* - message type
* - server identifier
*/
RawOption opt;
RT_ZERO(opt);
std::vector<RawOption> extra;
opt.u8OptId = RTNET_DHCP_OPT_MSG_TYPE;
opt.au8RawOpt[0] = RTNET_DHCP_MT_OFFER;
opt.cbRawOpt = 1;
extra.push_back(opt);
opt.u8OptId = RTNET_DHCP_OPT_LEASE_TIME;
const NetworkConfigEntity *pCfg = l.getConfig();
AssertPtr(pCfg);
*(uint32_t *)opt.au8RawOpt = RT_H2N_U32(pCfg->expirationPeriod());
opt.cbRawOpt = sizeof(RTNETADDRIPV4);
extra.push_back(opt);
processParameterReqList(client, pu8ReqList, cReqList, extra);
return doReply(client, extra);
}
/**
* @note: const dropped here, because of map<K,V>::operator[] which isn't const, map<K,V>::at() has const
* variant but it's C++11.
*/
int hostDnsServers(const ComHostPtr& host, const RTNETADDRIPV4& networkid,
/*const*/ AddressToOffsetMapping& mapping, AddressList& servers)
{
servers.clear();
ComBstrArray strs;
if (SUCCEEDED(host->COMGETTER(NameServers)(ComSafeArrayAsOutParam(strs))))
{
RTNETADDRIPV4 addr;
int rc;
for (unsigned int i = 0; i < strs.size(); ++i)
{
rc = RTNetStrToIPv4Addr(com::Utf8Str(strs[i]).c_str(), &addr);
if (RT_SUCCESS(rc))
{
if (addr.au8[0] == 127)
{
/* XXX: here we want map<K,V>::at(const K& k) const */
if (mapping[addr] != 0)
{
addr.u = RT_H2N_U32(RT_N2H_U32(networkid.u)
+ mapping[addr]);
}
else
continue; /* XXX: Warning here (local mapping wasn't registered) */
}
servers.push_back(addr);
}
}
}
else
return VERR_NOT_FOUND;
return VINF_SUCCESS;
}
/**
* We bind lease for client till it continue with it on DHCPREQUEST.
*/
Lease ConfigurationManager::allocateLease4Client(const Client& client, PCRTNETBOOTP pDhcpMsg, size_t cbDhcpMsg)
{
{
/**
* This mean that client has already bound or commited lease.
* If we've it happens it means that we received DHCPDISCOVER twice.
*/
const Lease l = client.lease();
if (l != Lease::NullLease)
{
/* Here we should take lease from the m_allocation which was feed with leases
* on start
*/
if (l.isExpired())
{
expireLease4Client(const_cast<Client&>(client));
if (!l.isExpired())
return l;
}
else
{
AssertReturn(l.getAddress().u != 0, Lease::NullLease);
return l;
}
}
}
RTNETADDRIPV4 hintAddress;
RawOption opt;
NetworkConfigEntity *pNetCfg;
Client cl(client);
AssertReturn(g_RootConfig->match(cl, (BaseConfigEntity **)&pNetCfg) > 0, Lease::NullLease);
/* DHCPDISCOVER MAY contain request address */
hintAddress.u = 0;
int rc = findOption(RTNET_DHCP_OPT_REQ_ADDR, pDhcpMsg, cbDhcpMsg, opt);
if (RT_SUCCESS(rc))
{
hintAddress.u = *(uint32_t *)opt.au8RawOpt;
if ( RT_H2N_U32(hintAddress.u) < RT_H2N_U32(pNetCfg->lowerIp().u)
|| RT_H2N_U32(hintAddress.u) > RT_H2N_U32(pNetCfg->upperIp().u))
hintAddress.u = 0; /* clear hint */
}
if ( hintAddress.u
&& !isAddressTaken(hintAddress))
{
Lease l(cl);
l.setConfig(pNetCfg);
l.setAddress(hintAddress);
m->m_allocations.insert(MapLease2Ip4AddressPair(l, hintAddress));
return l;
}
uint32_t u32 = 0;
for(u32 = RT_H2N_U32(pNetCfg->lowerIp().u);
u32 <= RT_H2N_U32(pNetCfg->upperIp().u);
++u32)
{
RTNETADDRIPV4 address;
address.u = RT_H2N_U32(u32);
if (!isAddressTaken(address))
{
Lease l(cl);
l.setConfig(pNetCfg);
l.setAddress(address);
m->m_allocations.insert(MapLease2Ip4AddressPair(l, address));
return l;
}
}
return Lease::NullLease;
}
/*
* 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
{
extern "C" int RTWinSocketPair(int domain, int type, int protocol, SOCKET socket_vector[2])
{
LogFlowFunc(("ENTER: domain:%d, type:%d, protocol:%d, socket_vector:%p\n",
domain, type, protocol, socket_vector));
switch (domain)
{
case AF_INET:
break;
case AF_INET6: /* I dobt we really need it. */
default:
AssertMsgFailedReturn(("Unsuported domain:%d\n", domain),
VERR_INVALID_PARAMETER);
}
switch(type)
{
case SOCK_STREAM:
case SOCK_DGRAM:
break;
default:
AssertMsgFailedReturn(("Unsuported type:%d\n", type),
VERR_INVALID_PARAMETER);
}
AssertPtrReturn(socket_vector, VERR_INVALID_PARAMETER);
if (!socket_vector)
return VERR_INVALID_PARAMETER;
socket_vector[0] = socket_vector[1] = INVALID_SOCKET;
SOCKET listener = INVALID_SOCKET;
union {
struct sockaddr_in in_addr;
struct sockaddr addr;
} sa[2];
int cb = sizeof(sa);
memset(&sa, 0, cb);
sa[0].in_addr.sin_family = domain;
sa[0].in_addr.sin_addr.s_addr = RT_H2N_U32(INADDR_LOOPBACK);
sa[0].in_addr.sin_port = 0;
cb = sizeof(sa[0]);
if (type == SOCK_STREAM)
{
listener = WSASocket(domain, type, protocol, 0, NULL, 0);
if (listener == INVALID_SOCKET)
{
return VERR_INTERNAL_ERROR;
}
int reuse = 1;
cb = sizeof(int);
int rc = setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, (char *)&reuse, cb);
if (rc)
{
goto close_socket;
}
cb = sizeof(sa[0]);
rc = bind(listener, &sa[0].addr, cb);
if(rc)
{
goto close_socket;
}
memset(&sa[0], 0, cb);
rc = getsockname(listener, &sa[0].addr, &cb);
if (rc)
{
goto close_socket;
}
rc = listen(listener, 1);
if (rc)
{
goto close_socket;
}
socket_vector[0] = WSASocket(domain, type, protocol, 0, NULL, 0);
if (socket_vector[0] == INVALID_SOCKET)
{
goto close_socket;
}
rc = connect(socket_vector[0], &sa[0].addr, cb);
if (rc)
goto close_socket;
socket_vector[1] = accept(listener, NULL, NULL);
if (socket_vector[1] == INVALID_SOCKET)
{
goto close_socket;
}
closesocket(listener);
}
else
{
socket_vector[0] = WSASocket(domain, type, protocol, 0, NULL, 0);
cb = sizeof(sa[0]);
int rc = bind(socket_vector[0], &sa[0].addr, cb);
Assert(rc != SOCKET_ERROR);
if (rc == SOCKET_ERROR)
{
goto close_socket;
}
sa[1].in_addr.sin_family = domain;
sa[1].in_addr.sin_addr.s_addr = RT_H2N_U32(INADDR_LOOPBACK);
sa[1].in_addr.sin_port = 0;
socket_vector[1] = WSASocket(domain, type, protocol, 0, NULL, 0);
rc = bind(socket_vector[1], &sa[1].addr, cb);
Assert(rc != SOCKET_ERROR);
if (rc == SOCKET_ERROR)
{
goto close_socket;
}
{
u_long mode = 0;
rc = ioctlsocket(socket_vector[0], FIONBIO, &mode);
AssertMsgReturn(rc != SOCKET_ERROR,
("ioctl error: %d\n", WSAGetLastError()),
VERR_INTERNAL_ERROR);
rc = ioctlsocket(socket_vector[1], FIONBIO, &mode);
AssertMsgReturn(rc != SOCKET_ERROR,
("ioctl error: %d\n", WSAGetLastError()),
VERR_INTERNAL_ERROR);
}
memset(&sa, 0, 2 * cb);
rc = getsockname(socket_vector[0], &sa[0].addr, &cb);
Assert(rc != SOCKET_ERROR);
if (rc == SOCKET_ERROR)
{
goto close_socket;
}
rc = getsockname(socket_vector[1], &sa[1].addr, &cb);
Assert(rc != SOCKET_ERROR);
if (rc == SOCKET_ERROR)
{
goto close_socket;
}
rc = connect(socket_vector[0], &sa[1].addr, cb);
Assert(rc != SOCKET_ERROR);
if (rc == SOCKET_ERROR)
{
goto close_socket;
}
rc = connect(socket_vector[1], &sa[0].addr, cb);
Assert(rc != SOCKET_ERROR);
if (rc == SOCKET_ERROR)
{
goto close_socket;
}
}
LogFlowFuncLeaveRC(VINF_SUCCESS);
return VINF_SUCCESS;
close_socket:
if (listener != INVALID_SOCKET)
closesocket(listener);
if (socket_vector[0] != INVALID_SOCKET)
closesocket(socket_vector[0]);
if (socket_vector[1] != INVALID_SOCKET)
closesocket(socket_vector[1]);
LogFlowFuncLeaveRC(VERR_INTERNAL_ERROR);
return VERR_INTERNAL_ERROR;
}
/* here we should check if we reached the end of the DNS server list */
hash_remove_request(pData, (struct request *)arg);
free((struct request *)arg);
++removed_queries;
}
#else /* VBOX */
static void
timeout(PNATState pData, struct socket *so, void *arg)
{
struct request *req = (struct request *)arg;
struct dns_entry *de;
/* be paranoid */
AssertPtrReturnVoid(arg);
if ( req->dnsgen != pData->dnsgen
|| req->dns_server == NULL
|| (de = TAILQ_PREV(req->dns_server, dns_list_head, de_list)) == NULL)
{
if (req->dnsgen != pData->dnsgen)
{
/* XXX: Log2 */
LogRel(("NAT: dnsproxy: timeout: req %p dnsgen %u != %u on %R[natsock]\n",
req, req->dnsgen, pData->dnsgen, so));
}
hash_remove_request(pData, req);
RTMemFree(req);
++removed_queries;
/* the rest of clean up at the end of the method. */
}
else
{
struct ip *ip;
struct udphdr *udp;
int iphlen;
struct mbuf *m = NULL;
char *data;
m = slirpDnsMbufAlloc(pData);
if (m == NULL)
{
LogRel(("NAT: Can't allocate mbuf\n"));
goto socket_clean_up;
}
/* mbuf initialization */
m->m_data += if_maxlinkhdr;
ip = mtod(m, struct ip *);
udp = (struct udphdr *)&ip[1]; /* ip attributes */
data = (char *)&udp[1];
iphlen = sizeof(struct ip);
m->m_len += sizeof(struct ip);
m->m_len += sizeof(struct udphdr);
m->m_len += req->nbyte;
ip->ip_src.s_addr = so->so_laddr.s_addr;
ip->ip_dst.s_addr = RT_H2N_U32(RT_N2H_U32(pData->special_addr.s_addr) | CTL_DNS);
udp->uh_dport = ntohs(53);
udp->uh_sport = so->so_lport;
memcpy(data, req->byte, req->nbyte); /* coping initial req */
/* req points to so->so_timeout_arg */
req->dns_server = de;
/* expiration will be bumped in dnsproxy_query */
dnsproxy_query(pData, so, m, iphlen);
/* should we free so->so_m ? */
return;
}
socket_clean_up:
/* This socket (so) will be detached, so we need to remove timeout(&_arg) references
* before leave
*/
so->so_timeout = NULL;
so->so_timeout_arg = NULL;
return;
}