dlls/urlmon/mimefilter.c

   1 /*
   2  * Copyright 2009 Jacek Caban 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 "urlmon_main.h"
  20 #include "wine/debug.h"
  21
  22 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
  23
  24 typedef struct {
  25     IInternetProtocol     IInternetProtocol_iface;
  26     IInternetProtocolSink IInternetProtocolSink_iface;
  27
  28     LONG ref;
  29 } MimeFilter;
  30
  31 static inline MimeFilter *impl_from_IInternetProtocol(IInternetProtocol *iface)
  32 {
  33     return CONTAINING_RECORD(iface, MimeFilter, IInternetProtocol_iface);
  34 }
  35
  36 static HRESULT WINAPI MimeFilterProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
  37 {
  38     MimeFilter *This = impl_from_IInternetProtocol(iface);
  39
  40     *ppv = NULL;
  41     if(IsEqualGUID(&IID_IUnknown, riid)) {
  42         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
  43         *ppv = &This->IInternetProtocol_iface;
  44     }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
  45         TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", This, ppv);
  46         *ppv = &This->IInternetProtocol_iface;
  47     }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
  48         TRACE("(%p)->(IID_IInternetProtocol %p)\n", This, ppv);
  49         *ppv = &This->IInternetProtocol_iface;
  50     }else if(IsEqualGUID(&IID_IInternetProtocolSink, riid)) {
  51         TRACE("(%p)->(IID_IInternetProtocolSink %p)\n", This, ppv);
  52         *ppv = &This->IInternetProtocolSink_iface;
  53     }
  54
  55     if(*ppv) {
  56         IInternetProtocol_AddRef(iface);
  57         return S_OK;
  58     }
  59
  60     WARN("not supported interface %s\n", debugstr_guid(riid));
  61     return E_NOINTERFACE;
  62 }
  63
  64 static ULONG WINAPI MimeFilterProtocol_AddRef(IInternetProtocol *iface)
  65 {
  66     MimeFilter *This = impl_from_IInternetProtocol(iface);
  67     LONG ref = InterlockedIncrement(&This->ref);
  68     TRACE("(%p) ref=%d\n", This, ref);
  69     return ref;
  70 }
  71
  72 static ULONG WINAPI MimeFilterProtocol_Release(IInternetProtocol *iface)
  73 {
  74     MimeFilter *This = impl_from_IInternetProtocol(iface);
  75     LONG ref = InterlockedDecrement(&This->ref);
  76
  77     TRACE("(%p) ref=%d\n", This, ref);
  78
  79     if(!ref) {
  80         heap_free(This);
  81
  82         URLMON_UnlockModule();
  83     }
  84
  85     return ref;
  86 }
  87
  88 static HRESULT WINAPI MimeFilterProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
  89         IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
  90         DWORD grfPI, HANDLE_PTR dwReserved)
  91 {
  92     MimeFilter *This = impl_from_IInternetProtocol(iface);
  93     FIXME("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink,
  94           pOIBindInfo, grfPI, dwReserved);
  95     return E_NOTIMPL;
  96 }
  97
  98 static HRESULT WINAPI MimeFilterProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData)
  99 {
 100     MimeFilter *This = impl_from_IInternetProtocol(iface);
 101     FIXME("(%p)->(%p)\n", This, pProtocolData);
 102     return E_NOTIMPL;
 103 }
 104
 105 static HRESULT WINAPI MimeFilterProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
 106         DWORD dwOptions)
 107 {
 108     MimeFilter *This = impl_from_IInternetProtocol(iface);
 109     FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
 110     return E_NOTIMPL;
 111 }
 112
 113 static HRESULT WINAPI MimeFilterProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
 114 {
 115     MimeFilter *This = impl_from_IInternetProtocol(iface);
 116     FIXME("(%p)->(%08x)\n", This, dwOptions);
 117     return E_NOTIMPL;
 118 }
 119
 120 static HRESULT WINAPI MimeFilterProtocol_Suspend(IInternetProtocol *iface)
 121 {
 122     MimeFilter *This = impl_from_IInternetProtocol(iface);
 123     FIXME("(%p)\n", This);
 124     return E_NOTIMPL;
 125 }
 126
 127 static HRESULT WINAPI MimeFilterProtocol_Resume(IInternetProtocol *iface)
 128 {
 129     MimeFilter *This = impl_from_IInternetProtocol(iface);
 130     FIXME("(%p)\n", This);
 131     return E_NOTIMPL;
 132 }
 133
 134 static HRESULT WINAPI MimeFilterProtocol_Read(IInternetProtocol *iface, void *pv,
 135         ULONG cb, ULONG *pcbRead)
 136 {
 137     MimeFilter *This = impl_from_IInternetProtocol(iface);
 138     FIXME("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
 139     return E_NOTIMPL;
 140 }
 141
 142 static HRESULT WINAPI MimeFilterProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
 143         DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
 144 {
 145     MimeFilter *This = impl_from_IInternetProtocol(iface);
 146     FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
 147     return E_NOTIMPL;
 148 }
 149
 150 static HRESULT WINAPI MimeFilterProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
 151 {
 152     MimeFilter *This = impl_from_IInternetProtocol(iface);
 153     FIXME("(%p)->(%08x)\n", This, dwOptions);
 154     return E_NOTIMPL;
 155 }
 156
 157 static HRESULT WINAPI MimeFilterProtocol_UnlockRequest(IInternetProtocol *iface)
 158 {
 159     MimeFilter *This = impl_from_IInternetProtocol(iface);
 160     FIXME("(%p)\n", This);
 161     return E_NOTIMPL;
 162 }
 163
 164 static const IInternetProtocolVtbl MimeFilterProtocolVtbl = {
 165     MimeFilterProtocol_QueryInterface,
 166     MimeFilterProtocol_AddRef,
 167     MimeFilterProtocol_Release,
 168     MimeFilterProtocol_Start,
 169     MimeFilterProtocol_Continue,
 170     MimeFilterProtocol_Abort,
 171     MimeFilterProtocol_Terminate,
 172     MimeFilterProtocol_Suspend,
 173     MimeFilterProtocol_Resume,
 174     MimeFilterProtocol_Read,
 175     MimeFilterProtocol_Seek,
 176     MimeFilterProtocol_LockRequest,
 177     MimeFilterProtocol_UnlockRequest
 178 };
 179
 180 static inline MimeFilter *impl_from_IInternetProtocolSink(IInternetProtocolSink *iface)
 181 {
 182     return CONTAINING_RECORD(iface, MimeFilter, IInternetProtocolSink_iface);
 183 }
 184
 185 static HRESULT WINAPI MimeFilterSink_QueryInterface(IInternetProtocolSink *iface,
 186         REFIID riid, void **ppv)
 187 {
 188     MimeFilter *This = impl_from_IInternetProtocolSink(iface);
 189     return IInternetProtocol_QueryInterface(&This->IInternetProtocol_iface, riid, ppv);
 190 }
 191
 192 static ULONG WINAPI MimeFilterSink_AddRef(IInternetProtocolSink *iface)
 193 {
 194     MimeFilter *This = impl_from_IInternetProtocolSink(iface);
 195     return IInternetProtocol_AddRef(&This->IInternetProtocol_iface);
 196 }
 197
 198 static ULONG WINAPI MimeFilterSink_Release(IInternetProtocolSink *iface)
 199 {
 200     MimeFilter *This = impl_from_IInternetProtocolSink(iface);
 201     return IInternetProtocol_Release(&This->IInternetProtocol_iface);
 202 }
 203
 204 static HRESULT WINAPI MimeFilterSink_Switch(IInternetProtocolSink *iface,
 205         PROTOCOLDATA *pProtocolData)
 206 {
 207     MimeFilter *This = impl_from_IInternetProtocolSink(iface);
 208     FIXME("(%p)->(%p)\n", This, pProtocolData);
 209     return E_NOTIMPL;
 210 }
 211
 212 static HRESULT WINAPI MimeFilterSink_ReportProgress(IInternetProtocolSink *iface,
 213         ULONG ulStatusCode, LPCWSTR szStatusText)
 214 {
 215     MimeFilter *This = impl_from_IInternetProtocolSink(iface);
 216     FIXME("(%p)->(%u %s)\n", This, ulStatusCode, debugstr_w(szStatusText));
 217     return E_NOTIMPL;
 218 }
 219
 220 static HRESULT WINAPI MimeFilterSink_ReportData(IInternetProtocolSink *iface,
 221         DWORD grfBSCF, ULONG ulProgress, ULONG ulProgressMax)
 222 {
 223     MimeFilter *This = impl_from_IInternetProtocolSink(iface);
 224     FIXME("(%p)->(%d %u %u)\n", This, grfBSCF, ulProgress, ulProgressMax);
 225     return E_NOTIMPL;
 226 }
 227
 228 static HRESULT WINAPI MimeFilterSink_ReportResult(IInternetProtocolSink *iface,
 229         HRESULT hrResult, DWORD dwError, LPCWSTR szResult)
 230 {
 231     MimeFilter *This = impl_from_IInternetProtocolSink(iface);
 232     FIXME("(%p)->(%08x %d %s)\n", This, hrResult, dwError, debugstr_w(szResult));
 233     return E_NOTIMPL;
 234 }
 235
 236 static const IInternetProtocolSinkVtbl InternetProtocolSinkVtbl = {
 237     MimeFilterSink_QueryInterface,
 238     MimeFilterSink_AddRef,
 239     MimeFilterSink_Release,
 240     MimeFilterSink_Switch,
 241     MimeFilterSink_ReportProgress,
 242     MimeFilterSink_ReportData,
 243     MimeFilterSink_ReportResult
 244 };
 245
 246 HRESULT MimeFilter_Construct(IUnknown *pUnkOuter, LPVOID *ppobj)
 247 {
 248     MimeFilter *ret;
 249
 250     TRACE("(%p %p)\n", pUnkOuter, ppobj);
 251
 252     URLMON_LockModule();
 253
 254     ret = heap_alloc_zero(sizeof(MimeFilter));
 255
 256     ret->IInternetProtocol_iface.lpVtbl = &MimeFilterProtocolVtbl;
 257     ret->IInternetProtocolSink_iface.lpVtbl = &InternetProtocolSinkVtbl;
 258     ret->ref = 1;
 259
 260     *ppobj = &ret->IInternetProtocol_iface;
 261     return S_OK;
 262 }
 263
 264 static BOOL text_richtext_filter(const BYTE *b, DWORD size)
 265 {
 266     return size > 5 && !memcmp(b, "{\\rtf", 5);
 267 }
 268
 269 static BOOL text_html_filter(const BYTE *b, DWORD size)
 270 {
 271     if(size < 6)
 272         return FALSE;
 273
 274     if((b[0] == '<'
 275                 && (b[1] == 'h' || b[1] == 'H')
 276                 && (b[2] == 't' || b[2] == 'T')
 277                 && (b[3] == 'm' || b[3] == 'M')
 278                 && (b[4] == 'l' || b[4] == 'L'))
 279             || (b[0] == '<'
 280                 && (b[1] == 'h' || b[1] == 'H')
 281                 && (b[2] == 'e' || b[2] == 'E')
 282                 && (b[3] == 'a' || b[3] == 'A')
 283                 && (b[4] == 'd' || b[4] == 'D'))
 284             || (b[0] == '<'
 285                 && (b[1] == 'b' || b[1] == 'B')
 286                 && (b[2] == 'o' || b[2] == 'O')
 287                 && (b[3] == 'd' || b[3] == 'D')
 288                 && (b[4] == 'y' || b[4] == 'Y'))) return TRUE;
 289
 290     return FALSE;
 291 }
 292
 293 static BOOL text_xml_filter(const BYTE *b, DWORD size)
 294 {
 295     if(size < 7)
 296         return FALSE;
 297
 298     if(b[0] == '<' && b[1] == '?'
 299             && (b[2] == 'x' || b[2] == 'X')
 300             && (b[3] == 'm' || b[3] == 'M')
 301             && (b[4] == 'l' || b[4] == 'L')
 302             && b[5] == ' ') return TRUE;
 303
 304     return FALSE;
 305 }
 306
 307 static BOOL audio_basic_filter(const BYTE *b, DWORD size)
 308 {
 309     return size > 4
 310         && b[0] == '.' && b[1] == 's' && b[2] == 'n' && b[3] == 'd';
 311 }
 312
 313 static BOOL audio_wav_filter(const BYTE *b, DWORD size)
 314 {
 315     return size > 12
 316         && b[0] == 'R' && b[1] == 'I' && b[2] == 'F' && b[3] == 'F'
 317         && b[8] == 'W' && b[9] == 'A' && b[10] == 'V' && b[11] == 'E';
 318 }
 319
 320 static BOOL image_gif_filter(const BYTE *b, DWORD size)
 321 {
 322     return size >= 6
 323         && (b[0] == 'G' || b[0] == 'g')
 324         && (b[1] == 'I' || b[1] == 'i')
 325         && (b[2] == 'F' || b[2] == 'f')
 326         &&  b[3] == '8'
 327         && (b[4] == '7' || b[4] == '9')
 328         && (b[5] == 'A' || b[5] == 'a');
 329 }
 330
 331 static BOOL image_pjpeg_filter(const BYTE *b, DWORD size)
 332 {
 333     return size > 2 && b[0] == 0xff && b[1] == 0xd8;
 334 }
 335
 336 static BOOL image_tiff_filter(const BYTE *b, DWORD size)
 337 {
 338     static const BYTE magic1[] = {0x4d,0x4d,0x00,0x2a};
 339     static const BYTE magic2[] = {0x49,0x49,0x2a,0xff};
 340
 341     return size >= 4 && (!memcmp(b, magic1, 4) || !memcmp(b, magic2, 4));
 342 }
 343
 344 static BOOL image_xpng_filter(const BYTE *b, DWORD size)
 345 {
 346     static const BYTE xpng_header[] = {0x89,'P','N','G',0x0d,0x0a,0x1a,0x0a};
 347     return size > sizeof(xpng_header) && !memcmp(b, xpng_header, sizeof(xpng_header));
 348 }
 349
 350 static BOOL image_bmp_filter(const BYTE *b, DWORD size)
 351 {
 352     return size >= 14
 353         && b[0] == 0x42 && b[1] == 0x4d
 354         && *(const DWORD *)(b+6) == 0;
 355 }
 356
 357 static BOOL video_avi_filter(const BYTE *b, DWORD size)
 358 {
 359     return size > 12
 360         && b[0] == 'R' && b[1] == 'I' && b[2] == 'F' && b[3] == 'F'
 361         && b[8] == 'A' && b[9] == 'V' && b[10] == 'I' && b[11] == 0x20;
 362 }
 363
 364 static BOOL video_mpeg_filter(const BYTE *b, DWORD size)
 365 {
 366     return size > 4
 367         && !b[0] && !b[1] && b[2] == 0x01
 368         && (b[3] == 0xb3 || b[3] == 0xba);
 369 }
 370
 371 static BOOL application_postscript_filter(const BYTE *b, DWORD size)
 372 {
 373     return size > 2 && b[0] == '%' && b[1] == '!';
 374 }
 375
 376 static BOOL application_pdf_filter(const BYTE *b, DWORD size)
 377 {
 378     return size > 4 && b[0] == 0x25 && b[1] == 0x50 && b[2] == 0x44 && b[3] == 0x46;
 379 }
 380
 381 static BOOL application_xzip_filter(const BYTE *b, DWORD size)
 382 {
 383     return size > 2 && b[0] == 0x50 && b[1] == 0x4b;
 384 }
 385
 386 static BOOL application_xgzip_filter(const BYTE *b, DWORD size)
 387 {
 388     return size > 2 && b[0] == 0x1f && b[1] == 0x8b;
 389 }
 390
 391 static BOOL application_java_filter(const BYTE *b, DWORD size)
 392 {
 393     return size > 4 && b[0] == 0xca && b[1] == 0xfe && b[2] == 0xba && b[3] == 0xbe;
 394 }
 395
 396 static BOOL application_xmsdownload(const BYTE *b, DWORD size)
 397 {
 398     return size > 2 && b[0] == 'M' && b[1] == 'Z';
 399 }
 400
 401 static inline BOOL is_text_plain_char(BYTE b)
 402 {
 403     if(b < 0x20 && b != '\n' && b != '\r' && b != '\t')
 404         return FALSE;
 405     return TRUE;
 406 }
 407
 408 static BOOL text_plain_filter(const BYTE *b, DWORD size)
 409 {
 410     const BYTE *ptr;
 411
 412     for(ptr = b; ptr < b+size-1; ptr++) {
 413         if(!is_text_plain_char(*ptr))
 414             return FALSE;
 415     }
 416
 417     return TRUE;
 418 }
 419
 420 static BOOL application_octet_stream_filter(const BYTE *b, DWORD size)
 421 {
 422     return TRUE;
 423 }
 424
 425 HRESULT find_mime_from_ext(const WCHAR *ext, WCHAR **ret)
 426 {
 427     DWORD res, size;
 428     WCHAR mime[64];
 429     HKEY hkey;
 430
 431     static const WCHAR content_typeW[] = {'C','o','n','t','e','n','t',' ','T','y','p','e','\0'};
 432
 433     res = RegOpenKeyW(HKEY_CLASSES_ROOT, ext, &hkey);
 434     if(res != ERROR_SUCCESS)
 435         return HRESULT_FROM_WIN32(res);
 436
 437     size = sizeof(mime);
 438     res = RegQueryValueExW(hkey, content_typeW, NULL, NULL, (LPBYTE)mime, &size);
 439     RegCloseKey(hkey);
 440     if(res != ERROR_SUCCESS)
 441         return HRESULT_FROM_WIN32(res);
 442
 443     TRACE("found MIME %s\n", debugstr_w(mime));
 444
 445     *ret = CoTaskMemAlloc(size);
 446     memcpy(*ret, mime, size);
 447     return S_OK;
 448 }
 449
 450 static HRESULT find_mime_from_url(const WCHAR *url, WCHAR **ret)
 451 {
 452     const WCHAR *ptr, *end_ptr;
 453     WCHAR *ext = NULL;
 454     HRESULT hres;
 455
 456     for(end_ptr = url; *end_ptr; end_ptr++) {
 457         if(*end_ptr == '?' || *end_ptr == '#')
 458             break;
 459     }
 460
 461     for(ptr = end_ptr; ptr >= url; ptr--) {
 462         if(*ptr == '.')
 463             break;
 464     }
 465
 466     if(ptr < url)
 467         return E_FAIL;
 468
 469     if(*end_ptr) {
 470         unsigned len = end_ptr-ptr;
 471
 472         ext = heap_alloc((len+1)*sizeof(WCHAR));
 473         if(!ext)
 474             return E_OUTOFMEMORY;
 475
 476         memcpy(ext, ptr, len*sizeof(WCHAR));
 477         ext[len] = 0;
 478     }
 479
 480     hres = find_mime_from_ext(ext ? ext : ptr, ret);
 481     heap_free(ext);
 482     return hres;
 483 }
 484
 485 static const WCHAR text_htmlW[] = {'t','e','x','t','/','h','t','m','l',0};
 486 static const WCHAR text_richtextW[] = {'t','e','x','t','/','r','i','c','h','t','e','x','t',0};
 487 static const WCHAR text_xmlW[] = {'t','e','x','t','/','x','m','l',0};
 488 static const WCHAR audio_basicW[] = {'a','u','d','i','o','/','b','a','s','i','c',0};
 489 static const WCHAR audio_wavW[] = {'a','u','d','i','o','/','w','a','v',0};
 490 static const WCHAR image_gifW[] = {'i','m','a','g','e','/','g','i','f',0};
 491 static const WCHAR image_pjpegW[] = {'i','m','a','g','e','/','p','j','p','e','g',0};
 492 static const WCHAR image_tiffW[] = {'i','m','a','g','e','/','t','i','f','f',0};
 493 static const WCHAR image_xpngW[] = {'i','m','a','g','e','/','x','-','p','n','g',0};
 494 static const WCHAR image_bmpW[] = {'i','m','a','g','e','/','b','m','p',0};
 495 static const WCHAR video_aviW[] = {'v','i','d','e','o','/','a','v','i',0};
 496 static const WCHAR video_mpegW[] = {'v','i','d','e','o','/','m','p','e','g',0};
 497 static const WCHAR app_postscriptW[] =
 498         {'a','p','p','l','i','c','a','t','i','o','n','/','p','o','s','t','s','c','r','i','p','t',0};
 499 static const WCHAR app_pdfW[] = {'a','p','p','l','i','c','a','t','i','o','n','/','p','d','f',0};
 500 static const WCHAR app_xzipW[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
 501         'x','-','z','i','p','-','c','o','m','p','r','e','s','s','e','d',0};
 502 static const WCHAR app_xgzipW[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
 503         'x','-','g','z','i','p','-','c','o','m','p','r','e','s','s','e','d',0};
 504 static const WCHAR app_javaW[] = {'a','p','p','l','i','c','a','t','i','o','n','/','j','a','v','a',0};
 505 static const WCHAR app_xmsdownloadW[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
 506         'x','-','m','s','d','o','w','n','l','o','a','d',0};
 507 static const WCHAR text_plainW[] = {'t','e','x','t','/','p','l','a','i','n','\0'};
 508 static const WCHAR app_octetstreamW[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
 509         'o','c','t','e','t','-','s','t','r','e','a','m','\0'};
 510
 511 static const struct {
 512     const WCHAR *mime;
 513     BOOL (*filter)(const BYTE *,DWORD);
 514 } mime_filters_any_pos[] = {
 515     {text_htmlW,       text_html_filter},
 516     {text_xmlW,        text_xml_filter}
 517 }, mime_filters[] = {
 518     {text_richtextW,   text_richtext_filter},
 519  /* {audio_xaiffW,     audio_xaiff_filter}, */
 520     {audio_basicW,     audio_basic_filter},
 521     {audio_wavW,       audio_wav_filter},
 522     {image_gifW,       image_gif_filter},
 523     {image_pjpegW,     image_pjpeg_filter},
 524     {image_tiffW,      image_tiff_filter},
 525     {image_xpngW,      image_xpng_filter},
 526  /* {image_xbitmapW,   image_xbitmap_filter}, */
 527     {image_bmpW,       image_bmp_filter},
 528  /* {image_xjgW,       image_xjg_filter}, */
 529  /* {image_xemfW,      image_xemf_filter}, */
 530  /* {image_xwmfW,      image_xwmf_filter}, */
 531     {video_aviW,       video_avi_filter},
 532     {video_mpegW,      video_mpeg_filter},
 533     {app_postscriptW,  application_postscript_filter},
 534  /* {app_base64W,      application_base64_filter}, */
 535  /* {app_macbinhex40W, application_macbinhex40_filter}, */
 536     {app_pdfW,         application_pdf_filter},
 537  /* {app_zcompressedW, application_xcompressed_filter}, */
 538     {app_xzipW,        application_xzip_filter},
 539     {app_xgzipW,       application_xgzip_filter},
 540     {app_javaW,        application_java_filter},
 541     {app_xmsdownloadW, application_xmsdownload},
 542     {text_plainW,      text_plain_filter},
 543     {app_octetstreamW, application_octet_stream_filter}
 544 };
 545
 546 static BOOL is_known_mime_type(const WCHAR *mime)
 547 {
 548     unsigned i;
 549
 550     for(i=0; i < sizeof(mime_filters_any_pos)/sizeof(*mime_filters_any_pos); i++) {
 551         if(!strcmpW(mime, mime_filters_any_pos[i].mime))
 552             return TRUE;
 553     }
 554
 555     for(i=0; i < sizeof(mime_filters)/sizeof(*mime_filters); i++) {
 556         if(!strcmpW(mime, mime_filters[i].mime))
 557             return TRUE;
 558     }
 559
 560     return FALSE;
 561 }
 562
 563 static HRESULT find_mime_from_buffer(const BYTE *buf, DWORD size, const WCHAR *proposed_mime, const WCHAR *url, WCHAR **ret_mime)
 564 {
 565     int len, i, any_pos_mime = -1;
 566     const WCHAR *ret = NULL;
 567
 568     if(!buf || !size) {
 569         if(!proposed_mime)
 570             return E_FAIL;
 571
 572         len = strlenW(proposed_mime)+1;
 573         *ret_mime = CoTaskMemAlloc(len*sizeof(WCHAR));
 574         if(!*ret_mime)
 575             return E_OUTOFMEMORY;
 576
 577         memcpy(*ret_mime, proposed_mime, len*sizeof(WCHAR));
 578         return S_OK;
 579     }
 580
 581     if(proposed_mime && (!strcmpW(proposed_mime, app_octetstreamW)
 582                 || !strcmpW(proposed_mime, text_plainW)))
 583         proposed_mime = NULL;
 584
 585     if(proposed_mime) {
 586         ret = proposed_mime;
 587
 588         for(i=0; i < sizeof(mime_filters_any_pos)/sizeof(*mime_filters_any_pos); i++) {
 589             if(!strcmpW(proposed_mime, mime_filters_any_pos[i].mime)) {
 590                 any_pos_mime = i;
 591                 for(len=size; len>0; len--) {
 592                     if(mime_filters_any_pos[i].filter(buf+size-len, len))
 593                         break;
 594                 }
 595                 if(!len)
 596                     ret = NULL;
 597                 break;
 598             }
 599         }
 600
 601         if(i == sizeof(mime_filters_any_pos)/sizeof(*mime_filters_any_pos)) {
 602             for(i=0; i < sizeof(mime_filters)/sizeof(*mime_filters); i++) {
 603                 if(!strcmpW(proposed_mime, mime_filters[i].mime)) {
 604                     if(!mime_filters[i].filter(buf, size))
 605                         ret = NULL;
 606                     break;
 607                 }
 608             }
 609         }
 610     }
 611
 612     /* Looks like a bug in native implementation, html and xml mimes
 613      * are not looked for if none of them was proposed */
 614     if(!proposed_mime || any_pos_mime!=-1) {
 615         for(len=size; !ret && len>0; len--) {
 616             for(i=0; i<sizeof(mime_filters_any_pos)/sizeof(*mime_filters_any_pos); i++) {
 617                 if(mime_filters_any_pos[i].filter(buf+size-len, len)) {
 618                     ret = mime_filters_any_pos[i].mime;
 619                     break;
 620                 }
 621             }
 622         }
 623     }
 624
 625     i=0;
 626     while(!ret) {
 627         if(mime_filters[i].filter(buf, size))
 628             ret = mime_filters[i].mime;
 629         i++;
 630     }
 631
 632     if(any_pos_mime!=-1 && ret==text_plainW)
 633         ret = mime_filters_any_pos[any_pos_mime].mime;
 634     else if(proposed_mime && ret==app_octetstreamW) {
 635         for(len=size; ret==app_octetstreamW && len>0; len--) {
 636             if(!is_text_plain_char(buf[size-len]))
 637                 break;
 638             for(i=0; i<sizeof(mime_filters_any_pos)/sizeof(*mime_filters_any_pos); i++) {
 639                 if(mime_filters_any_pos[i].filter(buf+size-len, len)) {
 640                     ret = text_plainW;
 641                     break;
 642                 }
 643             }
 644         }
 645
 646         if(ret == app_octetstreamW)
 647             ret = proposed_mime;
 648     }
 649
 650     if(url && (ret == app_octetstreamW || ret == text_plainW)) {
 651         WCHAR *url_mime;
 652         HRESULT hres;
 653
 654         hres = find_mime_from_url(url, &url_mime);
 655         if(SUCCEEDED(hres)) {
 656             if(!is_known_mime_type(url_mime)) {
 657                 *ret_mime = url_mime;
 658                 return hres;
 659             }
 660             CoTaskMemFree(url_mime);
 661         }
 662     }
 663
 664     TRACE("found %s for %s\n", debugstr_w(ret), debugstr_an((const char*)buf, min(32, size)));
 665
 666     len = strlenW(ret)+1;
 667     *ret_mime = CoTaskMemAlloc(len*sizeof(WCHAR));
 668     if(!*ret_mime)
 669         return E_OUTOFMEMORY;
 670
 671     memcpy(*ret_mime, ret, len*sizeof(WCHAR));
 672     return S_OK;
 673 }
 674
 675 /***********************************************************************
 676  *           FindMimeFromData (URLMON.@)
 677  *
 678  * Determines the Multipurpose Internet Mail Extensions (MIME) type from the data provided.
 679  */
 680 HRESULT WINAPI FindMimeFromData(LPBC pBC, LPCWSTR pwzUrl, LPVOID pBuffer,
 681         DWORD cbSize, LPCWSTR pwzMimeProposed, DWORD dwMimeFlags,
 682         LPWSTR* ppwzMimeOut, DWORD dwReserved)
 683 {
 684     TRACE("(%p,%s,%p,%d,%s,0x%x,%p,0x%x)\n", pBC, debugstr_w(pwzUrl), pBuffer, cbSize,
 685             debugstr_w(pwzMimeProposed), dwMimeFlags, ppwzMimeOut, dwReserved);
 686
 687     if(dwMimeFlags)
 688         WARN("dwMimeFlags=%08x\n", dwMimeFlags);
 689     if(dwReserved)
 690         WARN("dwReserved=%d\n", dwReserved);
 691
 692     /* pBC seams to not be used */
 693
 694     if(!ppwzMimeOut || (!pwzUrl && !pBuffer))
 695         return E_INVALIDARG;
 696
 697     if(pwzMimeProposed || pBuffer)
 698         return find_mime_from_buffer(pBuffer, cbSize, pwzMimeProposed, pwzUrl, ppwzMimeOut);
 699
 700     return find_mime_from_url(pwzUrl, ppwzMimeOut);
 701 }