reactos/dll/win32/shdocvw/shdocvw_main.c

   1 /*
   2  * SHDOCVW - Internet Explorer Web Control
   3  *
   4  * Copyright 2001 John R. Sheets (for CodeWeavers)
   5  * Copyright 2004 Mike McCormack (for CodeWeavers)
   6  * Copyright 2008 Detlef Riekenberg
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include <config.h>
  24
  25 //#include <stdarg.h>
  26 //#include <stdio.h>
  27
  28 //#include "wine/unicode.h"
  29 #include <wine/debug.h>
  30
  31 #include "shdocvw.h"
  32
  33 #include <winreg.h>
  34 #include <shlwapi.h>
  35 #include <wininet.h>
  36 //#include "isguids.h"
  37
  38 //#include "initguid.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(shdocvw);
  41
  42 LONG SHDOCVW_refCount = 0;
  43
  44 static HMODULE SHDOCVW_hshell32 = 0;
  45 static HINSTANCE ieframe_instance;
  46
  47 static HINSTANCE get_ieframe_instance(void)
  48 {
  49     static const WCHAR ieframe_dllW[] = {'i','e','f','r','a','m','e','.','d','l','l',0};
  50
  51     if(!ieframe_instance)
  52         ieframe_instance = LoadLibraryW(ieframe_dllW);
  53
  54     return ieframe_instance;
  55 }
  56
  57 static HRESULT get_ieframe_object(REFCLSID rclsid, REFIID riid, void **ppv)
  58 {
  59     HINSTANCE ieframe_instance;
  60
  61     static HRESULT (WINAPI *ieframe_DllGetClassObject)(REFCLSID,REFIID,void**);
  62
  63     if(!ieframe_DllGetClassObject) {
  64         ieframe_instance = get_ieframe_instance();
  65         if(!ieframe_instance)
  66             return CLASS_E_CLASSNOTAVAILABLE;
  67
  68         ieframe_DllGetClassObject = (void*)GetProcAddress(ieframe_instance, "DllGetClassObject");
  69         if(!ieframe_DllGetClassObject)
  70             return CLASS_E_CLASSNOTAVAILABLE;
  71     }
  72
  73     return ieframe_DllGetClassObject(rclsid, riid, ppv);
  74 }
  75
  76 /*************************************************************************
  77  *              DllGetClassObject (SHDOCVW.@)
  78  */
  79 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **ppv)
  80 {
  81     TRACE("\n");
  82
  83     if(IsEqualGUID(&CLSID_WebBrowser, rclsid)
  84        || IsEqualGUID(&CLSID_WebBrowser_V1, rclsid)
  85        || IsEqualGUID(&CLSID_InternetShortcut, rclsid)
  86        || IsEqualGUID(&CLSID_CUrlHistory, rclsid)
  87        || IsEqualGUID(&CLSID_TaskbarList, rclsid))
  88         return get_ieframe_object(rclsid, riid, ppv);
  89
  90     /* As a last resort, figure if the CLSID belongs to a 'Shell Instance Object' */
  91     return SHDOCVW_GetShellInstanceObjectClassObject(rclsid, riid, ppv);
  92 }
  93
  94 /***********************************************************************
  95  *          DllRegisterServer (shdocvw.@)
  96  */
  97 HRESULT WINAPI DllRegisterServer(void)
  98 {
  99     TRACE("\n");
 100     return S_OK;
 101 }
 102
 103 /***********************************************************************
 104  *          DllUnregisterServer (shdocvw.@)
 105  */
 106 HRESULT WINAPI DllUnregisterServer(void)
 107 {
 108     TRACE("\n");
 109     return S_OK;
 110 }
 111
 112 /******************************************************************
 113  *             IEWinMain            (SHDOCVW.101)
 114  *
 115  * Only returns on error.
 116  */
 117 DWORD WINAPI IEWinMain(LPSTR szCommandLine, int nShowWindow)
 118 {
 119     DWORD (WINAPI *pIEWinMain)(const WCHAR*,int);
 120     WCHAR *cmdline;
 121     DWORD ret, len;
 122
 123     TRACE("%s %d\n", debugstr_a(szCommandLine), nShowWindow);
 124
 125     pIEWinMain = (void*)GetProcAddress(get_ieframe_instance(), MAKEINTRESOURCEA(101));
 126     if(!pIEWinMain)
 127         ExitProcess(1);
 128
 129     len = MultiByteToWideChar(CP_ACP, 0, szCommandLine, -1, NULL, 0);
 130     cmdline = heap_alloc(len*sizeof(WCHAR));
 131     if(!cmdline)
 132         ExitProcess(1);
 133     MultiByteToWideChar(CP_ACP, 0, szCommandLine, -1, cmdline, len);
 134
 135     ret = pIEWinMain(cmdline, nShowWindow);
 136
 137     heap_free(cmdline);
 138     return ret;
 139 }
 140
 141 /*************************************************************************
 142  * SHDOCVW DllMain
 143  */
 144 BOOL WINAPI DllMain(HINSTANCE hinst, DWORD fdwReason, LPVOID fImpLoad)
 145 {
 146     TRACE("%p 0x%x %p\n", hinst, fdwReason, fImpLoad);
 147     switch (fdwReason)
 148     {
 149         case DLL_PROCESS_ATTACH:
 150         break;
 151     case DLL_PROCESS_DETACH:
 152         if (fImpLoad) break;
 153         if (SHDOCVW_hshell32) FreeLibrary(SHDOCVW_hshell32);
 154         if (ieframe_instance) FreeLibrary(ieframe_instance);
 155         break;
 156     }
 157     return TRUE;
 158 }
 159
 160 /*************************************************************************
 161  *              DllCanUnloadNow (SHDOCVW.@)
 162  */
 163 HRESULT WINAPI DllCanUnloadNow(void)
 164 {
 165     return SHDOCVW_refCount ? S_FALSE : S_OK;
 166 }
 167
 168 /***********************************************************************
 169  *              DllGetVersion (SHDOCVW.@)
 170  */
 171 HRESULT WINAPI DllGetVersion(DLLVERSIONINFO *info)
 172 {
 173     if (info->cbSize != sizeof(DLLVERSIONINFO)) FIXME("support DLLVERSIONINFO2\n");
 174
 175     /* this is what IE6 on Windows 98 reports */
 176     info->dwMajorVersion = 6;
 177     info->dwMinorVersion = 0;
 178     info->dwBuildNumber = 2600;
 179     info->dwPlatformID = DLLVER_PLATFORM_WINDOWS;
 180
 181     return NOERROR;
 182 }
 183
 184 /*************************************************************************
 185  *              DllInstall (SHDOCVW.@)
 186  */
 187 HRESULT WINAPI DllInstall(BOOL bInstall, LPCWSTR cmdline)
 188 {
 189    FIXME("(%s, %s): stub!\n", bInstall ? "TRUE":"FALSE", debugstr_w(cmdline));
 190
 191    return S_OK;
 192 }
 193
 194 /*************************************************************************
 195  * SHDOCVW_LoadShell32
 196  *
 197  * makes sure the handle to shell32 is valid
 198  */
 199 static BOOL SHDOCVW_LoadShell32(void)
 200 {
 201      if (SHDOCVW_hshell32)
 202        return TRUE;
 203      return ((SHDOCVW_hshell32 = LoadLibraryA("shell32.dll")) != NULL);
 204 }
 205
 206 /***********************************************************************
 207  *              @ (SHDOCVW.110)
 208  *
 209  * Called by Win98 explorer.exe main binary, definitely has 0
 210  * parameters.
 211  */
 212 DWORD WINAPI WinList_Init(void)
 213 {
 214     FIXME("(), stub!\n");
 215     return 0x0deadfeed;
 216 }
 217
 218 /***********************************************************************
 219  *              @ (SHDOCVW.118)
 220  *
 221  * Called by Win98 explorer.exe main binary, definitely has only one
 222  * parameter.
 223  */
 224 static BOOL (WINAPI *pShellDDEInit)(BOOL start) = NULL;
 225
 226 BOOL WINAPI ShellDDEInit(BOOL start)
 227 {
 228     TRACE("(%d)\n", start);
 229
 230     if (!pShellDDEInit)
 231     {
 232       if (!SHDOCVW_LoadShell32())
 233         return FALSE;
 234       pShellDDEInit = (void *)GetProcAddress(SHDOCVW_hshell32, (LPCSTR)188);
 235     }
 236
 237     if (pShellDDEInit)
 238       return pShellDDEInit(start);
 239     else
 240       return FALSE;
 241 }
 242
 243 /***********************************************************************
 244  *              @ (SHDOCVW.125)
 245  *
 246  * Called by Win98 explorer.exe main binary, definitely has 0
 247  * parameters.
 248  */
 249 DWORD WINAPI RunInstallUninstallStubs(void)
 250 {
 251     FIXME("(), stub!\n");
 252     return 0x0deadbee;
 253 }
 254
 255 /***********************************************************************
 256  *              @ (SHDOCVW.130)
 257  *
 258  * Called by Emerge Desktop (alternative Windows Shell).
 259  */
 260 DWORD WINAPI RunInstallUninstallStubs2(void)
 261 {
 262     FIXME("(), stub!\n");
 263     return 0x0deadbee;
 264 }
 265
 266 /***********************************************************************
 267  *              SetQueryNetSessionCount (SHDOCVW.@)
 268  */
 269 DWORD WINAPI SetQueryNetSessionCount(DWORD arg)
 270 {
 271     FIXME("(%u), stub!\n", arg);
 272     return 0;
 273 }
 274
 275 /**********************************************************************
 276  * Some forwards (by ordinal) to SHLWAPI
 277  */
 278
 279 static void* fetch_shlwapi_ordinal(UINT_PTR ord)
 280 {
 281     static const WCHAR shlwapiW[] = {'s','h','l','w','a','p','i','.','d','l','l','\0'};
 282     static HANDLE h;
 283
 284     if (!h && !(h = GetModuleHandleW(shlwapiW))) return NULL;
 285     return (void*)GetProcAddress(h, (const char*)ord);
 286 }
 287
 288 /******************************************************************
 289  *              WhichPlatformFORWARD            (SHDOCVW.@)
 290  */
 291 DWORD WINAPI WhichPlatformFORWARD(void)
 292 {
 293     static DWORD (WINAPI *p)(void);
 294
 295     if (p || (p = fetch_shlwapi_ordinal(276))) return p();
 296     return 1; /* not integrated, see shlwapi.WhichPlatform */
 297 }
 298
 299 /******************************************************************
 300  *              StopWatchModeFORWARD            (SHDOCVW.@)
 301  */
 302 void WINAPI StopWatchModeFORWARD(void)
 303 {
 304     static void (WINAPI *p)(void);
 305
 306     if (p || (p = fetch_shlwapi_ordinal(241))) p();
 307 }
 308
 309 /******************************************************************
 310  *              StopWatchFlushFORWARD            (SHDOCVW.@)
 311  */
 312 void WINAPI StopWatchFlushFORWARD(void)
 313 {
 314     static void (WINAPI *p)(void);
 315
 316     if (p || (p = fetch_shlwapi_ordinal(242))) p();
 317 }
 318
 319 /******************************************************************
 320  *              StopWatchWFORWARD            (SHDOCVW.@)
 321  */
 322 DWORD WINAPI StopWatchWFORWARD(DWORD dwClass, LPCWSTR lpszStr, DWORD dwUnknown,
 323                                DWORD dwMode, DWORD dwTimeStamp)
 324 {
 325     static DWORD (WINAPI *p)(DWORD, LPCWSTR, DWORD, DWORD, DWORD);
 326
 327     if (p || (p = fetch_shlwapi_ordinal(243)))
 328         return p(dwClass, lpszStr, dwUnknown, dwMode, dwTimeStamp);
 329     return ERROR_CALL_NOT_IMPLEMENTED;
 330 }
 331
 332 /******************************************************************
 333  *              StopWatchAFORWARD            (SHDOCVW.@)
 334  */
 335 DWORD WINAPI StopWatchAFORWARD(DWORD dwClass, LPCSTR lpszStr, DWORD dwUnknown,
 336                                DWORD dwMode, DWORD dwTimeStamp)
 337 {
 338     static DWORD (WINAPI *p)(DWORD, LPCSTR, DWORD, DWORD, DWORD);
 339
 340     if (p || (p = fetch_shlwapi_ordinal(244)))
 341         return p(dwClass, lpszStr, dwUnknown, dwMode, dwTimeStamp);
 342     return ERROR_CALL_NOT_IMPLEMENTED;
 343 }
 344
 345 /******************************************************************
 346  *  URLSubRegQueryA (SHDOCVW.151)
 347  */
 348 HRESULT WINAPI URLSubRegQueryA(LPCSTR regpath, LPCSTR name, DWORD type,
 349                                LPSTR out, DWORD outlen, DWORD unknown)
 350 {
 351     CHAR buffer[INTERNET_MAX_URL_LENGTH];
 352     DWORD len;
 353     LONG res;
 354
 355     TRACE("(%s, %s, %d, %p, %d, %d)\n", debugstr_a(regpath), debugstr_a(name),
 356             type, out, outlen, unknown);
 357
 358     if (!out) return S_OK;
 359
 360     len = sizeof(buffer);
 361     res = SHRegGetUSValueA(regpath, name, NULL, buffer,  &len, FALSE, NULL, 0);
 362     if (!res) {
 363         lstrcpynA(out, buffer, outlen);
 364         return S_OK;
 365     }
 366
 367     return E_FAIL;
 368 }
 369
 370 /******************************************************************
 371  *  ParseURLFromOutsideSourceW (SHDOCVW.170)
 372  */
 373 DWORD WINAPI ParseURLFromOutsideSourceW(LPCWSTR url, LPWSTR out, LPDWORD plen, LPDWORD unknown)
 374 {
 375     WCHAR buffer_in[INTERNET_MAX_URL_LENGTH];
 376     WCHAR buffer_out[INTERNET_MAX_URL_LENGTH];
 377     LPCWSTR ptr = url;
 378     HRESULT hr;
 379     DWORD needed;
 380     DWORD len;
 381     DWORD res = 0;
 382
 383
 384     TRACE("(%s, %p, %p, %p) len: %d, unknown: 0x%x\n", debugstr_w(url), out, plen, unknown,
 385             plen ? *plen : 0, unknown ? *unknown : 0);
 386
 387     if (!PathIsURLW(ptr)) {
 388         len = sizeof(buffer_in) / sizeof(buffer_in[0]);
 389         buffer_in[0] = 0;
 390         hr = UrlApplySchemeW(ptr, buffer_in, &len, URL_APPLY_GUESSSCHEME | URL_APPLY_DEFAULT);
 391         TRACE("got 0x%x with %s\n", hr, debugstr_w(buffer_in));
 392         if (hr == S_OK) {
 393             /* we parsed the url to buffer_in */
 394             ptr = buffer_in;
 395         }
 396         else
 397         {
 398             FIXME("call search hook for %s\n", debugstr_w(ptr));
 399         }
 400     }
 401
 402     len = sizeof(buffer_out) / sizeof(buffer_out[0]);
 403     buffer_out[0] = '\0';
 404     hr = UrlCanonicalizeW(ptr, buffer_out, &len, URL_ESCAPE_SPACES_ONLY);
 405     needed = lstrlenW(buffer_out)+1;
 406     TRACE("got 0x%x with %s (need %d)\n", hr, debugstr_w(buffer_out), needed);
 407
 408     if (*plen >= needed) {
 409         if (out != NULL) {
 410             lstrcpyW(out, buffer_out);
 411             res++;
 412         }
 413         needed--;
 414     }
 415
 416     *plen = needed;
 417
 418     TRACE("=> %d\n", res);
 419     return res;
 420 }
 421
 422 /******************************************************************
 423  *  ParseURLFromOutsideSourceA (SHDOCVW.169)
 424  *
 425  * See ParseURLFromOutsideSourceW
 426  */
 427 DWORD WINAPI ParseURLFromOutsideSourceA(LPCSTR url, LPSTR out, LPDWORD plen, LPDWORD unknown)
 428 {
 429     WCHAR buffer[INTERNET_MAX_URL_LENGTH];
 430     LPWSTR urlW = NULL;
 431     DWORD needed;
 432     DWORD res;
 433     DWORD len;
 434
 435     TRACE("(%s, %p, %p, %p) len: %d, unknown: 0x%x\n", debugstr_a(url), out, plen, unknown,
 436             plen ? *plen : 0, unknown ? *unknown : 0);
 437
 438     if (url) {
 439         len = MultiByteToWideChar(CP_ACP, 0, url, -1, NULL, 0);
 440         urlW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
 441         MultiByteToWideChar(CP_ACP, 0, url, -1, urlW, len);
 442     }
 443
 444     len = sizeof(buffer) / sizeof(buffer[0]);
 445     ParseURLFromOutsideSourceW(urlW, buffer, &len, unknown);
 446     HeapFree(GetProcessHeap(), 0, urlW);
 447
 448     needed = WideCharToMultiByte(CP_ACP, 0, buffer, -1, NULL, 0, NULL, NULL);
 449
 450     res = 0;
 451     if (*plen >= needed) {
 452         if (out != NULL) {
 453             WideCharToMultiByte(CP_ACP, 0, buffer, -1, out, *plen, NULL, NULL);
 454             res = needed;
 455         }
 456         needed--;
 457     }
 458
 459     *plen = needed;
 460
 461     TRACE("=> %d\n", res);
 462     return res;
 463 }
 464
 465 /******************************************************************
 466  *  IEParseDisplayNameWithBCW (SHDOCVW.218)
 467  */
 468 HRESULT WINAPI IEParseDisplayNameWithBCW(DWORD codepage, LPCWSTR lpszDisplayName, LPBC pbc, LPITEMIDLIST *ppidl)
 469 {
 470     /* Guessing at parameter 3 based on IShellFolder's  ParseDisplayName */
 471     FIXME("stub: 0x%x %s %p %p\n",codepage,debugstr_w(lpszDisplayName),pbc,ppidl);
 472     return E_FAIL;
 473 }
 474
 475 /******************************************************************
 476  *  SHRestricted2W (SHDOCVW.159)
 477  */
 478 DWORD WINAPI SHRestricted2W(DWORD res, LPCWSTR url, DWORD reserved)
 479 {
 480     FIXME("(%d %s %d) stub\n", res, debugstr_w(url), reserved);
 481     return 0;
 482 }
 483
 484 /******************************************************************
 485  * SHRestricted2A (SHDOCVW.158)
 486  *
 487  * See SHRestricted2W
 488  */
 489 DWORD WINAPI SHRestricted2A(DWORD restriction, LPCSTR url, DWORD reserved)
 490 {
 491     LPWSTR urlW = NULL;
 492     DWORD res;
 493
 494     TRACE("(%d, %s, %d)\n", restriction, debugstr_a(url), reserved);
 495     if (url) {
 496         DWORD len = MultiByteToWideChar(CP_ACP, 0, url, -1, NULL, 0);
 497         urlW = heap_alloc(len * sizeof(WCHAR));
 498         MultiByteToWideChar(CP_ACP, 0, url, -1, urlW, len);
 499     }
 500     res = SHRestricted2W(restriction, urlW, reserved);
 501     heap_free(urlW);
 502     return res;
 503 }
 504
 505 /******************************************************************
 506  * ImportPrivacySettings (SHDOCVW.@)
 507  *
 508  * Import global and/or per site privacy preferences from an xml file
 509  *
 510  * PARAMS
 511  *  filename      [I] XML file to use
 512  *  pGlobalPrefs  [IO] PTR to a usage flag for the global privacy preferences
 513  *  pPerSitePrefs [IO] PTR to a usage flag for the per site privacy preferences
 514  *
 515  * RETURNS
 516  *  Success: TRUE  (the privacy preferences where updated)
 517  *  Failure: FALSE (the privacy preferences are unchanged)
 518  *
 519  * NOTES
 520  *  Set the flag to TRUE, when the related privacy preferences in the xml file
 521  *  should be used (parsed and overwrite the current settings).
 522  *  On return, the flag is TRUE, when the related privacy settings where used
 523  *
 524  */
 525 BOOL WINAPI ImportPrivacySettings(LPCWSTR filename, BOOL *pGlobalPrefs, BOOL * pPerSitePrefs)
 526 {
 527     FIXME("(%s, %p->%d, %p->%d): stub\n", debugstr_w(filename),
 528         pGlobalPrefs, pGlobalPrefs ? *pGlobalPrefs : 0,
 529         pPerSitePrefs, pPerSitePrefs ? *pPerSitePrefs : 0);
 530
 531     if (pGlobalPrefs) *pGlobalPrefs = FALSE;
 532     if (pPerSitePrefs) *pPerSitePrefs = FALSE;
 533
 534     return TRUE;
 535 }