1 /*
2 * DirectPlay8 Peer
3 *
4 * Copyright 2004 Raphael Junqueira
5 * Copyright 2008 Alexander N. Sørnes <alex@thehandofagony.com>
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 *
21 */
22
23 #include "config.h"
24
25 #include <stdarg.h>
26
27 #define COBJMACROS
28 #include "windef.h"
29 #include "winbase.h"
30 #include "wingdi.h"
31 #include "winuser.h"
32 #include "objbase.h"
33 #include "wine/debug.h"
34
35 #include "dplay8.h"
36 #include "dpnet_private.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(dpnet);
39
40 static inline IDirectPlay8PeerImpl *impl_from_IDirectPlay8Peer(IDirectPlay8Peer *iface)
41 {
42 return CONTAINING_RECORD(iface, IDirectPlay8PeerImpl, IDirectPlay8Peer_iface);
43 }
44
45 /* IUnknown interface follows */
46 static HRESULT WINAPI IDirectPlay8PeerImpl_QueryInterface(IDirectPlay8Peer *iface, REFIID riid,
47 void **ppobj)
48 {
49 IDirectPlay8PeerImpl* This = impl_from_IDirectPlay8Peer(iface);
50
51 if(IsEqualGUID(riid, &IID_IUnknown) ||
52 IsEqualGUID(riid, &IID_IDirectPlay8Peer))
53 {
54 IUnknown_AddRef(iface);
55 *ppobj = This;
56 return DPN_OK;
57 }
58
59 WARN("(%p)->(%s,%p): not found\n", This, debugstr_guid(riid), ppobj);
60 return E_NOINTERFACE;
61 }
62
63 static ULONG WINAPI IDirectPlay8PeerImpl_AddRef(IDirectPlay8Peer *iface)
64 {
65 IDirectPlay8PeerImpl* This = impl_from_IDirectPlay8Peer(iface);
66 ULONG RefCount = InterlockedIncrement(&This->ref);
67
68 return RefCount;
69 }
70
71 static ULONG WINAPI IDirectPlay8PeerImpl_Release(IDirectPlay8Peer *iface)
72 {
73 IDirectPlay8PeerImpl* This = impl_from_IDirectPlay8Peer(iface);
74 ULONG RefCount = InterlockedDecrement(&This->ref);
75
76 if(!RefCount)
77 HeapFree(GetProcessHeap(), 0, This);
78
79 return RefCount;
80 }
81
82 /* IDirectPlay8Peer interface follows */
83
84 static HRESULT WINAPI IDirectPlay8PeerImpl_Initialize(IDirectPlay8Peer *iface,
85 void * const pvUserContext, const PFNDPNMESSAGEHANDLER pfn, const DWORD dwFlags)
86 {
87 FIXME("(%p)->(%p,%p,%x): stub\n", iface, pvUserContext, pfn, dwFlags);
88
89 return DPNERR_GENERIC;
90 }
91
92 static HRESULT WINAPI IDirectPlay8PeerImpl_EnumServiceProviders(IDirectPlay8Peer *iface,
93 const GUID * const pguidServiceProvider, const GUID * const pguidApplication,
94 DPN_SERVICE_PROVIDER_INFO * const pSPInfoBuffer, DWORD * const pcbEnumData,
95 DWORD * const pcReturned, const DWORD dwFlags)
96 {
97 FIXME("(%p)->(%p,%p,%p,%p,%p,%x): stub\n", iface, pguidServiceProvider, pguidApplication, pSPInfoBuffer, pcbEnumData, pcReturned, dwFlags);
98 return DPNERR_GENERIC;
99 }
100
101 static HRESULT WINAPI IDirectPlay8PeerImpl_CancelAsyncOperation(IDirectPlay8Peer *iface,
102 const DPNHANDLE hAsyncHandle, const DWORD dwFlags)
103 {
104 FIXME("(%p)->(%x,%x): stub\n", iface, hAsyncHandle, dwFlags);
105
106 return DPNERR_GENERIC;
107 }
108
109 static HRESULT WINAPI IDirectPlay8PeerImpl_Connect(IDirectPlay8Peer *iface,
110 const DPN_APPLICATION_DESC * const pdnAppDesc, IDirectPlay8Address * const pHostAddr,
111 IDirectPlay8Address * const pDeviceInfo, const DPN_SECURITY_DESC * const pdnSecurity,
112 const DPN_SECURITY_CREDENTIALS * const pdnCredentials, const void * const pvUserConnectData,
113 const DWORD dwUserConnectDataSize, void * const pvPlayerContext,
114 void * const pvAsyncContext, DPNHANDLE * const phAsyncHandle, const DWORD dwFlags)
115 {
116 FIXME("(%p)->(%p,%p,%p,%p,%p,%p,%x,%p,%p,%p,%x): stub\n", iface, pdnAppDesc, pHostAddr, pDeviceInfo, pdnSecurity, pdnCredentials, pvUserConnectData, dwUserConnectDataSize, pvPlayerContext, pvAsyncContext, phAsyncHandle, dwFlags);
117
118 return DPNERR_GENERIC;
119 }
120
121 static HRESULT WINAPI IDirectPlay8PeerImpl_SendTo(IDirectPlay8Peer *iface, const DPNID dpnId,
122 const DPN_BUFFER_DESC *pBufferDesc, const DWORD cBufferDesc, const DWORD dwTimeOut,
123 void * const pvAsyncContext, DPNHANDLE * const phAsyncHandle, const DWORD dwFlags)
124 {
125 FIXME("(%p)->(%x,%p,%x,%x,%p,%p,%x): stub\n", iface, dpnId, pBufferDesc, cBufferDesc, dwTimeOut, pvAsyncContext, phAsyncHandle, dwFlags);
126
127 return DPNERR_GENERIC;
128 }
129
130 static HRESULT WINAPI IDirectPlay8PeerImpl_GetSendQueueInfo(IDirectPlay8Peer *iface,
131 const DPNID dpnid, DWORD * const pdwNumMsgs, DWORD * const pdwNumBytes, const DWORD dwFlags)
132 {
133 FIXME("(%p)->(%x,%p,%p,%x): stub\n", iface, dpnid, pdwNumMsgs, pdwNumBytes, dwFlags);
134
135 return DPNERR_GENERIC;
136 }
137
138 static HRESULT WINAPI IDirectPlay8PeerImpl_Host(IDirectPlay8Peer *iface,
139 const DPN_APPLICATION_DESC * const pdnAppDesc, IDirectPlay8Address ** const prgpDeviceInfo,
140 const DWORD cDeviceInfo, const DPN_SECURITY_DESC * const pdpSecurity,
141 const DPN_SECURITY_CREDENTIALS * const pdpCredentials, void * const pvPlayerContext,
142 const DWORD dwFlags)
143 {
144 FIXME("(%p)->(%p,%p,%x,%p,%p,%p,%x): stub\n", iface, pdnAppDesc, prgpDeviceInfo, cDeviceInfo, pdpSecurity, pdpCredentials, pvPlayerContext, dwFlags);
145
146 return DPNERR_GENERIC;
147 }
148
149 static HRESULT WINAPI IDirectPlay8PeerImpl_GetApplicationDesc(IDirectPlay8Peer *iface,
150 DPN_APPLICATION_DESC * const pAppDescBuffer, DWORD * const pcbDataSize, const DWORD dwFlags)
151 {
152 FIXME("(%p)->(%p,%p,%x): stub\n", iface, pAppDescBuffer, pcbDataSize, dwFlags);
153
154 return DPNERR_GENERIC;
155 }
156
157 static HRESULT WINAPI IDirectPlay8PeerImpl_SetApplicationDesc(IDirectPlay8Peer *iface,
158 const DPN_APPLICATION_DESC * const pad, const DWORD dwFlags)
159 {
160 FIXME("(%p)->(%p,%x): stub\n", iface, pad, dwFlags);
161
162 return DPNERR_GENERIC;
163 }
164
165 static HRESULT WINAPI IDirectPlay8PeerImpl_CreateGroup(IDirectPlay8Peer *iface,
166 const DPN_GROUP_INFO * const pdpnGroupInfo, void * const pvGroupContext,
167 void * const pvAsyncContext, DPNHANDLE * const phAsyncHandle, const DWORD dwFlags)
168 {
169 FIXME("(%p)->(%p,%p,%p,%p,%x): stub\n", iface, pdpnGroupInfo, pvGroupContext, pvAsyncContext, phAsyncHandle, dwFlags);
170
171 return DPNERR_GENERIC;
172 }
173
174 static HRESULT WINAPI IDirectPlay8PeerImpl_DestroyGroup(IDirectPlay8Peer *iface,
175 const DPNID idGroup, void * const pvAsyncContext, DPNHANDLE * const phAsyncHandle,
176 const DWORD dwFlags)
177 {
178 FIXME("(%p)->(%x,%p,%p,%x): stub\n", iface, idGroup, pvAsyncContext, phAsyncHandle, dwFlags);
179
180 return DPNERR_GENERIC;
181 }
182
183 static HRESULT WINAPI IDirectPlay8PeerImpl_AddPlayerToGroup(IDirectPlay8Peer *iface,
184 const DPNID idGroup, const DPNID idClient, void * const pvAsyncContext,
185 DPNHANDLE * const phAsyncHandle, const DWORD dwFlags)
186 {
187 FIXME("(%p)->(%x,%x,%p,%p,%x): stub\n", iface, idGroup, idClient, pvAsyncContext, phAsyncHandle, dwFlags);
188
189 return DPNERR_GENERIC;
190 }
191
192 static HRESULT WINAPI IDirectPlay8PeerImpl_RemovePlayerFromGroup(IDirectPlay8Peer *iface,
193 const DPNID idGroup, const DPNID idClient, void * const pvAsyncContext,
194 DPNHANDLE * const phAsyncHandle, const DWORD dwFlags)
195 {
196 FIXME("(%p)->(%x,%x,%p,%p,%x): stub\n", iface, idGroup, idClient, pvAsyncContext, phAsyncHandle, dwFlags);
197
198 return DPNERR_GENERIC;
199 }
200
201 static HRESULT WINAPI IDirectPlay8PeerImpl_SetGroupInfo(IDirectPlay8Peer *iface, const DPNID dpnid,
202 DPN_GROUP_INFO * const pdpnGroupInfo, void * const pvAsyncContext,
203 DPNHANDLE * const phAsyncHandle, const DWORD dwFlags)
204 {
205 FIXME("(%p)->(%x,%p,%p,%p,%x): stub\n", iface, dpnid, pdpnGroupInfo, pvAsyncContext, phAsyncHandle, dwFlags);
206
207 return DPNERR_GENERIC;
208 }
209
210 static HRESULT WINAPI IDirectPlay8PeerImpl_GetGroupInfo(IDirectPlay8Peer *iface, const DPNID dpnid,
211 DPN_GROUP_INFO * const pdpnGroupInfo, DWORD * const pdwSize, const DWORD dwFlags)
212 {
213 FIXME("(%p)->(%x,%p,%p,%x): stub\n", iface, dpnid, pdpnGroupInfo, pdwSize, dwFlags);
214
215 return DPNERR_GENERIC;
216 }
217
218 static HRESULT WINAPI IDirectPlay8PeerImpl_EnumPlayersAndGroups(IDirectPlay8Peer *iface,
219 DPNID * const prgdpnid, DWORD * const pcdpnid, const DWORD dwFlags)
220 {
221 FIXME("(%p)->(%p,%p,%x): stub\n", iface, prgdpnid, pcdpnid, dwFlags);
222
223 return DPNERR_GENERIC;
224 }
225
226 static HRESULT WINAPI IDirectPlay8PeerImpl_EnumGroupMembers(IDirectPlay8Peer *iface,
227 const DPNID dpnid, DPNID * const prgdpnid, DWORD * const pcdpnid, const DWORD dwFlags)
228 {
229 FIXME("(%p)->(%x,%p,%p,%x): stub\n", iface, dpnid, prgdpnid, pcdpnid, dwFlags);
230
231 return DPNERR_GENERIC;
232 }
233
234 static HRESULT WINAPI IDirectPlay8PeerImpl_SetPeerInfo(IDirectPlay8Peer *iface,
235 const DPN_PLAYER_INFO * const pdpnPlayerInfo, void * const pvAsyncContext,
236 DPNHANDLE * const phAsyncHandle, const DWORD dwFlags)
237 {
238 FIXME("(%p)->(%p,%p,%p,%x): stub\n", iface, pdpnPlayerInfo, pvAsyncContext, phAsyncHandle, dwFlags);
239
240 return DPNERR_GENERIC;
241 }
242
243 static HRESULT WINAPI IDirectPlay8PeerImpl_GetPeerInfo(IDirectPlay8Peer *iface, const DPNID dpnid,
244 DPN_PLAYER_INFO * const pdpnPlayerInfo, DWORD * const pdwSize, const DWORD dwFlags)
245 {
246 FIXME("(%p)->(%x,%p,%p,%x): stub\n", iface, dpnid, pdpnPlayerInfo, pdwSize, dwFlags);
247
248 return DPNERR_GENERIC;
249 }
250
251 static HRESULT WINAPI IDirectPlay8PeerImpl_GetPeerAddress(IDirectPlay8Peer *iface,
252 const DPNID dpnid, IDirectPlay8Address ** const pAddress, const DWORD dwFlags)
253 {
254 FIXME("(%p)->(%x,%p,%x): stub\n", iface, dpnid, pAddress, dwFlags);
255
256 return DPNERR_GENERIC;
257 }
258
259 static HRESULT WINAPI IDirectPlay8PeerImpl_GetLocalHostAddresses(IDirectPlay8Peer *iface,
260 IDirectPlay8Address ** const prgpAddress, DWORD * const pcAddress, const DWORD dwFlags)
261 {
262 FIXME("(%p)->(%p,%p,%x): stub\n", iface, prgpAddress, pcAddress, dwFlags);
263
264 return DPNERR_GENERIC;
265 }
266
267 static HRESULT WINAPI IDirectPlay8PeerImpl_Close(IDirectPlay8Peer *iface, const DWORD dwFlags)
268 {
269 FIXME("(%p)->(%x): stub\n", iface, dwFlags);
270
271 return DPN_OK;
272 }
273
274 static const IDirectPlay8PeerVtbl DirectPlay8Peer_Vtbl =
275 {
276 IDirectPlay8PeerImpl_QueryInterface,
277 IDirectPlay8PeerImpl_AddRef,
278 IDirectPlay8PeerImpl_Release,
279 IDirectPlay8PeerImpl_Initialize,
280 IDirectPlay8PeerImpl_EnumServiceProviders,
281 IDirectPlay8PeerImpl_CancelAsyncOperation,
282 IDirectPlay8PeerImpl_Connect,
283 IDirectPlay8PeerImpl_SendTo,
284 IDirectPlay8PeerImpl_GetSendQueueInfo,
285 IDirectPlay8PeerImpl_Host,
286 IDirectPlay8PeerImpl_GetApplicationDesc,
287 IDirectPlay8PeerImpl_SetApplicationDesc,
288 IDirectPlay8PeerImpl_CreateGroup,
289 IDirectPlay8PeerImpl_DestroyGroup,
290 IDirectPlay8PeerImpl_AddPlayerToGroup,
291 IDirectPlay8PeerImpl_RemovePlayerFromGroup,
292 IDirectPlay8PeerImpl_SetGroupInfo,
293 IDirectPlay8PeerImpl_GetGroupInfo,
294 IDirectPlay8PeerImpl_EnumPlayersAndGroups,
295 IDirectPlay8PeerImpl_EnumGroupMembers,
296 IDirectPlay8PeerImpl_SetPeerInfo,
297 IDirectPlay8PeerImpl_GetPeerInfo,
298 IDirectPlay8PeerImpl_GetPeerAddress,
299 IDirectPlay8PeerImpl_GetLocalHostAddresses,
300 IDirectPlay8PeerImpl_Close
301 };
302
303 HRESULT DPNET_CreateDirectPlay8Peer(LPCLASSFACTORY iface, LPUNKNOWN punkOuter, REFIID riid, LPVOID *ppobj) {
304 IDirectPlay8PeerImpl* Client;
305 HRESULT ret;
306
307 Client = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectPlay8PeerImpl));
308
309 if(Client == NULL)
310 {
311 *ppobj = NULL;
312 WARN("Not enough memory\n");
313 return E_OUTOFMEMORY;
314 }
315
316 Client->IDirectPlay8Peer_iface.lpVtbl = &DirectPlay8Peer_Vtbl;
317 ret = IDirectPlay8PeerImpl_QueryInterface(&Client->IDirectPlay8Peer_iface, riid, ppobj);
318 if(ret != DPN_OK)
319 HeapFree(GetProcessHeap(), 0, Client);
320
321 return ret;
322 }
323
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.