main.cpp

《Windows网络编程技术》附书源码源码. 运行环境：9x/Me/NT/2000/XP/ 源码语言：简体中文 第十四章

    return NextProcTable.lpWSPGetSockOpt(SocketContext->ProviderSocket, level,           
        optname, optval, optlen, lpErrno);
}

BOOL WSPAPI WSPGetQOSByName(
    SOCKET s,               
    LPWSABUF lpQOSName,   
    LPQOS lpQOS,            
    LPINT lpErrno)
{
    SOCK_INFO *SocketContext;

    if (MainUpCallTable.lpWPUQuerySocketHandleContext(s, (LPDWORD) &SocketContext, lpErrno) == SOCKET_ERROR)
        return SOCKET_ERROR;

    return NextProcTable.lpWSPGetQOSByName(SocketContext->ProviderSocket, lpQOSName,
        lpQOS, lpErrno);
}


int WSPAPI WSPIoctl(
    SOCKET s,
    DWORD dwIoControlCode,
    LPVOID lpvInBuffer,
    DWORD cbInBuffer,
    LPVOID lpvOutBuffer,
    DWORD cbOutBuffer,
    LPDWORD lpcbBytesReturned,
    LPWSAOVERLAPPED lpOverlapped,
    LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
    LPWSATHREADID lpThreadId,
    LPINT lpErrno)
{
    SOCK_INFO *SocketContext;
    int Ret;
    LPWSAOVERLAPPED ProviderOverlapped;

    GUID AcceptExGuid = WSAID_ACCEPTEX;
    GUID TransmitFileGuid = WSAID_TRANSMITFILE;
    GUID GetAcceptExSockAddrsGuid = WSAID_GETACCEPTEXSOCKADDRS;

    if (MainUpCallTable.lpWPUQuerySocketHandleContext(s, (LPDWORD) &SocketContext,
        lpErrno) == SOCKET_ERROR)
    {
//        MessageBox(NULL, L"wham", L"wham", MB_OK);
        return SOCKET_ERROR;
    }

    if (dwIoControlCode == SIO_GET_EXTENSION_FUNCTION_POINTER)
    {
        if (memcmp (lpvInBuffer, &TransmitFileGuid, sizeof (GUID)) == 0)
        {
            *((LPFN_TRANSMITFILE *)lpvOutBuffer) = ExtTransmitFile;
            *lpErrno = 0;
            return 0;
        }
        else
            if (memcmp(lpvInBuffer, &AcceptExGuid, sizeof(GUID)) == 0)
            {
                *((LPFN_ACCEPTEX *)lpvOutBuffer) = ExtAcceptEx;
                *lpErrno = 0;
                return 0;
            }
            else 
                if (memcmp (lpvInBuffer, &GetAcceptExSockAddrsGuid, sizeof (GUID)) == 0)
                {
                    // No socket handle translation needed, let the call pass through below
                }
                else 
                {
                    *lpErrno = WSAEOPNOTSUPP;
                    return SOCKET_ERROR;
                }

    }


    // Check for overlapped I/O
    
    if (lpOverlapped)
    {
        ProviderOverlapped = GetOverlappedStructure(s, SocketContext->ProviderSocket, lpOverlapped, lpCompletionRoutine,
            lpThreadId, NULL);

        Ret = NextProcTable.lpWSPIoctl(SocketContext->ProviderSocket, dwIoControlCode, lpvInBuffer,
            cbInBuffer, lpvOutBuffer, cbOutBuffer, lpcbBytesReturned, ProviderOverlapped, NULL, NULL, lpErrno);
    }
    else
    {
        Ret = NextProcTable.lpWSPIoctl(SocketContext->ProviderSocket, dwIoControlCode, lpvInBuffer,
            cbInBuffer, lpvOutBuffer, cbOutBuffer, lpcbBytesReturned, lpOverlapped, lpCompletionRoutine, lpThreadId, lpErrno);
    }

    return Ret;
}

SOCKET WSPAPI WSPJoinLeaf(
    SOCKET s,                           
    const struct sockaddr FAR * name,     
    int namelen,                        
    LPWSABUF lpCallerData,                
    LPWSABUF lpCalleeData,              
    LPQOS lpSQOS,                         
    LPQOS lpGQOS,                       
    DWORD dwFlags,                        
    LPINT lpErrno)
{
    SOCK_INFO *SocketContext;
    SOCKET NextProviderSocket;
    SOCKET NewSocket;

    if (MainUpCallTable.lpWPUQuerySocketHandleContext(s, (LPDWORD) &SocketContext, lpErrno) == SOCKET_ERROR)
        return SOCKET_ERROR;

    NextProviderSocket = NextProcTable.lpWSPJoinLeaf(SocketContext->ProviderSocket,                           
        name, namelen, lpCallerData, lpCalleeData, lpSQOS, lpGQOS, dwFlags,                        
        lpErrno);
        
    if (NextProviderSocket != INVALID_SOCKET)
    {
        if ((SocketContext = (SOCK_INFO *) GlobalAlloc(GPTR, sizeof SOCK_INFO)) == NULL)
        {
            *lpErrno = WSAENOBUFS;
            return INVALID_SOCKET;
        }
        SocketContext->ProviderSocket = NextProviderSocket;
        SocketContext->bClosing  = FALSE;
        SocketContext->dwOutstandingAsync = 0;
        SocketContext->BytesRecv = 0;
        SocketContext->BytesSent = 0;

        NewSocket = MainUpCallTable.lpWPUCreateSocketHandle(gChainId, (DWORD) SocketContext, lpErrno);

        {
            TCHAR buffer[128];
            wsprintf(buffer, L"Creating socket %d\n", NewSocket);
            OutputDebugString(buffer);
        }

        return NewSocket;
    }

    return INVALID_SOCKET;
}

int WSPAPI WSPListen(
    SOCKET s,        
    int backlog,     
    LPINT lpErrno)
{
    SOCK_INFO *SocketContext;

    if (MainUpCallTable.lpWPUQuerySocketHandleContext(s, (LPDWORD) &SocketContext, lpErrno) == SOCKET_ERROR)
        return SOCKET_ERROR;

    return NextProcTable.lpWSPListen (SocketContext->ProviderSocket, backlog, lpErrno);
}

int WSPAPI WSPRecv(
    SOCKET s,                                                 
    LPWSABUF lpBuffers,                                       
    DWORD dwBufferCount,                                      
    LPDWORD lpNumberOfBytesRecvd,                             
    LPDWORD lpFlags,                                          
    LPWSAOVERLAPPED lpOverlapped,                             
    LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,   
    LPWSATHREADID lpThreadId,                                 
    LPINT lpErrno)
{
    SOCK_INFO *SocketContext;
    int Ret;
    LPWSAOVERLAPPED ProviderOverlapped;

    if (MainUpCallTable.lpWPUQuerySocketHandleContext(s, (LPDWORD) &SocketContext, lpErrno) == SOCKET_ERROR)
        return SOCKET_ERROR;


    // Check for overlapped I/O
    
    if (lpOverlapped)
    {
        ProviderOverlapped = GetOverlappedStructure(s, SocketContext->ProviderSocket, lpOverlapped, lpCompletionRoutine,
            lpThreadId, &SocketContext->BytesRecv);

        Ret = NextProcTable.lpWSPRecv(SocketContext->ProviderSocket, lpBuffers, dwBufferCount,
            lpNumberOfBytesRecvd, lpFlags, ProviderOverlapped, NULL, NULL, lpErrno);

    }
    else
    {
        // Process ordinary blocking call

        Ret = NextProcTable.lpWSPRecv(SocketContext->ProviderSocket, lpBuffers, dwBufferCount,
            lpNumberOfBytesRecvd, lpFlags, lpOverlapped, lpCompletionRoutine, lpThreadId,
            lpErrno);

        if (Ret != SOCKET_ERROR)
        {
            SocketContext->BytesRecv += *lpNumberOfBytesRecvd;
        }
    }

    return Ret;
}

int WSPAPI WSPRecvDisconnect(
    SOCKET s,                           
    LPWSABUF lpInboundDisconnectData,     
    LPINT lpErrno)
{
    SOCK_INFO *SocketContext;

    if (MainUpCallTable.lpWPUQuerySocketHandleContext(s, (LPDWORD) &SocketContext, lpErrno) == SOCKET_ERROR)
        return SOCKET_ERROR;

    return NextProcTable.lpWSPRecvDisconnect(SocketContext->ProviderSocket,                           
        lpInboundDisconnectData, lpErrno);
}

int WSPAPI WSPRecvFrom(
    SOCKET s,
    LPWSABUF lpBuffers,
    DWORD dwBufferCount,
    LPDWORD lpNumberOfBytesRecvd,
    LPDWORD lpFlags,
    struct sockaddr FAR * lpFrom,
    LPINT lpFromlen,
    LPWSAOVERLAPPED lpOverlapped,
    LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
    LPWSATHREADID lpThreadId,
    LPINT lpErrno)
{
    SOCK_INFO *SocketContext;
    int Ret;
    LPWSAOVERLAPPED ProviderOverlapped;

    if (MainUpCallTable.lpWPUQuerySocketHandleContext(s, (LPDWORD) &SocketContext, lpErrno) == SOCKET_ERROR)
        return SOCKET_ERROR;

    // Check for overlapped I/O
    
    if (lpOverlapped)
    {
        ProviderOverlapped = GetOverlappedStructure(s, SocketContext->ProviderSocket, lpOverlapped, lpCompletionRoutine,
            lpThreadId, &SocketContext->BytesRecv);

        if (ProviderOverlapped == NULL)
        {
            OutputDebugString(L"WSPRecvFrom got a NULL overlapp structure\n");
        }

        Ret = NextProcTable.lpWSPRecvFrom(SocketContext->ProviderSocket, lpBuffers, dwBufferCount,
            lpNumberOfBytesRecvd, lpFlags, lpFrom, lpFromlen, ProviderOverlapped, NULL, NULL, lpErrno);

    }
    else
    {
        Ret = NextProcTable.lpWSPRecvFrom(SocketContext->ProviderSocket, lpBuffers, dwBufferCount,
            lpNumberOfBytesRecvd, lpFlags, lpFrom, lpFromlen, lpOverlapped, lpCompletionRoutine, lpThreadId, lpErrno);

        if (Ret != SOCKET_ERROR)
        {
            SocketContext->BytesRecv += *lpNumberOfBytesRecvd;
        }
    }

    return Ret;
}

int WSPAPI WSPSelect(
    int nfds,
    fd_set FAR * readfds,
    fd_set FAR * writefds,
    fd_set FAR * exceptfds,
    const struct timeval FAR * timeout,
    LPINT lpErrno)
{
    SOCK_INFO *SocketContext;
    u_int i;
    u_int count;
    int Ret;
    int HandleCount;

    // Convert handles
    struct
    {
        SOCKET ClientSocket;
        SOCKET ProvSocket;

    } Read[FD_SETSIZE], Write[FD_SETSIZE], Except[FD_SETSIZE];

    fd_set ReadFds, WriteFds, ExceptFds;

    if (readfds)
    {
        FD_ZERO(&ReadFds);

        for (i = 0; i < readfds->fd_count; i++)
        {
            if (MainUpCallTable.lpWPUQuerySocketHandleContext(
                (Read[i].ClientSocket = readfds->fd_array[i]), 
                (LPDWORD) &SocketContext, lpErrno) == SOCKET_ERROR)
                return SOCKET_ERROR;
            FD_SET((Read[i].ProvSocket = SocketContext->ProviderSocket), &ReadFds);
        }
    }

    if (writefds)
    {
        FD_ZERO(&WriteFds);

        for (i = 0; i < writefds->fd_count; i++)
        {
            if (MainUpCallTable.lpWPUQuerySocketHandleContext(
                (Write[i].ClientSocket = writefds->fd_array[i]), 
                (LPDWORD) &SocketContext, lpErrno) == SOCKET_ERROR)
                return SOCKET_ERROR;
            FD_SET((Write[i].ProvSocket = SocketContext->ProviderSocket), &WriteFds);
        }
    }

    if (exceptfds)
    {
        FD_ZERO(&ExceptFds);

        for (i = 0; i < exceptfds->fd_count; i++)
        {
            if (MainUpCallTable.lpWPUQuerySocketHandleContext(
                (Except[i].ClientSocket = exceptfds->fd_array[i]), 
                (LPDWORD) &SocketContext, lpErrno) == SOCKET_ERROR)
                return SOCKET_ERROR;
            FD_SET((Except[i].ProvSocket = SocketContext->ProviderSocket), &ExceptFds);
        }
    }

    Ret = NextProcTable.lpWSPSelect(nfds, 
        (readfds ? &ReadFds : NULL), (writefds ? &WriteFds : NULL), 
        (exceptfds ? &ExceptFds : NULL), timeout, lpErrno);

    if (Ret != SOCKET_ERROR)
    {
        HandleCount = Ret;

        if (readfds)
        {
            count = readfds->fd_count;
            FD_ZERO(readfds);

            for(i = 0; (i < count) && HandleCount; i++)
            {
                if (MainUpCallTable.lpWPUFDIsSet(Read[i].ProvSocket, &ReadFds))
                {
                    FD_SET(Read[i].ClientSocket, readfds);
                    HandleCount--;
                }
            }
        }

        if (writefds)
        {
            count = writefds->fd_count;
            FD_ZERO(writefds);

            for(i = 0; (i < count) && HandleCount; i++)
            {
                if (MainUpCallTable.lpWPUFDIsSet(Write[i].ProvSocket, &WriteFds))
                {
                    FD_SET(Write[i].ClientSocket, writefds);
                    HandleCount--;
                }
            }
        }

        if (exceptfds)
        {
            count = exceptfds->fd_count;
            FD_ZERO(exceptfds);

            for(i = 0; (i < count) && HandleCount; i++)
            {
                if (MainUpCallTable.lpWPUFDIsSet(Except[i].ProvSocket, &ExceptFds))
                {
                    FD_SET(Except[i].ClientSocket, exceptfds);
                    HandleCount--;
                }
            }
        }
    }

    return Ret;
}