async.c File Reference

#include <ws2_32.h>

Include dependency graph for async.c:

Go to the source code of this file.

Macros
#define	WsAsyncLock()   EnterCriticalSection(&WsAsyncCritSect)
#define	WsAsyncUnlock()   LeaveCriticalSection(&WsAsyncCritSect)

Functions
VOID WSAAPI	WsAsyncGlobalInitialize (VOID)
VOID WSAAPI	WsAsyncGlobalTerminate (VOID)
SIZE_T WSAAPI	BytesInHostent (PHOSTENT Hostent)
SIZE_T WSAAPI	BytesInServent (PSERVENT Servent)
SIZE_T WSAAPI	BytesInProtoent (PPROTOENT Protoent)
SIZE_T WSAAPI	CopyHostentToBuffer (IN PCHAR Buffer, IN INT BufferLength, IN PHOSTENT Hostent)
SIZE_T WSAAPI	CopyServentToBuffer (IN PCHAR Buffer, IN INT BufferLength, IN PSERVENT Servent)
SIZE_T WSAAPI	CopyProtoentToBuffer (IN PCHAR Buffer, IN INT BufferLength, IN PPROTOENT Protoent)
PWSASYNCBLOCK WSAAPI	WsAsyncAllocateBlock (IN SIZE_T ExtraLength)
BOOL WINAPI	WsAsyncThreadBlockingHook (VOID)
VOID WSAAPI	WsAsyncFreeBlock (IN PWSASYNCBLOCK AsyncBlock)
VOID WSAAPI	WsAsyncGetServ (IN HANDLE TaskHandle, IN DWORD Operation, IN HWND hWnd, IN UINT wMsg, IN CHAR FAR *ByWhat, IN CHAR FAR *Protocol, IN CHAR FAR *Buffer, IN INT BufferLength)
VOID WSAAPI	WsAsyncGetProto (IN HANDLE TaskHandle, IN DWORD Operation, IN HWND hWnd, IN UINT wMsg, IN CHAR FAR *ByWhat, IN CHAR FAR *Buffer, IN INT BufferLength)
VOID WSAAPI	WsAsyncGetHost (IN HANDLE TaskHandle, IN DWORD Operation, IN HWND hWnd, IN UINT wMsg, IN CHAR FAR *ByWhat, IN INT Length, IN INT Type, IN CHAR FAR *Buffer, IN INT BufferLength)
DWORD WINAPI	WsAsyncThread (IN PVOID ThreadContext)
BOOL WSAAPI	WsAsyncCheckAndInitThread (VOID)
VOID WSAAPI	WsAsyncTerminateThread (VOID)
VOID WSAAPI	WsAsyncQueueRequest (IN PWSASYNCBLOCK AsyncBlock)
INT WSAAPI	WsAsyncCancelRequest (IN HANDLE TaskHandle)

Variables
BOOLEAN	WsAsyncThreadInitialized
LONG	WsAsyncTaskHandle
PLIST_ENTRY	WsAsyncQueue
CRITICAL_SECTION	WsAsyncCritSect
HANDLE	WsAsyncEvent
HANDLE	WsAsyncCurrentTaskHandle
HANDLE	WsAsyncCancelledTaskHandle
HINSTANCE	WsAsyncDllHandle

Macro Definition Documentation

WsAsyncLock

#define WsAsyncLock

(

)

EnterCriticalSection(&WsAsyncCritSect)

Definition at line 24 of file async.c.

WsAsyncUnlock

#define WsAsyncUnlock

(

)

LeaveCriticalSection(&WsAsyncCritSect)

Definition at line 25 of file async.c.

Function Documentation

BytesInHostent()

SIZE_T WSAAPI BytesInHostent

(

PHOSTENT

Hostent

)

Definition at line 48 of file async.c.

{
    SIZE_T Bytes;
    INT i;
 
    /* Start with the static stuff */
    Bytes = sizeof(HOSTENT) + strlen(Hostent->h_name) + sizeof(CHAR);
 
    /* Add 2 pointers for the list-terminators */
    Bytes += 2 * sizeof(ULONG_PTR);
 
    /* Now loop for the aliases */
    for (i = 0; Hostent->h_aliases[i]; i++)
    {
        /* Add the alias size, plus the space its pointer takes */
        Bytes += strlen(Hostent->h_aliases[i]) + sizeof(CHAR) + sizeof(ULONG_PTR);
    }
 
    /* Now loop for the hostnames  */
    for (i = 0; Hostent->h_addr_list[i]; i++)
    {
        /* Add the alias size, plus the space its pointer takes */
        Bytes += Hostent->h_length + sizeof(ULONG_PTR);
    }
 
    /* Align to 8 bytes */
    return (Bytes + 7) & ~7;
}

Referenced by CopyHostentToBuffer().

BytesInProtoent()

SIZE_T WSAAPI BytesInProtoent

(

PPROTOENT

Protoent

)

Definition at line 105 of file async.c.

{
    SIZE_T Bytes;
    INT i;
 
    /* Start with the static stuff */
    Bytes = sizeof(SERVENT) + strlen(Protoent->p_name) + sizeof(CHAR);
 
    /* Add 1 pointers for the list terminator */
    Bytes += sizeof(ULONG_PTR);
 
    /* Now loop for the aliases */
    for (i = 0; Protoent->p_aliases[i]; i++)
    {
        /* Add the alias size, plus the space its pointer takes */
        Bytes += strlen(Protoent->p_aliases[i]) + sizeof(CHAR) + sizeof(ULONG_PTR);
    }
 
    /* return */
    return Bytes;
}

Referenced by CopyProtoentToBuffer().

BytesInServent()

SIZE_T WSAAPI BytesInServent

(

PSERVENT

Servent

)

Definition at line 79 of file async.c.

{
    SIZE_T Bytes;
    INT i;
 
    /* Start with the static stuff */
    Bytes = sizeof(SERVENT) +
            strlen(Servent->s_name) + sizeof(CHAR) +
            strlen(Servent->s_proto) + sizeof(CHAR);
 
    /* Add 1 pointers for the list terminator */
    Bytes += sizeof(ULONG_PTR);
 
    /* Now loop for the aliases */
    for (i = 0; Servent->s_aliases[i]; i++)
    {
        /* Add the alias size, plus the space its pointer takes */
        Bytes += strlen(Servent->s_aliases[i]) + sizeof(CHAR) + sizeof(ULONG_PTR);
    }
 
    /* return */
    return Bytes;
}

Referenced by CopyServentToBuffer().

CopyHostentToBuffer()

SIZE_T WSAAPI CopyHostentToBuffer	(	IN PCHAR	Buffer,
		IN INT	BufferLength,
		IN PHOSTENT	Hostent
	)

Definition at line 129 of file async.c.

{
    SIZE_T BufferSize, CurrentSize, NameSize;
    PCHAR p = Buffer;
    DWORD Aliases = 0, Names = 0;
    DWORD i;
    PHOSTENT ReturnedHostent = (PHOSTENT)Buffer;
 
    /* Determine the buffer size required */
    BufferSize = BytesInHostent(Hostent);
 
    /* Check which size to use */
    if ((DWORD)BufferLength > BufferSize)
    {
        /* Zero the buffer */
        RtlZeroMemory(Buffer, BufferSize);
    }
    else
    {
        /* Zero the buffer */
        RtlZeroMemory(Buffer, BufferLength);
    }
 
    /* Start with the raw Hostent */
    CurrentSize = sizeof(HOSTENT);
 
    /* Return the size needed now */
    if (CurrentSize > (DWORD)BufferLength) return BufferSize;
 
    /* Copy the Hostent and initialize it */
    CopyMemory(p, Hostent, sizeof(HOSTENT));
    p = Buffer + CurrentSize;
    ReturnedHostent->h_name = NULL;
    ReturnedHostent->h_aliases = NULL;
    ReturnedHostent->h_addr_list = NULL;
 
    /* Find out how many aliases there are */
    while (Hostent->h_aliases[Aliases])
    {
        /* Increase the alias count */
        Aliases++;
    }
 
    /* Add the aliases to the size, and validate it */
    CurrentSize += (Aliases + 1) * sizeof(ULONG_PTR);
    if (CurrentSize > (DWORD)BufferLength)
    {
        /* Clear the aliases and return */
        Hostent->h_aliases = NULL;
        return BufferSize;
    }
 
    /* Write the aliases, update the pointer */
    ReturnedHostent->h_aliases = (PCHAR*)p;
    p = Buffer + CurrentSize;
 
    /* Find out how many names there are */
    while (Hostent->h_addr_list[Names])
    {
        /* Increase the alias count */
        Names++;
    }
 
    /* Add the names to the size, and validate it */
    CurrentSize += (Names + 1) * sizeof(ULONG_PTR);
    if (CurrentSize > (DWORD)BufferLength)
    {
        /* Clear the aliases and return */
        Hostent->h_addr_list = NULL;
        return BufferSize;
    }
 
    /* Write the names, update the pointer */
    ReturnedHostent->h_addr_list = (PCHAR*)p;
    p = Buffer + CurrentSize;
 
    /* Now add the names */
    for (i = 0; i < Names; i++)
    {
        /* Update size and validate */
        CurrentSize += Hostent->h_length;
        if (CurrentSize > (DWORD)BufferLength) return BufferSize;
 
        /* Write pointer and copy */
        ReturnedHostent->h_addr_list[i] = p;
        CopyMemory(p, Hostent->h_addr_list[i], Hostent->h_length);
 
        /* Update pointer */
        p = Buffer + CurrentSize;
    }
 
    /* Finalize the list */
    ReturnedHostent->h_addr_list[i] = NULL;
 
    /* Add the service name to the size, and validate it */
    NameSize = strlen(Hostent->h_name) + sizeof(CHAR);
    CurrentSize += NameSize;
    if (CurrentSize > (DWORD)BufferLength) return BufferSize;
 
    /* Write the service name and update the pointer */
    ReturnedHostent->h_name = p;
    CopyMemory(p, Hostent->h_name, NameSize);
    p = Buffer + CurrentSize;
 
    /* Now add the aliases */
    for (i = 0; i < Aliases; i++)
    {
        /* Update size and validate */
        NameSize = strlen(Hostent->h_aliases[i]) + sizeof(CHAR);
        CurrentSize += NameSize;
        if (CurrentSize > (DWORD)BufferLength) return BufferSize;
 
        /* Write pointer and copy */
        ReturnedHostent->h_aliases[i] = p;
        CopyMemory(p, Hostent->h_aliases[i], NameSize);
 
        /* Update pointer */
        p = Buffer + CurrentSize;
    }
 
    /* Finalize the list and return */
    ReturnedHostent->h_aliases[i] = NULL;
    return BufferSize;
}

Referenced by WsAsyncGetHost().

CopyProtoentToBuffer()

SIZE_T WSAAPI CopyProtoentToBuffer	(	IN PCHAR	Buffer,
		IN INT	BufferLength,
		IN PPROTOENT	Protoent
	)

Definition at line 349 of file async.c.

{
    SIZE_T BufferSize, CurrentSize, NameSize;
    PCHAR p = Buffer;
    DWORD Aliases = 0;
    DWORD i;
    PPROTOENT ReturnedProtoent = (PPROTOENT)Buffer;
 
    /* Determine the buffer size required */
    BufferSize = BytesInProtoent(Protoent);
 
    /* Check which size to use */
    if ((DWORD)BufferLength > BufferSize)
    {
        /* Zero the buffer */
        ZeroMemory(Buffer, BufferSize);
    }
    else
    {
        /* Zero the buffer */
        ZeroMemory(Buffer, BufferLength);
    }
 
    /* Start with the raw servent */
    CurrentSize = sizeof(PROTOENT);
 
    /* Return the size needed now */
    if (CurrentSize > (DWORD)BufferLength) return BufferSize;
 
    /* Copy the servent and initialize it */
    CopyMemory(p, Protoent, sizeof(PROTOENT));
    p = Buffer + CurrentSize;
    ReturnedProtoent->p_name = NULL;
    ReturnedProtoent->p_aliases = NULL;
 
    /* Find out how many aliases there are */
    while (Protoent->p_aliases[Aliases])
    {
        /* Increase the alias count */
        Aliases++;
    }
 
    /* Add the aliases to the size, and validate it */
    CurrentSize += (Aliases + 1) * sizeof(ULONG_PTR);
    if (CurrentSize > (DWORD)BufferLength)
    {
        /* Clear the aliases and return */
        Protoent->p_aliases = NULL;
        return BufferSize;
    }
 
    /* Write the aliases, update the pointer */
    ReturnedProtoent->p_aliases = (PCHAR*)p;
    p = Buffer + CurrentSize;
 
    /* Add the service name to the size, and validate it */
    NameSize = strlen(Protoent->p_name) + sizeof(CHAR);
    CurrentSize += NameSize;
    if (CurrentSize > (DWORD)BufferLength) return BufferSize;
 
    /* Write the service name and update the pointer */
    ReturnedProtoent->p_name = p;
    CopyMemory(p, Protoent->p_name, NameSize);
    p = Buffer + CurrentSize;
 
    /* Now add the aliases */
    for (i = 0; i < Aliases; i++)
    {
        /* Update size and validate */
        NameSize = strlen(Protoent->p_aliases[i]) + sizeof(CHAR);
        CurrentSize += NameSize;
        if (CurrentSize > (DWORD)BufferLength) return BufferSize;
 
        /* Write pointer and copy */
        ReturnedProtoent->p_aliases[i] = p;
        CopyMemory(p, Protoent->p_aliases[i], NameSize);
 
        /* Update pointer */
        p = Buffer + CurrentSize;
    }
 
    /* Finalize the list and return */
    ReturnedProtoent->p_aliases[i] = NULL;
    return BufferSize;
}

Referenced by WsAsyncGetProto().

CopyServentToBuffer()

SIZE_T WSAAPI CopyServentToBuffer	(	IN PCHAR	Buffer,
		IN INT	BufferLength,
		IN PSERVENT	Servent
	)

Definition at line 258 of file async.c.

{
    SIZE_T BufferSize, CurrentSize, NameSize;
    PCHAR p = Buffer;
    DWORD Aliases = 0;
    DWORD i;
    PSERVENT ReturnedServent = (PSERVENT)Buffer;
 
    /* Determine the buffer size required */
    BufferSize = BytesInServent(Servent);
 
    /* Check which size to use */
    if ((DWORD)BufferLength > BufferSize)
    {
        /* Zero the buffer */
        ZeroMemory(Buffer, BufferSize);
    }
    else
    {
        /* Zero the buffer */
        ZeroMemory(Buffer, BufferLength);
    }
 
    /* Start with the raw servent */
    CurrentSize = sizeof(SERVENT);
 
    /* Return the size needed now */
    if (CurrentSize > (DWORD)BufferLength) return BufferSize;
 
    /* Copy the servent and initialize it */
    CopyMemory(p, Servent, sizeof(SERVENT));
    p = Buffer + CurrentSize;
    ReturnedServent->s_name = NULL;
    ReturnedServent->s_aliases = NULL;
    ReturnedServent->s_proto = NULL;
 
    /* Find out how many aliases there are */
    while (Servent->s_aliases[Aliases])
    {
        /* Increase the alias count */
        Aliases++;
    }
 
    /* Add the aliases to the size, and validate it */
    CurrentSize += (Aliases + 1) * sizeof(ULONG_PTR);
    if (CurrentSize > (DWORD)BufferLength)
    {
        /* Clear the aliases and return */
        Servent->s_aliases = NULL;
        return BufferSize;
    }
 
    /* Write the aliases, update the pointer */
    ReturnedServent->s_aliases = (PCHAR*)p;
    p = Buffer + CurrentSize;
 
    /* Add the service name to the size, and validate it */
    NameSize = strlen(Servent->s_name) + sizeof(CHAR);
    CurrentSize += NameSize;
    if (CurrentSize > (DWORD)BufferLength) return BufferSize;
 
    /* Write the service name and update the pointer */
    ReturnedServent->s_name = p;
    CopyMemory(p, Servent->s_name, NameSize);
    p = Buffer + CurrentSize;
 
    /* Now add the aliases */
    for (i = 0; i < Aliases; i++)
    {
        /* Update size and validate */
        NameSize = strlen(Servent->s_aliases[i]) + sizeof(CHAR);
        CurrentSize += NameSize;
        if (CurrentSize > (DWORD)BufferLength) return BufferSize;
 
        /* Write pointer and copy */
        ReturnedServent->s_aliases[i] = p;
        CopyMemory(p, Servent->s_aliases[i], NameSize);
 
        /* Update pointer */
        p = Buffer + CurrentSize;
    }
 
    /* Finalize the list and return */
    ReturnedServent->s_aliases[i] = NULL;
    return BufferSize;
}

Referenced by WsAsyncGetServ().

WsAsyncAllocateBlock()

PWSASYNCBLOCK WSAAPI WsAsyncAllocateBlock

(

IN SIZE_T

ExtraLength

)

Definition at line 439 of file async.c.

{
    PWSASYNCBLOCK AsyncBlock;
 
    /* Add the size of the block */
    ExtraLength += sizeof(WSASYNCBLOCK);
 
    /* Allocate it */
    AsyncBlock = HeapAlloc(WsSockHeap, 0, ExtraLength);
 
    /* Get a handle to it */
    AsyncBlock->TaskHandle = UlongToPtr(InterlockedIncrement(&WsAsyncTaskHandle));
 
    /* Return it */
    return AsyncBlock;
}

Referenced by WSAAsyncGetHostByAddr(), WSAAsyncGetHostByName(), WSAAsyncGetProtoByName(), WSAAsyncGetProtoByNumber(), WSAAsyncGetServByName(), WSAAsyncGetServByPort(), and WsAsyncTerminateThread().

WsAsyncCancelRequest()

INT WSAAPI WsAsyncCancelRequest

(

IN HANDLE

TaskHandle

)

Definition at line 936 of file async.c.

{
    PLIST_ENTRY Entry;
    PWSASYNCBLOCK AsyncBlock;
 
    /* Make sure we're initialized */
    if (!WsAsyncThreadInitialized) return WSAEINVAL;
 
    /* Acquire the lock */
    WsAsyncLock();
 
    /* Check if we're cancelling the current task */
    if (TaskHandle == WsAsyncCurrentTaskHandle)
    {
        /* Mark us as cancelled, the async thread will see this later */
        WsAsyncCancelledTaskHandle = TaskHandle;
 
        /* Release lock and return */
        WsAsyncUnlock();
        return NO_ERROR;
    }
 
    /* Loop the queue */
    Entry = WsAsyncQueue->Flink;
    while (Entry != WsAsyncQueue)
    {
        /* Get the Async Block */
        AsyncBlock = CONTAINING_RECORD(Entry, WSASYNCBLOCK, AsyncQueue);
 
        /* Check if this is the one */
        if (TaskHandle == AsyncBlock->TaskHandle)
        {
            /* It is, remove it */
            RemoveEntryList(Entry);
 
            /* Release the lock, free the block, and return */
            WsAsyncUnlock();
            WsAsyncFreeBlock(AsyncBlock);
            return NO_ERROR;
        }
 
        /* Move to the next entry */
        Entry = Entry->Flink;
    }
 
    /* Nothing found, fail */
    WsAsyncUnlock();
    return WSAEINVAL;
}

Referenced by WSACancelAsyncRequest().

WsAsyncCheckAndInitThread()

BOOL WSAAPI WsAsyncCheckAndInitThread

(

VOID

)

Definition at line 832 of file async.c.

{
    HANDLE ThreadHandle;
    DWORD Tid;
    PWSASYNCCONTEXT Context = NULL;
    WSADATA WsaData;
 
    /* Make sure we're not initialized */
    if (WsAsyncThreadInitialized) return TRUE;
 
    /* Acquire the lock */
    WsAsyncLock();
 
    /* Make sure we're not initialized */
    if (!WsAsyncThreadInitialized)
    {
        /* Initialize Thread Context */
        Context = HeapAlloc(WsSockHeap, 0, sizeof(*Context));
        if (!Context)
            goto Exit;
 
        /* Initialize the Queue and event */
        WsAsyncQueue = &Context->AsyncQueue;
        InitializeListHead(WsAsyncQueue);
        Context->AsyncEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
        WsAsyncEvent = Context->AsyncEvent;
 
        /* Prevent us from ever being killed while running */
        if (WSAStartup(MAKEWORD(2,2), &WsaData) != ERROR_SUCCESS)
            goto Fail;
 
        /* Create the thread */
        ThreadHandle = CreateThread(NULL,
                                    0,
                                    WsAsyncThread,
                                    Context,
                                    0,
                                    &Tid);
        if (ThreadHandle == NULL)
        {
            /* Cleanup and fail */
            WSACleanup();
            goto Fail;
        }
 
        /* Close the handle and set init */
        CloseHandle(ThreadHandle);
        WsAsyncThreadInitialized = TRUE;
    }
 
Exit:
    /* Release the lock */
    WsAsyncUnlock();
    return WsAsyncThreadInitialized;
 
Fail:
    /* Close the event, free the Context */
    if (Context->AsyncEvent)
        CloseHandle(Context->AsyncEvent);
    HeapFree(WsSockHeap, 0, Context);
 
    /* Bail out */
    goto Exit;
}

Referenced by WSAAsyncGetHostByAddr(), WSAAsyncGetHostByName(), WSAAsyncGetProtoByName(), WSAAsyncGetProtoByNumber(), WSAAsyncGetServByName(), and WSAAsyncGetServByPort().

WsAsyncFreeBlock()

VOID WSAAPI WsAsyncFreeBlock

(

IN PWSASYNCBLOCK

AsyncBlock

)

Definition at line 473 of file async.c.

{
    /* Free it */
    HeapFree(WsSockHeap, 0, AsyncBlock);
}

Referenced by WsAsyncCancelRequest(), and WsAsyncThread().

WsAsyncGetHost()

VOID WSAAPI WsAsyncGetHost	(	IN HANDLE	TaskHandle,
		IN DWORD	Operation,
		IN HWND	hWnd,
		IN UINT	wMsg,
		IN CHAR FAR *	ByWhat,
		IN INT	Length,
		IN INT	Type,
		IN CHAR FAR *	Buffer,
		IN INT	BufferLength
	)

Definition at line 628 of file async.c.

{
    PHOSTENT Hostent;
    SIZE_T BufferSize = 0;
    LPARAM lParam;
    INT ErrorCode = 0;
 
    /* Check the operation */
    if (Operation == WsAsyncGetHostByAddr)
    {
        /* Call the API */
        Hostent = gethostbyaddr(ByWhat, Length, Type);
    }
    else
    {
        /* Call the API */
        Hostent = gethostbyname(ByWhat);
    }
 
    /* Make sure we got one */
    if (!Hostent) ErrorCode = GetLastError();
 
    /* Acquire the lock */
    WsAsyncLock();
 
    /* Check if this task got cancelled */
    if (TaskHandle == WsAsyncCancelledTaskHandle)
    {
        /* Return */
        WsAsyncUnlock();
        return;
    }
 
    /* If we got a Servent back, copy it */
    if (Hostent)
    {
        /* Copy it into the buffer */
        BufferSize = CopyHostentToBuffer(Buffer, BufferLength, Hostent);
 
        /* Check if we had enough space */
        if (BufferSize > (DWORD)BufferLength)
        {
            /* Not enough */
            ErrorCode = WSAENOBUFS;
        }
        else
        {
            /* Perfect */
            ErrorCode = NO_ERROR;
        }
    }
 
    /* Not processing anymore */
    WsAsyncCurrentTaskHandle = NULL;
 
    /* Release the lock */
    WsAsyncUnlock();
 
    /* Make the messed-up lParam reply */
    lParam = WSAMAKEASYNCREPLY(BufferSize, ErrorCode);
 
    /* Sent it through the Upcall API */
    WPUPostMessage(hWnd, wMsg, (WPARAM)TaskHandle, lParam);
}

Referenced by WsAsyncThread().

WsAsyncGetProto()

VOID WSAAPI WsAsyncGetProto	(	IN HANDLE	TaskHandle,
		IN DWORD	Operation,
		IN HWND	hWnd,
		IN UINT	wMsg,
		IN CHAR FAR *	ByWhat,
		IN CHAR FAR *	Buffer,
		IN INT	BufferLength
	)

Definition at line 555 of file async.c.

{
    PPROTOENT Protoent;
    SIZE_T BufferSize = 0;
    LPARAM lParam;
    INT ErrorCode = 0;
 
    /* Check the operation */
    if (Operation == WsAsyncGetProtoByName)
    {
        /* Call the API */
        Protoent = getprotobyname(ByWhat);
    }
    else
    {
        /* Call the API */
        Protoent = getprotobynumber(PtrToUlong(ByWhat));
    }
 
    /* Make sure we got one */
    if (!Protoent) ErrorCode = GetLastError();
 
    /* Acquire the lock */
    WsAsyncLock();
 
    /* Check if this task got cancelled */
    if (TaskHandle == WsAsyncCancelledTaskHandle)
    {
        /* Return */
        WsAsyncUnlock();
        return;
    }
 
    /* If we got a Servent back, copy it */
    if (Protoent)
    {
        /* Copy it into the buffer */
        BufferSize = CopyProtoentToBuffer(Buffer, BufferLength, Protoent);
 
        /* Check if we had enough space */
        if (BufferSize > (DWORD)BufferLength)
        {
            /* Not enough */
            ErrorCode = WSAENOBUFS;
        }
        else
        {
            /* Perfect */
            ErrorCode = NO_ERROR;
        }
    }
 
    /* Not processing anymore */
    WsAsyncCurrentTaskHandle = NULL;
 
    /* Release the lock */
    WsAsyncUnlock();
 
    /* Make the messed-up lParam reply */
    lParam = WSAMAKEASYNCREPLY(BufferSize, ErrorCode);
 
    /* Sent it through the Upcall API */
    WPUPostMessage(hWnd, wMsg, (WPARAM)TaskHandle, lParam);
}

Referenced by WsAsyncThread().

WsAsyncGetServ()

VOID WSAAPI WsAsyncGetServ	(	IN HANDLE	TaskHandle,
		IN DWORD	Operation,
		IN HWND	hWnd,
		IN UINT	wMsg,
		IN CHAR FAR *	ByWhat,
		IN CHAR FAR *	Protocol,
		IN CHAR FAR *	Buffer,
		IN INT	BufferLength
	)

Definition at line 481 of file async.c.

{
    PSERVENT Servent;
    SIZE_T BufferSize = 0;
    LPARAM lParam;
    INT ErrorCode = 0;
 
    /* Check the operation */
    if (Operation == WsAsyncGetServByName)
    {
        /* Call the API */
        Servent = getservbyname(ByWhat, Protocol);
    }
    else
    {
        /* Call the API */
        Servent = getservbyport(PtrToUlong(ByWhat), Protocol);
    }
 
    /* Make sure we got one */
    if (!Servent) ErrorCode = GetLastError();
 
    /* Acquire the lock */
    WsAsyncLock();
 
    /* Check if this task got cancelled */
    if (TaskHandle == WsAsyncCancelledTaskHandle)
    {
        /* Return */
        WsAsyncUnlock();
        return;
    }
 
    /* If we got a Servent back, copy it */
    if (Servent)
    {
        /* Copy it into the buffer */
        BufferSize = CopyServentToBuffer(Buffer, BufferLength, Servent);
 
        /* Check if we had enough space */
        if (BufferSize > (DWORD)BufferLength)
        {
            /* Not enough */
            ErrorCode = WSAENOBUFS;
        }
        else
        {
            /* Perfect */
            ErrorCode = NO_ERROR;
        }
    }
 
    /* Not processing anymore */
    WsAsyncCurrentTaskHandle = NULL;
 
    /* Release the lock */
    WsAsyncUnlock();
 
    /* Make the messed-up lParam reply */
    lParam = WSAMAKEASYNCREPLY(BufferSize, ErrorCode);
 
    /* Sent it through the Upcall API */
    WPUPostMessage(hWnd, wMsg, (WPARAM)TaskHandle, lParam);
}

Referenced by WsAsyncThread().

WsAsyncGlobalInitialize()

VOID WSAAPI WsAsyncGlobalInitialize

(

VOID

)

Definition at line 31 of file async.c.

{
    /* Initialize the async lock */
    InitializeCriticalSection(&WsAsyncCritSect);
}

Referenced by DllMain().

WsAsyncGlobalTerminate()

VOID WSAAPI WsAsyncGlobalTerminate

(

VOID

)

Definition at line 39 of file async.c.

{
    /* Destroy the async lock */
    DeleteCriticalSection(&WsAsyncCritSect);
}

Referenced by DllMain().

WsAsyncQueueRequest()

VOID WSAAPI WsAsyncQueueRequest

(

IN PWSASYNCBLOCK

AsyncBlock

)

Definition at line 919 of file async.c.

{
    /* Get the lock */
    WsAsyncLock();
 
    /* Insert it into the queue */
    InsertTailList(WsAsyncQueue, &AsyncBlock->AsyncQueue);
 
    /* Wake up the thread */
    SetEvent(WsAsyncEvent);
 
    /* Release lock and return */
    WsAsyncUnlock();
}

Referenced by WSAAsyncGetHostByAddr(), WSAAsyncGetHostByName(), WSAAsyncGetProtoByName(), WSAAsyncGetProtoByNumber(), WSAAsyncGetServByName(), WSAAsyncGetServByPort(), and WsAsyncTerminateThread().

WsAsyncTerminateThread()

VOID WSAAPI WsAsyncTerminateThread

(

VOID

)

Definition at line 899 of file async.c.

{
    PWSASYNCBLOCK AsyncBlock;
 
    /* Make sure we're initialized */
    if (!WsAsyncThreadInitialized) return;
 
    /* Allocate a block */
    AsyncBlock = WsAsyncAllocateBlock(0);
 
    /* Initialize it for termination */
    AsyncBlock->Operation = WsAsyncTerminate;
 
    /* Queue the request and return */
    WsAsyncQueueRequest(AsyncBlock);
    WsAsyncThreadInitialized = FALSE;
}

Referenced by WSACleanup().

WsAsyncThread()

DWORD WINAPI WsAsyncThread

(

IN PVOID

ThreadContext

)

Definition at line 703 of file async.c.

{
    PWSASYNCCONTEXT Context = ThreadContext;
    PWSASYNCBLOCK AsyncBlock;
    PLIST_ENTRY Entry;
    HANDLE AsyncEvent = Context->AsyncEvent;
    PLIST_ENTRY ListHead = &Context->AsyncQueue;
 
    /* Set the blocking hook */
    WSASetBlockingHook((FARPROC)WsAsyncThreadBlockingHook);
 
    /* Loop */
    while (TRUE)
    {
        /* Wait for the event */
        WaitForSingleObject(AsyncEvent, INFINITE);
 
        /* Get the lock */
        WsAsyncLock();
 
        /* Process the queue */
        while (!IsListEmpty(ListHead))
        {
            /* Remove this entry and get the async block */
            Entry = RemoveHeadList(ListHead);
            AsyncBlock = CONTAINING_RECORD(Entry, WSASYNCBLOCK, AsyncQueue);
 
            /* Save the current task handle */
            WsAsyncCurrentTaskHandle = AsyncBlock->TaskHandle;
 
            /* Release the lock */
            WsAsyncUnlock();
 
            /* Check which operation to do */
            switch (AsyncBlock->Operation)
            {
                /* Get Host by Y */
                case WsAsyncGetHostByAddr: case WsAsyncGetHostByName:
 
                    /* Call the handler */
                    WsAsyncGetHost(AsyncBlock->TaskHandle,
                                   AsyncBlock->Operation,
                                   AsyncBlock->GetHost.hWnd,
                                   AsyncBlock->GetHost.wMsg,
                                   AsyncBlock->GetHost.ByWhat,
                                   AsyncBlock->GetHost.Length,
                                   AsyncBlock->GetHost.Type,
                                   AsyncBlock->GetHost.Buffer,
                                   AsyncBlock->GetHost.BufferLength);
                    break;
 
                /* Get Proto by Y */
                case WsAsyncGetProtoByNumber: case WsAsyncGetProtoByName:
 
                    /* Call the handler */
                    WsAsyncGetProto(AsyncBlock->TaskHandle,
                                    AsyncBlock->Operation,
                                    AsyncBlock->GetProto.hWnd,
                                    AsyncBlock->GetProto.wMsg,
                                    AsyncBlock->GetHost.ByWhat,
                                    AsyncBlock->GetProto.Buffer,
                                    AsyncBlock->GetProto.BufferLength);
                    break;
 
                /* Get Serv by Y */
                case WsAsyncGetServByPort: case WsAsyncGetServByName:
 
                    /* Call the handler */
                    WsAsyncGetServ(AsyncBlock->TaskHandle,
                                   AsyncBlock->Operation,
                                   AsyncBlock->GetServ.hWnd,
                                   AsyncBlock->GetServ.wMsg,
                                   AsyncBlock->GetServ.ByWhat,
                                   AsyncBlock->GetServ.Protocol,
                                   AsyncBlock->GetServ.Buffer,
                                   AsyncBlock->GetServ.BufferLength);
                    break;
 
                /* Termination */
                case WsAsyncTerminate:
 
                    /* Clean up the extra reference */
                    WSACleanup();
 
                    /* Free the context block */
                    WsAsyncFreeBlock(AsyncBlock);
 
                    /* Acquire the lock */
                    WsAsyncLock();
 
                    /* Loop the queue and flush it */
                    while (!IsListEmpty(ListHead))
                    {
                        Entry = RemoveHeadList(ListHead);
                        AsyncBlock = CONTAINING_RECORD(Entry,
                                                       WSASYNCBLOCK,
                                                       AsyncQueue);
                        WsAsyncFreeBlock(AsyncBlock);
                    }
 
                    /* Release lock */
                    WsAsyncUnlock();
 
                    /* Close the event, free the Context */
                    CloseHandle(AsyncEvent);
                    HeapFree(WsSockHeap, 0, Context);
 
                    /* Remove the extra DLL reference and kill us */
                    FreeLibraryAndExitThread(WsAsyncDllHandle, 0);
 
                default:
                    break;
            }
 
            /* Done processing */
            WsAsyncCurrentTaskHandle = NULL;
 
            /* Free this block, get lock and reloop */
            WsAsyncFreeBlock(AsyncBlock);
            WsAsyncLock();
        }
 
        /* Release the lock */
        WsAsyncUnlock();
    }
}

Referenced by WsAsyncCheckAndInitThread().

WsAsyncThreadBlockingHook()

BOOL WINAPI WsAsyncThreadBlockingHook

(

VOID

)

Definition at line 458 of file async.c.

{
    /* Check if this task is being cancelled */
    if (WsAsyncCurrentTaskHandle == WsAsyncCancelledTaskHandle)
    {
        /* Cancel the blocking call so we can get back */
        WSACancelBlockingCall();
    }
 
    /* Return to system */
    return FALSE;
}

Referenced by WsAsyncThread().

Variable Documentation

WsAsyncCancelledTaskHandle

HANDLE WsAsyncCancelledTaskHandle

Definition at line 21 of file async.c.

Referenced by WsAsyncCancelRequest(), WsAsyncGetHost(), WsAsyncGetProto(), WsAsyncGetServ(), and WsAsyncThreadBlockingHook().

WsAsyncCritSect

CRITICAL_SECTION WsAsyncCritSect

Definition at line 18 of file async.c.

Referenced by WsAsyncGlobalInitialize(), and WsAsyncGlobalTerminate().

WsAsyncCurrentTaskHandle

HANDLE WsAsyncCurrentTaskHandle

Definition at line 20 of file async.c.

Referenced by WsAsyncCancelRequest(), WsAsyncGetHost(), WsAsyncGetProto(), WsAsyncGetServ(), WsAsyncThread(), and WsAsyncThreadBlockingHook().

WsAsyncDllHandle

HINSTANCE WsAsyncDllHandle

Definition at line 22 of file async.c.

Referenced by WsAsyncThread().

WsAsyncEvent

HANDLE WsAsyncEvent

Definition at line 19 of file async.c.

Referenced by WsAsyncCheckAndInitThread(), and WsAsyncQueueRequest().

WsAsyncQueue

PLIST_ENTRY WsAsyncQueue

Definition at line 17 of file async.c.

Referenced by WsAsyncCancelRequest(), WsAsyncCheckAndInitThread(), and WsAsyncQueueRequest().

WsAsyncTaskHandle

LONG WsAsyncTaskHandle

Definition at line 16 of file async.c.

Referenced by WsAsyncAllocateBlock().

WsAsyncThreadInitialized

BOOLEAN WsAsyncThreadInitialized

Definition at line 15 of file async.c.

Referenced by WSACleanup(), WsAsyncCancelRequest(), WsAsyncCheckAndInitThread(), and WsAsyncTerminateThread().