/*++

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;

    //
    // 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()
                        ));

            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 -= (USHORT) len;
            pXecb->ActualLength += (USHORT)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;

    LPSPX_PACKET pPacket;  //Multi-User addition
    int flags = 0;             //Multi-User addition

    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)
                ));

    //======Multi-User code merge ==============================
    // 2/18/97 cjc Code copied from _VwSPXSendSequencedPacket (vwspx.c) to fix
    //             problem where EndOfMessage bit was being set prematurely and
    //             caused BSPXCOM8 error messages with Btrieve.

    //
    // if the app set the END_OF_MESSAGE bit in the ConnectionControl
    // field then set the flags to 0: NWLink will automatically set the
    // end-of-message bit in the packet; otherwise set flags to MSG_PARTIAL
    // to indicate to NWLink that it *shouldn't* set the bit in the packet
    //
    pPacket = (LPSPX_PACKET)GET_FAR_POINTER(
                                    &(ECB_FRAGMENT(pXecb->Ecb, 0)->Address),
                                    IS_PROT_MODE(pXecb)
                                    );
    if (pPacket) {
        flags = (pPacket->ConnectionControl & SPX_END_OF_MESSAGE)
              ? 0
              : MSG_PARTIAL
              ;
    }

    rc = send(pConnectionInfo->Socket, pXecb->Data, pXecb->Length, flags);

    //rc = send(pConnectionInfo->Socket, pXecb->Data, pXecb->Length, 0); //Original
    //======Multi-User code merge End ==============================
    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
                        ));

            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