#include <stdarg.h>#include <string.h>#include <limits.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 | 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 BOOL | connectionsInitialized |
| 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
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 2544 of file dplay.c.
2551{
2553
2555 {
2556 IDirectPlayX_DeletePlayerFromGroup( &lpCtxt->This->IDirectPlay4_iface, dpId, lpCtxt->idPlayer );
2557
2558 /* Enumerate all groups in this group since this will normally only
2559 * be called for top level groups
2560 */
2563
2564 }
2565 else
2566 {
2568 }
2569
struct _DPFAGContext * lpDPFAGContext
static BOOL CALLBACK cbDeletePlayerFromAllGroups(DPID dpId, DWORD dwPlayerType, LPCDPNAME lpName, DWORD dwFlags, LPVOID lpContext)
Definition: dplay.c:2544
#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:2481
Referenced by cbDeletePlayerFromAllGroups(), and DP_IF_DestroyPlayer().
◆ cbDPCreateEnumConnections()
|
static |
Definition at line 6610 of file dplay.c.
6618{
6620
6622 {
6624
6627
6628 /* Found the record that we were looking for */
6630 }
6631
6632 /* Haven't found what were looking for yet */
struct tagCreateEnum * lpCreateEnumData
Definition: dplay.c:6604
Referenced by DirectPlayCreate().
◆ cbRemoveGroupOrPlayer()
|
static |
Definition at line 2362 of file dplay.c.
2369{
2371
2373 dpId, dwPlayerType, lpCtxt->idGroup );
2374
2376 {
2378 lpCtxt->idGroup, dpId ) ) )
2380 }
2382 lpCtxt->idGroup, dpId ) ) )
2384
struct _DPRGOPContext * lpDPRGOPContext
#define IDirectPlayX_DeleteGroupFromGroup(p, a, b)
Definition: dplay.h:900
Definition: dplay.c:2355
Referenced by DP_IF_DestroyGroup().
◆ DirectPlayCreate()
| HRESULT WINAPI DirectPlayCreate | ( | LPGUID | lpGUID, |
| LPDIRECTPLAY * | lplpDP, | ||
| IUnknown * | pUnk | ||
| ) |
Definition at line 6640 of file dplay.c.
6643{
6645 LPDIRECTPLAY3A lpDP3A;
6647
6649
6651 {
6653 }
6654
6656 {
6658 }
6659
6662
6664 {
6665 /* The GUID_NULL means don't bind a service provider. Just return the
6666 interface as is */
6668 }
6669
6670 /* Bind the desired service provider since lpGUID is non NULL */
6672
6673 /* We're going to use a DP3 interface */
6675 (LPVOID*)&lpDP3A );
6677 {
6680 }
6681
6683 cbData.lpGuid = lpGUID;
6684
6685 /* We were given a service provider, find info about it... */
6690 )
6691 {
6693 IDirectPlayX_Release( lpDP3A );
6695 }
6696
6697 /* Initialize the service provider */
6700 {
6703 IDirectPlayX_Release( lpDP3A );
6705 }
6706
6707 /* Release our version of the interface now that we're done with it */
6708 IDirectPlayX_Release( lpDP3A );
6710
static BOOL CALLBACK cbDPCreateEnumConnections(LPCGUID lpguidSP, LPVOID lpConnection, DWORD dwConnectionSize, LPCDPNAME lpName, DWORD dwFlags, LPVOID lpContext)
Definition: dplay.c:6610
#define IDirectPlayX_EnumConnections(p, a, b, c, d)
Definition: dplay.h:901
#define IDirectPlayX_InitializeConnection(p, a, b)
Definition: dplay.h:904
Definition: metahost.idl:58
Definition: nsiface.idl:2307
◆ DirectPlayEnumerateA()
| HRESULT WINAPI DirectPlayEnumerateA | ( | LPDPENUMDPCALLBACKA | lpEnumCallback, |
| LPVOID | lpContext | ||
| ) |
Definition at line 6586 of file dplay.c.
6588{
6590
static HRESULT DirectPlayEnumerateAW(LPDPENUMDPCALLBACKA lpEnumCallbackA, LPDPENUMDPCALLBACKW lpEnumCallbackW, LPVOID lpContext)
Definition: dplay.c:6540
◆ DirectPlayEnumerateAW()
|
static |
Definition at line 6540 of file dplay.c.
6544{
6547
6548 if (!lpEnumCallbackA && !lpEnumCallbackW)
6549 {
6551 }
6552
6554
6556 {
6558 continue;
6559
6560 /* The enumeration will return FALSE if we are not to continue.
6561 *
6562 * Note: on my windows box, major / minor version is 6 / 0 for all service providers
6563 * and have no relation to any of the two dwReserved1 and dwReserved2 keys.
6564 * I think that it simply means that they are in-line with DirectX 6.0
6565 */
6566 if (lpEnumCallbackA)
6567 {
6569 lpContext))
6570 break;
6571 }
6572 else
6573 {
6575 lpContext))
6576 break;
6577 }
6578 }
6579
Definition: dplay_global.h:36
Referenced by DirectPlayEnumerateA(), and DirectPlayEnumerateW().
◆ DirectPlayEnumerateW()
| HRESULT WINAPI DirectPlayEnumerateW | ( | LPDPENUMDPCALLBACKW | lpEnumCallback, |
| LPVOID | lpContext | ||
| ) |
◆ DP_AddPlayerToGroup()
| HRESULT DP_AddPlayerToGroup | ( | IDirectPlayImpl * | This, |
| DPID | group, | ||
| DPID | player | ||
| ) |
Definition at line 1210 of file dplay.c.
1212{
1213 DPMSG_ADDPLAYERTOGROUP addPlayerToGroupMsg;
1214 lpGroupData gdata;
1216 lpPlayerList newplist;
1218
1219 /* Find the group */
1222
1223 /* Find the player */
1226
1227 /* Create a player list (ie "shortcut" ) */
1229 if ( !newplist )
1231
1232 /* Add the shortcut */
1233 plist->lpPData->uRef++;
1235
1236 /* Add the player to the list of players for this group */
1237 DPQ_INSERT(gdata->players, newplist, players);
1238
1239 /* Let the SP know that we've added a player to the group */
1241 {
1243
1245
1246 data.idPlayer = player;
1249
1252 {
1253 DPQ_REMOVE( gdata->players, newplist, players );
1254 --plist->lpPData->uRef;
1255 free( newplist );
1257 }
1258 }
1259
1262 addPlayerToGroupMsg.dpIdPlayer = player;
1263
1267 {
1269 {
1271 data.idPlayer = player;
1275 }
1276 DPQ_REMOVE( gdata->players, newplist, players );
1277 --plist->lpPData->uRef;
1278 free( newplist );
1280 }
1281
static lpGroupData DP_FindAnyGroup(IDirectPlayImpl *This, DPID dpid)
Definition: dplay.c:1554
static HRESULT DP_QueueMessage(IDirectPlayImpl *This, DPID fromId, DPID toId, DPID excludeId, void *msg, FN_COPY_MESSAGE *copyMessage, DWORD genericSize)
Definition: dplay.c:361
static DWORD DP_CopyGeneric(DPMSG_GENERIC *genericDst, DPMSG_GENERIC *genericSrc, DWORD genericSize, BOOL ansi)
Definition: dplay.c:390
static lpPlayerList DP_FindPlayer(IDirectPlayImpl *This, DPID dpid)
Definition: dplay.c:2002
Definition: dplay_global.h:111
Definition: dplay_global.h:103
Definition: dplay.h:1181
Definition: dplaysp.h:116
Definition: dplaysp.h:200
Referenced by DP_MSG_ForwardPlayerCreation(), and IDirectPlay4Impl_AddPlayerToGroup().
◆ DP_BuildSPCompoundAddr()
|
static |
Definition at line 4820 of file dplay.c.
4823{
4824 DPCOMPOUNDADDRESSELEMENT dpCompoundAddress;
4826
4828 dpCompoundAddress.guidDataType = DPAID_ServiceProvider;
4829 dpCompoundAddress.lpData = lpcSpGuid;
4830
4831 *lplpAddrBuf = NULL;
4832 *lpdwBufSize = 0;
4833
4835 lpdwBufSize, TRUE );
4836
4838 {
4841 }
4842
4843 /* Now allocate the buffer */
4844 *lplpAddrBuf = calloc( 1, *lpdwBufSize );
4845
4847 lpdwBufSize, TRUE );
4849 {
4851 free( *lplpAddrBuf );
4853 }
4854
HRESULT DPL_CreateCompoundAddress(LPCDPCOMPOUNDADDRESSELEMENT lpElements, DWORD dwElementCount, LPVOID lpAddress, LPDWORD lpdwAddressSize, BOOL bAnsiInterface)
Definition: dplobby.c:1109
Definition: shobjidl.idl:3066
Definition: dplobby.h:296
Referenced by DP_IF_EnumSessions().
◆ DP_CopyCreatePlayerOrGroup()
|
static |
Definition at line 401 of file dplay.c.
404{
408
411
413 {
415 {
418 }
420 }
421
422 offset += DP_CopyString( &dst->dpnName.lpszShortNameA, src->dpnName.lpszShortNameA, ansi, FALSE,
423 genericDst, offset );
425 genericDst, offset );
426
static DWORD DP_CopyString(char **dst, const void *src, BOOL dstAnsi, BOOL srcAnsi, void *buffer, DWORD offset)
Definition: dplay.c:260
struct tagDPMSG_CREATEPLAYERORGROUP DPMSG_CREATEPLAYERORGROUP
Definition: dplay.h:1147
Referenced by DP_CreatePlayer().
◆ DP_CopyGeneric()
|
static |
Definition at line 390 of file dplay.c.
393{
394 if ( !genericDst )
395 return genericSize;
396
397 memcpy( genericDst, genericSrc, genericSize );
398
399 return genericSize;
Referenced by DP_AddPlayerToGroup(), DP_HandleGameMessage(), and IDirectPlay4Impl_SendEx().
◆ DP_CopyName()
Definition at line 2016 of file dplay.c.
2018{
2020
2022 {
2024 {
2027 }
2029 }
2030
2032 {
2035 }
2036
2038 offset );
2040 offset );
2041
struct tagDPNAME DPNAME
Definition: dplay.h:187
Referenced by DP_DuplicateName(), DP_IF_GetGroupName(), and DP_IF_GetPlayerName().
◆ DP_CopySessionDesc()
|
static |
Definition at line 4563 of file dplay.c.
4566{
4568
4569 if( lpSessionDest )
4571
4573 dstAnsi, srcAnsi, lpSessionDest, offset );
4575 dstAnsi, srcAnsi, lpSessionDest, offset );
4576
struct tagDPSESSIONDESC2 DPSESSIONDESC2
Referenced by DP_DuplicateSessionDesc(), and DP_GetSessionDesc().
◆ DP_CopySetPlayerOrGroupData()
|
static |
Definition at line 429 of file dplay.c.
432{
436
439
441 {
443 {
446 }
448 }
449
struct tagDPMSG_SETPLAYERORGROUPDATA DPMSG_SETPLAYERORGROUPDATA
Definition: dplay.h:1198
Referenced by DP_HandleMessage().
◆ DP_CopyString()
|
static |
Definition at line 260 of file dplay.c.
262{
264 DWORD dstSize = 0;
266
268 {
271
272 return 0;
273 }
274
276 {
278 dstSize = INT_MAX;
279 *dst = dstPtr;
280 }
281
282 if ( dstAnsi == srcAnsi )
283 {
284 if ( srcAnsi )
286 else
288
289 if ( dstPtr )
291 }
292 else
293 {
294 if ( srcAnsi )
296 else
298 }
299
Referenced by DP_CopyCreatePlayerOrGroup(), DP_CopyName(), DP_CopySessionDesc(), and DP_DuplicateString().
◆ DP_CreateDirectPlay2()
Definition at line 122 of file dplay.c.
124{
126
129 {
131 }
132
134
136 This->dp2->dwEnumSessionLock = 0;
137
139
142
144 {
145 /* FIXME: Memory leak */
147 }
148
149 /* Provide an initial session desc with nothing in it */
152 {
153 /* FIXME: Memory leak */
155 }
157
158 /* We are emulating a dp 6 implementation */
160
164
165 /* This is the pointer to the service provider */
167 {
168 /* FIXME: Memory leak */
170 }
171
172 /* Setup lobby provider information */
176
178 )
179 {
180 /* FIXME: Memory leak */
182 }
183
HRESULT dplobbysp_create(REFIID riid, void **ppv, IDirectPlayImpl *dp)
Definition: lobbysp.c:230
HRESULT dplaysp_create(REFIID riid, void **ppv, IDirectPlayImpl *dp)
Definition: dplaysp.c:696
BOOL NS_InitializeSessionCache(LPVOID *lplpNSInfo)
Definition: name_server.c:262
Definition: dplay_global.h:215
Referenced by dplay_create().
◆ DP_CreateGroup()
| HRESULT DP_CreateGroup | ( | IDirectPlayImpl * | This, |
| void * | msgHeader, | ||
| const DPID * | lpid, | ||
| const DPNAME * | lpName, | ||
| void * | data, | ||
| DWORD | dataSize, | ||
| DWORD | dwFlags, | ||
| DPID | idParent, | ||
| BOOL | bAnsi | ||
| ) |
Definition at line 1386 of file dplay.c.
1390{
1393 lpGroupData lpGData;
1395
1397 {
1401 }
1402
1403 /* Allocate the new space and add to end of high level group list */
1405
1407 {
1409 }
1410
1411 DPQ_INIT(lpGData->groups);
1412 DPQ_INIT(lpGData->players);
1413
1414 /* Set the desired player ID - no sanity checking to see if it exists */
1415 lpGData->dpid = *lpid;
1416
1419 {
1420 free( lpGData );
1422 }
1423
1426 {
1428 free( lpGData );
1430 }
1431
1432 lpGData->parent = idParent;
1433
1434 /* FIXME: Should we validate the dwFlags? */
1436
1437 /* Initialize the SP data section */
1440 {
1443 free( lpGData );
1445 }
1446
1448 {
1449 This->dp2->lpSysGroup = lpGData;
1451 }
1452 else
1453 {
1454 /* Insert into the parent group */
1456 if( !groupList )
1457 {
1460 free( lpGData );
1462 }
1463 groupList->lpGData = lpGData;
1464
1466 }
1467
1468 /* Something is now referencing this data */
1469 lpGData->uRef++;
1470
1472
1473 /* FIXME: We should only create the system group if GetCaps returns
1474 * DPCAPS_GROUPOPTIMIZED.
1475 */
1476
1477 /* Let the SP know that we've created this group */
1479 {
1481 DWORD dwCreateFlags = 0;
1482
1484
1486 dwCreateFlags |= DPLAYI_GROUP_SYSGROUP;
1487
1488 if( !msgHeader )
1489 dwCreateFlags |= DPLAYI_PLAYER_PLAYERLOCAL;
1490
1492 dwCreateFlags |= DPLAYI_GROUP_HIDDEN;
1493
1494 data.idGroup = *lpid;
1495 data.dwFlags = dwCreateFlags;
1496 data.lpSPMessageHeader = msgHeader;
1498
1501 {
1502 if( groupList )
1503 {
1505 free( groupList );
1506 }
1507 else
1508 {
1510 }
1513 free( lpGData );
1515 }
1516 }
1517
1519
static void DP_SetGroupData(lpGroupData lpGData, DWORD dwFlags, LPVOID lpData, DWORD dwDataSize)
Definition: dplay.c:1707
static DPNAME * DP_DuplicateName(const DPNAME *src, BOOL dstAnsi, BOOL srcAnsi)
Definition: dplay.c:2044
Definition: dplay_global.h:143
Definition: dplaysp.h:128
Referenced by DP_IF_CreateGroup(), DP_IF_CreateGroupInGroup(), and DP_MSG_ForwardPlayerCreation().
◆ DP_CreatePlayer()
| HRESULT DP_CreatePlayer | ( | IDirectPlayImpl * | This, |
| void * | msgHeader, | ||
| DPID * | lpid, | ||
| DPNAME * | lpName, | ||
| void * | data, | ||
| DWORD | dataSize, | ||
| void * | spData, | ||
| DWORD | spDataSize, | ||
| DWORD | dwFlags, | ||
| HANDLE | hEvent, | ||
| struct PlayerData ** | playerData, | ||
| BOOL | bAnsi | ||
| ) |
Definition at line 1823 of file dplay.c.
1827{
1828 lpPlayerData lpPData;
1829 lpPlayerList lpPList;
1831
1833
1834 /* Allocate the storage for the player and associate it with list element */
1838
1839 /* Set the desired player ID */
1840 lpPData->dpid = *lpid;
1841
1844 {
1845 free( lpPData );
1847 }
1848
1851 {
1853 free( lpPData );
1855 }
1856
1858
1859 /* If we were given an event handle, duplicate it */
1861 {
1865 )
1866 {
1867 /* FIXME: Memory leak */
1869 }
1870 }
1871
1872 /* Initialize the SP data section */
1874
1875 /* Create the list object and link it in */
1877 if( !lpPList )
1878 {
1883 free( lpPData );
1885 }
1886
1887 lpPData->uRef = 1;
1888 lpPList->lpPData = lpPData;
1889
1890 /* Add the player to the system group */
1892
1894
1896 DPSET_REMOTE );
1898 {
1901 free( lpPList );
1906 free( lpPData );
1908 }
1909
1912 {
1915 free( lpPList );
1920 free( lpPData );
1922 }
1923
1925 {
1927 DWORD currentPlayers;
1928
1929 currentPlayers = This->dp2->lpSessionDesc->dwCurrentPlayers;
1931 ++currentPlayers;
1932
1935 msg.dpId = *lpid;
1936 msg.dwCurrentPlayers = currentPlayers;
1940 msg.dpIdParent = 0;
1942
1944 DP_CopyCreatePlayerOrGroup, 0 );
1946 {
1951 free( lpPList );
1955 free( lpPData );
1957 }
1958
1959 This->dp2->lpSessionDesc->dwCurrentPlayers++;
1960 }
1961
1963
1964 if( playerData )
1965 *playerData = lpPData;
1966
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
static HRESULT DP_CreateSPPlayer(IDirectPlayImpl *This, DPID dpid, DWORD flags, void *msgHeader)
Definition: dplay.c:1748
static DWORD DP_CopyCreatePlayerOrGroup(DPMSG_GENERIC *genericDst, DPMSG_GENERIC *genericSrc, DWORD genericSize, BOOL ansi)
Definition: dplay.c:401
static void DP_SetPlayerData(lpPlayerData lpPData, DWORD dwFlags, LPVOID lpData, DWORD dwDataSize)
Definition: dplay.c:2061
static void DP_DeleteSPPlayer(IDirectPlayImpl *This, DPID dpid)
Definition: dplay.c:1803
#define IDirectPlaySP_SetSPPlayerData(p, a, b, c, d)
Definition: dplaysp.h:106
Definition: dplay_global.h:77
#define DUPLICATE_SAME_ACCESS
Referenced by DP_HandleMessage(), DP_IF_CreatePlayer(), DP_MSG_ForwardPlayerCreation(), and DP_SecureOpen().
◆ DP_CreateSPPlayer()
|
static |
Definition at line 1748 of file dplay.c.
1750{
1752
1753 /* Let the SP know that we've created this player */
1755 {
1757
1758 data.idPlayer = dpid;
1760 data.lpSPMessageHeader = msgHeader;
1762
1764 msgHeader );
1765
1768 {
1771 }
1772 }
1773
1774 /* Now let the SP know that this player is a member of the system group */
1776 {
1778
1779 data.idPlayer = dpid;
1782
1784
1787 {
1790 {
1792 data.idPlayer = dpid;
1793 data.dwFlags = 0;
1796 }
1798 }
1799 }
1800
Definition: dplaysp.h:136
Definition: dplaysp.h:151
Referenced by DP_CreatePlayer().
◆ DP_DeleteGroup()
|
static |
Definition at line 1523 of file dplay.c.
1525{
1526 lpGroupList lpGList;
1527
1529
1531
1533 {
1535 return;
1536 }
1537
1539 {
1541 DebugBreak();
1542 }
1543
1544 /* Delete player */
1549
1550 /* Remove and Delete Player List object */
1551 free( lpGList );
1552
#define DPQ_REMOVE_ENTRY(head, elm, field, fieldCompareOperator, fieldToCompare, rc)
Definition: dplayx_queue.h:162
void WINAPI DebugBreak(void)
Referenced by DP_IF_DestroyGroup().
◆ DP_DeletePlayer()
|
static |
Definition at line 1970 of file dplay.c.
1972{
1973 lpPlayerList lpPList;
1974
1976
1978
1980 {
1982 return;
1983 }
1984
1985 /* Verify that this is the last reference to the data */
1987 {
1989 DebugBreak();
1990 }
1991
1992 /* Delete player */
1995
1998
1999 /* Delete Player List object */
2000 free( lpPList );
Referenced by DP_IF_DestroyPlayer(), and DP_SecureOpen().
◆ DP_DeleteSPPlayer()
|
static |
◆ DP_DestroyDirectPlay2()
Definition at line 193 of file dplay.c.
195{
197
199 {
202 }
203
204 /* Finish with the SP - have it shutdown */
206 {
208
210
212
214 }
216 {
218 (*This->dp2->spData.lpCB->Shutdown)();
219 }
220
221 /* Unload the SP (if it exists) */
223 {
225 }
226
227 /* Unload the Lobby Provider (if it exists) */
229 {
231 }
232
233 /* FIXME: Need to delete receive and send msgs queue contents */
234
236
239
241
242 /* Delete the contents */
244
BOOL WINAPI TerminateThread(IN HANDLE hThread, IN DWORD dwExitCode)
Definition: thread.c:587
Definition: dplaysp.h:291
Referenced by dplay_destroy().
◆ DP_DuplicateName()
Definition at line 2044 of file dplay.c.
2046{
2049
2051
2055
2057
static DWORD DP_CopyName(DPNAME *dst, const DPNAME *src, BOOL dstAnsi, BOOL srcAnsi)
Definition: dplay.c:2016
Referenced by DP_CreateGroup(), DP_CreatePlayer(), DP_IF_SetGroupName(), and DP_IF_SetPlayerName().
◆ DP_DuplicateSessionDesc()
| DPSESSIONDESC2 * DP_DuplicateSessionDesc | ( | const DPSESSIONDESC2 * | src, |
| BOOL | dstAnsi, | ||
| BOOL | srcAnsi | ||
| ) |
Definition at line 4579 of file dplay.c.
4581{
4584
4586
4590
4592
static DWORD DP_CopySessionDesc(LPDPSESSIONDESC2 destSessionDesc, LPCDPSESSIONDESC2 srcSessDesc, BOOL dstAnsi, BOOL srcAnsi)
Definition: dplay.c:4563
Definition: dplay.h:231
Referenced by DP_SecureOpen(), DP_SetSessionDesc(), and NS_AddRemoteComputerAsNameServer().
◆ DP_DuplicateString()
Definition at line 302 of file dplay.c.
304{
307
310
312
316
318
Referenced by DP_GetRegString(), DP_IF_EnumSessions(), and DP_SecureOpen().
◆ DP_EnumSessionsSendAsyncRequestThread()
Definition at line 2827 of file dplay.c.
2829{
2833
2835
2836 for( ;; )
2837 {
2839
2840 /* Sleep up to dwTimeout waiting for request to terminate thread */
2842 {
2844 break;
2845 }
2846
2847 /* Now resend the enum request */
2849 data->dwEnumSessionFlags,
2850 data->password,
2851 data->lpSpData );
2852
2854 {
2856 /* FIXME: Should we kill this thread? How to inform the main thread? */
2857 }
2858
2859 }
2860
2862
2863 /* Clean up the thread data */
2864 CloseHandle( hSuicideRequest );
2866 free( lpContext );
2867
2868 /* FIXME: Need to have some notification to main app thread that this is
2869 * dead. It would serve two purposes. 1) allow sync on termination
2870 * so that we don't actually send something to ourselves when we
2871 * become name server (race condition) and 2) so that if we die
2872 * abnormally something else will be able to tell.
2873 */
2874
2875 return 1;
HRESULT NS_SendSessionRequestBroadcast(LPCGUID lpcGuid, DWORD dwFlags, WCHAR *password, const SPINITDATA *lpSpData)
Definition: name_server.c:192
Definition: dplay_global.h:51
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
Referenced by DP_IF_EnumSessions().
◆ DP_FindAnyGroup()
|
static |
Definition at line 1554 of file dplay.c.
1556{
1557 lpGroupList lpGroups;
1558
1560
1562 {
1564 }
1565
1568
1570
1572 {
1574 }
1575
#define DPQ_FIND_ENTRY(head, elm, field, fieldCompareOperator, fieldToCompare, rc)
Definition: dplayx_queue.h:100
Referenced by DP_AddPlayerToGroup(), DP_CreateGroup(), DP_GetSPPlayerData(), DP_HandleMessage(), DP_IF_DestroyGroup(), DP_IF_EnumGroupPlayers(), DP_IF_EnumGroupsInGroup(), DP_IF_GetGroupName(), DP_IF_SetGroupName(), DP_QueueMessage(), DP_SetSPPlayerData(), IDirectPlay4Impl_AddGroupToGroup(), IDirectPlay4Impl_DeleteGroupFromGroup(), IDirectPlay4Impl_DeletePlayerFromGroup(), IDirectPlay4Impl_GetGroupData(), IDirectPlay4Impl_GetGroupParent(), IDirectPlay4Impl_SendEx(), and IDirectPlay4Impl_SetGroupData().
◆ DP_FindPlayer()
|
static |
Definition at line 2002 of file dplay.c.
Referenced by DP_AddPlayerToGroup(), DP_GetSPPlayerData(), DP_IF_DestroyPlayer(), DP_IF_GetPlayerName(), DP_IF_SetPlayerName(), DP_QueueMessage(), DP_SetSPPlayerData(), IDirectPlay4Impl_DeletePlayerFromGroup(), IDirectPlay4Impl_GetMessageQueue(), IDirectPlay4Impl_GetPlayerData(), IDirectPlay4Impl_SendEx(), and IDirectPlay4Impl_SetPlayerData().
◆ DP_FreeConnections()
Definition at line 5133 of file dplay.c.
5135{
5137
5139 return;
5140
5142
5144 {
5146
5153 }
__WINE_SERVER_LIST_INLINE struct list * list_tail(const struct list *list)
Definition: list.h:139
Referenced by DllMain().
◆ DP_GetConnections()
Definition at line 5123 of file dplay.c.
5125{
5128
5130
BOOL WINAPI InitOnceExecuteOnce(_Inout_ PINIT_ONCE InitOnce, _In_ __callback PINIT_ONCE_FN InitFn, _Inout_opt_ PVOID Parameter, _Outptr_opt_result_maybenull_ LPVOID *Context)
Definition: InitOnce.c:12
static BOOL WINAPI DP_InitConnections(INIT_ONCE *initOnce, void *param, void **context)
Definition: dplay.c:5108
Referenced by DirectPlayEnumerateAW(), DP_FreeConnections(), DP_IF_EnumConnections(), and DP_LoadSP().
◆ DP_GetRegDword()
Definition at line 4923 of file dplay.c.
4925{
4928
4931
4935
4937 {
4940 }
4941
4943 {
4946 }
4947
4949
LSTATUS WINAPI RegGetValueW(HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData)
Definition: reg.c:1931
Definition: pdh_main.c:64
Referenced by DP_ReadConnections().
◆ DP_GetRegString()
|
static |
Definition at line 4873 of file dplay.c.
4876{
4880
4883 else
4885
4887 {
4891
4894 else
4896
4898 {
4899 *outValue = value;
4901 }
4902
4904 }
4905
4909
4910 *outValue = value;
static LSTATUS(WINAPI *pRegDeleteTreeW)(HKEY
LSTATUS WINAPI RegGetValueA(HKEY hKey, LPCSTR pszSubKey, LPCSTR pszValue, DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData)
Definition: reg.c:2037
static void * DP_DuplicateString(const void *src, BOOL dstAnsi, BOOL srcAnsi)
Definition: dplay.c:302
Referenced by DP_GetRegStringA(), and DP_GetRegStringW().
◆ DP_GetRegStringA()
|
static |
Definition at line 4918 of file dplay.c.
4920{
static BOOL DP_GetRegString(HKEY key, const void *name, const char *defaultValue, void **outValue, BOOL ansi)
Definition: dplay.c:4873
Referenced by DP_ReadConnections().
◆ DP_GetRegStringW()
|
static |
◆ DP_GetRemoteNextObjectId()
Definition at line 2249 of file dplay.c.
2251{
2253
2254 /* Hack solution */
Referenced by DP_IF_CreateGroup().
◆ DP_GetSessionDesc()
|
static |
Definition at line 3618 of file dplay.c.
3621{
3622 DWORD dwRequiredSize;
3623
3625
3627 {
3629 }
3630
3632 {
3634 }
3635
3637
3639
3641 ( *lpdwDataSize < dwRequiredSize )
3642 )
3643 {
3644 *lpdwDataSize = dwRequiredSize;
3647 }
3648
3650
3652
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
Referenced by IDirectPlay4AImpl_GetSessionDesc(), and IDirectPlay4Impl_GetSessionDesc().
◆ DP_GetSpLpGuidFromCompoundAddress()
|
static |
Definition at line 5317 of file dplay.c.
5323{
5324 /* Looking for the GUID of the provider to load */
5326 ( IsEqualGUID( guidDataType, &DPAID_LobbyProvider ) )
5327 )
5328 {
5331
5333 {
5335 }
5336
5337 memcpy( lpContext, lpData, dwDataSize );
5338
5339 /* There shouldn't be more than 1 GUID/compound address */
5341 }
5342
5343 /* Still waiting for what we want */
Referenced by IDirectPlay4Impl_InitializeConnection().
◆ DP_GetSPPlayerData()
| HRESULT DP_GetSPPlayerData | ( | IDirectPlayImpl * | lpDP, |
| DPID | idPlayer, | ||
| void ** | lplpData | ||
| ) |
Definition at line 6462 of file dplay.c.
6464{
6466 lpPlayerList lpPlayer;
6467
6469
6470 lpPlayer = DP_FindPlayer( lpDP, idPlayer );
6471 if( lpPlayer )
6472 {
6476 }
6477
6480 {
6481 *lplpData = group->lpSPPlayerData;
6484 }
6485
6487
Referenced by IDirectPlaySPImpl_GetSPPlayerData(), and IDirectPlaySPImpl_SetSPPlayerData().
◆ DP_HandleGameMessage()
| HRESULT DP_HandleGameMessage | ( | IDirectPlayImpl * | This, |
| void * | messageBody, | ||
| DWORD | messageBodySize, | ||
| DPID | fromId, | ||
| DPID | toId | ||
| ) |
Definition at line 695 of file dplay.c.
698{
700 DWORD msgSize;
702
703 TRACE( "(%p)->(%p,0x%08lx,0x%08lx,0x%08lx)\n", This, messageBody, messageBodySize, fromId, toId );
704
707
709
711
713
struct tagDPMSG_SYSMSGENVELOPE DPMSG_SYSMSGENVELOPE
Definition: dplay.h:1140
Referenced by IDirectPlaySPImpl_HandleMessage().
◆ DP_HandleMessage()
| HRESULT DP_HandleMessage | ( | IDirectPlayImpl * | This, |
| void * | messageBody, | ||
| DWORD | dwMessageBodySize, | ||
| void * | messageHeader, | ||
| WORD | wCommandId, | ||
| WORD | wVersion, | ||
| void ** | lplpReply, | ||
| DWORD * | lpdwMsgSize | ||
| ) |
Definition at line 453 of file dplay.c.
457{
459 This, messageBody, dwMessageBodySize, messageHeader, wCommandId,
460 wVersion );
461
462 switch( wCommandId )
463 {
464 /* Name server needs to handle this request */
466 /* Reply expected */
468 break;
469
470 /* Name server needs to handle this request */
473
474 /* No reply expected */
475 NS_AddRemoteComputerAsNameServer( messageHeader,
476 This->dp2->spData.dwSPHeaderSize,
477 messageBody,
478 dwMessageBodySize,
479 This->dp2->lpNameServerData );
480
482 break;
483
485 {
486 LPCDPMSG_REQUESTNEWPLAYERID lpcMsg = messageBody;
487
488 LPDPMSG_NEWPLAYERIDREPLY lpReply;
489
491
492 *lplpReply = calloc( 1, *lpdwMsgSize );
493
495 lpcMsg->dwFlags );
496
497 /* Setup the reply */
499 This->dp2->spData.dwSPHeaderSize );
500
504
506
508 lpReply->dpidNewPlayerId );
509 break;
510 }
511
514 DPPLAYERINFO playerInfo;
517
522
526
529
531
533 {
536 }
537
542
544 {
547 }
548
550
551 break;
552 }
553
559 break;
560
562 DPMSG_SETPLAYERORGROUPDATA setPlayerOrGroupDataMsg;
567
571
572 if( dwMessageBodySize < msg->dataOffset )
577
579
581 {
584 }
585
588 {
591 }
592
594
600
602 DP_CopySetPlayerOrGroupData, 0 );
604 {
607 }
608
610
611 break;
612 }
613
615 TRACE( "GOT THE SELF MESSAGE: %p -> 0x%08lx\n", messageHeader, ((const DWORD *)messageHeader)[1] );
618
622 break;
623
626
630
632
634 {
637 }
638
640
642
643 break;
644 }
645
648 DPPLAYERINFO playerInfo;
651
656
660
662
664 {
667 }
668
674 {
677 }
678
680
682
683 break;
684 }
685
686 default:
688 break;
689 }
690
691 /* FIXME: There is code in dplaysp.c to handle dplay commands. Move to here. */
692
HRESULT DP_CreatePlayer(IDirectPlayImpl *This, void *msgHeader, DPID *lpid, DPNAME *lpName, void *data, DWORD dataSize, void *spData, DWORD spDataSize, DWORD dwFlags, HANDLE hEvent, struct PlayerData **playerData, BOOL bAnsi)
Definition: dplay.c:1823
static DWORD DP_CopySetPlayerOrGroupData(DPMSG_GENERIC *genericDst, DPMSG_GENERIC *genericSrc, DWORD genericSize, BOOL ansi)
Definition: dplay.c:429
HRESULT DP_MSG_ReadPackedPlayer(char *data, DWORD *inoutOffset, DWORD maxSize, DPPLAYERINFO *playerInfo)
Definition: dplayx_messages.c:376
void DP_MSG_ReplyReceived(IDirectPlayImpl *This, WORD wCommandId, const void *lpcMsgBody, DWORD dwMsgBodySize, const void *msgHeader)
Definition: dplayx_messages.c:1009
void DP_MSG_ToSelf(IDirectPlayImpl *This, DPID dpidSelf)
Definition: dplayx_messages.c:1046
HRESULT DP_MSG_SendPingReply(IDirectPlayImpl *This, DPID toId, DPID fromId, DWORD tickCount)
Definition: dplayx_messages.c:877
HRESULT DP_MSG_SendAddForwardAck(IDirectPlayImpl *This, DPID id)
Definition: dplayx_messages.c:918
#define DPMSGCMD_SUPERENUMPLAYERSREPLY
Definition: dplayx_messages.h:119
struct tagDPMSG_CREATESESSION DPMSG_CREATESESSION
struct tagDPMSG_NEWPLAYERIDREPLY * LPDPMSG_NEWPLAYERIDREPLY
void NS_ReplyToEnumSessionsRequest(const void *lpcMsg, void **lplpReplyData, DWORD *lpdwReplySize, IDirectPlayImpl *lpDP)
Definition: name_server.c:371
void NS_AddRemoteComputerAsNameServer(LPCVOID lpcNSAddrHdr, DWORD dwHdrSize, LPCDPMSG_ENUMSESSIONSREPLY lpcMsg, DWORD msgSize, LPVOID lpNSInfo)
Definition: name_server.c:101
void NS_SetLocalAddr(LPVOID lpNSInfo, LPCVOID lpHdr, DWORD dwHdrSize)
Definition: name_server.c:180
Definition: dplayx_messages.h:32
Definition: dplayx_messages.h:321
Definition: dplayx_messages.h:248
Definition: dplayx_messages.h:296
Definition: dplayx_messages.h:203
Definition: dplayx_messages.h:225
Definition: dplayx_messages.h:215
Referenced by IDirectPlaySPImpl_HandleMessage().
◆ DP_IF_CreateGroup()
|
static |
Definition at line 1578 of file dplay.c.
1581{
1583
1585 This, lpMsgHdr, lpidGroup, lpGroupName, lpData, dwDataSize,
1586 dwFlags, bAnsi );
1587
1589 {
1591 }
1592
1594
1595 /* If the name is not specified, we must provide one */
1597 {
1598 /* If we are the name server, we decide on the group ids. If not, we
1599 * must ask for one before attempting a creation.
1600 */
1602 {
1603 *lpidGroup = DP_NextObjectId();
1604 }
1605 else
1606 {
1607 *lpidGroup = DP_GetRemoteNextObjectId();
1608 }
1609 }
1610
1612 DPID_NOPARENT_GROUP, bAnsi );
1613
1615 {
1618 }
1619
1620 /* Inform all other peers of the creation of a new group. If there are
1621 * no peers keep this event quiet.
1622 * Also if this message was sent to us, don't rebroadcast.
1623 */
1625 This->dp2->lpSessionDesc &&
1627 {
1630
1632 msg.dpId = *lpidGroup;
1634 msg.lpData = lpData;
1635 msg.dwDataSize = dwDataSize;
1636 msg.dpnName = *lpGroupName;
1639
1640 /* FIXME: Correct to just use send effectively? */
1641 /* FIXME: Should size include data w/ message or just message "header" */
1642 /* FIXME: Check return code */
1645 }
1646
1648
HRESULT DP_CreateGroup(IDirectPlayImpl *This, void *msgHeader, const DPID *lpid, const DPNAME *lpName, void *data, DWORD dataSize, DWORD dwFlags, DPID idParent, BOOL bAnsi)
Definition: dplay.c:1386
Referenced by DP_SecureOpen(), IDirectPlay4AImpl_CreateGroup(), IDirectPlay4Impl_CreateGroup(), and IDirectPlaySPImpl_HandleMessage().
◆ DP_IF_CreateGroupInGroup()
|
static |
Definition at line 4665 of file dplay.c.
4669{
4671
4673 This, idParentGroup, lpidGroup, lpGroupName, lpData,
4674 dwDataSize, dwFlags, bAnsi );
4675
4677 {
4679 }
4680
4682
4684 idParentGroup, bAnsi );
4685
4687 {
4690 }
4691
4692 /* Inform all other peers of the creation of a new group. If there are
4693 * no peers keep this quiet.
4694 */
4697 {
4699
4702 msg.dpId = *lpidGroup;
4704 msg.lpData = lpData;
4705 msg.dwDataSize = dwDataSize;
4706 msg.dpnName = *lpGroupName;
4707
4708 /* FIXME: Correct to just use send effectively? */
4709 /* FIXME: Should size include data w/ message or just message "header" */
4710 /* FIXME: Check return code */
4713 }
4714
4716
Referenced by IDirectPlay4AImpl_CreateGroupInGroup(), IDirectPlay4Impl_CreateGroupInGroup(), and IDirectPlaySPImpl_HandleMessage().
◆ DP_IF_CreatePlayer()
|
static |
Definition at line 2103 of file dplay.c.
2107{
2110 DWORD dwCreateFlags;
2111
2114 dwDataSize, dwFlags, bAnsi );
2116 {
2118 }
2119
2122 {
2125 }
2127
2129 {
2131 }
2132
2133
2134 /* Determine the creation flags for the player. These will be passed
2135 * to the name server if requesting a player id and to the SP when
2136 * informing it of the player creation
2137 */
2139
2140 /* Verify we know how to handle all the flags */
2143 )
2144 )
2145 {
2146 /* Assume non fatal failure */
2148 }
2149
2150 /* If the name is not specified, we must provide one */
2152 {
2153 /* If we are the session master, we dish out the group/player ids */
2155 {
2156 *lpidPlayer = DP_NextObjectId();
2157 }
2158 else
2159 {
2161
2163 {
2166 }
2167 }
2168 }
2169 else
2170 {
2171 /* FIXME: Would be nice to perhaps verify that we don't already have
2172 * this player.
2173 */
2174 *lpidPlayer = DPID_SERVERPLAYER;
2175 }
2176
2178
2179 /* We pass creation flags, so we can distinguish sysplayers and not count them in the current
2180 player total */
2182 dwCreateFlags, hEvent, &player, bAnsi );
2184 {
2187 }
2188
2190 lpData, dwDataSize, This->dp2->systemPlayerId );
2192 {
2195 }
2196
2198
HRESULT DP_MSG_SendRequestPlayerId(IDirectPlayImpl *This, DWORD dwFlags, DPID *lpdpidAllocatedId)
Definition: dplayx_messages.c:231
HRESULT DP_MSG_SendCreatePlayer(IDirectPlayImpl *This, DPID toId, DPID id, DWORD flags, DPNAME *name, void *playerData, DWORD playerDataSize, DPID systemPlayerId)
Definition: dplayx_messages.c:746
Referenced by IDirectPlay4AImpl_CreatePlayer(), IDirectPlay4Impl_CreatePlayer(), and IDirectPlaySPImpl_HandleMessage().
◆ DP_IF_DestroyGroup()
|
static |
Definition at line 2387 of file dplay.c.
2389{
2390 lpGroupData lpGData;
2392
2394 This, lpMsgHdr, idGroup, bAnsi );
2395
2397
2398 /* Find the group */
2400 {
2403 }
2404
2406 context.bAnsi = bAnsi;
2407 context.idGroup = idGroup;
2408
2409 /* Remove all players that this group has */
2410 IDirectPlayX_EnumGroupPlayers( &This->IDirectPlay4_iface, idGroup, NULL, cbRemoveGroupOrPlayer,
2411 &context, 0 );
2412
2413 /* Remove all links to groups that this group has since this is dp3 */
2414 IDirectPlayX_EnumGroupsInGroup( &This->IDirectPlay4_iface, idGroup, NULL, cbRemoveGroupOrPlayer,
2416
2417 /* Remove this group from the parent group - if it has one */
2420
2421 /* Now delete this group data and list from the system group */
2423
2424 /* Let the SP know that we've destroyed this group */
2426 {
2428
2430
2431 data.idGroup = idGroup;
2432 data.dwFlags = 0;
2434
2436 }
2437
2439
2441
static BOOL CALLBACK cbRemoveGroupOrPlayer(DPID dpId, DWORD dwPlayerType, LPCDPNAME lpName, DWORD dwFlags, LPVOID lpContext)
Definition: dplay.c:2362
#define IDirectPlayX_EnumGroupPlayers(p, a, b, c, d, e)
Definition: dplay.h:875
Definition: http.c:7252
Definition: dplaysp.h:144
Referenced by DP_SecureOpen(), IDirectPlay4AImpl_DestroyGroup(), IDirectPlay4Impl_DestroyGroup(), and IDirectPlaySPImpl_HandleMessage().
◆ DP_IF_DestroyPlayer()
|
static |
Definition at line 2487 of file dplay.c.
2490{
2491 DPFAGContext cbContext;
2492
2494 This, lpMsgHdr, idPlayer, bAnsi );
2495
2497 {
2499 }
2500
2502
2504 {
2507 }
2508
2509 /* FIXME: If the player is remote, we must be the host to delete this */
2510
2512 cbContext.idPlayer = idPlayer;
2513 cbContext.bAnsi = bAnsi;
2514
2515 /* Find each group and call DeletePlayerFromGroup if the player is a
2516 member of the group */
2517 IDirectPlayX_EnumGroups( &This->IDirectPlay4_iface, NULL, cbDeletePlayerFromAllGroups, &cbContext,
2518 DPENUMGROUPS_ALL );
2519
2520 /* Now delete player and player list from the sys group */
2522
2523 /* Let the SP know that we've destroyed this group */
2525 {
2527
2529
2530 data.idPlayer = idPlayer;
2531 data.dwFlags = 0;
2533
2535 }
2536
2538
2540
static void DP_DeletePlayer(IDirectPlayImpl *This, DPID dpid)
Definition: dplay.c:1970
Referenced by IDirectPlay4AImpl_DestroyPlayer(), IDirectPlay4Impl_DestroyPlayer(), and IDirectPlaySPImpl_HandleMessage().
◆ DP_IF_EnumConnections()
|
static |
Definition at line 5155 of file dplay.c.
5159{
5162
5163 TRACE("(%p)->(%p,%p,%p,0x%08lx)\n", This, lpguidApplication, lpEnumCallback, lpContext, dwFlags );
5164
5165 /* A default dwFlags (0) is backwards compatible -- DPCONNECTION_DIRECTPLAY */
5167 {
5169 }
5170
5173 )
5174 {
5176 }
5177
5178 if( !lpEnumCallback )
5179 {
5181 }
5182
5184
5186 {
5188 continue;
5189
5192 break;
5193 }
5194
Referenced by IDirectPlay4AImpl_EnumConnections(), and IDirectPlay4Impl_EnumConnections().
◆ DP_IF_EnumGroupPlayers()
|
static |
Definition at line 2640 of file dplay.c.
2643{
2644 lpGroupData gdata;
2646
2649
2652
2654
2655 /* Find the group */
2657 {
2660 }
2661
2662 /* Walk the players in this group */
2664 {
2665 DWORD playerFlags;
2666
2667 /* We do not enum the name server or app server as they are of no
2668 * consequence to the end user.
2669 */
2671 continue;
2672
2674 continue;
2676 continue;
2677
2678 playerFlags = plist->lpPData->dwFlags;
2680 playerFlags |= flags;
2681
2684 playerFlags, context ) )
2685 /* User requested break */
2686 break;
2687 }
2688
2690
Referenced by IDirectPlay4AImpl_EnumGroupPlayers(), and IDirectPlay4Impl_EnumGroupPlayers().
◆ DP_IF_EnumGroupsInGroup()
|
static |
Definition at line 5228 of file dplay.c.
5231{
5233 lpGroupData gdata;
5234
5237
5240
5242
5244 {
5247 }
5248
5250 {
5251 DWORD groupFlags;
5252
5254 continue;
5256 continue;
5257
5258 groupFlags = glist->lpGData->dwFlags;
5260 groupFlags |= flags;
5261
5264 break; /* User requested break */
5265 }
5266
5268
Referenced by IDirectPlay4AImpl_EnumGroupsInGroup(), and IDirectPlay4Impl_EnumGroupsInGroup().
◆ DP_IF_EnumSessions()
|
static |
Definition at line 2928 of file dplay.c.
2932{
2935 DWORD defaultTimeout;
2937 DPCAPS caps;
2941
2944
2947
2948 if ( !sdesc )
2950
2953
2954 /* Can't enumerate if the interface is already open */
2957 {
2960 }
2962
2963 /* The loading of a lobby provider _seems_ to require a backdoor loading
2964 * of the service provider to also associate with this DP object. This is
2965 * because the app doesn't seem to have to call EnumConnections and
2966 * InitializeConnection for the SP before calling this method. As such
2967 * we'll do their dirty work for them with a quick hack so as to always
2968 * load the TCP/IP service provider.
2969 *
2970 * The correct solution would seem to involve creating a dialog box which
2971 * contains the possible SPs. These dialog boxes most likely follow SDK
2972 * examples.
2973 */
2975 {
2977
2979 {
2982 }
2983
2987
2990 }
2991
2994 defaultTimeout = caps.dwTimeout;
2995 if ( !defaultTimeout )
2997
2999 {
3002 }
3003
3007
3008 for ( ;; )
3009 {
3011 {
3013
3014 /* Invalidate the session cache for the interface */
3016
3018
3019 /* Send the broadcast for session enumeration */
3021 &This->dp2->spData );
3023 {
3026 }
3028 }
3029
3031
3034
3036
3039 break;
3040 }
3041
3043 {
3046 }
3047
3048 /* Async enumeration */
3049
3051 {
3054 }
3055
3056 /* See if we've already created a thread to service this interface */
3058 {
3061 }
3062
3063 This->dp2->dwEnumSessionLock++;
3064
3065 /* Send the first enum request inline since the user may cancel a dialog
3066 * if one is presented. Also, may also have a connecting return code.
3067 */
3069 &This->dp2->spData );
3071 {
3072 This->dp2->dwEnumSessionLock--;
3075 }
3076
3078 /* FIXME: need to kill the thread on object deletion */
3084
3088 DUPLICATE_SAME_ACCESS ) )
3090
3096
3097 This->dp2->dwEnumSessionLock--;
3098
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_KillEnumSessionThread(IDirectPlayImpl *This)
Definition: dplay.c:2877
static BOOL DP_BuildSPCompoundAddr(LPGUID lpcSpGuid, LPVOID *lplpAddrBuf, LPDWORD lpdwBufSize)
Definition: dplay.c:4820
static BOOL DP_InvokeEnumSessionCallbacks(LPDPENUMSESSIONSCALLBACK2 lpEnumSessionsCallback2, LPVOID lpNSInfo, DWORD *timeout, LPVOID lpContext, BOOL ansi)
Definition: dplay.c:2804
static DWORD CALLBACK DP_EnumSessionsSendAsyncRequestThread(LPVOID lpContext)
Definition: dplay.c:2827
void NS_InvalidateSessionCache(LPVOID lpNSInfo)
Definition: name_server.c:245
void NS_ResetSessionEnumeration(LPVOID lpNSInfo)
Definition: name_server.c:290
Definition: dplay.h:168
Definition: dhcpd.h:248
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:587
Referenced by IDirectPlay4AImpl_EnumSessions(), and IDirectPlay4Impl_EnumSessions().
◆ DP_IF_GetGroupName()
|
static |
Definition at line 3230 of file dplay.c.
3233{
3234 lpGroupData lpGData;
3235 DWORD dwRequiredDataSize;
3236
3238 This, idGroup, lpData, lpdwDataSize, bAnsi );
3239
3241
3243 {
3246 }
3247
3248 dwRequiredDataSize = DP_CopyName( NULL, bAnsi ? lpGData->nameA : lpGData->name, bAnsi, bAnsi );
3249
3251 ( *lpdwDataSize < dwRequiredDataSize )
3252 )
3253 {
3254 *lpdwDataSize = dwRequiredDataSize;
3257 }
3258
3260
3262
Referenced by IDirectPlay4AImpl_GetGroupName(), and IDirectPlay4Impl_GetGroupName().
◆ DP_IF_GetPlayerName()
|
static |
Definition at line 3535 of file dplay.c.
3538{
3539 lpPlayerList lpPList;
3540 DWORD dwRequiredDataSize;
3541
3543 This, idPlayer, lpData, lpdwDataSize, bAnsi );
3544
3546 {
3548 }
3549
3551
3553 {
3556 }
3557
3558 dwRequiredDataSize = DP_CopyName( NULL, bAnsi ? lpPList->lpPData->nameA : lpPList->lpPData->name,
3559 bAnsi, bAnsi );
3560
3562 ( *lpdwDataSize < dwRequiredDataSize )
3563 )
3564 {
3565 *lpdwDataSize = dwRequiredDataSize;
3568 }
3569
3571
3573
Referenced by IDirectPlay4AImpl_GetPlayerName(), and IDirectPlay4Impl_GetPlayerName().
◆ DP_IF_Receive()
|
static |
Definition at line 3996 of file dplay.c.
3999{
4001 DWORD msgSize;
4002
4005
4007 {
4009 }
4010
4012
4014 {
4016 continue;
4018 continue;
4019 break;
4020 }
4021
4023 {
4026 }
4027
4029
4030 if( *lpdwDataSize < msgSize || !lpData )
4031 {
4032 *lpdwDataSize = msgSize;
4035 }
4036
4037 *lpidFrom = lpMsg->fromId;
4038 *lpidTo = lpMsg->toId;
4039 *lpdwDataSize = msgSize;
4040
4041 /* Copy into the provided buffer */
4043
4045 {
4048 free( lpMsg );
4049 }
4050
4052
Definition: dplay_global.h:154
Referenced by IDirectPlay4AImpl_Receive(), and IDirectPlay4Impl_Receive().
◆ DP_IF_SetGroupName()
|
static |
Definition at line 4214 of file dplay.c.
4217{
4218 lpGroupData lpGData;
4219 DPNAME *nameA;
4221
4223 lpGroupName, dwFlags, bAnsi );
4224
4226
4228 {
4231 }
4232
4235 {
4238 }
4239
4241 if ( !nameA )
4242 {
4246 }
4247
4249 lpGData->nameA = nameA;
4250
4251 /* Should send a DPMSG_SETPLAYERORGROUPNAME message */
4253
4255
Referenced by IDirectPlay4AImpl_SetGroupName(), IDirectPlay4Impl_SetGroupName(), and IDirectPlaySPImpl_HandleMessage().
◆ DP_IF_SetPlayerName()
|
static |
Definition at line 4377 of file dplay.c.
4380{
4381 lpPlayerList lpPList;
4382 DPNAME *nameA;
4384
4387
4389 {
4391 }
4392
4394
4396 {
4399 }
4400
4403 {
4406 }
4407
4409 if ( !nameA )
4410 {
4414 }
4415
4418
4419 /* Should send a DPMSG_SETPLAYERORGROUPNAME message */
4421
4423
Referenced by IDirectPlay4AImpl_SetPlayerName(), IDirectPlay4Impl_SetPlayerName(), and IDirectPlaySPImpl_HandleMessage().
◆ DP_InitConnections()
|
static |
Definition at line 5108 of file dplay.c.
5110{
5112
5115
5118
5120
static void DP_ReadConnections(const char *searchSubKey, DWORD dwFlags, const GUID *addressDataType, struct list *connections)
Definition: dplay.c:4952
Referenced by DP_GetConnections().
◆ DP_InitializeDPLSP()
|
static |
Definition at line 5420 of file dplay.c.
5422{
5424 LPSP_INIT DPLSPInit;
5425
5426 /* Initialize the service provider by calling SPInit */
5428
5430 {
5432 FreeLibrary( hLobbyProvider );
5434 }
5435
5437
5439
5441 {
5443 FreeLibrary( hLobbyProvider );
5445 }
5446
5447 /* FIXME: Need to verify the sanity of the returned callback table
5448 * using IsBadCodePtr */
5449
5451
5452 /* This interface is now initialized as a lobby object */
5454
5455 /* Store the handle of the module so that we can unload it later */
5456 This->dp2->hDPLobbyProvider = hLobbyProvider;
5457
Referenced by IDirectPlay4Impl_InitializeConnection().
◆ DP_InitializeDPSP()
|
static |
Definition at line 5381 of file dplay.c.
5383{
5386
5387 /* Initialize the service provider by calling SPInit */
5389
5391 {
5393 FreeLibrary( hServiceProvider );
5395 }
5396
5398
5400
5402 {
5404 FreeLibrary( hServiceProvider );
5406 }
5407
5408 /* FIXME: Need to verify the sanity of the returned callback table
5409 * using IsBadCodePtr */
5411
5412 /* This interface is now initialized as a DP object */
5414
5415 /* Store the handle of the module so that we can unload it later */
5416 This->dp2->hServiceProvider = hServiceProvider;
5417
Referenced by IDirectPlay4Impl_InitializeConnection().
◆ DP_InvokeEnumSessionCallbacks()
|
static |
Definition at line 2803 of file dplay.c.
2810{
2811 LPDPSESSIONDESC2 lpSessionDesc;
2812
2814
2815 /* Enumerate all sessions */
2816 /* FIXME: Need to indicate ANSI */
2818 {
2822 }
2823
2824 /* Invoke one last time to indicate that there is no more to come */
LPDPSESSIONDESC2 NS_WalkSessions(LPVOID lpNSInfo, void **spMessageHeader, BOOL ansi)
Definition: name_server.c:306
Referenced by DP_IF_EnumSessions().
◆ DP_KillEnumSessionThread()
|
static |
Definition at line 2877 of file dplay.c.
2879{
2880 /* Does a thread exist? If so we were doing an async enum session */
2882 {
2884 This->dp2->hEnumSessionThread );
2885
2886 /* Request that the thread kill itself nicely */
2889
2890 /* We no longer need to know about the thread */
2892
2894 }
Referenced by DP_IF_EnumSessions(), and DP_SecureOpen().
◆ DP_LoadSP()
|
static |
Definition at line 5348 of file dplay.c.
5350{
5353
5355
5357
5359 {
5360 /* Determine if this is the Service Provider that the user asked for */
5362 {
5363 continue;
5364 }
5365
5367 {
5371 }
5372
5374
5377 }
5378
5379 return 0;
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
Referenced by IDirectPlay4Impl_InitializeConnection().
◆ DP_NextObjectId()
Definition at line 255 of file dplay.c.
257{
Referenced by DP_GetRemoteNextObjectId(), DP_HandleMessage(), DP_IF_CreateGroup(), DP_IF_CreatePlayer(), and DP_SecureOpen().
◆ DP_QueueMessage()
|
static |
Definition at line 361 of file dplay.c.
364{
368
372 genericSize );
373
376 {
378 {
380 genericSize );
383 }
384
386 }
387
static HRESULT DP_QueuePlayerMessage(IDirectPlayImpl *This, DPID fromId, struct PlayerData *player, DPID excludeId, void *msg, FN_COPY_MESSAGE *copyMessage, DWORD genericSize)
Definition: dplay.c:321
Referenced by DP_AddPlayerToGroup(), DP_CreatePlayer(), DP_HandleGameMessage(), DP_HandleMessage(), and IDirectPlay4Impl_SendEx().
◆ DP_QueuePlayerMessage()
|
static |
Definition at line 321 of file dplay.c.
Referenced by DP_QueueMessage().
◆ DP_ReadConnections()
|
static |
Definition at line 4952 of file dplay.c.
4955{
4956 HKEY hkResult;
4957 char subKeyName[51];
4958 DWORD dwIndex, sizeOfSubKeyName=50;
4959 FILETIME filetime;
4960
4961 /* Need to loop over the service providers in the registry */
4964 {
4965 /* Hmmm. Does this mean that there are no service providers? */
4967 return;
4968 }
4969
4970
4971 /* Traverse all the service providers we have available */
4972 for( dwIndex=0;
4973 RegEnumKeyExA( hkResult, dwIndex, subKeyName, &sizeOfSubKeyName,
4975 ++dwIndex, sizeOfSubKeyName=51 )
4976 {
4977
4978 HKEY hkServiceProvider;
4979 WCHAR *spGuid;
4981
4982 DPCOMPOUNDADDRESSELEMENT dpCompoundAddress;
4984
4986
4987 /* Get a handle for this particular service provider */
4989 &hkServiceProvider ) != ERROR_SUCCESS )
4990 {
4992 continue;
4993 }
4994
4997 {
4998 RegCloseKey( hkServiceProvider );
4999 continue;
5000 }
5001
5003
5005 {
5008 RegCloseKey(hkServiceProvider);
5009 continue;
5010 }
5012 free( spGuid );
5013
5014 /* Fill in the DPNAME struct for the service provider */
5015
5018 &connection->name.lpszShortName ) )
5019 {
5021 RegCloseKey( hkServiceProvider );
5022 continue;
5023 }
5024
5027 &connection->nameA.lpszShortNameA ) )
5028 {
5031 RegCloseKey( hkServiceProvider );
5032 continue;
5033 }
5034
5036 {
5040 RegCloseKey( hkServiceProvider );
5041 continue;
5042 }
5043
5045 {
5049 RegCloseKey( hkServiceProvider );
5050 continue;
5051 }
5052
5054 {
5058 RegCloseKey( hkServiceProvider );
5059 continue;
5060 }
5061
5062 RegCloseKey( hkServiceProvider );
5063
5064 /* Create the compound address for the service provider.
5065 * NOTE: This is a gruesome architectural scar right now. DP
5066 * uses DPL and DPL uses DP. Nasty stuff. This may be why the
5067 * native dll just gets around this little bit by allocating an
5068 * 80 byte buffer which isn't even filled with a valid compound
5069 * address. Oh well. Creating a proper compound address is the
5070 * way to go anyways despite this method taking slightly more
5071 * heap space and realtime :) */
5072
5073 dpCompoundAddress.guidDataType = *addressDataType;
5076
5079 {
5085 continue;
5086 }
5087
5088 /* Now allocate the buffer */
5090
5093 {
5100 continue;
5101 }
5102
5104 }
static void list_add_tail(struct list_entry *head, struct list_entry *entry)
Definition: list.h:83
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
HRESULT WINAPI CLSIDFromString(LPCOLESTR str, LPCLSID clsid)
Definition: combase.c:1470
static BOOL DP_GetRegDword(HKEY key, const WCHAR *name, DWORD *value)
Definition: dplay.c:4923
static BOOL DP_GetRegStringA(HKEY key, const char *name, const char *defaultValue, char **outValue)
Definition: dplay.c:4918
static BOOL DP_GetRegStringW(HKEY key, const WCHAR *name, const char *defaultValue, WCHAR **outValue)
Definition: dplay.c:4913
Definition: mapidefs.h:60
Referenced by DP_InitConnections().
◆ DP_SecureOpen()
|
static |
Definition at line 3737 of file dplay.c.
3740{
3743
3746
3748 {
3751 }
3752
3754 {
3756 }
3757
3760 {
3764 }
3766
3767 /* If we're enumerating, kill the thread */
3769
3771 {
3772 /* Rightoo - this computer is the host and the local computer needs to be
3773 the name server so that others can join this session */
3775
3777
3780 {
3783 }
3784 }
3785 else
3786 {
3787 DPSESSIONDESC2 *sessionDesc;
3788
3790
3792
3794
3795 for ( ;; )
3796 {
3798 if ( !sessionDesc )
3801 break;
3802 }
3803
3804 /* No need to enter the critical section here as the messaging thread won't access the data
3805 * while bConnectionOpen is FALSE. */
3806
3811 }
3812
3813 /* Invoke the conditional callback for the service provider */
3815 {
3817
3819
3821 data.lpSPMessageHeader = spMessageHeader;
3826
3829 {
3832 }
3833 }
3834
3835 {
3836 /* Create the system group of which everything is a part of */
3838
3842 {
3844 {
3848 }
3850 }
3851 }
3852
3854 {
3857
3860 {
3863 {
3867 }
3869 }
3870
3871 /* Create the server player for this interface. This way we can receive
3872 * messages for this session.
3873 */
3874 /* FIXME: I suppose that we should be setting an event for a receive
3875 * type of thing. That way the messaging thread could know to wake
3876 * up. DPlay would then trigger the hEvent for the player the
3877 * message is directed to.
3878 */
3881 {
3886 {
3890 }
3892 }
3893
3894 /* No need to enter the critical section here as the messaging thread won't access the data
3895 * while bConnectionOpen is FALSE. */
3896
3900 {
3904 {
3908 }
3910 }
3911
3915 {
3919 {
3923 }
3925 }
3926 }
3928 {
3930
3932
3936 {
3939 {
3943 }
3945 }
3946 }
3947
3949
3951
3953
static HRESULT DP_IF_CreateGroup(IDirectPlayImpl *This, void *lpMsgHdr, DPID *lpidGroup, DPNAME *lpGroupName, void *lpData, DWORD dwDataSize, DWORD dwFlags, BOOL bAnsi)
Definition: dplay.c:1578
static HRESULT DP_IF_DestroyGroup(IDirectPlayImpl *This, void *lpMsgHdr, DPID idGroup, BOOL bAnsi)
Definition: dplay.c:2387
static HRESULT DP_SetSessionDesc(IDirectPlayImpl *This, const DPSESSIONDESC2 *lpSessDesc, DWORD dwFlags, BOOL bInitial, BOOL bAnsi)
Definition: dplay.c:4468
DPSESSIONDESC2 * DP_DuplicateSessionDesc(const DPSESSIONDESC2 *src, BOOL dstAnsi, BOOL srcAnsi)
Definition: dplay.c:4579
HRESULT DP_MSG_ForwardPlayerCreation(IDirectPlayImpl *This, DPID dpidServer, WCHAR *password)
Definition: dplayx_messages.c:550
void NS_SetLocalComputerAsNameServer(LPCDPSESSIONDESC2 lpsd, LPVOID lpNSInfo)
Definition: name_server.c:88
Definition: dplaysp.h:123
Definition: dplaysp.h:190
Referenced by IDirectPlay4AImpl_SecureOpen(), and IDirectPlay4Impl_SecureOpen().
◆ DP_SetGroupData()
|
static |
Definition at line 1707 of file dplay.c.
1710{
1711 /* Clear out the data with this player */
1713 {
1715 {
1718 lpGData->dwLocalDataSize = 0;
1719 }
1720 }
1721 else
1722 {
1724 {
1727 lpGData->dwRemoteDataSize = 0;
1728 }
1729 }
1730
1731 /* Reallocate for new data */
1733 {
1735 {
1736 lpGData->lpLocalData = lpData;
1737 lpGData->dwLocalDataSize = dwDataSize;
1738 }
1739 else
1740 {
1743 lpGData->dwRemoteDataSize = dwDataSize;
1744 }
1745 }
1746
Referenced by DP_CreateGroup(), DP_HandleMessage(), and IDirectPlay4Impl_SetGroupData().
◆ DP_SetPlayerData()
|
static |
Definition at line 2061 of file dplay.c.
2064{
2065 /* Clear out the data with this player */
2067 {
2069 {
2072 lpPData->dwLocalDataSize = 0;
2073 }
2074 }
2075 else
2076 {
2078 {
2081 lpPData->dwRemoteDataSize = 0;
2082 }
2083 }
2084
2085 /* Reallocate for new data */
2087 {
2088
2090 {
2091 lpPData->lpLocalData = lpData;
2092 lpPData->dwLocalDataSize = dwDataSize;
2093 }
2094 else
2095 {
2098 lpPData->dwRemoteDataSize = dwDataSize;
2099 }
2100 }
2101
Referenced by DP_CreatePlayer(), and IDirectPlay4Impl_SetPlayerData().
◆ DP_SetSessionDesc()
|
static |
Definition at line 4468 of file dplay.c.
4471{
4472 LPDPSESSIONDESC2 lpTempSessDesc;
4473
4476
4478 {
4480 }
4481
4483 {
4485 }
4486
4487 /* Only the host is allowed to update the session desc */
4489 {
4491 }
4492
4494
4495 lpTempSessDesc = DP_DuplicateSessionDesc( lpSessDesc, bAnsi, bAnsi );
4496
4498 {
4501 }
4502
4503 /* Free the old */
4505
4506 This->dp2->lpSessionDesc = lpTempSessDesc;
4507
4508 /* If this is an external invocation of the interface, we should be
4509 * letting everyone know that things have changed. Otherwise this is
4510 * just an initialization and it doesn't need to be propagated.
4511 */
4512 if( !bInitial )
4513 {
4515 }
4516
4518
Referenced by DP_SecureOpen(), IDirectPlay4AImpl_SetSessionDesc(), and IDirectPlay4Impl_SetSessionDesc().
◆ DP_SetSPPlayerData()
| HRESULT DP_SetSPPlayerData | ( | IDirectPlayImpl * | lpDP, |
| DPID | idPlayer, | ||
| void * | lpData | ||
| ) |
Definition at line 6490 of file dplay.c.
6492{
6494 lpPlayerList lpPlayer;
6495
6497
6498 lpPlayer = DP_FindPlayer( lpDP, idPlayer );
6499 if( lpPlayer )
6500 {
6504 }
6505
6508 {
6509 group->lpSPPlayerData = lpData;
6512 }
6513
6515
Referenced by IDirectPlaySPImpl_SetSPPlayerData().
◆ DPL_CreateCompoundAddress()
| HRESULT DPL_CreateCompoundAddress | ( | LPCDPCOMPOUNDADDRESSELEMENT | lpElements, |
| DWORD | dwElementCount, | ||
| LPVOID | lpAddress, | ||
| LPDWORD | lpdwAddressSize, | ||
| BOOL | bAnsiInterface | ||
| ) |
Definition at line 1108 of file dplobby.c.
1114{
1115 DWORD dwSizeRequired = 0;
1116 DWORD dwElements;
1117 LPCDPCOMPOUNDADDRESSELEMENT lpOrigElements = lpElements;
1118
1120
1121 /* Parameter check */
1123 ( dwElementCount == 0 ) /* FIXME: Not sure if this is a failure case */
1124 )
1125 {
1127 }
1128
1129 /* Add the total size chunk */
1131
1132 /* Calculate the size of the buffer required */
1133 for ( dwElements = dwElementCount; dwElements > 0; --dwElements, ++lpElements )
1134 {
1137 )
1138 {
1140 }
1144 )
1145 {
1146 if( !bAnsiInterface )
1147 {
1150 }
1151
1153 }
1157 )
1158 {
1159 if( bAnsiInterface )
1160 {
1163 }
1164
1167 }
1169 {
1171 }
1173 {
1176 }
1177 else
1178 {
1180 }
1181 }
1182
1183 /* The user wants to know how big a buffer to allocate for us */
1185 ( *lpdwAddressSize < dwSizeRequired )
1186 )
1187 {
1188 *lpdwAddressSize = dwSizeRequired;
1190 }
1191
1192 /* Add the total size chunk */
1193 {
1194 LPDPADDRESS lpdpAddress = lpAddress;
1195
1196 lpdpAddress->guidDataType = DPAID_TotalSize;
1199
1200 *(LPDWORD)lpAddress = dwSizeRequired;
1202 }
1203
1204 /* Calculate the size of the buffer required */
1205 for( dwElements = dwElementCount, lpElements = lpOrigElements;
1206 dwElements > 0;
1207 --dwElements, ++lpElements )
1208 {
1211 )
1212 {
1213 LPDPADDRESS lpdpAddress = lpAddress;
1214
1218
1221 }
1225 )
1226 {
1227 LPDPADDRESS lpdpAddress = lpAddress;
1228
1232
1235 }
1239 )
1240 {
1241 LPDPADDRESS lpdpAddress = lpAddress;
1242
1246
1249 }
1251 {
1252 LPDPADDRESS lpdpAddress = lpAddress;
1253
1257
1260 }
1262 {
1263 LPDPADDRESS lpdpAddress = lpAddress;
1264
1268
1271 }
1272 }
1273
1275}
struct tagDPADDRESS DPADDRESS
Definition: dplobby.h:251
Definition: dplobby.h:267
Referenced by DP_BuildSPCompoundAddr(), DP_ReadConnections(), DPL_CreateAddress(), IDirectPlayLobby3AImpl_CreateCompoundAddress(), and IDirectPlayLobby3Impl_CreateCompoundAddress().
◆ dplay_cancelmsg()
|
static |
Definition at line 6071 of file dplay.c.
6074{
6076
6078
6080 {
6082
6084
6085 /* FIXME: Undocumented callback */
6086
6090 data.cSPMsgID = msgid;
6091 data.dwMinPriority = minprio;
6092 data.dwMaxPriority = maxprio;
6093
6095 }
6096 else
6098
Definition: dplaysp.h:281
Referenced by IDirectPlay4Impl_CancelMessage(), and IDirectPlay4Impl_CancelPriority().
◆ dplay_create()
Definition at line 6428 of file dplay.c.
6430{
6433
6435
6440
6448 obj->ref = 1;
6449
6452
6455 else
6458
BOOL WINAPI InitializeCriticalSectionEx(OUT LPCRITICAL_SECTION lpCriticalSection, IN DWORD dwSpinCount, IN DWORD flags)
Definition: sync.c:107
Definition: usrmarshal.c:1272
#define RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO
Definition: winnt_old.h:1156
Referenced by DirectPlayCreate(), and DPL_ConnectEx().
◆ dplay_destroy()
|
static |
Definition at line 247 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 1175 of file dplay.c.
1178{
static IDirectPlayImpl * impl_from_IDirectPlay2A(IDirectPlay2A *iface)
Definition: dplay.c:97
◆ IDirectPlay2AImpl_AddRef()
|
static |
◆ IDirectPlay2AImpl_Close()
|
static |
◆ IDirectPlay2AImpl_CreateGroup()
|
static |
◆ IDirectPlay2AImpl_CreatePlayer()
|
static |
Definition at line 2201 of file dplay.c.
2204{
#define IDirectPlayX_CreatePlayer(p, a, b, c, d, e, f)
Definition: dplay.h:871
Definition: filter.c:185
◆ IDirectPlay2AImpl_DeletePlayerFromGroup()
|
static |
◆ IDirectPlay2AImpl_DestroyGroup()
|
static |
◆ IDirectPlay2AImpl_DestroyPlayer()
|
static |
◆ IDirectPlay2AImpl_EnumGroupPlayers()
|
static |
◆ IDirectPlay2AImpl_EnumGroups()
|
static |
◆ IDirectPlay2AImpl_EnumPlayers()
|
static |
◆ IDirectPlay2AImpl_EnumSessions()
|
static |
◆ IDirectPlay2AImpl_GetCaps()
|
static |
◆ IDirectPlay2AImpl_GetGroupData()
|
static |
◆ IDirectPlay2AImpl_GetGroupName()
|
static |
◆ IDirectPlay2AImpl_GetMessageCount()
|
static |
◆ IDirectPlay2AImpl_GetPlayerAddress()
|
static |
Definition at line 3347 of file dplay.c.
3350{
#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 1182 of file dplay.c.
1185{
static IDirectPlayImpl * impl_from_IDirectPlay2(IDirectPlay2 *iface)
Definition: dplay.c:92
◆ 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 4595 of file dplay.c.
4598{
static IDirectPlayImpl * impl_from_IDirectPlay3A(IDirectPlay3A *iface)
Definition: dplay.c:102
◆ IDirectPlay3AImpl_AddPlayerToGroup()
|
static |
◆ IDirectPlay3AImpl_AddRef()
|
static |
◆ IDirectPlay3AImpl_Close()
|
static |
◆ IDirectPlay3AImpl_CreateGroup()
|
static |
◆ IDirectPlay3AImpl_CreateGroupInGroup()
|
static |
Definition at line 4719 of file dplay.c.
4722{
#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 5285 of file dplay.c.
5288{
#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 5739 of file dplay.c.
5742{
#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 5576 of file dplay.c.
5579{
#define IDirectPlayX_SendChatMessage(p, a, b, c, d)
Definition: dplay.h:906
◆ IDirectPlay3AImpl_SetGroupConnectionSettings()
|
static |
Definition at line 5606 of file dplay.c.
5609{
5612 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 4602 of file dplay.c.
4605{
static IDirectPlayImpl * impl_from_IDirectPlay3(IDirectPlay3 *iface)
Definition: dplay.c:107
◆ 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 |
Definition at line 5614 of file dplay.c.
5617{
5620 connection );
◆ IDirectPlay3Impl_SetGroupData()
|
static |
◆ IDirectPlay3Impl_SetGroupName()
|
static |
◆ IDirectPlay3Impl_SetPlayerData()
|
static |
◆ IDirectPlay3Impl_SetPlayerName()
|
static |
◆ IDirectPlay3Impl_SetSessionDesc()
|
static |
◆ IDirectPlay3Impl_StartSession()
|
static |
◆ IDirectPlay4AImpl_AddGroupToGroup()
|
static |
Definition at line 4609 of file dplay.c.
4612{
static IDirectPlayImpl * impl_from_IDirectPlay4A(IDirectPlay4A *iface)
Definition: dplay.c:112
◆ IDirectPlay4AImpl_AddPlayerToGroup()
|
static |
◆ IDirectPlay4AImpl_AddRef()
|
static |
◆ IDirectPlay4AImpl_CancelMessage()
|
static |
◆ IDirectPlay4AImpl_CancelPriority()
|
static |
◆ IDirectPlay4AImpl_Close()
|
static |
◆ IDirectPlay4AImpl_CreateGroup()
|
static |
◆ IDirectPlay4AImpl_CreateGroupInGroup()
|
static |
Definition at line 4735 of file dplay.c.
4739{
4741
4742 *lpidGroup = DPID_UNKNOWN;
4743
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:4665
◆ IDirectPlay4AImpl_CreatePlayer()
|
static |
Definition at line 2233 of file dplay.c.
2236{
static HRESULT DP_IF_CreatePlayer(IDirectPlayImpl *This, DPID *lpidPlayer, DPNAME *lpPlayerName, HANDLE hEvent, void *lpData, DWORD dwDataSize, DWORD dwFlags, BOOL bAnsi)
Definition: dplay.c:2103
◆ IDirectPlay4AImpl_DeleteGroupFromGroup()
|
static |
◆ IDirectPlay4AImpl_DeletePlayerFromGroup()
|
static |
◆ IDirectPlay4AImpl_DestroyGroup()
|
static |
◆ IDirectPlay4AImpl_DestroyPlayer()
|
static |
Definition at line 2596 of file dplay.c.
2598{
static HRESULT DP_IF_DestroyPlayer(IDirectPlayImpl *This, void *lpMsgHdr, DPID idPlayer, BOOL bAnsi)
Definition: dplay.c:2487
◆ IDirectPlay4AImpl_EnumConnections()
|
static |
Definition at line 5197 of file dplay.c.
5201{
5203 return DP_IF_EnumConnections( This, lpguidApplication, lpEnumCallback, lpContext, dwFlags, TRUE );
static HRESULT DP_IF_EnumConnections(IDirectPlayImpl *This, const GUID *lpguidApplication, LPDPENUMCONNECTIONSCALLBACK lpEnumCallback, void *lpContext, DWORD dwFlags, BOOL ansi)
Definition: dplay.c:5155
◆ IDirectPlay4AImpl_EnumGroupPlayers()
|
static |
Definition at line 2693 of file dplay.c.
2696{
static HRESULT DP_IF_EnumGroupPlayers(IDirectPlayImpl *This, DPID group, GUID *instance, LPDPENUMPLAYERSCALLBACK2 enumplayercb, void *context, DWORD flags, BOOL ansi)
Definition: dplay.c:2640
◆ IDirectPlay4AImpl_EnumGroups()
|
static |
◆ IDirectPlay4AImpl_EnumGroupsInGroup()
|
static |
Definition at line 5271 of file dplay.c.
5274{
static HRESULT DP_IF_EnumGroupsInGroup(IDirectPlayImpl *This, DPID group, GUID *instance, LPDPENUMPLAYERSCALLBACK2 enumplayercb, void *context, DWORD flags, BOOL ansi)
Definition: dplay.c:5228
◆ IDirectPlay4AImpl_EnumPlayers()
|
static |
◆ IDirectPlay4AImpl_EnumSessions()
|
static |
Definition at line 3101 of file dplay.c.
3104{
static HRESULT DP_IF_EnumSessions(IDirectPlayImpl *This, DPSESSIONDESC2 *sdesc, DWORD timeout, LPDPENUMSESSIONSCALLBACK2 enumsessioncb, void *context, DWORD flags, BOOL ansi)
Definition: dplay.c:2928
◆ IDirectPlay4AImpl_GetCaps()
|
static |
◆ IDirectPlay4AImpl_GetGroupConnectionSettings()
◆ IDirectPlay4AImpl_GetGroupData()
|
static |
◆ IDirectPlay4AImpl_GetGroupFlags()
|
static |
◆ IDirectPlay4AImpl_GetGroupName()
|
static |
Definition at line 3293 of file dplay.c.
3296{
static HRESULT DP_IF_GetGroupName(IDirectPlayImpl *This, DPID idGroup, void *lpData, DWORD *lpdwDataSize, BOOL bAnsi)
Definition: dplay.c:3230
◆ IDirectPlay4AImpl_GetGroupOwner()
|
static |
◆ IDirectPlay4AImpl_GetGroupParent()
|
static |
◆ IDirectPlay4AImpl_GetMessageCount()
|
static |
Definition at line 3335 of file dplay.c.
3338{
#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 3604 of file dplay.c.
3607{
static HRESULT DP_IF_GetPlayerName(IDirectPlayImpl *This, DPID idPlayer, void *lpData, DWORD *lpdwDataSize, BOOL bAnsi)
Definition: dplay.c:3535
◆ IDirectPlay4AImpl_GetSessionDesc()
|
static |
Definition at line 3683 of file dplay.c.
3686{
static HRESULT DP_GetSessionDesc(IDirectPlayImpl *This, void *lpData, DWORD *lpdwDataSize, BOOL bAnsi)
Definition: dplay.c:3618
◆ IDirectPlay4AImpl_Initialize()
|
static |
◆ IDirectPlay4AImpl_InitializeConnection()
|
static |
◆ IDirectPlay4AImpl_Open()
|
static |
◆ IDirectPlay4AImpl_QueryInterface()
|
static |
◆ IDirectPlay4AImpl_Receive()
|
static |
Definition at line 4083 of file dplay.c.
4086{
static HRESULT DP_IF_Receive(IDirectPlayImpl *This, DPID *lpidFrom, DPID *lpidTo, DWORD dwFlags, void *lpData, DWORD *lpdwDataSize, BOOL bAnsi)
Definition: dplay.c:3996
◆ IDirectPlay4AImpl_Release()
|
static |
◆ IDirectPlay4AImpl_SecureOpen()
|
static |
Definition at line 5560 of file dplay.c.
5564{
static HRESULT DP_SecureOpen(IDirectPlayImpl *This, const DPSESSIONDESC2 *lpsd, DWORD dwFlags, const DPSECURITYDESC *lpSecurity, const DPCREDENTIALS *lpCredentials, BOOL bAnsi)
Definition: dplay.c:3737
◆ IDirectPlay4AImpl_Send()
◆ IDirectPlay4AImpl_SendChatMessage()
|
static |
◆ IDirectPlay4AImpl_SendEx()
|
static |
◆ IDirectPlay4AImpl_SetGroupConnectionSettings()
|
static |
◆ IDirectPlay4AImpl_SetGroupData()
|
static |
◆ IDirectPlay4AImpl_SetGroupName()
|
static |
Definition at line 4286 of file dplay.c.
4289{
static HRESULT DP_IF_SetGroupName(IDirectPlayImpl *This, DPID idGroup, DPNAME *lpGroupName, DWORD dwFlags, BOOL bAnsi)
Definition: dplay.c:4214
◆ IDirectPlay4AImpl_SetGroupOwner()
|
static |
◆ IDirectPlay4AImpl_SetPlayerData()
|
static |
◆ IDirectPlay4AImpl_SetPlayerName()
|
static |
Definition at line 4454 of file dplay.c.
4457{
static HRESULT DP_IF_SetPlayerName(IDirectPlayImpl *This, DPID idPlayer, DPNAME *lpPlayerName, DWORD dwFlags, BOOL bAnsi)
Definition: dplay.c:4377
◆ IDirectPlay4AImpl_SetSessionDesc()
|
static |
◆ IDirectPlay4AImpl_StartSession()
|
static |
◆ IDirectPlay4Impl_AddGroupToGroup()
|
static |
Definition at line 4616 of file dplay.c.
4619{
4621 lpGroupData gdata;
4623
4625
4628
4630
4632 {
4635 }
4636
4638 {
4641 }
4642
4643 /* Create a player list (ie "shortcut" ) */
4646 {
4649 }
4650
4651 /* Add the shortcut */
4652 gdata->uRef++;
4653 glist->lpGData = gdata;
4654
4655 /* Add the player to the list of players for this group */
4657
4658 /* Send a ADDGROUPTOGROUP message */
4660
4662
static IDirectPlayImpl * impl_from_IDirectPlay4(IDirectPlay4 *iface)
Definition: dplay.c:117
◆ IDirectPlay4Impl_AddPlayerToGroup()
|
static |
Definition at line 1284 of file dplay.c.
1287{
1290
1292
1295
1297
1300 {
1303 }
1304
1305 /* Inform all other peers of the addition of player to the group. If there are
1306 * no peers keep this event quiet.
1307 * Also, if this event was the result of another machine sending it to us,
1308 * don't bother rebroadcasting it.
1309 */
1312 {
1315 }
1316
1318
HRESULT DP_AddPlayerToGroup(IDirectPlayImpl *This, DPID group, DPID player)
Definition: dplay.c:1210
HRESULT DP_MSG_SendAddPlayerToGroup(IDirectPlayImpl *This, DPID toId, DPID playerId, DPID groupId)
Definition: dplayx_messages.c:834
◆ IDirectPlay4Impl_AddRef()
◆ IDirectPlay4Impl_CancelMessage()
|
static |
Definition at line 6108 of file dplay.c.
6111{
6113
6116
6117 if ( msgid == 0 )
6119
static HRESULT dplay_cancelmsg(IDirectPlayImpl *This, DWORD msgid, DWORD flags, DWORD minprio, DWORD maxprio)
Definition: dplay.c:6071
◆ IDirectPlay4Impl_CancelPriority()
|
static |
◆ IDirectPlay4Impl_Close()
Definition at line 1351 of file dplay.c.
1353{
1356
1358
1360
1362
1364
1365 /* FIXME: Need to find a new host I assume (how?) */
1366 /* FIXME: Need to destroy all local groups */
1367 /* FIXME: Need to migrate all remotely visible players to the new host */
1368
1369 /* Invoke the SP callback to inform of session close */
1371 {
1373
1377 }
1379 {
1382 }
1383
◆ IDirectPlay4Impl_CreateGroup()
|
static |
◆ IDirectPlay4Impl_CreateGroupInGroup()
|
static |
◆ IDirectPlay4Impl_CreatePlayer()
|
static |
◆ IDirectPlay4Impl_DeleteGroupFromGroup()
|
static |
Definition at line 4779 of file dplay.c.
4782{
4785 lpGroupData parentdata;
4786
4788
4790
4791 /* Is the parent group valid? */
4793 {
4796 }
4797
4798 /* Remove the group from the parent group queue */
4800
4802 {
4805 }
4806
4807 /* Decrement the ref count */
4808 glist->lpGData->uRef--;
4809
4810 /* Free up the list item */
4812
4813 /* Should send a DELETEGROUPFROMGROUP message */
4815
4817
◆ IDirectPlay4Impl_DeletePlayerFromGroup()
|
static |
Definition at line 2292 of file dplay.c.
2295{
2298
2299 lpGroupData gdata;
2301
2303
2305
2306 /* Find the group */
2308 {
2311 }
2312
2313 /* Find the player */
2315 {
2318 }
2319
2320 /* Remove the player shortcut from the group */
2322
2324 {
2327 }
2328
2329 /* One less reference */
2330 plist->lpPData->uRef--;
2331
2332 /* Delete the Player List element */
2334
2335 /* Inform the SP if they care */
2337 {
2339
2341 data.idPlayer = player;
2345 }
2346
2347 /* Need to send a DELETEPLAYERFROMGROUP message */
2349
2351
◆ IDirectPlay4Impl_DestroyGroup()
◆ IDirectPlay4Impl_DestroyPlayer()
◆ IDirectPlay4Impl_EnumConnections()
|
static |
◆ IDirectPlay4Impl_EnumGroupPlayers()
|
static |
◆ IDirectPlay4Impl_EnumGroups()
|
static |
◆ IDirectPlay4Impl_EnumGroupsInGroup()
|
static |
◆ IDirectPlay4Impl_EnumPlayers()
|
static |
◆ IDirectPlay4Impl_EnumSessions()
|
static |
◆ IDirectPlay4Impl_GetCaps()
|
static |
◆ IDirectPlay4Impl_GetGroupConnectionSettings()
◆ IDirectPlay4Impl_GetGroupData()
|
static |
Definition at line 3184 of file dplay.c.
3187{
3189 lpGroupData gdata;
3192
3194
3196
3198 {
3201 }
3202
3203 /* How much buffer is required? */
3205 {
3208 }
3209 else
3210 {
3213 }
3214
3216
3217 /* Is the user requesting to know how big a buffer is required? */
3219 {
3222 }
3223
3225
3227
◆ IDirectPlay4Impl_GetGroupFlags()
|
static |
◆ IDirectPlay4Impl_GetGroupName()
|
static |
◆ IDirectPlay4Impl_GetGroupOwner()
|
static |
◆ IDirectPlay4Impl_GetGroupParent()
|
static |
◆ IDirectPlay4Impl_GetMessageCount()
|
static |
◆ IDirectPlay4Impl_GetMessageQueue()
|
static |
Definition at line 5970 of file dplay.c.
5973{
5978
5980
5983
5986
5989
5991
5992 if ( to )
5993 {
5995 if ( !playerTo )
5996 {
5999 }
6000 }
6001
6003 {
6005 if ( !playerFrom )
6006 {
6009 }
6010 }
6011
6013 {
6015 DWORD msgCount = 0;
6017
6019 {
6022 }
6023
6025 {
6027 continue;
6029 continue;
6030
6031 ++msgCount;
6033 }
6034
6035 if ( msgs )
6036 *msgs = msgCount;
6039
6041
6043 }
6044
6045 /* FIXME: Do we need to do from and to sanity checking here? */
6046 /* FIXME: What about sends which are not immediate? */
6047
6049 {
6051
6053
6054 /* FIXME: None of this is documented :( */
6058 data.idTo = to;
6059 data.lpdwNumMsgs = msgs;
6061
6063 }
6064 else
6066
6068
Definition: dplaysp.h:268
◆ IDirectPlay4Impl_GetPlayerAccount()
◆ IDirectPlay4Impl_GetPlayerAddress()
|
static |
◆ IDirectPlay4Impl_GetPlayerCaps()
|
static |
Definition at line 3426 of file dplay.c.
3429{
3432
3434
3435 if ( !caps )
3437
3440
3443
3444 /* Query the service provider */
3445 data.idPlayer = player;
3447 data.lpCaps = caps;
3449
Definition: dplaysp.h:182
◆ IDirectPlay4Impl_GetPlayerData()
|
static |
◆ IDirectPlay4Impl_GetPlayerFlags()
|
static |
◆ IDirectPlay4Impl_GetPlayerName()
|
static |
◆ IDirectPlay4Impl_GetSessionDesc()
|
static |
◆ IDirectPlay4Impl_Initialize()
◆ IDirectPlay4Impl_InitializeConnection()
|
static |
Definition at line 5481 of file dplay.c.
5484{
5486 HMODULE servprov;
5491
5493
5496
5499
5502
5503 /* Find out what the requested SP is and how large this buffer is */
5505
5507 {
5510 }
5511
5512 /* Load the service provider */
5514
5515 if ( !servprov )
5516 {
5519 }
5520
5521 if ( is_dp_sp )
5522 {
5523 /* Fill in what we can of the Service Provider required information.
5524 * The rest was be done in DP_LoadSP
5525 */
5530 }
5531 else
5532 {
5535 }
5536
5539
static HRESULT DP_InitializeDPLSP(IDirectPlayImpl *This, HMODULE hLobbyProvider)
Definition: dplay.c:5420
static HRESULT DP_InitializeDPSP(IDirectPlayImpl *This, HMODULE hServiceProvider)
Definition: dplay.c:5381
static HMODULE DP_LoadSP(LPCGUID lpcGuid, LPSPINITDATA lpSpData, LPBOOL lpbIsDpSp)
Definition: dplay.c:5348
static BOOL CALLBACK DP_GetSpLpGuidFromCompoundAddress(REFGUID guidDataType, DWORD dwDataSize, LPCVOID lpData, LPVOID lpContext)
Definition: dplay.c:5317
HRESULT DPL_EnumAddress(LPDPENUMADDRESSCALLBACK lpEnumAddressCallback, LPCVOID lpAddress, DWORD dwAddressSize, LPVOID lpContext)
Definition: dplobby.c:368
◆ IDirectPlay4Impl_Open()
|
static |
◆ IDirectPlay4Impl_QueryInterface()
|
static |
Definition at line 981 of file dplay.c.
984{
986
988 {
991 }
993 {
996 }
998 {
1001 }
1003 {
1006 }
1008 {
1011 }
1013 {
1016 }
1018 {
1021 }
1023 {
1026 }
1027 else
1028 {
1032 }
1033
Definition: unknwn.idl:39
◆ IDirectPlay4Impl_Receive()
|
static |
◆ IDirectPlay4Impl_Release()
◆ IDirectPlay4Impl_SecureOpen()
|
static |
◆ IDirectPlay4Impl_Send()
◆ IDirectPlay4Impl_SendChatMessage()
|
static |
◆ IDirectPlay4Impl_SendEx()
|
static |
Definition at line 5837 of file dplay.c.
5841{
5843 DPMSG_SYSMSGENVELOPE envelope;
5846
5849
5852
5853 /* FIXME: Add parameter checking */
5854 /* FIXME: First call to this needs to acquire a message id which will be
5855 * used for multiple sends
5856 */
5857
5858 /* NOTE: Can't send messages to yourself - this will be trapped in receive */
5859
5861
5862 /* Verify that the message is being sent from a valid local player. The
5863 * from player may be anonymous DPID_UNKNOWN
5864 */
5866 {
5870 }
5871
5874 {
5877 }
5878
5880 envelope.dwPlayerTo = to;
5881
5888
5889 /* Verify that the message is being sent to a valid player, group or to
5890 * everyone. If it's valid, send it to those players.
5891 */
5893 {
5895 {
5896 DPSP_SENDEXDATA sendData;
5897
5900 sendData.idPlayerTo = to;
5905 sendData.cBuffers );
5909 sendData.lpdwSPMsgID = msgid;
5911
5913
5915
5917 }
5918 else
5920 }
5922 {
5923 /* See if SP has the ability to multicast. If so, use it */
5925 {
5926 DPSP_SENDTOGROUPEXDATA sendData;
5927
5930 sendData.idGroupTo = to;
5935 sendData.cBuffers );
5939 sendData.lpdwSPMsgID = msgid;
5940
5942
5944
5946 }
5949 else /* No multicast, multiplicate */
5951
5952 }
5953 else
5954 {
5957 }
5958
5960
DWORD DP_MSG_ComputeMessageSize(SGBUFFER *buffers, DWORD bufferCount)
Definition: dplayx_messages.c:222
Definition: dplay.h:309
Definition: dplayx_messages.h:151
Definition: dplaysp.h:237
Definition: dplaysp.h:253
◆ IDirectPlay4Impl_SetGroupConnectionSettings()
|
static |
◆ IDirectPlay4Impl_SetGroupData()
|
static |
Definition at line 4172 of file dplay.c.
4175{
4177 lpGroupData gdata;
4178
4180
4181 /* Parameter check */
4184
4186
4187 /* Find the pointer to the data for this player */
4189 {
4192 }
4193
4195 {
4197 /* FIXME: If this is a remote update need to allow it but not
4198 * send a message.
4199 */
4200 }
4201
4203
4204 /* FIXME: Only send a message if this group is local to the session otherwise
4205 * it will have been rejected above
4206 */
4209
4211
◆ IDirectPlay4Impl_SetGroupName()
|
static |
◆ IDirectPlay4Impl_SetGroupOwner()
|
static |
◆ IDirectPlay4Impl_SetPlayerData()
|
static |
Definition at line 4335 of file dplay.c.
4338{
4341
4343
4346
4347 /* Parameter check */
4350
4352
4353 /* Find the pointer to the data for this player */
4355 {
4358 }
4359
4361 {
4363 /* FIXME: If this is a remote update need to allow it but not
4364 * send a message.
4365 */
4366 }
4367
4369
4372
4374
◆ IDirectPlay4Impl_SetPlayerName()
|
static |
◆ IDirectPlay4Impl_SetSessionDesc()
|
static |
◆ IDirectPlay4Impl_StartSession()
|
static |
◆ IDirectPlayImpl_AddPlayerToGroup()
|
static |
Definition at line 745 of file dplay.c.
748{
static IDirectPlayImpl * impl_from_IDirectPlay(IDirectPlay *iface)
Definition: dplay.c:87
◆ 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 814 of file dplay.c.
817{
Definition: winhttp_private.h:77
◆ 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 87 of file dplay.c.
89{
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 92 of file dplay.c.
94{
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 97 of file dplay.c.
99{
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 107 of file dplay.c.
109{
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 102 of file dplay.c.
104{
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 117 of file dplay.c.
119{
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 112 of file dplay.c.
114{
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
◆ connectionsInitialized
|
static |
Definition at line 5106 of file dplay.c.
Referenced by DP_FreeConnections(), and DP_InitConnections().
◆ dp2_vt
|
static |
Definition at line 6140 of file dplay.c.
Referenced by dplay_create().
◆ dp2A_vt
|
static |
Definition at line 6176 of file dplay.c.
Referenced by dplay_create().
◆ dp3_vt
|
static |
Definition at line 6212 of file dplay.c.
Referenced by dplay_create().
◆ dp3A_vt
|
static |
Definition at line 6263 of file dplay.c.
Referenced by dplay_create().
◆ dp4_vt
|
static |
Definition at line 6314 of file dplay.c.
Referenced by dplay_create().
◆ dp4A_vt
|
static |
Definition at line 6371 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:907
static HRESULT WINAPI IDirectPlayImpl_Close(IDirectPlay *iface)
Definition: dplay.c:753
static HRESULT WINAPI IDirectPlayImpl_CreatePlayer(IDirectPlay *iface, DPID *player, LPSTR name, LPSTR fullname, HANDLE *event)
Definition: dplay.c:760
static HRESULT WINAPI IDirectPlayImpl_Initialize(IDirectPlay *iface, GUID *guid)
Definition: dplay.c:870
static HRESULT WINAPI IDirectPlayImpl_Receive(IDirectPlay *iface, DPID *from, DPID *to, DWORD flags, void *data, DWORD *size)
Definition: dplay.c:884
static HRESULT WINAPI IDirectPlayImpl_AddPlayerToGroup(IDirectPlay *iface, DPID group, DPID player)
Definition: dplay.c:745
static HRESULT WINAPI IDirectPlayImpl_EnumGroupPlayers(IDirectPlay *iface, DPID group, LPDPENUMPLAYERSCALLBACK enumplayercb, void *context, DWORD flags)
Definition: dplay.c:806
static HRESULT WINAPI IDirectPlayImpl_DeletePlayerFromGroup(IDirectPlay *iface, DPID group, DPID player)
Definition: dplay.c:777
static HRESULT WINAPI IDirectPlayImpl_Open(IDirectPlay *iface, DPSESSIONDESC *sdesc)
Definition: dplay.c:877
static HRESULT WINAPI IDirectPlayImpl_CreateGroup(IDirectPlay *iface, DPID *group, LPSTR name, LPSTR fullname)
Definition: dplay.c:769
static HRESULT WINAPI IDirectPlayImpl_EnumGroups(IDirectPlay *iface, DWORD session, LPDPENUMPLAYERSCALLBACK enumplayercb, void *context, DWORD flags)
Definition: dplay.c:814
static HRESULT WINAPI IDirectPlayImpl_EnumSessions(IDirectPlay *iface, DPSESSIONDESC *sdesc, DWORD timeout, LPDPENUMSESSIONSCALLBACK enumsessioncb, void *context, DWORD flags)
Definition: dplay.c:830
static HRESULT WINAPI IDirectPlayImpl_EnableNewPlayers(IDirectPlay *iface, BOOL enable)
Definition: dplay.c:799
static HRESULT WINAPI IDirectPlayImpl_GetPlayerCaps(IDirectPlay *iface, DPID player, DPCAPS *caps)
Definition: dplay.c:854
static HRESULT WINAPI IDirectPlayImpl_DestroyPlayer(IDirectPlay *iface, DPID player)
Definition: dplay.c:785
static HRESULT WINAPI IDirectPlayImpl_GetMessageCount(IDirectPlay *iface, DPID player, DWORD *count)
Definition: dplay.c:846
static ULONG WINAPI IDirectPlayImpl_AddRef(IDirectPlay *iface)
Definition: dplay.c:722
static HRESULT WINAPI IDirectPlayImpl_GetPlayerName(IDirectPlay *iface, DPID player, LPSTR name, DWORD *size_name, LPSTR fullname, DWORD *size_fullname)
Definition: dplay.c:861
static HRESULT WINAPI IDirectPlayImpl_Send(IDirectPlay *iface, DPID from, DPID to, DWORD flags, void *data, DWORD size)
Definition: dplay.c:899
static ULONG WINAPI IDirectPlayImpl_Release(IDirectPlay *iface)
Definition: dplay.c:732
static HRESULT WINAPI IDirectPlayImpl_QueryInterface(IDirectPlay *iface, REFIID riid, void **ppv)
Definition: dplay.c:716
static HRESULT WINAPI IDirectPlayImpl_DestroyGroup(IDirectPlay *iface, DPID group)
Definition: dplay.c:792
static HRESULT WINAPI IDirectPlayImpl_EnumPlayers(IDirectPlay *iface, DWORD session, LPDPENUMPLAYERSCALLBACK enumplayercb, void *context, DWORD flags)
Definition: dplay.c:822
static HRESULT WINAPI IDirectPlayImpl_SaveSession(IDirectPlay *iface, LPSTR reserved)
Definition: dplay.c:892
static HRESULT WINAPI IDirectPlayImpl_GetCaps(IDirectPlay *iface, DPCAPS *caps)
Definition: dplay.c:839
Definition at line 916 of file dplay.c.
Referenced by dplay_create().
◆ kludgePlayerGroupId
|
static |
Definition at line 84 of file dplay.c.
Referenced by DP_NextObjectId().
