|
|
/*==========================================================================
* * 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;}
voidEnumOnInterface(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
|
