bool Mapper_WinUPnP::add(const unsigned short port, const Protocol protocol, const string& description) {
IStaticPortMappingCollection* pSPMC = getStaticPortMappingCollection();
if(!pSPMC)
return false;
/// @todo use a BSTR wrapper
BSTR protocol_ = SysAllocString(Text::toT(protocols[protocol]).c_str());
BSTR description_ = SysAllocString(Text::toT(description).c_str());
BSTR localIP = SysAllocString(Text::toT(Util::getLocalIp()).c_str());
IStaticPortMapping* pSPM = 0;
HRESULT hr = pSPMC->Add(port, protocol_, port, localIP, VARIANT_TRUE, description_, &pSPM);
SysFreeString(protocol_);
SysFreeString(description_);
SysFreeString(localIP);
bool ret = SUCCEEDED(hr);
if(ret) {
pSPM->Release();
lastPort = port;
lastProtocol = protocol;
}
pSPMC->Release();
return ret;
}
string Mapper_WinUPnP::getExternalIP() {
// Get the External IP from the last added mapping
if(!lastPort)
return Util::emptyString;
IStaticPortMappingCollection* pSPMC = getStaticPortMappingCollection();
if(!pSPMC)
return Util::emptyString;
/// @todo use a BSTR wrapper
BSTR protocol_ = SysAllocString(Text::toT(protocols[lastProtocol]).c_str());
// Lets Query our mapping
IStaticPortMapping* pSPM;
HRESULT hr = pSPMC->get_Item(lastPort, protocol_, &pSPM);
SysFreeString(protocol_);
// Query failed!
if(FAILED(hr) || !pSPM) {
pSPMC->Release();
return Util::emptyString;
}
BSTR bstrExternal = 0;
hr = pSPM->get_ExternalIPAddress(&bstrExternal);
if(FAILED(hr) || !bstrExternal) {
pSPM->Release();
pSPMC->Release();
return Util::emptyString;
}
// convert the result
string ret = Text::wideToAcp(bstrExternal);
// no longer needed
SysFreeString(bstrExternal);
// no longer needed
pSPM->Release();
pSPMC->Release();
return ret;
}
bool UPnP::Create(u16 Port)
{
IUPnPNAT * Nat = NULL;
IStaticPortMappingCollection * PortMappingCollection = NULL;
IStaticPortMapping * PortMap = NULL;
HRESULT Result;
wchar_t Protocol[256];
wchar_t InternalClient[256];
wchar_t Description[256];
Destroy();
#ifdef MFC
TRACE("UPnP: Adding port\n");
#endif
if(!GetIp())
{
return false;
}
size_t num_chars_converted{};
mbstowcs_s(&num_chars_converted, InternalClient, m_Address, 256);
wcscpy_s(Protocol, L"UDP");
wcscpy_s(Description, L"Gunz");
// Create IUPnPNat
Result = CoCreateInstance(CLSID_UPnPNAT, NULL, CLSCTX_INPROC_SERVER, IID_IUPnPNAT, (void **)&Nat);
if(FAILED(Result))
{
#ifdef MFC
TRACE("UPnP: Unable to create UPnPNAT interface\n");
#endif
return false;
}
Result = Nat->get_StaticPortMappingCollection(&PortMappingCollection);
if(!PortMappingCollection || FAILED(Result))
{
if(PortMappingCollection) PortMappingCollection->Release();
Nat->Release();
#ifdef MFC
TRACE("UPnP: Unable to acquire a static portmapping collection\n");
#endif
return false;
}
Result = PortMappingCollection->Add(Port, Protocol, Port, InternalClient,
VARIANT_TRUE, Description, &PortMap);
if(!PortMap || FAILED(Result))
{
if(PortMap) PortMap->Release();
PortMappingCollection->Release();
Nat->Release();
#ifdef MFC
TRACE("UPnP: Unable add port\n");
#endif
return false;
}
#ifdef MFC
TRACE("UPnP: Port %d forwarded to %s\n", Port, m_Address);
#endif
PortMap->Release();
PortMappingCollection->Release();
Nat->Release();
m_Port = Port;
return true;
}
// Add a UPnP port
bool Win32UPnPAddPort(UINT outside_port, UINT inside_port, bool udp, char *local_ip, wchar_t *description, bool remove_before_add)
{
bool ret = false;
HRESULT hr;
IUPnPNAT *nat = NULL;
wchar_t ip_str[MAX_SIZE];
BSTR bstr_ip, bstr_description, bstr_protocol;
wchar_t *protocol_str = (udp ? L"UDP" : L"TCP");
// Validate arguments
if (outside_port == 0 || outside_port >= 65536 || inside_port == 0 || inside_port >= 65536 ||
IsEmptyStr(local_ip) || UniIsEmptyStr(description))
{
return false;
}
StrToUni(ip_str, sizeof(ip_str), local_ip);
bstr_ip = SysAllocString(ip_str);
bstr_description = SysAllocString(description);
bstr_protocol = SysAllocString(protocol_str);
hr = CoCreateInstance(CLSID_UPnPNAT, NULL, CLSCTX_INPROC_SERVER, IID_IUPnPNAT, (void **)&nat);
if (SUCCEEDED(hr))
{
if (nat != NULL)
{
IStaticPortMappingCollection *collection = NULL;
hr = nat->get_StaticPortMappingCollection(&collection);
if (SUCCEEDED(hr))
{
if (collection != NULL)
{
IStaticPortMapping *mapping = NULL;
if (remove_before_add)
{
hr = collection->Remove((long)outside_port, bstr_protocol);
}
hr = collection->Add((long)outside_port, bstr_protocol, (long)inside_port,
bstr_ip, VARIANT_TRUE, bstr_description, &mapping);
if (SUCCEEDED(hr))
{
ret = true;
if (mapping != NULL)
{
mapping->Release();
}
}
collection->Release();
}
else
{
WHERE;
}
}
else
{
WHERE;
}
nat->Release();
}
else
{
WHERE;
}
}
else
{
WHERE;
}
SysFreeString(bstr_ip);
SysFreeString(bstr_description);
SysFreeString(bstr_protocol);
return ret;
}
// Returns the current external IP address
_bstr_t UPnP::GetExternalIP() {
HRESULT hr;
// Check if we opened the desired port, 'cause we use it for getting the IP
// This shouldn't be a problem because we only try to get the external IP when
// we opened the mapping
// This function is not used somewhere else, hence it is "save" to do it like this
if(!PortsAreOpen) {
return "";
}
BSTR bstrExternal = NULL;
_bstr_t bstrWrapper;
CoInitializeEx ( NULL ,COINIT_MULTITHREADED);
hr = CoCreateInstance (__uuidof(UPnPNAT),
NULL,
CLSCTX_INPROC_SERVER,
__uuidof(IUPnPNAT),
(void**)&pUN);
if(SUCCEEDED(hr))
{
// Get the Collection
IStaticPortMappingCollection *pIMaps = NULL;
hr = pUN->get_StaticPortMappingCollection(&pIMaps);
// Check it
// We also check against that bug mentioned in OpenPorts()
if(!SUCCEEDED(hr) || !pIMaps ) {
// Only release when OK
if(pIMaps != NULL) {
pIMaps->Release();
}
pUN->Release();
pUN=NULL;
CoUninitialize();
return "";
}
// Lets Query our mapping
IStaticPortMapping *pISM;
hr = pIMaps->get_Item(
PortNumber,
bstrProtocol,
&pISM
);
// Query failed!
if(!SUCCEEDED(hr)) {
pIMaps->Release();
pUN->Release();
pUN=NULL;
CoUninitialize();
return "";
}
// Get the External IP from our mapping
hr = pISM->get_ExternalIPAddress(&bstrExternal);
// D'OH. Failed
if(!SUCCEEDED(hr)) {
pIMaps->Release();
pISM->Release();
pUN->Release();
pUN=NULL;
CoUninitialize();
return "";
}
// Check and convert the result
if(bstrExternal != NULL) {
bstrWrapper.Assign(bstrExternal);
} else {
bstrWrapper = "";
}
// no longer needed
SysFreeString(bstrExternal);
// no longer needed
pIMaps->Release();
pISM->Release();
pUN->Release();
pUN=NULL;
CoUninitialize();
}
return bstrWrapper;
}
int SetPortForwarding(char *localIP, char *description, int internalPort, int *externalPort)
{
CoInitialize(NULL);
int errorCode = 0;
IUPnPNAT *nat = NULL;
IStaticPortMappingCollection *mappingCollection = NULL;
IStaticPortMapping *mapping = NULL;
if( !SUCCEEDED( CoCreateInstance(__uuidof(UPnPNAT), NULL, CLSCTX_ALL, __uuidof(IUPnPNAT), (void **)&nat) ) || ( nat==NULL ) )
{
errorCode = ERROR_COCREATEINSTANCE;
goto ERROR_EXIT;
}
if ( !SUCCEEDED( nat->get_StaticPortMappingCollection(&mappingCollection) ) || (mappingCollection==NULL ) )
{
errorCode = ERROR_UPNP_NOT_FOUNDED;
goto ERROR_EXIT;
}
while( TRUE ) {
IStaticPortMapping *existMapping = NULL;
BOOL hasMappingInformation =
SUCCEEDED( mappingCollection->get_Item(*externalPort, L"TCP", &existMapping) );
if ( hasMappingInformation ) {
//printf( "hasMappingInformation \n" );
BSTR bStrIP = NULL;
existMapping->get_InternalClient(&bStrIP);
BSTR bstrDescryption = NULL;
existMapping->get_Description(&bstrDescryption);
long iExistInternalPort = 0;
existMapping->get_InternalPort(&iExistInternalPort);
if( bStrIP != NULL && bstrDescryption != NULL ) {
//printf( "bStrIP != NULL && bstrDescryption != NULL \n" );
USES_CONVERSION;
char *sClientIP = OLE2A(bStrIP);
char *sDescryption = OLE2A(bstrDescryption);
BOOL hasMapping =
( strcmp(sClientIP, localIP) == 0 ) &&
( strcmp(sDescryption, description) == 0) &&
( iExistInternalPort == internalPort );
if ( hasMapping ) {
//printf( "hasMapping \n" );
SysFreeString(bStrIP);
SysFreeString(bstrDescryption);
break;
}
SysFreeString(bStrIP);
SysFreeString(bstrDescryption);
}
existMapping->Release();
(*externalPort)++;
//printf( "(*externalPort)++: %d \n", *externalPort );
} else {
//printf( "not hasMappingInformation \n" );
VARIANT_BOOL vb = VARIANT_TRUE;
USES_CONVERSION;
BOOL isNewMappingRegistered =
SUCCEEDED( mappingCollection->Add(*externalPort, L"TCP", internalPort, A2W(localIP), vb, A2W(description), &mapping) );
if( ! isNewMappingRegistered ) {
//printf( "not isNewMappingRegistered \n" );
errorCode = ERROR_PORTMAPPING_FAILED;
goto ERROR_EXIT;
}
break;
}
}
ERROR_EXIT:
if ( NULL != mapping ) {
mapping->Release();
mapping = NULL;
}
if ( NULL != mappingCollection ) {
mappingCollection->Release();
mappingCollection = NULL;
}
if ( NULL != nat ) {
nat->Release();
nat = NULL;
}
CoUninitialize();
return errorCode;
}
