kernel32/tests: Prevent memory leak.
[wine] / dlls / mshtml / protocol.c
1 /*
2  * Copyright 2005 Jacek Caban
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 "config.h"
20
21 #include <stdarg.h>
22 #include <stdio.h>
23
24 #define COBJMACROS
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winuser.h"
29 #include "ole2.h"
30
31 #include "wine/debug.h"
32 #include "wine/unicode.h"
33
34 #include "mshtml_private.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
37
38 /********************************************************************
39  * common ProtocolFactory implementation
40  */
41
42 #define PROTOCOLINFO(x) ((IInternetProtocolInfo*) &(x)->lpInternetProtocolInfoVtbl)
43 #define CLASSFACTORY(x) ((IClassFactory*)         &(x)->lpClassFactoryVtbl)
44 #define PROTOCOL(x)     ((IInternetProtocol*)     &(x)->lpInternetProtocolVtbl)
45
46 typedef struct {
47     const IInternetProtocolInfoVtbl *lpInternetProtocolInfoVtbl;
48     const IClassFactoryVtbl         *lpClassFactoryVtbl;
49 } ProtocolFactory;
50
51 #define PROTOCOLINFO_THIS(iface) DEFINE_THIS(ProtocolFactory, InternetProtocolInfo, iface)
52
53 static HRESULT WINAPI InternetProtocolInfo_QueryInterface(IInternetProtocolInfo *iface, REFIID riid, void **ppv)
54 {
55     ProtocolFactory *This = PROTOCOLINFO_THIS(iface);
56
57     *ppv = NULL;
58     if(IsEqualGUID(&IID_IUnknown, riid)) {
59         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
60         *ppv = PROTOCOLINFO(This);
61     }else if(IsEqualGUID(&IID_IInternetProtocolInfo, riid)) {
62         TRACE("(%p)->(IID_IInternetProtocolInfo %p)\n", This, ppv);
63         *ppv = PROTOCOLINFO(This);
64     }else if(IsEqualGUID(&IID_IClassFactory, riid)) {
65         TRACE("(%p)->(IID_IClassFactory %p)\n", This, ppv);
66         *ppv = CLASSFACTORY(This);
67     }
68
69     if(!*ppv) {
70         WARN("unknown interface %s\n", debugstr_guid(riid));
71         return E_NOINTERFACE;
72     }
73
74     IInternetProtocolInfo_AddRef(iface);
75     return S_OK;
76 }
77
78 static ULONG WINAPI InternetProtocolInfo_AddRef(IInternetProtocolInfo *iface)
79 {
80     ProtocolFactory *This = PROTOCOLINFO_THIS(iface);
81     TRACE("(%p)\n", This);
82     LOCK_MODULE();
83     return 2;
84 }
85
86 static ULONG WINAPI InternetProtocolInfo_Release(IInternetProtocolInfo *iface)
87 {
88     ProtocolFactory *This = PROTOCOLINFO_THIS(iface);
89     TRACE("(%p)\n", This);
90     UNLOCK_MODULE();
91     return 1;
92 }
93
94 static HRESULT WINAPI InternetProtocolInfo_CombineUrl(IInternetProtocolInfo *iface,
95         LPCWSTR pwzBaseUrl, LPCWSTR pwzRelativeUrl, DWORD dwCombineFlags, LPWSTR pwzResult,
96         DWORD cchResult, DWORD* pcchResult, DWORD dwReserved)
97 {
98     TRACE("%p)->(%s %s %08x %p %d %p %d)\n", iface, debugstr_w(pwzBaseUrl),
99             debugstr_w(pwzRelativeUrl), dwCombineFlags, pwzResult, cchResult,
100             pcchResult, dwReserved);
101
102     return INET_E_USE_DEFAULT_PROTOCOLHANDLER;
103 }
104
105 static HRESULT WINAPI InternetProtocolInfo_CompareUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl1,
106         LPCWSTR pwzUrl2, DWORD dwCompareFlags)
107 {
108     TRACE("%p)->(%s %s %08x)\n", iface, debugstr_w(pwzUrl1), debugstr_w(pwzUrl2), dwCompareFlags);
109     return E_NOTIMPL;
110 }
111
112 #undef PROTOCOLINFO_THIS
113
114 #define CLASSFACTORY_THIS(iface) DEFINE_THIS(ProtocolFactory, ClassFactory, iface)
115
116 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
117 {
118     ProtocolFactory *This = CLASSFACTORY_THIS(iface);
119     return IInternetProtocolInfo_QueryInterface(PROTOCOLINFO(This), riid, ppv);
120 }
121
122 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
123 {
124     ProtocolFactory *This = CLASSFACTORY_THIS(iface);
125     return IInternetProtocolInfo_AddRef(PROTOCOLINFO(This));
126 }
127
128 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
129 {
130     ProtocolFactory *This = CLASSFACTORY_THIS(iface);
131     return IInternetProtocolInfo_Release(PROTOCOLINFO(This));
132 }
133
134 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
135 {
136     ProtocolFactory *This = CLASSFACTORY_THIS(iface);
137
138     TRACE("(%p)->(%x)\n", This, dolock);
139
140     if(dolock)
141         LOCK_MODULE();
142     else
143         UNLOCK_MODULE();
144
145     return S_OK;
146 }
147
148 #undef CLASSFACTORY_THIS
149
150 /********************************************************************
151  * AboutProtocol implementation
152  */
153
154 typedef struct {
155     const IInternetProtocolVtbl *lpInternetProtocolVtbl;
156
157     LONG ref;
158
159     BYTE *data;
160     ULONG data_len;
161     ULONG cur;
162
163     IUnknown *pUnkOuter;
164 } AboutProtocol;
165
166 #define PROTOCOL_THIS(iface) DEFINE_THIS(AboutProtocol, InternetProtocol, iface)
167
168 static HRESULT WINAPI AboutProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
169 {
170     AboutProtocol *This = PROTOCOL_THIS(iface);
171
172     *ppv = NULL;
173
174     if(IsEqualGUID(&IID_IUnknown, riid)) {
175         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
176         if(This->pUnkOuter)
177             return IUnknown_QueryInterface(This->pUnkOuter, riid, ppv);
178         *ppv = PROTOCOL(This);
179     }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
180         TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", iface, ppv);
181         *ppv = PROTOCOL(This);
182     }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
183         TRACE("(%p)->(IID_IInternetProtocol %p)\n", iface, ppv);
184         *ppv = PROTOCOL(This);
185     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
186         FIXME("IServiceProvider is not implemented\n");
187         return E_NOINTERFACE;
188     }
189
190     if(!*ppv) {
191         TRACE("unknown interface %s\n", debugstr_guid(riid));
192         return E_NOINTERFACE;
193     }
194
195     IInternetProtocol_AddRef(iface);
196     return S_OK;
197 }
198
199 static ULONG WINAPI AboutProtocol_AddRef(IInternetProtocol *iface)
200 {
201     AboutProtocol *This = PROTOCOL_THIS(iface);
202     ULONG ref = InterlockedIncrement(&This->ref);
203     TRACE("(%p) ref=%d\n", iface, ref);
204     return This->pUnkOuter ? IUnknown_AddRef(This->pUnkOuter) : ref;
205 }
206
207 static ULONG WINAPI AboutProtocol_Release(IInternetProtocol *iface)
208 {
209     AboutProtocol *This = PROTOCOL_THIS(iface);
210     IUnknown *pUnkOuter = This->pUnkOuter;
211     ULONG ref = InterlockedDecrement(&This->ref);
212
213     TRACE("(%p) ref=%x\n", iface, ref);
214
215     if(!ref) {
216         mshtml_free(This->data);
217         mshtml_free(This);
218         UNLOCK_MODULE();
219     }
220
221     return pUnkOuter ? IUnknown_Release(pUnkOuter) : ref;
222 }
223
224 static HRESULT WINAPI AboutProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
225         IInternetProtocolSink* pOIProtSink, IInternetBindInfo* pOIBindInfo,
226         DWORD grfPI, DWORD dwReserved)
227 {
228     AboutProtocol *This = PROTOCOL_THIS(iface);
229     BINDINFO bindinfo;
230     DWORD grfBINDF = 0;
231     LPCWSTR text = NULL;
232
233     static const WCHAR html_begin[] = {0xfeff,'<','H','T','M','L','>',0};
234     static const WCHAR html_end[] = {'<','/','H','T','M','L','>',0};
235     static const WCHAR wszBlank[] = {'b','l','a','n','k',0};
236     static const WCHAR wszAbout[] = {'a','b','o','u','t',':'};
237     static const WCHAR wszTextHtml[] = {'t','e','x','t','/','h','t','m','l',0};
238
239     /* NOTE:
240      * the about protocol seems not to work as I would expect. It creates html document
241      * for a given url, eg. about:some_text -> <HTML>some_text</HTML> except for the case when
242      * some_text = "blank", when document is blank (<HTML></HMTL>). The same happens
243      * when the url does not have "about:" in the beginning.
244      */
245
246     TRACE("(%p)->(%s %p %p %08x %d)\n", This, debugstr_w(szUrl), pOIProtSink,
247             pOIBindInfo, grfPI, dwReserved);
248
249     memset(&bindinfo, 0, sizeof(bindinfo));
250     bindinfo.cbSize = sizeof(BINDINFO);
251     IInternetBindInfo_GetBindInfo(pOIBindInfo, &grfBINDF, &bindinfo);
252     ReleaseBindInfo(&bindinfo);
253
254     if(strlenW(szUrl)>=sizeof(wszAbout)/sizeof(WCHAR) && !memcmp(wszAbout, szUrl, sizeof(wszAbout))) {
255         text = szUrl + sizeof(wszAbout)/sizeof(WCHAR);
256         if(!strcmpW(wszBlank, text))
257             text = NULL;
258     }
259
260     This->data_len = sizeof(html_begin)+sizeof(html_end)-sizeof(WCHAR) 
261         + (text ? strlenW(text)*sizeof(WCHAR) : 0);
262     This->data = mshtml_alloc(This->data_len);
263
264     memcpy(This->data, html_begin, sizeof(html_begin));
265     if(text)
266         strcatW((LPWSTR)This->data, text);
267     strcatW((LPWSTR)This->data, html_end);
268     
269     This->cur = 0;
270
271     IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_MIMETYPEAVAILABLE, wszTextHtml);
272
273     IInternetProtocolSink_ReportData(pOIProtSink,
274             BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE,
275             This->data_len, This->data_len);
276
277     IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL);
278
279     return S_OK;
280 }
281
282 static HRESULT WINAPI AboutProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA* pProtocolData)
283 {
284     AboutProtocol *This = PROTOCOL_THIS(iface);
285     FIXME("(%p)->(%p)\n", This, pProtocolData);
286     return E_NOTIMPL;
287 }
288
289 static HRESULT WINAPI AboutProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
290         DWORD dwOptions)
291 {
292     AboutProtocol *This = PROTOCOL_THIS(iface);
293     FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
294     return E_NOTIMPL;
295 }
296
297 static HRESULT WINAPI AboutProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
298 {
299     AboutProtocol *This = PROTOCOL_THIS(iface);
300     TRACE("(%p)->(%08x)\n", This, dwOptions);
301     return S_OK;
302 }
303
304 static HRESULT WINAPI AboutProtocol_Suspend(IInternetProtocol *iface)
305 {
306     AboutProtocol *This = PROTOCOL_THIS(iface);
307     FIXME("(%p)\n", This);
308     return E_NOTIMPL;
309 }
310
311 static HRESULT WINAPI AboutProtocol_Resume(IInternetProtocol *iface)
312 {
313     AboutProtocol *This = PROTOCOL_THIS(iface);
314     FIXME("(%p)\n", This);
315     return E_NOTIMPL;
316 }
317
318 static HRESULT WINAPI AboutProtocol_Read(IInternetProtocol *iface, void* pv, ULONG cb, ULONG* pcbRead)
319 {
320     AboutProtocol *This = PROTOCOL_THIS(iface);
321
322     TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
323
324     if(!This->data)
325         return E_FAIL;
326
327     *pcbRead = (cb > This->data_len-This->cur ? This->data_len-This->cur : cb);
328
329     if(!*pcbRead)
330         return S_FALSE;
331
332     memcpy(pv, This->data, *pcbRead);
333     This->cur += *pcbRead;
334
335     return S_OK;
336 }
337
338 static HRESULT WINAPI AboutProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
339         DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition)
340 {
341     AboutProtocol *This = PROTOCOL_THIS(iface);
342     FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
343     return E_NOTIMPL;
344 }
345
346 static HRESULT WINAPI AboutProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
347 {
348     AboutProtocol *This = PROTOCOL_THIS(iface);
349
350     TRACE("(%p)->(%d)\n", This, dwOptions);
351
352     return S_OK;
353 }
354
355 static HRESULT WINAPI AboutProtocol_UnlockRequest(IInternetProtocol *iface)
356 {
357     AboutProtocol *This = PROTOCOL_THIS(iface);
358
359     TRACE("(%p)\n", This);
360
361     return S_OK;
362 }
363
364 #undef PROTOCOL_THIS
365
366 static const IInternetProtocolVtbl AboutProtocolVtbl = {
367     AboutProtocol_QueryInterface,
368     AboutProtocol_AddRef,
369     AboutProtocol_Release,
370     AboutProtocol_Start,
371     AboutProtocol_Continue,
372     AboutProtocol_Abort,
373     AboutProtocol_Terminate,
374     AboutProtocol_Suspend,
375     AboutProtocol_Resume,
376     AboutProtocol_Read,
377     AboutProtocol_Seek,
378     AboutProtocol_LockRequest,
379     AboutProtocol_UnlockRequest
380 };
381
382 static HRESULT WINAPI AboutProtocolFactory_CreateInstance(IClassFactory *iface, IUnknown *pUnkOuter,
383         REFIID riid, void **ppv)
384 {
385     AboutProtocol *ret;
386     HRESULT hres = S_OK;
387
388     TRACE("(%p)->(%p %s %p)\n", iface, pUnkOuter, debugstr_guid(riid), ppv);
389
390     ret = mshtml_alloc(sizeof(AboutProtocol));
391     ret->lpInternetProtocolVtbl = &AboutProtocolVtbl;
392     ret->ref = 0;
393
394     ret->data = NULL;
395     ret->data_len = 0;
396     ret->cur = 0;
397     ret->pUnkOuter = pUnkOuter;
398
399     if(pUnkOuter) {
400         ret->ref = 1;
401         if(IsEqualGUID(&IID_IUnknown, riid))
402             *ppv = PROTOCOL(ret);
403         else
404             hres = E_INVALIDARG;
405     }else {
406         hres = IInternetProtocol_QueryInterface(PROTOCOL(ret), riid, ppv);
407     }
408
409     if(SUCCEEDED(hres))
410         LOCK_MODULE();
411     else
412         mshtml_free(ret);
413
414     return hres;
415 }
416
417 static HRESULT WINAPI AboutProtocolInfo_ParseUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
418         PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult, DWORD cchResult,
419         DWORD* pcchResult, DWORD dwReserved)
420 {
421     TRACE("%p)->(%s %08x %08x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), ParseAction,
422             dwParseFlags, pwzResult, cchResult, pcchResult, dwReserved);
423
424     if(ParseAction == PARSE_SECURITY_URL) {
425         int len = lstrlenW(pwzUrl);
426
427         if(len >= cchResult)
428             return S_FALSE;
429
430         memcpy(pwzResult, pwzUrl, (len+1)*sizeof(WCHAR));
431         return S_OK;
432     }
433
434     if(ParseAction == PARSE_DOMAIN) {
435         if(!pcchResult)
436             return E_POINTER;
437
438         if(pwzUrl)
439             *pcchResult = strlenW(pwzUrl)+1;
440         else
441             *pcchResult = 1;
442         return E_FAIL;
443     }
444
445     return INET_E_DEFAULT_ACTION;
446 }
447
448 static HRESULT WINAPI AboutProtocolInfo_QueryInfo(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
449         QUERYOPTION QueryOption, DWORD dwQueryFlags, LPVOID pBuffer, DWORD cbBuffer, DWORD* pcbBuf,
450         DWORD dwReserved)
451 {
452     FIXME("%p)->(%s %08x %08x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), QueryOption, dwQueryFlags, pBuffer,
453             cbBuffer, pcbBuf, dwReserved);
454     return E_NOTIMPL;
455 }
456
457 static const IInternetProtocolInfoVtbl AboutProtocolInfoVtbl = {
458     InternetProtocolInfo_QueryInterface,
459     InternetProtocolInfo_AddRef,
460     InternetProtocolInfo_Release,
461     AboutProtocolInfo_ParseUrl,
462     InternetProtocolInfo_CombineUrl,
463     InternetProtocolInfo_CompareUrl,
464     AboutProtocolInfo_QueryInfo
465 };
466
467 static const IClassFactoryVtbl AboutProtocolFactoryVtbl = {
468     ClassFactory_QueryInterface,
469     ClassFactory_AddRef,
470     ClassFactory_Release,
471     AboutProtocolFactory_CreateInstance,
472     ClassFactory_LockServer
473 };
474
475 static ProtocolFactory AboutProtocolFactory = {
476     &AboutProtocolInfoVtbl,
477     &AboutProtocolFactoryVtbl
478 };
479
480 /********************************************************************
481  * ResProtocol implementation
482  */
483
484 typedef struct {
485     const IInternetProtocolVtbl *lpInternetProtocolVtbl;
486     LONG ref;
487
488     BYTE *data;
489     ULONG data_len;
490     ULONG cur;
491
492     IUnknown *pUnkOuter;
493 } ResProtocol;
494
495 #define PROTOCOL_THIS(iface) DEFINE_THIS(ResProtocol, InternetProtocol, iface)
496
497 static HRESULT WINAPI ResProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
498 {
499     ResProtocol *This = PROTOCOL_THIS(iface);
500
501     *ppv = NULL;
502
503     if(IsEqualGUID(&IID_IUnknown, riid)) {
504         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
505         if(This->pUnkOuter)
506             return IUnknown_QueryInterface(This->pUnkOuter, &IID_IUnknown, ppv);
507         *ppv = PROTOCOL(This);
508     }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
509         TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", iface, ppv);
510         *ppv = PROTOCOL(This);
511     }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
512         TRACE("(%p)->(IID_IInternetProtocol %p)\n", iface, ppv);
513         *ppv = PROTOCOL(This);
514     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
515         FIXME("IServiceProvider is not implemented\n");
516         return E_NOINTERFACE;
517     }
518
519     if(!*ppv) {
520         TRACE("unknown interface %s\n", debugstr_guid(riid));
521         return E_NOINTERFACE;
522     }
523
524     IInternetProtocol_AddRef(iface);
525     return S_OK;
526 }
527
528 static ULONG WINAPI ResProtocol_AddRef(IInternetProtocol *iface)
529 {
530     ResProtocol *This = PROTOCOL_THIS(iface);
531     ULONG ref = InterlockedIncrement(&This->ref);
532     TRACE("(%p) ref=%d\n", iface, ref);
533     return This->pUnkOuter ? IUnknown_AddRef(This->pUnkOuter) : ref;
534 }
535
536 static ULONG WINAPI ResProtocol_Release(IInternetProtocol *iface)
537 {
538     ResProtocol *This = (ResProtocol*)iface;
539     IUnknown *pUnkOuter = This->pUnkOuter;
540     ULONG ref = InterlockedDecrement(&This->ref);
541
542     TRACE("(%p) ref=%x\n", iface, ref);
543
544     if(!ref) {
545         mshtml_free(This->data);
546         mshtml_free(This);
547         UNLOCK_MODULE();
548     }
549
550     return pUnkOuter ? IUnknown_Release(pUnkOuter) : ref;
551 }
552
553 static HRESULT WINAPI ResProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
554         IInternetProtocolSink* pOIProtSink, IInternetBindInfo* pOIBindInfo,
555         DWORD grfPI, DWORD dwReserved)
556 {
557     ResProtocol *This = PROTOCOL_THIS(iface);
558     DWORD grfBINDF = 0, len;
559     BINDINFO bindinfo;
560     LPWSTR url_dll, url_file, url, mime;
561     HMODULE hdll;
562     HRSRC src;
563     HRESULT hres;
564
565     static const WCHAR wszRes[] = {'r','e','s',':','/','/'};
566
567     TRACE("(%p)->(%s %p %p %08x %d)\n", This, debugstr_w(szUrl), pOIProtSink,
568             pOIBindInfo, grfPI, dwReserved);
569
570     memset(&bindinfo, 0, sizeof(bindinfo));
571     bindinfo.cbSize = sizeof(BINDINFO);
572     IInternetBindInfo_GetBindInfo(pOIBindInfo, &grfBINDF, &bindinfo);
573     ReleaseBindInfo(&bindinfo);
574
575     len = strlenW(szUrl)+16;
576     url = mshtml_alloc(len*sizeof(WCHAR));
577     hres = CoInternetParseUrl(szUrl, PARSE_ENCODE, 0, url, len, &len, 0);
578     if(FAILED(hres)) {
579         WARN("CoInternetParseUrl failed: %08x\n", hres);
580         mshtml_free(url);
581         IInternetProtocolSink_ReportResult(pOIProtSink, hres, 0, NULL);
582         return hres;
583     }
584
585     if(len < sizeof(wszRes)/sizeof(wszRes[0]) || memcmp(url, wszRes, sizeof(wszRes))) {
586         WARN("Wrong protocol of url: %s\n", debugstr_w(url));
587         IInternetProtocolSink_ReportResult(pOIProtSink, MK_E_SYNTAX, 0, NULL);
588         mshtml_free(url);
589         return MK_E_SYNTAX;
590     }
591
592     url_dll = url + sizeof(wszRes)/sizeof(wszRes[0]);
593     if(!(url_file = strrchrW(url_dll, '/'))) {
594         WARN("wrong url: %s\n", debugstr_w(url));
595         IInternetProtocolSink_ReportResult(pOIProtSink, MK_E_SYNTAX, 0, NULL);
596         mshtml_free(url);
597         return MK_E_SYNTAX;
598     }
599
600     *url_file++ = 0;
601     hdll = LoadLibraryExW(url_dll, NULL, LOAD_LIBRARY_AS_DATAFILE);
602     if(!hdll) {
603         WARN("Could not open dll: %s\n", debugstr_w(url_dll));
604         IInternetProtocolSink_ReportResult(pOIProtSink, HRESULT_FROM_WIN32(GetLastError()), 0, NULL);
605         return HRESULT_FROM_WIN32(GetLastError());
606     }
607
608     src = FindResourceW(hdll, url_file, (LPCWSTR)RT_HTML);
609     if(!src) {
610         LPWSTR endpoint = NULL;
611         DWORD file_id = strtolW(url_file, &endpoint, 10);
612         if(endpoint == url_file+strlenW(url_file))
613             src = FindResourceW(hdll, (LPCWSTR)file_id, (LPCWSTR)RT_HTML);
614
615         if(!src) {
616             WARN("Could not find resource\n");
617             IInternetProtocolSink_ReportResult(pOIProtSink,
618                     HRESULT_FROM_WIN32(GetLastError()), 0, NULL);
619             mshtml_free(url);
620             return HRESULT_FROM_WIN32(GetLastError());
621         }
622     }
623
624     if(This->data) {
625         WARN("data already loaded\n");
626         mshtml_free(This->data);
627     }
628
629     This->data_len = SizeofResource(hdll, src);
630     This->data = mshtml_alloc(This->data_len);
631     memcpy(This->data, LoadResource(hdll, src), This->data_len);
632     This->cur = 0;
633
634     FreeLibrary(hdll);
635
636     hres = FindMimeFromData(NULL, url_file, NULL, 0, NULL, 0, &mime, 0);
637     mshtml_free(url);
638     if(SUCCEEDED(hres)) {
639         IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_MIMETYPEAVAILABLE, mime);
640         CoTaskMemFree(mime);
641     }
642
643     IInternetProtocolSink_ReportData(pOIProtSink,
644             BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE,
645             This->data_len, This->data_len);
646
647     IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL);
648     
649     return S_OK;
650 }
651
652 static HRESULT WINAPI ResProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA* pProtocolData)
653 {
654     ResProtocol *This = PROTOCOL_THIS(iface);
655     FIXME("(%p)->(%p)\n", This, pProtocolData);
656     return E_NOTIMPL;
657 }
658
659 static HRESULT WINAPI ResProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
660         DWORD dwOptions)
661 {
662     ResProtocol *This = PROTOCOL_THIS(iface);
663     FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
664     return E_NOTIMPL;
665 }
666
667 static HRESULT WINAPI ResProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
668 {
669     ResProtocol *This = PROTOCOL_THIS(iface);
670
671     TRACE("(%p)->(%08x)\n", This, dwOptions);
672
673     /* test show that we don't have to do anything here */
674     return S_OK;
675 }
676
677 static HRESULT WINAPI ResProtocol_Suspend(IInternetProtocol *iface)
678 {
679     ResProtocol *This = PROTOCOL_THIS(iface);
680     FIXME("(%p)\n", This);
681     return E_NOTIMPL;
682 }
683
684 static HRESULT WINAPI ResProtocol_Resume(IInternetProtocol *iface)
685 {
686     ResProtocol *This = PROTOCOL_THIS(iface);
687     FIXME("(%p)\n", This);
688     return E_NOTIMPL;
689 }
690
691 static HRESULT WINAPI ResProtocol_Read(IInternetProtocol *iface, void* pv, ULONG cb, ULONG* pcbRead)
692 {
693     ResProtocol *This = PROTOCOL_THIS(iface);
694
695     TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
696
697     if(!This->data)
698         return E_FAIL;
699
700     *pcbRead = (cb > This->data_len-This->cur ? This->data_len-This->cur : cb);
701
702     if(!*pcbRead)
703         return S_FALSE;
704
705     memcpy(pv, This->data, *pcbRead);
706     This->cur += *pcbRead;
707
708     return S_OK;
709 }
710
711 static HRESULT WINAPI ResProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
712         DWORD dwOrigin, ULARGE_INTEGER* plibNewPosition)
713 {
714     ResProtocol *This = PROTOCOL_THIS(iface);
715     FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
716     return E_NOTIMPL;
717 }
718
719 static HRESULT WINAPI ResProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
720 {
721     ResProtocol *This = PROTOCOL_THIS(iface);
722
723     TRACE("(%p)->(%d)\n", This, dwOptions);
724
725     /* test show that we don't have to do anything here */
726     return S_OK;
727 }
728
729 static HRESULT WINAPI ResProtocol_UnlockRequest(IInternetProtocol *iface)
730 {
731     ResProtocol *This = PROTOCOL_THIS(iface);
732
733     TRACE("(%p)\n", This);
734
735     /* test show that we don't have to do anything here */
736     return S_OK;
737 }
738
739 #undef PROTOCOL_THIS
740
741 static const IInternetProtocolVtbl ResProtocolVtbl = {
742     ResProtocol_QueryInterface,
743     ResProtocol_AddRef,
744     ResProtocol_Release,
745     ResProtocol_Start,
746     ResProtocol_Continue,
747     ResProtocol_Abort,
748     ResProtocol_Terminate,
749     ResProtocol_Suspend,
750     ResProtocol_Resume,
751     ResProtocol_Read,
752     ResProtocol_Seek,
753     ResProtocol_LockRequest,
754     ResProtocol_UnlockRequest
755 };
756
757 static HRESULT WINAPI ResProtocolFactory_CreateInstance(IClassFactory *iface, IUnknown *pUnkOuter,
758         REFIID riid, void **ppv)
759 {
760     ResProtocol *ret;
761     HRESULT hres = S_OK;
762
763     TRACE("(%p)->(%p %s %p)\n", iface, pUnkOuter, debugstr_guid(riid), ppv);
764
765     ret = mshtml_alloc(sizeof(ResProtocol));
766     ret->lpInternetProtocolVtbl = &ResProtocolVtbl;
767     ret->ref = 0;
768     ret->data = NULL;
769     ret->data_len = 0;
770     ret->cur = 0;
771     ret->pUnkOuter = pUnkOuter;
772
773     if(pUnkOuter) {
774         ret->ref = 1;
775         if(IsEqualGUID(&IID_IUnknown, riid))
776             *ppv = PROTOCOL(ret);
777         else
778             hres = E_FAIL;
779     }else {
780         hres = IInternetProtocol_QueryInterface(PROTOCOL(ret), riid, ppv);
781     }
782
783     if(SUCCEEDED(hres))
784         LOCK_MODULE();
785     else
786         mshtml_free(ret);
787
788     return hres;
789 }
790
791 static HRESULT WINAPI ResProtocolInfo_ParseUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
792         PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult, DWORD cchResult,
793         DWORD* pcchResult, DWORD dwReserved)
794 {
795     TRACE("%p)->(%s %d %x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), ParseAction,
796             dwParseFlags, pwzResult, cchResult, pcchResult, dwReserved);
797
798     if(ParseAction == PARSE_SECURITY_URL) {
799         WCHAR *ptr;
800         DWORD size;
801
802         static const WCHAR wszFile[] = {'f','i','l','e',':','/','/'};
803         static const WCHAR wszRes[] = {'r','e','s',':','/','/'};
804
805         if(strlenW(pwzUrl) <= sizeof(wszRes)/sizeof(WCHAR) || memcmp(pwzUrl, wszRes, sizeof(wszRes)))
806             return MK_E_SYNTAX;
807
808         ptr = strchrW(pwzUrl + sizeof(wszRes)/sizeof(WCHAR), '/');
809         if(!ptr)
810             return MK_E_SYNTAX;
811
812         size = ptr-pwzUrl + sizeof(wszFile)/sizeof(WCHAR) - sizeof(wszRes)/sizeof(WCHAR);
813         if(size >= cchResult)
814             return S_FALSE;
815
816         /* FIXME: return full path */
817         memcpy(pwzResult, wszFile, sizeof(wszFile));
818         memcpy(pwzResult + sizeof(wszFile)/sizeof(WCHAR),
819                 pwzUrl + sizeof(wszRes)/sizeof(WCHAR),
820                 size*sizeof(WCHAR) - sizeof(wszFile));
821         pwzResult[size] = 0;
822
823         if(pcchResult)
824             *pcchResult = size;
825         return S_OK;
826     }
827
828     if(ParseAction == PARSE_DOMAIN) {
829         if(!pcchResult)
830             return E_POINTER;
831
832         if(pwzUrl)
833             *pcchResult = strlenW(pwzUrl)+1;
834         else
835             *pcchResult = 1;
836         return E_FAIL;
837     }
838
839     return INET_E_DEFAULT_ACTION;
840 }
841
842 static HRESULT WINAPI ResProtocolInfo_QueryInfo(IInternetProtocolInfo *iface, LPCWSTR pwzUrl,
843         QUERYOPTION QueryOption, DWORD dwQueryFlags, LPVOID pBuffer, DWORD cbBuffer, DWORD* pcbBuf,
844         DWORD dwReserved)
845 {
846     FIXME("%p)->(%s %08x %08x %p %d %p %d)\n", iface, debugstr_w(pwzUrl), QueryOption, dwQueryFlags, pBuffer,
847             cbBuffer, pcbBuf, dwReserved);
848     return E_NOTIMPL;
849 }
850
851 static const IInternetProtocolInfoVtbl ResProtocolInfoVtbl = {
852     InternetProtocolInfo_QueryInterface,
853     InternetProtocolInfo_AddRef,
854     InternetProtocolInfo_Release,
855     ResProtocolInfo_ParseUrl,
856     InternetProtocolInfo_CombineUrl,
857     InternetProtocolInfo_CompareUrl,
858     ResProtocolInfo_QueryInfo
859 };
860
861 static const IClassFactoryVtbl ResProtocolFactoryVtbl = {
862     ClassFactory_QueryInterface,
863     ClassFactory_AddRef,
864     ClassFactory_Release,
865     ResProtocolFactory_CreateInstance,
866     ClassFactory_LockServer
867 };
868
869 static ProtocolFactory ResProtocolFactory = {
870     &ResProtocolInfoVtbl,
871     &ResProtocolFactoryVtbl
872 };
873
874 HRESULT ProtocolFactory_Create(REFCLSID rclsid, REFIID riid, void **ppv)
875 {
876     ProtocolFactory *cf = NULL;
877
878     if(IsEqualGUID(&CLSID_AboutProtocol, rclsid))
879         cf = &AboutProtocolFactory;
880     else if(IsEqualGUID(&CLSID_ResProtocol, rclsid))
881         cf = &ResProtocolFactory;
882
883     if(!cf) {
884         FIXME("not implemented protocol %s\n", debugstr_guid(rclsid));
885         return CLASS_E_CLASSNOTAVAILABLE;
886     }
887  
888     return IUnknown_QueryInterface((IUnknown*)cf, riid, ppv);
889 }