ReactOS  0.4.14-dev-608-gd495a4f
protocol.c
Go to the documentation of this file.
1 /*
2  * Copyright 2006-2007 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 <stdarg.h>
20 
21 #define COBJMACROS
22 
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winuser.h"
26 #include "winreg.h"
27 #include "ole2.h"
28 #include "urlmon.h"
29 #include "shlwapi.h"
30 #include "itsstor.h"
31 #include "chm_lib.h"
32 
33 #include "wine/debug.h"
34 
36 
37 typedef struct {
41 
44 
46  struct chmFile *chm_file;
47  struct chmUnitInfo chm_object;
48 } ITSProtocol;
49 
50 static inline ITSProtocol *impl_from_IUnknown(IUnknown *iface)
51 {
52  return CONTAINING_RECORD(iface, ITSProtocol, IUnknown_inner);
53 }
54 
56 {
57  return CONTAINING_RECORD(iface, ITSProtocol, IInternetProtocol_iface);
58 }
59 
61 {
62  return CONTAINING_RECORD(iface, ITSProtocol, IInternetProtocolInfo_iface);
63 }
64 
66 {
67  if(This->chm_file) {
68  chm_close(This->chm_file);
69  This->chm_file = NULL;
70  }
71  This->offset = 0;
72 }
73 
75 {
77 
79  TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
80  *ppv = &This->IUnknown_inner;
81  }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
82  TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", This, ppv);
83  *ppv = &This->IInternetProtocol_iface;
84  }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
85  TRACE("(%p)->(IID_IInternetProtocol %p)\n", This, ppv);
86  *ppv = &This->IInternetProtocol_iface;
87  }else if(IsEqualGUID(&IID_IInternetProtocolInfo, riid)) {
88  TRACE("(%p)->(IID_IInternetProtocolInfo %p)\n", This, ppv);
89  *ppv = &This->IInternetProtocolInfo_iface;
90  }else {
91  *ppv = NULL;
92  WARN("not supported interface %s\n", debugstr_guid(riid));
93  return E_NOINTERFACE;
94  }
95 
96  IUnknown_AddRef((IUnknown*)*ppv);
97  return S_OK;
98 }
99 
101 {
104  TRACE("(%p) ref=%d\n", This, ref);
105  return ref;
106 }
107 
109 {
112 
113  TRACE("(%p) ref=%d\n", This, ref);
114 
115  if(!ref) {
116  release_chm(This);
118 
120  }
121 
122  return ref;
123 }
124 
125 static const IUnknownVtbl ITSProtocolUnkVtbl = {
129 };
130 
132 {
134  return IUnknown_QueryInterface(This->outer, riid, ppv);
135 }
136 
138 {
140  return IUnknown_AddRef(This->outer);
141 }
142 
144 {
146  return IUnknown_Release(This->outer);
147 }
148 
150 {
151  static const WCHAR its_schema[] = {'i','t','s',':'};
152  static const WCHAR msits_schema[] = {'m','s','-','i','t','s',':'};
153  static const WCHAR mk_schema[] = {'m','k',':','@','M','S','I','T','S','t','o','r','e',':'};
154 
155  if(!_wcsnicmp(its_schema, url, ARRAY_SIZE(its_schema)))
156  return url + ARRAY_SIZE(its_schema);
157  if(!_wcsnicmp(msits_schema, url, ARRAY_SIZE(msits_schema)))
158  return url + ARRAY_SIZE(msits_schema);
159  if(!_wcsnicmp(mk_schema, url, ARRAY_SIZE(mk_schema)))
160  return url + ARRAY_SIZE(mk_schema);
161 
162  return NULL;
163 }
164 
165 /* Adopted from urlmon */
167  const WCHAR *in = path;
168  WCHAR *out = path;
169 
170  while(1) {
171  /* Move the first path segment in the input buffer to the end of
172  * the output buffer, and any subsequent characters up to, including
173  * the next "/" character (if any) or the end of the input buffer.
174  */
175  while(*in != '/') {
176  if(!(*out++ = *in++))
177  return;
178  }
179 
180  *out++ = *in++;
181 
182  while(*in) {
183  if(*in != '.')
184  break;
185 
186  /* Handle ending "/." */
187  if(!in[1]) {
188  ++in;
189  break;
190  }
191 
192  /* Handle "/./" */
193  if(in[1] == '/') {
194  in += 2;
195  continue;
196  }
197 
198  /* If we don't have "/../" or ending "/.." */
199  if(in[1] != '.' || (in[2] && in[2] != '/'))
200  break;
201 
202  in += *in ? 3 : 2;
203 
204  /* Find the slash preceding out pointer and move out pointer to it */
205  if(out > path+1 && *--out == '/')
206  --out;
207  while(out > path && *(--out) != '/');
208  if(*out == '/')
209  ++out;
210  }
211  }
212 }
213 
215 {
216  IInternetProtocolSink_ReportResult(sink, hres, 0, NULL);
217  return hres;
218 }
219 
221  IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
222  DWORD grfPI, HANDLE_PTR dwReserved)
223 {
225  BINDINFO bindinfo;
226  DWORD bindf = 0, len;
227  LPWSTR file_name, mime, object_name, p;
228  LPCWSTR ptr;
229  struct chmFile *chm_file;
230  struct chmUnitInfo chm_object;
231  int res;
232  HRESULT hres;
233 
234  static const WCHAR separator[] = {':',':',0};
235 
236  TRACE("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink,
237  pOIBindInfo, grfPI, dwReserved);
238 
239  ptr = skip_schema(szUrl);
240  if(!ptr)
241  return INET_E_USE_DEFAULT_PROTOCOLHANDLER;
242 
243  memset(&bindinfo, 0, sizeof(bindinfo));
244  bindinfo.cbSize = sizeof(BINDINFO);
245  hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &bindf, &bindinfo);
246  if(FAILED(hres)) {
247  WARN("GetBindInfo failed: %08x\n", hres);
248  return hres;
249  }
250 
251  ReleaseBindInfo(&bindinfo);
252 
253  len = lstrlenW(ptr)+3;
254  file_name = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
255  memcpy(file_name, ptr, len*sizeof(WCHAR));
257  if(FAILED(hres)) {
258  WARN("UrlUnescape failed: %08x\n", hres);
260  return hres;
261  }
262 
264  if(!p) {
265  WARN("invalid url\n");
267  return report_result(pOIProtSink, STG_E_FILENOTFOUND);
268  }
269 
270  *p = 0;
271  chm_file = chm_openW(file_name);
272  if(!chm_file) {
273  WARN("Could not open chm file\n");
275  return report_result(pOIProtSink, STG_E_FILENOTFOUND);
276  }
277 
278  object_name = p+2;
279  len = lstrlenW(object_name);
280 
281  if(*object_name != '/' && *object_name != '\\') {
282  memmove(object_name+1, object_name, (len+1)*sizeof(WCHAR));
283  *object_name = '/';
284  len++;
285  }
286 
287  if(object_name[len-1] == '/')
288  object_name[--len] = 0;
289 
290  for(p=object_name; *p; p++) {
291  if(*p == '\\')
292  *p = '/';
293  }
294 
295  remove_dot_segments(object_name);
296 
297  TRACE("Resolving %s\n", debugstr_w(object_name));
298 
299  memset(&chm_object, 0, sizeof(chm_object));
300  res = chm_resolve_object(chm_file, object_name, &chm_object);
301  if(res != CHM_RESOLVE_SUCCESS) {
302  WARN("Could not resolve chm object\n");
304  chm_close(chm_file);
305  return report_result(pOIProtSink, STG_E_FILENOTFOUND);
306  }
307 
308  IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_SENDINGREQUEST,
309  wcsrchr(object_name, '/')+1);
310 
311  /* FIXME: Native doesn't use FindMimeFromData */
312  hres = FindMimeFromData(NULL, object_name, NULL, 0, NULL, 0, &mime, 0);
314  if(SUCCEEDED(hres)) {
315  IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_MIMETYPEAVAILABLE, mime);
317  }
318 
319  release_chm(This); /* Native leaks handle here */
320  This->chm_file = chm_file;
321  This->chm_object = chm_object;
322 
323  hres = IInternetProtocolSink_ReportData(pOIProtSink,
324  BSCF_FIRSTDATANOTIFICATION|BSCF_DATAFULLYAVAILABLE,
325  chm_object.length, chm_object.length);
326  if(FAILED(hres)) {
327  WARN("ReportData failed: %08x\n", hres);
328  release_chm(This);
329  return report_result(pOIProtSink, hres);
330  }
331 
332  hres = IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_BEGINDOWNLOADDATA, NULL);
333 
334  return report_result(pOIProtSink, hres);
335 }
336 
337 static HRESULT WINAPI ITSProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData)
338 {
340  FIXME("(%p)->(%p)\n", This, pProtocolData);
341  return E_NOTIMPL;
342 }
343 
346 {
348  FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
349  return E_NOTIMPL;
350 }
351 
353 {
355 
356  TRACE("(%p)->(%08x)\n", This, dwOptions);
357 
358  return S_OK;
359 }
360 
362 {
364  FIXME("(%p)\n", This);
365  return E_NOTIMPL;
366 }
367 
369 {
371  FIXME("(%p)\n", This);
372  return E_NOTIMPL;
373 }
374 
376  ULONG cb, ULONG *pcbRead)
377 {
379 
380  TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
381 
382  if(!This->chm_file)
383  return INET_E_DATA_NOT_AVAILABLE;
384 
385  *pcbRead = chm_retrieve_object(This->chm_file, &This->chm_object, pv, This->offset, cb);
386  This->offset += *pcbRead;
387 
388  return *pcbRead ? S_OK : S_FALSE;
389 }
390 
392  DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
393 {
395  FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
396  return E_NOTIMPL;
397 }
398 
400 {
402 
403  TRACE("(%p)->(%08x)\n", This, dwOptions);
404 
405  return S_OK;
406 }
407 
409 {
411 
412  TRACE("(%p)\n", This);
413 
414  return S_OK;
415 }
416 
417 static const IInternetProtocolVtbl ITSProtocolVtbl = {
431 };
432 
434  REFIID riid, void **ppv)
435 {
437  return IInternetProtocol_QueryInterface(&This->IInternetProtocol_iface, riid, ppv);
438 }
439 
441 {
443  return IInternetProtocol_AddRef(&This->IInternetProtocol_iface);
444 }
445 
447 {
449  return IInternetProtocol_Release(&This->IInternetProtocol_iface);
450 }
451 
453  PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult, DWORD cchResult,
454  DWORD *pcchResult, DWORD dwReserved)
455 {
457 
458  TRACE("(%p)->(%s %x %08x %p %d %p %d)\n", This, debugstr_w(pwzUrl), ParseAction,
459  dwParseFlags, pwzResult, cchResult, pcchResult, dwReserved);
460 
461  switch(ParseAction) {
462  case PARSE_CANONICALIZE:
463  FIXME("PARSE_CANONICALIZE\n");
464  return E_NOTIMPL;
465  case PARSE_SECURITY_URL:
466  FIXME("PARSE_SECURITY_URL\n");
467  return E_NOTIMPL;
468  default:
469  return INET_E_DEFAULT_ACTION;
470  }
471 
472  return S_OK;
473 }
474 
476  LPCWSTR pwzBaseUrl, LPCWSTR pwzRelativeUrl, DWORD dwCombineFlags, LPWSTR pwzResult,
477  DWORD cchResult, DWORD* pcchResult, DWORD dwReserved)
478 {
480  LPCWSTR base_end, ptr;
481  DWORD rel_len;
482 
483  static const WCHAR separator[] = {':',':',0};
484 
485  TRACE("(%p)->(%s %s %08x %p %d %p %d)\n", This, debugstr_w(pwzBaseUrl),
486  debugstr_w(pwzRelativeUrl), dwCombineFlags, pwzResult, cchResult,
487  pcchResult, dwReserved);
488 
489  base_end = wcsstr(pwzBaseUrl, separator);
490  if(!base_end)
491  return 0x80041001;
492  base_end += 2;
493 
494  if(!skip_schema(pwzBaseUrl))
495  return INET_E_USE_DEFAULT_PROTOCOLHANDLER;
496 
497  if(wcschr(pwzRelativeUrl, ':'))
498  return STG_E_INVALIDNAME;
499 
500  if(pwzRelativeUrl[0] == '#') {
501  base_end += lstrlenW(base_end);
502  }else if(pwzRelativeUrl[0] != '/') {
503  ptr = wcsrchr(base_end, '/');
504  if(ptr)
505  base_end = ptr+1;
506  else
507  base_end += lstrlenW(base_end);
508  }
509 
510  rel_len = lstrlenW(pwzRelativeUrl)+1;
511 
512  *pcchResult = rel_len + (base_end-pwzBaseUrl);
513 
514  if(*pcchResult > cchResult)
515  return E_OUTOFMEMORY;
516 
517  memcpy(pwzResult, pwzBaseUrl, (base_end-pwzBaseUrl)*sizeof(WCHAR));
518  lstrcpyW(pwzResult + (base_end-pwzBaseUrl), pwzRelativeUrl);
519 
520  return S_OK;
521 }
522 
524  LPCWSTR pwzUrl2, DWORD dwCompareFlags)
525 {
527  FIXME("%p)->(%s %s %08x)\n", This, debugstr_w(pwzUrl1), debugstr_w(pwzUrl2), dwCompareFlags);
528  return E_NOTIMPL;
529 }
530 
532  QUERYOPTION QueryOption, DWORD dwQueryFlags, LPVOID pBuffer, DWORD cbBuffer, DWORD* pcbBuf,
534 {
536  FIXME("(%p)->(%s %08x %08x %p %d %p %d)\n", This, debugstr_w(pwzUrl), QueryOption,
537  dwQueryFlags, pBuffer, cbBuffer, pcbBuf, dwReserved);
538  return E_NOTIMPL;
539 }
540 
541 static const IInternetProtocolInfoVtbl ITSProtocolInfoVtbl = {
549 };
550 
552 {
553  ITSProtocol *ret;
554 
555  TRACE("(%p %p)\n", outer, ppv);
556 
557  ITSS_LockModule();
558 
560  if(!ret)
561  return E_OUTOFMEMORY;
562 
563  ret->IUnknown_inner.lpVtbl = &ITSProtocolUnkVtbl;
564  ret->IInternetProtocol_iface.lpVtbl = &ITSProtocolVtbl;
565  ret->IInternetProtocolInfo_iface.lpVtbl = &ITSProtocolInfoVtbl;
566  ret->ref = 1;
567  ret->outer = outer ? outer : &ret->IUnknown_inner;
568 
569  *ppv = &ret->IUnknown_inner;
570  return S_OK;
571 }
static PARSEACTION
Definition: misc.c:73
struct _LARGE_INTEGER::@2220 u
DWORD dwOptions
Definition: solitaire.cpp:23
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
static ULONG WINAPI ITSProtocol_Release(IUnknown *iface)
Definition: protocol.c:108
#define REFIID
Definition: guiddef.h:118
static ULONG WINAPI ITSInternetProtocol_AddRef(IInternetProtocol *iface)
Definition: protocol.c:137
#define STG_E_INVALIDNAME
Definition: winerror.h:2584
ULONG offset
Definition: protocol.c:45
#define E_NOINTERFACE
Definition: winerror.h:2364
static const WCHAR separator[]
Definition: asmname.c:65
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:420
static HRESULT WINAPI ITSProtocolInfo_CompareUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl1, LPCWSTR pwzUrl2, DWORD dwCompareFlags)
Definition: protocol.c:523
static const IUnknownVtbl ITSProtocolUnkVtbl
Definition: protocol.c:125
static HRESULT WINAPI ITSProtocolInfo_QueryInfo(IInternetProtocolInfo *iface, LPCWSTR pwzUrl, QUERYOPTION QueryOption, DWORD dwQueryFlags, LPVOID pBuffer, DWORD cbBuffer, DWORD *pcbBuf, DWORD dwReserved)
Definition: protocol.c:531
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
static HRESULT WINAPI ITSInternetProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
Definition: protocol.c:131
const WCHAR * mime
Definition: mimefilter.c:512
struct chmFile * chm_file
Definition: protocol.c:46
static void ITSS_LockModule(void)
Definition: itsstor.h:41
GLsizei const GLchar ** path
Definition: glext.h:7234
_CONST_RETURN wchar_t *__cdecl wcsstr(_In_z_ const wchar_t *_Str, _In_z_ const wchar_t *_SubStr)
REFIID riid
Definition: precomp.h:44
#define URL_UNESCAPE_INPLACE
Definition: shlwapi.h:1224
void WINAPI ReleaseBindInfo(BINDINFO *pbindinfo)
Definition: urlmon_main.c:572
static ULONG WINAPI ITSProtocolInfo_AddRef(IInternetProtocolInfo *iface)
Definition: protocol.c:440
static void release_chm(ITSProtocol *This)
Definition: protocol.c:65
#define WARN(fmt,...)
Definition: debug.h:111
_Check_return_ _CRTIMP int __cdecl _wcsnicmp(_In_reads_or_z_(_MaxCount) const wchar_t *_Str1, _In_reads_or_z_(_MaxCount) const wchar_t *_Str2, _In_ size_t _MaxCount)
REFIID LPVOID * ppv
Definition: atlbase.h:39
static HRESULT WINAPI ITSProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl, IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo, DWORD grfPI, HANDLE_PTR dwReserved)
Definition: protocol.c:220
static ITSProtocol * impl_from_IInternetProtocolInfo(IInternetProtocolInfo *iface)
Definition: protocol.c:60
static HRESULT WINAPI ITSProtocol_UnlockRequest(IInternetProtocol *iface)
Definition: protocol.c:408
static void ITSS_UnlockModule(void)
Definition: itsstor.h:42
#define lstrlenW
Definition: compat.h:415
IInternetProtocolInfo IInternetProtocolInfo_iface
Definition: protocol.c:40
Definition: send.c:47
GLsizei GLenum GLboolean sink
Definition: glext.h:5672
HRESULT WINAPI UrlUnescapeW(LPWSTR pszUrl, LPWSTR pszUnescaped, LPDWORD pcchUnescaped, DWORD dwFlags)
Definition: url.c:1367
void chm_close(struct chmFile *h)
Definition: chm_lib.c:863
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
static HRESULT WINAPI ITSProtocol_Suspend(IInternetProtocol *iface)
Definition: protocol.c:361
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED _In_opt_ LPTRANSMIT_FILE_BUFFERS _In_ DWORD dwReserved
Definition: mswsock.h:90
long LONG
Definition: pedump.c:60
#define debugstr_w
Definition: kernel32.h:32
static LPCWSTR skip_schema(LPCWSTR url)
Definition: protocol.c:149
GLenum GLint ref
Definition: glext.h:6028
#define FIXME(fmt,...)
Definition: debug.h:110
static PVOID ptr
Definition: dispmode.c:27
#define S_FALSE
Definition: winerror.h:2357
smooth NULL
Definition: ftsmooth.c:416
PVOID pBuffer
static HRESULT WINAPI ITSProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData)
Definition: protocol.c:337
int chm_resolve_object(struct chmFile *h, const WCHAR *objPath, struct chmUnitInfo *ui)
Definition: chm_lib.c:1048
static QUERYOPTION
Definition: misc.c:74
_Check_return_ _CRTIMP _CONST_RETURN wchar_t *__cdecl wcsrchr(_In_z_ const wchar_t *_Str, _In_ wchar_t _Ch)
#define debugstr_guid
Definition: kernel32.h:35
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
static HRESULT WINAPI ITSProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason, DWORD dwOptions)
Definition: protocol.c:344
LONGINT64 chm_retrieve_object(struct chmFile *h, struct chmUnitInfo *ui, unsigned char *buf, LONGUINT64 addr, LONGINT64 len)
Definition: chm_lib.c:1342
#define TRACE(s)
Definition: solgame.cpp:4
HRESULT hres
Definition: protocol.c:465
#define GetProcessHeap()
Definition: compat.h:403
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
_CONST_RETURN wchar_t *__cdecl wcschr(_In_z_ const wchar_t *_Str, wchar_t _Ch)
__wchar_t WCHAR
Definition: xmlstorage.h:180
LONG HRESULT
Definition: typedefs.h:77
static const WCHAR url[]
Definition: encode.c:1432
const GUID IID_IUnknown
#define WINAPI
Definition: msvc.h:6
static HRESULT WINAPI ITSProtocolInfo_QueryInterface(IInternetProtocolInfo *iface, REFIID riid, void **ppv)
Definition: protocol.c:433
#define CHM_RESOLVE_SUCCESS
Definition: chm_lib.h:82
static FILE * out
Definition: regtests2xml.c:44
unsigned long DWORD
Definition: ntddk_ex.h:95
HRESULT ITSProtocol_create(IUnknown *outer, void **ppv)
Definition: protocol.c:551
static HRESULT WINAPI ITSProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
Definition: protocol.c:352
static ULONG WINAPI ITSInternetProtocol_Release(IInternetProtocol *iface)
Definition: protocol.c:143
struct chmFile * chm_openW(const WCHAR *filename)
Definition: chm_lib.c:678
static ULONG WINAPI ITSProtocol_AddRef(IUnknown *iface)
Definition: protocol.c:100
int ret
#define STG_E_FILENOTFOUND
Definition: winerror.h:2565
static HRESULT WINAPI ITSProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
Definition: protocol.c:391
#define InterlockedDecrement
Definition: armddk.h:52
static HRESULT WINAPI ITSProtocolInfo_ParseUrl(IInternetProtocolInfo *iface, LPCWSTR pwzUrl, PARSEACTION ParseAction, DWORD dwParseFlags, LPWSTR pwzResult, DWORD cchResult, DWORD *pcchResult, DWORD dwReserved)
Definition: protocol.c:452
static const IInternetProtocolInfoVtbl ITSProtocolInfoVtbl
Definition: protocol.c:541
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
LONG ref
Definition: protocol.c:42
IInternetProtocol IInternetProtocol_iface
Definition: protocol.c:39
#define S_OK
Definition: intsafe.h:59
#define InterlockedIncrement
Definition: armddk.h:53
#define lstrcpyW
Definition: compat.h:414
GLuint in
Definition: glext.h:9616
LONGUINT64 length
Definition: chm_lib.h:70
unsigned long HANDLE_PTR
Definition: basetsd.h:78
#define ARRAY_SIZE(a)
Definition: main.h:24
#define E_NOTIMPL
Definition: ddrawi.h:99
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4112
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
static HRESULT WINAPI ITSProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
Definition: protocol.c:399
static LPCWSTR file_name
Definition: protocol.c:147
static HMODULE MODULEINFO DWORD cb
Definition: module.c:32
static const IInternetProtocolVtbl ITSProtocolVtbl
Definition: protocol.c:417
GLuint res
Definition: glext.h:9613
static ITSProtocol * impl_from_IInternetProtocol(IInternetProtocol *iface)
Definition: protocol.c:55
IUnknown * outer
Definition: protocol.c:43
unsigned int ULONG
Definition: retypes.h:1
static HRESULT report_result(IInternetProtocolSink *sink, HRESULT hres)
Definition: protocol.c:214
static void remove_dot_segments(WCHAR *path)
Definition: protocol.c:166
static ITSProtocol * impl_from_IUnknown(IUnknown *iface)
Definition: protocol.c:50
static HRESULT WINAPI ITSProtocol_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
Definition: protocol.c:74
GLfloat GLfloat p
Definition: glext.h:8902
WCHAR * LPWSTR
Definition: xmlstorage.h:184
static HRESULT WINAPI ITSProtocol_Read(IInternetProtocol *iface, void *pv, ULONG cb, ULONG *pcbRead)
Definition: protocol.c:375
static ULONG WINAPI ITSProtocolInfo_Release(IInternetProtocolInfo *iface)
Definition: protocol.c:446
#define memset(x, y, z)
Definition: compat.h:39
HRESULT WINAPI FindMimeFromData(LPBC pBC, LPCWSTR pwzUrl, LPVOID pBuffer, DWORD cbSize, LPCWSTR pwzMimeProposed, DWORD dwMimeFlags, LPWSTR *ppwzMimeOut, DWORD dwReserved)
Definition: mimefilter.c:680
static HRESULT WINAPI ITSProtocolInfo_CombineUrl(IInternetProtocolInfo *iface, LPCWSTR pwzBaseUrl, LPCWSTR pwzRelativeUrl, DWORD dwCombineFlags, LPWSTR pwzResult, DWORD cchResult, DWORD *pcchResult, DWORD dwReserved)
Definition: protocol.c:475
IUnknown IUnknown_inner
Definition: protocol.c:38
#define HeapFree(x, y, z)
Definition: compat.h:402
#define SUCCEEDED(hr)
Definition: intsafe.h:57
static HRESULT WINAPI ITSProtocol_Resume(IInternetProtocol *iface)
Definition: protocol.c:368
WINE_DEFAULT_DEBUG_CHANNEL(inetcomm)
static DWORD bindf
Definition: protocol.c:70