#include "wine/test.h"
#include <stdio.h>
#include <dplay.h>
#include <dplobby.h>
#include <netfw.h>
#include <winsock2.h>
#include "pshpack1.h"
#include "poppack.h"

Include dependency graph for dplayx.c:

Classes
struct	tagCallbackData

struct	provider_data

struct	EnumSessionsParam

struct	OpenParam

struct	CreatePlayerParam

struct	SpHeader

struct	MessageHeader

struct	SpData

struct	PackedPlayer

struct	SuperPackedPlayer

struct	EnumSessionsRequest

struct	EnumSessionsReply

struct	RequestPlayerId

struct	RequestPlayerReply

struct	AddForwardRequest

struct	SuperEnumPlayersReply

struct	AddForwardReply

struct	AddForward

struct	AddForwardAck

struct	CreatePlayer

struct	GameMessage

struct	Ping

struct	AddPlayerToGroup

struct	GroupDataChanged

struct	ExpectedPlayer

struct	CheckPlayerListCallbackData

struct	ExpectedSession

struct	CheckSessionListCallbackData

struct	GetPlayerIdsCallbackData

Macros
#define	COBJMACROS

#define	INITGUID

#define	check(expected, result)

#define	checkLP(expected, result)

#define	checkHR(expected, result)

#define	checkStr(expected, result)

#define	checkFlags(expected, result, flags) checkFlags_(__LINE__, expected, result, flags)

#define	checkGuid(expected, result)

#define	checkConv(expected, result, function)

#define	AW(str, ansi) ((ansi) ? (const void ) str : (const void ) L##str)

#define	FLAGS_DPCONNECTION (1<<0)

#define	FLAGS_DPENUMPLAYERS (1<<1)

#define	FLAGS_DPENUMGROUPS (1<<2)

#define	FLAGS_DPPLAYER (1<<3)

#define	FLAGS_DPGROUP (1<<4)

#define	FLAGS_DPENUMSESSIONS (1<<5)

#define	FLAGS_DPGETCAPS (1<<6)

#define	FLAGS_DPGET (1<<7)

#define	FLAGS_DPRECEIVE (1<<8)

#define	FLAGS_DPSEND (1<<9)

#define	FLAGS_DPSET (1<<10)

#define	FLAGS_DPMESSAGEQUEUE (1<<11)

#define	FLAGS_DPCONNECT (1<<12)

#define	FLAGS_DPOPEN (1<<13)

#define	FLAGS_DPSESSION (1<<14)

#define	FLAGS_DPLCONNECTION (1<<15)

#define	FLAGS_DPESC (1<<16)

#define	FLAGS_DPCAPS (1<<17)

#define	bindUdp(port) bindUdp_( __LINE__, port )

#define	listenTcp(port) listenTcp_( __LINE__, port )

#define	acceptTcp(listenSock) acceptTcp_( __LINE__, listenSock )

#define	checkNoMoreAccepts(listenSock) checkNoMoreAccepts_( __LINE__, listenSock )

#define	connectTcp(port) connectTcp_( __LINE__, port )

#define	connectUdp(port) connectUdp_( __LINE__, port)

#define	receiveMessage(sock, buffer, size) receiveMessage_( __LINE__, sock, buffer, size )

#define	checkNoMoreMessages(sock) checkNoMoreMessages_( __LINE__, sock )

#define	checkSpHeader(header, expectedSize) checkSpHeader_( __LINE__, header, expectedSize )

#define	checkMessageHeader(header, expectedCommand) checkMessageHeader_( __LINE__, header, expectedCommand )

#define	checkSpData(spData) checkSpData_( __LINE__, spData, udpPort )

#define	checkPackedPlayer(player, expectedFlags, expectedId, expectedShortNameLength, expectedLongNameLength, expectedPlayerDataSize, expectedSystemPlayerId)

#define	checkGameMessage(message, expectedFromId, expectedToId) checkGameMessage_( __LINE__, message, expectedFromId, expectedToId )

#define	receiveEnumSessionsRequest(sock, expectedAppGuid, expectedPassword, expectedFlags) receiveEnumSessionsRequest_( __LINE__, sock, expectedAppGuid, expectedPassword, expectedFlags )

#define	sendEnumSessionsReply(sock, port, dpsd) sendEnumSessionsReply_( __LINE__, sock, port, dpsd )

#define	receiveRequestPlayerId(sock, expectedFlags) receiveRequestPlayerId_( __LINE__, sock, expectedFlags )

#define	sendRequestPlayerReply(sock, port, id, result) sendRequestPlayerReply_( __LINE__, sock, port, id, result )

#define	receiveAddForwardRequest(sock, expectedPlayerId, expectedPassword, expectedTickCount, udpPort) receiveAddForwardRequest_( __LINE__, sock, expectedPlayerId, expectedPassword, expectedTickCount, udpPort )

#define	sendSuperEnumPlayersReply(sock, tcpPort, udpPort, dpsd, sessionName) sendSuperEnumPlayersReply_( __LINE__, sock, tcpPort, udpPort, dpsd, sessionName )

#define	SHORT_NAME L"short name"

#define	LONG_NAME L"long name"

#define	sendAddForwardReply(sock, port, result) sendAddForwardReply_( __LINE__, sock, port, result )

#define	sendAddForward(sock, port, tcpPort, udpPort) sendAddForward_( __LINE__, sock, port, tcpPort, udpPort )

#define	receiveAddForwardAck(sock, expectedPlayerId) receiveAddForwardAck_( __LINE__, sock, expectedPlayerId )

#define	receiveCreatePlayer(sock, expectedPlayerId, expectedFlags, expectedShortName, expectedLongName, expectedPlayerData, expectedPlayerDataSize)

#define	sendCreatePlayer(sock, tcpPort, udpPort, shortName, longName, playerData, playerDataSize) sendCreatePlayer_( __LINE__, sock, tcpPort, udpPort, shortName, longName, playerData, playerDataSize )

#define	receiveGuaranteedGameMessage(sock, expectedFromId, expectedToId, expectedData, expectedDataSize) receiveGuaranteedGameMessage_( __LINE__, sock, expectedFromId, expectedToId, expectedData, expectedDataSize )

#define	receiveGameMessage(sock, expectedFromId, expectedToId, expectedData, expectedDataSize) receiveGameMessage_( __LINE__, sock, expectedFromId, expectedToId, expectedData, expectedDataSize )

#define	sendGuaranteedGameMessage(sock, port, fromId, toId, data, dataSize) sendGuaranteedGameMessage_( __LINE__, sock, port, fromId, toId, data, dataSize )

#define	sendGameMessage(sock, fromId, toId, data, dataSize) sendGameMessage_( __LINE__, sock, fromId, toId, data, dataSize )

#define	sendPing(sock, port, fromId, tickCount) sendPing_( __LINE__, sock, port, fromId, tickCount )

#define	receivePingReply(sock, expectedFromId, expectedTickCount) receivePingReply_( __LINE__, sock, expectedFromId, expectedTickCount )

#define	receiveAddPlayerToGroup(sock, expectedPlayerId, expectedGroupId) receiveAddPlayerToGroup_( __LINE__, sock, expectedPlayerId, expectedGroupId )

#define	sendGroupDataChanged(sock, port, groupId, data, dataSize) sendGroupDataChanged_( __LINE__, sock, port, groupId, data, dataSize )

#define	checkPlayerList(dp, expectedPlayers, expectedPlayerCount) checkPlayerList_( __LINE__, dp, expectedPlayers, expectedPlayerCount )

#define	checkGroupPlayerList(dp, group, expectedPlayers, expectedPlayerCount) checkGroupPlayerList_( __LINE__, dp, group, expectedPlayers, expectedPlayerCount )

#define	checkGroupList(dp, expectedGroups, expectedGroupCount) checkGroupList_( __LINE__, dp, expectedGroups, expectedGroupCount )

#define	checkPlayerExists(dp, expectedDpid, expectedPlayerType, expectedShortName, expectedLongName, expectedFlags, expectedPlayerData, expectedPlayerDataSize)

#define	check_Open(dp, dpsd, serverDpsd, idRequestExpected, forwardRequestExpected, listenPort, expectedPassword, idReplyHr, addForwardReplyHr, expectedHr)

#define	joinSession(dp, dpsd, serverDpsd, sendSock, recvSock, udpPort) joinSession_( __LINE__, dp, dpsd, serverDpsd, sendSock, recvSock, udpPort )

#define	check_EnumSessions(dp, dpsd, flags, expectedHr, expectedSessionCount, timeoutExpected, requestExpected, expectedPassword, replyCount, ansi, hrTodo)

#define	check_EnumSessions_async(dpsd, dp, ansi) check_EnumSessions_async_( __LINE__, dpsd, dp, ansi )

#define	N_SESSIONS 6

#define	checkCreatePlayerOrGroupMessage(dp, expectedType, expectedDpid, expectedCurrentPlayers, expectedPlayerData, expectedPlayerDataSize, expectedShortName, expectedLongName, expectedParent, expectedFlags)

#define	checkPlayerMessage(dp, expectedFromId, expectedData, expectedDataSize) checkPlayerMessage_( __LINE__, dp, expectedFromId, expectedData, expectedDataSize )

#define	checkNoMorePlayerMessages(dp) checkNoMorePlayerMessages_( __LINE__, dp )

#define	checkCreatePlayerOrGroupMessages(dp, expectedType, expectedDpid, expectedCurrentPlayers, expectedPlayerData, expectedPlayerDataSize, expectedShortName, expectedLongName, expectedParent, expectedFlags)

#define	check_CreatePlayer(dp, dpid, name, flags, expectedHr, expectedDpid, recvSock, requestExpected, expectedFlags, expectedShortName, expectedShortNameA, expectedLongName, expectedLongNameA, expectedCurrentPlayers)

#define	createPlayer(dp, inDpid, event, data, dataSize, flags, sendSock, recvSock) createPlayer_( __LINE__, dp, inDpid, event, data, dataSize, flags, sendSock, recvSock )

#define	checkAddPlayerToGroupMessage(dp, expectedGroupId, expectedPlayerId) checkAddPlayerToGroupMessage_( __LINE__, dp, expectedGroupId, expectedPlayerId )

#define	checkSetPlayerOrGroupDataMessage(dp, expectedPlayerType, expectedDpid, expectedData, expectedDataSize) checkSetPlayerOrGroupDataMessage_( __LINE__, dp, expectedPlayerType, expectedDpid, expectedData, expectedDataSize )

Typedefs
typedef struct tagCallbackData	CallbackData

typedef struct tagCallbackData *	lpCallbackData

Enumerations
enum	firewall_op { APP_ADD , APP_REMOVE , APP_ADD , APP_REMOVE , APP_ADD , APP_REMOVE }

Functions
static	HRESULT (WINAPI *pDirectPlayEnumerateA)(LPDPENUMDPCALLBACKA

static LPCSTR	dwFlags2str (DWORD dwFlags, DWORD flagType)

static void	checkFlags_ (unsigned line, DWORD expected, DWORD result, DWORD flags)

static const char *	dbgStrAW (const void *str, BOOL ansi)

static int	strcmpAW (const void str0, const void str1, BOOL ansi)

	DEFINE_GUID (appGuid, 0xbdcfe03e, 0xf0ec, 0x415b, 0x82, 0x11, 0x6f, 0x86, 0xd8, 0x19, 0x7f, 0xe1)

	DEFINE_GUID (appGuid2, 0x93417d3f, 0x7d26, 0x46ba, 0xb5, 0x76, 0xfe, 0x4b, 0x20, 0xbb, 0xad, 0x70)

	DEFINE_GUID (GUID_NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

	DEFINE_GUID (invalid_guid, 0x7b48b707, 0x0034, 0xc000, 0x02, 0x00, 0x00, 0x00, 0xec, 0xf6, 0x32, 0x00)

static LPSTR	get_temp_buffer (void)

static LPCSTR	Guid2str (const GUID *guid)

static LPCSTR	dpResult2str (HRESULT hr)

static LPCSTR	dpMsgType2str (DWORD dwType)

static char	dpid2char (DPID *dpid, DWORD dpidSize, DPID idPlayer)

static void	check_messages (IDirectPlay4 pDP, DPID dpid, DWORD dpidSize, lpCallbackData callbackData)

static DWORD CALLBACK	enumSessionsProc (void *p)

static HANDLE	enumSessionsAsync (IDirectPlay4 dp, DPSESSIONDESC2 dpsd, DWORD timeout, LPDPENUMSESSIONSCALLBACK2 callback, void *context, DWORD flags)

static HRESULT	enumSessionsAsyncWait (EnumSessionsParam *param, DWORD timeout)

static DWORD CALLBACK	openProc (void *p)

static OpenParam *	openAsync (IDirectPlay4 dp, DPSESSIONDESC2 dpsd, DWORD flags)

static HRESULT	openAsyncWait (OpenParam *param, DWORD timeout)

static DWORD CALLBACK	createPlayerProc (void *p)

static CreatePlayerParam *	createPlayerAsync (IDirectPlay4 dp, DPID dpid, DPNAME name, HANDLE event, void data, DWORD dataSize, DWORD flags)

static HRESULT	createPlayerAsyncWait (CreatePlayerParam *param, DWORD timeout)

static SOCKET	bindUdp_ (int line, unsigned short port)

static SOCKET	listenTcp_ (int line, unsigned short port)

static SOCKET	acceptTcp_ (int line, SOCKET listenSock)

static void	checkNoMoreAccepts_ (int line, SOCKET listenSock)

static SOCKET	connectTcp_ (int line, unsigned short port)

static SOCKET	connectUdp_ (int line, unsigned short port)

static int	receiveMessage_ (int line, SOCKET sock, void *buffer, int size)

static void	checkNoMoreMessages_ (int line, SOCKET sock)

static unsigned short	checkSpHeader_ (int line, SpHeader *header, DWORD expectedSize)

static void	checkMessageHeader_ (int line, MessageHeader *header, WORD expectedCommand)

static void	checkSpData_ (int line, SpData spData, unsigned short udpPort)

static void	checkPackedPlayer_ (int line, PackedPlayer *player, DWORD expectedFlags, DPID expectedId, DWORD expectedShortNameLength, DWORD expectedLongNameLength, DWORD expectedPlayerDataSize, DPID expectedSystemPlayerId)

static void	checkGameMessage_ (int line, GameMessage *message, DPID expectedFromId, DPID expectedToId)

static unsigned short	receiveEnumSessionsRequest_ (int line, SOCKET sock, const GUID expectedAppGuid, const WCHAR expectedPassword, DWORD expectedFlags)

static void	sendEnumSessionsReply_ (int line, SOCKET sock, unsigned short port, const DPSESSIONDESC2 *dpsd)

static unsigned short	receiveRequestPlayerId_ (int line, SOCKET sock, DWORD expectedFlags)

static void	sendRequestPlayerReply_ (int line, SOCKET sock, unsigned short port, DPID id, HRESULT result)

static unsigned short	receiveAddForwardRequest_ (int line, SOCKET sock, DPID expectedPlayerId, const WCHAR expectedPassword, DWORD expectedTickCount, unsigned short udpPort)

static void	sendSuperEnumPlayersReply_ (int line, SOCKET sock, unsigned short tcpPort, unsigned short udpPort, const DPSESSIONDESC2 dpsd, const WCHAR sessionName)

static void	sendAddForwardReply_ (int line, SOCKET sock, unsigned short port, HRESULT result)

static void	sendAddForward_ (int line, SOCKET sock, unsigned short port, unsigned short tcpPort, unsigned short udpPort)

static unsigned short	receiveAddForwardAck_ (int line, SOCKET sock, DPID expectedPlayerId)

static unsigned short	receiveCreatePlayer_ (int line, SOCKET sock, DPID expectedPlayerId, DWORD expectedFlags, const WCHAR expectedShortName, const WCHAR expectedLongName, void *expectedPlayerData, DWORD expectedPlayerDataSize)

static void	sendCreatePlayer_ (int line, SOCKET sock, unsigned short tcpPort, unsigned short udpPort, const WCHAR shortName, const WCHAR longName, void *playerData, DWORD playerDataSize)

static unsigned short	receiveGuaranteedGameMessage_ (int line, SOCKET sock, DPID expectedFromId, DPID expectedToId, void *expectedData, DWORD expectedDataSize)

static void	receiveGameMessage_ (int line, SOCKET sock, DPID expectedFromId, DPID expectedToId, void *expectedData, DWORD expectedDataSize)

static void	sendGuaranteedGameMessage_ (int line, SOCKET sock, unsigned short port, DPID fromId, DPID toId, void *data, DWORD dataSize)

static void	sendGameMessage_ (int line, SOCKET sock, DPID fromId, DPID toId, void *data, DWORD dataSize)

static void	sendPing_ (int line, SOCKET sock, unsigned short port, DPID fromId, DWORD tickCount)

static unsigned short	receivePingReply_ (int line, SOCKET sock, DPID expectedFromId, DWORD expectedTickCount)

static unsigned short	receiveAddPlayerToGroup_ (int line, SOCKET sock, DPID expectedPlayerId, DPID expectedGroupId)

static void	sendGroupDataChanged_ (int line, SOCKET sock, unsigned short port, DPID groupId, void *data, DWORD dataSize)

static void	init_TCPIP_provider (IDirectPlay4 *pDP, LPCSTR strIPAddressString, WORD port)

static BOOL CALLBACK	EnumSessions_cb_join (LPCDPSESSIONDESC2 lpThisSD, LPDWORD lpdwTimeOut, DWORD dwFlags, LPVOID lpContext)

static void	test_DirectPlayCreate (void)

static BOOL CALLBACK	callback_providersA (GUID guid, char name, DWORD major, DWORD minor, void *arg)

static BOOL CALLBACK	callback_providersW (GUID guid, WCHAR name, DWORD major, DWORD minor, void *arg)

static void	test_EnumerateProviders (void)

static BOOL CALLBACK	EnumAddress_cb2 (REFGUID guidDataType, DWORD dwDataSize, LPCVOID lpData, LPVOID lpContext)

static BOOL CALLBACK	EnumConnections_cb (LPCGUID lpguidSP, LPVOID lpConnection, DWORD dwConnectionSize, LPCDPNAME lpName, DWORD dwFlags, LPVOID lpContext)

static void	test_EnumConnections (void)

static BOOL CALLBACK	EnumConnections_cb2 (LPCGUID lpguidSP, LPVOID lpConnection, DWORD dwConnectionSize, LPCDPNAME lpName, DWORD dwFlags, LPVOID lpContext)

static void	test_InitializeConnection (void)

static void	test_GetCaps (void)

static BOOL CALLBACK	EnumAddressesCallback (REFGUID guidDataType, DWORD size, const void data, void context)

static void	test_EnumAddresses (void)

static BOOL CALLBACK	EnumAddressTypeCallback (REFGUID guidDataType, LPVOID lpContext, DWORD flags)

static void	test_EnumAddressTypes (void)

static BOOL CALLBACK	EnumSessions_cb2 (LPCDPSESSIONDESC2 lpThisSD, LPDWORD lpdwTimeOut, DWORD dwFlags, LPVOID lpContext)

static BOOL CALLBACK	checkPlayerListCallback (DPID dpid, DWORD playerType, const DPNAME name, DWORD flags, void context)

static void	checkPlayerList_ (int line, IDirectPlay4 dp, ExpectedPlayer expectedPlayers, int expectedPlayerCount)

static void	checkGroupPlayerList_ (int line, DPID group, IDirectPlay4 dp, ExpectedPlayer expectedPlayers, int expectedPlayerCount)

static void	checkGroupList_ (int line, IDirectPlay4 dp, ExpectedPlayer expectedGroups, int expectedGroupCount)

static void	checkPlayerExists_ (int line, IDirectPlay4 dp, DPID expectedDpid, DWORD expectedPlayerType, const char expectedShortName, const char expectedLongName, DWORD expectedFlags, BYTE expectedPlayerData, DWORD expectedPlayerDataSize)

static void	check_Open_ (int line, IDirectPlay4A dp, DPSESSIONDESC2 dpsd, const DPSESSIONDESC2 serverDpsd, BOOL idRequestExpected, BOOL forwardRequestExpected, unsigned short listenPort, const WCHAR expectedPassword, HRESULT idReplyHr, HRESULT addForwardReplyHr, HRESULT expectedHr)

static BOOL CALLBACK	countSessionsCallback (const DPSESSIONDESC2 thisSd, DWORD timeout, DWORD flags, void *context)

static void	test_Open (void)

static void	test_interactive_Open (void)

static void	joinSession_ (int line, IDirectPlay4 dp, DPSESSIONDESC2 dpsd, DPSESSIONDESC2 serverDpsd, SOCKET sendSock, SOCKET recvSock, unsigned short udpPort)

static void	test_ADDFORWARD (void)

static BOOL CALLBACK	EnumSessions_cb (LPCDPSESSIONDESC2 lpThisSD, LPDWORD lpdwTimeOut, DWORD dwFlags, LPVOID lpContext)

static IDirectPlay4 *	create_session (DPSESSIONDESC2 *lpdpsd)

static BOOL CALLBACK	checkSessionListCallback (const DPSESSIONDESC2 thisSd, DWORD timeout, DWORD flags, void *context)

static void	check_EnumSessions_ (int line, IDirectPlay4 dp, DPSESSIONDESC2 dpsd, DWORD flags, HRESULT expectedHr, DWORD expectedSessionCount, BOOL timeoutExpected, BOOL requestExpected, const WCHAR *expectedPassword, DWORD replyCount, BOOL ansi, BOOL hrTodo)

static void	check_EnumSessions_async_ (int line, DPSESSIONDESC2 dpsd, IDirectPlay4 dp, BOOL ansi)

static void	test_EnumSessions (void)

static void	test_interactive_EnumSessions (void)

static void	test_SessionDesc (void)

static DPID	checkCreatePlayerOrGroupMessage_ (int line, IDirectPlay4 dp, DWORD expectedType, DPID expectedDpid, DWORD expectedCurrentPlayers, void expectedPlayerData, DWORD expectedPlayerDataSize, const char expectedShortName, const char expectedLongName, DPID expectedParent, DWORD expectedFlags)

static DPID	checkPlayerMessage_ (int line, IDirectPlay4 dp, DPID expectedFromId, void expectedData, DWORD expectedDataSize)

static void	checkNoMorePlayerMessages_ (int line, IDirectPlay4 *dp)

static BOOL CALLBACK	getPlayerIdsCallback (DPID dpid, DWORD playerType, const DPNAME name, DWORD flags, void context)

static void	checkCreatePlayerOrGroupMessages_ (int line, IDirectPlay4 dp, DWORD expectedType, DPID expectedDpid, DWORD expectedCurrentPlayers, void expectedPlayerData, DWORD expectedPlayerDataSize, const char expectedShortName, const char expectedLongName, DPID expectedParent, DWORD expectedFlags)

static void	check_CreatePlayer_ (int line, IDirectPlay4 dp, DPID dpid, DPNAME name, DWORD flags, HRESULT expectedHr, DPID expectedDpid, SOCKET recvSock, BOOL requestExpected, DWORD expectedFlags, const WCHAR expectedShortName, const char expectedShortNameA, const WCHAR expectedLongName, const char *expectedLongNameA, DWORD expectedCurrentPlayers)

static void	test_CreatePlayer (void)

static void	test_interactive_CreatePlayer (void)

static void	createPlayer_ (int line, IDirectPlay4 dp, DPID inDpid, HANDLE event, void data, DWORD dataSize, DWORD flags, SOCKET sendSock, SOCKET recvSock)

static void	test_CREATEPLAYER (void)

static void	test_GetPlayerCaps (void)

static void	test_PlayerData (void)

static void	test_PlayerName (void)

static BOOL CALLBACK	EnumSessions_cb_join_secure (LPCDPSESSIONDESC2 lpThisSD, LPDWORD lpdwTimeOut, DWORD dwFlags, LPVOID lpContext)

static void	test_GetPlayerAccount (void)

static BOOL CALLBACK	EnumAddress_cb (REFGUID guidDataType, DWORD dwDataSize, LPCVOID lpData, LPVOID lpContext)

static void	test_GetPlayerAddress (void)

static void	test_GetPlayerFlags (void)

static void	test_CreateGroup (void)

static void	test_GroupOwner (void)

static BOOL CALLBACK	EnumPlayers_cb (DPID dpId, DWORD dwPlayerType, LPCDPNAME lpName, DWORD dwFlags, LPVOID lpContext)

static BOOL CALLBACK	EnumSessions_cb_EnumPlayers (LPCDPSESSIONDESC2 lpThisSD, LPDWORD lpdwTimeOut, DWORD dwFlags, LPVOID lpContext)

static void	test_EnumPlayers (void)

static BOOL CALLBACK	EnumGroups_cb (DPID dpId, DWORD dwPlayerType, LPCDPNAME lpName, DWORD dwFlags, LPVOID lpContext)

static BOOL CALLBACK	EnumSessions_cb_EnumGroups (LPCDPSESSIONDESC2 lpThisSD, LPDWORD lpdwTimeOut, DWORD dwFlags, LPVOID lpContext)

static void	test_EnumGroups (void)

static void	test_EnumGroupsInGroup (void)

static void	test_groups_p2p (void)

static void	test_groups_cs (void)

static void	test_Send (void)

static void	test_interactive_Send (void)

static void	test_Receive (void)

static void	test_interactive_Receive (void)

static void	test_PING (void)

static DPID	checkAddPlayerToGroupMessage_ (int line, IDirectPlay4 *dp, DPID expectedGroupId, DPID expectedPlayerId)

static void	test_AddPlayerToGroup (void)

static DPID	checkSetPlayerOrGroupDataMessage_ (int line, IDirectPlay4 dp, DWORD expectedPlayerType, DPID expectedDpid, void expectedData, DWORD expectedDataSize)

static void	test_GROUPDATACHANGED (void)

static void	test_GetMessageCount (void)

static void	test_GetMessageQueue (void)

static void	test_interactive_GetMessageQueue (void)

static void	test_remote_data_replication (void)

static void	test_host_migration (void)

static void	test_COM (void)

static void	test_COM_dplobby (void)

static BOOL	is_process_elevated (void)

static BOOL	is_firewall_enabled (void)

static HRESULT	set_firewall (enum firewall_op op)

static BOOL	is_stub_dll (const char *filename)

	START_TEST (dplayx)

Variables
static void static void static LPDIRECTPLAY *	lplpDP

static void static void static LPDIRECTPLAY IUnknown *	pUnk

static int	enum_addresses_cb_count = 0

static int	enum_address_cb_count = 0

Macro Definition Documentation

◆ acceptTcp

#define acceptTcp ( listenSock ) acceptTcp_( __LINE__, listenSock )

Definition at line 1074 of file dplayx.c.

◆ AW

#define AW	(	str,
		ansi
	)	((ansi) ? (const void ) str : (const void ) L##str)

Definition at line 78 of file dplayx.c.

◆ bindUdp

#define bindUdp ( port ) bindUdp_( __LINE__, port )

Definition at line 1023 of file dplayx.c.

◆ check

#define check	(	expected,
		result
	)

Value:

    ok( (expected) == (result),                 \
        "expected=%d got=%d\n",                 \
        (int)(expected), (int)(result) );

Definition at line 43 of file dplayx.c.

◆ check_CreatePlayer

#define check_CreatePlayer	(	dp,
		dpid,
		name,
		flags,
		expectedHr,
		expectedDpid,
		recvSock,
		requestExpected,
		expectedFlags,
		expectedShortName,
		expectedShortNameA,
		expectedLongName,
		expectedLongNameA,
		expectedCurrentPlayers
	)

Value:

        check_CreatePlayer_( __LINE__, dp, dpid, name, flags, expectedHr, expectedDpid, recvSock, requestExpected, \
                             expectedFlags, expectedShortName, expectedShortNameA, expectedLongName, expectedLongNameA, \
                             expectedCurrentPlayers )

Definition at line 4881 of file dplayx.c.

◆ check_EnumSessions

#define check_EnumSessions	(	dp,
		dpsd,
		flags,
		expectedHr,
		expectedSessionCount,
		timeoutExpected,
		requestExpected,
		expectedPassword,
		replyCount,
		ansi,
		hrTodo
	)

Value:

check_EnumSessions_( __LINE__, dp, dpsd, flags, expectedHr, expectedSessionCount, timeoutExpected, \

requestExpected, expectedPassword, replyCount, ansi, hrTodo )

check_EnumSessions_

static void check_EnumSessions_(int line, IDirectPlay4 *dp, DPSESSIONDESC2 *dpsd, DWORD flags, HRESULT expectedHr, DWORD expectedSessionCount, BOOL timeoutExpected, BOOL requestExpected, const WCHAR *expectedPassword, DWORD replyCount, BOOL ansi, BOOL hrTodo)

Definition: dplayx.c:3816

ansi

static UINT WPARAM LPARAM BOOL ansi

Definition: misc.c:135

Definition at line 3812 of file dplayx.c.

◆ check_EnumSessions_async

#define check_EnumSessions_async	(	dpsd,
		dp,
		ansi
	)	check_EnumSessions_async_( __LINE__, dpsd, dp, ansi )

Definition at line 3920 of file dplayx.c.

◆ check_Open

#define check_Open	(	dp,
		dpsd,
		serverDpsd,
		idRequestExpected,
		forwardRequestExpected,
		listenPort,
		expectedPassword,
		idReplyHr,
		addForwardReplyHr,
		expectedHr
	)

Value:

check_Open_( __LINE__, dp, dpsd, serverDpsd, idRequestExpected, forwardRequestExpected, listenPort, expectedPassword, \

idReplyHr, addForwardReplyHr, expectedHr )

check_Open_

static void check_Open_(int line, IDirectPlay4A *dp, DPSESSIONDESC2 *dpsd, const DPSESSIONDESC2 *serverDpsd, BOOL idRequestExpected, BOOL forwardRequestExpected, unsigned short listenPort, const WCHAR *expectedPassword, HRESULT idReplyHr, HRESULT addForwardReplyHr, HRESULT expectedHr)

Definition: dplayx.c:3156

Definition at line 3152 of file dplayx.c.

◆ checkAddPlayerToGroupMessage

#define checkAddPlayerToGroupMessage	(	dp,
		expectedGroupId,
		expectedPlayerId
	)	checkAddPlayerToGroupMessage_( __LINE__, dp, expectedGroupId, expectedPlayerId )

Definition at line 9141 of file dplayx.c.

◆ checkConv

#define checkConv	(	expected,
		result,
		function
	)

Value:

    ok( (expected) == (result),                  \
        "expected=0x%08x(%s) got=0x%08lx(%s)\n", \
        expected, function(expected),            \
        result, function(result) );

Definition at line 72 of file dplayx.c.

◆ checkCreatePlayerOrGroupMessage

#define checkCreatePlayerOrGroupMessage	(	dp,
		expectedType,
		expectedDpid,
		expectedCurrentPlayers,
		expectedPlayerData,
		expectedPlayerDataSize,
		expectedShortName,
		expectedLongName,
		expectedParent,
		expectedFlags
	)

Value:

        checkCreatePlayerOrGroupMessage_( __LINE__, dp, expectedType, expectedDpid, expectedCurrentPlayers, \
                                          expectedPlayerData, expectedPlayerDataSize, expectedShortName, \
                                          expectedLongName, expectedParent, expectedFlags )

Definition at line 4708 of file dplayx.c.

◆ checkCreatePlayerOrGroupMessages

#define checkCreatePlayerOrGroupMessages	(	dp,
		expectedType,
		expectedDpid,
		expectedCurrentPlayers,
		expectedPlayerData,
		expectedPlayerDataSize,
		expectedShortName,
		expectedLongName,
		expectedParent,
		expectedFlags
	)

Value:

        checkCreatePlayerOrGroupMessages_( __LINE__, dp, expectedType, expectedDpid, expectedCurrentPlayers, \
                                           expectedPlayerData, expectedPlayerDataSize, expectedShortName, \
                                           expectedLongName, expectedParent, expectedFlags )

Definition at line 4844 of file dplayx.c.

◆ checkFlags

#define checkFlags	(	expected,
		result,
		flags
	)	checkFlags_(__LINE__, expected, result, flags)

Definition at line 60 of file dplayx.c.

◆ checkGameMessage

#define checkGameMessage	(	message,
		expectedFromId,
		expectedToId
	)	checkGameMessage_( __LINE__, message, expectedFromId, expectedToId )

Definition at line 1254 of file dplayx.c.

◆ checkGroupList

#define checkGroupList	(	dp,
		expectedGroups,
		expectedGroupCount
	)	checkGroupList_( __LINE__, dp, expectedGroups, expectedGroupCount )

Definition at line 3093 of file dplayx.c.

◆ checkGroupPlayerList

#define checkGroupPlayerList	(	dp,
		group,
		expectedPlayers,
		expectedPlayerCount
	)	checkGroupPlayerList_( __LINE__, dp, group, expectedPlayers, expectedPlayerCount )

Definition at line 3070 of file dplayx.c.

◆ checkGuid

#define checkGuid	(	expected,
		result
	)

Value:

    ok( IsEqualGUID(expected, result),          \
        "expected=%s got=%s\n",                 \
        Guid2str(expected), Guid2str(result) );

Definition at line 68 of file dplayx.c.

◆ checkHR

#define checkHR	(	expected,
		result
	)

Value:

    ok( (expected) == (result),                         \
        "expected=%s got=%s\n",                         \
        dpResult2str(expected), dpResult2str(result) );

Definition at line 51 of file dplayx.c.

◆ checkLP

#define checkLP	(	expected,
		result
	)

Value:

    ok( (expected) == (result),                 \
        "expected=%p got=%p\n",                 \
        expected, result );

Definition at line 47 of file dplayx.c.

◆ checkMessageHeader

#define checkMessageHeader	(	header,
		expectedCommand
	)	checkMessageHeader_( __LINE__, header, expectedCommand )

Definition at line 1201 of file dplayx.c.

◆ checkNoMoreAccepts

#define checkNoMoreAccepts ( listenSock ) checkNoMoreAccepts_( __LINE__, listenSock )

Definition at line 1097 of file dplayx.c.

◆ checkNoMoreMessages

#define checkNoMoreMessages ( sock ) checkNoMoreMessages_( __LINE__, sock )

Definition at line 1171 of file dplayx.c.

◆ checkNoMorePlayerMessages

#define checkNoMorePlayerMessages ( dp ) checkNoMorePlayerMessages_( __LINE__, dp )

Definition at line 4811 of file dplayx.c.

◆ checkPackedPlayer

#define checkPackedPlayer	(	player,
		expectedFlags,
		expectedId,
		expectedShortNameLength,
		expectedLongNameLength,
		expectedPlayerDataSize,
		expectedSystemPlayerId
	)

Value:

checkPackedPlayer_( __LINE__, player, expectedFlags, expectedId, expectedShortNameLength, expectedLongNameLength, \

expectedPlayerDataSize, expectedSystemPlayerId )

checkPackedPlayer_

static void checkPackedPlayer_(int line, PackedPlayer *player, DWORD expectedFlags, DPID expectedId, DWORD expectedShortNameLength, DWORD expectedLongNameLength, DWORD expectedPlayerDataSize, DPID expectedSystemPlayerId)

Definition: dplayx.c:1230

Definition at line 1226 of file dplayx.c.

◆ checkPlayerExists

#define checkPlayerExists	(	dp,
		expectedDpid,
		expectedPlayerType,
		expectedShortName,
		expectedLongName,
		expectedFlags,
		expectedPlayerData,
		expectedPlayerDataSize
	)

Value:

checkPlayerExists_( __LINE__, dp, expectedDpid, expectedPlayerType, expectedShortName, expectedLongName, \

expectedFlags, expectedPlayerData, expectedPlayerDataSize )

checkPlayerExists_

static void checkPlayerExists_(int line, IDirectPlay4 *dp, DPID expectedDpid, DWORD expectedPlayerType, const char *expectedShortName, const char *expectedLongName, DWORD expectedFlags, BYTE *expectedPlayerData, DWORD expectedPlayerDataSize)

Definition: dplayx.c:3119

Definition at line 3115 of file dplayx.c.

◆ checkPlayerList

#define checkPlayerList	(	dp,
		expectedPlayers,
		expectedPlayerCount
	)	checkPlayerList_( __LINE__, dp, expectedPlayers, expectedPlayerCount )

Definition at line 3048 of file dplayx.c.

◆ checkPlayerMessage

#define checkPlayerMessage	(	dp,
		expectedFromId,
		expectedData,
		expectedDataSize
	)	checkPlayerMessage_( __LINE__, dp, expectedFromId, expectedData, expectedDataSize )

Definition at line 4787 of file dplayx.c.

◆ checkSetPlayerOrGroupDataMessage

#define checkSetPlayerOrGroupDataMessage	(	dp,
		expectedPlayerType,
		expectedDpid,
		expectedData,
		expectedDataSize
	)	checkSetPlayerOrGroupDataMessage_( __LINE__, dp, expectedPlayerType, expectedDpid, expectedData, expectedDataSize )

Definition at line 9223 of file dplayx.c.

◆ checkSpData

#define checkSpData ( spData ) checkSpData_( __LINE__, spData, udpPort )

Definition at line 1208 of file dplayx.c.

◆ checkSpHeader

#define checkSpHeader	(	header,
		expectedSize
	)	checkSpHeader_( __LINE__, header, expectedSize )

Definition at line 1189 of file dplayx.c.

◆ checkStr

#define checkStr	(	expected,
		result
	)

Value:

    ok( (result != NULL) && (!strcmp(expected, result)),        \
        "expected=%s got=%s\n",                                 \
        expected, result );

Definition at line 55 of file dplayx.c.

◆ COBJMACROS

#define COBJMACROS

Definition at line 20 of file dplayx.c.

◆ connectTcp

#define connectTcp ( port ) connectTcp_( __LINE__, port )

Definition at line 1112 of file dplayx.c.

◆ connectUdp

#define connectUdp ( port ) connectUdp_( __LINE__, port)

Definition at line 1131 of file dplayx.c.

◆ createPlayer

#define createPlayer	(	dp,
		inDpid,
		event,
		data,
		dataSize,
		flags,
		sendSock,
		recvSock
	)	createPlayer_( __LINE__, dp, inDpid, event, data, dataSize, flags, sendSock, recvSock )

Definition at line 5198 of file dplayx.c.

◆ FLAGS_DPCAPS

#define FLAGS_DPCAPS (1<<17)

◆ FLAGS_DPCONNECT

#define FLAGS_DPCONNECT (1<<12)

◆ FLAGS_DPCONNECTION

#define FLAGS_DPCONNECTION (1<<0)

◆ FLAGS_DPENUMGROUPS

#define FLAGS_DPENUMGROUPS (1<<2)

◆ FLAGS_DPENUMPLAYERS

#define FLAGS_DPENUMPLAYERS (1<<1)

◆ FLAGS_DPENUMSESSIONS

#define FLAGS_DPENUMSESSIONS (1<<5)

◆ FLAGS_DPESC

#define FLAGS_DPESC (1<<16)

◆ FLAGS_DPGET

#define FLAGS_DPGET (1<<7)

◆ FLAGS_DPGETCAPS

#define FLAGS_DPGETCAPS (1<<6)

◆ FLAGS_DPGROUP

#define FLAGS_DPGROUP (1<<4)

◆ FLAGS_DPLCONNECTION

#define FLAGS_DPLCONNECTION (1<<15)

◆ FLAGS_DPMESSAGEQUEUE

#define FLAGS_DPMESSAGEQUEUE (1<<11)

◆ FLAGS_DPOPEN

#define FLAGS_DPOPEN (1<<13)

◆ FLAGS_DPPLAYER

#define FLAGS_DPPLAYER (1<<3)

◆ FLAGS_DPRECEIVE

#define FLAGS_DPRECEIVE (1<<8)

◆ FLAGS_DPSEND

#define FLAGS_DPSEND (1<<9)

◆ FLAGS_DPSESSION

#define FLAGS_DPSESSION (1<<14)

◆ FLAGS_DPSET

#define FLAGS_DPSET (1<<10)

◆ INITGUID

#define INITGUID

Definition at line 23 of file dplayx.c.

◆ joinSession

#define joinSession	(	dp,
		dpsd,
		serverDpsd,
		sendSock,
		recvSock,
		udpPort
	)	joinSession_( __LINE__, dp, dpsd, serverDpsd, sendSock, recvSock, udpPort )

Definition at line 3570 of file dplayx.c.

◆ listenTcp

#define listenTcp ( port ) listenTcp_( __LINE__, port )

Definition at line 1046 of file dplayx.c.

◆ LONG_NAME

#define LONG_NAME L"long name"

◆ N_SESSIONS

#define N_SESSIONS 6

◆ receiveAddForwardAck

#define receiveAddForwardAck	(	sock,
		expectedPlayerId
	)	receiveAddForwardAck_( __LINE__, sock, expectedPlayerId )

Definition at line 1811 of file dplayx.c.

◆ receiveAddForwardRequest

#define receiveAddForwardRequest	(	sock,
		expectedPlayerId,
		expectedPassword,
		expectedTickCount,
		udpPort
	)	receiveAddForwardRequest_( __LINE__, sock, expectedPlayerId, expectedPassword, expectedTickCount, udpPort )

Definition at line 1419 of file dplayx.c.

◆ receiveAddPlayerToGroup

#define receiveAddPlayerToGroup	(	sock,
		expectedPlayerId,
		expectedGroupId
	)	receiveAddPlayerToGroup_( __LINE__, sock, expectedPlayerId, expectedGroupId )

Definition at line 2211 of file dplayx.c.

◆ receiveCreatePlayer

#define receiveCreatePlayer	(	sock,
		expectedPlayerId,
		expectedFlags,
		expectedShortName,
		expectedLongName,
		expectedPlayerData,
		expectedPlayerDataSize
	)

Value:

receiveCreatePlayer_( __LINE__, sock, expectedPlayerId, expectedFlags, expectedShortName, expectedLongName, \

expectedPlayerData, expectedPlayerDataSize )

receiveCreatePlayer_

static unsigned short receiveCreatePlayer_(int line, SOCKET sock, DPID expectedPlayerId, DWORD expectedFlags, const WCHAR *expectedShortName, const WCHAR *expectedLongName, void *expectedPlayerData, DWORD expectedPlayerDataSize)

Definition: dplayx.c:1837

sock

Definition: tcpcore.h:1455

Definition at line 1833 of file dplayx.c.

◆ receiveEnumSessionsRequest

#define receiveEnumSessionsRequest	(	sock,
		expectedAppGuid,
		expectedPassword,
		expectedFlags
	)	receiveEnumSessionsRequest_( __LINE__, sock, expectedAppGuid, expectedPassword, expectedFlags )

Definition at line 1262 of file dplayx.c.

◆ receiveGameMessage

#define receiveGameMessage	(	sock,
		expectedFromId,
		expectedToId,
		expectedData,
		expectedDataSize
	)	receiveGameMessage_( __LINE__, sock, expectedFromId, expectedToId, expectedData, expectedDataSize )

Definition at line 2057 of file dplayx.c.

◆ receiveGuaranteedGameMessage

#define receiveGuaranteedGameMessage	(	sock,
		expectedFromId,
		expectedToId,
		expectedData,
		expectedDataSize
	)	receiveGuaranteedGameMessage_( __LINE__, sock, expectedFromId, expectedToId, expectedData, expectedDataSize )

Definition at line 2029 of file dplayx.c.

◆ receiveMessage

#define receiveMessage	(	sock,
		buffer,
		size
	)	receiveMessage_( __LINE__, sock, buffer, size )

Definition at line 1150 of file dplayx.c.

◆ receivePingReply

#define receivePingReply	(	sock,
		expectedFromId,
		expectedTickCount
	)	receivePingReply_( __LINE__, sock, expectedFromId, expectedTickCount )

Definition at line 2185 of file dplayx.c.

◆ receiveRequestPlayerId

#define receiveRequestPlayerId	(	sock,
		expectedFlags
	)	receiveRequestPlayerId_( __LINE__, sock, expectedFlags )

Definition at line 1358 of file dplayx.c.

◆ sendAddForward

#define sendAddForward	(	sock,
		port,
		tcpPort,
		udpPort
	)	sendAddForward_( __LINE__, sock, port, tcpPort, udpPort )

Definition at line 1742 of file dplayx.c.

◆ sendAddForwardReply

#define sendAddForwardReply	(	sock,
		port,
		result
	)	sendAddForwardReply_( __LINE__, sock, port, result )

Definition at line 1705 of file dplayx.c.

◆ sendCreatePlayer

#define sendCreatePlayer	(	sock,
		tcpPort,
		udpPort,
		shortName,
		longName,
		playerData,
		playerDataSize
	)	sendCreatePlayer_( __LINE__, sock, tcpPort, udpPort, shortName, longName, playerData, playerDataSize )

Definition at line 1925 of file dplayx.c.

◆ sendEnumSessionsReply

#define sendEnumSessionsReply	(	sock,
		port,
		dpsd
	)	sendEnumSessionsReply_( __LINE__, sock, port, dpsd )

Definition at line 1309 of file dplayx.c.

◆ sendGameMessage

#define sendGameMessage	(	sock,
		fromId,
		toId,
		data,
		dataSize
	)	sendGameMessage_( __LINE__, sock, fromId, toId, data, dataSize )

Definition at line 2117 of file dplayx.c.

◆ sendGroupDataChanged

#define sendGroupDataChanged	(	sock,
		port,
		groupId,
		data,
		dataSize
	)	sendGroupDataChanged_( __LINE__, sock, port, groupId, data, dataSize )

Definition at line 2242 of file dplayx.c.

◆ sendGuaranteedGameMessage

#define sendGuaranteedGameMessage	(	sock,
		port,
		fromId,
		toId,
		data,
		dataSize
	)	sendGuaranteedGameMessage_( __LINE__, sock, port, fromId, toId, data, dataSize )

Definition at line 2080 of file dplayx.c.

◆ sendPing

#define sendPing	(	sock,
		port,
		fromId,
		tickCount
	)	sendPing_( __LINE__, sock, port, fromId, tickCount )

Definition at line 2146 of file dplayx.c.

◆ sendRequestPlayerReply

#define sendRequestPlayerReply	(	sock,
		port,
		id,
		result
	)	sendRequestPlayerReply_( __LINE__, sock, port, id, result )

Definition at line 1381 of file dplayx.c.

◆ sendSuperEnumPlayersReply

#define sendSuperEnumPlayersReply	(	sock,
		tcpPort,
		udpPort,
		dpsd,
		sessionName
	)	sendSuperEnumPlayersReply_( __LINE__, sock, tcpPort, udpPort, dpsd, sessionName )

Definition at line 1473 of file dplayx.c.

◆ SHORT_NAME

#define SHORT_NAME L"short name"

Typedef Documentation

◆ CallbackData

_Must_inspect_result_ _In_ PFLT_CALLBACK_DATA CallbackData

Definition at line 2090 of file fltkernel.h.

◆ lpCallbackData

typedef struct tagCallbackData * lpCallbackData

Enumeration Type Documentation

◆ firewall_op

enum firewall_op

Enumerator
APP_ADD
APP_REMOVE
APP_ADD
APP_REMOVE
APP_ADD
APP_REMOVE

Definition at line 10552 of file dplayx.c.

{
    APP_ADD,
    APP_REMOVE
};

Function Documentation

◆ acceptTcp_()

static SOCKET acceptTcp_	(	int	line,
		SOCKET	listenSock
	)

static

Definition at line 1075 of file dplayx.c.

{
    struct timeval timeout;
    SOCKADDR_IN addr;
    int addrSize;
    int wsResult;
    SOCKET sock;
    fd_set fds;
 
    FD_ZERO( &fds );
    FD_SET( listenSock, &fds );
    timeout.tv_sec = 2;
    timeout.tv_usec = 0;
    wsResult = select( listenSock + 1, &fds, NULL, &fds, &timeout );
    ok_( __FILE__, line )( wsResult != SOCKET_ERROR, "select() returned %d.\n", wsResult );
 
    addrSize = sizeof( addr );
    sock = accept( listenSock, (SOCKADDR *) &addr, &addrSize );
 
    return sock;
}

Referenced by check_Open_(), and joinSession_().

◆ bindUdp_()

static SOCKET bindUdp_	(	int	line,
		unsigned short	port
	)

static

Definition at line 1024 of file dplayx.c.

{
    u_long nbio = 1;
    SOCKADDR_IN addr;
    int wsResult;
    SOCKET sock;
 
    sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
    ok_( __FILE__, line) ( sock != INVALID_SOCKET, "got UDP socket %#Ix.\n", sock );
 
    addr.sin_family = AF_INET;
    addr.sin_port = htons( port );
    addr.sin_addr.s_addr = htonl( INADDR_ANY );
    wsResult = bind( sock, (SOCKADDR *) &addr, sizeof( addr ) );
    ok_( __FILE__, line)( !wsResult, "bind() returned %d.\n", wsResult );
 
    wsResult = ioctlsocket( sock, FIONBIO, &nbio );
    ok_( __FILE__, line)( !wsResult, "ioctlsocket() returned %d.\n", wsResult );
 
    return sock;
}

Referenced by check_EnumSessions_(), check_EnumSessions_async_(), and joinSession_().

◆ callback_providersA()

static BOOL CALLBACK callback_providersA	(	GUID *	guid,
		char *	name,
		DWORD	major,
		DWORD	minor,
		void *	arg
	)

static

Definition at line 2398 of file dplayx.c.

{
    struct provider_data *prov = arg;
 
    if (!prov) return TRUE;
 
    if (prov->call_count < ARRAY_SIZE(prov->guid_data))
    {
        prov->guid_ptr[prov->call_count] = guid;
        prov->guid_data[prov->call_count] = *guid;
 
        prov->call_count++;
    }
 
    if (prov->ret_value) /* Only trace when looping all providers */
        trace("Provider #%d '%s' (%ld.%ld)\n", prov->call_count, name, major, minor);
    return prov->ret_value;
}

Referenced by test_EnumerateProviders().

◆ callback_providersW()

static BOOL CALLBACK callback_providersW	(	GUID *	guid,
		WCHAR *	name,
		DWORD	major,
		DWORD	minor,
		void *	arg
	)

static

Definition at line 2417 of file dplayx.c.

{
    struct provider_data *prov = arg;
 
    if (!prov) return TRUE;
 
    if (prov->call_count < ARRAY_SIZE(prov->guid_data))
    {
        prov->guid_ptr[prov->call_count] = guid;
        prov->guid_data[prov->call_count] = *guid;
 
        prov->call_count++;
    }
 
    return prov->ret_value;
}

Referenced by test_EnumerateProviders().

◆ check_CreatePlayer_()

static void check_CreatePlayer_	(	int	line,
		IDirectPlay4 *	dp,
		DPID *	dpid,
		DPNAME *	name,
		DWORD	flags,
		HRESULT	expectedHr,
		DPID	expectedDpid,
		SOCKET	recvSock,
		BOOL	requestExpected,
		DWORD	expectedFlags,
		const WCHAR *	expectedShortName,
		const char *	expectedShortNameA,
		const WCHAR *	expectedLongName,
		const char *	expectedLongNameA,
		DWORD	expectedCurrentPlayers
	)

static

Definition at line 4887 of file dplayx.c.

{
    BYTE playerData[] = { 1, 2, 3, 4, 5, 6, 7, 8, };
    CreatePlayerParam *param;
    SOCKET sendSock;
    HRESULT hr;
 
    param = createPlayerAsync( dp, dpid, name, NULL, playerData, sizeof( playerData ), flags );
 
    if ( requestExpected )
    {
        unsigned short port;
 
        port = receiveRequestPlayerId_( line, recvSock, expectedFlags );
 
        sendSock = connectTcp_( line, port );
 
        sendRequestPlayerReply_( line, sendSock, 2349, expectedDpid, DP_OK );
        receiveCreatePlayer_( line, recvSock, expectedDpid, expectedFlags, expectedShortName, expectedLongName,
                              playerData, sizeof( playerData ) );
 
        hr = createPlayerAsyncWait( param, 2000 );
        ok_( __FILE__, line )( hr == expectedHr, "CreatePlayer() returned %#lx.\n", hr );
        if ( dpid )
            ok_( __FILE__, line )( *dpid == expectedDpid, "got dpid %#lx.\n", *dpid );
 
        checkPlayerExists_( line, dp, expectedDpid, DPPLAYERTYPE_PLAYER, expectedShortNameA, expectedLongNameA,
                            expectedFlags, playerData, sizeof( playerData ) );
 
        if ( hr == DP_OK )
            checkCreatePlayerOrGroupMessages_( line, dp, DPPLAYERTYPE_PLAYER, expectedDpid, expectedCurrentPlayers,
                                               playerData, sizeof( playerData ), expectedShortNameA, expectedLongNameA,
                                               0, expectedFlags );
 
        checkNoMorePlayerMessages_( line, dp );
 
        closesocket( sendSock );
    }
    else
    {
        hr = createPlayerAsyncWait( param, 2000 );
        ok_( __FILE__, line )( hr == expectedHr, "CreatePlayer() returned %#lx.\n", hr );
        if ( dpid )
            ok_( __FILE__, line )( *dpid == expectedDpid, "got dpid %#lx.\n", *dpid );
    }
 
    if ( recvSock != INVALID_SOCKET )
        checkNoMoreMessages_( line, recvSock );
}

◆ check_EnumSessions_()

static void check_EnumSessions_	(	int	line,
		IDirectPlay4 *	dp,
		DPSESSIONDESC2 *	dpsd,
		DWORD	flags,
		HRESULT	expectedHr,
		DWORD	expectedSessionCount,
		BOOL	timeoutExpected,
		BOOL	requestExpected,
		const WCHAR *	expectedPassword,
		DWORD	replyCount,
		BOOL	ansi,
		BOOL	hrTodo
	)

static

Definition at line 3816 of file dplayx.c.

{
    DPSESSIONDESC2 replyDpsds[] =
    {
        {
            .dwSize = sizeof( DPSESSIONDESC2 ),
            .dwFlags = 0,
            .guidInstance = appGuid,
            .guidApplication = appGuid,
            .dwMaxPlayers = 10,
            .dwCurrentPlayers = 0,
            .lpszSessionName = (WCHAR *) L"normal",
            .dwReserved1 = 0x11223344,
            .dwReserved2 = 0,
            .dwUser1 = 1,
            .dwUser2 = 2,
            .dwUser3 = 3,
            .dwUser4 = 4,
        },
        {
            .dwSize = sizeof( DPSESSIONDESC2 ),
            .dwFlags = DPSESSION_JOINDISABLED | DPSESSION_PASSWORDREQUIRED | DPSESSION_PRIVATE,
            .guidInstance = appGuid2,
            .guidApplication = appGuid2,
            .dwMaxPlayers = 10,
            .dwCurrentPlayers = 10,
            .lpszSessionName = (WCHAR *) L"private",
            .dwReserved1 = 0xaabbccdd,
            .dwReserved2 = 0,
            .dwUser1 = 5,
            .dwUser2 = 6,
            .dwUser3 = 7,
            .dwUser4 = 8,
        },
    };
    ExpectedSession expectedSessions[ ARRAYSIZE( replyDpsds ) ];
    CheckSessionListCallbackData callbackData;
    EnumSessionsParam *param;
    unsigned short port = 0;
    WSADATA wsaData;
    SOCKET enumSock;
    int tryIndex;
    int wsResult;
    SOCKET sock;
    HRESULT hr;
    int i;
 
    wsResult = WSAStartup( MAKEWORD( 2, 0 ), &wsaData );
    ok_( __FILE__, line )( !wsResult, "WSAStartup() returned %d.\n", wsResult );
 
    enumSock = bindUdp_( line, 47624 );
 
    for ( tryIndex = 0; ; ++tryIndex )
    {
        memset( &expectedSessions, 0, sizeof( expectedSessions ) );
        expectedSessions[ 0 ].dpsd = replyDpsds [ 0 ];
        expectedSessions[ 0 ].dpsd.lpszSessionNameA = (char *) AW( "normal", ansi );
        expectedSessions[ 1 ].dpsd = replyDpsds [ 1 ];
        expectedSessions[ 1 ].dpsd.lpszSessionNameA = (char *) AW( "private", ansi );
 
        memset( &callbackData, 0, sizeof( callbackData ) );
        callbackData.line = line;
        callbackData.expectedSessions = expectedSessions;
        callbackData.expectedCount = expectedSessionCount;
        callbackData.ansi = ansi;
 
        param = enumSessionsAsync( dp, dpsd, 100, checkSessionListCallback, &callbackData, flags );
 
        if ( requestExpected )
            port = receiveEnumSessionsRequest_( line, enumSock, &appGuid, expectedPassword, flags );
 
        for ( i = 0; i < replyCount; ++i )
        {
            sock = connectTcp_( line, port );
            if ( sock == INVALID_SOCKET )
                continue;
 
            sendEnumSessionsReply_( line, sock, 2349 - i, &replyDpsds[ i ] );
 
            closesocket( sock );
        }
 
        checkNoMoreMessages_( line, enumSock );
 
        hr = enumSessionsAsyncWait( param, 2000 );
        todo_wine_if( hrTodo ) ok_( __FILE__, line )( hr == expectedHr, "got hr %#lx.\n", hr );
 
        if ( tryIndex < 19 && callbackData.actualCount < callbackData.expectedCount )
            continue;
 
        ok_( __FILE__, line )( callbackData.actualCount == callbackData.expectedCount, "got session count %d.\n",
                               callbackData.actualCount );
        ok_( __FILE__, line )( !!callbackData.timeoutCount == timeoutExpected, "got timeout count %d.\n",
                               callbackData.timeoutCount );
 
        break;
    }
 
    closesocket( enumSock );
    WSACleanup();
}

◆ check_EnumSessions_async_()

static void check_EnumSessions_async_	(	int	line,
		DPSESSIONDESC2 *	dpsd,
		IDirectPlay4 *	dp,
		BOOL	ansi
	)

static

Definition at line 3921 of file dplayx.c.

{
    DPSESSIONDESC2 replyDpsds[] =
    {
        {
            .dwSize = sizeof( DPSESSIONDESC2 ),
            .dwFlags = 0,
            .guidInstance = appGuid,
            .guidApplication = appGuid,
            .dwMaxPlayers = 10,
            .dwCurrentPlayers = 0,
            .lpszSessionName = (WCHAR *) L"normal",
            .dwReserved1 = 0x11223344,
            .dwReserved2 = 0,
            .dwUser1 = 1,
            .dwUser2 = 2,
            .dwUser3 = 3,
            .dwUser4 = 4,
        },
        {
            .dwSize = sizeof( DPSESSIONDESC2 ),
            .dwFlags = DPSESSION_JOINDISABLED | DPSESSION_PASSWORDREQUIRED | DPSESSION_PRIVATE,
            .guidInstance = appGuid2,
            .guidApplication = appGuid2,
            .dwMaxPlayers = 10,
            .dwCurrentPlayers = 10,
            .lpszSessionName = (WCHAR *) L"private",
            .dwReserved1 = 0xaabbccdd,
            .dwReserved2 = 0,
            .dwUser1 = 5,
            .dwUser2 = 6,
            .dwUser3 = 7,
            .dwUser4 = 8,
        },
    };
    CheckSessionListCallbackData callbackData;
    ExpectedSession expectedSessions[ 2 ];
    EnumSessionsParam *param;
    unsigned short port;
    SOCKET enumSock;
    int tryIndex;
    SOCKET sock;
    HRESULT hr;
    int i;
 
    enumSock = bindUdp_( line, 47624 );
 
    for ( tryIndex = 0; ; ++tryIndex )
    {
        memset( expectedSessions, 0, sizeof( expectedSessions ) );
        expectedSessions[ 0 ].dpsd = replyDpsds [ 0 ];
        expectedSessions[ 0 ].dpsd.lpszSessionNameA = (char *) AW( "normal", ansi );
 
        memset( &callbackData, 0, sizeof( callbackData ) );
        callbackData.line = line;
        callbackData.expectedSessions = expectedSessions;
        callbackData.expectedCount = 1;
        callbackData.ansi = ansi;
 
        /* Do a sync enumeration first to fill the cache */
        param = enumSessionsAsync( dp, dpsd, 100, checkSessionListCallback, &callbackData, 0 );
 
        port = receiveEnumSessionsRequest_( line, enumSock, &appGuid, NULL, 0 );
 
        sock = connectTcp_( line, port );
 
        if ( sock != INVALID_SOCKET )
        {
            sendEnumSessionsReply_( line, sock, 2349, &replyDpsds[ 0 ] );
 
            closesocket( sock );
        }
 
        checkNoMoreMessages_( line, enumSock );
 
        hr = enumSessionsAsyncWait( param, 2000 );
        ok_( __FILE__, line )( hr == DP_OK, "got hr %#lx.\n", hr );
 
        if ( tryIndex < 19 && callbackData.actualCount < callbackData.expectedCount )
            continue;
 
        ok_( __FILE__, line )( callbackData.actualCount == callbackData.expectedCount, "got session count %d.\n",
                               callbackData.actualCount );
        ok_( __FILE__, line )( callbackData.timeoutCount, "got timeout count %d.\n", callbackData.timeoutCount );
 
        break;
    }
 
    memset( expectedSessions, 0, sizeof( expectedSessions ) );
    expectedSessions[ 0 ].dpsd = replyDpsds [ 0 ];
    expectedSessions[ 0 ].dpsd.lpszSessionNameA = (char *) AW( "normal", ansi );
 
    memset( &callbackData, 0, sizeof( callbackData ) );
    callbackData.line = line;
    callbackData.expectedSessions = expectedSessions;
    callbackData.expectedCount = 1;
    callbackData.ansi = ansi;
 
    /* Read cache of last sync enumeration */
    param = enumSessionsAsync( dp, dpsd, 100, checkSessionListCallback, &callbackData, DPENUMSESSIONS_ASYNC );
 
    receiveEnumSessionsRequest_( line, enumSock, &appGuid, NULL, DPENUMSESSIONS_ASYNC );
 
    hr = enumSessionsAsyncWait( param, 2000 );
    ok_( __FILE__, line )( hr == DP_OK, "got hr %#lx.\n", hr );
 
    ok_( __FILE__, line )( callbackData.actualCount == callbackData.expectedCount, "got session count %d.\n",
                           callbackData.actualCount );
    ok_( __FILE__, line )( callbackData.timeoutCount, "got timeout count %d.\n", callbackData.timeoutCount );
 
    /* Check that requests are sent periodically */
    for ( i = 0; i < 2; ++i )
        port = receiveEnumSessionsRequest_( line, enumSock, &appGuid, NULL, DPENUMSESSIONS_ASYNC );
 
    for ( i = 0; i < ARRAYSIZE( replyDpsds ); ++i )
    {
        sock = connectTcp_( line, port );
        if ( sock == INVALID_SOCKET )
            continue;
 
        sendEnumSessionsReply_( line, sock, 2349 - i, &replyDpsds[ i ] );
 
        closesocket( sock );
    }
 
    for ( tryIndex = 0; ; ++tryIndex )
    {
        memset( expectedSessions, 0, sizeof( expectedSessions ) );
        expectedSessions[ 0 ].dpsd = replyDpsds [ 0 ];
        expectedSessions[ 0 ].dpsd.lpszSessionNameA = (char *) AW( "normal", ansi );
        expectedSessions[ 1 ].dpsd = replyDpsds [ 1 ];
        expectedSessions[ 1 ].dpsd.lpszSessionNameA = (char *) AW( "private", ansi );
 
        memset( &callbackData, 0, sizeof( callbackData ) );
        callbackData.line = line;
        callbackData.expectedSessions = expectedSessions;
        callbackData.expectedCount = ARRAYSIZE( expectedSessions );
        callbackData.ansi = ansi;
 
        /* Retrieve results */
        param = enumSessionsAsync( dp, dpsd, 100, checkSessionListCallback, &callbackData, DPENUMSESSIONS_ASYNC );
        hr = enumSessionsAsyncWait( param, 2000 );
        ok_( __FILE__, line )( hr == DP_OK, "got hr %#lx.\n", hr );
 
        if ( tryIndex < 19 && callbackData.actualCount < callbackData.expectedCount )
            continue;
 
        ok_( __FILE__, line )( callbackData.actualCount == callbackData.expectedCount, "got session count %d.\n",
                               callbackData.actualCount );
        ok_( __FILE__, line )( callbackData.timeoutCount, "got timeout count %d.\n", callbackData.timeoutCount );
 
        break;
    }
 
    memset( &callbackData, 0, sizeof( callbackData ) );
    callbackData.line = line;
    callbackData.expectedSessions = NULL;
    callbackData.expectedCount = 0;
    callbackData.ansi = ansi;
 
    /* Stop enumeration */
    param = enumSessionsAsync( dp, dpsd, 100, checkSessionListCallback, &callbackData, DPENUMSESSIONS_STOPASYNC );
    hr = enumSessionsAsyncWait( param, 2000 );
    ok_( __FILE__, line )( hr == DP_OK, "got hr %#lx.\n", hr );
 
    ok_( __FILE__, line )( !callbackData.actualCount, "got session count %d.\n", callbackData.actualCount );
    todo_wine ok_( __FILE__, line )( callbackData.timeoutCount, "got timeout count %d.\n", callbackData.timeoutCount );
 
    closesocket( enumSock );
}

◆ check_messages()

static void check_messages	(	IDirectPlay4 *	pDP,
		DPID *	dpid,
		DWORD	dpidSize,
		lpCallbackData	callbackData
	)

static

Definition at line 616 of file dplayx.c.

{
    /* Retrieves all messages from the queue of pDP, performing tests
     * to check if we are receiving what we expect.
     *
     * Information about the messages is stores in callbackData:
     *
     * callbackData->dwCounter1: Number of messages received.
     * callbackData->szTrace1: Traces for sender and receiver.
     *     We store the position a dpid holds in the dpid array.
     *     Example:
     *
     *       trace string: "01,02,03,14"
     *           expanded: [ '01', '02', '03', '14' ]
     *                         \     \     \     \
     *                          \     \     \     ) message 3: from 1 to 4
     *                           \     \     ) message 2: from 0 to 3
     *                            \     ) message 1: from 0 to 2
     *                             ) message 0: from 0 to 1
     *
     *     In general terms:
     *       sender of message i   = character in place 3*i of the array
     *       receiver of message i = character in place 3*i+1 of the array
     *
     *     A sender value of 'S' means DPID_SYSMSG, this is, a system message.
     *
     * callbackData->szTrace2: Traces for message sizes.
     */
 
    DPID idFrom, idTo;
    UINT i;
    DWORD dwDataSize = 1024;
    LPVOID lpData = calloc( 1, dwDataSize );
    HRESULT hr;
    char temp[5];
 
    callbackData->szTrace2[0] = '\0';
 
    i = 0;
    while ( DP_OK == (hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0,
                                                 lpData, &dwDataSize )) )
    {
 
        callbackData->szTrace1[ 3*i   ] = dpid2char( dpid, dpidSize, idFrom );
        callbackData->szTrace1[ 3*i+1 ] = dpid2char( dpid, dpidSize, idTo );
        callbackData->szTrace1[ 3*i+2 ] = ',';
 
        sprintf( temp, "%ld,", dwDataSize );
        strcat( callbackData->szTrace2, temp );
 
        dwDataSize = 1024;
        ++i;
    }
 
    checkHR( DPERR_NOMESSAGES, hr );
 
    callbackData->szTrace1[ 3*i ] = '\0';
    callbackData->dwCounter1 = i;
 
 
    free( lpData );
}

◆ check_Open_()

static void check_Open_	(	int	line,
		IDirectPlay4A *	dp,
		DPSESSIONDESC2 *	dpsd,
		const DPSESSIONDESC2 *	serverDpsd,
		BOOL	idRequestExpected,
		BOOL	forwardRequestExpected,
		unsigned short	listenPort,
		const WCHAR *	expectedPassword,
		HRESULT	idReplyHr,
		HRESULT	addForwardReplyHr,
		HRESULT	expectedHr
	)

static

Definition at line 3156 of file dplayx.c.

{
    SOCKET listenSock;
    OpenParam *param;
    WSADATA wsaData;
    SOCKET recvSock;
    SOCKET sendSock;
    int wsResult;
    HRESULT hr;
 
    wsResult = WSAStartup( MAKEWORD( 2, 0 ), &wsaData );
    ok_( __FILE__, line )( !wsResult, "WSAStartup() returned %d.\n", wsResult );
 
    listenSock = listenTcp_( line, listenPort );
 
    param = openAsync( dp, dpsd, DPOPEN_JOIN );
 
    if ( idRequestExpected )
    {
        unsigned short port;
 
        recvSock = acceptTcp_( line, listenSock );
        ok_( __FILE__, line )( recvSock != INVALID_SOCKET, "accept() returned %#Ix.\n", recvSock );
 
        port = receiveRequestPlayerId_( line, recvSock, 0x9 );
 
        sendSock = connectTcp_( line, port );
 
        sendRequestPlayerReply_( line, sendSock, listenPort, 0x12345678, idReplyHr );
 
        if ( forwardRequestExpected )
        {
            receiveAddForwardRequest_( line, recvSock, 0x12345678, expectedPassword, serverDpsd->dwReserved1, NULL );
 
            if ( addForwardReplyHr == DP_OK )
                sendSuperEnumPlayersReply_( line, sendSock, listenPort, 2399, serverDpsd, L"normal" );
            else
                sendAddForwardReply_( line, sendSock, listenPort, addForwardReplyHr );
 
            hr = openAsyncWait( param, 7000 );
            ok_( __FILE__, line )( hr == expectedHr, "Open() returned %#lx.\n", hr );
 
            checkNoMoreMessages_( line, recvSock );
 
            if ( hr == DP_OK )
            {
                BYTE expectedPlayerData[] = { 1, 2, 3, 4, };
                ExpectedPlayer expectedPlayers[] = {
                    {
                        .expectedDpid = 0x1337,
                        .expectedPlayerType = DPPLAYERTYPE_PLAYER,
                        .expectedShortName = "short name",
                        .expectedLongName = "long name",
                        .expectedFlags = DPENUMPLAYERS_REMOTE,
                        .expectedPlayerData = expectedPlayerData,
                        .expectedPlayerDataSize = sizeof( expectedPlayerData ),
                    },
                    {
                        .expectedDpid = 0xd00de,
                        .expectedPlayerType = DPPLAYERTYPE_PLAYER,
                        .expectedFlags = DPENUMPLAYERS_REMOTE,
                    },
                };
                ExpectedPlayer expectedGroups[] =
                {
                    {
                        .expectedDpid = 0x5e7,
                        .expectedPlayerType = DPPLAYERTYPE_GROUP,
                        .expectedShortName = "short name",
                        .expectedLongName = "long name",
                        .expectedFlags = DPENUMPLAYERS_REMOTE,
                        .expectedPlayerData = expectedPlayerData,
                        .expectedPlayerDataSize = sizeof( expectedPlayerData ),
                    },
                };
                ExpectedPlayer expectedGroupPlayers[] =
                {
                    {
                        .expectedDpid = 0xd00de,
                        .expectedPlayerType = DPPLAYERTYPE_PLAYER,
                        .expectedFlags = DPENUMPLAYERS_REMOTE,
                    },
                };
 
                checkPlayerList_( line, dp, expectedPlayers, ARRAYSIZE( expectedPlayers ) );
                checkGroupList_( line, dp, expectedGroups, ARRAYSIZE( expectedGroups ) );
                checkGroupPlayerList_( line, 0x5e7, dp, expectedGroupPlayers, ARRAYSIZE( expectedGroupPlayers ) );
 
                hr = IDirectPlayX_Close( dp );
                checkHR( DP_OK, hr );
            }
        }
        else
        {
            hr = openAsyncWait( param, 7000 );
            ok_( __FILE__, line )( hr == expectedHr, "Open() returned %#lx.\n", hr );
        }
        closesocket( sendSock );
        closesocket( recvSock );
    }
    else
    {
        hr = openAsyncWait( param, 7000 );
        ok_( __FILE__, line )( hr == expectedHr, "Open() returned %#lx.\n", hr );
    }
 
    checkNoMoreAccepts_( line, listenSock );
 
    closesocket( listenSock );
    WSACleanup();
}

◆ checkAddPlayerToGroupMessage_()

static DPID checkAddPlayerToGroupMessage_	(	int	line,
		IDirectPlay4 *	dp,
		DPID	expectedGroupId,
		DPID	expectedPlayerId
	)

static

Definition at line 9143 of file dplayx.c.

{
    DPMSG_ADDPLAYERTOGROUP *msg;
    BYTE msgData[ 256 ];
    DWORD msgDataSize;
    DPID fromId, toId;
    HRESULT hr;
 
    memset( &msgData, 0, sizeof( msgData ) );
    msgDataSize = sizeof( msgData );
    fromId = 0xdeadbeef;
    toId = 0xdeadbeef;
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, 0, msgData, &msgDataSize );
    ok_( __FILE__, line )( hr == DP_OK, "got hr %#lx.\n", hr );
    ok_( __FILE__, line )( fromId == DPID_SYSMSG, "got source id %#lx.\n", fromId );
 
    msg = (DPMSG_ADDPLAYERTOGROUP *) msgData;
    ok_( __FILE__, line )( msg->dwType == DPSYS_ADDPLAYERTOGROUP, "got message type %#lx.\n", msg->dwType );
    ok_( __FILE__, line )( msg->dpIdGroup == expectedGroupId, "got id %#lx.\n", msg->dpIdGroup );
    ok_( __FILE__, line )( msg->dpIdPlayer == expectedPlayerId, "got id %#lx.\n", msg->dpIdPlayer );
 
    return toId;
}

◆ checkCreatePlayerOrGroupMessage_()

static DPID checkCreatePlayerOrGroupMessage_	(	int	line,
		IDirectPlay4 *	dp,
		DWORD	expectedType,
		DPID	expectedDpid,
		DWORD	expectedCurrentPlayers,
		void *	expectedPlayerData,
		DWORD	expectedPlayerDataSize,
		const char *	expectedShortName,
		const char *	expectedLongName,
		DPID	expectedParent,
		DWORD	expectedFlags
	)

static

Definition at line 4714 of file dplayx.c.

{
    DPMSG_CREATEPLAYERORGROUP *msg;
    DWORD expectedShortNameSize;
    DWORD expectedLongNameSize;
    DWORD expectedMsgDataSize;
    BYTE msgData[ 256 ];
    DWORD msgDataSize;
    DPID fromId, toId;
    HRESULT hr;
 
    memset( &msgData, 0, sizeof( msgData ) );
    msgDataSize = sizeof( msgData );
    fromId = 0xdeadbeef;
    toId = 0xdeadbeef;
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, 0, msgData, &msgDataSize );
    ok_( __FILE__, line )( hr == DP_OK, "got hr %#lx.\n", hr );
    ok_( __FILE__, line )( fromId == DPID_SYSMSG, "got source id %#lx.\n", fromId );
 
    msg = (DPMSG_CREATEPLAYERORGROUP *) msgData;
    ok_( __FILE__, line )( msg->dwType == DPSYS_CREATEPLAYERORGROUP, "got message type %#lx.\n", msg->dwType );
    ok_( __FILE__, line )( msg->dwPlayerType == expectedType, "got player type %#lx.\n", msg->dwPlayerType );
    ok_( __FILE__, line )( msg->dpId == expectedDpid, "got id %#lx.\n", msg->dpId );
    ok_( __FILE__, line )( msg->dwCurrentPlayers == expectedCurrentPlayers, "got current players %lu.\n",
                           msg->dwCurrentPlayers );
    ok_( __FILE__, line )( msg->dwDataSize == expectedPlayerDataSize, "got player data size %lu.\n", msg->dwDataSize );
    if ( expectedPlayerData )
    {
        ok_( __FILE__, line )( msg->lpData && !memcmp( msg->lpData, expectedPlayerData, expectedPlayerDataSize ),
                               "player data didn't match.\n" );
    }
    else
    {
        ok_( __FILE__, line )( !msg->lpData, "got player data %p.\n", msg->lpData );
    }
    ok_( __FILE__, line )( msg->dpnName.dwSize == sizeof( DPNAME ), "got name size %lu.\n", msg->dpnName.dwSize );
    ok_( __FILE__, line )( !msg->dpnName.dwFlags, "got name flags %#lx.\n", msg->dpnName.dwFlags );
    if ( expectedShortName )
    {
        ok_( __FILE__, line )( msg->dpnName.lpszShortNameA && !strcmp( msg->dpnName.lpszShortNameA, expectedShortName ),
                               "got short name %s.\n", wine_dbgstr_a( msg->dpnName.lpszShortNameA ) );
    }
    else
    {
        ok_( __FILE__, line )( !msg->dpnName.lpszShortNameA, "got short name %s.\n",
                               wine_dbgstr_a( msg->dpnName.lpszShortNameA ) );
    }
    if ( expectedLongName )
    {
        ok_( __FILE__, line )( msg->dpnName.lpszLongNameA && !strcmp( msg->dpnName.lpszLongNameA, expectedLongName ),
                               "got long name %s.\n", wine_dbgstr_a( msg->dpnName.lpszLongNameA ) );
    }
    else
    {
        ok_( __FILE__, line )( !msg->dpnName.lpszLongNameA, "got long name %s.\n",
                               wine_dbgstr_a( msg->dpnName.lpszLongNameA ) );
    }
    ok_( __FILE__, line )( msg->dpIdParent == expectedParent, "got parent id %#lx.\n", msg->dpIdParent );
    ok_( __FILE__, line )( msg->dwFlags == expectedFlags, "got flags %#lx.\n", msg->dwFlags );
 
    expectedShortNameSize = expectedShortName ? strlen( expectedShortName ) + 1 : 0;
    expectedLongNameSize = expectedLongName ? strlen( expectedLongName ) + 1 : 0;
    expectedMsgDataSize = sizeof( DPMSG_CREATEPLAYERORGROUP ) + expectedShortNameSize + expectedLongNameSize
                        + expectedPlayerDataSize;
 
    ok_( __FILE__, line )( msgDataSize == expectedMsgDataSize, "got message size %lu.\n", msgDataSize );
 
    return toId;
}

Referenced by checkCreatePlayerOrGroupMessages_().

◆ checkCreatePlayerOrGroupMessages_()

static void checkCreatePlayerOrGroupMessages_	(	int	line,
		IDirectPlay4 *	dp,
		DWORD	expectedType,
		DPID	expectedDpid,
		DWORD	expectedCurrentPlayers,
		void *	expectedPlayerData,
		DWORD	expectedPlayerDataSize,
		const char *	expectedShortName,
		const char *	expectedLongName,
		DPID	expectedParent,
		DWORD	expectedFlags
	)

static

Definition at line 4850 of file dplayx.c.

{
    GetPlayerIdsCallbackData data = { 0 };
    HRESULT hr;
    DPID dpid;
    DWORD i;
    DWORD j;
 
    hr = IDirectPlayX_EnumPlayers( dp, NULL, getPlayerIdsCallback, &data, DPENUMPLAYERS_LOCAL );
    ok_( __FILE__, line )( hr == DP_OK, "got hr %#lx.\n", hr );
 
    for ( i = 0; i < data.idCount - 1; ++i )
    {
        dpid = checkCreatePlayerOrGroupMessage_( line, dp, expectedType, expectedDpid, expectedCurrentPlayers,
                                                 expectedPlayerData, expectedPlayerDataSize, expectedShortName,
                                                 expectedLongName, expectedParent, expectedFlags );
        for ( j = 0; j < data.idCount; ++j )
        {
            if ( data.ids[ j ] == dpid )
            {
                data.ids[ j ] = 0;
                break;
            }
        }
        ok_( __FILE__, line )( dpid && dpid != expectedDpid && j < data.idCount, "got destination id %#lx.\n", dpid );
    }
}

Referenced by check_CreatePlayer_().

◆ checkFlags_()

static void checkFlags_	(	unsigned	line,
		DWORD	expected,
		DWORD	result,
		DWORD	flags
	)

static

Definition at line 61 of file dplayx.c.

{
    ok_(__FILE__, line)( expected == result,
        "expected=0x%08lx(%s) got=0x%08lx(%s)\n",
        expected, dwFlags2str(expected, flags),
        result, dwFlags2str(result, flags) );
}

◆ checkGameMessage_()

static void checkGameMessage_	(	int	line,
		GameMessage *	message,
		DPID	expectedFromId,
		DPID	expectedToId
	)

static

Definition at line 1256 of file dplayx.c.

{
    ok_( __FILE__, line )( message->fromId == expectedFromId, "got source id %#lx.\n", message->fromId );
    ok_( __FILE__, line )( message->toId == expectedToId, "got destination id %#lx.\n", message->toId );
}

Referenced by receiveGameMessage_(), and receiveGuaranteedGameMessage_().

◆ checkGroupList_()

static void checkGroupList_	(	int	line,
		IDirectPlay4 *	dp,
		ExpectedPlayer *	expectedGroups,
		int	expectedGroupCount
	)

static

Definition at line 3095 of file dplayx.c.

{
    CheckPlayerListCallbackData data = {
        .line = line,
        .dp = dp,
        .expectedPlayers = expectedGroups,
        .expectedPlayerCount = expectedGroupCount,
    };
    HRESULT hr;
 
    hr = IDirectPlayX_EnumGroups( dp, NULL, checkPlayerListCallback, &data, DPENUMGROUPS_LOCAL );
    ok_( __FILE__, line )( hr == DP_OK, "EnumGroups() returned %#lx.\n", hr );
 
    hr = IDirectPlayX_EnumGroups( dp, NULL, checkPlayerListCallback, &data, DPENUMGROUPS_REMOTE );
    ok_( __FILE__, line )( hr == DP_OK, "EnumGroups() returned %#lx.\n", hr );
 
    ok_( __FILE__, line )( data.actualPlayerCount == data.expectedPlayerCount, "got group count %d.\n",
                           data.actualPlayerCount );
}

Referenced by check_Open_().

◆ checkGroupPlayerList_()

static void checkGroupPlayerList_	(	int	line,
		DPID	group,
		IDirectPlay4 *	dp,
		ExpectedPlayer *	expectedPlayers,
		int	expectedPlayerCount
	)

static

Definition at line 3072 of file dplayx.c.

{
    CheckPlayerListCallbackData data = {
        .line = line,
        .dp = dp,
        .expectedPlayers = expectedPlayers,
        .expectedPlayerCount = expectedPlayerCount,
    };
    HRESULT hr;
 
    hr = IDirectPlayX_EnumGroupPlayers( dp, group, NULL, checkPlayerListCallback, &data, DPENUMPLAYERS_LOCAL );
    ok_( __FILE__, line )( hr == DP_OK, "EnumGroupPlayers() returned %#lx.\n", hr );
 
    hr = IDirectPlayX_EnumGroupPlayers( dp, group, NULL, checkPlayerListCallback, &data, DPENUMPLAYERS_REMOTE );
    ok_( __FILE__, line )( hr == DP_OK, "EnumGroupPlayers() returned %#lx.\n", hr );
 
    ok_( __FILE__, line )( data.actualPlayerCount == data.expectedPlayerCount, "got player count %d.\n",
                           data.actualPlayerCount );
}

Referenced by check_Open_().

◆ checkMessageHeader_()

static void checkMessageHeader_	(	int	line,
		MessageHeader *	header,
		WORD	expectedCommand
	)

static

Definition at line 1202 of file dplayx.c.

{
    ok_( __FILE__, line )( header->magic == 0x79616c70, "got magic %#lx.\n", header->magic );
    ok_( __FILE__, line )( header->command == expectedCommand, "got command %d.\n", header->command );
}

Referenced by receiveAddForwardAck_(), receiveAddForwardRequest_(), receiveAddPlayerToGroup_(), receiveCreatePlayer_(), receiveEnumSessionsRequest_(), receivePingReply_(), and receiveRequestPlayerId_().

◆ checkNoMoreAccepts_()

static void checkNoMoreAccepts_	(	int	line,
		SOCKET	listenSock
	)

static

Definition at line 1098 of file dplayx.c.

{
    struct timeval timeout;
    int wsResult;
    fd_set fds;
 
    FD_ZERO( &fds );
    FD_SET( listenSock, &fds );
    timeout.tv_sec = 0;
    timeout.tv_usec = 100000;
    wsResult = select( listenSock + 1, &fds, NULL, &fds, &timeout );
    ok_( __FILE__, line )( !wsResult, "select() returned %d.\n", wsResult );
}

Referenced by check_Open_(), and joinSession_().

◆ checkNoMoreMessages_()

static void checkNoMoreMessages_	(	int	line,
		SOCKET	sock
	)

static

Definition at line 1172 of file dplayx.c.

{
    struct timeval timeout;
    char buffer[ 1024 ];
    int wsResult;
    fd_set fds;
 
    FD_ZERO( &fds );
    FD_SET( sock, &fds );
    timeout.tv_sec = 0;
    timeout.tv_usec = 100000;
    select( sock + 1, &fds, NULL, &fds, &timeout );
 
    wsResult = recv( sock, buffer, sizeof( buffer ), 0 );
    ok_( __FILE__, line )( !wsResult || wsResult == SOCKET_ERROR, "recv() returned %d.\n", wsResult );
}

Referenced by check_CreatePlayer_(), check_EnumSessions_(), check_EnumSessions_async_(), check_Open_(), and joinSession_().

◆ checkNoMorePlayerMessages_()

static void checkNoMorePlayerMessages_	(	int	line,
		IDirectPlay4 *	dp
	)

static

Definition at line 4812 of file dplayx.c.

{
    char msgData[ 256 ];
    DWORD msgDataSize;
    DPID fromId, toId;
    HRESULT hr;
 
    msgDataSize = sizeof( msgData );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, 0, msgData, &msgDataSize );
    ok_( __FILE__, line )( hr == DPERR_NOMESSAGES, "got hr %#lx.\n", hr );
}

Referenced by check_CreatePlayer_().

◆ checkPackedPlayer_()

static void checkPackedPlayer_	(	int	line,
		PackedPlayer *	player,
		DWORD	expectedFlags,
		DPID	expectedId,
		DWORD	expectedShortNameLength,
		DWORD	expectedLongNameLength,
		DWORD	expectedPlayerDataSize,
		DPID	expectedSystemPlayerId
	)

static

Definition at line 1230 of file dplayx.c.

{
    DWORD expectedSize = sizeof( PackedPlayer ) + expectedShortNameLength + expectedLongNameLength + sizeof( SpData )
                       + expectedPlayerDataSize;
 
    ok_( __FILE__, line )( player->size == expectedSize, "got player info size %lu.\n", player->size );
    ok_( __FILE__, line )( player->flags == expectedFlags, "got flags %#lx.\n", player->flags );
    ok_( __FILE__, line )( player->id == expectedId, "got player info player id %#lx.\n", player->id );
    ok_( __FILE__, line )( player->shortNameLength == expectedShortNameLength, "got short name length %lu.\n",
                           player->shortNameLength );
    ok_( __FILE__, line )( player->longNameLength == expectedLongNameLength, "got long name length %lu.\n",
                           player->longNameLength );
    ok_( __FILE__, line )( player->spDataSize == sizeof( SpData ), "got SP data size %lu.\n", player->spDataSize );
    ok_( __FILE__, line )( player->playerDataSize == expectedPlayerDataSize, "got player data size %lu.\n",
                           player->playerDataSize );
    ok_( __FILE__, line )( !player->playerCount, "got player count %lu.\n", player->playerCount );
    ok_( __FILE__, line )( player->systemPlayerId == expectedSystemPlayerId, "got system player id %#lx.\n",
                           player->systemPlayerId );
    ok_( __FILE__, line )( player->fixedSize == sizeof( PackedPlayer ), "got fixed size %lu.\n", player->fixedSize );
    ok_( __FILE__, line )( !player->parentId, "got parent id %#lx.\n", player->parentId );
}

Referenced by receiveAddForwardRequest_(), and receiveCreatePlayer_().

◆ checkPlayerExists_()

static void checkPlayerExists_	(	int	line,
		IDirectPlay4 *	dp,
		DPID	expectedDpid,
		DWORD	expectedPlayerType,
		const char *	expectedShortName,
		const char *	expectedLongName,
		DWORD	expectedFlags,
		BYTE *	expectedPlayerData,
		DWORD	expectedPlayerDataSize
	)

static

Definition at line 3119 of file dplayx.c.

{
    ExpectedPlayer expectedPlayer =
    {
        .expectedDpid = expectedDpid,
        .expectedPlayerType = expectedPlayerType,
        .expectedShortName = expectedShortName,
        .expectedLongName = expectedLongName,
        .expectedFlags = expectedFlags,
        .expectedPlayerData = expectedPlayerData,
        .expectedPlayerDataSize = expectedPlayerDataSize,
    };
    CheckPlayerListCallbackData data =
    {
        .line = line,
        .dp = dp,
        .expectedPlayers = &expectedPlayer,
        .expectedPlayerCount = 1,
        .ignoreUnexpected = TRUE,
    };
    HRESULT hr;
 
    hr = IDirectPlayX_EnumPlayers( dp, NULL, checkPlayerListCallback, &data, DPENUMPLAYERS_LOCAL );
    ok_( __FILE__, line )( hr == DP_OK, "EnumPlayers() returned %#lx.\n", hr );
 
    hr = IDirectPlayX_EnumPlayers( dp, NULL, checkPlayerListCallback, &data, DPENUMPLAYERS_REMOTE );
    ok_( __FILE__, line )( hr == DP_OK, "EnumPlayers() returned %#lx.\n", hr );
 
    ok_( __FILE__, line )( expectedPlayer.actualCount == 1, "got player count %d.\n", expectedPlayer.actualCount );
}

Referenced by check_CreatePlayer_().

◆ checkPlayerList_()

static void checkPlayerList_	(	int	line,
		IDirectPlay4 *	dp,
		ExpectedPlayer *	expectedPlayers,
		int	expectedPlayerCount
	)

static

Definition at line 3050 of file dplayx.c.

{
    CheckPlayerListCallbackData data = {
        .line = line,
        .dp = dp,
        .expectedPlayers = expectedPlayers,
        .expectedPlayerCount = expectedPlayerCount,
    };
    HRESULT hr;
 
    hr = IDirectPlayX_EnumPlayers( dp, NULL, checkPlayerListCallback, &data, DPENUMPLAYERS_LOCAL );
    ok_( __FILE__, line )( hr == DP_OK, "EnumPlayers() returned %#lx.\n", hr );
 
    hr = IDirectPlayX_EnumPlayers( dp, NULL, checkPlayerListCallback, &data, DPENUMPLAYERS_REMOTE );
    ok_( __FILE__, line )( hr == DP_OK, "EnumPlayers() returned %#lx.\n", hr );
 
    ok_( __FILE__, line )( data.actualPlayerCount == data.expectedPlayerCount, "got player count %d.\n",
                           data.actualPlayerCount );
}

Referenced by check_Open_().

◆ checkPlayerListCallback()

static BOOL CALLBACK checkPlayerListCallback	(	DPID	dpid,
		DWORD	playerType,
		const DPNAME *	name,
		DWORD	flags,
		void *	context
	)

static

Definition at line 2930 of file dplayx.c.

{
    CheckPlayerListCallbackData *data = context;
    int i;
 
    for ( i = 0; i < data->expectedPlayerCount; ++i )
    {
        ExpectedPlayer *player = &data->expectedPlayers[ i ];
        if ( player->expectedDpid == dpid )
        {
            BYTE playerData[ 256 ];
            DWORD playerDataSize;
            BYTE nameData[ 256 ];
            DWORD nameDataSize;
            char *shortName;
            char *longName;
            HRESULT hr;
 
            if ( player->actualCount )
                ok_( __FILE__, data->line )( 0, "duplicate player dpid %#lx.\n", dpid );
            ok_( __FILE__, data->line )( playerType == player->expectedPlayerType, "got player type %lu.\n",
                                         playerType );
            if ( player->expectedShortName )
            {
                ok_( __FILE__, data->line )( name->lpszShortNameA && !strcmp( name->lpszShortNameA, player->expectedShortName ),
                                             "got short name %s.\n", wine_dbgstr_a( name->lpszShortNameA ) );
            }
            else
            {
                ok_( __FILE__, data->line )( !name->lpszShortNameA, "got short name %s.\n",
                                             wine_dbgstr_a( name->lpszShortNameA ) );
            }
            if ( player->expectedLongName )
            {
                ok_( __FILE__, data->line )( name->lpszLongNameA && !strcmp( name->lpszLongNameA, player->expectedLongName ),
                                             "got long name %s.\n", wine_dbgstr_a( name->lpszLongNameA ) );
            }
            else
            {
                ok_( __FILE__, data->line )( !name->lpszLongNameA, "got long name %s.\n",
                                             wine_dbgstr_a( name->lpszLongNameA ) );
            }
            ok_( __FILE__, data->line )( flags == player->expectedFlags, "got flags %#lx.\n", flags );
 
            memset( &playerData, 0xcc, sizeof( playerData ) );
            playerDataSize = sizeof( playerData );
            if ( playerType == DPPLAYERTYPE_PLAYER )
                hr = IDirectPlayX_GetPlayerData( data->dp, dpid, playerData, &playerDataSize, DPGET_REMOTE );
            else
                hr = IDirectPlayX_GetGroupData( data->dp, dpid, playerData, &playerDataSize, DPGET_REMOTE );
            ok_( __FILE__, data->line )( hr == DP_OK, "GetPlayerData() returned %#lx.\n", hr );
            ok_( __FILE__, data->line )( playerDataSize == player->expectedPlayerDataSize,
                                         "got player data size %lu.\n", playerDataSize );
            ok_( __FILE__, data->line )( !memcmp( playerData, player->expectedPlayerData, player->expectedPlayerDataSize ),
                                         "player data doesn't match.\n" );
 
            memset( &nameData, 0xcc, sizeof( nameData ) );
            nameDataSize = sizeof( nameData );
            if ( playerType == DPPLAYERTYPE_PLAYER )
                hr = IDirectPlayX_GetPlayerName( data->dp, dpid, &nameData, &nameDataSize );
            else
                hr = IDirectPlayX_GetGroupName( data->dp, dpid, &nameData, &nameDataSize );
            ok_( __FILE__, data->line )( hr == DP_OK, "GetPlayerName() returned %#lx.\n", hr );
            ok_( __FILE__, data->line )( ((DPNAME *) nameData)->dwSize == sizeof( DPNAME ),
                                         "got name size %lu.\n", ((DPNAME *) nameData)->dwSize );
            ok_( __FILE__, data->line )( !((DPNAME *) nameData)->dwFlags, "got name flags %#lx.\n",
                                         ((DPNAME *) nameData)->dwFlags );
            shortName = ((DPNAME *) nameData)->lpszShortNameA;
            if ( player->expectedShortName )
            {
                if ( (char *) nameData <= shortName && shortName < (char *) nameData + nameDataSize )
                {
                    ok_( __FILE__, data->line )( shortName && !strcmp( shortName, player->expectedShortName ),
                                                 "got short name %s.\n", wine_dbgstr_a( shortName ) );
                }
                else
                {
                    ok_( __FILE__, data->line)( 0, "got short name %p.\n", shortName );
                }
            }
            else
            {
                ok_( __FILE__, data->line )( !shortName, "got short name %s.\n", wine_dbgstr_a( shortName ) );
            }
            longName = ((DPNAME *) nameData)->lpszLongNameA;
            if ( player->expectedLongName )
            {
                if ( (char *) nameData <= longName && longName < (char *) nameData + nameDataSize )
                {
                    ok_( __FILE__, data->line )( longName && !strcmp( longName, player->expectedLongName ),
                                                 "got long name %s.\n", wine_dbgstr_a( longName ) );
                }
                else
                {
                    ok_( __FILE__, data->line)( 0, "got long name %p.\n", longName );
                }
            }
            else
            {
                ok_( __FILE__, data->line )( !longName, "got long name %s.\n", wine_dbgstr_a( longName ) );
            }
 
            ++player->actualCount;
            ++data->actualPlayerCount;
 
            return TRUE;
        }
    }
 
    if ( !data->ignoreUnexpected )
        ok_( __FILE__, data->line )( 0, "unexpected player dpid %#lx.\n", dpid );
 
    ++data->actualPlayerCount;
 
    return TRUE;
}

Referenced by checkGroupList_(), checkGroupPlayerList_(), checkPlayerExists_(), and checkPlayerList_().

◆ checkPlayerMessage_()

static DPID checkPlayerMessage_	(	int	line,
		IDirectPlay4 *	dp,
		DPID	expectedFromId,
		void *	expectedData,
		DWORD	expectedDataSize
	)

static

Definition at line 4789 of file dplayx.c.

{
    DPID fromId, toId;
    BYTE data[ 1024 ];
    DWORD dataSize;
    HRESULT hr;
 
    fromId = 0xdeadbeef;
    toId = 0xdeadbeef;
    memset( data, 0xcc, sizeof( data ) );
    dataSize = sizeof( data );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, 0, data, &dataSize );
    ok_( __FILE__, line )( hr == DP_OK, "got hr %#lx.\n", hr );
 
    ok_( __FILE__, line )( fromId == expectedFromId, "got source id %#lx.\n", fromId );
    ok_( __FILE__, line )( !memcmp( data, expectedData, expectedDataSize ), "message data didn't match.\n" );
    ok_( __FILE__, line )( dataSize == expectedDataSize, "got data size %lu.\n", dataSize );
 
    return toId;
}

◆ checkSessionListCallback()

static BOOL CALLBACK checkSessionListCallback	(	const DPSESSIONDESC2 *	thisSd,
		DWORD *	timeout,
		DWORD	flags,
		void *	context
	)

static

Definition at line 3751 of file dplayx.c.

{
    CheckSessionListCallbackData *data = context;
    ExpectedSession *expectedSession;
    int i;
 
    if ( flags & DPESC_TIMEDOUT )
    {
        ++data->timeoutCount;
 
        return FALSE;
    }
 
    ++data->actualCount;
 
    for ( i = 0; i < data->expectedCount; ++i )
    {
        expectedSession = &data->expectedSessions[ i ];
        if ( !IsEqualGUID( &expectedSession->dpsd.guidInstance, &thisSd->guidInstance ) )
            continue;
 
        ok_( __FILE__, data->line )( !expectedSession->actualCount, "duplicate session %s.\n",
                                     wine_dbgstr_guid( &thisSd->guidInstance ) );
 
        ok_( __FILE__, data->line )( thisSd->dwSize == expectedSession->dpsd.dwSize, "got size %lu.\n",
                                     thisSd->dwSize );
        ok_( __FILE__, data->line )( thisSd->dwFlags == expectedSession->dpsd.dwFlags, "got flags %#lx.\n",
                                     thisSd->dwFlags );
        ok_( __FILE__, data->line )( IsEqualGUID( &thisSd->guidApplication, &expectedSession->dpsd.guidApplication ),
                                     "got application GUID %s.\n", wine_dbgstr_guid( &thisSd->guidApplication ) );
        ok_( __FILE__, data->line )( thisSd->dwMaxPlayers == expectedSession->dpsd.dwMaxPlayers,
                                     "got current player count %lu.\n", thisSd->dwMaxPlayers );
        ok_( __FILE__, data->line )( thisSd->dwCurrentPlayers == expectedSession->dpsd.dwCurrentPlayers,
                                     "got max player count %lu.\n", thisSd->dwCurrentPlayers );
        ok_( __FILE__, data->line )( !strcmpAW( thisSd->lpszSessionNameA, expectedSession->dpsd.lpszSessionNameA, data->ansi ),
                                     "got session name %s.\n", dbgStrAW( thisSd->lpszSessionNameA, data->ansi ) );
        ok_( __FILE__, data->line )( !thisSd->lpszPasswordA, "got password %s.\n",
                                     dbgStrAW( thisSd->lpszPasswordA, data->ansi ) );
        ok_( __FILE__, data->line )( thisSd->dwReserved1 == expectedSession->dpsd.dwReserved1, "got reserved1 %#lx.\n",
                                     thisSd->dwReserved1 );
        ok_( __FILE__, data->line )( thisSd->dwReserved2 == expectedSession->dpsd.dwReserved2, "got reserved2 %#lx.\n",
                                     thisSd->dwReserved2 );
        ok_( __FILE__, data->line )( thisSd->dwUser1 == expectedSession->dpsd.dwUser1, "got user1 %#lx.\n",
                                     thisSd->dwUser1 );
        ok_( __FILE__, data->line )( thisSd->dwUser2 == expectedSession->dpsd.dwUser2, "got user2 %#lx.\n",
                                     thisSd->dwUser2 );
        ok_( __FILE__, data->line )( thisSd->dwUser3 == expectedSession->dpsd.dwUser3, "got user3 %#lx.\n",
                                     thisSd->dwUser3 );
        ok_( __FILE__, data->line )( thisSd->dwUser4 == expectedSession->dpsd.dwUser4, "got user4 %#lx.\n",
                                     thisSd->dwUser4 );
 
        ++expectedSession->actualCount;
 
        return TRUE;
    }
 
    ok_( __FILE__, data->line )( 0, "unexpected session %s.\n", wine_dbgstr_guid( &thisSd->guidInstance ) );
 
    return TRUE;
}

Referenced by check_EnumSessions_(), and check_EnumSessions_async_().

◆ checkSetPlayerOrGroupDataMessage_()

static DPID checkSetPlayerOrGroupDataMessage_	(	int	line,
		IDirectPlay4 *	dp,
		DWORD	expectedPlayerType,
		DPID	expectedDpid,
		void *	expectedData,
		DWORD	expectedDataSize
	)

static

Definition at line 9225 of file dplayx.c.

{
    DPMSG_SETPLAYERORGROUPDATA *msg;
    BYTE msgData[ 256 ];
    DWORD msgDataSize;
    DPID fromId, toId;
    HRESULT hr;
 
    memset( &msgData, 0, sizeof( msgData ) );
    msgDataSize = sizeof( msgData );
    fromId = 0xdeadbeef;
    toId = 0xdeadbeef;
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, 0, msgData, &msgDataSize );
    ok_( __FILE__, line )( hr == DP_OK, "got hr %#lx.\n", hr );
    ok_( __FILE__, line )( fromId == DPID_SYSMSG, "got source id %#lx.\n", fromId );
 
    msg = (DPMSG_SETPLAYERORGROUPDATA *) msgData;
    ok_( __FILE__, line )( msg->dwType == DPSYS_SETPLAYERORGROUPDATA, "got message type %#lx.\n", msg->dwType );
    ok_( __FILE__, line )( msg->dwPlayerType == expectedPlayerType, "got player type %#lx.\n", msg->dwPlayerType );
    ok_( __FILE__, line )( msg->dpId == expectedDpid, "got dpid %#lx.\n", msg->dpId );
    ok_( __FILE__, line )( msg->dwDataSize == expectedDataSize, "got player data size %lu.\n", msg->dwDataSize );
    if ( expectedData )
    {
        ok_( __FILE__, line )( msg->lpData && !memcmp( msg->lpData, expectedData, expectedDataSize ),
                               "data didn't match.\n" );
    }
    else
    {
        ok_( __FILE__, line )( !msg->lpData, "got data %p.\n", msg->lpData );
    }
 
    return toId;
}

◆ checkSpData_()

static void checkSpData_	(	int	line,
		SpData *	spData,
		unsigned short *	udpPort
	)

static

Definition at line 1209 of file dplayx.c.

{
    ok_( __FILE__, line )( spData->tcpAddr.sin_family == AF_INET, "got TCP family %d.\n", spData->tcpAddr.sin_family );
    ok_( __FILE__, line )( 2300 <= ntohs( spData->tcpAddr.sin_port ) && ntohs( spData->tcpAddr.sin_port ) < 2350,
                           "got TCP port %d.\n", ntohs( spData->tcpAddr.sin_port ) );
    ok_( __FILE__, line )( !spData->tcpAddr.sin_addr.s_addr, "got TCP address %#lx.\n",
                           spData->tcpAddr.sin_addr.s_addr );
    ok_( __FILE__, line )( spData->udpAddr.sin_family == AF_INET, "got UDP family %d.\n", spData->udpAddr.sin_family );
    ok_( __FILE__, line )( 2350 <= ntohs( spData->udpAddr.sin_port ) && ntohs( spData->udpAddr.sin_port ) < 2400,
                           "got UDP port %d.\n", ntohs( spData->udpAddr.sin_port ) );
    ok_( __FILE__, line )( !spData->udpAddr.sin_addr.s_addr, "got UDP address %#lx.\n",
                           spData->udpAddr.sin_addr.s_addr );
 
    if ( udpPort )
        *udpPort = ntohs( spData->udpAddr.sin_port );
}

Referenced by receiveAddForwardRequest_(), and receiveCreatePlayer_().

◆ checkSpHeader_()

static unsigned short checkSpHeader_	(	int	line,
		SpHeader *	header,
		DWORD	expectedSize
	)

static

Definition at line 1190 of file dplayx.c.

{
    ok_( __FILE__, line )( header->mixed == 0xfab00000 + expectedSize, "got mixed %#lx.\n", header->mixed );
    ok_( __FILE__, line )( header->addr.sin_family == AF_INET, "got family %d.\n", header->addr.sin_family );
    ok_( __FILE__, line )( 2300 <= ntohs( header->addr.sin_port ) && ntohs( header->addr.sin_port ) < 2350,
                           "got port %d.\n", ntohs( header->addr.sin_port ) );
    ok_( __FILE__, line )( !header->addr.sin_addr.s_addr, "got address %#lx.\n", header->addr.sin_addr.s_addr );
 
    return ntohs( header->addr.sin_port );
}

Referenced by receiveAddForwardAck_(), receiveAddForwardRequest_(), receiveAddPlayerToGroup_(), receiveCreatePlayer_(), receiveEnumSessionsRequest_(), receiveGuaranteedGameMessage_(), receivePingReply_(), and receiveRequestPlayerId_().

◆ connectTcp_()

static SOCKET connectTcp_	(	int	line,
		unsigned short	port
	)

static

Definition at line 1113 of file dplayx.c.

{
    SOCKADDR_IN addr;
    int wsResult;
    SOCKET sock;
 
    sock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
    ok_( __FILE__, line)( sock != INVALID_SOCKET, "got send socket %#Ix.\n", sock );
 
    addr.sin_family = AF_INET;
    addr.sin_port = htons( port );
    addr.sin_addr.s_addr = htonl( INADDR_LOOPBACK );
    wsResult = connect( sock, (SOCKADDR *) &addr, sizeof( addr ) );
    ok_( __FILE__, line)( !wsResult, "connect returned %d.\n", wsResult );
 
    return sock;
}

Referenced by check_CreatePlayer_(), check_EnumSessions_(), check_EnumSessions_async_(), check_Open_(), and joinSession_().

◆ connectUdp_()

static SOCKET connectUdp_	(	int	line,
		unsigned short	port
	)

static

Definition at line 1132 of file dplayx.c.

{
    SOCKADDR_IN addr;
    int wsResult;
    SOCKET sock;
 
    sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
    ok_( __FILE__, line)( sock != INVALID_SOCKET, "got send socket %#Ix.\n", sock );
 
    addr.sin_family = AF_INET;
    addr.sin_port = htons( port );
    addr.sin_addr.s_addr = htonl( INADDR_LOOPBACK );
    wsResult = connect( sock, (SOCKADDR *) &addr, sizeof( addr ) );
    ok_( __FILE__, line)( !wsResult, "connect returned %d.\n", wsResult );
 
    return sock;
}

◆ countSessionsCallback()

static BOOL CALLBACK countSessionsCallback	(	const DPSESSIONDESC2 *	thisSd,
		DWORD *	timeout,
		DWORD	flags,
		void *	context
	)

static

Definition at line 3271 of file dplayx.c.

{
    int *count = context;
 
    if (flags & DPESC_TIMEDOUT)
        return FALSE;
 
    ++*count;
 
    return TRUE;
}

Referenced by joinSession_(), and test_Open().

◆ create_session()

static IDirectPlay4 * create_session ( DPSESSIONDESC2 * lpdpsd )

static

Definition at line 3702 of file dplayx.c.

{
 
    IDirectPlay4 *pDP;
    DPNAME name;
    DPID dpid;
    HRESULT hr;
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                           &IID_IDirectPlay4A, (LPVOID*) &pDP );
    ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
    if (FAILED(hr)) return NULL;
 
    init_TCPIP_provider( pDP, "127.0.0.1", 0 );
 
    hr = IDirectPlayX_Open( pDP, lpdpsd, DPOPEN_CREATE );
    todo_wine checkHR( DP_OK, hr );
 
    if ( ! (lpdpsd->dwFlags & DPSESSION_NEWPLAYERSDISABLED) )
    {
        ZeroMemory( &name, sizeof(DPNAME) );
        name.dwSize = sizeof(DPNAME);
        name.lpszShortNameA = (LPSTR) "bofh";
 
        hr = IDirectPlayX_CreatePlayer( pDP, &dpid, &name, NULL, NULL,
                                        0, DPPLAYER_SERVERPLAYER );
        todo_wine checkHR( DP_OK, hr );
    }
 
    return pDP;
 
}

Referenced by test_interactive_EnumSessions().

◆ createPlayer_()

static void createPlayer_	(	int	line,
		IDirectPlay4 *	dp,
		DPID	inDpid,
		HANDLE	event,
		void *	data,
		DWORD	dataSize,
		DWORD	flags,
		SOCKET	sendSock,
		SOCKET	recvSock
	)

static

Definition at line 5200 of file dplayx.c.

{
    CreatePlayerParam *param;
    HRESULT hr;
    DPID dpid;
 
    dpid = 0xdeadbeef;
    param = createPlayerAsync( dp, &dpid, NULL, event, data, dataSize, flags );
 
    receiveRequestPlayerId_( line, recvSock, flags | DPPLAYER_LOCAL );
 
    sendRequestPlayerReply_( line, sendSock, 2349, inDpid, DP_OK );
 
    receiveCreatePlayer_( line, recvSock, inDpid, flags | DPPLAYER_LOCAL, NULL, NULL, data, dataSize );
 
    hr = createPlayerAsyncWait( param, 2000 );
    ok_( __FILE__, line )( hr == DP_OK, "got hr %#lx.\n", hr );
    ok_( __FILE__, line )( dpid == inDpid, "got dpid %#lx.\n", dpid );
}

◆ createPlayerAsync()

static CreatePlayerParam * createPlayerAsync	(	IDirectPlay4 *	dp,
		DPID *	dpid,
		DPNAME *	name,
		HANDLE	event,
		void *	data,
		DWORD	dataSize,
		DWORD	flags
	)

static

Definition at line 815 of file dplayx.c.

{
    CreatePlayerParam *param;
 
    param = calloc( 1, sizeof( CreatePlayerParam ) );
 
    param->dp = dp;
    param->dpid = dpid;
    param->name = name;
    param->event = event;
    param->data = data;
    param->dataSize = dataSize;
    param->flags = flags;
 
    param->thread = CreateThread( NULL, 0, createPlayerProc, param, 0, NULL );
 
    return param;
}

Referenced by check_CreatePlayer_(), createPlayer_(), and test_GetMessageQueue().

◆ createPlayerAsyncWait()

static HRESULT createPlayerAsyncWait	(	CreatePlayerParam *	param,
		DWORD	timeout
	)

static

Definition at line 835 of file dplayx.c.

{
    HRESULT hr = 0xdeadbeef;
    DWORD waitResult;
 
    waitResult = WaitForSingleObject( param->thread, timeout );
    CloseHandle( param->thread );
    if ( waitResult == WAIT_OBJECT_0 )
    {
        hr = param->hr;
        free( param );
    }
 
    return hr;
}

Referenced by check_CreatePlayer_(), createPlayer_(), and test_GetMessageQueue().

◆ createPlayerProc()

static DWORD CALLBACK createPlayerProc ( void * p )

static

Definition at line 805 of file dplayx.c.

{
    CreatePlayerParam *param = p;
 
    param->hr = IDirectPlayX_CreatePlayer( param->dp, param->dpid, param->name, param->event, param->data,
                                           param->dataSize, param->flags );
 
    return 0;
}

Referenced by createPlayerAsync().

◆ dbgStrAW()

static const char * dbgStrAW	(	const void *	str,
		BOOL	ansi
	)

static

Definition at line 80 of file dplayx.c.

{
    return ansi ? wine_dbgstr_a( str ) : wine_dbgstr_w( str );
}

Referenced by checkSessionListCallback().

◆ DEFINE_GUID() [1/4]

DEFINE_GUID	(	appGuid	,
		0xbdcfe03e	,
		0xf0ec	,
		0x415b	,
		0x82	,
		0x11	,
		0x6f	,
		0x86	,
		0xd8	,
		0x19	,
		0x7f	,
		0xe1
	)

◆ DEFINE_GUID() [2/4]

DEFINE_GUID	(	appGuid2	,
		0x93417d3f	,
		0x7d26	,
		0x46ba	,
		0xb5	,
		0x76	,
		0xfe	,
		0x4b	,
		0x20	,
		0xbb	,
		0xad	,
		0x70
	)

◆ DEFINE_GUID() [3/4]

DEFINE_GUID	(	GUID_NULL	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0
	)

◆ DEFINE_GUID() [4/4]

DEFINE_GUID	(	invalid_guid	,
		0x7b48b707	,
		0x0034	,
		0xc000	,
		0x02	,
		0x00	,
		0x00	,
		0x00	,
		0xec	,
		0xf6	,
		0x32	,
		0x00
	)

◆ dpid2char()

static char dpid2char	(	DPID *	dpid,
		DWORD	dpidSize,
		DPID	idPlayer
	)

static

Definition at line 603 of file dplayx.c.

{
    UINT i;
    if ( idPlayer == DPID_SYSMSG )
        return 'S';
    for (i=0; i<dpidSize; i++)
    {
        if ( idPlayer == dpid[i] )
            return (char)(i+48);
    }
    return '?';
}

Referenced by check_messages(), EnumGroups_cb(), and EnumPlayers_cb().

◆ dpMsgType2str()

static LPCSTR dpMsgType2str ( DWORD dwType )

static

Definition at line 249 of file dplayx.c.

{
    switch(dwType)
    {
    case DPSYS_CREATEPLAYERORGROUP:      return "DPSYS_CREATEPLAYERORGROUP";
    case DPSYS_DESTROYPLAYERORGROUP:     return "DPSYS_DESTROYPLAYERORGROUP";
    case DPSYS_ADDPLAYERTOGROUP:         return "DPSYS_ADDPLAYERTOGROUP";
    case DPSYS_DELETEPLAYERFROMGROUP:    return "DPSYS_DELETEPLAYERFROMGROUP";
    case DPSYS_SESSIONLOST:              return "DPSYS_SESSIONLOST";
    case DPSYS_HOST:                     return "DPSYS_HOST";
    case DPSYS_SETPLAYERORGROUPDATA:     return "DPSYS_SETPLAYERORGROUPDATA";
    case DPSYS_SETPLAYERORGROUPNAME:     return "DPSYS_SETPLAYERORGROUPNAME";
    case DPSYS_SETSESSIONDESC:           return "DPSYS_SETSESSIONDESC";
    case DPSYS_ADDGROUPTOGROUP:          return "DPSYS_ADDGROUPTOGROUP";
    case DPSYS_DELETEGROUPFROMGROUP:     return "DPSYS_DELETEGROUPFROMGROUP";
    case DPSYS_SECUREMESSAGE:            return "DPSYS_SECUREMESSAGE";
    case DPSYS_STARTSESSION:             return "DPSYS_STARTSESSION";
    case DPSYS_CHAT:                     return "DPSYS_DPSYS_CHAT";
    case DPSYS_SETGROUPOWNER:            return "DPSYS_SETGROUPOWNER";
    case DPSYS_SENDCOMPLETE:             return "DPSYS_SENDCOMPLETE";
 
    default:                             return "UNKNOWN";
    }
}

Referenced by test_CreateGroup(), test_host_migration(), test_interactive_Receive(), test_interactive_Send(), and test_remote_data_replication().

◆ dpResult2str()

static LPCSTR dpResult2str ( HRESULT hr )

static

Definition at line 167 of file dplayx.c.

{
    switch (hr)
    {
    case DP_OK:                          return "DP_OK";
    case DPERR_ALREADYINITIALIZED:       return "DPERR_ALREADYINITIALIZED";
    case DPERR_ACCESSDENIED:             return "DPERR_ACCESSDENIED";
    case DPERR_ACTIVEPLAYERS:            return "DPERR_ACTIVEPLAYERS";
    case DPERR_BUFFERTOOSMALL:           return "DPERR_BUFFERTOOSMALL";
    case DPERR_CANTADDPLAYER:            return "DPERR_CANTADDPLAYER";
    case DPERR_CANTCREATEGROUP:          return "DPERR_CANTCREATEGROUP";
    case DPERR_CANTCREATEPLAYER:         return "DPERR_CANTCREATEPLAYER";
    case DPERR_CANTCREATESESSION:        return "DPERR_CANTCREATESESSION";
    case DPERR_CAPSNOTAVAILABLEYET:      return "DPERR_CAPSNOTAVAILABLEYET";
    case DPERR_EXCEPTION:                return "DPERR_EXCEPTION";
    case DPERR_GENERIC:                  return "DPERR_GENERIC";
    case DPERR_INVALIDFLAGS:             return "DPERR_INVALIDFLAGS";
    case DPERR_INVALIDOBJECT:            return "DPERR_INVALIDOBJECT";
    case DPERR_INVALIDPARAMS:            return "DPERR_INVALIDPARAMS";
        /*           symbol with the same value: DPERR_INVALIDPARAM */
    case DPERR_INVALIDPLAYER:            return "DPERR_INVALIDPLAYER";
    case DPERR_INVALIDGROUP:             return "DPERR_INVALIDGROUP";
    case DPERR_NOCAPS:                   return "DPERR_NOCAPS";
    case DPERR_NOCONNECTION:             return "DPERR_NOCONNECTION";
    case DPERR_NOMEMORY:                 return "DPERR_NOMEMORY";
        /*           symbol with the same value: DPERR_OUTOFMEMORY */
    case DPERR_NOMESSAGES:               return "DPERR_NOMESSAGES";
    case DPERR_NONAMESERVERFOUND:        return "DPERR_NONAMESERVERFOUND";
    case DPERR_NOPLAYERS:                return "DPERR_NOPLAYERS";
    case DPERR_NOSESSIONS:               return "DPERR_NOSESSIONS";
    case DPERR_PENDING:                  return "DPERR_PENDING";
    case DPERR_SENDTOOBIG:               return "DPERR_SENDTOOBIG";
    case DPERR_TIMEOUT:                  return "DPERR_TIMEOUT";
    case DPERR_UNAVAILABLE:              return "DPERR_UNAVAILABLE";
    case DPERR_UNSUPPORTED:              return "DPERR_UNSUPPORTED";
    case DPERR_BUSY:                     return "DPERR_BUSY";
    case DPERR_USERCANCEL:               return "DPERR_USERCANCEL";
    case DPERR_NOINTERFACE:              return "DPERR_NOINTERFACE";
    case DPERR_CANNOTCREATESERVER:       return "DPERR_CANNOTCREATESERVER";
    case DPERR_PLAYERLOST:               return "DPERR_PLAYERLOST";
    case DPERR_SESSIONLOST:              return "DPERR_SESSIONLOST";
    case DPERR_UNINITIALIZED:            return "DPERR_UNINITIALIZED";
    case DPERR_NONEWPLAYERS:             return "DPERR_NONEWPLAYERS";
    case DPERR_INVALIDPASSWORD:          return "DPERR_INVALIDPASSWORD";
    case DPERR_CONNECTING:               return "DPERR_CONNECTING";
    case DPERR_CONNECTIONLOST:           return "DPERR_CONNECTIONLOST";
    case DPERR_UNKNOWNMESSAGE:           return "DPERR_UNKNOWNMESSAGE";
    case DPERR_CANCELFAILED:             return "DPERR_CANCELFAILED";
    case DPERR_INVALIDPRIORITY:          return "DPERR_INVALIDPRIORITY";
    case DPERR_NOTHANDLED:               return "DPERR_NOTHANDLED";
    case DPERR_CANCELLED:                return "DPERR_CANCELLED";
    case DPERR_ABORTED:                  return "DPERR_ABORTED";
    case DPERR_BUFFERTOOLARGE:           return "DPERR_BUFFERTOOLARGE";
    case DPERR_CANTCREATEPROCESS:        return "DPERR_CANTCREATEPROCESS";
    case DPERR_APPNOTSTARTED:            return "DPERR_APPNOTSTARTED";
    case DPERR_INVALIDINTERFACE:         return "DPERR_INVALIDINTERFACE";
    case DPERR_NOSERVICEPROVIDER:        return "DPERR_NOSERVICEPROVIDER";
    case DPERR_UNKNOWNAPPLICATION:       return "DPERR_UNKNOWNAPPLICATION";
    case DPERR_NOTLOBBIED:               return "DPERR_NOTLOBBIED";
    case DPERR_SERVICEPROVIDERLOADED:    return "DPERR_SERVICEPROVIDERLOADED";
    case DPERR_ALREADYREGISTERED:        return "DPERR_ALREADYREGISTERED";
    case DPERR_NOTREGISTERED:            return "DPERR_NOTREGISTERED";
    case DPERR_AUTHENTICATIONFAILED:     return "DPERR_AUTHENTICATIONFAILED";
    case DPERR_CANTLOADSSPI:             return "DPERR_CANTLOADSSPI";
    case DPERR_ENCRYPTIONFAILED:         return "DPERR_ENCRYPTIONFAILED";
    case DPERR_SIGNFAILED:               return "DPERR_SIGNFAILED";
    case DPERR_CANTLOADSECURITYPACKAGE:  return "DPERR_CANTLOADSECURITYPACKAGE";
    case DPERR_ENCRYPTIONNOTSUPPORTED:   return "DPERR_ENCRYPTIONNOTSUPPORTED";
    case DPERR_CANTLOADCAPI:             return "DPERR_CANTLOADCAPI";
    case DPERR_NOTLOGGEDIN:              return "DPERR_NOTLOGGEDIN";
    case DPERR_LOGONDENIED:              return "DPERR_LOGONDENIED";
    case CLASS_E_NOAGGREGATION:          return "CLASS_E_NOAGGREGATION";
 
    default:
    {
        LPSTR buffer = get_temp_buffer();
        sprintf( buffer, "%ld", HRESULT_CODE(hr) );
        return buffer;
    }
    }
}

◆ dwFlags2str()

static LPCSTR dwFlags2str	(	DWORD	dwFlags,
		DWORD	flagType
	)

static

Definition at line 274 of file dplayx.c.

{
 
#define FLAGS_DPCONNECTION     (1<<0)
#define FLAGS_DPENUMPLAYERS    (1<<1)
#define FLAGS_DPENUMGROUPS     (1<<2)
#define FLAGS_DPPLAYER         (1<<3)
#define FLAGS_DPGROUP          (1<<4)
#define FLAGS_DPENUMSESSIONS   (1<<5)
#define FLAGS_DPGETCAPS        (1<<6)
#define FLAGS_DPGET            (1<<7)
#define FLAGS_DPRECEIVE        (1<<8)
#define FLAGS_DPSEND           (1<<9)
#define FLAGS_DPSET            (1<<10)
#define FLAGS_DPMESSAGEQUEUE   (1<<11)
#define FLAGS_DPCONNECT        (1<<12)
#define FLAGS_DPOPEN           (1<<13)
#define FLAGS_DPSESSION        (1<<14)
#define FLAGS_DPLCONNECTION    (1<<15)
#define FLAGS_DPESC            (1<<16)
#define FLAGS_DPCAPS           (1<<17)
 
    LPSTR flags = get_temp_buffer();
 
    /* EnumConnections */
 
    if (flagType & FLAGS_DPCONNECTION)
    {
        if (dwFlags & DPCONNECTION_DIRECTPLAY)
            strcat(flags, "DPCONNECTION_DIRECTPLAY,");
        if (dwFlags & DPCONNECTION_DIRECTPLAYLOBBY)
            strcat(flags, "DPCONNECTION_DIRECTPLAYLOBBY,");
    }
 
    /* EnumPlayers,
       EnumGroups */
 
    if (flagType & FLAGS_DPENUMPLAYERS)
    {
        if (dwFlags == DPENUMPLAYERS_ALL)
            strcat(flags, "DPENUMPLAYERS_ALL,");
        if (dwFlags & DPENUMPLAYERS_LOCAL)
            strcat(flags, "DPENUMPLAYERS_LOCAL,");
        if (dwFlags & DPENUMPLAYERS_REMOTE)
            strcat(flags, "DPENUMPLAYERS_REMOTE,");
        if (dwFlags & DPENUMPLAYERS_GROUP)
            strcat(flags, "DPENUMPLAYERS_GROUP,");
        if (dwFlags & DPENUMPLAYERS_SESSION)
            strcat(flags, "DPENUMPLAYERS_SESSION,");
        if (dwFlags & DPENUMPLAYERS_SERVERPLAYER)
            strcat(flags, "DPENUMPLAYERS_SERVERPLAYER,");
        if (dwFlags & DPENUMPLAYERS_SPECTATOR)
            strcat(flags, "DPENUMPLAYERS_SPECTATOR,");
        if (dwFlags & DPENUMPLAYERS_OWNER)
            strcat(flags, "DPENUMPLAYERS_OWNER,");
    }
    if (flagType & FLAGS_DPENUMGROUPS)
    {
        if (dwFlags == DPENUMGROUPS_ALL)
            strcat(flags, "DPENUMGROUPS_ALL,");
        if (dwFlags & DPENUMPLAYERS_LOCAL)
            strcat(flags, "DPENUMGROUPS_LOCAL,");
        if (dwFlags & DPENUMPLAYERS_REMOTE)
            strcat(flags, "DPENUMGROUPS_REMOTE,");
        if (dwFlags & DPENUMPLAYERS_GROUP)
            strcat(flags, "DPENUMGROUPS_GROUP,");
        if (dwFlags & DPENUMPLAYERS_SESSION)
            strcat(flags, "DPENUMGROUPS_SESSION,");
        if (dwFlags & DPENUMGROUPS_SHORTCUT)
            strcat(flags, "DPENUMGROUPS_SHORTCUT,");
        if (dwFlags & DPENUMGROUPS_STAGINGAREA)
            strcat(flags, "DPENUMGROUPS_STAGINGAREA,");
        if (dwFlags & DPENUMGROUPS_HIDDEN)
            strcat(flags, "DPENUMGROUPS_HIDDEN,");
    }
 
    /* CreatePlayer */
 
    if (flagType & FLAGS_DPPLAYER)
    {
        if (dwFlags & DPPLAYER_SERVERPLAYER)
            strcat(flags, "DPPLAYER_SERVERPLAYER,");
        if (dwFlags & DPPLAYER_SPECTATOR)
            strcat(flags, "DPPLAYER_SPECTATOR,");
        if (dwFlags & DPPLAYER_LOCAL)
            strcat(flags, "DPPLAYER_LOCAL,");
        if (dwFlags & DPPLAYER_OWNER)
            strcat(flags, "DPPLAYER_OWNER,");
    }
 
    /* CreateGroup */
 
    if (flagType & FLAGS_DPGROUP)
    {
        if (dwFlags & DPGROUP_STAGINGAREA)
            strcat(flags, "DPGROUP_STAGINGAREA,");
        if (dwFlags & DPGROUP_LOCAL)
            strcat(flags, "DPGROUP_LOCAL,");
        if (dwFlags & DPGROUP_HIDDEN)
            strcat(flags, "DPGROUP_HIDDEN,");
    }
 
    /* EnumSessions */
 
    if (flagType & FLAGS_DPENUMSESSIONS)
    {
        if (dwFlags & DPENUMSESSIONS_AVAILABLE)
            strcat(flags, "DPENUMSESSIONS_AVAILABLE,");
        if (dwFlags &  DPENUMSESSIONS_ALL)
            strcat(flags, "DPENUMSESSIONS_ALL,");
        if (dwFlags & DPENUMSESSIONS_ASYNC)
            strcat(flags, "DPENUMSESSIONS_ASYNC,");
        if (dwFlags & DPENUMSESSIONS_STOPASYNC)
            strcat(flags, "DPENUMSESSIONS_STOPASYNC,");
        if (dwFlags & DPENUMSESSIONS_PASSWORDREQUIRED)
            strcat(flags, "DPENUMSESSIONS_PASSWORDREQUIRED,");
        if (dwFlags & DPENUMSESSIONS_RETURNSTATUS)
            strcat(flags, "DPENUMSESSIONS_RETURNSTATUS,");
    }
 
    /* GetCaps,
       GetPlayerCaps */
 
    if (flagType & FLAGS_DPGETCAPS)
    {
        if (dwFlags & DPGETCAPS_GUARANTEED)
            strcat(flags, "DPGETCAPS_GUARANTEED,");
    }
 
    /* GetGroupData,
       GetPlayerData */
 
    if (flagType & FLAGS_DPGET)
    {
        if (dwFlags == DPGET_REMOTE)
            strcat(flags, "DPGET_REMOTE,");
        if (dwFlags & DPGET_LOCAL)
            strcat(flags, "DPGET_LOCAL,");
    }
 
    /* Receive */
 
    if (flagType & FLAGS_DPRECEIVE)
    {
        if (dwFlags & DPRECEIVE_ALL)
            strcat(flags, "DPRECEIVE_ALL,");
        if (dwFlags & DPRECEIVE_TOPLAYER)
            strcat(flags, "DPRECEIVE_TOPLAYER,");
        if (dwFlags & DPRECEIVE_FROMPLAYER)
            strcat(flags, "DPRECEIVE_FROMPLAYER,");
        if (dwFlags & DPRECEIVE_PEEK)
            strcat(flags, "DPRECEIVE_PEEK,");
    }
 
    /* Send */
 
    if (flagType & FLAGS_DPSEND)
    {
        /*if (dwFlags == DPSEND_NONGUARANTEED)
          strcat(flags, "DPSEND_NONGUARANTEED,");*/
        if (dwFlags == DPSEND_MAX_PRIORITY) /* = DPSEND_MAX_PRI */
        {
            strcat(flags, "DPSEND_MAX_PRIORITY,");
        }
        else
        {
            if (dwFlags & DPSEND_GUARANTEED)
                strcat(flags, "DPSEND_GUARANTEED,");
            if (dwFlags & DPSEND_HIGHPRIORITY)
                strcat(flags, "DPSEND_HIGHPRIORITY,");
            if (dwFlags & DPSEND_OPENSTREAM)
                strcat(flags, "DPSEND_OPENSTREAM,");
            if (dwFlags & DPSEND_CLOSESTREAM)
                strcat(flags, "DPSEND_CLOSESTREAM,");
            if (dwFlags & DPSEND_SIGNED)
                strcat(flags, "DPSEND_SIGNED,");
            if (dwFlags & DPSEND_ENCRYPTED)
                strcat(flags, "DPSEND_ENCRYPTED,");
            if (dwFlags & DPSEND_LOBBYSYSTEMMESSAGE)
                strcat(flags, "DPSEND_LOBBYSYSTEMMESSAGE,");
            if (dwFlags & DPSEND_ASYNC)
                strcat(flags, "DPSEND_ASYNC,");
            if (dwFlags & DPSEND_NOSENDCOMPLETEMSG)
                strcat(flags, "DPSEND_NOSENDCOMPLETEMSG,");
        }
    }
 
    /* SetGroupData,
       SetGroupName,
       SetPlayerData,
       SetPlayerName,
       SetSessionDesc */
 
    if (flagType & FLAGS_DPSET)
    {
        if (dwFlags == DPSET_REMOTE)
            strcat(flags, "DPSET_REMOTE,");
        if (dwFlags & DPSET_LOCAL)
            strcat(flags, "DPSET_LOCAL,");
        if (dwFlags & DPSET_GUARANTEED)
            strcat(flags, "DPSET_GUARANTEED,");
    }
 
    /* GetMessageQueue */
 
    if (flagType & FLAGS_DPMESSAGEQUEUE)
    {
        if (dwFlags & DPMESSAGEQUEUE_SEND)
            strcat(flags, "DPMESSAGEQUEUE_SEND,");
        if (dwFlags & DPMESSAGEQUEUE_RECEIVE)
            strcat(flags, "DPMESSAGEQUEUE_RECEIVE,");
    }
 
    /* Connect */
 
    if (flagType & FLAGS_DPCONNECT)
    {
        if (dwFlags & DPCONNECT_RETURNSTATUS)
            strcat(flags, "DPCONNECT_RETURNSTATUS,");
    }
 
    /* Open */
 
    if (flagType & FLAGS_DPOPEN)
    {
        if (dwFlags & DPOPEN_JOIN)
            strcat(flags, "DPOPEN_JOIN,");
        if (dwFlags & DPOPEN_CREATE)
            strcat(flags, "DPOPEN_CREATE,");
        if (dwFlags & DPOPEN_RETURNSTATUS)
            strcat(flags, "DPOPEN_RETURNSTATUS,");
    }
 
    /* DPSESSIONDESC2 */
 
    if (flagType & FLAGS_DPSESSION)
    {
        if (dwFlags & DPSESSION_NEWPLAYERSDISABLED)
            strcat(flags, "DPSESSION_NEWPLAYERSDISABLED,");
        if (dwFlags & DPSESSION_MIGRATEHOST)
            strcat(flags, "DPSESSION_MIGRATEHOST,");
        if (dwFlags & DPSESSION_NOMESSAGEID)
            strcat(flags, "DPSESSION_NOMESSAGEID,");
        if (dwFlags & DPSESSION_JOINDISABLED)
            strcat(flags, "DPSESSION_JOINDISABLED,");
        if (dwFlags & DPSESSION_KEEPALIVE)
            strcat(flags, "DPSESSION_KEEPALIVE,");
        if (dwFlags & DPSESSION_NODATAMESSAGES)
            strcat(flags, "DPSESSION_NODATAMESSAGES,");
        if (dwFlags & DPSESSION_SECURESERVER)
            strcat(flags, "DPSESSION_SECURESERVER,");
        if (dwFlags & DPSESSION_PRIVATE)
            strcat(flags, "DPSESSION_PRIVATE,");
        if (dwFlags & DPSESSION_PASSWORDREQUIRED)
            strcat(flags, "DPSESSION_PASSWORDREQUIRED,");
        if (dwFlags & DPSESSION_MULTICASTSERVER)
            strcat(flags, "DPSESSION_MULTICASTSERVER,");
        if (dwFlags & DPSESSION_CLIENTSERVER)
            strcat(flags, "DPSESSION_CLIENTSERVER,");
 
        if (dwFlags & DPSESSION_DIRECTPLAYPROTOCOL)
            strcat(flags, "DPSESSION_DIRECTPLAYPROTOCOL,");
        if (dwFlags & DPSESSION_NOPRESERVEORDER)
            strcat(flags, "DPSESSION_NOPRESERVEORDER,");
        if (dwFlags & DPSESSION_OPTIMIZELATENCY)
            strcat(flags, "DPSESSION_OPTIMIZELATENCY,");
 
    }
 
    /* DPLCONNECTION */
 
    if (flagType & FLAGS_DPLCONNECTION)
    {
        if (dwFlags & DPLCONNECTION_CREATESESSION)
            strcat(flags, "DPLCONNECTION_CREATESESSION,");
        if (dwFlags & DPLCONNECTION_JOINSESSION)
            strcat(flags, "DPLCONNECTION_JOINSESSION,");
    }
 
    /* EnumSessionsCallback2 */
 
    if (flagType & FLAGS_DPESC)
    {
        if (dwFlags & DPESC_TIMEDOUT)
            strcat(flags, "DPESC_TIMEDOUT,");
    }
 
    /* GetCaps,
       GetPlayerCaps */
 
    if (flagType & FLAGS_DPCAPS)
    {
        if (dwFlags & DPCAPS_ISHOST)
            strcat(flags, "DPCAPS_ISHOST,");
        if (dwFlags & DPCAPS_GROUPOPTIMIZED)
            strcat(flags, "DPCAPS_GROUPOPTIMIZED,");
        if (dwFlags & DPCAPS_KEEPALIVEOPTIMIZED)
            strcat(flags, "DPCAPS_KEEPALIVEOPTIMIZED,");
        if (dwFlags & DPCAPS_GUARANTEEDOPTIMIZED)
            strcat(flags, "DPCAPS_GUARANTEEDOPTIMIZED,");
        if (dwFlags & DPCAPS_GUARANTEEDSUPPORTED)
            strcat(flags, "DPCAPS_GUARANTEEDSUPPORTED,");
        if (dwFlags & DPCAPS_SIGNINGSUPPORTED)
            strcat(flags, "DPCAPS_SIGNINGSUPPORTED,");
        if (dwFlags & DPCAPS_ENCRYPTIONSUPPORTED)
            strcat(flags, "DPCAPS_ENCRYPTIONSUPPORTED,");
        if (dwFlags & DPCAPS_ASYNCCANCELSUPPORTED)
            strcat(flags, "DPCAPS_ASYNCCANCELSUPPORTED,");
        if (dwFlags & DPCAPS_ASYNCCANCELALLSUPPORTED)
            strcat(flags, "DPCAPS_ASYNCCANCELALLSUPPORTED,");
        if (dwFlags & DPCAPS_SENDTIMEOUTSUPPORTED)
            strcat(flags, "DPCAPS_SENDTIMEOUTSUPPORTED,");
        if (dwFlags & DPCAPS_SENDPRIORITYSUPPORTED)
            strcat(flags, "DPCAPS_SENDPRIORITYSUPPORTED,");
        if (dwFlags & DPCAPS_ASYNCSUPPORTED)
            strcat(flags, "DPCAPS_ASYNCSUPPORTED,");
 
        if (dwFlags & DPPLAYERCAPS_LOCAL)
            strcat(flags, "DPPLAYERCAPS_LOCAL,");
    }
 
    if ((strlen(flags) == 0) && (dwFlags != 0))
        strcpy(flags, "UNKNOWN");
    else
        flags[strlen(flags)-1] = '\0';
 
    return flags;
}

Referenced by checkFlags_(), EnumGroups_cb(), and EnumPlayers_cb().

◆ EnumAddress_cb()

static BOOL CALLBACK EnumAddress_cb	(	REFGUID	guidDataType,
		DWORD	dwDataSize,
		LPCVOID	lpData,
		LPVOID	lpContext
	)

static

Definition at line 6138 of file dplayx.c.

{
    lpCallbackData callbackData = lpContext;
    static REFGUID types[] = { &DPAID_TotalSize,
                               &DPAID_ServiceProvider,
                               &DPAID_INet,
                               &DPAID_INetW };
    static DWORD sizes[] = { 4, 16, 12, 24, 4, 16, 10, 20 };
 
 
    checkGuid( types[callbackData->dwCounter1%4], guidDataType );
    check( sizes[callbackData->dwCounter1], dwDataSize );
 
    switch(callbackData->dwCounter1)
    {
    case 0:
        check( 136, *(LPDWORD) lpData );
        break;
    case 4:
        check( 130, *(LPDWORD) lpData );
        break;
    case 1:
    case 5:
        checkGuid( &DPSPGUID_TCPIP, lpData );
        break;
    case 6:
        checkStr( "127.0.0.1", (LPSTR) lpData );
        break;
    default: break;
    }
 
 
    callbackData->dwCounter1++;
 
    return TRUE;
}

Referenced by test_GetPlayerAddress().

◆ EnumAddress_cb2()

static BOOL CALLBACK EnumAddress_cb2	(	REFGUID	guidDataType,
		DWORD	dwDataSize,
		LPCVOID	lpData,
		LPVOID	lpContext
	)

static

Definition at line 2507 of file dplayx.c.

{
    lpCallbackData callbackData = lpContext;
 
    static REFGUID types[] = { &DPAID_TotalSize,
                               &DPAID_ServiceProvider,
                               &GUID_NULL };
    static DWORD sizes[] = { 4, 16, 0  };
    static REFGUID sps[] = { &DPSPGUID_SERIAL, &DPSPGUID_MODEM,
                             &DPSPGUID_IPX, &DPSPGUID_TCPIP };
 
 
    checkGuid( types[ callbackData->dwCounter2 ], guidDataType );
    check( sizes[ callbackData->dwCounter2 ], dwDataSize );
 
    if ( IsEqualGUID( types[0], guidDataType ) )
    {
        todo_wine check( 80, *((LPDWORD) lpData) );
    }
    else if ( IsEqualGUID( types[1], guidDataType ) )
    {
        BOOL found = FALSE;
        int i;
        for( i=0; i < ARRAY_SIZE(sps) && !found; i++ )
            found = IsEqualGUID( sps[i], lpData );
        ok( found, "Unknown Address type found %s\n", wine_dbgstr_guid(lpData) );
    }
 
    callbackData->dwCounter2++;
 
    return TRUE;
}

Referenced by EnumConnections_cb().

◆ EnumAddressesCallback()

static BOOL CALLBACK EnumAddressesCallback	(	REFGUID	guidDataType,
		DWORD	size,
		const void *	data,
		void *	context
	)

static

Definition at line 2769 of file dplayx.c.

{
    if (IsEqualGUID(guidDataType, &DPAID_TotalSize))
        enum_addresses_cb_count++;
    else if (IsEqualGUID(guidDataType, &DPAID_ServiceProvider))
        enum_addresses_cb_count++;
    else if(IsEqualGUID(guidDataType, &invalid_guid))
        enum_addresses_cb_count++;
    else
        ok(0, "guidDataType %s\n", wine_dbgstr_guid(guidDataType));
 
    return TRUE;
}

Referenced by test_EnumAddresses().

◆ EnumAddressTypeCallback()

static BOOL CALLBACK EnumAddressTypeCallback	(	REFGUID	guidDataType,
		LPVOID	lpContext,
		DWORD	flags
	)

static

Definition at line 2836 of file dplayx.c.

{
    if (IsEqualGUID(guidDataType, &DPAID_INet))
        enum_address_cb_count++;
    else
        ok(0, "guidDataType %s\n", wine_dbgstr_guid(guidDataType));
 
    return TRUE;
}

Referenced by test_EnumAddressTypes().

◆ EnumConnections_cb()

static BOOL CALLBACK EnumConnections_cb	(	LPCGUID	lpguidSP,
		LPVOID	lpConnection,
		DWORD	dwConnectionSize,
		LPCDPNAME	lpName,
		DWORD	dwFlags,
		LPVOID	lpContext
	)

static

Definition at line 2543 of file dplayx.c.

{
 
    lpCallbackData callbackData = lpContext;
    IDirectPlayLobby *pDPL;
    HRESULT hr;
 
 
    if (!callbackData->dwFlags)
    {
        callbackData->dwFlags = DPCONNECTION_DIRECTPLAY;
    }
 
    checkFlags( callbackData->dwFlags, dwFlags, FLAGS_DPCONNECTION );
 
    /* Get info from lpConnection */
    hr = CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL,
                           &IID_IDirectPlayLobby3A, (LPVOID*) &pDPL );
    ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlayLobby / IID_IDirectPlayLobby3A failed\n");
    if (FAILED(hr))
        return FALSE;
 
    callbackData->dwCounter2 = 0;
    IDirectPlayLobby_EnumAddress( pDPL, EnumAddress_cb2, lpConnection,
                                  dwConnectionSize, callbackData );
    todo_wine check( 3, callbackData->dwCounter2 );
 
    callbackData->dwCounter1++;
 
    IDirectPlayLobby_Release(pDPL);
 
    return TRUE;
}

Referenced by test_EnumConnections().

◆ EnumConnections_cb2()

static BOOL CALLBACK EnumConnections_cb2	(	LPCGUID	lpguidSP,
		LPVOID	lpConnection,
		DWORD	dwConnectionSize,
		LPCDPNAME	lpName,
		DWORD	dwFlags,
		LPVOID	lpContext
	)

static

Definition at line 2655 of file dplayx.c.

{
    IDirectPlay4 *pDP = lpContext;
    HRESULT hr;
 
    /* Incorrect parameters */
    hr = IDirectPlayX_InitializeConnection( pDP, NULL, 1 );
    checkHR( DPERR_INVALIDPARAMS, hr );
    hr = IDirectPlayX_InitializeConnection( pDP, lpConnection, 1 );
    checkHR( DPERR_INVALIDFLAGS, hr );
 
    /* Normal operation.
       We're only interested in ensuring that the TCP/IP provider works */
 
    if( IsEqualGUID(lpguidSP, &DPSPGUID_TCPIP) )
    {
        hr = IDirectPlayX_InitializeConnection( pDP, lpConnection, 0 );
        checkHR( DP_OK, hr );
        hr = IDirectPlayX_InitializeConnection( pDP, lpConnection, 0 );
        checkHR( DPERR_ALREADYINITIALIZED, hr );
    }
 
    return TRUE;
}

Referenced by test_InitializeConnection().

◆ EnumGroups_cb()

static BOOL CALLBACK EnumGroups_cb	(	DPID	dpId,
		DWORD	dwPlayerType,
		LPCDPNAME	lpName,
		DWORD	dwFlags,
		LPVOID	lpContext
	)

static

Definition at line 7142 of file dplayx.c.

{
    lpCallbackData callbackData = lpContext;
    char playerIndex = dpid2char( callbackData->dpid,
                                  callbackData->dpidSize,
                                  dpId );
 
 
    /* Trace to study player ids */
    callbackData->szTrace1[ callbackData->dwCounter1 ] = playerIndex;
    callbackData->dwCounter1++;
    callbackData->szTrace1[ callbackData->dwCounter1 ] = '\0';
 
    /* Trace to study flags received */
    strcat( callbackData->szTrace2,
            ( dwFlags2str(dwFlags, FLAGS_DPENUMGROUPS) +
              strlen("DPENUMGROUPS_") ) );
    strcat( callbackData->szTrace2, ":" );
 
 
    check( DPPLAYERTYPE_GROUP, dwPlayerType );
 
    return TRUE;
}

Referenced by EnumSessions_cb_EnumGroups(), test_EnumGroups(), and test_EnumGroupsInGroup().

◆ EnumPlayers_cb()

static BOOL CALLBACK EnumPlayers_cb	(	DPID	dpId,
		DWORD	dwPlayerType,
		LPCDPNAME	lpName,
		DWORD	dwFlags,
		LPVOID	lpContext
	)

static

Definition at line 6811 of file dplayx.c.

{
    lpCallbackData callbackData = lpContext;
    char playerIndex = dpid2char( callbackData->dpid,
                                  callbackData->dpidSize,
                                  dpId );
 
 
    /* Trace to study player ids */
    callbackData->szTrace1[ callbackData->dwCounter1 ] = playerIndex;
    callbackData->dwCounter1++;
    callbackData->szTrace1[ callbackData->dwCounter1 ] = '\0';
 
    /* Trace to study flags received */
    strcat( callbackData->szTrace2,
            ( dwFlags2str(dwFlags, FLAGS_DPENUMPLAYERS) +
              strlen("DPENUMPLAYERS_") ) );
    strcat( callbackData->szTrace2, ":" );
 
 
    if ( playerIndex < '5' )
    {
        check( DPPLAYERTYPE_PLAYER, dwPlayerType );
    }
    else
    {
        check( DPPLAYERTYPE_GROUP, dwPlayerType );
    }
 
    return TRUE;
 
}

Referenced by EnumSessions_cb_EnumPlayers(), and test_EnumPlayers().

◆ EnumSessions_cb()

static BOOL CALLBACK EnumSessions_cb	(	LPCDPSESSIONDESC2	lpThisSD,
		LPDWORD	lpdwTimeOut,
		DWORD	dwFlags,
		LPVOID	lpContext
	)

static

Definition at line 3670 of file dplayx.c.

{
    lpCallbackData callbackData = lpContext;
    callbackData->dwCounter1++;
 
    if ( dwFlags & DPESC_TIMEDOUT )
    {
        check( TRUE, lpThisSD == NULL );
        return FALSE;
    }
    check( FALSE, lpThisSD == NULL );
 
 
    if ( lpThisSD->lpszPasswordA != NULL )
    {
        check( TRUE, (lpThisSD->dwFlags & DPSESSION_PASSWORDREQUIRED) != 0 );
    }
 
    if ( lpThisSD->dwFlags & DPSESSION_NEWPLAYERSDISABLED )
    {
        check( 0, lpThisSD->dwCurrentPlayers );
    }
 
    check( sizeof(*lpThisSD), lpThisSD->dwSize );
    checkLP( NULL, lpThisSD->lpszPasswordA );
 
    return TRUE;
}

Referenced by test_interactive_EnumSessions().

◆ EnumSessions_cb2()

static BOOL CALLBACK EnumSessions_cb2	(	LPCDPSESSIONDESC2	lpThisSD,
		LPDWORD	lpdwTimeOut,
		DWORD	dwFlags,
		LPVOID	lpContext
	)

static

Definition at line 2866 of file dplayx.c.

{
    IDirectPlay4 *pDP = lpContext;
    DPSESSIONDESC2 dpsd;
    HRESULT hr;
 
    if (dwFlags & DPESC_TIMEDOUT)
        return FALSE;
 
 
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    dpsd.guidInstance = lpThisSD->guidInstance;
 
    if ( lpThisSD->dwFlags & DPSESSION_PASSWORDREQUIRED )
    {
        /* Incorrect password */
        dpsd.lpszPasswordA = (LPSTR) "sonic boom";
        hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
        checkHR( DPERR_INVALIDPASSWORD, hr );
 
        /* Correct password */
        dpsd.lpszPasswordA = (LPSTR) "hadouken";
        hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
        checkHR( DP_OK, hr );
    }
    else
    {
        hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
        checkHR( DP_OK, hr );
    }
 
    hr = IDirectPlayX_Close( pDP );
    checkHR( DP_OK, hr );
 
    return TRUE;
}

Referenced by test_interactive_Open().

◆ EnumSessions_cb_EnumGroups()

static BOOL CALLBACK EnumSessions_cb_EnumGroups	(	LPCDPSESSIONDESC2	lpThisSD,
		LPDWORD	lpdwTimeOut,
		DWORD	dwFlags,
		LPVOID	lpContext
	)

static

Definition at line 7171 of file dplayx.c.

{
    lpCallbackData callbackData = lpContext;
    HRESULT hr;
 
    if (dwFlags & DPESC_TIMEDOUT)
    {
        return FALSE;
    }
 
    /* guid = NULL */
    callbackData->dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroups( callbackData->pDP, NULL,
                                  EnumGroups_cb, &callbackData, 0 );
    checkHR( DPERR_NOSESSIONS, hr );
    check( 0, callbackData->dwCounter1 );
 
    /* guid = appGuid */
    callbackData->dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroups( callbackData->pDP, (LPGUID) &appGuid,
                                  EnumGroups_cb, &callbackData, 0 );
    checkHR( DPERR_NOSESSIONS, hr );
    check( 0, callbackData->dwCounter1 );
 
    callbackData->dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroups( callbackData->pDP, (LPGUID) &appGuid,
                                  EnumGroups_cb, &callbackData,
                                  DPENUMGROUPS_SESSION );
    checkHR( DPERR_NOSESSIONS, hr );
    check( 0, callbackData->dwCounter1 );
 
    /* guid = guidInstance */
    callbackData->dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroups( callbackData->pDP,
                                  (LPGUID) &lpThisSD->guidInstance,
                                  EnumGroups_cb, &callbackData, 0 );
    checkHR( DPERR_NOSESSIONS, hr );
    check( 0, callbackData->dwCounter1 );
 
    callbackData->dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroups( callbackData->pDP,
                                  (LPGUID) &lpThisSD->guidInstance,
                                  EnumGroups_cb, &callbackData,
                                  DPENUMGROUPS_SESSION );
    checkHR( DPERR_GENERIC, hr ); /* Why? */
    check( 0, callbackData->dwCounter1 );
 
    return TRUE;
 
}

Referenced by test_EnumGroups(), and test_EnumGroupsInGroup().

◆ EnumSessions_cb_EnumPlayers()

static BOOL CALLBACK EnumSessions_cb_EnumPlayers	(	LPCDPSESSIONDESC2	lpThisSD,
		LPDWORD	lpdwTimeOut,
		DWORD	dwFlags,
		LPVOID	lpContext
	)

static

Definition at line 6848 of file dplayx.c.

{
    lpCallbackData callbackData = lpContext;
    HRESULT hr;
 
    if (dwFlags & DPESC_TIMEDOUT)
    {
        return FALSE;
    }
 
    /* guid = NULL */
    callbackData->dwCounter1 = 0;
    hr = IDirectPlayX_EnumPlayers( callbackData->pDP, NULL, EnumPlayers_cb,
                                   &callbackData, 0 );
    checkHR( DPERR_NOSESSIONS, hr );
    check( 0, callbackData->dwCounter1 );
 
    /* guid = appGuid */
    callbackData->dwCounter1 = 0;
    hr = IDirectPlayX_EnumPlayers( callbackData->pDP, (LPGUID) &appGuid,
                                   EnumPlayers_cb, &callbackData, 0 );
    checkHR( DPERR_NOSESSIONS, hr );
    check( 0, callbackData->dwCounter1 );
 
    callbackData->dwCounter1 = 0;
    hr = IDirectPlayX_EnumPlayers( callbackData->pDP, (LPGUID) &appGuid,
                                   EnumPlayers_cb, &callbackData,
                                   DPENUMPLAYERS_SESSION );
    checkHR( DPERR_NOSESSIONS, hr );
    check( 0, callbackData->dwCounter1 );
 
    /* guid = guidInstance */
    callbackData->dwCounter1 = 0;
    hr = IDirectPlayX_EnumPlayers( callbackData->pDP,
                                   (LPGUID) &lpThisSD->guidInstance,
                                   EnumPlayers_cb, &callbackData, 0 );
    checkHR( DPERR_NOSESSIONS, hr );
    check( 0, callbackData->dwCounter1 );
 
    callbackData->dwCounter1 = 0;
    hr = IDirectPlayX_EnumPlayers( callbackData->pDP,
                                   (LPGUID) &lpThisSD->guidInstance,
                                   EnumPlayers_cb, &callbackData,
                                   DPENUMPLAYERS_SESSION );
    checkHR( DPERR_GENERIC, hr ); /* Why? */
    check( 0, callbackData->dwCounter1 );
 
    return TRUE;
 
}

Referenced by test_EnumPlayers().

◆ EnumSessions_cb_join()

static BOOL CALLBACK EnumSessions_cb_join	(	LPCDPSESSIONDESC2	lpThisSD,
		LPDWORD	lpdwTimeOut,
		DWORD	dwFlags,
		LPVOID	lpContext
	)

static

Definition at line 2340 of file dplayx.c.

{
    IDirectPlay4 *pDP = lpContext;
    DPSESSIONDESC2 dpsd;
    HRESULT hr;
 
    if (dwFlags & DPESC_TIMEDOUT)
    {
        return FALSE;
    }
 
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    dpsd.guidInstance = lpThisSD->guidInstance;
 
    hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
    checkHR( DP_OK, hr );
 
    return TRUE;
}

Referenced by test_EnumGroups(), test_EnumGroupsInGroup(), test_EnumPlayers(), test_GetMessageCount(), test_GetPlayerAccount(), test_GetPlayerAddress(), test_GetPlayerCaps(), test_GetPlayerFlags(), test_GroupOwner(), test_groups_cs(), test_groups_p2p(), test_host_migration(), test_interactive_CreatePlayer(), test_interactive_GetMessageQueue(), test_interactive_Send(), test_PlayerName(), test_remote_data_replication(), and test_SessionDesc().

◆ EnumSessions_cb_join_secure()

static BOOL CALLBACK EnumSessions_cb_join_secure	(	LPCDPSESSIONDESC2	lpThisSD,
		LPDWORD	lpdwTimeOut,
		DWORD	dwFlags,
		LPVOID	lpContext
	)

static

Definition at line 5961 of file dplayx.c.

{
    IDirectPlay4 *pDP = lpContext;
    DPSESSIONDESC2 dpsd;
    DPCREDENTIALS dpCredentials;
    HRESULT hr;
 
    if (dwFlags & DPESC_TIMEDOUT)
    {
        return FALSE;
    }
 
    checkFlags( DPSESSION_SECURESERVER, lpThisSD->dwFlags, FLAGS_DPSESSION );
 
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    dpsd.guidInstance = lpThisSD->guidInstance;
 
    ZeroMemory( &dpCredentials, sizeof(DPCREDENTIALS) );
    dpCredentials.dwSize = sizeof(DPCREDENTIALS);
    dpCredentials.lpszUsernameA = (LPSTR) "user";
    dpCredentials.lpszPasswordA = (LPSTR) "pass";
    hr = IDirectPlayX_SecureOpen( pDP, &dpsd, DPOPEN_JOIN,
                                  NULL, &dpCredentials );
    checkHR( DPERR_LOGONDENIED, hr ); /* TODO: Make this work */
 
    return TRUE;
}

Referenced by test_GetPlayerAccount().

◆ enumSessionsAsync()

static HANDLE enumSessionsAsync	(	IDirectPlay4 *	dp,
		DPSESSIONDESC2 *	dpsd,
		DWORD	timeout,
		LPDPENUMSESSIONSCALLBACK2	callback,
		void *	context,
		DWORD	flags
	)

static

Definition at line 704 of file dplayx.c.

{
    EnumSessionsParam *param;
 
    param = calloc( 1, sizeof( EnumSessionsParam ) );
 
    param->dp = dp;
    param->dpsd = dpsd;
    param->timeout = timeout;
    param->callback = callback;
    param->context = context;
    param->flags = flags;
 
    param->thread = CreateThread( NULL, 0, enumSessionsProc, param, 0, NULL );
 
    return param;
}

Referenced by check_EnumSessions_(), check_EnumSessions_async_(), joinSession_(), and test_Open().

◆ enumSessionsAsyncWait()

static HRESULT enumSessionsAsyncWait	(	EnumSessionsParam *	param,
		DWORD	timeout
	)

static

Definition at line 723 of file dplayx.c.

{
    HRESULT hr = 0xdeadbeef;
    DWORD waitResult;
 
    waitResult = WaitForSingleObject( param->thread, timeout );
    CloseHandle( param->thread );
    if ( waitResult == WAIT_OBJECT_0 )
    {
        hr = param->hr;
        free( param );
    }
 
    return hr;
}

Referenced by check_EnumSessions_(), check_EnumSessions_async_(), joinSession_(), and test_Open().

◆ enumSessionsProc()

static DWORD CALLBACK enumSessionsProc ( void * p )

static

Definition at line 694 of file dplayx.c.

{
    EnumSessionsParam *param = p;
 
    param->hr = IDirectPlayX_EnumSessions( param->dp, param->dpsd, param->timeout, param->callback,
                                           param->context, param->flags );
 
    return 0;
}

Referenced by enumSessionsAsync().

◆ get_temp_buffer()

static LPSTR get_temp_buffer ( void )

static

Definition at line 114 of file dplayx.c.

{
    static UINT index = 0;
    static char buff[10][256];
 
    index = (index + 1) % 10;
    *buff[index] = 0;
 
    return buff[index];
}

Referenced by dpResult2str(), and dwFlags2str().

◆ getPlayerIdsCallback()

static BOOL CALLBACK getPlayerIdsCallback	(	DPID	dpid,
		DWORD	playerType,
		const DPNAME *	name,
		DWORD	flags,
		void *	context
	)

static

Definition at line 4830 of file dplayx.c.

{
    GetPlayerIdsCallbackData *data = context;
 
    if ( data->idCount >= ARRAYSIZE( data->ids ) )
        return FALSE;
 
    data->ids[ data->idCount ] = dpid;
    ++data->idCount;
 
    return TRUE;
}

Referenced by checkCreatePlayerOrGroupMessages_().

◆ Guid2str()

static LPCSTR Guid2str ( const GUID * guid )

static

Definition at line 126 of file dplayx.c.

{
    if (!guid) return "(null)";
 
    /* Service providers */
    if (IsEqualGUID(guid, &DPSPGUID_IPX))
        return "DPSPGUID_IPX";
    if (IsEqualGUID(guid, &DPSPGUID_TCPIP))
        return "DPSPGUID_TCPIP";
    if (IsEqualGUID(guid, &DPSPGUID_SERIAL))
        return "DPSPGUID_SERIAL";
    if (IsEqualGUID(guid, &DPSPGUID_MODEM))
        return "DPSPGUID_MODEM";
    /* DirectPlay Address IDs */
    if (IsEqualGUID(guid, &DPAID_TotalSize))
        return "DPAID_TotalSize";
    if (IsEqualGUID(guid, &DPAID_ServiceProvider))
        return "DPAID_ServiceProvider";
    if (IsEqualGUID(guid, &DPAID_LobbyProvider))
        return "DPAID_LobbyProvider";
    if (IsEqualGUID(guid, &DPAID_Phone))
        return "DPAID_Phone";
    if (IsEqualGUID(guid, &DPAID_PhoneW))
        return "DPAID_PhoneW";
    if (IsEqualGUID(guid, &DPAID_Modem))
        return "DPAID_Modem";
    if (IsEqualGUID(guid, &DPAID_ModemW))
        return "DPAID_ModemW";
    if (IsEqualGUID(guid, &DPAID_INet))
        return "DPAID_INet";
    if (IsEqualGUID(guid, &DPAID_INetW))
        return "DPAID_INetW";
    if (IsEqualGUID(guid, &DPAID_INetPort))
        return "DPAID_INetPort";
    if (IsEqualGUID(guid, &DPAID_ComPort))
        return "DPAID_ComPort";
 
    return wine_dbgstr_guid(guid);
}

◆ HRESULT()

static HRESULT ( WINAPI * pDirectPlayEnumerateA )

static

◆ init_TCPIP_provider()

static void init_TCPIP_provider	(	IDirectPlay4 *	pDP,
		LPCSTR	strIPAddressString,
		WORD	port
	)

static

Definition at line 2288 of file dplayx.c.

{
 
    DPCOMPOUNDADDRESSELEMENT addressElements[3];
    LPVOID pAddress = NULL;
    DWORD dwAddressSize = 0;
    IDirectPlayLobby3 *pDPL;
    HRESULT hr;
 
    hr = CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL,
                           &IID_IDirectPlayLobby3A, (LPVOID*) &pDPL );
    ok (SUCCEEDED (hr), "CCI of CLSID_DirectPlayLobby / IID_IDirectPlayLobby3A failed\n");
    if (FAILED (hr)) return;
 
    /* Service provider */
    addressElements[0].guidDataType = DPAID_ServiceProvider;
    addressElements[0].dwDataSize   = sizeof(GUID);
    addressElements[0].lpData       = (LPVOID) &DPSPGUID_TCPIP;
 
    /* IP address string */
    addressElements[1].guidDataType = DPAID_INet;
    addressElements[1].dwDataSize   = lstrlenA(strIPAddressString) + 1;
    addressElements[1].lpData       = (LPVOID) strIPAddressString;
 
    /* Optional Port number */
    if( port > 0 )
    {
        addressElements[2].guidDataType = DPAID_INetPort;
        addressElements[2].dwDataSize   = sizeof(WORD);
        addressElements[2].lpData       = &port;
    }
 
 
    hr = IDirectPlayLobby_CreateCompoundAddress( pDPL, addressElements, 2,
                                                 NULL, &dwAddressSize );
    checkHR( DPERR_BUFFERTOOSMALL, hr );
 
    if( hr == DPERR_BUFFERTOOSMALL )
    {
        pAddress = calloc( 1, dwAddressSize );
        hr = IDirectPlayLobby_CreateCompoundAddress( pDPL, addressElements, 2,
                                                     pAddress, &dwAddressSize );
        checkHR( DP_OK, hr );
    }
 
    hr = IDirectPlayX_InitializeConnection( pDP, pAddress, 0 );
    checkHR( DP_OK, hr );
 
    free( pAddress );
    IDirectPlayLobby_Release(pDPL);
}

Referenced by create_session(), test_ADDFORWARD(), test_AddPlayerToGroup(), test_CreateGroup(), test_CreatePlayer(), test_CREATEPLAYER(), test_EnumGroups(), test_EnumGroupsInGroup(), test_EnumPlayers(), test_EnumSessions(), test_GetCaps(), test_GetMessageCount(), test_GetMessageQueue(), test_GetPlayerAccount(), test_GetPlayerAddress(), test_GetPlayerCaps(), test_GetPlayerFlags(), test_GROUPDATACHANGED(), test_GroupOwner(), test_groups_cs(), test_groups_p2p(), test_host_migration(), test_interactive_CreatePlayer(), test_interactive_EnumSessions(), test_interactive_GetMessageQueue(), test_interactive_Open(), test_interactive_Receive(), test_interactive_Send(), test_Open(), test_PING(), test_PlayerData(), test_PlayerName(), test_Receive(), test_remote_data_replication(), test_Send(), and test_SessionDesc().

◆ is_firewall_enabled()

static BOOL is_firewall_enabled ( void )

static

Definition at line 10574 of file dplayx.c.

{
    HRESULT hr, init;
    INetFwMgr *mgr = NULL;
    INetFwPolicy *policy = NULL;
    INetFwProfile *profile = NULL;
    VARIANT_BOOL enabled = VARIANT_FALSE;
 
    init = CoInitializeEx( 0, COINIT_APARTMENTTHREADED );
 
    hr = CoCreateInstance( &CLSID_NetFwMgr, NULL, CLSCTX_INPROC_SERVER, &IID_INetFwMgr,
                           (void **)&mgr );
    ok( hr == S_OK, "got %08lx\n", hr );
    if (hr != S_OK) goto done;
 
    hr = INetFwMgr_get_LocalPolicy( mgr, &policy );
    ok( hr == S_OK, "got %08lx\n", hr );
    if (hr != S_OK) goto done;
 
    hr = INetFwPolicy_get_CurrentProfile( policy, &profile );
    if (hr != S_OK) goto done;
 
    hr = INetFwProfile_get_FirewallEnabled( profile, &enabled );
    ok( hr == S_OK, "got %08lx\n", hr );
 
done:
    if (policy) INetFwPolicy_Release( policy );
    if (profile) INetFwProfile_Release( profile );
    if (mgr) INetFwMgr_Release( mgr );
    if (SUCCEEDED( init )) CoUninitialize();
    return (enabled == VARIANT_TRUE);
}

Referenced by START_TEST().

◆ is_process_elevated()

static BOOL is_process_elevated ( void )

static

Definition at line 10558 of file dplayx.c.

{
    HANDLE token;
    if (OpenProcessToken( GetCurrentProcess(), TOKEN_QUERY, &token ))
    {
        TOKEN_ELEVATION_TYPE type;
        DWORD size;
        BOOL ret;
 
        ret = GetTokenInformation( token, TokenElevationType, &type, sizeof(type), &size );
        CloseHandle( token );
        return (ret && type == TokenElevationTypeFull);
    }
    return FALSE;
}

Referenced by START_TEST(), test_appsearch_complocator(), test_command_line_parsing(), test_concurrentinstall(), test_create_remove_folder(), test_create_remove_shortcut(), test_delete_services(), test_duplicate_files(), test_envvar(), test_find_related_products(), test_ini_values(), test_install_remove_odbc(), test_install_services(), test_Installer_InstallProduct(), test_move_files(), test_MsiConfigureProductEx(), test_MsiEnumComponents(), test_MsiEnumComponentsEx(), test_MsiEnumProducts(), test_MsiGetFeatureInfo(), test_MsiProvideComponent(), test_MsiProvideQualifiedComponentEx(), test_MsiSetFeatureAttributes(), test_MsiSourceListAddMediaDisk(), test_MsiSourceListAddSource(), test_MsiSourceListAddSourceEx(), test_MsiSourceListSetInfo(), test_patch_registration(), test_process_components(), test_publish(), test_publish_assemblies(), test_publish_components(), test_publish_features(), test_publish_product(), test_publish_sourcelist(), test_register_class_info(), test_register_extension_info(), test_register_font(), test_register_mime_info(), test_register_product(), test_register_progid_info(), test_register_typelib(), test_register_user(), test_remove_duplicate_files(), test_remove_existing_products(), test_remove_files(), test_self_registration(), test_setpropertyfolder(), test_simple_patch(), test_sourcedir_props(), test_states(), test_system_tables(), test_validate_product_id(), and test_write_registry_values().

◆ is_stub_dll()

static BOOL is_stub_dll ( const char * filename )

static

Definition at line 10707 of file dplayx.c.

{
    UINT size;
    DWORD ver;
    BOOL isstub = FALSE;
    char *p, *data;
 
    size = GetFileVersionInfoSizeA(filename, &ver);
    if (!size) return FALSE;
 
    data = malloc(size);
    if (!data) return FALSE;
 
    if (GetFileVersionInfoA(filename, ver, size, data))
    {
        char buf[256];
 
        sprintf(buf, "\\StringFileInfo\\%04x%04x\\OriginalFilename", MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), 1200);
        if (VerQueryValueA(data, buf, (void**)&p, &size))
            isstub = !lstrcmpiA("wcodstub.dll", p);
    }
    free(data);
 
    return isstub;
}

Referenced by START_TEST().

◆ joinSession_()

static void joinSession_	(	int	line,
		IDirectPlay4 *	dp,
		DPSESSIONDESC2 *	dpsd,
		DPSESSIONDESC2 *	serverDpsd,
		SOCKET *	sendSock,
		SOCKET *	recvSock,
		unsigned short *	udpPort
	)

static

Definition at line 3572 of file dplayx.c.

{
    EnumSessionsParam *enumSessionsParam;
    OpenParam *openParam;
    unsigned short port;
    SOCKET listenSock;
    SOCKET enumSock;
    int tryIndex;
    HRESULT hr;
 
    enumSock = bindUdp_( line, 47624 );
 
    listenSock = listenTcp_( line, 2349 );
 
    for ( tryIndex = 0; ; ++tryIndex )
    {
        int count = 0;
 
        enumSessionsParam = enumSessionsAsync( dp, dpsd, 100, countSessionsCallback, &count, 0 );
 
        port = receiveEnumSessionsRequest_( line, enumSock, &appGuid, NULL, 0 );
 
        *sendSock = connectTcp_( line, port );
 
        sendEnumSessionsReply_( line, *sendSock, 2349, serverDpsd );
 
        hr = enumSessionsAsyncWait( enumSessionsParam, 2000 );
        ok_( __FILE__, line )( hr == DP_OK, "EnumSessions() returned %#lx.\n", hr );
 
        if ( tryIndex < 19 && count < 1 )
            continue;
 
        ok( count == 1, "got session count %d.\n", count );
 
        break;
    }
 
    openParam = openAsync( dp, dpsd, DPOPEN_JOIN );
 
    *recvSock = acceptTcp_( line, listenSock );
    ok_( __FILE__, line )( *recvSock != INVALID_SOCKET, "accept() returned %#Ix.\n", *recvSock );
 
    receiveRequestPlayerId_( line, *recvSock, 0x9 );
    sendRequestPlayerReply_( line, *sendSock, 2349, 0x12345678, DP_OK );
    receiveAddForwardRequest_( line, *recvSock, 0x12345678, L"", serverDpsd->dwReserved1, udpPort );
    sendSuperEnumPlayersReply_( line, *sendSock, 2349, 2399, serverDpsd, L"normal" );
    checkNoMoreMessages_( line, *recvSock );
 
    checkNoMoreAccepts_( line, listenSock );
 
    hr = openAsyncWait( openParam, 2000 );
    ok_( __FILE__, line )( hr == DP_OK, "Open() returned %#lx.\n", hr );
 
    closesocket( listenSock );
    closesocket( enumSock );
}

◆ listenTcp_()

static SOCKET listenTcp_	(	int	line,
		unsigned short	port
	)

static

Definition at line 1047 of file dplayx.c.

{
    u_long nbio = 1;
    SOCKADDR_IN addr;
    int wsResult;
    SOCKET sock;
 
    sock = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );
    ok_( __FILE__, line)( sock != INVALID_SOCKET, "got TCP listen socket %#Ix.\n", sock );
 
    memset( &addr, 0, sizeof( addr ) );
    addr.sin_family = AF_INET;
    addr.sin_port = htons( port );
    addr.sin_addr.s_addr = INADDR_ANY;
 
    wsResult = bind( sock, (SOCKADDR *) &addr, sizeof( addr ) );
    ok_( __FILE__, line )( wsResult != SOCKET_ERROR, "bind() returned %d.\n", wsResult );
 
    wsResult = listen( sock, SOMAXCONN );
    ok_( __FILE__, line )( wsResult != SOCKET_ERROR, "listen() returned %d.\n", wsResult );
 
    wsResult = ioctlsocket( sock, FIONBIO, &nbio );
    ok_( __FILE__, line)( wsResult != SOCKET_ERROR, "ioctlsocket() returned %d.\n", wsResult );
 
    return sock;
}

Referenced by check_Open_(), and joinSession_().

◆ openAsync()

static OpenParam * openAsync	(	IDirectPlay4 *	dp,
		DPSESSIONDESC2 *	dpsd,
		DWORD	flags
	)

static

Definition at line 759 of file dplayx.c.

{
    OpenParam *param;
 
    param = calloc( 1, sizeof( OpenParam ) );
 
    param->dp = dp;
    param->dpsd = dpsd;
    param->flags = flags;
 
    param->thread = CreateThread( NULL, 0, openProc, param, 0, NULL );
 
    return param;
}

Referenced by check_Open_(), and joinSession_().

◆ openAsyncWait()

static HRESULT openAsyncWait	(	OpenParam *	param,
		DWORD	timeout
	)

static

Definition at line 774 of file dplayx.c.

{
    HRESULT hr = 0xdeadbeef;
    DWORD waitResult;
 
    waitResult = WaitForSingleObject( param->thread, timeout );
    CloseHandle( param->thread );
    if ( waitResult == WAIT_OBJECT_0 )
    {
        hr = param->hr;
        free( param );
    }
 
    return hr;
}

Referenced by check_Open_(), and joinSession_().

◆ openProc()

static DWORD CALLBACK openProc ( void * p )

static

Definition at line 750 of file dplayx.c.

{
    OpenParam *param = p;
 
    param->hr = IDirectPlayX_Open( param->dp, param->dpsd, param->flags );
 
    return 0;
}

Referenced by openAsync().

◆ receiveAddForwardAck_()

static unsigned short receiveAddForwardAck_	(	int	line,
		SOCKET	sock,
		DPID	expectedPlayerId
	)

static

Definition at line 1812 of file dplayx.c.

{
#include "pshpack1.h"
    struct
    {
        SpHeader spHeader;
        AddForwardAck request;
    } request;
#include "poppack.h"
    unsigned short port;
    int wsResult;
 
    wsResult = receiveMessage_( line, sock, &request, sizeof( request ) );
    ok_( __FILE__, line )( wsResult == sizeof( request ), "recv() returned %d.\n", wsResult );
 
    port = checkSpHeader_( line, &request.spHeader, sizeof( request ) );
    checkMessageHeader_( line, &request.request.header, 47 );
 
    return port;
}

◆ receiveAddForwardRequest_()

static unsigned short receiveAddForwardRequest_	(	int	line,
		SOCKET	sock,
		DPID	expectedPlayerId,
		const WCHAR *	expectedPassword,
		DWORD	expectedTickCount,
		unsigned short *	udpPort
	)

static

Definition at line 1421 of file dplayx.c.

{
#include "pshpack1.h"
    struct
    {
        SpHeader spHeader;
        AddForwardRequest request;
    } request;
#include "poppack.h"
    DWORD expectedPasswordSize;
    WCHAR password[ 256 ];
    unsigned short port;
    DWORD expectedSize;
    DWORD tickCount;
    int wsResult;
 
    expectedPasswordSize = (lstrlenW( expectedPassword ) + 1) * sizeof( WCHAR );
    expectedSize = sizeof( request ) + expectedPasswordSize + sizeof( DWORD );
 
    wsResult = receiveMessage_( line, sock, &request, sizeof( request ) );
    ok_( __FILE__, line )( wsResult == sizeof( request ), "recv() returned %d.\n", wsResult );
    if ( wsResult == SOCKET_ERROR )
        return 0;
 
    port = checkSpHeader_( line, &request.spHeader, expectedSize );
    checkMessageHeader_( line, &request.request.header, 19 );
    ok_( __FILE__, line )( !request.request.toId, "got destination id %#lx.\n", request.request.toId );
    ok_( __FILE__, line )( request.request.playerId == expectedPlayerId, "got player id %#lx.\n",
                           request.request.playerId );
    ok_( __FILE__, line )( !request.request.groupId, "got group id %#lx.\n", request.request.groupId );
    ok_( __FILE__, line )( request.request.createOffset == 28, "got create offset %lu.\n",
                           request.request.createOffset );
    ok_( __FILE__, line )( request.request.passwordOffset == 108, "got password offset %lu.\n",
                           request.request.passwordOffset );
    checkPackedPlayer_( line, &request.request.playerInfo, 0x9, expectedPlayerId, 0, 0, 0, expectedPlayerId );
    checkSpData_( line, &request.request.spData, udpPort );
 
    wsResult = receiveMessage_( line, sock, password, expectedPasswordSize );
 
    ok_( __FILE__, line )( wsResult == expectedPasswordSize, "recv() returned %d.\n", wsResult );
    ok_( __FILE__, line )( !lstrcmpW( password, expectedPassword ), "got password %s.\n", wine_dbgstr_w( password ) );
 
    wsResult = receiveMessage_( line, sock, &tickCount, sizeof( DWORD ) );
 
    ok_( __FILE__, line )( wsResult == sizeof( DWORD ), "recv() returned %d.\n", wsResult );
    ok_( __FILE__, line )( tickCount == expectedTickCount, "got tick count %#lx.\n", tickCount );
 
    return port;
}

Referenced by check_Open_(), and joinSession_().

◆ receiveAddPlayerToGroup_()

static unsigned short receiveAddPlayerToGroup_	(	int	line,
		SOCKET	sock,
		DPID	expectedPlayerId,
		DPID	expectedGroupId
	)

static

Definition at line 2213 of file dplayx.c.

{
#include "pshpack1.h"
    struct
    {
        SpHeader spHeader;
        AddPlayerToGroup request;
    } request;
#include "poppack.h"
    unsigned short port;
    int wsResult;
 
    wsResult = receiveMessage_( line, sock, &request, sizeof( request ) );
    ok_( __FILE__, line )( wsResult == sizeof( request ), "recv() returned %d.\n", wsResult );
 
    port = checkSpHeader_( line, &request.spHeader, sizeof( request ) );
    checkMessageHeader_( line, &request.request.header, 13 );
 
    ok_( __FILE__, line )( !request.request.toId, "got destination id %#lx.\n", request.request.toId );
    ok_( __FILE__, line )( request.request.playerId == expectedPlayerId, "got player id %#lx.\n",
                           request.request.playerId );
    ok_( __FILE__, line )( request.request.groupId == expectedGroupId, "got group id %#lx.\n",
                           request.request.groupId );
    ok_( __FILE__, line )( !request.request.createOffset, "got create offset %lu.\n", request.request.createOffset );
    ok_( __FILE__, line )( !request.request.passwordOffset, "got password offset %lu.\n", request.request.passwordOffset );
 
    return port;
}

◆ receiveCreatePlayer_()

static unsigned short receiveCreatePlayer_	(	int	line,
		SOCKET	sock,
		DPID	expectedPlayerId,
		DWORD	expectedFlags,
		const WCHAR *	expectedShortName,
		const WCHAR *	expectedLongName,
		void *	expectedPlayerData,
		DWORD	expectedPlayerDataSize
	)

static

Definition at line 1837 of file dplayx.c.

{
#include "pshpack1.h"
    struct
    {
        SpHeader spHeader;
        CreatePlayer request;
    } request;
#include "poppack.h"
    DWORD expectedShortNameSize;
    DWORD expectedLongNameSize;
    WCHAR shortName[ 256 ];
    BYTE playerData[ 256 ];
    WCHAR longName[ 256 ];
    unsigned short port;
    DWORD expectedSize;
    DWORD reserved2;
    WORD reserved1;
    SpData spData;
    int wsResult;
 
    expectedShortNameSize = expectedShortName ? (lstrlenW( expectedShortName ) + 1) * sizeof( WCHAR ) : 0;
    expectedLongNameSize = expectedLongName ? (lstrlenW( expectedLongName ) + 1) * sizeof( WCHAR ) : 0;
    expectedSize = sizeof( request ) + expectedShortNameSize + expectedLongNameSize + sizeof( spData )
                 + expectedPlayerDataSize + sizeof( reserved1 ) + sizeof( reserved2 );
 
    wsResult = receiveMessage_( line, sock, &request, sizeof( request ) );
    ok_( __FILE__, line )( wsResult == sizeof( request ), "recv() returned %d.\n", wsResult );
 
    port = checkSpHeader_( line, &request.spHeader, expectedSize );
    checkMessageHeader_( line, &request.request.header, 8 );
    ok_( __FILE__, line )( !request.request.toId, "got destination id %#lx.\n", request.request.toId );
    ok_( __FILE__, line )( request.request.playerId == expectedPlayerId, "got player id %#lx.\n",
                           request.request.playerId );
    ok_( __FILE__, line )( !request.request.groupId, "got group id %#lx.\n", request.request.groupId );
    ok_( __FILE__, line )( request.request.createOffset == 28, "got create offset %lu.\n",
                           request.request.createOffset );
    ok_( __FILE__, line )( !request.request.passwordOffset, "got password offset %lu.\n",
                           request.request.passwordOffset );
    checkPackedPlayer_( line, &request.request.playerInfo, expectedFlags, expectedPlayerId, expectedShortNameSize,
                        expectedLongNameSize, expectedPlayerDataSize, 0x12345678 );
 
    if ( expectedShortName )
    {
        wsResult = receiveMessage_( line, sock, shortName, expectedShortNameSize );
 
        ok_( __FILE__, line )( wsResult == expectedShortNameSize, "recv() returned %d.\n", wsResult );
        ok_( __FILE__, line )( !lstrcmpW( shortName, expectedShortName ), "got short name %s.\n",
                               wine_dbgstr_w( shortName ) );
    }
 
    if ( expectedLongName )
    {
        wsResult = receiveMessage_( line, sock, longName, expectedLongNameSize );
 
        ok_( __FILE__, line )( wsResult == expectedLongNameSize, "recv() returned %d.\n", wsResult );
        ok_( __FILE__, line )( !lstrcmpW( longName, expectedLongName ), "got long name %s.\n",
                               wine_dbgstr_w( longName ) );
    }
 
    wsResult = receiveMessage_( line, sock, &spData, sizeof( spData ) );
    ok_( __FILE__, line )( wsResult == sizeof( spData ), "recv() returned %d.\n", wsResult );
    checkSpData_( line, &spData, NULL );
 
    if ( expectedPlayerDataSize )
    {
        wsResult = receiveMessage_( line, sock, playerData, expectedPlayerDataSize );
 
        ok_( __FILE__, line )( wsResult == expectedPlayerDataSize, "recv() returned %d.\n", wsResult );
        ok_( __FILE__, line )( !memcmp( playerData, expectedPlayerData, expectedPlayerDataSize ),
                               "player data didn't match.\n" );
    }
 
    wsResult = receiveMessage_( line, sock, &reserved1, sizeof( reserved1 ) );
 
    ok_( __FILE__, line )( wsResult == sizeof( reserved1 ), "recv() returned %d.\n", wsResult );
    ok_( __FILE__, line )( !reserved1, "got reserved1 %d.\n", reserved1 );
 
    wsResult = receiveMessage_( line, sock, &reserved2, sizeof( reserved2 ) );
 
    ok_( __FILE__, line )( wsResult == sizeof( reserved2 ), "recv() returned %d.\n", wsResult );
    ok_( __FILE__, line )( !reserved2, "got reserved2 %lu.\n", reserved2 );
 
    return port;
}

Referenced by check_CreatePlayer_(), and createPlayer_().

◆ receiveEnumSessionsRequest_()

static unsigned short receiveEnumSessionsRequest_	(	int	line,
		SOCKET	sock,
		const GUID *	expectedAppGuid,
		const WCHAR *	expectedPassword,
		DWORD	expectedFlags
	)

static

Definition at line 1264 of file dplayx.c.

{
#include "pshpack1.h"
    struct
    {
        SpHeader spHeader;
        EnumSessionsRequest request;
        WCHAR password[ 256 ];
    } request;
#include "poppack.h"
    DWORD expectedPasswordSize;
    unsigned short port;
    DWORD expectedSize;
    int wsResult;
 
    expectedPasswordSize = expectedPassword ? (lstrlenW( expectedPassword ) + 1) * sizeof( WCHAR ) : 0;
    expectedSize = sizeof( request.spHeader ) + sizeof( request.request ) + expectedPasswordSize;
 
    wsResult = receiveMessage_( line, sock, &request, sizeof( request ) );
    ok_( __FILE__, line )( wsResult == expectedSize, "recv() returned %d.\n", wsResult );
    if ( wsResult == SOCKET_ERROR )
        return 0;
 
    port = checkSpHeader_( line, &request.spHeader, expectedSize );
    checkMessageHeader_( line, &request.request.header, 2 );
    ok_( __FILE__, line )( IsEqualGUID( &request.request.appGuid, expectedAppGuid ), "got app guid %s.\n",
                           wine_dbgstr_guid( &request.request.appGuid ) );
    if ( expectedPassword )
    {
        ok_( __FILE__, line )( request.request.passwordOffset == 32, "got password offset %lu.\n",
                               request.request.passwordOffset );
        ok_( __FILE__, line )( !lstrcmpW( request.password, expectedPassword ), "got password %s.\n",
                               wine_dbgstr_w( request.password ) );
    }
    else
    {
        ok_( __FILE__, line )( !request.request.passwordOffset, "got password offset %lu.\n",
                               request.request.passwordOffset );
    }
    ok_( __FILE__, line )( request.request.flags == expectedFlags, "got flags %#lx.\n", request.request.flags );
 
    return port;
}

Referenced by check_EnumSessions_(), check_EnumSessions_async_(), and joinSession_().

◆ receiveGameMessage_()

static void receiveGameMessage_	(	int	line,
		SOCKET	sock,
		DPID	expectedFromId,
		DPID	expectedToId,
		void *	expectedData,
		DWORD	expectedDataSize
	)

static

Definition at line 2059 of file dplayx.c.

{
#include "pshpack1.h"
    struct
    {
        GameMessage request;
        BYTE data[ 256 ];
    } request;
#include "poppack.h"
    int wsResult;
 
    DWORD expectedSize = sizeof( request.request ) + expectedDataSize;
 
    wsResult = receiveMessage_( line, sock, &request, expectedSize );
    ok_( __FILE__, line )( wsResult == expectedSize, "recv() returned %d.\n", wsResult );
 
    checkGameMessage_( line, &request.request, expectedFromId, expectedToId );
    ok_( __FILE__, line )( !memcmp( &request.data, expectedData, expectedDataSize ), "message data didn't match.\n" );
}

◆ receiveGuaranteedGameMessage_()

static unsigned short receiveGuaranteedGameMessage_	(	int	line,
		SOCKET	sock,
		DPID	expectedFromId,
		DPID	expectedToId,
		void *	expectedData,
		DWORD	expectedDataSize
	)

static

Definition at line 2031 of file dplayx.c.

{
#include "pshpack1.h"
    struct
    {
        SpHeader spHeader;
        GameMessage request;
        BYTE data[ 256 ];
    } request;
#include "poppack.h"
    unsigned short port;
    int wsResult;
 
    DWORD expectedSize = sizeof( request.spHeader ) + sizeof( request.request ) + expectedDataSize;
 
    wsResult = receiveMessage_( line, sock, &request, expectedSize );
    ok_( __FILE__, line )( wsResult == expectedSize, "recv() returned %d.\n", wsResult );
 
    port = checkSpHeader_( line, &request.spHeader, expectedSize );
    checkGameMessage_( line, &request.request, expectedFromId, expectedToId );
    ok_( __FILE__, line )( !memcmp( &request.data, expectedData, expectedDataSize ), "message data didn't match.\n" );
 
    return port;
}

◆ receiveMessage_()

static int receiveMessage_	(	int	line,
		SOCKET	sock,
		void *	buffer,
		int	size
	)

static

Definition at line 1151 of file dplayx.c.

{
    struct timeval timeout;
    int recvResult;
    int wsResult;
    fd_set fds;
 
    FD_ZERO( &fds );
    FD_SET( sock, &fds );
    timeout.tv_sec = 2;
    timeout.tv_usec = 0;
    wsResult = select( sock + 1, &fds, NULL, &fds, &timeout );
    ok_( __FILE__, line )( wsResult != SOCKET_ERROR, "select() returned %d.\n", wsResult );
 
    memset( buffer, 0xcc, size );
    recvResult = recv( sock, buffer, size, 0 );
 
    return recvResult;
}

Referenced by receiveAddForwardAck_(), receiveAddForwardRequest_(), receiveAddPlayerToGroup_(), receiveCreatePlayer_(), receiveEnumSessionsRequest_(), receiveGameMessage_(), receiveGuaranteedGameMessage_(), receivePingReply_(), and receiveRequestPlayerId_().

◆ receivePingReply_()

static unsigned short receivePingReply_	(	int	line,
		SOCKET	sock,
		DPID	expectedFromId,
		DWORD	expectedTickCount
	)

static

Definition at line 2187 of file dplayx.c.

{
#include "pshpack1.h"
    struct
    {
        SpHeader spHeader;
        Ping request;
    } request;
#include "poppack.h"
    unsigned short port;
    int wsResult;
 
    wsResult = receiveMessage_( line, sock, &request, sizeof( request ) );
    ok_( __FILE__, line )( wsResult == sizeof( request ), "recv() returned %d.\n", wsResult );
 
    port = checkSpHeader_( line, &request.spHeader, sizeof( request ) );
    checkMessageHeader_( line, &request.request.header, 23 );
    ok_( __FILE__, line )( request.request.fromId == expectedFromId, "got source id %#lx.\n", request.request.fromId );
    ok_( __FILE__, line )( request.request.tickCount == expectedTickCount, "got tick count %#lx.\n",
                           request.request.tickCount );
 
    return port;
}

◆ receiveRequestPlayerId_()

static unsigned short receiveRequestPlayerId_	(	int	line,
		SOCKET	sock,
		DWORD	expectedFlags
	)

static

Definition at line 1359 of file dplayx.c.

{
#include "pshpack1.h"
    struct
    {
        SpHeader spHeader;
        RequestPlayerId request;
    } request;
#include "poppack.h"
    unsigned short port;
    int wsResult;
 
    wsResult = receiveMessage_( line, sock, &request, sizeof( request ) );
    ok_( __FILE__, line )( wsResult == sizeof( request ), "recv() returned %d.\n", wsResult );
 
    port = checkSpHeader_( line, &request.spHeader, sizeof( request ) );
    checkMessageHeader_( line, &request.request.header, 5 );
    ok_( __FILE__, line )( request.request.flags == expectedFlags, "got flags %#lx.\n", request.request.flags );
 
    return port;
}

Referenced by check_CreatePlayer_(), check_Open_(), createPlayer_(), and joinSession_().

◆ sendAddForward_()

static void sendAddForward_	(	int	line,
		SOCKET	sock,
		unsigned short	port,
		unsigned short	tcpPort,
		unsigned short	udpPort
	)

static

Definition at line 1743 of file dplayx.c.

{
#include "pshpack1.h"
    struct
    {
        SpHeader spHeader;
        AddForward reply;
    } reply =
    {
        .spHeader =
        {
            .mixed = 0xfab00000 + sizeof( reply ),
            .addr =
            {
                .sin_family = AF_INET,
                .sin_port = htons( port ),
            },
        },
        .reply =
        {
            .header =
            {
                .magic = 0x79616c70,
                .command = 46,
                .version = 14,
            },
            .toId = 0,
            .playerId = 0x07734,
            .groupId = 0,
            .createOffset = 28,
            .passwordOffset = 0,
            .playerInfo =
            {
                .size = 48 + sizeof( SpData ),
                .flags = 0x5,
                .id = 0x07734,
                .shortNameLength = 0,
                .longNameLength = 0,
                .spDataSize = sizeof( SpData ),
                .playerDataSize = 0,
                .playerCount = 0,
                .systemPlayerId = 0x07734,
                .fixedSize = 48,
                .playerVersion = 14,
                .parentId = 0,
            },
            .spData = {
                .tcpAddr =
                {
                    .sin_family = AF_INET,
                    .sin_port = htons( tcpPort ),
                },
                .udpAddr =
                {
                    .sin_family = AF_INET,
                    .sin_port = htons( udpPort ),
                },
            },
        },
    };
#include "poppack.h"
 
    int wsResult;
 
    wsResult = send( sock, (char *) &reply, sizeof( reply ), 0 );
    ok_( __FILE__, line )( wsResult == sizeof( reply ), "send() returned %d.\n", wsResult );
}

◆ sendAddForwardReply_()

static void sendAddForwardReply_	(	int	line,
		SOCKET	sock,
		unsigned short	port,
		HRESULT	result
	)

static

Definition at line 1706 of file dplayx.c.

{
#include "pshpack1.h"
    struct
    {
        SpHeader spHeader;
        AddForwardReply reply;
    } reply =
    {
        .spHeader =
        {
            .mixed = 0xfab00000 + sizeof( reply ),
            .addr =
            {
                .sin_family = AF_INET,
                .sin_port = htons( port ),
            },
        },
        .reply =
        {
            .header =
            {
                .magic = 0x79616c70,
                .command = 36,
                .version = 14,
            },
            .result = result,
        },
    };
#include "poppack.h"
    int wsResult;
 
    wsResult = send( sock, (char *) &reply, sizeof( reply ), 0 );
    ok_( __FILE__, line )( wsResult == sizeof( reply ), "send() returned %d.\n", wsResult );
}

Referenced by check_Open_().

◆ sendCreatePlayer_()

static void sendCreatePlayer_	(	int	line,
		SOCKET	sock,
		unsigned short	tcpPort,
		unsigned short	udpPort,
		const WCHAR *	shortName,
		const WCHAR *	longName,
		void *	playerData,
		DWORD	playerDataSize
	)

static

Definition at line 1927 of file dplayx.c.

{
#include "pshpack1.h"
    struct
    {
        SpHeader spHeader;
        CreatePlayer request;
    } request =
    {
        .spHeader =
        {
            .mixed = 0xfab00000,
            .addr =
            {
                .sin_family = AF_INET,
                .sin_port = htons( tcpPort ),
            },
        },
        .request =
        {
            .header =
            {
                .magic = 0x79616c70,
                .command = 8,
                .version = 14,
            },
            .toId = 0,
            .playerId = 0x07734,
            .groupId = 0,
            .createOffset = 28,
            .passwordOffset = 0,
            .playerInfo =
            {
                .size = sizeof( request.request.playerInfo ) + sizeof( SpData ),
                .flags = 0x8,
                .id = 0x07734,
                .shortNameLength = 0,
                .longNameLength = 0,
                .spDataSize = sizeof( SpData ),
                .playerDataSize = 0,
                .playerCount = 0,
                .systemPlayerId = 0x51573,
                .fixedSize = 48,
                .playerVersion = 14,
                .parentId = 0,
            },
        },
    };
#include "poppack.h"
    SpData spData = {
        .tcpAddr.sin_family = AF_INET,
        .tcpAddr.sin_port = htons( tcpPort ),
        .udpAddr.sin_family = AF_INET,
        .udpAddr.sin_port = htons( udpPort ),
    };
    char reserved[ 6 ] = { 0 };
    DWORD shortNameSize = 0;
    DWORD longNameSize = 0;
    int wsResult;
 
    if ( shortName )
        shortNameSize = (wcslen( shortName ) + 1) * sizeof( WCHAR );
 
    if ( longName )
        longNameSize = (wcslen( longName ) + 1) * sizeof( WCHAR );
 
    request.spHeader.mixed += sizeof( request ) + shortNameSize + longNameSize + sizeof( spData )
                            + playerDataSize + sizeof( reserved );
    request.request.playerInfo.size += shortNameSize + longNameSize + playerDataSize;
    request.request.playerInfo.shortNameLength = shortNameSize;
    request.request.playerInfo.longNameLength = longNameSize;
    request.request.playerInfo.playerDataSize = playerDataSize;
 
    wsResult = send( sock, (char *) &request, sizeof( request ), 0 );
    ok_( __FILE__, line )( wsResult == sizeof( request ), "send() returned %d.\n", wsResult );
 
    if ( shortName )
    {
        wsResult = send( sock, (char *) shortName, shortNameSize, 0 );
        ok_( __FILE__, line )( wsResult == shortNameSize, "send() returned %d.\n", wsResult );
    }
 
    if ( longName )
    {
        wsResult = send( sock, (char *) longName, longNameSize, 0 );
        ok_( __FILE__, line )( wsResult == longNameSize, "send() returned %d.\n", wsResult );
    }
 
    wsResult = send( sock, (char *) &spData, sizeof( spData ), 0 );
    ok_( __FILE__, line )( wsResult == sizeof( spData ), "send() returned %d.\n", wsResult );
 
    if ( playerData )
    {
        wsResult = send( sock, playerData, playerDataSize, 0 );
        ok_( __FILE__, line )( wsResult == playerDataSize, "send() returned %d.\n", wsResult );
    }
 
    wsResult = send( sock, reserved, sizeof( reserved ), 0 );
    ok_( __FILE__, line )( wsResult == sizeof( reserved ), "send() returned %d.\n", wsResult );
}

◆ sendEnumSessionsReply_()

static void sendEnumSessionsReply_	(	int	line,
		SOCKET	sock,
		unsigned short	port,
		const DPSESSIONDESC2 *	dpsd
	)

static

Definition at line 1310 of file dplayx.c.

{
#include "pshpack1.h"
    struct
    {
        SpHeader spHeader;
        EnumSessionsReply reply;
        WCHAR name[ 256 ];
    } reply =
    {
        .spHeader =
        {
            .mixed = 0xfab00000,
            .addr =
            {
                .sin_family = AF_INET,
                .sin_port = htons( port ),
            },
        },
        .reply =
        {
            .header =
            {
                .magic = 0x79616c70,
                .command = 1,
                .version = 14,
            },
            .dpsd = *dpsd,
            .nameOffset = sizeof( reply.reply ),
        },
    };
#include "poppack.h"
    DWORD passwordSize;
    int wsResult;
    DWORD size;
 
    passwordSize = (lstrlenW( dpsd->lpszSessionName ) + 1) * sizeof( WCHAR );
    size = sizeof( reply.spHeader ) + sizeof( reply.reply ) + passwordSize;
 
    reply.spHeader.mixed += size;
    reply.reply.dpsd.lpszSessionName = NULL;
    reply.reply.dpsd.lpszPassword = NULL;
    memcpy( reply.name, dpsd->lpszSessionName, passwordSize );
 
    wsResult = send( sock, (char *) &reply, size, 0 );
    ok_( __FILE__, line )( wsResult == size, "send() returned %d.\n", wsResult );
}

Referenced by check_EnumSessions_(), check_EnumSessions_async_(), and joinSession_().

◆ sendGameMessage_()

static void sendGameMessage_	(	int	line,
		SOCKET	sock,
		DPID	fromId,
		DPID	toId,
		void *	data,
		DWORD	dataSize
	)

static

Definition at line 2119 of file dplayx.c.

{
#include "pshpack1.h"
    struct
    {
        GameMessage request;
        BYTE data[ 256 ];
    } request =
    {
        .request =
        {
            .fromId = fromId,
            .toId = toId,
        }
    };
#include "poppack.h"
    int wsResult;
    DWORD size;
 
    size = sizeof( request.request ) + dataSize;
 
    memcpy( request.data, data, dataSize );
 
    wsResult = send( sock, (char *) &request, size, 0 );
    ok_( __FILE__, line )( wsResult == size, "send() returned %d.\n", wsResult );
}

◆ sendGroupDataChanged_()

static void sendGroupDataChanged_	(	int	line,
		SOCKET	sock,
		unsigned short	port,
		DPID	groupId,
		void *	data,
		DWORD	dataSize
	)

static

Definition at line 2244 of file dplayx.c.

{
#include "pshpack1.h"
    struct
    {
        SpHeader spHeader;
        GroupDataChanged request;
        BYTE data[ 256 ];
    } request =
    {
        .spHeader =
        {
            .mixed = 0xfab00000 + sizeof( request ),
            .addr =
            {
                .sin_family = AF_INET,
                .sin_port = htons( port ),
            },
        },
        .request =
        {
            .header =
            {
                .magic = 0x79616c70,
                .command = 17,
                .version = 14,
            },
            .toId = 0,
            .groupId = groupId,
            .dataSize = dataSize,
            .dataOffset = sizeof( request.request ),
        },
    };
#include "poppack.h"
    int wsResult;
    int size;
 
    size = sizeof( request ) + dataSize;
    memcpy( &request.data, data, dataSize );
 
    wsResult = send( sock, (char *) &request, size, 0 );
    ok_( __FILE__, line )( wsResult == size, "send() returned %d.\n", wsResult );
}

◆ sendGuaranteedGameMessage_()

static void sendGuaranteedGameMessage_	(	int	line,
		SOCKET	sock,
		unsigned short	port,
		DPID	fromId,
		DPID	toId,
		void *	data,
		DWORD	dataSize
	)

static

Definition at line 2082 of file dplayx.c.

{
#include "pshpack1.h"
    struct
    {
        SpHeader spHeader;
        GameMessage request;
    } request =
    {
        .spHeader =
        {
            .mixed = 0xfab00000 + sizeof( request ) + dataSize,
            .addr =
            {
                .sin_family = AF_INET,
                .sin_port = htons( port ),
            },
        },
        .request =
        {
            .fromId = fromId,
            .toId = toId,
        }
    };
#include "poppack.h"
    int wsResult;
 
    wsResult = send( sock, (char *) &request, sizeof( request ), 0 );
    ok_( __FILE__, line )( wsResult == sizeof( request ), "send() returned %d.\n", wsResult );
 
    wsResult = send( sock, data, dataSize, 0 );
    ok_( __FILE__, line )( wsResult == dataSize, "send() returned %d.\n", wsResult );
}

◆ sendPing_()

static void sendPing_	(	int	line,
		SOCKET	sock,
		unsigned short	port,
		DPID	fromId,
		DWORD	tickCount
	)

static

Definition at line 2148 of file dplayx.c.

{
#include "pshpack1.h"
    struct
    {
        SpHeader spHeader;
        Ping request;
    } request =
    {
        .spHeader =
        {
            .mixed = 0xfab00000 + sizeof( request ),
            .addr =
            {
                .sin_family = AF_INET,
                .sin_port = htons( port ),
            },
        },
        .request =
        {
            .header =
            {
                .magic = 0x79616c70,
                .command = 22,
                .version = 14,
            },
            .fromId = fromId,
            .tickCount = tickCount,
        }
    };
#include "poppack.h"
    int wsResult;
 
    wsResult = send( sock, (char *) &request, sizeof( request ), 0 );
    ok_( __FILE__, line )( wsResult == sizeof( request ), "send() returned %d.\n", wsResult );
}

◆ sendRequestPlayerReply_()

static void sendRequestPlayerReply_	(	int	line,
		SOCKET	sock,
		unsigned short	port,
		DPID	id,
		HRESULT	result
	)

static

Definition at line 1382 of file dplayx.c.

{
#include "pshpack1.h"
    struct
    {
        SpHeader spHeader;
        RequestPlayerReply reply;
    } reply =
    {
        .spHeader =
        {
            .mixed = 0xfab00000 + sizeof( reply ),
            .addr =
            {
                .sin_family = AF_INET,
                .sin_port = htons( port ),
            },
        },
        .reply =
        {
            .header =
            {
                .magic = 0x79616c70,
                .command = 7,
                .version = 14,
            },
            .id = id,
            .result = result,
        },
    };
#include "poppack.h"
    int wsResult;
 
    wsResult = send( sock, (char *) &reply, sizeof( reply ), 0 );
    ok_( __FILE__, line )( wsResult == sizeof( reply ), "send() returned %d.\n", wsResult );
}

Referenced by check_CreatePlayer_(), check_Open_(), createPlayer_(), and joinSession_().

◆ sendSuperEnumPlayersReply_()

static void sendSuperEnumPlayersReply_	(	int	line,
		SOCKET	sock,
		unsigned short	tcpPort,
		unsigned short	udpPort,
		const DPSESSIONDESC2 *	dpsd,
		const WCHAR *	sessionName
	)

static

Definition at line 1475 of file dplayx.c.

{
#define SHORT_NAME L"short name"
#define LONG_NAME L"long name"
#include "pshpack1.h"
    struct
    {
        SpHeader spHeader;
        SuperEnumPlayersReply reply;
        DPSESSIONDESC2 dpsd;
        WCHAR sessionName[ 256 ];
        struct
        {
            SuperPackedPlayer superPackedPlayer;
            BYTE spDataLength;
            SpData spData;
        } player0;
        struct
        {
            SuperPackedPlayer superPackedPlayer;
            BYTE spDataLength;
            SpData spData;
        } player1;
        struct
        {
            SuperPackedPlayer superPackedPlayer;
            WCHAR shortName[ ARRAYSIZE( SHORT_NAME ) ];
            WCHAR longName[ ARRAYSIZE( LONG_NAME ) ];
            BYTE playerDataLength;
            BYTE playerData[ 4 ];
            BYTE spDataLength;
            SpData spData;
        } player2;
        struct
        {
            SuperPackedPlayer superPackedPlayer;
            BYTE spDataLength;
            SpData spData;
        } player3;
        struct
        {
            SuperPackedPlayer superPackedPlayer;
            WCHAR shortName[ ARRAYSIZE( SHORT_NAME ) ];
            WCHAR longName[ ARRAYSIZE( LONG_NAME ) ];
            BYTE playerDataLength;
            BYTE playerData[ 4 ];
            BYTE spDataLength;
            SpData spData;
            BYTE playerCount;
            DPID playerIds[ 1 ];
        } group0;
    } reply =
    {
        .spHeader =
        {
            .mixed = 0xfab00000 + sizeof( reply ),
            .addr =
            {
                .sin_family = AF_INET,
                .sin_port = htons( tcpPort ),
            },
        },
        .reply =
        {
            .header =
            {
                .magic = 0x79616c70,
                .command = 41,
                .version = 14,
            },
            .playerCount = 4,
            .groupCount = 1,
            .packedOffset = sizeof( reply.reply ) + sizeof( reply.dpsd ) + sizeof( reply.sessionName ),
            .shortcutCount = 0,
            .descriptionOffset = sizeof( reply.reply ),
            .nameOffset = sizeof( reply.reply ) + sizeof( reply.dpsd ),
            .passwordOffset = 0,
        },
        .dpsd = *dpsd,
        .player0 =
        {
            .superPackedPlayer =
            {
                .size = 16,
                .flags = 0x5,
                .id = 0x12345678,
                .infoMask = 0x4,
                .versionOrSystemPlayerId = 14,
            },
            .spDataLength = sizeof( SpData ),
            .spData =
            {
                .tcpAddr =
                {
                    .sin_family = AF_INET,
                    .sin_port = htons( tcpPort ),
                },
                .udpAddr =
                {
                    .sin_family = AF_INET,
                    .sin_port = htons( udpPort ),
                },
            },
        },
        .player1 =
        {
            .superPackedPlayer =
            {
                .size = 16,
                .flags = 0xf,
                .id = 0x51573,
                .infoMask = 0x4,
                .versionOrSystemPlayerId = 14,
            },
            .spDataLength = sizeof( SpData ),
            .spData =
            {
                .tcpAddr =
                {
                    .sin_family = AF_INET,
                    .sin_port = htons( tcpPort ),
                },
                .udpAddr =
                {
                    .sin_family = AF_INET,
                    .sin_port = htons( udpPort ),
                },
            },
        },
        .player2 =
        {
            .superPackedPlayer =
            {
                .size = 16,
                .flags = 0x8,
                .id = 0x1337,
                .infoMask = 0x17,
                .versionOrSystemPlayerId = 0x51573,
            },
            .shortName = SHORT_NAME,
            .longName = LONG_NAME,
            .playerDataLength = 4,
            .playerData = { 1, 2, 3, 4, },
            .spDataLength = sizeof( SpData ),
            .spData =
            {
                .tcpAddr =
                {
                    .sin_family = AF_INET,
                    .sin_port = htons( tcpPort ),
                },
                .udpAddr =
                {
                    .sin_family = AF_INET,
                    .sin_port = htons( udpPort ),
                },
            },
        },
        .player3 =
        {
            .superPackedPlayer =
            {
                .size = 16,
                .flags = 0x8,
                .id = 0xd00de,
                .infoMask = 0x4,
                .versionOrSystemPlayerId = 0x51573,
            },
            .spDataLength = sizeof( SpData ),
            .spData =
            {
                .tcpAddr =
                {
                    .sin_family = AF_INET,
                    .sin_port = htons( tcpPort ),
                },
                .udpAddr =
                {
                    .sin_family = AF_INET,
                    .sin_port = htons( udpPort ),
                },
            },
        },
        .group0 =
        {
            .superPackedPlayer =
            {
                .size = 16,
                .flags = 0x48,
                .id = 0x5e7,
                .infoMask = 0x57,
                .versionOrSystemPlayerId = 0x51573,
            },
            .shortName = SHORT_NAME,
            .longName = LONG_NAME,
            .playerDataLength = 4,
            .playerData = { 1, 2, 3, 4, },
            .spDataLength = sizeof( SpData ),
            .spData =
            {
                .tcpAddr =
                {
                    .sin_family = AF_INET,
                    .sin_port = htons( tcpPort ),
                },
                .udpAddr =
                {
                    .sin_family = AF_INET,
                    .sin_port = htons( udpPort ),
                },
            },
            .playerCount = 1,
            .playerIds = { 0xd00de, },
        },
    };
#include "poppack.h"
#undef LONG_NAME
#undef SHORT_NAME
    int wsResult;
 
    reply.dpsd.lpszSessionName = NULL;
    reply.dpsd.lpszPassword = NULL;
 
    lstrcpyW( reply.sessionName, sessionName );
 
    wsResult = send( sock, (char *) &reply, sizeof( reply ), 0 );
    ok_( __FILE__, line )( wsResult == sizeof( reply ), "send() returned %d.\n", wsResult );
}

Referenced by check_Open_(), and joinSession_().

◆ set_firewall()

static HRESULT set_firewall ( enum firewall_op op )

static

Definition at line 10607 of file dplayx.c.

{
    HRESULT hr, init;
    INetFwMgr *mgr = NULL;
    INetFwPolicy *policy = NULL;
    INetFwProfile *profile = NULL;
    INetFwAuthorizedApplication *app = NULL;
    INetFwAuthorizedApplications *apps = NULL;
    BSTR name, image = SysAllocStringLen( NULL, MAX_PATH );
    WCHAR path[MAX_PATH];
 
    if (!GetModuleFileNameW( NULL, image, MAX_PATH ))
    {
        SysFreeString( image );
        return E_FAIL;
    }
 
    if(!GetSystemDirectoryW(path, MAX_PATH))
    {
        SysFreeString( image );
        return E_FAIL;
    }
    lstrcatW( path, L"\\dplaysvr.exe" );
 
    init = CoInitializeEx( 0, COINIT_APARTMENTTHREADED );
 
    hr = CoCreateInstance( &CLSID_NetFwMgr, NULL, CLSCTX_INPROC_SERVER, &IID_INetFwMgr,
                           (void **)&mgr );
    ok( hr == S_OK, "got %08lx\n", hr );
    if (hr != S_OK) goto done;
 
    hr = INetFwMgr_get_LocalPolicy( mgr, &policy );
    ok( hr == S_OK, "got %08lx\n", hr );
    if (hr != S_OK) goto done;
 
    hr = INetFwPolicy_get_CurrentProfile( policy, &profile );
    if (hr != S_OK) goto done;
 
    hr = INetFwProfile_get_AuthorizedApplications( profile, &apps );
    ok( hr == S_OK, "got %08lx\n", hr );
    if (hr != S_OK) goto done;
 
    hr = CoCreateInstance( &CLSID_NetFwAuthorizedApplication, NULL, CLSCTX_INPROC_SERVER,
                           &IID_INetFwAuthorizedApplication, (void **)&app );
    ok( hr == S_OK, "got %08lx\n", hr );
    if (hr != S_OK) goto done;
 
    hr = INetFwAuthorizedApplication_put_ProcessImageFileName( app, image );
    if (hr != S_OK) goto done;
 
    name = SysAllocString( L"dplay_client" );
    hr = INetFwAuthorizedApplication_put_Name( app, name );
    SysFreeString( name );
    ok( hr == S_OK, "got %08lx\n", hr );
    if (hr != S_OK) goto done;
 
    if (op == APP_ADD)
        hr = INetFwAuthorizedApplications_Add( apps, app );
    else if (op == APP_REMOVE)
        hr = INetFwAuthorizedApplications_Remove( apps, image );
    else
        hr = E_INVALIDARG;
    if (hr != S_OK) goto done;
 
    INetFwAuthorizedApplication_Release( app );
    hr = CoCreateInstance( &CLSID_NetFwAuthorizedApplication, NULL, CLSCTX_INPROC_SERVER,
                           &IID_INetFwAuthorizedApplication, (void **)&app );
    ok( hr == S_OK, "got %08lx\n", hr );
    if (hr != S_OK) goto done;
 
    SysFreeString( image );
    image = SysAllocString( path );
    hr = INetFwAuthorizedApplication_put_ProcessImageFileName( app, image );
    if (hr != S_OK) goto done;
 
    name = SysAllocString( L"dplay_server" );
    hr = INetFwAuthorizedApplication_put_Name( app, name );
    SysFreeString( name );
    ok( hr == S_OK, "got %08lx\n", hr );
    if (hr != S_OK) goto done;
 
    if (op == APP_ADD)
        hr = INetFwAuthorizedApplications_Add( apps, app );
    else if (op == APP_REMOVE)
        hr = INetFwAuthorizedApplications_Remove( apps, image );
    else
        hr = E_INVALIDARG;
 
done:
    if (app) INetFwAuthorizedApplication_Release( app );
    if (apps) INetFwAuthorizedApplications_Release( apps );
    if (policy) INetFwPolicy_Release( policy );
    if (profile) INetFwProfile_Release( profile );
    if (mgr) INetFwMgr_Release( mgr );
    if (SUCCEEDED( init )) CoUninitialize();
    SysFreeString( image );
    return hr;
}

Referenced by START_TEST().

◆ START_TEST()

START_TEST ( dplayx )

Definition at line 10733 of file dplayx.c.

{
    BOOL firewall_enabled;
    HRESULT hr;
    char path[MAX_PATH];
    HMODULE module;
 
    if(!GetSystemDirectoryA(path, MAX_PATH))
    {
        skip("Failed to get systems directory\n");
        return;
    }
    strcat(path, "\\dplayx.dll");
 
    if (!winetest_interactive && (GetFileAttributesA(path) == INVALID_FILE_ATTRIBUTES || is_stub_dll(path)))
    {
        win_skip("dplayx is missing or a stub dll, skipping tests\n");
        return;
    }
 
    if ((firewall_enabled = is_firewall_enabled()) && !is_process_elevated())
    {
        skip("no privileges, skipping tests to avoid firewall dialog\n");
        return;
    }
 
    if (firewall_enabled)
    {
        hr = set_firewall(APP_ADD);
        if (hr != S_OK)
        {
            skip("can't authorize app in firewall %08lx\n", hr);
            return;
        }
    }
 
    CoInitialize( NULL );
 
    module = LoadLibraryA("dplayx.dll");
 
    pDirectPlayEnumerateA = (void *)GetProcAddress(module, "DirectPlayEnumerateA");
    pDirectPlayEnumerateW = (void *)GetProcAddress(module, "DirectPlayEnumerateW");
    pDirectPlayCreate = (void *)GetProcAddress(module, "DirectPlayCreate");
 
    test_COM();
    test_COM_dplobby();
    test_EnumerateProviders();
    test_DirectPlayCreate();
    test_EnumConnections();
    test_InitializeConnection();
    test_GetCaps();
    test_EnumAddressTypes();
    test_EnumAddresses();
    test_EnumSessions();
    test_Open();
    test_ADDFORWARD();
    test_CreatePlayer();
    test_CREATEPLAYER();
    test_Send();
    test_Receive();
    test_PING();
    test_AddPlayerToGroup();
    test_GROUPDATACHANGED();
    test_GetMessageQueue();
 
    if (!winetest_interactive)
    {
        skip("Run in interactive mode to run all dplayx tests.\n");
        goto done;
    }
 
    trace("Running in interactive mode, tests will take a while\n");
 
    /* test_interactive_Open() takes almost a minute, */
    test_interactive_Open();
    /* test_interactive_EnumSessions takes three minutes */
    test_interactive_EnumSessions();
    test_SessionDesc();
 
    /* test_interactive_CreatePlayer() takes over a minute */
    test_interactive_CreatePlayer();
    test_GetPlayerCaps();
    test_PlayerData();
    test_PlayerName();
 
    /* test_GetPlayerAccount() takes over 30s */
    test_GetPlayerAccount();
    test_GetPlayerAddress();
    test_GetPlayerFlags();
 
    test_CreateGroup();
    test_GroupOwner();
 
    test_EnumPlayers();
    test_EnumGroups();
    test_EnumGroupsInGroup();
 
    test_groups_p2p();
    test_groups_cs();
 
    test_interactive_Send();
    test_interactive_Receive();
    test_GetMessageCount();
    test_interactive_GetMessageQueue();
 
    test_remote_data_replication();
    test_host_migration();
 
done:
    FreeLibrary(module);
    CoUninitialize();
    if (firewall_enabled) set_firewall(APP_REMOVE);
}

◆ strcmpAW()

static int strcmpAW	(	const void *	str0,
		const void *	str1,
		BOOL	ansi
	)

static

Definition at line 85 of file dplayx.c.

{
    return ansi ? strcmp( str0, str1 ) : lstrcmpW( str0, str1 );
}

Referenced by checkSessionListCallback().

◆ test_ADDFORWARD()

static void test_ADDFORWARD ( void )

static

Definition at line 3630 of file dplayx.c.

{
    DPSESSIONDESC2 appGuidDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidInstance = appGuid,
        .guidApplication = appGuid,
    };
    DPSESSIONDESC2 serverDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidApplication = appGuid,
        .guidInstance = appGuid,
        .lpszSessionName = (WCHAR *) L"normal",
        .dwReserved1 = 0xaabbccdd,
    };
    IDirectPlay4A *dp;
    SOCKET sendSock;
    SOCKET recvSock;
    HRESULT hr;
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlay4A, (void **) &dp );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
 
    init_TCPIP_provider( dp, "127.0.0.1", 0 );
 
    joinSession( dp, &appGuidDpsd, &serverDpsd, &sendSock, &recvSock, NULL );
 
    sendAddForward( sendSock, 2349, 2348, 2398 );
    receiveAddForwardAck( recvSock, 0x07734 );
    checkNoMoreMessages( recvSock );
 
    closesocket( recvSock );
    closesocket( sendSock );
 
    IDirectPlayX_Release( dp );
}

Referenced by START_TEST().

◆ test_AddPlayerToGroup()

static void test_AddPlayerToGroup ( void )

static

Definition at line 9167 of file dplayx.c.

{
    DPSESSIONDESC2 appGuidDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidApplication = appGuid,
        .guidInstance = appGuid,
    };
    DPSESSIONDESC2 serverDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidApplication = appGuid,
        .guidInstance = appGuid,
        .lpszSessionName = (WCHAR *) L"normal",
        .dwReserved1 = 0xaabbccdd,
    };
    IDirectPlay4 *dp;
    SOCKET sendSock;
    SOCKET recvSock;
    HRESULT hr;
    DPID dpid;
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlay4A, (void **) &dp );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
 
    hr = IDirectPlayX_AddPlayerToGroup( dp, 0x5e7, 0x07734 );
    ok( hr == DPERR_UNINITIALIZED, "got hr %#lx.\n", hr );
 
    init_TCPIP_provider( dp, "127.0.0.1", 0 );
 
    joinSession( dp, &appGuidDpsd, &serverDpsd, &sendSock, &recvSock, NULL );
 
    hr = IDirectPlayX_AddPlayerToGroup( dp, 0x5e7, 0x07734 );
    ok( hr == DPERR_INVALIDPLAYER, "got hr %#lx.\n", hr );
 
    createPlayer( dp, 0x07734, NULL, NULL, 0, 0, sendSock, recvSock );
 
    hr = IDirectPlayX_AddPlayerToGroup( dp, 0x5e7, 0x07734 );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
 
    dpid = checkAddPlayerToGroupMessage( dp, 0x5e7, 0x07734 );
    ok( dpid == 0x07734, "got destination id %#lx.\n", dpid );
 
    receiveAddPlayerToGroup( recvSock, 0x07734, 0x5e7 );
 
    checkNoMorePlayerMessages( dp );
    checkNoMoreMessages( recvSock );
 
    closesocket( recvSock );
    closesocket( sendSock );
 
    IDirectPlayX_Release( dp );
}

Referenced by START_TEST().

◆ test_COM()

static void test_COM ( void )

static

Definition at line 10405 of file dplayx.c.

{
    IDirectPlay *dp;
    IDirectPlay2A *dp2A;
    IDirectPlay2 *dp2;
    IDirectPlay3A *dp3A;
    IDirectPlay3 *dp3;
    IDirectPlay4A *dp4A;
#ifdef __REACTOS__ /* MSVC C4312: widen the sentinel so the cast is not narrowing on Win64 */
    IDirectPlay4 *dp4 = (IDirectPlay4*)(ULONG_PTR)0xdeadbeefdeadbeefull;
#else
    IDirectPlay4 *dp4 = (IDirectPlay4*)0xdeadbeef;
#endif
    IUnknown *unk;
    ULONG refcount;
    HRESULT hr;
 
    /* COM aggregation */
#ifdef __REACTOS__
    hr = CoCreateInstance(&CLSID_DirectPlay, (IUnknown*)(ULONG_PTR)0xdeadbeefdeadbeefull, CLSCTX_INPROC_SERVER,
            &IID_IUnknown, (void**)&dp4);
#else
    hr = CoCreateInstance(&CLSID_DirectPlay, (IUnknown*)0xdeadbeef, CLSCTX_INPROC_SERVER,
            &IID_IUnknown, (void**)&dp4);
#endif
    ok(hr == CLASS_E_NOAGGREGATION || broken(hr == E_INVALIDARG),
            "DirectPlay create failed: %08lx, expected CLASS_E_NOAGGREGATION\n", hr);
#ifdef __REACTOS__
    ok(!dp4 || dp4 == (IDirectPlay4*)(ULONG_PTR)0xdeadbeefdeadbeefull, "dp4 = %p\n", dp4);
#else
    ok(!dp4 || dp4 == (IDirectPlay4*)0xdeadbeef, "dp4 = %p\n", dp4);
#endif
 
    /* Invalid RIID */
    hr = CoCreateInstance(&CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlayLobby,
            (void**)&dp4);
    ok(hr == E_NOINTERFACE, "DirectPlay create failed: %08lx, expected E_NOINTERFACE\n", hr);
 
    /* Different refcount for all DirectPlay Interfaces */
    hr = CoCreateInstance(&CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlay4,
            (void**)&dp4);
    ok(hr == S_OK, "DirectPlay create failed: %08lx, expected S_OK\n", hr);
 
    hr = IDirectPlayX_QueryInterface(dp4, &IID_IDirectPlay2A, (void**)&dp2A);
    ok(hr == S_OK, "QueryInterface for IID_IDirectPlay2A failed: %08lx\n", hr);
    IDirectPlay2_Release(dp2A);
 
    hr = IDirectPlayX_QueryInterface(dp4, &IID_IDirectPlay2, (void**)&dp2);
    ok(hr == S_OK, "QueryInterface for IID_IDirectPlay2 failed: %08lx\n", hr);
    IDirectPlay2_Release(dp2);
 
    hr = IDirectPlayX_QueryInterface(dp4, &IID_IDirectPlay3A, (void**)&dp3A);
    ok(hr == S_OK, "QueryInterface for IID_IDirectPlay3A failed: %08lx\n", hr);
    IDirectPlay3_Release(dp3A);
 
    hr = IDirectPlayX_QueryInterface(dp4, &IID_IDirectPlay3, (void**)&dp3);
    ok(hr == S_OK, "QueryInterface for IID_IDirectPlay3 failed: %08lx\n", hr);
    IDirectPlay3_Release(dp3);
 
    hr = IDirectPlayX_QueryInterface(dp4, &IID_IDirectPlay4A, (void**)&dp4A);
    ok(hr == S_OK, "QueryInterface for IID_IDirectPlay4A failed: %08lx\n", hr);
    IDirectPlayX_Release(dp4A);
 
    /* IDirectPlay and IUnknown share a refcount */
    hr = IDirectPlayX_QueryInterface(dp4, &IID_IDirectPlay, (void**)&dp);
    ok(hr == S_OK, "QueryInterface for IID_IDirectPlay failed: %08lx\n", hr);
    IDirectPlay_Release(dp);
 
    hr = IDirectPlayX_QueryInterface(dp4, &IID_IUnknown, (void**)&unk);
    ok(hr == S_OK, "QueryInterface for IID_IUnknown failed: %08lx\n", hr);
 
    IUnknown_Release(unk);
    refcount = IDirectPlayX_Release(dp4);
    ok(refcount == 0, "refcount == %lu, expected 0\n", refcount);
}

Referenced by START_TEST().

◆ test_COM_dplobby()

static void test_COM_dplobby ( void )

static

Definition at line 10481 of file dplayx.c.

{
#ifdef __REACTOS__ /* MSVC C4312: widen the sentinel so the cast is not narrowing on Win64 */
    IDirectPlayLobby *dpl = (IDirectPlayLobby*)(ULONG_PTR)0xdeadbeefdeadbeefull;
#else
    IDirectPlayLobby *dpl = (IDirectPlayLobby*)0xdeadbeef;
#endif
    IDirectPlayLobbyA *dplA;
    IDirectPlayLobby2A *dpl2A;
    IDirectPlayLobby2 *dpl2;
    IDirectPlayLobby3A *dpl3A;
    IDirectPlayLobby3 *dpl3;
    IUnknown *unk;
    ULONG refcount;
    HRESULT hr;
 
    /* COM aggregation */
#ifdef __REACTOS__
    hr = CoCreateInstance(&CLSID_DirectPlayLobby, (IUnknown*)(ULONG_PTR)0xdeadbeefdeadbeefull, CLSCTX_INPROC_SERVER,
            &IID_IUnknown, (void**)&dpl);
#else
    hr = CoCreateInstance(&CLSID_DirectPlayLobby, (IUnknown*)0xdeadbeef, CLSCTX_INPROC_SERVER,
            &IID_IUnknown, (void**)&dpl);
#endif
    ok(hr == CLASS_E_NOAGGREGATION || broken(hr == E_INVALIDARG),
            "DirectPlayLobby create failed: %08lx, expected CLASS_E_NOAGGREGATION\n", hr);
#ifdef __REACTOS__
    ok(!dpl || dpl == (IDirectPlayLobby*)(ULONG_PTR)0xdeadbeefdeadbeefull, "dpl = %p\n", dpl);
#else
    ok(!dpl || dpl == (IDirectPlayLobby*)0xdeadbeef, "dpl = %p\n", dpl);
#endif
 
    /* Invalid RIID */
    hr = CoCreateInstance(&CLSID_DirectPlayLobby, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlay,
            (void**)&dpl);
    ok(hr == E_NOINTERFACE, "DirectPlayLobby create failed: %08lx, expected E_NOINTERFACE\n", hr);
 
    /* Different refcount for all DirectPlayLobby Interfaces */
    hr = CoCreateInstance(&CLSID_DirectPlayLobby, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlayLobby,
            (void**)&dpl);
    ok(hr == S_OK, "DirectPlayLobby create failed: %08lx, expected S_OK\n", hr);
 
    hr = IDirectPlayLobby_QueryInterface(dpl, &IID_IDirectPlayLobbyA, (void**)&dplA);
    ok(hr == S_OK, "QueryInterface for IID_IDirectPlayLobbyA failed: %08lx\n", hr);
    IDirectPlayLobby_Release(dplA);
 
    hr = IDirectPlayLobby_QueryInterface(dpl, &IID_IDirectPlayLobby2, (void**)&dpl2);
    ok(hr == S_OK, "QueryInterface for IID_IDirectPlayLobby2 failed: %08lx\n", hr);
    IDirectPlayLobby_Release(dpl2);
 
    hr = IDirectPlayLobby_QueryInterface(dpl, &IID_IDirectPlayLobby2A, (void**)&dpl2A);
    ok(hr == S_OK, "QueryInterface for IID_IDirectPlayLobby2A failed: %08lx\n", hr);
    IDirectPlayLobby_Release(dpl2A);
 
    hr = IDirectPlayLobby_QueryInterface(dpl, &IID_IDirectPlayLobby3, (void**)&dpl3);
    ok(hr == S_OK, "QueryInterface for IID_IDirectPlayLobby3 failed: %08lx\n", hr);
    IDirectPlayLobby_Release(dpl3);
 
    hr = IDirectPlayLobby_QueryInterface(dpl, &IID_IDirectPlayLobby3A, (void**)&dpl3A);
    ok(hr == S_OK, "QueryInterface for IID_IDirectPlayLobby3A failed: %08lx\n", hr);
    IDirectPlayLobby_Release(dpl3A);
 
    /* IDirectPlayLobby and IUnknown share a refcount */
    hr = IDirectPlayX_QueryInterface(dpl, &IID_IUnknown, (void**)&unk);
    ok(hr == S_OK, "QueryInterface for IID_IUnknown failed: %08lx\n", hr);
    IUnknown_Release(unk);
 
    refcount = IDirectPlayLobby_Release(dpl);
    ok(refcount == 0, "refcount == %lu, expected 0\n", refcount);
}

Referenced by START_TEST().

◆ test_CreateGroup()

static void test_CreateGroup ( void )

static

Definition at line 6426 of file dplayx.c.

{
 
    IDirectPlay4 *pDP;
    DPSESSIONDESC2 dpsd;
    DPID idFrom, idTo, dpid, idGroup, idGroupParent;
    DPNAME groupName;
    HRESULT hr;
    UINT i;
 
    LPCSTR lpData = "data";
    DWORD dwDataSize = strlen(lpData)+1;
    LPDPMSG_CREATEPLAYERORGROUP lpDataGet = calloc( 1, 1024 );
    DWORD dwDataSizeGet = 1024;
    CallbackData callbackData;
 
 
    hr= CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                          &IID_IDirectPlay4A, (LPVOID*) &pDP );
    ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
    if (FAILED(hr)) return;
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    dpsd.dwMaxPlayers = 10;
    ZeroMemory( &groupName, sizeof(DPNAME) );
 
 
    /* No service provider */
    hr = IDirectPlayX_CreateGroup( pDP, &idGroup, NULL, NULL, 0, 0 );
    checkHR( DPERR_UNINITIALIZED, hr );
 
    hr = IDirectPlayX_CreateGroupInGroup( pDP, 0, &idGroup, NULL, NULL, 0, 0 );
    checkHR( DPERR_UNINITIALIZED, hr );
 
 
 
    init_TCPIP_provider( pDP, "127.0.0.1", 0 );
 
 
    /* No session */
    hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
                                   NULL, NULL, 0, 0 );
    todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
 
    if ( hr == DPERR_UNINITIALIZED )
    {
        todo_wine win_skip( "CreateGroup not implemented\n" );
        return;
    }
 
    hr = IDirectPlayX_CreateGroupInGroup( pDP, 0, &idGroup,
                                          NULL, NULL, 0, 0 );
    checkHR( DPERR_INVALIDGROUP, hr );
 
    hr = IDirectPlayX_CreateGroupInGroup( pDP, 2, &idGroup,
                                          NULL, NULL, 0, 0 );
    checkHR( DPERR_INVALIDGROUP, hr );
 
 
    hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_CREATE );
    checkHR( DP_OK, hr );
    IDirectPlayX_CreatePlayer( pDP, &dpid,
                               NULL, NULL, NULL, 0, 0 );
 
 
 
    /* With name */
    hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
                                   NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup,
                                          NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
                                   &groupName, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup,
                                          &groupName, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
 
    groupName.dwSize = sizeof(DPNAME);
    groupName.lpszShortNameA = (LPSTR) lpData;
 
 
    hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
                                   &groupName, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup,
                                          &groupName, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
 
    /* Message checking */
    for (i=0; i<6; i++)
    {
        dwDataSizeGet = 1024;
        hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, lpDataGet,
                                   &dwDataSizeGet );
        checkHR( DP_OK, hr );
        if ( NULL == lpDataGet->dpnName.lpszShortNameA )
        {
            check( 48, dwDataSizeGet );
        }
        else
        {
            check( 48 + dwDataSize, dwDataSizeGet );
            checkStr( lpData, lpDataGet->dpnName.lpszShortNameA );
        }
        check( DPID_SYSMSG, idFrom );
        checkConv( DPSYS_CREATEPLAYERORGROUP, lpDataGet->dwType, dpMsgType2str );
        check( DPPLAYERTYPE_GROUP,            lpDataGet->dwPlayerType );
        checkFlags( DPGROUP_LOCAL,            lpDataGet->dwFlags, FLAGS_DPGROUP );
    }
    check_messages( pDP, &dpid, 1, &callbackData );
    checkStr( "", callbackData.szTrace1 );
 
 
    /* With data */
    hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
                                   NULL, (LPVOID) lpData, -1, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
                                   NULL, (LPVOID) lpData, 0, 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
                                   NULL, NULL, dwDataSize, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
                                   NULL, (LPVOID) lpData, dwDataSize, 0 );
    checkHR( DP_OK, hr );
 
 
    hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup,
                                          NULL, (LPVOID) lpData, -1, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup,
                                          NULL, (LPVOID) lpData, 0, 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup,
                                          NULL, NULL, dwDataSize, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroup, &idGroup,
                                          NULL, (LPVOID)lpData, dwDataSize, 0 );
    checkHR( DP_OK, hr );
 
 
    hr = IDirectPlayX_CreateGroup( pDP, &idGroupParent,
                                   NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
 
    /* Message checking */
    for (i=0; i<5; i++)
    {
        dwDataSizeGet = 1024;
        hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, lpDataGet,
                                   &dwDataSizeGet );
        checkHR( DP_OK, hr );
        check( 48 + lpDataGet->dwDataSize, dwDataSizeGet );
        check( DPID_SYSMSG, idFrom );
        checkConv( DPSYS_CREATEPLAYERORGROUP, lpDataGet->dwType, dpMsgType2str );
        check( DPPLAYERTYPE_GROUP,            lpDataGet->dwPlayerType );
        checkFlags( DPGROUP_LOCAL,            lpDataGet->dwFlags, FLAGS_DPGROUP );
    }
    check_messages( pDP, &dpid, 1, &callbackData );
    checkStr( "", callbackData.szTrace1 );
 
 
    /* Flags and idGroupParent */
    hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
                                   NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
                                   NULL, NULL, 0, DPGROUP_HIDDEN );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
                                   NULL, NULL, 0, DPGROUP_STAGINGAREA );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
                                   NULL, NULL, 0,
                                   DPGROUP_HIDDEN | DPGROUP_STAGINGAREA );
    checkHR( DP_OK, hr );
 
 
    hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroupParent, &idGroup,
                                          NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroupParent, &idGroup,
                                          NULL, NULL, 0, DPGROUP_HIDDEN );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroupParent, &idGroup,
                                          NULL, NULL, 0, DPGROUP_STAGINGAREA );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreateGroupInGroup( pDP, idGroupParent, &idGroup,
                                          NULL, NULL, 0,
                                          DPGROUP_HIDDEN |
                                          DPGROUP_STAGINGAREA );
    checkHR( DP_OK, hr );
 
 
    /* Message checking */
    for (i=0; i<8; i++)
    {
        dwDataSizeGet = 1024;
        hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, lpDataGet,
                                   &dwDataSizeGet );
        checkHR( DP_OK, hr );
        check( 48, dwDataSizeGet );
        check( DPID_SYSMSG, idFrom );
        checkConv( DPSYS_CREATEPLAYERORGROUP, lpDataGet->dwType, dpMsgType2str );
        check( DPPLAYERTYPE_GROUP,            lpDataGet->dwPlayerType );
 
        if ( lpDataGet->dpIdParent != 0 )
        {
            check( idGroupParent, lpDataGet->dpIdParent );
        }
 
        switch (i%4)
        {
        case 0:
            checkFlags( DPGROUP_LOCAL,
                        lpDataGet->dwFlags, FLAGS_DPGROUP );
            break;
        case 1:
            checkFlags( DPGROUP_LOCAL | DPGROUP_HIDDEN,
                        lpDataGet->dwFlags, FLAGS_DPGROUP );
            break;
        case 2:
            checkFlags( DPGROUP_STAGINGAREA | DPGROUP_LOCAL,
                        lpDataGet->dwFlags, FLAGS_DPGROUP );
            break;
        case 3:
            checkFlags( DPGROUP_STAGINGAREA | DPGROUP_LOCAL | DPGROUP_HIDDEN,
                        lpDataGet->dwFlags, FLAGS_DPGROUP );
            break;
        default: break;
        }
    }
    check_messages( pDP, &dpid, 1, &callbackData );
    checkStr( "", callbackData.szTrace1 );
 
 
    /* If a group is created in C/S mode, no messages are sent */
 
    /* - Peer 2 peer */
    IDirectPlayX_Close( pDP );
 
    dpsd.dwFlags = 0;
    hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_CREATE );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreatePlayer( pDP, &dpid, NULL, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreateGroup( pDP, &idGroup, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
    /* Messages are received */
    check_messages( pDP, &dpid, 1, &callbackData );
    checkStr( "S0,", callbackData.szTrace1 );
 
 
    /* - Client/Server */
    IDirectPlayX_Close( pDP );
 
    dpsd.dwFlags = DPSESSION_CLIENTSERVER;
    hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_CREATE );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreatePlayer( pDP, &dpid,
                                    NULL, NULL, NULL, 0,
                                    DPPLAYER_SERVERPLAYER );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreateGroup( pDP, &idGroup,
                                   NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
    /* No messages */
    check_messages( pDP, &dpid, 1, &callbackData );
    checkStr( "S0,", callbackData.szTrace1 ); /* Or at least there
                                                 shouldn't be messages... */
 
 
    free( lpDataGet );
    IDirectPlayX_Release( pDP );
 
}

Referenced by START_TEST().

◆ test_CreatePlayer()

static void test_CreatePlayer ( void )

static

Definition at line 4941 of file dplayx.c.

{
    DPSESSIONDESC2 appGuidDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidApplication = appGuid,
        .guidInstance = appGuid,
    };
    DPSESSIONDESC2 serverDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidApplication = appGuid,
        .guidInstance = appGuid,
        .lpszSessionName = (WCHAR *) L"normal",
        .dwReserved1 = 0xaabbccdd,
    };
    DPNAME fullName =
    {
        .dwSize = sizeof( DPNAME ),
        .lpszShortNameA = (char *) "short player name",
        .lpszLongNameA = (char *) "long player name",
    };
    DPNAME nullName =
    {
        .dwSize = sizeof( DPNAME ),
    };
    IDirectPlay4 *dp;
    SOCKET sendSock;
    SOCKET recvSock;
    DPNAME name;
    HRESULT hr;
    DPID dpid;
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlay4A, (void **) &dp );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
 
    /* Connection not initialized */
    dpid = 0xdeadbeef;
    check_CreatePlayer( dp, &dpid, NULL, 0, DPERR_UNINITIALIZED, 0xdeadbeef, INVALID_SOCKET, FALSE, 0, NULL, NULL,
                        NULL, NULL, 0 );
 
    init_TCPIP_provider( dp, "127.0.0.1", 0 );
 
    /* Session not open */
    dpid = 0xdeadbeef;
    check_CreatePlayer( dp, &dpid, NULL, 0, DPERR_INVALIDPARAMS, 0xdeadbeef, INVALID_SOCKET, FALSE, 0, NULL, NULL,
                        NULL, NULL, 0 );
 
    /* Join to normal session */
    joinSession( dp, &appGuidDpsd, &serverDpsd, &sendSock, &recvSock, NULL );
 
    /* Player name */
    dpid = 0xdeadbeef;
    check_CreatePlayer( dp, &dpid, NULL, 0, DP_OK, 2, recvSock, TRUE, 0x8, NULL, NULL, NULL, NULL, 2 );
 
    dpid = 0xdeadbeef;
    check_CreatePlayer( dp, &dpid, &fullName, 0, DP_OK, 3, recvSock, TRUE, 0x8, L"short player name",
                        "short player name", L"long player name", "long player name", 3 );
 
    name = fullName;
    name.dwSize = 1;
    dpid = 0xdeadbeef;
    check_CreatePlayer( dp, &dpid, &name, 0, DP_OK, 4, recvSock, TRUE, 0x8, L"short player name", "short player name",
                        L"long player name", "long player name", 4 );
 
    dpid = 0xdeadbeef;
    check_CreatePlayer( dp, &dpid, &nullName, 0, DP_OK, 5, recvSock, TRUE, 0x8, NULL, NULL, NULL, NULL, 5 );
 
    /* Null dpid */
    dpid = 0xdeadbeef;
    check_CreatePlayer( dp, NULL, NULL, 0, DPERR_INVALIDPARAMS, 0, recvSock, FALSE, 0, NULL, NULL, NULL, NULL, 0 );
 
    /* Flags */
    dpid = 0xdeadbeef;
    check_CreatePlayer( dp, &dpid, NULL, 0, DP_OK, 6, recvSock, TRUE, 0x8, NULL, NULL, NULL, NULL, 6 );
 
    dpid = 0xdeadbeef;
    check_CreatePlayer( dp, &dpid, NULL, DPPLAYER_SPECTATOR, DP_OK, 7, recvSock, TRUE, 0x208, NULL, NULL, NULL, NULL,
                        7 );
 
    closesocket( recvSock );
    closesocket( sendSock );
 
    IDirectPlayX_Release( dp );
}

Referenced by START_TEST().

◆ test_CREATEPLAYER()

static void test_CREATEPLAYER ( void )

static

Definition at line 5221 of file dplayx.c.

{
    BYTE playerData[] = { 4, 3, 2, 1, };
    DPSESSIONDESC2 appGuidDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidInstance = appGuid,
        .guidApplication = appGuid,
    };
    DPSESSIONDESC2 serverDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidApplication = appGuid,
        .guidInstance = appGuid,
        .lpszSessionName = (WCHAR *) L"normal",
        .dwReserved1 = 0xaabbccdd,
    };
    IDirectPlay4A *dp;
    DWORD waitResult;
    SOCKET sendSock;
    SOCKET recvSock;
    HANDLE event;
    HRESULT hr;
    DPID dpid;
 
    event = CreateEventA( NULL, FALSE, FALSE, NULL );
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlay4A, (void **) &dp );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
 
    init_TCPIP_provider( dp, "127.0.0.1", 0 );
 
    joinSession( dp, &appGuidDpsd, &serverDpsd, &sendSock, &recvSock, NULL );
 
    createPlayer( dp, 0x11223344, event, NULL, 0, 0, sendSock, recvSock );
 
    sendCreatePlayer( sendSock, 2349, 2399, L"new player short name", L"new player long name", playerData,
                      sizeof( playerData ) );
 
    waitResult = WaitForSingleObject( event, 2000 );
    ok( waitResult == WAIT_OBJECT_0, "message wait returned %lu\n", waitResult );
 
    checkPlayerExists( dp, 0x07734, DPPLAYERTYPE_PLAYER, "new player short name", "new player long name",
                       DPENUMPLAYERS_REMOTE, playerData, sizeof( playerData ) );
 
    dpid = checkCreatePlayerOrGroupMessage( dp, DPPLAYERTYPE_PLAYER, 0x07734, 4, playerData, sizeof( playerData ),
                                            "new player short name", "new player long name", 0, 0 );
    ok( dpid == 0x11223344, "got destination id %#lx.\n", dpid );
 
    checkNoMorePlayerMessages( dp );
 
    closesocket( recvSock );
    closesocket( sendSock );
 
    IDirectPlayX_Release( dp );
 
    CloseHandle( event );
}

Referenced by START_TEST().

◆ test_DirectPlayCreate()

static void test_DirectPlayCreate ( void )

static

Definition at line 2368 of file dplayx.c.

{
 
    IDirectPlay *pDP;
    HRESULT hr;
 
    /* TODO: Check how it behaves with pUnk!=NULL */
 
    /* pDP==NULL */
    hr = pDirectPlayCreate( NULL, NULL, NULL );
    checkHR( DPERR_INVALIDPARAMS, hr );
    hr = pDirectPlayCreate( (LPGUID) &GUID_NULL, NULL, NULL );
    checkHR( DPERR_INVALIDPARAMS, hr );
    hr = pDirectPlayCreate( (LPGUID) &DPSPGUID_TCPIP, NULL, NULL );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    /* pUnk==NULL, pDP!=NULL */
    hr = pDirectPlayCreate( NULL, &pDP, NULL );
    checkHR( DPERR_INVALIDPARAMS, hr );
    hr = pDirectPlayCreate( (LPGUID) &GUID_NULL, &pDP, NULL );
    checkHR( DP_OK, hr );
    if ( hr == DP_OK )
        IDirectPlayX_Release( pDP );
    hr = pDirectPlayCreate( (LPGUID) &DPSPGUID_TCPIP, &pDP, NULL );
    checkHR( DP_OK, hr );
    if ( hr == DP_OK )
        IDirectPlayX_Release( pDP );
 
}

Referenced by START_TEST().

◆ test_EnumAddresses()

static void test_EnumAddresses ( void )

static

Definition at line 2783 of file dplayx.c.

{
    IDirectPlay4 *pDP;
    HRESULT hr;
    DPCOMPOUNDADDRESSELEMENT addressElements[2];
    LPVOID pAddress = NULL;
    DWORD dwAddressSize = 0;
    IDirectPlayLobby3 *pDPL;
    WORD port = 6001;
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                           &IID_IDirectPlay4A, (LPVOID*) &pDP );
    ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
    if (FAILED(hr))
        return;
 
    hr = CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL,
                           &IID_IDirectPlayLobby3A, (LPVOID*) &pDPL );
    ok (SUCCEEDED (hr), "CCI of CLSID_DirectPlayLobby / IID_IDirectPlayLobby3A failed\n");
    if (FAILED (hr)) return;
 
    addressElements[0].guidDataType = DPAID_ServiceProvider;
    addressElements[0].dwDataSize   = sizeof(GUID);
    addressElements[0].lpData       = (void*) &DPSPGUID_TCPIP;
 
    addressElements[1].guidDataType = invalid_guid;
    addressElements[1].dwDataSize   = sizeof(WORD);
    addressElements[1].lpData       = &port;
 
    hr = IDirectPlayLobby_CreateCompoundAddress( pDPL, addressElements, 2, NULL, &dwAddressSize );
    checkHR( DPERR_BUFFERTOOSMALL, hr );
 
    if( hr == DPERR_BUFFERTOOSMALL )
    {
        pAddress = calloc( 1, dwAddressSize );
        hr = IDirectPlayLobby_CreateCompoundAddress( pDPL, addressElements, 2,
                                                     pAddress, &dwAddressSize );
        checkHR( DP_OK, hr );
    }
 
    enum_addresses_cb_count = 0;
    hr = IDirectPlayLobby_EnumAddress(pDPL, EnumAddressesCallback, pAddress, dwAddressSize, NULL);
    ok (SUCCEEDED (hr), "IDirectPlayLobby3A_EnumAddress %lx\n", hr);
    todo_wine ok (enum_addresses_cb_count == 3, "wrong count %d\n", enum_addresses_cb_count);
 
    IDirectPlayX_Close(pDP);
    IDirectPlayX_Release(pDP);
    IDirectPlayLobby_Release(pDPL);
 
    free( pAddress );
}

Referenced by START_TEST().

◆ test_EnumAddressTypes()

static void test_EnumAddressTypes ( void )

static

Definition at line 2846 of file dplayx.c.

{
    HRESULT hr;
    IDirectPlayLobby3 *pDPL;
 
    hr = CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL,
                           &IID_IDirectPlayLobby3A, (LPVOID*) &pDPL );
    ok (SUCCEEDED (hr), "CCI of CLSID_DirectPlayLobby / IID_IDirectPlayLobby3A failed\n");
    if (FAILED (hr)) return;
 
    enum_address_cb_count = 0;
    hr = IDirectPlayLobby_EnumAddressTypes(pDPL, EnumAddressTypeCallback, &DPSPGUID_TCPIP, NULL, 0);
    ok (SUCCEEDED (hr), "IDirectPlayLobby3A_EnumAddress %lx\n", hr);
    todo_wine ok (enum_address_cb_count == 1, "IDirectPlayLobby3A_EnumAddress %lx\n", hr);
 
    IDirectPlayLobby_Release(pDPL);
}

Referenced by START_TEST().

◆ test_EnumConnections()

static void test_EnumConnections ( void )

static

Definition at line 2582 of file dplayx.c.

{
 
    IDirectPlay4 *pDP;
    CallbackData callbackData;
    HRESULT hr;
 
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                           &IID_IDirectPlay4A, (LPVOID*) &pDP );
 
    ok (SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n");
    if (FAILED(hr)) return;
 
    callbackData.dwCounter1 = 0;
    callbackData.dwFlags = 0;
    hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
                                       &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    ok( callbackData.dwCounter1 == 4 || callbackData.dwCounter1 == 3, "got=%d\n", callbackData.dwCounter1 );
 
    callbackData.dwCounter1 = 0;
    callbackData.dwFlags = 0;
    hr = IDirectPlayX_EnumConnections( pDP, NULL, EnumConnections_cb,
                                       &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    ok( callbackData.dwCounter1 == 4 || callbackData.dwCounter1 == 3, "got=%d\n", callbackData.dwCounter1 );
 
    callbackData.dwCounter1 = 0;
    callbackData.dwFlags = 0;
    hr = IDirectPlayX_EnumConnections( pDP, &appGuid, NULL,
                                       &callbackData, callbackData.dwFlags );
    checkHR( DPERR_INVALIDPARAMS, hr );
    check( 0, callbackData.dwCounter1 );
 
 
    /* Flag tests */
    callbackData.dwCounter1 = 0;
    callbackData.dwFlags = DPCONNECTION_DIRECTPLAY;
    hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
                                       &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    ok( callbackData.dwCounter1 == 4 || callbackData.dwCounter1 == 3, "got=%d\n", callbackData.dwCounter1 );
 
    callbackData.dwCounter1 = 0;
    callbackData.dwFlags = DPCONNECTION_DIRECTPLAYLOBBY;
    hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
                                       &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( 0, callbackData.dwCounter1 );
 
    callbackData.dwCounter1 = 0;
    callbackData.dwFlags = ( DPCONNECTION_DIRECTPLAY |
                             DPCONNECTION_DIRECTPLAYLOBBY );
    hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
                                       &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    ok( callbackData.dwCounter1 == 4 || callbackData.dwCounter1 == 3, "got=%d\n", callbackData.dwCounter1 );
 
    callbackData.dwCounter1 = 0;
    callbackData.dwFlags = ~( DPCONNECTION_DIRECTPLAY |
                              DPCONNECTION_DIRECTPLAYLOBBY );
    hr = IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb,
                                       &callbackData, callbackData.dwFlags );
    checkHR( DPERR_INVALIDFLAGS, hr );
    check( 0, callbackData.dwCounter1 );
 
 
    IDirectPlayX_Release( pDP );
}

Referenced by START_TEST().

◆ test_EnumerateProviders()

static void test_EnumerateProviders ( void )

static

Definition at line 2434 of file dplayx.c.

{
    HRESULT hr;
    int i;
    struct provider_data arg;
 
    memset(&arg, 0, sizeof(arg));
    arg.ret_value = TRUE;
 
    hr = pDirectPlayEnumerateA(callback_providersA, NULL);
    ok(SUCCEEDED(hr), "DirectPlayEnumerateA failed\n");
 
    SetLastError(0xdeadbeef);
    hr = pDirectPlayEnumerateA(NULL, &arg);
    ok(FAILED(hr), "DirectPlayEnumerateA expected to fail\n");
    ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got 0x%lx\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    hr = pDirectPlayEnumerateA(NULL, NULL);
    ok(FAILED(hr), "DirectPlayEnumerateA expected to fail\n");
    ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got 0x%lx\n", GetLastError());
 
    hr = pDirectPlayEnumerateA(callback_providersA, &arg);
    ok(SUCCEEDED(hr), "DirectPlayEnumerateA failed\n");
    ok(arg.call_count > 0, "Expected at least one valid provider\n");
    trace("Found %d providers\n", arg.call_count);
 
    /* The returned GUID values must have persisted after enumeration (bug 37185) */
    for(i = 0; i < arg.call_count; i++)
    {
        ok(IsEqualGUID(arg.guid_ptr[i], &arg.guid_data[i]), "#%d Expected equal GUID values\n", i);
    }
 
    memset(&arg, 0, sizeof(arg));
    arg.ret_value = FALSE;
    hr = pDirectPlayEnumerateA(callback_providersA, &arg);
    ok(SUCCEEDED(hr), "DirectPlayEnumerateA failed\n");
    ok(arg.call_count == 1, "Expected 1, got %d\n", arg.call_count);
 
    hr = pDirectPlayEnumerateW(callback_providersW, NULL);
    ok(SUCCEEDED(hr), "DirectPlayEnumerateW failed\n");
 
    SetLastError(0xdeadbeef);
    hr = pDirectPlayEnumerateW(NULL, &arg);
    ok(FAILED(hr), "DirectPlayEnumerateW expected to fail\n");
    ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got 0x%lx\n", GetLastError());
 
    SetLastError(0xdeadbeef);
    hr = pDirectPlayEnumerateW(NULL, NULL);
    ok(FAILED(hr), "DirectPlayEnumerateW expected to fail\n");
    ok(GetLastError() == 0xdeadbeef, "Expected 0xdeadbeef, got 0x%lx\n", GetLastError());
 
    memset(&arg, 0, sizeof(arg));
    arg.ret_value = TRUE;
    hr = pDirectPlayEnumerateW(callback_providersW, &arg);
    ok(SUCCEEDED(hr), "DirectPlayEnumerateW failed\n");
    ok(arg.call_count > 0, "Expected at least one valid provider\n");
 
    /* The returned GUID values must have persisted after enumeration (bug 37185) */
    for(i = 0; i < arg.call_count; i++)
    {
        ok(IsEqualGUID(arg.guid_ptr[i], &arg.guid_data[i]), "#%d Expected equal GUID values\n", i);
    }
 
    memset(&arg, 0, sizeof(arg));
    arg.ret_value = FALSE;
    hr = pDirectPlayEnumerateW(callback_providersW, &arg);
    ok(SUCCEEDED(hr), "DirectPlayEnumerateW failed\n");
    ok(arg.call_count == 1, "Expected 1, got %d\n", arg.call_count);
}

Referenced by START_TEST().

◆ test_EnumGroups()

static void test_EnumGroups ( void )

static

Definition at line 7225 of file dplayx.c.

{
    IDirectPlay4 *pDP[3];
    DPSESSIONDESC2 dpsd[3];
    DPID dpid[5];
    CallbackData callbackData;
    HRESULT hr;
    UINT i;
 
 
    for (i=0; i<3; i++)
    {
        hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                               &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
        ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
        if (FAILED(hr)) return;
 
        ZeroMemory( &dpsd[i], sizeof(DPSESSIONDESC2) );
        dpsd[i].dwSize = sizeof(DPSESSIONDESC2);
    }
 
    dpsd[0].guidApplication = appGuid;
    dpsd[1].guidApplication = appGuid2;
    dpsd[2].guidApplication = GUID_NULL;
 
    callbackData.dpid = dpid;
    callbackData.dpidSize = 5;
 
 
    /* Uninitialized service provider */
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroups( pDP[0], NULL, EnumGroups_cb,
                                  &callbackData, 0 );
    checkHR( DPERR_UNINITIALIZED, hr );
    check( 0, callbackData.dwCounter1 );
 
 
    init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
    init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
    init_TCPIP_provider( pDP[2], "127.0.0.1", 0 );
 
 
    /* No session */
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroups( pDP[0], NULL, EnumGroups_cb,
                                  &callbackData, 0 );
    todo_wine checkHR( DPERR_NOSESSIONS, hr );
    check( 0, callbackData.dwCounter1 );
 
    if ( hr == DPERR_UNINITIALIZED )
    {
        todo_wine win_skip( "EnumGroups not implemented\n" );
        return;
    }
 
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroups( pDP[0], (LPGUID) &appGuid, EnumGroups_cb,
                                  &callbackData, 0 );
    checkHR( DPERR_NOSESSIONS, hr );
    check( 0, callbackData.dwCounter1 );
 
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroups( pDP[0], (LPGUID) &appGuid, EnumGroups_cb,
                                  &callbackData, DPENUMGROUPS_SESSION );
    checkHR( DPERR_NOSESSIONS, hr );
    check( 0, callbackData.dwCounter1 );
 
 
    hr = IDirectPlayX_Open( pDP[0], &dpsd[0], DPOPEN_CREATE );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_Open( pDP[1], &dpsd[1], DPOPEN_CREATE );
    checkHR( DP_OK, hr );
 
 
    /* No groups */
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroups( pDP[0], NULL, EnumGroups_cb,
                                  &callbackData, 0 );
    checkHR( DP_OK, hr );
    check( 0, callbackData.dwCounter1 );
 
 
    /* Create groups */
    hr = IDirectPlayX_CreateGroup( pDP[0], &dpid[0],
                                   NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreateGroupInGroup( pDP[0], dpid[0], &dpid[3],
                                          NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr ); /* Not a superior level group,
                             won't appear in the enumerations */
    hr = IDirectPlayX_CreateGroup( pDP[1], &dpid[1],
                                   NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreateGroup( pDP[0], &dpid[2],
                                   NULL, NULL, 0, DPGROUP_HIDDEN );
    checkHR( DP_OK, hr );
 
 
    /* Invalid parameters */
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroups( pDP[0], (LPGUID) &appGuid, NULL,
                                  &callbackData, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
    check( 0, callbackData.dwCounter1 );
 
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroups( pDP[0], NULL, EnumGroups_cb,
                                  &callbackData, DPENUMGROUPS_SESSION );
    checkHR( DPERR_INVALIDPARAMS, hr );
    check( 0, callbackData.dwCounter1 );
 
 
    /* Regular operation */
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumGroups( pDP[0], NULL, EnumGroups_cb,
                                  &callbackData, 0 );
    checkHR( DP_OK, hr );
    check( 2, callbackData.dwCounter1 );
    checkStr( "02", callbackData.szTrace1 );
    checkStr( "ALL:HIDDEN:", callbackData.szTrace2 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumGroups( pDP[1], NULL, EnumGroups_cb,
                                  &callbackData, 0 );
    checkHR( DP_OK, hr );
    check( 1, callbackData.dwCounter1 );
    checkStr( "1", callbackData.szTrace1 );
    checkStr( "ALL:", callbackData.szTrace2 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumGroups( pDP[0], (LPGUID) &appGuid, EnumGroups_cb,
                                  &callbackData, 0 );
    checkHR( DP_OK, hr );
    check( 2, callbackData.dwCounter1 ); /* Guid is ignored */
    checkStr( "02", callbackData.szTrace1 );
    checkStr( "ALL:HIDDEN:", callbackData.szTrace2 );
 
 
    /* Enumerating from a remote session */
    /* - Session not open */
    callbackData.pDP = pDP[2];
    hr = IDirectPlayX_EnumSessions( pDP[2], &dpsd[2], 0,
                                    EnumSessions_cb_EnumGroups,
                                    &callbackData, 0 );
    checkHR( DP_OK, hr );
 
    /* - Open session */
    callbackData.pDP = pDP[2];
    hr = IDirectPlayX_EnumSessions( pDP[2], &dpsd[0], 0, EnumSessions_cb_join,
                                    pDP[2], 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreateGroup( pDP[2], &dpid[3],
                                   NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreateGroup( pDP[2], &dpid[4],
                                   NULL, NULL, 0, DPGROUP_STAGINGAREA );
    checkHR( DP_OK, hr );
 
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumGroups( pDP[2], NULL, EnumGroups_cb,
                                  &callbackData, 0 );
    checkHR( DP_OK, hr );
    check( 4, callbackData.dwCounter1 );
    checkStr( "0234", callbackData.szTrace1 );
    checkStr( "ALL:HIDDEN:ALL:STAGINGAREA:", callbackData.szTrace2 );
 
    /* Flag tests */
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumGroups( pDP[2], NULL, EnumGroups_cb,
                                  &callbackData, DPENUMGROUPS_ALL );
    checkHR( DP_OK, hr );
    check( 4, callbackData.dwCounter1 );
    checkStr( "0234", callbackData.szTrace1 );
    checkStr( "ALL:HIDDEN:ALL:STAGINGAREA:", callbackData.szTrace2 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumGroups( pDP[2], NULL, EnumGroups_cb,
                                  &callbackData, DPENUMGROUPS_HIDDEN );
    checkHR( DP_OK, hr );
    check( 1, callbackData.dwCounter1 );
    checkStr( "2", callbackData.szTrace1 );
    checkStr( "HIDDEN:", callbackData.szTrace2 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumGroups( pDP[2], NULL, EnumGroups_cb,
                                  &callbackData, DPENUMGROUPS_LOCAL );
    checkHR( DP_OK, hr );
    check( 2, callbackData.dwCounter1 );
    checkStr( "34", callbackData.szTrace1 );
    checkStr( "LOCAL:"
              "LOCAL,DPENUMGROUPS_STAGINGAREA:", callbackData.szTrace2 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumGroups( pDP[2], NULL, EnumGroups_cb,
                                  &callbackData, DPENUMGROUPS_REMOTE );
    checkHR( DP_OK, hr );
    check( 2, callbackData.dwCounter1 );
    checkStr( "02", callbackData.szTrace1 );
    checkStr( "REMOTE:"
              "REMOTE,DPENUMGROUPS_HIDDEN:", callbackData.szTrace2 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumGroups( pDP[2], NULL, EnumGroups_cb,
                                  &callbackData, DPENUMGROUPS_STAGINGAREA );
    checkHR( DP_OK, hr );
    check( 1, callbackData.dwCounter1 );
    checkStr( "4", callbackData.szTrace1 );
    checkStr( "STAGINGAREA:", callbackData.szTrace2 );
 
 
    IDirectPlayX_Release( pDP[0] );
    IDirectPlayX_Release( pDP[1] );
    IDirectPlayX_Release( pDP[2] );
 
}

Referenced by START_TEST().

◆ test_EnumGroupsInGroup()

static void test_EnumGroupsInGroup ( void )

static

Definition at line 7452 of file dplayx.c.

{
    IDirectPlay4 *pDP[2];
    DPSESSIONDESC2 dpsd[2];
    DPID dpid[6];
    CallbackData callbackData;
    HRESULT hr;
    UINT i;
 
 
    for (i=0; i<2; i++)
    {
        hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                               &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
        ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
        if (FAILED(hr)) return;
 
        ZeroMemory( &dpsd[i], sizeof(DPSESSIONDESC2) );
        dpsd[i].dwSize = sizeof(DPSESSIONDESC2);
    }
 
    dpsd[0].guidApplication = appGuid;
    dpsd[1].guidApplication = GUID_NULL;
 
    callbackData.dpid = dpid;
    callbackData.dpidSize = 6;
 
 
    /* Uninitialized service provider */
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], 0, NULL, EnumGroups_cb,
                                         &callbackData, 0 );
    checkHR( DPERR_UNINITIALIZED, hr );
    check( 0, callbackData.dwCounter1 );
 
 
    init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
    init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
 
    hr = IDirectPlayX_Open( pDP[0], &dpsd[0], DPOPEN_CREATE );
    todo_wine checkHR( DP_OK, hr );
 
    if ( hr == DPERR_UNINITIALIZED )
    {
        todo_wine win_skip( "EnumGroupsInGroup not implemented\n" );
        return;
    }
 
    /* Create groups */
    /*
     * 0
     *   / 2
     * 1 | 3
     *   | 4
     *   \ 5 (shortcut)
     */
    hr = IDirectPlayX_CreateGroup( pDP[0], &dpid[0],
                                   NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreateGroup( pDP[0], &dpid[1],
                                   NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreateGroupInGroup( pDP[0], dpid[1], &dpid[2],
                                          NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreateGroupInGroup( pDP[0], dpid[1], &dpid[3],
                                          NULL, NULL, 0,
                                          DPGROUP_HIDDEN );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreateGroupInGroup( pDP[0], dpid[1], &dpid[4],
                                          NULL, NULL, 0,
                                          DPGROUP_STAGINGAREA );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreateGroup( pDP[0], &dpid[5],
                                   NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_AddGroupToGroup( pDP[0], dpid[1], dpid[5] );
    checkHR( DP_OK, hr );
 
 
    /* Invalid parameters */
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], 0, NULL, EnumGroups_cb,
                                         &callbackData, 0 );
    checkHR( DPERR_INVALIDGROUP, hr );
    check( 0, callbackData.dwCounter1 );
 
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], 10, NULL, EnumGroups_cb,
                                         &callbackData, 0 );
    checkHR( DPERR_INVALIDGROUP, hr );
    check( 0, callbackData.dwCounter1 );
 
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], (LPGUID) &appGuid,
                                         NULL, &callbackData, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
    check( 0, callbackData.dwCounter1 );
 
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb,
                                         &callbackData, DPENUMGROUPS_SESSION );
    checkHR( DPERR_INVALIDPARAMS, hr );
    check( 0, callbackData.dwCounter1 );
 
 
    /* Regular operation */
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[0], NULL, EnumGroups_cb,
                                         &callbackData, 0 );
    checkHR( DP_OK, hr );
    check( 0, callbackData.dwCounter1 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb,
                                         &callbackData, 0 );
    checkHR( DP_OK, hr );
    check( 4, callbackData.dwCounter1 );
    checkStr( "5432", callbackData.szTrace1 );
    checkStr( "SHORTCUT:STAGINGAREA:HIDDEN:ALL:", callbackData.szTrace2 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], (LPGUID) &appGuid,
                                         EnumGroups_cb, &callbackData, 0 );
    checkHR( DP_OK, hr );
    check( 4, callbackData.dwCounter1 ); /* Guid is ignored */
    checkStr( "5432", callbackData.szTrace1 );
    checkStr( "SHORTCUT:STAGINGAREA:HIDDEN:ALL:", callbackData.szTrace2 );
 
 
    /* Enumerating from a remote session */
    /* - Session not open */
    callbackData.pDP = pDP[1];
    hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd[1], 0,
                                    EnumSessions_cb_EnumGroups,
                                    &callbackData, 0 );
    checkHR( DP_OK, hr );
 
    /* - Open session */
    hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd[0], 0, EnumSessions_cb_join,
                                    pDP[1], 0 );
    checkHR( DP_OK, hr );
 
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumGroupsInGroup( pDP[1], dpid[1], NULL, EnumGroups_cb,
                                         &callbackData, 0 );
    checkHR( DP_OK, hr );
    check( 4, callbackData.dwCounter1 );
    checkStr( "5432", callbackData.szTrace1 );
    checkStr( "SHORTCUT:STAGINGAREA:HIDDEN:ALL:", callbackData.szTrace2 );
 
    /* Flag tests */
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb,
                                         &callbackData, DPENUMGROUPS_ALL );
    checkHR( DP_OK, hr );
    check( 4, callbackData.dwCounter1 );
    checkStr( "5432", callbackData.szTrace1 );
    checkStr( "SHORTCUT:STAGINGAREA:HIDDEN:ALL:", callbackData.szTrace2 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb,
                                         &callbackData, DPENUMGROUPS_HIDDEN );
    checkHR( DP_OK, hr );
    check( 1, callbackData.dwCounter1 );
    checkStr( "3", callbackData.szTrace1 );
    checkStr( "HIDDEN:", callbackData.szTrace2 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb,
                                         &callbackData, DPENUMGROUPS_LOCAL );
    checkHR( DP_OK, hr );
    check( 4, callbackData.dwCounter1 );
    checkStr( "5432", callbackData.szTrace1 );
    checkStr( "LOCAL,DPENUMGROUPS_SHORTCUT:"
              "LOCAL,DPENUMGROUPS_STAGINGAREA:"
              "LOCAL,DPENUMGROUPS_HIDDEN:LOCAL:", callbackData.szTrace2 );
 
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb,
                                         &callbackData, DPENUMGROUPS_REMOTE );
    checkHR( DP_OK, hr );
    check( 0, callbackData.dwCounter1 );
 
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumGroupsInGroup( pDP[1], dpid[1], NULL, EnumGroups_cb,
                                         &callbackData, DPENUMGROUPS_LOCAL );
    checkHR( DP_OK, hr );
    check( 0, callbackData.dwCounter1 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumGroupsInGroup( pDP[1], dpid[1], NULL, EnumGroups_cb,
                                         &callbackData, DPENUMGROUPS_REMOTE );
    checkHR( DP_OK, hr );
    check( 4, callbackData.dwCounter1 );
    checkStr( "5432", callbackData.szTrace1 );
    checkStr( "REMOTE,DPENUMGROUPS_SHORTCUT:"
              "REMOTE,DPENUMGROUPS_STAGINGAREA:"
              "REMOTE,DPENUMGROUPS_HIDDEN:REMOTE:", callbackData.szTrace2 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb,
                                         &callbackData, DPENUMGROUPS_SHORTCUT );
    checkHR( DP_OK, hr );
    check( 1, callbackData.dwCounter1 );
    checkStr( "5", callbackData.szTrace1 );
    checkStr( "SHORTCUT:", callbackData.szTrace2 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumGroupsInGroup( pDP[0], dpid[1], NULL, EnumGroups_cb,
                                         &callbackData,
                                         DPENUMGROUPS_STAGINGAREA );
    checkHR( DP_OK, hr );
    check( 1, callbackData.dwCounter1 );
    checkStr( "4", callbackData.szTrace1 );
    checkStr( "STAGINGAREA:", callbackData.szTrace2 );
 
 
    IDirectPlayX_Release( pDP[0] );
    IDirectPlayX_Release( pDP[1] );
 
}

Referenced by START_TEST().

◆ test_EnumPlayers()

static void test_EnumPlayers ( void )

static

Definition at line 6902 of file dplayx.c.

{
    IDirectPlay4 *pDP[3];
    DPSESSIONDESC2 dpsd[3];
    DPID dpid[5+2]; /* 5 players, 2 groups */
    CallbackData callbackData;
    HRESULT hr;
    UINT i;
 
 
    for (i=0; i<3; i++)
    {
        hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                               &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
        ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
        if (FAILED(hr)) return;
 
        ZeroMemory( &dpsd[i], sizeof(DPSESSIONDESC2) );
        dpsd[i].dwSize = sizeof(DPSESSIONDESC2);
    }
 
    dpsd[0].guidApplication = appGuid;
    dpsd[1].guidApplication = appGuid2;
    dpsd[2].guidApplication = GUID_NULL;
 
    callbackData.dpid = dpid;
    callbackData.dpidSize = 5+2;
 
 
    /* Uninitialized service provider */
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumPlayers( pDP[0], (LPGUID) &appGuid, NULL,
                                   &callbackData, 0 );
    checkHR( DPERR_UNINITIALIZED, hr );
    check( 0, callbackData.dwCounter1 );
 
 
    init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
    init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
    init_TCPIP_provider( pDP[2], "127.0.0.1", 0 );
 
 
    /* No session */
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumPlayers( pDP[0], NULL, EnumPlayers_cb,
                                   &callbackData, 0 );
    todo_wine checkHR( DPERR_NOSESSIONS, hr );
    check( 0, callbackData.dwCounter1 );
 
    if ( hr == DPERR_UNINITIALIZED )
    {
        todo_wine win_skip( "EnumPlayers not implemented\n" );
        return;
    }
 
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumPlayers( pDP[0], (LPGUID) &appGuid, EnumPlayers_cb,
                                   &callbackData, 0 );
    checkHR( DPERR_NOSESSIONS, hr );
    check( 0, callbackData.dwCounter1 );
 
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumPlayers( pDP[0], (LPGUID) &appGuid, EnumPlayers_cb,
                                   &callbackData, DPENUMPLAYERS_SESSION );
    checkHR( DPERR_NOSESSIONS, hr );
    check( 0, callbackData.dwCounter1 );
 
 
    hr = IDirectPlayX_Open( pDP[0], &dpsd[0], DPOPEN_CREATE );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_Open( pDP[1], &dpsd[1], DPOPEN_CREATE );
    checkHR( DP_OK, hr );
 
 
    /* No players */
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumPlayers( pDP[0], NULL, EnumPlayers_cb,
                                   &callbackData, 0 );
    checkHR( DP_OK, hr );
    check( 0, callbackData.dwCounter1 );
 
 
    /* Create players */
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[0],
                                    NULL, NULL, NULL, 0,
                                    DPPLAYER_SERVERPLAYER );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid[1],
                                    NULL, NULL, NULL, 0,
                                    0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[2],
                                    NULL, NULL, NULL, 0,
                                    0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreateGroup( pDP[0], &dpid[5],
                                   NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
 
    /* Invalid parameters */
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumPlayers( pDP[0], (LPGUID) &appGuid, NULL,
                                   &callbackData, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
    check( 0, callbackData.dwCounter1 );
 
    callbackData.dwCounter1 = 0;
    hr = IDirectPlayX_EnumPlayers( pDP[0], NULL, EnumPlayers_cb,
                                   &callbackData, DPENUMPLAYERS_SESSION );
    checkHR( DPERR_INVALIDPARAMS, hr );
    check( 0, callbackData.dwCounter1 );
 
 
    /* Regular operation */
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumPlayers( pDP[0], NULL, EnumPlayers_cb,
                                   &callbackData, 0 );
    checkHR( DP_OK, hr );
    check( 2, callbackData.dwCounter1 );
    checkStr( "20", callbackData.szTrace1 );
    checkStr( "ALL:SERVERPLAYER:", callbackData.szTrace2 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumPlayers( pDP[1], NULL, EnumPlayers_cb,
                                   &callbackData, 0 );
    checkHR( DP_OK, hr );
    check( 1, callbackData.dwCounter1 );
    checkStr( "1", callbackData.szTrace1 );
    checkStr( "ALL:", callbackData.szTrace2 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumPlayers( pDP[0], (LPGUID) &appGuid, EnumPlayers_cb,
                                   &callbackData, 0 );
    checkHR( DP_OK, hr );
    check( 2, callbackData.dwCounter1 ); /* Guid is ignored */
    checkStr( "20", callbackData.szTrace1 );
    checkStr( "ALL:SERVERPLAYER:", callbackData.szTrace2 );
 
 
    /* Enumerating from a remote session */
    /* - Session not open */
    callbackData.pDP = pDP[2];
    hr = IDirectPlayX_EnumSessions( pDP[2], &dpsd[2], 0,
                                    EnumSessions_cb_EnumPlayers,
                                    &callbackData, 0 );
    checkHR( DP_OK, hr );
 
 
    /* - Open session */
    callbackData.pDP = pDP[2];
    hr = IDirectPlayX_EnumSessions( pDP[2], &dpsd[0], 0, EnumSessions_cb_join,
                                    pDP[2], 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreatePlayer( pDP[2], &dpid[3],
                                    NULL, NULL, NULL, 0,
                                    DPPLAYER_SPECTATOR );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreatePlayer( pDP[2], &dpid[4],
                                    NULL, NULL, NULL, 0,
                                    0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreateGroup( pDP[2], &dpid[6],
                                   NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumPlayers( pDP[2], NULL, EnumPlayers_cb,
                                   &callbackData, 0 );
    checkHR( DP_OK, hr );
    check( 4, callbackData.dwCounter1 );
    checkStr( "4302", callbackData.szTrace1 );
    checkStr( "ALL:SPECTATOR:SERVERPLAYER:ALL:", callbackData.szTrace2 );
 
 
    /* Flag tests */
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumPlayers( pDP[2], NULL, EnumPlayers_cb,
                                   &callbackData, DPENUMPLAYERS_ALL );
    checkHR( DP_OK, hr );
    check( 4, callbackData.dwCounter1 );
    checkStr( "4302", callbackData.szTrace1 );
    checkStr( "ALL:SPECTATOR:SERVERPLAYER:ALL:", callbackData.szTrace2 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumPlayers( pDP[2], NULL, EnumPlayers_cb,
                                   &callbackData, DPENUMPLAYERS_GROUP );
    checkHR( DP_OK, hr );
    check( 6, callbackData.dwCounter1 );
    checkStr( "430256", callbackData.szTrace1 );
    checkStr( "GROUP:"
              "GROUP,DPENUMPLAYERS_SPECTATOR:"
              "GROUP,DPENUMPLAYERS_SERVERPLAYER:"
              "GROUP:ALL:ALL:", callbackData.szTrace2 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumPlayers( pDP[2], NULL, EnumPlayers_cb,
                                   &callbackData, DPENUMPLAYERS_LOCAL );
    checkHR( DP_OK, hr );
    check( 2, callbackData.dwCounter1 );
    checkStr( "43", callbackData.szTrace1 );
    checkStr( "LOCAL:"
              "LOCAL,DPENUMPLAYERS_SPECTATOR:", callbackData.szTrace2 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumPlayers( pDP[2], NULL, EnumPlayers_cb,
                                   &callbackData, DPENUMPLAYERS_SERVERPLAYER );
    checkHR( DP_OK, hr );
    check( 1, callbackData.dwCounter1 );
    checkStr( "0", callbackData.szTrace1 );
    checkStr( "SERVERPLAYER:", callbackData.szTrace2 );
 
    callbackData.dwCounter1 = 0;
    callbackData.szTrace2[0] = 0;
    hr = IDirectPlayX_EnumPlayers( pDP[2], NULL, EnumPlayers_cb,
                                   &callbackData, DPENUMPLAYERS_SPECTATOR );
    checkHR( DP_OK, hr );
    check( 1, callbackData.dwCounter1 );
    checkStr( "3", callbackData.szTrace1 );
    checkStr( "SPECTATOR:", callbackData.szTrace2 );
 
 
    IDirectPlayX_Release( pDP[0] );
    IDirectPlayX_Release( pDP[1] );
    IDirectPlayX_Release( pDP[2] );
 
}

Referenced by START_TEST().

◆ test_EnumSessions()

static void test_EnumSessions ( void )

static

Definition at line 4092 of file dplayx.c.

{
    DPSESSIONDESC2 appGuidDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidApplication = appGuid,
        .guidInstance = appGuid,
    };
    DPSESSIONDESC2 dpsd;
    IDirectPlay4 *dpA;
    IDirectPlay4 *dp;
    HRESULT hr;
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlay4A, (void **) &dpA );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    hr = IDirectPlayX_QueryInterface( dpA, &IID_IDirectPlay4, (void **) &dp );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
 
    /* Service provider not initialized */
    check_EnumSessions( dpA, &appGuidDpsd, 0, DPERR_UNINITIALIZED, 0, FALSE, FALSE, NULL, 0, TRUE, FALSE );
    check_EnumSessions( dp, &appGuidDpsd, 0, DPERR_UNINITIALIZED, 0, FALSE, FALSE, NULL, 0, FALSE, FALSE );
 
    init_TCPIP_provider( dpA, "127.0.0.1", 0 );
 
    /* Session with no size */
    dpsd = appGuidDpsd;
    dpsd.dwSize = 0;
    check_EnumSessions( dpA, &dpsd, 0, DPERR_INVALIDPARAMS, 0, FALSE, FALSE, NULL, 0, TRUE, FALSE );
    check_EnumSessions( dp, &dpsd, 0, DPERR_INVALIDPARAMS, 0, FALSE, FALSE, NULL, 0, FALSE, FALSE );
 
    /* No sessions */
    check_EnumSessions( dpA, &appGuidDpsd, 0, DP_OK, 0, TRUE, TRUE, NULL, 0, TRUE, FALSE );
    check_EnumSessions( dp, &appGuidDpsd, 0, DP_OK, 0, TRUE, TRUE, NULL, 0, FALSE, FALSE );
 
    /* Invalid params */
    check_EnumSessions( dpA, &appGuidDpsd, -1, DPERR_INVALIDPARAMS, 0, FALSE, FALSE, NULL, 0, TRUE, TRUE );
    check_EnumSessions( dp, &appGuidDpsd, -1, DPERR_INVALIDPARAMS, 0, FALSE, FALSE, NULL, 0, FALSE, TRUE );
    check_EnumSessions( dpA, NULL, 0, DPERR_INVALIDPARAMS, 0, FALSE, FALSE, NULL, 0, TRUE, FALSE );
    check_EnumSessions( dp, NULL, 0, DPERR_INVALIDPARAMS, 0, FALSE, FALSE, NULL, 0, FALSE, FALSE );
 
    /* All sessions are enumerated regardless of flags */
    check_EnumSessions( dpA, &appGuidDpsd, 0, DP_OK, 2, TRUE, TRUE, NULL, 2, TRUE, FALSE );
    check_EnumSessions( dp, &appGuidDpsd, 0, DP_OK, 2, TRUE, TRUE, NULL, 2, FALSE, FALSE );
    check_EnumSessions( dpA, &appGuidDpsd, DPENUMSESSIONS_AVAILABLE, DP_OK, 2, TRUE, TRUE, NULL, 2, TRUE, FALSE );
    check_EnumSessions( dp, &appGuidDpsd, DPENUMSESSIONS_AVAILABLE, DP_OK, 2, TRUE, TRUE, NULL, 2, FALSE, FALSE );
 
    /* Async enumeration */
    check_EnumSessions_async( &appGuidDpsd, dpA, TRUE );
    check_EnumSessions_async( &appGuidDpsd, dp, FALSE );
 
    /* Enumeration with password */
    dpsd = appGuidDpsd;
    dpsd.lpszPasswordA = (char *) "password";
    check_EnumSessions( dpA, &dpsd, 0, DP_OK, 2, TRUE, TRUE, L"password", 2, TRUE, FALSE );
    dpsd = appGuidDpsd;
    dpsd.lpszPassword = (WCHAR *) L"password";
    check_EnumSessions( dp, &dpsd, 0, DP_OK, 2, TRUE, TRUE, L"password", 2, FALSE, FALSE );
 
    IDirectPlayX_Release( dp );
    IDirectPlayX_Release( dpA );
}

Referenced by START_TEST().

◆ test_GetCaps()

static void test_GetCaps ( void )

static

Definition at line 2704 of file dplayx.c.

{
 
    IDirectPlay4 *pDP;
    DPCAPS dpcaps;
    DWORD dwFlags;
    HRESULT hr;
 
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                           &IID_IDirectPlay4A, (LPVOID*) &pDP );
    ok (SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n");
    if (FAILED(hr)) return;
 
    ZeroMemory( &dpcaps, sizeof(DPCAPS) );
 
    /* Service provider not ininitialized */
    hr = IDirectPlayX_GetCaps( pDP, &dpcaps, 0 );
    checkHR( DPERR_UNINITIALIZED, hr );
 
    init_TCPIP_provider( pDP, "127.0.0.1", 0 );
 
    /* dpcaps not ininitialized */
    hr = IDirectPlayX_GetCaps( pDP, &dpcaps, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    dpcaps.dwSize = sizeof(DPCAPS);
 
    for (dwFlags=0;
         dwFlags<=DPGETCAPS_GUARANTEED;
         dwFlags+=DPGETCAPS_GUARANTEED)
    {
 
        hr = IDirectPlayX_GetCaps( pDP, &dpcaps, dwFlags );
        checkHR( DP_OK, hr );
        check( sizeof(DPCAPS), dpcaps.dwSize );
        check( DPCAPS_ASYNCSUPPORTED |
               DPCAPS_GUARANTEEDOPTIMIZED |
               DPCAPS_GUARANTEEDSUPPORTED,
               dpcaps.dwFlags );
        check( 0,     dpcaps.dwMaxQueueSize );
        check( 0,     dpcaps.dwHundredBaud );
        check( 500,   dpcaps.dwLatency );
        check( 65536, dpcaps.dwMaxLocalPlayers );
        check( 20,    dpcaps.dwHeaderLength );
        check( 5000,  dpcaps.dwTimeout );
 
        switch (dwFlags)
        {
        case 0:
            check( 65479,   dpcaps.dwMaxBufferSize );
            check( 65536,   dpcaps.dwMaxPlayers );
            break;
        case DPGETCAPS_GUARANTEED:
            check( 1048547, dpcaps.dwMaxBufferSize );
            check( 64,      dpcaps.dwMaxPlayers );
            break;
        default: break;
        }
    }
 
    IDirectPlayX_Release( pDP );
}

Referenced by START_TEST().

◆ test_GetMessageCount()

static void test_GetMessageCount ( void )

static

Definition at line 9326 of file dplayx.c.

{
 
    IDirectPlay4 *pDP[2];
    DPSESSIONDESC2 dpsd;
    DPID dpid[4];
    HRESULT hr;
    UINT i;
    DWORD dwCount;
 
    DWORD dwDataSize = 1024;
    LPVOID lpData = calloc( 1, dwDataSize );
    CallbackData callbackData;
 
 
    for (i=0; i<2; i++)
    {
        hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                               &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
        ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
        if (FAILED(hr)) return;
    }
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], 0,  &dwCount );
    todo_wine checkHR( DPERR_UNINITIALIZED, hr );
    check( -1, dwCount );
 
    if ( hr == DP_OK )
    {
        todo_wine win_skip( "GetMessageCount not implemented\n" );
        return;
    }
 
 
    init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
    init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
 
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], 0, &dwCount );
    checkHR( DP_OK, hr );
    check( 0, dwCount );
 
 
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    dpsd.dwMaxPlayers = 10;
    IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
    IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
                               pDP[1], 0 );
 
    IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 );
    IDirectPlayX_CreatePlayer( pDP[0], &dpid[1], NULL, NULL, NULL, 0, 0 );
    IDirectPlayX_CreatePlayer( pDP[1], &dpid[3], NULL, NULL, NULL, 0, 0 );
    IDirectPlayX_CreatePlayer( pDP[0], &dpid[2], NULL, NULL, NULL, 0, 0 );
 
 
    /* Incorrect parameters */
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[0], NULL );
    checkHR( DPERR_INVALIDPARAMS, hr );
    check( -1, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], 0, NULL );
    checkHR( DPERR_INVALIDPARAMS, hr );
    check( -1, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], -1, &dwCount );
    checkHR( DPERR_INVALIDPLAYER, hr );
    check( -1, dwCount );
 
 
    /* Correct parameters */
    /* Player creation messages */
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], 0, &dwCount );
    checkHR( DP_OK, hr );
    check( 5, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[1], 0, &dwCount );
    checkHR( DP_OK, hr );
    check( 1, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[0], &dwCount );
    checkHR( DP_OK, hr );
    check( 3, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[1], &dwCount );
    checkHR( DP_OK, hr );
    check( 2, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[3], &dwCount );
    checkHR( DP_OK, hr );
    /* Remote player: doesn't throw error but result is 0 and not 1 */
    check( 0, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[1], dpid[3], &dwCount );
    checkHR( DP_OK, hr );
    check( 1, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[1], &dwCount );
    checkHR( DP_OK, hr );
    check( 2, dwCount );
 
 
    /* Purge queues */
    check_messages( pDP[0], dpid, 6, &callbackData );
    checkStr( "S0,S1,S0,S1,S0,", callbackData.szTrace1 );
    check_messages( pDP[1], dpid, 6, &callbackData );
    checkStr( "S3,", callbackData.szTrace1 );
 
 
    /* Ensure queues is purged */
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], 0, &dwCount );
    checkHR( DP_OK, hr );
    check( 0, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[1], 0, &dwCount );
    checkHR( DP_OK, hr );
    check( 0, dwCount );
 
 
    /* Send data messages */
    for (i=0; i<5; i++)
        IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 0, lpData, dwDataSize );
    for (i=0; i<6; i++)
        IDirectPlayX_Send( pDP[0], dpid[1], dpid[2], 0, lpData, dwDataSize );
    for (i=0; i<7; i++)
        IDirectPlayX_Send( pDP[0], dpid[2], dpid[3], 0, lpData, dwDataSize );
 
 
    /* Check all messages are in the queues */
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], 0, &dwCount );
    checkHR( DP_OK, hr );
    check( 11, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[1], 0, &dwCount );
    checkHR( DP_OK, hr );
    check( 7, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[0], &dwCount );
    checkHR( DP_OK, hr );
    check( 0, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[1], &dwCount );
    checkHR( DP_OK, hr );
    check( 5, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[2], &dwCount );
    checkHR( DP_OK, hr );
    check( 6, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[1], dpid[3], &dwCount );
    checkHR( DP_OK, hr );
    check( 7, dwCount );
 
 
    /* Purge queues again */
    check_messages( pDP[0], dpid, 6, &callbackData );
    checkStr( "01,01,01,01,01,"
              "12,12,12,12,12,12,", callbackData.szTrace1 );
    check_messages( pDP[1], dpid, 6, &callbackData );
    checkStr( "23,23,23,23,23,23,23,", callbackData.szTrace1 );
 
 
    /* Check queues are purged */
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], 0, &dwCount );
    checkHR( DP_OK, hr );
    check( 0, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[1], 0, &dwCount );
    checkHR( DP_OK, hr );
    check( 0, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[0], &dwCount );
    checkHR( DP_OK, hr );
    check( 0, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[1], &dwCount );
    checkHR( DP_OK, hr );
    check( 0, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[0], dpid[2], &dwCount );
    checkHR( DP_OK, hr );
    check( 0, dwCount );
 
    dwCount = -1;
    hr = IDirectPlayX_GetMessageCount( pDP[1], dpid[3], &dwCount );
    checkHR( DP_OK, hr );
    check( 0, dwCount );
 
 
    free( lpData );
    IDirectPlayX_Release( pDP[0] );
    IDirectPlayX_Release( pDP[1] );
 
}

Referenced by START_TEST().

◆ test_GetMessageQueue()

static void test_GetMessageQueue ( void )

static

Definition at line 9549 of file dplayx.c.

{
    BYTE playerData[] = { 1, 2, 3, 4, 5, 6, 7, 8, };
    BYTE data[] = { 1, 2, 3, 4, };
    DPSESSIONDESC2 appGuidDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidApplication = appGuid,
        .guidInstance = appGuid,
    };
    DPSESSIONDESC2 serverDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidApplication = appGuid,
        .guidInstance = appGuid,
        .lpszSessionName = (WCHAR *) L"normal",
        .dwReserved1 = 0xaabbccdd,
    };
    DPNAME name =
    {
        .dwSize = sizeof( DPNAME ),
        .lpszShortNameA = (char *) "short name",
    };
    DWORD createPlayerMsgSize;
    CreatePlayerParam *param;
    IDirectPlay4 *dpA;
    IDirectPlay4 *dp;
    DWORD waitResult;
    SOCKET sendSock;
    SOCKET recvSock;
    DWORD byteCount;
    DWORD msgCount;
    HANDLE event;
    HRESULT hr;
    DPID dpid;
 
    event = CreateEventA( NULL, FALSE, FALSE, NULL );
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlay4A, (void **) &dpA );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    hr = IDirectPlayX_QueryInterface( dpA, &IID_IDirectPlay4, (void **) &dp );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
 
    msgCount = 0xdeadbeef;
    byteCount = 0xdeadbeef;
    hr = IDirectPlayX_GetMessageQueue( dpA, 0, 0, 0, &msgCount, &byteCount );
    ok( hr == DPERR_UNINITIALIZED, "got hr %#lx.\n", hr );
    ok( msgCount == 0xdeadbeef, "got message count %lu.\n", msgCount );
    ok( byteCount == 0xdeadbeef, "got byte count %lu.\n", byteCount );
 
    init_TCPIP_provider( dpA, "127.0.0.1", 0 );
 
    msgCount = 0xdeadbeef;
    byteCount = 0xdeadbeef;
    hr = IDirectPlayX_GetMessageQueue( dpA, 0, 0, DPMESSAGEQUEUE_SEND | DPMESSAGEQUEUE_RECEIVE, &msgCount, &byteCount );
    ok( hr == DPERR_INVALIDFLAGS, "got hr %#lx.\n", hr );
    ok( msgCount == 0xdeadbeef, "got message count %lu.\n", msgCount );
    ok( byteCount == 0xdeadbeef, "got byte count %lu.\n", byteCount );
 
    msgCount = 0xdeadbeef;
    byteCount = 0xdeadbeef;
    hr = IDirectPlayX_GetMessageQueue( dpA, 0, 0, 4, &msgCount, &byteCount );
    ok( hr == DPERR_INVALIDFLAGS, "got hr %#lx.\n", hr );
    ok( msgCount == 0xdeadbeef, "got message count %lu.\n", msgCount );
    ok( byteCount == 0xdeadbeef, "got byte count %lu.\n", byteCount );
 
    msgCount = 0xdeadbeef;
    byteCount = 0xdeadbeef;
    hr = IDirectPlayX_GetMessageQueue( dpA, 0x07734, 0, DPMESSAGEQUEUE_RECEIVE, &msgCount, &byteCount );
    ok( hr == DPERR_INVALIDPLAYER, "got hr %#lx.\n", hr );
    ok( msgCount == 0xdeadbeef, "got message count %lu.\n", msgCount );
    ok( byteCount == 0xdeadbeef, "got byte count %lu.\n", byteCount );
 
    msgCount = 0xdeadbeef;
    byteCount = 0xdeadbeef;
    hr = IDirectPlayX_GetMessageQueue( dpA, 0, 0x07734, DPMESSAGEQUEUE_RECEIVE, &msgCount, &byteCount );
    ok( hr == DPERR_INVALIDPLAYER, "got hr %#lx.\n", hr );
    ok( msgCount == 0xdeadbeef, "got message count %lu.\n", msgCount );
    ok( byteCount == 0xdeadbeef, "got byte count %lu.\n", byteCount );
 
    msgCount = 0xdeadbeef;
    byteCount = 0xdeadbeef;
    hr = IDirectPlayX_GetMessageQueue( dpA, 0, 0, DPMESSAGEQUEUE_RECEIVE, &msgCount, &byteCount );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    ok( msgCount == 0, "got message count %lu.\n", msgCount );
    ok( byteCount == 0, "got byte count %lu.\n", byteCount );
 
    joinSession( dpA, &appGuidDpsd, &serverDpsd, &sendSock, &recvSock, NULL );
 
    createPlayer( dpA, 0x07734, NULL, NULL, 0, 0, sendSock, recvSock );
 
    msgCount = 0xdeadbeef;
    byteCount = 0xdeadbeef;
    hr = IDirectPlayX_GetMessageQueue( dpA, 0x07734, 0, DPMESSAGEQUEUE_RECEIVE, &msgCount, &byteCount );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    ok( msgCount == 0, "got message count %lu.\n", msgCount );
    ok( byteCount == 0, "got byte count %lu.\n", byteCount );
 
    msgCount = 0xdeadbeef;
    byteCount = 0xdeadbeef;
    hr = IDirectPlayX_GetMessageQueue( dpA, 0, 0x07734, DPMESSAGEQUEUE_RECEIVE, &msgCount, &byteCount );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    ok( msgCount == 0, "got message count %lu.\n", msgCount );
    ok( byteCount == 0, "got byte count %lu.\n", byteCount );
 
    msgCount = 0xdeadbeef;
    byteCount = 0xdeadbeef;
    hr = IDirectPlayX_GetMessageQueue( dpA, 0x1337, 0, DPMESSAGEQUEUE_RECEIVE, &msgCount, &byteCount );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    ok( msgCount == 0, "got message count %lu.\n", msgCount );
    ok( byteCount == 0, "got byte count %lu.\n", byteCount );
 
    msgCount = 0xdeadbeef;
    byteCount = 0xdeadbeef;
    hr = IDirectPlayX_GetMessageQueue( dpA, 0, 0x1337, DPMESSAGEQUEUE_RECEIVE, &msgCount, &byteCount );
    ok( hr == DPERR_INVALIDPLAYER, "got hr %#lx.\n", hr );
    ok( msgCount == 0xdeadbeef, "got message count %lu.\n", msgCount );
    ok( byteCount == 0xdeadbeef, "got byte count %lu.\n", byteCount );
 
    msgCount = 0xdeadbeef;
    byteCount = 0xdeadbeef;
    hr = IDirectPlayX_GetMessageQueue( dpA, 0x5e7, 0, DPMESSAGEQUEUE_RECEIVE, &msgCount, &byteCount );
    ok( hr == DPERR_INVALIDPLAYER, "got hr %#lx.\n", hr );
    ok( msgCount == 0xdeadbeef, "got message count %lu.\n", msgCount );
    ok( byteCount == 0xdeadbeef, "got byte count %lu.\n", byteCount );
 
    msgCount = 0xdeadbeef;
    byteCount = 0xdeadbeef;
    hr = IDirectPlayX_GetMessageQueue( dpA, 0, 0x5e7, DPMESSAGEQUEUE_RECEIVE, &msgCount, &byteCount );
    ok( hr == DPERR_INVALIDPLAYER, "got hr %#lx.\n", hr );
    ok( msgCount == 0xdeadbeef, "got message count %lu.\n", msgCount );
    ok( byteCount == 0xdeadbeef, "got byte count %lu.\n", byteCount );
 
    dpid = 0xdeadbeef;
    param = createPlayerAsync( dpA, &dpid, &name, event, playerData, sizeof( playerData ), 0 );
    receiveRequestPlayerId( recvSock, DPPLAYER_LOCAL );
    sendRequestPlayerReply( sendSock, 2349, 0x14, DP_OK );
    receiveCreatePlayer( recvSock, 0x14, DPPLAYER_LOCAL, L"short name", NULL, playerData, sizeof( playerData ) );
    hr = createPlayerAsyncWait( param, 2000 );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    ok( dpid == 0x14, "got dpid %#lx.\n", dpid );
 
    sendGuaranteedGameMessage( sendSock, 2349, 0x1337, 0x14, data, sizeof( data ) );
 
    waitResult = WaitForSingleObject( event, 2000 );
    ok( waitResult == WAIT_OBJECT_0, "message wait returned %lu\n", waitResult );
 
    /* Both UNICODE and ANSI GetMessageQueue() return the same size. */
    createPlayerMsgSize = sizeof( DPMSG_CREATEPLAYERORGROUP ) + sizeof( playerData ) + sizeof( L"short name" );
 
    msgCount = 0xdeadbeef;
    byteCount = 0xdeadbeef;
    hr = IDirectPlayX_GetMessageQueue( dpA, 0, 0x07734, DPMESSAGEQUEUE_RECEIVE, &msgCount, &byteCount );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    ok( msgCount == 1, "got message count %lu.\n", msgCount );
    ok( byteCount == createPlayerMsgSize, "got byte count %lu.\n", byteCount );
 
    msgCount = 0xdeadbeef;
    byteCount = 0xdeadbeef;
    hr = IDirectPlayX_GetMessageQueue( dp, 0, 0x07734, DPMESSAGEQUEUE_RECEIVE, &msgCount, &byteCount );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    ok( msgCount == 1, "got message count %lu.\n", msgCount );
    ok( byteCount == createPlayerMsgSize, "got byte count %lu.\n", byteCount );
 
    msgCount = 0xdeadbeef;
    byteCount = 0xdeadbeef;
    hr = IDirectPlayX_GetMessageQueue( dpA, 0x1337, 0, DPMESSAGEQUEUE_RECEIVE, &msgCount, &byteCount );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    ok( msgCount == 1, "got message count %lu.\n", msgCount );
    ok( byteCount == sizeof( data ), "got byte count %lu.\n", byteCount );
 
    msgCount = 0xdeadbeef;
    byteCount = 0xdeadbeef;
    hr = IDirectPlayX_GetMessageQueue( dpA, 0, 0, DPMESSAGEQUEUE_RECEIVE, &msgCount, &byteCount );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    ok( msgCount == 2, "got message count %lu.\n", msgCount );
    ok( byteCount == createPlayerMsgSize + sizeof( data ), "got byte count %lu.\n", byteCount );
 
    closesocket( recvSock );
    closesocket( sendSock );
 
    IDirectPlayX_Release( dp );
    IDirectPlayX_Release( dpA );
 
    CloseHandle( event );
}

Referenced by START_TEST().

◆ test_GetPlayerAccount()

static void test_GetPlayerAccount ( void )

static

Definition at line 5994 of file dplayx.c.

{
 
    IDirectPlay4 *pDP[2];
    DPSESSIONDESC2 dpsd;
    DPID dpid[2];
    HRESULT hr;
    UINT i;
 
    DWORD dwDataSize = 1024;
    LPVOID lpData = calloc( 1, dwDataSize );
 
 
    for (i=0; i<2; i++)
    {
        hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                               &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
        ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
        if (FAILED(hr)) return;
    }
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    dpsd.dwMaxPlayers = 10;
 
    /* Uninitialized service provider */
    hr = IDirectPlayX_GetPlayerAccount( pDP[0], 0, 0, lpData, &dwDataSize );
    todo_wine checkHR( DPERR_UNINITIALIZED, hr );
 
    if ( hr == DP_OK )
    {
        todo_wine win_skip( "GetPlayerAccount not implemented\n" );
        return;
    }
 
 
    init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
    init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
 
 
    /* No session */
    hr = IDirectPlayX_GetPlayerAccount( pDP[0], 0, 0, lpData, &dwDataSize );
    checkHR( DPERR_NOSESSIONS, hr );
 
 
    IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
    IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
                               pDP[1], 0 );
 
    for (i=0; i<2; i++)
    {
        hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i], NULL, NULL, NULL,
                                        0, 0 );
        checkHR( DP_OK, hr );
    }
 
 
    /* Session is not secure */
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0,
                                        lpData, &dwDataSize );
    checkHR( DPERR_UNSUPPORTED, hr );
    check( 1024, dwDataSize );
 
 
    /* Open a secure session */
    for (i=0; i<2; i++)
    {
        hr = IDirectPlayX_Close( pDP[i] );
        checkHR( DP_OK, hr );
    }
 
    dpsd.dwFlags = DPSESSION_SECURESERVER;
    hr = IDirectPlayX_SecureOpen( pDP[0], &dpsd, DPOPEN_CREATE, NULL, NULL );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[0],
                                    NULL, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0,
                                    EnumSessions_cb_join_secure, pDP[1], 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid[1],
                                    NULL, NULL, NULL, 0, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    /* TODO: Player creation so that this works */
 
    /* Invalid player */
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerAccount( pDP[0], 0, 0,
                                        lpData, &dwDataSize );
    checkHR( DPERR_INVALIDPLAYER, hr );
    check( 1024, dwDataSize );
 
    /* Invalid flags */
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], -1,
                                        lpData, &dwDataSize );
    checkHR( DPERR_INVALIDFLAGS, hr );
    check( 1024, dwDataSize );
 
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 1,
                                        lpData, &dwDataSize );
    checkHR( DPERR_INVALIDFLAGS, hr );
    check( 1024, dwDataSize );
 
    /* Small buffer */
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0,
                                        NULL, &dwDataSize );
    checkHR( DPERR_INVALIDPLAYER, hr );
    check( 0, dwDataSize );
 
    dwDataSize = 0;
    hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0,
                                        lpData, &dwDataSize );
    checkHR( DPERR_INVALIDPLAYER, hr );
    check( 0, dwDataSize );
 
    hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0,
                                        lpData, &dwDataSize );
    checkHR( DPERR_INVALIDPLAYER, hr );
    check( 0, dwDataSize );
 
    /* Normal operation */
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerAccount( pDP[0], dpid[0], 0,
                                        lpData, &dwDataSize );
    checkHR( DPERR_INVALIDPLAYER, hr );
    check( 1024, dwDataSize );
 
 
    free( lpData );
    IDirectPlayX_Release( pDP[0] );
    IDirectPlayX_Release( pDP[1] );
 
}

Referenced by START_TEST().

◆ test_GetPlayerAddress()

static void test_GetPlayerAddress ( void )

static

Definition at line 6178 of file dplayx.c.

{
 
    IDirectPlay4 *pDP[2];
    IDirectPlayLobby3 *pDPL;
    DPSESSIONDESC2 dpsd;
    DPID dpid[2];
    CallbackData callbackData;
    HRESULT hr;
    UINT i;
 
    DWORD dwDataSize = 1024;
    LPVOID lpData = calloc( 1, dwDataSize );
 
 
    for (i=0; i<2; i++)
    {
        hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                               &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
        ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
        if (FAILED(hr)) return;
    }
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
    hr = CoCreateInstance( &CLSID_DirectPlayLobby, NULL, CLSCTX_ALL,
                           &IID_IDirectPlayLobby3A, (LPVOID*) &pDPL );
    ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlayLobby / IID_IDirectPlayLobby3A failed\n" );
    if (FAILED(hr)) return;
 
    /* Uninitialized service provider */
    hr = IDirectPlayX_GetPlayerAddress( pDP[0], 0, lpData, &dwDataSize );
    todo_wine checkHR( DPERR_UNINITIALIZED, hr );
 
    if ( hr == DP_OK )
    {
        todo_wine win_skip( "GetPlayerAddress not implemented\n" );
        goto cleanup;
    }
 
    init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
    init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
 
 
    /* No session */
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerAddress( pDP[0], 0, lpData, &dwDataSize );
    checkHR( DPERR_UNSUPPORTED, hr );
    check( 1024, dwDataSize );
 
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerAddress( pDP[0], 1, lpData, &dwDataSize );
    checkHR( DPERR_INVALIDPLAYER, hr );
    check( 1024, dwDataSize );
 
 
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    dpsd.dwMaxPlayers = 10;
    IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
    IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
                               pDP[1], 0 );
 
    for (i=0; i<2; i++)
    {
        hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i], NULL, NULL, NULL,
                                        0, 0 );
        checkHR( DP_OK, hr );
    }
 
    /* Invalid player */
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerAddress( pDP[0], 0,
                                        lpData, &dwDataSize );
    checkHR( DPERR_UNSUPPORTED, hr );
    check( 1024, dwDataSize );
 
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerAddress( pDP[0], 1,
                                        lpData, &dwDataSize );
    checkHR( DPERR_INVALIDPLAYER, hr );
    check( 1024, dwDataSize );
 
    /* Small buffer */
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[0],
                                        NULL, &dwDataSize );
    checkHR( DPERR_BUFFERTOOSMALL, hr );
    check( 136, dwDataSize );
 
    dwDataSize = 0;
    hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[0],
                                        lpData, &dwDataSize );
    checkHR( DPERR_BUFFERTOOSMALL, hr );
    check( 136, dwDataSize );
 
    hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[0],
                                        lpData, &dwDataSize );
    checkHR( DP_OK, hr );
    check( 136, dwDataSize );
 
 
    /* Regular parameters */
    callbackData.dwCounter1 = 0;
 
    /* - Local */
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[0],
                                        lpData, &dwDataSize );
    checkHR( DP_OK, hr );
    check( 136, dwDataSize );
 
    hr = IDirectPlayLobby_EnumAddress( pDPL, EnumAddress_cb, lpData, dwDataSize,
                                       &callbackData );
    checkHR( DP_OK, hr );
 
    check( 4, callbackData.dwCounter1 );
 
    /* - Remote */
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerAddress( pDP[0], dpid[1],
                                        lpData, &dwDataSize );
    checkHR( DP_OK, hr );
    check( 130, dwDataSize );
 
    hr = IDirectPlayLobby_EnumAddress( pDPL, EnumAddress_cb, lpData, dwDataSize,
                                       &callbackData );
    checkHR( DP_OK, hr );
 
    check( 8, callbackData.dwCounter1 );
 
 
    free( lpData );
 
cleanup:
    IDirectPlayX_Release( pDP[0] );
    IDirectPlayX_Release( pDP[1] );
    IDirectPlayLobby_Release(pDPL);
}

Referenced by START_TEST().

◆ test_GetPlayerCaps()

static void test_GetPlayerCaps ( void )

static

Definition at line 5282 of file dplayx.c.

{
 
    IDirectPlay4 *pDP[2];
    DPSESSIONDESC2 dpsd;
    DPID dpid[2];
    HRESULT hr;
    UINT i;
 
    DPCAPS playerCaps;
    DWORD dwFlags;
 
 
    for (i=0; i<2; i++)
    {
        hr= CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                              &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
        ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
        if (FAILED(hr)) return;
    }
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    dpsd.dwMaxPlayers = 10;
 
    ZeroMemory( &playerCaps, sizeof(DPCAPS) );
 
 
    /* Uninitialized service provider */
    playerCaps.dwSize = 0;
    hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 );
    checkHR( DPERR_UNINITIALIZED, hr );
 
    playerCaps.dwSize = sizeof(DPCAPS);
    hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 );
    checkHR( DPERR_UNINITIALIZED, hr );
 
 
    init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
    init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
 
 
    /* No session */
    playerCaps.dwSize = 0;
 
    hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 );
    todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
 
    if ( hr == DPERR_UNINITIALIZED )
    {
        todo_wine win_skip( "GetPlayerCaps not implemented\n" );
        return;
    }
 
    playerCaps.dwSize = sizeof(DPCAPS);
 
    hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 );
    checkHR( DPERR_INVALIDPLAYER, hr );
 
    hr = IDirectPlayX_GetPlayerCaps( pDP[0], 2, &playerCaps, 0 );
    checkHR( DPERR_INVALIDPLAYER, hr );
 
 
    hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
                                    pDP[1], 0 );
    checkHR( DP_OK, hr );
 
    for (i=0; i<2; i++)
    {
        hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i],
                                        NULL, NULL, NULL, 0, 0 );
        checkHR( DP_OK, hr );
    }
 
 
    /* Uninitialized playerCaps */
    playerCaps.dwSize = 0;
 
    hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    hr = IDirectPlayX_GetPlayerCaps( pDP[0], 2, &playerCaps, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    hr = IDirectPlayX_GetPlayerCaps( pDP[0], dpid[0], &playerCaps, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    /* Invalid player */
    playerCaps.dwSize = sizeof(DPCAPS);
 
    hr = IDirectPlayX_GetPlayerCaps( pDP[0], 0, &playerCaps, 0 );
    checkHR( DPERR_INVALIDPLAYER, hr );
 
    hr = IDirectPlayX_GetPlayerCaps( pDP[0], 2, &playerCaps, 0 );
    checkHR( DPERR_INVALIDPLAYER, hr );
 
    hr = IDirectPlayX_GetPlayerCaps( pDP[0], dpid[0], &playerCaps, 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_GetPlayerCaps( pDP[0], dpid[0], NULL, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    /* Regular parameters */
    for (i=0; i<2; i++)
    {
        for (dwFlags=0;
             dwFlags<=DPGETCAPS_GUARANTEED;
             dwFlags+=DPGETCAPS_GUARANTEED)
        {
 
            hr = IDirectPlayX_GetPlayerCaps( pDP[0], dpid[i],
                                             &playerCaps, dwFlags );
            checkHR( DP_OK, hr );
 
 
            check( sizeof(DPCAPS), playerCaps.dwSize );
            check( 40,    playerCaps.dwSize );
            check( 0,     playerCaps.dwMaxQueueSize );
            check( 0,     playerCaps.dwHundredBaud );
            check( 0,     playerCaps.dwLatency );
            check( 65536, playerCaps.dwMaxLocalPlayers );
            check( 20,    playerCaps.dwHeaderLength );
 
            if ( i == 0 )
            {
                checkFlags( DPCAPS_ISHOST |
                            DPCAPS_GUARANTEEDOPTIMIZED |
                            DPCAPS_GUARANTEEDSUPPORTED |
                            DPCAPS_ASYNCSUPPORTED |
                            DPPLAYERCAPS_LOCAL,
                            playerCaps.dwFlags, FLAGS_DPCAPS );
            }
            else
                checkFlags( DPCAPS_ISHOST |
                            DPCAPS_GUARANTEEDOPTIMIZED |
                            DPCAPS_GUARANTEEDSUPPORTED |
                            DPCAPS_ASYNCSUPPORTED,
                            playerCaps.dwFlags, FLAGS_DPCAPS );
 
            if ( dwFlags == DPGETCAPS_GUARANTEED )
            {
                check( 1048547, playerCaps.dwMaxBufferSize );
                check( 64,      playerCaps.dwMaxPlayers );
            }
            else
            {
                check( 65479, playerCaps.dwMaxBufferSize );
                check( 65536, playerCaps.dwMaxPlayers );
            }
 
        }
    }
 
 
    IDirectPlayX_Release( pDP[0] );
    IDirectPlayX_Release( pDP[1] );
 
}

Referenced by START_TEST().

◆ test_GetPlayerFlags()

static void test_GetPlayerFlags ( void )

static

Definition at line 6318 of file dplayx.c.

{
 
    IDirectPlay4 *pDP[2];
    DPSESSIONDESC2 dpsd;
    DPID dpid[4];
    HRESULT hr;
    UINT i;
 
    DWORD dwFlags = 0;
 
 
    for (i=0; i<2; i++)
    {
        hr= CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                              &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
        ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
        if (FAILED(hr)) return;
    }
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    dpsd.dwMaxPlayers = 10;
 
    /* Uninitialized service provider */
    hr = IDirectPlayX_GetPlayerFlags( pDP[0], 0, &dwFlags );
    todo_wine checkHR( DPERR_UNINITIALIZED, hr );
 
    if ( hr == DP_OK )
    {
        todo_wine win_skip( "GetPlayerFlags not implemented\n" );
        return;
    }
 
    init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
    init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
 
 
    /* No session */
    hr = IDirectPlayX_GetPlayerFlags( pDP[0], 0, &dwFlags );
    checkHR( DPERR_INVALIDPLAYER, hr );
 
    hr = IDirectPlayX_GetPlayerFlags( pDP[0], 1, &dwFlags );
    checkHR( DPERR_INVALIDPLAYER, hr );
 
 
    IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
    IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
                               pDP[1], 0 );
 
    for (i=0; i<2; i++)
    {
        hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i],
                                        NULL, NULL, NULL, 0, 0 );
        checkHR( DP_OK, hr );
    }
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[2],
                                    NULL, NULL, NULL,
                                    0, DPPLAYER_SPECTATOR );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[3],
                                    NULL, NULL, NULL,
                                    0, DPPLAYER_SERVERPLAYER );
    checkHR( DP_OK, hr );
 
 
    /* Invalid player */
    hr = IDirectPlayX_GetPlayerFlags( pDP[0], 0, &dwFlags );
    checkHR( DPERR_INVALIDPLAYER, hr );
 
    hr = IDirectPlayX_GetPlayerFlags( pDP[0], 2, &dwFlags );
    checkHR( DPERR_INVALIDPLAYER, hr );
 
    /* Invalid parameters */
    hr = IDirectPlayX_GetPlayerFlags( pDP[0], dpid[0], NULL );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
 
    /* Regular parameters */
    hr = IDirectPlayX_GetPlayerFlags( pDP[0], dpid[0], &dwFlags );
    checkHR( DP_OK, hr );
    checkFlags( dwFlags, DPPLAYER_LOCAL, FLAGS_DPPLAYER );
 
    hr = IDirectPlayX_GetPlayerFlags( pDP[1], dpid[1], &dwFlags );
    checkHR( DP_OK, hr );
    checkFlags( dwFlags, DPPLAYER_LOCAL, FLAGS_DPPLAYER );
 
    hr = IDirectPlayX_GetPlayerFlags( pDP[0], dpid[1], &dwFlags );
    checkHR( DP_OK, hr );
    checkFlags( dwFlags, 0, FLAGS_DPPLAYER );
 
    hr = IDirectPlayX_GetPlayerFlags( pDP[0], dpid[2], &dwFlags );
    checkHR( DP_OK, hr );
    checkFlags( dwFlags, DPPLAYER_SPECTATOR | DPPLAYER_LOCAL, FLAGS_DPPLAYER );
 
    hr = IDirectPlayX_GetPlayerFlags( pDP[1], dpid[3], &dwFlags );
    checkHR( DP_OK, hr );
    checkFlags( dwFlags, DPPLAYER_SERVERPLAYER, FLAGS_DPPLAYER );
 
 
    IDirectPlayX_Release( pDP[0] );
    IDirectPlayX_Release( pDP[1] );
 
}

Referenced by START_TEST().

◆ test_GROUPDATACHANGED()

static void test_GROUPDATACHANGED ( void )

static

Definition at line 9260 of file dplayx.c.

{
    BYTE expectedGroupData[] = { 8, 7, 6, 5, 4, 3, 2, 1, };
    DPSESSIONDESC2 appGuidDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidInstance = appGuid,
        .guidApplication = appGuid,
    };
    DPSESSIONDESC2 serverDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidApplication = appGuid,
        .guidInstance = appGuid,
        .lpszSessionName = (WCHAR *) L"normal",
        .dwReserved1 = 0xaabbccdd,
    };
    BYTE groupData[ 256 ];
    DWORD groupDataSize;
    IDirectPlay4A *dp;
    DWORD waitResult;
    SOCKET sendSock;
    SOCKET recvSock;
    HANDLE event;
    HRESULT hr;
    DPID dpid;
 
    event = CreateEventA( NULL, FALSE, FALSE, NULL );
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlay4A, (void **) &dp );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
 
    init_TCPIP_provider( dp, "127.0.0.1", 0 );
 
    joinSession( dp, &appGuidDpsd, &serverDpsd, &sendSock, &recvSock, NULL );
 
    createPlayer( dp, 0x11223344, event, NULL, 0, 0, sendSock, recvSock );
 
    sendGroupDataChanged( sendSock, 2349, 0x5e7, expectedGroupData, sizeof( expectedGroupData ) );
 
    waitResult = WaitForSingleObject( event, 2000 );
    ok( waitResult == WAIT_OBJECT_0, "message wait returned %lu\n", waitResult );
 
    dpid = checkSetPlayerOrGroupDataMessage( dp, DPPLAYERTYPE_GROUP, 0x5e7, expectedGroupData,
                                             sizeof( expectedGroupData ) );
    ok( dpid == 0x11223344, "got destination id %#lx.\n", dpid );
 
    memset( groupData, 0xcc, sizeof( groupData ) );
    groupDataSize = sizeof( groupData );
    hr = IDirectPlayX_GetGroupData( dp, 0x5e7, groupData, &groupDataSize, DPGET_REMOTE );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    ok( groupDataSize == sizeof( expectedGroupData ), "got group data size %lu.\n", groupDataSize );
    ok( !memcmp( groupData, expectedGroupData, sizeof( expectedGroupData ) ), "group data didn't match.\n" );
 
    checkNoMorePlayerMessages( dp );
 
    closesocket( recvSock );
    closesocket( sendSock );
 
    IDirectPlayX_Release( dp );
 
    CloseHandle( event );
}

Referenced by START_TEST().

◆ test_GroupOwner()

static void test_GroupOwner ( void )

static

Definition at line 6733 of file dplayx.c.

{
 
    IDirectPlay4 *pDP[2];
    DPSESSIONDESC2 dpsd;
    DPID dpid[2], idGroup, idOwner;
    HRESULT hr;
    UINT i;
 
 
    for (i=0; i<2; i++)
    {
        hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                               &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
        ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
        if (FAILED(hr)) return;
    }
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    dpsd.dwMaxPlayers = 10;
    idGroup = 0;
    idOwner = 0;
 
    /* Service provider not initialized */
    hr = IDirectPlayX_GetGroupOwner( pDP[0], idGroup, &idOwner );
    todo_wine checkHR( DPERR_UNINITIALIZED, hr );
    check( 0, idOwner );
 
    if ( hr == DP_OK )
    {
        todo_wine win_skip( "GetGroupOwner not implemented\n" );
        return;
    }
 
 
    for (i=0; i<2; i++)
        init_TCPIP_provider( pDP[i], "127.0.0.1", 0 );
 
    hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
                                    pDP[1], 0 );
    checkHR( DP_OK, hr );
 
    for (i=0; i<2; i++)
    {
        hr = IDirectPlayX_CreatePlayer( pDP[i], &dpid[i],
                                        NULL, NULL, NULL, 0, 0 );
        checkHR( DP_OK, hr );
    }
 
    /* Invalid group */
    hr = IDirectPlayX_GetGroupOwner( pDP[0], idGroup, &idOwner );
    checkHR( DPERR_INVALIDGROUP, hr );
 
    hr = IDirectPlayX_CreateGroup( pDP[0], &idGroup, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
    /* Fails, because we need a lobby session */
    hr = IDirectPlayX_GetGroupOwner( pDP[0], idGroup, &idOwner );
    checkHR( DPERR_UNSUPPORTED, hr );
 
 
    /* TODO:
     * - Make this work
     * - Check migration of the ownership of a group
     *   when the owner leaves
     */
 
 
    IDirectPlayX_Release( pDP[0] );
    IDirectPlayX_Release( pDP[1] );
 
}

Referenced by START_TEST().

◆ test_groups_cs()

static void test_groups_cs ( void )

static

Definition at line 7921 of file dplayx.c.

{
 
    IDirectPlay4 *pDP[2];
    DPSESSIONDESC2 dpsd;
    DPID idPlayer[6], idGroup[3];
    CallbackData callbackData;
    HRESULT hr;
    UINT i;
 
    DWORD dwDataSize = 1024;
    LPVOID lpData = calloc( 1, 1024 );
 
 
    for (i=0; i<2; i++)
    {
        hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                               &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
        ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
        if (FAILED(hr)) return;
    }
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    dpsd.dwMaxPlayers = 10;
 
 
    init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
    init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
 
    dpsd.dwFlags = DPSESSION_CLIENTSERVER;
    hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
    todo_wine checkHR( DP_OK, hr );
    dpsd.dwFlags = 0;
    hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
                                    pDP[1], 0 );
    todo_wine checkHR( DP_OK, hr );
 
    if ( hr == DPERR_UNINITIALIZED )
    {
        todo_wine win_skip( "dplay not implemented enough for this test yet\n" );
        return;
    }
 
 
    /* Create players */
    hr = IDirectPlayX_CreatePlayer( pDP[0], &idPlayer[0],
                                    NULL, NULL, NULL, 0, 0 );
    checkHR( DPERR_ACCESSDENIED, hr );
    hr = IDirectPlayX_CreatePlayer( pDP[0], &idPlayer[0],
                                    NULL, NULL, NULL, 0,
                                    DPPLAYER_SERVERPLAYER );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreatePlayer( pDP[0], &idPlayer[1],
                                    NULL, NULL, NULL, 0, 0 );
    checkHR( DPERR_ACCESSDENIED, hr );
    hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[1],
                                    NULL, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[2],
                                    NULL, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[3],
                                    NULL, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[4],
                                    NULL, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[5],
                                    NULL, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreateGroup( pDP[0], &idGroup[0],
                                   NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreateGroup( pDP[1], &idGroup[2],
                                   NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreateGroupInGroup( pDP[1], idGroup[2], &idGroup[1],
                                          NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
 
    /* Purge queues */
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "S0,S0,S0,S0,S0,S0,", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "S1," "S2,S1," "S3,S2,S1," "S4,S3,S2,S1,"
              "S5,S4,S3,S2,S1," "S5,S4,S3,S2,S1,", callbackData.szTrace1 );
 
    /*
     * Player 0   |                  | pDP 0
     * Player 1   | Group 0           |
     * Player 2   |                   |
     * Player 3  | Group 1 )          |
     * Player 4  |         | Group 2  | pDP 1
     * Player 5            |          |
     */
 
    /* Build groups */
    hr = IDirectPlayX_AddPlayerToGroup( pDP[0], idGroup[0], idPlayer[0] );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_AddPlayerToGroup( pDP[0], idGroup[0], idPlayer[1] );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_AddPlayerToGroup( pDP[0], idGroup[0], idPlayer[2] );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[1], idPlayer[3] );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[1], idPlayer[4] );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[2], idPlayer[4] );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[2], idPlayer[5] );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_AddGroupToGroup( pDP[1], idGroup[2], idGroup[1] );
    checkHR( DP_OK, hr );
 
    /* Purge queues */
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "S0,S0,S0,S0,", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "S5," "S4,S3,S2,S1," "S5,S4,S3,S2,S1,"
              "S5,S4,S3,S2,S1," "S5,S4,S3,S2,S1,", callbackData.szTrace1 );
 
 
    /* Sending broadcast messages, and checking who receives them */
    dwDataSize = 4;
    /* 0 -> * */
    hr = IDirectPlayX_Send( pDP[0], idPlayer[0], DPID_ALLPLAYERS, 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "05,04,03,02,01,", callbackData.szTrace1 );
 
    /* 0 -> g0 */
    hr = IDirectPlayX_Send( pDP[0], idPlayer[0], idGroup[0], 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "02,01,", callbackData.szTrace1 );
    /* 0 -> g1 */
    hr = IDirectPlayX_Send( pDP[0], idPlayer[0], idGroup[1], 0,
                            lpData, dwDataSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    /* 0 -> g2 */
    hr = IDirectPlayX_Send( pDP[0], idPlayer[0], idGroup[2], 0,
                            lpData, dwDataSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
 
    /* 3 -> * */
    hr = IDirectPlayX_Send( pDP[1], idPlayer[3], DPID_ALLPLAYERS, 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "30,", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "35,34,32,31,", callbackData.szTrace1 );
    /* 3 -> g0 */
    hr = IDirectPlayX_Send( pDP[1], idPlayer[3], idGroup[0], 0,
                            lpData, dwDataSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    /* 3 -> g1 */
    hr = IDirectPlayX_Send( pDP[1], idPlayer[3], idGroup[1], 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "34,", callbackData.szTrace1 );
    /* 3 -> g2 */
    hr = IDirectPlayX_Send( pDP[1], idPlayer[3], idGroup[2], 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "35,34,", callbackData.szTrace1 );
 
    /* 5 -> * */
    hr = IDirectPlayX_Send( pDP[1], idPlayer[5], DPID_ALLPLAYERS, 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "50,", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "54,53,52,51,", callbackData.szTrace1 );
    /* 5 -> g0 */
    hr = IDirectPlayX_Send( pDP[1], idPlayer[5], idGroup[0], 0,
                            lpData, dwDataSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    /* 5 -> g1 */
    hr = IDirectPlayX_Send( pDP[1], idPlayer[5], idGroup[1], 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "54,53,", callbackData.szTrace1 );
    /* 5 -> g2 */
    hr = IDirectPlayX_Send( pDP[1], idPlayer[5], idGroup[2], 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "54,", callbackData.szTrace1 );
 
 
    free( lpData );
    IDirectPlayX_Release( pDP[0] );
    IDirectPlayX_Release( pDP[1] );
 
}

Referenced by START_TEST().

◆ test_groups_p2p()

static void test_groups_p2p ( void )

static

Definition at line 7686 of file dplayx.c.

{
 
    IDirectPlay4 *pDP[2];
    DPSESSIONDESC2 dpsd;
    DPID idPlayer[6], idGroup[3];
    HRESULT hr;
    UINT i;
 
    DWORD dwDataSize = 1024;
    LPVOID lpData = calloc( 1, 1024 );
    CallbackData callbackData;
 
 
    for (i=0; i<2; i++)
    {
        hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                               &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
        ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
        if (FAILED(hr)) return;
    }
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    dpsd.dwMaxPlayers = 10;
 
 
    init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
    init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
 
    hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
    todo_wine checkHR( DP_OK, hr );
    hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
                                    pDP[1], 0 );
    todo_wine checkHR( DP_OK, hr );
 
    if ( hr == DPERR_UNINITIALIZED )
    {
        todo_wine win_skip( "dplay not implemented enough for this test yet\n" );
        return;
    }
 
 
    /* Create players */
    hr = IDirectPlayX_CreatePlayer( pDP[0], &idPlayer[0],
                                    NULL, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreatePlayer( pDP[0], &idPlayer[1],
                                    NULL, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreatePlayer( pDP[0], &idPlayer[2],
                                    NULL, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[3],
                                    NULL, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[4],
                                    NULL, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreatePlayer( pDP[1], &idPlayer[5],
                                    NULL, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreateGroup( pDP[0], &idGroup[0],
                                   NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreateGroup( pDP[1], &idGroup[2],
                                   NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_CreateGroupInGroup( pDP[1], idGroup[2], &idGroup[1],
                                          NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
 
    /* Purge queues */
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "S0," "S1,S0,"
              "S2,S1,S0," "S2,S1,S0,"
              "S2,S1,S0," "S2,S1,S0,"
              "S2,S1,S0," "S2,S1,S0,", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "S3," "S4,S3,"
              "S5,S4,S3," "S5,S4,S3,"
              "S5,S4,S3,", callbackData.szTrace1 );
 
 
    /*
     * Player 0   |                  |
     * Player 1   | Group 0          | pDP 0
     * Player 2   |                  |
     * Player 3  | Group 1 )          |
     * Player 4  |         | Group 2  | pDP 1
     * Player 5            |          |
     */
 
    /* Build groups */
    hr = IDirectPlayX_AddPlayerToGroup( pDP[0], idGroup[0], idPlayer[0] );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_AddPlayerToGroup( pDP[0], idGroup[0], idPlayer[1] );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_AddPlayerToGroup( pDP[0], idGroup[0], idPlayer[2] );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[1], idPlayer[3] );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[1], idPlayer[4] );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[2], idPlayer[4] );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_AddPlayerToGroup( pDP[1], idGroup[2], idPlayer[5] );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_AddGroupToGroup( pDP[1], idGroup[2], idGroup[1] );
    checkHR( DP_OK, hr );
 
    /* Purge queues */
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "S2,S1,S0," "S2,S1,S0," "S2,S1,S0,"
              "S2,S1,S0," "S2,S1,S0," "S2,S1,S0,"
              "S2,S1,S0,", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "S5,S4,S3," "S5,S4,S3," "S5,S4,S3,"
              "S5,S4,S3," "S5,S4,S3," "S5,S4,S3,"
              "S5,S4,S3,", callbackData.szTrace1 );
 
 
    /* Sending broadcast messages, and checking who receives them */
 
    dwDataSize = 4;
    /* 0 -> * */
    hr = IDirectPlayX_Send( pDP[0], idPlayer[0], DPID_ALLPLAYERS, 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "02,01,", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "05,04,03,", callbackData.szTrace1 );
 
    /* 0 -> g0 */
    hr = IDirectPlayX_Send( pDP[0], idPlayer[0], idGroup[0], 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "02,01,", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    /* 0 -> g1 */
    hr = IDirectPlayX_Send( pDP[0], idPlayer[0], idGroup[1], 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "04,03,", callbackData.szTrace1 );
    /* 0 -> g2 */
    hr = IDirectPlayX_Send( pDP[0], idPlayer[0], idGroup[2], 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "05,04,", callbackData.szTrace1 );
 
    /* 3 -> * */
    hr = IDirectPlayX_Send( pDP[1], idPlayer[3], DPID_ALLPLAYERS, 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "32,31,30,", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "35,34,", callbackData.szTrace1 );
    /* 3 -> g0 */
    hr = IDirectPlayX_Send( pDP[1], idPlayer[3], idGroup[0], 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "32,31,30,", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    /* 3 -> g1 */
    hr = IDirectPlayX_Send( pDP[1], idPlayer[3], idGroup[1], 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "34,", callbackData.szTrace1 );
    /* 3 -> g2 */
    hr = IDirectPlayX_Send( pDP[1], idPlayer[3], idGroup[2], 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "35,34,", callbackData.szTrace1 );
 
    /* 5 -> * */
    hr = IDirectPlayX_Send( pDP[1], idPlayer[5], DPID_ALLPLAYERS, 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "52,51,50,", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "54,53,", callbackData.szTrace1 );
    /* 5 -> g0 */
    hr = IDirectPlayX_Send( pDP[1], idPlayer[5], idGroup[0], 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "52,51,50,", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    /* 5 -> g1 */
    hr = IDirectPlayX_Send( pDP[1], idPlayer[5], idGroup[1], 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "54,53,", callbackData.szTrace1 );
    /* 5 -> g2 */
    hr = IDirectPlayX_Send( pDP[1], idPlayer[5], idGroup[2], 0,
                            lpData, dwDataSize );
    checkHR( DP_OK, hr );
    check_messages( pDP[0], idPlayer, 6, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], idPlayer, 6, &callbackData );
    checkStr( "54,", callbackData.szTrace1 );
 
 
    free( lpData );
    IDirectPlayX_Release( pDP[0] );
    IDirectPlayX_Release( pDP[1] );
 
}

Referenced by START_TEST().

◆ test_host_migration()

static void test_host_migration ( void )

static

Definition at line 10275 of file dplayx.c.

{
 
    IDirectPlay4 *pDP[2];
    DPSESSIONDESC2 dpsd;
    DPID dpid[2], idFrom, idTo;
    HRESULT hr;
    UINT i;
    DWORD dwCount;
 
    DWORD dwDataSize = 1024;
    LPDPMSG_DESTROYPLAYERORGROUP lpData = calloc( 1, dwDataSize );
 
 
    for (i=0; i<2; i++)
    {
        hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                               &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
        ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
        if (FAILED(hr)) return;
        init_TCPIP_provider( pDP[i], "127.0.0.1", 0 );
    }
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    dpsd.dwMaxPlayers = 10;
    dpsd.dwFlags = DPSESSION_MIGRATEHOST;
 
    /* Host */
    hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
    todo_wine checkHR( DP_OK, hr );
 
    if ( hr != DP_OK )
    {
        todo_wine win_skip( "dplay not implemented enough for this test yet\n" );
        return;
    }
 
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
    /* Peer */
    hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
                                    pDP[1], 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid[1], NULL, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
 
    /* Host: One message in queue */
    IDirectPlayX_GetMessageCount( pDP[0], dpid[0], &dwCount );
    check( 1, dwCount );
    dwDataSize = 1024;
    hr = IDirectPlayX_Receive( pDP[0], &idFrom, &idTo, DPRECEIVE_PEEK,
                               lpData, &dwDataSize );
    checkHR( DP_OK, hr );
    checkConv( DPSYS_CREATEPLAYERORGROUP, lpData->dwType, dpMsgType2str );
 
    /* Peer: No messages */
    IDirectPlayX_GetMessageCount( pDP[1], dpid[1], &dwCount );
    check( 0, dwCount );
    hr = IDirectPlayX_Receive( pDP[1], &idFrom, &idTo, DPRECEIVE_PEEK,
                               lpData, &dwDataSize );
    checkHR( DPERR_NOMESSAGES, hr );
 
 
    /* Closing host */
    IDirectPlayX_Close( pDP[0] );
 
 
    /* Host: Queue is cleaned */
    IDirectPlayX_GetMessageCount( pDP[0], dpid[0], &dwCount );
    check( 0, dwCount );
    hr = IDirectPlayX_Receive( pDP[0], &idFrom, &idTo, DPRECEIVE_PEEK,
                               lpData, &dwDataSize );
    checkHR( DPERR_NOMESSAGES, hr );
 
    /* Peer: gets message of player destruction */
    IDirectPlayX_GetMessageCount( pDP[1], dpid[1], &dwCount );
    check( 2, dwCount );
    dwDataSize = 1024;
    hr = IDirectPlayX_Receive( pDP[1], &idFrom, &idTo, DPRECEIVE_PEEK,
                               lpData, &dwDataSize );
    checkHR( DP_OK, hr );
    checkConv( DPSYS_DESTROYPLAYERORGROUP, lpData->dwType, dpMsgType2str );
 
 
    /* Message analysis */
    for (i=0; i<2; i++)
    {
        hr = IDirectPlayX_Receive( pDP[1], &idFrom, &idTo, 0,
                                   lpData, &dwDataSize );
        checkHR( DP_OK, hr );
        check( DPID_SYSMSG, idFrom );
        check( dpid[1], idTo ); /* Peer player id */
        switch(i)
        {
        case 0:
            checkConv( DPSYS_DESTROYPLAYERORGROUP, lpData->dwType,
                       dpMsgType2str );
            check( DPPLAYERTYPE_PLAYER, lpData->dwPlayerType );
            check( dpid[0],             lpData->dpId ); /* Host player id */
            checkLP( NULL,              lpData->lpLocalData );
            check( 0,                   lpData->dwLocalDataSize );
            checkLP( NULL,              lpData->lpRemoteData );
            check( 0,                   lpData->dwRemoteDataSize );
            checkLP( NULL,              lpData->dpnName.lpszShortNameA );
            check( 0,                   lpData->dpIdParent );
            checkFlags( 0,              lpData->dwFlags,
                        FLAGS_DPPLAYER | FLAGS_DPGROUP );
            break;
        case 1:
            checkConv( DPSYS_HOST, lpData->dwType, dpMsgType2str );
            break;
        default:
            break;
        }
        dwDataSize = 1024;
    }
    hr = IDirectPlayX_Receive( pDP[1], &idFrom, &idTo, 0, lpData, &dwDataSize );
    checkHR( DPERR_NOMESSAGES, hr );
 
 
    free( lpData );
    IDirectPlayX_Release( pDP[0] );
    IDirectPlayX_Release( pDP[1] );
 
}

Referenced by START_TEST().

◆ test_InitializeConnection()

static void test_InitializeConnection ( void )

static

Definition at line 2685 of file dplayx.c.

{
 
    IDirectPlay4 *pDP;
    HRESULT hr;
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                           &IID_IDirectPlay4A, (LPVOID*) &pDP );
 
    ok (SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n");
    if (FAILED(hr)) return;
 
    IDirectPlayX_EnumConnections( pDP, &appGuid, EnumConnections_cb2, pDP, 0 );
 
    IDirectPlayX_Release( pDP );
}

Referenced by START_TEST().

◆ test_interactive_CreatePlayer()

static void test_interactive_CreatePlayer ( void )

static

Definition at line 5027 of file dplayx.c.

{
 
    IDirectPlay4 *pDP[2];
    DPSESSIONDESC2 dpsd;
    DPNAME name;
    DPID dpid;
    HRESULT hr;
 
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                           &IID_IDirectPlay4A, (LPVOID*) &pDP[0] );
    ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
    if (FAILED(hr)) return;
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                           &IID_IDirectPlay4A, (LPVOID*) &pDP[1] );
    ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
    if (FAILED(hr)) return;
 
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
    ZeroMemory( &name, sizeof(DPNAME) );
 
 
    /* Connection not initialized */
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 0, 0 );
    checkHR( DPERR_UNINITIALIZED, hr );
 
 
    init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
    init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
 
 
    /* Session not open */
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 0, 0 );
    todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
 
    if ( hr == DPERR_UNINITIALIZED )
    {
        todo_wine win_skip( "CreatePlayer not implemented\n" );
        return;
    }
 
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
 
 
    /* Player name */
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
 
    name.dwSize = -1;
 
 
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, &name, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
 
    name.dwSize = sizeof(DPNAME);
    name.lpszShortNameA = (LPSTR) "test";
    name.lpszLongNameA = NULL;
 
 
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, &name, NULL, NULL,
                                    0, 0 );
    checkHR( DP_OK, hr );
 
 
    /* Null dpid */
    hr = IDirectPlayX_CreatePlayer( pDP[0], NULL, NULL, NULL, NULL,
                                    0, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
 
    /* There can only be one server player */
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
                                    0, DPPLAYER_SERVERPLAYER );
    checkHR( DP_OK, hr );
    check( DPID_SERVERPLAYER, dpid );
 
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
                                    0, DPPLAYER_SERVERPLAYER );
    checkHR( DPERR_CANTCREATEPLAYER, hr );
 
    IDirectPlayX_DestroyPlayer( pDP[0], dpid );
 
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
                                    0, DPPLAYER_SERVERPLAYER );
    checkHR( DP_OK, hr );
    check( DPID_SERVERPLAYER, dpid );
    IDirectPlayX_DestroyPlayer( pDP[0], dpid );
 
 
    /* Flags */
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
                                    0, 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
                                    0, DPPLAYER_SERVERPLAYER );
    checkHR( DP_OK, hr );
    check( DPID_SERVERPLAYER, dpid );
    IDirectPlayX_DestroyPlayer( pDP[0], dpid );
 
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
                                    0, DPPLAYER_SPECTATOR );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
                                    0, ( DPPLAYER_SERVERPLAYER |
                                         DPPLAYER_SPECTATOR ) );
    checkHR( DP_OK, hr );
    check( DPID_SERVERPLAYER, dpid );
    IDirectPlayX_DestroyPlayer( pDP[0], dpid );
 
 
    /* Session with DPSESSION_NEWPLAYERSDISABLED */
    IDirectPlayX_Close( pDP[0] );
    dpsd.dwFlags = DPSESSION_NEWPLAYERSDISABLED;
    hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
    checkHR( DP_OK, hr );
 
 
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
                                    0, 0 );
    checkHR( DPERR_CANTCREATEPLAYER, hr );
 
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
                                    0, DPPLAYER_SERVERPLAYER );
    checkHR( DPERR_CANTCREATEPLAYER, hr );
 
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
                                    0, DPPLAYER_SPECTATOR );
    checkHR( DPERR_CANTCREATEPLAYER, hr );
 
 
    /* Creating players in a Client/Server session */
    IDirectPlayX_Close( pDP[0] );
    dpsd.dwFlags = DPSESSION_CLIENTSERVER;
    hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
                                    pDP[1], 0 );
    checkHR( DP_OK, hr );
 
 
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
                                    0, 0 );
    checkHR( DPERR_ACCESSDENIED, hr );
 
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid, NULL, NULL, NULL,
                                    0, DPPLAYER_SERVERPLAYER );
    checkHR( DP_OK, hr );
    check( DPID_SERVERPLAYER, dpid );
 
    hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid, NULL, NULL, NULL,
                                    0, DPPLAYER_SERVERPLAYER );
    checkHR( DPERR_INVALIDFLAGS, hr );
 
    hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid, NULL, NULL, NULL,
                                    0, 0 );
    checkHR( DP_OK, hr );
 
 
    IDirectPlayX_Release( pDP[0] );
    IDirectPlayX_Release( pDP[1] );
 
}

Referenced by START_TEST().

◆ test_interactive_EnumSessions()

static void test_interactive_EnumSessions ( void )

static

Definition at line 4154 of file dplayx.c.

{
 
#define N_SESSIONS 6
 
    IDirectPlay4 *pDP, *pDPserver[N_SESSIONS];
    DPSESSIONDESC2 dpsd, dpsd_server[N_SESSIONS];
    CallbackData callbackData;
    HRESULT hr;
    UINT i;
 
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                           &IID_IDirectPlay4A, (LPVOID*) &pDP );
    ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
    if (FAILED(hr)) return;
 
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
    callbackData.dwCounter1 = -1; /* So that after a call to EnumSessions
                                     we get the exact number of sessions */
    callbackData.dwFlags = 0;
 
 
    /* Service provider not initialized */
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, 0 );
    checkHR( DPERR_UNINITIALIZED, hr );
 
 
    init_TCPIP_provider( pDP, "127.0.0.1", 0 );
 
 
    /* Session with no size */
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, 0 );
    todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
 
    if ( hr == DPERR_UNINITIALIZED )
    {
        todo_wine win_skip( "EnumSessions not implemented\n" );
        return;
    }
 
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
 
 
    /* No sessions */
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, 0 );
    checkHR( DP_OK, hr );
    check( 0, callbackData.dwCounter1 );
 
 
    dpsd.guidApplication = appGuid;
 
    /* Set up sessions */
    for (i=0; i<N_SESSIONS; i++)
    {
        memcpy( &dpsd_server[i], &dpsd, sizeof(DPSESSIONDESC2) );
    }
 
    dpsd_server[0].lpszSessionNameA = (LPSTR) "normal";
    dpsd_server[0].dwFlags = ( DPSESSION_CLIENTSERVER |
                               DPSESSION_DIRECTPLAYPROTOCOL );
    dpsd_server[0].dwMaxPlayers = 10;
 
    dpsd_server[1].lpszSessionNameA = (LPSTR) "full";
    dpsd_server[1].dwFlags = ( DPSESSION_CLIENTSERVER |
                               DPSESSION_DIRECTPLAYPROTOCOL );
    dpsd_server[1].dwMaxPlayers = 1;
 
    dpsd_server[2].lpszSessionNameA = (LPSTR) "no new";
    dpsd_server[2].dwFlags = ( DPSESSION_CLIENTSERVER |
                               DPSESSION_DIRECTPLAYPROTOCOL |
                               DPSESSION_NEWPLAYERSDISABLED );
    dpsd_server[2].dwMaxPlayers = 10;
 
    dpsd_server[3].lpszSessionNameA = (LPSTR) "no join";
    dpsd_server[3].dwFlags = ( DPSESSION_CLIENTSERVER |
                               DPSESSION_DIRECTPLAYPROTOCOL |
                               DPSESSION_JOINDISABLED );
    dpsd_server[3].dwMaxPlayers = 10;
 
    dpsd_server[4].lpszSessionNameA = (LPSTR) "private";
    dpsd_server[4].dwFlags = ( DPSESSION_CLIENTSERVER |
                               DPSESSION_DIRECTPLAYPROTOCOL |
                               DPSESSION_PRIVATE );
    dpsd_server[4].dwMaxPlayers = 10;
    dpsd_server[4].lpszPasswordA = (LPSTR) "password";
 
    dpsd_server[5].lpszSessionNameA = (LPSTR) "protected";
    dpsd_server[5].dwFlags = ( DPSESSION_CLIENTSERVER |
                               DPSESSION_DIRECTPLAYPROTOCOL |
                               DPSESSION_PASSWORDREQUIRED );
    dpsd_server[5].dwMaxPlayers = 10;
    dpsd_server[5].lpszPasswordA = (LPSTR) "password";
 
 
    for (i=0; i<N_SESSIONS; i++)
    {
        pDPserver[i] = create_session( &dpsd_server[i] );
        if (!pDPserver[i]) return;
    }
 
 
    /* Invalid params */
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, -1 );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    hr = IDirectPlayX_EnumSessions( pDP, NULL, 0, EnumSessions_cb,
                                    &callbackData, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    check( -1, callbackData.dwCounter1 );
 
 
    /* Flag tests */
    callbackData.dwFlags = DPENUMSESSIONS_ALL; /* Doesn't list private,
                                                  protected */
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( N_SESSIONS-2, callbackData.dwCounter1 );
 
    /* Doesn't list private */
    callbackData.dwFlags = ( DPENUMSESSIONS_ALL |
                             DPENUMSESSIONS_PASSWORDREQUIRED );
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( N_SESSIONS-1, callbackData.dwCounter1 );
 
    /* Doesn't list full, no new, no join, private, protected */
    callbackData.dwFlags = DPENUMSESSIONS_AVAILABLE;
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( N_SESSIONS-5, callbackData.dwCounter1 );
 
    /* Like with DPENUMSESSIONS_AVAILABLE */
    callbackData.dwFlags = 0;
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( N_SESSIONS-5, callbackData.dwCounter1 );
 
    /* Doesn't list full, no new, no join, private */
    callbackData.dwFlags = DPENUMSESSIONS_PASSWORDREQUIRED;
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( N_SESSIONS-4, callbackData.dwCounter1 );
 
 
    /* Async enumeration */
    callbackData.dwFlags = DPENUMSESSIONS_ASYNC;
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( N_SESSIONS-4, callbackData.dwCounter1 ); /* Read cache of last
                                                       sync enumeration */
 
    callbackData.dwFlags = DPENUMSESSIONS_STOPASYNC;
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( 0, callbackData.dwCounter1 ); /* Stop enumeration */
 
    callbackData.dwFlags = DPENUMSESSIONS_ASYNC;
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( 0, callbackData.dwCounter1 ); /* Start enumeration */
 
    Sleep(500); /* Give time to fill the cache */
 
    callbackData.dwFlags = DPENUMSESSIONS_ASYNC;
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( N_SESSIONS-5, callbackData.dwCounter1 ); /* Retrieve results */
 
    callbackData.dwFlags = DPENUMSESSIONS_STOPASYNC;
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( 0, callbackData.dwCounter1 ); /* Stop enumeration */
 
 
    /* Specific tests for passworded sessions */
 
    for (i=0; i<N_SESSIONS; i++)
    {
        IDirectPlayX_Release( pDPserver[i] );
    }
 
    /* - Only session password set */
    for (i=4;i<=5;i++)
    {
        dpsd_server[i].lpszPasswordA = (LPSTR) "password";
        dpsd_server[i].dwFlags = 0;
        pDPserver[i] = create_session( &dpsd_server[i] );
    }
 
    callbackData.dwFlags = 0;
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( 0, callbackData.dwCounter1 );
 
    callbackData.dwFlags = DPENUMSESSIONS_PASSWORDREQUIRED;
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( 2, callbackData.dwCounter1 ); /* Both sessions automatically
                                            set DPSESSION_PASSWORDREQUIRED */
 
    /* - Only session flag set */
    for (i=4; i<=5; i++)
    {
        IDirectPlayX_Release( pDPserver[i] );
        dpsd_server[i].lpszPasswordA = NULL;
    }
    dpsd_server[4].dwFlags = DPSESSION_PRIVATE;
    dpsd_server[5].dwFlags = DPSESSION_PASSWORDREQUIRED;
    for (i=4; i<=5; i++)
    {
        pDPserver[i] = create_session( &dpsd_server[i] );
    }
 
    callbackData.dwFlags = 0;
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( 2, callbackData.dwCounter1 ); /* Without password,
                                            the flag is ignored */
 
    /* - Both session flag and password set */
    for (i=4; i<=5; i++)
    {
        IDirectPlayX_Release( pDPserver[i] );
        dpsd_server[i].lpszPasswordA = (LPSTR) "password";
    }
    dpsd_server[4].dwFlags = DPSESSION_PRIVATE;
    dpsd_server[5].dwFlags = DPSESSION_PASSWORDREQUIRED;
    for (i=4; i<=5; i++)
    {
        pDPserver[i] = create_session( &dpsd_server[i] );
    }
 
    /* - Listing without password */
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( 0, callbackData.dwCounter1 );
 
    callbackData.dwFlags = DPENUMSESSIONS_PASSWORDREQUIRED;
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( 1, callbackData.dwCounter1 );
 
    /* - Listing with incorrect password */
    dpsd.lpszPasswordA = (LPSTR) "bad_password";
    callbackData.dwFlags = 0;
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( 0, callbackData.dwCounter1 );
 
    callbackData.dwFlags = DPENUMSESSIONS_PASSWORDREQUIRED;
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( 1, callbackData.dwCounter1 );
 
    /* - Listing with  correct password */
    dpsd.lpszPasswordA = (LPSTR) "password";
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( 2, callbackData.dwCounter1 );
 
 
    dpsd.lpszPasswordA = NULL;
    callbackData.dwFlags = DPENUMSESSIONS_ASYNC;
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( 2, callbackData.dwCounter1 ); /* Read cache of last sync enumeration,
                                            even private sessions */
 
 
    /* GUID tests */
 
    /* - Creating two servers with different application GUIDs */
    for (i=4; i<=5; i++)
    {
        IDirectPlayX_Release( pDPserver[i] );
        dpsd_server[i].dwFlags = ( DPSESSION_CLIENTSERVER |
                                   DPSESSION_DIRECTPLAYPROTOCOL );
        dpsd_server[i].lpszPasswordA = NULL;
        dpsd_server[i].dwMaxPlayers = 10;
    }
    dpsd_server[4].lpszSessionNameA = (LPSTR) "normal1";
    dpsd_server[4].guidApplication = appGuid;
    dpsd_server[5].lpszSessionNameA = (LPSTR) "normal2";
    dpsd_server[5].guidApplication = appGuid2;
    for (i=4; i<=5; i++)
    {
        pDPserver[i] = create_session( &dpsd_server[i] );
    }
 
    callbackData.dwFlags = 0;
 
    dpsd.guidApplication = appGuid2;
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( 1, callbackData.dwCounter1 ); /* Only one of the sessions */
 
    dpsd.guidApplication = appGuid;
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( 1, callbackData.dwCounter1 ); /* The other session */
    /* FIXME:
       For some reason, if we enum 1st with appGuid and 2nd with appGuid2,
       in the second enum we get the 2 sessions. Dplay fault? Elves? */
 
    dpsd.guidApplication = GUID_NULL;
    callbackData.dwCounter1 = -1;
    hr = IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb,
                                    &callbackData, callbackData.dwFlags );
    checkHR( DP_OK, hr );
    check( 2, callbackData.dwCounter1 ); /* Both sessions */
 
    for (i=4; i<=5; i++)
    {
        IDirectPlayX_Release( pDPserver[i] );
    }
    IDirectPlayX_Release( pDP );
 
}

Referenced by START_TEST().

◆ test_interactive_GetMessageQueue()

static void test_interactive_GetMessageQueue ( void )

static

Definition at line 9736 of file dplayx.c.

{
 
    IDirectPlay4 *pDP[2];
    DPSESSIONDESC2 dpsd;
    DPID dpid[4];
    CallbackData callbackData;
    HRESULT hr;
    UINT i;
    DWORD dwNumMsgs, dwNumBytes;
 
    DWORD dwDataSize = 1024;
    LPVOID lpData = calloc( 1, dwDataSize );
 
 
    for (i=0; i<2; i++)
    {
        hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                               &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
        ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
        if (FAILED(hr)) return;
    }
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
 
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, 0, 0,
                                       &dwNumMsgs, &dwNumBytes );
    todo_wine checkHR( DPERR_UNINITIALIZED, hr );
    check( -1, dwNumMsgs );
    check( -1, dwNumBytes );
 
    if ( hr == DP_OK )
    {
        todo_wine win_skip( "GetMessageQueue not implemented\n" );
        return;
    }
 
 
    init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
    init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
 
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, 0, 0,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( 0, dwNumMsgs );
    check( 0, dwNumBytes );
 
 
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    dpsd.dwMaxPlayers = 10;
    IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
    IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
                               pDP[1], 0 );
 
    IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 );
    IDirectPlayX_CreatePlayer( pDP[0], &dpid[1], NULL, NULL, NULL, 0, 0 );
    IDirectPlayX_CreatePlayer( pDP[1], &dpid[3], NULL, NULL, NULL, 0, 0 );
    IDirectPlayX_CreatePlayer( pDP[0], &dpid[2], NULL, NULL, NULL, 0, 0 );
 
 
 
    /* Incorrect parameters */
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], -1, dpid[1],
                                       0,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DPERR_INVALIDPLAYER, hr );
    check( -1, dwNumMsgs );
    check( -1, dwNumBytes );
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], -1,
                                       0,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DPERR_INVALIDPLAYER, hr );
    check( -1, dwNumMsgs );
    check( -1, dwNumBytes );
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[0],
                                       -1,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DPERR_INVALIDFLAGS, hr );
    check( -1, dwNumMsgs );
    check( -1, dwNumBytes );
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1],
                                       ( DPMESSAGEQUEUE_SEND |
                                         DPMESSAGEQUEUE_RECEIVE ),
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DPERR_INVALIDFLAGS, hr );
    check( -1, dwNumMsgs );
    check( -1, dwNumBytes );
 
    /* - Remote players */
if(0)
{
    /* Crash under Win7 */
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, dpid[3],
                                       DPMESSAGEQUEUE_RECEIVE,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DPERR_INVALIDPLAYER, hr ); /* Player 3 is remote */
    check( -1, dwNumMsgs );
    check( -1, dwNumBytes );
}
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[3], 0,
                                       DPMESSAGEQUEUE_SEND,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DPERR_INVALIDPLAYER, hr ); /* Player 3 is remote */
    check( -1, dwNumMsgs );
    check( -1, dwNumBytes );
 
    /* - Remote players, this time in the right place */
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, dpid[3],
                                       DPMESSAGEQUEUE_SEND,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( 0, dwNumMsgs );
    check( 0, dwNumBytes );
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[3], 0,
                                       DPMESSAGEQUEUE_RECEIVE,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( 0, dwNumMsgs );
    check( 0, dwNumBytes );
 
 
    /* Correct parameters */
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, dpid[1],
                                       DPMESSAGEQUEUE_RECEIVE,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( 2, dwNumMsgs );
    check( 96, dwNumBytes );
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], 0,
                                       DPMESSAGEQUEUE_RECEIVE,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( 0, dwNumMsgs );
    check( 0, dwNumBytes );
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, 0,
                                       DPMESSAGEQUEUE_RECEIVE,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( 5, dwNumMsgs );
    check( 240, dwNumBytes );
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1],
                                       DPMESSAGEQUEUE_RECEIVE,
                                       NULL, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( -1, dwNumMsgs );
    check( 0, dwNumBytes );
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1],
                                       DPMESSAGEQUEUE_RECEIVE,
                                       &dwNumMsgs, NULL );
    checkHR( DP_OK, hr );
    check( 0, dwNumMsgs );
    check( -1, dwNumBytes );
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1],
                                       DPMESSAGEQUEUE_RECEIVE,
                                       NULL, NULL );
    checkHR( DP_OK, hr );
    check( -1, dwNumMsgs );
    check( -1, dwNumBytes );
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1],
                                       DPMESSAGEQUEUE_RECEIVE,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( 0, dwNumMsgs );
    check( 0, dwNumBytes );
 
 
    /* Purge messages */
    check_messages( pDP[0], dpid, 6, &callbackData );
    checkStr( "S0,S1,S0,S1,S0,", callbackData.szTrace1 );
    check_messages( pDP[1], dpid, 6, &callbackData );
    checkStr( "S3,", callbackData.szTrace1 );
 
    /* Check queues are empty */
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, 0,
                                       DPMESSAGEQUEUE_RECEIVE,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( 0, dwNumMsgs );
    check( 0, dwNumBytes );
 
 
    /* Sending 4 data messages from 0 to 1 */
    /*         3               from 0 to 3 */
    /*         2               from 1 to 3 */
    for (i=0; i<4; i++)
        IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 0, lpData, dwDataSize );
    for (i=0; i<3; i++)
        IDirectPlayX_Send( pDP[0], dpid[0], dpid[3], 0, lpData, dwDataSize );
    for (i=0; i<2; i++)
        IDirectPlayX_Send( pDP[0], dpid[1], dpid[3], 0, lpData, dwDataSize );
 
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1],
                                       DPMESSAGEQUEUE_RECEIVE,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( 4, dwNumMsgs );
    check( 4*dwDataSize, dwNumBytes );
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[1], dpid[0], dpid[3],
                                       DPMESSAGEQUEUE_RECEIVE,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( 3, dwNumMsgs );
    check( 3*dwDataSize, dwNumBytes );
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[1], dpid[1], dpid[3],
                                       DPMESSAGEQUEUE_RECEIVE,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( 2, dwNumMsgs );
    check( 2*dwDataSize, dwNumBytes );
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], 0,
                                       DPMESSAGEQUEUE_RECEIVE,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( 4, dwNumMsgs );
    check( 4*dwDataSize, dwNumBytes );
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[1], dpid[0], 0,
                                       DPMESSAGEQUEUE_RECEIVE,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( 3, dwNumMsgs );
    check( 3*dwDataSize, dwNumBytes );
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[1], 0, dpid[3],
                                       DPMESSAGEQUEUE_RECEIVE,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( 5, dwNumMsgs );
    check( 5*dwDataSize, dwNumBytes );
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], 0, 0,
                                       DPMESSAGEQUEUE_RECEIVE,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( 4, dwNumMsgs );
    check( 4*dwDataSize, dwNumBytes );
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[1], 0, 0,
                                       DPMESSAGEQUEUE_RECEIVE,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( 5, dwNumMsgs );
    check( 5*dwDataSize, dwNumBytes );
 
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1],
                                       DPMESSAGEQUEUE_SEND,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( 0, dwNumMsgs );
    check( 0, dwNumBytes );
 
    dwNumMsgs = dwNumBytes = -1;
    hr = IDirectPlayX_GetMessageQueue( pDP[0], dpid[0], dpid[1],
                                       0,
                                       &dwNumMsgs, &dwNumBytes );
    checkHR( DP_OK, hr );
    check( 0, dwNumMsgs );
    check( 0, dwNumBytes );
 
 
    free( lpData );
    IDirectPlayX_Release( pDP[0] );
    IDirectPlayX_Release( pDP[1] );
 
}

Referenced by START_TEST().

◆ test_interactive_Open()

static void test_interactive_Open ( void )

static

Definition at line 3441 of file dplayx.c.

{
 
    IDirectPlay4 *pDP, *pDP_server;
    DPSESSIONDESC2 dpsd, dpsd_server;
    HRESULT hr;
 
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                           &IID_IDirectPlay4A, (LPVOID*) &pDP_server );
    ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
    if (FAILED(hr)) return;
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                           &IID_IDirectPlay4A, (LPVOID*) &pDP );
    ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
    if (FAILED(hr)) return;
 
    ZeroMemory( &dpsd_server, sizeof(DPSESSIONDESC2) );
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
 
    /* Service provider not initialized */
    hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
    todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
 
    init_TCPIP_provider( pDP_server, "127.0.0.1", 0 );
    init_TCPIP_provider( pDP, "127.0.0.1", 0 );
 
    /* Uninitialized  dpsd */
    hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
 
    dpsd_server.dwSize = sizeof(DPSESSIONDESC2);
    dpsd_server.guidApplication = appGuid;
    dpsd_server.dwMaxPlayers = 10;
 
 
    /* Regular operation */
    hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
    todo_wine checkHR( DP_OK, hr );
 
    /* Opening twice */
    hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
    todo_wine checkHR( DPERR_ALREADYINITIALIZED, hr );
 
    /* Session flags */
    IDirectPlayX_Close( pDP_server );
 
    dpsd_server.dwFlags = DPSESSION_CLIENTSERVER | DPSESSION_MIGRATEHOST;
    hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
    todo_wine checkHR( DPERR_INVALIDFLAGS, hr );
 
    dpsd_server.dwFlags = DPSESSION_MULTICASTSERVER | DPSESSION_MIGRATEHOST;
    hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
    todo_wine checkHR( DPERR_INVALIDFLAGS, hr );
 
    dpsd_server.dwFlags = DPSESSION_SECURESERVER | DPSESSION_MIGRATEHOST;
    hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
    todo_wine checkHR( DPERR_INVALIDFLAGS, hr );
 
 
    /* Joining sessions */
    /* - Checking how strict dplay is with sizes */
    dpsd.dwSize = 0;
    hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    dpsd.dwSize = sizeof(DPSESSIONDESC2)-1;
    hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    dpsd.dwSize = sizeof(DPSESSIONDESC2)+1;
    hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
    todo_wine checkHR( DPERR_NOSESSIONS, hr ); /* Only checks for size, not guids */
 
 
    dpsd.guidApplication = appGuid;
    dpsd.guidInstance = appGuid;
 
 
    hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN );
    todo_wine checkHR( DPERR_NOSESSIONS, hr );
    hr = IDirectPlayX_Open( pDP, &dpsd, DPOPEN_JOIN | DPOPEN_CREATE );
    todo_wine checkHR( DPERR_NOSESSIONS, hr ); /* Second flag is ignored */
 
    dpsd_server.dwFlags = 0;
 
 
    /* Join to normal session */
    hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
    todo_wine checkHR( DP_OK, hr );
 
    IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb2, pDP, 0 );
 
 
    /* Already initialized session */
    hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
    todo_wine checkHR( DPERR_ALREADYINITIALIZED, hr );
 
 
    /* Checking which is the error checking order */
    dpsd_server.dwSize = 0;
 
    hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    dpsd_server.dwSize = sizeof(DPSESSIONDESC2);
 
 
    /* Join to protected session */
    IDirectPlayX_Close( pDP_server );
    dpsd_server.lpszPasswordA = (LPSTR) "hadouken";
    hr = IDirectPlayX_Open( pDP_server, &dpsd_server, DPOPEN_CREATE );
    todo_wine checkHR( DP_OK, hr );
 
    IDirectPlayX_EnumSessions( pDP, &dpsd, 0, EnumSessions_cb2,
                               pDP, DPENUMSESSIONS_PASSWORDREQUIRED );
 
 
    IDirectPlayX_Release( pDP );
    IDirectPlayX_Release( pDP_server );
 
}

Referenced by START_TEST().

◆ test_interactive_Receive()

static void test_interactive_Receive ( void )

static

Definition at line 8810 of file dplayx.c.

{
 
    IDirectPlay4 *pDP;
    DPSESSIONDESC2 dpsd;
    DPID dpid[4], idFrom, idTo;
    HRESULT hr;
    LPCSTR message = "message";
    DWORD messageSize = strlen(message) + 1;
    DWORD dwDataSize = 1024;
    LPDPMSG_GENERIC lpData = calloc( 1, dwDataSize );
    LPDPMSG_CREATEPLAYERORGROUP lpDataCreate;
    LPDPMSG_DESTROYPLAYERORGROUP lpDataDestroy;
 
    DWORD dwCount;
    UINT i;
 
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                           &IID_IDirectPlay4A, (LPVOID*) &pDP );
    ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
    if (FAILED(hr)) return;
 
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
 
    init_TCPIP_provider( pDP, "127.0.0.1", 0 );
 
    IDirectPlayX_Open( pDP, &dpsd, DPOPEN_CREATE );
 
 
    /* Invalid parameters */
    hr = IDirectPlayX_Receive( pDP, NULL, &idTo, 0,
                               lpData, &dwDataSize );
    todo_wine checkHR( DPERR_INVALIDPARAMS, hr );
 
    if ( hr == DPERR_UNINITIALIZED )
    {
        todo_wine win_skip( "Receive not implemented\n" );
        return;
    }
 
    hr = IDirectPlayX_Receive( pDP, &idFrom, NULL, 0,
                               lpData, &dwDataSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
    hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0,
                               lpData, NULL );
    checkHR( DPERR_INVALIDPARAMS, hr );
    dwDataSize = -1;
    hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0,
                               lpData, &dwDataSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    /* No messages yet */
    hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0,
                               NULL, &dwDataSize );
    checkHR( DPERR_NOMESSAGES, hr );
    dwDataSize = 0;
    hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0,
                               lpData, &dwDataSize );
    checkHR( DPERR_NOMESSAGES, hr );
 
 
    IDirectPlayX_CreatePlayer( pDP, &dpid[0], NULL, 0, NULL, 0, 0 );
    IDirectPlayX_CreatePlayer( pDP, &dpid[1], NULL, 0, NULL, 0,
                               DPPLAYER_SPECTATOR );
    IDirectPlayX_CreatePlayer( pDP, &dpid[2], NULL, 0, NULL, 0, 0 );
    IDirectPlayX_CreatePlayer( pDP, &dpid[3], NULL, 0, NULL, 0, 0 );
 
 
    /* 0, 1, 2, 3 */
    /* 3, 2, 1, 0 */
    for (i=0; i<4; i++)
    {
        IDirectPlayX_GetMessageCount( pDP, dpid[i], &dwCount );
        check( 3-i, dwCount );
    }
 
 
    IDirectPlayX_DestroyPlayer( pDP, dpid[3] );
    IDirectPlayX_DestroyPlayer( pDP, dpid[1] );
 
 
    /* 0, 1, 2, 3 */
    /* 5, 5, 3, 3 */
    IDirectPlayX_GetMessageCount( pDP, dpid[0], &dwCount );
    check( 5, dwCount );
    IDirectPlayX_GetMessageCount( pDP, dpid[1], &dwCount );
    check( 5, dwCount );
    IDirectPlayX_GetMessageCount( pDP, dpid[2], &dwCount );
    check( 3, dwCount );
    IDirectPlayX_GetMessageCount( pDP, dpid[3], &dwCount );
    check( 3, dwCount );
 
 
    /* Buffer too small */
    hr = IDirectPlayX_Receive( pDP, &idFrom, &idFrom, 0,
                               NULL, &dwDataSize );
    checkHR( DPERR_BUFFERTOOSMALL, hr );
    check( 48, dwDataSize );
    dwDataSize = 0;
    hr = IDirectPlayX_Receive( pDP, &idTo, &idFrom, 0,
                               lpData, &dwDataSize );
    checkHR( DPERR_BUFFERTOOSMALL, hr );
    check( 48, dwDataSize );
 
 
    /* Checking the order or reception */
    for (i=0; i<11; i++)
    {
        dwDataSize = 1024;
        hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0,
                                   lpData, &dwDataSize );
 
        checkHR( DP_OK, hr );
        check( DPID_SYSMSG, idFrom );
 
        if (i<6)  /* Player creation */
        {
            checkConv( DPSYS_CREATEPLAYERORGROUP, lpData->dwType, dpMsgType2str );
            check( 48, dwDataSize );
            lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData;
            check( DPPLAYERTYPE_PLAYER,   lpDataCreate->dwPlayerType );
            checkLP( NULL,                lpDataCreate->lpData );
            check( 0,                     lpDataCreate->dwDataSize );
            checkLP( NULL,                lpDataCreate->dpnName.lpszShortNameA );
            check( 0,                     lpDataCreate->dpIdParent );
        }
        else  /* Player destruction */
        {
            checkConv( DPSYS_DESTROYPLAYERORGROUP, lpData->dwType,
                       dpMsgType2str );
            check( 52, dwDataSize );
            lpDataDestroy = (LPDPMSG_DESTROYPLAYERORGROUP) lpData;
            check( DPPLAYERTYPE_PLAYER,   lpDataDestroy->dwPlayerType );
            checkLP( NULL,                lpDataDestroy->lpLocalData );
            check( 0,                     lpDataDestroy->dwLocalDataSize );
            checkLP( NULL,                lpDataDestroy->lpRemoteData );
            check( 0,                     lpDataDestroy->dwRemoteDataSize );
            checkLP( NULL,                lpDataDestroy->dpnName.lpszShortNameA );
            check( 0,                     lpDataDestroy->dpIdParent );
        }
 
        switch(i)
        {
            /* 1 -> 0 */
        case 0:
            lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData;
            check( dpid[0], idTo );
            check( dpid[1],              lpDataCreate->dpId );
            check( 1,                    lpDataCreate->dwCurrentPlayers );
            checkFlags( DPPLAYER_LOCAL|DPPLAYER_SPECTATOR, lpDataCreate->dwFlags,
                        FLAGS_DPPLAYER|FLAGS_DPGROUP );
            break;
 
            /* 2 -> 1,0 */
        case 1:
            check( dpid[1], idTo );
            lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData;
            check( dpid[2],              lpDataCreate->dpId );
            check( 2,                    lpDataCreate->dwCurrentPlayers );
            checkFlags( DPPLAYER_LOCAL,  lpDataCreate->dwFlags,
                        FLAGS_DPPLAYER | FLAGS_DPGROUP );
            break;
        case 2:
            check( dpid[0], idTo );
            lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData;
            check( dpid[2],              lpDataCreate->dpId );
            check( 2,                    lpDataCreate->dwCurrentPlayers );
            checkFlags( DPPLAYER_LOCAL,  lpDataCreate->dwFlags,
                        FLAGS_DPPLAYER | FLAGS_DPGROUP );
            break;
 
            /* 3 -> 2,1,0 */
        case 3:
            check( dpid[2], idTo );
            lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData;
            check( dpid[3],              lpDataCreate->dpId );
            check( 3,                    lpDataCreate->dwCurrentPlayers );
            checkFlags( DPPLAYER_LOCAL,  lpDataCreate->dwFlags,
                        FLAGS_DPPLAYER | FLAGS_DPGROUP );
            break;
        case 4:
            check( dpid[1], idTo );
            lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData;
            check( dpid[3],              lpDataCreate->dpId );
            check( 3,                    lpDataCreate->dwCurrentPlayers );
            checkFlags( DPPLAYER_LOCAL,  lpDataCreate->dwFlags,
                        FLAGS_DPPLAYER | FLAGS_DPGROUP );
            break;
        case 5:
            check( dpid[0], idTo );
            lpDataCreate = (LPDPMSG_CREATEPLAYERORGROUP) lpData;
            check( dpid[3],              lpDataCreate->dpId );
            check( 3,                    lpDataCreate->dwCurrentPlayers );
            checkFlags( DPPLAYER_LOCAL,  lpDataCreate->dwFlags,
                        FLAGS_DPPLAYER | FLAGS_DPGROUP );
            break;
 
            /* 3 -> 2,1,0 */
        case 6:
            check( dpid[2], idTo );
            lpDataDestroy = (LPDPMSG_DESTROYPLAYERORGROUP) lpData;
            check( dpid[3],              lpDataDestroy->dpId );
            checkFlags( DPPLAYER_LOCAL,  lpDataDestroy->dwFlags,
                        FLAGS_DPPLAYER | FLAGS_DPGROUP );
            break;
        case 7:
            check( dpid[1], idTo );
            lpDataDestroy = (LPDPMSG_DESTROYPLAYERORGROUP) lpData;
            check( dpid[3],              lpDataDestroy->dpId );
            checkFlags( DPPLAYER_LOCAL,  lpDataDestroy->dwFlags,
                        FLAGS_DPPLAYER | FLAGS_DPGROUP );
            break;
        case 8:
            check( dpid[0], idTo );
            lpDataDestroy = (LPDPMSG_DESTROYPLAYERORGROUP) lpData;
            check( dpid[3],              lpDataDestroy->dpId );
            checkFlags( DPPLAYER_LOCAL,  lpDataDestroy->dwFlags,
                        FLAGS_DPPLAYER | FLAGS_DPGROUP );
            break;
 
            /* 1 -> 2,0 */
        case 9:
            check( dpid[2], idTo );
            lpDataDestroy = (LPDPMSG_DESTROYPLAYERORGROUP) lpData;
            check( dpid[1],                 lpDataDestroy->dpId );
            checkFlags( DPPLAYER_LOCAL |
                        DPPLAYER_SPECTATOR, lpDataDestroy->dwFlags,
                        FLAGS_DPPLAYER | FLAGS_DPGROUP );
            break;
        case 10:
            check( dpid[0], idTo );
            lpDataDestroy = (LPDPMSG_DESTROYPLAYERORGROUP) lpData;
            check( dpid[1],                 lpDataDestroy->dpId );
            checkFlags( DPPLAYER_LOCAL |
                        DPPLAYER_SPECTATOR, lpDataDestroy->dwFlags,
                        FLAGS_DPPLAYER | FLAGS_DPGROUP );
            break;
 
        default:
            trace( "%s\n", dpMsgType2str(lpData->dwType) );
            break;
        }
    }
 
    hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, lpData, &dwDataSize );
    checkHR( DPERR_NOMESSAGES, hr );
 
 
    /* New data message */
    hr = IDirectPlayX_Send( pDP, dpid[0], dpid[2], 0,
                            (LPVOID) message, messageSize );
    checkHR( DP_OK, hr );
 
 
    /* Ensuring DPRECEIVE_PEEK doesn't remove the messages from the queue */
    for (i=0; i<10; i++)
    {
        hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, DPRECEIVE_PEEK,
                                   lpData, &dwDataSize );
        checkHR( DP_OK, hr );
        checkStr( message, (LPSTR) lpData );
    }
 
    /* Removing the message from the queue */
    hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, lpData, &dwDataSize );
    checkHR( DP_OK, hr );
    check( idFrom, dpid[0] );
    check( idTo, dpid[2] );
    checkStr( message, (LPSTR) lpData );
 
    hr = IDirectPlayX_Receive( pDP, &idFrom, &idTo, 0, lpData, &dwDataSize );
    checkHR( DPERR_NOMESSAGES, hr );
 
 
    free( lpData );
    IDirectPlayX_Release( pDP );
 
}

Referenced by START_TEST().

◆ test_interactive_Send()

static void test_interactive_Send ( void )

static

Definition at line 8245 of file dplayx.c.

{
 
    IDirectPlay4 *pDP[2];
    DPSESSIONDESC2 dpsd;
    DPID dpid[4], idFrom, idTo;
    CallbackData callbackData;
    HRESULT hr;
    LPCSTR message = "message";
    DWORD messageSize = strlen(message) + 1;
    DWORD dwDataSize = 1024;
    LPDPMSG_GENERIC lpData = calloc( 1, dwDataSize );
    LPDPMSG_SECUREMESSAGE lpDataSecure;
    UINT i;
 
 
    for (i=0; i<2; i++)
    {
        hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                               &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
        ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
        if (FAILED(hr)) return;
    }
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
 
 
    /* Uninitialized service provider */
    hr = IDirectPlayX_Send( pDP[0], 0, 0, 0,
                            (LPVOID) message, messageSize );
    checkHR( DPERR_UNINITIALIZED, hr );
 
 
    init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
    init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
 
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    dpsd.dwMaxPlayers = 10;
    IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
    IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
                               pDP[1], 0 );
    IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
 
 
    /* Incorrect players */
    hr = IDirectPlayX_Send( pDP[0], 0, 1, 2,
                            (LPVOID) message, messageSize );
    todo_wine checkHR( DPERR_INVALIDPLAYER, hr );
 
    if ( hr == DPERR_UNINITIALIZED )
    {
        todo_wine win_skip( "Send not implemented\n" );
        return;
    }
 
 
    IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 );
    IDirectPlayX_CreatePlayer( pDP[0], &dpid[1], NULL, NULL, NULL, 0, 0 );
    IDirectPlayX_CreatePlayer( pDP[0], &dpid[2], NULL, NULL, NULL, 0, 0 );
    IDirectPlayX_CreatePlayer( pDP[1], &dpid[3], NULL, NULL, NULL, 0, 0 );
 
    /* Purge player creation messages */
    check_messages( pDP[0], dpid, 4, &callbackData );
    checkStr( "S0," "S1,S0," "S2,S1,S0,", callbackData.szTrace1 );
    check_messages( pDP[1], dpid, 4, &callbackData );
    checkStr( "", callbackData.szTrace1 );
 
 
    /* Message to self: no error, but no message is sent */
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[0], 0,
                            (LPVOID) message, messageSize );
    checkHR( DP_OK, hr );
 
    /* Send a message from a remote player */
    hr = IDirectPlayX_Send( pDP[1], dpid[0], dpid[1], 0,
                            (LPVOID) message, messageSize );
    checkHR( DPERR_ACCESSDENIED, hr );
    hr = IDirectPlayX_Send( pDP[1], dpid[0], dpid[3], 0,
                            (LPVOID) message, messageSize );
    checkHR( DPERR_ACCESSDENIED, hr );
 
    /* Null message */
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 0,
                            NULL, messageSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1], 0,
                            (LPVOID) message, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
 
    /* Checking no message was sent */
    check_messages( pDP[0], dpid, 4, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], dpid, 4, &callbackData );
    checkStr( "", callbackData.szTrace1 );
 
 
    /* Regular parameters */
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
                            0,
                            (LPVOID) message, messageSize );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_Receive( pDP[0], &dpid[0], &dpid[1],
                               DPRECEIVE_FROMPLAYER | DPRECEIVE_TOPLAYER,
                               lpData, &dwDataSize );
    checkHR( DP_OK, hr );
    checkStr( message, (LPSTR) lpData );
    check( strlen(message)+1, dwDataSize );
 
    check_messages( pDP[0], dpid, 4, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], dpid, 4, &callbackData );
    checkStr( "", callbackData.szTrace1 );
 
 
    /* Message to a remote player */
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[3], 0,
                            (LPVOID) message, messageSize );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_Receive( pDP[0], &dpid[0], &dpid[3],
                               DPRECEIVE_FROMPLAYER | DPRECEIVE_TOPLAYER,
                               lpData, &dwDataSize );
    checkHR( DPERR_NOMESSAGES, hr );
    hr = IDirectPlayX_Receive( pDP[1], &dpid[0], &dpid[3],
                               DPRECEIVE_FROMPLAYER | DPRECEIVE_TOPLAYER,
                               lpData, &dwDataSize );
    checkHR( DP_OK, hr );
    checkStr( message, (LPSTR) lpData );
    check( strlen(message)+1, dwDataSize );
 
    check_messages( pDP[0], dpid, 4, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], dpid, 4, &callbackData );
    checkStr( "", callbackData.szTrace1 );
 
 
    /* Broadcast */
 
    hr = IDirectPlayX_Send( pDP[0], dpid[0], DPID_ALLPLAYERS, 0,
                            (LPVOID) message, messageSize );
    checkHR( DP_OK, hr );
 
    for (i=1; i<3; i++)
    {
        hr = IDirectPlayX_Receive( pDP[0], &dpid[0], &dpid[i],
                                   DPRECEIVE_FROMPLAYER | DPRECEIVE_TOPLAYER,
                                   lpData, &dwDataSize );
        checkHR( DP_OK, hr );
        checkStr( message, (LPSTR) lpData );
    }
    hr = IDirectPlayX_Receive( pDP[1], &dpid[0], &dpid[3],
                               DPRECEIVE_FROMPLAYER | DPRECEIVE_TOPLAYER,
                               lpData, &dwDataSize );
    checkHR( DP_OK, hr );
    checkStr( message, (LPSTR) lpData );
 
    check_messages( pDP[0], dpid, 4, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], dpid, 4, &callbackData );
    checkStr( "", callbackData.szTrace1 );
 
 
    hr = IDirectPlayX_Send( pDP[0], DPID_ALLPLAYERS, dpid[1],
                            0,
                            (LPVOID) message, messageSize );
    checkHR( DPERR_INVALIDPLAYER, hr );
    hr = IDirectPlayX_Send( pDP[0], DPID_ALLPLAYERS, DPID_ALLPLAYERS,
                            0,
                            (LPVOID) message, messageSize );
    checkHR( DPERR_INVALIDPLAYER, hr );
 
 
    /* Flags */
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
                            DPSEND_GUARANTEED,
                            (LPVOID) message, messageSize );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_Receive( pDP[0], &dpid[0], &dpid[1],
                               DPRECEIVE_FROMPLAYER | DPRECEIVE_TOPLAYER,
                               lpData, &dwDataSize );
    checkHR( DP_OK, hr );
    checkStr( message, (LPSTR)lpData );
 
    /* - Inorrect flags */
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
                            DPSEND_ENCRYPTED,
                            (LPVOID) message, messageSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
                            DPSEND_SIGNED,
                            (LPVOID) message, messageSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
                            DPSEND_ENCRYPTED | DPSEND_SIGNED,
                            (LPVOID) message, messageSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    /* - Correct flags, but session is not secure */
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
                            DPSEND_ENCRYPTED | DPSEND_GUARANTEED,
                            (LPVOID) message, messageSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
                            DPSEND_SIGNED | DPSEND_GUARANTEED,
                            (LPVOID) message, messageSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
                            ( DPSEND_ENCRYPTED |
                              DPSEND_SIGNED |
                              DPSEND_GUARANTEED ),
                            (LPVOID) message, messageSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    /* - Correct flags, secure session incorrectly opened (without flags) */
    hr = IDirectPlayX_Close( pDP[0] );
    checkHR( DP_OK, hr );
 
    dpsd.dwFlags = 0;
    hr = IDirectPlayX_SecureOpen( pDP[0], &dpsd, DPOPEN_CREATE, NULL, NULL );
    checkHR( DP_OK, hr );
    for (i=0; i<2; i++)
        IDirectPlayX_CreatePlayer( pDP[0], &dpid[i], NULL, NULL, NULL, 0, 0 );
 
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
                            DPSEND_ENCRYPTED | DPSEND_GUARANTEED,
                            (LPVOID) message, messageSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
                            DPSEND_SIGNED | DPSEND_GUARANTEED,
                            (LPVOID) message, messageSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
                            ( DPSEND_ENCRYPTED |
                              DPSEND_SIGNED |
                              DPSEND_GUARANTEED ),
                            (LPVOID) message, messageSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    /* - Correct flags, secure session */
    hr = IDirectPlayX_Close( pDP[0] );
    checkHR( DP_OK, hr );
 
    dpsd.dwFlags = DPSESSION_SECURESERVER;
    hr = IDirectPlayX_SecureOpen( pDP[0], &dpsd, DPOPEN_CREATE, NULL, NULL );
    checkHR( DP_OK, hr );
    IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 );
    IDirectPlayX_CreatePlayer( pDP[0], &dpid[1], NULL, NULL, NULL, 0, 0 );
 
    /* Purge */
    check_messages( pDP[0], dpid, 6, &callbackData );
    checkStr( "S0,", callbackData.szTrace1 );
 
 
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
                            DPSEND_ENCRYPTED | DPSEND_GUARANTEED,
                            (LPVOID) message, messageSize );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
                            DPSEND_SIGNED | DPSEND_GUARANTEED,
                            (LPVOID) message, messageSize );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
                            ( DPSEND_ENCRYPTED |
                              DPSEND_SIGNED |
                              DPSEND_GUARANTEED ),
                            (LPVOID) message, messageSize );
    checkHR( DP_OK, hr );
 
 
    for (i=0; i<3; i++)
    {
        dwDataSize = 1024;
        hr = IDirectPlayX_Receive( pDP[0], &idFrom, &idTo, 0, lpData,
                                   &dwDataSize );
 
        lpDataSecure = (LPDPMSG_SECUREMESSAGE) lpData;
 
        checkHR( DP_OK, hr );
        checkConv( DPSYS_SECUREMESSAGE,   lpData->dwType, dpMsgType2str );
        check( DPID_SYSMSG,               idFrom );
        check( dpid[1],                   idTo );
        check( dpid[0],                   lpDataSecure->dpIdFrom );
        checkStr( message,        (LPSTR) lpDataSecure->lpData );
        check( strlen(message)+1,         lpDataSecure->dwDataSize );
 
        switch(i)
        {
        case 0:
            checkFlags( DPSEND_ENCRYPTED,
                        lpDataSecure->dwFlags,
                        FLAGS_DPSEND );
            break;
        case 1:
            checkFlags( DPSEND_SIGNED,
                        lpDataSecure->dwFlags,
                        FLAGS_DPSEND );
            break;
        case 2:
            checkFlags( DPSEND_SIGNED | DPSEND_ENCRYPTED,
                        lpDataSecure->dwFlags,
                        FLAGS_DPSEND );
            break;
        default: break;
        }
    }
    check_messages( pDP[0], dpid, 4, &callbackData );
    checkStr( "", callbackData.szTrace1 );
 
 
    /* - Even in a secure session, incorrect flags still not working */
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
                            DPSEND_ENCRYPTED,
                            (LPVOID) message, messageSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
                            DPSEND_SIGNED,
                            (LPVOID) message, messageSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
    hr = IDirectPlayX_Send( pDP[0], dpid[0], dpid[1],
                            DPSEND_ENCRYPTED | DPSEND_SIGNED,
                            (LPVOID) message, messageSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
 
    free( lpData );
    IDirectPlayX_Release( pDP[0] );
    IDirectPlayX_Release( pDP[1] );
 
}

Referenced by START_TEST().

◆ test_Open()

static void test_Open ( void )

static

Definition at line 3286 of file dplayx.c.

{
    DPSESSIONDESC2 dpsdZero =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
    };
    DPSESSIONDESC2 dpsdAppGuid =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidInstance = appGuid,
        .guidApplication = appGuid,
    };
    DPSESSIONDESC2 normalDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidApplication = appGuid,
        .guidInstance = appGuid,
        .dwMaxPlayers = 10,
        .lpszSessionName = (WCHAR *) L"normal",
        .dwReserved1 = 0xaabbccdd,
    };
    DPSESSIONDESC2 protectedDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .dwFlags = DPSESSION_PASSWORDREQUIRED,
        .guidApplication = appGuid,
        .guidInstance = appGuid,
        .dwMaxPlayers = 10,
        .lpszSessionName = (WCHAR *) L"protected",
        .lpszPassword = (WCHAR *) L"hadouken",
        .dwReserved1 = 0xaabbccdd,
    };
    EnumSessionsParam *enumSessionsParam;
    DPSESSIONDESC2 replyDpsd;
    DPSESSIONDESC2 dpsd;
    unsigned short port;
    IDirectPlay4 *dp;
    SOCKET enumSock;
    int tryIndex;
    SOCKET sock;
    HRESULT hr;
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlay4A, (void **) &dp );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
 
    dpsd = dpsdZero;
    dpsd.dwSize = 0;
    check_Open( dp, &dpsd, NULL, FALSE, FALSE, 2349, NULL, DP_OK, DP_OK, DPERR_INVALIDPARAMS );
 
    check_Open( dp, &dpsdZero, NULL, FALSE, FALSE, 2349, NULL, DP_OK, DP_OK, DPERR_UNINITIALIZED );
 
    init_TCPIP_provider( dp, "127.0.0.1", 0 );
 
    /* Joining sessions */
    /* - Checking how strict dplay is with sizes */
    dpsd = dpsdZero;
    dpsd.dwSize = 0;
    check_Open( dp, &dpsd, NULL, FALSE, FALSE, 2349, NULL, DP_OK, DP_OK, DPERR_INVALIDPARAMS );
 
    dpsd = dpsdZero;
    dpsd.dwSize = sizeof( DPSESSIONDESC2 ) - 1;
    check_Open( dp, &dpsd, NULL, FALSE, FALSE, 2349, NULL, DP_OK, DP_OK, DPERR_INVALIDPARAMS );
 
    dpsd = dpsdZero;
    dpsd.dwSize = sizeof( DPSESSIONDESC2 ) + 1;
    check_Open( dp, &dpsd, NULL, FALSE, FALSE, 2349, NULL, DP_OK, DP_OK, DPERR_INVALIDPARAMS );
 
    check_Open( dp, &dpsdZero, NULL, FALSE, FALSE, 2349, NULL, DP_OK, DP_OK, DPERR_NOSESSIONS );
 
    check_Open( dp, &dpsdAppGuid, NULL, FALSE, FALSE, 2349, NULL, DP_OK, DP_OK, DPERR_NOSESSIONS );
 
    enumSock = bindUdp( 47624 );
 
    /* Join to normal session */
    for ( tryIndex = 0; ; ++tryIndex )
    {
        int count = 0;
 
        enumSessionsParam = enumSessionsAsync( dp, &dpsdAppGuid, 100, countSessionsCallback, &count, 0 );
 
        port = receiveEnumSessionsRequest( enumSock, &appGuid, NULL, 0 );
 
        sock = connectTcp( port );
 
        sendEnumSessionsReply( sock, 2349, &normalDpsd );
 
        replyDpsd = normalDpsd;
        replyDpsd.guidInstance = appGuid2;
        sendEnumSessionsReply( sock, 2348, &replyDpsd );
 
        hr = enumSessionsAsyncWait( enumSessionsParam, 2000 );
        checkHR( DP_OK, hr );
 
        closesocket( sock );
 
        if ( tryIndex < 19 && count < 2 )
            continue;
 
        ok( count == 2, "got session count %d.\n", count );
 
        break;
    }
 
    check_Open( dp, &dpsdAppGuid, &normalDpsd, TRUE, FALSE, 2349, L"", DPERR_CANTCREATEPLAYER, DP_OK,
                DPERR_CANTCREATEPLAYER );
 
    check_Open( dp, &dpsdAppGuid, &normalDpsd, TRUE, TRUE, 2349, L"", DP_OK, DP_OK, DP_OK );
 
    dpsd = dpsdAppGuid;
    dpsd.guidInstance = appGuid2;
    replyDpsd = normalDpsd;
    replyDpsd.guidInstance = appGuid2;
    check_Open( dp, &dpsd, &replyDpsd, TRUE, TRUE, 2348, L"", DP_OK, DP_OK, DP_OK );
 
    /* Join to protected session */
    for ( tryIndex = 0; ; ++tryIndex )
    {
        int count = 0;
 
        enumSessionsParam = enumSessionsAsync( dp, &dpsdAppGuid, 100, countSessionsCallback, &count,
                                               DPENUMSESSIONS_PASSWORDREQUIRED );
 
        port = receiveEnumSessionsRequest( enumSock, &appGuid, NULL, DPENUMSESSIONS_PASSWORDREQUIRED );
 
        sock = connectTcp( port );
 
        sendEnumSessionsReply( sock, 2349, &protectedDpsd );
 
        hr = enumSessionsAsyncWait( enumSessionsParam, 2000 );
        checkHR( DP_OK, hr );
 
        closesocket( sock );
 
        if ( tryIndex < 19 && count < 1 )
            continue;
 
        ok( count == 1, "got session count %d.\n", count );
 
        break;
    }
 
    dpsd = dpsdAppGuid;
    dpsd.lpszPasswordA = (char *) "hadouken";
    check_Open( dp, &dpsd, &protectedDpsd, TRUE, TRUE, 2349, L"hadouken", DP_OK, DP_OK, DP_OK );
 
    dpsd = dpsdAppGuid;
    dpsd.lpszPasswordA = (char *) "sonic boom";
    check_Open( dp, &dpsd, &protectedDpsd, TRUE, TRUE, 2349, L"sonic boom", DP_OK, DPERR_INVALIDPASSWORD,
                DPERR_INVALIDPASSWORD );
 
    closesocket( enumSock );
 
    IDirectPlayX_Release( dp );
}

Referenced by START_TEST().

◆ test_PING()

static void test_PING ( void )

static

Definition at line 9092 of file dplayx.c.

{
    DPSESSIONDESC2 appGuidDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidInstance = appGuid,
        .guidApplication = appGuid,
    };
    DPSESSIONDESC2 serverDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidApplication = appGuid,
        .guidInstance = appGuid,
        .lpszSessionName = (WCHAR *) L"normal",
        .dwReserved1 = 0xaabbccdd,
    };
    unsigned short udpPort;
    SOCKET udpSendSock;
    SOCKET udpRecvSock;
    IDirectPlay4A *dp;
    SOCKET sendSock;
    SOCKET recvSock;
    HRESULT hr;
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlay4A, (void **) &dp );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
 
    init_TCPIP_provider( dp, "127.0.0.1", 0 );
 
    joinSession( dp, &appGuidDpsd, &serverDpsd, &sendSock, &recvSock, &udpPort );
 
    udpSendSock = connectUdp( udpPort );
 
    udpRecvSock = bindUdp( 2399 );
 
    sendPing( udpSendSock, 2349, 0x51573, 0x44332211 );
    receivePingReply( udpRecvSock, 0x12345678, 0x44332211 );
    checkNoMoreMessages( udpRecvSock );
 
    closesocket( udpRecvSock );
    closesocket( udpSendSock );
    closesocket( recvSock );
    closesocket( sendSock );
 
    IDirectPlayX_Release( dp );
}

Referenced by START_TEST().

◆ test_PlayerData()

static void test_PlayerData ( void )

static

Definition at line 5446 of file dplayx.c.

{
    IDirectPlay4 *pDP;
    DPSESSIONDESC2 dpsd;
    DPID dpid;
    HRESULT hr;
 
    /* lpDataFake has to be bigger than the rest, limits lpDataGet size */
    LPCSTR lpDataFake     = "big_fake_data_chunk";
    DWORD dwDataSizeFake  = strlen(lpDataFake)+1;
 
    LPCSTR lpData         = "remote_data";
    DWORD dwDataSize      = strlen(lpData)+1;
 
    LPCSTR lpDataLocal    = "local_data";
    DWORD dwDataSizeLocal = strlen(lpDataLocal)+1;
 
    LPSTR lpDataGet       = calloc( 1, dwDataSizeFake );
    DWORD dwDataSizeGet   = dwDataSizeFake;
 
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                           &IID_IDirectPlay4A, (LPVOID*) &pDP );
    ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
    if (FAILED(hr)) return;
 
    /* No service provider */
    hr = IDirectPlayX_SetPlayerData( pDP, 0, (LPVOID) lpData,
                                     dwDataSize, 0 );
    checkHR( DPERR_UNINITIALIZED, hr );
 
    hr = IDirectPlayX_GetPlayerData( pDP, 0, lpDataGet, &dwDataSizeGet, 0 );
    checkHR( DPERR_UNINITIALIZED, hr );
 
 
    init_TCPIP_provider( pDP, "127.0.0.1", 0 );
 
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    IDirectPlayX_Open( pDP, &dpsd, DPOPEN_CREATE );
 
 
    /* Invalid player */
    hr = IDirectPlayX_SetPlayerData( pDP, 0, (LPVOID) lpData,
                                     dwDataSize, 0 );
    todo_wine checkHR( DPERR_INVALIDPLAYER, hr );
 
    hr = IDirectPlayX_GetPlayerData( pDP, 0, lpDataGet, &dwDataSizeGet, 0 );
    todo_wine checkHR( DPERR_INVALIDPLAYER, hr );
 
    if ( hr == DPERR_UNINITIALIZED )
    {
        todo_wine win_skip( "Get/SetPlayerData not implemented\n" );
        return;
    }
 
    /* Create the player */
    /* By default, the data is remote */
    hr = IDirectPlayX_CreatePlayer( pDP, &dpid, NULL, NULL, (LPVOID) lpData,
                                    dwDataSize, 0 );
    checkHR( DP_OK, hr );
 
    /* Invalid parameters */
    hr = IDirectPlayX_SetPlayerData( pDP, dpid, NULL, dwDataSize, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
    hr = IDirectPlayX_SetPlayerData( pDP, dpid, lpDataGet, -1, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, NULL, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
 
    /*
     * Remote data (default)
     */
 
 
    /* Buffer redimension */
    dwDataSizeGet = dwDataSizeFake;
    strcpy(lpDataGet, lpDataFake);
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, NULL,
                                     &dwDataSizeGet, 0 );
    check( DPERR_BUFFERTOOSMALL, hr );
    check( dwDataSize, dwDataSizeGet );
    checkStr( lpDataFake, lpDataGet );
 
    dwDataSizeGet = 2;
    strcpy(lpDataGet, lpDataFake);
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 );
    check( DPERR_BUFFERTOOSMALL, hr );
    check( dwDataSize, dwDataSizeGet );
 
    strcpy(lpDataGet, lpDataFake);
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 );
    checkHR( DP_OK, hr );
    check( dwDataSize, dwDataSizeGet );
    checkStr( lpData, lpDataGet );
 
    /* Normal operation */
    dwDataSizeGet = dwDataSizeFake;
    strcpy(lpDataGet, lpDataFake);
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 );
    checkHR( DP_OK, hr );
    check( dwDataSize, dwDataSizeGet );
    checkStr( lpData, lpDataGet );
 
    /* Flag tests */
    dwDataSizeGet = dwDataSizeFake;
    strcpy(lpDataGet, lpDataFake);
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 );
    checkHR( DP_OK, hr );
    check( dwDataSize, dwDataSizeGet ); /* Remote: works as expected */
    checkStr( lpData, lpDataGet );
 
    dwDataSizeGet = dwDataSizeFake;
    strcpy(lpDataGet, lpDataFake);
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet,
                                     DPGET_REMOTE );
    checkHR( DP_OK, hr );
    check( dwDataSize, dwDataSizeGet ); /* Same behaviour as in previous test */
    checkStr( lpData, lpDataGet );
 
    dwDataSizeGet = dwDataSizeFake;
    strcpy(lpDataGet, lpDataFake);
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet,
                                     DPGET_LOCAL );
    checkHR( DP_OK, hr );
    check( 0, dwDataSizeGet ); /* Sets size to 0 (as local data doesn't exist) */
    checkStr( lpDataFake, lpDataGet );
 
    dwDataSizeGet = dwDataSizeFake;
    strcpy(lpDataGet, lpDataFake);
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet,
                                     DPGET_LOCAL | DPGET_REMOTE );
    checkHR( DP_OK, hr );
    check( 0, dwDataSizeGet ); /* Same behaviour as in previous test */
    checkStr( lpDataFake, lpDataGet );
 
    /* Getting local data (which doesn't exist), buffer size is ignored */
    dwDataSizeGet = 0;
    strcpy(lpDataGet, lpDataFake);
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet,
                                     DPGET_LOCAL );
    checkHR( DP_OK, hr );
    check( 0, dwDataSizeGet ); /* Sets size to 0 */
    checkStr( lpDataFake, lpDataGet );
 
    dwDataSizeGet = dwDataSizeFake;
    strcpy(lpDataGet, lpDataFake);
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, NULL, &dwDataSizeGet,
                                     DPGET_LOCAL );
    checkHR( DP_OK, hr );
    check( 0, dwDataSizeGet ); /* Sets size to 0 */
    checkStr( lpDataFake, lpDataGet );
 
 
    /*
     * Local data
     */
 
 
    /* Invalid flags */
    hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataLocal,
                                     dwDataSizeLocal,
                                     DPSET_LOCAL | DPSET_GUARANTEED );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    /* Correct parameters */
    hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataLocal,
                                     dwDataSizeLocal, DPSET_LOCAL );
    checkHR( DP_OK, hr );
 
    /* Flag tests (again) */
    dwDataSizeGet = dwDataSizeFake;
    strcpy(lpDataGet, lpDataFake);
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 );
    checkHR( DP_OK, hr );
    check( dwDataSize, dwDataSizeGet ); /* Remote: works as expected */
    checkStr( lpData, lpDataGet );
 
    dwDataSizeGet = dwDataSizeFake;
    strcpy(lpDataGet, lpDataFake);
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet,
                                     DPGET_REMOTE );
    checkHR( DP_OK, hr );
    check( dwDataSize, dwDataSizeGet ); /* Like in previous test */
    checkStr( lpData, lpDataGet );
 
    dwDataSizeGet = dwDataSizeFake;
    strcpy(lpDataGet, lpDataFake);
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet,
                                     DPGET_LOCAL );
    checkHR( DP_OK, hr );
    check( dwDataSizeLocal, dwDataSizeGet ); /* Local: works as expected */
    checkStr( lpDataLocal, lpDataGet );
 
    dwDataSizeGet = dwDataSizeFake;
    strcpy(lpDataGet, lpDataFake);
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet,
                                     DPGET_LOCAL | DPGET_REMOTE );
    checkHR( DP_OK, hr );
    check( dwDataSizeLocal, dwDataSizeGet ); /* Like in previous test */
    checkStr( lpDataLocal, lpDataGet );
 
    /* Small buffer works as expected again */
    dwDataSizeGet = 0;
    strcpy(lpDataGet, lpDataFake);
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet,
                                     DPGET_LOCAL );
    checkHR( DPERR_BUFFERTOOSMALL, hr );
    check( dwDataSizeLocal, dwDataSizeGet );
    checkStr( lpDataFake, lpDataGet );
 
    dwDataSizeGet = dwDataSizeFake;
    strcpy(lpDataGet, lpDataFake);
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, NULL,
                                     &dwDataSizeGet, DPGET_LOCAL );
    check( DPERR_BUFFERTOOSMALL, hr );
    check( dwDataSizeLocal, dwDataSizeGet );
    checkStr( lpDataFake, lpDataGet );
 
 
    /*
     * Changing remote data
     */
 
 
    /* Remote data := local data */
    hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataLocal,
                                     dwDataSizeLocal,
                                     DPSET_GUARANTEED | DPSET_REMOTE );
    checkHR( DP_OK, hr );
    hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataLocal,
                                     dwDataSizeLocal, 0 );
    checkHR( DP_OK, hr );
 
    dwDataSizeGet = dwDataSizeFake;
    strcpy(lpDataGet, lpDataFake);
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 );
    checkHR( DP_OK, hr );
    check( dwDataSizeLocal, dwDataSizeGet );
    checkStr( lpDataLocal, lpDataGet );
 
    /* Remote data := fake data */
    hr = IDirectPlayX_SetPlayerData( pDP, dpid, (LPVOID) lpDataFake,
                                     dwDataSizeFake, DPSET_REMOTE );
    checkHR( DP_OK, hr );
 
    dwDataSizeGet = dwDataSizeFake + 1;
    strcpy(lpDataGet, lpData);
    hr = IDirectPlayX_GetPlayerData( pDP, dpid, lpDataGet, &dwDataSizeGet, 0 );
    checkHR( DP_OK, hr );
    check( dwDataSizeFake, dwDataSizeGet );
    checkStr( lpDataFake, lpDataGet );
 
 
    free( lpDataGet );
    IDirectPlayX_Release( pDP );
}

Referenced by START_TEST().

◆ test_PlayerName()

static void test_PlayerName ( void )

static

Definition at line 5710 of file dplayx.c.

{
 
    IDirectPlay4 *pDP[2];
    DPSESSIONDESC2 dpsd;
    DPID dpid[2];
    HRESULT hr;
    UINT i;
 
    DPNAME playerName;
    DWORD dwDataSize = 1024;
    LPVOID lpData = calloc( 1, dwDataSize );
    CallbackData callbackData;
 
 
    for (i=0; i<2; i++)
    {
        hr= CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                              &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
        ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
        if (FAILED(hr)) return;
    }
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
    ZeroMemory( &playerName, sizeof(DPNAME) );
 
 
    /* Service provider not initialized */
    hr = IDirectPlayX_SetPlayerName( pDP[0], 0, &playerName, 0 );
    checkHR( DPERR_UNINITIALIZED, hr );
 
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerName( pDP[0], 0, lpData, &dwDataSize );
    checkHR( DPERR_UNINITIALIZED, hr );
    check( 1024, dwDataSize );
 
 
    init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
    init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
 
 
    /* Session not initialized */
    hr = IDirectPlayX_SetPlayerName( pDP[0], 0, &playerName, 0 );
    todo_wine checkHR( DPERR_INVALIDPLAYER, hr );
 
    if ( hr == DPERR_UNINITIALIZED )
    {
        todo_wine win_skip( "Get/SetPlayerName not implemented\n" );
        return;
    }
 
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerName( pDP[0], 0, lpData, &dwDataSize );
    checkHR( DPERR_INVALIDPLAYER, hr );
    check( 1024, dwDataSize );
 
 
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    dpsd.dwMaxPlayers = 10;
    IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
    IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
                               pDP[1], 0 );
 
    IDirectPlayX_CreatePlayer( pDP[0], &dpid[0], NULL, NULL, NULL, 0, 0 );
    IDirectPlayX_CreatePlayer( pDP[1], &dpid[1], NULL, NULL, NULL, 0, 0 );
 
 
    /* Name not initialized */
    playerName.dwSize = -1;
    hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName, 0 );
    checkHR( DP_OK, hr );
 
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerName( pDP[0], 0, lpData, &dwDataSize );
    checkHR( DPERR_INVALIDPLAYER, hr );
    check( 1024, dwDataSize );
 
 
    playerName.dwSize = sizeof(DPNAME);
    playerName.lpszShortNameA = (LPSTR) "player_name";
    playerName.lpszLongNameA = (LPSTR) "player_long_name";
 
 
    /* Invalid parameters */
    hr = IDirectPlayX_SetPlayerName( pDP[0], -1, &playerName, 0 );
    checkHR( DPERR_INVALIDPLAYER, hr );
    hr = IDirectPlayX_SetPlayerName( pDP[0], 0, &playerName, 0 );
    checkHR( DPERR_INVALIDPLAYER, hr );
    hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName, -1 );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerName( pDP[0], 0, lpData, &dwDataSize );
    checkHR( DPERR_INVALIDPLAYER, hr );
    check( 1024, dwDataSize );
 
if(0)
{
    /* Crashes under Win7 */
    dwDataSize = -1;
    hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
    check( -1, dwDataSize );
}
 
    hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, NULL );
    checkHR( DPERR_INVALIDPARAMS, hr );
 
    /* Trying to modify remote player */
    hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[1], &playerName, 0 );
    checkHR( DPERR_ACCESSDENIED, hr );
 
 
    /* Regular operation */
    hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName, 0 );
    checkHR( DP_OK, hr );
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize );
    checkHR( DP_OK, hr );
    check( 45, dwDataSize );
    checkStr( playerName.lpszShortNameA, ((LPDPNAME)lpData)->lpszShortNameA );
    checkStr( playerName.lpszLongNameA,  ((LPDPNAME)lpData)->lpszLongNameA );
    check( 0,                            ((LPDPNAME)lpData)->dwFlags );
 
    hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], NULL, 0 );
    checkHR( DP_OK, hr );
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize );
    checkHR( DP_OK, hr );
    check( 16, dwDataSize );
    checkLP( NULL, ((LPDPNAME)lpData)->lpszShortNameA );
    checkLP( NULL, ((LPDPNAME)lpData)->lpszLongNameA );
    check( 0,      ((LPDPNAME)lpData)->dwFlags );
 
 
    /* Small buffer in get operation */
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], NULL, &dwDataSize );
    checkHR( DPERR_BUFFERTOOSMALL, hr );
    check( 16, dwDataSize );
 
    dwDataSize = 0;
    hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize );
    checkHR( DPERR_BUFFERTOOSMALL, hr );
    check( 16, dwDataSize );
 
    hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize );
    checkHR( DP_OK, hr );
    check( 16, dwDataSize );
    checkLP( NULL, ((LPDPNAME)lpData)->lpszShortNameA );
    checkLP( NULL, ((LPDPNAME)lpData)->lpszLongNameA );
    check( 0, ((LPDPNAME)lpData)->dwFlags );
 
 
    /* Flags */
    hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName,
                                     DPSET_GUARANTEED );
    checkHR( DP_OK, hr );
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0], lpData, &dwDataSize );
    checkHR( DP_OK, hr );
    check( 45, dwDataSize );
    checkStr( playerName.lpszShortNameA, ((LPDPNAME)lpData)->lpszShortNameA );
    checkStr( playerName.lpszLongNameA,  ((LPDPNAME)lpData)->lpszLongNameA );
    check( 0, ((LPDPNAME)lpData)->dwFlags );
 
    /* - Local (no propagation) */
    playerName.lpszShortNameA = (LPSTR) "no_propagation";
    hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName,
                                     DPSET_LOCAL );
    checkHR( DP_OK, hr );
 
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0],
                                     lpData, &dwDataSize ); /* Local fetch */
    checkHR( DP_OK, hr );
    check( 48, dwDataSize );
    checkStr( "no_propagation", ((LPDPNAME)lpData)->lpszShortNameA );
 
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerName( pDP[1], dpid[0],
                                     lpData, &dwDataSize ); /* Remote fetch */
    checkHR( DP_OK, hr );
    check( 45, dwDataSize );
    checkStr( "player_name", ((LPDPNAME)lpData)->lpszShortNameA );
 
    /* -- 2 */
 
    playerName.lpszShortNameA = (LPSTR) "no_propagation_2";
    hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName,
                                     DPSET_LOCAL | DPSET_REMOTE );
    checkHR( DP_OK, hr );
 
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerName( pDP[0], dpid[0],
                                     lpData, &dwDataSize ); /* Local fetch */
    checkHR( DP_OK, hr );
    check( 50, dwDataSize );
    checkStr( "no_propagation_2", ((LPDPNAME)lpData)->lpszShortNameA );
 
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerName( pDP[1], dpid[0],
                                     lpData, &dwDataSize ); /* Remote fetch */
    checkHR( DP_OK, hr );
    check( 45, dwDataSize );
    checkStr( "player_name", ((LPDPNAME)lpData)->lpszShortNameA );
 
    /* - Remote (propagation, default) */
    playerName.lpszShortNameA = (LPSTR) "propagation";
    hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName,
                                     DPSET_REMOTE );
    checkHR( DP_OK, hr );
 
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerName( pDP[1], dpid[0],
                                     lpData, &dwDataSize ); /* Remote fetch */
    checkHR( DP_OK, hr );
    check( 45, dwDataSize );
    checkStr( "propagation", ((LPDPNAME)lpData)->lpszShortNameA );
 
    /* -- 2 */
    playerName.lpszShortNameA = (LPSTR) "propagation_2";
    hr = IDirectPlayX_SetPlayerName( pDP[0], dpid[0], &playerName,
                                     0 );
    checkHR( DP_OK, hr );
 
    dwDataSize = 1024;
    hr = IDirectPlayX_GetPlayerName( pDP[1], dpid[0],
                                     lpData, &dwDataSize ); /* Remote fetch */
    checkHR( DP_OK, hr );
    check( 47, dwDataSize );
    checkStr( "propagation_2", ((LPDPNAME)lpData)->lpszShortNameA );
 
 
    /* Checking system messages */
    check_messages( pDP[0], dpid, 2, &callbackData );
    checkStr( "S0,S0,S0,S0,S0,S0,S0,", callbackData.szTrace1 );
    checkStr( "48,28,57,28,57,57,59,", callbackData.szTrace2 );
    check_messages( pDP[1], dpid, 2, &callbackData );
    checkStr( "S1,S1,S1,S1,S1,S1,", callbackData.szTrace1 );
    checkStr( "28,57,28,57,57,59,", callbackData.szTrace2 );
 
 
    free( lpData );
    IDirectPlayX_Release( pDP[0] );
    IDirectPlayX_Release( pDP[1] );
 
}

Referenced by START_TEST().

◆ test_Receive()

static void test_Receive ( void )

static

Definition at line 8580 of file dplayx.c.

{
    DPSESSIONDESC2 appGuidDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidApplication = appGuid,
        .guidInstance = appGuid,
    };
    DPSESSIONDESC2 serverDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidApplication = appGuid,
        .guidInstance = appGuid,
        .lpszSessionName = (WCHAR *) L"normal",
        .dwReserved1 = 0xaabbccdd,
    };
    BYTE data0[] = { 1, 2, 3, 4, 5, 6, 7, 8, };
    BYTE data1[] = { 4, 3, 2, 1, };
    unsigned short udpPort;
    BYTE msgData[ 256 ];
    DWORD msgDataSize;
    DPID fromId, toId;
    DWORD waitResult;
    IDirectPlay4 *dp;
    SOCKET sendSock;
    SOCKET recvSock;
    SOCKET udpSock;
    HANDLE event0;
    HANDLE event1;
    HRESULT hr;
 
    event0 = CreateEventA( NULL, FALSE, FALSE, NULL );
    event1 = CreateEventA( NULL, FALSE, FALSE, NULL );
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlay4A, (void **) &dp );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
 
    msgDataSize = sizeof( msgData );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, 0, msgData, &msgDataSize );
    ok( hr == DPERR_UNINITIALIZED, "got hr %#lx.\n", hr );
 
    init_TCPIP_provider( dp, "127.0.0.1", 0 );
 
    msgDataSize = sizeof( msgData );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, 0, msgData, &msgDataSize );
    ok( hr == DPERR_NOMESSAGES, "got hr %#lx.\n", hr );
 
    joinSession( dp, &appGuidDpsd, &serverDpsd, &sendSock, &recvSock, &udpPort );
 
    createPlayer( dp, 0x07734, event0, NULL, 0, 0, sendSock, recvSock );
    createPlayer( dp, 0x14, event1, NULL, 0, 0, sendSock, recvSock );
 
    waitResult = WaitForSingleObject( event0, 2000 );
    ok( waitResult == WAIT_OBJECT_0, "message wait returned %lu\n", waitResult );
 
    checkCreatePlayerOrGroupMessage( dp, DPPLAYERTYPE_PLAYER, 0x14, 3, NULL, 0, NULL, NULL, 0, DPPLAYER_LOCAL );
 
    sendGuaranteedGameMessage( sendSock, 2349, 0x1337, 0x07734, data0, sizeof( data0 ) );
    sendGuaranteedGameMessage( sendSock, 2349, 0x1337, 0x14, data1, sizeof( data1 ) );
 
    waitResult = WaitForSingleObject( event0, 2000 );
    ok( waitResult == WAIT_OBJECT_0, "message wait returned %lu\n", waitResult );
    waitResult = WaitForSingleObject( event1, 2000 );
    ok( waitResult == WAIT_OBJECT_0, "message wait returned %lu\n", waitResult );
 
    fromId = 0xdeadbeef;
    toId = 0xdeadbeef;
    msgDataSize = sizeof( data0 ) - 1;
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, DPRECEIVE_ALL | DPRECEIVE_PEEK, msgData, &msgDataSize );
    ok( hr == DPERR_BUFFERTOOSMALL, "got hr %#lx.\n", hr );
    ok( fromId == 0xdeadbeef, "got source id %#lx.\n", fromId );
    ok( toId == 0xdeadbeef, "got destination id %#lx.\n", toId );
    ok( msgDataSize == sizeof( data0 ), "got message size %lu.\n", msgDataSize );
 
    fromId = 0xdeadbeef;
    toId = 0xdeadbeef;
    msgDataSize = sizeof( msgData );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, 0, NULL, &msgDataSize );
    ok( hr == DPERR_BUFFERTOOSMALL, "got hr %#lx.\n", hr );
    ok( fromId == 0xdeadbeef, "got source id %#lx.\n", fromId );
    ok( toId == 0xdeadbeef, "got destination id %#lx.\n", toId );
    ok( msgDataSize == sizeof( data0 ), "got message size %lu.\n", msgDataSize );
 
    fromId = 0xdeadbeef;
    toId = 0xdeadbeef;
    memset( msgData, 0xcc, sizeof( msgData ) );
    msgDataSize = sizeof( msgData );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, DPRECEIVE_ALL | DPRECEIVE_PEEK, msgData, &msgDataSize );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    ok( fromId == 0x1337, "got source id %#lx.\n", fromId );
    ok( toId == 0x07734, "got destination id %#lx.\n", toId );
    ok( !memcmp( msgData, data0, sizeof( data0 ) ), "message data didn't match.\n" );
    ok( msgDataSize == sizeof( data0 ), "got message size %lu.\n", msgDataSize );
 
    fromId = 0xdeadbeef;
    toId = 0xdeadbeef;
    memset( msgData, 0xcc, sizeof( msgData ) );
    msgDataSize = sizeof( msgData );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, DPRECEIVE_PEEK, msgData, &msgDataSize );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    ok( fromId == 0x1337, "got source id %#lx.\n", fromId );
    ok( toId == 0x07734, "got destination id %#lx.\n", toId );
    ok( !memcmp( msgData, data0, sizeof( data0 ) ), "message data didn't match.\n" );
    ok( msgDataSize == sizeof( data0 ), "got message size %lu.\n", msgDataSize );
 
    fromId = 0xdeadbeef;
    toId = 0xdeadbeef;
    memset( msgData, 0xcc, sizeof( msgData ) );
    msgDataSize = sizeof( msgData );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, 0, msgData, &msgDataSize );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    ok( fromId == 0x1337, "got source id %#lx.\n", fromId );
    ok( toId == 0x07734, "got destination id %#lx.\n", toId );
    ok( !memcmp( msgData, data0, sizeof( data0 ) ), "message data didn't match.\n" );
    ok( msgDataSize == sizeof( data0 ), "got message size %lu.\n", msgDataSize );
 
    fromId = 0xdeadbeef;
    toId = 0xdeadbeef;
    memset( msgData, 0xcc, sizeof( msgData ) );
    msgDataSize = sizeof( msgData );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, 0, msgData, &msgDataSize );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    ok( fromId == 0x1337, "got source id %#lx.\n", fromId );
    ok( toId == 0x14, "got destination id %#lx.\n", toId );
    ok( !memcmp( msgData, data1, sizeof( data1 ) ), "message data didn't match.\n" );
    ok( msgDataSize == sizeof( data1 ), "got message size %lu.\n", msgDataSize );
 
    msgDataSize = sizeof( msgData );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, 0, msgData, &msgDataSize );
    ok( hr == DPERR_NOMESSAGES, "got hr %#lx.\n", hr );
 
    sendGuaranteedGameMessage( sendSock, 2349, 0x1337, 0x07734, data0, sizeof( data0 ) );
 
    waitResult = WaitForSingleObject( event0, 2000 );
    ok( waitResult == WAIT_OBJECT_0, "message wait returned %lu\n", waitResult );
 
    fromId = 0x14;
    toId = 0xdeadbeef;
    msgDataSize = sizeof( msgData );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, DPRECEIVE_FROMPLAYER, msgData, &msgDataSize );
    ok( hr == DPERR_NOMESSAGES, "got hr %#lx.\n", hr );
 
    fromId = 0x1337;
    toId = 0xdeadbeef;
    memset( msgData, 0xcc, sizeof( msgData ) );
    msgDataSize = sizeof( msgData );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, DPRECEIVE_FROMPLAYER, msgData, &msgDataSize );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    ok( fromId == 0x1337, "got source id %#lx.\n", fromId );
    ok( toId == 0x07734, "got destination id %#lx.\n", toId );
    ok( !memcmp( msgData, data0, sizeof( data0 ) ), "message data didn't match.\n" );
    ok( msgDataSize == sizeof( data0 ), "got message size %lu.\n", msgDataSize );
 
    fromId = 0x1337;
    toId = 0xdeadbeef;
    msgDataSize = sizeof( msgData );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, DPRECEIVE_FROMPLAYER, msgData, &msgDataSize );
    ok( hr == DPERR_NOMESSAGES, "got hr %#lx.\n", hr );
 
    sendGuaranteedGameMessage( sendSock, 2349, 0x1337, DPID_ALLPLAYERS, data0, sizeof( data0 ) );
 
    waitResult = WaitForSingleObject( event0, 2000 );
    ok( waitResult == WAIT_OBJECT_0, "message wait returned %lu\n", waitResult );
    waitResult = WaitForSingleObject( event1, 2000 );
    ok( waitResult == WAIT_OBJECT_0, "message wait returned %lu\n", waitResult );
 
    fromId = 0xdeadbeef;
    toId = 0x07734;
    memset( msgData, 0xcc, sizeof( msgData ) );
    msgDataSize = sizeof( msgData );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, DPRECEIVE_TOPLAYER, msgData, &msgDataSize );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    ok( fromId == 0x1337, "got source id %#lx.\n", fromId );
    ok( toId == 0x07734, "got destination id %#lx.\n", toId );
    ok( !memcmp( msgData, data0, sizeof( data0 ) ), "message data didn't match.\n" );
    ok( msgDataSize == sizeof( data0 ), "got message size %lu.\n", msgDataSize );
 
    toId = 0x07734;
    msgDataSize = sizeof( msgData );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, DPRECEIVE_TOPLAYER, msgData, &msgDataSize );
    ok( hr == DPERR_NOMESSAGES, "got hr %#lx.\n", hr );
 
    fromId = 0xdeadbeef;
    toId = 0x14;
    memset( msgData, 0xcc, sizeof( msgData ) );
    msgDataSize = sizeof( msgData );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, DPRECEIVE_TOPLAYER, msgData, &msgDataSize );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    ok( fromId == 0x1337, "got source id %#lx.\n", fromId );
    ok( toId == 0x14, "got destination id %#lx.\n", toId );
    ok( !memcmp( msgData, data0, sizeof( data0 ) ), "message data didn't match.\n" );
    ok( msgDataSize == sizeof( data0 ), "got message size %lu.\n", msgDataSize );
 
    toId = 0x14;
    msgDataSize = sizeof( msgData );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, DPRECEIVE_TOPLAYER, msgData, &msgDataSize );
    ok( hr == DPERR_NOMESSAGES, "got hr %#lx.\n", hr );
 
    udpSock = connectUdp( udpPort );
 
    sendGameMessage( udpSock, 0x1337, 0x07734, data0, sizeof( data0 ) );
 
    waitResult = WaitForSingleObject( event0, 2000 );
    ok( waitResult == WAIT_OBJECT_0, "message wait returned %lu\n", waitResult );
 
    fromId = 0xdeadbeef;
    toId = 0xdeadbeef;
    memset( msgData, 0xcc, sizeof( msgData ) );
    msgDataSize = sizeof( msgData );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, 0, msgData, &msgDataSize );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
    ok( fromId == 0x1337, "got source id %#lx.\n", fromId );
    ok( toId == 0x07734, "got destination id %#lx.\n", toId );
    ok( !memcmp( msgData, data0, sizeof( data0 ) ), "message data didn't match.\n" );
    ok( msgDataSize == sizeof( data0 ), "got message size %lu.\n", msgDataSize );
 
    msgDataSize = sizeof( msgData );
    hr = IDirectPlayX_Receive( dp, &fromId, &toId, 0, msgData, &msgDataSize );
    ok( hr == DPERR_NOMESSAGES, "got hr %#lx.\n", hr );
 
    closesocket( udpSock );
    closesocket( recvSock );
    closesocket( sendSock );
 
    IDirectPlayX_Release( dp );
 
    CloseHandle( event1 );
    CloseHandle( event0 );
}

Referenced by START_TEST().

◆ test_remote_data_replication()

static void test_remote_data_replication ( void )

static

Definition at line 10049 of file dplayx.c.

{
 
    IDirectPlay4 *pDP[2];
    DPSESSIONDESC2 dpsd;
    DPID dpid[2], idFrom, idTo;
    CallbackData callbackData;
    HRESULT hr;
    UINT i, j;
    DWORD dwFlags, dwDataSize = 1024;
    DWORD dwCount;
 
    LPDPMSG_SETPLAYERORGROUPDATA lpData = calloc( 1, dwDataSize );
 
    LPCSTR lpDataLocal[] = { "local_0", "local_1" };
    LPCSTR lpDataRemote[] = { "remote_0", "remote_1" };
    LPCSTR lpDataFake = "ugly_fake_data";
    LPSTR lpDataGet = calloc( 1, 32 );
    DWORD dwDataSizeLocal = strlen(lpDataLocal[0])+1,
        dwDataSizeRemote = strlen(lpDataRemote[0])+1,
        dwDataSizeFake = strlen(lpDataFake)+1,
        dwDataSizeGet;
 
 
    for (i=0; i<2; i++)
    {
        hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                               &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
        ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
        if (FAILED(hr)) return;
        init_TCPIP_provider( pDP[i], "127.0.0.1", 0 );
    }
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
 
    /* Host */
    hr = IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
    todo_wine checkHR( DP_OK, hr );
 
    if ( hr == DPERR_UNINITIALIZED )
    {
        todo_wine win_skip( "dplay not implemented enough for this test yet\n" );
        return;
    }
 
    hr = IDirectPlayX_CreatePlayer( pDP[0], &dpid[0],
                                    NULL, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
    /* Peer */
    hr = IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
                                    pDP[1], 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_CreatePlayer( pDP[1], &dpid[1],
                                    NULL, NULL, NULL, 0, 0 );
    checkHR( DP_OK, hr );
 
    /* Check players */
    for (i=0; i<2; i++)
    {
        /* Local (0,0) (1,1) */
        IDirectPlayX_GetPlayerFlags( pDP[i], dpid[i], &dwFlags );
        checkFlags( DPPLAYER_LOCAL, dwFlags, FLAGS_DPPLAYER );
        /* Remote (0,1) (1,0) */
        IDirectPlayX_GetPlayerFlags( pDP[i], dpid[!i], &dwFlags );
        checkFlags( 0, dwFlags, FLAGS_DPPLAYER );
    }
 
    /* Set data for a local player */
    for (i=0; i<2; i++)
    {
        hr = IDirectPlayX_SetPlayerData( pDP[i], dpid[i],
                                         (LPVOID) lpDataLocal[i],
                                         dwDataSizeLocal,
                                         DPSET_LOCAL );
        checkHR( DP_OK, hr );
        hr = IDirectPlayX_SetPlayerData( pDP[i], dpid[i],
                                         (LPVOID) lpDataRemote[i],
                                         dwDataSizeRemote,
                                         DPSET_REMOTE );
        checkHR( DP_OK, hr );
    }
 
    /* Retrieve data locally (0->0, 1->1) */
    for (i=0; i<2; i++)
    {
        dwDataSizeGet = dwDataSizeFake;
        strcpy( lpDataGet, lpDataFake );
        hr = IDirectPlayX_GetPlayerData( pDP[i], dpid[i],
                                         lpDataGet, &dwDataSizeGet,
                                         DPGET_LOCAL );
        checkHR( DP_OK, hr );
        check( dwDataSizeLocal, dwDataSizeGet );
        checkStr( lpDataLocal[i], lpDataGet );
 
        dwDataSizeGet = dwDataSizeFake;
        strcpy( lpDataGet, lpDataFake );
        hr = IDirectPlayX_GetPlayerData( pDP[i], dpid[i],
                                         lpDataGet, &dwDataSizeGet,
                                         DPGET_REMOTE );
        checkHR( DP_OK, hr );
        check( dwDataSizeRemote, dwDataSizeGet );
        checkStr( lpDataRemote[i], lpDataGet );
    }
 
 
    /* Set data for a remote player */
    /* This should fail with DPERR_ACCESSDENIED,
       but for some reason it doesn't */
    for (i=0; i<2; i++)
    {
        IDirectPlayX_SetPlayerData( pDP[i], dpid[!i],
                                    (LPVOID) lpDataLocal[!i],
                                    dwDataSizeLocal,
                                    DPSET_LOCAL );
        checkHR( DP_OK, hr );
        IDirectPlayX_SetPlayerData( pDP[i], dpid[!i],
                                    (LPVOID) lpDataRemote[!i],
                                    dwDataSizeRemote,
                                    DPSET_REMOTE );
        checkHR( DP_OK, hr );
    }
 
    /* Retrieve crossed data (0->1, 1->0) */
    for (i=0; i<2; i++)
    {
        dwDataSizeGet = dwDataSizeFake;
        strcpy( lpDataGet, lpDataFake );
        hr = IDirectPlayX_GetPlayerData( pDP[i], dpid[!i],
                                         lpDataGet, &dwDataSizeGet,
                                         DPGET_LOCAL );
        checkHR( DP_OK, hr );
        check( dwDataSizeLocal, dwDataSizeGet );
        checkStr( lpDataLocal[!i], lpDataGet );
 
        dwDataSizeGet = dwDataSizeFake;
        strcpy( lpDataGet, lpDataFake );
        hr = IDirectPlayX_GetPlayerData( pDP[i], dpid[!i],
                                         lpDataGet, &dwDataSizeGet,
                                         DPGET_REMOTE );
        checkHR( DP_OK, hr );
        check( dwDataSizeRemote, dwDataSizeGet );
        checkStr( lpDataRemote[!i], lpDataGet );
    }
 
 
    /* Purge "new player" messages from queue */
    hr = IDirectPlayX_Receive( pDP[0], &idFrom, &idTo, 0, lpData, &dwDataSize );
    checkHR( DP_OK, hr );
    checkConv( DPSYS_CREATEPLAYERORGROUP, lpData->dwType, dpMsgType2str );
 
    /* Check number of messages in queue */
    for (i=0; i<2; i++)
    {
        IDirectPlayX_GetMessageCount( pDP[i], dpid[i], &dwCount );
        check( 2, dwCount );
        IDirectPlayX_GetMessageCount( pDP[i], dpid[!i], &dwCount );
        check( 0, dwCount );
    }
 
    /* Checking system messages */
    for (i=0; i<2; i++)
    {
        for (j=0; j<2; j++)
        {
            hr = IDirectPlayX_Receive( pDP[i], &idFrom, &idTo, 0, lpData,
                                       &dwDataSize );
            checkHR( DP_OK, hr );
            check( 29, dwDataSize );
            check( DPID_SYSMSG, idFrom );
            check( dpid[i], idTo );
            checkConv( DPSYS_SETPLAYERORGROUPDATA, lpData->dwType,
                       dpMsgType2str );
            check( DPPLAYERTYPE_PLAYER,            lpData->dwPlayerType );
            check( dpid[j],                        lpData->dpId );
            checkStr( lpDataRemote[j],     (LPSTR) lpData->lpData );
            check( dwDataSizeRemote,               lpData->dwDataSize );
            dwDataSize = 1024;
        }
        hr = IDirectPlayX_Receive( pDP[i], &idFrom, &idTo, 0,
                                   lpData, &dwDataSize );
        checkHR( DPERR_NOMESSAGES, hr );
    }
 
 
    /* Changing remote data */
    hr = IDirectPlayX_SetPlayerData( pDP[0], dpid[0],
                                     (LPVOID) lpDataRemote[0], dwDataSizeRemote,
                                     DPSET_REMOTE );
    checkHR( DP_OK, hr );
 
    /* Checking system messages (j=0) */
    for (i=0; i<2; i++)
    {
        hr = IDirectPlayX_Receive( pDP[i], &idFrom, &idTo, 0,
                                   lpData, &dwDataSize );
        checkHR( DP_OK, hr );
        check( 29, dwDataSize );
        check( DPID_SYSMSG, idFrom );
        check( dpid[i], idTo );
        checkConv( DPSYS_SETPLAYERORGROUPDATA, lpData->dwType, dpMsgType2str );
        check( DPPLAYERTYPE_PLAYER,            lpData->dwPlayerType );
        check( dpid[0],                        lpData->dpId );
        checkStr( lpDataRemote[0],     (LPSTR) lpData->lpData );
        check( dwDataSizeRemote,               lpData->dwDataSize );
        dwDataSize = 1024;
    }
 
    /* Queue is empty */
    check_messages( pDP[0], dpid, 2, &callbackData );
    checkStr( "", callbackData.szTrace1 );
    check_messages( pDP[1], dpid, 2, &callbackData );
    checkStr( "", callbackData.szTrace1 );
 
 
    free( lpDataGet );
    free( lpData );
    IDirectPlayX_Release( pDP[0] );
    IDirectPlayX_Release( pDP[1] );
 
}

Referenced by START_TEST().

◆ test_Send()

static void test_Send ( void )

static

Definition at line 8158 of file dplayx.c.

{
    DPSESSIONDESC2 appGuidDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidApplication = appGuid,
        .guidInstance = appGuid,
    };
    DPSESSIONDESC2 serverDpsd =
    {
        .dwSize = sizeof( DPSESSIONDESC2 ),
        .guidApplication = appGuid,
        .guidInstance = appGuid,
        .lpszSessionName = (WCHAR *) L"normal",
        .dwReserved1 = 0xaabbccdd,
    };
    BYTE data[] = { 1, 2, 3, 4, 5, 6, 7, 8, };
    IDirectPlay4 *dp;
    SOCKET sendSock;
    SOCKET recvSock;
    SOCKET udpSock;
    HRESULT hr;
    DPID dpid;
 
    hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectPlay4A, (void **) &dp );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
 
    hr = IDirectPlayX_Send( dp, 0x07734, 0x1337, DPSEND_GUARANTEED, data, sizeof( data ) );
    ok( hr == DPERR_UNINITIALIZED, "got hr %#lx.\n", hr );
 
    init_TCPIP_provider( dp, "127.0.0.1", 0 );
 
    hr = IDirectPlayX_Send( dp, 0x07734, 0x1337, DPSEND_GUARANTEED, data, sizeof( data ) );
    ok( hr == DPERR_INVALIDPLAYER, "got hr %#lx.\n", hr );
 
    joinSession( dp, &appGuidDpsd, &serverDpsd, &sendSock, &recvSock, NULL );
 
    createPlayer( dp, 0x07734, NULL, NULL, 0, 0, sendSock, recvSock );
    createPlayer( dp, 0x14, NULL, NULL, 0, 0, sendSock, recvSock );
 
    checkCreatePlayerOrGroupMessage( dp, DPPLAYERTYPE_PLAYER, 0x14, 3, NULL, 0, NULL, NULL, 0, DPPLAYER_LOCAL );
 
    hr = IDirectPlayX_Send( dp, 0x07734, 0xdeadbeef, DPSEND_GUARANTEED, data, sizeof( data ) );
    todo_wine ok( hr == DPERR_INVALIDPARAM, "got hr %#lx.\n", hr );
 
    hr = IDirectPlayX_Send( dp, 0x07734, 0x1337, DPSEND_GUARANTEED, data, sizeof( data ) );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
 
    receiveGuaranteedGameMessage( recvSock, 0x07734, 0x1337, data, sizeof( data ) );
 
    hr = IDirectPlayX_Send( dp, 0x07734, 0x14, DPSEND_GUARANTEED, data, sizeof( data ) );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
 
    dpid = checkPlayerMessage( dp, 0x07734, data, sizeof( data ) );
    ok( dpid == 0x14, "got destination id %#lx.\n", dpid );
 
    hr = IDirectPlayX_Send( dp, 0x07734, 0x07734, DPSEND_GUARANTEED, data, sizeof( data ) );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
 
    checkNoMorePlayerMessages( dp );
    checkNoMoreMessages( recvSock );
 
    hr = IDirectPlayX_Send( dp, 0x07734, DPID_ALLPLAYERS, DPSEND_GUARANTEED, data, sizeof( data ) );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
 
    dpid = checkPlayerMessage( dp, 0x07734, data, sizeof( data ) );
    ok( dpid == 0x14, "got destination id %#lx.\n", dpid );
    receiveGuaranteedGameMessage( recvSock, 0x07734, DPID_ALLPLAYERS, data, sizeof( data ) );
 
    udpSock = bindUdp( 2399 );
 
    hr = IDirectPlayX_Send( dp, 0x07734, 0x1337, 0, data, sizeof( data ) );
    ok( hr == DP_OK, "got hr %#lx.\n", hr );
 
    receiveGameMessage( udpSock, 0x07734, 0x1337, data, sizeof( data ) );
 
    checkNoMorePlayerMessages( dp );
    checkNoMoreMessages( udpSock );
    checkNoMoreMessages( recvSock );
 
    closesocket( udpSock );
    closesocket( recvSock );
    closesocket( sendSock );
 
    IDirectPlayX_Release( dp );
}

Referenced by START_TEST().

◆ test_SessionDesc()

static void test_SessionDesc ( void )

static

Definition at line 4526 of file dplayx.c.

{
 
    IDirectPlay4 *pDP[2];
    DPSESSIONDESC2 dpsd;
    LPDPSESSIONDESC2 lpData[2];
    LPVOID lpDataMsg;
    DPID dpid[2];
    DWORD dwDataSize;
    HRESULT hr;
    UINT i;
    CallbackData callbackData;
 
 
    for (i=0; i<2; i++)
    {
        hr = CoCreateInstance( &CLSID_DirectPlay, NULL, CLSCTX_ALL,
                               &IID_IDirectPlay4A, (LPVOID*) &pDP[i] );
        ok( SUCCEEDED(hr), "CCI of CLSID_DirectPlay / IID_IDirectPlay4A failed\n" );
        if (FAILED(hr)) return;
    }
    ZeroMemory( &dpsd, sizeof(DPSESSIONDESC2) );
 
    /* Service provider not initialized */
    hr = IDirectPlayX_SetSessionDesc( pDP[0], NULL, 0 );
    checkHR( DPERR_UNINITIALIZED, hr );
 
    hr = IDirectPlayX_GetSessionDesc( pDP[0], NULL, NULL );
    checkHR( DPERR_UNINITIALIZED, hr );
 
 
    init_TCPIP_provider( pDP[0], "127.0.0.1", 0 );
    init_TCPIP_provider( pDP[1], "127.0.0.1", 0 );
 
 
    /* No sessions open */
    hr = IDirectPlayX_SetSessionDesc( pDP[0], NULL, 0 );
    todo_wine checkHR( DPERR_NOSESSIONS, hr );
 
    if ( hr == DPERR_UNINITIALIZED )
    {
        todo_wine win_skip("Get/SetSessionDesc not implemented\n");
        return;
    }
 
    hr = IDirectPlayX_GetSessionDesc( pDP[0], NULL, NULL );
    checkHR( DPERR_NOSESSIONS, hr );
 
 
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    dpsd.guidApplication = appGuid;
    dpsd.dwMaxPlayers = 10;
 
 
    /* Host */
    IDirectPlayX_Open( pDP[0], &dpsd, DPOPEN_CREATE );
    /* Peer */
    IDirectPlayX_EnumSessions( pDP[1], &dpsd, 0, EnumSessions_cb_join,
                               pDP[1], 0 );
 
    for (i=0; i<2; i++)
    {
        /* Players, only to receive messages */
        IDirectPlayX_CreatePlayer( pDP[i], &dpid[i], NULL, NULL, NULL, 0, 0 );
 
        lpData[i] = calloc( 1, 1024 );
    }
    lpDataMsg = calloc( 1, 1024 );
 
 
    /* Incorrect parameters */
    hr = IDirectPlayX_SetSessionDesc( pDP[0], NULL, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
    hr = IDirectPlayX_GetSessionDesc( pDP[0], NULL, NULL );
    checkHR( DPERR_INVALIDPARAM, hr );
if(0)
{
    /* Crashes under Win7 */
    hr = IDirectPlayX_GetSessionDesc( pDP[0], lpData[0], NULL );
    checkHR( DPERR_INVALIDPARAM, hr );
    dwDataSize=-1;
    hr = IDirectPlayX_GetSessionDesc( pDP[0], lpData[0], &dwDataSize );
    checkHR( DPERR_INVALIDPARAMS, hr );
    check( -1, dwDataSize );
}
 
    /* Get: Insufficient buffer size */
    dwDataSize=0;
    hr = IDirectPlayX_GetSessionDesc( pDP[0], lpData[0], &dwDataSize );
    checkHR( DPERR_BUFFERTOOSMALL, hr );
    check( dpsd.dwSize, dwDataSize );
    dwDataSize=4;
    hr = IDirectPlayX_GetSessionDesc( pDP[0], lpData[0], &dwDataSize );
    checkHR( DPERR_BUFFERTOOSMALL, hr );
    check( dpsd.dwSize, dwDataSize );
    dwDataSize=1024;
    hr = IDirectPlayX_GetSessionDesc( pDP[0], NULL, &dwDataSize );
    checkHR( DPERR_BUFFERTOOSMALL, hr );
    check( dpsd.dwSize, dwDataSize );
 
    /* Get: Regular operation
     *  i=0: Local session
     *  i=1: Remote session */
    for (i=0; i<2; i++)
    {
        hr = IDirectPlayX_GetSessionDesc( pDP[i], lpData[i], &dwDataSize );
        checkHR( DP_OK, hr );
        check( sizeof(DPSESSIONDESC2), dwDataSize );
        check( sizeof(DPSESSIONDESC2), lpData[i]->dwSize );
        checkGuid( &appGuid, &lpData[i]->guidApplication );
        check( dpsd.dwMaxPlayers, lpData[i]->dwMaxPlayers );
    }
 
    checkGuid( &lpData[0]->guidInstance, &lpData[1]->guidInstance );
 
    /* Set: Regular operation */
    dpsd.lpszSessionNameA = (LPSTR) "Wahaa";
    hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 );
    checkHR( DP_OK, hr );
 
    dwDataSize = 1024;
    hr = IDirectPlayX_GetSessionDesc( pDP[1], lpData[1], &dwDataSize );
    checkHR( DP_OK, hr );
    checkStr( dpsd.lpszSessionNameA, lpData[1]->lpszSessionNameA );
 
 
    /* Set: Failing to modify a remote session */
    hr = IDirectPlayX_SetSessionDesc( pDP[1], &dpsd, 0 );
    checkHR( DPERR_ACCESSDENIED, hr );
 
    /* Trying to change immutable properties */
    /*  Flags */
    hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 );
    checkHR( DP_OK, hr );
    dpsd.dwFlags = DPSESSION_SECURESERVER;
    hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
    dpsd.dwFlags = 0;
    hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 );
    checkHR( DP_OK, hr );
    /*  Size */
    dpsd.dwSize = 2048;
    hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 );
    checkHR( DPERR_INVALIDPARAMS, hr );
    dpsd.dwSize = sizeof(DPSESSIONDESC2);
    hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 );
    checkHR( DP_OK, hr );
 
    /* Changing the GUIDs and size is ignored */
    dpsd.guidApplication = appGuid2;
    hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 );
    checkHR( DP_OK, hr );
    dpsd.guidInstance = appGuid2;
    hr = IDirectPlayX_SetSessionDesc( pDP[0], &dpsd, 0 );
    checkHR( DP_OK, hr );
 
    hr = IDirectPlayX_GetSessionDesc( pDP[0], lpData[0], &dwDataSize );
    checkHR( DP_OK, hr );
    checkGuid( &appGuid, &lpData[0]->guidApplication );
    checkGuid( &lpData[1]->guidInstance, &lpData[0]->guidInstance );
    check( sizeof(DPSESSIONDESC2), lpData[0]->dwSize );
 
 
    /* Checking system messages */
    check_messages( pDP[0], dpid, 2, &callbackData );
    checkStr( "S0,S0,S0,S0,S0,S0,S0,", callbackData.szTrace1 );
    checkStr( "48,90,90,90,90,90,90,", callbackData.szTrace2 );
    check_messages( pDP[1], dpid, 2, &callbackData );
    checkStr( "S1,S1,S1,S1,S1,S1,", callbackData.szTrace1 );
    checkStr( "90,90,90,90,90,90,", callbackData.szTrace2 );
 
    free( lpDataMsg );
    for (i=0; i<2; i++)
    {
        free( lpData[i] );
        IDirectPlayX_Release( pDP[i] );
    }
 
}

Referenced by START_TEST().

Variable Documentation

◆ enum_address_cb_count

int enum_address_cb_count = 0

static

Definition at line 2835 of file dplayx.c.

Referenced by EnumAddressTypeCallback(), and test_EnumAddressTypes().

◆ enum_addresses_cb_count

int enum_addresses_cb_count = 0

static

Definition at line 2768 of file dplayx.c.

Referenced by EnumAddressesCallback(), and test_EnumAddresses().

◆ lplpDP

void *static void *static LPDIRECTPLAY* lplpDP

Definition at line 41 of file dplayx.c.

Referenced by DirectPlayCreate(), DPL_ConnectEx(), IDirectPlayLobby3AImpl_ConnectEx(), and IDirectPlayLobby3Impl_ConnectEx().

◆ pUnk

void *static void *static LPDIRECTPLAY IUnknown* pUnk

Definition at line 41 of file dplayx.c.

Referenced by ATL::CComDynamicUnkArray::Add(), AntiMoniker_CreateInstance(), ATL::AtlAdvise(), AtlAdvise(), AtlAxGetControl(), AtlIPersistPropertyBag_Load(), AtlIPersistPropertyBag_Save(), AtlIPersistStreamInit_Load(), AtlIPersistStreamInit_Save(), AtlMarshalPtrInProc(), ClassMoniker_CreateInstance(), CoAllowSetForegroundWindow(), CoGetStandardMarshal(), CompositeMoniker_CreateInstance(), create_node(), create_stub(), CreateConnectionPoint(), CreateStartMenu(), DECLARE_INTERFACE_(), delegating_invoke_test_QI(), delegating_QueryInterface(), DirectPlayCreate(), domdoc_save(), DPL_ConnectEx(), EnumConnections_Next(), EnumConnectionsImpl_Construct(), RecycleBin5::EnumObjects(), ExecResetDefViewFolderSettings(), FileMoniker_CreateInstance(), FileSystemBindData_GetFindData(), FileSystemBindData_SetFindData(), FTMarshalCF_CreateInstance(), GetDefaultRecycleBin(), GetInterfaceOffset(), CFolderItem::GetParentAndItem(), HandlerCF_CreateInstance(), HlinkNavigateString(), HlinkSimpleNavigateToMoniker(), HlinkSimpleNavigateToString(), HTMLElement2_addFilter(), HTMLElement2_removeFilter(), IDirectPlayLobby3AImpl_ConnectEx(), IDirectPlayLobby3Impl_ConnectEx(), IDirectSoundCaptureImpl_CreateCaptureBuffer(), IDirectSoundFullDuplex_IDirectSoundCapture_CreateCaptureBuffer(), IMAPTransportCF_CreateInstance(), INetCfgComponent_fnRaisePropertyUi(), ATL::CComEnumImpl< Base, piid, T, Copy >::Init(), InvokeShellExecuteHook(), IPropertyBag_Read_Proxy(), ITypeInfo_fnCreateInstance(), IUnknown_InitializeCommand(), IUnknown_SetOwner(), list_invoke(), Load(), NdrInterfacePointerFree(), objectset_get__NewEnum(), OleCreate(), OleDraw(), OleLoad(), CTrayBandSite::OnSave(), PointerMoniker_CreateInstance(), POP3TransportCF_CreateInstance(), CInternetToolbar::QIBand(), CDocumentMgr::QueryInterface(), CThreadMgr::QueryInterface(), CContext::QueryInterface(), ReleaseBindInfo(), CBandSiteBase::SetDeskBarSite(), SHELL_InitializeExtension(), SHForwardContextMenuMsg(), SHGetObjectCompatFlags(), SHInvokeCommandOnContextMenu(), SHInvokeCommandOnContextMenuEx(), SHInvokeCommandOnContextMenuInternal(), SHInvokeCommandWithFlagsAndSite(), SHLoadInProc(), CInternetToolbar::ShowDW(), SHWeakQueryInterface(), SMTPTransportCF_CreateInstance(), START_TEST(), StdGlobalInterfaceTable_RegisterInterfaceInGlobal(), test_CoCreateInstance(), test_CoFreeUnusedLibraries(), test_CoGetCallContext(), test_CoGetClassObject(), test_CoGetInterfaceAndReleaseStream(), test_CopyBindInfo(), test_createDebugger(), test_DirectInput8Create(), test_DirectInputCreateEx(), test_get_clipboard_uninitialized(), test_Installer_Products(), Test_InvalidClsid(), test_OleInitialize_InitCounting(), test_pack_RemBINDINFO(), test_QueryInterface(), test_ReleaseBindInfo(), Test_Version(), TestManualInstantiation(), and TestModuleInterfaces().

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ acceptTcp

◆ AW

◆ bindUdp

◆ check

◆ check_CreatePlayer

◆ check_EnumSessions

◆ check_EnumSessions_async

◆ check_Open

◆ checkAddPlayerToGroupMessage

◆ checkConv

◆ checkCreatePlayerOrGroupMessage

◆ checkCreatePlayerOrGroupMessages

◆ checkFlags

◆ checkGameMessage

◆ checkGroupList

◆ checkGroupPlayerList

◆ checkGuid

◆ checkHR

◆ checkLP

◆ checkMessageHeader

◆ checkNoMoreAccepts

◆ checkNoMoreMessages

◆ checkNoMorePlayerMessages

◆ checkPackedPlayer

◆ checkPlayerExists

◆ checkPlayerList

◆ checkPlayerMessage

◆ checkSetPlayerOrGroupDataMessage

◆ checkSpData

◆ checkSpHeader

◆ checkStr

◆ COBJMACROS

◆ connectTcp

◆ connectUdp

◆ createPlayer

◆ FLAGS_DPCAPS

◆ FLAGS_DPCONNECT

◆ FLAGS_DPCONNECTION

◆ FLAGS_DPENUMGROUPS

◆ FLAGS_DPENUMPLAYERS

◆ FLAGS_DPENUMSESSIONS

◆ FLAGS_DPESC

◆ FLAGS_DPGET

◆ FLAGS_DPGETCAPS

◆ FLAGS_DPGROUP

◆ FLAGS_DPLCONNECTION

◆ FLAGS_DPMESSAGEQUEUE

◆ FLAGS_DPOPEN

◆ FLAGS_DPPLAYER

◆ FLAGS_DPRECEIVE

◆ FLAGS_DPSEND

◆ FLAGS_DPSESSION

◆ FLAGS_DPSET

◆ INITGUID

◆ joinSession

◆ listenTcp

◆ LONG_NAME

◆ N_SESSIONS

◆ receiveAddForwardAck

◆ receiveAddForwardRequest

◆ receiveAddPlayerToGroup

◆ receiveCreatePlayer

◆ receiveEnumSessionsRequest

◆ receiveGameMessage

◆ receiveGuaranteedGameMessage

◆ receiveMessage

◆ receivePingReply

◆ receiveRequestPlayerId

◆ sendAddForward

◆ sendAddForwardReply

◆ sendCreatePlayer

◆ sendEnumSessionsReply

◆ sendGameMessage