2 * Copyright 2009 Jacek Caban for CodeWeavers
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.
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.
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
19 #include "urlmon_main.h"
22 IInternetProtocol IInternetProtocol_iface
;
23 IInternetProtocolSink IInternetProtocolSink_iface
;
28 static inline MimeFilter
*impl_from_IInternetProtocol(IInternetProtocol
*iface
)
30 return CONTAINING_RECORD(iface
, MimeFilter
, IInternetProtocol_iface
);
33 static HRESULT WINAPI
MimeFilterProtocol_QueryInterface(IInternetProtocol
*iface
, REFIID riid
, void **ppv
)
35 MimeFilter
*This
= impl_from_IInternetProtocol(iface
);
38 if(IsEqualGUID(&IID_IUnknown
, riid
)) {
39 TRACE("(%p)->(IID_IUnknown %p)\n", This
, ppv
);
40 *ppv
= &This
->IInternetProtocol_iface
;
41 }else if(IsEqualGUID(&IID_IInternetProtocolRoot
, riid
)) {
42 TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", This
, ppv
);
43 *ppv
= &This
->IInternetProtocol_iface
;
44 }else if(IsEqualGUID(&IID_IInternetProtocol
, riid
)) {
45 TRACE("(%p)->(IID_IInternetProtocol %p)\n", This
, ppv
);
46 *ppv
= &This
->IInternetProtocol_iface
;
47 }else if(IsEqualGUID(&IID_IInternetProtocolSink
, riid
)) {
48 TRACE("(%p)->(IID_IInternetProtocolSink %p)\n", This
, ppv
);
49 *ppv
= &This
->IInternetProtocolSink_iface
;
53 IInternetProtocol_AddRef(iface
);
57 WARN("not supported interface %s\n", debugstr_guid(riid
));
61 static ULONG WINAPI
MimeFilterProtocol_AddRef(IInternetProtocol
*iface
)
63 MimeFilter
*This
= impl_from_IInternetProtocol(iface
);
64 LONG ref
= InterlockedIncrement(&This
->ref
);
65 TRACE("(%p) ref=%d\n", This
, ref
);
69 static ULONG WINAPI
MimeFilterProtocol_Release(IInternetProtocol
*iface
)
71 MimeFilter
*This
= impl_from_IInternetProtocol(iface
);
72 LONG ref
= InterlockedDecrement(&This
->ref
);
74 TRACE("(%p) ref=%d\n", This
, ref
);
79 URLMON_UnlockModule();
85 static HRESULT WINAPI
MimeFilterProtocol_Start(IInternetProtocol
*iface
, LPCWSTR szUrl
,
86 IInternetProtocolSink
*pOIProtSink
, IInternetBindInfo
*pOIBindInfo
,
87 DWORD grfPI
, HANDLE_PTR dwReserved
)
89 MimeFilter
*This
= impl_from_IInternetProtocol(iface
);
90 FIXME("(%p)->(%s %p %p %08x %lx)\n", This
, debugstr_w(szUrl
), pOIProtSink
,
91 pOIBindInfo
, grfPI
, dwReserved
);
95 static HRESULT WINAPI
MimeFilterProtocol_Continue(IInternetProtocol
*iface
, PROTOCOLDATA
*pProtocolData
)
97 MimeFilter
*This
= impl_from_IInternetProtocol(iface
);
98 FIXME("(%p)->(%p)\n", This
, pProtocolData
);
102 static HRESULT WINAPI
MimeFilterProtocol_Abort(IInternetProtocol
*iface
, HRESULT hrReason
,
105 MimeFilter
*This
= impl_from_IInternetProtocol(iface
);
106 FIXME("(%p)->(%08x %08x)\n", This
, hrReason
, dwOptions
);
110 static HRESULT WINAPI
MimeFilterProtocol_Terminate(IInternetProtocol
*iface
, DWORD dwOptions
)
112 MimeFilter
*This
= impl_from_IInternetProtocol(iface
);
113 FIXME("(%p)->(%08x)\n", This
, dwOptions
);
117 static HRESULT WINAPI
MimeFilterProtocol_Suspend(IInternetProtocol
*iface
)
119 MimeFilter
*This
= impl_from_IInternetProtocol(iface
);
120 FIXME("(%p)\n", This
);
124 static HRESULT WINAPI
MimeFilterProtocol_Resume(IInternetProtocol
*iface
)
126 MimeFilter
*This
= impl_from_IInternetProtocol(iface
);
127 FIXME("(%p)\n", This
);
131 static HRESULT WINAPI
MimeFilterProtocol_Read(IInternetProtocol
*iface
, void *pv
,
132 ULONG cb
, ULONG
*pcbRead
)
134 MimeFilter
*This
= impl_from_IInternetProtocol(iface
);
135 FIXME("(%p)->(%p %u %p)\n", This
, pv
, cb
, pcbRead
);
139 static HRESULT WINAPI
MimeFilterProtocol_Seek(IInternetProtocol
*iface
, LARGE_INTEGER dlibMove
,
140 DWORD dwOrigin
, ULARGE_INTEGER
*plibNewPosition
)
142 MimeFilter
*This
= impl_from_IInternetProtocol(iface
);
143 FIXME("(%p)->(%d %d %p)\n", This
, dlibMove
.u
.LowPart
, dwOrigin
, plibNewPosition
);
147 static HRESULT WINAPI
MimeFilterProtocol_LockRequest(IInternetProtocol
*iface
, DWORD dwOptions
)
149 MimeFilter
*This
= impl_from_IInternetProtocol(iface
);
150 FIXME("(%p)->(%08x)\n", This
, dwOptions
);
154 static HRESULT WINAPI
MimeFilterProtocol_UnlockRequest(IInternetProtocol
*iface
)
156 MimeFilter
*This
= impl_from_IInternetProtocol(iface
);
157 FIXME("(%p)\n", This
);
161 static const IInternetProtocolVtbl MimeFilterProtocolVtbl
= {
162 MimeFilterProtocol_QueryInterface
,
163 MimeFilterProtocol_AddRef
,
164 MimeFilterProtocol_Release
,
165 MimeFilterProtocol_Start
,
166 MimeFilterProtocol_Continue
,
167 MimeFilterProtocol_Abort
,
168 MimeFilterProtocol_Terminate
,
169 MimeFilterProtocol_Suspend
,
170 MimeFilterProtocol_Resume
,
171 MimeFilterProtocol_Read
,
172 MimeFilterProtocol_Seek
,
173 MimeFilterProtocol_LockRequest
,
174 MimeFilterProtocol_UnlockRequest
177 static inline MimeFilter
*impl_from_IInternetProtocolSink(IInternetProtocolSink
*iface
)
179 return CONTAINING_RECORD(iface
, MimeFilter
, IInternetProtocolSink_iface
);
182 static HRESULT WINAPI
MimeFilterSink_QueryInterface(IInternetProtocolSink
*iface
,
183 REFIID riid
, void **ppv
)
185 MimeFilter
*This
= impl_from_IInternetProtocolSink(iface
);
186 return IInternetProtocol_QueryInterface(&This
->IInternetProtocol_iface
, riid
, ppv
);
189 static ULONG WINAPI
MimeFilterSink_AddRef(IInternetProtocolSink
*iface
)
191 MimeFilter
*This
= impl_from_IInternetProtocolSink(iface
);
192 return IInternetProtocol_AddRef(&This
->IInternetProtocol_iface
);
195 static ULONG WINAPI
MimeFilterSink_Release(IInternetProtocolSink
*iface
)
197 MimeFilter
*This
= impl_from_IInternetProtocolSink(iface
);
198 return IInternetProtocol_Release(&This
->IInternetProtocol_iface
);
201 static HRESULT WINAPI
MimeFilterSink_Switch(IInternetProtocolSink
*iface
,
202 PROTOCOLDATA
*pProtocolData
)
204 MimeFilter
*This
= impl_from_IInternetProtocolSink(iface
);
205 FIXME("(%p)->(%p)\n", This
, pProtocolData
);
209 static HRESULT WINAPI
MimeFilterSink_ReportProgress(IInternetProtocolSink
*iface
,
210 ULONG ulStatusCode
, LPCWSTR szStatusText
)
212 MimeFilter
*This
= impl_from_IInternetProtocolSink(iface
);
213 FIXME("(%p)->(%u %s)\n", This
, ulStatusCode
, debugstr_w(szStatusText
));
217 static HRESULT WINAPI
MimeFilterSink_ReportData(IInternetProtocolSink
*iface
,
218 DWORD grfBSCF
, ULONG ulProgress
, ULONG ulProgressMax
)
220 MimeFilter
*This
= impl_from_IInternetProtocolSink(iface
);
221 FIXME("(%p)->(%d %u %u)\n", This
, grfBSCF
, ulProgress
, ulProgressMax
);
225 static HRESULT WINAPI
MimeFilterSink_ReportResult(IInternetProtocolSink
*iface
,
226 HRESULT hrResult
, DWORD dwError
, LPCWSTR szResult
)
228 MimeFilter
*This
= impl_from_IInternetProtocolSink(iface
);
229 FIXME("(%p)->(%08x %d %s)\n", This
, hrResult
, dwError
, debugstr_w(szResult
));
233 static const IInternetProtocolSinkVtbl InternetProtocolSinkVtbl
= {
234 MimeFilterSink_QueryInterface
,
235 MimeFilterSink_AddRef
,
236 MimeFilterSink_Release
,
237 MimeFilterSink_Switch
,
238 MimeFilterSink_ReportProgress
,
239 MimeFilterSink_ReportData
,
240 MimeFilterSink_ReportResult
243 HRESULT
MimeFilter_Construct(IUnknown
*pUnkOuter
, LPVOID
*ppobj
)
247 TRACE("(%p %p)\n", pUnkOuter
, ppobj
);
251 ret
= heap_alloc_zero(sizeof(MimeFilter
));
253 ret
->IInternetProtocol_iface
.lpVtbl
= &MimeFilterProtocolVtbl
;
254 ret
->IInternetProtocolSink_iface
.lpVtbl
= &InternetProtocolSinkVtbl
;
257 *ppobj
= &ret
->IInternetProtocol_iface
;
261 static BOOL
text_richtext_filter(const BYTE
*b
, DWORD size
)
263 return size
> 5 && !memcmp(b
, "{\\rtf", 5);
266 static BOOL
text_html_filter(const BYTE
*b
, DWORD size
)
272 && (b
[1] == 'h' || b
[1] == 'H')
273 && (b
[2] == 't' || b
[2] == 'T')
274 && (b
[3] == 'm' || b
[3] == 'M')
275 && (b
[4] == 'l' || b
[4] == 'L'))
277 && (b
[1] == 'h' || b
[1] == 'H')
278 && (b
[2] == 'e' || b
[2] == 'E')
279 && (b
[3] == 'a' || b
[3] == 'A')
280 && (b
[4] == 'd' || b
[4] == 'D'))) return TRUE
;
285 static BOOL
text_xml_filter(const BYTE
*b
, DWORD size
)
290 if(b
[0] == '<' && b
[1] == '?'
291 && (b
[2] == 'x' || b
[2] == 'X')
292 && (b
[3] == 'm' || b
[3] == 'M')
293 && (b
[4] == 'l' || b
[4] == 'L')
294 && b
[5] == ' ') return TRUE
;
299 static BOOL
audio_basic_filter(const BYTE
*b
, DWORD size
)
302 && b
[0] == '.' && b
[1] == 's' && b
[2] == 'n' && b
[3] == 'd';
305 static BOOL
audio_wav_filter(const BYTE
*b
, DWORD size
)
308 && b
[0] == 'R' && b
[1] == 'I' && b
[2] == 'F' && b
[3] == 'F'
309 && b
[8] == 'W' && b
[9] == 'A' && b
[10] == 'V' && b
[11] == 'E';
312 static BOOL
image_gif_filter(const BYTE
*b
, DWORD size
)
315 && (b
[0] == 'G' || b
[0] == 'g')
316 && (b
[1] == 'I' || b
[1] == 'i')
317 && (b
[2] == 'F' || b
[2] == 'f')
319 && (b
[4] == '7' || b
[4] == '9')
320 && (b
[5] == 'A' || b
[5] == 'a');
323 static BOOL
image_pjpeg_filter(const BYTE
*b
, DWORD size
)
325 return size
> 2 && b
[0] == 0xff && b
[1] == 0xd8;
328 static BOOL
image_tiff_filter(const BYTE
*b
, DWORD size
)
330 static const BYTE magic1
[] = {0x4d,0x4d,0x00,0x2a};
331 static const BYTE magic2
[] = {0x49,0x49,0x2a,0xff};
333 return size
>= 4 && (!memcmp(b
, magic1
, 4) || !memcmp(b
, magic2
, 4));
336 static BOOL
image_xpng_filter(const BYTE
*b
, DWORD size
)
338 static const BYTE xpng_header
[] = {0x89,'P','N','G',0x0d,0x0a,0x1a,0x0a};
339 return size
> sizeof(xpng_header
) && !memcmp(b
, xpng_header
, sizeof(xpng_header
));
342 static BOOL
image_bmp_filter(const BYTE
*b
, DWORD size
)
345 && b
[0] == 0x42 && b
[1] == 0x4d
346 && *(const DWORD
*)(b
+6) == 0;
349 static BOOL
video_avi_filter(const BYTE
*b
, DWORD size
)
352 && b
[0] == 'R' && b
[1] == 'I' && b
[2] == 'F' && b
[3] == 'F'
353 && b
[8] == 'A' && b
[9] == 'V' && b
[10] == 'I' && b
[11] == 0x20;
356 static BOOL
video_mpeg_filter(const BYTE
*b
, DWORD size
)
359 && !b
[0] && !b
[1] && b
[2] == 0x01
360 && (b
[3] == 0xb3 || b
[3] == 0xba);
363 static BOOL
application_postscript_filter(const BYTE
*b
, DWORD size
)
365 return size
> 2 && b
[0] == '%' && b
[1] == '!';
368 static BOOL
application_pdf_filter(const BYTE
*b
, DWORD size
)
370 return size
> 4 && b
[0] == 0x25 && b
[1] == 0x50 && b
[2] == 0x44 && b
[3] == 0x46;
373 static BOOL
application_xzip_filter(const BYTE
*b
, DWORD size
)
375 return size
> 2 && b
[0] == 0x50 && b
[1] == 0x4b;
378 static BOOL
application_xgzip_filter(const BYTE
*b
, DWORD size
)
380 return size
> 2 && b
[0] == 0x1f && b
[1] == 0x8b;
383 static BOOL
application_java_filter(const BYTE
*b
, DWORD size
)
385 return size
> 4 && b
[0] == 0xca && b
[1] == 0xfe && b
[2] == 0xba && b
[3] == 0xbe;
388 static BOOL
application_xmsdownload(const BYTE
*b
, DWORD size
)
390 return size
> 2 && b
[0] == 'M' && b
[1] == 'Z';
393 static inline BOOL
is_text_plain_char(BYTE b
)
395 if(b
< 0x20 && b
!= '\n' && b
!= '\r' && b
!= '\t')
400 static BOOL
text_plain_filter(const BYTE
*b
, DWORD size
)
404 for(ptr
= b
; ptr
< b
+size
-1; ptr
++) {
405 if(!is_text_plain_char(*ptr
))
412 static BOOL
application_octet_stream_filter(const BYTE
*b
, DWORD size
)
417 static HRESULT
find_mime_from_url(const WCHAR
*url
, WCHAR
**ret
)
424 static const WCHAR content_typeW
[] = {'C','o','n','t','e','n','t',' ','T','y','p','e','\0'};
426 ptr
= strrchrW(url
, '.');
430 res
= RegOpenKeyW(HKEY_CLASSES_ROOT
, ptr
, &hkey
);
431 if(res
!= ERROR_SUCCESS
)
432 return HRESULT_FROM_WIN32(res
);
435 res
= RegQueryValueExW(hkey
, content_typeW
, NULL
, NULL
, (LPBYTE
)mime
, &size
);
437 if(res
!= ERROR_SUCCESS
)
438 return HRESULT_FROM_WIN32(res
);
440 TRACE("found MIME %s\n", debugstr_w(mime
));
442 *ret
= CoTaskMemAlloc(size
);
443 memcpy(*ret
, mime
, size
);
447 static const WCHAR text_htmlW
[] = {'t','e','x','t','/','h','t','m','l',0};
448 static const WCHAR text_richtextW
[] = {'t','e','x','t','/','r','i','c','h','t','e','x','t',0};
449 static const WCHAR text_xmlW
[] = {'t','e','x','t','/','x','m','l',0};
450 static const WCHAR audio_basicW
[] = {'a','u','d','i','o','/','b','a','s','i','c',0};
451 static const WCHAR audio_wavW
[] = {'a','u','d','i','o','/','w','a','v',0};
452 static const WCHAR image_gifW
[] = {'i','m','a','g','e','/','g','i','f',0};
453 static const WCHAR image_pjpegW
[] = {'i','m','a','g','e','/','p','j','p','e','g',0};
454 static const WCHAR image_tiffW
[] = {'i','m','a','g','e','/','t','i','f','f',0};
455 static const WCHAR image_xpngW
[] = {'i','m','a','g','e','/','x','-','p','n','g',0};
456 static const WCHAR image_bmpW
[] = {'i','m','a','g','e','/','b','m','p',0};
457 static const WCHAR video_aviW
[] = {'v','i','d','e','o','/','a','v','i',0};
458 static const WCHAR video_mpegW
[] = {'v','i','d','e','o','/','m','p','e','g',0};
459 static const WCHAR app_postscriptW
[] =
460 {'a','p','p','l','i','c','a','t','i','o','n','/','p','o','s','t','s','c','r','i','p','t',0};
461 static const WCHAR app_pdfW
[] = {'a','p','p','l','i','c','a','t','i','o','n','/','p','d','f',0};
462 static const WCHAR app_xzipW
[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
463 'x','-','z','i','p','-','c','o','m','p','r','e','s','s','e','d',0};
464 static const WCHAR app_xgzipW
[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
465 'x','-','g','z','i','p','-','c','o','m','p','r','e','s','s','e','d',0};
466 static const WCHAR app_javaW
[] = {'a','p','p','l','i','c','a','t','i','o','n','/','j','a','v','a',0};
467 static const WCHAR app_xmsdownloadW
[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
468 'x','-','m','s','d','o','w','n','l','o','a','d',0};
469 static const WCHAR text_plainW
[] = {'t','e','x','t','/','p','l','a','i','n','\0'};
470 static const WCHAR app_octetstreamW
[] = {'a','p','p','l','i','c','a','t','i','o','n','/',
471 'o','c','t','e','t','-','s','t','r','e','a','m','\0'};
473 static const struct {
475 BOOL (*filter
)(const BYTE
*,DWORD
);
476 } mime_filters_any_pos
[] = {
477 {text_htmlW
, text_html_filter
},
478 {text_xmlW
, text_xml_filter
}
479 }, mime_filters
[] = {
480 {text_richtextW
, text_richtext_filter
},
481 /* {audio_xaiffW, audio_xaiff_filter}, */
482 {audio_basicW
, audio_basic_filter
},
483 {audio_wavW
, audio_wav_filter
},
484 {image_gifW
, image_gif_filter
},
485 {image_pjpegW
, image_pjpeg_filter
},
486 {image_tiffW
, image_tiff_filter
},
487 {image_xpngW
, image_xpng_filter
},
488 /* {image_xbitmapW, image_xbitmap_filter}, */
489 {image_bmpW
, image_bmp_filter
},
490 /* {image_xjgW, image_xjg_filter}, */
491 /* {image_xemfW, image_xemf_filter}, */
492 /* {image_xwmfW, image_xwmf_filter}, */
493 {video_aviW
, video_avi_filter
},
494 {video_mpegW
, video_mpeg_filter
},
495 {app_postscriptW
, application_postscript_filter
},
496 /* {app_base64W, application_base64_filter}, */
497 /* {app_macbinhex40W, application_macbinhex40_filter}, */
498 {app_pdfW
, application_pdf_filter
},
499 /* {app_zcompressedW, application_xcompressed_filter}, */
500 {app_xzipW
, application_xzip_filter
},
501 {app_xgzipW
, application_xgzip_filter
},
502 {app_javaW
, application_java_filter
},
503 {app_xmsdownloadW
, application_xmsdownload
},
504 {text_plainW
, text_plain_filter
},
505 {app_octetstreamW
, application_octet_stream_filter
}
508 static BOOL
is_known_mime_type(const WCHAR
*mime
)
512 for(i
=0; i
< sizeof(mime_filters_any_pos
)/sizeof(*mime_filters_any_pos
); i
++) {
513 if(!strcmpW(mime
, mime_filters_any_pos
[i
].mime
))
517 for(i
=0; i
< sizeof(mime_filters
)/sizeof(*mime_filters
); i
++) {
518 if(!strcmpW(mime
, mime_filters
[i
].mime
))
525 static HRESULT
find_mime_from_buffer(const BYTE
*buf
, DWORD size
, const WCHAR
*proposed_mime
, const WCHAR
*url
, WCHAR
**ret_mime
)
527 int len
, i
, any_pos_mime
= -1;
528 const WCHAR
*ret
= NULL
;
534 len
= strlenW(proposed_mime
)+1;
535 *ret_mime
= CoTaskMemAlloc(len
*sizeof(WCHAR
));
537 return E_OUTOFMEMORY
;
539 memcpy(*ret_mime
, proposed_mime
, len
*sizeof(WCHAR
));
543 if(proposed_mime
&& (!strcmpW(proposed_mime
, app_octetstreamW
)
544 || !strcmpW(proposed_mime
, text_plainW
)))
545 proposed_mime
= NULL
;
550 for(i
=0; i
< sizeof(mime_filters_any_pos
)/sizeof(*mime_filters_any_pos
); i
++) {
551 if(!strcmpW(proposed_mime
, mime_filters_any_pos
[i
].mime
)) {
553 for(len
=size
; len
>0; len
--) {
554 if(mime_filters_any_pos
[i
].filter(buf
+size
-len
, len
))
563 if(i
== sizeof(mime_filters_any_pos
)/sizeof(*mime_filters_any_pos
)) {
564 for(i
=0; i
< sizeof(mime_filters
)/sizeof(*mime_filters
); i
++) {
565 if(!strcmpW(proposed_mime
, mime_filters
[i
].mime
)) {
566 if(!mime_filters
[i
].filter(buf
, size
))
574 /* Looks like a bug in native implementation, html and xml mimes
575 * are not looked for if none of them was proposed */
576 if(!proposed_mime
|| any_pos_mime
!=-1) {
577 for(len
=size
; !ret
&& len
>0; len
--) {
578 for(i
=0; i
<sizeof(mime_filters_any_pos
)/sizeof(*mime_filters_any_pos
); i
++) {
579 if(mime_filters_any_pos
[i
].filter(buf
+size
-len
, len
)) {
580 ret
= mime_filters_any_pos
[i
].mime
;
589 if(mime_filters
[i
].filter(buf
, size
))
590 ret
= mime_filters
[i
].mime
;
594 if(any_pos_mime
!=-1 && ret
==text_plainW
)
595 ret
= mime_filters_any_pos
[any_pos_mime
].mime
;
596 else if(proposed_mime
&& ret
==app_octetstreamW
) {
597 for(len
=size
; ret
==app_octetstreamW
&& len
>0; len
--) {
598 if(!is_text_plain_char(buf
[size
-len
]))
600 for(i
=0; i
<sizeof(mime_filters_any_pos
)/sizeof(*mime_filters_any_pos
); i
++) {
601 if(mime_filters_any_pos
[i
].filter(buf
+size
-len
, len
)) {
608 if(ret
== app_octetstreamW
)
612 if(url
&& (ret
== app_octetstreamW
|| ret
== text_plainW
)) {
616 hres
= find_mime_from_url(url
, &url_mime
);
617 if(SUCCEEDED(hres
)) {
618 if(!is_known_mime_type(url_mime
)) {
619 *ret_mime
= url_mime
;
622 CoTaskMemFree(url_mime
);
626 TRACE("found %s for %s\n", debugstr_w(ret
), debugstr_an((const char*)buf
, min(32, size
)));
628 len
= strlenW(ret
)+1;
629 *ret_mime
= CoTaskMemAlloc(len
*sizeof(WCHAR
));
631 return E_OUTOFMEMORY
;
633 memcpy(*ret_mime
, ret
, len
*sizeof(WCHAR
));
637 /***********************************************************************
638 * FindMimeFromData (URLMON.@)
640 * Determines the Multipurpose Internet Mail Extensions (MIME) type from the data provided.
642 HRESULT WINAPI
FindMimeFromData(LPBC pBC
, LPCWSTR pwzUrl
, LPVOID pBuffer
,
643 DWORD cbSize
, LPCWSTR pwzMimeProposed
, DWORD dwMimeFlags
,
644 LPWSTR
* ppwzMimeOut
, DWORD dwReserved
)
646 TRACE("(%p,%s,%p,%d,%s,0x%x,%p,0x%x)\n", pBC
, debugstr_w(pwzUrl
), pBuffer
, cbSize
,
647 debugstr_w(pwzMimeProposed
), dwMimeFlags
, ppwzMimeOut
, dwReserved
);
650 WARN("dwMimeFlags=%08x\n", dwMimeFlags
);
652 WARN("dwReserved=%d\n", dwReserved
);
654 /* pBC seams to not be used */
656 if(!ppwzMimeOut
|| (!pwzUrl
&& !pBuffer
))
659 if(pwzMimeProposed
|| pBuffer
)
660 return find_mime_from_buffer(pBuffer
, cbSize
, pwzMimeProposed
, pwzUrl
, ppwzMimeOut
);
663 return find_mime_from_url(pwzUrl
, ppwzMimeOut
);