diff options
Diffstat (limited to 'private/nw/vwipxspx/dll/socket.c')
| -rw-r--r-- | private/nw/vwipxspx/dll/socket.c | 2309 |
1 files changed, 2309 insertions, 0 deletions
diff --git a/private/nw/vwipxspx/dll/socket.c b/private/nw/vwipxspx/dll/socket.c new file mode 100644 index 000000000..874d4691f --- /dev/null +++ b/private/nw/vwipxspx/dll/socket.c @@ -0,0 +1,2309 @@ +/*++ + +Copyright (c) 1991 Microsoft Corporation + +Module Name: + + socket.c + +Abstract: + + Contains functions to create, delete and manipulate IPX sockets and SPX + connections + + Contents: + CreateSocket + AllocateTemporarySocket + QueueSocket + DequeueSocket + FindSocket + FindActiveSocket + ReopenSocket + KillSocket + KillShortLivedSockets + AllocateConnection + DeallocateConnection + FindConnection + QueueConnection + DequeueConnection + KillConnection + AbortOrTerminateConnection + CheckPendingSpxRequests + (CheckSocketState) + (CheckSelectRead) + (CheckSelectWrite) + (AsyncReadAction) + (AsyncWriteAction) + (CompleteAccept) + (CompleteReceive) + (CompleteConnect) + (CompleteSend) + +Author: + + Richard L Firth (rfirth) 25-Oct-1993 + +Environment: + + User-mode Win32 + +Revision History: + + 25-Oct-1993 rfirth + Created + +--*/ + +#include "vw.h" +#pragma hdrstop + +// +// miscellaneous manifests +// + +#define ARBITRARY_CONNECTION_INCREMENT 2 + +// +// macros +// + +#define ALLOCATE_CONNECTION_NUMBER() (ConnectionNumber += ARBITRARY_CONNECTION_INCREMENT) + +// +// private data +// + +PRIVATE LPSOCKET_INFO SocketList = NULL; +PRIVATE LPCONNECTION_INFO ConnectionList = NULL; +PRIVATE WORD ConnectionNumber = ARBITRARY_CONNECTION_NUMBER; + +// +// private functions +// + +PRIVATE +BOOL +CheckSocketState( + IN SOCKET Socket, + OUT LPBOOL Readable, + OUT LPBOOL Writeable, + OUT LPBOOL Error + ); + + +PRIVATE +VOID +CheckSelectRead( + IN LPSOCKET_INFO pSocketInfo, + IN LPCONNECTION_INFO pConnectionInfo, + OUT BOOL *CheckRead + ); + +PRIVATE +VOID +CheckSelectWrite( + IN LPSOCKET_INFO pSocketInfo, + IN LPCONNECTION_INFO pConnectionInfo, + OUT BOOL *CheckWrite + ); + +PRIVATE +VOID +AsyncReadAction( + IN LPSOCKET_INFO pSocketInfo, + IN LPCONNECTION_INFO pConnectionInfo, + OUT BOOL *ReadPerformed + ); + +PRIVATE +VOID +AsyncWriteAction( + IN LPSOCKET_INFO pSocketInfo, + IN LPCONNECTION_INFO pConnectionInfo, + OUT BOOL *WritePerformed + ); + +PRIVATE +VOID +CompleteAccept( + IN LPSOCKET_INFO pSocketInfo, + IN LPCONNECTION_INFO pConnectionInfo + ); + +PRIVATE +VOID +CompleteReceive( + IN LPSOCKET_INFO pSocketInfo, + IN LPCONNECTION_INFO pConnectionInfo + ); + +PRIVATE +VOID +CompleteConnect( + IN LPSOCKET_INFO pSocketInfo, + IN LPCONNECTION_INFO pConnectionInfo + ); + +PRIVATE +VOID +CompleteSend( + IN LPSOCKET_INFO pSocketInfo, + IN LPCONNECTION_INFO pConnectionInfo + ); + +#if SPX_HACK +PRIVATE VOID ModifyFirstReceive(LPBYTE, LPDWORD, WORD, SOCKET); +#endif + +// +// public functions +// + + +int +CreateSocket( + IN SOCKET_TYPE SocketType, + IN OUT ULPWORD pSocketNumber, + OUT SOCKET* pSocket + ) + +/*++ + +Routine Description: + + Creates a socket for IPX or SPX (a connection). Once the socket is created + we have to bind it to the IPX/SPX 'socket' - i.e. port. We also need to + change a few things about the standard socket: + + * if this is an SPX request then we must set the REUSEADDR socket option + since there may typically be several connect requests over the same + WinSock socket: we need to be able to bind multiple connections to the + same socket number + + * all sockets opened by this function are put into non-blocking mode + * all sockets opened by this function will return the packet header in + any received data (IPX_RECVHDR) + + The requested socket number can be 0 in which case we bind to a dynamic + socket number. We always return the number of the socket bound to: if not 0 + on input, this should always be the same value as that requested in + pSocketNumber + + If any WinSock call fails (and the socket was created) then we close the + socket before returning + +Arguments: + + SocketType - SOCKET_TYPE_IPX or SOCKET_TYPE_SPX + pSocketNumber - input: socket number to bind (can be 0) + output: socket number bound + pSocket - pointer to address of socket identifier to return + +Return Value: + + int + Success - IPX_SUCCESS/SPX_SUCCESS (0) + + Failure - IPX_SOCKET_TABLE_FULL + WinSock cannot create the socket + + IPX_SOCKET_ALREADY_OPEN + Assume the request was for an IPX socket: we do not allow + multiple IPX sockets to be bound to the same socket number, + only SPX + + +--*/ + +{ + SOCKET s; + SOCKADDR_IPX socketAddress; + BOOL true = TRUE; + int rc; + int status = IPX_SOCKET_TABLE_FULL; // default error + + s = socket(AF_IPX, + (SocketType == SOCKET_TYPE_SPX) ? SOCK_SEQPACKET : SOCK_DGRAM, + (SocketType == SOCKET_TYPE_SPX) ? NSPROTO_SPX : NSPROTO_IPX + ); + + if (s != INVALID_SOCKET) { + + // + // for stream (SPX) sockets, we need multiple sockets bound to the + // same socket number if we are to have multiple connections on the + // same SPX socket + // + + if (SocketType == SOCKET_TYPE_SPX) { + rc = setsockopt(s, + SOL_SOCKET, + SO_REUSEADDR, + (char FAR*)&true, + sizeof(true) + ); + if (rc == SOCKET_ERROR) { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "CreateSocket: setsockopt(SO_REUSEADDR) returns %d\n", + WSAGetLastError() + )); + + } else { + rc = setsockopt(s, + SOL_SOCKET, + SO_OOBINLINE, + (char FAR*)&true, + sizeof(true) + ); + + if (rc == SOCKET_ERROR) { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "CreateSocket: setsockopt(SO_OOBINLINE) returns %d\n", + WSAGetLastError() + )); + + } + } + } else { + + // + // allow broadcasts to be transmitted on IPX sockets + // + + rc = setsockopt(s, + SOL_SOCKET, + SO_BROADCAST, + (char FAR*)&true, + sizeof(true) + ); + } + if (!rc) { + + // + // bind the socket to the local socket number (port) + // + + ZeroMemory(&socketAddress, sizeof(socketAddress)); + socketAddress.sa_family = AF_IPX; + socketAddress.sa_socket = *pSocketNumber; + rc = bind(s, (LPSOCKADDR)&socketAddress, sizeof(socketAddress)); + if (rc != SOCKET_ERROR) { + + int length = sizeof(socketAddress); + + ZeroMemory(&socketAddress, sizeof(socketAddress)); + socketAddress.sa_family = AF_IPX; + + // + // use getsockname() to find the (big-endian) socket value that + // was actually assigned: should only be different from + // *pSocketNumber if the latter was 0 on input + // + + rc = getsockname(s, (LPSOCKADDR)&socketAddress, &length); + if (rc != SOCKET_ERROR) { + + u_long arg = !0; + + // + // put the socket into non-blocking mode. Neither IPX nor + // SPX sockets are blocking: the app starts an I/O request + // and if it doesn't complete immediately, will be completed + // by AES which periodically polls the outstanding I/O + // requests + // + + rc = ioctlsocket(s, FIONBIO, &arg); + if (rc != SOCKET_ERROR) { + + // + // return protocol header on receive frames + // + + rc = setsockopt(s, + NSPROTO_IPX, + IPX_RECVHDR, + (char FAR*)&true, + sizeof(true) + ); + if (rc != SOCKET_ERROR) { + *pSocketNumber = socketAddress.sa_socket; + *pSocket = s; + status = IPX_SUCCESS; + } else { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "CreateSocket: setsockopt(RECVHDR) returns %d\n", + WSAGetLastError() + )); + + } + } else { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "CreateSocket: ioctlsocket(FIONBIO) returns %d\n", + WSAGetLastError() + )); + + } + } else { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "CreateSocket: getsockname() returns %d\n", + WSAGetLastError() + )); + + } + } else { + + // + // bind() failed - either an expected error (the requested socket + // is already in use), or (horror) an unexpected error, in which + // case report table full (?) + // + + switch (WSAGetLastError()) { + case WSAEADDRINUSE: + + ASSERT(*pSocketNumber != 0); + ASSERT(SocketType == SOCKET_TYPE_IPX); + + status = IPX_SOCKET_ALREADY_OPEN; + break; + + default: + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "CreateSocket: bind() on socket %#x returns %d\n", + s, + WSAGetLastError() + )); + + } + } + } + } else { + + // + // the socket() call failed - treat as table full + // + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "CreateSocket: socket() returns %d\n", + WSAGetLastError() + )); + + } + if (status != IPX_SUCCESS) { + if (s != INVALID_SOCKET) { + closesocket(s); + } + } + return status; +} + + +LPSOCKET_INFO +AllocateTemporarySocket( + VOID + ) + +/*++ + +Routine Description: + + Allocates a temporary socket. Creates an IPX socket having a dynamically + allocated socket number + +Arguments: + + None. + +Return Value: + + LPSOCKET_INFO + Success - pointer to SOCKET_INFO structure + Failure - NULL + +--*/ + +{ + LPSOCKET_INFO pSocketInfo; + int rc; + + pSocketInfo = AllocateSocket(); + if (pSocketInfo) { + + // + // assumption: the SOCKET_INFO structure was zeroed by LocalAlloc(LPTR,.. + // hence the SocketNumber fields is 0. This causes CreateSocket to + // generate a dynamic socket number + // + + rc = CreateSocket(SOCKET_TYPE_IPX, + &pSocketInfo->SocketNumber, + &pSocketInfo->Socket + ); + if (rc == IPX_SUCCESS) { + pSocketInfo->Flags |= SOCKET_FLAG_TEMPORARY; + } else { + DeallocateSocket(pSocketInfo); + pSocketInfo = NULL; + } + } + return pSocketInfo; +} + + +VOID +QueueSocket( + IN LPSOCKET_INFO pSocketInfo + ) + +/*++ + +Routine Description: + + Add a SOCKET_INFO structure to the list (LIFO) of (opened) sockets + +Arguments: + + pSocketInfo - pointer to filled-in SOCKET_INFO structure + +Return Value: + + None. + +--*/ + +{ + RequestMutex(); + pSocketInfo->Next = SocketList; + SocketList = pSocketInfo; + ReleaseMutex(); +} + + +LPSOCKET_INFO +DequeueSocket( + IN LPSOCKET_INFO pSocketInfo + ) + +/*++ + +Routine Description: + + Remove a SOCKET_INFO structure from the list + +Arguments: + + pSocketInfo - pointer to SOCKET_INFO structure to remove + +Return Value: + + LPSOCKET_INFO + pSocketInfo - should be this value + NULL - couldn't find pSocketInfo (should not get this!) + +--*/ + +{ + LPSOCKET_INFO prev, p; + + ASSERT(SocketList); + + RequestMutex(); + prev = (LPSOCKET_INFO)&SocketList; + p = SocketList; + while (p) { + if (p == pSocketInfo) { + prev->Next = p->Next; + p->Next = NULL; + break; + } else { + prev = p; + p = p->Next; + } + } + + if (!p) { + + // + // should never reach here + // + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_FATAL, + "DequeueSocket: can't find socket structure %08x on queue\n", + pSocketInfo + )); + + } + + ReleaseMutex(); + return p; +} + + +LPSOCKET_INFO +FindSocket( + IN WORD SocketNumber + ) + +/*++ + +Routine Description: + + Locate a SOCKET_INFO structure in the list, by (big-endian) socket number + + Assumes: 1. There is 1 and only 1 SOCKET_INFO structure that contains + SocketNumber + +Arguments: + + SocketNumber - big-endian socket number to find + +Return Value: + + LPSOCKET_INFO + NULL - couldn't find requested socket + !NULL - pointer to discovered SOCKET_INFO structure + +--*/ + +{ + LPSOCKET_INFO p; + + RequestMutex(); + p = SocketList; + while (p) { + if (p->SocketNumber == SocketNumber) { + break; + } else { + p = p->Next; + } + } + ReleaseMutex(); + return p; +} + + +LPSOCKET_INFO +FindActiveSocket( + IN LPSOCKET_INFO pSocketInfo + ) + +/*++ + +Routine Description: + + Find a SOCKET_INFO structure with pending send or receive. Called as FindFirst, + FindNext - first call made with pSocketInfo == NULL: enters critical section + if an active socket is found, returns pointer + + Subsequent calls are made with pSocketInfo pointing to last returned + SOCKET_INFO. This continues the search. When search exhausted, critical + section is released + +Arguments: + + pSocketInfo - pointer to SOCKET_INFO structure: first time must be NULL + +Return Value: + + LPSOCKET_INFO - next active SOCKET_INFO structure or NULL + +--*/ + +{ + if (!pSocketInfo) { + RequestMutex(); + pSocketInfo = SocketList; + } else { + pSocketInfo = pSocketInfo->Next; + } + for (; pSocketInfo; pSocketInfo = pSocketInfo->Next) { + if (pSocketInfo->Flags & (SOCKET_FLAG_SENDING | SOCKET_FLAG_LISTENING)) { + return pSocketInfo; + } + } + ReleaseMutex(); + return NULL; +} + + +int +ReopenSocket( + LPSOCKET_INFO pSocketInfo + ) + +/*++ + +Routine Description: + + Called expressly to close an IPX socket and reassign the descriptor to SPX. + Note that after this function completes, IPXSendPacket and IPXListenForPacket + cannot be made agains the IPX socket + +Arguments: + + pSocketInfo - pointer to SOCKET_INFO which currently describes an IPX socket + +Return Value: + + int - return code from CreateSocket + +--*/ + +{ + int rc; + + rc = closesocket(pSocketInfo->Socket); + if (rc == SOCKET_ERROR) { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "ReopenSocket: closesocket() returns %d\n", + WSAGetLastError() + )); + + } + + // + // mark this socket as connection-based (SPX) socket + // + + pSocketInfo->SpxSocket = TRUE; + + // + // BUGBUG: need the DOS/Windows task ID: owner may have changed! + // + + // + // re-open the socket for SPX use + // + + return CreateSocket(SOCKET_TYPE_SPX, + &pSocketInfo->SocketNumber, + &pSocketInfo->Socket + ); +} + + +VOID +KillSocket( + IN LPSOCKET_INFO pSocketInfo + ) + +/*++ + +Routine Description: + + closes a socket, removes the SOCKET_INFO structure from the list and cancels + any pending send, listen or timed events associated with the socket + +Arguments: + + pSocketInfo - identifying socket to kill + +Return Value: + + None. + +--*/ + +{ + + int rc; + + // + // remove the SOCKET_INFO structure from the list of sockets. Cancel + // any pending ECB requests and any IPX timed events that have the + // same socket number + // + + DequeueSocket(pSocketInfo); + rc = closesocket(pSocketInfo->Socket); + if (rc == SOCKET_ERROR) { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "KillSocket: closesocket() returns %d\n", + WSAGetLastError() + )); + + } + + // + // the socket has been removed from SocketList: no need to grab mutex to + // perform the following + // + + CancelTimedEvents(pSocketInfo->SocketNumber, 0, 0); + CancelSocketQueue(&pSocketInfo->ListenQueue); + CancelSocketQueue(&pSocketInfo->HeaderQueue); + CancelSocketQueue(&pSocketInfo->SendQueue); + if (pSocketInfo->SpxSocket) { + + LPCONNECTION_INFO pConnectionInfo; + + while (pConnectionInfo = pSocketInfo->Connections) { + DequeueConnection(pSocketInfo, pConnectionInfo); + KillConnection(pConnectionInfo); + } + } + DeallocateSocket(pSocketInfo); +} + + +VOID +KillShortLivedSockets( + IN WORD Owner + ) + +/*++ + +Routine Description: + + For all those sockets created by a DOS process as SHORT_LIVED, terminate + the sockets, cancelling any outstanding ECBs + +Arguments: + + Owner - DOS PDB which opened sockets + +Return Value: + + None. + +--*/ + +{ + LPSOCKET_INFO pSocketInfo; + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_INFO, + "KillShortLivedSockets(%04x)\n", + Owner + )); + + RequestMutex(); + + // + // kill any non-socket (AES) timed events owned by this DOS process + // + + CancelTimedEvents(0, Owner, 0); + + // + // kill all sockets owned by this PDB + // + + pSocketInfo = SocketList; + while (pSocketInfo) { + + LPSOCKET_INFO next; + + next = pSocketInfo->Next; + if (!pSocketInfo->LongLived && (pSocketInfo->Owner == Owner)) { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_INFO, + "KillShortLivedSockets: Socket %04x owned by %04x\n", + B2LW(pSocketInfo->SocketNumber), + pSocketInfo->Owner + )); + + KillSocket(pSocketInfo); + } + pSocketInfo = next; + } + ReleaseMutex(); +} + + +LPCONNECTION_INFO +AllocateConnection( + LPSOCKET_INFO pSocketInfo + ) + +/*++ + +Routine Description: + + Allocates a CONNECTION_INFO structure. If successful, links it at the head + of ConnectionList + +Arguments: + + pSocketInfo - pointer to owner SOCKET_INFO + +Return Value: + + LPCONNECTION_INFO + Success - !NULL + Failure - NULL + +--*/ + +{ + LPCONNECTION_INFO pConnectionInfo; + + pConnectionInfo = (LPCONNECTION_INFO)LocalAlloc(LPTR, sizeof(*pConnectionInfo)); + if (pConnectionInfo) { + RequestMutex(); + pConnectionInfo->ConnectionId = ALLOCATE_CONNECTION_NUMBER(); + pConnectionInfo->List = ConnectionList; + ConnectionList = pConnectionInfo; + ReleaseMutex(); + } + +#if SPX_HACK + pConnectionInfo->Flags = CF_1ST_RECEIVE; +#endif + + return pConnectionInfo; +} + + +VOID +DeallocateConnection( + IN LPCONNECTION_INFO pConnectionInfo + ) + +/*++ + +Routine Description: + + Undoes the work of AllocateConnection - removes pConnectionInfo from + ConnectionList and deallocates the structure + +Arguments: + + pConnectionInfo - pointer to CONNECTION_INFO to deallocate + +Return Value: + + None. + +--*/ + +{ + LPCONNECTION_INFO p; + LPCONNECTION_INFO prev = (LPCONNECTION_INFO)&ConnectionList; + + RequestMutex(); + for (p = ConnectionList; p != pConnectionInfo; ) { + prev = p; + p = p->List; + } + + // + // if p is NULL or differs from pConnectionInfo then there's a problem + // + + ASSERT(p); + + // + // special case if pConnectionInfo is first on list: can't say + // &ConnectionList->List - accesses one pointer beyond ConnectionList + // which is WRONG + // + + if (prev == (LPCONNECTION_INFO)&ConnectionList) { + ConnectionList = p->List; + } else { + prev->List = p->List; + } + FREE_OBJECT(pConnectionInfo); + ReleaseMutex(); +} + + +LPCONNECTION_INFO +FindConnection( + IN WORD ConnectionId + ) + +/*++ + +Routine Description: + + Returns a pointer to CONNECTION_INFO given a unique connection ID + +Arguments: + + ConnectionId - value to find + +Return Value: + + LPCONNECTION_INFO + Success - !NULL + Failure - NULL + +--*/ + +{ + LPCONNECTION_INFO pConnectionInfo; + + RequestMutex(); + for (pConnectionInfo = ConnectionList; pConnectionInfo; ) { + if (pConnectionInfo->ConnectionId == ConnectionId) { + break; + } else { + pConnectionInfo = pConnectionInfo->List; + } + } + ReleaseMutex(); + return pConnectionInfo; +} + + +VOID +QueueConnection( + IN LPSOCKET_INFO pSocketInfo, + IN LPCONNECTION_INFO pConnectionInfo + ) + +/*++ + +Routine Description: + + Adds a CONNECTION_INFO to the list of connections owned by a SOCKET_INFO. + Points the CONNECTION_INFO back to the SOCKET_INFO + +Arguments: + + pSocketInfo - owning SOCKET_INFO + pConnectionInfo - CONNECTION_INFO to add + +Return Value: + + None. + +--*/ + +{ + pConnectionInfo->Next = pSocketInfo->Connections; + pSocketInfo->Connections = pConnectionInfo; + pConnectionInfo->OwningSocket = pSocketInfo; +} + + +LPCONNECTION_INFO +DequeueConnection( + IN LPSOCKET_INFO pSocketInfo, + IN LPCONNECTION_INFO pConnectionInfo + ) + +/*++ + +Routine Description: + + Removes a CONNECTION_INFO from the list of connections owned by a SOCKET_INFO + +Arguments: + + pSocketInfo - owning SOCKET_INFO + pConnectionInfo - CONNECTION_INFO to remove + +Return Value: + + LPCONNECTION_INFO + Success - pointer to removed CONNECTION_INFO (should be same as + pConnectionInfo) + Failure - NULL (not expected) + +--*/ + +{ + LPCONNECTION_INFO prev = (LPCONNECTION_INFO)&pSocketInfo->Connections; + LPCONNECTION_INFO p = prev->Next; + + while (p && p != pConnectionInfo) { + prev = p; + p = p->Next; + } + + ASSERT(p == pConnectionInfo); + + prev->Next = p->Next; + p->OwningSocket = NULL; + return p; +} + + +VOID +KillConnection( + IN LPCONNECTION_INFO pConnectionInfo + ) + +/*++ + +Routine Description: + + Closes a socket belonging to a connection and cancels all outstanding + requests. The CONNECTION_INFO is deallocated + +Arguments: + + pConnectionInfo - pointer to CONNECTION_INFO to kill + +Return Value: + + None. + +--*/ + +{ + if (pConnectionInfo->Socket) { + closesocket(pConnectionInfo->Socket); + } + CancelConnectionQueue(&pConnectionInfo->ConnectQueue); + CancelConnectionQueue(&pConnectionInfo->AcceptQueue); + CancelConnectionQueue(&pConnectionInfo->ListenQueue); + CancelConnectionQueue(&pConnectionInfo->SendQueue); + DeallocateConnection(pConnectionInfo); +} + + +VOID +AbortOrTerminateConnection( + IN LPCONNECTION_INFO pConnectionInfo, + IN BYTE CompletionCode + ) + +/*++ + +Routine Description: + + Aborts or terminates a connection: closes the socket, dequeues and completes + all outstanding ECBs with relevant code and deallocates the CONNECTION_INFO + structure + + The CONNECTION_INFO must NOT be queued on a SOCKET_INFO when this routine + is called + +Arguments: + + pConnectionInfo - pointer to CONNECTION_INFO to kill + CompletionCode - completion code to put in pending ECBs + +Return Value: + + None. + +--*/ + +{ + if (pConnectionInfo->Socket) { + closesocket(pConnectionInfo->Socket); + } + AbortQueue(&pConnectionInfo->ConnectQueue, CompletionCode); + AbortQueue(&pConnectionInfo->AcceptQueue, CompletionCode); + AbortQueue(&pConnectionInfo->ListenQueue, CompletionCode); + AbortQueue(&pConnectionInfo->SendQueue, CompletionCode); + DeallocateConnection(pConnectionInfo); +} + + +VOID +CheckPendingSpxRequests( + BOOL *pfOperationPerformed + ) + +/*++ + +Routine Description: + + Checks the open non-blocking SPX sockets for: + + errors + outgoing established connections (connect) + incoming established connections (listen/accept) + data to receive (recv) + send completions (send) + +Arguments: + + None. + +Return Value: + + None. + +--*/ + +{ + LPSOCKET_INFO pSocketInfo; + + *pfOperationPerformed = FALSE ; + + RequestMutex(); + pSocketInfo = SocketList; + while (pSocketInfo) { + if (pSocketInfo->SpxSocket) { + + LPCONNECTION_INFO pConnectionInfo; + + pConnectionInfo = pSocketInfo->Connections; + while (pConnectionInfo) { + + LPCONNECTION_INFO next; + + // + // pluck out the Next field now, in case this CONNECTION_INFO + // is destroyed as the result of an error + // + + next = pConnectionInfo->Next; + + // + // if this connection has an active socket or we have issued + // SPXListenForConnection against the socket then check the + // state + // + + if (pConnectionInfo->Socket + || (pConnectionInfo->State == CI_WAITING)) { + + SOCKET sock; + BOOL readable; + BOOL writeable; + BOOL sockError; + + CheckSelectRead(pSocketInfo, + pConnectionInfo, + &readable); + + CheckSelectWrite(pSocketInfo, + pConnectionInfo, + &writeable); + + sock = pConnectionInfo->Socket + ? pConnectionInfo->Socket + : pSocketInfo->Socket + ; + + if (CheckSocketState(sock, &readable, &writeable, &sockError)) { + if (!sockError) { + + if (readable) { + AsyncReadAction(pSocketInfo, + pConnectionInfo, + pfOperationPerformed); + } + if (writeable) { + AsyncWriteAction(pSocketInfo, + pConnectionInfo, + pfOperationPerformed); + } + } else { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "CheckPendingSpxRequests: socket %x has error. Connection %08x state %d\n", + sock, + pConnectionInfo, + pConnectionInfo->State + )); + + // + // irrespective of the error, we just abort any + // connection that gets an error + // + + DequeueConnection(pConnectionInfo->OwningSocket, + pConnectionInfo + ); + AbortOrTerminateConnection(pConnectionInfo, + ECB_CC_CONNECTION_ABORTED + ); + } + } else { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "CheckPendingSpxRequests: CheckSocketState returns %d\n", + WSAGetLastError() + )); + + } + } else { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "CheckPendingSpxRequests: connection %04x (%08x) in weird state?\n", + pConnectionInfo->ConnectionId, + pConnectionInfo + )); + + } + pConnectionInfo = next; + } + } + pSocketInfo = pSocketInfo->Next; + } + ReleaseMutex(); +} + + +PRIVATE +BOOL +CheckSocketState( + IN SOCKET Socket, + OUT LPBOOL Readable, + OUT LPBOOL Writeable, + OUT LPBOOL Error + ) + +/*++ + +Routine Description: + + Given a socket descriptor, checks to see if it is in one of the following + states: + + readable - if waiting for a connection, connection has been made + else if established, data is ready to be received + + writeable - if waiting to make a connection, connection has been + made, else if established, we can send data on this + socket + + error - some error has occurred on the socket + +Arguments: + + Socket - socket descriptor to check + Readable - returned TRUE if readable + Writeable - returned TRUE if writeable + Error - returned TRUE if error on socket + +Return Value: + + BOOL + TRUE - contents of Readable, Writeable and Error are valid + FALSE - an error occurred performing the select + +--*/ + +{ + fd_set errors; + fd_set reads; + fd_set writes; + int n; + static struct timeval timeout = {0, 0}; + + FD_ZERO(&errors); + FD_ZERO(&reads); + FD_ZERO(&writes); + + if (*Readable) + FD_SET(Socket, &reads); + if (*Writeable) + FD_SET(Socket, &writes); + FD_SET(Socket, &errors); + + n = select(0, &reads, &writes, &errors, &timeout); + + if (n != SOCKET_ERROR) { + *Readable = (BOOL)(reads.fd_count == 1); + *Writeable = (BOOL)(writes.fd_count == 1); + *Error = (BOOL)(errors.fd_count == 1); + return TRUE; + } else if (n) { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_INFO, + "CheckSocketState: select returns %d\n", + WSAGetLastError() + )); + + } + return FALSE; +} + + +PRIVATE +VOID +AsyncReadAction( + IN LPSOCKET_INFO pSocketInfo, + IN LPCONNECTION_INFO pConnectionInfo, + OUT BOOL *ReadPerformed + ) + +/*++ + +Routine Description: + + A connection has some read action to complete - complete a pending + SPXListenForConnection or SPXListenForSequencedPacket + +Arguments: + + pSocketInfo - pointer to SOCKET_INFO + pConnectionInfo - pointer to CONNECTION_INFO + +Return Value: + + None. + +--*/ + +{ + *ReadPerformed = FALSE ; + + switch (pConnectionInfo->State) { + case CI_STARTING: + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_INFO, + "AsyncReadAction: STARTING connection %04x (%08x) readable\n", + pConnectionInfo->ConnectionId, + pConnectionInfo + )); + + break; + + case CI_WAITING: + if (pConnectionInfo->AcceptQueue.Head) { + CompleteAccept(pSocketInfo, pConnectionInfo); + *ReadPerformed = TRUE ; + } else { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "AsyncReadAction: connection %04x (%08x): no AcceptQueue\n", + pConnectionInfo->ConnectionId, + pConnectionInfo + )); + + } + break; + + case CI_ESTABLISHED: + if (pSocketInfo->ListenQueue.Head) { + CompleteReceive(pSocketInfo, pConnectionInfo); + *ReadPerformed = TRUE ; + } else { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_WARNING, + "AsyncReadAction: connection %04x (%08x): no ListenQueue\n", + pConnectionInfo->ConnectionId, + pConnectionInfo + )); + + } + break; + + case CI_TERMINATING: + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_INFO, + "AsyncReadAction: TERMINATING connection %04x (%08x) readable\n", + pConnectionInfo->ConnectionId, + pConnectionInfo + )); + + break; + } +} + + +PRIVATE +VOID +AsyncWriteAction( + IN LPSOCKET_INFO pSocketInfo, + IN LPCONNECTION_INFO pConnectionInfo, + OUT BOOL *WritePerformed + ) + +/*++ + +Routine Description: + + A connection has some write action to complete - complete a pending + SPXEstablishConnection or SPXSendSequencedPacket + +Arguments: + + pSocketInfo - pointer to SOCKET_INFO + pConnectionInfo - pointer to CONNECTION_INFO + +Return Value: + + None. + +--*/ + +{ + *WritePerformed = FALSE ; + + switch (pConnectionInfo->State) { + case CI_STARTING: + if (pConnectionInfo->ConnectQueue.Head) { + CompleteConnect(pSocketInfo, pConnectionInfo); + *WritePerformed = TRUE ; + } else { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "AsyncWriteAction: connection %04x (%08x): no ConnectQueue\n", + pConnectionInfo->ConnectionId, + pConnectionInfo + )); + + } + break; + + case CI_WAITING: + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_INFO, + "AsyncWriteAction: WAITING connection %04x (%08x) is writeable\n", + pConnectionInfo->ConnectionId, + pConnectionInfo + )); + + break; + + case CI_ESTABLISHED: + if (pConnectionInfo->SendQueue.Head) { + CompleteSend(pSocketInfo, pConnectionInfo); + *WritePerformed = TRUE ; + } else { +/* + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_WARNING, + "AsyncWriteAction: connection %04x (%08x): no SendQueue\n", + pConnectionInfo->ConnectionId, + pConnectionInfo + )); +*/ + } + break; + + case CI_TERMINATING: + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_INFO, + "AsyncWriteAction: TERMINATING connection %04x (%08x) writeable\n", + pConnectionInfo->ConnectionId, + pConnectionInfo + )); + + break; + } +} + +PRIVATE +VOID +CheckSelectRead( + IN LPSOCKET_INFO pSocketInfo, + IN LPCONNECTION_INFO pConnectionInfo, + OUT BOOL *CheckRead + ) + +/*++ + +Routine Description: + + See if want to check for Read readiness in select statement. + +Arguments: + + pSocketInfo - pointer to SOCKET_INFO + pConnectionInfo - pointer to CONNECTION_INFO + +Return Value: + + None. + +--*/ + +{ + *CheckRead = FALSE ; + + switch (pConnectionInfo->State) + { + case CI_WAITING: + + if (pConnectionInfo->AcceptQueue.Head) + *CheckRead = TRUE ; + break; + + case CI_ESTABLISHED: + + if (pSocketInfo->ListenQueue.Head) + *CheckRead = TRUE ; + break; + + default: + + break; + } +} + + +PRIVATE +VOID +CheckSelectWrite( + IN LPSOCKET_INFO pSocketInfo, + IN LPCONNECTION_INFO pConnectionInfo, + OUT BOOL *CheckWrite + ) + +/*++ + +Routine Description: + + See if want to check for Write readiness in select statement. + +Arguments: + + pSocketInfo - pointer to SOCKET_INFO + pConnectionInfo - pointer to CONNECTION_INFO + +Return Value: + + None. + +--*/ + +{ + *CheckWrite = FALSE ; + + switch (pConnectionInfo->State) + { + + case CI_STARTING: + + if (pConnectionInfo->ConnectQueue.Head) + *CheckWrite = TRUE ; + break; + + case CI_ESTABLISHED: + + if (pConnectionInfo->SendQueue.Head) + *CheckWrite = TRUE ; + break; + + default: + + break; + } +} + + + +PRIVATE +VOID +CompleteAccept( + IN LPSOCKET_INFO pSocketInfo, + IN LPCONNECTION_INFO pConnectionInfo + ) + +/*++ + +Routine Description: + + Complete a SPXListenForConnection + +Arguments: + + pSocketInfo - pointer to SOCKET_INFO + pConnectionInfo - pointer to CONNECTION_INFO + +Return Value: + + None. + +--*/ + +{ + SOCKET conn; + SOCKADDR_IPX remoteAddress; + int addressLength = sizeof(remoteAddress); + LPXECB pXecb = pConnectionInfo->AcceptQueue.Head; + BOOL true = TRUE; + int rc; + + conn = accept(pSocketInfo->Socket, (LPSOCKADDR)&remoteAddress, &addressLength); + if (conn != SOCKET_ERROR) { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_INFO, + "CompleteAccept: connection %04x (%08x) socket=%x\n", + pConnectionInfo->ConnectionId, + pConnectionInfo, + conn + )); + + // + // we want to receive the frame headers from this socket + // + + rc = setsockopt(conn, + NSPROTO_IPX, + IPX_RECVHDR, + (char FAR*)&true, + sizeof(true) + ); + rc = !SOCKET_ERROR; + if (rc != SOCKET_ERROR) { + + // + // update the CONNECTION_INFO structure with the actual socket + // identifier and set the connection state to established + // + + pConnectionInfo->Socket = conn; + pConnectionInfo->State = CI_ESTABLISHED; + + // + // update the app's ECB with the connection ID + // + + SPX_ECB_CONNECTION_ID(pXecb->Ecb) = pConnectionInfo->ConnectionId; + + // + // and with the partner address info + // + + CopyMemory(&pXecb->Ecb->DriverWorkspace, + &remoteAddress.sa_netnum, + sizeof(pXecb->Ecb->DriverWorkspace) + ); + + // + // fill in the immediate address field + // + + CopyMemory(&pXecb->Ecb->ImmediateAddress, + &remoteAddress.sa_nodenum, + sizeof(pXecb->Ecb->ImmediateAddress) + ); + + // + // remove the XECB from AcceptQueue and complete the SPXListenForConnection ECB + // + + DequeueEcb(pXecb, &pConnectionInfo->AcceptQueue); + + IPXDUMPECB((pXecb->Ecb, + HIWORD(pXecb->EcbAddress), + LOWORD(pXecb->EcbAddress), + ECB_TYPE_SPX, + FALSE, + FALSE, + IS_PROT_MODE(pXecb) + )); + + CompleteOrQueueEcb(pXecb, ECB_CC_SUCCESS); + } else { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "CompleteAccept: setsockopt(IPX_RECVHDR) returns %d\n", + WSAGetLastError() + )); + + // + // BUGBUG: value? + // + + closesocket(conn); + DequeueEcb(pXecb, &pConnectionInfo->AcceptQueue); + DequeueConnection(pSocketInfo, pConnectionInfo); + DeallocateConnection(pConnectionInfo); + CompleteOrQueueEcb(pXecb, ECB_CC_CONNECTION_ABORTED); + } + } else { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "CompleteAccept: accept() returns %d\n", + WSAGetLastError() + )); + + } +} + + +PRIVATE +VOID +CompleteReceive( + IN LPSOCKET_INFO pSocketInfo, + IN LPCONNECTION_INFO pConnectionInfo + ) + +/*++ + +Routine Description: + + Complete a SPXListenForSequencedPacket + +Arguments: + + pSocketInfo - pointer to SOCKET_INFO + pConnectionInfo - pointer to CONNECTION_INFO + +Return Value: + + None. + +--*/ + +{ + LPXECB pXecb; + int rc; + BOOL conn_q; + LPXECB_QUEUE pQueue; + int len; + BOOL completeRequest; + BYTE status; + + // + // receive packets while there are listen ECBs and data waiting + // + + while (1) { + if (pConnectionInfo->ListenQueue.Head) { + pQueue = &pConnectionInfo->ListenQueue; + pXecb = pConnectionInfo->ListenQueue.Head; + conn_q = TRUE; + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_INFO, + "CompleteReceive: XECB %08x from CONNECTION_INFO %08x\n", + pXecb, + pConnectionInfo + )); + + + } else if (pSocketInfo->ListenQueue.Head) { + pQueue = &pSocketInfo->ListenQueue; + pXecb = pSocketInfo->ListenQueue.Head; + conn_q = FALSE; + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_INFO, + "CompleteReceive: XECB %08x from SOCKET_INFO %08x\n", + pXecb, + pSocketInfo + )); + + } else { + break; + } + + rc = recv(pConnectionInfo->Socket, pXecb->Data, pXecb->Length, 0); + + if (rc != SOCKET_ERROR) { + + len = rc; + status = ECB_CC_SUCCESS; + completeRequest = TRUE; + + } else { + rc = WSAGetLastError(); + if (rc == WSAEMSGSIZE) { + len = pXecb->Length; + status = ECB_CC_PACKET_OVERFLOW; + completeRequest = TRUE; + } else { + completeRequest = FALSE; + + // + // if no data to receive, quit the loop (don't go down error path) + // + + if (rc == WSAEWOULDBLOCK) { + break; + } + } + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "CompleteReceive: error %d on socket %08x (CID %04x)\n", + rc, + pConnectionInfo->Socket, + pConnectionInfo->ConnectionId + )); + + DUMPXECB(pXecb); + + } + + if( rc == WSAEDISCON ) { + + // + // handle the disconnect case - we still need to complete the + // ECB. + // + + LPSPX_PACKET pPacket = (LPSPX_PACKET)pXecb->Buffer; + + status = ECB_CC_SUCCESS; + + + pPacket->DestinationConnectId = pConnectionInfo->ConnectionId; + pPacket->SourceConnectId = pConnectionInfo->RemoteConnectionId; + pPacket->DataStreamType = SPX_DS_TERMINATE ; + pPacket->Checksum = 0xffff; + pPacket->Length = L2BW(SPX_HEADER_LENGTH); + pPacket->TransportControl = 0; + pPacket->PacketType = 5; + + pXecb->Length = SPX_HEADER_LENGTH ; + ScatterData(pXecb); + + DequeueEcb(pXecb, pQueue); + + // + // Put the remote node address in the ECB's immediate address + // field + // + + CopyMemory(pXecb->Ecb->ImmediateAddress, + pConnectionInfo->RemoteNode, + sizeof(pXecb->Ecb->ImmediateAddress) + ); + + CompleteOrQueueIo(pXecb, status); + + DequeueConnection(pConnectionInfo->OwningSocket, pConnectionInfo); + AbortOrTerminateConnection(pConnectionInfo, ECB_CC_CONNECTION_ABORTED); + break ; + + } + else if (completeRequest) { + +#if SPX_HACK + if (pConnectionInfo->Flags & CF_1ST_RECEIVE) { + pConnectionInfo->Flags &= ~CF_1ST_RECEIVE; + ModifyFirstReceive(pXecb->Data, &len, pSocketInfo->SocketNumber, pConnectionInfo->Socket); + } +#endif + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_INFO, + "CompleteReceive: recv() on socket %#x returns %d bytes (Addr=%08x)\n", + pConnectionInfo->Socket, + len, + pXecb->Data + )); + + IPXDUMPDATA((pXecb->Data, 0, 0, FALSE, (WORD)len)); + + pXecb->Length -= len; + pXecb->ActualLength += len; + pXecb->Data += len; + if (pXecb->ActualLength >= SPX_HEADER_LENGTH) { + if (pXecb->Flags & XECB_FLAG_FIRST_RECEIVE) { + + LPSPX_PACKET pPacket = (LPSPX_PACKET)pXecb->Buffer; + + // + // record in the SPX header the local connection id we invented + // + + pPacket->DestinationConnectId = pConnectionInfo->ConnectionId; + + // + // record the actual frame length from the header + // + + pXecb->FrameLength = B2LW(((LPSPX_PACKET)pXecb->Buffer)->Length); + pXecb->Flags &= ~XECB_FLAG_FIRST_RECEIVE; + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_INFO, + "CompleteReceive: FrameLength=%x (%d)\n", + pXecb->FrameLength, + pXecb->FrameLength + )); + + } + + // + // if we received all the data in the packet (according to length + // field in the SPX header) OR we ran out of buffer space, remove + // the ECB from its queue and complete it + // + + if (!pXecb->Length || (pXecb->ActualLength == pXecb->FrameLength)) { + if (pXecb->Flags & XECB_FLAG_BUFFER_ALLOCATED) { + + // + // update the XECB.Length field to reflect the amount of + // data received and copy it to the fragmented buffers + // in VDM. do not overflow buffer if FrameLength turns + // out to be larger than we expect. + // + + pXecb->Length = min(pXecb->FrameLength, + pXecb->ActualLength); + ScatterData(pXecb); + } + DequeueEcb(pXecb, pQueue); + + // DUMPXECB(pXecb); + + + IPXDUMPECB((pXecb->Ecb, + HIWORD(pXecb->EcbAddress), + LOWORD(pXecb->EcbAddress), + ECB_TYPE_SPX, + TRUE, + TRUE, + IS_PROT_MODE(pXecb) + )); + + // + // Put the remote node address in the ECB's immediate address + // field + // + + CopyMemory(pXecb->Ecb->ImmediateAddress, + pConnectionInfo->RemoteNode, + sizeof(pXecb->Ecb->ImmediateAddress) + ); + CompleteOrQueueIo(pXecb, status); + } else { + + // + // partial receive. If the listen ECB came off the socket + // queue then put it on the connection queue: this is the + // ECB that will be used for this connection until all data + // received or we get an error + // + + if (!conn_q) { + DequeueEcb(pXecb, &pSocketInfo->ListenQueue); + QueueEcb(pXecb, + &pConnectionInfo->ListenQueue, + CONNECTION_LISTEN_QUEUE + ); + } + + // + // not enough data to satisfy read: don't continue yet + // + + break; + } + } + } else { + + // + // error occurred - abort the connection + // + + if (!conn_q) { + DequeueEcb(pXecb, &pSocketInfo->ListenQueue); + QueueEcb(pXecb, + &pConnectionInfo->ListenQueue, + CONNECTION_LISTEN_QUEUE + ); + } + DequeueConnection(pConnectionInfo->OwningSocket, pConnectionInfo); + AbortOrTerminateConnection(pConnectionInfo, ECB_CC_CONNECTION_ABORTED); + + // + // don't continue in this case + // + + break; + } + } +} + + +PRIVATE +VOID +CompleteConnect( + IN LPSOCKET_INFO pSocketInfo, + IN LPCONNECTION_INFO pConnectionInfo + ) + +/*++ + +Routine Description: + + Complete a SPXEstablishConnection + +Arguments: + + pSocketInfo - pointer to SOCKET_INFO + pConnectionInfo - pointer to CONNECTION_INFO + +Return Value: + + None. + +--*/ + +{ + LPXECB pXecb = pConnectionInfo->ConnectQueue.Head; +/* + LPSPX_PACKET pPacket; + + // + // the connection ID also appears in the first segment of the establish + // ECB + // + + pPacket = (LPSPX_PACKET)GET_FAR_POINTER(&ECB_FRAGMENT(pXecb->Ecb, 0)->Address, + IS_PROT_MODE(pXecb) + ); + pPacket->Checksum = 0xffff; + pPacket->Length = L2BW(SPX_HEADER_LENGTH); + pPacket->TransportControl = 0; + pPacket->PacketType = 5; + pPacket->Source.Socket = pSocketInfo->SocketNumber; + pPacket->ConnectionControl = 0xc0; + pPacket->DataStreamType = 0; + pPacket->SourceConnectId = pConnectionInfo->ConnectionId; + pPacket->DestinationConnectId = 0xffff; + pPacket->SequenceNumber = 0; + pPacket->AckNumber = 0; + pPacket->AllocationNumber = 0; +*/ + + pConnectionInfo->State = CI_ESTABLISHED; + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_INFO, + "CompleteConnect: connection %04x (%08x) completed\n", + pConnectionInfo->ConnectionId, + pConnectionInfo + )); + + DUMPCONN(pConnectionInfo); + + DequeueEcb(pXecb, &pConnectionInfo->ConnectQueue); + + IPXDUMPECB((pXecb->Ecb, + HIWORD(pXecb->EcbAddress), + LOWORD(pXecb->EcbAddress), + ECB_TYPE_SPX, + TRUE, + TRUE, + IS_PROT_MODE(pXecb) + )); + + CompleteOrQueueEcb(pXecb, ECB_CC_SUCCESS); +} + + +PRIVATE +VOID +CompleteSend( + IN LPSOCKET_INFO pSocketInfo, + IN LPCONNECTION_INFO pConnectionInfo + ) + +/*++ + +Routine Description: + + Complete a SPXSendSequencedPacket + +Arguments: + + pSocketInfo - pointer to SOCKET_INFO + pConnectionInfo - pointer to CONNECTION_INFO + +Return Value: + + None. + +--*/ + +{ + LPXECB pXecb = pConnectionInfo->SendQueue.Head; + int rc; + BYTE status; + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_INFO, + "CompleteSend: sending %d (0x%x) bytes from %08x\n", + pXecb->Length, + pXecb->Length, + pXecb->Data + )); + + IPXDUMPECB((pXecb->Ecb, + HIWORD(pXecb->EcbAddress), + LOWORD(pXecb->EcbAddress), + ECB_TYPE_SPX, + TRUE, + TRUE, + IS_PROT_MODE(pXecb) + )); + + rc = send(pConnectionInfo->Socket, pXecb->Data, pXecb->Length, 0); + if (rc == pXecb->Length) { + + // + // all data sent + // + + status = ECB_CC_SUCCESS; + } else if (rc == SOCKET_ERROR) { + rc = WSAGetLastError(); + if (rc == WSAEWOULDBLOCK) { + + // + // huh??? + // + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "CompleteSend: send() returns WSAEWOODBLOCK??\n" + )); + + // + // leave ECB on queue + // + + return; + } else { + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_ERROR, + "CompleteSend: send() returns %d\n", + rc + )); + + // + // BUGBUG: abort connection? + // + + status = ECB_CC_CONNECTION_ABORTED; + } + } else { + + // + // partial data sent. Update the buffer pointer and length fields + // and leave this ECB at the head of the send queue + // + + pXecb->Data += rc; + pXecb->Length -= (WORD)rc; + return; + } + DequeueEcb(pXecb, &pConnectionInfo->SendQueue); + CompleteOrQueueIo(pXecb, status); +} + +#if SPX_HACK + +PRIVATE +VOID +ModifyFirstReceive( + LPBYTE Buffer, + LPDWORD pLength, + WORD SocketNumber, + SOCKET Socket + ) +{ + WORD len = *(LPWORD)pLength; + + if ((*(ULPWORD)Buffer != 0xffff) && (*(ULPWORD)(Buffer+2) != L2BW(len))) { + + LPSPX_PACKET packet; + SOCKADDR_IPX remote; + int rc; + int remlen; + + IPXDBGPRINT((__FILE__, __LINE__, + FUNCTION_ANY, + IPXDBG_LEVEL_INFO, + "ModifyFirstReceive: Modifying: Buffer=%08x Length=%04x SocketNumber=%04x Socket=%08x\n", + Buffer, + len, + B2LW(SocketNumber), + Socket + )); + + MoveMemory(Buffer+42, Buffer, len); + packet = (LPSPX_PACKET)Buffer; + packet->Checksum = 0xffff; + packet->Length = L2BW(42+len); + packet->TransportControl = 0; + packet->PacketType = 5; + CopyMemory((LPVOID)&packet->Destination, + (LPVOID)&MyInternetAddress.sa_netnum, + sizeof(INTERNET_ADDRESS) + ); + packet->Destination.Socket = SocketNumber; + rc = getpeername(Socket, (LPSOCKADDR)&remote, &remlen); + if (rc != SOCKET_ERROR) { + CopyMemory((LPVOID)&packet->Source, + (LPVOID)&remote.sa_netnum, + sizeof(NETWARE_ADDRESS) + ); + } else { + ZeroMemory((LPVOID)&packet->Source, sizeof(NETWARE_ADDRESS)); + } + packet->ConnectionControl = 0x40; + packet->DataStreamType = 0; + packet->SourceConnectId = 0; + packet->DestinationConnectId = 0; + packet->SequenceNumber = 0; + packet->AckNumber = 0; + packet->AllocationNumber = 0; + *pLength += 42; + } +} + +#endif |