include: Update the nldef.h and *mib.h headers.
[wine/multimedia.git] / dlls / mshtml / protocol.c
blobd9a008c87c25436e16814c27228cc0b27007fee9
1 /*
2 * Copyright 2005 Jacek Caban
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 "config.h"
21 #include <stdarg.h>
22 #include <stdio.h>
24 #define COBJMACROS
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winuser.h"
29 #include "ole2.h"
31 #include "wine/debug.h"
33 #include "mshtml_private.h"
35 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
37 /********************************************************************
38 * common ProtocolFactory implementation
41 typedef struct {
42 IInternetProtocolInfo IInternetProtocolInfo_iface;
43 IClassFactory IClassFactory_iface;
44 } ProtocolFactory;
46 static inline ProtocolFactory *impl_from_IInternetProtocolInfo(IInternetProtocolInfo *iface)
48 return CONTAINING_RECORD(iface, ProtocolFactory, IInternetProtocolInfo_iface);
51 static HRESULT WINAPI InternetProtocolInfo_QueryInterface(IInternetProtocolInfo *iface, REFIID riid, void **ppv)
53 ProtocolFactory *This = impl_from_IInternetProtocolInfo(iface);
55 *ppv = NULL;
56 if(IsEqualGUID(&IID_IUnknown, riid)) {
57 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
58 *ppv = &This->IInternetProtocolInfo_iface;
59 }else if(IsEqualGUID(&IID_IInternetProtocolInfo, riid)) {
60 TRACE("(%p)->(IID_IInternetProtocolInfo %p)\n", This, ppv);
61 *ppv = &This->IInternetProtocolInfo_iface;
62 }else if(IsEqualGUID(&IID_IClassFactory, riid)) {
63 TRACE("(%p)->(IID_IClassFactory %p)\n", This, ppv);
64 *ppv = &This->IClassFactory_iface;
67 if(!*ppv) {
68 WARN("unknown interface %s\n", debugstr_guid(riid));
69 return E_NOINTERFACE;
72 IInternetProtocolInfo_AddRef(iface);
73 return S_OK;
76 static ULONG WINAPI InternetProtocolInfo_AddRef(IInternetProtocolInfo *iface)
78 TRACE("(%p)\n", iface);
79 return 2;
82 static ULONG WINAPI InternetProtocolInfo_Release(IInternetProtocolInfo *iface)
84 TRACE("(%p)\n", iface);
85 return 1;
88 static HRESULT WINAPI InternetProtocolInfo_CombineUrl(IInternetProtocolInfo *iface,
89 LPCWSTR pwzBaseUrl, LPCWSTR pwzRelativeUrl, DWORD dwCombineFlags, LPWSTR pwzResult,
90 DWORD cchResult, DWORD* pcchResult, DWORD dwReserved)
92 TRACE("%p)->(%s %s %08x %p %d %p %d)\n", iface, debugstr_w(pwzBaseUrl),
93 debugstr_w(pwzRelativeUrl), dwCombineFlags, pwzResult, cchResult,
94 pcchResult, dwReserved);
96 return INET_E_USE_DEFAULT_PROTOCOLHANDLER;
99 static HRESULT WINAPI InternetProtocolInfo_CompareUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl1,
100 LPCWSTR pwzUrl2, DWORD dwCompareFlags)
102 TRACE("%p)->(%s %s %08x)\n", iface, debugstr_w(pwzUrl1), debugstr_w(pwzUrl2), dwCompareFlags);
103 return E_NOTIMPL;
106 static inline ProtocolFactory *impl_from_IClassFactory(IClassFactory *iface)
108 return CONTAINING_RECORD(iface, ProtocolFactory, IClassFactory_iface);
111 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
113 ProtocolFactory *This = impl_from_IClassFactory(iface);
114 return IInternetProtocolInfo_QueryInterface(&This->IInternetProtocolInfo_iface, riid, ppv);
117 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
119 ProtocolFactory *This = impl_from_IClassFactory(iface);
120 return IInternetProtocolInfo_AddRef(&This->IInternetProtocolInfo_iface);
123 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
125 ProtocolFactory *This = impl_from_IClassFactory(iface);
126 return IInternetProtocolInfo_Release(&This->IInternetProtocolInfo_iface);
129 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
131 TRACE("(%p)->(%x)\n", iface, dolock);
132 return S_OK;
135 /********************************************************************
136 * AboutProtocol implementation
139 typedef struct {
140 IInternetProtocol IInternetProtocol_iface;
142 LONG ref;
144 BYTE *data;
145 ULONG data_len;
146 ULONG cur;
148 IUnknown *pUnkOuter;
149 } AboutProtocol;
151 static inline AboutProtocol *AboutProtocol_from_IInternetProtocol(IInternetProtocol *iface)
153 return CONTAINING_RECORD(iface, AboutProtocol, IInternetProtocol_iface);
156 static HRESULT WINAPI AboutProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
158 AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
160 *ppv = NULL;
162 if(IsEqualGUID(&IID_IUnknown, riid)) {
163 TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
164 if(This->pUnkOuter)
165 return IUnknown_QueryInterface(This->pUnkOuter, riid, ppv);
166 *ppv = &This->IInternetProtocol_iface;
167 }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
168 TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", iface, ppv);
169 *ppv = &This->IInternetProtocol_iface;
170 }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
171 TRACE("(%p)->(IID_IInternetProtocol %p)\n", iface, ppv);
172 *ppv = &This->IInternetProtocol_iface;
173 }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
174 FIXME("IServiceProvider is not implemented\n");
175 return E_NOINTERFACE;
178 if(!*ppv) {
179 TRACE("unknown interface %s\n", debugstr_guid(riid));
180 return E_NOINTERFACE;
183 IInternetProtocol_AddRef(iface);
184 return S_OK;
187 static ULONG WINAPI AboutProtocol_AddRef(IInternetProtocol *iface)
189 AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
190 ULONG ref = InterlockedIncrement(&This->ref);
191 TRACE("(%p) ref=%d\n", iface, ref);
192 return This->pUnkOuter ? IUnknown_AddRef(This->pUnkOuter) : ref;
195 static ULONG WINAPI AboutProtocol_Release(IInternetProtocol *iface)
197 AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
198 IUnknown *pUnkOuter = This->pUnkOuter;
199 ULONG ref = InterlockedDecrement(&This->ref);
201 TRACE("(%p) ref=%x\n", iface, ref);
203 if(!ref) {
204 heap_free(This->data);
205 heap_free(This);
208 return pUnkOuter ? IUnknown_Release(pUnkOuter) : ref;
211 static HRESULT WINAPI AboutProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
212 IInternetProtocolSink* pOIProtSink, IInternetBindInfo* pOIBindInfo,
213 DWORD grfPI, HANDLE_PTR dwReserved)
215 AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
216 BINDINFO bindinfo;
217 DWORD grfBINDF = 0;
218 LPCWSTR text = NULL;
219 DWORD data_len;
220 BYTE *data;
222 static const WCHAR html_begin[] = {0xfeff,'<','H','T','M','L','>',0};
223 static const WCHAR html_end[] = {'<','/','H','T','M','L','>',0};
224 static const WCHAR wszBlank[] = {'b','l','a','n','k',0};
225 static const WCHAR wszAbout[] = {'a','b','o','u','t',':'};
226 static const WCHAR wszTextHtml[] = {'t','e','x','t','/','h','t','m','l',0};
228 /* NOTE:
229 * the about protocol seems not to work as I would expect. It creates html document
230 * for a given url, eg. about:some_text -> <HTML>some_text</HTML> except for the case when
231 * some_text = "blank", when document is blank (<HTML></HMTL>). The same happens
232 * when the url does not have "about:" in the beginning.
235 TRACE("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink,
236 pOIBindInfo, grfPI, dwReserved);
238 memset(&bindinfo, 0, sizeof(bindinfo));
239 bindinfo.cbSize = sizeof(BINDINFO);
240 IInternetBindInfo_GetBindInfo(pOIBindInfo, &grfBINDF, &bindinfo);
241 ReleaseBindInfo(&bindinfo);
243 TRACE("bindf %x\n", grfBINDF);
245 if(strlenW(szUrl)>=sizeof(wszAbout)/sizeof(WCHAR) && !memcmp(wszAbout, szUrl, sizeof(wszAbout))) {
246 text = szUrl + sizeof(wszAbout)/sizeof(WCHAR);
247 if(!strcmpW(wszBlank, text))
248 text = NULL;
251 data_len = sizeof(html_begin)+sizeof(html_end)-sizeof(WCHAR)
252 + (text ? strlenW(text)*sizeof(WCHAR) : 0);
253 data = heap_alloc(data_len);
254 if(!data)
255 return E_OUTOFMEMORY;
257 heap_free(This->data);
258 This->data = data;
259 This->data_len = data_len;
261 memcpy(This->data, html_begin, sizeof(html_begin));
262 if(text)
263 strcatW((LPWSTR)This->data, text);
264 strcatW((LPWSTR)This->data, html_end);
266 This->cur = 0;
268 IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_MIMETYPEAVAILABLE, wszTextHtml);
270 IInternetProtocolSink_ReportData(pOIProtSink,
271 BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE,
272 This->data_len, This->data_len);
274 IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL);
276 return S_OK;
279 static HRESULT WINAPI AboutProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA* pProtocolData)
281 AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
282 FIXME("(%p)->(%p)\n", This, pProtocolData);
283 return E_NOTIMPL;
286 static HRESULT WINAPI AboutProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
287 DWORD dwOptions)
289 AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
290 FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
291 return E_NOTIMPL;
294 static HRESULT WINAPI AboutProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
296 AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
297 TRACE("(%p)->(%08x)\n", This, dwOptions);
298 return S_OK;
301 static HRESULT WINAPI AboutProtocol_Suspend(IInternetProtocol *iface)
303 AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
304 FIXME("(%p)\n", This);
305 return E_NOTIMPL;
308 static HRESULT WINAPI AboutProtocol_Resume(IInternetProtocol *iface)
310 AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
311 FIXME("(%p)\n", This);
312 return E_NOTIMPL;
315 static HRESULT WINAPI AboutProtocol_Read(IInternetProtocol *iface, void* pv, ULONG cb, ULONG* pcbRead)
317 AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
319 TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
321 if(!This->data)
322 return E_FAIL;
324 *pcbRead = (cb > This->data_len-This->cur ? This->data_len-This->cur : cb);
326 if(!*pcbRead)
327 return S_FALSE;
329 memcpy(pv, This->data+This->cur, *pcbRead);
330 This->cur += *pcbRead;
332 return S_OK;
335 static HRESULT WINAPI AboutProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
336 DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition)
338 AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
339 FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
340 return E_NOTIMPL;
343 static HRESULT WINAPI AboutProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
345 AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
347 TRACE("(%p)->(%d)\n", This, dwOptions);
349 return S_OK;
352 static HRESULT WINAPI AboutProtocol_UnlockRequest(IInternetProtocol *iface)
354 AboutProtocol *This = AboutProtocol_from_IInternetProtocol(iface);
356 TRACE("(%p)\n", This);
358 return S_OK;
361 static const IInternetProtocolVtbl AboutProtocolVtbl = {
362 AboutProtocol_QueryInterface,
363 AboutProtocol_AddRef,
364 AboutProtocol_Release,
365 AboutProtocol_Start,
366 AboutProtocol_Continue,
367 AboutProtocol_Abort,
368 AboutProtocol_Terminate,
369 AboutProtocol_Suspend,
370 AboutProtocol_Resume,
371 AboutProtocol_Read,
372 AboutProtocol_Seek,
373 AboutProtocol_LockRequest,
374 AboutProtocol_UnlockRequest
377 static HRESULT WINAPI AboutProtocolFactory_CreateInstance(IClassFactory *iface, IUnknown *pUnkOuter,
378 REFIID riid, void **ppv)
380 AboutProtocol *ret;
381 HRESULT hres = S_OK;
383 TRACE("(%p)->(%p %s %p)\n", iface, pUnkOuter, debugstr_guid(riid), ppv);
385 ret = heap_alloc(sizeof(AboutProtocol));
386 ret->IInternetProtocol_iface.lpVtbl = &AboutProtocolVtbl;
387 ret->ref = 0;
389 ret->data = NULL;
390 ret->data_len = 0;
391 ret->cur = 0;
392 ret->pUnkOuter = pUnkOuter;
394 if(pUnkOuter) {
395 ret->ref = 1;
396 if(IsEqualGUID(&IID_IUnknown, riid))
397 *ppv = &ret->IInternetProtocol_iface;
398 else
399 hres = E_INVALIDARG;
400 }else {
401 hres = IInternetProtocol_QueryInterface(&ret->IInternetProtocol_iface, riid, ppv);
404 if(FAILED(hres))
405 heap_free(ret);
407 return hres;
410 static HRESULT WINAPI AboutProtocolInfo_ParseUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
411 PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult, DWORD cchResult,
412 DWORD* pcchResult, DWORD dwReserved)
414 TRACE("%p)->(%s %d %08x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), ParseAction,
415 dwParseFlags, pwzResult, cchResult, pcchResult, dwReserved);
417 if(ParseAction == PARSE_SECURITY_URL) {
418 unsigned int len = strlenW(pwzUrl)+1;
420 *pcchResult = len;
421 if(len > cchResult)
422 return S_FALSE;
424 memcpy(pwzResult, pwzUrl, len*sizeof(WCHAR));
425 return S_OK;
428 if(ParseAction == PARSE_DOMAIN) {
429 if(!pcchResult)
430 return E_POINTER;
432 if(pwzUrl)
433 *pcchResult = strlenW(pwzUrl)+1;
434 else
435 *pcchResult = 1;
436 return E_FAIL;
439 return INET_E_DEFAULT_ACTION;
442 static HRESULT WINAPI AboutProtocolInfo_QueryInfo(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
443 QUERYOPTION QueryOption, DWORD dwQueryFlags, LPVOID pBuffer, DWORD cbBuffer, DWORD* pcbBuf,
444 DWORD dwReserved)
446 TRACE("%p)->(%s %08x %08x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), QueryOption, dwQueryFlags, pBuffer,
447 cbBuffer, pcbBuf, dwReserved);
449 switch(QueryOption) {
450 case QUERY_CAN_NAVIGATE:
451 return INET_E_USE_DEFAULT_PROTOCOLHANDLER;
453 case QUERY_USES_NETWORK:
454 if(!pBuffer || cbBuffer < sizeof(DWORD))
455 return E_FAIL;
457 *(DWORD*)pBuffer = 0;
458 if(pcbBuf)
459 *pcbBuf = sizeof(DWORD);
461 break;
463 case QUERY_IS_CACHED:
464 FIXME("Unsupported option QUERY_IS_CACHED\n");
465 return E_NOTIMPL;
466 case QUERY_IS_INSTALLEDENTRY:
467 FIXME("Unsupported option QUERY_IS_INSTALLEDENTRY\n");
468 return E_NOTIMPL;
469 case QUERY_IS_CACHED_OR_MAPPED:
470 FIXME("Unsupported option QUERY_IS_CACHED_OR_MAPPED\n");
471 return E_NOTIMPL;
472 case QUERY_IS_SECURE:
473 FIXME("Unsupported option QUERY_IS_SECURE\n");
474 return E_NOTIMPL;
475 case QUERY_IS_SAFE:
476 FIXME("Unsupported option QUERY_IS_SAFE\n");
477 return E_NOTIMPL;
478 case QUERY_USES_HISTORYFOLDER:
479 FIXME("Unsupported option QUERY_USES_HISTORYFOLDER\n");
480 return E_FAIL;
481 case QUERY_IS_CACHED_AND_USABLE_OFFLINE:
482 FIXME("Unsupported option QUERY_IS_CACHED_AND_USABLE_OFFLINE\n");
483 return E_NOTIMPL;
484 default:
485 return E_FAIL;
488 return S_OK;
491 static const IInternetProtocolInfoVtbl AboutProtocolInfoVtbl = {
492 InternetProtocolInfo_QueryInterface,
493 InternetProtocolInfo_AddRef,
494 InternetProtocolInfo_Release,
495 AboutProtocolInfo_ParseUrl,
496 InternetProtocolInfo_CombineUrl,
497 InternetProtocolInfo_CompareUrl,
498 AboutProtocolInfo_QueryInfo
501 static const IClassFactoryVtbl AboutProtocolFactoryVtbl = {
502 ClassFactory_QueryInterface,
503 ClassFactory_AddRef,
504 ClassFactory_Release,
505 AboutProtocolFactory_CreateInstance,
506 ClassFactory_LockServer
509 static ProtocolFactory AboutProtocolFactory = {
510 { &AboutProtocolInfoVtbl },
511 { &AboutProtocolFactoryVtbl }
514 /********************************************************************
515 * ResProtocol implementation
518 typedef struct {
519 IInternetProtocol IInternetProtocol_iface;
520 LONG ref;
522 BYTE *data;
523 ULONG data_len;
524 ULONG cur;
526 IUnknown *pUnkOuter;
527 } ResProtocol;
529 static inline ResProtocol *ResProtocol_from_IInternetProtocol(IInternetProtocol *iface)
531 return CONTAINING_RECORD(iface, ResProtocol, IInternetProtocol_iface);
534 static HRESULT WINAPI ResProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
536 ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
538 *ppv = NULL;
540 if(IsEqualGUID(&IID_IUnknown, riid)) {
541 TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
542 if(This->pUnkOuter)
543 return IUnknown_QueryInterface(This->pUnkOuter, &IID_IUnknown, ppv);
544 *ppv = &This->IInternetProtocol_iface;
545 }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
546 TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", iface, ppv);
547 *ppv = &This->IInternetProtocol_iface;
548 }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
549 TRACE("(%p)->(IID_IInternetProtocol %p)\n", iface, ppv);
550 *ppv = &This->IInternetProtocol_iface;
551 }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
552 FIXME("IServiceProvider is not implemented\n");
553 return E_NOINTERFACE;
556 if(!*ppv) {
557 TRACE("unknown interface %s\n", debugstr_guid(riid));
558 return E_NOINTERFACE;
561 IInternetProtocol_AddRef(iface);
562 return S_OK;
565 static ULONG WINAPI ResProtocol_AddRef(IInternetProtocol *iface)
567 ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
568 ULONG ref = InterlockedIncrement(&This->ref);
569 TRACE("(%p) ref=%d\n", iface, ref);
570 return This->pUnkOuter ? IUnknown_AddRef(This->pUnkOuter) : ref;
573 static ULONG WINAPI ResProtocol_Release(IInternetProtocol *iface)
575 ResProtocol *This = (ResProtocol*)iface;
576 IUnknown *pUnkOuter = This->pUnkOuter;
577 ULONG ref = InterlockedDecrement(&This->ref);
579 TRACE("(%p) ref=%x\n", iface, ref);
581 if(!ref) {
582 heap_free(This->data);
583 heap_free(This);
586 return pUnkOuter ? IUnknown_Release(pUnkOuter) : ref;
589 static HRESULT WINAPI ResProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
590 IInternetProtocolSink* pOIProtSink, IInternetBindInfo* pOIBindInfo,
591 DWORD grfPI, HANDLE_PTR dwReserved)
593 ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
594 DWORD grfBINDF = 0, len;
595 BINDINFO bindinfo;
596 LPWSTR url_dll, url_file, url, mime, res_type = (LPWSTR)RT_HTML;
597 HMODULE hdll;
598 HRSRC src;
599 HRESULT hres;
601 static const WCHAR wszRes[] = {'r','e','s',':','/','/'};
603 TRACE("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink,
604 pOIBindInfo, grfPI, dwReserved);
606 memset(&bindinfo, 0, sizeof(bindinfo));
607 bindinfo.cbSize = sizeof(BINDINFO);
608 IInternetBindInfo_GetBindInfo(pOIBindInfo, &grfBINDF, &bindinfo);
609 ReleaseBindInfo(&bindinfo);
611 len = strlenW(szUrl)+16;
612 url = heap_alloc(len*sizeof(WCHAR));
613 hres = CoInternetParseUrl(szUrl, PARSE_ENCODE, 0, url, len, &len, 0);
614 if(FAILED(hres)) {
615 WARN("CoInternetParseUrl failed: %08x\n", hres);
616 heap_free(url);
617 IInternetProtocolSink_ReportResult(pOIProtSink, hres, 0, NULL);
618 return hres;
621 if(len < sizeof(wszRes)/sizeof(wszRes[0]) || memcmp(url, wszRes, sizeof(wszRes))) {
622 WARN("Wrong protocol of url: %s\n", debugstr_w(url));
623 IInternetProtocolSink_ReportResult(pOIProtSink, E_INVALIDARG, 0, NULL);
624 heap_free(url);
625 return E_INVALIDARG;
628 url_dll = url + sizeof(wszRes)/sizeof(wszRes[0]);
629 if(!(url_file = strrchrW(url_dll, '/'))) {
630 WARN("wrong url: %s\n", debugstr_w(url));
631 IInternetProtocolSink_ReportResult(pOIProtSink, MK_E_SYNTAX, 0, NULL);
632 heap_free(url);
633 return MK_E_SYNTAX;
636 *url_file++ = 0;
637 hdll = LoadLibraryExW(url_dll, NULL, LOAD_LIBRARY_AS_DATAFILE);
638 if(!hdll) {
639 if (!(res_type = strrchrW(url_dll, '/'))) {
640 WARN("Could not open dll: %s\n", debugstr_w(url_dll));
641 IInternetProtocolSink_ReportResult(pOIProtSink, HRESULT_FROM_WIN32(GetLastError()), 0, NULL);
642 heap_free(url);
643 return HRESULT_FROM_WIN32(GetLastError());
645 *res_type++ = 0;
647 hdll = LoadLibraryExW(url_dll, NULL, LOAD_LIBRARY_AS_DATAFILE);
648 if(!hdll) {
649 WARN("Could not open dll: %s\n", debugstr_w(url_dll));
650 IInternetProtocolSink_ReportResult(pOIProtSink, HRESULT_FROM_WIN32(GetLastError()), 0, NULL);
651 heap_free(url);
652 return HRESULT_FROM_WIN32(GetLastError());
656 TRACE("trying to find resource type %s, name %s\n", debugstr_w(res_type), debugstr_w(url_file));
658 src = FindResourceW(hdll, url_file, res_type);
659 if(!src) {
660 LPWSTR endpoint = NULL;
661 DWORD file_id = strtolW(url_file, &endpoint, 10);
662 if(endpoint == url_file+strlenW(url_file))
663 src = FindResourceW(hdll, MAKEINTRESOURCEW(file_id), MAKEINTRESOURCEW(RT_HTML));
665 if(!src) {
666 WARN("Could not find resource\n");
667 IInternetProtocolSink_ReportResult(pOIProtSink,
668 HRESULT_FROM_WIN32(GetLastError()), 0, NULL);
669 heap_free(url);
670 return HRESULT_FROM_WIN32(GetLastError());
674 if(This->data) {
675 WARN("data already loaded\n");
676 heap_free(This->data);
679 This->data_len = SizeofResource(hdll, src);
680 This->data = heap_alloc(This->data_len);
681 memcpy(This->data, LoadResource(hdll, src), This->data_len);
682 This->cur = 0;
684 FreeLibrary(hdll);
686 hres = FindMimeFromData(NULL, url_file, This->data, This->data_len, NULL, 0, &mime, 0);
687 heap_free(url);
688 if(SUCCEEDED(hres)) {
689 IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_MIMETYPEAVAILABLE, mime);
690 CoTaskMemFree(mime);
693 IInternetProtocolSink_ReportData(pOIProtSink,
694 BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE,
695 This->data_len, This->data_len);
697 IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL);
699 return S_OK;
702 static HRESULT WINAPI ResProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA* pProtocolData)
704 ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
705 FIXME("(%p)->(%p)\n", This, pProtocolData);
706 return E_NOTIMPL;
709 static HRESULT WINAPI ResProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
710 DWORD dwOptions)
712 ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
713 FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
714 return E_NOTIMPL;
717 static HRESULT WINAPI ResProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
719 ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
721 TRACE("(%p)->(%08x)\n", This, dwOptions);
723 /* test show that we don't have to do anything here */
724 return S_OK;
727 static HRESULT WINAPI ResProtocol_Suspend(IInternetProtocol *iface)
729 ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
730 FIXME("(%p)\n", This);
731 return E_NOTIMPL;
734 static HRESULT WINAPI ResProtocol_Resume(IInternetProtocol *iface)
736 ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
737 FIXME("(%p)\n", This);
738 return E_NOTIMPL;
741 static HRESULT WINAPI ResProtocol_Read(IInternetProtocol *iface, void* pv, ULONG cb, ULONG* pcbRead)
743 ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
745 TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
747 if(!This->data)
748 return E_FAIL;
750 *pcbRead = (cb > This->data_len-This->cur ? This->data_len-This->cur : cb);
752 if(!*pcbRead)
753 return S_FALSE;
755 memcpy(pv, This->data+This->cur, *pcbRead);
756 This->cur += *pcbRead;
758 return S_OK;
761 static HRESULT WINAPI ResProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
762 DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition)
764 ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
765 FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
766 return E_NOTIMPL;
769 static HRESULT WINAPI ResProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
771 ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
773 TRACE("(%p)->(%d)\n", This, dwOptions);
775 /* test show that we don't have to do anything here */
776 return S_OK;
779 static HRESULT WINAPI ResProtocol_UnlockRequest(IInternetProtocol *iface)
781 ResProtocol *This = ResProtocol_from_IInternetProtocol(iface);
783 TRACE("(%p)\n", This);
785 /* test show that we don't have to do anything here */
786 return S_OK;
789 static const IInternetProtocolVtbl ResProtocolVtbl = {
790 ResProtocol_QueryInterface,
791 ResProtocol_AddRef,
792 ResProtocol_Release,
793 ResProtocol_Start,
794 ResProtocol_Continue,
795 ResProtocol_Abort,
796 ResProtocol_Terminate,
797 ResProtocol_Suspend,
798 ResProtocol_Resume,
799 ResProtocol_Read,
800 ResProtocol_Seek,
801 ResProtocol_LockRequest,
802 ResProtocol_UnlockRequest
805 static HRESULT WINAPI ResProtocolFactory_CreateInstance(IClassFactory *iface, IUnknown *pUnkOuter,
806 REFIID riid, void **ppv)
808 ResProtocol *ret;
809 HRESULT hres = S_OK;
811 TRACE("(%p)->(%p %s %p)\n", iface, pUnkOuter, debugstr_guid(riid), ppv);
813 ret = heap_alloc(sizeof(ResProtocol));
814 ret->IInternetProtocol_iface.lpVtbl = &ResProtocolVtbl;
815 ret->ref = 0;
816 ret->data = NULL;
817 ret->data_len = 0;
818 ret->cur = 0;
819 ret->pUnkOuter = pUnkOuter;
821 if(pUnkOuter) {
822 ret->ref = 1;
823 if(IsEqualGUID(&IID_IUnknown, riid))
824 *ppv = &ret->IInternetProtocol_iface;
825 else
826 hres = E_FAIL;
827 }else {
828 hres = IInternetProtocol_QueryInterface(&ret->IInternetProtocol_iface, riid, ppv);
831 if(FAILED(hres))
832 heap_free(ret);
834 return hres;
837 static HRESULT WINAPI ResProtocolInfo_ParseUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
838 PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult, DWORD cchResult,
839 DWORD* pcchResult, DWORD dwReserved)
841 TRACE("%p)->(%s %d %x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), ParseAction,
842 dwParseFlags, pwzResult, cchResult, pcchResult, dwReserved);
844 if(ParseAction == PARSE_SECURITY_URL) {
845 WCHAR file_part[MAX_PATH], full_path[MAX_PATH];
846 WCHAR *ptr;
847 DWORD size, len;
849 static const WCHAR wszFile[] = {'f','i','l','e',':','/','/'};
850 static const WCHAR wszRes[] = {'r','e','s',':','/','/'};
852 if(strlenW(pwzUrl) <= sizeof(wszRes)/sizeof(WCHAR) || memcmp(pwzUrl, wszRes, sizeof(wszRes)))
853 return E_INVALIDARG;
855 ptr = strchrW(pwzUrl + sizeof(wszRes)/sizeof(WCHAR), '/');
856 if(!ptr)
857 return E_INVALIDARG;
859 len = ptr - (pwzUrl + sizeof(wszRes)/sizeof(WCHAR));
860 if(len >= sizeof(file_part)/sizeof(WCHAR)) {
861 FIXME("Too long URL\n");
862 return MK_E_SYNTAX;
865 memcpy(file_part, pwzUrl + sizeof(wszRes)/sizeof(WCHAR), len*sizeof(WCHAR));
866 file_part[len] = 0;
868 len = SearchPathW(NULL, file_part, NULL, sizeof(full_path)/sizeof(WCHAR), full_path, NULL);
869 if(!len) {
870 HMODULE module;
872 /* SearchPath does not work well with winelib files (like our test executable),
873 * so we also try to load the library here */
874 module = LoadLibraryExW(file_part, NULL, LOAD_LIBRARY_AS_DATAFILE);
875 if(!module) {
876 WARN("Could not find file %s\n", debugstr_w(file_part));
877 return MK_E_SYNTAX;
880 len = GetModuleFileNameW(module, full_path, sizeof(full_path)/sizeof(WCHAR));
881 FreeLibrary(module);
882 if(!len)
883 return E_FAIL;
886 size = sizeof(wszFile)/sizeof(WCHAR) + len + 1;
887 if(pcchResult)
888 *pcchResult = size;
889 if(size > cchResult)
890 return S_FALSE;
892 memcpy(pwzResult, wszFile, sizeof(wszFile));
893 memcpy(pwzResult + sizeof(wszFile)/sizeof(WCHAR), full_path, (len+1)*sizeof(WCHAR));
894 return S_OK;
897 if(ParseAction == PARSE_DOMAIN) {
898 if(!pcchResult)
899 return E_POINTER;
901 if(pwzUrl)
902 *pcchResult = strlenW(pwzUrl)+1;
903 else
904 *pcchResult = 1;
905 return E_FAIL;
908 return INET_E_DEFAULT_ACTION;
911 static HRESULT WINAPI ResProtocolInfo_QueryInfo(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
912 QUERYOPTION QueryOption, DWORD dwQueryFlags, LPVOID pBuffer, DWORD cbBuffer, DWORD* pcbBuf,
913 DWORD dwReserved)
915 TRACE("%p)->(%s %08x %08x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), QueryOption, dwQueryFlags, pBuffer,
916 cbBuffer, pcbBuf, dwReserved);
918 switch(QueryOption) {
919 case QUERY_USES_NETWORK:
920 if(!pBuffer || cbBuffer < sizeof(DWORD))
921 return E_FAIL;
923 *(DWORD*)pBuffer = 0;
924 if(pcbBuf)
925 *pcbBuf = sizeof(DWORD);
926 break;
928 case QUERY_IS_SECURE:
929 FIXME("QUERY_IS_SECURE not supported\n");
930 return E_NOTIMPL;
931 case QUERY_IS_SAFE:
932 FIXME("QUERY_IS_SAFE not supported\n");
933 return E_NOTIMPL;
934 default:
935 return INET_E_USE_DEFAULT_PROTOCOLHANDLER;
938 return S_OK;
941 static const IInternetProtocolInfoVtbl ResProtocolInfoVtbl = {
942 InternetProtocolInfo_QueryInterface,
943 InternetProtocolInfo_AddRef,
944 InternetProtocolInfo_Release,
945 ResProtocolInfo_ParseUrl,
946 InternetProtocolInfo_CombineUrl,
947 InternetProtocolInfo_CompareUrl,
948 ResProtocolInfo_QueryInfo
951 static const IClassFactoryVtbl ResProtocolFactoryVtbl = {
952 ClassFactory_QueryInterface,
953 ClassFactory_AddRef,
954 ClassFactory_Release,
955 ResProtocolFactory_CreateInstance,
956 ClassFactory_LockServer
959 static ProtocolFactory ResProtocolFactory = {
960 { &ResProtocolInfoVtbl },
961 { &ResProtocolFactoryVtbl }
964 /********************************************************************
965 * JSProtocol implementation
968 static HRESULT WINAPI JSProtocolFactory_CreateInstance(IClassFactory *iface, IUnknown *pUnkOuter,
969 REFIID riid, void **ppv)
971 FIXME("(%p)->(%p %s %p)\n", iface, pUnkOuter, debugstr_guid(riid), ppv);
972 return E_NOTIMPL;
975 static HRESULT WINAPI JSProtocolInfo_ParseUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
976 PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult, DWORD cchResult,
977 DWORD* pcchResult, DWORD dwReserved)
979 TRACE("%p)->(%s %d %x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), ParseAction,
980 dwParseFlags, pwzResult, cchResult, pcchResult, dwReserved);
982 switch(ParseAction) {
983 case PARSE_SECURITY_URL:
984 FIXME("PARSE_SECURITY_URL\n");
985 return E_NOTIMPL;
986 case PARSE_DOMAIN:
987 FIXME("PARSE_DOMAIN\n");
988 return E_NOTIMPL;
989 default:
990 return INET_E_DEFAULT_ACTION;
993 return S_OK;
996 static HRESULT WINAPI JSProtocolInfo_QueryInfo(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
997 QUERYOPTION QueryOption, DWORD dwQueryFlags, LPVOID pBuffer, DWORD cbBuffer, DWORD* pcbBuf,
998 DWORD dwReserved)
1000 TRACE("%p)->(%s %08x %08x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), QueryOption, dwQueryFlags, pBuffer,
1001 cbBuffer, pcbBuf, dwReserved);
1003 switch(QueryOption) {
1004 case QUERY_USES_NETWORK:
1005 if(!pBuffer || cbBuffer < sizeof(DWORD))
1006 return E_FAIL;
1008 *(DWORD*)pBuffer = 0;
1009 if(pcbBuf)
1010 *pcbBuf = sizeof(DWORD);
1011 break;
1013 case QUERY_IS_SECURE:
1014 FIXME("QUERY_IS_SECURE not supported\n");
1015 return E_NOTIMPL;
1017 default:
1018 return INET_E_USE_DEFAULT_PROTOCOLHANDLER;
1021 return S_OK;
1024 static const IInternetProtocolInfoVtbl JSProtocolInfoVtbl = {
1025 InternetProtocolInfo_QueryInterface,
1026 InternetProtocolInfo_AddRef,
1027 InternetProtocolInfo_Release,
1028 JSProtocolInfo_ParseUrl,
1029 InternetProtocolInfo_CombineUrl,
1030 InternetProtocolInfo_CompareUrl,
1031 JSProtocolInfo_QueryInfo
1034 static const IClassFactoryVtbl JSProtocolFactoryVtbl = {
1035 ClassFactory_QueryInterface,
1036 ClassFactory_AddRef,
1037 ClassFactory_Release,
1038 JSProtocolFactory_CreateInstance,
1039 ClassFactory_LockServer
1042 static ProtocolFactory JSProtocolFactory = {
1043 { &JSProtocolInfoVtbl },
1044 { &JSProtocolFactoryVtbl }
1047 HRESULT ProtocolFactory_Create(REFCLSID rclsid, REFIID riid, void **ppv)
1049 ProtocolFactory *cf = NULL;
1051 if(IsEqualGUID(&CLSID_AboutProtocol, rclsid))
1052 cf = &AboutProtocolFactory;
1053 else if(IsEqualGUID(&CLSID_ResProtocol, rclsid))
1054 cf = &ResProtocolFactory;
1055 else if(IsEqualGUID(&CLSID_JSProtocol, rclsid))
1056 cf = &JSProtocolFactory;
1058 if(!cf) {
1059 FIXME("not implemented protocol %s\n", debugstr_guid(rclsid));
1060 return CLASS_E_CLASSNOTAVAILABLE;
1063 return IInternetProtocolInfo_QueryInterface(&cf->IInternetProtocolInfo_iface, riid, ppv);