[LT2013]
[reactos.git] / dll / win32 / urlmon / gopher.c
1 /*
2 * Copyright 2009 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 "urlmon_main.h"
20 #include <wine/debug.h>
21
22 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
23
24 typedef struct {
25 Protocol base;
26
27 IInternetProtocol IInternetProtocol_iface;
28 IInternetPriority IInternetPriority_iface;
29
30 LONG ref;
31 } GopherProtocol;
32
33 static inline GopherProtocol *impl_from_Protocol(Protocol *prot)
34 {
35 return CONTAINING_RECORD(prot, GopherProtocol, base);
36 }
37
38 static HRESULT GopherProtocol_open_request(Protocol *prot, IUri *uri, DWORD request_flags,
39 HINTERNET internet_session, IInternetBindInfo *bind_info)
40 {
41 GopherProtocol *This = impl_from_Protocol(prot);
42 BSTR url;
43 HRESULT hres;
44
45 hres = IUri_GetAbsoluteUri(uri, &url);
46 if(FAILED(hres))
47 return hres;
48
49 This->base.request = InternetOpenUrlW(internet_session, url, NULL, 0,
50 request_flags, (DWORD_PTR)&This->base);
51 SysFreeString(url);
52 if (!This->base.request && GetLastError() != ERROR_IO_PENDING) {
53 WARN("InternetOpenUrl failed: %d\n", GetLastError());
54 return INET_E_RESOURCE_NOT_FOUND;
55 }
56
57 return S_OK;
58 }
59
60 static HRESULT GopherProtocol_end_request(Protocol *prot)
61 {
62 return E_NOTIMPL;
63 }
64
65 static HRESULT GopherProtocol_start_downloading(Protocol *prot)
66 {
67 return S_OK;
68 }
69
70 static void GopherProtocol_close_connection(Protocol *prot)
71 {
72 }
73
74 static void GopherProtocol_on_error(Protocol *prot, DWORD error)
75 {
76 FIXME("(%p) %d - stub\n", prot, error);
77 }
78
79 static const ProtocolVtbl AsyncProtocolVtbl = {
80 GopherProtocol_open_request,
81 GopherProtocol_end_request,
82 GopherProtocol_start_downloading,
83 GopherProtocol_close_connection,
84 GopherProtocol_on_error
85 };
86
87 static inline GopherProtocol *impl_from_IInternetProtocol(IInternetProtocol *iface)
88 {
89 return CONTAINING_RECORD(iface, GopherProtocol, IInternetProtocol_iface);
90 }
91
92 static HRESULT WINAPI GopherProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
93 {
94 GopherProtocol *This = impl_from_IInternetProtocol(iface);
95
96 *ppv = NULL;
97 if(IsEqualGUID(&IID_IUnknown, riid)) {
98 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
99 *ppv = &This->IInternetProtocol_iface;
100 }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
101 TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", This, ppv);
102 *ppv = &This->IInternetProtocol_iface;
103 }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
104 TRACE("(%p)->(IID_IInternetProtocol %p)\n", This, ppv);
105 *ppv = &This->IInternetProtocol_iface;
106 }else if(IsEqualGUID(&IID_IInternetPriority, riid)) {
107 TRACE("(%p)->(IID_IInternetPriority %p)\n", This, ppv);
108 *ppv = &This->IInternetPriority_iface;
109 }
110
111 if(*ppv) {
112 IInternetProtocol_AddRef(iface);
113 return S_OK;
114 }
115
116 WARN("not supported interface %s\n", debugstr_guid(riid));
117 return E_NOINTERFACE;
118 }
119
120 static ULONG WINAPI GopherProtocol_AddRef(IInternetProtocol *iface)
121 {
122 GopherProtocol *This = impl_from_IInternetProtocol(iface);
123 LONG ref = InterlockedIncrement(&This->ref);
124 TRACE("(%p) ref=%d\n", This, ref);
125 return ref;
126 }
127
128 static ULONG WINAPI GopherProtocol_Release(IInternetProtocol *iface)
129 {
130 GopherProtocol *This = impl_from_IInternetProtocol(iface);
131 LONG ref = InterlockedDecrement(&This->ref);
132
133 TRACE("(%p) ref=%d\n", This, ref);
134
135 if(!ref) {
136 heap_free(This);
137
138 URLMON_UnlockModule();
139 }
140
141 return ref;
142 }
143
144 static HRESULT WINAPI GopherProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
145 IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
146 DWORD grfPI, HANDLE_PTR dwReserved)
147 {
148 GopherProtocol *This = impl_from_IInternetProtocol(iface);
149 IUri *uri;
150 HRESULT hres;
151
152 TRACE("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink,
153 pOIBindInfo, grfPI, dwReserved);
154
155 hres = CreateUri(szUrl, 0, 0, &uri);
156 if(FAILED(hres))
157 return hres;
158
159 hres = protocol_start(&This->base, &This->IInternetProtocol_iface, uri, pOIProtSink,
160 pOIBindInfo);
161
162 IUri_Release(uri);
163 return hres;
164 }
165
166 static HRESULT WINAPI GopherProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData)
167 {
168 GopherProtocol *This = impl_from_IInternetProtocol(iface);
169
170 TRACE("(%p)->(%p)\n", This, pProtocolData);
171
172 return protocol_continue(&This->base, pProtocolData);
173 }
174
175 static HRESULT WINAPI GopherProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
176 DWORD dwOptions)
177 {
178 GopherProtocol *This = impl_from_IInternetProtocol(iface);
179
180 TRACE("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
181
182 return protocol_abort(&This->base, hrReason);
183 }
184
185 static HRESULT WINAPI GopherProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
186 {
187 GopherProtocol *This = impl_from_IInternetProtocol(iface);
188
189 TRACE("(%p)->(%08x)\n", This, dwOptions);
190
191 protocol_close_connection(&This->base);
192 return S_OK;
193 }
194
195 static HRESULT WINAPI GopherProtocol_Suspend(IInternetProtocol *iface)
196 {
197 GopherProtocol *This = impl_from_IInternetProtocol(iface);
198 FIXME("(%p)\n", This);
199 return E_NOTIMPL;
200 }
201
202 static HRESULT WINAPI GopherProtocol_Resume(IInternetProtocol *iface)
203 {
204 GopherProtocol *This = impl_from_IInternetProtocol(iface);
205 FIXME("(%p)\n", This);
206 return E_NOTIMPL;
207 }
208
209 static HRESULT WINAPI GopherProtocol_Read(IInternetProtocol *iface, void *pv,
210 ULONG cb, ULONG *pcbRead)
211 {
212 GopherProtocol *This = impl_from_IInternetProtocol(iface);
213
214 TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
215
216 return protocol_read(&This->base, pv, cb, pcbRead);
217 }
218
219 static HRESULT WINAPI GopherProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
220 DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
221 {
222 GopherProtocol *This = impl_from_IInternetProtocol(iface);
223 FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
224 return E_NOTIMPL;
225 }
226
227 static HRESULT WINAPI GopherProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
228 {
229 GopherProtocol *This = impl_from_IInternetProtocol(iface);
230
231 TRACE("(%p)->(%08x)\n", This, dwOptions);
232
233 return protocol_lock_request(&This->base);
234 }
235
236 static HRESULT WINAPI GopherProtocol_UnlockRequest(IInternetProtocol *iface)
237 {
238 GopherProtocol *This = impl_from_IInternetProtocol(iface);
239
240 TRACE("(%p)\n", This);
241
242 return protocol_unlock_request(&This->base);
243 }
244
245 static const IInternetProtocolVtbl GopherProtocolVtbl = {
246 GopherProtocol_QueryInterface,
247 GopherProtocol_AddRef,
248 GopherProtocol_Release,
249 GopherProtocol_Start,
250 GopherProtocol_Continue,
251 GopherProtocol_Abort,
252 GopherProtocol_Terminate,
253 GopherProtocol_Suspend,
254 GopherProtocol_Resume,
255 GopherProtocol_Read,
256 GopherProtocol_Seek,
257 GopherProtocol_LockRequest,
258 GopherProtocol_UnlockRequest
259 };
260
261 static inline GopherProtocol *impl_from_IInternetPriority(IInternetPriority *iface)
262 {
263 return CONTAINING_RECORD(iface, GopherProtocol, IInternetPriority_iface);
264 }
265
266 static HRESULT WINAPI GopherPriority_QueryInterface(IInternetPriority *iface, REFIID riid, void **ppv)
267 {
268 GopherProtocol *This = impl_from_IInternetPriority(iface);
269 return IInternetProtocol_QueryInterface(&This->IInternetProtocol_iface, riid, ppv);
270 }
271
272 static ULONG WINAPI GopherPriority_AddRef(IInternetPriority *iface)
273 {
274 GopherProtocol *This = impl_from_IInternetPriority(iface);
275 return IInternetProtocol_AddRef(&This->IInternetProtocol_iface);
276 }
277
278 static ULONG WINAPI GopherPriority_Release(IInternetPriority *iface)
279 {
280 GopherProtocol *This = impl_from_IInternetPriority(iface);
281 return IInternetProtocol_Release(&This->IInternetProtocol_iface);
282 }
283
284 static HRESULT WINAPI GopherPriority_SetPriority(IInternetPriority *iface, LONG nPriority)
285 {
286 GopherProtocol *This = impl_from_IInternetPriority(iface);
287
288 TRACE("(%p)->(%d)\n", This, nPriority);
289
290 This->base.priority = nPriority;
291 return S_OK;
292 }
293
294 static HRESULT WINAPI GopherPriority_GetPriority(IInternetPriority *iface, LONG *pnPriority)
295 {
296 GopherProtocol *This = impl_from_IInternetPriority(iface);
297
298 TRACE("(%p)->(%p)\n", This, pnPriority);
299
300 *pnPriority = This->base.priority;
301 return S_OK;
302 }
303
304 static const IInternetPriorityVtbl GopherPriorityVtbl = {
305 GopherPriority_QueryInterface,
306 GopherPriority_AddRef,
307 GopherPriority_Release,
308 GopherPriority_SetPriority,
309 GopherPriority_GetPriority
310 };
311
312 HRESULT GopherProtocol_Construct(IUnknown *pUnkOuter, LPVOID *ppobj)
313 {
314 GopherProtocol *ret;
315
316 TRACE("(%p %p)\n", pUnkOuter, ppobj);
317
318 URLMON_LockModule();
319
320 ret = heap_alloc_zero(sizeof(GopherProtocol));
321
322 ret->base.vtbl = &AsyncProtocolVtbl;
323 ret->IInternetProtocol_iface.lpVtbl = &GopherProtocolVtbl;
324 ret->IInternetPriority_iface.lpVtbl = &GopherPriorityVtbl;
325 ret->ref = 1;
326
327 *ppobj = &ret->IInternetProtocol_iface;
328
329 return S_OK;
330 }