#include <stdarg.h>#include <string.h>#include "windef.h"#include "winerror.h"#include "winbase.h"#include "winnt.h"#include "winreg.h"#include "winnls.h"#include "wine/debug.h"#include "dplayx_global.h"#include "name_server.h"#include "dplayx_queue.h"#include "wine/dplaysp.h"#include "dplay_global.h"
Include dependency graph for dplay.c:
Go to the source code of this file.
Classes | |
| struct | _DPRGOPContext |
| struct | _DPFAGContext |
| struct | tagCreateEnum |
Macros | |
| #define | COBJMACROS |
| #define | NONAMELESSUNION |
| #define | DPID_NOPARENT_GROUP 0 /* Magic number to indicate no parent of group */ |
| #define | DPID_SYSTEM_GROUP |
| #define | DPID_NAME_SERVER 0x19a9d65b /* Don't ask me why */ |
| #define | DPMSG_CREATEGROUP_DWFLAGS(x) ( (x) & DPGROUP_HIDDEN ) |
| #define | DPMSG_CREATEPLAYER_DWFLAGS(x) 0 |
Typedefs | |
| typedef struct _DPRGOPContext | DPRGOPContext |
| typedef struct _DPRGOPContext * | lpDPRGOPContext |
| typedef struct _DPFAGContext | DPFAGContext |
| typedef struct _DPFAGContext * | lpDPFAGContext |
| typedef struct tagCreateEnum | CreateEnumData |
| typedef struct tagCreateEnum * | lpCreateEnumData |
Variables | |
| static LONG | kludgePlayerGroupId = 1000 |
| static const IDirectPlayVtbl | dp_vt |
| static const IDirectPlay2Vtbl | dp2_vt |
| static const IDirectPlay2Vtbl | dp2A_vt |
| static const IDirectPlay3Vtbl | dp3_vt |
| static const IDirectPlay3Vtbl | dp3A_vt |
| static const IDirectPlay4Vtbl | dp4_vt |
| static const IDirectPlay4Vtbl | dp4A_vt |
Macro Definition Documentation
◆ COBJMACROS
◆ DPID_NAME_SERVER
◆ DPID_NOPARENT_GROUP
◆ DPID_SYSTEM_GROUP
| #define DPID_SYSTEM_GROUP |
Value:
DPID_NOPARENT_GROUP /* If system group is supported
we don't have to change much */
◆ DPMSG_CREATEGROUP_DWFLAGS
| #define DPMSG_CREATEGROUP_DWFLAGS | ( | x | ) | ( (x) & DPGROUP_HIDDEN ) |
◆ DPMSG_CREATEPLAYER_DWFLAGS
◆ NONAMELESSUNION
Typedef Documentation
◆ CreateEnumData
| typedef struct tagCreateEnum CreateEnumData |
◆ DPFAGContext
| typedef struct _DPFAGContext DPFAGContext |
◆ DPRGOPContext
| typedef struct _DPRGOPContext DPRGOPContext |
◆ lpCreateEnumData
| typedef struct tagCreateEnum * lpCreateEnumData |
◆ lpDPFAGContext
| typedef struct _DPFAGContext * lpDPFAGContext |
◆ lpDPRGOPContext
| typedef struct _DPRGOPContext * lpDPRGOPContext |
Function Documentation
◆ cbDeletePlayerFromAllGroups()
|
static |
Definition at line 2051 of file dplay.c.
2058{
2060
2062 {
2063 IDirectPlayX_DeletePlayerFromGroup( &lpCtxt->This->IDirectPlay4_iface, dpId, lpCtxt->idPlayer );
2064
2065 /* Enumerate all groups in this group since this will normally only
2066 * be called for top level groups
2067 */
2070
2071 }
2072 else
2073 {
2075 }
2076
struct _DPFAGContext * lpDPFAGContext
static BOOL CALLBACK cbDeletePlayerFromAllGroups(DPID dpId, DWORD dwPlayerType, LPCDPNAME lpName, DWORD dwFlags, LPVOID lpContext)
Definition: dplay.c:2051
#define IDirectPlayX_DeletePlayerFromGroup(p, a, b)
Definition: dplay.h:872
#define IDirectPlayX_EnumGroupsInGroup(p, a, b, c, d, e)
Definition: dplay.h:902
Definition: dplay.c:1993
Referenced by cbDeletePlayerFromAllGroups(), and DP_IF_DestroyPlayer().
◆ cbDPCreateEnumConnections()
|
static |
Definition at line 5959 of file dplay.c.
5967{
5969
5971 {
5973
5975 dwConnectionSize );
5977
5978 /* Found the record that we were looking for */
5980 }
5981
5982 /* Haven't found what were looking for yet */
struct tagCreateEnum * lpCreateEnumData
Definition: dplay.c:5953
Referenced by DirectPlayCreate().
◆ cbRemoveGroupOrPlayer()
|
static |
Definition at line 1879 of file dplay.c.
1886{
1888
1890 dpId, dwPlayerType, lpCtxt->idGroup );
1891
1893 {
1895 lpCtxt->idGroup, dpId ) ) )
1897 }
1899 lpCtxt->idGroup, dpId ) ) )
1901
struct _DPRGOPContext * lpDPRGOPContext
#define IDirectPlayX_DeleteGroupFromGroup(p, a, b)
Definition: dplay.h:900
Definition: dplay.c:1872
Referenced by DP_IF_DestroyGroup().
◆ DirectPlayCreate()
| HRESULT WINAPI DirectPlayCreate | ( | LPGUID | lpGUID, |
| LPDIRECTPLAY * | lplpDP, | ||
| IUnknown * | pUnk | ||
| ) |
Definition at line 5990 of file dplay.c.
5993{
5995 LPDIRECTPLAY3A lpDP3A;
5996 CreateEnumData cbData;
5997
5999
6001 {
6003 }
6004
6006 {
6008 }
6009
6012
6014 {
6015 /* The GUID_NULL means don't bind a service provider. Just return the
6016 interface as is */
6018 }
6019
6020 /* Bind the desired service provider since lpGUID is non NULL */
6022
6023 /* We're going to use a DP3 interface */
6025 (LPVOID*)&lpDP3A );
6027 {
6030 }
6031
6033 cbData.lpGuid = lpGUID;
6034
6035 /* We were given a service provider, find info about it... */
6037 &cbData, DPCONNECTION_DIRECTPLAY );
6040 )
6041 {
6043 IDirectPlayX_Release( lpDP3A );
6045 }
6046
6047 /* Initialize the service provider */
6050 {
6053 IDirectPlayX_Release( lpDP3A );
6055 }
6056
6057 /* Release our version of the interface now that we're done with it */
6058 IDirectPlayX_Release( lpDP3A );
6060
static BOOL CALLBACK cbDPCreateEnumConnections(LPCGUID lpguidSP, LPVOID lpConnection, DWORD dwConnectionSize, LPCDPNAME lpName, DWORD dwFlags, LPVOID lpContext)
Definition: dplay.c:5959
#define IDirectPlayX_EnumConnections(p, a, b, c, d)
Definition: dplay.h:901
#define IDirectPlayX_InitializeConnection(p, a, b)
Definition: dplay.h:904
Definition: mshtmhst.idl:286
Definition: nsiface.idl:2307
◆ DirectPlayEnumerateA()
| HRESULT WINAPI DirectPlayEnumerateA | ( | LPDPENUMDPCALLBACKA | lpEnumCallback, |
| LPVOID | lpContext | ||
| ) |
Definition at line 5935 of file dplay.c.
5937{
5939
static HRESULT DirectPlayEnumerateAW(LPDPENUMDPCALLBACKA lpEnumCallbackA, LPDPENUMDPCALLBACKW lpEnumCallbackW, LPVOID lpContext)
Definition: dplay.c:5767
◆ DirectPlayEnumerateAW()
|
static |
Definition at line 5767 of file dplay.c.
5771{
5772 HKEY hkResult;
5774 'S', 'O', 'F', 'T', 'W', 'A', 'R', 'E', '\\',
5775 'M', 'i', 'c', 'r', 'o', 's', 'o', 'f', 't', '\\',
5776 'D', 'i', 'r', 'e', 'c', 't', 'P', 'l', 'a', 'y', '\\',
5777 'S', 'e', 'r', 'v', 'i', 'c', 'e', ' ', 'P', 'r', 'o', 'v', 'i', 'd', 'e', 'r', 's', 0 };
5779 static const WCHAR descW[] = { 'D', 'e', 's', 'c', 'r', 'i', 'p', 't', 'i', 'o', 'n', 'W', 0 };
5780
5781 DWORD dwIndex;
5783
5785 DWORD max_sizeOfDescriptionA = 0;
5787 DWORD max_sizeOfDescriptionW = 0;
5788 DWORD sizeOfSubKeyName;
5790 LONG ret_value;
5792 static int cache_count;
5793
5794 if (!lpEnumCallbackA && !lpEnumCallbackW)
5795 {
5797 }
5798
5799 /* Need to loop over the service providers in the registry */
5802 {
5803 /* Hmmm. Does this mean that there are no service providers? */
5806 }
5807
5808 dwIndex = 0;
5809 do
5810 {
5811 sizeOfSubKeyName = ARRAY_SIZE(subKeyName);
5812 ret_value = RegEnumKeyW(hkResult, dwIndex, subKeyName, sizeOfSubKeyName);
5813 dwIndex++;
5814 }
5816 /* The game Swing from bug 37185 expects GUID values to persist after
5817 * the end of the enumeration. */
5818 if (cache_count < dwIndex)
5819 {
5822 if (!guid_cache)
5823 {
5826 }
5827 cache_count = dwIndex;
5828 }
5829 /* Traverse all the service providers we have available */
5830 dwIndex = 0;
5831 while (1)
5832 {
5833 HKEY hkServiceProvider;
5836
5837 sizeOfSubKeyName = ARRAY_SIZE(subKeyName);
5838 ret_value = RegEnumKeyExW(hkResult, dwIndex, subKeyName, &sizeOfSubKeyName,
5841 break;
5843 {
5846 }
5848
5849 /* Open the key for this service provider */
5851 {
5853 continue;
5854 }
5855
5856 /* Get the GUID from the registry */
5859 {
5861 continue;
5862 }
5863 if (sizeOfGuidKeyContent != sizeof(guidKeyContent))
5864 {
5865 ERR(": invalid format for the GUID registry data member for service provider %s (%s).\n", debugstr_w(subKeyName), debugstr_w(guidKeyContent));
5866 continue;
5867 }
5868 CLSIDFromString(guidKeyContent, &guid_cache[dwIndex]);
5869
5870 /* The enumeration will return FALSE if we are not to continue.
5871 *
5872 * Note: on my windows box, major / minor version is 6 / 0 for all service providers
5873 * and have no relation to any of the two dwReserved1 and dwReserved2 keys.
5874 * I think that it simply means that they are in-line with DirectX 6.0
5875 */
5876 if (lpEnumCallbackA)
5877 {
5878 DWORD sizeOfDescription = 0;
5879
5880 /* Note that this is the A case of this function, so use the A variant to get the description string */
5883 {
5884 ERR(": missing 'DescriptionA' registry data member for service provider %s.\n", debugstr_w(subKeyName));
5885 continue;
5886 }
5887 if (sizeOfDescription > max_sizeOfDescriptionA)
5888 {
5890 max_sizeOfDescriptionA = sizeOfDescription;
5891 }
5895
5896 if (!lpEnumCallbackA(&guid_cache[dwIndex], descriptionA, 6, 0, lpContext))
5898 }
5899 else
5900 {
5901 DWORD sizeOfDescription = 0;
5902
5905 {
5906 ERR(": missing 'DescriptionW' registry data member for service provider %s.\n", debugstr_w(subKeyName));
5907 continue;
5908 }
5909 if (sizeOfDescription > max_sizeOfDescriptionW)
5910 {
5912 max_sizeOfDescriptionW = sizeOfDescription;
5913 }
5915 RegQueryValueExW(hkServiceProvider, descW,
5917
5920 }
5921
5922 dwIndex++;
5923 }
5924
5925 end:
5928
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
LONG WINAPI RegEnumKeyExW(_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPWSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPWSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)
Definition: reg.c:2504
LONG WINAPI RegQueryValueExA(_In_ HKEY hkeyorg, _In_ LPCSTR name, _In_ LPDWORD reserved, _Out_opt_ LPDWORD type, _Out_opt_ LPBYTE data, _Inout_opt_ LPDWORD count)
Definition: reg.c:4009
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4103
LONG WINAPI RegEnumKeyW(HKEY hKey, DWORD dwIndex, LPWSTR lpName, DWORD cbName)
Definition: reg.c:2393
HRESULT WINAPI CLSIDFromString(LPCOLESTR idstr, LPCLSID id)
Definition: compobj.c:2338
Definition: shobjidl.idl:2913
Definition: mapidefs.h:60
Definition: fatfs.h:121
Referenced by DirectPlayEnumerateA(), and DirectPlayEnumerateW().
◆ DirectPlayEnumerateW()
| HRESULT WINAPI DirectPlayEnumerateW | ( | LPDPENUMDPCALLBACKW | lpEnumCallback, |
| LPVOID | lpContext | ||
| ) |
◆ DP_BuildSPCompoundAddr()
|
static |
Definition at line 4197 of file dplay.c.
4200{
4201 DPCOMPOUNDADDRESSELEMENT dpCompoundAddress;
4203
4205 dpCompoundAddress.guidDataType = DPAID_ServiceProvider;
4206 dpCompoundAddress.lpData = lpcSpGuid;
4207
4208 *lplpAddrBuf = NULL;
4209 *lpdwBufSize = 0;
4210
4212 lpdwBufSize, TRUE );
4213
4215 {
4218 }
4219
4220 /* Now allocate the buffer */
4222 *lpdwBufSize );
4223
4225 lpdwBufSize, TRUE );
4227 {
4230 }
4231
HRESULT DPL_CreateCompoundAddress(LPCDPCOMPOUNDADDRESSELEMENT lpElements, DWORD dwElementCount, LPVOID lpAddress, LPDWORD lpdwAddressSize, BOOL bAnsiInterface)
Definition: dplobby.c:1660
Definition: dplobby.h:296
Referenced by IDirectPlay4AImpl_EnumConnections(), and IDirectPlay4Impl_EnumSessions().
◆ DP_CalcSessionDescSize()
|
static |
Definition at line 3865 of file dplay.c.
3867{
3869
3871 {
3872 /* Hmmm..don't need any size? */
3875 }
3876
3878
3879 if( bAnsi )
3880 {
3882 {
3884 }
3885
3887 {
3889 }
3890 }
3891 else /* UNICODE */
3892 {
3894 {
3897 }
3898
3900 {
3903 }
3904 }
3905
Referenced by DP_GetSessionDesc(), and DP_SetSessionDesc().
◆ DP_CopyDPNAMEStruct()
Definition at line 1398 of file dplay.c.
1400{
1402 {
1406 }
1407
1409 {
1411 }
1412
1413 /* Delete any existing pointers */
1416
1417 /* Copy as required */
1419
1420 if( bAnsi )
1421 {
1423 {
1427 }
1429 {
1433 }
1434 }
1435 else
1436 {
1438 {
1442 }
1444 {
1448 }
1449 }
1450
Referenced by DP_CreateGroup(), DP_CreatePlayer(), DP_IF_SetGroupName(), and DP_IF_SetPlayerName().
◆ DP_CopySessionDesc()
|
static |
Definition at line 3909 of file dplay.c.
3912{
3913 BYTE* lpStartOfFreeSpace;
3914
3916 {
3918 return;
3919 }
3920
3922
3924
3925 if( bAnsi )
3926 {
3927 if( lpSessionSrc->u1.lpszSessionNameA )
3928 {
3930 lpSessionDest->u1.lpszSessionNameA );
3931 lpSessionDest->u1.lpszSessionNameA = (LPSTR)lpStartOfFreeSpace;
3932 lpStartOfFreeSpace +=
3933 lstrlenA( lpSessionDest->u1.lpszSessionNameA ) + 1;
3934 }
3935
3936 if( lpSessionSrc->u2.lpszPasswordA )
3937 {
3939 lpSessionDest->u2.lpszPasswordA );
3940 lpSessionDest->u2.lpszPasswordA = (LPSTR)lpStartOfFreeSpace;
3941 }
3942 }
3943 else /* UNICODE */
3944 {
3945 if( lpSessionSrc->u1.lpszSessionName )
3946 {
3948 lpSessionDest->u1.lpszSessionName );
3949 lpSessionDest->u1.lpszSessionName = (LPWSTR)lpStartOfFreeSpace;
3951 ( lstrlenW( lpSessionDest->u1.lpszSessionName ) + 1 );
3952 }
3953
3954 if( lpSessionSrc->u2.lpszPassword )
3955 {
3957 lpSessionDest->u2.lpszPassword );
3958 lpSessionDest->u2.lpszPassword = (LPWSTR)lpStartOfFreeSpace;
3959 }
3960 }
Referenced by DP_GetSessionDesc(), and DP_SetSessionDesc().
◆ DP_CreateDirectPlay2()
Definition at line 125 of file dplay.c.
127{
129
132 {
134 }
135
137
139 This->dp2->dwEnumSessionLock = 0;
140
142
146
148 {
149 /* FIXME: Memory leak */
151 }
152
153 /* Provide an initial session desc with nothing in it */
155 HEAP_ZERO_MEMORY,
158 {
159 /* FIXME: Memory leak */
161 }
163
164 /* We are emulating a dp 6 implementation */
166
171
172 /* This is the pointer to the service provider */
174 {
175 /* FIXME: Memory leak */
177 }
178
179 /* Setup lobby provider information */
184
186 )
187 {
188 /* FIXME: Memory leak */
190 }
191
HRESULT dplobbysp_create(REFIID riid, void **ppv, IDirectPlayImpl *dp) DECLSPEC_HIDDEN
Definition: lobbysp.c:230
HRESULT dplaysp_create(REFIID riid, void **ppv, IDirectPlayImpl *dp) DECLSPEC_HIDDEN
Definition: dplaysp.c:686
BOOL NS_InitializeSessionCache(LPVOID *lplpNSInfo)
Definition: name_server.c:263
Definition: dplay_global.h:184
Referenced by dplay_create().
◆ DP_CreateGroup()
|
static |
Definition at line 998 of file dplay.c.
1001{
1002 lpGroupData lpGData;
1003
1004 /* Allocate the new space and add to end of high level group list */
1006
1008 {
1010 }
1011
1012 DPQ_INIT(lpGData->groups);
1013 DPQ_INIT(lpGData->players);
1014
1015 /* Set the desired player ID - no sanity checking to see if it exists */
1016 lpGData->dpid = *lpid;
1017
1019
1020 /* FIXME: Should we check that the parent exists? */
1021 lpGData->parent = idParent;
1022
1023 /* FIXME: Should we validate the dwFlags? */
1025
1027
1028 return lpGData;
static BOOL DP_CopyDPNAMEStruct(LPDPNAME lpDst, const DPNAME *lpSrc, BOOL bAnsi)
Definition: dplay.c:1398
Definition: dplay_global.h:92
Referenced by DP_IF_CreateGroup(), and DP_IF_CreateGroupInGroup().
◆ DP_CreatePlayer()
|
static |
Definition at line 1298 of file dplay.c.
1301{
1302 lpPlayerData lpPData;
1303
1305
1306 /* Allocate the storage for the player and associate it with list element */
1309 {
1311 }
1312
1313 /* Set the desired player ID */
1314 lpPData->dpid = *lpid;
1315
1317
1319
1320 /* If we were given an event handle, duplicate it */
1322 {
1326 )
1327 {
1328 /* FIXME: Memory leak */
1330 }
1331 }
1332
1333 /* Initialize the SP data section */
1335
1337
1339 This->dp2->lpSessionDesc->dwCurrentPlayers++;
1340
1341 return lpPData;
BOOL WINAPI DuplicateHandle(IN HANDLE hSourceProcessHandle, IN HANDLE hSourceHandle, IN HANDLE hTargetProcessHandle, OUT LPHANDLE lpTargetHandle, IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwOptions)
Definition: handle.c:149
LPVOID DPSP_CreateSPPlayerData(void) DECLSPEC_HIDDEN
Definition: dplaysp.c:711
Definition: dplay_global.h:59
#define DUPLICATE_SAME_ACCESS
Referenced by DP_IF_CreatePlayer().
◆ DP_DeleteDPNameStruct()
Definition at line 1345 of file dplay.c.
1347{
Referenced by DP_DeleteGroup(), and DP_DeletePlayer().
◆ DP_DeleteGroup()
|
static |
Definition at line 1031 of file dplay.c.
1033{
1034 lpGroupList lpGList;
1035
1037
1039
1041 {
1043 return;
1044 }
1045
1047 {
1049 DebugBreak();
1050 }
1051
1052 /* Delete player */
1055
1056 /* Remove and Delete Player List object */
1058
#define DPQ_REMOVE_ENTRY(head, elm, field, fieldCompareOperator, fieldToCompare, rc)
Definition: dplayx_queue.h:162
Definition: dplay_global.h:120
void WINAPI DebugBreak(void)
Referenced by DP_IF_DestroyGroup().
◆ DP_DeletePlayer()
|
static |
Definition at line 1352 of file dplay.c.
1354{
1355 lpPlayerList lpPList;
1356
1358
1360
1362 {
1364 return;
1365 }
1366
1367 /* Verify that this is the last reference to the data */
1369 {
1371 DebugBreak();
1372 }
1373
1374 /* Delete player */
1376
1379
1380 /* Delete Player List object */
Definition: dplay_global.h:84
Referenced by DP_IF_DestroyPlayer().
◆ DP_DestroyDirectPlay2()
Definition at line 201 of file dplay.c.
203{
205
207 {
210 }
211
212 /* Finish with the SP - have it shutdown */
214 {
216
218
220
222 }
224 {
226 (*This->dp2->spData.lpCB->Shutdown)();
227 }
228
229 /* Unload the SP (if it exists) */
231 {
233 }
234
235 /* Unload the Lobby Provider (if it exists) */
237 {
239 }
240
241 /* FIXME: Need to delete receive and send msgs queue contents */
242
244
247
249
250 /* Delete the contents */
252
BOOL WINAPI TerminateThread(IN HANDLE hThread, IN DWORD dwExitCode)
Definition: thread.c:587
Definition: dplaysp.h:291
Referenced by dplay_destroy().
◆ DP_EnumSessionsSendAsyncRequestThread()
Definition at line 2323 of file dplay.c.
2325{
2329
2331
2332 for( ;; )
2333 {
2335
2336 /* Sleep up to dwTimeout waiting for request to terminate thread */
2338 {
2340 break;
2341 }
2342
2343 /* Now resend the enum request */
2345 data->dwEnumSessionFlags,
2346 data->lpSpData );
2347
2349 {
2351 /* FIXME: Should we kill this thread? How to inform the main thread? */
2352 }
2353
2354 }
2355
2357
2358 /* Clean up the thread data */
2359 CloseHandle( hSuicideRequest );
2361
2362 /* FIXME: Need to have some notification to main app thread that this is
2363 * dead. It would serve two purposes. 1) allow sync on termination
2364 * so that we don't actually send something to ourselves when we
2365 * become name server (race condition) and 2) so that if we die
2366 * abnormally something else will be able to tell.
2367 */
2368
2369 return 1;
HRESULT NS_SendSessionRequestBroadcast(LPCGUID lpcGuid, DWORD dwFlags, const SPINITDATA *lpSpData)
Definition: name_server.c:196
Definition: dplay_global.h:35
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
_In_ void _In_ PCCERT_CONTEXT _In_opt_ LPFILETIME _In_ DWORD _In_ DWORD dwTimeout
Definition: wincrypt.h:6081
Referenced by IDirectPlay4Impl_EnumSessions().
◆ DP_FindAnyGroup()
|
static |
Definition at line 1060 of file dplay.c.
1062{
1063 lpGroupList lpGroups;
1064
1066
1068 {
1070 }
1071 else
1072 {
1074 }
1075
1077 {
1079 }
1080
#define DPQ_FIND_ENTRY(head, elm, field, fieldCompareOperator, fieldToCompare, rc)
Definition: dplayx_queue.h:100
Referenced by DP_IF_CreateGroupInGroup(), DP_IF_DestroyGroup(), DP_IF_GetGroupName(), DP_IF_SetGroupName(), IDirectPlay4Impl_AddGroupToGroup(), IDirectPlay4Impl_AddPlayerToGroup(), IDirectPlay4Impl_DeleteGroupFromGroup(), IDirectPlay4Impl_DeletePlayerFromGroup(), IDirectPlay4Impl_EnumGroupPlayers(), IDirectPlay4Impl_EnumGroupsInGroup(), IDirectPlay4Impl_GetGroupData(), IDirectPlay4Impl_GetGroupParent(), IDirectPlay4Impl_SendEx(), and IDirectPlay4Impl_SetGroupData().
◆ DP_FindPlayer()
|
static |
Definition at line 1383 of file dplay.c.
Referenced by DP_GetSPPlayerData(), DP_IF_DestroyPlayer(), DP_IF_GetPlayerName(), DP_IF_SetPlayerName(), DP_SetSPPlayerData(), IDirectPlay4Impl_AddPlayerToGroup(), IDirectPlay4Impl_DeletePlayerFromGroup(), IDirectPlay4Impl_GetPlayerData(), IDirectPlay4Impl_SendEx(), and IDirectPlay4Impl_SetPlayerData().
◆ DP_GetRemoteNextObjectId()
Definition at line 1779 of file dplay.c.
1781{
1783
1784 /* Hack solution */
Referenced by DP_IF_CreateGroup().
◆ DP_GetSessionDesc()
|
static |
Definition at line 3090 of file dplay.c.
3093{
3094 DWORD dwRequiredSize;
3095
3097
3099 {
3101 }
3102
3104 {
3106 }
3107
3108 /* FIXME: Get from This->dp2->lpSessionDesc */
3110
3112 ( *lpdwDataSize < dwRequiredSize )
3113 )
3114 {
3115 *lpdwDataSize = dwRequiredSize;
3117 }
3118
3120
static DWORD DP_CalcSessionDescSize(LPCDPSESSIONDESC2 lpSessDesc, BOOL bAnsi)
Definition: dplay.c:3865
static void DP_CopySessionDesc(LPDPSESSIONDESC2 destSessionDesc, LPCDPSESSIONDESC2 srcSessDesc, BOOL bAnsi)
Definition: dplay.c:3909
Referenced by IDirectPlay4AImpl_GetSessionDesc(), and IDirectPlay4Impl_GetSessionDesc().
◆ DP_GetSpLpGuidFromCompoundAddress()
|
static |
Definition at line 4583 of file dplay.c.
4589{
4590 /* Looking for the GUID of the provider to load */
4592 ( IsEqualGUID( guidDataType, &DPAID_LobbyProvider ) )
4593 )
4594 {
4597
4599 {
4601 }
4602
4603 memcpy( lpContext, lpData, dwDataSize );
4604
4605 /* There shouldn't be more than 1 GUID/compound address */
4607 }
4608
4609 /* Still waiting for what we want */
Referenced by IDirectPlay4Impl_InitializeConnection().
◆ DP_GetSPPlayerData()
| HRESULT DP_GetSPPlayerData | ( | IDirectPlayImpl * | lpDP, |
| DPID | idPlayer, | ||
| void ** | lplpData | ||
| ) |
Definition at line 5717 of file dplay.c.
5719{
5721
5723 {
5725 }
5726
5728
static lpPlayerList DP_FindPlayer(IDirectPlayImpl *This, DPID dpid)
Definition: dplay.c:1383
Referenced by IDirectPlaySPImpl_GetSPPlayerData(), and IDirectPlaySPImpl_SetSPPlayerData().
◆ DP_HandleMessage()
| HRESULT DP_HandleMessage | ( | IDirectPlayImpl * | This, |
| const void * | lpcMessageBody, | ||
| DWORD | dwMessageBodySize, | ||
| const void * | lpcMessageHeader, | ||
| WORD | wCommandId, | ||
| WORD | wVersion, | ||
| void ** | lplpReply, | ||
| DWORD * | lpdwMsgSize | ||
| ) |
Definition at line 269 of file dplay.c.
273{
275 This, lpcMessageBody, dwMessageBodySize, lpcMessageHeader, wCommandId,
276 wVersion );
277
278 switch( wCommandId )
279 {
280 /* Name server needs to handle this request */
282 /* Reply expected */
284 break;
285
286 /* Name server needs to handle this request */
288 /* No reply expected */
289 NS_AddRemoteComputerAsNameServer( lpcMessageHeader,
290 This->dp2->spData.dwSPHeaderSize,
291 lpcMessageBody,
292 This->dp2->lpNameServerData );
293 break;
294
296 {
297 LPCDPMSG_REQUESTNEWPLAYERID lpcMsg = lpcMessageBody;
298
299 LPDPMSG_NEWPLAYERIDREPLY lpReply;
300
302
304
306 lpcMsg->dwFlags );
307
308 /* Setup the reply */
310 This->dp2->spData.dwSPHeaderSize );
311
315
317
319 lpReply->dpidNewPlayerId );
320 break;
321 }
322
326 break;
327
329 TRACE( "GOT THE SELF MESSAGE: %p -> 0x%08x\n", lpcMessageHeader, ((const DWORD *)lpcMessageHeader)[1] );
332
336 break;
337
340 break;
341
342 default:
344 DebugBreak();
345 break;
346 }
347
348 /* FIXME: There is code in dplaysp.c to handle dplay commands. Move to here. */
349
void DP_MSG_ErrorReceived(IDirectPlayImpl *This, WORD wCommandId, const void *lpMsgBody, DWORD dwMsgBodySize)
Definition: dplayx_messages.c:484
void DP_MSG_ReplyReceived(IDirectPlayImpl *This, WORD wCommandId, const void *lpcMsgBody, DWORD dwMsgBodySize)
Definition: dplayx_messages.c:408
void DP_MSG_ToSelf(IDirectPlayImpl *This, DPID dpidSelf)
Definition: dplayx_messages.c:447
struct tagDPMSG_NEWPLAYERIDREPLY * LPDPMSG_NEWPLAYERIDREPLY
void NS_AddRemoteComputerAsNameServer(LPCVOID lpcNSAddrHdr, DWORD dwHdrSize, LPCDPMSG_ENUMSESSIONSREPLY lpcMsg, LPVOID lpNSInfo)
Definition: name_server.c:87
void NS_ReplyToEnumSessionsRequest(const void *lpcMsg, void **lplpReplyData, DWORD *lpdwReplySize, IDirectPlayImpl *lpDP)
Definition: name_server.c:358
void NS_SetLocalAddr(LPVOID lpNSInfo, LPCVOID lpHdr, DWORD dwHdrSize)
Definition: name_server.c:184
Definition: dplayx_messages.h:173
Definition: dplayx_messages.h:163
Referenced by IDirectPlaySPImpl_HandleMessage().
◆ DP_IF_CreateGroup()
|
static |
Definition at line 1083 of file dplay.c.
1086{
1087 lpGroupData lpGData;
1088
1090 This, lpMsgHdr, lpidGroup, lpGroupName, lpData, dwDataSize,
1091 dwFlags, bAnsi );
1092
1094 {
1096 }
1097
1098 /* If the name is not specified, we must provide one */
1100 {
1101 /* If we are the name server, we decide on the group ids. If not, we
1102 * must ask for one before attempting a creation.
1103 */
1105 {
1106 *lpidGroup = DP_NextObjectId();
1107 }
1108 else
1109 {
1110 *lpidGroup = DP_GetRemoteNextObjectId();
1111 }
1112 }
1113
1115 DPID_NOPARENT_GROUP, bAnsi );
1116
1118 {
1120 }
1121
1123 {
1124 This->dp2->lpSysGroup = lpGData;
1126 }
1127 else
1128 {
1129 /* Insert into the system group */
1131 lpGroup->lpGData = lpGData;
1132
1134 }
1135
1136 /* Something is now referencing this data */
1137 lpGData->uRef++;
1138
1139 /* Set all the important stuff for the group */
1141
1142 /* FIXME: We should only create the system group if GetCaps returns
1143 * DPCAPS_GROUPOPTIMIZED.
1144 */
1145
1146 /* Let the SP know that we've created this group */
1148 {
1150 DWORD dwCreateFlags = 0;
1151
1153
1155 dwCreateFlags |= DPLAYI_GROUP_SYSGROUP;
1156
1158 dwCreateFlags |= DPLAYI_PLAYER_PLAYERLOCAL;
1159
1161 dwCreateFlags |= DPLAYI_GROUP_HIDDEN;
1162
1163 data.idGroup = *lpidGroup;
1164 data.dwFlags = dwCreateFlags;
1165 data.lpSPMessageHeader = lpMsgHdr;
1167
1169 }
1170
1171 /* Inform all other peers of the creation of a new group. If there are
1172 * no peers keep this event quiet.
1173 * Also if this message was sent to us, don't rebroadcast.
1174 */
1176 This->dp2->lpSessionDesc &&
1178 {
1181
1183 msg.dpId = *lpidGroup;
1185 msg.lpData = lpData;
1186 msg.dwDataSize = dwDataSize;
1187 msg.dpnName = *lpGroupName;
1190
1191 /* FIXME: Correct to just use send effectively? */
1192 /* FIXME: Should size include data w/ message or just message "header" */
1193 /* FIXME: Check return code */
1196 }
1197
static void DP_SetGroupData(lpGroupData lpGData, DWORD dwFlags, LPVOID lpData, DWORD dwDataSize)
Definition: dplay.c:1256
static lpGroupData DP_CreateGroup(IDirectPlayImpl *This, const DPID *lpid, const DPNAME *lpName, DWORD dwFlags, DPID idParent, BOOL bAnsi)
Definition: dplay.c:998
Definition: dplay.h:1147
Definition: dplaysp.h:128
Referenced by DP_SecureOpen(), IDirectPlay4AImpl_CreateGroup(), IDirectPlay4Impl_CreateGroup(), and IDirectPlaySPImpl_HandleMessage().
◆ DP_IF_CreateGroupInGroup()
|
static |
Definition at line 4019 of file dplay.c.
4023{
4024 lpGroupData lpGParentData;
4025 lpGroupList lpGList;
4026 lpGroupData lpGData;
4027
4029 This, idParentGroup, lpidGroup, lpGroupName, lpData,
4030 dwDataSize, dwFlags, bAnsi );
4031
4033 {
4035 }
4036
4037 /* Verify that the specified parent is valid */
4040
4042
4044 {
4046 }
4047
4048 /* Something else is referencing this data */
4049 lpGData->uRef++;
4050
4052
4053 /* The list has now been inserted into the interface group list. We now
4054 need to put a "shortcut" to this group in the parent group */
4057 {
4060 }
4061
4062 lpGList->lpGData = lpGData;
4063
4065
4066 /* Let the SP know that we've created this group */
4068 {
4070
4072
4073 data.idGroup = *lpidGroup;
4075 data.lpSPMessageHeader = lpMsgHdr;
4077
4079 }
4080
4081 /* Inform all other peers of the creation of a new group. If there are
4082 * no peers keep this quiet.
4083 */
4086 {
4088
4091 msg.dpId = *lpidGroup;
4093 msg.lpData = lpData;
4094 msg.dwDataSize = dwDataSize;
4095 msg.dpnName = *lpGroupName;
4096
4097 /* FIXME: Correct to just use send effectively? */
4098 /* FIXME: Should size include data w/ message or just message "header" */
4099 /* FIXME: Check return code */
4102 }
4103
static lpGroupData DP_FindAnyGroup(IDirectPlayImpl *This, DPID dpid)
Definition: dplay.c:1060
Referenced by IDirectPlay4AImpl_CreateGroupInGroup(), IDirectPlay4Impl_CreateGroupInGroup(), and IDirectPlaySPImpl_HandleMessage().
◆ DP_IF_CreatePlayer()
|
static |
Definition at line 1497 of file dplay.c.
1501{
1503 lpPlayerData lpPData;
1504 lpPlayerList lpPList;
1505 DWORD dwCreateFlags = 0;
1506
1509 dwDataSize, dwFlags, bAnsi );
1511 {
1513 }
1514
1516 {
1518 }
1519
1521 {
1523 }
1524
1525
1526 /* Determine the creation flags for the player. These will be passed
1527 * to the name server if requesting a player id and to the SP when
1528 * informing it of the player creation
1529 */
1530 {
1532 {
1534 {
1535 /* Server player for the host interface */
1536 dwCreateFlags |= DPLAYI_PLAYER_APPSERVER;
1537 }
1539 {
1540 /* Name server - master of everything */
1542 }
1543 else
1544 {
1545 /* Server player for a non host interface */
1546 dwCreateFlags |= DPLAYI_PLAYER_SYSPLAYER;
1547 }
1548 }
1549
1551 dwCreateFlags |= DPLAYI_PLAYER_PLAYERLOCAL;
1552 }
1553
1554 /* Verify we know how to handle all the flags */
1557 )
1558 )
1559 {
1560 /* Assume non fatal failure */
1562 }
1563
1564 /* If the name is not specified, we must provide one */
1566 {
1567 /* If we are the session master, we dish out the group/player ids */
1569 {
1570 *lpidPlayer = DP_NextObjectId();
1571 }
1572 else
1573 {
1575
1577 {
1580 }
1581 }
1582 }
1583 else
1584 {
1585 /* FIXME: Would be nice to perhaps verify that we don't already have
1586 * this player.
1587 */
1588 }
1589
1590 /* We pass creation flags, so we can distinguish sysplayers and not count them in the current
1591 player total */
1593 hEvent, bAnsi );
1594 /* Create the list object and link it in */
1596 if( !lpPData || !lpPList )
1597 {
1601 }
1602
1603 lpPData->uRef = 1;
1604 lpPList->lpPData = lpPData;
1605
1606 /* Add the player to the system group */
1608
1609 /* Update the information and send it to all players in the session */
1611
1612 /* Let the SP know that we've created this player */
1614 {
1616
1617 data.idPlayer = *lpidPlayer;
1618 data.dwFlags = dwCreateFlags;
1619 data.lpSPMessageHeader = lpMsgHdr;
1621
1624
1626 }
1627
1629 {
1632 }
1633
1634 /* Now let the SP know that this player is a member of the system group */
1636 {
1638
1639 data.idPlayer = *lpidPlayer;
1642
1644
1646 }
1647
1649 {
1653 }
1654
1655#if 1
1657 {
1658 /* Let the name server know about the creation of this player */
1659 /* FIXME: Is this only to be done for the creation of a server player or
1660 * is this used for regular players? If only for server players, move
1661 * this call to DP_SecureOpen(...);
1662 */
1663#if 0
1666#endif
1667
1669 }
1670#else
1671 /* Inform all other peers of the creation of a new player. If there are
1672 * no peers keep this quiet.
1673 * Also, if this was a remote event, no need to rebroadcast it.
1674 */
1676 This->dp2->lpSessionDesc &&
1678 {
1681
1683 msg.dpId = *lpidPlayer;
1685 msg.lpData = lpData;
1686 msg.dwDataSize = dwDataSize;
1687 msg.dpnName = *lpPlayerName;
1690
1691 /* FIXME: Correct to just use send effectively? */
1692 /* FIXME: Should size include data w/ message or just message "header" */
1693 /* FIXME: Check return code */
1696 }
1697#endif
1698
static lpPlayerData DP_CreatePlayer(IDirectPlayImpl *This, DPID *lpid, DPNAME *lpName, DWORD dwFlags, HANDLE hEvent, BOOL bAnsi)
Definition: dplay.c:1298
static void DP_SetPlayerData(lpPlayerData lpPData, DWORD dwFlags, LPVOID lpData, DWORD dwDataSize)
Definition: dplay.c:1454
HRESULT DP_MSG_SendRequestPlayerId(IDirectPlayImpl *This, DWORD dwFlags, DPID *lpdpidAllocatedId)
Definition: dplayx_messages.c:184
HRESULT DP_MSG_ForwardPlayerCreation(IDirectPlayImpl *This, DPID dpidServer)
Definition: dplayx_messages.c:250
Definition: dplaysp.h:116
Definition: dplaysp.h:136
Referenced by DP_SecureOpen(), IDirectPlay4AImpl_CreatePlayer(), IDirectPlay4Impl_CreatePlayer(), and IDirectPlaySPImpl_HandleMessage().
◆ DP_IF_DestroyGroup()
|
static |
Definition at line 1904 of file dplay.c.
1906{
1907 lpGroupData lpGData;
1909
1911 This, lpMsgHdr, idGroup, bAnsi );
1912
1913 /* Find the group */
1915 {
1917 }
1918
1920 context.bAnsi = bAnsi;
1921 context.idGroup = idGroup;
1922
1923 /* Remove all players that this group has */
1924 IDirectPlayX_EnumGroupPlayers( &This->IDirectPlay4_iface, idGroup, NULL, cbRemoveGroupOrPlayer,
1925 &context, 0 );
1926
1927 /* Remove all links to groups that this group has since this is dp3 */
1928 IDirectPlayX_EnumGroupsInGroup( &This->IDirectPlay4_iface, idGroup, NULL, cbRemoveGroupOrPlayer,
1930
1931 /* Remove this group from the parent group - if it has one */
1934
1935 /* Now delete this group data and list from the system group */
1937
1938 /* Let the SP know that we've destroyed this group */
1940 {
1942
1944
1945 data.idGroup = idGroup;
1946 data.dwFlags = 0;
1948
1950 }
1951
1953
static BOOL CALLBACK cbRemoveGroupOrPlayer(DPID dpId, DWORD dwPlayerType, LPCDPNAME lpName, DWORD dwFlags, LPVOID lpContext)
Definition: dplay.c:1879
#define IDirectPlayX_EnumGroupPlayers(p, a, b, c, d, e)
Definition: dplay.h:875
Definition: http.c:7252
Definition: dplaysp.h:144
Referenced by IDirectPlay4AImpl_DestroyGroup(), IDirectPlay4Impl_DestroyGroup(), and IDirectPlaySPImpl_HandleMessage().
◆ DP_IF_DestroyPlayer()
|
static |
Definition at line 1999 of file dplay.c.
2002{
2003 DPFAGContext cbContext;
2004
2006 This, lpMsgHdr, idPlayer, bAnsi );
2007
2009 {
2011 }
2012
2014 {
2016 }
2017
2018 /* FIXME: If the player is remote, we must be the host to delete this */
2019
2021 cbContext.idPlayer = idPlayer;
2022 cbContext.bAnsi = bAnsi;
2023
2024 /* Find each group and call DeletePlayerFromGroup if the player is a
2025 member of the group */
2026 IDirectPlayX_EnumGroups( &This->IDirectPlay4_iface, NULL, cbDeletePlayerFromAllGroups, &cbContext,
2027 DPENUMGROUPS_ALL );
2028
2029 /* Now delete player and player list from the sys group */
2031
2032 /* Let the SP know that we've destroyed this group */
2034 {
2036
2038
2039 data.idPlayer = idPlayer;
2040 data.dwFlags = 0;
2042
2044 }
2045
2047
static void DP_DeletePlayer(IDirectPlayImpl *This, DPID dpid)
Definition: dplay.c:1352
Definition: dplaysp.h:151
Referenced by IDirectPlay4AImpl_DestroyPlayer(), IDirectPlay4Impl_DestroyPlayer(), and IDirectPlaySPImpl_HandleMessage().
◆ DP_IF_GetGroupName()
|
static |
Definition at line 2660 of file dplay.c.
2663{
2664 lpGroupData lpGData;
2666 DWORD dwRequiredDataSize;
2667
2669 This, idGroup, lpData, lpdwDataSize, bAnsi );
2670
2672 {
2674 }
2675
2677
2679 {
2681 }
2682
2684 {
2686 }
2687
2689 ( *lpdwDataSize < dwRequiredDataSize )
2690 )
2691 {
2692 *lpdwDataSize = dwRequiredDataSize;
2694 }
2695
2696 /* Copy the structure */
2698
2700 {
2703 }
2704 else
2705 {
2707 }
2708
2710 {
2713 }
2714 else
2715 {
2717 }
2718
Definition: dplay.h:187
Referenced by IDirectPlay4AImpl_GetGroupName(), and IDirectPlay4Impl_GetGroupName().
◆ DP_IF_GetPlayerName()
|
static |
Definition at line 2982 of file dplay.c.
2985{
2986 lpPlayerList lpPList;
2988 DWORD dwRequiredDataSize;
2989
2991 This, idPlayer, lpData, lpdwDataSize, bAnsi );
2992
2994 {
2996 }
2997
2999 {
3001 }
3002
3004
3006 {
3008 }
3009
3011 {
3013 }
3014
3016 ( *lpdwDataSize < dwRequiredDataSize )
3017 )
3018 {
3019 *lpdwDataSize = dwRequiredDataSize;
3021 }
3022
3023 /* Copy the structure */
3025
3027 {
3030 }
3031 else
3032 {
3034 }
3035
3037 {
3040 }
3041 else
3042 {
3044 }
3045
Referenced by IDirectPlay4AImpl_GetPlayerName(), and IDirectPlay4Impl_GetPlayerName().
◆ DP_IF_Receive()
|
static |
Definition at line 3355 of file dplay.c.
3358{
3360
3363
3365 {
3367 }
3368
3370 {
3372 }
3373
3374 /* If the lpData is NULL, we must be peeking the message */
3377 )
3378 {
3380 }
3381
3383 {
3384 lpMsg = This->dp2->receiveMsgs.lpQHFirst;
3385
3387 {
3389 }
3390 }
3393 )
3394 {
3396 }
3397 else
3398 {
3400 }
3401
3403 {
3405 }
3406
3407 /* Copy into the provided buffer */
3409
Definition: dplay_global.h:128
Referenced by IDirectPlay4AImpl_Receive(), and IDirectPlay4Impl_Receive().
◆ DP_IF_SetGroupName()
|
static |
Definition at line 3564 of file dplay.c.
3567{
3568 lpGroupData lpGData;
3569
3571 lpGroupName, dwFlags, bAnsi );
3572
3574 {
3576 }
3577
3579
3580 /* Should send a DPMSG_SETPLAYERORGROUPNAME message */
3582
Referenced by IDirectPlay4AImpl_SetGroupName(), IDirectPlay4Impl_SetGroupName(), and IDirectPlaySPImpl_HandleMessage().
◆ DP_IF_SetPlayerName()
|
static |
Definition at line 3697 of file dplay.c.
3700{
3701 lpPlayerList lpPList;
3702
3705
3707 {
3709 }
3710
3712 {
3714 }
3715
3717
3718 /* Should send a DPMSG_SETPLAYERORGROUPNAME message */
3720
Referenced by IDirectPlay4AImpl_SetPlayerName(), IDirectPlay4Impl_SetPlayerName(), and IDirectPlaySPImpl_HandleMessage().
◆ DP_InitializeDPLSP()
|
static |
Definition at line 4784 of file dplay.c.
4786{
4788 LPSP_INIT DPLSPInit;
4789
4790 /* Initialize the service provider by calling SPInit */
4792
4794 {
4796 FreeLibrary( hLobbyProvider );
4798 }
4799
4801
4803
4805 {
4807 FreeLibrary( hLobbyProvider );
4809 }
4810
4811 /* FIXME: Need to verify the sanity of the returned callback table
4812 * using IsBadCodePtr */
4813
4815
4816 /* This interface is now initialized as a lobby object */
4818
4819 /* Store the handle of the module so that we can unload it later */
4820 This->dp2->hDPLobbyProvider = hLobbyProvider;
4821
Referenced by IDirectPlay4Impl_InitializeConnection().
◆ DP_InitializeDPSP()
|
static |
Definition at line 4745 of file dplay.c.
4747{
4749 LPDPSP_SPINIT SPInit;
4750
4751 /* Initialize the service provider by calling SPInit */
4753
4755 {
4757 FreeLibrary( hServiceProvider );
4759 }
4760
4762
4764
4766 {
4768 FreeLibrary( hServiceProvider );
4770 }
4771
4772 /* FIXME: Need to verify the sanity of the returned callback table
4773 * using IsBadCodePtr */
4775
4776 /* This interface is now initialized as a DP object */
4778
4779 /* Store the handle of the module so that we can unload it later */
4780 This->dp2->hServiceProvider = hServiceProvider;
4781
Referenced by IDirectPlay4Impl_InitializeConnection().
◆ DP_InvokeEnumSessionCallbacks()
|
static |
Definition at line 2293 of file dplay.c.
2299{
2300 LPDPSESSIONDESC2 lpSessionDesc;
2301
2303
2304 /* Not sure if this should be pruning but it's convenient */
2305 NS_PruneSessionCache( lpNSInfo );
2306
2307 NS_ResetSessionEnumeration( lpNSInfo );
2308
2309 /* Enumerate all sessions */
2310 /* FIXME: Need to indicate ANSI */
2312 {
2315 {
2316 return;
2317 }
2318 }
2319
2320 /* Invoke one last time to indicate that there is no more to come */
void NS_ResetSessionEnumeration(LPVOID lpNSInfo)
Definition: name_server.c:289
Definition: dplay.h:231
Referenced by IDirectPlay4Impl_EnumSessions().
◆ DP_KillEnumSessionThread()
|
static |
Definition at line 2371 of file dplay.c.
2373{
2374 /* Does a thread exist? If so we were doing an async enum session */
2376 {
2378 This->dp2->hEnumSessionThread );
2379
2380 /* Request that the thread kill itself nicely */
2383
2384 /* We no longer need to know about the thread */
2386
2388 }
Referenced by DP_SecureOpen(), and IDirectPlay4Impl_EnumSessions().
◆ DP_LoadSP()
|
static |
Definition at line 4614 of file dplay.c.
4616{
4624
4626
4627 /* FIXME: Cloned code with a quick hack. */
4629 {
4630 HKEY hkResult;
4631 LPCSTR searchSubKey;
4632 char subKeyName[51];
4633 DWORD dwIndex, sizeOfSubKeyName=50;
4635
4636 (i == 0) ? (searchSubKey = spSubKey ) : (searchSubKey = lpSubKey );
4637 *lpbIsDpSp = (i == 0);
4638
4639
4640 /* Need to loop over the service providers in the registry */
4643 {
4644 /* Hmmm. Does this mean that there are no service providers? */
4646 return 0;
4647 }
4648
4649 /* Traverse all the service providers we have available */
4650 for( dwIndex=0;
4651 RegEnumKeyExA( hkResult, dwIndex, subKeyName, &sizeOfSubKeyName,
4653 ++dwIndex, sizeOfSubKeyName=51 )
4654 {
4655
4656 HKEY hkServiceProvider;
4657 GUID serviceProviderGUID;
4658 DWORD returnType, sizeOfReturnBuffer = 255;
4659 char returnBuffer[256];
4662
4664
4665 /* Get a handle for this particular service provider */
4667 &hkServiceProvider ) != ERROR_SUCCESS )
4668 {
4670 continue;
4671 }
4672
4675 &sizeOfReturnBuffer ) != ERROR_SUCCESS )
4676 {
4678 continue;
4679 }
4680
4681 /* FIXME: Check return types to ensure we're interpreting data right */
4684 /* FIXME: Have I got a memory leak on the serviceProviderGUID? */
4685
4686 /* Determine if this is the Service Provider that the user asked for */
4688 {
4689 continue;
4690 }
4691
4693 {
4697 }
4698
4699 sizeOfReturnBuffer = 255;
4700
4701 /* Get dwReserved1 */
4704 &sizeOfReturnBuffer ) != ERROR_SUCCESS )
4705 {
4707 continue;
4708 }
4709
4712
4713 sizeOfReturnBuffer = 255;
4714
4715 /* Get dwReserved2 */
4718 &sizeOfReturnBuffer ) != ERROR_SUCCESS )
4719 {
4721 continue;
4722 }
4723
4726
4727 sizeOfReturnBuffer = 255;
4728
4729 /* Get the path for this service provider */
4732 &sizeOfReturnBuffer ) ) != ERROR_SUCCESS )
4733 {
4735 continue;
4736 }
4737
4740 }
4741 }
4742
4743 return 0;
LONG WINAPI RegOpenKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD ulOptions, _In_ REGSAM samDesired, _Out_ PHKEY phkResult)
Definition: reg.c:3298
LONG WINAPI RegEnumKeyExA(_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)
Definition: reg.c:2419
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
Referenced by IDirectPlay4Impl_InitializeConnection().
◆ DP_NextObjectId()
Definition at line 263 of file dplay.c.
265{
Referenced by DP_GetRemoteNextObjectId(), DP_HandleMessage(), DP_IF_CreateGroup(), and DP_IF_CreatePlayer().
◆ DP_SecureOpen()
|
static |
Definition at line 3205 of file dplay.c.
3208{
3210
3213
3215 {
3217 }
3218
3220 {
3223 }
3224
3226 {
3229 }
3230
3231 /* If we're enumerating, kill the thread */
3233
3235 {
3236 /* Rightoo - this computer is the host and the local computer needs to be
3237 the name server so that others can join this session */
3239
3241
3244 {
3247 }
3248 }
3249
3250 /* Invoke the conditional callback for the service provider */
3252 {
3254
3256
3264
3267 {
3270 }
3271 }
3272
3273 {
3274 /* Create the system group of which everything is a part of */
3276
3279
3280 }
3281
3283 {
3285
3286 /* Create the server player for this interface. This way we can receive
3287 * messages for this session.
3288 */
3289 /* FIXME: I suppose that we should be setting an event for a receive
3290 * type of thing. That way the messaging thread could know to wake
3291 * up. DPlay would then trigger the hEvent for the player the
3292 * message is directed to.
3293 */
3295 0,
3297
3298 }
3300 {
3302
3304 0, DPPLAYER_SERVERPLAYER, bAnsi );
3305 }
3306
3308 {
3311 }
3312
static HRESULT DP_IF_CreateGroup(IDirectPlayImpl *This, void *lpMsgHdr, DPID *lpidGroup, DPNAME *lpGroupName, void *lpData, DWORD dwDataSize, DWORD dwFlags, BOOL bAnsi)
Definition: dplay.c:1083
static void DP_KillEnumSessionThread(IDirectPlayImpl *This)
Definition: dplay.c:2371
static HRESULT DP_IF_CreatePlayer(IDirectPlayImpl *This, void *lpMsgHdr, DPID *lpidPlayer, DPNAME *lpPlayerName, HANDLE hEvent, void *lpData, DWORD dwDataSize, DWORD dwFlags, BOOL bAnsi)
Definition: dplay.c:1497
static HRESULT DP_SetSessionDesc(IDirectPlayImpl *This, const DPSESSIONDESC2 *lpSessDesc, DWORD dwFlags, BOOL bInitial, BOOL bAnsi)
Definition: dplay.c:3765
void NS_SetLocalComputerAsNameServer(LPCDPSESSIONDESC2 lpsd, LPVOID lpNSInfo)
Definition: name_server.c:74
Definition: dplaysp.h:190
Referenced by IDirectPlay4AImpl_SecureOpen(), and IDirectPlay4Impl_SecureOpen().
◆ DP_SetGroupData()
|
static |
Definition at line 1256 of file dplay.c.
1259{
1260 /* Clear out the data with this player */
1262 {
1264 {
1267 lpGData->dwLocalDataSize = 0;
1268 }
1269 }
1270 else
1271 {
1273 {
1276 lpGData->dwRemoteDataSize = 0;
1277 }
1278 }
1279
1280 /* Reallocate for new data */
1282 {
1284 {
1285 lpGData->lpLocalData = lpData;
1286 lpGData->dwLocalDataSize = dwDataSize;
1287 }
1288 else
1289 {
1292 lpGData->dwRemoteDataSize = dwDataSize;
1293 }
1294 }
1295
Referenced by DP_IF_CreateGroup(), DP_IF_CreateGroupInGroup(), and IDirectPlay4Impl_SetGroupData().
◆ DP_SetPlayerData()
|
static |
Definition at line 1454 of file dplay.c.
1457{
1458 /* Clear out the data with this player */
1460 {
1462 {
1465 lpPData->dwLocalDataSize = 0;
1466 }
1467 }
1468 else
1469 {
1471 {
1474 lpPData->dwRemoteDataSize = 0;
1475 }
1476 }
1477
1478 /* Reallocate for new data */
1480 {
1481
1483 {
1484 lpPData->lpLocalData = lpData;
1485 lpPData->dwLocalDataSize = dwDataSize;
1486 }
1487 else
1488 {
1491 lpPData->dwRemoteDataSize = dwDataSize;
1492 }
1493 }
1494
Referenced by DP_IF_CreatePlayer(), and IDirectPlay4Impl_SetPlayerData().
◆ DP_SetSessionDesc()
|
static |
Definition at line 3765 of file dplay.c.
3768{
3769 DWORD dwRequiredSize;
3770 LPDPSESSIONDESC2 lpTempSessDesc;
3771
3774
3776 {
3778 }
3779
3781 {
3783 }
3784
3785 /* Only the host is allowed to update the session desc */
3787 {
3789 }
3790
3791 /* FIXME: Copy into This->dp2->lpSessionDesc */
3792 dwRequiredSize = DP_CalcSessionDescSize( lpSessDesc, bAnsi );
3794
3796 {
3798 }
3799
3800 /* Free the old */
3802
3803 This->dp2->lpSessionDesc = lpTempSessDesc;
3804 /* Set the new */
3806 if( bInitial )
3807 {
3808 /*Initializing session GUID*/
3810 }
3811 /* If this is an external invocation of the interface, we should be
3812 * letting everyone know that things have changed. Otherwise this is
3813 * just an initialization and it doesn't need to be propagated.
3814 */
3815 if( !bInitial )
3816 {
3818 }
3819
Referenced by DP_SecureOpen(), IDirectPlay4AImpl_SetSessionDesc(), and IDirectPlay4Impl_SetSessionDesc().
◆ DP_SetSPPlayerData()
| HRESULT DP_SetSPPlayerData | ( | IDirectPlayImpl * | lpDP, |
| DPID | idPlayer, | ||
| void * | lpData | ||
| ) |
Definition at line 5731 of file dplay.c.
5733{
5735
5737 {
5739 }
5740
5742
Referenced by IDirectPlaySPImpl_SetSPPlayerData().
◆ DP_SP_SendEx()
|
static |
Definition at line 5259 of file dplay.c.
5262{
5263 LPDPMSG lpMElem;
5264
5266
5267 /* FIXME: This queuing should only be for async messages */
5268
5271
5273
5274 /* FIXME: Need to queue based on priority */
5276
Referenced by IDirectPlay4Impl_SendEx().
◆ DPL_CreateCompoundAddress()
| HRESULT DPL_CreateCompoundAddress | ( | LPCDPCOMPOUNDADDRESSELEMENT | lpElements, |
| DWORD | dwElementCount, | ||
| LPVOID | lpAddress, | ||
| LPDWORD | lpdwAddressSize, | ||
| BOOL | bAnsiInterface | ||
| ) |
Definition at line 1659 of file dplobby.c.
1665{
1666 DWORD dwSizeRequired = 0;
1667 DWORD dwElements;
1668 LPCDPCOMPOUNDADDRESSELEMENT lpOrigElements = lpElements;
1669
1671
1672 /* Parameter check */
1674 ( dwElementCount == 0 ) /* FIXME: Not sure if this is a failure case */
1675 )
1676 {
1678 }
1679
1680 /* Add the total size chunk */
1682
1683 /* Calculate the size of the buffer required */
1684 for ( dwElements = dwElementCount; dwElements > 0; --dwElements, ++lpElements )
1685 {
1688 )
1689 {
1691 }
1695 )
1696 {
1697 if( !bAnsiInterface )
1698 {
1701 }
1702
1704 }
1708 )
1709 {
1710 if( bAnsiInterface )
1711 {
1714 }
1715
1718 }
1720 {
1722 }
1724 {
1727 }
1728 else
1729 {
1731 }
1732 }
1733
1734 /* The user wants to know how big a buffer to allocate for us */
1736 ( *lpdwAddressSize < dwSizeRequired )
1737 )
1738 {
1739 *lpdwAddressSize = dwSizeRequired;
1741 }
1742
1743 /* Add the total size chunk */
1744 {
1745 LPDPADDRESS lpdpAddress = lpAddress;
1746
1747 lpdpAddress->guidDataType = DPAID_TotalSize;
1750
1751 *(LPDWORD)lpAddress = dwSizeRequired;
1753 }
1754
1755 /* Calculate the size of the buffer required */
1756 for( dwElements = dwElementCount, lpElements = lpOrigElements;
1757 dwElements > 0;
1758 --dwElements, ++lpElements )
1759 {
1762 )
1763 {
1764 LPDPADDRESS lpdpAddress = lpAddress;
1765
1769
1772 }
1776 )
1777 {
1778 LPDPADDRESS lpdpAddress = lpAddress;
1779
1783
1786 }
1790 )
1791 {
1792 LPDPADDRESS lpdpAddress = lpAddress;
1793
1797
1800 }
1802 {
1803 LPDPADDRESS lpdpAddress = lpAddress;
1804
1808
1811 }
1813 {
1814 LPDPADDRESS lpdpAddress = lpAddress;
1815
1819
1822 }
1823 }
1824
1826}
struct tagDPADDRESS DPADDRESS
Definition: dplobby.h:251
Definition: dplobby.h:267
Referenced by DP_BuildSPCompoundAddr(), DPL_CreateAddress(), IDirectPlay4AImpl_EnumConnections(), IDirectPlayLobby3AImpl_CreateCompoundAddress(), and IDirectPlayLobby3Impl_CreateCompoundAddress().
◆ dplay_cancelmsg()
|
static |
Definition at line 5319 of file dplay.c.
5322{
5324
5326
5328 {
5330
5332
5333 /* FIXME: Undocumented callback */
5334
5338 data.cSPMsgID = msgid;
5339 data.dwMinPriority = minprio;
5340 data.dwMaxPriority = maxprio;
5341
5343 }
5344 else
5346
Definition: dplaysp.h:281
Referenced by IDirectPlay4Impl_CancelMessage(), and IDirectPlay4Impl_CancelPriority().
◆ dplay_create()
Definition at line 5676 of file dplay.c.
5678{
5681
5683
5688
5696 obj->numIfaces = 1;
5697 obj->ref = 0;
5698 obj->ref2A = 0;
5699 obj->ref2 = 0;
5700 obj->ref3A = 0;
5701 obj->ref3 = 0;
5702 obj->ref4A = 0;
5703 obj->ref4 = 1;
5704
5707
5710 else
5713
Definition: usrmarshal.c:1272
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
Referenced by DirectPlayCreate(), and DPL_ConnectEx().
◆ dplay_destroy()
|
static |
Definition at line 255 of file dplay.c.
Referenced by IDirectPlay2AImpl_Release(), IDirectPlay2Impl_Release(), IDirectPlay3AImpl_Release(), IDirectPlay3Impl_Release(), IDirectPlay4AImpl_Release(), IDirectPlay4Impl_Release(), and IDirectPlayImpl_Release().
◆ DPQ_DECL_DELETECB()
◆ IDirectPlay2AImpl_AddPlayerToGroup()
|
static |
Definition at line 833 of file dplay.c.
836{
static IDirectPlayImpl * impl_from_IDirectPlay2A(IDirectPlay2A *iface)
Definition: dplay.c:100
◆ IDirectPlay2AImpl_AddRef()
|
static |
◆ IDirectPlay2AImpl_Close()
|
static |
◆ IDirectPlay2AImpl_CreateGroup()
|
static |
◆ IDirectPlay2AImpl_CreatePlayer()
|
static |
Definition at line 1701 of file dplay.c.
1704{
#define IDirectPlayX_CreatePlayer(p, a, b, c, d, e, f)
Definition: dplay.h:871
◆ IDirectPlay2AImpl_DeletePlayerFromGroup()
|
static |
◆ IDirectPlay2AImpl_DestroyGroup()
|
static |
◆ IDirectPlay2AImpl_DestroyPlayer()
|
static |
◆ IDirectPlay2AImpl_EnumGroupPlayers()
|
static |
◆ IDirectPlay2AImpl_EnumGroups()
|
static |
◆ IDirectPlay2AImpl_EnumPlayers()
|
static |
◆ IDirectPlay2AImpl_EnumSessions()
|
static |
Definition at line 2390 of file dplay.c.
2393{
Definition: dhcpd.h:245
◆ IDirectPlay2AImpl_GetCaps()
|
static |
◆ IDirectPlay2AImpl_GetGroupData()
|
static |
◆ IDirectPlay2AImpl_GetGroupName()
|
static |
◆ IDirectPlay2AImpl_GetMessageCount()
|
static |
◆ IDirectPlay2AImpl_GetPlayerAddress()
|
static |
Definition at line 2803 of file dplay.c.
2806{
#define IDirectPlayX_GetPlayerAddress(p, a, b, c)
Definition: dplay.h:883
◆ IDirectPlay2AImpl_GetPlayerCaps()
|
static |
◆ IDirectPlay2AImpl_GetPlayerData()
|
static |
◆ IDirectPlay2AImpl_GetPlayerName()
|
static |
◆ IDirectPlay2AImpl_GetSessionDesc()
|
static |
◆ IDirectPlay2AImpl_Initialize()
|
static |
◆ IDirectPlay2AImpl_Open()
|
static |
◆ IDirectPlay2AImpl_QueryInterface()
|
static |
◆ IDirectPlay2AImpl_Receive()
|
static |
◆ IDirectPlay2AImpl_Release()
|
static |
◆ IDirectPlay2AImpl_Send()
|
static |
◆ IDirectPlay2AImpl_SetGroupData()
|
static |
◆ IDirectPlay2AImpl_SetGroupName()
|
static |
◆ IDirectPlay2AImpl_SetPlayerData()
|
static |
◆ IDirectPlay2AImpl_SetPlayerName()
|
static |
◆ IDirectPlay2AImpl_SetSessionDesc()
|
static |
◆ IDirectPlay2Impl_AddPlayerToGroup()
|
static |
Definition at line 840 of file dplay.c.
843{
static IDirectPlayImpl * impl_from_IDirectPlay2(IDirectPlay2 *iface)
Definition: dplay.c:95
◆ IDirectPlay2Impl_AddRef()
◆ IDirectPlay2Impl_Close()
◆ IDirectPlay2Impl_CreateGroup()
|
static |
◆ IDirectPlay2Impl_CreatePlayer()
|
static |
◆ IDirectPlay2Impl_DeletePlayerFromGroup()
|
static |
◆ IDirectPlay2Impl_DestroyGroup()
◆ IDirectPlay2Impl_DestroyPlayer()
◆ IDirectPlay2Impl_EnumGroupPlayers()
|
static |
◆ IDirectPlay2Impl_EnumGroups()
|
static |
◆ IDirectPlay2Impl_EnumPlayers()
|
static |
◆ IDirectPlay2Impl_EnumSessions()
|
static |
◆ IDirectPlay2Impl_GetCaps()
|
static |
◆ IDirectPlay2Impl_GetGroupData()
|
static |
◆ IDirectPlay2Impl_GetGroupName()
|
static |
◆ IDirectPlay2Impl_GetMessageCount()
|
static |
◆ IDirectPlay2Impl_GetPlayerAddress()
|
static |
◆ IDirectPlay2Impl_GetPlayerCaps()
|
static |
◆ IDirectPlay2Impl_GetPlayerData()
|
static |
◆ IDirectPlay2Impl_GetPlayerName()
|
static |
◆ IDirectPlay2Impl_GetSessionDesc()
|
static |
◆ IDirectPlay2Impl_Initialize()
◆ IDirectPlay2Impl_Open()
|
static |
◆ IDirectPlay2Impl_QueryInterface()
|
static |
◆ IDirectPlay2Impl_Receive()
|
static |
◆ IDirectPlay2Impl_Release()
◆ IDirectPlay2Impl_Send()
|
static |
◆ IDirectPlay2Impl_SetGroupData()
|
static |
◆ IDirectPlay2Impl_SetGroupName()
|
static |
◆ IDirectPlay2Impl_SetPlayerData()
|
static |
◆ IDirectPlay2Impl_SetPlayerName()
|
static |
◆ IDirectPlay2Impl_SetSessionDesc()
|
static |
◆ IDirectPlay3AImpl_AddGroupToGroup()
|
static |
Definition at line 3962 of file dplay.c.
3965{
static IDirectPlayImpl * impl_from_IDirectPlay3A(IDirectPlay3A *iface)
Definition: dplay.c:105
◆ IDirectPlay3AImpl_AddPlayerToGroup()
|
static |
◆ IDirectPlay3AImpl_AddRef()
|
static |
◆ IDirectPlay3AImpl_Close()
|
static |
◆ IDirectPlay3AImpl_CreateGroup()
|
static |
◆ IDirectPlay3AImpl_CreateGroupInGroup()
|
static |
Definition at line 4106 of file dplay.c.
4109{
#define IDirectPlayX_CreateGroupInGroup(p, a, b, c, d, e, f)
Definition: dplay.h:899
◆ IDirectPlay3AImpl_CreatePlayer()
|
static |
◆ IDirectPlay3AImpl_DeleteGroupFromGroup()
|
static |
◆ IDirectPlay3AImpl_DeletePlayerFromGroup()
|
static |
◆ IDirectPlay3AImpl_DestroyGroup()
|
static |
◆ IDirectPlay3AImpl_DestroyPlayer()
|
static |
◆ IDirectPlay3AImpl_EnumConnections()
|
static |
◆ IDirectPlay3AImpl_EnumGroupPlayers()
|
static |
◆ IDirectPlay3AImpl_EnumGroups()
|
static |
◆ IDirectPlay3AImpl_EnumGroupsInGroup()
|
static |
◆ IDirectPlay3AImpl_EnumPlayers()
|
static |
◆ IDirectPlay3AImpl_EnumSessions()
|
static |
◆ IDirectPlay3AImpl_GetCaps()
|
static |
◆ IDirectPlay3AImpl_GetGroupConnectionSettings()
|
static |
Definition at line 4551 of file dplay.c.
4554{
#define IDirectPlayX_GetGroupConnectionSettings(p, a, b, c, d)
Definition: dplay.h:903
◆ IDirectPlay3AImpl_GetGroupData()
|
static |
◆ IDirectPlay3AImpl_GetGroupFlags()
|
static |
◆ IDirectPlay3AImpl_GetGroupName()
|
static |
◆ IDirectPlay3AImpl_GetGroupParent()
|
static |
◆ IDirectPlay3AImpl_GetMessageCount()
|
static |
◆ IDirectPlay3AImpl_GetPlayerAccount()
|
static |
Definition at line 5096 of file dplay.c.
5099{
#define IDirectPlayX_GetPlayerAccount(p, a, b, c, d)
Definition: dplay.h:911
◆ IDirectPlay3AImpl_GetPlayerAddress()
|
static |
◆ IDirectPlay3AImpl_GetPlayerCaps()
|
static |
◆ IDirectPlay3AImpl_GetPlayerData()
|
static |
◆ IDirectPlay3AImpl_GetPlayerFlags()
|
static |
◆ IDirectPlay3AImpl_GetPlayerName()
|
static |
◆ IDirectPlay3AImpl_GetSessionDesc()
|
static |
◆ IDirectPlay3AImpl_Initialize()
|
static |
◆ IDirectPlay3AImpl_InitializeConnection()
|
static |
◆ IDirectPlay3AImpl_Open()
|
static |
◆ IDirectPlay3AImpl_QueryInterface()
|
static |
◆ IDirectPlay3AImpl_Receive()
|
static |
◆ IDirectPlay3AImpl_Release()
|
static |
◆ IDirectPlay3AImpl_SecureOpen()
|
static |
◆ IDirectPlay3AImpl_Send()
|
static |
◆ IDirectPlay3AImpl_SendChatMessage()
|
static |
Definition at line 4940 of file dplay.c.
4943{
#define IDirectPlayX_SendChatMessage(p, a, b, c, d)
Definition: dplay.h:906
◆ IDirectPlay3AImpl_SetGroupConnectionSettings()
|
static |
Definition at line 4970 of file dplay.c.
4973{
4976 connection );
#define IDirectPlayX_SetGroupConnectionSettings(p, a, b, c)
Definition: dplay.h:907
◆ IDirectPlay3AImpl_SetGroupData()
|
static |
◆ IDirectPlay3AImpl_SetGroupName()
|
static |
◆ IDirectPlay3AImpl_SetPlayerData()
|
static |
◆ IDirectPlay3AImpl_SetPlayerName()
|
static |
◆ IDirectPlay3AImpl_SetSessionDesc()
|
static |
◆ IDirectPlay3AImpl_StartSession()
|
static |
◆ IDirectPlay3Impl_AddGroupToGroup()
|
static |
Definition at line 3969 of file dplay.c.
3972{
static IDirectPlayImpl * impl_from_IDirectPlay3(IDirectPlay3 *iface)
Definition: dplay.c:110
◆ IDirectPlay3Impl_AddPlayerToGroup()
|
static |
◆ IDirectPlay3Impl_AddRef()
◆ IDirectPlay3Impl_Close()
◆ IDirectPlay3Impl_CreateGroup()
|
static |
◆ IDirectPlay3Impl_CreateGroupInGroup()
|
static |
◆ IDirectPlay3Impl_CreatePlayer()
|
static |
◆ IDirectPlay3Impl_DeleteGroupFromGroup()
|
static |
◆ IDirectPlay3Impl_DeletePlayerFromGroup()
|
static |
◆ IDirectPlay3Impl_DestroyGroup()
◆ IDirectPlay3Impl_DestroyPlayer()
◆ IDirectPlay3Impl_EnumConnections()
|
static |
◆ IDirectPlay3Impl_EnumGroupPlayers()
|
static |
◆ IDirectPlay3Impl_EnumGroups()
|
static |
◆ IDirectPlay3Impl_EnumGroupsInGroup()
|
static |
◆ IDirectPlay3Impl_EnumPlayers()
|
static |
◆ IDirectPlay3Impl_EnumSessions()
|
static |
◆ IDirectPlay3Impl_GetCaps()
|
static |
◆ IDirectPlay3Impl_GetGroupConnectionSettings()
|
static |
◆ IDirectPlay3Impl_GetGroupData()
|
static |
◆ IDirectPlay3Impl_GetGroupFlags()
|
static |
◆ IDirectPlay3Impl_GetGroupName()
|
static |
◆ IDirectPlay3Impl_GetGroupParent()
|
static |
◆ IDirectPlay3Impl_GetMessageCount()
|
static |
◆ IDirectPlay3Impl_GetPlayerAccount()
|
static |
◆ IDirectPlay3Impl_GetPlayerAddress()
|
static |
◆ IDirectPlay3Impl_GetPlayerCaps()
|
static |
◆ IDirectPlay3Impl_GetPlayerData()
|
static |
◆ IDirectPlay3Impl_GetPlayerFlags()
|
static |
◆ IDirectPlay3Impl_GetPlayerName()
|
static |
◆ IDirectPlay3Impl_GetSessionDesc()
|
static |
◆ IDirectPlay3Impl_Initialize()
◆ IDirectPlay3Impl_InitializeConnection()
|
static |
◆ IDirectPlay3Impl_Open()
|
static |
◆ IDirectPlay3Impl_QueryInterface()
|
static |
◆ IDirectPlay3Impl_Receive()
|
static |
◆ IDirectPlay3Impl_Release()
◆ IDirectPlay3Impl_SecureOpen()
|
static |
◆ IDirectPlay3Impl_Send()
|
static |
◆ IDirectPlay3Impl_SendChatMessage()
|
static |
◆ IDirectPlay3Impl_SetGroupConnectionSettings()
|
static |
◆ IDirectPlay3Impl_SetGroupData()
|
static |
◆ IDirectPlay3Impl_SetGroupName()
|
static |
◆ IDirectPlay3Impl_SetPlayerData()
|
static |
◆ IDirectPlay3Impl_SetPlayerName()
|
static |
◆ IDirectPlay3Impl_SetSessionDesc()
|
static |
◆ IDirectPlay3Impl_StartSession()
|
static |
◆ IDirectPlay4AImpl_AddGroupToGroup()
|
static |
Definition at line 3976 of file dplay.c.
3979{
static IDirectPlayImpl * impl_from_IDirectPlay4A(IDirectPlay4A *iface)
Definition: dplay.c:115
◆ IDirectPlay4AImpl_AddPlayerToGroup()
|
static |
◆ IDirectPlay4AImpl_AddRef()
|
static |
◆ IDirectPlay4AImpl_CancelMessage()
|
static |
◆ IDirectPlay4AImpl_CancelPriority()
|
static |
◆ IDirectPlay4AImpl_Close()
|
static |
◆ IDirectPlay4AImpl_CreateGroup()
|
static |
◆ IDirectPlay4AImpl_CreateGroupInGroup()
|
static |
Definition at line 4122 of file dplay.c.
4126{
4128
4129 *lpidGroup = DPID_UNKNOWN;
4130
static HRESULT DP_IF_CreateGroupInGroup(IDirectPlayImpl *This, void *lpMsgHdr, DPID idParentGroup, DPID *lpidGroup, DPNAME *lpGroupName, void *lpData, DWORD dwDataSize, DWORD dwFlags, BOOL bAnsi)
Definition: dplay.c:4019
◆ IDirectPlay4AImpl_CreatePlayer()
|
static |
Definition at line 1733 of file dplay.c.
1736{
1738
1740 {
1742 }
1743
1745 {
1746 *lpidPlayer = DPID_SERVERPLAYER;
1747 }
1748 else
1749 {
1750 *lpidPlayer = DPID_UNKNOWN;
1751 }
1752
◆ IDirectPlay4AImpl_DeleteGroupFromGroup()
|
static |
◆ IDirectPlay4AImpl_DeletePlayerFromGroup()
|
static |
◆ IDirectPlay4AImpl_DestroyGroup()
|
static |
Definition at line 1980 of file dplay.c.
1982{
static HRESULT DP_IF_DestroyGroup(IDirectPlayImpl *This, void *lpMsgHdr, DPID idGroup, BOOL bAnsi)
Definition: dplay.c:1904
◆ IDirectPlay4AImpl_DestroyPlayer()
|
static |
Definition at line 2103 of file dplay.c.
2105{
static HRESULT DP_IF_DestroyPlayer(IDirectPlayImpl *This, void *lpMsgHdr, DPID idPlayer, BOOL bAnsi)
Definition: dplay.c:1999
◆ IDirectPlay4AImpl_EnumConnections()
|
static |
Definition at line 4250 of file dplay.c.
4254{
4256 TRACE("(%p)->(%p,%p,%p,0x%08x)\n", This, lpguidApplication, lpEnumCallback, lpContext, dwFlags );
4257
4258 /* A default dwFlags (0) is backwards compatible -- DPCONNECTION_DIRECTPLAY */
4260 {
4262 }
4263
4266 )
4267 {
4269 }
4270
4271 if( !lpEnumCallback )
4272 {
4274 }
4275
4276 /* Enumerate DirectPlay service providers */
4278 {
4279 HKEY hkResult;
4282 char subKeyName[51];
4283 DWORD dwIndex, sizeOfSubKeyName=50;
4285
4286 /* Need to loop over the service providers in the registry */
4289 {
4290 /* Hmmm. Does this mean that there are no service providers? */
4293 }
4294
4295
4296 /* Traverse all the service providers we have available */
4297 for( dwIndex=0;
4298 RegEnumKeyExA( hkResult, dwIndex, subKeyName, &sizeOfSubKeyName,
4300 ++dwIndex, sizeOfSubKeyName=51 )
4301 {
4302
4303 HKEY hkServiceProvider;
4304 GUID serviceProviderGUID;
4305 DWORD returnTypeGUID, sizeOfReturnBuffer = 50;
4306 char returnBuffer[51];
4308 DPNAME dpName;
4309 BOOL bBuildPass;
4310
4312 DWORD dwAddressBufferSize = 0;
4313
4315
4316 /* Get a handle for this particular service provider */
4318 &hkServiceProvider ) != ERROR_SUCCESS )
4319 {
4321 continue;
4322 }
4323
4326 &sizeOfReturnBuffer ) != ERROR_SUCCESS )
4327 {
4329 RegCloseKey(hkServiceProvider);
4330 continue;
4331 }
4332 RegCloseKey(hkServiceProvider);
4333
4334 /* FIXME: Check return types to ensure we're interpreting data right */
4337 /* FIXME: Have I got a memory leak on the serviceProviderGUID? */
4338
4339 /* Fill in the DPNAME struct for the service provider */
4341 dpName.dwFlags = 0;
4342 dpName.u1.lpszShortNameA = subKeyName;
4344
4345 /* Create the compound address for the service provider.
4346 * NOTE: This is a gruesome architectural scar right now. DP
4347 * uses DPL and DPL uses DP. Nasty stuff. This may be why the
4348 * native dll just gets around this little bit by allocating an
4349 * 80 byte buffer which isn't even filled with a valid compound
4350 * address. Oh well. Creating a proper compound address is the
4351 * way to go anyways despite this method taking slightly more
4352 * heap space and realtime :) */
4353
4354 bBuildPass = DP_BuildSPCompoundAddr( &serviceProviderGUID,
4355 &lpAddressBuffer,
4356 &dwAddressBufferSize );
4357 if( !bBuildPass )
4358 {
4361 }
4362
4363 /* The enumeration will return FALSE if we are not to continue */
4364 if( !lpEnumCallback( &serviceProviderGUID, lpAddressBuffer, dwAddressBufferSize,
4365 &dpName, dwFlags, lpContext ) )
4366 {
4369 }
4371 }
4372 }
4373
4374 /* Enumerate DirectPlayLobby service providers */
4376 {
4377 HKEY hkResult;
4380 char subKeyName[51];
4381 DWORD dwIndex, sizeOfSubKeyName=50;
4383
4384 /* Need to loop over the service providers in the registry */
4387 {
4390 }
4391
4392
4393 /* Traverse all the lobby providers we have available */
4394 for( dwIndex=0;
4395 RegEnumKeyExA( hkResult, dwIndex, subKeyName, &sizeOfSubKeyName,
4397 ++dwIndex, sizeOfSubKeyName=51 )
4398 {
4399
4400 HKEY hkServiceProvider;
4401 GUID serviceProviderGUID;
4402 DWORD returnTypeGUID, sizeOfReturnBuffer = 50;
4403 char returnBuffer[51];
4405 DPNAME dpName;
4407
4408 DPCOMPOUNDADDRESSELEMENT dpCompoundAddress;
4410 DWORD dwAddressBufferSize = 0;
4411
4413
4414 /* Get a handle for this particular service provider */
4416 &hkServiceProvider ) != ERROR_SUCCESS )
4417 {
4419 continue;
4420 }
4421
4424 &sizeOfReturnBuffer ) != ERROR_SUCCESS )
4425 {
4427 RegCloseKey(hkServiceProvider);
4428 continue;
4429 }
4430 RegCloseKey(hkServiceProvider);
4431
4432 /* FIXME: Check return types to ensure we're interpreting data right */
4435 /* FIXME: Have I got a memory leak on the serviceProviderGUID? */
4436
4437 /* Fill in the DPNAME struct for the service provider */
4439 dpName.dwFlags = 0;
4440 dpName.u1.lpszShortNameA = subKeyName;
4442
4443 /* Create the compound address for the service provider.
4444 NOTE: This is a gruesome architectural scar right now. DP uses DPL and DPL uses DP
4445 nast stuff. This may be why the native dll just gets around this little bit by
4446 allocating an 80 byte buffer which isn't even a filled with a valid compound
4447 address. Oh well. Creating a proper compound address is the way to go anyways
4448 despite this method taking slightly more heap space and realtime :) */
4449
4450 dpCompoundAddress.guidDataType = DPAID_LobbyProvider;
4452 dpCompoundAddress.lpData = &serviceProviderGUID;
4453
4456 {
4459 }
4460
4461 /* Now allocate the buffer */
4463
4466 {
4470 }
4471
4472 /* The enumeration will return FALSE if we are not to continue */
4473 if( !lpEnumCallback( &serviceProviderGUID, lpAddressBuffer, dwAddressBufferSize,
4474 &dpName, dwFlags, lpContext ) )
4475 {
4478 }
4480 }
4481 }
4482
static BOOL DP_BuildSPCompoundAddr(LPGUID lpcSpGuid, LPVOID *lplpAddrBuf, LPDWORD lpdwBufSize)
Definition: dplay.c:4197
◆ IDirectPlay4AImpl_EnumGroupPlayers()
|
static |
◆ IDirectPlay4AImpl_EnumGroups()
|
static |
◆ IDirectPlay4AImpl_EnumGroupsInGroup()
|
static |
◆ IDirectPlay4AImpl_EnumPlayers()
|
static |
◆ IDirectPlay4AImpl_EnumSessions()
|
static |
◆ IDirectPlay4AImpl_GetCaps()
|
static |
◆ IDirectPlay4AImpl_GetGroupConnectionSettings()
◆ IDirectPlay4AImpl_GetGroupData()
|
static |
◆ IDirectPlay4AImpl_GetGroupFlags()
|
static |
◆ IDirectPlay4AImpl_GetGroupName()
|
static |
Definition at line 2749 of file dplay.c.
2752{
static HRESULT DP_IF_GetGroupName(IDirectPlayImpl *This, DPID idGroup, void *lpData, DWORD *lpdwDataSize, BOOL bAnsi)
Definition: dplay.c:2660
◆ IDirectPlay4AImpl_GetGroupOwner()
|
static |
◆ IDirectPlay4AImpl_GetGroupParent()
|
static |
◆ IDirectPlay4AImpl_GetMessageCount()
|
static |
Definition at line 2791 of file dplay.c.
2794{
#define IDirectPlayX_GetMessageQueue(p, a, b, c, d, e)
Definition: dplay.h:917
◆ IDirectPlay4AImpl_GetMessageQueue()
|
static |
◆ IDirectPlay4AImpl_GetPlayerAccount()
◆ IDirectPlay4AImpl_GetPlayerAddress()
|
static |
◆ IDirectPlay4AImpl_GetPlayerCaps()
|
static |
◆ IDirectPlay4AImpl_GetPlayerData()
|
static |
◆ IDirectPlay4AImpl_GetPlayerFlags()
|
static |
◆ IDirectPlay4AImpl_GetPlayerName()
|
static |
Definition at line 3076 of file dplay.c.
3079{
static HRESULT DP_IF_GetPlayerName(IDirectPlayImpl *This, DPID idPlayer, void *lpData, DWORD *lpdwDataSize, BOOL bAnsi)
Definition: dplay.c:2982
◆ IDirectPlay4AImpl_GetSessionDesc()
|
static |
Definition at line 3151 of file dplay.c.
3154{
static HRESULT DP_GetSessionDesc(IDirectPlayImpl *This, void *lpData, DWORD *lpdwDataSize, BOOL bAnsi)
Definition: dplay.c:3090
◆ IDirectPlay4AImpl_Initialize()
|
static |
◆ IDirectPlay4AImpl_InitializeConnection()
|
static |
◆ IDirectPlay4AImpl_Open()
|
static |
◆ IDirectPlay4AImpl_QueryInterface()
|
static |
◆ IDirectPlay4AImpl_Receive()
|
static |
Definition at line 3440 of file dplay.c.
3443{
static HRESULT DP_IF_Receive(IDirectPlayImpl *This, DPID *lpidFrom, DPID *lpidTo, DWORD dwFlags, void *lpData, DWORD *lpdwDataSize, BOOL bAnsi)
Definition: dplay.c:3355
◆ IDirectPlay4AImpl_Release()
|
static |
◆ IDirectPlay4AImpl_SecureOpen()
|
static |
Definition at line 4924 of file dplay.c.
4928{
static HRESULT DP_SecureOpen(IDirectPlayImpl *This, const DPSESSIONDESC2 *lpsd, DWORD dwFlags, const DPSECURITYDESC *lpSecurity, const DPCREDENTIALS *lpCredentials, BOOL bAnsi)
Definition: dplay.c:3205
◆ IDirectPlay4AImpl_Send()
◆ IDirectPlay4AImpl_SendChatMessage()
|
static |
◆ IDirectPlay4AImpl_SendEx()
|
static |
◆ IDirectPlay4AImpl_SetGroupConnectionSettings()
|
static |
◆ IDirectPlay4AImpl_SetGroupData()
|
static |
◆ IDirectPlay4AImpl_SetGroupName()
|
static |
Definition at line 3613 of file dplay.c.
3616{
static HRESULT DP_IF_SetGroupName(IDirectPlayImpl *This, DPID idGroup, DPNAME *lpGroupName, DWORD dwFlags, BOOL bAnsi)
Definition: dplay.c:3564
◆ IDirectPlay4AImpl_SetGroupOwner()
|
static |
◆ IDirectPlay4AImpl_SetPlayerData()
|
static |
◆ IDirectPlay4AImpl_SetPlayerName()
|
static |
Definition at line 3751 of file dplay.c.
3754{
static HRESULT DP_IF_SetPlayerName(IDirectPlayImpl *This, DPID idPlayer, DPNAME *lpPlayerName, DWORD dwFlags, BOOL bAnsi)
Definition: dplay.c:3697
◆ IDirectPlay4AImpl_SetSessionDesc()
|
static |
◆ IDirectPlay4AImpl_StartSession()
|
static |
◆ IDirectPlay4Impl_AddGroupToGroup()
|
static |
Definition at line 3983 of file dplay.c.
3986{
3988 lpGroupData gdata;
3990
3992
3995
3998
4001
4002 /* Create a player list (ie "shortcut" ) */
4006
4007 /* Add the shortcut */
4008 gdata->uRef++;
4009 glist->lpGData = gdata;
4010
4011 /* Add the player to the list of players for this group */
4013
4014 /* Send a ADDGROUPTOGROUP message */
4016
static IDirectPlayImpl * impl_from_IDirectPlay4(IDirectPlay4 *iface)
Definition: dplay.c:120
◆ IDirectPlay4Impl_AddPlayerToGroup()
|
static |
Definition at line 868 of file dplay.c.
871{
873 lpGroupData gdata;
875 lpPlayerList newplist;
876
878
881
882 /* Find the group */
885
886 /* Find the player */
889
890 /* Create a player list (ie "shortcut" ) */
892 if ( !newplist )
894
895 /* Add the shortcut */
896 plist->lpPData->uRef++;
898
899 /* Add the player to the list of players for this group */
900 DPQ_INSERT(gdata->players, newplist, players);
901
902 /* Let the SP know that we've added a player to the group */
904 {
906
908
909 data.idPlayer = player;
912
914 }
915
916 /* Inform all other peers of the addition of player to the group. If there are
917 * no peers keep this event quiet.
918 * Also, if this event was the result of another machine sending it to us,
919 * don't bother rebroadcasting it.
920 */
923 {
926
928 msg.dpIdPlayer = player;
929
930 /* FIXME: Correct to just use send effectively? */
931 /* FIXME: Should size include data w/ message or just message "header" */
932 /* FIXME: Check return code */
935 }
936
Definition: dplay.h:1181
◆ IDirectPlay4Impl_AddRef()
◆ IDirectPlay4Impl_CancelMessage()
|
static |
Definition at line 5356 of file dplay.c.
5359{
5361
5364
5365 if ( msgid == 0 )
5367
static HRESULT dplay_cancelmsg(IDirectPlayImpl *This, DWORD msgid, DWORD flags, DWORD minprio, DWORD maxprio)
Definition: dplay.c:5319
◆ IDirectPlay4Impl_CancelPriority()
|
static |
◆ IDirectPlay4Impl_Close()
Definition at line 969 of file dplay.c.
971{
974
976
977 /* FIXME: Need to find a new host I assume (how?) */
978 /* FIXME: Need to destroy all local groups */
979 /* FIXME: Need to migrate all remotely visible players to the new host */
980
981 /* Invoke the SP callback to inform of session close */
983 {
985
989 }
991 {
994 }
995
Definition: dplaysp.h:123
◆ IDirectPlay4Impl_CreateGroup()
|
static |
◆ IDirectPlay4Impl_CreateGroupInGroup()
|
static |
◆ IDirectPlay4Impl_CreatePlayer()
|
static |
Definition at line 1756 of file dplay.c.
1759{
1761
1763 {
1765 }
1766
1768 {
1769 *lpidPlayer = DPID_SERVERPLAYER;
1770 }
1771 else
1772 {
1773 *lpidPlayer = DPID_UNKNOWN;
1774 }
1775
◆ IDirectPlay4Impl_DeleteGroupFromGroup()
|
static |
Definition at line 4166 of file dplay.c.
4169{
4172 lpGroupData parentdata;
4173
4175
4176 /* Is the parent group valid? */
4179
4180 /* Remove the group from the parent group queue */
4182
4185
4186 /* Decrement the ref count */
4187 glist->lpGData->uRef--;
4188
4189 /* Free up the list item */
4191
4192 /* Should send a DELETEGROUPFROMGROUP message */
4194
◆ IDirectPlay4Impl_DeletePlayerFromGroup()
|
static |
Definition at line 1822 of file dplay.c.
1825{
1828
1829 lpGroupData gdata;
1831
1833
1834 /* Find the group */
1837
1838 /* Find the player */
1841
1842 /* Remove the player shortcut from the group */
1844
1847
1848 /* One less reference */
1849 plist->lpPData->uRef--;
1850
1851 /* Delete the Player List element */
1853
1854 /* Inform the SP if they care */
1856 {
1858
1860 data.idPlayer = player;
1864 }
1865
1866 /* Need to send a DELETEPLAYERFROMGROUP message */
1868
Definition: dplaysp.h:200
◆ IDirectPlay4Impl_DestroyGroup()
◆ IDirectPlay4Impl_DestroyPlayer()
◆ IDirectPlay4Impl_EnumConnections()
|
static |
◆ IDirectPlay4Impl_EnumGroupPlayers()
|
static |
Definition at line 2155 of file dplay.c.
2158{
2160 lpGroupData gdata;
2162
2165
2168
2169 /* Find the group */
2172
2175
2176 /* Walk the players in this group */
2178 {
2179 /* We do not enum the name server or app server as they are of no
2180 * consequence to the end user.
2181 */
2184 {
2185 /* FIXME: Need to add stuff for flags checking */
2188 /* User requested break */
2190 }
2191
2193 break;
2194 }
◆ IDirectPlay4Impl_EnumGroups()
|
static |
◆ IDirectPlay4Impl_EnumGroupsInGroup()
|
static |
Definition at line 4517 of file dplay.c.
4520{
4523 lpGroupData gdata;
4524
4527
4530
4533
4536
4537
4539 {
4540 /* FIXME: Should check flags for match here */
4544
4546 break;
4547 }
4548
◆ IDirectPlay4Impl_EnumPlayers()
|
static |
◆ IDirectPlay4Impl_EnumSessions()
|
static |
Definition at line 2430 of file dplay.c.
2433{
2435 void *connection;
2438
2441
2444
2445 /* Can't enumerate if the interface is already open */
2448
2449 /* The loading of a lobby provider _seems_ to require a backdoor loading
2450 * of the service provider to also associate with this DP object. This is
2451 * because the app doesn't seem to have to call EnumConnections and
2452 * InitializeConnection for the SP before calling this method. As such
2453 * we'll do their dirty work for them with a quick hack so as to always
2454 * load the TCP/IP service provider.
2455 *
2456 * The correct solution would seem to involve creating a dialog box which
2457 * contains the possible SPs. These dialog boxes most likely follow SDK
2458 * examples.
2459 */
2461 {
2463
2465 {
2468 }
2469
2473
2476 }
2477
2478
2479 /* Use the service provider default? */
2481 {
2482 DPCAPS caps;
2484
2489 }
2490
2492 {
2495 }
2496
2498 {
2499 /* Enumerate everything presently in the local session cache */
2501 context );
2502
2505
2506 /* See if we've already created a thread to service this interface */
2508 {
2510 This->dp2->dwEnumSessionLock++;
2511
2512 /* Send the first enum request inline since the user may cancel a dialog
2513 * if one is presented. Also, may also have a connecting return code.
2514 */
2516 &This->dp2->spData );
2517
2519 {
2522 /* FIXME: need to kill the thread on object deletion */
2527
2531 DUPLICATE_SAME_ACCESS ) )
2533
2537 }
2538 This->dp2->dwEnumSessionLock--;
2539 }
2540 }
2541 else
2542 {
2543 /* Invalidate the session cache for the interface */
2545 /* Send the broadcast for session enumeration */
2549 context );
2550 }
2551
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
static void DP_InvokeEnumSessionCallbacks(LPDPENUMSESSIONSCALLBACK2 lpEnumSessionsCallback2, LPVOID lpNSInfo, DWORD dwTimeout, LPVOID lpContext)
Definition: dplay.c:2294
static DWORD CALLBACK DP_EnumSessionsSendAsyncRequestThread(LPVOID lpContext)
Definition: dplay.c:2323
void NS_InvalidateSessionCache(LPVOID lpNSInfo)
Definition: name_server.c:243
Definition: dplay.h:168
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:651
◆ IDirectPlay4Impl_GetCaps()
|
static |
◆ IDirectPlay4Impl_GetGroupConnectionSettings()
◆ IDirectPlay4Impl_GetGroupData()
|
static |
Definition at line 2623 of file dplay.c.
2626{
2628 lpGroupData gdata;
2631
2633
2636
2637 /* How much buffer is required? */
2639 {
2642 }
2643 else
2644 {
2647 }
2648
2649 /* Is the user requesting to know how big a buffer is required? */
2651 {
2654 }
2655
2657
◆ IDirectPlay4Impl_GetGroupFlags()
|
static |
◆ IDirectPlay4Impl_GetGroupName()
|
static |
◆ IDirectPlay4Impl_GetGroupOwner()
|
static |
◆ IDirectPlay4Impl_GetGroupParent()
|
static |
◆ IDirectPlay4Impl_GetMessageCount()
|
static |
◆ IDirectPlay4Impl_GetMessageQueue()
|
static |
Definition at line 5286 of file dplay.c.
5289{
5292
5293 FIXME( "(%p)->(0x%08x,0x%08x,0x%08x,%p,%p): semi-stub\n", This, from, to, flags, msgs, bytes );
5294
5295 /* FIXME: Do we need to do from and to sanity checking here? */
5296 /* FIXME: What about sends which are not immediate? */
5297
5299 {
5301
5303
5304 /* FIXME: None of this is documented :( */
5308 data.idTo = to;
5309 data.lpdwNumMsgs = msgs;
5311
5313 }
5314 else
5316
Definition: dplaysp.h:268
◆ IDirectPlay4Impl_GetPlayerAccount()
◆ IDirectPlay4Impl_GetPlayerAddress()
|
static |
◆ IDirectPlay4Impl_GetPlayerCaps()
|
static |
Definition at line 2882 of file dplay.c.
2885{
2888
2890
2891 if ( !caps )
2893
2896
2899
2900 /* Query the service provider */
2901 data.idPlayer = player;
2903 data.lpCaps = caps;
2905
Definition: dplaysp.h:182
◆ IDirectPlay4Impl_GetPlayerData()
|
static |
◆ IDirectPlay4Impl_GetPlayerFlags()
|
static |
◆ IDirectPlay4Impl_GetPlayerName()
|
static |
◆ IDirectPlay4Impl_GetSessionDesc()
|
static |
◆ IDirectPlay4Impl_Initialize()
◆ IDirectPlay4Impl_InitializeConnection()
|
static |
Definition at line 4845 of file dplay.c.
4848{
4850 HMODULE servprov;
4855
4857
4858 if ( !connection )
4860
4863
4866
4867 /* Find out what the requested SP is and how large this buffer is */
4869
4871 {
4874 }
4875
4876 /* Load the service provider */
4878
4879 if ( !servprov )
4880 {
4883 }
4884
4885 if ( is_dp_sp )
4886 {
4887 /* Fill in what we can of the Service Provider required information.
4888 * The rest was be done in DP_LoadSP
4889 */
4890 This->dp2->spData.lpAddress = connection;
4894 }
4895 else
4896 {
4897 This->dp2->dplspData.lpAddress = connection;
4899 }
4900
4903
static HRESULT DP_InitializeDPLSP(IDirectPlayImpl *This, HMODULE hLobbyProvider)
Definition: dplay.c:4784
static HRESULT DP_InitializeDPSP(IDirectPlayImpl *This, HMODULE hServiceProvider)
Definition: dplay.c:4745
static HMODULE DP_LoadSP(LPCGUID lpcGuid, LPSPINITDATA lpSpData, LPBOOL lpbIsDpSp)
Definition: dplay.c:4614
static BOOL CALLBACK DP_GetSpLpGuidFromCompoundAddress(REFGUID guidDataType, DWORD dwDataSize, LPCVOID lpData, LPVOID lpContext)
Definition: dplay.c:4583
HRESULT DPL_EnumAddress(LPDPENUMADDRESSCALLBACK lpEnumAddressCallback, LPCVOID lpAddress, DWORD dwAddressSize, LPVOID lpContext) DECLSPEC_HIDDEN
Definition: dplobby.c:644
◆ IDirectPlay4Impl_Open()
|
static |
◆ IDirectPlay4Impl_QueryInterface()
|
static |
Definition at line 621 of file dplay.c.
624{
626
628 {
631 }
633 {
636 }
638 {
641 }
643 {
646 }
648 {
651 }
653 {
656 }
658 {
661 }
663 {
666 }
667 else
668 {
672 }
673
Definition: unknwn.idl:39
◆ IDirectPlay4Impl_Receive()
|
static |
◆ IDirectPlay4Impl_Release()
◆ IDirectPlay4Impl_SecureOpen()
|
static |
◆ IDirectPlay4Impl_Send()
◆ IDirectPlay4Impl_SendChatMessage()
|
static |
◆ IDirectPlay4Impl_SendEx()
|
static |
Definition at line 5194 of file dplay.c.
5198{
5200
5203
5206
5207 /* FIXME: Add parameter checking */
5208 /* FIXME: First call to this needs to acquire a message id which will be
5209 * used for multiple sends
5210 */
5211
5212 /* NOTE: Can't send messages to yourself - this will be trapped in receive */
5213
5214 /* Verify that the message is being sent from a valid local player. The
5215 * from player may be anonymous DPID_UNKNOWN
5216 */
5218 {
5221 }
5222
5223 /* Verify that the message is being sent to a valid player, group or to
5224 * everyone. If it's valid, send it to those players.
5225 */
5227 {
5228 /* See if SP has the ability to multicast. If so, use it */
5233 else /* No multicast, multiplicate */
5235 }
5237 {
5238 /* Have the service provider send this message */
5239 /* FIXME: Could optimize for local interface sends */
5241 }
5243 {
5244 /* See if SP has the ability to multicast. If so, use it */
5249 else /* No multicast, multiplicate */
5251
5252 }
5253 else
5255
5256 /* FIXME: Should return what the send returned */
static HRESULT DP_SP_SendEx(IDirectPlayImpl *This, DWORD dwFlags, void *lpData, DWORD dwDataSize, DWORD dwPriority, DWORD dwTimeout, void *lpContext, DWORD *lpdwMsgID)
Definition: dplay.c:5259
◆ IDirectPlay4Impl_SetGroupConnectionSettings()
|
static |
◆ IDirectPlay4Impl_SetGroupData()
|
static |
Definition at line 3529 of file dplay.c.
3532{
3534 lpGroupData gdata;
3535
3537
3538 /* Parameter check */
3541
3542 /* Find the pointer to the data for this player */
3545
3547 {
3549 /* FIXME: If this is a remote update need to allow it but not
3550 * send a message.
3551 */
3552 }
3553
3555
3556 /* FIXME: Only send a message if this group is local to the session otherwise
3557 * it will have been rejected above
3558 */
3561
◆ IDirectPlay4Impl_SetGroupName()
|
static |
◆ IDirectPlay4Impl_SetGroupOwner()
|
static |
◆ IDirectPlay4Impl_SetPlayerData()
|
static |
◆ IDirectPlay4Impl_SetPlayerName()
|
static |
◆ IDirectPlay4Impl_SetSessionDesc()
|
static |
◆ IDirectPlay4Impl_StartSession()
|
static |
◆ IDirectPlayImpl_AddPlayerToGroup()
|
static |
Definition at line 385 of file dplay.c.
388{
static IDirectPlayImpl * impl_from_IDirectPlay(IDirectPlay *iface)
Definition: dplay.c:90
◆ IDirectPlayImpl_AddRef()
◆ IDirectPlayImpl_Close()
◆ IDirectPlayImpl_CreateGroup()
|
static |
◆ IDirectPlayImpl_CreatePlayer()
|
static |
◆ IDirectPlayImpl_DeletePlayerFromGroup()
|
static |
◆ IDirectPlayImpl_DestroyGroup()
◆ IDirectPlayImpl_DestroyPlayer()
◆ IDirectPlayImpl_EnableNewPlayers()
◆ IDirectPlayImpl_EnumGroupPlayers()
◆ IDirectPlayImpl_EnumGroups()
|
static |
Definition at line 454 of file dplay.c.
457{
Definition: winhttp_private.h:79
◆ IDirectPlayImpl_EnumPlayers()
◆ IDirectPlayImpl_EnumSessions()
|
static |
◆ IDirectPlayImpl_GetCaps()
◆ IDirectPlayImpl_GetMessageCount()
|
static |
◆ IDirectPlayImpl_GetPlayerCaps()
|
static |
◆ IDirectPlayImpl_GetPlayerName()
|
static |
◆ IDirectPlayImpl_Initialize()
◆ IDirectPlayImpl_Open()
|
static |
◆ IDirectPlayImpl_QueryInterface()
|
static |
◆ IDirectPlayImpl_Receive()
◆ IDirectPlayImpl_Release()
◆ IDirectPlayImpl_SaveSession()
◆ IDirectPlayImpl_Send()
◆ IDirectPlayImpl_SetPlayerName()
|
static |
◆ impl_from_IDirectPlay()
|
inlinestatic |
Definition at line 90 of file dplay.c.
92{
Referenced by IDirectPlayImpl_AddPlayerToGroup(), IDirectPlayImpl_AddRef(), IDirectPlayImpl_Close(), IDirectPlayImpl_CreateGroup(), IDirectPlayImpl_CreatePlayer(), IDirectPlayImpl_DeletePlayerFromGroup(), IDirectPlayImpl_DestroyGroup(), IDirectPlayImpl_DestroyPlayer(), IDirectPlayImpl_EnableNewPlayers(), IDirectPlayImpl_EnumGroupPlayers(), IDirectPlayImpl_EnumGroups(), IDirectPlayImpl_EnumPlayers(), IDirectPlayImpl_EnumSessions(), IDirectPlayImpl_GetCaps(), IDirectPlayImpl_GetMessageCount(), IDirectPlayImpl_GetPlayerCaps(), IDirectPlayImpl_GetPlayerName(), IDirectPlayImpl_Initialize(), IDirectPlayImpl_Open(), IDirectPlayImpl_QueryInterface(), IDirectPlayImpl_Receive(), IDirectPlayImpl_Release(), IDirectPlayImpl_SaveSession(), IDirectPlayImpl_Send(), and IDirectPlayImpl_SetPlayerName().
◆ impl_from_IDirectPlay2()
|
inlinestatic |
Definition at line 95 of file dplay.c.
97{
Referenced by IDirectPlay2Impl_AddPlayerToGroup(), IDirectPlay2Impl_AddRef(), IDirectPlay2Impl_Close(), IDirectPlay2Impl_CreateGroup(), IDirectPlay2Impl_CreatePlayer(), IDirectPlay2Impl_DeletePlayerFromGroup(), IDirectPlay2Impl_DestroyGroup(), IDirectPlay2Impl_DestroyPlayer(), IDirectPlay2Impl_EnumGroupPlayers(), IDirectPlay2Impl_EnumGroups(), IDirectPlay2Impl_EnumPlayers(), IDirectPlay2Impl_EnumSessions(), IDirectPlay2Impl_GetCaps(), IDirectPlay2Impl_GetGroupData(), IDirectPlay2Impl_GetGroupName(), IDirectPlay2Impl_GetMessageCount(), IDirectPlay2Impl_GetPlayerAddress(), IDirectPlay2Impl_GetPlayerCaps(), IDirectPlay2Impl_GetPlayerData(), IDirectPlay2Impl_GetPlayerName(), IDirectPlay2Impl_GetSessionDesc(), IDirectPlay2Impl_Initialize(), IDirectPlay2Impl_Open(), IDirectPlay2Impl_QueryInterface(), IDirectPlay2Impl_Receive(), IDirectPlay2Impl_Release(), IDirectPlay2Impl_Send(), IDirectPlay2Impl_SetGroupData(), IDirectPlay2Impl_SetGroupName(), IDirectPlay2Impl_SetPlayerData(), IDirectPlay2Impl_SetPlayerName(), and IDirectPlay2Impl_SetSessionDesc().
◆ impl_from_IDirectPlay2A()
|
inlinestatic |
Definition at line 100 of file dplay.c.
102{
Referenced by IDirectPlay2AImpl_AddPlayerToGroup(), IDirectPlay2AImpl_AddRef(), IDirectPlay2AImpl_Close(), IDirectPlay2AImpl_CreateGroup(), IDirectPlay2AImpl_CreatePlayer(), IDirectPlay2AImpl_DeletePlayerFromGroup(), IDirectPlay2AImpl_DestroyGroup(), IDirectPlay2AImpl_DestroyPlayer(), IDirectPlay2AImpl_EnumGroupPlayers(), IDirectPlay2AImpl_EnumGroups(), IDirectPlay2AImpl_EnumPlayers(), IDirectPlay2AImpl_EnumSessions(), IDirectPlay2AImpl_GetCaps(), IDirectPlay2AImpl_GetGroupData(), IDirectPlay2AImpl_GetGroupName(), IDirectPlay2AImpl_GetMessageCount(), IDirectPlay2AImpl_GetPlayerAddress(), IDirectPlay2AImpl_GetPlayerCaps(), IDirectPlay2AImpl_GetPlayerData(), IDirectPlay2AImpl_GetPlayerName(), IDirectPlay2AImpl_GetSessionDesc(), IDirectPlay2AImpl_Initialize(), IDirectPlay2AImpl_Open(), IDirectPlay2AImpl_QueryInterface(), IDirectPlay2AImpl_Receive(), IDirectPlay2AImpl_Release(), IDirectPlay2AImpl_Send(), IDirectPlay2AImpl_SetGroupData(), IDirectPlay2AImpl_SetGroupName(), IDirectPlay2AImpl_SetPlayerData(), IDirectPlay2AImpl_SetPlayerName(), and IDirectPlay2AImpl_SetSessionDesc().
◆ impl_from_IDirectPlay3()
|
inlinestatic |
Definition at line 110 of file dplay.c.
112{
Referenced by IDirectPlay3Impl_AddGroupToGroup(), IDirectPlay3Impl_AddPlayerToGroup(), IDirectPlay3Impl_AddRef(), IDirectPlay3Impl_Close(), IDirectPlay3Impl_CreateGroup(), IDirectPlay3Impl_CreateGroupInGroup(), IDirectPlay3Impl_CreatePlayer(), IDirectPlay3Impl_DeleteGroupFromGroup(), IDirectPlay3Impl_DeletePlayerFromGroup(), IDirectPlay3Impl_DestroyGroup(), IDirectPlay3Impl_DestroyPlayer(), IDirectPlay3Impl_EnumConnections(), IDirectPlay3Impl_EnumGroupPlayers(), IDirectPlay3Impl_EnumGroups(), IDirectPlay3Impl_EnumGroupsInGroup(), IDirectPlay3Impl_EnumPlayers(), IDirectPlay3Impl_EnumSessions(), IDirectPlay3Impl_GetCaps(), IDirectPlay3Impl_GetGroupConnectionSettings(), IDirectPlay3Impl_GetGroupData(), IDirectPlay3Impl_GetGroupFlags(), IDirectPlay3Impl_GetGroupName(), IDirectPlay3Impl_GetGroupParent(), IDirectPlay3Impl_GetMessageCount(), IDirectPlay3Impl_GetPlayerAccount(), IDirectPlay3Impl_GetPlayerAddress(), IDirectPlay3Impl_GetPlayerCaps(), IDirectPlay3Impl_GetPlayerData(), IDirectPlay3Impl_GetPlayerFlags(), IDirectPlay3Impl_GetPlayerName(), IDirectPlay3Impl_GetSessionDesc(), IDirectPlay3Impl_Initialize(), IDirectPlay3Impl_InitializeConnection(), IDirectPlay3Impl_Open(), IDirectPlay3Impl_QueryInterface(), IDirectPlay3Impl_Receive(), IDirectPlay3Impl_Release(), IDirectPlay3Impl_SecureOpen(), IDirectPlay3Impl_Send(), IDirectPlay3Impl_SendChatMessage(), IDirectPlay3Impl_SetGroupConnectionSettings(), IDirectPlay3Impl_SetGroupData(), IDirectPlay3Impl_SetGroupName(), IDirectPlay3Impl_SetPlayerData(), IDirectPlay3Impl_SetPlayerName(), IDirectPlay3Impl_SetSessionDesc(), and IDirectPlay3Impl_StartSession().
◆ impl_from_IDirectPlay3A()
|
inlinestatic |
Definition at line 105 of file dplay.c.
107{
Referenced by IDirectPlay3AImpl_AddGroupToGroup(), IDirectPlay3AImpl_AddPlayerToGroup(), IDirectPlay3AImpl_AddRef(), IDirectPlay3AImpl_Close(), IDirectPlay3AImpl_CreateGroup(), IDirectPlay3AImpl_CreateGroupInGroup(), IDirectPlay3AImpl_CreatePlayer(), IDirectPlay3AImpl_DeleteGroupFromGroup(), IDirectPlay3AImpl_DeletePlayerFromGroup(), IDirectPlay3AImpl_DestroyGroup(), IDirectPlay3AImpl_DestroyPlayer(), IDirectPlay3AImpl_EnumConnections(), IDirectPlay3AImpl_EnumGroupPlayers(), IDirectPlay3AImpl_EnumGroups(), IDirectPlay3AImpl_EnumGroupsInGroup(), IDirectPlay3AImpl_EnumPlayers(), IDirectPlay3AImpl_EnumSessions(), IDirectPlay3AImpl_GetCaps(), IDirectPlay3AImpl_GetGroupConnectionSettings(), IDirectPlay3AImpl_GetGroupData(), IDirectPlay3AImpl_GetGroupFlags(), IDirectPlay3AImpl_GetGroupName(), IDirectPlay3AImpl_GetGroupParent(), IDirectPlay3AImpl_GetMessageCount(), IDirectPlay3AImpl_GetPlayerAccount(), IDirectPlay3AImpl_GetPlayerAddress(), IDirectPlay3AImpl_GetPlayerCaps(), IDirectPlay3AImpl_GetPlayerData(), IDirectPlay3AImpl_GetPlayerFlags(), IDirectPlay3AImpl_GetPlayerName(), IDirectPlay3AImpl_GetSessionDesc(), IDirectPlay3AImpl_Initialize(), IDirectPlay3AImpl_InitializeConnection(), IDirectPlay3AImpl_Open(), IDirectPlay3AImpl_QueryInterface(), IDirectPlay3AImpl_Receive(), IDirectPlay3AImpl_Release(), IDirectPlay3AImpl_SecureOpen(), IDirectPlay3AImpl_Send(), IDirectPlay3AImpl_SendChatMessage(), IDirectPlay3AImpl_SetGroupConnectionSettings(), IDirectPlay3AImpl_SetGroupData(), IDirectPlay3AImpl_SetGroupName(), IDirectPlay3AImpl_SetPlayerData(), IDirectPlay3AImpl_SetPlayerName(), IDirectPlay3AImpl_SetSessionDesc(), and IDirectPlay3AImpl_StartSession().
◆ impl_from_IDirectPlay4()
|
inlinestatic |
Definition at line 120 of file dplay.c.
122{
Referenced by IDirectPlay4Impl_AddGroupToGroup(), IDirectPlay4Impl_AddPlayerToGroup(), IDirectPlay4Impl_AddRef(), IDirectPlay4Impl_CancelMessage(), IDirectPlay4Impl_CancelPriority(), IDirectPlay4Impl_Close(), IDirectPlay4Impl_CreateGroup(), IDirectPlay4Impl_CreateGroupInGroup(), IDirectPlay4Impl_CreatePlayer(), IDirectPlay4Impl_DeleteGroupFromGroup(), IDirectPlay4Impl_DeletePlayerFromGroup(), IDirectPlay4Impl_DestroyGroup(), IDirectPlay4Impl_DestroyPlayer(), IDirectPlay4Impl_EnumConnections(), IDirectPlay4Impl_EnumGroupPlayers(), IDirectPlay4Impl_EnumGroupsInGroup(), IDirectPlay4Impl_EnumSessions(), IDirectPlay4Impl_GetGroupConnectionSettings(), IDirectPlay4Impl_GetGroupData(), IDirectPlay4Impl_GetGroupFlags(), IDirectPlay4Impl_GetGroupName(), IDirectPlay4Impl_GetGroupOwner(), IDirectPlay4Impl_GetGroupParent(), IDirectPlay4Impl_GetMessageQueue(), IDirectPlay4Impl_GetPlayerAccount(), IDirectPlay4Impl_GetPlayerAddress(), IDirectPlay4Impl_GetPlayerCaps(), IDirectPlay4Impl_GetPlayerData(), IDirectPlay4Impl_GetPlayerFlags(), IDirectPlay4Impl_GetPlayerName(), IDirectPlay4Impl_GetSessionDesc(), IDirectPlay4Impl_Initialize(), IDirectPlay4Impl_InitializeConnection(), IDirectPlay4Impl_QueryInterface(), IDirectPlay4Impl_Receive(), IDirectPlay4Impl_Release(), IDirectPlay4Impl_SecureOpen(), IDirectPlay4Impl_SendChatMessage(), IDirectPlay4Impl_SendEx(), IDirectPlay4Impl_SetGroupConnectionSettings(), IDirectPlay4Impl_SetGroupData(), IDirectPlay4Impl_SetGroupName(), IDirectPlay4Impl_SetGroupOwner(), IDirectPlay4Impl_SetPlayerData(), IDirectPlay4Impl_SetPlayerName(), IDirectPlay4Impl_SetSessionDesc(), and IDirectPlay4Impl_StartSession().
◆ impl_from_IDirectPlay4A()
|
inlinestatic |
Definition at line 115 of file dplay.c.
117{
Referenced by IDirectPlay4AImpl_AddGroupToGroup(), IDirectPlay4AImpl_AddPlayerToGroup(), IDirectPlay4AImpl_AddRef(), IDirectPlay4AImpl_CancelMessage(), IDirectPlay4AImpl_CancelPriority(), IDirectPlay4AImpl_Close(), IDirectPlay4AImpl_CreateGroup(), IDirectPlay4AImpl_CreateGroupInGroup(), IDirectPlay4AImpl_CreatePlayer(), IDirectPlay4AImpl_DeleteGroupFromGroup(), IDirectPlay4AImpl_DeletePlayerFromGroup(), IDirectPlay4AImpl_DestroyGroup(), IDirectPlay4AImpl_DestroyPlayer(), IDirectPlay4AImpl_EnumConnections(), IDirectPlay4AImpl_EnumGroupPlayers(), IDirectPlay4AImpl_EnumGroupsInGroup(), IDirectPlay4AImpl_EnumSessions(), IDirectPlay4AImpl_GetGroupConnectionSettings(), IDirectPlay4AImpl_GetGroupData(), IDirectPlay4AImpl_GetGroupFlags(), IDirectPlay4AImpl_GetGroupName(), IDirectPlay4AImpl_GetGroupOwner(), IDirectPlay4AImpl_GetGroupParent(), IDirectPlay4AImpl_GetMessageQueue(), IDirectPlay4AImpl_GetPlayerAccount(), IDirectPlay4AImpl_GetPlayerAddress(), IDirectPlay4AImpl_GetPlayerCaps(), IDirectPlay4AImpl_GetPlayerData(), IDirectPlay4AImpl_GetPlayerFlags(), IDirectPlay4AImpl_GetPlayerName(), IDirectPlay4AImpl_GetSessionDesc(), IDirectPlay4AImpl_Initialize(), IDirectPlay4AImpl_InitializeConnection(), IDirectPlay4AImpl_QueryInterface(), IDirectPlay4AImpl_Receive(), IDirectPlay4AImpl_Release(), IDirectPlay4AImpl_SecureOpen(), IDirectPlay4AImpl_SendChatMessage(), IDirectPlay4AImpl_SendEx(), IDirectPlay4AImpl_SetGroupConnectionSettings(), IDirectPlay4AImpl_SetGroupData(), IDirectPlay4AImpl_SetGroupName(), IDirectPlay4AImpl_SetGroupOwner(), IDirectPlay4AImpl_SetPlayerData(), IDirectPlay4AImpl_SetPlayerName(), IDirectPlay4AImpl_SetSessionDesc(), and IDirectPlay4AImpl_StartSession().
◆ WINE_DEFAULT_DEBUG_CHANNEL()
| WINE_DEFAULT_DEBUG_CHANNEL | ( | dplay | ) |
Variable Documentation
◆ dp2_vt
|
static |
Definition at line 5388 of file dplay.c.
Referenced by dplay_create().
◆ dp2A_vt
|
static |
Definition at line 5424 of file dplay.c.
Referenced by dplay_create().
◆ dp3_vt
|
static |
Definition at line 5460 of file dplay.c.
Referenced by dplay_create().
◆ dp3A_vt
|
static |
Definition at line 5511 of file dplay.c.
Referenced by dplay_create().
◆ dp4_vt
|
static |
Definition at line 5562 of file dplay.c.
Referenced by dplay_create().
◆ dp4A_vt
|
static |
Definition at line 5619 of file dplay.c.
Referenced by dplay_create().
◆ dp_vt
|
static |
Initial value:
=
{
}
static HRESULT WINAPI IDirectPlayImpl_SetPlayerName(IDirectPlay *iface, DPID player, LPSTR name, LPSTR fullname)
Definition: dplay.c:547
static HRESULT WINAPI IDirectPlayImpl_Close(IDirectPlay *iface)
Definition: dplay.c:393
static HRESULT WINAPI IDirectPlayImpl_CreatePlayer(IDirectPlay *iface, DPID *player, LPSTR name, LPSTR fullname, HANDLE *event)
Definition: dplay.c:400
static HRESULT WINAPI IDirectPlayImpl_Initialize(IDirectPlay *iface, GUID *guid)
Definition: dplay.c:510
static HRESULT WINAPI IDirectPlayImpl_Receive(IDirectPlay *iface, DPID *from, DPID *to, DWORD flags, void *data, DWORD *size)
Definition: dplay.c:524
static HRESULT WINAPI IDirectPlayImpl_AddPlayerToGroup(IDirectPlay *iface, DPID group, DPID player)
Definition: dplay.c:385
static HRESULT WINAPI IDirectPlayImpl_EnumGroupPlayers(IDirectPlay *iface, DPID group, LPDPENUMPLAYERSCALLBACK enumplayercb, void *context, DWORD flags)
Definition: dplay.c:446
static HRESULT WINAPI IDirectPlayImpl_DeletePlayerFromGroup(IDirectPlay *iface, DPID group, DPID player)
Definition: dplay.c:417
static HRESULT WINAPI IDirectPlayImpl_Open(IDirectPlay *iface, DPSESSIONDESC *sdesc)
Definition: dplay.c:517
static HRESULT WINAPI IDirectPlayImpl_CreateGroup(IDirectPlay *iface, DPID *group, LPSTR name, LPSTR fullname)
Definition: dplay.c:409
static HRESULT WINAPI IDirectPlayImpl_EnumGroups(IDirectPlay *iface, DWORD session, LPDPENUMPLAYERSCALLBACK enumplayercb, void *context, DWORD flags)
Definition: dplay.c:454
static HRESULT WINAPI IDirectPlayImpl_EnumSessions(IDirectPlay *iface, DPSESSIONDESC *sdesc, DWORD timeout, LPDPENUMSESSIONSCALLBACK enumsessioncb, void *context, DWORD flags)
Definition: dplay.c:470
static HRESULT WINAPI IDirectPlayImpl_EnableNewPlayers(IDirectPlay *iface, BOOL enable)
Definition: dplay.c:439
static HRESULT WINAPI IDirectPlayImpl_GetPlayerCaps(IDirectPlay *iface, DPID player, DPCAPS *caps)
Definition: dplay.c:494
static HRESULT WINAPI IDirectPlayImpl_DestroyPlayer(IDirectPlay *iface, DPID player)
Definition: dplay.c:425
static HRESULT WINAPI IDirectPlayImpl_GetMessageCount(IDirectPlay *iface, DPID player, DWORD *count)
Definition: dplay.c:486
static ULONG WINAPI IDirectPlayImpl_AddRef(IDirectPlay *iface)
Definition: dplay.c:359
static HRESULT WINAPI IDirectPlayImpl_GetPlayerName(IDirectPlay *iface, DPID player, LPSTR name, DWORD *size_name, LPSTR fullname, DWORD *size_fullname)
Definition: dplay.c:501
static HRESULT WINAPI IDirectPlayImpl_Send(IDirectPlay *iface, DPID from, DPID to, DWORD flags, void *data, DWORD size)
Definition: dplay.c:539
static ULONG WINAPI IDirectPlayImpl_Release(IDirectPlay *iface)
Definition: dplay.c:372
static HRESULT WINAPI IDirectPlayImpl_QueryInterface(IDirectPlay *iface, REFIID riid, void **ppv)
Definition: dplay.c:353
static HRESULT WINAPI IDirectPlayImpl_DestroyGroup(IDirectPlay *iface, DPID group)
Definition: dplay.c:432
static HRESULT WINAPI IDirectPlayImpl_EnumPlayers(IDirectPlay *iface, DWORD session, LPDPENUMPLAYERSCALLBACK enumplayercb, void *context, DWORD flags)
Definition: dplay.c:462
static HRESULT WINAPI IDirectPlayImpl_SaveSession(IDirectPlay *iface, LPSTR reserved)
Definition: dplay.c:532
static HRESULT WINAPI IDirectPlayImpl_GetCaps(IDirectPlay *iface, DPCAPS *caps)
Definition: dplay.c:479
Definition at line 556 of file dplay.c.
Referenced by dplay_create().
◆ kludgePlayerGroupId
|
static |
Definition at line 87 of file dplay.c.
Referenced by DP_NextObjectId().
