urlmon_main.c 26.9 KB
Newer Older
1 2 3 4 5
/*
 * UrlMon
 *
 * Copyright (c) 2000 Patrik Stridvall
 *
6 7 8 9 10 11 12 13 14 15 16 17
 * 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
18
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 20
 */

21 22
#include <stdarg.h>

Jacek Caban's avatar
Jacek Caban committed
23
#include "urlmon_main.h"
24

25 26
#include "winreg.h"

27 28
#define NO_SHLWAPI_REG
#include "shlwapi.h"
29 30
#include "advpub.h"

31
#include "wine/debug.h"
32

33
#include "urlmon.h"
34 35 36

WINE_DEFAULT_DEBUG_CHANNEL(urlmon);

37 38
LONG URLMON_refCount = 0;

39
static HMODULE hCabinet = NULL;
40
static DWORD urlmon_tls = TLS_OUT_OF_INDEXES;
41

42 43
static void init_session(BOOL);

44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
static struct list tls_list = LIST_INIT(tls_list);

static CRITICAL_SECTION tls_cs;
static CRITICAL_SECTION_DEBUG tls_cs_dbg =
{
    0, 0, &tls_cs,
    { &tls_cs_dbg.ProcessLocksList, &tls_cs_dbg.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": tls") }
};

static CRITICAL_SECTION tls_cs = { &tls_cs_dbg, -1, 0, 0, 0, 0 };

tls_data_t *get_tls_data(void)
{
    tls_data_t *data;

60
    if(urlmon_tls == TLS_OUT_OF_INDEXES) {
61
        DWORD tls = TlsAlloc();
62 63 64 65
        if(tls == TLS_OUT_OF_INDEXES)
            return NULL;

        tls = InterlockedCompareExchange((LONG*)&urlmon_tls, tls, TLS_OUT_OF_INDEXES);
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
        if(tls != urlmon_tls)
            TlsFree(tls);
    }

    data = TlsGetValue(urlmon_tls);
    if(!data) {
        data = heap_alloc_zero(sizeof(tls_data_t));
        if(!data)
            return NULL;

        EnterCriticalSection(&tls_cs);
        list_add_tail(&tls_list, &data->entry);
        LeaveCriticalSection(&tls_cs);

        TlsSetValue(urlmon_tls, data);
    }

    return data;
}

static void free_tls_list(void)
{
    tls_data_t *data;

90
    if(urlmon_tls == TLS_OUT_OF_INDEXES)
91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
        return;

    while(!list_empty(&tls_list)) {
        data = LIST_ENTRY(list_head(&tls_list), tls_data_t, entry);
        list_remove(&data->entry);
        heap_free(data);
    }

    TlsFree(urlmon_tls);
}

static void detach_thread(void)
{
    tls_data_t *data;

106
    if(urlmon_tls == TLS_OUT_OF_INDEXES)
107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
        return;

    data = TlsGetValue(urlmon_tls);
    if(!data)
        return;

    EnterCriticalSection(&tls_cs);
    list_remove(&data->entry);
    LeaveCriticalSection(&tls_cs);

    if(data->notif_hwnd) {
        WARN("notif_hwnd not destroyed\n");
        DestroyWindow(data->notif_hwnd);
    }

    heap_free(data);
}

125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
static void process_detach(void)
{
    HINTERNET internet_session;

    internet_session = get_internet_session(NULL);
    if(internet_session)
        InternetCloseHandle(internet_session);

    if (hCabinet)
        FreeLibrary(hCabinet);

    init_session(FALSE);
    free_session();
    free_tls_list();
}

141
/***********************************************************************
142
 *		DllMain (URLMON.init)
143
 */
144
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
145
{
146
    TRACE("%p 0x%x %p\n", hinstDLL, fdwReason, fImpLoad);
147

148 149
    URLMON_DllMain( hinstDLL, fdwReason, fImpLoad );

150 151
    switch(fdwReason) {
    case DLL_PROCESS_ATTACH:
152
        init_session(TRUE);
153
        break;
154 155

    case DLL_PROCESS_DETACH:
156 157
        process_detach();
        break;
158 159 160 161

    case DLL_THREAD_DETACH:
        detach_thread();
        break;
162 163 164 165
    }
    return TRUE;
}

166 167

/***********************************************************************
Patrik Stridvall's avatar
Patrik Stridvall committed
168
 *		DllInstall (URLMON.@)
169
 */
170
HRESULT WINAPI DllInstall(BOOL bInstall, LPCWSTR cmdline)
171
{
172
  FIXME("(%s, %s): stub\n", bInstall?"TRUE":"FALSE",
173 174 175 176 177
	debugstr_w(cmdline));

  return S_OK;
}

178 179 180
/***********************************************************************
 *		DllCanUnloadNow (URLMON.@)
 */
181
HRESULT WINAPI DllCanUnloadNow(void)
182
{
183
    return URLMON_refCount != 0 ? S_FALSE : S_OK;
184 185
}

186 187 188 189


/******************************************************************************
 * Urlmon ClassFactory
190
 */
191
typedef struct {
192
    IClassFactory IClassFactory_iface;
193 194

    HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj);
195
} ClassFactory;
196

197 198 199 200
static inline ClassFactory *impl_from_IClassFactory(IClassFactory *iface)
{
    return CONTAINING_RECORD(iface, ClassFactory, IClassFactory_iface);
}
201

202
static HRESULT WINAPI CF_QueryInterface(IClassFactory *iface, REFIID riid, LPVOID *ppv)
203
{
204 205 206 207 208 209 210 211 212
    *ppv = NULL;

    if(IsEqualGUID(riid, &IID_IUnknown)) {
        TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
        *ppv = iface;
    }else if(IsEqualGUID(riid, &IID_IClassFactory)) {
        TRACE("(%p)->(IID_IClassFactory %p)\n", iface, ppv);
        *ppv = iface;
    }
213

214 215
    if(*ppv) {
	IUnknown_AddRef((IUnknown*)*ppv);
216 217 218
	return S_OK;
    }

219
    WARN("(%p)->(%s,%p),not found\n", iface, debugstr_guid(riid), ppv);
220 221 222
    return E_NOINTERFACE;
}

223
static ULONG WINAPI CF_AddRef(IClassFactory *iface)
224
{
225 226
    URLMON_LockModule();
    return 2;
227 228
}

229
static ULONG WINAPI CF_Release(IClassFactory *iface)
230
{
231 232
    URLMON_UnlockModule();
    return 1;
233 234
}

235

236
static HRESULT WINAPI CF_CreateInstance(IClassFactory *iface, IUnknown *pOuter,
237 238
                                        REFIID riid, LPVOID *ppobj)
{
239
    ClassFactory *This = impl_from_IClassFactory(iface);
240 241 242 243 244 245 246 247 248 249 250 251 252 253 254
    HRESULT hres;
    LPUNKNOWN punk;
    
    TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);

    *ppobj = NULL;
    if(SUCCEEDED(hres = This->pfnCreateInstance(pOuter, (LPVOID *) &punk))) {
        hres = IUnknown_QueryInterface(punk, riid, ppobj);
        IUnknown_Release(punk);
    }
    return hres;
}

static HRESULT WINAPI CF_LockServer(LPCLASSFACTORY iface,BOOL dolock)
{
255 256 257 258 259 260 261
    TRACE("(%d)\n", dolock);

    if (dolock)
	   URLMON_LockModule();
    else
	   URLMON_UnlockModule();

262 263 264
    return S_OK;
}

265
static const IClassFactoryVtbl ClassFactoryVtbl =
266 267 268 269 270 271 272 273
{
    CF_QueryInterface,
    CF_AddRef,
    CF_Release,
    CF_CreateInstance,
    CF_LockServer
};

274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294
static ClassFactory FileProtocolCF =
    { { &ClassFactoryVtbl }, FileProtocol_Construct};
static ClassFactory FtpProtocolCF =
    { { &ClassFactoryVtbl }, FtpProtocol_Construct};
static ClassFactory GopherProtocolCF =
    { { &ClassFactoryVtbl }, GopherProtocol_Construct};
static ClassFactory HttpProtocolCF =
    { { &ClassFactoryVtbl }, HttpProtocol_Construct};
static ClassFactory HttpSProtocolCF =
    { { &ClassFactoryVtbl }, HttpSProtocol_Construct};
static ClassFactory MkProtocolCF =
    { { &ClassFactoryVtbl }, MkProtocol_Construct};
static ClassFactory SecurityManagerCF =
    { { &ClassFactoryVtbl }, SecManagerImpl_Construct};
static ClassFactory ZoneManagerCF =
    { { &ClassFactoryVtbl }, ZoneMgrImpl_Construct};
static ClassFactory StdURLMonikerCF =
    { { &ClassFactoryVtbl }, StdURLMoniker_Construct};
static ClassFactory MimeFilterCF =
    { { &ClassFactoryVtbl }, MimeFilter_Construct};

295 296 297 298
struct object_creation_info
{
    const CLSID *clsid;
    IClassFactory *cf;
299
    LPCWSTR protocol;
300 301
};

302 303
static const WCHAR wszFile[] = {'f','i','l','e',0};
static const WCHAR wszFtp[]  = {'f','t','p',0};
304
static const WCHAR wszGopher[]  = {'g','o','p','h','e','r',0};
305
static const WCHAR wszHttp[] = {'h','t','t','p',0};
306
static const WCHAR wszHttps[] = {'h','t','t','p','s',0};
307
static const WCHAR wszMk[]   = {'m','k',0};
308

309 310
static const struct object_creation_info object_creation[] =
{
311 312 313 314 315 316 317 318 319 320
    { &CLSID_FileProtocol,            &FileProtocolCF.IClassFactory_iface,    wszFile },
    { &CLSID_FtpProtocol,             &FtpProtocolCF.IClassFactory_iface,     wszFtp  },
    { &CLSID_GopherProtocol,          &GopherProtocolCF.IClassFactory_iface,  wszGopher },
    { &CLSID_HttpProtocol,            &HttpProtocolCF.IClassFactory_iface,    wszHttp },
    { &CLSID_HttpSProtocol,           &HttpSProtocolCF.IClassFactory_iface,   wszHttps },
    { &CLSID_MkProtocol,              &MkProtocolCF.IClassFactory_iface,      wszMk },
    { &CLSID_InternetSecurityManager, &SecurityManagerCF.IClassFactory_iface, NULL    },
    { &CLSID_InternetZoneManager,     &ZoneManagerCF.IClassFactory_iface,     NULL    },
    { &CLSID_StdURLMoniker,           &StdURLMonikerCF.IClassFactory_iface,   NULL    },
    { &CLSID_DeCompMimeFilter,        &MimeFilterCF.IClassFactory_iface,      NULL    }
321 322
};

323 324
static void init_session(BOOL init)
{
325
    unsigned int i;
326 327 328

    for(i=0; i < sizeof(object_creation)/sizeof(object_creation[0]); i++) {

329 330 331 332
        if(object_creation[i].protocol)
            register_urlmon_namespace(object_creation[i].cf, object_creation[i].clsid,
                                      object_creation[i].protocol, init);
    }
333 334
}

335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
/*******************************************************************************
 * DllGetClassObject [URLMON.@]
 * Retrieves class object from a DLL object
 *
 * NOTES
 *    Docs say returns STDAPI
 *
 * PARAMS
 *    rclsid [I] CLSID for the class object
 *    riid   [I] Reference to identifier of interface for class object
 *    ppv    [O] Address of variable to receive interface pointer for riid
 *
 * RETURNS
 *    Success: S_OK
 *    Failure: CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, E_INVALIDARG,
 *             E_UNEXPECTED
 */

353
HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
354
{
355
    unsigned int i;
356
    HRESULT hr;
357 358 359 360 361 362
    
    TRACE("(%s,%s,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
    
    for (i=0; i < sizeof(object_creation)/sizeof(object_creation[0]); i++)
    {
	if (IsEqualGUID(object_creation[i].clsid, rclsid))
363
	    return IClassFactory_QueryInterface(object_creation[i].cf, riid, ppv);
364 365
    }

366 367 368 369
    hr = URLMON_DllGetClassObject(rclsid, riid, ppv);
    if(SUCCEEDED(hr))
        return hr;

370 371
    FIXME("%s: no class found.\n", debugstr_guid(rclsid));
    return CLASS_E_CLASSNOTAVAILABLE;
372 373
}

374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
static HRESULT register_inf(BOOL doregister)
{
    HRESULT (WINAPI *pRegInstall)(HMODULE hm, LPCSTR pszSection, const STRTABLEA* pstTable);
    HMODULE hAdvpack;

    static const WCHAR wszAdvpack[] = {'a','d','v','p','a','c','k','.','d','l','l',0};

    hAdvpack = LoadLibraryW(wszAdvpack);
    pRegInstall = (void *)GetProcAddress(hAdvpack, "RegInstall");

    return pRegInstall(hProxyDll, doregister ? "RegisterDll" : "UnregisterDll", NULL);
}

/***********************************************************************
 *		DllRegisterServer (URLMON.@)
 */
HRESULT WINAPI DllRegisterServer(void)
{
    HRESULT hr;

    TRACE("\n");

    hr = URLMON_DllRegisterServer();
    return SUCCEEDED(hr) ? register_inf(TRUE) : hr;
}

/***********************************************************************
 *		DllUnregisterServer (URLMON.@)
 */
HRESULT WINAPI DllUnregisterServer(void)
{
    HRESULT hr;

    TRACE("\n");

    hr = URLMON_DllUnregisterServer();
    return SUCCEEDED(hr) ? register_inf(FALSE) : hr;
}
412

413 414 415
/***********************************************************************
 *		DllRegisterServerEx (URLMON.@)
 */
416
HRESULT WINAPI DllRegisterServerEx(void)
417 418 419 420 421 422
{
    FIXME("(void): stub\n");

    return E_FAIL;
}

423 424 425 426 427 428
/**************************************************************************
 *                 IsValidURL (URLMON.@)
 * 
 * Determines if a specified string is a valid URL.
 *
 * PARAMS
429
 *  pBC        [I] ignored, should be NULL.
430 431 432 433 434 435 436 437 438 439 440 441 442
 *  szURL      [I] string that represents the URL in question.
 *  dwReserved [I] reserved and must be zero.
 *
 * RETURNS
 *  Success: S_OK.
 *  Failure: S_FALSE.
 *  returns E_INVALIDARG if one or more of the args is invalid.
 *
 * TODO:
 *  test functionality against windows to see what a valid URL is.
 */
HRESULT WINAPI IsValidURL(LPBC pBC, LPCWSTR szURL, DWORD dwReserved)
{
443
    FIXME("(%p, %s, %d): stub\n", pBC, debugstr_w(szURL), dwReserved);
444

445
    if (dwReserved || !szURL)
446
        return E_INVALIDARG;
447

448 449
    return S_OK;
}
450 451 452 453 454 455 456 457 458

/**************************************************************************
 *                 FaultInIEFeature (URLMON.@)
 *
 *  Undocumented.  Appears to be used by native shdocvw.dll.
 */
HRESULT WINAPI FaultInIEFeature( HWND hwnd, uCLSSPEC * pClassSpec,
                                 QUERYCONTEXT *pQuery, DWORD flags )
{
459
    FIXME("%p %p %p %08x\n", hwnd, pClassSpec, pQuery, flags);
460 461
    return E_NOTIMPL;
}
462 463 464 465 466 467 468

/**************************************************************************
 *                 CoGetClassObjectFromURL (URLMON.@)
 */
HRESULT WINAPI CoGetClassObjectFromURL( REFCLSID rclsid, LPCWSTR szCodeURL, DWORD dwFileVersionMS,
                                        DWORD dwFileVersionLS, LPCWSTR szContentType,
                                        LPBINDCTX pBindCtx, DWORD dwClsContext, LPVOID pvReserved,
469
                                        REFIID riid, LPVOID *ppv )
470
{
471
    FIXME("(%s %s %d %d %s %p %d %p %s %p) Stub!\n", debugstr_guid(rclsid), debugstr_w(szCodeURL),
472 473 474 475
	dwFileVersionMS, dwFileVersionLS, debugstr_w(szContentType), pBindCtx, dwClsContext, pvReserved,
	debugstr_guid(riid), ppv);
    return E_NOINTERFACE;
}
476 477 478 479 480 481 482 483 484 485 486 487 488 489

/***********************************************************************
 *           ReleaseBindInfo (URLMON.@)
 *
 * Release the resources used by the specified BINDINFO structure.
 *
 * PARAMS
 *  pbindinfo [I] BINDINFO to release.
 *
 * RETURNS
 *  Nothing.
 */
void WINAPI ReleaseBindInfo(BINDINFO* pbindinfo)
{
490 491
    DWORD size;

492 493
    TRACE("(%p)\n", pbindinfo);

494
    if(!pbindinfo || !(size = pbindinfo->cbSize))
495 496 497
        return;

    CoTaskMemFree(pbindinfo->szExtraInfo);
498 499 500 501
    ReleaseStgMedium(&pbindinfo->stgmedData);

    if(offsetof(BINDINFO, szExtraInfo) < size)
        CoTaskMemFree(pbindinfo->szCustomVerb);
502

503
    if(pbindinfo->pUnk && offsetof(BINDINFO, pUnk) < size)
504
        IUnknown_Release(pbindinfo->pUnk);
505 506 507

    memset(pbindinfo, 0, size);
    pbindinfo->cbSize = size;
508
}
509

510 511 512 513 514 515 516 517 518 519
/***********************************************************************
 *           CopyStgMedium (URLMON.@)
 */
HRESULT WINAPI CopyStgMedium(const STGMEDIUM *src, STGMEDIUM *dst)
{
    TRACE("(%p %p)\n", src, dst);

    if(!src || !dst)
        return E_POINTER;

520
    *dst = *src;
521 522 523 524

    switch(dst->tymed) {
    case TYMED_NULL:
        break;
525 526 527 528 529 530 531
    case TYMED_FILE:
        if(src->u.lpszFileName && !src->pUnkForRelease) {
            DWORD size = (strlenW(src->u.lpszFileName)+1)*sizeof(WCHAR);
            dst->u.lpszFileName = CoTaskMemAlloc(size);
            memcpy(dst->u.lpszFileName, src->u.lpszFileName, size);
        }
        break;
532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
    case TYMED_ISTREAM:
        if(dst->u.pstm)
            IStream_AddRef(dst->u.pstm);
        break;
    case TYMED_ISTORAGE:
        if(dst->u.pstg)
            IStorage_AddRef(dst->u.pstg);
        break;
    default:
        FIXME("Unimplemented tymed %d\n", src->tymed);
    }

    if(dst->pUnkForRelease)
        IUnknown_AddRef(dst->pUnkForRelease);

    return S_OK;
}

550 551 552 553
static BOOL text_richtext_filter(const BYTE *b, DWORD size)
{
    return size > 5 && !memcmp(b, "{\\rtf", 5);
}
554

555
static BOOL text_html_filter(const BYTE *b, DWORD size)
556
{
557
    DWORD i;
558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573

    if(size < 5)
        return FALSE;

    for(i=0; i < size-5; i++) {
        if(b[i] == '<'
           && (b[i+1] == 'h' || b[i+1] == 'H')
           && (b[i+2] == 't' || b[i+2] == 'T')
           && (b[i+3] == 'm' || b[i+3] == 'M')
           && (b[i+4] == 'l' || b[i+4] == 'L'))
            return TRUE;
    }

    return FALSE;
}

574 575 576 577 578 579
static BOOL audio_basic_filter(const BYTE *b, DWORD size)
{
    return size > 4
        && b[0] == '.' && b[1] == 's' && b[2] == 'n' && b[3] == 'd';
}

580 581 582 583 584 585 586
static BOOL audio_wav_filter(const BYTE *b, DWORD size)
{
    return size > 12
        && b[0] == 'R' && b[1] == 'I' && b[2] == 'F' && b[3] == 'F'
        && b[8] == 'W' && b[9] == 'A' && b[10] == 'V' && b[11] == 'E';
}

587
static BOOL image_gif_filter(const BYTE *b, DWORD size)
588 589 590 591 592 593 594 595 596 597
{
    return size >= 6
        && (b[0] == 'G' || b[0] == 'g')
        && (b[1] == 'I' || b[1] == 'i')
        && (b[2] == 'F' || b[2] == 'f')
        &&  b[3] == '8'
        && (b[4] == '7' || b[4] == '9')
        && (b[5] == 'A' || b[5] == 'a');
}

598
static BOOL image_pjpeg_filter(const BYTE *b, DWORD size)
599
{
Jacek Caban's avatar
Jacek Caban committed
600
    return size > 2 && b[0] == 0xff && b[1] == 0xd8;
601 602
}

603
static BOOL image_tiff_filter(const BYTE *b, DWORD size)
604
{
Jacek Caban's avatar
Jacek Caban committed
605
    return size > 2 && b[0] == 0x4d && b[1] == 0x4d;
606 607
}

608
static BOOL image_xpng_filter(const BYTE *b, DWORD size)
609 610
{
    static const BYTE xpng_header[] = {0x89,'P','N','G',0x0d,0x0a,0x1a,0x0a};
Jacek Caban's avatar
Jacek Caban committed
611
    return size > sizeof(xpng_header) && !memcmp(b, xpng_header, sizeof(xpng_header));
612 613
}

614
static BOOL image_bmp_filter(const BYTE *b, DWORD size)
615 616
{
    return size >= 14
Jacek Caban's avatar
Jacek Caban committed
617
        && b[0] == 0x42 && b[1] == 0x4d
618
        && *(const DWORD *)(b+6) == 0;
619 620
}

621
static BOOL video_avi_filter(const BYTE *b, DWORD size)
622 623 624 625 626 627
{
    return size > 12
        && b[0] == 'R' && b[1] == 'I' && b[2] == 'F' && b[3] == 'F'
        && b[8] == 'A' && b[9] == 'V' && b[10] == 'I' && b[11] == 0x20;
}

628
static BOOL video_mpeg_filter(const BYTE *b, DWORD size)
629 630 631 632 633 634
{
    return size > 4
        && !b[0] && !b[1] && b[2] == 0x01
        && (b[3] == 0xb3 || b[3] == 0xba);
}

635 636 637 638 639
static BOOL application_postscript_filter(const BYTE *b, DWORD size)
{
    return size > 2 && b[0] == '%' && b[1] == '!';
}

640
static BOOL application_pdf_filter(const BYTE *b, DWORD size)
641 642 643 644
{
    return size > 4 && b[0] == 0x25 && b[1] == 0x50 && b[2] == 0x44 && b[3] == 0x46;
}

645
static BOOL application_xzip_filter(const BYTE *b, DWORD size)
646 647 648 649
{
    return size > 2 && b[0] == 0x50 && b[1] == 0x4b;
}

650
static BOOL application_xgzip_filter(const BYTE *b, DWORD size)
651 652 653 654
{
    return size > 2 && b[0] == 0x1f && b[1] == 0x8b;
}

655
static BOOL application_java_filter(const BYTE *b, DWORD size)
656 657 658 659
{
    return size > 4 && b[0] == 0xca && b[1] == 0xfe && b[2] == 0xba && b[3] == 0xbe;
}

660
static BOOL application_xmsdownload(const BYTE *b, DWORD size)
661 662 663 664
{
    return size > 2 && b[0] == 'M' && b[1] == 'Z';
}

665
static BOOL text_plain_filter(const BYTE *b, DWORD size)
666
{
Jacek Caban's avatar
Jacek Caban committed
667
    const BYTE *ptr;
668

Jacek Caban's avatar
Jacek Caban committed
669
    for(ptr = b; ptr < b+size-1; ptr++) {
670 671 672 673 674 675 676
        if(*ptr < 0x20 && *ptr != '\n' && *ptr != '\r' && *ptr != '\t')
            return FALSE;
    }

    return TRUE;
}

677
static BOOL application_octet_stream_filter(const BYTE *b, DWORD size)
678 679 680 681
{
    return TRUE;
}

682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
static HRESULT find_mime_from_buffer(const BYTE *buf, DWORD size, const WCHAR *proposed_mime, WCHAR **ret_mime)
{
    LPCWSTR ret = NULL;
    DWORD len, i;

    static const WCHAR text_htmlW[] = {'t','e','x','t','/','h','t','m','l',0};
    static const WCHAR text_richtextW[] = {'t','e','x','t','/','r','i','c','h','t','e','x','t',0};
    static const WCHAR audio_basicW[] = {'a','u','d','i','o','/','b','a','s','i','c',0};
    static const WCHAR audio_wavW[] = {'a','u','d','i','o','/','w','a','v',0};
    static const WCHAR image_gifW[] = {'i','m','a','g','e','/','g','i','f',0};
    static const WCHAR image_pjpegW[] = {'i','m','a','g','e','/','p','j','p','e','g',0};
    static const WCHAR image_tiffW[] = {'i','m','a','g','e','/','t','i','f','f',0};
    static const WCHAR image_xpngW[] = {'i','m','a','g','e','/','x','-','p','n','g',0};
    static const WCHAR image_bmpW[] = {'i','m','a','g','e','/','b','m','p',0};
    static const WCHAR video_aviW[] = {'v','i','d','e','o','/','a','v','i',0};
    static const WCHAR video_mpegW[] = {'v','i','d','e','o','/','m','p','e','g',0};
    static const WCHAR app_postscriptW[] =
        {'a','p','p','l','i','c','a','t','i','o','n','/','p','o','s','t','s','c','r','i','p','t',0};
    static const WCHAR app_pdfW[] = {'a','p','p','l','i','c','a','t','i','o','n','/','p','d','f',0};
    static const WCHAR app_xzipW[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
        'x','-','z','i','p','-','c','o','m','p','r','e','s','s','e','d',0};
    static const WCHAR app_xgzipW[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
        'x','-','g','z','i','p','-','c','o','m','p','r','e','s','s','e','d',0};
    static const WCHAR app_javaW[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
        'j','a','v','a',0};
    static const WCHAR app_xmsdownloadW[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
        'x','-','m','s','d','o','w','n','l','o','a','d',0};
    static const WCHAR text_plainW[] = {'t','e','x','t','/','p','l','a','i','n','\0'};
    static const WCHAR app_octetstreamW[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
        'o','c','t','e','t','-','s','t','r','e','a','m','\0'};

    static const struct {
        LPCWSTR mime;
        BOOL (*filter)(const BYTE *,DWORD);
    } mime_filters[] = {
        {text_htmlW,       text_html_filter},
        {text_richtextW,   text_richtext_filter},
     /* {audio_xaiffW,     audio_xaiff_filter}, */
        {audio_basicW,     audio_basic_filter},
        {audio_wavW,       audio_wav_filter},
        {image_gifW,       image_gif_filter},
        {image_pjpegW,     image_pjpeg_filter},
        {image_tiffW,      image_tiff_filter},
        {image_xpngW,      image_xpng_filter},
     /* {image_xbitmapW,   image_xbitmap_filter}, */
        {image_bmpW,       image_bmp_filter},
     /* {image_xjgW,       image_xjg_filter}, */
     /* {image_xemfW,      image_xemf_filter}, */
     /* {image_xwmfW,      image_xwmf_filter}, */
        {video_aviW,       video_avi_filter},
        {video_mpegW,      video_mpeg_filter},
        {app_postscriptW,  application_postscript_filter},
     /* {app_base64W,      application_base64_filter}, */
     /* {app_macbinhex40W, application_macbinhex40_filter}, */
        {app_pdfW,         application_pdf_filter},
     /* {app_zcompressedW, application_xcompressed_filter}, */
        {app_xzipW,        application_xzip_filter},
        {app_xgzipW,       application_xgzip_filter},
        {app_javaW,        application_java_filter},
        {app_xmsdownloadW, application_xmsdownload},
        {text_plainW,      text_plain_filter},
        {app_octetstreamW, application_octet_stream_filter}
    };

    if(!buf || !size) {
        if(!proposed_mime)
            return E_FAIL;

        len = strlenW(proposed_mime)+1;
        *ret_mime = CoTaskMemAlloc(len*sizeof(WCHAR));
        if(!*ret_mime)
            return E_OUTOFMEMORY;

        memcpy(*ret_mime, proposed_mime, len*sizeof(WCHAR));
        return S_OK;
    }

    if(proposed_mime && strcmpW(proposed_mime, app_octetstreamW)) {
        for(i=0; i < sizeof(mime_filters)/sizeof(*mime_filters); i++) {
            if(!strcmpW(proposed_mime, mime_filters[i].mime))
                break;
        }

        if(i == sizeof(mime_filters)/sizeof(*mime_filters) || mime_filters[i].filter(buf, size)) {
            len = strlenW(proposed_mime)+1;
            *ret_mime = CoTaskMemAlloc(len*sizeof(WCHAR));
            if(!*ret_mime)
                return E_OUTOFMEMORY;

            memcpy(*ret_mime, proposed_mime, len*sizeof(WCHAR));
            return S_OK;
        }
    }

    i=0;
    while(!ret) {
        if(mime_filters[i].filter(buf, size))
            ret = mime_filters[i].mime;
        i++;
    }

    TRACE("found %s for %s\n", debugstr_w(ret), debugstr_an((const char*)buf, min(32, size)));

    if(proposed_mime) {
        if(i == sizeof(mime_filters)/sizeof(*mime_filters))
            ret = proposed_mime;

        /* text/html is a special case */
        if(!strcmpW(proposed_mime, text_htmlW) && !strcmpW(ret, text_plainW))
            ret = text_htmlW;
    }

    len = strlenW(ret)+1;
    *ret_mime = CoTaskMemAlloc(len*sizeof(WCHAR));
    if(!*ret_mime)
        return E_OUTOFMEMORY;

    memcpy(*ret_mime, ret, len*sizeof(WCHAR));
    return S_OK;
}

803 804 805 806 807
/***********************************************************************
 *           FindMimeFromData (URLMON.@)
 *
 * Determines the Multipurpose Internet Mail Extensions (MIME) type from the data provided.
 */
808 809 810 811
HRESULT WINAPI FindMimeFromData(LPBC pBC, LPCWSTR pwzUrl, LPVOID pBuffer,
        DWORD cbSize, LPCWSTR pwzMimeProposed, DWORD dwMimeFlags,
        LPWSTR* ppwzMimeOut, DWORD dwReserved)
{
812
    TRACE("(%p,%s,%p,%d,%s,0x%x,%p,0x%x)\n", pBC, debugstr_w(pwzUrl), pBuffer, cbSize,
813 814 815
            debugstr_w(pwzMimeProposed), dwMimeFlags, ppwzMimeOut, dwReserved);

    if(dwMimeFlags)
816
        WARN("dwMimeFlags=%08x\n", dwMimeFlags);
817
    if(dwReserved)
818
        WARN("dwReserved=%d\n", dwReserved);
819 820 821 822 823 824

    /* pBC seams to not be used */

    if(!ppwzMimeOut || (!pwzUrl && !pBuffer))
        return E_INVALIDARG;

825 826
    if(pwzMimeProposed || pBuffer)
        return find_mime_from_buffer(pBuffer, cbSize, pwzMimeProposed, ppwzMimeOut);
827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842

    if(pwzUrl) {
        HKEY hkey;
        DWORD res, size;
        LPCWSTR ptr;
        WCHAR mime[64];

        static const WCHAR wszContentType[] =
                {'C','o','n','t','e','n','t',' ','T','y','p','e','\0'};

        ptr = strrchrW(pwzUrl, '.');
        if(!ptr)
            return E_FAIL;

        res = RegOpenKeyW(HKEY_CLASSES_ROOT, ptr, &hkey);
        if(res != ERROR_SUCCESS)
843
            return HRESULT_FROM_WIN32(res);
844 845 846 847 848

        size = sizeof(mime);
        res = RegQueryValueExW(hkey, wszContentType, NULL, NULL, (LPBYTE)mime, &size);
        RegCloseKey(hkey);
        if(res != ERROR_SUCCESS)
849
            return HRESULT_FROM_WIN32(res);
850 851 852 853 854 855 856 857

        *ppwzMimeOut = CoTaskMemAlloc(size);
        memcpy(*ppwzMimeOut, mime, size);
        return S_OK;
    }

    return E_FAIL;
}
858

859 860 861 862 863 864 865 866 867 868 869 870 871 872 873
/***********************************************************************
 *           GetClassFileOrMime (URLMON.@)
 *
 * Determines the class ID from the bind context, file name or MIME type.
 */
HRESULT WINAPI GetClassFileOrMime(LPBC pBC, LPCWSTR pszFilename,
        LPVOID pBuffer, DWORD cbBuffer, LPCWSTR pszMimeType, DWORD dwReserved,
        CLSID *pclsid)
{
    FIXME("(%p, %s, %p, %d, %p, 0x%08x, %p): stub\n", pBC,
        debugstr_w(pszFilename), pBuffer, cbBuffer, debugstr_w(pszMimeType),
        dwReserved, pclsid);
    return E_NOTIMPL;
}

874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889
/***********************************************************************
 * Extract (URLMON.@)
 */
HRESULT WINAPI Extract(void *dest, LPCSTR szCabName)
{
    HRESULT (WINAPI *pExtract)(void *, LPCSTR);

    if (!hCabinet)
        hCabinet = LoadLibraryA("cabinet.dll");

    if (!hCabinet) return HRESULT_FROM_WIN32(GetLastError());
    pExtract = (void *)GetProcAddress(hCabinet, "Extract");
    if (!pExtract) return HRESULT_FROM_WIN32(GetLastError());

    return pExtract(dest, szCabName);
}
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907

/***********************************************************************
 *           IsLoggingEnabledA (URLMON.@)
 */
BOOL WINAPI IsLoggingEnabledA(LPCSTR url)
{
    FIXME("(%s)\n", debugstr_a(url));
    return FALSE;
}

/***********************************************************************
 *           IsLoggingEnabledW (URLMON.@)
 */
BOOL WINAPI IsLoggingEnabledW(LPCWSTR url)
{
    FIXME("(%s)\n", debugstr_w(url));
    return FALSE;
}
908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927

/***********************************************************************
 *           URLMON_410 (URLMON.410)
 *    Undocumented, added in IE8
 */
BOOL WINAPI URLMON_410(DWORD unknown1, DWORD unknown2)
{
    FIXME("stub: %d %d\n", unknown1, unknown2);
    return FALSE;
}

/***********************************************************************
 *           URLMON_423 (URLMON.423)
 *    Undocumented, added in IE8
 */
BOOL WINAPI URLMON_423(DWORD unknown1, DWORD unknown2, DWORD unknown3, DWORD unknown4)
{
    FIXME("stub: %d %d %d %d\n", unknown1, unknown2, unknown3, unknown4);
    return FALSE;
}