dthread.c File Reference

#include <ws2_32.h>

Include dependency graph for dthread.c:

Go to the source code of this file.

Functions
DWORD WSAAPI	WsThreadDefaultBlockingHook (VOID)
BOOL WSAAPI	WsThreadBlockingCallback (IN DWORD_PTR Context)
FARPROC WSAAPI	WsThreadSetBlockingHook (IN PWSTHREAD Thread, IN FARPROC BlockingHook)
DWORD WSAAPI	WsThreadUnhookBlockingHook (IN PWSTHREAD Thread)
DWORD WSAAPI	WsThreadCancelBlockingCall (IN PWSTHREAD Thread)
PWSPROTO_BUFFER WSAAPI	WsThreadGetProtoBuffer (IN PWSTHREAD Thread)
PWSTHREAD WSAAPI	WsThreadAllocate (VOID)
DWORD WSAAPI	WsThreadStartup (VOID)
VOID WSAAPI	WsThreadCleanup (VOID)
DWORD WSAAPI	WsThreadInitialize (IN PWSTHREAD Thread, IN PWSPROCESS Process)
VOID WSAAPI	WsThreadDelete (IN PWSTHREAD Thread)
VOID WSAAPI	WsThreadDestroyCurrentThread (VOID)
DWORD WSAAPI	WsThreadCreate (IN PWSPROCESS Process, IN PWSTHREAD *CurrentThread)
DWORD WSAAPI	WsThreadGetCurrentThread (IN PWSPROCESS Process, IN PWSTHREAD *Thread)
LPWSATHREADID WSAAPI	WsThreadGetThreadId (IN PWSPROCESS Process)
PHOSTENT WSAAPI	WsThreadBlobToHostent (IN PWSTHREAD Thread, IN LPBLOB Blob)
PSERVENT WSAAPI	WsThreadBlobToServent (IN PWSTHREAD Thread, IN LPBLOB Blob)

Function Documentation

WsThreadAllocate()

PWSTHREAD WSAAPI WsThreadAllocate

(

VOID

)

Definition at line 135 of file dthread.c.

{
    PWSTHREAD Thread;
 
    /* Allocate the object */
    Thread = HeapAlloc(WsSockHeap, HEAP_ZERO_MEMORY, sizeof(*Thread));
    if (Thread)
    {
        /* Set non-zero data */
        Thread->BlockingHook = (FARPROC)WsThreadDefaultBlockingHook;
    }
 
    /* Return it */
    return Thread;
}

Referenced by WsThreadCreate().

WsThreadBlobToHostent()

PHOSTENT WSAAPI WsThreadBlobToHostent	(	IN PWSTHREAD	Thread,
		IN LPBLOB	Blob
	)

Definition at line 316 of file dthread.c.

{
    /* Check if our buffer is too small */
    if (Thread->HostentSize < Blob->cbSize)
    {
        /* Delete the current buffer and allocate a new one */
        HeapFree(WsSockHeap, 0, Thread->Hostent);
        Thread->Hostent = HeapAlloc(WsSockHeap, 0, Blob->cbSize);
 
        /* Set the new size */
        Thread->HostentSize = Blob->cbSize;
    }
 
    /* Do we have a buffer? */
    if (Thread->Hostent)
    {
        /* Copy the data inside */
        RtlMoveMemory(Thread->Hostent, Blob->pBlobData, Blob->cbSize);
    }
    else
    {
        /* No buffer space! */
        Thread->HostentSize = 0;
        SetLastError(WSA_NOT_ENOUGH_MEMORY);
    }
 
    /* Return the buffer */
    return (PHOSTENT)Thread->Hostent;
}

Referenced by gethostbyaddr(), and gethostbyname().

WsThreadBlobToServent()

PSERVENT WSAAPI WsThreadBlobToServent	(	IN PWSTHREAD	Thread,
		IN LPBLOB	Blob
	)

Definition at line 349 of file dthread.c.

{
    /* Check if our buffer is too small */
    if (Thread->ServentSize < Blob->cbSize)
    {
        /* Delete the current buffer and allocate a new one */
        HeapFree(WsSockHeap, 0, Thread->Servent);
        Thread->Servent = HeapAlloc(WsSockHeap, 0, Blob->cbSize);
 
        /* Set the new size */
        Thread->ServentSize = Blob->cbSize;
    }
 
    /* Do we have a buffer? */
    if (Thread->Servent)
    {
        /* Copy the data inside */
        RtlMoveMemory(Thread->Servent, Blob->pBlobData, Blob->cbSize);
    }
    else
    {
        /* No buffer space! */
        Thread->ServentSize = 0;
        SetLastError(WSA_NOT_ENOUGH_MEMORY);
    }
 
    /* Return the buffer */
    return (PSERVENT)Thread->Servent;
}

Referenced by getservbyname(), and getservbyport().

WsThreadBlockingCallback()

BOOL WSAAPI WsThreadBlockingCallback

(

IN DWORD_PTR

Context

)

Definition at line 39 of file dthread.c.

{
    PWSTHREAD Thread = TlsGetValue(TlsIndex);
 
    /* Set thread as blocking, set cancel callback and the clear cancel flag */
    Thread->Blocking = TRUE;
    Thread->CancelBlockingCall = (LPWSPCANCELBLOCKINGCALL)Context;
    Thread->Cancelled = FALSE;
 
    /* Call the blocking hook */
    while (Thread->BlockingHook());
 
    /* We're not blocking anymore */
    Thread->Blocking = FALSE;
 
    /* Return whether or not we were cancelled */
    return !Thread->Cancelled;
}

Referenced by WsThreadSetBlockingHook().

WsThreadCancelBlockingCall()

DWORD WSAAPI WsThreadCancelBlockingCall

(

IN PWSTHREAD

Thread

)

Definition at line 96 of file dthread.c.

{
    INT ErrorCode, ReturnValue;
 
    /* Make sure that the Thread is really in a blocking call */
    if (!Thread->Blocking) return WSAEINVAL;
 
    /* Make sure we haven't already been cancelled */
    if (!Thread->Cancelled)
    {
        /* Call the cancel procedure */
        ReturnValue = Thread->CancelBlockingCall(&ErrorCode);
        if (ReturnValue != ERROR_SUCCESS) return ErrorCode;
 
        /* Set us as cancelled */
        Thread->Cancelled = TRUE;
    }
 
    /* Success */
    return ERROR_SUCCESS;
}

Referenced by WSACancelBlockingCall().

WsThreadCleanup()

VOID WSAAPI WsThreadCleanup

(

VOID

)

Definition at line 170 of file dthread.c.

{
}

Referenced by DllMain().

WsThreadCreate()

DWORD WSAAPI WsThreadCreate	(	IN PWSPROCESS	Process,
		IN PWSTHREAD *	CurrentThread
	)

Definition at line 244 of file dthread.c.

{
    PWSTHREAD Thread = NULL;
    INT ErrorCode = WSASYSCALLFAILURE;
 
    /* Make sure we have TLS */
    if (TlsIndex != TLS_OUT_OF_INDEXES)
    {
        /* Allocate the thread */
        if ((Thread = WsThreadAllocate()))
        {
            /* Initialize it */
            if (WsThreadInitialize(Thread, Process) == ERROR_SUCCESS)
            {
                /* Set the TLS */
                if (TlsSetValue(TlsIndex, Thread))
                {
                    /* Return it and success */
                    *CurrentThread = Thread;
                    ErrorCode = ERROR_SUCCESS;
                }
            }
 
            /* Check for any failures */
            if (ErrorCode != ERROR_SUCCESS) WsThreadDelete(Thread);
        }
    }
 
    /* Return */
    return ErrorCode;
}

Referenced by WsThreadGetCurrentThread().

WsThreadDefaultBlockingHook()

DWORD WSAAPI WsThreadDefaultBlockingHook

(

VOID

)

Definition at line 17 of file dthread.c.

{
    MSG Message;
    BOOL GotMessage = FALSE;
 
    /* Get the message */
    GotMessage = PeekMessage(&Message, NULL, 0, 0, PM_REMOVE);
 
    /* Check if we got one */
    if (GotMessage)
    {
        /* Process it */
        TranslateMessage(&Message);
        DispatchMessage(&Message);
    }
 
    /* return */
    return GotMessage;
}

Referenced by WsThreadAllocate(), WsThreadSetBlockingHook(), and WsThreadUnhookBlockingHook().

WsThreadDelete()

VOID WSAAPI WsThreadDelete

(

IN PWSTHREAD

Thread

)

Definition at line 202 of file dthread.c.

{
    /* Remove the blocking hook */
    Thread->BlockingHook = NULL;
 
    /* Free our buffers */
    if (Thread->Hostent) HeapFree(WsSockHeap, 0, Thread->Hostent);
    if (Thread->Servent) HeapFree(WsSockHeap, 0, Thread->Servent);
    if (Thread->ProtocolInfo) HeapFree(WsSockHeap, 0, Thread->ProtocolInfo);
 
    /* Clear the TLS */
    TlsSetValue(TlsIndex, NULL);
 
    /* Close the WAH Handle */
    WahCloseThread(Thread->AsyncHelper, &Thread->WahThreadId);
 
    /* Unlink the process and free us */
    Thread->Process = NULL;
    HeapFree(WsSockHeap, 0, Thread);
}

Referenced by WsThreadCreate(), and WsThreadDestroyCurrentThread().

WsThreadDestroyCurrentThread()

VOID WSAAPI WsThreadDestroyCurrentThread

(

VOID

)

Definition at line 225 of file dthread.c.

{
    PWSTHREAD Thread;
 
    /* Make sure we have TLS */
    if (TlsIndex != TLS_OUT_OF_INDEXES)
    {
        /* Get the thread */
        if ((Thread = TlsGetValue(TlsIndex)))
        {
            /* Delete it */
            WsThreadDelete(Thread);
            TlsSetValue(TlsIndex, 0);
        }
    }
}

Referenced by DllMain().

WsThreadGetCurrentThread()

DWORD WSAAPI WsThreadGetCurrentThread	(	IN PWSPROCESS	Process,
		IN PWSTHREAD *	Thread
	)

Definition at line 279 of file dthread.c.

{
    /* Get the thread */
    if ((*Thread = TlsGetValue(TlsIndex)))
    {
        /* Success */
        return ERROR_SUCCESS;
    }
    else
    {
        /* We failed, initialize it */
        return WsThreadCreate(Process, Thread);
    }
}

Referenced by WsApiProlog().

WsThreadGetProtoBuffer()

PWSPROTO_BUFFER WSAAPI WsThreadGetProtoBuffer

(

IN PWSTHREAD

Thread

)

Definition at line 120 of file dthread.c.

{
    /* See if it already exists */
    if (!Thread->ProtocolInfo)
    {
        /* We don't have a buffer; allocate it */
        Thread->ProtocolInfo = HeapAlloc(WsSockHeap, 0, sizeof(WSPROTO_BUFFER));
    }
 
    /* Return it */
    return Thread->ProtocolInfo;
}

Referenced by getprotobyname(), and getprotobynumber().

WsThreadGetThreadId()

LPWSATHREADID WSAAPI WsThreadGetThreadId

(

IN PWSPROCESS

Process

)

Definition at line 297 of file dthread.c.

{
    PWSTHREAD Thread;
 
    /* Get the thread */
    if ((Thread = TlsGetValue(TlsIndex)))
    {
        /* Return the ID */
        return &Thread->WahThreadId;
    }
    else
    {
        /* Not a valid thread */
        return NULL;
    }
}

Referenced by WsQuickPrologTid().

WsThreadInitialize()

DWORD WSAAPI WsThreadInitialize	(	IN PWSTHREAD	Thread,
		IN PWSPROCESS	Process
	)

Definition at line 176 of file dthread.c.

{
    INT ErrorCode = WSASYSCALLFAILURE;
 
    /* Set the process */
    Thread->Process = Process;
 
    /* Get the helper device */
    if ((WsProcGetAsyncHelper(Process, &Thread->AsyncHelper)) == ERROR_SUCCESS)
    {
        /* Initialize a WAH Thread ID */
        if ((WahOpenCurrentThread(Thread->AsyncHelper,
                                  &Thread->WahThreadId)) == ERROR_SUCCESS)
        {
            /* Success */
            ErrorCode = ERROR_SUCCESS;
        }
    }
 
    /* Return */
    return ErrorCode;
}

Referenced by WsThreadCreate().

WsThreadSetBlockingHook()

FARPROC WSAAPI WsThreadSetBlockingHook	(	IN PWSTHREAD	Thread,
		IN FARPROC	BlockingHook
	)

Definition at line 60 of file dthread.c.

{
    FARPROC OldHook = Thread->BlockingHook;
 
    /* Check if we're resetting to our default hook */
    if (BlockingHook == (FARPROC)WsThreadDefaultBlockingHook)
    {
        /* Clear out the blocking callback */
        Thread->BlockingCallback = NULL;
    }
    else
    {
        /* Set the blocking callback */
        Thread->BlockingCallback = WsThreadBlockingCallback;
    }
 
    /* Set the new blocking hook and return the previous */
    Thread->BlockingHook = BlockingHook;
    return OldHook;
}

Referenced by WSASetBlockingHook().

WsThreadStartup()

DWORD WSAAPI WsThreadStartup

(

VOID

)

Definition at line 153 of file dthread.c.

{
    INT ErrorCode = WSASYSCALLFAILURE;
 
    /* Check if we have a valid TLS */
    if (TlsIndex != TLS_OUT_OF_INDEXES)
    {
        /* TLS was already OK */
        ErrorCode = ERROR_SUCCESS;
    }
 
    /* Return */
    return ErrorCode;
}

Referenced by WSAStartup().

WsThreadUnhookBlockingHook()

DWORD WSAAPI WsThreadUnhookBlockingHook

(

IN PWSTHREAD

Thread

)

Definition at line 84 of file dthread.c.

{
    /* Reset the hook to the default, and remove the callback */
    Thread->BlockingHook = (FARPROC)WsThreadDefaultBlockingHook;
    Thread->BlockingCallback = NULL;
 
    /* Return success */
    return ERROR_SUCCESS;
}

Referenced by WSAUnhookBlockingHook().