archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/net/tcpip/tpipv6/dplayip6/dpsp.c

4053 lines
122 KiB
Raw Blame History

/*==========================================================================
*
* Copyright (C) 1995 - 1997 Microsoft Corporation. All Rights Reserved.
*
* File: dpsp.c
* Content: sample direct play service provider, based on winsock
* History:
* Date By Reason
* ==== == ======
* 1/96 andyco created it
* 2/8/96 andyco steam + dgram model, including name server support
* 2/15/96 andyco added reliable receive. added send (udp + stream).
* added macros for dwReserved to clean up, (and provide
* means for reducing # dwords reserved per player)
* 3/13/96 andyco relaible send + receive for all players. MW2
* 3/16/96 andyco shutdown method - code cleanup - shared stream receive, etc.
* 3/19/96 andyco new message macros (IS_VALID, GET_MESSAGE_SIZE). see dpmess.h
* 4/3/96 andyco moved start up / shut down winsock code here from dllmain
* 4/10/96 andyco added spplayerdata
* 4/12/96 andyco got rid of dpmess.h! use DPlay_ instead of message macros
* 4/18/96 andyco added multihomed support, started ipx
* 4/23/96 andyco ipx support. ipx only - no spx. spx doesn't support
* graceful disconnect (winsock bug?) so we don't know
* when it's safe to closesocket.
* 4/25/96 andyco messages now have blobs (sockaddr's) instead of dwReserveds
* 5/31/96 andyco all non-system players share a socket (gsStream and
* gsDGramSocket).
* 6/9/96 andyco ouch. dplayi_player + group are gone!
* 6/19/96 andyco sp sets own header!
* 6/22/96 andyco no more stashing goodies in sessiondesc. tossed cookies.
* 6/23/96 kipo updated for latest service provider interfaces.
* 6/25/96 kipo added WINAPI prototypes and updated for DPADDRESS;
* added version.
* 7/11/96 andyco reset gsEnumSocket to INVALID_SOCKET if spInit fails
* #2348. added sp_getaddress.
* 7/18/96 andyco added dphelp for server socket
* 7/16/96 kipo changed address types to be GUIDs instead of 4CC
* 8/1/96 andyco fixed up caps. dplay allocs sp data, not us.
* 8/9/96 andyco throw DPCAPS_GUARANTEEDOPTIMIZED for AF_INET
* 8/12/96 andyco changed failure check on inithelper
* 8/15/96 andyco added sp local data + clean up on thread terminate
* 8/30/96 andyco clean it up b4 you shut it down! added globaldata.
* 9/1/96 andyco right said thread! if you spin it, they won't block.
* bagosockets.
* 9/4/96 andyco kill threads at shutdown only. add all threads to
* threadlist. don't add thread to list if it's already
* done.
* 11/11/96 andyco check for NULL header or data when creating
* non-local players (support game server). Memset our
* sockaddr to 0 before calling getserveraddress.
* 12/18/96 andyco de-threading - use a fixed # of prealloced threads.
* cruised the enum socket / thread - use the system
* socket / thread instead
* 1/15/97 andyco return actual hr on open failure (bug 5197) instead of
* just DP_OK. also, allow system messages to go in the
* socket cache.
* 1/17/97 andyco workaround for nt bug 68093 - recvfrom returns buffer size
* instead of WSAEMSGSIZE
* 1/23/97 kipo return an error code from StartDPHelp() so Open() returns
* an error if you cannot host a session.
* 1/24/97 andyco handle incoming message when receive thread isn't running yet
* 2/7/97 andyco store globals w/ IDirectPlaySP, so we can have > 1 SP per DLL.
* 2/10/97 andyco remove sockets from receive list if we get an error when receiving
* on them. this keeps us from going into a spin on select(...).
* 2/15/97 andyco wait on accept thread b4 receive thread. pass port to
* helperdeletedplayserver.
* 3/04/97 kipo external definition of gdwDPlaySPRefCount now in dplaysp.h
* 3/18/97 andyco create socket at spinit to verify support for requested
* address family
* 3/18/97 kipo GetServerAddress() now returns an error so that we can
* return DPERR_USERCANCEL from the EnumSessions dialog
* 3/25/97 andyco tweaked shutdown code to send message to streamreceivethreadproc
* to exit, rather than nuking the control socket which
* would sometimes hang.
* 4/11/97 andyco make sure it's really the control socket @ init
* 5/12/97 kipo return DPERR_UNAVAILABLE if SP could not be opened (i.e. if
* IPX not installed) to be compatible with the modem SP; added
* support for Unicode IP address strings.
* 5/18/97 andyco close threads + sockets at close. this way, we don't hold
* sockets across sessions.
* 6/11/97 andyco changed reply thread proc to flush q when waking up
* 6/18/97 andyco check for bogus reply headers, just to be safe
* 6/19/97 myronth Fixed handle leak (#10059)
* 6/20/97 andyco check for bogus IPX install by looking for sa_nodenum
* of all 0's at SPInit. raid 9625.
* 7/11/97 andyco added async reply thread and ws2 support
* 7/30/97 andyco call wsastartup w/ version 1.1 if app has already
* called it.
* 8/4/97 andyco added support for DPSEND_ASYNC (no return status) so
* we can make addforward async
* 8/25/97 sohailm updated stream receive logic to avoid congestion (bug #10952)
* 9/05/97 kipo Fixed memphis bug #43655 to deal with getsockopt failing
* 12/5/97 andyco voice support
* 01/5/98 sohailm fd set now grows dynamically - allows for any number of clients (#15244).
* 01/14/98 sohailm don't look for Winsock2.0 on non-nt platforms for IPX (#15253)
* 1/20/98 myronth #ifdef'd out voice support
* 1/21/98 a-PeterZ Fix #15242 SP_GetAddress supports local players
* 1/27/98 sohailm added Firewall support.
* 1/30/98 sohailm bug fix for 17731
* 2/09/98 a-PeterZ Fix #17737 ReceiveList Memory Leak
* 2/13/98 aarono added async support
* 2/13/98 aarono made IPX return proper header size
* 2/16/98 a-PeterZ Fix #15342 Detect no local connection in SP_EnumSessions and SP_Open
* 2/18/98 a-peterz Comment byte order mess-up with SERVER_xxx_PORT constants
* 2/24/98 aarono Bug#18646 fix startup/close race crashing stress.
* 3/3/98 aarono Bug#19188 remove accept thread
* 3/30/98 aarono changed KillSocket on StreamAccept socket to closesocket
* 4/6/98 aarono mapped WSAECONNRESET to DPERR_CONNECTIONLOST
* 4/23/98 aarono workaround Winsock shutdown bug.
* The workaround for DPLAY would be to close all accepted sockets first
* and only then listening socket. (VadimE)
* 6/19/98 aarono map WSAENETRESET and WSAENOTCONN to DPERR_CONNECTIONLOST too.
* required since we now turn on keepalives on reliable
* connections.
* 12/15/98 aarono Fix Async Enum.
* 7/9/99 aarono Cleaning up GetLastError misuse, must call right away,
* before calling anything else, including DPF.
*
***************************************************************************/
/***************************************************************************
* summary -
* + SPInit is the entry point called by dplay. SP fills in callbacks,
* does any other init stuff there.
* + All dplay callbacks start with SP_
*
*****************************************************************************/
// todo - need a meaningful mapping from socket errors to hresults
// todo - figure out when to pop a message box to the user for tragic errors
#define INITGUID
#ifdef BIGMESSAGEDEFENSE
#include <dplobby.h>
// a-josbor: this terrible, terrible hack is brought to you by the elmer build system
#ifndef MAXMSGSIZEGUIDDEFINED
// {F5D09980-F0C4-11d1-8326-006097B01411}
DEFINE_GUID(DPAID_MaxMessageSize,
0xf5d09980, 0xf0c4, 0x11d1, 0x83, 0x26, 0x0, 0x60, 0x97, 0xb0, 0x14, 0x11);
#endif
#endif /* BIGMESSAGEDEFENSE */
#include "dpsp.h"
#include "fpm.h"
#include <initguid.h>
#include "helpcli.h"
/* */
/* globals */
/* */
WSADATA gwsaData; // from wsastartup
HINSTANCE hWS2; // dynaload the ws2_32.dll, so if it's not installed (e.g. win 95 gold)
// we still load
HINSTANCE hWSHIP6 = NULL; // dynaload the wship6.dll only if on Win2k
// stuff for ddhelp
DWORD dwHelperPid; // for ddhelp
HANDLE hModule; // for ddhelp
CRITICAL_SECTION gcsDPSPCritSection;
#ifdef DEBUG
int gCSCount;
#endif
#ifdef DPLAY_VOICE_SUPPORT
BOOL gbVoiceInit = FALSE; // set to TRUE if we have nm voice init'ed
BOOL gbVoiceOpen = FALSE; // set to TRUE if we have a call open
#endif // DPLAY_VOICE_SUPPORT
const IN6_ADDR in6addr_multicast = IN6ADDR_MULTICAST_INIT;
const SOCKADDR_IN6 sockaddr_any = {AF_INET6,0};
#undef DPF_MODNAME
#define DPF_MODNAME "DEBUGPRINTSOCKADDR"
#ifdef DEBUG
void DebugPrintAddr(UINT nLevel,LPSTR pStr,SOCKADDR * psockaddr)
{
char buff[INET6_ADDRSTRLEN];
int ret;
LPSOCKADDR_IN6 pin6 = (LPSOCKADDR_IN6)psockaddr;
ULONG ulLength = INET6_ADDRSTRLEN;
ret = WSAAddressToString(psockaddr, sizeof(SOCKADDR_IN6), NULL,
buff, &ulLength);
if (!ret)
DPF(nLevel,"%s af = AF_INET6 : address = %s\n",pStr,buff);
} // DebugPrintAddr
void DebugPrintSocket(UINT level,LPSTR pStr,SOCKET * pSock)
{
SOCKADDR_IN6 sockaddr;
int addrlen=sizeof(sockaddr);
getsockname(*pSock,(LPSOCKADDR)&sockaddr,&addrlen);
DEBUGPRINTADDR(level,pStr,&sockaddr);
}
#endif // debug
#undef DPF_MODNAME
#define DPF_MODNAME "DatagramListenThread"
void SetMessageHeader(LPDWORD pdwMsg,DWORD dwSize, DWORD dwToken)
{
if (dwSize > SPMAXMESSAGELEN)
{
ASSERT(FALSE);
}
*pdwMsg = dwSize | dwToken;
return ;
}// SetMessageHeader
#undef DPF_MODNAME
#define DPF_MODNAME "DatagramReceiveThread"
// our initial guess at the size of the dgram receive buffer.
// any messages bigger than this will be truncated BUT when we
// receive a too big message, we double the buffer size (winsock
// won't tell us exactly how big the message was, so we guess).
// a-josbor: I thought 1024 was really stingy, so I bumped this up to 16K
#define BUF_SIZE 0x4000
DWORD WINAPI DgramListenThreadProc(LPVOID pvCast)
{
UINT err;
LPBYTE pBuffer;
SOCKADDR_IN6 sockaddr; // the from address
INT addrlen=sizeof(sockaddr);
DWORD dwBufSize = BUF_SIZE;
IDirectPlaySP * pISP = (IDirectPlaySP *)pvCast;
LPGLOBALDATA pgd;
DWORD dwDataSize = sizeof(GLOBALDATA);
SOCKET sSocket;
HRESULT hr;
DPF(2,"starting udp listen thread ");
// get the global data
hr =pISP->lpVtbl->GetSPData(pISP,(LPVOID *)&pgd,&dwDataSize,DPGET_LOCAL);
if (FAILED(hr) || (dwDataSize != sizeof(GLOBALDATA) ))
{
DPF_ERR("couldn't get SP data from DirectPlay - failing");
ExitThread(0);
return 0;
}
// use the dgram socket
sSocket = pgd->sSystemDGramSocket;
ENTER_DPSP();
pBuffer = MemAlloc(BUF_SIZE);
LEAVE_DPSP();
if (!pBuffer)
{
DPF_ERR("could not alloc dgram receive buffer");
ExitThread(0);
return 0;
}
while (1)
{
err = recvfrom(sSocket,pBuffer,dwBufSize,0,(LPSOCKADDR)&sockaddr,&addrlen);
if ( (SOCKET_ERROR == err) || (dwBufSize == err))
{
if (dwBufSize == err)
{
// this works around NT bug 68093
err = WSAEMSGSIZE;
}
else
{
err = WSAGetLastError();
}
DPF(2,"\n udp recv error - err = %d socket = %d",err,(DWORD)sSocket);
if (WSAEMSGSIZE == err)
{
// buffer too small!
dwBufSize *= 2;
ENTER_DPSP();
pBuffer = MemReAlloc(pBuffer,dwBufSize);
LEAVE_DPSP();
if (!pBuffer)
{
DPF_ERR("could not realloc dgram receive buffer");
ExitThread(0);
return 0;
}
// we don't pass dplay this message, since it was truncated...
}
else
{
// bail on other errors
goto ERROR_EXIT;
}
}
else if ( (err >= sizeof(DWORD)) && (VALID_DPWS_MESSAGE(pBuffer)) )
{
DEBUGPRINTADDR(9,"received udp message from : ",&sockaddr);
if (VALID_SP_MESSAGE(pBuffer))
{
// it came from another dplay (not from our dplay helper)
// if it came from our helper, we've already poked the ip addr
// into the message body
IP6_SetAddr((LPVOID)pBuffer,(SOCKADDR_IN6 *)&sockaddr);
}
// pass message to dplays handler
pISP->lpVtbl->HandleMessage(pISP,pBuffer + sizeof(MESSAGEHEADER),
err - sizeof(MESSAGEHEADER), pBuffer);
}
else
{
DEBUGPRINTADDR(9,"received udp message from : ",&sockaddr);
// it must be just a raw send...
pISP->lpVtbl->HandleMessage(pISP,pBuffer,err,NULL);
}
}
ERROR_EXIT:
DPF(2,"UDP Listen thread exiting");
ENTER_DPSP();
if (pBuffer) MemFree(pBuffer);
LEAVE_DPSP();
// all done
ExitThread(0);
return 0;
} // UDPListenThreadProc
#undef DPF_MODNAME
#define DPF_MODNAME "StreamListenThread"
// make sure the buffer is big enough to fit the message size
HRESULT MakeBufferSpace(LPBYTE * ppBuffer,LPDWORD pdwBufferSize,DWORD dwMessageSize)
{
HRESULT hr = DP_OK;
ASSERT(ppBuffer);
ASSERT(pdwBufferSize);
ENTER_DPSP();
if (!*ppBuffer)
{
DPF(9, "Allocating space for message of size %d", dwMessageSize);
// need to alloc receive buffer?
*ppBuffer = MemAlloc(dwMessageSize);
if (!*ppBuffer)
{
DPF_ERR("could not alloc stream receive buffer - out of memory");
hr = E_OUTOFMEMORY;
goto CLEANUP_EXIT;
}
*pdwBufferSize = dwMessageSize;
}
// make sure receive buffer can hold data
else if (dwMessageSize > *pdwBufferSize)
{
LPVOID pvTemp;
DPF(9, "ReAllocating space for message of size %d", dwMessageSize);
// realloc buffer to hold data
pvTemp = MemReAlloc(*ppBuffer,dwMessageSize);
if (!pvTemp)
{
DPF_ERR("could not realloc stream receive buffer - out of memory");
hr = E_OUTOFMEMORY;
goto CLEANUP_EXIT;
}
*ppBuffer = pvTemp;
*pdwBufferSize = dwMessageSize;
}
// fall through
CLEANUP_EXIT:
LEAVE_DPSP();
return hr;
} // MakeBufferSpace
// is this sockaddr local to this machine?
BOOL IsLocalIP(SOCKADDR_IN6 sockaddr)
{
SOCKADDR_IN6 temp;
SOCKET s;
int ret;
s = socket(AF_INET6, SOCK_DGRAM, 0);
if (s == INVALID_SOCKET)
{
return FALSE;
}
temp = sockaddr;
temp.sin6_port = 0;
ret = bind(s, (LPSOCKADDR)&temp, sizeof(temp));
closesocket(s);
return (ret == 0);
} // IsLocalIP
// adds socket to our send list
HRESULT AddSocketToBag(LPGLOBALDATA pgd, SOCKET socket, DPID dpid, SOCKADDR_IN6 *psockaddr, DWORD dwFlags)
{
UINT i=0;
BOOL bFound = FALSE;
BOOL bTrue = TRUE;
HRESULT hr=DP_OK;
ASSERT(psockaddr);
ENTER_DPSP();
// see if we can find an empty slot
i=0;
while (( i < pgd->nSocketsInBag) && !bFound)
{
if (INVALID_SOCKET == pgd->BagOSockets[i].sSocket) bFound = TRUE;
else i++;
}
if (!bFound)
{
// no space. bummer
DPF(5,"no space in bag o' sockets. slowness ensues");
hr = E_FAIL;
goto CLEANUP_EXIT;
}
DPF(5,"adding new socket to bag for id = %d, slot = %d",dpid,i);
DEBUGPRINTSOCK(7, "Adding socket to bag - ",&socket);
pgd->BagOSockets[i].dwPlayerID = dpid;
pgd->BagOSockets[i].sSocket = socket;
pgd->BagOSockets[i].sockaddr = *psockaddr;
pgd->BagOSockets[i].dwFlags = dwFlags;
// fall through
CLEANUP_EXIT:
LEAVE_DPSP();
return hr;
}
void FreeConnection(LPCONNECTION pConnection)
{
if (pConnection->pBuffer && (pConnection->pBuffer != pConnection->pDefaultBuffer))
{
MemFree(pConnection->pBuffer);
pConnection->pBuffer = NULL;
}
if (pConnection->pDefaultBuffer)
{
MemFree(pConnection->pDefaultBuffer);
pConnection->pDefaultBuffer = NULL;
}
// initialize connection
pConnection->socket = INVALID_SOCKET; // this tells us if connection is valid
pConnection->dwCurMessageSize = 0;
pConnection->dwTotalMessageSize = 0;
pConnection->dwFlags = 0;
}
HRESULT AddSocketToReceiveList(LPGLOBALDATA pgd,SOCKET sSocket,DWORD dwFlags)
{
UINT i = 0;
UINT err, iNewSlot;
BOOL bFoundSlot = FALSE;
HRESULT hr = DP_OK;
INT addrlen=sizeof(SOCKADDR_IN6);
LPCONNECTION pNewConnection=NULL;
DWORD dwCurrentSize,dwNewSize;
ENTER_DPSP();
// look for an empty slot
while ( (i < pgd->ReceiveList.nConnections) && !bFoundSlot)
{
if (INVALID_SOCKET == pgd->ReceiveList.pConnection[i].socket)
{
bFoundSlot = TRUE;
iNewSlot = i;
}
else
{
i++;
}
}
if (!bFoundSlot)
{
// allocate space for list of connections
dwCurrentSize = pgd->ReceiveList.nConnections * sizeof(CONNECTION);
dwNewSize = dwCurrentSize + INITIAL_RECEIVELIST_SIZE * sizeof(CONNECTION);
hr = MakeBufferSpace((LPBYTE *)&(pgd->ReceiveList.pConnection),&dwCurrentSize,dwNewSize);
if (FAILED(hr))
{
ASSERT(FALSE);
goto ERROR_EXIT;
}
ASSERT(dwCurrentSize == dwNewSize);
// set all the new entries to INVALID
for (i = pgd->ReceiveList.nConnections + 1;
i < pgd->ReceiveList.nConnections + INITIAL_RECEIVELIST_SIZE; i++ )
{
pgd->ReceiveList.pConnection[i].socket = INVALID_SOCKET;
}
// store the new socket in the 1st new spot
iNewSlot = pgd->ReceiveList.nConnections;
// allocate space for an fd set (fd_count + fd_array)
if (pgd->ReceiveList.nConnections)
{
dwCurrentSize = sizeof(u_int) + pgd->ReceiveList.nConnections * sizeof(SOCKET);
dwNewSize = dwCurrentSize + INITIAL_RECEIVELIST_SIZE * sizeof(SOCKET);
}
else
{
dwCurrentSize = 0;
dwNewSize = sizeof(u_int) + INITIAL_RECEIVELIST_SIZE * sizeof(SOCKET);
}
hr = MakeBufferSpace((LPBYTE *)&(pgd->readfds.pfdbigset),&dwCurrentSize,dwNewSize);
if (FAILED(hr))
{
ASSERT(FALSE);
goto ERROR_EXIT;
}
ASSERT(dwCurrentSize == dwNewSize);
// update the # of connections
pgd->ReceiveList.nConnections += INITIAL_RECEIVELIST_SIZE;
// update the fd_array buffer size
pgd->readfds.dwArraySize = pgd->ReceiveList.nConnections;
} // !bFoundSlot
// we have a space holder for a connection when we get here
// Initialize new connection
pNewConnection = &(pgd->ReceiveList.pConnection[iNewSlot]);
pNewConnection->socket = sSocket;
pNewConnection->dwFlags = dwFlags;
if(dwFlags != SP_STREAM_ACCEPT){
// allocate a default receive buffer if don't have one already
if (!pNewConnection->pDefaultBuffer)
{
pNewConnection->pDefaultBuffer = MemAlloc(DEFAULT_RECEIVE_BUFFERSIZE);
if (!pNewConnection->pDefaultBuffer)
{
hr = DPERR_OUTOFMEMORY;
DPF_ERR("could not alloc default receive buffer - out of memory");
goto ERROR_EXIT;
}
}
// receive buffer initially points to our default buffer
pNewConnection->pBuffer = pNewConnection->pDefaultBuffer;
// remember the address we are connected to
err = getpeername(pNewConnection->socket, (LPSOCKADDR)&(pNewConnection->sockAddr), &addrlen);
if (SOCKET_ERROR == err)
{
err = WSAGetLastError();
DPF(1,"could not getpeername err = %d\n",err);
}
DEBUGPRINTADDR(9, "Socket is connected to address - ",&(pNewConnection->sockAddr));
}
LEAVE_DPSP();
DPF(5, "Added new socket at index %d", iNewSlot);
// success
return DP_OK;
// not a fall through
ERROR_EXIT:
if (pNewConnection)
{
KillSocket(pNewConnection->socket,TRUE,FALSE);
FreeConnection(pNewConnection);
}
LEAVE_DPSP();
return hr;
} // AddSocketToReceiveList
// updates the player associated with a socket in the send list
void UpdateSocketPlayerID(LPGLOBALDATA pgd, SOCKADDR_IN6 *pSockAddr, DPID dpidPlayer)
{
UINT i=0;
IN6_ADDR *pIPCurrent, *pIPFind;
BOOL bFound = FALSE;
ASSERT(pSockAddr);
DEBUGPRINTADDR(9, "Updating player id for socket connected to - ",pSockAddr);
ENTER_DPSP();
while (!bFound && (i < pgd->nSocketsInBag))
{
pIPCurrent = &(((SOCKADDR_IN6 *)&pgd->BagOSockets[i].sockaddr)->sin6_addr);
pIPFind = &(((SOCKADDR_IN6 *)pSockAddr)->sin6_addr);
// todo - we are only comparing the IP here, need to look at the complete socket address
if ((INVALID_SOCKET != pgd->BagOSockets[i].sSocket) &&
!memcmp(pIPCurrent, pIPFind, sizeof(IN6_ADDR)))
{
bFound = TRUE;
// update the player id
pgd->BagOSockets[i].dwPlayerID = dpidPlayer;
}
i++;
}
LEAVE_DPSP();
return;
}
BOOL FindSocketInReceiveList(LPGLOBALDATA pgd, SOCKADDR *pSockAddr, SOCKET * psSocket)
{
UINT i=0;
IN6_ADDR *pIPCurrent, *pIPFind;
BOOL bFound = FALSE;
ASSERT(psSocket);
ENTER_DPSP();
while (!bFound && (i < pgd->ReceiveList.nConnections))
{
pIPCurrent = &(((SOCKADDR_IN6 *)&pgd->ReceiveList.pConnection[i].sockAddr)->sin6_addr);
pIPFind = &(((SOCKADDR_IN6 *)pSockAddr)->sin6_addr);
// todo - we are only comparing the IP here, need to look at the complete socket address
if ((INVALID_SOCKET != pgd->ReceiveList.pConnection[i].socket) &&
!memcmp(pIPCurrent, pIPFind, sizeof(IN6_ADDR)))
{
*psSocket = pgd->ReceiveList.pConnection[i].socket;
bFound = TRUE;
}
i++;
}
LEAVE_DPSP();
return bFound;
}
BOOL FindSocketInBag(LPGLOBALDATA pgd, SOCKADDR *pSockAddr, SOCKET * psSocket, LPDPID lpdpidPlayer)
{
UINT i=0;
IN6_ADDR *pIPCurrent, *pIPFind;
BOOL bFound = FALSE;
ASSERT(psSocket);
ASSERT(lpdpidPlayer);
ENTER_DPSP();
while (!bFound && (i < pgd->nSocketsInBag))
{
pIPCurrent = &(((SOCKADDR_IN6 *)&pgd->BagOSockets[i].sockaddr)->sin6_addr);
pIPFind = &(((SOCKADDR_IN6 *)pSockAddr)->sin6_addr);
if ((INVALID_SOCKET != pgd->BagOSockets[i].sSocket) &&
!memcmp(pIPCurrent, pIPFind, sizeof(IN6_ADDR)))
{
*psSocket = pgd->BagOSockets[i].sSocket;
*lpdpidPlayer = pgd->BagOSockets[i].dwPlayerID;
DPF(9, "Found socket in send list for id %d", *lpdpidPlayer);
bFound = TRUE;
}
i++;
}
LEAVE_DPSP();
return bFound;
}
void RemoveSocketFromBag(LPGLOBALDATA pgd, SOCKET socket)
{
BOOL bFound = FALSE;
UINT i=0;
ENTER_DPSP();
// look for the socket
while (!bFound && (i < pgd->nSocketsInBag))
{
if (socket == pgd->BagOSockets[i].sSocket)
{
pgd->BagOSockets[i].sSocket = INVALID_SOCKET;
bFound = TRUE;
}
else
{
i++;
}
} // while
LEAVE_DPSP();
}
void RemoveSocketFromReceiveList(LPGLOBALDATA pgd, SOCKET socket)
{
UINT i = 0;
BOOL bFound = FALSE;
SOCKET sSocket=INVALID_SOCKET;
DWORD dwSocketFlags=0;
ENTER_DPSP();
// look for the corresponding connection
while ( !bFound && (i < pgd->ReceiveList.nConnections))
{
if (socket == pgd->ReceiveList.pConnection[i].socket)
{
DEBUGPRINTSOCK(9, "Removing socket from receive list - ", &socket);
socket = pgd->ReceiveList.pConnection[i].socket;
dwSocketFlags = pgd->ReceiveList.pConnection[i].dwFlags;
FreeConnection(&pgd->ReceiveList.pConnection[i]);
bFound = TRUE;
}
else
{
i++;
}
} // while
LEAVE_DPSP();
if (bFound)
{
KillSocket(socket, TRUE, FALSE);
if (dwSocketFlags & SP_CONNECTION_FULLDUPLEX)
RemoveSocketFromBag(pgd,sSocket);
}
return ;
} //RemoveSocketFromReceiveList
HRESULT HandleSPMessage(IDirectPlaySP *pISP, LPGLOBALDATA pgd, LPCONNECTION pConnection)
{
HRESULT hr;
switch (SP_MESSAGE_TOKEN(pConnection->pBuffer))
{
// VALID_SP_MESSAGE
case TOKEN:
{
if (SPMESSAGEHEADERLEN == pConnection->dwTotalMessageSize)
{
// if we get a message w/ 0 size, it means we've accepted a connection
// and need to add the new socket to our recv list...
// basically, it's a no-op for the receive loop
return DP_OK;
}
// now, we've read all the bits
// store the address we received from w/ the message
// todo - don't store address if it's a player - player message
if (pgd->dwFlags & DPSP_OUTBOUNDONLY)
{
((LPMESSAGEHEADER)pConnection->pBuffer)->sockaddr = pConnection->sockAddr;
}
else
{
IP6_SetAddr((LPVOID)pConnection->pBuffer,(SOCKADDR_IN6 *)&pConnection->sockAddr);
}
// pass message to dplays handler
// need to drop the lock here...
ASSERT( 1 == gCSCount);
DPF(9, "received a complete message - handing it off to dplay");
LEAVE_DPSP();
// received a complete message - hand it off to dplay
pISP->lpVtbl->HandleMessage(pISP, pConnection->pBuffer + sizeof(MESSAGEHEADER),
pConnection->dwTotalMessageSize - sizeof(MESSAGEHEADER),pConnection->pBuffer);
ENTER_DPSP();
}
break;
// VALID_SERVER_MESSAGE
case SERVER_TOKEN:
{
HandleServerMessage(pgd, pConnection->socket, pConnection->pBuffer + sizeof(MESSAGEHEADER),
pConnection->dwTotalMessageSize - sizeof(MESSAGEHEADER));
}
break;
// if we get this token, the sender wants us to reuse the connection
// so put it in the send list
case REUSE_TOKEN:
{
DEBUGPRINTSOCK(9, "Received reuse message on - ", &pConnection->socket);
// we only allow reusing connections in client/server mode at this time.
// peer-peer can't work without making inbound connections
if (pgd->dwSessionFlags & DPSESSION_CLIENTSERVER)
{
DEBUGPRINTSOCK(9, "Reusing connection - ", &pConnection->socket);
hr = AddSocketToBag(pgd, pConnection->socket, 0, &pConnection->sockAddr,
SP_CONNECTION_FULLDUPLEX);
if (FAILED(hr))
{
DEBUGPRINTSOCK(0, "Failed to reuse connection - ",&pConnection->socket);
return hr;
}
}
else
{
DPF(2, "Not accepting reuse request in peer-peer");
return E_FAIL;
}
}
break;
default:
{
DPF(0, "Received a message with invalid token - 0x%08x",SP_MESSAGE_TOKEN(pConnection->pBuffer));
}
break;
} // switch
return DP_OK;
} // HandleSPMessage
/*
** StreamReceive
*
* CALLED BY: StreamReceiveThreadProc
*
* PARAMETERS:
* sSocket - socket to receive on
* ppBuffer - buffer to receive into - alloc'ed / realloc'ed as necessary
* pdwBuffersize - size of pBuffer
*
* DESCRIPTION:
* suck the bytes out of sSocket until no more bytes
*
* RETURNS: E_FAIL on sockerr, or DP_OK.
*
*/
HRESULT StreamReceive(IDirectPlaySP * pISP,LPGLOBALDATA pgd, LPCONNECTION pConnection)
{
HRESULT hr = DP_OK;
UINT err;
DWORD dwBytesReceived=0;
DWORD dwMessageSize = 0;
LPBYTE pReceiveBuffer=NULL;
DWORD dwReceiveBufferSize;
// is it a new message ?
if (pConnection->dwCurMessageSize == 0)
{
// make sure we have a buffer to recive data in
if (!pConnection->pDefaultBuffer)
{
DEBUGPRINTADDR(0, "No buffer to receive data - removing connection to - ",&pConnection->sockAddr);
goto CLEANUP_EXIT;
}
// receive the header first
pConnection->dwTotalMessageSize = SPMESSAGEHEADERLEN;
}
// continue receiving message
pReceiveBuffer = pConnection->pBuffer + pConnection->dwCurMessageSize;
dwReceiveBufferSize = pConnection->dwTotalMessageSize - pConnection->dwCurMessageSize;
DPF(9,"Attempting to receive %d bytes", dwReceiveBufferSize);
DEBUGPRINTSOCK(9,">>> receiving data on socket - ",&pConnection->socket);
// receive data from socket
// note - make exactly one call to recv after select otherwise we'll hang
dwBytesReceived = recv(pConnection->socket, (LPBYTE)pReceiveBuffer, dwReceiveBufferSize, 0);
if (0 == dwBytesReceived)
{
// remote side has shutdown connection gracefully
DEBUGPRINTSOCK(9,"<<< received data on socket - ",&pConnection->socket);
hr = DP_OK;
DEBUGPRINTSOCK(5,"Remote side has shutdown connection gracefully - ",&pConnection->socket);
goto CLEANUP_EXIT;
}
else if (SOCKET_ERROR == dwBytesReceived)
{
err = WSAGetLastError();
DEBUGPRINTSOCK(9,"<<< received data on socket - ",&pConnection->socket);
DPF(0,"STREAMRECEIVEE: receive error - err = %d",err);
hr = E_UNEXPECTED;
goto CLEANUP_EXIT;
}
DPF(5, "received %d bytes", dwBytesReceived);
// we have received this much message so far
pConnection->dwCurMessageSize += dwBytesReceived;
// did we receive the header
if (pConnection->dwCurMessageSize == SPMESSAGEHEADERLEN)
{
// we just completed receiving message header
// make sure its valid
if (VALID_DPWS_MESSAGE(pConnection->pDefaultBuffer))
{
dwMessageSize = SP_MESSAGE_SIZE(pConnection->pDefaultBuffer); // total message size
#ifdef BIGMESSAGEDEFENSE
// make sure it is not greater that the max message len
if (dwMessageSize > pgd->dwMaxMessageSize)
{
DPF(0, "Got message (%d bytes) that's bigger than max allowed len (%d)! Disconnecting sender.\n",
dwMessageSize - sizeof(MESSAGEHEADER), pgd->dwMaxMessageSize - sizeof(MESSAGEHEADER));
ASSERT(dwMessageSize <= pgd->dwMaxMessageSize);
// we want to receive another 12 bytes so that DPLAY can have
// something to look at to decide whether or not to continue
// receiving this message. So instead of setting dwMessageSize
// to its real size, we fake it out.
dwMessageSize = SPMESSAGEHEADERLEN + 12;
}
#endif
}
else
{
DPF(2,"got invalid message - token = 0x%08x",SP_MESSAGE_TOKEN(pConnection->pDefaultBuffer));
ASSERT(FALSE);
hr = E_UNEXPECTED;
goto CLEANUP_EXIT;
}
// prepare to receive rest of the message (after the token)
if (dwMessageSize)
{
pConnection->dwTotalMessageSize = dwMessageSize;
// which buffer to receive message in ?
if (dwMessageSize > DEFAULT_RECEIVE_BUFFERSIZE)
{
ASSERT(pConnection->pBuffer == pConnection->pDefaultBuffer);
// get a new buffer to fit the message
pConnection->pBuffer = MemAlloc(dwMessageSize);
if (!pConnection->pBuffer)
{
DPF(0,"Failed to allocate receive buffer for message - out of memory");
goto CLEANUP_EXIT;
}
// copy header into new message buffer
memcpy(pConnection->pBuffer, pConnection->pDefaultBuffer, SPMESSAGEHEADERLEN);
}
}
}
#ifdef BIGMESSAGEDEFENSE
// this MIGHT be because the message is really huge, and we're just getting
// enough to hand to DPLAY
else if (pConnection->dwCurMessageSize == SPMESSAGEHEADERLEN + 12)
{
dwMessageSize = SP_MESSAGE_SIZE(pConnection->pBuffer);
if (dwMessageSize > pgd->dwMaxMessageSize)
{
DPSP_MSGTOOBIG msgTooBigErr;
// okay. This is message is too big, and we now have enough data
// to hand to DPLAY. Find out if it wants us to continue receiving,
// or bail on this connection
// call into DPLAY to let it do its thing
msgTooBigErr.dwType = DPSPWARN_MESSAGETOOBIG;
msgTooBigErr.pReceiveBuffer = pConnection->pBuffer + sizeof(MESSAGEHEADER);
msgTooBigErr.dwBytesReceived = pConnection->dwCurMessageSize;
msgTooBigErr.dwMessageSize = dwMessageSize - sizeof(MESSAGEHEADER);
LEAVE_DPSP();
pISP->lpVtbl->HandleSPWarning(pISP, &msgTooBigErr, sizeof(DPSP_MSGTOOBIG), pConnection->pBuffer);
ENTER_DPSP();
// now, kill the connection
hr = E_UNEXPECTED;
goto CLEANUP_EXIT;
}
}
#endif
// did we receive a complete message ?
if (pConnection->dwCurMessageSize == pConnection->dwTotalMessageSize)
{
// process message
hr = HandleSPMessage(pISP, pgd, pConnection);
// cleanup up new receive buffer if any
if (pConnection->dwTotalMessageSize > DEFAULT_RECEIVE_BUFFERSIZE)
{
DPF(9, "Releasing receive buffer of size %d", pConnection->dwTotalMessageSize);
if (pConnection->pBuffer) MemFree(pConnection->pBuffer);
}
// initialize message information
pConnection->dwCurMessageSize = 0;
pConnection->dwTotalMessageSize = 0;
pConnection->pBuffer = pConnection->pDefaultBuffer;
if (FAILED(hr))
{
goto CLEANUP_EXIT;
}
}
// all done
return DP_OK;
CLEANUP_EXIT:
RemoveSocketFromReceiveList(pgd,pConnection->socket);
return hr;
} // StreamReceive
void EmptyConnectionList(LPGLOBALDATA pgd)
{
UINT i;
ENTER_DPSP();
for (i=0;i<pgd->ReceiveList.nConnections ;i++ )
{
if (INVALID_SOCKET != pgd->ReceiveList.pConnection[i].socket)
{
KillSocket(pgd->ReceiveList.pConnection[i].socket,TRUE,FALSE);
FreeConnection(&(pgd->ReceiveList.pConnection[i]));
}
}
LEAVE_DPSP();
return ;
} // EmptyConnectionList
// watch our list of sockets, waiting for one to have data to be received, or to be closed
DWORD WINAPI StreamReceiveThreadProc(LPVOID pvCast)
{
HRESULT hr;
int rval;
UINT i = 0;
UINT err;
DWORD dwBufferSize = 0;
UINT nSelected;
IDirectPlaySP * pISP = (IDirectPlaySP *)pvCast;
DWORD dwDataSize = sizeof(GLOBALDATA);
LPGLOBALDATA pgd;
TIMEVAL tv={0,250000}; // 250000 us = 1/4 sec.
DWORD dwPrevSelectLastError=0;
// get the global data
hr =pISP->lpVtbl->GetSPData(pISP,(LPVOID *)&pgd,&dwDataSize,DPGET_LOCAL);
if (FAILED(hr) || (dwDataSize != sizeof(GLOBALDATA) ))
{
DPF_ERR("couldn't get SP data from DirectPlay - failing");
ExitThread(0);
return 0;
}
AddSocketToReceiveList(pgd,pgd->sSystemStreamSocket,SP_STREAM_ACCEPT);
while (1)
{
ENTER_DPSP();
ASSERT(pgd->readfds.pfdbigset);
// add all sockets in our recv list to readfds
FD_ZERO(pgd->readfds.pfdbigset);
nSelected = 0;
for (i=0;i < pgd->ReceiveList.nConnections ; i++)
{
if (INVALID_SOCKET != pgd->ReceiveList.pConnection[i].socket)
{
FD_BIG_SET(pgd->ReceiveList.pConnection[i].socket,&pgd->readfds);
nSelected++;
}
}
LEAVE_DPSP();
if (0 == nSelected)
{
if (pgd->bShutdown)
{
DPF(2,"stream receive thread proc detected shutdown - bailing");
goto CLEANUP_EXIT;
}
// we should have at least one?
DPF_ERR("No sockets in receive list - missing control socket? bailing!");
ASSERT(FALSE);
goto CLEANUP_EXIT;
}
// now, we wait for something to happen w/ our socket set
rval = select(0,(fd_set *)(pgd->readfds.pfdbigset),NULL,NULL,&tv);
if (SOCKET_ERROR == rval)
{
err = WSAGetLastError();
if(dwPrevSelectLastError==err){
DPF(0,"Got two bogus last errors of(%x) from select, bailing",err);
goto CLEANUP_EXIT;
}
// WSAEINTR is returned when a socket is shutdown behind us - this can happen
// when a socket is removed from the receivelist
if (WSAEINTR != err)
{
dwPrevSelectLastError=err;
DPF(2,"StreamReceiveThreadProc failing w/ sockerr = %d\n - trying again",err);
ASSERT(FALSE);
rval = 0; // try again...
} else {
dwPrevSelectLastError=0;
}
} else {
dwPrevSelectLastError=0;
}
// shut 'em down?
if (pgd->bShutdown)
{
DPF(2,"receive thread proc detected bShutdown - bailing");
goto CLEANUP_EXIT;
}
// a-josbor: why are we waking up with 0 events?
// in any case, a workaround is to just go back to sleep if we have
// no real events
if ( rval == 0)
{
continue;
}
DPF(5,"receive thread proc - events on %d sockets",rval);
i = 0;
ENTER_DPSP();
while (rval>0)
{
// walk the receive list, dealing w/ all new sockets
if (i >= pgd->ReceiveList.nConnections)
{
DPF(0, "nConnections = %d, selected = %d", pgd->ReceiveList.nConnections, i);
ASSERT(FALSE); // should never happen
rval = 0; // just to be safe, reset
}
if (pgd->ReceiveList.pConnection[i].socket != INVALID_SOCKET)
{
// see if it's in the set
if (FD_ISSET(pgd->ReceiveList.pConnection[i].socket,pgd->readfds.pfdbigset))
{
DPF(9, "Receiving on socket %d from ReceiveList", i);
if(pgd->ReceiveList.pConnection[i].dwFlags != SP_STREAM_ACCEPT){
// got one! this socket has something going on...
hr = StreamReceive(pISP, pgd, &(pgd->ReceiveList.pConnection[i]));
if (FAILED(hr))
{
DPF(1,"Stream Receive failed - hr = 0x%08lx\n",hr);
}
} else {
// accept any incoming connection
SOCKADDR_IN6 sockaddr;
INT addrlen=sizeof(sockaddr);
SOCKET sSocket;
sSocket = accept(pgd->sSystemStreamSocket,(LPSOCKADDR)&sockaddr,&addrlen);
if (INVALID_SOCKET == sSocket)
{
err = WSAGetLastError();
DPF(2,"\n stream accept error - err = %d socket = %d",err,(DWORD)sSocket);
} else {
DEBUGPRINTADDR(5,"stream - accepted connection from",&sockaddr);
// add the new socket to our receive q
hr = AddSocketToReceiveList(pgd,sSocket,0);
if (FAILED(hr))
{
ASSERT(FALSE);
}
}
}
rval--; // one less to hunt for
} // IS_SET
} // != INVALID_SOCKET
i++;
} // while rval
LEAVE_DPSP();
} // while 1
CLEANUP_EXIT:
EmptyConnectionList(pgd);
return 0;
} // ReceiveThreadProc
// send a message of 0 length telling receiver to reuse connection
HRESULT SendReuseConnectionMessage(SOCKET sSocket)
{
DWORD dwMessage;
HRESULT hr=DP_OK;
UINT err;
// send a 0 sized message (w/ our header) to the stream socket, to tell
// receive thread proc to reuse this socket for replies to us
SetMessageHeader(&dwMessage,0,REUSE_TOKEN);
err = send(sSocket,(LPBYTE)&dwMessage,sizeof(DWORD),0);
if (SOCKET_ERROR == err)
{
err = WSAGetLastError();
// if we're shutdown, don't print a scary
DPF(0,"SendReuseControlMessage failed with error - err = %d\n",err);
hr = E_FAIL;
}
return hr;
}
#undef DPF_MODNAME
#define DPF_MODNAME "CreateAndConnectSocket"
// called by reliable send and DoTCPEnumSessions
HRESULT CreateAndConnectSocket(LPGLOBALDATA pgd,SOCKET * psSocket,DWORD dwType,LPSOCKADDR_IN6 psockaddr, BOOL bOutBoundOnly)
{
UINT err;
HRESULT hr;
int iAddrLen = sizeof(SOCKADDR_IN6);
ASSERT(psSocket);
hr = CreateSocket(pgd,psSocket,dwType,0,&sockaddr_any,&err,FALSE);
if (FAILED(hr))
{
DPF(0,"createandconnect :: create socket failed - err = %d\n",err);
return hr;
}
// try to connect
hr = SPConnect(psSocket,(LPSOCKADDR)psockaddr,iAddrLen, bOutBoundOnly);
if (FAILED(hr))
{
DPF(0,"createandconnect - connect socket failed\n");
goto ERROR_EXIT;
}
if (bOutBoundOnly)
{
// so we receive the reply (server will reuse the connection)
hr = AddSocketToReceiveList(pgd, *psSocket,SP_CONNECTION_FULLDUPLEX);
if (FAILED(hr))
{
DPF(0, "failed to add socket to receive list");
goto ERROR_EXIT;
}
}
return DP_OK;
// not a fall through
ERROR_EXIT:
if (INVALID_SOCKET != *psSocket)
{
err = closesocket(*psSocket);
if (SOCKET_ERROR == err)
{
err = WSAGetLastError();
DPF(0,"send closesocket error - err = %d\n",err);
return E_UNEXPECTED;
}
*psSocket = INVALID_SOCKET;
}
return hr;
} // CreateAndConnectSocket
#undef DPF_MODNAME
#define DPF_MODNAME "EnumSessions"
// starts the streamacceptthread (TCP) or the dgramlistenthreadproc (IPX) so we can
// get replies from the nameserver for our requests
HRESULT StartupEnumThread(IDirectPlaySP * pISP,LPGLOBALDATA pgd)
{
HRESULT hr;
UINT err;
DWORD dwThreadID;
// set up socket
{
if (pgd->hStreamReceiveThread)
{
return DP_OK; // already running
}
// create system stream socket so we can start listening for connections
ASSERT(INVALID_SOCKET == pgd->sSystemStreamSocket);
hr = CreateAndInitStreamSocket(pgd);
if (FAILED(hr))
{
ASSERT(FALSE);
return hr;
}
// start the enum accept thread (listen for new connections)
pgd->hStreamReceiveThread = CreateThread(NULL,0,StreamReceiveThreadProc,
(LPVOID)pISP,0,&dwThreadID);
if (!pgd->hStreamReceiveThread)
{
DPF(0, "Failed to start stream receive thread");
ASSERT(FALSE);
} else SetThreadPriority(pgd->hDGramReceiveThread, THREAD_PRIORITY_ABOVE_NORMAL);
}
return DP_OK;
} // StartupEnumThread
/*
* Creates a dgram socket, sends enum sessions request, and closes socket.
*
* reply is received in streamlistenthreadproc and passed into dplay.
*/
HRESULT DoUDPEnumSessions(LPGLOBALDATA pgd, SOCKADDR_IN6 *lpSockAddr, DWORD dwAddrSize,
LPDPSP_ENUMSESSIONSDATA ped)
{
SOCKET sSocket;
HRESULT hr;
BOOL bTrue=TRUE;
UINT err;
unsigned int index;
DEBUGPRINTADDR(5,"enum unreliable - sending to ",lpSockAddr);
hr = CreateSocket(pgd,&sSocket,SOCK_DGRAM,0,&sockaddr_any,&err,FALSE);
if (FAILED(hr))
{
DPF(0,"!!! enum - could not create socket error = %d\n",err);
return E_FAIL;
}
if (IN6_ADDR_EQUAL(&in6addr_multicast, &lpSockAddr->sin6_addr)) {
// Workaround a current bug in the IPv6 stack which requires
// the scope id to be 0 and use IPV6_MULTICAST_IF instead
index = lpSockAddr->sin6_scope_id;
lpSockAddr->sin6_scope_id = 0;
if( SOCKET_ERROR == setsockopt( sSocket,IPPROTO_IPV6,IPV6_MULTICAST_IF,
(char FAR *)&index,sizeof(index) ) )
{
DPF(0, "IPV6_MULTICAST_IF got error = %d\n", WSAGetLastError());
return E_FAIL;
}
}
// send out the enum message
err = sendto(sSocket,ped->lpMessage,ped->dwMessageSize,0,(LPSOCKADDR)lpSockAddr,dwAddrSize);
if (SOCKET_ERROR == err)
{
err = WSAGetLastError();
DPF(0,"send error - err = %d\n",err);
hr = E_UNEXPECTED;
goto CLEANUP_EXIT;
}
// fall through
CLEANUP_EXIT:
KillSocket(sSocket,TRUE,FALSE);
return hr;
} // DoUDPEnumSessions
// A very short lived thread -- may hang in connect with invalid id to connect to.
DWORD WINAPI TCPEnumSessionsAsyncThread(LPVOID lpv)
{
LPGLOBALDATA pgd=(LPGLOBALDATA) lpv;
HRESULT hr;
UINT err;
DPF(9,"==> Entering TCPEnumSessionsAsyncThread(0x%08x)\n", lpv);
pgd->sEnum = INVALID_SOCKET;
DEBUGPRINTADDR(5,"enum reliable - sending to ",&pgd->saEnum);
// get us a new connection
hr = CreateAndConnectSocket(pgd,&pgd->sEnum,SOCK_STREAM,&pgd->saEnum,pgd->bOutBoundOnly);
if (FAILED(hr))
{
DPF(0, "Failed to get socket for enum sessions - hr: 0x%08x",hr);
goto EXIT;
}
// send the request
err = send(pgd->sEnum,pgd->lpEnumMessage,pgd->dwEnumMessageSize,0);
if (SOCKET_ERROR == err)
{
err = WSAGetLastError();
DPF(0,"send error - err = %d\n",err);
DEBUGPRINTADDR(0,"reliable send - FAILED - sending to ",&pgd->saEnum);
hr = E_FAIL;
goto ERROR_EXIT;
// fall through
}
if (!pgd->bOutBoundOnly)
{
DEBUGPRINTSOCK(5,"Closing enum sessions connection - ", &pgd->sEnum);
// close the connection
KillSocket(pgd->sEnum,TRUE,FALSE);
pgd->sEnum=INVALID_SOCKET;
}
goto EXIT;
// not a fall through
ERROR_EXIT:
if (INVALID_SOCKET != pgd->sEnum) {
KillSocket(pgd->sEnum,TRUE,FALSE);
pgd->sEnum=INVALID_SOCKET;
}
EXIT:
ENTER_DPSP();
if(pgd->hTCPEnumAsyncThread){
CloseHandle(pgd->hTCPEnumAsyncThread);
pgd->hTCPEnumAsyncThread=0;
}
if(pgd->lpEnumMessage){
MemFree(pgd->lpEnumMessage);
pgd->lpEnumMessage=0;
}
LEAVE_DPSP();
DPF(5,"<== Leaving TCPEnumSessionsAsyncThread\n");
return 0;
} // TCPEnumSessionsAsyncThread
/*
* Creates a stream socket, sends enum sessions request, and closes socket
* depending on bHostWillReuseConnection. If bHostWillReuseConnection is TRUE, server will
* close the connection after sending reply.
*
* reply is received in streamlistenthreadproc and passed into dplay.
*/
HRESULT DoTCPEnumSessionsAsync(LPGLOBALDATA pgd, SOCKADDR *lpSockAddr, DWORD dwAddrSize,
LPDPSP_ENUMSESSIONSDATA ped,BOOL bOutBoundOnly)
{
DWORD dwJunk;
HRESULT hr=DP_OK;
// First see if we have a thread running already, if we do cancel it.
KillTCPEnumAsyncThread(pgd);
// package the request up and hand it to the thread.
ENTER_DPSP();
pgd->lpEnumMessage=MemAlloc(ped->dwMessageSize);
if(pgd->lpEnumMessage){
memcpy(pgd->lpEnumMessage, ped->lpMessage, ped->dwMessageSize);
pgd->dwEnumMessageSize=ped->dwMessageSize;
} else {
hr=DPERR_OUTOFMEMORY;
goto EXIT;
}
memcpy(&pgd->saEnum,lpSockAddr,dwAddrSize);
pgd->dwEnumAddrSize=dwAddrSize;
pgd->bOutBoundOnly=bOutBoundOnly;
pgd->sEnum=INVALID_SOCKET;
if(!(pgd->hTCPEnumAsyncThread=CreateThread(NULL,0,TCPEnumSessionsAsyncThread,pgd,0,&dwJunk))){
MemFree(pgd->lpEnumMessage);
pgd->lpEnumMessage=NULL;
hr=DPERR_OUTOFMEMORY;
}
EXIT:
LEAVE_DPSP();
return hr;
}
void
EnumOnInterface(IPV6_INFO_INTERFACE *IF, void *Context1, void *Context2, void *Context3)
{
LPGLOBALDATA pgd = (LPGLOBALDATA)Context1;
LPSOCKADDR_IN6 psa = (LPSOCKADDR_IN6)Context2;
LPDPSP_ENUMSESSIONSDATA ped = (LPDPSP_ENUMSESSIONSDATA)Context3;
SOCKADDR_IN6 sa;
psa->sin6_scope_id = IF->This.Index;
DoUDPEnumSessions(pgd, psa, sizeof(SOCKADDR_IN6), ped);
}
/*
** EnumSessions
*
* CALLED BY: DPLAY
*
* PARAMETERS: ped - see dplayi.h
*
* DESCRIPTION:
*
* creates a stream socket. sends a message to the address specified by the user.
* fills in return address so server can reply.
*
* reply is received in streamlistenthreadproc and passed into dplay.
*
* RETURNS:
* DP_OK always.
*
*/
HRESULT WINAPI SP_EnumSessions(LPDPSP_ENUMSESSIONSDATA ped)
{
#ifdef DEBUG
SOCKET sSocket; // bcast socket
#endif // DEBUG
SOCKADDR_IN6 sockaddr;
INT addrlen=sizeof(sockaddr);
HRESULT hr;
DWORD dwErr=0;
BOOL bTrue = TRUE;
DWORD dwDataSize = sizeof(GLOBALDATA);
LPGLOBALDATA pgd;
BOOL bOutBoundOnly = FALSE;
DPF(5,"SP_EnumSessions");
// get the global data
hr =ped->lpISP->lpVtbl->GetSPData(ped->lpISP,(LPVOID *)&pgd,&dwDataSize,DPGET_LOCAL);
if (FAILED(hr) || (dwDataSize != sizeof(GLOBALDATA) ))
{
DPF_ERR("couldn't get SP data from DirectPlay - failing");
return E_FAIL;
}
// Do we have an active IP address? If not and DUN is enabled, a DUN
// dialog will pop for enum to a specific machine.
// bReturnStatus means no extra dialogs are wanted so we will abort
// if there are no local connections.
if (ped->bReturnStatus)
{
SOCKET_ADDRESS_LIST *pList = GetHostAddr();
if (!pList)
{
DPF(0, "No Dial-up network or netcard present");
return DPERR_NOCONNECTION; // no local IP address = no network
}
FreeHostAddr(pList);
}
memset(&sockaddr,0,sizeof(sockaddr));
// find out where we should send request to
hr = GetServerAddress(pgd,&sockaddr);
if (FAILED(hr))
{
DPF_ERR("failed to get enumeration address");
return hr;
}
hr = StartupEnumThread(ped->lpISP,pgd);
if (FAILED(hr))
{
DPF(0," could not start enum handler - hr = 0x%08lx\n",hr);
return hr;
}
// set message header
SetMessageHeader(ped->lpMessage,ped->dwMessageSize,TOKEN);
SetReturnAddress(ped->lpMessage,SERVICE_SOCKET(pgd));
#ifdef DEBUG
sSocket = SERVICE_SOCKET(pgd); // we'll borrow this var for our debug spew
DEBUGPRINTSOCK(5,"enum - return address = ",&sSocket);
#endif // DEBUG
if (IN6_ADDR_EQUAL(&in6addr_multicast, &sockaddr.sin6_addr))
{
ForEachInterface(EnumOnInterface, pgd, &sockaddr, ped);
}
else
{
hr = DoUDPEnumSessions(pgd, &sockaddr, addrlen, ped);
if (FAILED(hr))
{
return hr;
}
// send a reliable enum sessions as well, duplicates will be filtered by dplay
// poke the correct server port
if (pgd->wApplicationPort)
{
// if app specified a port, let's use the mode specified
// because we'll be enuming the app directly
sockaddr.sin6_port = htons(pgd->wApplicationPort);
bOutBoundOnly = (pgd->dwFlags & DPSP_OUTBOUNDONLY);
}
else
{
// otherwise send enum to dplaysvr
// see byte-order comment in dpsp.h for this constant
sockaddr.sin6_port = SERVER_STREAM_PORT;
bOutBoundOnly = FALSE;
}
hr = DoTCPEnumSessionsAsync(pgd, (LPSOCKADDR)&sockaddr, addrlen, ped, bOutBoundOnly);
}
// fall through
DPF(5,"enum exiting");
return DP_OK;
}// EnumSessions
#undef DPFSessions
#undef DPF_MODNAME
#define DPF_MODNAME "SP_GetAddress"
// helper to handle local player address(es)
HRESULT WINAPI SP_GetAddressLocal(LPDPSP_GETADDRESSDATA pad)
{
int i, j, count, ret;
HRESULT hr = DP_OK;
SOCKET_ADDRESS_LIST *pList;
char *pszIPAddr, *pszBuf = NULL;
DWORD dwIPAddrSize;
WCHAR *pszIPAddrW, *pszBufW = NULL;
LPDPCOMPOUNDADDRESSELEMENT paDPAddrEl = NULL;
pList = GetHostAddr();
if (!pList)
{
return DPERR_GENERIC;
}
count = pList->iAddressCount;
// allocate our DPAddress assembly buffers
// ANSI and UNICODE elements for each IP address plus one SP guid
// max size of IPv6 address literal notation = INET6_ADDRSTRLEN
ENTER_DPSP();
// addressElement array
paDPAddrEl = MemAlloc(sizeof(DPCOMPOUNDADDRESSELEMENT)*(2*count + 1));
// one big buffer each for ANSI and UNICODE strings
pszIPAddr = pszBuf = MemAlloc(INET6_ADDRSTRLEN*count);
pszIPAddrW = pszBufW = MemAlloc(sizeof(WCHAR)*(INET6_ADDRSTRLEN*count));
if (!paDPAddrEl || !pszBuf || !pszBufW)
{
ASSERT(FALSE);
FreeHostAddr(pList);
MemFree(paDPAddrEl);
MemFree(pszBuf);
MemFree(pszBufW);
LEAVE_DPSP();
return DPERR_NOMEMORY;
}
LEAVE_DPSP();
// service provider chunk
paDPAddrEl[0].guidDataType = DPAID_ServiceProvider;
paDPAddrEl[0].dwDataSize = sizeof(GUID);
paDPAddrEl[0].lpData = (LPVOID) &GUID_IPV6;
// make an ANSI and UNICODE string of each IP address
for (i=0,j=1; i<pList->iAddressCount; i++)
{
DWORD dwStrLen; // includes terminator
dwIPAddrSize = INET6_ADDRSTRLEN;
ret = WSAAddressToString(pList->Address[i].lpSockaddr,
pList->Address[i].iSockaddrLength,
NULL, pszIPAddr, &dwIPAddrSize);
if (ret) {
hr = DPERR_GENERIC;
goto cleanup;
}
dwStrLen = (DWORD)AnsiToWide(pszIPAddrW, pszIPAddr, INET6_ADDRSTRLEN);
if (dwStrLen == 0 || dwStrLen > INET6_ADDRSTRLEN)
{
ASSERT(FALSE);
hr = DPERR_GENERIC;
goto cleanup;
}
paDPAddrEl[j].guidDataType = DPAID_INet; // XXX
paDPAddrEl[j].dwDataSize = dwStrLen;
paDPAddrEl[j++].lpData = pszIPAddr;
paDPAddrEl[j].guidDataType = DPAID_INetW; // XXX
paDPAddrEl[j].dwDataSize = dwStrLen * sizeof(WCHAR);
paDPAddrEl[j++].lpData = pszIPAddrW;
pszIPAddr += INET6_ADDRSTRLEN; // bump buffer ptrs by max str size
pszIPAddrW += INET6_ADDRSTRLEN;
}
// create the address
hr = pad->lpISP->lpVtbl->CreateCompoundAddress(pad->lpISP,
paDPAddrEl, 2*count+1, pad->lpAddress, pad->lpdwAddressSize);
cleanup:
ENTER_DPSP();
FreeHostAddr(pList);
MemFree(paDPAddrEl);
MemFree(pszBuf);
MemFree(pszBufW);
LEAVE_DPSP();
return hr;
} // SP_GetAddressLocal
// get the ip address of the player from its playerdata
// ask winsock to convert that to a hostname
HRESULT WINAPI SP_GetAddress(LPDPSP_GETADDRESSDATA pad)
{
HRESULT hr = DP_OK;
LPSPPLAYERDATA ppd;
DWORD dwSize = sizeof(SPPLAYERDATA);
CHAR szNetName[INET6_ADDRSTRLEN];
DWORD dwNetNameSize;
UINT nStrLen;
LPSOCKADDR_IN6 psockaddr;
DWORD dwDataSize = sizeof(GLOBALDATA);
LPGLOBALDATA pgd;
DPCOMPOUNDADDRESSELEMENT addressElements[3];
WCHAR szNetNameW[HOST_NAME_LENGTH];
INT ret;
// get the global data
hr = pad->lpISP->lpVtbl->GetSPData(pad->lpISP,(LPVOID *)&pgd,&dwDataSize,DPGET_LOCAL);
if (FAILED(hr) || (dwDataSize != sizeof(GLOBALDATA) ))
{
DPF_ERR("couldn't get SP data from DirectPlay - failing");
return E_FAIL;
}
hr = pad->lpISP->lpVtbl->GetSPPlayerData(pad->lpISP,pad->idPlayer,&ppd,&dwSize,DPGET_REMOTE);
if (FAILED(hr))
{
ASSERT(FALSE);
return hr;
}
if (pad->dwFlags & DPLAYI_PLAYER_PLAYERLOCAL)
{
// We use a different approach for local players
return SP_GetAddressLocal(pad);
}
else
{
psockaddr = DGRAM_PSOCKADDR(ppd);
dwNetNameSize = sizeof(szNetName);
ret = WSAAddressToString((LPSOCKADDR)psockaddr, sizeof(*psockaddr),
NULL, szNetName, &dwNetNameSize);
}
if (ret)
{
// rut ro
DPF_ERR("got no string back from getaddress");
return E_FAIL;
}
nStrLen = strlen(szNetName)+1;
DPF(2,"get address found address for player id %d = %s\n",pad->idPlayer,szNetName);
// get UNICODE version of address
if (!AnsiToWide(szNetNameW, szNetName, HOST_NAME_LENGTH))
return (DPERR_GENERIC);
// service provider chunk
addressElements[0].guidDataType = DPAID_ServiceProvider;
addressElements[0].dwDataSize = sizeof(GUID);
addressElements[0].lpData = (LPVOID) &GUID_IPV6;
// ANSI name
addressElements[1].guidDataType = DPAID_INet;
addressElements[1].dwDataSize = nStrLen;
addressElements[1].lpData = szNetName;
// UNICODE name
addressElements[2].guidDataType = DPAID_INetW;
addressElements[2].dwDataSize = nStrLen * sizeof(WCHAR);
addressElements[2].lpData = szNetNameW;
// create the address
hr = pad->lpISP->lpVtbl->CreateCompoundAddress(pad->lpISP,
addressElements, 3,
pad->lpAddress, pad->lpdwAddressSize);
return hr;
} // SP_GetAddress
#undef DPF_MODNAME
#define DPF_MODNAME "Reply"
// called by ReplyThreadProc to send the reply out on the wire
HRESULT SendReply(LPGLOBALDATA pgd,LPREPLYLIST prd)
{
HRESULT hr;
SOCKET sSocket;
UINT addrlen = sizeof(SOCKADDR_IN6);
UINT err;
BOOL bConnectionExists = FALSE;
// now, send out prd
{
DPID dpidPlayer=0;
#ifdef FULLDUPLEX_SUPPORT
// if client wants us to reuse a connection, it would have indicated so and the connection
// would have been added to our send list by now. See if it exists.
// todo - we don't want to search the receive list everytime - find a better way
bConnectionExists = FindSocketInBag(pgd, &prd->sockaddr, &prd->sSocket,&dpidPlayer);
#endif // FULLDUPLEX_SUPPORT
if (!bConnectionExists)
{
// socket didn't exist in our send list, let's send it on a new temporary connection
DEBUGPRINTADDR(9,"Sending reply on a new connection to - ", &(prd->sockaddr));
hr = CreateSocket(pgd,&sSocket,SOCK_STREAM,0,&sockaddr_any,&err,FALSE);
if (FAILED(hr))
{
DPF(0,"create reply socket failed - err = %d\n",err);
return hr;
}
SetReturnAddress(prd->lpMessage,pgd->sSystemStreamSocket);
hr = SPConnect(&sSocket,(LPSOCKADDR)&(prd->sockaddr),addrlen,FALSE);
if (FAILED(hr))
{
DEBUGPRINTADDR(0,"reply - connect failed - addr = ",(LPSOCKADDR)&(prd->sockaddr));
}
else
{
DEBUGPRINTADDR(9,"Sending reply to - ", &(prd->sockaddr));
err = send(sSocket,prd->lpMessage,prd->dwMessageSize,0);
if (SOCKET_ERROR == err)
{
err = WSAGetLastError();
DPF(0,"reply - send error - err = %d\n",err);
hr = E_FAIL;
}
}
// nuke the socket
KillSocket(sSocket,TRUE,FALSE);
}
else
{
DEBUGPRINTADDR(9,"Sending reply on an existing connection to - ", &(prd->sockaddr));
err = send(prd->sSocket,prd->lpMessage,prd->dwMessageSize,0);
if (SOCKET_ERROR == err)
{
err = WSAGetLastError();
DPF(0,"reply - send error - err = %d\n",err);
hr = E_FAIL;
}
// close the connection if it's a temporary one (no player id yet).
if (0 == dpidPlayer)
{
RemoveSocketFromReceiveList(pgd,prd->sSocket);
RemoveSocketFromBag(pgd,prd->sSocket);
}
}
}
return hr;
} // SendReply
DWORD WINAPI ReplyThreadProc(LPVOID pvCast)
{
LPREPLYLIST prd,prdNext;
HRESULT hr=DP_OK;
DWORD dwRet;
LPGLOBALDATA pgd = (LPGLOBALDATA) pvCast;
while (1)
{
// wait on our event. when it's set, we either split, or empty the reply list
dwRet = WaitForSingleObject(pgd->hReplyEvent,INFINITE);
if (WAIT_OBJECT_0 != dwRet)
{
ASSERT(FALSE);
goto CLEANUP_EXIT;
}
// shutdown?
if (pgd->bShutdown)
{
goto CLEANUP_EXIT;
}
Top:
// find our reply node
ENTER_DPSP();
// take the first one off the list
prd = pgd->pReplyList;
if (pgd->pReplyList) pgd->pReplyList = pgd->pReplyList->pNextReply;
LEAVE_DPSP();
while (prd)
{
hr = SendReply(pgd,prd);
if (FAILED(hr))
{
DPF_ERR("SendReply failed hr = 0x%08lx\n");
// we can't reach the guy, clean out other async sends.
RemovePendingAsyncSends(pgd, prd->dwPlayerTo);
goto Top;
}
// free up the reply node
ENTER_DPSP();
if (prd->lpMessage) MemFree(prd->lpMessage);
MemFree(prd);
// take the next one off the list
prd = pgd->pReplyList;
if (pgd->pReplyList) pgd->pReplyList = pgd->pReplyList->pNextReply;
LEAVE_DPSP();
}
} // 1
CLEANUP_EXIT:
ENTER_DPSP();
// cleanout reply list
prd = pgd->pReplyList;
while (prd)
{
prdNext = prd->pNextReply;
if (prd->lpMessage) MemFree(prd->lpMessage);
MemFree(prd);
prd = prdNext;
}
pgd->pReplyList = NULL;
CloseHandle(pgd->hReplyEvent);
pgd->hReplyEvent = 0;
LEAVE_DPSP();
DPF(6,"replythreadproc exit");
return 0;
} // ReplyThreadProc
HRESULT StartReplyThread(LPGLOBALDATA pgd)
{
HANDLE hThread;
DWORD dwThreadID;
// 1st, create the event
pgd->hReplyEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
if (!pgd->hReplyEvent)
{
ASSERT(FALSE);
return E_FAIL;
}
// now, spin the thread
if (hWS2)
{
hThread = CreateThread(NULL,0,AsyncSendThreadProc,pgd,0,&dwThreadID);
}
else
{
hThread = CreateThread(NULL,0,ReplyThreadProc,pgd,0,&dwThreadID);
}
if (!hThread)
{
ASSERT(FALSE);
return E_FAIL;
}
pgd->hReplyThread = hThread;
return DP_OK;
} // StartReplyThread
HRESULT WINAPI InternalSP_Reply(LPDPSP_REPLYDATA prd, DPID dwPlayerID)
{
LPSOCKADDR_IN6 psockaddr;
HRESULT hr=DP_OK;
LPMESSAGEHEADER phead;
LPBYTE pSendBufferCopy;
LPREPLYLIST prl,prlList;
DWORD dwDataSize = sizeof(GLOBALDATA);
LPGLOBALDATA pgd;
// get the global data
hr =prd->lpISP->lpVtbl->GetSPData(prd->lpISP,(LPVOID *)&pgd,&dwDataSize,DPGET_LOCAL);
if (FAILED(hr) || (dwDataSize != sizeof(GLOBALDATA) ))
{
DPF_ERR("couldn't get SP data from DirectPlay - failing");
return E_FAIL;
}
if (prd->dwMessageSize > SPMAXMESSAGELEN)
{
ASSERT(FALSE);
return DPERR_SENDTOOBIG;
}
// check the header
if (!prd->lpSPMessageHeader || !VALID_DPWS_MESSAGE(prd->lpSPMessageHeader))
{
DPF_ERR(" YIKES! Got invalid SP header - can't reply ");
ASSERT(FALSE);
return E_FAIL;
}
// get the address to reply to
phead = (LPMESSAGEHEADER)prd->lpSPMessageHeader;
psockaddr = &(phead->sockaddr);
DEBUGPRINTADDR(5,"reply - sending to ",psockaddr);
DPF(7,"reply - q'ing %d bytes hEvent = 0x%08lx\n",prd->dwMessageSize,pgd->hReplyEvent);
// stick the message size in the message
SetMessageHeader(prd->lpMessage,prd->dwMessageSize,TOKEN);
// build a copy of everything for our receive thread
ENTER_DPSP();
prl = MemAlloc(sizeof(REPLYLIST));
if (!prl)
{
LEAVE_DPSP();
DPF_ERR("could not send reply - out of memory");
return E_OUTOFMEMORY;
}
pSendBufferCopy = MemAlloc(prd->dwMessageSize);
if (!pSendBufferCopy)
{
MemFree(prl);
LEAVE_DPSP();
DPF_ERR("could not send reply - out of memory");
return E_OUTOFMEMORY;
}
memcpy(pSendBufferCopy,prd->lpMessage,prd->dwMessageSize);
prl->lpMessage = pSendBufferCopy;
prl->dwMessageSize = prd->dwMessageSize;
prl->sockaddr = *psockaddr;
prl->sSocket = INVALID_SOCKET;
// since are replies could be sent async, we need to keep track
// of how many bytes have gone out
prl->pbSend = pSendBufferCopy;
prl->dwBytesLeft = prd->dwMessageSize;
prl->dwPlayerTo=dwPlayerID;
// put prl on the end of the reply list
prlList = pgd->pReplyList;
if (!prlList)
{
pgd->pReplyList = prl;
}
else
{
// find the end
while (prlList->pNextReply) prlList = prlList->pNextReply;
ASSERT(!prlList->pNextReply);
prlList->pNextReply = prl;
}
// do we need to start the reply event?
if (!pgd->hReplyThread)
{
hr = StartReplyThread(pgd);
if (FAILED(hr))
{
ASSERT(FALSE);
}
}
LEAVE_DPSP();
// tell the reply event to do its thing
SetEvent(pgd->hReplyEvent);
return DP_OK;
} // reply
/*
** Reply
*
* CALLED BY: DPLAY
*
* PARAMETERS: prd - see dplayi.h
*
* DESCRIPTION:
* when one of the receive loops calls into dplay, dplay may call reply.
* the receive loop extracts the return address out of the message, and passes
* it to dplay . dplay passes this to reply (via prd), which figures out how to send the
* return message.
*
*
* RETURNS: E_FAIL on a socket error or DP_OK.
*
*/
HRESULT WINAPI SP_Reply(LPDPSP_REPLYDATA prd)
{
return InternalSP_Reply(prd, 0);
}
#undef DPF_MODNAME
#define DPF_MODNAME "CreatePlayer"
//
// if we're starting up a nameserver, register it w/ dphelp.exe
// see %MANROOT%\misc\w95help.c and %MANROOT%\ddhelp\dphelp.c
HRESULT StartDPHelp(LPGLOBALDATA pgd, USHORT port)
{
DWORD hpid = 0, dwFlags=0;
HRESULT hr;
CreateHelperProcess( &hpid );
if (!hpid)
{
// could't start one...
return DPERR_UNAVAILABLE;
}
if (!WaitForHelperStartup())
{
return DPERR_UNAVAILABLE;
}
hr = HelperAddDPlayServer(port);
return hr;
} // StartDPHelp
//
// we've just created a player of type dwFlags.
// if it's a system player, see if we need to start up our receive thread procs
//
HRESULT StartPlayerListenThreads(IDirectPlaySP * pISP,LPGLOBALDATA pgd,DWORD dwFlags)
{
DWORD dwThreadID;
HANDLE hThread;
if ( !(dwFlags & DPLAYI_PLAYER_SYSPLAYER) ) return DP_OK;
if (!pgd->hDGramReceiveThread)
{
ASSERT(INVALID_SOCKET != pgd->sSystemDGramSocket);
hThread = CreateThread(NULL,0,DgramListenThreadProc,
(LPVOID)pISP,0,&dwThreadID);
ASSERT(hThread);
if(pgd->hDGramReceiveThread = hThread){ // check for non-zero hThread
SetThreadPriority(hThread, THREAD_PRIORITY_ABOVE_NORMAL);
}
}
if (!pgd->hStreamReceiveThread)
{
ASSERT(INVALID_SOCKET != pgd->sSystemStreamSocket);
hThread = CreateThread(NULL,0,StreamReceiveThreadProc,
(LPVOID)pISP,0,&dwThreadID);
ASSERT(hThread);
if(pgd->hStreamReceiveThread = hThread){ // check for non-zero hThread
SetThreadPriority(hThread, THREAD_PRIORITY_ABOVE_NORMAL);
}
}
return DP_OK;
} // StartPlayerListenThreads
// create a player. get a stream and dgram socket for it, and start their listen threads.
HRESULT WINAPI SP_CreatePlayer(LPDPSP_CREATEPLAYERDATA pcpd)
{
HRESULT hr=DP_OK;
LPSPPLAYERDATA ppd;
DWORD dwSize = sizeof(SPPLAYERDATA);
DWORD dwDataSize = sizeof(GLOBALDATA);
LPGLOBALDATA pgd;
// get the global data
hr =pcpd->lpISP->lpVtbl->GetSPData(pcpd->lpISP,(LPVOID *)&pgd,&dwDataSize,DPGET_LOCAL);
if (FAILED(hr) || (dwDataSize != sizeof(GLOBALDATA) ))
{
DPF_ERR("couldn't get SP data from DirectPlay - failing");
return E_FAIL;
}
if (!(pcpd->dwFlags & DPLAYI_PLAYER_PLAYERLOCAL))
{
DWORD dwSize = sizeof(SPPLAYERDATA);
LPMESSAGEHEADER pmsg;
hr = pcpd->lpISP->lpVtbl->GetSPPlayerData(pcpd->lpISP,pcpd->idPlayer,&ppd,&dwSize,DPGET_REMOTE);
if (FAILED(hr))
{
ASSERT(FALSE);
return hr;
}
if (sizeof(SPPLAYERDATA) != dwSize)
{
// this can happen if it's a game server supplied player
return DP_OK;
}
pmsg = (LPMESSAGEHEADER)pcpd->lpSPMessageHeader;
if (!pmsg)
{
// this can happen if it's a game server supplied player
return DP_OK;
}
// make it multihomed. we passed the received address w/ the createplayer message.
// set the receive address on the player here.
// if the ip addr wasn't set, this player hasn't been "homed" yet.
// we set it here.
IP6_GetAddr((SOCKADDR_IN6 *)DGRAM_PSOCKADDR(ppd),(SOCKADDR_IN6 *)&(pmsg->sockaddr));
IP6_GetAddr((SOCKADDR_IN6 *)STREAM_PSOCKADDR(ppd),(SOCKADDR_IN6 *)&(pmsg->sockaddr));
#ifdef FULLDUPLEX_SUPPORT
// if client want's us to reuse a connection, the socket would have been added to the
// send bag already, but the id would be 0. Update the player id.
UpdateSocketPlayerID(pgd,&pmsg->sockaddr,pcpd->idPlayer);
#endif // FULLDUPLEX_SUPPORT
return DP_OK;
} // !Local
// it's local, so get it some sockets + threads if we need to
// alloc the sp player data for this player
ENTER_DPSP();
ppd = MemAlloc(sizeof(SPPLAYERDATA));
LEAVE_DPSP();
if (!ppd)
{
DPF_ERR("could not alloc player data struct");
return E_OUTOFMEMORY;
}
hr = CreatePlayerDgramSocket(pgd,ppd,pcpd->dwFlags);
if (FAILED(hr))
{
DPF_ERR("could not create dgram socket");
goto CLEANUP_EXIT;
}
hr = CreatePlayerStreamSocket(pgd,ppd,pcpd->dwFlags);
if (FAILED(hr))
{
DPF_ERR("could not create stream socket");
goto CLEANUP_EXIT;
}
// store the ppd
hr = pcpd->lpISP->lpVtbl->SetSPPlayerData(pcpd->lpISP,pcpd->idPlayer,ppd,dwSize,DPSET_REMOTE);
if (FAILED(hr))
{
ASSERT(FALSE);
goto CLEANUP_EXIT;
}
// see if we need to start listen thread for this player type.
hr = StartPlayerListenThreads(pcpd->lpISP,pgd,pcpd->dwFlags);
// if we need ddhelp, start it up
if (pcpd->dwFlags & DPLAYI_PLAYER_NAMESRVR)
{
// it's ok to pass dgram port to dplaysvr always - we use the same number for stream
// socket as well
hr = StartDPHelp(pgd,IP_DGRAM_PORT(ppd));
if (FAILED(hr))
{
// ddhelp.exe barfed
DPF_ERR(" CREATE SERVER - COULD NOT START ENUM LISTEN APPLICATION");
DPF_ERR(" GAME WILL PLAY - BUT WILL NOT RECEIVE ENUMSESSIONS REQUESTS");
goto CLEANUP_EXIT;
}
}
// fall through to clean up
CLEANUP_EXIT:
ENTER_DPSP();
if (ppd) MemFree(ppd);
LEAVE_DPSP();
return hr;
} // CreatePlayer
#undef DPF_MODNAME
#define DPF_MODNAME "DeletePlayer"
void RemovePlayerFromSocketBag(LPGLOBALDATA pgd,DWORD dwID)
{
UINT i=0;
BOOL bFound = FALSE;
SOCKET sSocket=INVALID_SOCKET;
DWORD dwSocketFlags;
if (0 == dwID)
{
return;
}
ENTER_DPSP();
// see if we've got one
while (!bFound && (i<pgd->nSocketsInBag))
{
if (pgd->BagOSockets[i].dwPlayerID == dwID)
{
bFound = TRUE;
sSocket = pgd->BagOSockets[i].sSocket;
dwSocketFlags = pgd->BagOSockets[i].dwFlags;
DPF(5,"removing socket from bago id = %d, slot = %d",dwID,i);
pgd->BagOSockets[i].sSocket = INVALID_SOCKET;
pgd->BagOSockets[i].dwPlayerID = 0;
}
else i++;
}
LEAVE_DPSP();
if (bFound)
{
if (INVALID_SOCKET == sSocket) return ;
// if socket is fullduplex, remove it from the receive list as well
if (dwSocketFlags & DPSP_OUTBOUNDONLY)
{
// this function will kill the socket as well
RemoveSocketFromReceiveList(pgd,sSocket);
}
else
{
KillSocket(sSocket,TRUE,FALSE);
}
}
return ;
} // RemovePlayerFromSocketBag
HRESULT WINAPI SP_DeletePlayer(LPDPSP_DELETEPLAYERDATA pdpd)
{
DWORD dwDataSize = sizeof(GLOBALDATA);
LPGLOBALDATA pgd;
HRESULT hr;
DWORD sleepcount=0;
DPF(9, "Entering SP_DeletePlayer, player %d, flags 0x%x, lpISP 0x%08x\n",
pdpd->idPlayer, pdpd->dwFlags, pdpd->lpISP);
// get the global data
hr =pdpd->lpISP->lpVtbl->GetSPData(pdpd->lpISP,(LPVOID *)&pgd,&dwDataSize,DPGET_LOCAL);
if (FAILED(hr) || (dwDataSize != sizeof(GLOBALDATA) ))
{
DPF_ERR("couldn't get SP data from DirectPlay - failing");
return E_FAIL;
}
// give the reply list 5 seconds to clear out
while(bAsyncSendsPending(pgd, pdpd->idPlayer)){
Sleep(100);
if(sleepcount++ == 50){
break;
}
}
RemovePendingAsyncSends(pgd, pdpd->idPlayer);
// if it's not local, we don't care
if (!(pdpd->dwFlags & DPLAYI_PLAYER_PLAYERLOCAL))
{
RemovePlayerFromSocketBag(pgd,pdpd->idPlayer);
return DP_OK;
}
// if it's not a sysplayer - we're done
// if its a sysplayer, we kill 'em, cause we may need to rebind to a new port
if (!(pdpd->dwFlags & DPLAYI_PLAYER_SYSPLAYER))
{
return DP_OK;
}
if (pdpd->dwFlags & DPLAYI_PLAYER_NAMESRVR)
{
USHORT port;
LPSPPLAYERDATA ppd;
DWORD dwSize = sizeof(SPPLAYERDATA);
// we need to get the port to to delete the server
hr = pdpd->lpISP->lpVtbl->GetSPPlayerData(pdpd->lpISP,pdpd->idPlayer,&ppd,&dwSize,DPGET_REMOTE);
if ( FAILED(hr) || (sizeof(SPPLAYERDATA) != dwSize) )
{
ASSERT(FALSE);
}
else
{
// tell dplaysvr to delete this server
port = IP_DGRAM_PORT(ppd);
if ( !HelperDeleteDPlayServer(port) )
{
// ddhelp.exe barfed
DPF_ERR(" could not unregister w/ dphelp");
// keep going...
}
}
}
return DP_OK;
} // DeletePlayer
#undef DPF_MODNAME
#define DPF_MODNAME "UnreliableSend"
HRESULT UnreliableSend(LPDPSP_SENDDATA psd)
{
SOCKADDR_IN6 sockaddr;
INT iAddrLen = sizeof(sockaddr);
HRESULT hr=DP_OK;
UINT err;
DWORD dwSize = sizeof(SPPLAYERDATA);
LPSPPLAYERDATA ppdTo;
DWORD dwDataSize = sizeof(GLOBALDATA);
LPGLOBALDATA pgd;
// get the global data
hr =psd->lpISP->lpVtbl->GetSPData(psd->lpISP,(LPVOID *)&pgd,&dwDataSize,DPGET_LOCAL);
if (FAILED(hr) || (dwDataSize != sizeof(GLOBALDATA) ))
{
DPF_ERR("couldn't get SP data from DirectPlay - failing");
return E_FAIL;
}
if (pgd->iMaxUdpDg && (psd->dwMessageSize >= pgd->iMaxUdpDg))
{
return DPERR_SENDTOOBIG;
}
if (INVALID_SOCKET == pgd->sUnreliableSocket)
{
hr = CreateSocket(pgd,&(pgd->sUnreliableSocket),SOCK_DGRAM,0,&sockaddr_any,&err,FALSE);
if (FAILED(hr))
{
DPF(0,"create unreliable send socket failed - err = %d\n",err);
return hr;
}
}
// get to address
if (0 == psd->idPlayerTo)
{
sockaddr = pgd->saddrNS;
}
else
{
hr = psd->lpISP->lpVtbl->GetSPPlayerData(psd->lpISP,psd->idPlayerTo,&ppdTo,&dwSize,DPGET_REMOTE);
if (FAILED(hr))
{
ASSERT(FALSE);
return hr;
}
CopyMemory(&sockaddr, DGRAM_PSOCKADDR(ppdTo), iAddrLen);
}
// put the token + size on front of the mesage
SetMessageHeader(psd->lpMessage,psd->dwMessageSize,TOKEN);
if (psd->bSystemMessage)
{
SetReturnAddress(psd->lpMessage,SERVICE_SOCKET(pgd));
} // reply
else
{
// see if we can send this message w/ no header
// if the message is smaller than a dword, or, if it's a valid sp header (fooling us
// on the other end, don't send any header
if ( !((psd->dwMessageSize >= sizeof(DWORD)) && !(VALID_SP_MESSAGE(psd->lpMessage))) )
{
psd->lpMessage = (LPBYTE)psd->lpMessage +sizeof(MESSAGEHEADER);
psd->dwMessageSize -= sizeof(MESSAGEHEADER);
}
}
DEBUGPRINTADDR(5,"unreliable send - sending to ",&sockaddr);
err = sendto(pgd->sUnreliableSocket,psd->lpMessage,psd->dwMessageSize,0,
(LPSOCKADDR)&sockaddr,iAddrLen);
if (SOCKET_ERROR == err)
{
err = WSAGetLastError();
DPF(0,"send error - err = %d\n",err);
hr = E_UNEXPECTED;
}
// fall through...
return hr;
} // UnreliableSend
#undef DPF_MODNAME
#define DPF_MODNAME "ReliableSend"
// see if we can find or create a connected socket in our
// bag o' sockets for player dwID
HRESULT GetSocketFromBag(LPGLOBALDATA pgd,SOCKET * psSocket, DWORD dwID,
LPSOCKADDR_IN6 psockaddr)
{
HRESULT hr;
UINT i=0;
BOOL bFound = FALSE;
BOOL bTrue = TRUE;
UINT err;
SOCKET sSocket;
DPF(9, "GetSocketFromBag for id %d",dwID);
if (0 == dwID)
{
// need a real id
return E_FAIL;
}
ENTER_DPSP();
// see if we've got one already hooked up
while ((i < pgd->nSocketsInBag) && !bFound)
{
// if it's a valid socket and the id's match, use it
if ( (INVALID_SOCKET != pgd->BagOSockets[i].sSocket) &&
(pgd->BagOSockets[i].dwPlayerID == dwID) )
{
bFound = TRUE;
}
else i++;
}
LEAVE_DPSP();
if (bFound)
{
// bingo! got one
DPF(7, "Found socket in bag for player %d",dwID);
*psSocket = pgd->BagOSockets[i].sSocket;
return DP_OK;
}
// we don't have a socket for this player, let's get a new one
DPF(5,"adding new socket to bag for id = %d, slot = %d",dwID,i);
// create and connect socket
hr = CreateAndConnectSocket(pgd,&sSocket,SOCK_STREAM,psockaddr, (pgd->dwFlags & DPSP_OUTBOUNDONLY));
if (FAILED(hr))
{
return hr;
}
// enable keepalives
if( SOCKET_ERROR == setsockopt( sSocket,SOL_SOCKET,SO_KEEPALIVE,
(char FAR *)&bTrue,sizeof(bTrue) ) )
{
err = WSAGetLastError();
DPF(2,"create - could not turn on keepalive err = %d\n",err);
// keep trying
}
hr = AddSocketToBag(pgd, sSocket, dwID, psockaddr, 0);
if (FAILED(hr))
{
DPF(0,"Failed to add socket to bag: hr = 0x%08x", hr);
return hr;
}
DPF(7,"Created a new socket for player %d",dwID);
*psSocket = sSocket ;
return hr;
} // GetSocketFromBag
HRESULT ReliableSend(LPDPSP_SENDDATA psd)
{
SOCKET sSocket = INVALID_SOCKET;
SOCKADDR_IN6 sockaddr;
INT iAddrLen = sizeof(sockaddr);
HRESULT hr;
DWORD dwSize = sizeof(SPPLAYERDATA);
LPSPPLAYERDATA ppdTo;
BOOL fKillSocket = FALSE; // don't kill this socket, it's from the bago
DWORD dwDataSize = sizeof(GLOBALDATA);
LPGLOBALDATA pgd;
// get the global data
hr =psd->lpISP->lpVtbl->GetSPData(psd->lpISP,(LPVOID *)&pgd,&dwDataSize,DPGET_LOCAL);
if (FAILED(hr) || (dwDataSize != sizeof(GLOBALDATA) ))
{
DPF_ERR("couldn't get SP data from DirectPlay - failing");
return E_FAIL;
}
// get player to
if (0 == psd->idPlayerTo)
{
sockaddr = pgd->saddrNS;
}
else
{
hr = psd->lpISP->lpVtbl->GetSPPlayerData(psd->lpISP,psd->idPlayerTo,&ppdTo,&dwSize,DPGET_REMOTE);
if (FAILED(hr))
{
DPF(1, "GetSPPlayerData for player %d returned err %d", psd->idPlayerTo, hr);
if (hr != DPERR_INVALIDPLAYER) // this can happen because of race conditions
ASSERT(FALSE);
return hr;
}
CopyMemory(&sockaddr, STREAM_PSOCKADDR(ppdTo), iAddrLen);
}
if (psd->bSystemMessage)
{
SetReturnAddress(psd->lpMessage,SERVICE_SOCKET(pgd));
}
// put the token + size on front of the mesage
SetMessageHeader(psd->lpMessage,psd->dwMessageSize,TOKEN);
DEBUGPRINTADDR(5,"reliable send - sending to ",&sockaddr);
hr = InternalReliableSend(pgd,psd->idPlayerTo,&sockaddr, psd->lpMessage, psd->dwMessageSize);
return hr;
} // InternalReliableSend
// puts together a replynode, and calls sp_reply to do
// an async send
HRESULT AsyncSend(LPDPSP_SENDDATA psd)
{
SOCKADDR_IN6 sockaddr;
INT iAddrLen = sizeof(sockaddr);
HRESULT hr;
DWORD dwSize = sizeof(SPPLAYERDATA);
LPSPPLAYERDATA ppdTo;
DWORD dwDataSize = sizeof(GLOBALDATA);
LPGLOBALDATA pgd;
MESSAGEHEADER head;
DPSP_REPLYDATA rd;
// get the global data
hr =psd->lpISP->lpVtbl->GetSPData(psd->lpISP,(LPVOID *)&pgd,&dwDataSize,DPGET_LOCAL);
if (FAILED(hr) || (dwDataSize != sizeof(GLOBALDATA) ))
{
DPF_ERR("couldn't get SP data from DirectPlay - failing");
return E_FAIL;
}
// get player to
if (0 == psd->idPlayerTo)
{
sockaddr = pgd->saddrNS;
}
else
{
hr = psd->lpISP->lpVtbl->GetSPPlayerData(psd->lpISP,psd->idPlayerTo,&ppdTo,&dwSize,DPGET_REMOTE);
if (FAILED(hr))
{
ASSERT(FALSE);
return hr;
}
iAddrLen = sizeof(SOCKADDR_IN6);
CopyMemory(&sockaddr,STREAM_PSOCKADDR(ppdTo), iAddrLen);
}
// write the return address into the on the wire message
SetReturnAddress(psd->lpMessage,SERVICE_SOCKET(pgd));
// put the token + size on front of the mesage
SetMessageHeader(psd->lpMessage,psd->dwMessageSize,TOKEN);
// set up a header. this will be passed to reply, and will tell the reply thread
// whre to send teh message
CopyMemory(& head.sockaddr, &sockaddr, iAddrLen);
// put our token on the front so the reply thread knows its a valid reply
SetMessageHeader((LPDWORD)(&head),0,TOKEN);
// use SP_Reply to send this for us...
memset(&rd,0,sizeof(rd));
rd.lpSPMessageHeader = &head;
rd.lpMessage = psd->lpMessage;
rd.dwMessageSize = psd->dwMessageSize;
rd.lpISP = psd->lpISP;
hr = InternalSP_Reply(&rd,psd->idPlayerTo);
return hr;
} // AsyncSend
#ifdef SENDEX
HRESULT WINAPI SP_GetMessageQueue(LPDPSP_GETMESSAGEQUEUEDATA pgqd)
{
LPGLOBALDATA pgd;
DWORD dwDataSize;
BILINK *pBilinkWalker;
DWORD dwNumMsgs = 0;
DWORD dwNumBytes = 0;
LPSENDINFO lpSendInfo;
HRESULT hr;
hr = pgqd->lpISP->lpVtbl->GetSPData(pgqd->lpISP,(LPVOID *)&pgd,&dwDataSize,DPGET_LOCAL);
if (FAILED(hr) || (dwDataSize != sizeof(GLOBALDATA) ))
{
DPF_ERR("couldn't get SP data from DirectPlay - failing");
return E_FAIL;
}
EnterCriticalSection(&pgd->csSendEx);
if(!pgqd->idFrom && !pgqd->idTo){
// just wants totals, I already know that!
dwNumMsgs = pgd->dwMessagesPending;
dwNumBytes = pgd->dwBytesPending;
} else {
// gotta walk the list.
pBilinkWalker=pgd->PendingSendQ.next;
while(pBilinkWalker != &pgd->PendingSendQ)
{
lpSendInfo=CONTAINING_RECORD(pBilinkWalker, SENDINFO, PendingSendQ);
pBilinkWalker=pBilinkWalker->next;
if(pgqd->idTo && pgqd->idFrom) {
if(lpSendInfo->idTo==pgqd->idTo && lpSendInfo->idFrom==pgqd->idFrom){
dwNumMsgs++;
dwNumBytes+=lpSendInfo->dwMessageSize;
}
} else if (pgqd->idTo){
if(lpSendInfo->idTo==pgqd->idTo){
dwNumMsgs++;
dwNumBytes+=lpSendInfo->dwMessageSize;
}
} else if (pgqd->idFrom) {
if(lpSendInfo->idFrom==pgqd->idFrom){
dwNumMsgs++;
dwNumBytes+=lpSendInfo->dwMessageSize;
}
} else {
ASSERT(0);
}
}
}
LeaveCriticalSection(&pgd->csSendEx);
if(pgqd->lpdwNumMsgs){
*pgqd->lpdwNumMsgs = dwNumMsgs;
}
if(pgqd->lpdwNumBytes){
*pgqd->lpdwNumBytes = dwNumBytes;
}
return DP_OK;
}
HRESULT WINAPI SP_SendEx(LPDPSP_SENDEXDATA psd)
{
HRESULT hr=DP_OK;
DWORD dwDataSize = sizeof(GLOBALDATA);
LPGLOBALDATA pgd;
LPSENDINFO lpSendInfo;
// get the global data
hr =psd->lpISP->lpVtbl->GetSPData(psd->lpISP,(LPVOID *)&pgd,&dwDataSize,DPGET_LOCAL);
if (FAILED(hr) || (dwDataSize != sizeof(GLOBALDATA) ))
{
DPF_ERR("couldn't get SP data from DirectPlay - failing");
return E_FAIL;
}
if (psd->dwMessageSize >= SPMAXMESSAGELEN)
{
return DPERR_SENDTOOBIG;
}
// overlapped and SPheader buffer are allocated together.
lpSendInfo = pgd->pSendInfoPool->Get(pgd->pSendInfoPool);
if(!lpSendInfo){
hr=DPERR_OUTOFMEMORY;
DPF(0,"WSOCK: sendex couldn't allocate overlapped, out of memory!\n");
goto EXIT;
}
lpSendInfo->SendArray[0].buf = (CHAR *)(lpSendInfo+1);
lpSendInfo->SendArray[0].len = sizeof(MESSAGEHEADER);
ASSERT(psd->cBuffers < MAX_SG-1); //BUGBUG: coalesce please!
memcpy(&lpSendInfo->SendArray[1], psd->lpSendBuffers, psd->cBuffers*sizeof(SGBUFFER));
if (psd->dwFlags & DPSEND_GUARANTEE)
{
hr = ReliableSendEx(psd,lpSendInfo);
if (hr!=DPERR_PENDING && FAILED(hr)) {
pgd->pSendInfoPool->Release(pgd->pSendInfoPool, lpSendInfo);
DPF(0,"reliable sendex failed - error - hr = 0x%08lx\n",hr);
}
}
else
{
hr = UnreliableSendEx(psd,lpSendInfo);
if (hr!=DPERR_PENDING && FAILED(hr)) {
pgd->pSendInfoPool->Release(pgd->pSendInfoPool, lpSendInfo);
DPF(0,"unreliable sendex failed - error - hr = 0x%08lx\n",hr);
}
}
EXIT:
return hr;
} // send
HRESULT ReliableSendEx(LPDPSP_SENDEXDATA psd, LPSENDINFO pSendInfo)
{
SOCKET sSocket = INVALID_SOCKET;
SOCKADDR_IN6 sockaddr;
INT iAddrLen = sizeof(sockaddr);
HRESULT hr;
DWORD dwSize = sizeof(SPPLAYERDATA);
LPSPPLAYERDATA ppdTo;
BOOL fKillSocket = FALSE; // don't kill this socket, it's from the bago
DWORD dwDataSize = sizeof(GLOBALDATA);
LPGLOBALDATA pgd;
// get the global data
hr =psd->lpISP->lpVtbl->GetSPData(psd->lpISP,(LPVOID *)&pgd,&dwDataSize,DPGET_LOCAL);
if (FAILED(hr) || (dwDataSize != sizeof(GLOBALDATA) ))
{
DPF_ERR("couldn't get SP data from DirectPlay - failing");
return E_FAIL;
}
// get player to
if (0 == psd->idPlayerTo)
{
sockaddr = pgd->saddrNS;
}
else
{
hr = psd->lpISP->lpVtbl->GetSPPlayerData(psd->lpISP,psd->idPlayerTo,&ppdTo,&dwSize,DPGET_REMOTE);
if (FAILED(hr))
{
DPF(1, "GetSPPlayerData for player %d returned err %d", psd->idPlayerTo, hr);
if (hr != DPERR_INVALIDPLAYER) // this can happen because of race conditions
ASSERT(FALSE);
return hr;
}
iAddrLen = sizeof(SOCKADDR_IN6);
CopyMemory(&sockaddr, STREAM_PSOCKADDR(ppdTo), iAddrLen);
}
if (psd->bSystemMessage)
{
SetReturnAddress((pSendInfo->SendArray)[0].buf,SERVICE_SOCKET(pgd));
}
// put the token + size on front of the mesage
SetMessageHeader((LPVOID)(pSendInfo->SendArray)[0].buf,psd->dwMessageSize+sizeof(MESSAGEHEADER),TOKEN);
DEBUGPRINTADDR(5,"reliable send - sending to ",&sockaddr);
hr = InternalReliableSendEx(pgd,psd,pSendInfo,&sockaddr);
return hr;
} // ReliableSendEx
#endif //SENDEX
HRESULT InternalReliableSend(LPGLOBALDATA pgd, DPID idPlayerTo, SOCKADDR_IN6 *
lpSockAddr, LPBYTE lpMessage, DWORD dwMessageSize)
{
HRESULT hr;
SOCKET sSocket = INVALID_SOCKET;
UINT err;
// see if we have a connection already
hr = GetSocketFromBag(pgd,&sSocket,idPlayerTo,lpSockAddr);
if (SUCCEEDED(hr))
{
// we do, send the message
err = send(sSocket,lpMessage,dwMessageSize,0);
if (SOCKET_ERROR == err)
{
err = WSAGetLastError();
// we got a socket from the bag. send failed,
// so we're cruising it from the bag
DPF(0,"send error - err = %d\n",err);
DPF(4,"send failed - removing socket from bag");
RemovePlayerFromSocketBag(pgd,idPlayerTo);
if(err==WSAECONNRESET || err==WSAENETRESET || err==WSAENOTCONN){
hr=DPERR_CONNECTIONLOST;
} else {
hr = E_FAIL;
}
}
return hr;
}
// if we reach here, we don't have a connection so get a new one
hr = CreateAndConnectSocket(pgd,&sSocket,SOCK_STREAM,lpSockAddr,(pgd->dwFlags & DPSP_OUTBOUNDONLY));
if (FAILED(hr))
{
goto CLEANUP_EXIT;
}
// send the message
err = send(sSocket,lpMessage,dwMessageSize,0);
if (SOCKET_ERROR == err)
{
err = WSAGetLastError();
DPF(0,"send error - err = %d\n",err);
if(err == WSAECONNRESET || err==WSAENETRESET || err==WSAENOTCONN){
hr = DPERR_CONNECTIONLOST;
} else {
hr = E_FAIL;
}
goto CLEANUP_EXIT;
}
// success
hr = DP_OK;
// fall through
CLEANUP_EXIT:
// if we are in outbound only mode, receiver will close the connection, so don't bother
if ((INVALID_SOCKET != sSocket) && !(pgd->dwFlags & DPSP_OUTBOUNDONLY))
{
KillSocket(sSocket, TRUE, FALSE);
}
return hr;
}
// called when a to player can't be reached or is deleted.
VOID RemovePendingAsyncSends(LPGLOBALDATA pgd, DPID dwPlayerTo)
{
LPREPLYLIST prl, prlPrev;
#ifdef DEBUG
DWORD dwBlowAwayCount=0;
#endif
if(!dwPlayerTo){
return;
}
ENTER_DPSP();
prlPrev = (LPREPLYLIST)(&pgd->pReplyList); // HACKHACK, treat struct as dummy node.
prl = pgd->pReplyList;
while(prl){
if(prl->dwPlayerTo == dwPlayerTo){
prlPrev->pNextReply=prl->pNextReply;
if(prl->lpMessage) {
MemFree(prl->lpMessage);
}
MemFree(prl);
#ifdef DEBUG
dwBlowAwayCount++;
#endif
} else {
prlPrev=prl;
}
prl=prlPrev->pNextReply;
}
DPF(4,"RemovePendingAsyncSends for player %x, blew away %d pending sends\n",dwPlayerTo,dwBlowAwayCount);
LEAVE_DPSP();
}
// In order to ensure send ordering even if we are doing async sends, we
// check and wait for any pending async sends to complete. If they don't complete
// in 5 seconds then we make the send async.
BOOL bAsyncSendsPending(LPGLOBALDATA pgd, DPID dwPlayerTo)
{
LPREPLYLIST prlList;
if(!dwPlayerTo){
return FALSE;
}
ENTER_DPSP();
prlList = pgd->pReplyList;
while(prlList){
if(prlList->dwPlayerTo == dwPlayerTo){
LEAVE_DPSP();
return TRUE;
}
prlList=prlList->pNextReply;
}
LEAVE_DPSP()
return FALSE;
}
HRESULT WINAPI SP_Send(LPDPSP_SENDDATA psd)
{
HRESULT hr=DP_OK;
DWORD dwDataSize = sizeof(GLOBALDATA);
LPGLOBALDATA pgd;
// get the global data
hr =psd->lpISP->lpVtbl->GetSPData(psd->lpISP,(LPVOID *)&pgd,&dwDataSize,DPGET_LOCAL);
if (FAILED(hr) || (dwDataSize != sizeof(GLOBALDATA) ))
{
DPF_ERR("couldn't get SP data from DirectPlay - failing");
return E_FAIL;
}
if (psd->dwMessageSize >= SPMAXMESSAGELEN)
{
return DPERR_SENDTOOBIG;
}
if (psd->dwFlags & DPSEND_GUARANTEE)
{
if (psd->dwFlags & DPSEND_ASYNC) hr = AsyncSend(psd);
else {
if(bAsyncSendsPending(pgd, psd->idPlayerTo)){
hr = AsyncSend(psd);
} else {
hr = ReliableSend(psd);
}
}
if (FAILED(hr)) DPF(0,"reliable send failed - error - hr = 0x%08lx\n",hr);
}
else
{
hr = UnreliableSend(psd);
if (FAILED(hr)) DPF(0,"unreliable send failed - error - hr = 0x%08lx\n",hr);
}
return hr;
} // send
#ifdef SENDEX
HRESULT InitGlobalsInPlace(LPGLOBALDATA pgd)
{
InitBilink(&pgd->PendingSendQ);
InitBilink(&pgd->ReadyToSendQ);
//pgd->dwBytesPending=0; //by memset below.
//pgd->dwMessagesPending=0; //by memset below.
// Initialize the pool for send headers and overlapped stucts
pgd->pSendInfoPool=FPM_Init(sizeof(SENDINFO)+sizeof(MESSAGEHEADER),NULL,NULL,NULL);
if(!pgd->pSendInfoPool){
goto ERROR_EXIT;
}
InitializeCriticalSection(&pgd->csSendEx);
return DP_OK;
ERROR_EXIT:
return DPERR_NOMEMORY;
}
#endif
void KillTCPEnumAsyncThread(LPGLOBALDATA pgd)
{
HANDLE hTCPEnumAsyncThread;
DWORD SleepCount=0;
ENTER_DPSP();
if(pgd->hTCPEnumAsyncThread){
DPF(9,"Killing Running Async TCP enum thread\n");
//hTCPEnumAsyncThread is 0, thread knows we are
//waiting for thread to finish, so we own closing
// the handle.
hTCPEnumAsyncThread=pgd->hTCPEnumAsyncThread;
pgd->hTCPEnumAsyncThread=0;
// We need to close the socket out from under the
// TCPEnum thread in order to have it continue and
// exit. So make sure the socket has been allocated
// first, but don't wait if the thread has exited
// already (which is why we check lpEnumMessage.)
while(pgd->sEnum==INVALID_SOCKET && pgd->lpEnumMessage){
LEAVE_DPSP();
Sleep(500);
ENTER_DPSP();
if(SleepCount++ > 10 )break; // don't wait more than 5 seconds.
}
if(pgd->sEnum!=INVALID_SOCKET){
if(pgd->bOutBoundOnly){
RemoveSocketFromReceiveList(pgd,pgd->sEnum);
} else {
closesocket(pgd->sEnum);
}
}
LEAVE_DPSP();
WaitForSingleObject(hTCPEnumAsyncThread,150*1000);
CloseHandle(hTCPEnumAsyncThread);
DPF(9,"Async enum thread is dead.\n");
} else {
LEAVE_DPSP();
}
}
void InitGlobals(LPGLOBALDATA pgd)
{
if(pgd->hTCPEnumAsyncThread){
KillTCPEnumAsyncThread(pgd);
}
ENTER_DPSP();
if (pgd->BagOSockets)
{
MemFree(pgd->BagOSockets);
}
if (pgd->ReceiveList.pConnection)
{
MemFree(pgd->ReceiveList.pConnection);
}
if (pgd->readfds.pfdbigset)
{
MemFree(pgd->readfds.pfdbigset);
}
#ifdef SENDEX
if(pgd->bSendThreadRunning){
pgd->bStopSendThread=TRUE;
SetEvent(pgd->hSendWait);
}
while(pgd->bSendThreadRunning){
Sleep(0);
}
if(pgd->hSendWait){
CloseHandle(pgd->hSendWait);
pgd->hSendWait=NULL;
}
if(pgd->pSendInfoPool){
pgd->pSendInfoPool->Fini(pgd->pSendInfoPool,0);
DeleteCriticalSection(&pgd->csSendEx);
//pgd->pSendInfoPool=NULL; //by memset below.
}
#endif
// set global data to 0
memset(pgd,0,sizeof(GLOBALDATA));
// uses INVALID_SOCKET, not 0, to indicate bogus socket
pgd->sSystemDGramSocket= INVALID_SOCKET;
pgd->sSystemStreamSocket= INVALID_SOCKET;
pgd->sUnreliableSocket = INVALID_SOCKET;
#ifdef BIGMESSAGEDEFENSE
pgd->dwMaxMessageSize = SPMAXMESSAGELEN;
#endif
ZeroMemory(&pgd->saddrEnumAddress, sizeof(pgd->saddrEnumAddress));
LEAVE_DPSP();
} // InitGlobals
HRESULT WaitForThread(HANDLE hThread)
{
DWORD dwRet;
if (!hThread) return DP_OK;
// we assume the thread has been told to go away
// we wait for it to do so
dwRet = WaitForSingleObject(hThread,INFINITE);
if (WAIT_OBJECT_0 != dwRet)
{
ASSERT(FALSE);
return E_FAIL;
}
CloseHandle(hThread);
return DP_OK;
} // WaitForThread
HRESULT WINAPI SP_Shutdown(LPDPSP_SHUTDOWNDATA psd)
{
UINT err;
DWORD dwDataSize = sizeof(GLOBALDATA);
LPGLOBALDATA pgd;
HRESULT hr;
DPSP_CLOSEDATA cd;
BOOL bFree;
DPF(2," dpwsock - got shutdown!!\n");
// get the global data
hr = psd->lpISP->lpVtbl->GetSPData(psd->lpISP,(LPVOID *)&pgd,&dwDataSize,DPGET_LOCAL);
if (FAILED(hr) || (dwDataSize != sizeof(GLOBALDATA) ))
{
DPF_ERR("couldn't get SP data from DirectPlay - failing");
return E_FAIL;
}
// call close
cd.lpISP = psd->lpISP;
hr = SP_Close(&cd);
if (FAILED(hr))
{
DPF(0," shutdown - could not close SP hr = 0x%08lx\n",hr);
ASSERT(FALSE);
// rut roh! - keep trying
}
#ifdef DPLAY_VOICE_SUPPORT
// turn off voice, if it exists...
if (gbVoiceInit)
{
ASSERT(!gbVoiceOpen); // dplay should have shut it down!
FiniVoice();
gbVoiceInit = FALSE;
}
#endif // DPLAY_VOICE_SUPPORT
DPF(2,"shutdown, calling WSACleanup");
// it's ok to call this for each idirectplaysp that goes away, since
// we called WSAStartup once for each one at SPInit
if ( SOCKET_ERROR == WSACleanup())
{
err = WSAGetLastError();
DPF(0,"could not stop winsock err = %d\n",err);
// keep trying...
}
// if we have a winsock2, free it
if (hWS2)
{
bFree = FreeLibrary(hWS2);
if (!bFree)
{
DWORD dwError = GetLastError();
DPF(0,"SP_Shutdown - could not free ws2 library - error = %d\n",dwError);
// keep trying
}
hWS2 = NULL;
}
if (hWSHIP6)
{
bFree = FreeLibrary(hWSHIP6);
if (!bFree)
{
DWORD dwError = GetLastError();
DPF(0,"SP_Shutdown - could not free wship6 library - error = %d\n",dwError);
// keep trying
}
hWSHIP6 = NULL;
}
// reset everything...
InitGlobals(pgd);
gdwDPlaySPRefCount--;
DPF(2,"shutdown leaving");
return DP_OK;
} //Shutdown
// sp only sets fields it cares about
HRESULT WINAPI SP_GetCaps(LPDPSP_GETCAPSDATA pcd)
{
DWORD dwDataSize = sizeof(GLOBALDATA);
LPGLOBALDATA pgd;
HRESULT hr;
// get the global data
hr =pcd->lpISP->lpVtbl->GetSPData(pcd->lpISP,(LPVOID *)&pgd,&dwDataSize,DPGET_LOCAL);
if (FAILED(hr) || (dwDataSize != sizeof(GLOBALDATA) ))
{
DPF_ERR("couldn't get SP data from DirectPlay - failing");
return E_FAIL;
}
{
// AF_INET6 optimizes guaranteed
pcd->lpCaps->dwFlags |= DPCAPS_GUARANTEEDOPTIMIZED;
if (pcd->dwFlags & DPGETCAPS_GUARANTEED)
{
// TCP
pcd->lpCaps->dwHeaderLength = sizeof(MESSAGEHEADER);
pcd->lpCaps->dwMaxBufferSize = SPMAXMESSAGELEN -sizeof(MESSAGEHEADER);
pcd->lpCaps->dwMaxPlayers = pgd->nSocketsInBag;
}
else
{
// UDP
pcd->lpCaps->dwHeaderLength = sizeof(MESSAGEHEADER);
pcd->lpCaps->dwMaxBufferSize = pgd->iMaxUdpDg-sizeof(MESSAGEHEADER);
}
}
// set async caps flags
if(pgd->bSendThreadRunning){
// we are supporting async.
pcd->lpCaps->dwFlags |= (DPCAPS_ASYNCSUPPORTED);
}
// set the timeout
pcd->lpCaps->dwLatency = pgd->dwLatency;
pcd->lpCaps->dwTimeout = SPTIMEOUT(pcd->lpCaps->dwLatency);
#ifdef DPLAY_VOICE_SUPPORT
// check the voice
if (gbVoiceInit || CheckVoice()) pcd->lpCaps->dwFlags |= DPCAPS_VOICE;
#endif // DPLAY_VOICE_SUPPORT
return DP_OK;
} // SP_GetCaps
HRESULT WINAPI SP_Open(LPDPSP_OPENDATA pod)
{
LPMESSAGEHEADER phead;
DWORD dwDataSize = sizeof(GLOBALDATA);
LPGLOBALDATA pgd;
HRESULT hr;
DPF(5,"SP_Open");
#ifdef DPLAY_VOICE_SUPPORT
if (pod->dwOpenFlags & DPOPEN_VOICE)
{
if (gbVoiceOpen)
{
DPF_ERR("voice channel already open - only one per process");
return DPERR_ALREADYINITIALIZED;
}
if (!gbVoiceInit)
{
DPF(0,"DPWSOCK - listen up!!! - init'ing voice!");
hr = InitVoice();
if (FAILED(hr))
{
DPF(0,"init voice failed hr = 0x%08lx\n");
return hr;
}
gbVoiceInit = TRUE;
}
}
#endif // DPLAY_VOICE_SUPPORT
// get the global data
hr =pod->lpISP->lpVtbl->GetSPData(pod->lpISP,(LPVOID *)&pgd,&dwDataSize,DPGET_LOCAL);
if (FAILED(hr) || (dwDataSize != sizeof(GLOBALDATA) ))
{
DPF_ERR("couldn't get SP data from DirectPlay - failing");
return E_FAIL;
}
// do we have a TCP connection?
{
SOCKET_ADDRESS_LIST *pList = GetHostAddr();
if (!pList)
{
DPF(0, "No Dial-up network or netcard present");
return DPERR_NOCONNECTION; // no local IP address = no network
}
FreeHostAddr(pList);
}
// remember session information so we know if we need to turn off nagling
pgd->dwSessionFlags = pod->dwSessionFlags;
if (pod->dwOpenFlags & DPOPEN_CREATE)
{
// host should never go into this mode
pgd->dwFlags &= ~(DPSP_OUTBOUNDONLY);
}
if (pod->bCreate)
return DP_OK; // all done
phead = (LPMESSAGEHEADER)pod->lpSPMessageHeader;
// get name server address out of phead, stores it in pgd->saddrNS
pgd->saddrNS = phead->sockaddr;
// make sure we have a thread running to get the nametable
hr = StartupEnumThread(pod->lpISP,pgd);
if (FAILED(hr))
{
DPF(0," could not start open threads - hr = 0x%08lx\n",hr);
return hr;
}
return DP_OK;
} // SP_Open
#ifdef DEBUG
// make sure there are no connected sockets left in the bug
void VerifySocketBagIsEmpty(LPGLOBALDATA pgd)
{
UINT i=0;
while (i < pgd->nSocketsInBag)
{
if (INVALID_SOCKET != pgd->BagOSockets[i].sSocket)
{
DPF_ERR("socket bag not empty at close!");
ASSERT(FALSE);
}
i++;
}
} // VerifySocketBagIsEmpty
#endif // DEBUG
HRESULT WINAPI SP_Close(LPDPSP_CLOSEDATA pcd)
{
DWORD dwDataSize = sizeof(GLOBALDATA);
LPGLOBALDATA pgd;
HRESULT hr;
DWORD sleepcount=0;
DPF(2," dpwsock - got close");
// get the global data
hr =pcd->lpISP->lpVtbl->GetSPData(pcd->lpISP,(LPVOID *)&pgd,&dwDataSize,DPGET_LOCAL);
if (FAILED(hr) || (dwDataSize != sizeof(GLOBALDATA) ))
{
DPF_ERR("couldn't get SP data from DirectPlay - failing");
return E_FAIL;
}
// Stop asynchronous TCP enumeration thread if it's running
KillTCPEnumAsyncThread(pgd);
// give the reply list 5 seconds to clear out
while(pgd->pReplyList){
Sleep(100);
if(sleepcount++ == 50){
break;
}
}
// reset the nameserver address
memset(&(pgd->saddrNS),0,sizeof(SOCKADDR));
pgd->bShutdown = TRUE;
DPF(2,"close, datagram sockets");
KillSocket(pgd->sSystemDGramSocket,FALSE,TRUE);
pgd->sSystemDGramSocket = INVALID_SOCKET;
DPF(2,"Waiting for stream receive thread");
WaitForThread(pgd->hStreamReceiveThread);
pgd->hStreamReceiveThread = NULL;
DPF(2,"close stream socket");
closesocket(pgd->sSystemStreamSocket);
pgd->sSystemStreamSocket = INVALID_SOCKET;
DPF(2,"close unreliable socket");
KillSocket(pgd->sUnreliableSocket,FALSE,TRUE);
pgd->sUnreliableSocket = INVALID_SOCKET;
DPF(2,"close, waiting on threads");
// signal the reply thread
if (pgd->hReplyEvent)
{
SetEvent(pgd->hReplyEvent);
}
WaitForThread(pgd->hDGramReceiveThread);
pgd->hDGramReceiveThread = NULL;
WaitForThread(pgd->hReplyThread);
pgd->hReplyThread = NULL;
pgd->bShutdown = FALSE;
#ifdef DEBUG
// verify that the bag o' sockets is really empty
VerifySocketBagIsEmpty(pgd);
#endif
while(pgd->dwMessagesPending){
DPF(0,"Waiting for pending messages to complete\n");
Sleep(55);
}
return DP_OK;
} // SP_Close
#ifdef FIND_IP
//
// we get the ip addr of our host. this is for debug purposes only.
// we never use the ip addr of our host, since it may be multihomed.
// the receiving system assigns our players their ip addresses
HRESULT DebugFindIPAddresses(void)
{
SOCKET_ADDRESS_LIST *pList;
int i;
pList = GetHostAddr();
if (NULL == pList)
{
return E_FAIL;
}
for (i=0; i<pList->iAddressCount; i++)
{
DEBUGPRINTADDR(0,"sp - found host addr = %s \n",pList->Address[i].lpSockaddr);
}
FreeHostAddr(pList);
return DP_OK;
} // DebugFindIPAddresses
#endif // FIND_IP
/*
* EnumConnectionData
*
* Search for valid connection data
*/
BOOL FAR PASCAL EnumConnectionData(REFGUID lpguidDataType, DWORD dwDataSize,
LPCVOID lpData, LPVOID lpContext)
{
LPGLOBALDATA pgd = (LPGLOBALDATA) lpContext;
// this is an ANSI internet address
if (IsEqualGUID(lpguidDataType, &DPAID_INet))
{
// make sure there is room (for terminating null too)
if (dwDataSize > ADDR_BUFFER_SIZE)
dwDataSize = (ADDR_BUFFER_SIZE - 1);
// copy string for use later
memcpy(pgd->szServerAddress, lpData, dwDataSize);
pgd->bHaveServerAddress = TRUE; // we have a server address
}
// this is a UNICODE internet address
else if (IsEqualGUID(lpguidDataType, &DPAID_INetW))
{
if (WideToAnsi(pgd->szServerAddress, (LPWSTR) lpData, ADDR_BUFFER_SIZE))
pgd->bHaveServerAddress = TRUE; // we have a server address
}
else if (IsEqualGUID(lpguidDataType, &DPAID_INetPort))
{
pgd->wApplicationPort = *(LPWORD)lpData;
DPF(5, "Application port specified in dp address: %d",pgd->wApplicationPort);
}
#ifdef BIGMESSAGEDEFENSE
else if (IsEqualGUID(lpguidDataType, &DPAID_MaxMessageSize))
{
pgd->dwMaxMessageSize = *(LPDWORD)lpData;
ASSERT(pgd->dwMaxMessageSize > 11); // set an arbitrary minimum
if (pgd->dwMaxMessageSize < 12)
pgd->dwMaxMessageSize = 12;
DPF(5, "Max message size specified in dp address: %d",pgd->dwMaxMessageSize);
pgd->dwMaxMessageSize += sizeof(MESSAGEHEADER); // add a little extra for the shop
}
#endif
return TRUE;
} // EnumConnectionData
// nSockets was passed into spinit as dwReserved2
HRESULT InitBagOSockets(LPGLOBALDATA pgd,DWORD nSockets)
{
UINT i;
ENTER_DPSP();
if (0 == nSockets)
{
pgd->nSocketsInBag = MAX_CONNECTED_SOCKETS;
}
else
{
pgd->nSocketsInBag = nSockets;
}
pgd->BagOSockets = MemAlloc(pgd->nSocketsInBag * sizeof(PLAYERSOCK));
LEAVE_DPSP();
if (!pgd->BagOSockets)
{
pgd->nSocketsInBag = 0;
DPF_ERR("could not alloc space for socket cache - out of memory");
return E_OUTOFMEMORY;
}
for (i=0;i<pgd->nSocketsInBag;i++ )
{
pgd->BagOSockets[i].sSocket = INVALID_SOCKET;
}
return DP_OK ;
} // InitBagOSockets
extern void InitIPv6Library();
// main entry point for service provider
// sp should fill in callbacks (pSD->lpCB) and do init stuff here
HRESULT WINAPI SPInit(LPSPINITDATA pSD)
{
HRESULT hr;
UINT err;
GLOBALDATA gd,*pgd;
UINT dwSize;
SOCKET sVerifySocket; // used to verify support for the requested address family
// so, if they ask for ipx, and it's not installed, we fail here
WORD wVersion;
OSVERSIONINFO osInfo;
HANDLE hAlertThread;
// initialize global data
memset(&gd,0,sizeof(gd));
InitGlobals(&gd);
ASSERT(pSD->lpGuid);
if (IsEqualIID(pSD->lpGuid,&GUID_LOCAL_IPV6))
{
ZeroMemory(&gd.saddrEnumAddress, sizeof(gd.saddrEnumAddress));
gd.saddrEnumAddress.sin6_family = AF_INET6;
gd.saddrEnumAddress.sin6_addr = in6addr_multicast;
DPF(0," ** DPWSOCK -- RUNNING LOCAL TCP / IP ** ");
}
else
{
DPF(0," ** DPWSOCK -- RUNNING INTERNET TCP / IP ** ");
}
gd.AddressFamily = AF_INET6;
// find out what os we are running on
memset(&osInfo,0,sizeof(osInfo));
osInfo.dwOSVersionInfoSize = sizeof(osInfo);
if (!GetVersionEx(&osInfo))
{
err = GetLastError();
DPF(0,"Failed to get OS information - err = %d\n", err);
return DPERR_GENERIC;
}
// start up sockets
if (gwsaData.wVersion)
{
// note - there is a bug in winsock 1.1. if you've called WSAStartup 1x in a process,
// then if any subsequent call asks for a version # > then that returned to the first
// call, we get WSAEVERNOTSUPPORTED. So, if we've already got a version in the wsadata,
// we make sure to use that
wVersion = gwsaData.wVersion;
}
// otherwise, ask for winsock 2.0
else
{
// if we are trying to initialize IPX on a non-NT platform, don't look for Winsock 2.0
// Only look for Winsock 1.1 as Winsock 2.0 functionality is not supported for IPX on
// Memphis and Win'95.
wVersion = MAKEWORD(2,0);
}
err = WSAStartup(wVersion, &gwsaData);
if (WSAVERNOTSUPPORTED == err)
{
// they (the app) must have already called WSAStartup. see note above
// about winsock 1.1 bug.
wVersion = MAKEWORD(1,1);
err = WSAStartup(wVersion, &gwsaData);
}
if (err)
{
DPF(0,"could not start winsock err = %d\n",err);
return E_FAIL;
}
DPF(1,"spinit - name = %ls,dwReserved1 = %d,dwReserved2 = %d\n",pSD->lpszName,
pSD->dwReserved1,pSD->dwReserved2);
gd.iMaxUdpDg = gwsaData.iMaxUdpDg;
DPF(0,"detected winsock version %d.%d\n",LOBYTE(gwsaData.wVersion),HIBYTE(gwsaData.wVersion));
if (LOBYTE(gwsaData.wVersion) >= 2)
{
hr = InitWinsock2();
if (FAILED(hr))
{
DPF_ERR("detected winsock 2, but could not init it! yikes!");
ASSERT(FALSE);
}
}
DPF(1,"\nspinit - setting latency to %d\n\n", pSD->dwReserved1);
gd.dwLatency = pSD->dwReserved1;
hr = InitBagOSockets(&gd,pSD->dwReserved2);
if (FAILED(hr))
{
DPF_ERR("could not init socket cache. bailing");
goto ERROR_EXIT;
}
// make sure support exists for address family
hr = CreateSocket(&gd,&sVerifySocket,SOCK_DGRAM,0,&sockaddr_any,&err,FALSE);
if (FAILED(hr))
{
DPF(0," COULD NOT CREATE SOCKET IN REQUESTED ADDRESS FAMILY af = %d, err = %d\n",gd.AddressFamily,err);
DPF(0," SERVICE PROVIDER INITIALIZATION FAILED");
// return the same error as the modem service provider
hr = DPERR_UNAVAILABLE;
goto ERROR_EXIT;
}
if (LOBYTE(gwsaData.wVersion) >= 2)
{
// get max udp buffer size through getsockopt because
// WSAStartup doesn't return this info from winsock 2.0 onwards.
hr = GetMaxUdpBufferSize(sVerifySocket, &gd.iMaxUdpDg);
if (FAILED(hr))
{
DPF(0,"Failed to get max udp buffer size");
// since memphis still returns this value in WSAStartup
// use it. This is just a workaround for memphis bug #43655
if (gwsaData.iMaxUdpDg)
{
DPF(0, "Using iMaxUdpDg value from WSAStartup: %d", gwsaData.iMaxUdpDg);
gd.iMaxUdpDg = gwsaData.iMaxUdpDg;
}
else
{
DPF_ERR("No max UDP buffer size could be found!");
// all done w/ verify socket
KillSocket(sVerifySocket,FALSE,TRUE);
goto ERROR_EXIT;
}
}
}
// all done w/ verify socket
KillSocket(sVerifySocket,FALSE,TRUE);
InitIPv6Library();
#ifdef FIND_IP
// print out the ip address(es) of this host
DebugFindIPAddresses();
#endif
// set up callbacks
pSD->lpCB->CreatePlayer = SP_CreatePlayer;
pSD->lpCB->DeletePlayer = SP_DeletePlayer;
pSD->lpCB->Send = SP_Send;
pSD->lpCB->EnumSessions = SP_EnumSessions;
pSD->lpCB->Reply = SP_Reply;
pSD->lpCB->ShutdownEx = SP_Shutdown;
pSD->lpCB->GetCaps = SP_GetCaps;
pSD->lpCB->Open = SP_Open;
pSD->lpCB->CloseEx = SP_Close;
pSD->lpCB->GetAddress = SP_GetAddress;
#ifdef DPLAY_VOICE_SUPPORT
pSD->lpCB->OpenVoice = SP_OpenVoice;
pSD->lpCB->CloseVoice = SP_CloseVoice;
#endif // DPLAY_VOICE_SUPPORT
#ifdef SENDEX
if(LOBYTE(gwsaData.wVersion) >= 2)
{
DPF(1,"SENDEX being provided by SP\n");
// Only do new functions when Winsock 2 functions avail.
// NOTE: not supported on IPX with win9x at present, but reports 1.1 in this case.
//pSD->lpCB->SendToGroupEx = SP_SendToGroupEx; // optional - not impl
//pSD->lpCB->Cancel = SP_Cancel; // optional - not impl
pSD->lpCB->SendEx = SP_SendEx; // required for async
pSD->lpCB->GetMessageQueue = SP_GetMessageQueue;
} else {
DPF(1,"SENDEX not being provided by SP on winsock ver < 2\n");
}
#endif
// we put (at most) 1 sockaddr and one dword (size) in each message
pSD->dwSPHeaderSize = sizeof(MESSAGEHEADER);
// return version number so DirectPlay will treat us with respect
pSD->dwSPVersion = VERSIONNUMBER;
// look at connnection data
if (pSD->dwAddressSize)
{
// ask dplay to enum the chunks for us. if one of them is
// af_inet, we'll use it as our name servers address
pSD->lpISP->lpVtbl->EnumAddress(pSD->lpISP, EnumConnectionData,
pSD->lpAddress, pSD->dwAddressSize,
&gd);
}
#ifdef FULLDUPLEX_SUPPORT
// get the flags from registry
hr = GetFlagsFromRegistry(pSD->lpGuid, &gd.dwFlags);
if (FAILED(hr))
{
DPF(2, "Failed to get sp flags from the registry");
}
#endif // FULLDUPLEX_SUPPORT
// store the globaldata
hr = pSD->lpISP->lpVtbl->SetSPData(pSD->lpISP,&gd,sizeof(GLOBALDATA),DPSET_LOCAL);
if (FAILED(hr))
{
ASSERT(FALSE);
goto ERROR_EXIT;
}
hr = pSD->lpISP->lpVtbl->GetSPData(pSD->lpISP,&pgd,&dwSize,DPGET_LOCAL);
if (FAILED(hr))
{
ASSERT(FALSE);
goto ERROR_EXIT;
}
#ifdef SENDEX
if(LOBYTE(gwsaData.wVersion) >= 2) {
// some globals are self referential, can't set until here.
hr=InitGlobalsInPlace(pgd);
if(FAILED(hr))
{
ASSERT(FALSE);
goto ERROR_EXIT;
}
// added alertable thread.
pgd->hSendWait=CreateEvent(NULL, FALSE, FALSE, NULL); // autoreset.
if(!pgd->hSendWait){
ASSERT(FALSE);
goto ERROR_EXIT;
}
pgd->bSendThreadRunning=TRUE;
hAlertThread=CreateThread(NULL, 4000, SPSendThread, pgd, 0, (ULONG *)&hAlertThread);
if(!hAlertThread){
pgd->bSendThreadRunning=FALSE;
ASSERT(FALSE);
goto ERROR_EXIT;
} else {
SetThreadPriority(hAlertThread, THREAD_PRIORITY_ABOVE_NORMAL);
}
CloseHandle(hAlertThread);// don't need a handle.
}
#endif
gdwDPlaySPRefCount++;
// success!
return DP_OK;
ERROR_EXIT:
DPF_ERR("SPInit - abnormal exit");
// call this again to clean up anything we alloc'ed
InitGlobals(&gd);
DPF(2,"SPInit - calling WSACleanup");
if ( SOCKET_ERROR == WSACleanup())
{
err = WSAGetLastError();
DPF(0,"could not stop winsock err = %d\n",err);
}
return hr;
} // SPInit