extension.cpp

< WINDOWS网络编程>>英文版,一本详细讲解WINDOWS平台下网络编程的国外经典书籍,适合英文水平高的牛人

        ProviderOverlapped->lpCallerOverlapped = lpOverlapped;
        CopyOffset(&ProviderOverlapped->ProviderOverlapped, lpOverlapped);
        ProviderOverlapped->SockInfo           = SocketContext;
        ProviderOverlapped->CallerSocket       = s;
        ProviderOverlapped->ProviderSocket     = SocketContext->ProviderSocket;
        ProviderOverlapped->Error              = NO_ERROR;
        ProviderOverlapped->Operation          = LSP_OP_CONNECTEX;
        ProviderOverlapped->lpCallerThreadId   = NULL;
        ProviderOverlapped->lpCallerCompletionRoutine      = NULL;
        ProviderOverlapped->ConnectExArgs.s                = s;
        if (namelen <= sizeof(ProviderOverlapped->ConnectExArgs.name))
            CopyMemory(&ProviderOverlapped->ConnectExArgs.name, name, namelen);
        ProviderOverlapped->ConnectExArgs.namelen          = namelen;
        ProviderOverlapped->ConnectExArgs.lpSendBuffer     = lpSendBuffer;
        ProviderOverlapped->ConnectExArgs.dwSendDataLength = dwSendDataLength;
        ProviderOverlapped->ConnectExArgs.dwBytesSent      = (lpdwBytesSent ? *lpdwBytesSent : 0);
        ProviderOverlapped->Provider           = SocketContext->Provider;

        ret = QueueOverlappedOperation(ProviderOverlapped, SocketContext);

        if (ret != NO_ERROR)
        {
            WSASetLastError(ret);
            ret = FALSE;
        }
        else
        {
            ret = TRUE;
        }
    }
    else
    {
        ret = SocketContext->Provider->NextProcTableExt.lpfnConnectEx(
            SocketContext->ProviderSocket,
            name,
            namelen,
            lpSendBuffer,
            dwSendDataLength,
            lpdwBytesSent,
            NULL);
    }
    UnlockSocketContext(SocketContext, &Errno);

    return ret;
}

BOOL PASCAL FAR ExtTransmitPackets(
    SOCKET hSocket,
    LPTRANSMIT_PACKETS_ELEMENT lpPacketArray,
    DWORD nElementCount,
    DWORD nSendSize,
    LPOVERLAPPED lpOverlapped,
    DWORD dwFlags)
{
    SOCK_INFO           *SocketContext=NULL;
    LPWSAOVERLAPPEDPLUS  ProviderOverlapped=NULL;
    int                  Errno,
                         ret;

    SocketContext = FindAndLockSocketContext(hSocket, &Errno);
    if (SocketContext == NULL)
    {
        dbgprint("ExtTransmitPackets: WPUQuerySocketHandleContext() failed: %d", Errno);
        WSASetLastError(Errno);
        return FALSE;
    }

    if (!SocketContext->Provider->NextProcTableExt.lpfnTransmitPackets)
    {
        UnlockSocketContext(SocketContext, &Errno);
        dbgprint("Next proc table TransmitPackets == NULL!");
        WSASetLastError(WSAEFAULT);
        return FALSE;
    }
    //
    // Check for overlapped I/O
    //
    if (lpOverlapped)
    {
        ProviderOverlapped = GetOverlappedStructure(SocketContext);
        if (!ProviderOverlapped)
        {
            UnlockSocketContext(SocketContext, &Errno);
            dbgprint("ExtTransmitPackets: GetOverlappedStructure() returned NULL");
            WSASetLastError(WSAENOBUFS);
            return FALSE;
        }
        //
        // Save off the arguments and setup the overlapped structure
        //
        ProviderOverlapped->lpCallerOverlapped = lpOverlapped;
        CopyOffset(&ProviderOverlapped->ProviderOverlapped, lpOverlapped);
        ProviderOverlapped->SockInfo           = SocketContext;
        ProviderOverlapped->CallerSocket       = hSocket;
        ProviderOverlapped->ProviderSocket     = SocketContext->ProviderSocket;
        ProviderOverlapped->Error              = NO_ERROR;
        ProviderOverlapped->Operation          = LSP_OP_TRANSMITPACKETS;
        ProviderOverlapped->lpCallerThreadId   = NULL;
        ProviderOverlapped->lpCallerCompletionRoutine           = NULL;
        ProviderOverlapped->TransmitPacketsArgs.s               = hSocket;
        ProviderOverlapped->TransmitPacketsArgs.lpPacketArray   = lpPacketArray;
        ProviderOverlapped->TransmitPacketsArgs.nElementCount   = nElementCount;
        ProviderOverlapped->TransmitPacketsArgs.nSendSize       = nSendSize;
        ProviderOverlapped->TransmitPacketsArgs.dwFlags         = dwFlags;
        ProviderOverlapped->Provider           = SocketContext->Provider;

        ret = QueueOverlappedOperation(ProviderOverlapped, SocketContext);

        if (ret != NO_ERROR)
        {
            WSASetLastError(ret);
            ret = FALSE;
        }
        else
        {
            ret = TRUE;
        }

    }
    else
    {
        ret = SocketContext->Provider->NextProcTableExt.lpfnTransmitPackets(
            SocketContext->ProviderSocket,
            lpPacketArray,
            nElementCount,
            nSendSize,
            NULL,
            dwFlags);
    }
    UnlockSocketContext(SocketContext, &Errno);

    return ret;
}

BOOL PASCAL FAR ExtDisconnectEx(
    IN SOCKET s,
    IN LPOVERLAPPED lpOverlapped,
    IN DWORD  dwFlags,
    IN DWORD  dwReserved)
{
    SOCK_INFO           *SocketContext=NULL;
    LPWSAOVERLAPPEDPLUS  ProviderOverlapped=NULL;
    int                  Errno,
                         ret;

    SocketContext = FindAndLockSocketContext(s, &Errno);
    if (SocketContext == NULL)
    {
        dbgprint("ExtDisconnectEx: WPUQuerySocketHandleContext() failed: %d", Errno);
        WSASetLastError(Errno);
        return FALSE;
    }

    if (!SocketContext->Provider->NextProcTableExt.lpfnDisconnectEx)
    {
        UnlockSocketContext(SocketContext, &Errno);
        dbgprint("Next proc table DisconnectEx == NULL!");
        WSASetLastError(WSAEFAULT);
        return FALSE;
    }

    // Check for overlapped I/O

    if (lpOverlapped)
    {
        ProviderOverlapped = GetOverlappedStructure(SocketContext);
        if (!ProviderOverlapped)
        {
            UnlockSocketContext(SocketContext, &Errno);
            dbgprint("ExtDisconnectEx: GetOverlappedStructure() returned NULL");
            WSASetLastError(WSAENOBUFS);
            return FALSE;
        }
        //
        // Save off the arguments and setup the overlapped structure
        //
        ProviderOverlapped->lpCallerOverlapped = lpOverlapped;
        CopyOffset(&ProviderOverlapped->ProviderOverlapped, lpOverlapped);
        ProviderOverlapped->SockInfo           = SocketContext;
        ProviderOverlapped->CallerSocket       = s;
        ProviderOverlapped->ProviderSocket     = SocketContext->ProviderSocket;
        ProviderOverlapped->Error              = NO_ERROR;
        ProviderOverlapped->Operation          = LSP_OP_DISCONNECTEX;
        ProviderOverlapped->lpCallerThreadId   = NULL;
        ProviderOverlapped->lpCallerCompletionRoutine           = NULL;
        ProviderOverlapped->DisconnectExArgs.s                  = s;
        ProviderOverlapped->DisconnectExArgs.dwFlags            = dwFlags;
        ProviderOverlapped->DisconnectExArgs.dwReserved         = dwReserved;
        ProviderOverlapped->Provider           = SocketContext->Provider;
 
        ret = QueueOverlappedOperation(ProviderOverlapped, SocketContext);

        if (ret != NO_ERROR)
        {
            WSASetLastError(ret);
            ret = FALSE;
        }
        else
        {
            ret = TRUE;
        }
    }
    else
    {
        ret = SocketContext->Provider->NextProcTableExt.lpfnDisconnectEx(
            SocketContext->ProviderSocket,
            lpOverlapped,
            dwFlags,
            dwReserved);
    }
    UnlockSocketContext(SocketContext, &Errno);

    return ret;
}

INT PASCAL FAR ExtWSARecvMsg(
    IN SOCKET s,
    IN OUT LPWSAMSG lpMsg,
    OUT LPDWORD lpdwNumberOfBytesRecvd,
    IN LPWSAOVERLAPPED lpOverlapped,
    IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
{
    SOCK_INFO           *SocketContext=NULL;
    LPWSAOVERLAPPEDPLUS  ProviderOverlapped=NULL;
    int                  Errno,
                         ret;

    SocketContext = FindAndLockSocketContext(s, &Errno);
    if (SocketContext == NULL)
    {
        dbgprint("ExtWSARecvmsg: WPUQuerySocketHandleContext() failed: %d", Errno);
        WSASetLastError(Errno);
        return FALSE;
    }

    if (!SocketContext->Provider->NextProcTableExt.lpfnWSARecvMsg)
    {
        UnlockSocketContext(SocketContext, &Errno);
        dbgprint("Next proc table WSARecvMsg == NULL!");
        WSASetLastError(WSAEFAULT);
        return FALSE;
    }
    //
    // Check for overlapped I/O
    //
    if (lpOverlapped)
    {
        ProviderOverlapped = GetOverlappedStructure(SocketContext);
        if (!ProviderOverlapped)
        {
            UnlockSocketContext(SocketContext, &Errno);
            dbgprint("ExtWSARecvMsg: GetOverlappedStructure() returned NULL");
            WSASetLastError(WSAENOBUFS);
            return FALSE;
        }
        //
        // Save off the arguments and setup the overlapped structure
        //
        ProviderOverlapped->lpCallerOverlapped = lpOverlapped;
        CopyOffset(&ProviderOverlapped->ProviderOverlapped, lpOverlapped);
        ProviderOverlapped->SockInfo           = SocketContext;
        ProviderOverlapped->CallerSocket       = s;
        ProviderOverlapped->ProviderSocket     = SocketContext->ProviderSocket;
        ProviderOverlapped->Error              = NO_ERROR;
        ProviderOverlapped->Operation          = LSP_OP_WSARECVMSG;
        ProviderOverlapped->lpCallerThreadId   = NULL;
        ProviderOverlapped->lpCallerCompletionRoutine           = lpCompletionRoutine;
        ProviderOverlapped->WSARecvMsgArgs.s                    = s;
        ProviderOverlapped->WSARecvMsgArgs.lpMsg                = lpMsg;
        ProviderOverlapped->WSARecvMsgArgs.dwNumberOfBytesRecvd = (lpdwNumberOfBytesRecvd ? *lpdwNumberOfBytesRecvd : 0);
        ProviderOverlapped->Provider           = SocketContext->Provider;

        ret = QueueOverlappedOperation(ProviderOverlapped, SocketContext);

        if (ret != NO_ERROR)
        {
            WSASetLastError(ret);
            ret = FALSE;
        }
        else
        {
            ret = TRUE;
        }
    }
    else
    {
        ret = SocketContext->Provider->NextProcTableExt.lpfnWSARecvMsg(
            SocketContext->ProviderSocket,
            lpMsg,
            lpdwNumberOfBytesRecvd,
            NULL,
            NULL);
    }

    UnlockSocketContext(SocketContext, &Errno);

    return ret;
}