system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-10-31 11:43:31 +00:00
Code Issues Projects Releases Packages Wiki Activity
wine/dlls/hnetcfg/port.c
Francois Gouget fcc0f1fb64 hnetcfg: Fix the spelling of a TRACE() message. 
Signed-off-by: Francois Gouget <fgouget@free.fr>
Signed-off-by: Alexandre Julliard <julliard@winehq.org>
2022-02-14 21:20:42 +01:00

2330 lines
67 KiB
C
Raw Blame History

/*
* Copyright 2009 Hans Leidekker for CodeWeavers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include <stdarg.h>
#include <stdio.h>
#define COBJMACROS
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "string.h"
#include "initguid.h"
#include "assert.h"
#include "winsock2.h"
#include "winhttp.h"
#include "shlwapi.h"
#include "xmllite.h"
#include "ole2.h"
#include "netfw.h"
#include "natupnp.h"
#include "wine/debug.h"
#include "hnetcfg_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(hnetcfg);
struct port_mapping
{
BSTR external_ip;
LONG external;
BSTR protocol;
LONG internal;
BSTR client;
VARIANT_BOOL enabled;
BSTR descr;
};
struct xml_value_desc
{
const WCHAR *name;
BSTR value;
};
static struct
{
LONG refs;
BOOL winsock_initialized;
WCHAR locationW[256];
HINTERNET session, connection;
WCHAR desc_urlpath[128];
WCHAR control_url[256];
unsigned int version;
struct port_mapping *mappings;
unsigned int mapping_count;
}
upnp_gateway_connection;
static SRWLOCK upnp_gateway_connection_lock = SRWLOCK_INIT;
static void free_port_mapping( struct port_mapping *mapping )
{
SysFreeString( mapping->external_ip );
SysFreeString( mapping->protocol );
SysFreeString( mapping->client );
SysFreeString( mapping->descr );
}
static void free_mappings(void)
{
unsigned int i;
for (i = 0; i < upnp_gateway_connection.mapping_count; ++i)
free_port_mapping( &upnp_gateway_connection.mappings[i] );
free( upnp_gateway_connection.mappings );
upnp_gateway_connection.mappings = NULL;
upnp_gateway_connection.mapping_count = 0;
}
static BOOL copy_port_mapping( struct port_mapping *dst, const struct port_mapping *src )
{
memset( dst, 0, sizeof(*dst) );
#define COPY_BSTR_CHECK(name) if (src->name && !(dst->name = SysAllocString( src->name ))) \
{ \
free_port_mapping( dst ); \
return FALSE; \
}
COPY_BSTR_CHECK( external_ip );
COPY_BSTR_CHECK( protocol );
COPY_BSTR_CHECK( client );
COPY_BSTR_CHECK( descr );
#undef COPY_BSTR_CHECK
dst->external = src->external;
dst->internal = src->internal;
dst->enabled = src->enabled;
return TRUE;
}
static BOOL parse_search_response( char *response, WCHAR *locationW, unsigned int location_size )
{
char *saveptr = NULL, *tok, *tok2;
unsigned int status;
tok = strtok_s( response, "\n", &saveptr );
if (!tok) return FALSE;
/* HTTP/1.1 200 OK */
tok2 = strtok( tok, " " );
if (!tok2) return FALSE;
tok2 = strtok( NULL, " " );
if (!tok2) return FALSE;
status = atoi( tok2 );
if (status != HTTP_STATUS_OK)
{
WARN( "status %u.\n", status );
return FALSE;
}
while ((tok = strtok_s( NULL, "\n", &saveptr )))
{
tok2 = strtok( tok, " " );
if (!tok2) continue;
if (!stricmp( tok2, "LOCATION:" ))
{
tok2 = strtok( NULL, " \r" );
if (!tok2)
{
WARN( "Error parsing location.\n" );
return FALSE;
}
return !!MultiByteToWideChar( CP_UTF8, 0, tok2, -1, locationW, location_size / 2 );
}
}
return FALSE;
}
static BOOL parse_desc_xml( const char *desc_xml )
{
static const WCHAR urn_wanipconnection[] = L"urn:schemas-upnp-org:service:WANIPConnection:";
WCHAR control_url[ARRAY_SIZE(upnp_gateway_connection.control_url)];
BOOL service_type_matches, control_url_found, found = FALSE;
unsigned int version = 0;
XmlNodeType node_type;
IXmlReader *reader;
const WCHAR *value;
BOOL ret = FALSE;
IStream *stream;
HRESULT hr;
if (!(stream = SHCreateMemStream( (BYTE *)desc_xml, strlen( desc_xml ) + 1 ))) return FALSE;
if (FAILED(hr = CreateXmlReader( &IID_IXmlReader, (void **)&reader, NULL )))
{
IStream_Release( stream );
return FALSE;
}
if (FAILED(hr = IXmlReader_SetInput( reader, (IUnknown*)stream ))) goto done;
while (SUCCEEDED(IXmlReader_Read( reader, &node_type )) && node_type != XmlNodeType_None)
{
if (node_type != XmlNodeType_Element) continue;
if (FAILED(IXmlReader_GetLocalName( reader, &value, NULL ))) goto done;
if (wcsicmp( value, L"service" )) continue;
control_url_found = service_type_matches = FALSE;
while (SUCCEEDED(IXmlReader_Read( reader, &node_type )))
{
if (node_type != XmlNodeType_Element && node_type != XmlNodeType_EndElement) continue;
if (FAILED(IXmlReader_GetLocalName( reader, &value, NULL )))
{
WARN( "IXmlReader_GetLocalName failed.\n" );
goto done;
}
if (node_type == XmlNodeType_EndElement)
{
if (!wcsicmp( value, L"service" )) break;
continue;
}
if (!wcsicmp( value, L"serviceType" ))
{
if (FAILED(IXmlReader_Read(reader, &node_type ))) goto done;
if (node_type != XmlNodeType_Text) goto done;
if (FAILED(IXmlReader_GetValue( reader, &value, NULL ))) goto done;
if (wcsnicmp( value, urn_wanipconnection, ARRAY_SIZE(urn_wanipconnection) - 1 )) break;
version = _wtoi( value + ARRAY_SIZE(urn_wanipconnection) - 1 );
service_type_matches = version >= 1;
}
else if (!wcsicmp( value, L"controlURL" ))
{
if (FAILED(IXmlReader_Read(reader, &node_type ))) goto done;
if (node_type != XmlNodeType_Text) goto done;
if (FAILED(IXmlReader_GetValue( reader, &value, NULL ))) goto done;
if (wcslen( value ) + 1 > ARRAY_SIZE(control_url)) goto done;
wcscpy( control_url, value );
control_url_found = TRUE;
}
}
if (service_type_matches && control_url_found)
{
if (found)
{
FIXME( "Found another WANIPConnection service, ignoring.\n" );
continue;
}
found = TRUE;
wcscpy( upnp_gateway_connection.control_url, control_url );
upnp_gateway_connection.version = version;
}
}
ret = found;
done:
IXmlReader_Release( reader );
IStream_Release( stream );
return ret;
}
static BOOL get_xml_elements( const char *desc_xml, struct xml_value_desc *values, unsigned int value_count )
{
XmlNodeType node_type;
IXmlReader *reader;
const WCHAR *value;
BOOL ret = FALSE;
IStream *stream;
unsigned int i;
HRESULT hr;
for (i = 0; i < value_count; ++i) assert( !values[i].value );
if (!(stream = SHCreateMemStream( (BYTE *)desc_xml, strlen( desc_xml ) + 1 ))) return FALSE;
if (FAILED(hr = CreateXmlReader( &IID_IXmlReader, (void **)&reader, NULL )))
{
IStream_Release( stream );
return FALSE;
}
if (FAILED(hr = IXmlReader_SetInput( reader, (IUnknown*)stream ))) goto done;
while (SUCCEEDED(IXmlReader_Read( reader, &node_type )) && node_type != XmlNodeType_None)
{
if (node_type != XmlNodeType_Element) continue;
if (FAILED(IXmlReader_GetQualifiedName( reader, &value, NULL ))) goto done;
for (i = 0; i < value_count; ++i)
if (!wcsicmp( value, values[i].name )) break;
if (i == value_count) continue;
if (FAILED(IXmlReader_Read(reader, &node_type ))) goto done;
if (node_type != XmlNodeType_Text)
{
if (node_type == XmlNodeType_EndElement) value = L"";
else goto done;
}
else
{
if (FAILED(IXmlReader_GetValue( reader, &value, NULL ))) goto done;
}
if (values[i].value)
{
WARN( "Duplicate value %s.\n", debugstr_w(values[i].name) );
goto done;
}
if (!(values[i].value = SysAllocString( value ))) goto done;
}
ret = TRUE;
done:
if (!ret)
{
for (i = 0; i < value_count; ++i)
{
SysFreeString( values[i].value );
values[i].value = NULL;
}
}
IXmlReader_Release( reader );
IStream_Release( stream );
return ret;
}
static BOOL open_gateway_connection(void)
{
static const int timeout = 3000;
WCHAR hostname[64];
URL_COMPONENTS url;
memset( &url, 0, sizeof(url) );
url.dwStructSize = sizeof(url);
url.lpszHostName = hostname;
url.dwHostNameLength = ARRAY_SIZE(hostname);
url.lpszUrlPath = upnp_gateway_connection.desc_urlpath;
url.dwUrlPathLength = ARRAY_SIZE(upnp_gateway_connection.desc_urlpath);
if (!WinHttpCrackUrl( upnp_gateway_connection.locationW, 0, 0, &url )) return FALSE;
upnp_gateway_connection.session = WinHttpOpen( L"hnetcfg", WINHTTP_ACCESS_TYPE_NO_PROXY,
WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0 );
if (!upnp_gateway_connection.session) return FALSE;
if (!WinHttpSetTimeouts( upnp_gateway_connection.session, timeout, timeout, timeout, timeout ))
return FALSE;
TRACE( "hostname %s, urlpath %s, port %u.\n",
debugstr_w(hostname), debugstr_w(upnp_gateway_connection.desc_urlpath), url.nPort );
upnp_gateway_connection.connection = WinHttpConnect ( upnp_gateway_connection.session, hostname, url.nPort, 0 );
if (!upnp_gateway_connection.connection)
{
WARN( "WinHttpConnect error %lu.\n", GetLastError() );
return FALSE;
}
return TRUE;
}
static BOOL get_control_url(void)
{
static const WCHAR *accept_types[] =
{
L"text/xml",
NULL
};
unsigned int desc_xml_size, offset;
DWORD size, status = 0;
HINTERNET request;
char *desc_xml;
BOOL ret;
request = WinHttpOpenRequest( upnp_gateway_connection.connection, NULL, upnp_gateway_connection.desc_urlpath, NULL,
WINHTTP_NO_REFERER, accept_types, 0 );
if (!request) return FALSE;
if (!WinHttpSendRequest( request, WINHTTP_NO_ADDITIONAL_HEADERS, 0, NULL, 0, 0, 0 ))
{
WARN( "Error sending request %lu.\n", GetLastError() );
WinHttpCloseHandle( request );
return FALSE;
}
if (!WinHttpReceiveResponse(request, NULL))
{
WARN( "Error receiving response %lu.\n", GetLastError() );
WinHttpCloseHandle( request );
return FALSE;
}
size = sizeof(status);
if (!WinHttpQueryHeaders( request, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
NULL, &status, &size, NULL) || status != HTTP_STATUS_OK )
{
WARN( "Error response from server, error %lu, http status %lu.\n", GetLastError(), status );
WinHttpCloseHandle( request );
return FALSE;
}
desc_xml_size = 1024;
desc_xml = malloc( desc_xml_size );
offset = 0;
while (WinHttpReadData( request, desc_xml + offset, desc_xml_size - offset - 1, &size ) && size)
{
offset += size;
if (offset + 1 == desc_xml_size)
{
char *new;
desc_xml_size *= 2;
if (!(new = realloc( desc_xml, desc_xml_size )))
{
ERR( "No memory.\n" );
break;
}
desc_xml = new;
}
}
desc_xml[offset] = 0;
WinHttpCloseHandle( request );
ret = parse_desc_xml( desc_xml );
free( desc_xml );
return ret;
}
static void gateway_connection_cleanup(void)
{
TRACE( ".\n" );
free_mappings();
WinHttpCloseHandle( upnp_gateway_connection.connection );
WinHttpCloseHandle( upnp_gateway_connection.session );
if (upnp_gateway_connection.winsock_initialized) WSACleanup();
memset( &upnp_gateway_connection, 0, sizeof(upnp_gateway_connection) );
}
static BOOL request_service( const WCHAR *function, const struct xml_value_desc *request_param,
unsigned int request_param_count, struct xml_value_desc *result,
unsigned int result_count, DWORD *http_status, BSTR *server_error_code_str )
{
static const char request_template_header[] =
"<?xml version=\"1.0\"?>\r\n"
"<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\" "
"SOAP-ENV:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">\r\n"
" <SOAP-ENV:Body>\r\n"
" <m:%S xmlns:m=\"urn:schemas-upnp-org:service:WANIPConnection:%u\">\r\n";
static const char request_template_footer[] =
" </m:%S>\r\n"
" </SOAP-ENV:Body>\r\n"
"</SOAP-ENV:Envelope>\r\n";
unsigned int request_data_size, request_len, offset, i, reply_buffer_size;
char *request_data, *reply_buffer = NULL, *ptr;
struct xml_value_desc error_value_desc;
WCHAR request_headers[1024];
HINTERNET request = NULL;
BOOL ret = FALSE;
DWORD size;
*server_error_code_str = NULL;
request_data_size = strlen(request_template_header) + strlen(request_template_footer) + 2 * wcslen( function )
+ 9 /* version + zero terminator */;
for (i = 0; i < request_param_count; ++i)
{
request_data_size += 13 + 2 * wcslen( request_param[i].name ) + wcslen( request_param[i].value );
}
if (!(request_data = malloc( request_data_size ))) return FALSE;
request = WinHttpOpenRequest( upnp_gateway_connection.connection, L"POST", upnp_gateway_connection.control_url,
NULL, WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, 0 );
if (!request) goto done;
ptr = request_data;
snprintf( ptr, request_data_size, request_template_header, function, upnp_gateway_connection.version );
offset = strlen( ptr );
ptr += offset;
request_data_size -= offset;
for (i = 0; i < request_param_count; ++i)
{
snprintf( ptr, request_data_size, " <%S>%S</%S>\r\n",
request_param[i].name, request_param[i].value, request_param[i].name);
offset = strlen( ptr );
ptr += offset;
request_data_size -= offset;
}
snprintf( ptr, request_data_size, request_template_footer, function );
request_len = strlen( request_data );
swprintf( request_headers, ARRAY_SIZE(request_headers),
L"SOAPAction: \"urn:schemas-upnp-org:service:WANIPConnection:%u#%s\"\r\n"
L"Content-Type: text/xml",
upnp_gateway_connection.version, function );
if (!WinHttpSendRequest( request, request_headers, -1, request_data, request_len, request_len, 0 ))
{
WARN( "Error sending request %lu.\n", GetLastError() );
goto done;
}
if (!WinHttpReceiveResponse(request, NULL))
{
WARN( "Error receiving response %lu.\n", GetLastError() );
goto done;
}
size = sizeof(*http_status);
if (!WinHttpQueryHeaders( request, WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
NULL, http_status, &size, NULL) || *http_status != HTTP_STATUS_OK )
{
if (*http_status != HTTP_STATUS_SERVER_ERROR)
{
ret = TRUE;
goto done;
}
}
offset = 0;
reply_buffer_size = 1024;
if (!(reply_buffer = malloc( reply_buffer_size ))) goto done;
while ((ret = WinHttpReadData( request, reply_buffer + offset, reply_buffer_size - offset - 1, &size )) && size)
{
offset += size;
if (offset + 1 == reply_buffer_size)
{
char *new;
reply_buffer_size *= 2;
if (!(new = realloc( reply_buffer, reply_buffer_size ))) goto done;
reply_buffer = new;
}
}
reply_buffer[offset] = 0;
if (*http_status == HTTP_STATUS_OK) ret = get_xml_elements( reply_buffer, result, result_count );
else
{
error_value_desc.name = L"errorCode";
error_value_desc.value = NULL;
if ((ret = get_xml_elements( reply_buffer, &error_value_desc, 1 )))
*server_error_code_str = error_value_desc.value;
}
done:
free( reply_buffer );
free( request_data );
WinHttpCloseHandle( request );
return ret;
}
enum port_mapping_parameter
{
PM_EXTERNAL_IP,
PM_EXTERNAL,
PM_PROTOCOL,
PM_INTERNAL,
PM_CLIENT,
PM_ENABLED,
PM_DESC,
PM_LEASE_DURATION,
PM_LAST,
PM_REMOVE_PORT_LAST = PM_INTERNAL,
};
static struct xml_value_desc port_mapping_template[] =
{
{ L"NewRemoteHost" },
{ L"NewExternalPort" },
{ L"NewProtocol" },
{ L"NewInternalPort" },
{ L"NewInternalClient" },
{ L"NewEnabled" },
{ L"NewPortMappingDescription" },
{ L"NewLeaseDuration" },
};
static LONG long_from_bstr( BSTR s )
{
if (!s) return 0;
return _wtoi( s );
}
static BSTR mapping_move_bstr( BSTR *s )
{
BSTR ret;
if (*s)
{
ret = *s;
*s = NULL;
}
else if (!(ret = SysAllocString( L"" )))
{
ERR( "No memory.\n" );
}
return ret;
}
static void update_mapping_list(void)
{
struct xml_value_desc mapping_desc[ARRAY_SIZE(port_mapping_template)];
struct xml_value_desc index_param;
struct port_mapping *new_mappings;
unsigned int i, index;
WCHAR index_str[9];
BSTR error_str;
DWORD status;
BOOL ret;
free_mappings();
index_param.name = L"NewPortMappingIndex";
index = 0;
while (1)
{
new_mappings = realloc( upnp_gateway_connection.mappings, (index + 1) * sizeof(*new_mappings) );
if (!new_mappings) break;
upnp_gateway_connection.mappings = new_mappings;
memcpy( mapping_desc, port_mapping_template, sizeof(mapping_desc) );
swprintf( index_str, ARRAY_SIZE(index_str), L"%u", index );
index_param.value = SysAllocString( index_str );
ret = request_service( L"GetGenericPortMappingEntry", &index_param, 1,
mapping_desc, ARRAY_SIZE(mapping_desc), &status, &error_str );
SysFreeString( index_param.value );
if (!ret) break;
if (status != HTTP_STATUS_OK)
{
if (error_str)
{
if (long_from_bstr( error_str ) != 713)
WARN( "Server returned error %s.\n", debugstr_w(error_str) );
SysFreeString( error_str );
}
break;
}
new_mappings[index].external_ip = mapping_move_bstr( &mapping_desc[PM_EXTERNAL_IP].value );
new_mappings[index].external = long_from_bstr( mapping_desc[PM_EXTERNAL].value );
new_mappings[index].protocol = mapping_move_bstr( &mapping_desc[PM_PROTOCOL].value );
new_mappings[index].internal = long_from_bstr( mapping_desc[PM_INTERNAL].value );
new_mappings[index].client = mapping_move_bstr( &mapping_desc[PM_CLIENT].value );
if (mapping_desc[PM_ENABLED].value && (!wcsicmp( mapping_desc[PM_ENABLED].value, L"true" )
|| long_from_bstr( mapping_desc[PM_ENABLED].value )))
new_mappings[index].enabled = VARIANT_TRUE;
else
new_mappings[index].enabled = VARIANT_FALSE;
new_mappings[index].descr = mapping_move_bstr( &mapping_desc[PM_DESC].value );
TRACE( "%s %s %s:%lu -> %s:%lu, enabled %d.\n", debugstr_w(new_mappings[index].descr),
debugstr_w(new_mappings[index].protocol), debugstr_w(new_mappings[index].external_ip),
new_mappings[index].external, debugstr_w(new_mappings[index].client),
new_mappings[index].internal, new_mappings[index].enabled );
for (i = 0; i < ARRAY_SIZE(mapping_desc); ++i)
SysFreeString( mapping_desc[i].value );
upnp_gateway_connection.mappings = new_mappings;
upnp_gateway_connection.mapping_count = ++index;
}
}
static BOOL remove_port_mapping( LONG port, BSTR protocol )
{
struct xml_value_desc mapping_desc[PM_REMOVE_PORT_LAST];
DWORD status = 0;
BSTR error_str;
WCHAR portW[6];
BOOL ret;
AcquireSRWLockExclusive( &upnp_gateway_connection_lock );
memcpy( mapping_desc, port_mapping_template, sizeof(mapping_desc) );
swprintf( portW, ARRAY_SIZE(portW), L"%u", port );
mapping_desc[PM_EXTERNAL_IP].value = SysAllocString( L"" );
mapping_desc[PM_EXTERNAL].value = SysAllocString( portW );
mapping_desc[PM_PROTOCOL].value = protocol;
ret = request_service( L"DeletePortMapping", mapping_desc, PM_REMOVE_PORT_LAST,
NULL, 0, &status, &error_str );
if (ret && status != HTTP_STATUS_OK)
{
WARN( "status %lu, server returned error %s.\n", status, debugstr_w(error_str) );
SysFreeString( error_str );
ret = FALSE;
}
else if (!ret)
{
WARN( "Request failed.\n" );
}
update_mapping_list();
ReleaseSRWLockExclusive( &upnp_gateway_connection_lock );
SysFreeString( mapping_desc[PM_EXTERNAL_IP].value );
SysFreeString( mapping_desc[PM_EXTERNAL].value );
return ret;
}
static BOOL add_port_mapping( LONG external, BSTR protocol, LONG internal, BSTR client,
VARIANT_BOOL enabled, BSTR description )
{
struct xml_value_desc mapping_desc[PM_LAST];
WCHAR externalW[6], internalW[6];
DWORD status = 0;
BSTR error_str;
BOOL ret;
AcquireSRWLockExclusive( &upnp_gateway_connection_lock );
memcpy( mapping_desc, port_mapping_template, sizeof(mapping_desc) );
swprintf( externalW, ARRAY_SIZE(externalW), L"%u", external );
swprintf( internalW, ARRAY_SIZE(internalW), L"%u", internal );
mapping_desc[PM_EXTERNAL_IP].value = SysAllocString( L"" );
mapping_desc[PM_EXTERNAL].value = SysAllocString( externalW );
mapping_desc[PM_PROTOCOL].value = protocol;
mapping_desc[PM_INTERNAL].value = SysAllocString( internalW );
mapping_desc[PM_CLIENT].value = client;
mapping_desc[PM_ENABLED].value = SysAllocString( enabled ? L"1" : L"0" );
mapping_desc[PM_DESC].value = description;
mapping_desc[PM_LEASE_DURATION].value = SysAllocString( L"0" );
ret = request_service( L"AddPortMapping", mapping_desc, PM_LAST,
NULL, 0, &status, &error_str );
if (ret && status != HTTP_STATUS_OK)
{
WARN( "status %lu, server returned error %s.\n", status, debugstr_w(error_str) );
SysFreeString( error_str );
ret = FALSE;
}
else if (!ret)
{
WARN( "Request failed.\n" );
}
update_mapping_list();
ReleaseSRWLockExclusive( &upnp_gateway_connection_lock );
SysFreeString( mapping_desc[PM_EXTERNAL_IP].value );
SysFreeString( mapping_desc[PM_EXTERNAL].value );
SysFreeString( mapping_desc[PM_INTERNAL].value );
SysFreeString( mapping_desc[PM_ENABLED].value );
SysFreeString( mapping_desc[PM_LEASE_DURATION].value );
return ret;
}
static BOOL init_gateway_connection(void)
{
static const char upnp_search_request[] =
"M-SEARCH * HTTP/1.1\r\n"
"HOST:239.255.255.250:1900\r\n"
"ST:upnp:rootdevice\r\n"
"MX:2\r\n"
"MAN:\"ssdp:discover\"\r\n"
"\r\n";
const DWORD timeout = 1000;
int len, address_len;
char buffer[2048];
SOCKADDR_IN addr;
WSADATA wsa_data;
unsigned int i;
SOCKET s;
upnp_gateway_connection.winsock_initialized = WSAStartup( MAKEWORD( 2, 2 ), &wsa_data );
if ((s = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP )) == -1)
{
ERR( "Failed to create socket, error %u.\n", WSAGetLastError() );
return FALSE;
}
if (setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof(timeout)) == SOCKET_ERROR)
{
ERR( "setsockopt(SO_RCVTIME0) failed, error %u.\n", WSAGetLastError() );
closesocket( s );
return FALSE;
}
addr.sin_family = AF_INET;
addr.sin_port = htons( 1900 );
addr.sin_addr.S_un.S_addr = inet_addr( "239.255.255.250" );
if (sendto( s, upnp_search_request, strlen( upnp_search_request ), 0, (SOCKADDR *)&addr, sizeof(addr) )
== SOCKET_ERROR)
{
ERR( "sendto failed, error %u\n", WSAGetLastError() );
closesocket( s );
return FALSE;
}
/* Windows has a dedicated SSDP discovery service which maintains gateway device info and does
* not usually delay in get_StaticPortMappingCollection(). Although it may still delay depending
* on network connection state and always delays in IUPnPNAT_get_NATEventManager(). */
FIXME( "Waiting for reply from router.\n" );
for (i = 0; i < 2; ++i)
{
address_len = sizeof(addr);
len = recvfrom( s, buffer, sizeof(buffer) - 1, 0, (SOCKADDR *)&addr, &address_len );
if (len == -1)
{
if (WSAGetLastError() != WSAETIMEDOUT)
{
WARN( "recvfrom error %u.\n", WSAGetLastError() );
closesocket( s );
return FALSE;
}
}
else break;
}
closesocket( s );
if (i == 2)
{
TRACE( "No reply from router.\n" );
return FALSE;
}
TRACE( "Received reply from gateway, len %d.\n", len );
buffer[len] = 0;
if (!parse_search_response( buffer, upnp_gateway_connection.locationW, sizeof(upnp_gateway_connection.locationW) ))
{
WARN( "Error parsing response.\n" );
return FALSE;
}
TRACE( "Gateway description location %s.\n", debugstr_w(upnp_gateway_connection.locationW) );
if (!open_gateway_connection())
{
WARN( "Error opening gateway connection.\n" );
return FALSE;
}
TRACE( "Opened gateway connection.\n" );
if (!get_control_url())
{
WARN( "Could not get_control URL.\n" );
gateway_connection_cleanup();
return FALSE;
}
TRACE( "control_url %s, version %u.\n", debugstr_w(upnp_gateway_connection.control_url),
upnp_gateway_connection.version );
update_mapping_list();
return TRUE;
}
static BOOL grab_gateway_connection(void)
{
AcquireSRWLockExclusive( &upnp_gateway_connection_lock );
if (!upnp_gateway_connection.refs && !init_gateway_connection())
{
gateway_connection_cleanup();
ReleaseSRWLockExclusive( &upnp_gateway_connection_lock );
return FALSE;
}
++upnp_gateway_connection.refs;
ReleaseSRWLockExclusive( &upnp_gateway_connection_lock );
return TRUE;
}
static void release_gateway_connection(void)
{
AcquireSRWLockExclusive( &upnp_gateway_connection_lock );
assert( upnp_gateway_connection.refs );
if (!--upnp_gateway_connection.refs)
gateway_connection_cleanup();
ReleaseSRWLockExclusive( &upnp_gateway_connection_lock );
}
static BOOL find_port_mapping( LONG port, BSTR protocol, struct port_mapping *ret )
{
unsigned int i;
BOOL found;
AcquireSRWLockExclusive( &upnp_gateway_connection_lock );
for (i = 0; i < upnp_gateway_connection.mapping_count; ++i)
{
if (upnp_gateway_connection.mappings[i].external == port
&& !wcscmp( upnp_gateway_connection.mappings[i].protocol, protocol ))
break;
}
found = i < upnp_gateway_connection.mapping_count;
if (found) copy_port_mapping( ret, &upnp_gateway_connection.mappings[i] );
ReleaseSRWLockExclusive( &upnp_gateway_connection_lock );
return found;
}
static unsigned int get_port_mapping_range( unsigned int index, unsigned int count, struct port_mapping *ret )
{
unsigned int i;
AcquireSRWLockExclusive( &upnp_gateway_connection_lock );
for (i = 0; i < count && index + i < upnp_gateway_connection.mapping_count; ++i)
if (!copy_port_mapping( &ret[i], &upnp_gateway_connection.mappings[index + i] ))
{
ERR( "No memory.\n" );
break;
}
ReleaseSRWLockExclusive( &upnp_gateway_connection_lock );
return i;
}
static unsigned int get_port_mapping_count(void)
{
unsigned int ret;
AcquireSRWLockExclusive( &upnp_gateway_connection_lock );
ret = upnp_gateway_connection.mapping_count;
ReleaseSRWLockExclusive( &upnp_gateway_connection_lock );
return ret;
}
static BOOL is_valid_protocol( BSTR protocol )
{
if (!protocol) return FALSE;
return !wcscmp( protocol, L"UDP" ) || !wcscmp( protocol, L"TCP" );
}
struct static_port_mapping
{
IStaticPortMapping IStaticPortMapping_iface;
LONG refs;
struct port_mapping data;
};
static inline struct static_port_mapping *impl_from_IStaticPortMapping( IStaticPortMapping *iface )
{
return CONTAINING_RECORD(iface, struct static_port_mapping, IStaticPortMapping_iface);
}
static ULONG WINAPI static_port_mapping_AddRef(
IStaticPortMapping *iface )
{
struct static_port_mapping *mapping = impl_from_IStaticPortMapping( iface );
return InterlockedIncrement( &mapping->refs );
}
static ULONG WINAPI static_port_mapping_Release(
IStaticPortMapping *iface )
{
struct static_port_mapping *mapping = impl_from_IStaticPortMapping( iface );
LONG refs = InterlockedDecrement( &mapping->refs );
if (!refs)
{
TRACE("destroying %p\n", mapping);
free_port_mapping( &mapping->data );
free( mapping );
}
return refs;
}
static HRESULT WINAPI static_port_mapping_QueryInterface(
IStaticPortMapping *iface,
REFIID riid,
void **ppvObject )
{
struct static_port_mapping *mapping = impl_from_IStaticPortMapping( iface );
TRACE("%p %s %p\n", mapping, debugstr_guid( riid ), ppvObject );
if ( IsEqualGUID( riid, &IID_IStaticPortMapping ) ||
IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IUnknown ) )
{
*ppvObject = iface;
}
else
{
FIXME("interface %s not implemented\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
IStaticPortMapping_AddRef( iface );
return S_OK;
}
static HRESULT WINAPI static_port_mapping_GetTypeInfoCount(
IStaticPortMapping *iface,
UINT *pctinfo )
{
struct static_port_mapping *mapping = impl_from_IStaticPortMapping( iface );
TRACE("%p %p\n", mapping, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI static_port_mapping_GetTypeInfo(
IStaticPortMapping *iface,
UINT iTInfo,
LCID lcid,
ITypeInfo **ppTInfo )
{
struct static_port_mapping *mapping = impl_from_IStaticPortMapping( iface );
TRACE("%p %u %lu %p\n", mapping, iTInfo, lcid, ppTInfo);
return get_typeinfo( IStaticPortMapping_tid, ppTInfo );
}
static HRESULT WINAPI static_port_mapping_GetIDsOfNames(
IStaticPortMapping *iface,
REFIID riid,
LPOLESTR *rgszNames,
UINT cNames,
LCID lcid,
DISPID *rgDispId )
{
struct static_port_mapping *mapping = impl_from_IStaticPortMapping( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("%p %s %p %u %lu %p\n", mapping, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
hr = get_typeinfo( IStaticPortMapping_tid, &typeinfo );
if (SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames( typeinfo, rgszNames, cNames, rgDispId );
ITypeInfo_Release( typeinfo );
}
return hr;
}
static HRESULT WINAPI static_port_mapping_Invoke(
IStaticPortMapping *iface,
DISPID dispIdMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS *pDispParams,
VARIANT *pVarResult,
EXCEPINFO *pExcepInfo,
UINT *puArgErr )
{
struct static_port_mapping *mapping = impl_from_IStaticPortMapping( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("%p %ld %s %ld %d %p %p %p %p\n", mapping, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo( IStaticPortMapping_tid, &typeinfo );
if (SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke( typeinfo, &mapping->IStaticPortMapping_iface, dispIdMember,
wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr );
ITypeInfo_Release( typeinfo );
}
return hr;
}
static HRESULT WINAPI static_port_mapping_get_ExternalIPAddress(
IStaticPortMapping *iface,
BSTR *value )
{
struct static_port_mapping *mapping = impl_from_IStaticPortMapping( iface );
TRACE( "iface %p, value %p.\n", iface, value );
if (!value) return E_POINTER;
*value = SysAllocString( mapping->data.external_ip );
if (mapping->data.external_ip && !*value) return E_OUTOFMEMORY;
return S_OK;
}
static HRESULT WINAPI static_port_mapping_get_ExternalPort(
IStaticPortMapping *iface,
LONG *value )
{
struct static_port_mapping *mapping = impl_from_IStaticPortMapping( iface );
TRACE( "iface %p, value %p.\n", iface, value );
if (!value) return E_POINTER;
*value = mapping->data.external;
return S_OK;
}
static HRESULT WINAPI static_port_mapping_get_InternalPort(
IStaticPortMapping *iface,
LONG *value )
{
struct static_port_mapping *mapping = impl_from_IStaticPortMapping( iface );
TRACE( "iface %p, value %p.\n", iface, value );
if (!value) return E_POINTER;
*value = mapping->data.internal;
return S_OK;
}
static HRESULT WINAPI static_port_mapping_get_Protocol(
IStaticPortMapping *iface,
BSTR *value )
{
struct static_port_mapping *mapping = impl_from_IStaticPortMapping( iface );
TRACE( "iface %p, value %p.\n", iface, value );
if (!value) return E_POINTER;
*value = SysAllocString( mapping->data.protocol );
if (mapping->data.protocol && !*value) return E_OUTOFMEMORY;
return S_OK;
}
static HRESULT WINAPI static_port_mapping_get_InternalClient(
IStaticPortMapping *iface,
BSTR *value )
{
struct static_port_mapping *mapping = impl_from_IStaticPortMapping( iface );
TRACE( "iface %p, value %p.\n", iface, value );
if (!value) return E_POINTER;
*value = SysAllocString( mapping->data.client );
if (mapping->data.client && !*value) return E_OUTOFMEMORY;
return S_OK;
}
static HRESULT WINAPI static_port_mapping_get_Enabled(
IStaticPortMapping *iface,
VARIANT_BOOL *value )
{
struct static_port_mapping *mapping = impl_from_IStaticPortMapping( iface );
TRACE( "iface %p, value %p.\n", iface, value );
if (!value) return E_POINTER;
*value = mapping->data.enabled;
return S_OK;
}
static HRESULT WINAPI static_port_mapping_get_Description(
IStaticPortMapping *iface,
BSTR *value )
{
struct static_port_mapping *mapping = impl_from_IStaticPortMapping( iface );
TRACE( "iface %p, value %p.\n", iface, value );
if (!value) return E_POINTER;
*value = SysAllocString( mapping->data.descr );
if (mapping->data.descr && !*value) return E_OUTOFMEMORY;
return S_OK;
}
static HRESULT WINAPI static_port_mapping_EditInternalClient(
IStaticPortMapping *iface,
BSTR value )
{
FIXME( "iface %p, value %s stub.\n", iface, debugstr_w(value) );
return E_NOTIMPL;
}
static HRESULT WINAPI static_port_mapping_Enable(
IStaticPortMapping *iface,
VARIANT_BOOL value )
{
FIXME( "iface %p, value %d stub.\n", iface, value );
return E_NOTIMPL;
}
static HRESULT WINAPI static_port_mapping_EditDescription(
IStaticPortMapping *iface,
BSTR value )
{
FIXME( "iface %p, value %s stub.\n", iface, debugstr_w(value) );
return E_NOTIMPL;
}
static HRESULT WINAPI static_port_mapping_EditInternalPort(
IStaticPortMapping *iface,
LONG value )
{
FIXME( "iface %p, value %ld stub.\n", iface, value );
return E_NOTIMPL;
}
static const IStaticPortMappingVtbl static_port_mapping_vtbl =
{
static_port_mapping_QueryInterface,
static_port_mapping_AddRef,
static_port_mapping_Release,
static_port_mapping_GetTypeInfoCount,
static_port_mapping_GetTypeInfo,
static_port_mapping_GetIDsOfNames,
static_port_mapping_Invoke,
static_port_mapping_get_ExternalIPAddress,
static_port_mapping_get_ExternalPort,
static_port_mapping_get_InternalPort,
static_port_mapping_get_Protocol,
static_port_mapping_get_InternalClient,
static_port_mapping_get_Enabled,
static_port_mapping_get_Description,
static_port_mapping_EditInternalClient,
static_port_mapping_Enable,
static_port_mapping_EditDescription,
static_port_mapping_EditInternalPort,
};
static HRESULT static_port_mapping_create( const struct port_mapping *mapping_data, IStaticPortMapping **ret )
{
struct static_port_mapping *mapping;
if (!(mapping = calloc( 1, sizeof(*mapping) ))) return E_OUTOFMEMORY;
mapping->refs = 1;
mapping->IStaticPortMapping_iface.lpVtbl = &static_port_mapping_vtbl;
mapping->data = *mapping_data;
*ret = &mapping->IStaticPortMapping_iface;
return S_OK;
}
struct port_mapping_enum
{
IEnumVARIANT IEnumVARIANT_iface;
LONG refs;
unsigned int index;
};
static inline struct port_mapping_enum *impl_from_IEnumVARIANT( IEnumVARIANT *iface )
{
return CONTAINING_RECORD(iface, struct port_mapping_enum, IEnumVARIANT_iface);
}
static ULONG WINAPI port_mapping_enum_AddRef(
IEnumVARIANT *iface )
{
struct port_mapping_enum *mapping_enum = impl_from_IEnumVARIANT( iface );
return InterlockedIncrement( &mapping_enum->refs );
}
static ULONG WINAPI port_mapping_enum_Release(
IEnumVARIANT *iface )
{
struct port_mapping_enum *mapping_enum = impl_from_IEnumVARIANT( iface );
LONG refs = InterlockedDecrement( &mapping_enum->refs );
if (!refs)
{
TRACE("destroying %p\n", mapping_enum);
free( mapping_enum );
release_gateway_connection();
}
return refs;
}
static HRESULT WINAPI port_mapping_enum_QueryInterface(
IEnumVARIANT *iface,
REFIID riid,
void **ppvObject )
{
struct port_mapping_enum *mapping_enum = impl_from_IEnumVARIANT( iface );
TRACE("%p %s %p\n", mapping_enum, debugstr_guid( riid ), ppvObject );
if ( IsEqualGUID( riid, &IID_IEnumVARIANT ) ||
IsEqualGUID( riid, &IID_IUnknown ) )
{
*ppvObject = iface;
}
else
{
FIXME("interface %s not implemented\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
IEnumVARIANT_AddRef( iface );
return S_OK;
}
static HRESULT WINAPI port_mapping_enum_Next( IEnumVARIANT *iface, ULONG celt, VARIANT *var, ULONG *fetched )
{
struct port_mapping_enum *mapping_enum = impl_from_IEnumVARIANT( iface );
struct port_mapping *data;
IStaticPortMapping *pm;
unsigned int i, count;
HRESULT ret;
TRACE( "iface %p, celt %lu, var %p, fetched %p.\n", iface, celt, var, fetched );
if (fetched) *fetched = 0;
if (!celt) return S_OK;
if (!var) return E_POINTER;
if (!(data = calloc( 1, celt * sizeof(*data) ))) return E_OUTOFMEMORY;
count = get_port_mapping_range( mapping_enum->index, celt, data );
TRACE( "count %u.\n", count );
for (i = 0; i < count; ++i)
{
if (FAILED(static_port_mapping_create( &data[i], &pm ))) break;
V_VT(&var[i]) = VT_DISPATCH;
V_DISPATCH(&var[i]) = (IDispatch *)pm;
}
mapping_enum->index += i;
if (fetched) *fetched = i;
ret = (i < celt) ? S_FALSE : S_OK;
for ( ; i < count; ++i)
{
free_port_mapping( &data[i] );
VariantInit( &var[i] );
}
for ( ; i < celt; ++i)
VariantInit( &var[i] );
free( data );
return ret;
}
static HRESULT WINAPI port_mapping_enum_Skip( IEnumVARIANT *iface, ULONG celt )
{
struct port_mapping_enum *mapping_enum = impl_from_IEnumVARIANT( iface );
unsigned int count = get_port_mapping_count();
TRACE( "iface %p, celt %lu.\n", iface, celt );
mapping_enum->index += celt;
return mapping_enum->index <= count ? S_OK : S_FALSE;
}
static HRESULT WINAPI port_mapping_enum_Reset( IEnumVARIANT *iface )
{
struct port_mapping_enum *mapping_enum = impl_from_IEnumVARIANT( iface );
TRACE( "iface %p.\n", iface );
mapping_enum->index = 0;
return S_OK;
}
static HRESULT create_port_mapping_enum( IUnknown **ret );
static HRESULT WINAPI port_mapping_enum_Clone( IEnumVARIANT *iface, IEnumVARIANT **ret )
{
struct port_mapping_enum *mapping_enum = impl_from_IEnumVARIANT( iface );
HRESULT hr;
TRACE( "iface %p, ret %p.\n", iface, ret );
if (!ret) return E_POINTER;
*ret = NULL;
if (FAILED(hr = create_port_mapping_enum( (IUnknown **)ret ))) return hr;
impl_from_IEnumVARIANT( *ret )->index = mapping_enum->index;
return S_OK;
}
static const IEnumVARIANTVtbl port_mapping_enum_vtbl =
{
port_mapping_enum_QueryInterface,
port_mapping_enum_AddRef,
port_mapping_enum_Release,
port_mapping_enum_Next,
port_mapping_enum_Skip,
port_mapping_enum_Reset,
port_mapping_enum_Clone,
};
static HRESULT create_port_mapping_enum( IUnknown **ret )
{
struct port_mapping_enum *mapping_enum;
if (!(mapping_enum = calloc( 1, sizeof(*mapping_enum) ))) return E_OUTOFMEMORY;
grab_gateway_connection();
mapping_enum->refs = 1;
mapping_enum->IEnumVARIANT_iface.lpVtbl = &port_mapping_enum_vtbl;
mapping_enum->index = 0;
*ret = (IUnknown *)&mapping_enum->IEnumVARIANT_iface;
return S_OK;
}
struct static_port_mapping_collection
{
IStaticPortMappingCollection IStaticPortMappingCollection_iface;
LONG refs;
};
static inline struct static_port_mapping_collection *impl_from_IStaticPortMappingCollection
( IStaticPortMappingCollection *iface )
{
return CONTAINING_RECORD(iface, struct static_port_mapping_collection, IStaticPortMappingCollection_iface);
}
static ULONG WINAPI static_ports_AddRef(
IStaticPortMappingCollection *iface )
{
struct static_port_mapping_collection *ports = impl_from_IStaticPortMappingCollection( iface );
return InterlockedIncrement( &ports->refs );
}
static ULONG WINAPI static_ports_Release(
IStaticPortMappingCollection *iface )
{
struct static_port_mapping_collection *ports = impl_from_IStaticPortMappingCollection( iface );
LONG refs = InterlockedDecrement( &ports->refs );
if (!refs)
{
TRACE("destroying %p\n", ports);
release_gateway_connection();
free( ports );
}
return refs;
}
static HRESULT WINAPI static_ports_QueryInterface(
IStaticPortMappingCollection *iface,
REFIID riid,
void **ppvObject )
{
struct static_port_mapping_collection *ports = impl_from_IStaticPortMappingCollection( iface );
TRACE("%p %s %p\n", ports, debugstr_guid( riid ), ppvObject );
if ( IsEqualGUID( riid, &IID_IStaticPortMappingCollection ) ||
IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IUnknown ) )
{
*ppvObject = iface;
}
else
{
FIXME("interface %s not implemented\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
IStaticPortMappingCollection_AddRef( iface );
return S_OK;
}
static HRESULT WINAPI static_ports_GetTypeInfoCount(
IStaticPortMappingCollection *iface,
UINT *pctinfo )
{
struct static_port_mapping_collection *ports = impl_from_IStaticPortMappingCollection( iface );
TRACE("%p %p\n", ports, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI static_ports_GetTypeInfo(
IStaticPortMappingCollection *iface,
UINT iTInfo,
LCID lcid,
ITypeInfo **ppTInfo )
{
struct static_port_mapping_collection *ports = impl_from_IStaticPortMappingCollection( iface );
TRACE("%p %u %lu %p\n", ports, iTInfo, lcid, ppTInfo);
return get_typeinfo( IStaticPortMappingCollection_tid, ppTInfo );
}
static HRESULT WINAPI static_ports_GetIDsOfNames(
IStaticPortMappingCollection *iface,
REFIID riid,
LPOLESTR *rgszNames,
UINT cNames,
LCID lcid,
DISPID *rgDispId )
{
struct static_port_mapping_collection *ports = impl_from_IStaticPortMappingCollection( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("%p %s %p %u %lu %p\n", ports, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
hr = get_typeinfo( IStaticPortMappingCollection_tid, &typeinfo );
if (SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames( typeinfo, rgszNames, cNames, rgDispId );
ITypeInfo_Release( typeinfo );
}
return hr;
}
static HRESULT WINAPI static_ports_Invoke(
IStaticPortMappingCollection *iface,
DISPID dispIdMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS *pDispParams,
VARIANT *pVarResult,
EXCEPINFO *pExcepInfo,
UINT *puArgErr )
{
struct static_port_mapping_collection *ports = impl_from_IStaticPortMappingCollection( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("%p %ld %s %ld %d %p %p %p %p\n", ports, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo( IStaticPortMappingCollection_tid, &typeinfo );
if (SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke( typeinfo, &ports->IStaticPortMappingCollection_iface, dispIdMember,
wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr );
ITypeInfo_Release( typeinfo );
}
return hr;
}
static HRESULT WINAPI static_ports__NewEnum(
IStaticPortMappingCollection *iface,
IUnknown **ret )
{
TRACE( "iface %p, ret %p.\n", iface, ret );
if (!ret) return E_POINTER;
*ret = NULL;
return create_port_mapping_enum( ret );
}
static HRESULT WINAPI static_ports_get_Item(
IStaticPortMappingCollection *iface,
LONG port,
BSTR protocol,
IStaticPortMapping **mapping )
{
struct port_mapping mapping_data;
HRESULT ret;
TRACE( "iface %p, port %ld, protocol %s.\n", iface, port, debugstr_w(protocol) );
if (!mapping) return E_POINTER;
*mapping = NULL;
if (!is_valid_protocol( protocol )) return E_INVALIDARG;
if (port < 0 || port > 65535) return E_INVALIDARG;
if (!find_port_mapping( port, protocol, &mapping_data )) return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
if (FAILED(ret = static_port_mapping_create( &mapping_data, mapping ))) free_port_mapping( &mapping_data );
return ret;
}
static HRESULT WINAPI static_ports_get_Count(
IStaticPortMappingCollection *iface,
LONG *count )
{
TRACE( "iface %p, count %p.\n", iface, count );
if (!count) return E_POINTER;
*count = get_port_mapping_count();
return S_OK;
}
static HRESULT WINAPI static_ports_Remove(
IStaticPortMappingCollection *iface,
LONG port,
BSTR protocol )
{
TRACE( "iface %p, port %ld, protocol %s.\n", iface, port, debugstr_w(protocol) );
if (!is_valid_protocol( protocol )) return E_INVALIDARG;
if (port < 0 || port > 65535) return E_INVALIDARG;
if (!remove_port_mapping( port, protocol )) return E_FAIL;
return S_OK;
}
static HRESULT WINAPI static_ports_Add(
IStaticPortMappingCollection *iface,
LONG external,
BSTR protocol,
LONG internal,
BSTR client,
VARIANT_BOOL enabled,
BSTR description,
IStaticPortMapping **mapping )
{
struct port_mapping mapping_data;
HRESULT ret;
TRACE( "iface %p, external %ld, protocol %s, internal %ld, client %s, enabled %d, description %s, mapping %p.\n",
iface, external, debugstr_w(protocol), internal, debugstr_w(client), enabled, debugstr_w(description),
mapping );
if (!mapping) return E_POINTER;
*mapping = NULL;
if (!is_valid_protocol( protocol )) return E_INVALIDARG;
if (external < 0 || external > 65535) return E_INVALIDARG;
if (internal < 0 || internal > 65535) return E_INVALIDARG;
if (!client || !description) return E_INVALIDARG;
if (!add_port_mapping( external, protocol, internal, client, enabled, description )) return E_FAIL;
mapping_data.external_ip = NULL;
mapping_data.external = external;
mapping_data.protocol = SysAllocString( protocol );
mapping_data.internal = internal;
mapping_data.client = SysAllocString( client );
mapping_data.enabled = enabled;
mapping_data.descr = SysAllocString( description );
if (!mapping_data.protocol || !mapping_data.client || !mapping_data.descr)
{
free_port_mapping( &mapping_data );
return E_OUTOFMEMORY;
}
if (FAILED(ret = static_port_mapping_create( &mapping_data, mapping ))) free_port_mapping( &mapping_data );
return ret;
}
static const IStaticPortMappingCollectionVtbl static_ports_vtbl =
{
static_ports_QueryInterface,
static_ports_AddRef,
static_ports_Release,
static_ports_GetTypeInfoCount,
static_ports_GetTypeInfo,
static_ports_GetIDsOfNames,
static_ports_Invoke,
static_ports__NewEnum,
static_ports_get_Item,
static_ports_get_Count,
static_ports_Remove,
static_ports_Add,
};
static HRESULT static_port_mapping_collection_create(IStaticPortMappingCollection **object)
{
struct static_port_mapping_collection *ports;
if (!object) return E_POINTER;
if (!grab_gateway_connection())
{
*object = NULL;
return S_OK;
}
if (!(ports = calloc( 1, sizeof(*ports) )))
{
release_gateway_connection();
return E_OUTOFMEMORY;
}
ports->refs = 1;
ports->IStaticPortMappingCollection_iface.lpVtbl = &static_ports_vtbl;
*object = &ports->IStaticPortMappingCollection_iface;
return S_OK;
}
typedef struct fw_port
{
INetFwOpenPort INetFwOpenPort_iface;
LONG refs;
BSTR name;
NET_FW_IP_PROTOCOL protocol;
LONG port;
} fw_port;
static inline fw_port *impl_from_INetFwOpenPort( INetFwOpenPort *iface )
{
return CONTAINING_RECORD(iface, fw_port, INetFwOpenPort_iface);
}
static ULONG WINAPI fw_port_AddRef(
INetFwOpenPort *iface )
{
fw_port *fw_port = impl_from_INetFwOpenPort( iface );
return InterlockedIncrement( &fw_port->refs );
}
static ULONG WINAPI fw_port_Release(
INetFwOpenPort *iface )
{
fw_port *fw_port = impl_from_INetFwOpenPort( iface );
LONG refs = InterlockedDecrement( &fw_port->refs );
if (!refs)
{
TRACE("destroying %p\n", fw_port);
SysFreeString( fw_port->name );
free( fw_port );
}
return refs;
}
static HRESULT WINAPI fw_port_QueryInterface(
INetFwOpenPort *iface,
REFIID riid,
void **ppvObject )
{
fw_port *This = impl_from_INetFwOpenPort( iface );
TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
if ( IsEqualGUID( riid, &IID_INetFwOpenPort ) ||
IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IUnknown ) )
{
*ppvObject = iface;
}
else
{
FIXME("interface %s not implemented\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
INetFwOpenPort_AddRef( iface );
return S_OK;
}
static HRESULT WINAPI fw_port_GetTypeInfoCount(
INetFwOpenPort *iface,
UINT *pctinfo )
{
fw_port *This = impl_from_INetFwOpenPort( iface );
TRACE("%p %p\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI fw_port_GetTypeInfo(
INetFwOpenPort *iface,
UINT iTInfo,
LCID lcid,
ITypeInfo **ppTInfo )
{
fw_port *This = impl_from_INetFwOpenPort( iface );
TRACE("%p %u %lu %p\n", This, iTInfo, lcid, ppTInfo);
return get_typeinfo( INetFwOpenPort_tid, ppTInfo );
}
static HRESULT WINAPI fw_port_GetIDsOfNames(
INetFwOpenPort *iface,
REFIID riid,
LPOLESTR *rgszNames,
UINT cNames,
LCID lcid,
DISPID *rgDispId )
{
fw_port *This = impl_from_INetFwOpenPort( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("%p %s %p %u %lu %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
hr = get_typeinfo( INetFwOpenPort_tid, &typeinfo );
if (SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames( typeinfo, rgszNames, cNames, rgDispId );
ITypeInfo_Release( typeinfo );
}
return hr;
}
static HRESULT WINAPI fw_port_Invoke(
INetFwOpenPort *iface,
DISPID dispIdMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS *pDispParams,
VARIANT *pVarResult,
EXCEPINFO *pExcepInfo,
UINT *puArgErr )
{
fw_port *This = impl_from_INetFwOpenPort( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("%p %ld %s %ld %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo( INetFwOpenPort_tid, &typeinfo );
if (SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke( typeinfo, &This->INetFwOpenPort_iface, dispIdMember,
wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr );
ITypeInfo_Release( typeinfo );
}
return hr;
}
static HRESULT WINAPI fw_port_get_Name(
INetFwOpenPort *iface,
BSTR *name)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %p\n", This, name);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_put_Name(
INetFwOpenPort *iface,
BSTR name)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
TRACE("%p %s\n", This, debugstr_w(name));
if (!(name = SysAllocString( name )))
return E_OUTOFMEMORY;
SysFreeString( This->name );
This->name = name;
return S_OK;
}
static HRESULT WINAPI fw_port_get_IpVersion(
INetFwOpenPort *iface,
NET_FW_IP_VERSION *ipVersion)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %p\n", This, ipVersion);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_put_IpVersion(
INetFwOpenPort *iface,
NET_FW_IP_VERSION ipVersion)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %u\n", This, ipVersion);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_get_Protocol(
INetFwOpenPort *iface,
NET_FW_IP_PROTOCOL *ipProtocol)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %p\n", This, ipProtocol);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_put_Protocol(
INetFwOpenPort *iface,
NET_FW_IP_PROTOCOL ipProtocol)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
TRACE("%p %u\n", This, ipProtocol);
if (ipProtocol != NET_FW_IP_PROTOCOL_TCP && ipProtocol != NET_FW_IP_PROTOCOL_UDP)
return E_INVALIDARG;
This->protocol = ipProtocol;
return S_OK;
}
static HRESULT WINAPI fw_port_get_Port(
INetFwOpenPort *iface,
LONG *portNumber)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %p\n", This, portNumber);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_put_Port(
INetFwOpenPort *iface,
LONG portNumber)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
TRACE("%p %ld\n", This, portNumber);
This->port = portNumber;
return S_OK;
}
static HRESULT WINAPI fw_port_get_Scope(
INetFwOpenPort *iface,
NET_FW_SCOPE *scope)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %p\n", This, scope);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_put_Scope(
INetFwOpenPort *iface,
NET_FW_SCOPE scope)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %u\n", This, scope);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_get_RemoteAddresses(
INetFwOpenPort *iface,
BSTR *remoteAddrs)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %p\n", This, remoteAddrs);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_put_RemoteAddresses(
INetFwOpenPort *iface,
BSTR remoteAddrs)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %s\n", This, debugstr_w(remoteAddrs));
return E_NOTIMPL;
}
static HRESULT WINAPI fw_port_get_Enabled(
INetFwOpenPort *iface,
VARIANT_BOOL *enabled)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %p\n", This, enabled);
*enabled = VARIANT_TRUE;
return S_OK;
}
static HRESULT WINAPI fw_port_put_Enabled(
INetFwOpenPort *iface,
VARIANT_BOOL enabled)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %d\n", This, enabled);
return S_OK;
}
static HRESULT WINAPI fw_port_get_BuiltIn(
INetFwOpenPort *iface,
VARIANT_BOOL *builtIn)
{
fw_port *This = impl_from_INetFwOpenPort( iface );
FIXME("%p %p\n", This, builtIn);
return E_NOTIMPL;
}
static const struct INetFwOpenPortVtbl fw_port_vtbl =
{
fw_port_QueryInterface,
fw_port_AddRef,
fw_port_Release,
fw_port_GetTypeInfoCount,
fw_port_GetTypeInfo,
fw_port_GetIDsOfNames,
fw_port_Invoke,
fw_port_get_Name,
fw_port_put_Name,
fw_port_get_IpVersion,
fw_port_put_IpVersion,
fw_port_get_Protocol,
fw_port_put_Protocol,
fw_port_get_Port,
fw_port_put_Port,
fw_port_get_Scope,
fw_port_put_Scope,
fw_port_get_RemoteAddresses,
fw_port_put_RemoteAddresses,
fw_port_get_Enabled,
fw_port_put_Enabled,
fw_port_get_BuiltIn
};
HRESULT NetFwOpenPort_create( IUnknown *pUnkOuter, LPVOID *ppObj )
{
fw_port *fp;
TRACE("(%p,%p)\n", pUnkOuter, ppObj);
fp = malloc( sizeof(*fp) );
if (!fp) return E_OUTOFMEMORY;
fp->INetFwOpenPort_iface.lpVtbl = &fw_port_vtbl;
fp->refs = 1;
fp->name = NULL;
fp->protocol = NET_FW_IP_PROTOCOL_TCP;
fp->port = 0;
*ppObj = &fp->INetFwOpenPort_iface;
TRACE("returning iface %p\n", *ppObj);
return S_OK;
}
typedef struct fw_ports
{
INetFwOpenPorts INetFwOpenPorts_iface;
LONG refs;
} fw_ports;
static inline fw_ports *impl_from_INetFwOpenPorts( INetFwOpenPorts *iface )
{
return CONTAINING_RECORD(iface, fw_ports, INetFwOpenPorts_iface);
}
static ULONG WINAPI fw_ports_AddRef(
INetFwOpenPorts *iface )
{
fw_ports *fw_ports = impl_from_INetFwOpenPorts( iface );
return InterlockedIncrement( &fw_ports->refs );
}
static ULONG WINAPI fw_ports_Release(
INetFwOpenPorts *iface )
{
fw_ports *fw_ports = impl_from_INetFwOpenPorts( iface );
LONG refs = InterlockedDecrement( &fw_ports->refs );
if (!refs)
{
TRACE("destroying %p\n", fw_ports);
free( fw_ports );
}
return refs;
}
static HRESULT WINAPI fw_ports_QueryInterface(
INetFwOpenPorts *iface,
REFIID riid,
void **ppvObject )
{
fw_ports *This = impl_from_INetFwOpenPorts( iface );
TRACE("%p %s %p\n", This, debugstr_guid( riid ), ppvObject );
if ( IsEqualGUID( riid, &IID_INetFwOpenPorts ) ||
IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IUnknown ) )
{
*ppvObject = iface;
}
else
{
FIXME("interface %s not implemented\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
INetFwOpenPorts_AddRef( iface );
return S_OK;
}
static HRESULT WINAPI fw_ports_GetTypeInfoCount(
INetFwOpenPorts *iface,
UINT *pctinfo )
{
fw_ports *This = impl_from_INetFwOpenPorts( iface );
TRACE("%p %p\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI fw_ports_GetTypeInfo(
INetFwOpenPorts *iface,
UINT iTInfo,
LCID lcid,
ITypeInfo **ppTInfo )
{
fw_ports *This = impl_from_INetFwOpenPorts( iface );
TRACE("%p %u %lu %p\n", This, iTInfo, lcid, ppTInfo);
return get_typeinfo( INetFwOpenPorts_tid, ppTInfo );
}
static HRESULT WINAPI fw_ports_GetIDsOfNames(
INetFwOpenPorts *iface,
REFIID riid,
LPOLESTR *rgszNames,
UINT cNames,
LCID lcid,
DISPID *rgDispId )
{
fw_ports *This = impl_from_INetFwOpenPorts( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("%p %s %p %u %lu %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
hr = get_typeinfo( INetFwOpenPorts_tid, &typeinfo );
if (SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames( typeinfo, rgszNames, cNames, rgDispId );
ITypeInfo_Release( typeinfo );
}
return hr;
}
static HRESULT WINAPI fw_ports_Invoke(
INetFwOpenPorts *iface,
DISPID dispIdMember,
REFIID riid,
LCID lcid,
WORD wFlags,
DISPPARAMS *pDispParams,
VARIANT *pVarResult,
EXCEPINFO *pExcepInfo,
UINT *puArgErr )
{
fw_ports *This = impl_from_INetFwOpenPorts( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("%p %ld %s %ld %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo( INetFwOpenPorts_tid, &typeinfo );
if (SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke( typeinfo, &This->INetFwOpenPorts_iface, dispIdMember,
wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr );
ITypeInfo_Release( typeinfo );
}
return hr;
}
static HRESULT WINAPI fw_ports_get_Count(
INetFwOpenPorts *iface,
LONG *count)
{
fw_ports *This = impl_from_INetFwOpenPorts( iface );
FIXME("%p, %p\n", This, count);
*count = 0;
return S_OK;
}
static HRESULT WINAPI fw_ports_Add(
INetFwOpenPorts *iface,
INetFwOpenPort *port)
{
fw_ports *This = impl_from_INetFwOpenPorts( iface );
FIXME("%p, %p\n", This, port);
return S_OK;
}
static HRESULT WINAPI fw_ports_Remove(
INetFwOpenPorts *iface,
LONG portNumber,
NET_FW_IP_PROTOCOL ipProtocol)
{
fw_ports *This = impl_from_INetFwOpenPorts( iface );
FIXME("%p, %ld, %u\n", This, portNumber, ipProtocol);
return E_NOTIMPL;
}
static HRESULT WINAPI fw_ports_Item(
INetFwOpenPorts *iface,
LONG portNumber,
NET_FW_IP_PROTOCOL ipProtocol,
INetFwOpenPort **openPort)
{
HRESULT hr;
fw_ports *This = impl_from_INetFwOpenPorts( iface );
FIXME("%p, %ld, %u, %p\n", This, portNumber, ipProtocol, openPort);
hr = NetFwOpenPort_create( NULL, (void **)openPort );
if (SUCCEEDED(hr))
{
INetFwOpenPort_put_Protocol( *openPort, ipProtocol );
INetFwOpenPort_put_Port( *openPort, portNumber );
}
return hr;
}
static HRESULT WINAPI fw_ports_get__NewEnum(
INetFwOpenPorts *iface,
IUnknown **newEnum)
{
fw_ports *This = impl_from_INetFwOpenPorts( iface );
FIXME("%p, %p\n", This, newEnum);
return E_NOTIMPL;
}
static const struct INetFwOpenPortsVtbl fw_ports_vtbl =
{
fw_ports_QueryInterface,
fw_ports_AddRef,
fw_ports_Release,
fw_ports_GetTypeInfoCount,
fw_ports_GetTypeInfo,
fw_ports_GetIDsOfNames,
fw_ports_Invoke,
fw_ports_get_Count,
fw_ports_Add,
fw_ports_Remove,
fw_ports_Item,
fw_ports_get__NewEnum
};
HRESULT NetFwOpenPorts_create( IUnknown *pUnkOuter, LPVOID *ppObj )
{
fw_ports *fp;
TRACE("(%p,%p)\n", pUnkOuter, ppObj);
fp = malloc( sizeof(*fp) );
if (!fp) return E_OUTOFMEMORY;
fp->INetFwOpenPorts_iface.lpVtbl = &fw_ports_vtbl;
fp->refs = 1;
*ppObj = &fp->INetFwOpenPorts_iface;
TRACE("returning iface %p\n", *ppObj);
return S_OK;
}
typedef struct _upnpnat
{
IUPnPNAT IUPnPNAT_iface;
LONG ref;
} upnpnat;
static inline upnpnat *impl_from_IUPnPNAT( IUPnPNAT *iface )
{
return CONTAINING_RECORD(iface, upnpnat, IUPnPNAT_iface);
}
static HRESULT WINAPI upnpnat_QueryInterface(IUPnPNAT *iface, REFIID riid, void **object)
{
upnpnat *This = impl_from_IUPnPNAT( iface );
TRACE("%p %s %p\n", This, debugstr_guid( riid ), object );
if ( IsEqualGUID( riid, &IID_IUPnPNAT ) ||
IsEqualGUID( riid, &IID_IDispatch ) ||
IsEqualGUID( riid, &IID_IUnknown ) )
{
*object = iface;
}
else if(IsEqualGUID( riid, &IID_IProvideClassInfo))
{
TRACE("IProvideClassInfo not supported.\n");
return E_NOINTERFACE;
}
else
{
FIXME("interface %s not implemented\n", debugstr_guid(riid));
return E_NOINTERFACE;
}
IUPnPNAT_AddRef( iface );
return S_OK;
}
static ULONG WINAPI upnpnat_AddRef(IUPnPNAT *iface)
{
upnpnat *This = impl_from_IUPnPNAT( iface );
return InterlockedIncrement( &This->ref );
}
static ULONG WINAPI upnpnat_Release(IUPnPNAT *iface)
{
upnpnat *This = impl_from_IUPnPNAT( iface );
LONG refs = InterlockedDecrement( &This->ref );
if (!refs)
{
free( This );
}
return refs;
}
static HRESULT WINAPI upnpnat_GetTypeInfoCount(IUPnPNAT *iface, UINT *pctinfo)
{
upnpnat *This = impl_from_IUPnPNAT( iface );
TRACE("%p %p\n", This, pctinfo);
*pctinfo = 1;
return S_OK;
}
static HRESULT WINAPI upnpnat_GetTypeInfo(IUPnPNAT *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
{
upnpnat *This = impl_from_IUPnPNAT( iface );
TRACE("%p %u %lu %p\n", This, iTInfo, lcid, ppTInfo);
return get_typeinfo( IUPnPNAT_tid, ppTInfo );
}
static HRESULT WINAPI upnpnat_GetIDsOfNames(IUPnPNAT *iface, REFIID riid, LPOLESTR *rgszNames,
UINT cNames, LCID lcid, DISPID *rgDispId)
{
upnpnat *This = impl_from_IUPnPNAT( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("%p %s %p %u %lu %p\n", This, debugstr_guid(riid), rgszNames, cNames, lcid, rgDispId);
hr = get_typeinfo( IUPnPNAT_tid, &typeinfo );
if (SUCCEEDED(hr))
{
hr = ITypeInfo_GetIDsOfNames( typeinfo, rgszNames, cNames, rgDispId );
ITypeInfo_Release( typeinfo );
}
return hr;
}
static HRESULT WINAPI upnpnat_Invoke(IUPnPNAT *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
UINT *puArgErr)
{
upnpnat *This = impl_from_IUPnPNAT( iface );
ITypeInfo *typeinfo;
HRESULT hr;
TRACE("%p %ld %s %ld %d %p %p %p %p\n", This, dispIdMember, debugstr_guid(riid),
lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
hr = get_typeinfo( IUPnPNAT_tid, &typeinfo );
if (SUCCEEDED(hr))
{
hr = ITypeInfo_Invoke( typeinfo, &This->IUPnPNAT_iface, dispIdMember,
wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr );
ITypeInfo_Release( typeinfo );
}
return hr;
}
static HRESULT WINAPI upnpnat_get_StaticPortMappingCollection(IUPnPNAT *iface, IStaticPortMappingCollection **collection)
{
upnpnat *This = impl_from_IUPnPNAT( iface );
TRACE("%p, %p\n", This, collection);
return static_port_mapping_collection_create( collection );
}
static HRESULT WINAPI upnpnat_get_DynamicPortMappingCollection(IUPnPNAT *iface, IDynamicPortMappingCollection **collection)
{
upnpnat *This = impl_from_IUPnPNAT( iface );
FIXME("%p, %p\n", This, collection);
if(collection)
*collection = NULL;
return E_NOTIMPL;
}
static HRESULT WINAPI upnpnat_get_NATEventManager(IUPnPNAT *iface, INATEventManager **manager)
{
upnpnat *This = impl_from_IUPnPNAT( iface );
FIXME("%p, %p\n", This, manager);
if(manager)
*manager = NULL;
return E_NOTIMPL;
}
const static IUPnPNATVtbl upnpnat_vtbl =
{
upnpnat_QueryInterface,
upnpnat_AddRef,
upnpnat_Release,
upnpnat_GetTypeInfoCount,
upnpnat_GetTypeInfo,
upnpnat_GetIDsOfNames,
upnpnat_Invoke,
upnpnat_get_StaticPortMappingCollection,
upnpnat_get_DynamicPortMappingCollection,
upnpnat_get_NATEventManager
};
HRESULT IUPnPNAT_create(IUnknown *outer, void **object)
{
upnpnat *nat;
TRACE("(%p,%p)\n", outer, object);
nat = malloc( sizeof(*nat) );
if (!nat) return E_OUTOFMEMORY;
nat->IUPnPNAT_iface.lpVtbl = &upnpnat_vtbl;
nat->ref = 1;
*object = &nat->IUPnPNAT_iface;
TRACE("returning iface %p\n", *object);
return S_OK;
}
Reference in a new issue View git blame Copy permalink