Create a branch for audio work
[reactos.git] / dll / win32 / urlmon / urlmon_main.h
1 /*
2 * Copyright 2002 Huw D M Davies for CodeWeavers
3 * Copyright 2009 Jacek Caban for CodeWeavers
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 #ifndef __WINE_URLMON_MAIN_H
21 #define __WINE_URLMON_MAIN_H
22
23 #include <stdarg.h>
24
25 #define COBJMACROS
26 #define NONAMELESSUNION
27 #define NONAMELESSSTRUCT
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "winuser.h"
32 #include "ole2.h"
33 #include "urlmon.h"
34 #include "wininet.h"
35
36 #include "wine/unicode.h"
37 #include "wine/list.h"
38
39 extern HINSTANCE hProxyDll DECLSPEC_HIDDEN;
40 extern HRESULT SecManagerImpl_Construct(IUnknown *pUnkOuter, LPVOID *ppobj);
41 extern HRESULT ZoneMgrImpl_Construct(IUnknown *pUnkOuter, LPVOID *ppobj);
42 extern HRESULT StdURLMoniker_Construct(IUnknown *pUnkOuter, LPVOID *ppobj);
43 extern HRESULT FileProtocol_Construct(IUnknown *pUnkOuter, LPVOID *ppobj);
44 extern HRESULT HttpProtocol_Construct(IUnknown *pUnkOuter, LPVOID *ppobj);
45 extern HRESULT HttpSProtocol_Construct(IUnknown *pUnkOuter, LPVOID *ppobj);
46 extern HRESULT FtpProtocol_Construct(IUnknown *pUnkOuter, LPVOID *ppobj);
47 extern HRESULT GopherProtocol_Construct(IUnknown *pUnkOuter, LPVOID *ppobj);
48 extern HRESULT MkProtocol_Construct(IUnknown *pUnkOuter, LPVOID *ppobj);
49 extern HRESULT MimeFilter_Construct(IUnknown *pUnkOuter, LPVOID *ppobj);
50
51 extern BOOL WINAPI URLMON_DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) DECLSPEC_HIDDEN;
52 extern HRESULT WINAPI URLMON_DllGetClassObject(REFCLSID rclsid, REFIID iid,LPVOID *ppv) DECLSPEC_HIDDEN;
53 extern HRESULT WINAPI URLMON_DllRegisterServer(void) DECLSPEC_HIDDEN;
54 extern HRESULT WINAPI URLMON_DllUnregisterServer(void) DECLSPEC_HIDDEN;
55
56 extern GUID const CLSID_PSFactoryBuffer DECLSPEC_HIDDEN;
57
58 /**********************************************************************
59 * Dll lifetime tracking declaration for urlmon.dll
60 */
61 extern LONG URLMON_refCount;
62 static inline void URLMON_LockModule(void) { InterlockedIncrement( &URLMON_refCount ); }
63 static inline void URLMON_UnlockModule(void) { InterlockedDecrement( &URLMON_refCount ); }
64
65 #define DEFINE_THIS2(cls,ifc,iface) ((cls*)((BYTE*)(iface)-offsetof(cls,ifc)))
66 #define DEFINE_THIS(cls,ifc,iface) DEFINE_THIS2(cls,lp ## ifc ## Vtbl,iface)
67
68 IInternetProtocolInfo *get_protocol_info(LPCWSTR);
69 HRESULT get_protocol_handler(LPCWSTR,CLSID*,BOOL*,IClassFactory**);
70 IInternetProtocol *get_mime_filter(LPCWSTR);
71 BOOL is_registered_protocol(LPCWSTR);
72 void register_urlmon_namespace(IClassFactory*,REFIID,LPCWSTR,BOOL);
73 HINTERNET get_internet_session(IInternetBindInfo*);
74 LPWSTR get_useragent(void);
75 void free_session(void);
76
77 HRESULT bind_to_storage(LPCWSTR url, IBindCtx *pbc, REFIID riid, void **ppv);
78 HRESULT bind_to_object(IMoniker *mon, LPCWSTR url, IBindCtx *pbc, REFIID riid, void **ppv);
79
80 HRESULT create_binding_protocol(LPCWSTR url, BOOL from_urlmon, IInternetProtocol **protocol);
81 void set_binding_sink(IInternetProtocol *bind_protocol, IInternetProtocolSink *sink, IInternetBindInfo *bind_info);
82 IWinInetInfo *get_wininet_info(IInternetProtocol*);
83
84 typedef struct ProtocolVtbl ProtocolVtbl;
85
86 typedef struct {
87 const ProtocolVtbl *vtbl;
88
89 IInternetProtocol *protocol;
90 IInternetProtocolSink *protocol_sink;
91
92 DWORD bindf;
93 BINDINFO bind_info;
94
95 HINTERNET request;
96 HINTERNET connection;
97 DWORD flags;
98 HANDLE lock;
99
100 ULONG current_position;
101 ULONG content_length;
102 ULONG available_bytes;
103
104 LONG priority;
105 } Protocol;
106
107 struct ProtocolVtbl {
108 HRESULT (*open_request)(Protocol*,IUri*,DWORD,HINTERNET,IInternetBindInfo*);
109 HRESULT (*start_downloading)(Protocol*);
110 void (*close_connection)(Protocol*);
111 };
112
113 HRESULT protocol_start(Protocol*,IInternetProtocol*,IUri*,IInternetProtocolSink*,IInternetBindInfo*);
114 HRESULT protocol_continue(Protocol*,PROTOCOLDATA*);
115 HRESULT protocol_read(Protocol*,void*,ULONG,ULONG*);
116 HRESULT protocol_lock_request(Protocol*);
117 HRESULT protocol_unlock_request(Protocol*);
118 void protocol_close_connection(Protocol*);
119
120 typedef struct {
121 const IInternetProtocolVtbl *lpIInternetProtocolVtbl;
122 const IInternetProtocolSinkVtbl *lpIInternetProtocolSinkVtbl;
123
124 LONG ref;
125
126 IInternetProtocolSink *protocol_sink;
127 IInternetProtocol *protocol;
128 } ProtocolProxy;
129
130 #define PROTOCOL(x) ((IInternetProtocol*) &(x)->lpIInternetProtocolVtbl)
131 #define PROTSINK(x) ((IInternetProtocolSink*) &(x)->lpIInternetProtocolSinkVtbl)
132
133 HRESULT create_protocol_proxy(IInternetProtocol*,IInternetProtocolSink*,ProtocolProxy**);
134
135 typedef struct {
136 HWND notif_hwnd;
137 DWORD notif_hwnd_cnt;
138
139 struct list entry;
140 } tls_data_t;
141
142 tls_data_t *get_tls_data(void);
143
144 HWND get_notif_hwnd(void);
145 void release_notif_hwnd(HWND);
146
147 static inline void *heap_alloc(size_t len)
148 {
149 return HeapAlloc(GetProcessHeap(), 0, len);
150 }
151
152 static inline void *heap_alloc_zero(size_t len)
153 {
154 return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
155 }
156
157 static inline void *heap_realloc(void *mem, size_t len)
158 {
159 return HeapReAlloc(GetProcessHeap(), 0, mem, len);
160 }
161
162 static inline void *heap_realloc_zero(void *mem, size_t len)
163 {
164 return HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mem, len);
165 }
166
167 static inline BOOL heap_free(void *mem)
168 {
169 return HeapFree(GetProcessHeap(), 0, mem);
170 }
171
172 static inline LPWSTR heap_strdupW(LPCWSTR str)
173 {
174 LPWSTR ret = NULL;
175
176 if(str) {
177 DWORD size;
178
179 size = (strlenW(str)+1)*sizeof(WCHAR);
180 ret = heap_alloc(size);
181 memcpy(ret, str, size);
182 }
183
184 return ret;
185 }
186
187 static inline LPWSTR heap_strndupW(LPCWSTR str, int len)
188 {
189 LPWSTR ret = NULL;
190
191 if(str) {
192 ret = heap_alloc((len+1)*sizeof(WCHAR));
193 if(ret) {
194 memcpy(ret, str, len*sizeof(WCHAR));
195 ret[len] = 0;
196 }
197 }
198
199 return ret;
200 }
201
202 static inline LPWSTR heap_strdupAtoW(const char *str)
203 {
204 LPWSTR ret = NULL;
205
206 if(str) {
207 DWORD len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
208 ret = heap_alloc(len*sizeof(WCHAR));
209 MultiByteToWideChar(CP_ACP, 0, str, -1, ret, len);
210 }
211
212 return ret;
213 }
214
215 #endif /* __WINE_URLMON_MAIN_H */