/*==========================================================================; * * Copyright (C) 1994-1997 Microsoft Corporation. All Rights Reserved. * * File: wsock2.c * Content: DirectPlay Winsock 2 SP support. Called from dpsp.c. * History: * Date By Reason * ==== == ====== * 7/11//97 andyco created it * 2/13/98 aarono added async support. * 4/6/98 aarono mapped WSAECONNRESET to DPERR_CONNECTIONLOST * 6/6/98 aarono B#27187 fix ref counting on send blocks in sync error case * 7/9/99 aarono Cleaning up GetLastError misuse, must call right away, * before calling anything else, including DPF. **************************************************************************/ // this module is for async connections and sends // only used w/ TCP:IP - IPX is dgram only, so we don't bother... // currently only used as the reply thread proc for async replies. see dpsp.c::sp_reply #define INCL_WINSOCK_API_TYPEDEFS 1 // includes winsock 2 fn proto's, for getprocaddress #include #include "dpsp.h" #undef DPF_MODNAME #define DPF_MODNAME "AsyncSendThreadProc" extern HINSTANCE hWS2; // dynaload the ws2_32.dll, so if it's not installed // (e.g. win 95 gold) we still load // prototypes for our dynaload fn's LPFN_WSAWAITFORMULTIPLEEVENTS g_WSAWaitForMultipleEvents; LPFN_WSASEND g_WSASend; LPFN_WSASENDTO g_WSASendTo; LPFN_WSACLOSEEVENT g_WSACloseEvent; LPFN_WSACREATEEVENT g_WSACreateEvent; LPFN_WSAENUMNETWORKEVENTS g_WSAEnumNetworkEvents; LPFN_WSAEVENTSELECT g_WSAEventSelect; LPFN_GETSOCKOPT g_getsockopt; // attempt to load the winsock 2 dll, and get our proc addresses from it HRESULT InitWinsock2() { // load winsock library hWS2 = LoadLibrary("ws2_32.dll"); if (!hWS2) { DPF(0,"Could not load ws2_32.dll\n"); // reset our winsock 2 global goto LOADLIBRARYFAILED; } // get pointers to the entry points we need g_WSAWaitForMultipleEvents = (LPFN_WSAWAITFORMULTIPLEEVENTS)GetProcAddress(hWS2, "WSAWaitForMultipleEvents"); if(!g_WSAWaitForMultipleEvents) goto GETPROCADDRESSFAILED; g_WSASend = (LPFN_WSASEND)GetProcAddress(hWS2, "WSASend"); if (!g_WSASend) goto GETPROCADDRESSFAILED; g_WSASendTo = (LPFN_WSASENDTO)GetProcAddress(hWS2, "WSASendTo"); if (!g_WSASendTo) goto GETPROCADDRESSFAILED; g_WSAEventSelect = ( LPFN_WSAEVENTSELECT )GetProcAddress(hWS2, "WSAEventSelect"); if (!g_WSAEventSelect) goto GETPROCADDRESSFAILED; g_WSAEnumNetworkEvents = (LPFN_WSAENUMNETWORKEVENTS)GetProcAddress(hWS2, "WSAEnumNetworkEvents"); if (!g_WSAEnumNetworkEvents) goto GETPROCADDRESSFAILED; g_WSACreateEvent = (LPFN_WSACREATEEVENT)GetProcAddress(hWS2, "WSACreateEvent"); if (!g_WSACreateEvent) goto GETPROCADDRESSFAILED; g_WSACloseEvent = (LPFN_WSACLOSEEVENT)GetProcAddress(hWS2, "WSACloseEvent"); if (!g_WSACloseEvent) goto GETPROCADDRESSFAILED; g_getsockopt = (LPFN_GETSOCKOPT)GetProcAddress(hWS2, "getsockopt"); if (!g_getsockopt) goto GETPROCADDRESSFAILED; return DP_OK; GETPROCADDRESSFAILED: DPF(0,"Could not find required Winsock entry point"); FreeLibrary(hWS2); hWS2 = NULL; // fall through LOADLIBRARYFAILED: g_WSAEventSelect = NULL; g_WSAEnumNetworkEvents = NULL; g_WSACreateEvent = NULL; g_WSACloseEvent = NULL; return DPERR_UNAVAILABLE; } // InitWinsock2 // remove the reply node from the list void DeleteReplyNode(LPGLOBALDATA pgd,LPREPLYLIST prd, BOOL bKillSocket) { LPREPLYLIST prdPrev; ENTER_DPSP(); // 1st, remove prd from the list // is it the root? if (prd == pgd->pReplyList) pgd->pReplyList = pgd->pReplyList->pNextReply; else { BOOL bFound = FALSE; // it's not the root - take it out of the middle prdPrev = pgd->pReplyList; while (prdPrev && !bFound) { if (prdPrev->pNextReply == prd) { prdPrev->pNextReply = prd->pNextReply; bFound = TRUE; } else { prdPrev = prdPrev->pNextReply; } } // while ASSERT(bFound); } // not the root // now clean up prd // nuke the socket if (bKillSocket) KillSocket(prd->sSocket,TRUE,FALSE); // free up the node if (prd->lpMessage) MemFree(prd->lpMessage); MemFree(prd); LEAVE_DPSP(); return ; } // DeleteReplyNode /* ** AsyncConnectAndSend * * CALLED BY: AsyncSendThreadProc * * DESCRIPTION: * * if necessary, creates a non-blocking socket, and initiates a connection * to address specified in prd * once connection has been completed, does a synchronous (blocking) send and * removes prd from the global list */ HRESULT AsyncConnectAndSend(LPGLOBALDATA pgd,LPREPLYLIST prd) { UINT err; HRESULT hr; UINT addrlen = sizeof(SOCKADDR); BOOL bConnectionExists = FALSE; BOOL bKillConnection = TRUE; if (INVALID_SOCKET == prd->sSocket) { u_long lNonBlock = 1; // passed to ioctlsocket to make socket non-blocking 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 list everytime - find a better way bConnectionExists = FindSocketInBag(pgd, &prd->sockaddr, &prd->sSocket, &dpidPlayer); #endif // FULLDUPLEX_SUPPORT if (!bConnectionExists) { SOCKET sSocket; // socket didn't exist in our send list, let's send it on a new temporary connection DEBUGPRINTADDR(9,"Sending aync reply on a new connection to - ", &(prd->sockaddr)); // need to get the new socket hr = CreateSocket(pgd,&sSocket,SOCK_STREAM,0,INADDR_ANY,&err,FALSE); if (FAILED(hr)) { DPF(0,"create async socket failed - err = %d\n",err); return hr; } prd->sSocket = sSocket; // set socket to non-blocking err = ioctlsocket(prd->sSocket,FIONBIO,&lNonBlock); if (SOCKET_ERROR == err) { err = WSAGetLastError(); DPF(0,"could not set non-blocking mode on socket err = %d!",err); DPF(0,"will revert to synchronous behavior. bummer"); } // now, start the connect SetReturnAddress(prd->lpMessage,pgd->sSystemStreamSocket); err = connect(prd->sSocket,&prd->sockaddr,addrlen); if (SOCKET_ERROR == err) { err = WSAGetLastError(); if (WSAEWOULDBLOCK == err) { // this is expected. the operation needs time to complete. // select will tell us when the socket is good to go. return DP_OK; } // else it's a real error! DPF(0,"async reply - connect failed - error = %d\n",err); DEBUGPRINTADDR(0,"async reply - connect failed - addr = ",(LPSOCKADDR)&(prd->sockaddr)); goto CLEANUP_EXIT; } } else { // we found our connection, let's reuse it // set it to non-blocking DEBUGPRINTADDR(9,"Sending async reply on an existing connection to - ", &(prd->sockaddr)); err = ioctlsocket(prd->sSocket,FIONBIO,&lNonBlock); if (SOCKET_ERROR == err) { err = WSAGetLastError(); DPF(0,"could not set non-blocking mode on socket err = %d!",err); DPF(0,"will revert to synchronous behavior. bummer"); } // once we have a player id, the session has started. let's hold on to the connection // we have and reuse it for the rest of the session if (dpidPlayer) bKillConnection = FALSE; } // FindSocketInBag } // INVALID_SOCKET // once we get here, we should have a connected socket ready to send! err = 0; // keep spitting bits at the socket until we finish or get an error while ((prd->dwBytesLeft != 0) && (SOCKET_ERROR != err)) { err = send(prd->sSocket,prd->pbSend,prd->dwBytesLeft,0); if (SOCKET_ERROR != err) { // some bytes went out on the wire prd->dwBytesLeft -= err; // we just sent err bytes prd->pbSend += err; // advance our send buffer by err bytes } } // now, we've either finished the send, or we have an error if (SOCKET_ERROR == err) { err = WSAGetLastError(); if (WSAEWOULDBLOCK == err) { // this means we couldn't send any bytes w/o blocking // that's ok. we'll let select tell us when it's ready to not block return DP_OK; } // else it's a real eror! // any other error, we give up and clean up this reply DPF(0,"async send - send failed - error = %d\n",err); DEBUGPRINTADDR(0,"async send - send failed - addr = ",(LPSOCKADDR)&(prd->sockaddr)); } else ASSERT(0 == prd->dwBytesLeft); // if it's not an error, we better have sent it all // fall through CLEANUP_EXIT: if (bConnectionExists && bKillConnection) { // close the connection after we're done RemoveSocketFromReceiveList(pgd,prd->sSocket); RemoveSocketFromBag(pgd,prd->sSocket); // so DeleteReplyNode won't try to kill socket again prd->sSocket = INVALID_SOCKET; } // remove the node from the list DeleteReplyNode(pgd,prd,bKillConnection); return DP_OK; } // AsyncConnectAndSend // walk the reply list, tell winsock to watch any of the nodes which has a valid socket // (i.e. has a connection or send pending) HRESULT DoEventSelect(LPGLOBALDATA pgd,WSAEVENT hSelectEvent) { UINT err; LPREPLYLIST prd; ENTER_DPSP(); prd = pgd->pReplyList; while (prd) { if (INVALID_SOCKET != prd->sSocket) { // have winscok tell us when anything good (connection complete, ready to write more data) // happens on this socket err = g_WSAEventSelect(prd->sSocket,hSelectEvent,FD_WRITE | FD_CONNECT); if (SOCKET_ERROR == err) { err = WSAGetLastError(); DPF(0,"could not do event select ! err = %d!",err); // keep trying... } } // invalid_socket prd = prd->pNextReply; } LEAVE_DPSP(); return DP_OK; } // DoEventSelect // wsaeventselect woke us up. one or more of our sockets had something happen // (e.g. connect completed, send ready for more data, etc.) // walk the reply list, find nodes who need to be serviced void ServiceReplyList(LPGLOBALDATA pgd,WSAEVENT hEvent) { UINT err; LPREPLYLIST prd,prdNext; WSANETWORKEVENTS WSANetEvents; ENTER_DPSP(); Top: prd = pgd->pReplyList; while (prd) { // save this now - asyncconnectandsend could destroy prd prdNext = prd->pNextReply; if (INVALID_SOCKET != prd->sSocket) { // go ask winsock if this socket had anything intersting happen err = g_WSAEnumNetworkEvents(prd->sSocket,NULL,&WSANetEvents); if (SOCKET_ERROR == err) { err = WSAGetLastError(); DPF(0,"could not enum events!! err = %d!",err); // keep trying... } else { BOOL bError=FALSE; // no error - go see what we got if ((WSANetEvents.lNetworkEvents & FD_CONNECT) || (WSANetEvents.lNetworkEvents & FD_WRITE)) { // was there an error? if (WSANetEvents.iErrorCode[FD_CONNECT_BIT]) { // we got a connect error! DPF(0,"async reply - WSANetEvents - connect failed - error = %d\n", WSANetEvents.iErrorCode[FD_CONNECT_BIT]); DEBUGPRINTADDR(0,"async reply - connect failed - addr = ", (LPSOCKADDR)&(prd->sockaddr)); RemovePendingAsyncSends(pgd, prd->dwPlayerTo); goto Top; } if (WSANetEvents.iErrorCode[FD_WRITE_BIT]) { // we got a send error! DPF(0,"async reply - WSANetEvents - send failed - error = %d\n", WSANetEvents.iErrorCode[FD_WRITE_BIT]); DEBUGPRINTADDR(0,"async reply - send failed - addr = ", (LPSOCKADDR)&(prd->sockaddr)); RemovePendingAsyncSends(pgd, prd->dwPlayerTo); goto Top; } // note - we try + send even if there was an error. seems like it's worth a shot... // go try + send AsyncConnectAndSend(pgd,prd); } } } // invalid_socket else { // it it's an invalid socket, we need to init our connect and send AsyncConnectAndSend(pgd,prd); } prd = prdNext; } LEAVE_DPSP(); return ; } // ServiceReplyList // this thread works on doing async sends DWORD WINAPI AsyncSendThreadProc(LPVOID pvCast) { HRESULT hr=DP_OK; LPGLOBALDATA pgd = (LPGLOBALDATA) pvCast; HANDLE hHandleList[3]; DWORD rc; WSAEVENT hSelectEvent; // event used by WSASelectEvent DPF(9,"Entered AsyncSendThreadProc\n"); // get the event 4 selectevent hSelectEvent = g_WSACreateEvent(); if (WSA_INVALID_EVENT == hSelectEvent) { rc = WSAGetLastError(); DPF(0,"could not create winsock event - rc = %d\n",rc); ExitThread(0); return 0; } hHandleList[0] = hSelectEvent; hHandleList[1] = pgd->hReplyEvent; // This extra handle is here because of a Windows 95 bug. Windows // will occasionally miss when it walks the handle table, causing // my thread to wait on the wrong handles. By putting a guaranteed // invalid handle at the end of our array, the kernel will do a // forced re-walk of the handle table and find the correct handles. hHandleList[2] = INVALID_HANDLE_VALUE; while (1) { // tell winsock to watch all of our reply nodes. it will set our event // when something cool happens... DoEventSelect(pgd,hSelectEvent); // wait on our event. when it's set, we either split, or empty the reply list rc = WaitForMultipleObjectsEx(2,hHandleList,FALSE,INFINITE,TRUE); if ((DWORD)-1 == rc) { DWORD dwError = GetLastError(); // rut roh! errror on the wait DPF(0,"!!!!! error on WaitForMultipleObjects -- async reply bailing -- dwError = %d",dwError); goto CLEANUP_EXIT; } if (rc == WAIT_OBJECT_0) // a-josbor: need to reset this manual event { ResetEvent(hSelectEvent); } // ok. someone woke us up. it could be 1. shutdown, or 2. one // of our sockets needs attention (i.e. a connect completed), or 3. someone // put a new reply node on the list // shutdown? if (pgd->bShutdown) { goto CLEANUP_EXIT; } DPF(8,"In AsyncSendThreadProc, servicing event %d\n", rc - WAIT_OBJECT_0); // otherwise, it must be a socket in need or a new replynode ServiceReplyList(pgd,hSelectEvent); } // 1 CLEANUP_EXIT: ENTER_DPSP(); // cleanout reply list while (pgd->pReplyList) DeleteReplyNode(pgd,pgd->pReplyList,TRUE); CloseHandle(pgd->hReplyEvent); pgd->hReplyEvent = 0; LEAVE_DPSP(); g_WSACloseEvent(hSelectEvent); DPF(6,"replythreadproc exit"); return 0; } // AsyncSendThreadProc HRESULT GetMaxUdpBufferSize(SOCKET socket, UINT * piMaxUdpDg) { INT iBufferSize; INT err; ASSERT(piMaxUdpDg); iBufferSize = sizeof(UINT); err = g_getsockopt(socket, SOL_SOCKET, SO_MAX_MSG_SIZE, (LPBYTE)piMaxUdpDg, &iBufferSize); if (SOCKET_ERROR == err) { DPF(0,"getsockopt for SO_MAX_MSG_SIZE returned err = %d", WSAGetLastError()); return DPERR_UNAVAILABLE; } return DP_OK; } #ifdef SENDEX DWORD wsaoDecRef(LPSENDINFO pSendInfo) { #define pgd (pSendInfo->pgd) DWORD count; #ifdef DEBUG EnterCriticalSection(&pgd->csSendEx); count=(--pSendInfo->RefCount); LeaveCriticalSection(&pgd->csSendEx); #else count=InterlockedDecrement(&pSendInfo->RefCount); #endif if(!count){ EnterCriticalSection(&pgd->csSendEx); Delete(&pSendInfo->PendingSendQ); pgd->dwBytesPending -= pSendInfo->dwMessageSize; pgd->dwMessagesPending -= 1; LeaveCriticalSection(&pgd->csSendEx); DPF(9,"RefCount 0 pSendInfo %x , SC context %x, status=%x \n",pSendInfo, pSendInfo->dwUserContext,pSendInfo->Status); if(pSendInfo->dwSendFlags & DPSEND_ASYNC){ pSendInfo->lpISP->lpVtbl->SendComplete(pSendInfo->lpISP,(LPVOID)pSendInfo->dwUserContext,pSendInfo->Status); } pgd->pSendInfoPool->Release(pgd->pSendInfoPool, pSendInfo); } else { DPF(9,"wsaoDecRef pSendInfo %x, Refcount= %d\n",pSendInfo,pSendInfo->RefCount); } if(count& 0x80000000){ DEBUG_BREAK(); } return count; #undef pgd } void CALLBACK SendComplete( DWORD dwError, DWORD cbTransferred, LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags ) { LPSENDINFO lpSendInfo=(LPSENDINFO)CONTAINING_RECORD(lpOverlapped,SENDINFO,wsao); DPF(9,"DPWSOCK:SendComplete, lpSendInfo %x\n",lpSendInfo); if(dwError){ DPF(0,"DPWSOCK: send completion error, dwError=x%x\n",dwError); lpSendInfo->Status=DPERR_GENERIC; } wsaoDecRef(lpSendInfo); } HRESULT DoSend(LPGLOBALDATA pgd, LPSENDINFO pSendInfo) { #define fAsync (pSendInfo->dwSendFlags & DPSEND_ASYNC) DWORD dwBytesSent; UINT err; HRESULT hr; if(pSendInfo->dwFlags & SI_RELIABLE){ // Reliable Send DPF(9,"WSASend, pSendInfo %x\n",pSendInfo); // send the message err = g_WSASend(pSendInfo->sSocket, (LPWSABUF)&pSendInfo->SendArray[pSendInfo->iFirstBuf], pSendInfo->cBuffers, &dwBytesSent, 0, /*flags*/ (fAsync)?(&pSendInfo->wsao):NULL, (fAsync)?(SendComplete):NULL); if(!err){ DPF(9,"WSASend, sent synchronously, pSendInfo %x\n",pSendInfo); wsaoDecRef(pSendInfo); hr=DP_OK; } else { if (SOCKET_ERROR == err) { err = WSAGetLastError(); if(err==WSA_IO_PENDING){ hr=DPERR_PENDING; wsaoDecRef(pSendInfo); DPF(9,"ASYNC SEND Pending pSendInfo %x\n",pSendInfo); } else { if(err==WSAECONNRESET){ hr=DPERR_CONNECTIONLOST; } else { hr=DPERR_GENERIC; } if(fAsync){ // Got an error, need to dump 2 refs. pSendInfo->RefCount=1; pSendInfo->Status=hr; } wsaoDecRef(pSendInfo); // 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,pSendInfo->idTo); } } } } else { // Datagram Send DEBUGPRINTADDR(5,"unreliable send - sending to ",&pSendInfo->sockaddr); // send the message err = g_WSASendTo(pSendInfo->sSocket, (LPWSABUF)&pSendInfo->SendArray[pSendInfo->iFirstBuf], pSendInfo->cBuffers, &dwBytesSent, 0, /*flags*/ (LPSOCKADDR)&pSendInfo->sockaddr, sizeof(SOCKADDR), (fAsync)?(&pSendInfo->wsao):NULL, (fAsync)?(SendComplete):NULL); if(!err){ hr=DP_OK; wsaoDecRef(pSendInfo); } else { if (SOCKET_ERROR == err) { err = WSAGetLastError(); if(err==WSA_IO_PENDING){ hr=DPERR_PENDING; wsaoDecRef(pSendInfo); } else { hr=DPERR_GENERIC; if(fAsync){ // some error, force completion. pSendInfo->RefCount=1; pSendInfo->Status=DPERR_GENERIC; } wsaoDecRef(pSendInfo); DPF(0,"send error - err = %d\n",err); } } else { DEBUG_BREAK();// SHOULD NEVER HAPPEN } } } return hr; #undef fAsync } // Alert thread provides a thread for send completions to run on. DWORD WINAPI SPSendThread(LPVOID lpv) { LPGLOBALDATA pgd=(LPGLOBALDATA) lpv; LPSENDINFO pSendInfo; DWORD rcWait=WAIT_IO_COMPLETION; BILINK *pBilink; BOOL bSent; pgd->BogusHandle=INVALID_HANDLE_VALUE; // workaround win95 wait for multiple bug. while(!pgd->bStopSendThread){ rcWait=g_WSAWaitForMultipleEvents(1,&pgd->hSendWait,FALSE,INFINITE,TRUE); #ifdef DEBUG if(rcWait==WAIT_IO_COMPLETION){ DPF(9,"ooooh, IO completion\n"); } #endif do { bSent = FALSE; EnterCriticalSection(&pgd->csSendEx); pBilink=pgd->ReadyToSendQ.next; if(pBilink != &pgd->ReadyToSendQ){ Delete(pBilink); LeaveCriticalSection(&pgd->csSendEx); pSendInfo=CONTAINING_RECORD(pBilink, SENDINFO, ReadyToSendQ); DoSend(pgd, pSendInfo); bSent=TRUE; } else { LeaveCriticalSection(&pgd->csSendEx); } } while (bSent); } pgd->bSendThreadRunning=FALSE; return FALSE; #undef hWait } void QueueForSend(LPGLOBALDATA pgd,LPSENDINFO pSendInfo) { EnterCriticalSection(&pgd->csSendEx); InsertBefore(&pSendInfo->ReadyToSendQ,&pgd->ReadyToSendQ); LeaveCriticalSection(&pgd->csSendEx); SetEvent(pgd->hSendWait); } // some common code for InternalReliableSendEx and UnreliableSendEx VOID CommonInitForSend(LPGLOBALDATA pgd,LPDPSP_SENDEXDATA psd,LPSENDINFO pSendInfo) { pSendInfo->dwMessageSize= psd->dwMessageSize; pSendInfo->dwUserContext= (DWORD_PTR)psd->lpDPContext; pSendInfo->RefCount = 2; // one for completion, 1 for this routine pSendInfo->pgd = pgd; pSendInfo->lpISP = psd->lpISP; pSendInfo->Status = DP_OK; pSendInfo->idTo = psd->idPlayerTo; pSendInfo->idFrom = psd->idPlayerFrom; pSendInfo->dwSendFlags = psd->dwFlags; if(psd->lpdwSPMsgID){ *psd->lpdwSPMsgID=0; } EnterCriticalSection(&pgd->csSendEx); InsertBefore(&pSendInfo->PendingSendQ,&pgd->PendingSendQ); pgd->dwBytesPending += psd->dwMessageSize; pgd->dwMessagesPending += 1; LeaveCriticalSection(&pgd->csSendEx); } VOID UnpendSendInfo(LPGLOBALDATA pgd, LPSENDINFO pSendInfo) { EnterCriticalSection(&pgd->csSendEx); Delete(&pSendInfo->PendingSendQ); pgd->dwBytesPending -= pSendInfo->dwMessageSize; pgd->dwMessagesPending -= 1; LeaveCriticalSection(&pgd->csSendEx); } HRESULT InternalReliableSendEx(LPGLOBALDATA pgd, LPDPSP_SENDEXDATA psd, LPSENDINFO pSendInfo, SOCKADDR *lpSockAddr) { HRESULT hr; SOCKET sSocket = INVALID_SOCKET; BOOL fCreate=FALSE; // see if we have a connection already hr = GetSocketFromBag(pgd,&sSocket,psd->idPlayerTo,lpSockAddr); if(hr != DP_OK){ hr=DPERR_GENERIC; return hr; } CommonInitForSend(pgd,psd,pSendInfo); // puts 2 refs on send. pSendInfo->dwFlags = SI_RELIABLE; pSendInfo->sSocket = sSocket; pSendInfo->iFirstBuf = 0; pSendInfo->cBuffers = psd->cBuffers+1; if(psd->dwFlags & DPSEND_ASYNC){ QueueForSend(pgd,pSendInfo); hr=DPERR_PENDING; } else { hr=DoSend(pgd,pSendInfo); if(hr==DP_OK || hr==DPERR_PENDING){ wsaoDecRef(pSendInfo); } else { // error, UnpendSendInfo(pgd, pSendInfo); } } return hr; } HRESULT UnreliableSendEx(LPDPSP_SENDEXDATA psd, LPSENDINFO pSendInfo) { SOCKADDR sockaddr; INT iAddrLen = sizeof(sockaddr); HRESULT hr=DP_OK; UINT err; DWORD dwSize = sizeof(SPPLAYERDATA); LPSPPLAYERDATA ppdTo; DWORD dwDataSize = sizeof(GLOBALDATA); LPGLOBALDATA pgd; BOOL bSendHeader; // 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,INADDR_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; } sockaddr = *(DGRAM_PSOCKADDR(ppdTo)); } // put the token + size on front of the mesage SetMessageHeader((LPVOID)(pSendInfo->SendArray[0].buf),psd->dwMessageSize+sizeof(MESSAGEHEADER),TOKEN); bSendHeader=TRUE; if (psd->bSystemMessage) { SetReturnAddress(pSendInfo->SendArray[0].buf,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(pSendInfo->SendArray[0].buf))) ) { bSendHeader=FALSE; } } CommonInitForSend(pgd,psd,pSendInfo); pSendInfo->dwFlags = SI_DATAGRAM; pSendInfo->sSocket = pgd->sUnreliableSocket; pSendInfo->sockaddr = sockaddr; if(bSendHeader){ pSendInfo->iFirstBuf=0; pSendInfo->cBuffers =psd->cBuffers+1; } else { pSendInfo->iFirstBuf=1; pSendInfo->cBuffers=psd->cBuffers; } if(psd->dwFlags & DPSEND_ASYNC){ QueueForSend(pgd,pSendInfo); hr=DPERR_PENDING; } else { hr=DoSend(pgd,pSendInfo); if(hr==DP_OK || hr==DPERR_PENDING){ wsaoDecRef(pSendInfo); } else { UnpendSendInfo(pgd, pSendInfo); } } return hr; } // UnreliableSendEx #endif //SendEx