configure: Check if version of msgfmt (from gettext) is recent enough.
[wine] / dlls / urlmon / urlmon_main.c
1 /*
2  * UrlMon
3  *
4  * Copyright (c) 2000 Patrik Stridvall
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * 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 #include <stdarg.h>
22
23 #include "urlmon_main.h"
24
25 #include "winreg.h"
26
27 #define NO_SHLWAPI_REG
28 #include "shlwapi.h"
29 #include "advpub.h"
30 #include "initguid.h"
31
32 #include "wine/debug.h"
33
34 #include "urlmon.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
37
38 DEFINE_GUID(CLSID_CUri, 0xDF2FCE13, 0x25EC, 0x45BB, 0x9D,0x4C, 0xCE,0xCD,0x47,0xC2,0x43,0x0C);
39
40 LONG URLMON_refCount = 0;
41
42 static HMODULE hCabinet = NULL;
43 static DWORD urlmon_tls = TLS_OUT_OF_INDEXES;
44
45 static void init_session(BOOL);
46
47 static struct list tls_list = LIST_INIT(tls_list);
48
49 static CRITICAL_SECTION tls_cs;
50 static CRITICAL_SECTION_DEBUG tls_cs_dbg =
51 {
52     0, 0, &tls_cs,
53     { &tls_cs_dbg.ProcessLocksList, &tls_cs_dbg.ProcessLocksList },
54       0, 0, { (DWORD_PTR)(__FILE__ ": tls") }
55 };
56
57 static CRITICAL_SECTION tls_cs = { &tls_cs_dbg, -1, 0, 0, 0, 0 };
58
59 tls_data_t *get_tls_data(void)
60 {
61     tls_data_t *data;
62
63     if(urlmon_tls == TLS_OUT_OF_INDEXES) {
64         DWORD tls = TlsAlloc();
65         if(tls == TLS_OUT_OF_INDEXES)
66             return NULL;
67
68         tls = InterlockedCompareExchange((LONG*)&urlmon_tls, tls, TLS_OUT_OF_INDEXES);
69         if(tls != urlmon_tls)
70             TlsFree(tls);
71     }
72
73     data = TlsGetValue(urlmon_tls);
74     if(!data) {
75         data = heap_alloc_zero(sizeof(tls_data_t));
76         if(!data)
77             return NULL;
78
79         EnterCriticalSection(&tls_cs);
80         list_add_tail(&tls_list, &data->entry);
81         LeaveCriticalSection(&tls_cs);
82
83         TlsSetValue(urlmon_tls, data);
84     }
85
86     return data;
87 }
88
89 static void free_tls_list(void)
90 {
91     tls_data_t *data;
92
93     if(urlmon_tls == TLS_OUT_OF_INDEXES)
94         return;
95
96     while(!list_empty(&tls_list)) {
97         data = LIST_ENTRY(list_head(&tls_list), tls_data_t, entry);
98         list_remove(&data->entry);
99         heap_free(data);
100     }
101
102     TlsFree(urlmon_tls);
103 }
104
105 static void detach_thread(void)
106 {
107     tls_data_t *data;
108
109     if(urlmon_tls == TLS_OUT_OF_INDEXES)
110         return;
111
112     data = TlsGetValue(urlmon_tls);
113     if(!data)
114         return;
115
116     EnterCriticalSection(&tls_cs);
117     list_remove(&data->entry);
118     LeaveCriticalSection(&tls_cs);
119
120     if(data->notif_hwnd) {
121         WARN("notif_hwnd not destroyed\n");
122         DestroyWindow(data->notif_hwnd);
123     }
124
125     heap_free(data);
126 }
127
128 static void process_detach(void)
129 {
130     HINTERNET internet_session;
131
132     internet_session = get_internet_session(NULL);
133     if(internet_session)
134         InternetCloseHandle(internet_session);
135
136     if (hCabinet)
137         FreeLibrary(hCabinet);
138
139     init_session(FALSE);
140     free_session();
141     free_tls_list();
142 }
143
144 /***********************************************************************
145  *              DllMain (URLMON.init)
146  */
147 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
148 {
149     TRACE("%p 0x%x %p\n", hinstDLL, fdwReason, fImpLoad);
150
151     URLMON_DllMain( hinstDLL, fdwReason, fImpLoad );
152
153     switch(fdwReason) {
154     case DLL_PROCESS_ATTACH:
155         init_session(TRUE);
156         break;
157
158     case DLL_PROCESS_DETACH:
159         process_detach();
160         DeleteCriticalSection(&tls_cs);
161         break;
162
163     case DLL_THREAD_DETACH:
164         detach_thread();
165         break;
166     }
167     return TRUE;
168 }
169
170
171 /***********************************************************************
172  *              DllInstall (URLMON.@)
173  */
174 HRESULT WINAPI DllInstall(BOOL bInstall, LPCWSTR cmdline)
175 {
176   FIXME("(%s, %s): stub\n", bInstall?"TRUE":"FALSE",
177         debugstr_w(cmdline));
178
179   return S_OK;
180 }
181
182 /***********************************************************************
183  *              DllCanUnloadNow (URLMON.@)
184  */
185 HRESULT WINAPI DllCanUnloadNow(void)
186 {
187     return URLMON_refCount != 0 ? S_FALSE : S_OK;
188 }
189
190
191
192 /******************************************************************************
193  * Urlmon ClassFactory
194  */
195 typedef struct {
196     IClassFactory IClassFactory_iface;
197
198     HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj);
199 } ClassFactory;
200
201 static inline ClassFactory *impl_from_IClassFactory(IClassFactory *iface)
202 {
203     return CONTAINING_RECORD(iface, ClassFactory, IClassFactory_iface);
204 }
205
206 static HRESULT WINAPI CF_QueryInterface(IClassFactory *iface, REFIID riid, LPVOID *ppv)
207 {
208     *ppv = NULL;
209
210     if(IsEqualGUID(riid, &IID_IUnknown)) {
211         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
212         *ppv = iface;
213     }else if(IsEqualGUID(riid, &IID_IClassFactory)) {
214         TRACE("(%p)->(IID_IClassFactory %p)\n", iface, ppv);
215         *ppv = iface;
216     }
217
218     if(*ppv) {
219         IUnknown_AddRef((IUnknown*)*ppv);
220         return S_OK;
221     }
222
223     WARN("(%p)->(%s,%p),not found\n", iface, debugstr_guid(riid), ppv);
224     return E_NOINTERFACE;
225 }
226
227 static ULONG WINAPI CF_AddRef(IClassFactory *iface)
228 {
229     URLMON_LockModule();
230     return 2;
231 }
232
233 static ULONG WINAPI CF_Release(IClassFactory *iface)
234 {
235     URLMON_UnlockModule();
236     return 1;
237 }
238
239
240 static HRESULT WINAPI CF_CreateInstance(IClassFactory *iface, IUnknown *pOuter,
241                                         REFIID riid, LPVOID *ppobj)
242 {
243     ClassFactory *This = impl_from_IClassFactory(iface);
244     HRESULT hres;
245     LPUNKNOWN punk;
246     
247     TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
248
249     *ppobj = NULL;
250     if(SUCCEEDED(hres = This->pfnCreateInstance(pOuter, (LPVOID *) &punk))) {
251         hres = IUnknown_QueryInterface(punk, riid, ppobj);
252         IUnknown_Release(punk);
253     }
254     return hres;
255 }
256
257 static HRESULT WINAPI CF_LockServer(LPCLASSFACTORY iface,BOOL dolock)
258 {
259     TRACE("(%d)\n", dolock);
260
261     if (dolock)
262            URLMON_LockModule();
263     else
264            URLMON_UnlockModule();
265
266     return S_OK;
267 }
268
269 static const IClassFactoryVtbl ClassFactoryVtbl =
270 {
271     CF_QueryInterface,
272     CF_AddRef,
273     CF_Release,
274     CF_CreateInstance,
275     CF_LockServer
276 };
277
278 static ClassFactory FileProtocolCF =
279     { { &ClassFactoryVtbl }, FileProtocol_Construct};
280 static ClassFactory FtpProtocolCF =
281     { { &ClassFactoryVtbl }, FtpProtocol_Construct};
282 static ClassFactory GopherProtocolCF =
283     { { &ClassFactoryVtbl }, GopherProtocol_Construct};
284 static ClassFactory HttpProtocolCF =
285     { { &ClassFactoryVtbl }, HttpProtocol_Construct};
286 static ClassFactory HttpSProtocolCF =
287     { { &ClassFactoryVtbl }, HttpSProtocol_Construct};
288 static ClassFactory MkProtocolCF =
289     { { &ClassFactoryVtbl }, MkProtocol_Construct};
290 static ClassFactory SecurityManagerCF =
291     { { &ClassFactoryVtbl }, SecManagerImpl_Construct};
292 static ClassFactory ZoneManagerCF =
293     { { &ClassFactoryVtbl }, ZoneMgrImpl_Construct};
294 static ClassFactory StdURLMonikerCF =
295     { { &ClassFactoryVtbl }, StdURLMoniker_Construct};
296 static ClassFactory MimeFilterCF =
297     { { &ClassFactoryVtbl }, MimeFilter_Construct};
298 static ClassFactory CUriCF =
299     { { &ClassFactoryVtbl }, Uri_Construct};
300
301 struct object_creation_info
302 {
303     const CLSID *clsid;
304     IClassFactory *cf;
305     LPCWSTR protocol;
306 };
307
308 static const WCHAR wszFile[] = {'f','i','l','e',0};
309 static const WCHAR wszFtp[]  = {'f','t','p',0};
310 static const WCHAR wszGopher[]  = {'g','o','p','h','e','r',0};
311 static const WCHAR wszHttp[] = {'h','t','t','p',0};
312 static const WCHAR wszHttps[] = {'h','t','t','p','s',0};
313 static const WCHAR wszMk[]   = {'m','k',0};
314
315 static const struct object_creation_info object_creation[] =
316 {
317     { &CLSID_FileProtocol,            &FileProtocolCF.IClassFactory_iface,    wszFile },
318     { &CLSID_FtpProtocol,             &FtpProtocolCF.IClassFactory_iface,     wszFtp  },
319     { &CLSID_GopherProtocol,          &GopherProtocolCF.IClassFactory_iface,  wszGopher },
320     { &CLSID_HttpProtocol,            &HttpProtocolCF.IClassFactory_iface,    wszHttp },
321     { &CLSID_HttpSProtocol,           &HttpSProtocolCF.IClassFactory_iface,   wszHttps },
322     { &CLSID_MkProtocol,              &MkProtocolCF.IClassFactory_iface,      wszMk },
323     { &CLSID_InternetSecurityManager, &SecurityManagerCF.IClassFactory_iface, NULL    },
324     { &CLSID_InternetZoneManager,     &ZoneManagerCF.IClassFactory_iface,     NULL    },
325     { &CLSID_StdURLMoniker,           &StdURLMonikerCF.IClassFactory_iface,   NULL    },
326     { &CLSID_DeCompMimeFilter,        &MimeFilterCF.IClassFactory_iface,      NULL    },
327     { &CLSID_CUri,                    &CUriCF.IClassFactory_iface,            NULL    }
328 };
329
330 static void init_session(BOOL init)
331 {
332     unsigned int i;
333
334     for(i=0; i < sizeof(object_creation)/sizeof(object_creation[0]); i++) {
335
336         if(object_creation[i].protocol)
337             register_urlmon_namespace(object_creation[i].cf, object_creation[i].clsid,
338                                       object_creation[i].protocol, init);
339     }
340 }
341
342 /*******************************************************************************
343  * DllGetClassObject [URLMON.@]
344  * Retrieves class object from a DLL object
345  *
346  * NOTES
347  *    Docs say returns STDAPI
348  *
349  * PARAMS
350  *    rclsid [I] CLSID for the class object
351  *    riid   [I] Reference to identifier of interface for class object
352  *    ppv    [O] Address of variable to receive interface pointer for riid
353  *
354  * RETURNS
355  *    Success: S_OK
356  *    Failure: CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, E_INVALIDARG,
357  *             E_UNEXPECTED
358  */
359
360 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
361 {
362     unsigned int i;
363     HRESULT hr;
364     
365     TRACE("(%s,%s,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
366     
367     for (i=0; i < sizeof(object_creation)/sizeof(object_creation[0]); i++)
368     {
369         if (IsEqualGUID(object_creation[i].clsid, rclsid))
370             return IClassFactory_QueryInterface(object_creation[i].cf, riid, ppv);
371     }
372
373     hr = URLMON_DllGetClassObject(rclsid, riid, ppv);
374     if(SUCCEEDED(hr))
375         return hr;
376
377     FIXME("%s: no class found.\n", debugstr_guid(rclsid));
378     return CLASS_E_CLASSNOTAVAILABLE;
379 }
380
381 static HRESULT register_inf(BOOL doregister)
382 {
383     HRESULT (WINAPI *pRegInstall)(HMODULE hm, LPCSTR pszSection, const STRTABLEA* pstTable);
384     HMODULE hAdvpack;
385
386     static const WCHAR wszAdvpack[] = {'a','d','v','p','a','c','k','.','d','l','l',0};
387
388     hAdvpack = LoadLibraryW(wszAdvpack);
389     pRegInstall = (void *)GetProcAddress(hAdvpack, "RegInstall");
390
391     return pRegInstall(hProxyDll, doregister ? "RegisterDll" : "UnregisterDll", NULL);
392 }
393
394 /***********************************************************************
395  *              DllRegisterServer (URLMON.@)
396  */
397 HRESULT WINAPI DllRegisterServer(void)
398 {
399     HRESULT hr;
400
401     TRACE("\n");
402
403     hr = URLMON_DllRegisterServer();
404     return SUCCEEDED(hr) ? register_inf(TRUE) : hr;
405 }
406
407 /***********************************************************************
408  *              DllUnregisterServer (URLMON.@)
409  */
410 HRESULT WINAPI DllUnregisterServer(void)
411 {
412     HRESULT hr;
413
414     TRACE("\n");
415
416     hr = URLMON_DllUnregisterServer();
417     return SUCCEEDED(hr) ? register_inf(FALSE) : hr;
418 }
419
420 /***********************************************************************
421  *              DllRegisterServerEx (URLMON.@)
422  */
423 HRESULT WINAPI DllRegisterServerEx(void)
424 {
425     FIXME("(void): stub\n");
426
427     return E_FAIL;
428 }
429
430 /**************************************************************************
431  *                 IsValidURL (URLMON.@)
432  * 
433  * Determines if a specified string is a valid URL.
434  *
435  * PARAMS
436  *  pBC        [I] ignored, should be NULL.
437  *  szURL      [I] string that represents the URL in question.
438  *  dwReserved [I] reserved and must be zero.
439  *
440  * RETURNS
441  *  Success: S_OK.
442  *  Failure: S_FALSE.
443  *  returns E_INVALIDARG if one or more of the args is invalid.
444  *
445  * TODO:
446  *  test functionality against windows to see what a valid URL is.
447  */
448 HRESULT WINAPI IsValidURL(LPBC pBC, LPCWSTR szURL, DWORD dwReserved)
449 {
450     FIXME("(%p, %s, %d): stub\n", pBC, debugstr_w(szURL), dwReserved);
451
452     if (dwReserved || !szURL)
453         return E_INVALIDARG;
454
455     return S_OK;
456 }
457
458 /**************************************************************************
459  *                 FaultInIEFeature (URLMON.@)
460  *
461  *  Undocumented.  Appears to be used by native shdocvw.dll.
462  */
463 HRESULT WINAPI FaultInIEFeature( HWND hwnd, uCLSSPEC * pClassSpec,
464                                  QUERYCONTEXT *pQuery, DWORD flags )
465 {
466     FIXME("%p %p %p %08x\n", hwnd, pClassSpec, pQuery, flags);
467     return E_NOTIMPL;
468 }
469
470 /**************************************************************************
471  *                 CoGetClassObjectFromURL (URLMON.@)
472  */
473 HRESULT WINAPI CoGetClassObjectFromURL( REFCLSID rclsid, LPCWSTR szCodeURL, DWORD dwFileVersionMS,
474                                         DWORD dwFileVersionLS, LPCWSTR szContentType,
475                                         LPBINDCTX pBindCtx, DWORD dwClsContext, LPVOID pvReserved,
476                                         REFIID riid, LPVOID *ppv )
477 {
478     FIXME("(%s %s %d %d %s %p %d %p %s %p) Stub!\n", debugstr_guid(rclsid), debugstr_w(szCodeURL),
479         dwFileVersionMS, dwFileVersionLS, debugstr_w(szContentType), pBindCtx, dwClsContext, pvReserved,
480         debugstr_guid(riid), ppv);
481     return E_NOINTERFACE;
482 }
483
484 /***********************************************************************
485  *           ReleaseBindInfo (URLMON.@)
486  *
487  * Release the resources used by the specified BINDINFO structure.
488  *
489  * PARAMS
490  *  pbindinfo [I] BINDINFO to release.
491  *
492  * RETURNS
493  *  Nothing.
494  */
495 void WINAPI ReleaseBindInfo(BINDINFO* pbindinfo)
496 {
497     DWORD size;
498
499     TRACE("(%p)\n", pbindinfo);
500
501     if(!pbindinfo || !(size = pbindinfo->cbSize))
502         return;
503
504     CoTaskMemFree(pbindinfo->szExtraInfo);
505     ReleaseStgMedium(&pbindinfo->stgmedData);
506
507     if(offsetof(BINDINFO, szExtraInfo) < size)
508         CoTaskMemFree(pbindinfo->szCustomVerb);
509
510     if(pbindinfo->pUnk && offsetof(BINDINFO, pUnk) < size)
511         IUnknown_Release(pbindinfo->pUnk);
512
513     memset(pbindinfo, 0, size);
514     pbindinfo->cbSize = size;
515 }
516
517 /***********************************************************************
518  *           CopyStgMedium (URLMON.@)
519  */
520 HRESULT WINAPI CopyStgMedium(const STGMEDIUM *src, STGMEDIUM *dst)
521 {
522     TRACE("(%p %p)\n", src, dst);
523
524     if(!src || !dst)
525         return E_POINTER;
526
527     *dst = *src;
528
529     switch(dst->tymed) {
530     case TYMED_NULL:
531         break;
532     case TYMED_FILE:
533         if(src->u.lpszFileName && !src->pUnkForRelease) {
534             DWORD size = (strlenW(src->u.lpszFileName)+1)*sizeof(WCHAR);
535             dst->u.lpszFileName = CoTaskMemAlloc(size);
536             if(!dst->u.lpszFileName)
537                 return E_OUTOFMEMORY;
538             memcpy(dst->u.lpszFileName, src->u.lpszFileName, size);
539         }
540         break;
541     case TYMED_ISTREAM:
542         if(dst->u.pstm)
543             IStream_AddRef(dst->u.pstm);
544         break;
545     case TYMED_ISTORAGE:
546         if(dst->u.pstg)
547             IStorage_AddRef(dst->u.pstg);
548         break;
549     default:
550         FIXME("Unimplemented tymed %d\n", src->tymed);
551     }
552
553     if(dst->pUnkForRelease)
554         IUnknown_AddRef(dst->pUnkForRelease);
555
556     return S_OK;
557 }
558
559 /***********************************************************************
560  *           CopyBindInfo (URLMON.@)
561  */
562 HRESULT WINAPI CopyBindInfo(const BINDINFO *pcbiSrc, BINDINFO *pcbiDest)
563 {
564     DWORD size;
565     HRESULT hres;
566
567     TRACE("(%p %p)\n", pcbiSrc, pcbiDest);
568
569     if(!pcbiSrc || !pcbiDest)
570         return E_POINTER;
571     if(!pcbiSrc->cbSize || !pcbiDest->cbSize)
572         return E_INVALIDARG;
573
574     size = pcbiDest->cbSize;
575     if(size > pcbiSrc->cbSize) {
576         memcpy(pcbiDest, pcbiSrc, pcbiSrc->cbSize);
577         memset((char*)pcbiDest+pcbiSrc->cbSize, 0, size-pcbiSrc->cbSize);
578     } else {
579         memcpy(pcbiDest, pcbiSrc, size);
580     }
581     pcbiDest->cbSize = size;
582
583     size = FIELD_OFFSET(BINDINFO, szExtraInfo)+sizeof(void*);
584     if(pcbiSrc->cbSize>=size && pcbiDest->cbSize>=size && pcbiSrc->szExtraInfo) {
585         size = (strlenW(pcbiSrc->szExtraInfo)+1)*sizeof(WCHAR);
586         pcbiDest->szExtraInfo = CoTaskMemAlloc(size);
587         if(!pcbiDest->szExtraInfo)
588             return E_OUTOFMEMORY;
589         memcpy(pcbiDest->szExtraInfo, pcbiSrc->szExtraInfo, size);
590     }
591
592     size = FIELD_OFFSET(BINDINFO, stgmedData)+sizeof(STGMEDIUM);
593     if(pcbiSrc->cbSize>=size && pcbiDest->cbSize>=size) {
594         hres = CopyStgMedium(&pcbiSrc->stgmedData, &pcbiDest->stgmedData);
595         if(FAILED(hres)) {
596             CoTaskMemFree(pcbiDest->szExtraInfo);
597             return hres;
598         }
599     }
600
601     size = FIELD_OFFSET(BINDINFO, szCustomVerb)+sizeof(void*);
602     if(pcbiSrc->cbSize>=size && pcbiDest->cbSize>=size && pcbiSrc->szCustomVerb) {
603         size = (strlenW(pcbiSrc->szCustomVerb)+1)*sizeof(WCHAR);
604         pcbiDest->szCustomVerb = CoTaskMemAlloc(size);
605         if(!pcbiDest->szCustomVerb) {
606             CoTaskMemFree(pcbiDest->szExtraInfo);
607             ReleaseStgMedium(&pcbiDest->stgmedData);
608             return E_OUTOFMEMORY;
609         }
610     }
611
612     size = FIELD_OFFSET(BINDINFO, securityAttributes)+sizeof(SECURITY_ATTRIBUTES);
613     if(pcbiDest->cbSize >= size)
614         memset(&pcbiDest->securityAttributes, 0, sizeof(SECURITY_ATTRIBUTES));
615
616     if(pcbiSrc->pUnk)
617         IUnknown_AddRef(pcbiDest->pUnk);
618
619     return S_OK;
620 }
621
622 static BOOL text_richtext_filter(const BYTE *b, DWORD size)
623 {
624     return size > 5 && !memcmp(b, "{\\rtf", 5);
625 }
626
627 static BOOL text_html_filter(const BYTE *b, DWORD size)
628 {
629     DWORD i;
630
631     if(size < 5)
632         return FALSE;
633
634     for(i = 0; i < size-5; i++) {
635         if((b[i] == '<'
636             && (b[i+1] == 'h' || b[i+1] == 'H')
637             && (b[i+2] == 't' || b[i+2] == 'T')
638             && (b[i+3] == 'm' || b[i+3] == 'M')
639             && (b[i+4] == 'l' || b[i+4] == 'L')) ||
640            ((size - i >= 6)
641             &&  b[i]   == '<'
642             && (b[i+1] == 'h' || b[i+1] == 'H')
643             && (b[i+2] == 'e' || b[i+2] == 'E')
644             && (b[i+3] == 'a' || b[i+3] == 'A')
645             && (b[i+4] == 'd' || b[i+4] == 'D')
646             &&  b[i+5] == '>')) return TRUE;
647     }
648
649     return FALSE;
650 }
651
652 static BOOL audio_basic_filter(const BYTE *b, DWORD size)
653 {
654     return size > 4
655         && b[0] == '.' && b[1] == 's' && b[2] == 'n' && b[3] == 'd';
656 }
657
658 static BOOL audio_wav_filter(const BYTE *b, DWORD size)
659 {
660     return size > 12
661         && b[0] == 'R' && b[1] == 'I' && b[2] == 'F' && b[3] == 'F'
662         && b[8] == 'W' && b[9] == 'A' && b[10] == 'V' && b[11] == 'E';
663 }
664
665 static BOOL image_gif_filter(const BYTE *b, DWORD size)
666 {
667     return size >= 6
668         && (b[0] == 'G' || b[0] == 'g')
669         && (b[1] == 'I' || b[1] == 'i')
670         && (b[2] == 'F' || b[2] == 'f')
671         &&  b[3] == '8'
672         && (b[4] == '7' || b[4] == '9')
673         && (b[5] == 'A' || b[5] == 'a');
674 }
675
676 static BOOL image_pjpeg_filter(const BYTE *b, DWORD size)
677 {
678     return size > 2 && b[0] == 0xff && b[1] == 0xd8;
679 }
680
681 static BOOL image_tiff_filter(const BYTE *b, DWORD size)
682 {
683     static const BYTE magic1[] = {0x4d,0x4d,0x00,0x2a};
684     static const BYTE magic2[] = {0x49,0x49,0x2a,0xff};
685
686     return size >= 4 && (!memcmp(b, magic1, 4) || !memcmp(b, magic2, 4));
687 }
688
689 static BOOL image_xpng_filter(const BYTE *b, DWORD size)
690 {
691     static const BYTE xpng_header[] = {0x89,'P','N','G',0x0d,0x0a,0x1a,0x0a};
692     return size > sizeof(xpng_header) && !memcmp(b, xpng_header, sizeof(xpng_header));
693 }
694
695 static BOOL image_bmp_filter(const BYTE *b, DWORD size)
696 {
697     return size >= 14
698         && b[0] == 0x42 && b[1] == 0x4d
699         && *(const DWORD *)(b+6) == 0;
700 }
701
702 static BOOL video_avi_filter(const BYTE *b, DWORD size)
703 {
704     return size > 12
705         && b[0] == 'R' && b[1] == 'I' && b[2] == 'F' && b[3] == 'F'
706         && b[8] == 'A' && b[9] == 'V' && b[10] == 'I' && b[11] == 0x20;
707 }
708
709 static BOOL video_mpeg_filter(const BYTE *b, DWORD size)
710 {
711     return size > 4
712         && !b[0] && !b[1] && b[2] == 0x01
713         && (b[3] == 0xb3 || b[3] == 0xba);
714 }
715
716 static BOOL application_postscript_filter(const BYTE *b, DWORD size)
717 {
718     return size > 2 && b[0] == '%' && b[1] == '!';
719 }
720
721 static BOOL application_pdf_filter(const BYTE *b, DWORD size)
722 {
723     return size > 4 && b[0] == 0x25 && b[1] == 0x50 && b[2] == 0x44 && b[3] == 0x46;
724 }
725
726 static BOOL application_xzip_filter(const BYTE *b, DWORD size)
727 {
728     return size > 2 && b[0] == 0x50 && b[1] == 0x4b;
729 }
730
731 static BOOL application_xgzip_filter(const BYTE *b, DWORD size)
732 {
733     return size > 2 && b[0] == 0x1f && b[1] == 0x8b;
734 }
735
736 static BOOL application_java_filter(const BYTE *b, DWORD size)
737 {
738     return size > 4 && b[0] == 0xca && b[1] == 0xfe && b[2] == 0xba && b[3] == 0xbe;
739 }
740
741 static BOOL application_xmsdownload(const BYTE *b, DWORD size)
742 {
743     return size > 2 && b[0] == 'M' && b[1] == 'Z';
744 }
745
746 static BOOL text_plain_filter(const BYTE *b, DWORD size)
747 {
748     const BYTE *ptr;
749
750     for(ptr = b; ptr < b+size-1; ptr++) {
751         if(*ptr < 0x20 && *ptr != '\n' && *ptr != '\r' && *ptr != '\t')
752             return FALSE;
753     }
754
755     return TRUE;
756 }
757
758 static BOOL application_octet_stream_filter(const BYTE *b, DWORD size)
759 {
760     return TRUE;
761 }
762
763 static HRESULT find_mime_from_buffer(const BYTE *buf, DWORD size, const WCHAR *proposed_mime, WCHAR **ret_mime)
764 {
765     LPCWSTR ret = NULL;
766     DWORD len, i;
767
768     static const WCHAR text_htmlW[] = {'t','e','x','t','/','h','t','m','l',0};
769     static const WCHAR text_richtextW[] = {'t','e','x','t','/','r','i','c','h','t','e','x','t',0};
770     static const WCHAR audio_basicW[] = {'a','u','d','i','o','/','b','a','s','i','c',0};
771     static const WCHAR audio_wavW[] = {'a','u','d','i','o','/','w','a','v',0};
772     static const WCHAR image_gifW[] = {'i','m','a','g','e','/','g','i','f',0};
773     static const WCHAR image_pjpegW[] = {'i','m','a','g','e','/','p','j','p','e','g',0};
774     static const WCHAR image_tiffW[] = {'i','m','a','g','e','/','t','i','f','f',0};
775     static const WCHAR image_xpngW[] = {'i','m','a','g','e','/','x','-','p','n','g',0};
776     static const WCHAR image_bmpW[] = {'i','m','a','g','e','/','b','m','p',0};
777     static const WCHAR video_aviW[] = {'v','i','d','e','o','/','a','v','i',0};
778     static const WCHAR video_mpegW[] = {'v','i','d','e','o','/','m','p','e','g',0};
779     static const WCHAR app_postscriptW[] =
780         {'a','p','p','l','i','c','a','t','i','o','n','/','p','o','s','t','s','c','r','i','p','t',0};
781     static const WCHAR app_pdfW[] = {'a','p','p','l','i','c','a','t','i','o','n','/','p','d','f',0};
782     static const WCHAR app_xzipW[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
783         'x','-','z','i','p','-','c','o','m','p','r','e','s','s','e','d',0};
784     static const WCHAR app_xgzipW[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
785         'x','-','g','z','i','p','-','c','o','m','p','r','e','s','s','e','d',0};
786     static const WCHAR app_javaW[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
787         'j','a','v','a',0};
788     static const WCHAR app_xmsdownloadW[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
789         'x','-','m','s','d','o','w','n','l','o','a','d',0};
790     static const WCHAR text_plainW[] = {'t','e','x','t','/','p','l','a','i','n','\0'};
791     static const WCHAR app_octetstreamW[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
792         'o','c','t','e','t','-','s','t','r','e','a','m','\0'};
793
794     static const struct {
795         LPCWSTR mime;
796         BOOL (*filter)(const BYTE *,DWORD);
797     } mime_filters[] = {
798         {text_htmlW,       text_html_filter},
799         {text_richtextW,   text_richtext_filter},
800      /* {audio_xaiffW,     audio_xaiff_filter}, */
801         {audio_basicW,     audio_basic_filter},
802         {audio_wavW,       audio_wav_filter},
803         {image_gifW,       image_gif_filter},
804         {image_pjpegW,     image_pjpeg_filter},
805         {image_tiffW,      image_tiff_filter},
806         {image_xpngW,      image_xpng_filter},
807      /* {image_xbitmapW,   image_xbitmap_filter}, */
808         {image_bmpW,       image_bmp_filter},
809      /* {image_xjgW,       image_xjg_filter}, */
810      /* {image_xemfW,      image_xemf_filter}, */
811      /* {image_xwmfW,      image_xwmf_filter}, */
812         {video_aviW,       video_avi_filter},
813         {video_mpegW,      video_mpeg_filter},
814         {app_postscriptW,  application_postscript_filter},
815      /* {app_base64W,      application_base64_filter}, */
816      /* {app_macbinhex40W, application_macbinhex40_filter}, */
817         {app_pdfW,         application_pdf_filter},
818      /* {app_zcompressedW, application_xcompressed_filter}, */
819         {app_xzipW,        application_xzip_filter},
820         {app_xgzipW,       application_xgzip_filter},
821         {app_javaW,        application_java_filter},
822         {app_xmsdownloadW, application_xmsdownload},
823         {text_plainW,      text_plain_filter},
824         {app_octetstreamW, application_octet_stream_filter}
825     };
826
827     if(!buf || !size) {
828         if(!proposed_mime)
829             return E_FAIL;
830
831         len = strlenW(proposed_mime)+1;
832         *ret_mime = CoTaskMemAlloc(len*sizeof(WCHAR));
833         if(!*ret_mime)
834             return E_OUTOFMEMORY;
835
836         memcpy(*ret_mime, proposed_mime, len*sizeof(WCHAR));
837         return S_OK;
838     }
839
840     if(proposed_mime && strcmpW(proposed_mime, app_octetstreamW)) {
841         for(i=0; i < sizeof(mime_filters)/sizeof(*mime_filters); i++) {
842             if(!strcmpW(proposed_mime, mime_filters[i].mime))
843                 break;
844         }
845
846         if(i == sizeof(mime_filters)/sizeof(*mime_filters) || mime_filters[i].filter(buf, size)) {
847             len = strlenW(proposed_mime)+1;
848             *ret_mime = CoTaskMemAlloc(len*sizeof(WCHAR));
849             if(!*ret_mime)
850                 return E_OUTOFMEMORY;
851
852             memcpy(*ret_mime, proposed_mime, len*sizeof(WCHAR));
853             return S_OK;
854         }
855     }
856
857     i=0;
858     while(!ret) {
859         if(mime_filters[i].filter(buf, size))
860             ret = mime_filters[i].mime;
861         i++;
862     }
863
864     TRACE("found %s for %s\n", debugstr_w(ret), debugstr_an((const char*)buf, min(32, size)));
865
866     if(proposed_mime) {
867         if(i == sizeof(mime_filters)/sizeof(*mime_filters))
868             ret = proposed_mime;
869
870         /* text/html is a special case */
871         if(!strcmpW(proposed_mime, text_htmlW) && !strcmpW(ret, text_plainW))
872             ret = text_htmlW;
873     }
874
875     len = strlenW(ret)+1;
876     *ret_mime = CoTaskMemAlloc(len*sizeof(WCHAR));
877     if(!*ret_mime)
878         return E_OUTOFMEMORY;
879
880     memcpy(*ret_mime, ret, len*sizeof(WCHAR));
881     return S_OK;
882 }
883
884 /***********************************************************************
885  *           FindMimeFromData (URLMON.@)
886  *
887  * Determines the Multipurpose Internet Mail Extensions (MIME) type from the data provided.
888  */
889 HRESULT WINAPI FindMimeFromData(LPBC pBC, LPCWSTR pwzUrl, LPVOID pBuffer,
890         DWORD cbSize, LPCWSTR pwzMimeProposed, DWORD dwMimeFlags,
891         LPWSTR* ppwzMimeOut, DWORD dwReserved)
892 {
893     TRACE("(%p,%s,%p,%d,%s,0x%x,%p,0x%x)\n", pBC, debugstr_w(pwzUrl), pBuffer, cbSize,
894             debugstr_w(pwzMimeProposed), dwMimeFlags, ppwzMimeOut, dwReserved);
895
896     if(dwMimeFlags)
897         WARN("dwMimeFlags=%08x\n", dwMimeFlags);
898     if(dwReserved)
899         WARN("dwReserved=%d\n", dwReserved);
900
901     /* pBC seams to not be used */
902
903     if(!ppwzMimeOut || (!pwzUrl && !pBuffer))
904         return E_INVALIDARG;
905
906     if(pwzMimeProposed || pBuffer)
907         return find_mime_from_buffer(pBuffer, cbSize, pwzMimeProposed, ppwzMimeOut);
908
909     if(pwzUrl) {
910         HKEY hkey;
911         DWORD res, size;
912         LPCWSTR ptr;
913         WCHAR mime[64];
914
915         static const WCHAR wszContentType[] =
916                 {'C','o','n','t','e','n','t',' ','T','y','p','e','\0'};
917
918         ptr = strrchrW(pwzUrl, '.');
919         if(!ptr)
920             return E_FAIL;
921
922         res = RegOpenKeyW(HKEY_CLASSES_ROOT, ptr, &hkey);
923         if(res != ERROR_SUCCESS)
924             return HRESULT_FROM_WIN32(res);
925
926         size = sizeof(mime);
927         res = RegQueryValueExW(hkey, wszContentType, NULL, NULL, (LPBYTE)mime, &size);
928         RegCloseKey(hkey);
929         if(res != ERROR_SUCCESS)
930             return HRESULT_FROM_WIN32(res);
931
932         *ppwzMimeOut = CoTaskMemAlloc(size);
933         memcpy(*ppwzMimeOut, mime, size);
934         return S_OK;
935     }
936
937     return E_FAIL;
938 }
939
940 /***********************************************************************
941  *           GetClassFileOrMime (URLMON.@)
942  *
943  * Determines the class ID from the bind context, file name or MIME type.
944  */
945 HRESULT WINAPI GetClassFileOrMime(LPBC pBC, LPCWSTR pszFilename,
946         LPVOID pBuffer, DWORD cbBuffer, LPCWSTR pszMimeType, DWORD dwReserved,
947         CLSID *pclsid)
948 {
949     FIXME("(%p, %s, %p, %d, %p, 0x%08x, %p): stub\n", pBC,
950         debugstr_w(pszFilename), pBuffer, cbBuffer, debugstr_w(pszMimeType),
951         dwReserved, pclsid);
952     return E_NOTIMPL;
953 }
954
955 /***********************************************************************
956  * Extract (URLMON.@)
957  */
958 HRESULT WINAPI Extract(void *dest, LPCSTR szCabName)
959 {
960     HRESULT (WINAPI *pExtract)(void *, LPCSTR);
961
962     if (!hCabinet)
963         hCabinet = LoadLibraryA("cabinet.dll");
964
965     if (!hCabinet) return HRESULT_FROM_WIN32(GetLastError());
966     pExtract = (void *)GetProcAddress(hCabinet, "Extract");
967     if (!pExtract) return HRESULT_FROM_WIN32(GetLastError());
968
969     return pExtract(dest, szCabName);
970 }
971
972 /***********************************************************************
973  *           IsLoggingEnabledA (URLMON.@)
974  */
975 BOOL WINAPI IsLoggingEnabledA(LPCSTR url)
976 {
977     FIXME("(%s)\n", debugstr_a(url));
978     return FALSE;
979 }
980
981 /***********************************************************************
982  *           IsLoggingEnabledW (URLMON.@)
983  */
984 BOOL WINAPI IsLoggingEnabledW(LPCWSTR url)
985 {
986     FIXME("(%s)\n", debugstr_w(url));
987     return FALSE;
988 }
989
990 /***********************************************************************
991  *           IsProtectedModeURL (URLMON.111)
992  *    Undocumented, added in IE7
993  */
994 BOOL WINAPI IsProtectedModeURL(const WCHAR *url)
995 {
996     FIXME("stub: %s\n", debugstr_w(url));
997     return TRUE;
998 }
999
1000 /***********************************************************************
1001  *           LogSqmBits (URLMON.410)
1002  *    Undocumented, added in IE8
1003  */
1004 int WINAPI LogSqmBits(DWORD unk1, DWORD unk2)
1005 {
1006     FIXME("stub: %d %d\n", unk1, unk2);
1007     return 0;
1008 }
1009
1010 /***********************************************************************
1011  *           LogSqmUXCommandOffsetInternal (URLMON.423)
1012  *    Undocumented, added in IE8
1013  */
1014 void WINAPI LogSqmUXCommandOffsetInternal(DWORD unk1, DWORD unk2, DWORD unk3, DWORD unk4)
1015 {
1016     FIXME("stub: %d %d %d %d\n", unk1, unk2, unk3, unk4);
1017 }
1018
1019 /***********************************************************************
1020  *           MapUriToBrowserEmulationState (URLMON.444)
1021  *    Undocumented, added in IE8
1022  */
1023 int WINAPI MapUriToBrowserEmulationState(DWORD unk1, DWORD unk2, DWORD unk3)
1024 {
1025     FIXME("stub: %d %d %d\n", unk1, unk2, unk3);
1026     return 0;
1027 }
1028
1029 /***********************************************************************
1030  *           MapBrowserEmulationModeToUserAgent (URLMON.445)
1031  *    Undocumented, added in IE8
1032  */
1033 int WINAPI MapBrowserEmulationModeToUserAgent(DWORD unk1, DWORD unk2)
1034 {
1035     FIXME("stub: %d %d\n", unk1, unk2);
1036     return 0;
1037 }
1038
1039 /***********************************************************************
1040  *            RegisterMediaTypes
1041  *    Added in IE3, registers known MIME-type strings.
1042  */
1043 HRESULT WINAPI RegisterMediaTypes(UINT types, LPCSTR *szTypes, CLIPFORMAT *cfTypes)
1044 {
1045    FIXME("stub: %u %p %p\n", types, szTypes, cfTypes);
1046    return E_INVALIDARG;
1047 }