STDMETHODIMP NATNetworkWrap::COMGETTER(NetworkName)(BSTR *aNetworkName)
{
LogRelFlow(("{%p} %s: enter aNetworkName=%p\n", this, "NATNetwork::getNetworkName", aNetworkName));
VirtualBoxBase::clearError();
HRESULT hrc;
try
{
CheckComArgOutPointerValidThrow(aNetworkName);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc()))
throw autoCaller.rc();
hrc = getNetworkName(BSTROutConverter(aNetworkName).str());
}
catch (HRESULT hrc2)
{
hrc = hrc2;
}
catch (...)
{
hrc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
}
LogRelFlow(("{%p} %s: leave *aNetworkName=%ls hrc=%Rhrc\n", this, "NATNetwork::getNetworkName", *aNetworkName, hrc));
return hrc;
}
HRESULT VBoxNetDhcp::HandleEvent(VBoxEventType_T aEventType, IEvent *pEvent)
{
switch(aEventType)
{
case VBoxEventType_OnHostNameResolutionConfigurationChange:
fetchAndUpdateDnsInfo();
break;
case VBoxEventType_OnNATNetworkStartStop:
{
ComPtr <INATNetworkStartStopEvent> pStartStopEvent = pEvent;
com::Bstr networkName;
HRESULT hrc = pStartStopEvent->COMGETTER(NetworkName)(networkName.asOutParam());
AssertComRCReturn(hrc, hrc);
if (networkName.compare(getNetworkName().c_str()))
break; /* change not for our network */
BOOL fStart = TRUE;
hrc = pStartStopEvent->COMGETTER(StartEvent)(&fStart);
AssertComRCReturn(hrc, hrc);
if (!fStart)
shutdown();
break;
}
case VBoxEventType_OnVBoxSVCAvailabilityChanged:
{
shutdown();
break;
}
}
return S_OK;
}
QString QNetworkInfoPrivate::networkName(QNetworkInfo::NetworkMode mode, int interface)
{
if (watchNetworkName && (mode == QNetworkInfo::WlanMode
|| mode == QNetworkInfo::EthernetMode
|| mode == QNetworkInfo::BluetoothMode)) {
return networkNames.value(QPair<QNetworkInfo::NetworkMode, int>(mode, interface));
} else
return getNetworkName(mode, interface);
}
void GameLabyrinth::Client::disconenct()
{
if (peer != NULL)
{
log_msg("net", "Disconnecting client " + getNetworkName());
enet_peer_disconnect_now(peer, 0);
state = DISCONNECTED;
peer->data = NULL;
peer = NULL;
}
}
/**
* Main thread. Starts also the LWIP thread.
*/
int VBoxNetLwipNAT::init()
{
LogFlowFuncEnter();
/* virtualbox initialized in super class */
int rc = ::VBoxNetBaseService::init();
AssertRCReturn(rc, rc);
std::string networkName = getNetworkName();
rc = findNatNetwork(virtualbox, networkName, m_net);
AssertRCReturn(rc, rc);
ComEventTypeArray aNetEvents;
aNetEvents.push_back(VBoxEventType_OnNATNetworkPortForward);
aNetEvents.push_back(VBoxEventType_OnNATNetworkSetting);
rc = createNatListener(m_listener, virtualbox, this, aNetEvents);
AssertRCReturn(rc, rc);
// resolver changes are reported on vbox but are retrieved from
// host so stash a pointer for future lookups
HRESULT hrc = virtualbox->COMGETTER(Host)(m_host.asOutParam());
AssertComRCReturn(hrc, VERR_INTERNAL_ERROR);
ComEventTypeArray aVBoxEvents;
aVBoxEvents.push_back(VBoxEventType_OnHostNameResolutionConfigurationChange);
aVBoxEvents.push_back(VBoxEventType_OnNATNetworkStartStop);
rc = createNatListener(m_vboxListener, virtualbox, this, aVBoxEvents);
AssertRCReturn(rc, rc);
BOOL fIPv6Enabled = FALSE;
hrc = m_net->COMGETTER(IPv6Enabled)(&fIPv6Enabled);
AssertComRCReturn(hrc, VERR_NOT_FOUND);
BOOL fIPv6DefaultRoute = FALSE;
if (fIPv6Enabled)
{
hrc = m_net->COMGETTER(AdvertiseDefaultIPv6RouteEnabled)(&fIPv6DefaultRoute);
AssertComRCReturn(hrc, VERR_NOT_FOUND);
}
m_ProxyOptions.ipv6_enabled = fIPv6Enabled;
m_ProxyOptions.ipv6_defroute = fIPv6DefaultRoute;
com::Bstr bstrSourceIp4Key = com::BstrFmt("NAT/%s/SourceIp4", networkName.c_str());
com::Bstr bstrSourceIpX;
hrc = virtualbox->GetExtraData(bstrSourceIp4Key.raw(), bstrSourceIpX.asOutParam());
if (SUCCEEDED(hrc))
{
RTNETADDRIPV4 addr;
rc = RTNetStrToIPv4Addr(com::Utf8Str(bstrSourceIpX).c_str(), &addr);
if (RT_SUCCESS(rc))
{
RT_ZERO(m_src4);
m_src4.sin_addr.s_addr = addr.u;
m_ProxyOptions.src4 = &m_src4;
bstrSourceIpX.setNull();
}
}
if (!fDontLoadRulesOnStartup)
{
fetchNatPortForwardRules(m_net, false, m_vecPortForwardRule4);
fetchNatPortForwardRules(m_net, true, m_vecPortForwardRule6);
} /* if (!fDontLoadRulesOnStartup) */
AddressToOffsetMapping tmp;
rc = localMappings(m_net, tmp);
if (RT_SUCCESS(rc) && tmp.size() != 0)
{
unsigned long i = 0;
for (AddressToOffsetMapping::iterator it = tmp.begin();
it != tmp.end() && i < RT_ELEMENTS(m_lo2off);
++it, ++i)
{
ip4_addr_set_u32(&m_lo2off[i].loaddr, it->first.u);
m_lo2off[i].off = it->second;
}
m_loOptDescriptor.lomap = m_lo2off;
m_loOptDescriptor.num_lomap = i;
m_ProxyOptions.lomap_desc = &m_loOptDescriptor;
}
com::Bstr bstr;
hrc = virtualbox->COMGETTER(HomeFolder)(bstr.asOutParam());
AssertComRCReturn(hrc, VERR_NOT_FOUND);
if (!bstr.isEmpty())
{
com::Utf8Str strTftpRoot(com::Utf8StrFmt("%ls%c%s",
bstr.raw(), RTPATH_DELIMITER, "TFTP"));
char *pszStrTemp; // avoid const char ** vs char **
rc = RTStrUtf8ToCurrentCP(&pszStrTemp, strTftpRoot.c_str());
AssertRC(rc);
m_ProxyOptions.tftp_root = pszStrTemp;
}
m_ProxyOptions.nameservers = getHostNameservers();
/* end of COM initialization */
rc = g_pLwipNat->tryGoOnline();
if (RT_FAILURE(rc))
return rc;
/* this starts LWIP thread */
vboxLwipCoreInitialize(VBoxNetLwipNAT::onLwipTcpIpInit, this);
LogFlowFuncLeaveRC(rc);
return rc;
}
/**
* @note: this work on Event thread.
*/
HRESULT VBoxNetLwipNAT::HandleEvent(VBoxEventType_T aEventType, IEvent *pEvent)
{
HRESULT hrc = S_OK;
switch (aEventType)
{
case VBoxEventType_OnNATNetworkSetting:
{
ComPtr<INATNetworkSettingEvent> pSettingsEvent(pEvent);
com::Bstr networkName;
hrc = pSettingsEvent->COMGETTER(NetworkName)(networkName.asOutParam());
AssertComRCReturn(hrc, hrc);
if (networkName.compare(getNetworkName().c_str()))
break; /* change not for our network */
// XXX: only handle IPv6 default route for now
if (!m_ProxyOptions.ipv6_enabled)
break;
BOOL fIPv6DefaultRoute = FALSE;
hrc = pSettingsEvent->COMGETTER(AdvertiseDefaultIPv6RouteEnabled)(&fIPv6DefaultRoute);
AssertComRCReturn(hrc, hrc);
if (m_ProxyOptions.ipv6_defroute == fIPv6DefaultRoute)
break;
m_ProxyOptions.ipv6_defroute = fIPv6DefaultRoute;
tcpip_callback_with_block(proxy_rtadvd_do_quick, &m_LwipNetIf, 0);
break;
}
case VBoxEventType_OnNATNetworkPortForward:
{
ComPtr<INATNetworkPortForwardEvent> pForwardEvent = pEvent;
com::Bstr networkName;
hrc = pForwardEvent->COMGETTER(NetworkName)(networkName.asOutParam());
AssertComRCReturn(hrc, hrc);
if (networkName.compare(getNetworkName().c_str()))
break; /* change not for our network */
BOOL fCreateFW;
hrc = pForwardEvent->COMGETTER(Create)(&fCreateFW);
AssertComRCReturn(hrc, hrc);
BOOL fIPv6FW;
hrc = pForwardEvent->COMGETTER(Ipv6)(&fIPv6FW);
AssertComRCReturn(hrc, hrc);
com::Bstr name;
hrc = pForwardEvent->COMGETTER(Name)(name.asOutParam());
AssertComRCReturn(hrc, hrc);
NATProtocol_T proto = NATProtocol_TCP;
hrc = pForwardEvent->COMGETTER(Proto)(&proto);
AssertComRCReturn(hrc, hrc);
com::Bstr strHostAddr;
hrc = pForwardEvent->COMGETTER(HostIp)(strHostAddr.asOutParam());
AssertComRCReturn(hrc, hrc);
LONG lHostPort;
hrc = pForwardEvent->COMGETTER(HostPort)(&lHostPort);
AssertComRCReturn(hrc, hrc);
com::Bstr strGuestAddr;
hrc = pForwardEvent->COMGETTER(GuestIp)(strGuestAddr.asOutParam());
AssertComRCReturn(hrc, hrc);
LONG lGuestPort;
hrc = pForwardEvent->COMGETTER(GuestPort)(&lGuestPort);
AssertComRCReturn(hrc, hrc);
VECNATSERVICEPF& rules = fIPv6FW ? m_vecPortForwardRule6
: m_vecPortForwardRule4;
NATSEVICEPORTFORWARDRULE r;
RT_ZERO(r);
r.Pfr.fPfrIPv6 = fIPv6FW;
switch (proto)
{
case NATProtocol_TCP:
r.Pfr.iPfrProto = IPPROTO_TCP;
break;
case NATProtocol_UDP:
r.Pfr.iPfrProto = IPPROTO_UDP;
break;
default:
LogRel(("Event: %s %s port-forwarding rule \"%s\":"
" invalid protocol %d\n",
fCreateFW ? "Add" : "Remove",
fIPv6FW ? "IPv6" : "IPv4",
com::Utf8Str(name).c_str(),
(int)proto));
goto port_forward_done;
}
LogRel(("Event: %s %s port-forwarding rule \"%s\":"
" %s %s%s%s:%d -> %s%s%s:%d\n",
fCreateFW ? "Add" : "Remove",
fIPv6FW ? "IPv6" : "IPv4",
com::Utf8Str(name).c_str(),
proto == NATProtocol_TCP ? "TCP" : "UDP",
/* from */
fIPv6FW ? "[" : "",
com::Utf8Str(strHostAddr).c_str(),
fIPv6FW ? "]" : "",
lHostPort,
/* to */
fIPv6FW ? "[" : "",
com::Utf8Str(strGuestAddr).c_str(),
fIPv6FW ? "]" : "",
lGuestPort));
if (name.length() > sizeof(r.Pfr.szPfrName))
{
hrc = E_INVALIDARG;
goto port_forward_done;
}
RTStrPrintf(r.Pfr.szPfrName, sizeof(r.Pfr.szPfrName),
"%s", com::Utf8Str(name).c_str());
RTStrPrintf(r.Pfr.szPfrHostAddr, sizeof(r.Pfr.szPfrHostAddr),
"%s", com::Utf8Str(strHostAddr).c_str());
/* XXX: limits should be checked */
r.Pfr.u16PfrHostPort = (uint16_t)lHostPort;
RTStrPrintf(r.Pfr.szPfrGuestAddr, sizeof(r.Pfr.szPfrGuestAddr),
"%s", com::Utf8Str(strGuestAddr).c_str());
/* XXX: limits should be checked */
r.Pfr.u16PfrGuestPort = (uint16_t)lGuestPort;
if (fCreateFW) /* Addition */
{
int rc = natServicePfRegister(r);
if (RT_SUCCESS(rc))
rules.push_back(r);
}
else /* Deletion */
{
ITERATORNATSERVICEPF it;
for (it = rules.begin(); it != rules.end(); ++it)
{
/* compare */
NATSEVICEPORTFORWARDRULE& natFw = *it;
if ( natFw.Pfr.iPfrProto == r.Pfr.iPfrProto
&& natFw.Pfr.u16PfrHostPort == r.Pfr.u16PfrHostPort
&& (strncmp(natFw.Pfr.szPfrHostAddr, r.Pfr.szPfrHostAddr, INET6_ADDRSTRLEN) == 0)
&& natFw.Pfr.u16PfrGuestPort == r.Pfr.u16PfrGuestPort
&& (strncmp(natFw.Pfr.szPfrGuestAddr, r.Pfr.szPfrGuestAddr, INET6_ADDRSTRLEN) == 0))
{
RTCMemAutoPtr<fwspec> pFwCopy;
if (RT_UNLIKELY(!pFwCopy.alloc()))
break;
memcpy(pFwCopy.get(), &natFw.FWSpec, sizeof(natFw.FWSpec));
int status = portfwd_rule_del(pFwCopy.get());
if (status != 0)
break;
pFwCopy.release(); /* owned by lwip thread now */
rules.erase(it);
break;
}
} /* loop over vector elements */
} /* condition add or delete */
port_forward_done:
/* clean up strings */
name.setNull();
strHostAddr.setNull();
strGuestAddr.setNull();
break;
}
case VBoxEventType_OnHostNameResolutionConfigurationChange:
{
const char **ppcszNameServers = getHostNameservers();
err_t error;
error = tcpip_callback_with_block(pxdns_set_nameservers,
ppcszNameServers,
/* :block */ 0);
if (error != ERR_OK && ppcszNameServers != NULL)
RTMemFree(ppcszNameServers);
break;
}
case VBoxEventType_OnNATNetworkStartStop:
{
ComPtr <INATNetworkStartStopEvent> pStartStopEvent = pEvent;
com::Bstr networkName;
hrc = pStartStopEvent->COMGETTER(NetworkName)(networkName.asOutParam());
AssertComRCReturn(hrc, hrc);
if (networkName.compare(getNetworkName().c_str()))
break; /* change not for our network */
BOOL fStart = TRUE;
hrc = pStartStopEvent->COMGETTER(StartEvent)(&fStart);
AssertComRCReturn(hrc, hrc);
if (!fStart)
shutdown();
break;
}
}
return hrc;
}
/* This will process library data. It will return true, if nothing was processing -> the data are for the sketch, otherwise, it returns false, so the data are processed here
* and nothing should be processed by the sketch.
*/
boolean RemoteHomeWifi::processCommonData() {
if (stringComplete) {
if (inputString.startsWith(" ")) {
//wifi config
createTableWithForm(WIFI_CONFIG, WIFI_CONFIG_ACTION);
char* netName = getNetworkName();
createTextBoxTableRow(CAPTION_WIFI_SSID, ACTION_S, netName, MAXSIZE_32);
free(netName);
createTextBoxTableRow(CAPTION_WIFI_PWD, ACTION_P, "", MAXSIZE_64);
createTextBoxTableRow(CAPTION_WIFI_IP, ACTION_I, "", MAXSIZE_15);
createSubmitButton();
endTableWithForm();
} else if (inputString.startsWith("ca")) {
//device config
createTableWithForm(DEVICE_CONFIG, DEVICE_CONFIG_ACTION);
char* ip = readIpAddrFromEEPROM(EEPROM_POSITION_SERVER_IP);
createTextBoxTableRow(CAPTION_SERVER_IP, ACTION_S, ip, MAXSIZE_15);
free(ip);
createTextBoxTableRow(CAPTION_SERVER_PORT, ACTION_P, readIntFromEEPROM(EEPROM_POSITION_SERVER_PORT), MAXSIZE_5);
createTextBoxTableRow(CAPTION_PGM_PORT, ACTION_R, readIntFromEEPROM(EEPROM_POSITION_SERVER_PROGPORT), MAXSIZE_5);
createTextBoxTableRow(CAPTION_DEVICE_ID, ACTION_D, readByteFromEEPROM(EEPROM_POSITION_NODE_ID), MAXSIZE_4);
if (0 != fpAppendConfigTable) (*fpAppendConfigTable)();
createSubmitButton();
endTableWithForm();
} else if (inputString.startsWith("cb")) {
//sketch upload
pageHeadString = F("<meta http-equiv='refresh' content=\"60;URL='/'\"/>");
outputString = F("<p>Programming, the page is going to reload after 1 min.</p>");
sendPageWithMenuAndHeaderResponse();
delay(30);
cleanVariablesAfterProcessing();
if (establishConnectionToServer(true, EEPROM_POSITION_SERVER_IP, EEPROM_POSITION_SERVER_PROGPORT)) {
delay(10);
_ser.print((byte)1);
if (!_ser.find("a")) {
setup();
}
}
} else if (inputString.startsWith("cc")) {
//it is join network request cc?s=SSID&p=Password&i=192.168.1.30 HTTP/1.1
skipInputToChar('=');
String ssid = inputString.substring(0,inputString.indexOf('&'));
skipInputToChar('=');
String password = inputString.substring(0,inputString.indexOf('&'));
skipInputToChar('=');
String ip = inputString.substring(0,inputString.indexOf(' '));
pageHeadString = F("<meta http-equiv='refresh' content=\"25;URL='");
if (ip.length() != 0) {
pageHeadString += F("http://");
pageHeadString += ip;
pageHeadString += F("/");
}
pageHeadString += F("cd'\"/>");
outputString = F("<p>Connecting, please wait, the result is going to be displayed within 25 seconds...</p>");
sendPageWithMenuAndHeaderResponse();
if (!joinNetwork(ssid, password, ip)) {
becomeAdHocNetwork();
listenOnPort();
connectedToWifi = false;
}
cleanVariablesAfterProcessing();
} else if (inputString.startsWith("cd")) {
if (waitToConnectToNetwork(1)) {
outputString = F("<p>Connected:<b>");
outputString += getIPAddress();
outputString += F("</b><BR>Please reserve the IP in your router.</p>");
sendPageWithMenuAndHeaderResponse();
delay(1000);
setSingleJoinNetwork();
outputString = "";
} else {
outputString = F("<p>Not connected, please try again.</p>");
}
} else if (inputString.startsWith("ce")) {
//it is configure device: ce?s=192.168.1.2&p=8080&r=8081&d=1&e=0 HTTP/1.1
saveIpAddrToEEPROM(EEPROM_POSITION_SERVER_IP);
saveIntToEEPROM(EEPROM_POSITION_SERVER_PORT);
saveIntToEEPROM(EEPROM_POSITION_SERVER_PROGPORT);
saveByteToEEPROM(EEPROM_POSITION_NODE_ID);
nodeId = EEPROM.read(EEPROM_POSITION_NODE_ID);
if (0 != fpSaveConfigValues) (*fpSaveConfigValues)();
outputString = F("<p>Configured.</p>");
} else {
return true;
}
if (outputString.length()!=0) {
sendPageWithMenuAndHeaderResponse();
}
cleanVariablesAfterProcessing();
return false;
}
return true;
}
int VBoxNetDhcp::initWithMain()
{
/* ok, here we should initiate instance of dhcp server
* and listener for Dhcp configuration events
*/
AssertRCReturn(virtualbox.isNull(), VERR_INTERNAL_ERROR);
std::string networkName = getNetworkName();
int rc = findDhcpServer(virtualbox, networkName, m_DhcpServer);
AssertRCReturn(rc, rc);
rc = findNatNetwork(virtualbox, networkName, m_NATNetwork);
AssertRCReturn(rc, rc);
BOOL fNeedDhcpServer = isDhcpRequired(m_NATNetwork);
if (!fNeedDhcpServer)
return VERR_CANCELLED;
RTNETADDRIPV4 gateway;
com::Bstr strGateway;
HRESULT hrc = m_NATNetwork->COMGETTER(Gateway)(strGateway.asOutParam());
AssertComRCReturn(hrc, VERR_INTERNAL_ERROR);
RTNetStrToIPv4Addr(com::Utf8Str(strGateway).c_str(), &gateway);
ConfigurationManager *confManager = ConfigurationManager::getConfigurationManager();
AssertPtrReturn(confManager, VERR_INTERNAL_ERROR);
confManager->addToAddressList(RTNET_DHCP_OPT_ROUTERS, gateway);
rc = fetchAndUpdateDnsInfo();
AssertMsgRCReturn(rc, ("Wasn't able to fetch Dns info"), rc);
{
ComEventTypeArray eventTypes;
eventTypes.push_back(VBoxEventType_OnHostNameResolutionConfigurationChange);
eventTypes.push_back(VBoxEventType_OnNATNetworkStartStop);
rc = createNatListener(m_VBoxListener, virtualbox, this, eventTypes);
AssertRCReturn(rc, rc);
}
{
ComEventTypeArray eventTypes;
eventTypes.push_back(VBoxEventType_OnVBoxSVCAvailabilityChanged);
rc = createClientListener(m_VBoxClientListener, virtualboxClient, this, eventTypes);
AssertRCReturn(rc, rc);
}
RTNETADDRIPV4 LowerAddress;
rc = configGetBoundryAddress(m_DhcpServer, false, LowerAddress);
AssertMsgRCReturn(rc, ("can't get lower boundrary adderss'"),rc);
RTNETADDRIPV4 UpperAddress;
rc = configGetBoundryAddress(m_DhcpServer, true, UpperAddress);
AssertMsgRCReturn(rc, ("can't get upper boundrary adderss'"),rc);
RTNETADDRIPV4 address = getIpv4Address();
RTNETADDRIPV4 netmask = getIpv4Netmask();
RTNETADDRIPV4 networkId = networkid(address, netmask);
std::string name = std::string("default");
confManager->addNetwork(unconst(g_RootConfig),
networkId,
netmask,
LowerAddress,
UpperAddress);
com::Bstr bstr;
hrc = virtualbox->COMGETTER(HomeFolder)(bstr.asOutParam());
com::Utf8StrFmt strXmlLeaseFile("%ls%c%s.leases",
bstr.raw(), RTPATH_DELIMITER, networkName.c_str());
confManager->loadFromFile(strXmlLeaseFile);
return VINF_SUCCESS;
}
