dlls/jsproxy/main.c

   1 /*
   2  * Copyright 2014 Hans Leidekker for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20 #include <sys/types.h>
  21
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "winsock2.h"
  25 #include "ws2ipdef.h"
  26 #include "ws2tcpip.h"
  27 #include "winnls.h"
  28 #include "wininet.h"
  29 #define COBJMACROS
  30 #include "ole2.h"
  31 #include "dispex.h"
  32 #include "activscp.h"
  33 #include "wine/debug.h"
  34 #include "wine/heap.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(jsproxy);
  37
  38 static CRITICAL_SECTION cs_jsproxy;
  39 static CRITICAL_SECTION_DEBUG critsect_debug =
  40 {
  41     0, 0, &cs_jsproxy,
  42     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  43       0, 0, { (DWORD_PTR)(__FILE__ ": cs_jsproxy") }
  44 };
  45 static CRITICAL_SECTION cs_jsproxy = { &critsect_debug, -1, 0, 0, 0, 0 };
  46
  47 static inline WCHAR *strdupAW( const char *src, int len )
  48 {
  49     WCHAR *dst = NULL;
  50     if (src)
  51     {
  52         int dst_len = MultiByteToWideChar( CP_ACP, 0, src, len, NULL, 0 );
  53         if ((dst = heap_alloc( (dst_len + 1) * sizeof(WCHAR) )))
  54         {
  55             len = MultiByteToWideChar( CP_ACP, 0, src, len, dst, dst_len );
  56             dst[dst_len] = 0;
  57         }
  58     }
  59     return dst;
  60 }
  61
  62 static inline char *strdupWA( const WCHAR *src )
  63 {
  64     char *dst = NULL;
  65     if (src)
  66     {
  67         int len = WideCharToMultiByte( CP_ACP, 0, src, -1, NULL, 0, NULL, NULL );
  68         if ((dst = heap_alloc( len ))) WideCharToMultiByte( CP_ACP, 0, src, -1, dst, len, NULL, NULL );
  69     }
  70     return dst;
  71 }
  72
  73 static struct pac_script
  74 {
  75     WCHAR *text;
  76 } pac_script;
  77 static struct pac_script *global_script = &pac_script;
  78
  79 /******************************************************************
  80  *      InternetDeInitializeAutoProxyDll (jsproxy.@)
  81  */
  82 BOOL WINAPI InternetDeInitializeAutoProxyDll( LPSTR mime, DWORD reserved )
  83 {
  84     TRACE( "%s, %u\n", debugstr_a(mime), reserved );
  85
  86     EnterCriticalSection( &cs_jsproxy );
  87
  88     heap_free( global_script->text );
  89     global_script->text = NULL;
  90
  91     LeaveCriticalSection( &cs_jsproxy );
  92     return TRUE;
  93 }
  94
  95 static WCHAR *load_script( const char *filename )
  96 {
  97     HANDLE handle;
  98     DWORD size, bytes_read;
  99     char *buffer;
 100     int len;
 101     WCHAR *script = NULL;
 102
 103     handle = CreateFileA( filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
 104     if (handle == INVALID_HANDLE_VALUE) return NULL;
 105
 106     size = GetFileSize( handle, NULL );
 107     if (!(buffer = heap_alloc( size ))) goto done;
 108     if (!ReadFile( handle, buffer, size, &bytes_read, NULL ) || bytes_read != size) goto done;
 109
 110     len = MultiByteToWideChar( CP_ACP, 0, buffer, size, NULL, 0 );
 111     if (!(script = heap_alloc( (len + 1) * sizeof(WCHAR) ))) goto done;
 112     MultiByteToWideChar( CP_ACP, 0, buffer, size, script, len );
 113     script[len] = 0;
 114
 115 done:
 116     CloseHandle( handle );
 117     heap_free( buffer );
 118     return script;
 119 }
 120
 121 /******************************************************************
 122  *      InternetInitializeAutoProxyDll (jsproxy.@)
 123  */
 124 BOOL WINAPI JSPROXY_InternetInitializeAutoProxyDll( DWORD version, LPSTR tmpfile, LPSTR mime,
 125                                                     AutoProxyHelperFunctions *callbacks,
 126                                                     LPAUTO_PROXY_SCRIPT_BUFFER buffer )
 127 {
 128     BOOL ret = FALSE;
 129
 130     TRACE( "%u, %s, %s, %p, %p\n", version, debugstr_a(tmpfile), debugstr_a(mime), callbacks, buffer );
 131
 132     if (callbacks) FIXME( "callbacks not supported\n" );
 133
 134     EnterCriticalSection( &cs_jsproxy );
 135
 136     if (buffer && buffer->dwStructSize == sizeof(*buffer) && buffer->lpszScriptBuffer)
 137     {
 138         if (!buffer->dwScriptBufferSize)
 139         {
 140             SetLastError( ERROR_INVALID_PARAMETER );
 141             LeaveCriticalSection( &cs_jsproxy );
 142             return FALSE;
 143         }
 144         heap_free( global_script->text );
 145         if ((global_script->text = strdupAW( buffer->lpszScriptBuffer,
 146                         buffer->dwScriptBufferSize ))) ret = TRUE;
 147     }
 148     else
 149     {
 150         heap_free( global_script->text );
 151         if ((global_script->text = load_script( tmpfile ))) ret = TRUE;
 152     }
 153
 154     LeaveCriticalSection( &cs_jsproxy );
 155     return ret;
 156 }
 157
 158 static HRESULT WINAPI dispex_QueryInterface(
 159     IDispatchEx *iface, REFIID riid, void **ppv )
 160 {
 161     *ppv = NULL;
 162
 163     if (IsEqualGUID( riid, &IID_IUnknown )  ||
 164         IsEqualGUID( riid, &IID_IDispatch ) ||
 165         IsEqualGUID( riid, &IID_IDispatchEx ))
 166         *ppv = iface;
 167     else
 168         return E_NOINTERFACE;
 169
 170     return S_OK;
 171 }
 172
 173 static ULONG WINAPI dispex_AddRef(
 174     IDispatchEx *iface )
 175 {
 176     return 2;
 177 }
 178
 179 static ULONG WINAPI dispex_Release(
 180     IDispatchEx *iface )
 181 {
 182     return 1;
 183 }
 184
 185 static HRESULT WINAPI dispex_GetTypeInfoCount(
 186     IDispatchEx *iface, UINT *info )
 187 {
 188     return E_NOTIMPL;
 189 }
 190
 191 static HRESULT WINAPI dispex_GetTypeInfo(
 192     IDispatchEx *iface, UINT info, LCID lcid, ITypeInfo **type_info )
 193 {
 194     return E_NOTIMPL;
 195 }
 196
 197 static HRESULT WINAPI dispex_GetIDsOfNames(
 198     IDispatchEx *iface, REFIID riid, LPOLESTR *names, UINT count, LCID lcid, DISPID *id )
 199 {
 200     return E_NOTIMPL;
 201 }
 202
 203 static HRESULT WINAPI dispex_Invoke(
 204     IDispatchEx *iface, DISPID member, REFIID riid, LCID lcid, WORD flags,
 205     DISPPARAMS *params, VARIANT *result, EXCEPINFO *excep, UINT *err )
 206 {
 207     return E_NOTIMPL;
 208 }
 209
 210 static HRESULT WINAPI dispex_DeleteMemberByName(
 211     IDispatchEx *iface, BSTR name, DWORD flags )
 212 {
 213     return E_NOTIMPL;
 214 }
 215
 216 static HRESULT WINAPI dispex_DeleteMemberByDispID(
 217     IDispatchEx *iface, DISPID id )
 218 {
 219     return E_NOTIMPL;
 220 }
 221
 222 static HRESULT WINAPI dispex_GetMemberProperties(
 223     IDispatchEx *iface, DISPID id, DWORD flags_fetch, DWORD *flags )
 224 {
 225     return E_NOTIMPL;
 226 }
 227
 228 static HRESULT WINAPI dispex_GetMemberName(
 229     IDispatchEx *iface, DISPID id, BSTR *name )
 230 {
 231     return E_NOTIMPL;
 232 }
 233
 234 static HRESULT WINAPI dispex_GetNextDispID(
 235     IDispatchEx *iface, DWORD flags, DISPID id, DISPID *next )
 236 {
 237     return E_NOTIMPL;
 238 }
 239
 240 static HRESULT WINAPI dispex_GetNameSpaceParent(
 241     IDispatchEx *iface, IUnknown **unk )
 242 {
 243     return E_NOTIMPL;
 244 }
 245
 246 #define DISPID_GLOBAL_DNSRESOLVE  0x1000
 247
 248 static HRESULT WINAPI dispex_GetDispID(
 249     IDispatchEx *iface, BSTR name, DWORD flags, DISPID *id )
 250 {
 251     if (!lstrcmpW( name, L"dns_resolve" ))
 252     {
 253         *id = DISPID_GLOBAL_DNSRESOLVE;
 254         return S_OK;
 255     }
 256     return DISP_E_UNKNOWNNAME;
 257 }
 258
 259 static char *get_computer_name( COMPUTER_NAME_FORMAT format )
 260 {
 261     char *ret;
 262     DWORD size = 0;
 263
 264     GetComputerNameExA( format, NULL, &size );
 265     if (GetLastError() != ERROR_MORE_DATA) return NULL;
 266     if (!(ret = heap_alloc( size ))) return NULL;
 267     if (!GetComputerNameExA( format, ret, &size ))
 268     {
 269         heap_free( ret );
 270         return NULL;
 271     }
 272     return ret;
 273 }
 274
 275 static void printf_addr( const WCHAR *fmt, WCHAR *buf, SIZE_T size, struct sockaddr_in *addr )
 276 {
 277     swprintf( buf, size, fmt,
 278               (unsigned int)(ntohl( addr->sin_addr.s_addr ) >> 24 & 0xff),
 279               (unsigned int)(ntohl( addr->sin_addr.s_addr ) >> 16 & 0xff),
 280               (unsigned int)(ntohl( addr->sin_addr.s_addr ) >> 8 & 0xff),
 281               (unsigned int)(ntohl( addr->sin_addr.s_addr ) & 0xff) );
 282 }
 283
 284 static HRESULT dns_resolve( const WCHAR *hostname, VARIANT *result )
 285 {
 286         WCHAR addr[16];
 287         struct addrinfo *ai, *elem;
 288         char *hostnameA;
 289         int res;
 290
 291         if (hostname[0])
 292             hostnameA = strdupWA( hostname );
 293         else
 294             hostnameA = get_computer_name( ComputerNamePhysicalDnsFullyQualified );
 295
 296         if (!hostnameA) return E_OUTOFMEMORY;
 297         res = getaddrinfo( hostnameA, NULL, NULL, &ai );
 298         heap_free( hostnameA );
 299         if (res) return S_FALSE;
 300
 301         elem = ai;
 302         while (elem && elem->ai_family != AF_INET) elem = elem->ai_next;
 303         if (!elem)
 304         {
 305             freeaddrinfo( ai );
 306             return S_FALSE;
 307         }
 308         printf_addr( L"%u.%u.%u.%u", addr, ARRAY_SIZE(addr), (struct sockaddr_in *)elem->ai_addr );
 309         freeaddrinfo( ai );
 310         V_VT( result ) = VT_BSTR;
 311         V_BSTR( result ) = SysAllocString( addr );
 312         return S_OK;
 313 }
 314
 315 static HRESULT WINAPI dispex_InvokeEx(
 316     IDispatchEx *iface, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
 317     VARIANT *result, EXCEPINFO *exep, IServiceProvider *caller )
 318 {
 319     if (id == DISPID_GLOBAL_DNSRESOLVE)
 320     {
 321         if (params->cArgs != 1) return DISP_E_BADPARAMCOUNT;
 322         if (V_VT(&params->rgvarg[0]) != VT_BSTR) return DISP_E_BADVARTYPE;
 323         return dns_resolve( V_BSTR(&params->rgvarg[0]), result );
 324     }
 325     return DISP_E_MEMBERNOTFOUND;
 326 }
 327
 328 static const IDispatchExVtbl dispex_vtbl =
 329 {
 330     dispex_QueryInterface,
 331     dispex_AddRef,
 332     dispex_Release,
 333     dispex_GetTypeInfoCount,
 334     dispex_GetTypeInfo,
 335     dispex_GetIDsOfNames,
 336     dispex_Invoke,
 337     dispex_GetDispID,
 338     dispex_InvokeEx,
 339     dispex_DeleteMemberByName,
 340     dispex_DeleteMemberByDispID,
 341     dispex_GetMemberProperties,
 342     dispex_GetMemberName,
 343     dispex_GetNextDispID,
 344     dispex_GetNameSpaceParent
 345 };
 346
 347 static IDispatchEx global_dispex = { &dispex_vtbl };
 348
 349 static HRESULT WINAPI site_QueryInterface(
 350     IActiveScriptSite *iface, REFIID riid, void **ppv )
 351 {
 352     *ppv = NULL;
 353
 354     if (IsEqualGUID( &IID_IUnknown, riid ))
 355         *ppv = iface;
 356     else if (IsEqualGUID( &IID_IActiveScriptSite, riid ))
 357         *ppv = iface;
 358     else
 359         return E_NOINTERFACE;
 360
 361     IUnknown_AddRef( (IUnknown *)*ppv );
 362     return S_OK;
 363 }
 364
 365 static ULONG WINAPI site_AddRef(
 366     IActiveScriptSite *iface )
 367 {
 368     return 2;
 369 }
 370
 371 static ULONG WINAPI site_Release(
 372     IActiveScriptSite *iface )
 373 {
 374     return 1;
 375 }
 376
 377 static HRESULT WINAPI site_GetLCID(
 378     IActiveScriptSite *iface, LCID *lcid )
 379 {
 380     return E_NOTIMPL;
 381 }
 382
 383 static HRESULT WINAPI site_GetItemInfo(
 384     IActiveScriptSite *iface, LPCOLESTR name, DWORD mask,
 385     IUnknown **item, ITypeInfo **type_info )
 386 {
 387     if (!lstrcmpW( name, L"global_funcs" ) && mask == SCRIPTINFO_IUNKNOWN)
 388     {
 389         *item = (IUnknown *)&global_dispex;
 390         return S_OK;
 391     }
 392     return E_NOTIMPL;
 393 }
 394
 395 static HRESULT WINAPI site_GetDocVersionString(
 396     IActiveScriptSite *iface, BSTR *version )
 397 {
 398     return E_NOTIMPL;
 399 }
 400
 401 static HRESULT WINAPI site_OnScriptTerminate(
 402     IActiveScriptSite *iface, const VARIANT *result, const EXCEPINFO *info )
 403 {
 404     return E_NOTIMPL;
 405 }
 406
 407 static HRESULT WINAPI site_OnStateChange(
 408     IActiveScriptSite *iface, SCRIPTSTATE state )
 409 {
 410     return E_NOTIMPL;
 411 }
 412
 413 static HRESULT WINAPI site_OnScriptError(
 414     IActiveScriptSite *iface, IActiveScriptError *error )
 415 {
 416     return E_NOTIMPL;
 417 }
 418
 419 static HRESULT WINAPI site_OnEnterScript(
 420     IActiveScriptSite *iface )
 421 {
 422     return E_NOTIMPL;
 423 }
 424
 425 static HRESULT WINAPI site_OnLeaveScript(
 426     IActiveScriptSite *iface )
 427 {
 428     return E_NOTIMPL;
 429 }
 430
 431 static const IActiveScriptSiteVtbl site_vtbl =
 432 {
 433     site_QueryInterface,
 434     site_AddRef,
 435     site_Release,
 436     site_GetLCID,
 437     site_GetItemInfo,
 438     site_GetDocVersionString,
 439     site_OnScriptTerminate,
 440     site_OnStateChange,
 441     site_OnScriptError,
 442     site_OnEnterScript,
 443     site_OnLeaveScript
 444 };
 445
 446 static IActiveScriptSite script_site = { &site_vtbl };
 447
 448 static BSTR include_pac_utils( const WCHAR *script )
 449 {
 450     HMODULE hmod = GetModuleHandleA( "jsproxy.dll" );
 451     HRSRC rsrc;
 452     DWORD size;
 453     const char *data;
 454     BSTR ret;
 455     int len;
 456
 457     if (!(rsrc = FindResourceW( hmod, L"pac.js", (LPCWSTR)40 ))) return NULL;
 458     size = SizeofResource( hmod, rsrc );
 459     data = LoadResource( hmod, rsrc );
 460
 461     len = MultiByteToWideChar( CP_ACP, 0, data, size, NULL, 0 );
 462     if (!(ret = SysAllocStringLen( NULL, len + lstrlenW( script ) + 1 ))) return NULL;
 463     MultiByteToWideChar( CP_ACP, 0, data, size, ret, len );
 464     lstrcpyW( ret + len, script );
 465     return ret;
 466 }
 467
 468 #ifdef _WIN64
 469 #define IActiveScriptParse_Release IActiveScriptParse64_Release
 470 #define IActiveScriptParse_InitNew IActiveScriptParse64_InitNew
 471 #define IActiveScriptParse_ParseScriptText IActiveScriptParse64_ParseScriptText
 472 #else
 473 #define IActiveScriptParse_Release IActiveScriptParse32_Release
 474 #define IActiveScriptParse_InitNew IActiveScriptParse32_InitNew
 475 #define IActiveScriptParse_ParseScriptText IActiveScriptParse32_ParseScriptText
 476 #endif
 477
 478 static BOOL run_script( const WCHAR *script, const WCHAR *url, const WCHAR *hostname, char **result_str, DWORD *result_len )
 479 {
 480     IActiveScriptParse *parser = NULL;
 481     IActiveScript *engine = NULL;
 482     IDispatch *dispatch = NULL;
 483     BOOL ret = FALSE;
 484     CLSID clsid;
 485     DISPID dispid;
 486     BSTR func = NULL, full_script = NULL;
 487     VARIANT args[2], retval;
 488     DISPPARAMS params;
 489     HRESULT hr, init;
 490
 491     init = CoInitialize( NULL );
 492     hr = CLSIDFromProgID( L"JScript", &clsid );
 493     if (hr != S_OK) goto done;
 494
 495     hr = CoCreateInstance( &clsid, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 496                            &IID_IActiveScript, (void **)&engine );
 497     if (hr != S_OK) goto done;
 498
 499     hr = IActiveScript_QueryInterface( engine, &IID_IActiveScriptParse, (void **)&parser );
 500     if (hr != S_OK) goto done;
 501
 502     hr = IActiveScriptParse_InitNew( parser );
 503     if (hr != S_OK) goto done;
 504
 505     hr = IActiveScript_SetScriptSite( engine, &script_site );
 506     if (hr != S_OK) goto done;
 507
 508     hr = IActiveScript_AddNamedItem( engine, L"global_funcs", SCRIPTITEM_GLOBALMEMBERS );
 509     if (hr != S_OK) goto done;
 510
 511     if (!(full_script = include_pac_utils( script ))) goto done;
 512
 513     hr = IActiveScriptParse_ParseScriptText( parser, full_script, NULL, NULL, NULL, 0, 0, 0, NULL, NULL );
 514     if (hr != S_OK) goto done;
 515
 516     hr = IActiveScript_SetScriptState( engine, SCRIPTSTATE_STARTED );
 517     if (hr != S_OK) goto done;
 518
 519     hr = IActiveScript_GetScriptDispatch( engine, NULL, &dispatch );
 520     if (hr != S_OK) goto done;
 521
 522     if (!(func = SysAllocString( L"FindProxyForURL" ))) goto done;
 523     hr = IDispatch_GetIDsOfNames( dispatch, &IID_NULL, &func, 1, LOCALE_SYSTEM_DEFAULT, &dispid );
 524     if (hr != S_OK) goto done;
 525
 526     V_VT( &args[0] ) = VT_BSTR;
 527     V_BSTR( &args[0] ) = SysAllocString( hostname );
 528     V_VT( &args[1] ) = VT_BSTR;
 529     V_BSTR( &args[1] ) = SysAllocString( url );
 530
 531     params.rgvarg = args;
 532     params.rgdispidNamedArgs = NULL;
 533     params.cArgs = 2;
 534     params.cNamedArgs = 0;
 535     hr = IDispatch_Invoke( dispatch, dispid, &IID_NULL, LOCALE_SYSTEM_DEFAULT, DISPATCH_METHOD,
 536                            &params, &retval, NULL, NULL );
 537     VariantClear( &args[0] );
 538     VariantClear( &args[1] );
 539     if (hr != S_OK)
 540     {
 541         WARN("script failed 0x%08x\n", hr);
 542         goto done;
 543     }
 544     if ((*result_str = strdupWA( V_BSTR( &retval ) )))
 545     {
 546         TRACE( "result: %s\n", debugstr_a(*result_str) );
 547         *result_len = strlen( *result_str ) + 1;
 548         ret = TRUE;
 549     }
 550     VariantClear( &retval );
 551
 552 done:
 553     SysFreeString( full_script );
 554     SysFreeString( func );
 555     if (dispatch) IDispatch_Release( dispatch );
 556     if (parser) IActiveScriptParse_Release( parser );
 557     if (engine) IActiveScript_Release( engine );
 558     if (SUCCEEDED( init )) CoUninitialize();
 559     return ret;
 560 }
 561
 562 /******************************************************************
 563  *      InternetGetProxyInfo (jsproxy.@)
 564  */
 565 BOOL WINAPI InternetGetProxyInfo( LPCSTR url, DWORD len_url, LPCSTR hostname, DWORD len_hostname, LPSTR *proxy,
 566                                   LPDWORD len_proxy )
 567 {
 568     WCHAR *urlW = NULL, *hostnameW = NULL;
 569     BOOL ret = FALSE;
 570
 571     TRACE( "%s, %u, %s, %u, %p, %p\n", debugstr_a(url), len_url, hostname, len_hostname, proxy, len_proxy );
 572
 573     EnterCriticalSection( &cs_jsproxy );
 574
 575     if (!global_script->text)
 576     {
 577         SetLastError( ERROR_CAN_NOT_COMPLETE );
 578         goto done;
 579     }
 580     if (hostname && len_hostname < strlen( hostname ))
 581     {
 582         SetLastError( ERROR_INSUFFICIENT_BUFFER );
 583         goto done;
 584     }
 585     if (!(urlW = strdupAW( url, -1 ))) goto done;
 586     if (hostname && !(hostnameW = strdupAW( hostname, -1 ))) goto done;
 587
 588     TRACE( "%s\n", debugstr_w(global_script->text) );
 589     ret = run_script( global_script->text, urlW, hostnameW, proxy, len_proxy );
 590
 591 done:
 592     heap_free( hostnameW );
 593     heap_free( urlW );
 594     LeaveCriticalSection( &cs_jsproxy );
 595     return ret;
 596 }