#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:2988
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 }
1787 else if ( ( <