crypt32: Partially implement checking name constraints with directory names.
[wine] / dlls / dpnet / peer.c
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 /* IUnknown interface follows */
41
42 static HRESULT WINAPI IDirectPlay8PeerImpl_QueryInterface(PDIRECTPLAY8PEER iface, REFIID riid, LPVOID* ppobj)
43 {
44     IDirectPlay8PeerImpl* This = (IDirectPlay8PeerImpl*)iface;
45
46     if(IsEqualGUID(riid, &IID_IUnknown) ||
47        IsEqualGUID(riid, &IID_IDirectPlay8Peer))
48     {
49         IUnknown_AddRef(iface);
50         *ppobj = This;
51         return DPN_OK;
52     }
53
54     WARN("(%p)->(%s,%p): not found\n", This, debugstr_guid(riid), ppobj);
55     return E_NOINTERFACE;
56 }
57
58 static ULONG WINAPI IDirectPlay8PeerImpl_AddRef(PDIRECTPLAY8PEER iface)
59 {
60     IDirectPlay8PeerImpl* This = (IDirectPlay8PeerImpl*)iface;
61     ULONG RefCount = InterlockedIncrement(&This->ref);
62
63     return RefCount;
64 }
65
66 static ULONG WINAPI IDirectPlay8PeerImpl_Release(PDIRECTPLAY8PEER iface)
67 {
68     IDirectPlay8PeerImpl* This = (IDirectPlay8PeerImpl*)iface;
69     ULONG RefCount = InterlockedDecrement(&This->ref);
70
71     if(!RefCount)
72         HeapFree(GetProcessHeap(), 0, This);
73
74     return RefCount;
75 }
76
77 /* IDirectPlay8Peer interface follows */
78
79 static HRESULT WINAPI IDirectPlay8PeerImpl_Initialize(PDIRECTPLAY8PEER iface, PVOID CONST pvUserContext, CONST PFNDPNMESSAGEHANDLER pfn, CONST DWORD dwFlags)
80 {
81     FIXME("(%p)->(%p,%p,%x): stub\n", iface, pvUserContext, pfn, dwFlags);
82
83     return DPNERR_GENERIC;
84 }
85
86 static HRESULT WINAPI IDirectPlay8PeerImpl_EnumServiceProviders(PDIRECTPLAY8PEER iface, CONST GUID *CONST pguidServiceProvider, CONST GUID *CONST pguidApplication, DPN_SERVICE_PROVIDER_INFO *CONST pSPInfoBuffer, DWORD *CONST pcbEnumData, DWORD *CONST pcReturned, CONST DWORD dwFlags)
87 {
88     FIXME("(%p)->(%p,%p,%p,%p,%p,%x): stub\n", iface, pguidServiceProvider, pguidApplication, pSPInfoBuffer, pcbEnumData, pcReturned, dwFlags);
89     return DPNERR_GENERIC;
90 }
91
92 static HRESULT WINAPI IDirectPlay8PeerImpl_CancelAsyncOperation(PDIRECTPLAY8PEER iface,
93                                                                 CONST DPNHANDLE hAsyncHandle,
94                                                                 CONST DWORD dwFlags)
95 {
96     FIXME("(%p)->(%x,%x): stub\n", iface, hAsyncHandle, dwFlags);
97
98     return DPNERR_GENERIC;
99 }
100
101 static HRESULT WINAPI IDirectPlay8PeerImpl_Connect(PDIRECTPLAY8PEER iface,
102                                                    CONST DPN_APPLICATION_DESC* CONST pdnAppDesc,
103                                                    IDirectPlay8Address *CONST pHostAddr,
104                                                    IDirectPlay8Address *CONST pDeviceInfo,
105                                                    CONST DPN_SECURITY_DESC *CONST pdnSecurity,
106                                                    CONST DPN_SECURITY_CREDENTIALS *CONST pdnCredentials,
107                                                    CONST VOID *CONST pvUserConnectData,
108                                                    CONST DWORD dwUserConnectDataSize,
109                                                    VOID *CONST pvPlayerContext,
110                                                    VOID *CONST pvAsyncContext,
111                                                    DPNHANDLE *CONST phAsyncHandle,
112                                                    CONST DWORD dwFlags)
113 {
114     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);
115
116     return DPNERR_GENERIC;
117 }
118
119 static HRESULT WINAPI IDirectPlay8PeerImpl_SendTo(PDIRECTPLAY8PEER iface,
120                                                   CONST DPNID dpnId,
121                                                   CONST DPN_BUFFER_DESC *pBufferDesc,
122                                                   CONST DWORD cBufferDesc,
123                                                   CONST DWORD dwTimeOut,
124                                                   VOID *CONST pvAsyncContext,
125                                                   DPNHANDLE *CONST phAsyncHandle,
126                                                   CONST DWORD dwFlags)
127 {
128     FIXME("(%p)->(%x,%p,%x,%x,%p,%p,%x): stub\n", iface, dpnId, pBufferDesc, cBufferDesc, dwTimeOut, pvAsyncContext, phAsyncHandle, dwFlags);
129
130     return DPNERR_GENERIC;
131 }
132
133 static HRESULT WINAPI IDirectPlay8PeerImpl_GetSendQueueInfo(PDIRECTPLAY8PEER iface,
134                                                             CONST DPNID dpnid,
135                                                             DWORD *CONST pdwNumMsgs,
136                                                             DWORD *CONST pdwNumBytes,
137                                                             CONST DWORD dwFlags)
138 {
139     FIXME("(%p)->(%x,%p,%p,%x): stub\n", iface, dpnid, pdwNumMsgs, pdwNumBytes, dwFlags);
140
141     return DPNERR_GENERIC;
142 }
143
144 static HRESULT WINAPI IDirectPlay8PeerImpl_Host(PDIRECTPLAY8PEER iface,
145                                                 CONST DPN_APPLICATION_DESC *CONST pdnAppDesc,
146                                                 IDirectPlay8Address **CONST prgpDeviceInfo,
147                                                 CONST DWORD cDeviceInfo,
148                                                 CONST DPN_SECURITY_DESC *CONST pdpSecurity,
149                                                 CONST DPN_SECURITY_CREDENTIALS *CONST pdpCredentials,
150                                                 VOID *CONST pvPlayerContext,
151                                                 CONST DWORD dwFlags)
152 {
153     FIXME("(%p)->(%p,%p,%x,%p,%p,%p,%x): stub\n", iface, pdnAppDesc, prgpDeviceInfo, cDeviceInfo, pdpSecurity, pdpCredentials, pvPlayerContext, dwFlags);
154
155     return DPNERR_GENERIC;
156 }
157
158 static HRESULT WINAPI IDirectPlay8PeerImpl_GetApplicationDesc(PDIRECTPLAY8PEER iface,
159                                                               DPN_APPLICATION_DESC *CONST pAppDescBuffer,
160                                                               DWORD *CONST pcbDataSize,
161                                                               CONST DWORD dwFlags)
162 {
163     FIXME("(%p)->(%p,%p,%x): stub\n", iface, pAppDescBuffer, pcbDataSize, dwFlags);
164
165     return DPNERR_GENERIC;
166 }
167
168 static HRESULT WINAPI IDirectPlay8PeerImpl_SetApplicationDesc(PDIRECTPLAY8PEER iface,
169                                                               CONST DPN_APPLICATION_DESC *CONST pad,
170                                                               CONST DWORD dwFlags)
171 {
172     FIXME("(%p)->(%p,%x): stub\n", iface, pad, dwFlags);
173
174     return DPNERR_GENERIC;
175 }
176
177 static HRESULT WINAPI IDirectPlay8PeerImpl_CreateGroup(PDIRECTPLAY8PEER iface,
178                                                        CONST DPN_GROUP_INFO *CONST pdpnGroupInfo,
179                                                        VOID *CONST pvGroupContext,
180                                                        VOID *CONST pvAsyncContext,
181                                                        DPNHANDLE *CONST phAsyncHandle,
182                                                        CONST DWORD dwFlags)
183 {
184     FIXME("(%p)->(%p,%p,%p,%p,%x): stub\n", iface, pdpnGroupInfo, pvGroupContext, pvAsyncContext, phAsyncHandle, dwFlags);
185
186     return DPNERR_GENERIC;
187 }
188
189 static HRESULT WINAPI IDirectPlay8PeerImpl_DestroyGroup(PDIRECTPLAY8PEER iface,
190                                                         CONST DPNID idGroup,
191                                                         PVOID CONST pvAsyncContext,
192                                                         DPNHANDLE *CONST phAsyncHandle,
193                                                         CONST DWORD dwFlags)
194 {
195     FIXME("(%p)->(%x,%p,%p,%x): stub\n", iface, idGroup, pvAsyncContext, phAsyncHandle, dwFlags);
196
197     return DPNERR_GENERIC;
198 }
199
200 static HRESULT WINAPI IDirectPlay8PeerImpl_AddPlayerToGroup(PDIRECTPLAY8PEER iface,
201                                                             CONST DPNID idGroup,
202                                                             CONST DPNID idClient,
203                                                             PVOID CONST pvAsyncContext,
204                                                             DPNHANDLE *CONST phAsyncHandle,
205                                                             CONST DWORD dwFlags)
206 {
207     FIXME("(%p)->(%x,%x,%p,%p,%x): stub\n", iface, idGroup, idClient, pvAsyncContext, phAsyncHandle, dwFlags);
208
209     return DPNERR_GENERIC;
210 }
211
212 static HRESULT WINAPI IDirectPlay8PeerImpl_RemovePlayerFromGroup(PDIRECTPLAY8PEER iface,
213                                                                  CONST DPNID idGroup,
214                                                                  CONST DPNID idClient,
215                                                                  PVOID CONST pvAsyncContext,
216                                                                  DPNHANDLE *CONST phAsyncHandle,
217                                                                  CONST DWORD dwFlags)
218 {
219     FIXME("(%p)->(%x,%x,%p,%p,%x): stub\n", iface, idGroup, idClient, pvAsyncContext, phAsyncHandle, dwFlags);
220
221     return DPNERR_GENERIC;
222 }
223
224 static HRESULT WINAPI IDirectPlay8PeerImpl_SetGroupInfo(PDIRECTPLAY8PEER iface,
225                                                         CONST DPNID dpnid,
226                                                         DPN_GROUP_INFO *CONST pdpnGroupInfo,
227                                                         PVOID CONST pvAsyncContext,
228                                                         DPNHANDLE *CONST phAsyncHandle,
229                                                         CONST DWORD dwFlags)
230 {
231     FIXME("(%p)->(%x,%p,%p,%p,%x): stub\n", iface, dpnid, pdpnGroupInfo, pvAsyncContext, phAsyncHandle, dwFlags);
232
233     return DPNERR_GENERIC;
234 }
235
236 static HRESULT WINAPI IDirectPlay8PeerImpl_GetGroupInfo(PDIRECTPLAY8PEER iface,
237                                                         CONST DPNID dpnid,
238                                                         DPN_GROUP_INFO *CONST pdpnGroupInfo,
239                                                         DWORD *CONST pdwSize,
240                                                         CONST DWORD dwFlags)
241 {
242     FIXME("(%p)->(%x,%p,%p,%x): stub\n", iface, dpnid, pdpnGroupInfo, pdwSize, dwFlags);
243
244     return DPNERR_GENERIC;
245 }
246
247 static HRESULT WINAPI IDirectPlay8PeerImpl_EnumPlayersAndGroups(PDIRECTPLAY8PEER iface,
248                                                                 DPNID *CONST prgdpnid,
249                                                                 DWORD *CONST pcdpnid,
250                                                                 CONST DWORD dwFlags)
251 {
252     FIXME("(%p)->(%p,%p,%x): stub\n", iface, prgdpnid, pcdpnid, dwFlags);
253
254     return DPNERR_GENERIC;
255 }
256
257 static HRESULT WINAPI IDirectPlay8PeerImpl_EnumGroupMembers(PDIRECTPLAY8PEER iface,
258                                                             CONST DPNID dpnid,
259                                                             DPNID *CONST prgdpnid,
260                                                             DWORD *CONST pcdpnid,
261                                                             CONST DWORD dwFlags)
262 {
263     FIXME("(%p)->(%x,%p,%p,%x): stub\n", iface, dpnid, prgdpnid, pcdpnid, dwFlags);
264
265     return DPNERR_GENERIC;
266 }
267
268 static HRESULT WINAPI IDirectPlay8PeerImpl_SetPeerInfo(PDIRECTPLAY8PEER iface,
269                                                        CONST DPN_PLAYER_INFO *CONST pdpnPlayerInfo,
270                                                        PVOID CONST pvAsyncContext,
271                                                        DPNHANDLE *CONST phAsyncHandle,
272                                                        CONST DWORD dwFlags)
273 {
274     FIXME("(%p)->(%p,%p,%p,%x): stub\n", iface, pdpnPlayerInfo, pvAsyncContext, phAsyncHandle, dwFlags);
275
276     return DPNERR_GENERIC;
277 }
278
279 static HRESULT WINAPI IDirectPlay8PeerImpl_GetPeerInfo(PDIRECTPLAY8PEER iface,
280                                                        CONST DPNID dpnid,
281                                                        DPN_PLAYER_INFO *CONST pdpnPlayerInfo,
282                                                        DWORD *CONST pdwSize,
283                                                        CONST DWORD dwFlags)
284 {
285     FIXME("(%p)->(%x,%p,%p,%x): stub\n", iface, dpnid, pdpnPlayerInfo, pdwSize, dwFlags);
286
287     return DPNERR_GENERIC;
288 }
289
290 static HRESULT WINAPI IDirectPlay8PeerImpl_GetPeerAddress(PDIRECTPLAY8PEER iface,
291                                                           CONST DPNID dpnid,
292                                                           IDirectPlay8Address **CONST pAddress,
293                                                           CONST DWORD dwFlags)
294 {
295     FIXME("(%p)->(%x,%p,%x): stub\n", iface, dpnid, pAddress, dwFlags);
296
297     return DPNERR_GENERIC;
298 }
299
300 static HRESULT WINAPI IDirectPlay8PeerImpl_GetLocalHostAddresses(PDIRECTPLAY8PEER iface,
301                                                                  IDirectPlay8Address **CONST prgpAddress,
302                                                                  DWORD *CONST pcAddress,
303                                                                  CONST DWORD dwFlags)
304 {
305     FIXME("(%p)->(%p,%p,%x): stub\n", iface, prgpAddress, pcAddress, dwFlags);
306
307     return DPNERR_GENERIC;
308 }
309
310 static HRESULT WINAPI IDirectPlay8PeerImpl_Close(PDIRECTPLAY8PEER iface,
311                                                  CONST DWORD dwFlags)
312 {
313     FIXME("(%p)->(%x): stub\n", iface, dwFlags);
314
315     return DPN_OK;
316 }
317
318 static const IDirectPlay8PeerVtbl DirectPlay8Peer_Vtbl =
319 {
320     IDirectPlay8PeerImpl_QueryInterface,
321     IDirectPlay8PeerImpl_AddRef,
322     IDirectPlay8PeerImpl_Release,
323     IDirectPlay8PeerImpl_Initialize,
324     IDirectPlay8PeerImpl_EnumServiceProviders,
325     IDirectPlay8PeerImpl_CancelAsyncOperation,
326     IDirectPlay8PeerImpl_Connect,
327     IDirectPlay8PeerImpl_SendTo,
328     IDirectPlay8PeerImpl_GetSendQueueInfo,
329     IDirectPlay8PeerImpl_Host,
330     IDirectPlay8PeerImpl_GetApplicationDesc,
331     IDirectPlay8PeerImpl_SetApplicationDesc,
332     IDirectPlay8PeerImpl_CreateGroup,
333     IDirectPlay8PeerImpl_DestroyGroup,
334     IDirectPlay8PeerImpl_AddPlayerToGroup,
335     IDirectPlay8PeerImpl_RemovePlayerFromGroup,
336     IDirectPlay8PeerImpl_SetGroupInfo,
337     IDirectPlay8PeerImpl_GetGroupInfo,
338     IDirectPlay8PeerImpl_EnumPlayersAndGroups,
339     IDirectPlay8PeerImpl_EnumGroupMembers,
340     IDirectPlay8PeerImpl_SetPeerInfo,
341     IDirectPlay8PeerImpl_GetPeerInfo,
342     IDirectPlay8PeerImpl_GetPeerAddress,
343     IDirectPlay8PeerImpl_GetLocalHostAddresses,
344     IDirectPlay8PeerImpl_Close
345 };
346
347 HRESULT DPNET_CreateDirectPlay8Peer(LPCLASSFACTORY iface, LPUNKNOWN punkOuter, REFIID riid, LPVOID *ppobj) {
348     IDirectPlay8PeerImpl* Client;
349     HRESULT Ret;
350
351     Client = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectPlay8PeerImpl));
352
353     if(Client == NULL)
354     {
355         *ppobj = NULL;
356         WARN("Not enough memory\n");
357         return E_OUTOFMEMORY;
358     }
359
360     Client->lpVtbl = &DirectPlay8Peer_Vtbl;
361     if((Ret = IDirectPlay8PeerImpl_QueryInterface((PDIRECTPLAY8PEER)Client, riid, ppobj)) != DPN_OK)
362         HeapFree(GetProcessHeap(), 0, Client);
363
364     return Ret;
365 }