sockinfo.cpp File Reference

#include "lspdef.h"

Include dependency graph for sockinfo.cpp:

Go to the source code of this file.

Functions
SOCK_INFO *	FindSockInfoFromProviderSocket (PROVIDER *provider, SOCKET socket)
SOCK_INFO *	FindAndRefSocketContext (SOCKET s, int *lpErrno)
void	DerefSocketContext (SOCK_INFO *context, int *lpErrno)
void	AcquireSocketLock (SOCK_INFO *SockInfo)
void	ReleaseSocketLock (SOCK_INFO *SockInfo)
SOCK_INFO *	CreateSockInfo (PROVIDER *Provider, SOCKET ProviderSocket, SOCK_INFO *Inherit, BOOL Insert, int *lpErrno)
void	FreeSockInfo (SOCK_INFO *info)
void	InsertSocketInfo (PROVIDER *provider, SOCK_INFO *sock)
void	RemoveSocketInfo (PROVIDER *provider, SOCK_INFO *si)
void	CloseAndFreeSocketInfo (PROVIDER *provider, BOOL processDetach)
SOCK_INFO *	GetCallerSocket (PROVIDER *provider, SOCKET ProviderSock)

---

Function Documentation

void AcquireSocketLock

(

SOCK_INFO *

SockInfo

)

Definition at line 133 of file sockinfo.cpp.

{
    EnterCriticalSection( &SockInfo->SockCritSec );
}

void CloseAndFreeSocketInfo	(	PROVIDER *	provider,
		BOOL	processDetach
	)

Definition at line 309 of file sockinfo.cpp.

{
    LIST_ENTRY   *entry = NULL;
    SOCK_INFO    *si = NULL;
    struct linger linger;
    int           Error, 
                  ret;

    ASSERT( provider );

    linger.l_onoff  = 1;
    linger.l_linger = 0;

    // Walk the list of sockets
    while ( !IsListEmpty( &provider->SocketList ) )
    {
        entry = RemoveHeadList( &provider->SocketList );

        ASSERT( entry );

        si = CONTAINING_RECORD( entry, SOCK_INFO, Link );

        if ( ( !processDetach ) || 
             ( provider->NextProvider.ProtocolChain.ChainLen == BASE_PROTOCOL ) )
        {

            ASSERT( provider->NextProcTable.lpWSPSetSockOpt );

            // Set the abortive linger
            ret = provider->NextProcTable.lpWSPSetSockOpt(
                    si->ProviderSocket,
                    SOL_SOCKET,
                    SO_LINGER,
                    (char *) &linger,
                    sizeof(linger),
                    &Error
                    );
            if ( SOCKET_ERROR != ret )
            {
                ASSERT( provider->NextProcTable.lpWSPCloseSocket );

                // Close the lower provider socket
                ret = provider->NextProcTable.lpWSPCloseSocket(
                        si->ProviderSocket,
                        &Error
                        );
                if ( SOCKET_ERROR == ret )
                {
                    dbgprint("WSPCloseSocket() on handle %d failed: %d", si->ProviderSocket, Error);
                }
#ifdef DEBUG
                else
                {
                    dbgprint("Successfully closed socket %d", si->ProviderSocket);
                }
#endif
            }
#ifdef DEBUG
            else
            {
                dbgprint("WSPSetSockOpt(SO_LINGER) failed: %d", Error);
            }
#endif
        }

        ASSERT( gMainUpCallTable.lpWPUCloseSocketHandle );

        // Close the layered handle
        gMainUpCallTable.lpWPUCloseSocketHandle(
                si->LayeredSocket, 
               &Error
                );

        // Free the context structure
        FreeSockInfo( si );
    }

    return;
}

SOCK_INFO* CreateSockInfo	(	PROVIDER *	Provider,
		SOCKET	ProviderSocket,
		SOCK_INFO *	Inherit,
		BOOL	Insert,
		int *	lpErrno
	)

Definition at line 171 of file sockinfo.cpp.

{
    SOCK_INFO   *NewInfo = NULL;

    NewInfo = (SOCK_INFO *) LspAlloc(
            sizeof( SOCK_INFO ),
            lpErrno
            );
    if ( NULL == NewInfo )
    {
        dbgprint("HeapAlloc() failed: %d", GetLastError());
       *lpErrno = WSAENOBUFS;
        goto cleanup;
    }

    //
    // Initialize the fields to default values
    //
    NewInfo->ProviderSocket     = ProviderSocket;
    NewInfo->bClosing           = FALSE;
    NewInfo->dwOutstandingAsync = 0;
    NewInfo->BytesRecv          = 0;
    NewInfo->BytesSent          = 0;
    NewInfo->Provider           = Provider;
    NewInfo->hWnd               = (Inherit ? Inherit->hWnd : 0);
    NewInfo->uMsg               = (Inherit ? Inherit->uMsg : 0);

    __try
    {
        InitializeCriticalSection( &NewInfo->SockCritSec );
    }
    __except( EXCEPTION_EXECUTE_HANDLER )
    {
        *lpErrno = WSAENOBUFS;
        goto cleanup;
    }

    if ( TRUE == Insert )
        InsertSocketInfo(Provider, NewInfo);

    return NewInfo;

cleanup:

    if ( NULL != NewInfo )
        LspFree( NewInfo );

    return NULL;
}

void DerefSocketContext	(	SOCK_INFO *	context,
		int *	lpErrno
	)

Definition at line 83 of file sockinfo.cpp.

{
    LONG    newval;
    int     ret = NO_ERROR;

    EnterCriticalSection(&gCriticalSection);

    // Decrement the ref count and see if someone closed this socket (from another thread)
    newval = InterlockedDecrement(&context->RefCount);
    if ( ( 0 == newval ) && 
         ( 0 == context->dwOutstandingAsync ) && 
         ( TRUE == context->bClosing ) 
       )
    {
        ASSERT( gMainUpCallTable.lpWPUCloseSocketHandle );

        // Socket has been closed so close the handle and free associated resources
        ret = gMainUpCallTable.lpWPUCloseSocketHandle(context->LayeredSocket, lpErrno);
        if ( SOCKET_ERROR == ret )
        {
            dbgprint("DerefSocketContext: WPUCloseSocketHandle() failed: %d", *lpErrno);
        }

        context->LayeredSocket = INVALID_SOCKET;

        RemoveSocketInfo(context->Provider, context);

        dbgprint("Closing socket %d Bytes Sent [%lu] Bytes Recv [%lu]", 
                context->LayeredSocket, context->BytesSent, context->BytesRecv);

        FreeSockInfo( context );
        context = NULL;
    }

    LeaveCriticalSection( &gCriticalSection );
}

SOCK_INFO* FindAndRefSocketContext	(	SOCKET	s,
		int *	lpErrno
	)

Definition at line 40 of file sockinfo.cpp.

{
    SOCK_INFO *SocketContext = NULL;
    int        ret;

    EnterCriticalSection(&gCriticalSection);

    ASSERT( gMainUpCallTable.lpWPUQuerySocketHandleContext );

    ret = gMainUpCallTable.lpWPUQuerySocketHandleContext(
            s,
            (PDWORD_PTR) &SocketContext,
            lpErrno
            );
    if ( SOCKET_ERROR == ret )
    {
        dbgprint("FindAndRefSocketContext: WPUQuerySocketHandleContext failed: %d", *lpErrno);
        *lpErrno = WSAENOTSOCK;
    }
    else
    {
        InterlockedIncrement(&SocketContext->RefCount);
    }

    LeaveCriticalSection(&gCriticalSection);

    return SocketContext;
}

SOCK_INFO * FindSockInfoFromProviderSocket	(	PROVIDER *	provider,
		SOCKET	socket
	)

Definition at line 401 of file sockinfo.cpp.

{
    LIST_ENTRY *lptr = NULL;
    SOCK_INFO  *si = NULL;

    ASSERT( provider );

    if ( IsListEmpty( &provider->SocketList ) )
    {
        dbgprint( "FindSockInfoFromProviderSocket: Empty SOCK_INFO list!" );
        goto cleanup;
    }

    for(lptr = provider->SocketList.Flink ; lptr != &provider->SocketList ; lptr = lptr->Flink )
    {
        si = CONTAINING_RECORD( lptr, SOCK_INFO, Link );

        if ( socket == si->ProviderSocket )
            break;

        si = NULL;
    }

cleanup:

    return si;
}

void FreeSockInfo

(

SOCK_INFO *

info

)

Definition at line 234 of file sockinfo.cpp.

{
    DeleteCriticalSection( &info->SockCritSec );
    LspFree( info );

    return;
}

SOCK_INFO* GetCallerSocket	(	PROVIDER *	provider,
		SOCKET	ProviderSock
	)

Definition at line 444 of file sockinfo.cpp.

{
    SOCK_INFO *si = NULL;

    EnterCriticalSection( &gCriticalSection );

    if ( NULL != provider )
    {
        // If we know the provider just search its list of sockets
        si = FindSockInfoFromProviderSocket( provider, ProviderSock );
    }
    else
    {
        // Don't know the provider so we must search all of them
        for(INT i=0; i < gLayerCount ;i++)
        {
            si = FindSockInfoFromProviderSocket( &gBaseInfo[ i ], ProviderSock );
            if ( NULL != si )
                break;
        }
    }

    LeaveCriticalSection( &gCriticalSection );

    return si;
}

void InsertSocketInfo	(	PROVIDER *	provider,
		SOCK_INFO *	sock
	)

Definition at line 253 of file sockinfo.cpp.

{
    if ( ( NULL == provider ) || ( NULL == sock ) )
    {
        dbgprint("InsertSocketInfo: PROVIDER or SOCK_INFO == NULL!");
        goto cleanup;
    }

    EnterCriticalSection( &provider->ProviderCritSec );

    InsertTailList( &provider->SocketList, &sock->Link );

    LeaveCriticalSection( &provider->ProviderCritSec );

    SetEvent( gAddContextEvent );

cleanup:

    return;
}

void ReleaseSocketLock

(

SOCK_INFO *

SockInfo

)

Definition at line 147 of file sockinfo.cpp.

{
    LeaveCriticalSection( &SockInfo->SockCritSec );
}

void RemoveSocketInfo	(	PROVIDER *	provider,
		SOCK_INFO *	si
	)

Definition at line 286 of file sockinfo.cpp.

{
    EnterCriticalSection( &provider->ProviderCritSec );

    RemoveEntryList( &si->Link );

    LeaveCriticalSection( &provider->ProviderCritSec );

    return;
}