Create a branch for header work.
[reactos.git] / dll / win32 / urlmon / http.c
1 /*
2 * Copyright 2005 Jacek Caban
3 * Copyright 2007 Misha Koshelev
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 /*
21 * TODO:
22 * - Handle redirects as native.
23 */
24
25 #include "urlmon_main.h"
26 #include "wininet.h"
27
28 #include "wine/debug.h"
29
30 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
31
32 typedef struct {
33 Protocol base;
34
35 const IInternetProtocolVtbl *lpIInternetProtocolVtbl;
36 const IInternetPriorityVtbl *lpInternetPriorityVtbl;
37 const IWinInetHttpInfoVtbl *lpWinInetHttpInfoVtbl;
38
39 BOOL https;
40 IHttpNegotiate *http_negotiate;
41 LPWSTR full_header;
42
43 LONG ref;
44 } HttpProtocol;
45
46 #define PRIORITY(x) ((IInternetPriority*) &(x)->lpInternetPriorityVtbl)
47 #define INETHTTPINFO(x) ((IWinInetHttpInfo*) &(x)->lpWinInetHttpInfoVtbl)
48
49 /* Default headers from native */
50 static const WCHAR wszHeaders[] = {'A','c','c','e','p','t','-','E','n','c','o','d','i','n','g',
51 ':',' ','g','z','i','p',',',' ','d','e','f','l','a','t','e',0};
52
53 static LPWSTR query_http_info(HttpProtocol *This, DWORD option)
54 {
55 LPWSTR ret = NULL;
56 DWORD len = 0;
57 BOOL res;
58
59 res = HttpQueryInfoW(This->base.request, option, NULL, &len, NULL);
60 if (!res && GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
61 ret = heap_alloc(len);
62 res = HttpQueryInfoW(This->base.request, option, ret, &len, NULL);
63 }
64 if(!res) {
65 TRACE("HttpQueryInfoW(%d) failed: %08x\n", option, GetLastError());
66 heap_free(ret);
67 return NULL;
68 }
69
70 return ret;
71 }
72
73 #define ASYNCPROTOCOL_THIS(iface) DEFINE_THIS2(HttpProtocol, base, iface)
74
75 static HRESULT HttpProtocol_open_request(Protocol *prot, LPCWSTR url, DWORD request_flags,
76 HINTERNET internet_session, IInternetBindInfo *bind_info)
77 {
78 HttpProtocol *This = ASYNCPROTOCOL_THIS(prot);
79 LPWSTR addl_header = NULL, post_cookie = NULL, optional = NULL;
80 IServiceProvider *service_provider = NULL;
81 IHttpNegotiate2 *http_negotiate2 = NULL;
82 LPWSTR host, user, pass, path;
83 LPOLESTR accept_mimes[257];
84 URL_COMPONENTSW url_comp;
85 BYTE security_id[512];
86 DWORD len = 0;
87 ULONG num = 0;
88 BOOL res, b;
89 HRESULT hres;
90
91 static const WCHAR wszBindVerb[BINDVERB_CUSTOM][5] =
92 {{'G','E','T',0},
93 {'P','O','S','T',0},
94 {'P','U','T',0}};
95
96 memset(&url_comp, 0, sizeof(url_comp));
97 url_comp.dwStructSize = sizeof(url_comp);
98 url_comp.dwSchemeLength = url_comp.dwHostNameLength = url_comp.dwUrlPathLength =
99 url_comp.dwUserNameLength = url_comp.dwPasswordLength = 1;
100 if (!InternetCrackUrlW(url, 0, 0, &url_comp))
101 return MK_E_SYNTAX;
102
103 if(!url_comp.nPort)
104 url_comp.nPort = This->https ? INTERNET_DEFAULT_HTTPS_PORT : INTERNET_DEFAULT_HTTP_PORT;
105
106 host = heap_strndupW(url_comp.lpszHostName, url_comp.dwHostNameLength);
107 user = heap_strndupW(url_comp.lpszUserName, url_comp.dwUserNameLength);
108 pass = heap_strndupW(url_comp.lpszPassword, url_comp.dwPasswordLength);
109 This->base.connection = InternetConnectW(internet_session, host, url_comp.nPort, user, pass,
110 INTERNET_SERVICE_HTTP, This->https ? INTERNET_FLAG_SECURE : 0, (DWORD_PTR)&This->base);
111 heap_free(pass);
112 heap_free(user);
113 heap_free(host);
114 if(!This->base.connection) {
115 WARN("InternetConnect failed: %d\n", GetLastError());
116 return INET_E_CANNOT_CONNECT;
117 }
118
119 num = sizeof(accept_mimes)/sizeof(accept_mimes[0])-1;
120 hres = IInternetBindInfo_GetBindString(bind_info, BINDSTRING_ACCEPT_MIMES, accept_mimes, num, &num);
121 if(hres != S_OK) {
122 WARN("GetBindString BINDSTRING_ACCEPT_MIMES failed: %08x\n", hres);
123 return INET_E_NO_VALID_MEDIA;
124 }
125 accept_mimes[num] = 0;
126
127 path = heap_strndupW(url_comp.lpszUrlPath, url_comp.dwUrlPathLength);
128 if(This->https)
129 request_flags |= INTERNET_FLAG_SECURE;
130 This->base.request = HttpOpenRequestW(This->base.connection,
131 This->base.bind_info.dwBindVerb < BINDVERB_CUSTOM
132 ? wszBindVerb[This->base.bind_info.dwBindVerb] : This->base.bind_info.szCustomVerb,
133 path, NULL, NULL, (LPCWSTR *)accept_mimes, request_flags, (DWORD_PTR)&This->base);
134 heap_free(path);
135 while (num<sizeof(accept_mimes)/sizeof(accept_mimes[0]) && accept_mimes[num])
136 CoTaskMemFree(accept_mimes[num++]);
137 if (!This->base.request) {
138 WARN("HttpOpenRequest failed: %d\n", GetLastError());
139 return INET_E_RESOURCE_NOT_FOUND;
140 }
141
142 hres = IInternetProtocolSink_QueryInterface(This->base.protocol_sink, &IID_IServiceProvider,
143 (void **)&service_provider);
144 if (hres != S_OK) {
145 WARN("IInternetProtocolSink_QueryInterface IID_IServiceProvider failed: %08x\n", hres);
146 return hres;
147 }
148
149 hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate,
150 &IID_IHttpNegotiate, (void **)&This->http_negotiate);
151 if (hres != S_OK) {
152 WARN("IServiceProvider_QueryService IID_IHttpNegotiate failed: %08x\n", hres);
153 return hres;
154 }
155
156 hres = IHttpNegotiate_BeginningTransaction(This->http_negotiate, url, wszHeaders,
157 0, &addl_header);
158 if(hres != S_OK) {
159 WARN("IHttpNegotiate_BeginningTransaction failed: %08x\n", hres);
160 IServiceProvider_Release(service_provider);
161 return hres;
162 }
163
164 if(addl_header) {
165 int len_addl_header = strlenW(addl_header);
166
167 This->full_header = heap_alloc(len_addl_header*sizeof(WCHAR)+sizeof(wszHeaders));
168
169 lstrcpyW(This->full_header, addl_header);
170 lstrcpyW(&This->full_header[len_addl_header], wszHeaders);
171 CoTaskMemFree(addl_header);
172 }else {
173 This->full_header = (LPWSTR)wszHeaders;
174 }
175
176 hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate2,
177 &IID_IHttpNegotiate2, (void **)&http_negotiate2);
178 IServiceProvider_Release(service_provider);
179 if(hres != S_OK) {
180 WARN("IServiceProvider_QueryService IID_IHttpNegotiate2 failed: %08x\n", hres);
181 /* No goto done as per native */
182 }else {
183 len = sizeof(security_id)/sizeof(security_id[0]);
184 hres = IHttpNegotiate2_GetRootSecurityId(http_negotiate2, security_id, &len, 0);
185 IHttpNegotiate2_Release(http_negotiate2);
186 if (hres != S_OK)
187 WARN("IHttpNegotiate2_GetRootSecurityId failed: %08x\n", hres);
188 }
189
190 /* FIXME: Handle security_id. Native calls undocumented function IsHostInProxyBypassList. */
191
192 if(This->base.bind_info.dwBindVerb == BINDVERB_POST) {
193 num = 0;
194 hres = IInternetBindInfo_GetBindString(bind_info, BINDSTRING_POST_COOKIE, &post_cookie, 1, &num);
195 if(hres == S_OK && num) {
196 if(!InternetSetOptionW(This->base.request, INTERNET_OPTION_SECONDARY_CACHE_KEY,
197 post_cookie, lstrlenW(post_cookie)))
198 WARN("InternetSetOption INTERNET_OPTION_SECONDARY_CACHE_KEY failed: %d\n", GetLastError());
199 CoTaskMemFree(post_cookie);
200 }
201 }
202
203 if(This->base.bind_info.dwBindVerb != BINDVERB_GET) {
204 /* Native does not use GlobalLock/GlobalUnlock, so we won't either */
205 if (This->base.bind_info.stgmedData.tymed != TYMED_HGLOBAL)
206 WARN("Expected This->base.bind_info.stgmedData.tymed to be TYMED_HGLOBAL, not %d\n",
207 This->base.bind_info.stgmedData.tymed);
208 else
209 optional = (LPWSTR)This->base.bind_info.stgmedData.u.hGlobal;
210 }
211
212 b = TRUE;
213 res = InternetSetOptionW(This->base.request, INTERNET_OPTION_HTTP_DECODING, &b, sizeof(b));
214 if(!res)
215 WARN("InternetSetOption(INTERNET_OPTION_HTTP_DECODING) failed: %08x\n", GetLastError());
216
217 res = HttpSendRequestW(This->base.request, This->full_header, lstrlenW(This->full_header),
218 optional, optional ? This->base.bind_info.cbstgmedData : 0);
219 if(!res && GetLastError() != ERROR_IO_PENDING) {
220 WARN("HttpSendRequest failed: %d\n", GetLastError());
221 return INET_E_DOWNLOAD_FAILURE;
222 }
223
224 return S_OK;
225 }
226
227 static HRESULT HttpProtocol_start_downloading(Protocol *prot)
228 {
229 HttpProtocol *This = ASYNCPROTOCOL_THIS(prot);
230 LPWSTR content_type = 0, content_length = 0;
231 DWORD len = sizeof(DWORD);
232 DWORD status_code;
233 BOOL res;
234 HRESULT hres;
235
236 static const WCHAR wszDefaultContentType[] =
237 {'t','e','x','t','/','h','t','m','l',0};
238
239 if(!This->http_negotiate) {
240 WARN("Expected IHttpNegotiate pointer to be non-NULL\n");
241 return S_OK;
242 }
243
244 res = HttpQueryInfoW(This->base.request, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER,
245 &status_code, &len, NULL);
246 if(res) {
247 LPWSTR response_headers = query_http_info(This, HTTP_QUERY_RAW_HEADERS_CRLF);
248 if(response_headers) {
249 hres = IHttpNegotiate_OnResponse(This->http_negotiate, status_code, response_headers,
250 NULL, NULL);
251 heap_free(response_headers);
252 if (hres != S_OK) {
253 WARN("IHttpNegotiate_OnResponse failed: %08x\n", hres);
254 return S_OK;
255 }
256 }
257 }else {
258 WARN("HttpQueryInfo failed: %d\n", GetLastError());
259 }
260
261 if(This->https)
262 IInternetProtocolSink_ReportProgress(This->base.protocol_sink, BINDSTATUS_ACCEPTRANGES, NULL);
263
264 content_type = query_http_info(This, HTTP_QUERY_CONTENT_TYPE);
265 if(content_type) {
266 /* remove the charset, if present */
267 LPWSTR p = strchrW(content_type, ';');
268 if (p) *p = '\0';
269
270 IInternetProtocolSink_ReportProgress(This->base.protocol_sink,
271 (This->base.bindf & BINDF_FROMURLMON)
272 ? BINDSTATUS_MIMETYPEAVAILABLE : BINDSTATUS_RAWMIMETYPE,
273 content_type);
274 heap_free(content_type);
275 }else {
276 WARN("HttpQueryInfo failed: %d\n", GetLastError());
277 IInternetProtocolSink_ReportProgress(This->base.protocol_sink,
278 (This->base.bindf & BINDF_FROMURLMON)
279 ? BINDSTATUS_MIMETYPEAVAILABLE : BINDSTATUS_RAWMIMETYPE,
280 wszDefaultContentType);
281 }
282
283 content_length = query_http_info(This, HTTP_QUERY_CONTENT_LENGTH);
284 if(content_length) {
285 This->base.content_length = atoiW(content_length);
286 heap_free(content_length);
287 }
288
289 return S_OK;
290 }
291
292 static void HttpProtocol_close_connection(Protocol *prot)
293 {
294 HttpProtocol *This = ASYNCPROTOCOL_THIS(prot);
295
296 if(This->http_negotiate) {
297 IHttpNegotiate_Release(This->http_negotiate);
298 This->http_negotiate = 0;
299 }
300
301 if(This->full_header) {
302 if(This->full_header != wszHeaders)
303 heap_free(This->full_header);
304 This->full_header = 0;
305 }
306 }
307
308 #undef ASYNCPROTOCOL_THIS
309
310 static const ProtocolVtbl AsyncProtocolVtbl = {
311 HttpProtocol_open_request,
312 HttpProtocol_start_downloading,
313 HttpProtocol_close_connection
314 };
315
316 #define PROTOCOL_THIS(iface) DEFINE_THIS(HttpProtocol, IInternetProtocol, iface)
317
318 static HRESULT WINAPI HttpProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
319 {
320 HttpProtocol *This = PROTOCOL_THIS(iface);
321
322 *ppv = NULL;
323 if(IsEqualGUID(&IID_IUnknown, riid)) {
324 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
325 *ppv = PROTOCOL(This);
326 }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
327 TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", This, ppv);
328 *ppv = PROTOCOL(This);
329 }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
330 TRACE("(%p)->(IID_IInternetProtocol %p)\n", This, ppv);
331 *ppv = PROTOCOL(This);
332 }else if(IsEqualGUID(&IID_IInternetPriority, riid)) {
333 TRACE("(%p)->(IID_IInternetPriority %p)\n", This, ppv);
334 *ppv = PRIORITY(This);
335 }else if(IsEqualGUID(&IID_IWinInetInfo, riid)) {
336 TRACE("(%p)->(IID_IWinInetInfo %p)\n", This, ppv);
337 *ppv = INETHTTPINFO(This);
338 }else if(IsEqualGUID(&IID_IWinInetHttpInfo, riid)) {
339 TRACE("(%p)->(IID_IWinInetHttpInfo %p)\n", This, ppv);
340 *ppv = INETHTTPINFO(This);
341 }
342
343 if(*ppv) {
344 IInternetProtocol_AddRef(iface);
345 return S_OK;
346 }
347
348 WARN("not supported interface %s\n", debugstr_guid(riid));
349 return E_NOINTERFACE;
350 }
351
352 static ULONG WINAPI HttpProtocol_AddRef(IInternetProtocol *iface)
353 {
354 HttpProtocol *This = PROTOCOL_THIS(iface);
355 LONG ref = InterlockedIncrement(&This->ref);
356 TRACE("(%p) ref=%d\n", This, ref);
357 return ref;
358 }
359
360 static ULONG WINAPI HttpProtocol_Release(IInternetProtocol *iface)
361 {
362 HttpProtocol *This = PROTOCOL_THIS(iface);
363 LONG ref = InterlockedDecrement(&This->ref);
364
365 TRACE("(%p) ref=%d\n", This, ref);
366
367 if(!ref) {
368 protocol_close_connection(&This->base);
369 heap_free(This);
370
371 URLMON_UnlockModule();
372 }
373
374 return ref;
375 }
376
377 static HRESULT WINAPI HttpProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
378 IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
379 DWORD grfPI, HANDLE_PTR dwReserved)
380 {
381 HttpProtocol *This = PROTOCOL_THIS(iface);
382
383 static const WCHAR httpW[] = {'h','t','t','p',':'};
384 static const WCHAR httpsW[] = {'h','t','t','p','s',':'};
385
386 TRACE("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink,
387 pOIBindInfo, grfPI, dwReserved);
388
389 if(This->https
390 ? strncmpW(szUrl, httpsW, sizeof(httpsW)/sizeof(WCHAR))
391 : strncmpW(szUrl, httpW, sizeof(httpW)/sizeof(WCHAR)))
392 return MK_E_SYNTAX;
393
394 return protocol_start(&This->base, PROTOCOL(This), szUrl, pOIProtSink, pOIBindInfo);
395 }
396
397 static HRESULT WINAPI HttpProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData)
398 {
399 HttpProtocol *This = PROTOCOL_THIS(iface);
400
401 TRACE("(%p)->(%p)\n", This, pProtocolData);
402
403 return protocol_continue(&This->base, pProtocolData);
404 }
405
406 static HRESULT WINAPI HttpProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
407 DWORD dwOptions)
408 {
409 HttpProtocol *This = PROTOCOL_THIS(iface);
410 FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
411 return E_NOTIMPL;
412 }
413
414 static HRESULT WINAPI HttpProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
415 {
416 HttpProtocol *This = PROTOCOL_THIS(iface);
417
418 TRACE("(%p)->(%08x)\n", This, dwOptions);
419
420 protocol_close_connection(&This->base);
421 return S_OK;
422 }
423
424 static HRESULT WINAPI HttpProtocol_Suspend(IInternetProtocol *iface)
425 {
426 HttpProtocol *This = PROTOCOL_THIS(iface);
427 FIXME("(%p)\n", This);
428 return E_NOTIMPL;
429 }
430
431 static HRESULT WINAPI HttpProtocol_Resume(IInternetProtocol *iface)
432 {
433 HttpProtocol *This = PROTOCOL_THIS(iface);
434 FIXME("(%p)\n", This);
435 return E_NOTIMPL;
436 }
437
438 static HRESULT WINAPI HttpProtocol_Read(IInternetProtocol *iface, void *pv,
439 ULONG cb, ULONG *pcbRead)
440 {
441 HttpProtocol *This = PROTOCOL_THIS(iface);
442
443 TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
444
445 return protocol_read(&This->base, pv, cb, pcbRead);
446 }
447
448 static HRESULT WINAPI HttpProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
449 DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
450 {
451 HttpProtocol *This = PROTOCOL_THIS(iface);
452 FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
453 return E_NOTIMPL;
454 }
455
456 static HRESULT WINAPI HttpProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
457 {
458 HttpProtocol *This = PROTOCOL_THIS(iface);
459
460 TRACE("(%p)->(%08x)\n", This, dwOptions);
461
462 return protocol_lock_request(&This->base);
463 }
464
465 static HRESULT WINAPI HttpProtocol_UnlockRequest(IInternetProtocol *iface)
466 {
467 HttpProtocol *This = PROTOCOL_THIS(iface);
468
469 TRACE("(%p)\n", This);
470
471 return protocol_unlock_request(&This->base);
472 }
473
474 #undef PROTOCOL_THIS
475
476 static const IInternetProtocolVtbl HttpProtocolVtbl = {
477 HttpProtocol_QueryInterface,
478 HttpProtocol_AddRef,
479 HttpProtocol_Release,
480 HttpProtocol_Start,
481 HttpProtocol_Continue,
482 HttpProtocol_Abort,
483 HttpProtocol_Terminate,
484 HttpProtocol_Suspend,
485 HttpProtocol_Resume,
486 HttpProtocol_Read,
487 HttpProtocol_Seek,
488 HttpProtocol_LockRequest,
489 HttpProtocol_UnlockRequest
490 };
491
492 #define PRIORITY_THIS(iface) DEFINE_THIS(HttpProtocol, InternetPriority, iface)
493
494 static HRESULT WINAPI HttpPriority_QueryInterface(IInternetPriority *iface, REFIID riid, void **ppv)
495 {
496 HttpProtocol *This = PRIORITY_THIS(iface);
497 return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
498 }
499
500 static ULONG WINAPI HttpPriority_AddRef(IInternetPriority *iface)
501 {
502 HttpProtocol *This = PRIORITY_THIS(iface);
503 return IInternetProtocol_AddRef(PROTOCOL(This));
504 }
505
506 static ULONG WINAPI HttpPriority_Release(IInternetPriority *iface)
507 {
508 HttpProtocol *This = PRIORITY_THIS(iface);
509 return IInternetProtocol_Release(PROTOCOL(This));
510 }
511
512 static HRESULT WINAPI HttpPriority_SetPriority(IInternetPriority *iface, LONG nPriority)
513 {
514 HttpProtocol *This = PRIORITY_THIS(iface);
515
516 TRACE("(%p)->(%d)\n", This, nPriority);
517
518 This->base.priority = nPriority;
519 return S_OK;
520 }
521
522 static HRESULT WINAPI HttpPriority_GetPriority(IInternetPriority *iface, LONG *pnPriority)
523 {
524 HttpProtocol *This = PRIORITY_THIS(iface);
525
526 TRACE("(%p)->(%p)\n", This, pnPriority);
527
528 *pnPriority = This->base.priority;
529 return S_OK;
530 }
531
532 #undef PRIORITY_THIS
533
534 static const IInternetPriorityVtbl HttpPriorityVtbl = {
535 HttpPriority_QueryInterface,
536 HttpPriority_AddRef,
537 HttpPriority_Release,
538 HttpPriority_SetPriority,
539 HttpPriority_GetPriority
540 };
541
542 #define INETINFO_THIS(iface) DEFINE_THIS(HttpProtocol, WinInetHttpInfo, iface)
543
544 static HRESULT WINAPI HttpInfo_QueryInterface(IWinInetHttpInfo *iface, REFIID riid, void **ppv)
545 {
546 HttpProtocol *This = INETINFO_THIS(iface);
547 return IBinding_QueryInterface(PROTOCOL(This), riid, ppv);
548 }
549
550 static ULONG WINAPI HttpInfo_AddRef(IWinInetHttpInfo *iface)
551 {
552 HttpProtocol *This = INETINFO_THIS(iface);
553 return IBinding_AddRef(PROTOCOL(This));
554 }
555
556 static ULONG WINAPI HttpInfo_Release(IWinInetHttpInfo *iface)
557 {
558 HttpProtocol *This = INETINFO_THIS(iface);
559 return IBinding_Release(PROTOCOL(This));
560 }
561
562 static HRESULT WINAPI HttpInfo_QueryOption(IWinInetHttpInfo *iface, DWORD dwOption,
563 void *pBuffer, DWORD *pcbBuffer)
564 {
565 HttpProtocol *This = INETINFO_THIS(iface);
566 FIXME("(%p)->(%x %p %p)\n", This, dwOption, pBuffer, pcbBuffer);
567 return E_NOTIMPL;
568 }
569
570 static HRESULT WINAPI HttpInfo_QueryInfo(IWinInetHttpInfo *iface, DWORD dwOption,
571 void *pBuffer, DWORD *pcbBuffer, DWORD *pdwFlags, DWORD *pdwReserved)
572 {
573 HttpProtocol *This = INETINFO_THIS(iface);
574 FIXME("(%p)->(%x %p %p %p %p)\n", This, dwOption, pBuffer, pcbBuffer, pdwFlags, pdwReserved);
575 return E_NOTIMPL;
576 }
577
578 #undef INETINFO_THIS
579
580 static const IWinInetHttpInfoVtbl WinInetHttpInfoVtbl = {
581 HttpInfo_QueryInterface,
582 HttpInfo_AddRef,
583 HttpInfo_Release,
584 HttpInfo_QueryOption,
585 HttpInfo_QueryInfo
586 };
587
588 static HRESULT create_http_protocol(BOOL https, void **ppobj)
589 {
590 HttpProtocol *ret;
591
592 ret = heap_alloc_zero(sizeof(HttpProtocol));
593 if(!ret)
594 return E_OUTOFMEMORY;
595
596 ret->base.vtbl = &AsyncProtocolVtbl;
597 ret->lpIInternetProtocolVtbl = &HttpProtocolVtbl;
598 ret->lpInternetPriorityVtbl = &HttpPriorityVtbl;
599 ret->lpWinInetHttpInfoVtbl = &WinInetHttpInfoVtbl;
600
601 ret->https = https;
602 ret->ref = 1;
603
604 *ppobj = PROTOCOL(ret);
605
606 URLMON_LockModule();
607 return S_OK;
608 }
609
610 HRESULT HttpProtocol_Construct(IUnknown *pUnkOuter, LPVOID *ppobj)
611 {
612 TRACE("(%p %p)\n", pUnkOuter, ppobj);
613
614 return create_http_protocol(FALSE, ppobj);
615 }
616
617 HRESULT HttpSProtocol_Construct(IUnknown *pUnkOuter, LPVOID *ppobj)
618 {
619 TRACE("(%p %p)\n", pUnkOuter, ppobj);
620
621 return create_http_protocol(TRUE, ppobj);
622 }