ws2_32p.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_WSASYNCBLOCK
struct	_WSASYNCCONTEXT
struct	_WSPROTO_BUFFER
struct	_TPROVIDER
struct	_TCATALOG_ENTRY
struct	_TCATALOG
struct	_NSPROVIDER
struct	_NSQUERY_PROVIDER
struct	_NSCATALOG_ENTRY
struct	_NSCATALOG
struct	_NSQUERY
struct	_WSPROCESS
struct	_WSTHREAD
struct	_WSSOCKET
struct	_ENUM_CONTEXT
struct	_NSPROVIDER_ENUM_CONTEXT
struct	_PROTOCOL_ENUM_CONTEXT
struct	_PROVIDER_ENUM_CONTEXT
struct	_WS_BUFFER

Macros
#define	WINSOCK_ROOT   "System\\CurrentControlSet\\Services\\WinSock2\\Parameters"
#define	MAXALIASES   35
#define	TlsIndex   GlobalTlsIndex

Typedefs
typedef enum _WSASYNCOPS	WSASYNCOPS
typedef struct _WSASYNCBLOCK	WSASYNCBLOCK
typedef struct _WSASYNCBLOCK *	PWSASYNCBLOCK
typedef struct _WSASYNCCONTEXT	WSASYNCCONTEXT
typedef struct _WSASYNCCONTEXT *	PWSASYNCCONTEXT
typedef struct _WSPROTO_BUFFER	WSPROTO_BUFFER
typedef struct _WSPROTO_BUFFER *	PWSPROTO_BUFFER
typedef struct _TPROVIDER	TPROVIDER
typedef struct _TPROVIDER *	PTPROVIDER
typedef struct _TCATALOG_ENTRY	TCATALOG_ENTRY
typedef struct _TCATALOG_ENTRY *	PTCATALOG_ENTRY
typedef struct _TCATALOG	TCATALOG
typedef struct _TCATALOG *	PTCATALOG
typedef struct _NSPROVIDER	NSPROVIDER
typedef struct _NSPROVIDER *	PNS_PROVIDER
typedef struct _NSQUERY_PROVIDER	NSQUERY_PROVIDER
typedef struct _NSQUERY_PROVIDER *	PNSQUERY_PROVIDER
typedef struct _NSCATALOG_ENTRY	NSCATALOG_ENTRY
typedef struct _NSCATALOG_ENTRY *	PNSCATALOG_ENTRY
typedef struct _NSCATALOG	NSCATALOG
typedef struct _NSCATALOG *	PNSCATALOG
typedef struct _NSQUERY	NSQUERY
typedef struct _NSQUERY *	PNSQUERY
typedef struct _WSPROCESS	WSPROCESS
typedef struct _WSPROCESS *	PWSPROCESS
typedef struct _WSTHREAD	WSTHREAD
typedef struct _WSTHREAD *	PWSTHREAD
typedef struct _WSSOCKET	WSSOCKET
typedef struct _WSSOCKET *	PWSSOCKET
typedef struct _ENUM_CONTEXT	ENUM_CONTEXT
typedef struct _ENUM_CONTEXT *	PENUM_CONTEXT
typedef struct _NSPROVIDER_ENUM_CONTEXT	NSPROVIDER_ENUM_CONTEXT
typedef struct _NSPROVIDER_ENUM_CONTEXT *	PNSPROVIDER_ENUM_CONTEXT
typedef struct _PROTOCOL_ENUM_CONTEXT	PROTOCOL_ENUM_CONTEXT
typedef struct _PROTOCOL_ENUM_CONTEXT *	PPROTOCOL_ENUM_CONTEXT
typedef struct _PROVIDER_ENUM_CONTEXT	PROVIDER_ENUM_CONTEXT
typedef struct _PROVIDER_ENUM_CONTEXT *	PPROVIDER_ENUM_CONTEXT
typedef struct _WS_BUFFER	WS_BUFFER
typedef struct _WS_BUFFER *	PWS_BUFFER
typedef BOOL(WINAPI *	PNSCATALOG_ENUMERATE_PROC) (IN PVOID Context, IN PNSCATALOG_ENTRY Entry)
typedef BOOL(WINAPI *	PTCATALOG_ENUMERATE_PROC) (IN PVOID Context, IN PTCATALOG_ENTRY Entry)
typedef BOOL(WINAPI *	PWS_SOCK_POST_ROUTINE) (IN HWND hWnd, IN UINT wMsg, IN WPARAM wParam, IN LPARAM lParam)

Enumerations
enum	_WSASYNCOPS {   WsAsyncGetHostByAddr , WsAsyncGetHostByName , WsAsyncGetProtoByName , WsAsyncGetProtoByNumber ,   WsAsyncGetServByName , WsAsyncGetServByPort , WsAsyncTerminate }

Functions
LPSTR WSAAPI	AnsiDupFromUnicode (IN LPCWSTR UnicodeString)
LPWSTR WSAAPI	UnicodeDupFromAnsi (IN LPCSTR AnsiString)
VOID WSAAPI	WsRasInitializeAutodial (VOID)
VOID WSAAPI	WsRasUninitializeAutodial (VOID)
BOOL WSAAPI	WSAttemptAutodialName (IN CONST LPWSAQUERYSETW lpqsRestrictions)
BOOL WSAAPI	WSAttemptAutodialAddr (IN CONST SOCKADDR FAR *Name, IN INT NameLength)
VOID WSAAPI	WSNoteSuccessfulHostentLookup (IN CONST CHAR FAR *Name, IN CONST ULONG Address)
INT WSAAPI	MapUnicodeProtocolInfoToAnsi (IN LPWSAPROTOCOL_INFOW UnicodeInfo, OUT LPWSAPROTOCOL_INFOA AnsiInfo)
INT WSAAPI	MapAnsiQuerySetToUnicode (IN LPWSAQUERYSETA AnsiSet, IN OUT PSIZE_T SetSize, OUT LPWSAQUERYSETW UnicodeSet)
INT WSAAPI	MapUnicodeQuerySetToAnsi (IN LPWSAQUERYSETW UnicodeSet, IN OUT PSIZE_T SetSize, OUT LPWSAQUERYSETA AnsiSet)
INT WSAAPI	CopyQuerySetW (IN LPWSAQUERYSETW UnicodeSet, OUT LPWSAQUERYSETW *UnicodeCopy)
INT WSAAPI	WsSlowProlog (VOID)
INT WSAAPI	WsSlowPrologTid (OUT LPWSATHREADID *ThreadId)
PWSSOCKET WSAAPI	WsSockGetSocket (IN SOCKET Handle)
INT WSAAPI	WsApiProlog (OUT PWSPROCESS *Process, OUT PWSTHREAD *Thread)
HKEY WSAAPI	WsOpenRegistryRoot (VOID)
VOID WSAAPI	WsCreateStartupSynchronization (VOID)
VOID WSAAPI	WsDestroyStartupSynchronization (VOID)
INT WSAAPI	WsSetupCatalogProtection (IN HKEY CatalogKey, IN HANDLE CatalogEvent, OUT LPDWORD UniqueId)
BOOL WSAAPI	WsCheckCatalogState (IN HANDLE Event)
PNSCATALOG WSAAPI	WsNcAllocate (VOID)
VOID WSAAPI	WsNcDelete (IN PNSCATALOG Catalog)
INT WSAAPI	WsNcInitializeFromRegistry (IN PNSCATALOG Catalog, IN HKEY ParentKey, IN HANDLE CatalogEvent)
INT WSAAPI	WsNcRefreshFromRegistry (IN PNSCATALOG Catalog, IN HANDLE CatalogEvent)
VOID WSAAPI	WsNcUpdateNamespaceList (IN PNSCATALOG Catalog, IN PLIST_ENTRY List)
BOOL WSAAPI	WsNcMatchProtocols (IN DWORD NameSpace, IN LONG AddressFamily, IN LPWSAQUERYSETW QuerySet)
INT WSAAPI	WsNcLoadProvider (IN PNSCATALOG Catalog, IN PNSCATALOG_ENTRY CatalogEntry)
INT WSAAPI	WsNcGetCatalogFromProviderId (IN PNSCATALOG Catalog, IN LPGUID ProviderId, OUT PNSCATALOG_ENTRY *CatalogEntry)
VOID WSAAPI	WsNcEnumerateCatalogItems (IN PNSCATALOG Catalog, IN PNSCATALOG_ENUMERATE_PROC Callback, IN PVOID Context)
INT WSAAPI	WsNcGetServiceClassInfo (IN PNSCATALOG Catalog, IN OUT LPDWORD BugSize, IN OUT LPWSASERVICECLASSINFOW lpServiceClassInfo)
PNSCATALOG_ENTRY WSAAPI	WsNcEntryAllocate (VOID)
INT WSAAPI	WsNcEntryInitializeFromRegistry (IN PNSCATALOG_ENTRY CatalogEntry, IN HKEY ParentKey, IN ULONG UniqueId)
VOID WSAAPI	WsNcEntryDereference (IN PNSCATALOG_ENTRY CatalogEntry)
VOID WSAAPI	WsNcEntrySetProvider (IN PNSCATALOG_ENTRY Entry, IN PNS_PROVIDER Provider)
BOOL WSAAPI	WsNqAddProvider (IN PNSQUERY NsQuery, IN PNS_PROVIDER Provider)
PNSQUERY WSAAPI	WsNqAllocate (VOID)
BOOL WSAAPI	WsNqBeginEnumerationProc (PVOID Context, PNSCATALOG_ENTRY CatalogEntry)
VOID WSAAPI	WsNqDelete (IN PNSQUERY NsQuery)
DWORD WSAAPI	WsNqInitialize (IN PNSQUERY NsQuery)
DWORD WSAAPI	WsNqLookupServiceBegin (IN PNSQUERY NsQuery, IN LPWSAQUERYSETW QuerySet, IN DWORD ControlFlags, IN PNSCATALOG Catalog)
DWORD WSAAPI	WsNqLookupServiceEnd (IN PNSQUERY NsQuery)
DWORD WSAAPI	WsNqLookupServiceNext (PNSQUERY NsQuery, DWORD, PDWORD, OUT LPWSAQUERYSETW QuerySet)
PNSQUERY_PROVIDER WSAAPI	WsNqNextProvider (PNSQUERY NsQuery, IN PNSQUERY_PROVIDER Provider)
PNSQUERY_PROVIDER WSAAPI	WsNqPreviousProvider (IN PNSQUERY Query, IN PNSQUERY_PROVIDER Provider)
VOID WSAAPI	WsNqDereference (IN PNSQUERY Query)
BOOL WSAAPI	WsNqValidateAndReference (IN PNSQUERY Query)
DWORD WSAAPI	WsNqProvLookupServiceNext (IN PNSQUERY_PROVIDER QueryProvider, DWORD, PDWORD, LPWSAQUERYSETW QuerySet)
DWORD WSAAPI	WsNqProvLookupServiceEnd (IN PNSQUERY_PROVIDER QueryProvider)
DWORD WSAAPI	WsNqProvInitialize (IN PNSQUERY_PROVIDER QueryProvider, IN PNS_PROVIDER Provider)
PNSQUERY_PROVIDER WSAAPI	WsNqProvAllocate (VOID)
VOID WSAAPI	WsNqProvDelete (IN PNSQUERY_PROVIDER QueryProvider)
DWORD WSAAPI	WsNqProvLookupServiceBegin (IN PNSQUERY_PROVIDER QueryProvider, IN LPWSAQUERYSETW QuerySet, IN LPWSASERVICECLASSINFOW ServiceClassInfo, IN DWORD)
VOID WSAAPI	WsNpDelete (IN PNS_PROVIDER Provider)
DWORD WSAAPI	WsNpLookupServiceBegin (IN PNS_PROVIDER Provider, IN LPWSAQUERYSETW Restrictions, struct _WSAServiceClassInfoW *, IN DWORD ControlFlags, OUT PHANDLE LookupHandle)
DWORD WSAAPI	WsNpNSPCleanup (IN PNS_PROVIDER Provider)
DWORD WSAAPI	WsNpLookupServiceEnd (IN PNS_PROVIDER Provider, IN HANDLE LookupHandle)
DWORD WSAAPI	WsNpInitialize (IN PNS_PROVIDER Provider, IN LPWSTR DllPath, IN LPGUID ProviderGuid)
PNS_PROVIDER WSAAPI	WsNpAllocate (VOID)
VOID WSAAPI	WsNpDereference (IN PNS_PROVIDER Provider)
DWORD WSAAPI	WsNpLookupServiceNext (IN PNS_PROVIDER Provider, IN HANDLE LookupHandle, IN DWORD ControlFlags, OUT PDWORD BufferLength, OUT LPWSAQUERYSETW Results)
VOID WSAAPI	WsTpDelete (IN PTPROVIDER Provider)
DWORD WSAAPI	WsTpWSPCleanup (IN PTPROVIDER Provider, int *)
PTPROVIDER WSAAPI	WsTpAllocate (VOID)
DWORD WSAAPI	WsTpInitialize (IN PTPROVIDER Provider, IN LPSTR DllName, LPWSAPROTOCOL_INFOW ProtocolInfo)
VOID WSAAPI	WsTpDereference (IN PTPROVIDER Provider)
VOID WSAAPI	WsThreadDelete (IN PWSTHREAD Thread)
VOID WSAAPI	WsThreadDestroyCurrentThread (VOID)
DWORD WSAAPI	WsThreadCreate (IN PWSPROCESS Process, IN PWSTHREAD *Thread)
DWORD WSAAPI	WsThreadGetCurrentThread (IN PWSPROCESS Process, IN PWSTHREAD *Thread)
LPWSATHREADID WSAAPI	WsThreadGetThreadId (IN PWSPROCESS Process)
DWORD WSAAPI	WsThreadStartup (VOID)
VOID WSAAPI	WsThreadCleanup (VOID)
DWORD WSAAPI	WsThreadCancelBlockingCall (IN PWSTHREAD Thread)
DWORD WSAAPI	WsThreadUnhookBlockingHook (IN PWSTHREAD Thread)
FARPROC WSAAPI	WsThreadSetBlockingHook (IN PWSTHREAD Thread, IN FARPROC BlockingHook)
PHOSTENT WSAAPI	WsThreadBlobToHostent (IN PWSTHREAD Thread, IN LPBLOB Blob)
PSERVENT WSAAPI	WsThreadBlobToServent (IN PWSTHREAD Thread, IN LPBLOB Blob)
PWSPROTO_BUFFER WSAAPI	WsThreadGetProtoBuffer (IN PWSTHREAD Thread)
PWSTHREAD WSAAPI	WsThreadAllocate (VOID)
DWORD WSAAPI	WsThreadDefaultBlockingHook (VOID)
DWORD WSAAPI	WsThreadInitialize (IN PWSTHREAD Thread, IN PWSPROCESS Process)
DWORD WSAAPI	WsTcFindIfsProviderForSocket (IN PTCATALOG TCatalog, SOCKET Socket)
DWORD WSAAPI	WsTcEntryInitializeFromRegistry (IN PTCATALOG_ENTRY CatalogEntry, IN HKEY, unsigned long)
DWORD WSAAPI	WsTcGetEntryFromAf (IN PTCATALOG TCatalog, IN INT AddressFamily, IN PTCATALOG_ENTRY *CatalogEntry)
PTCATALOG_ENTRY WSAAPI	WsTcEntryAllocate (VOID)
VOID WSAAPI	WsTcEntrySetProvider (IN PTCATALOG_ENTRY CatalogEntry, IN PTPROVIDER Provider)
DWORD WSAAPI	WsTcRefreshFromRegistry (IN PTCATALOG TCatalog, PVOID)
BOOL WSAAPI	WsTcOpen (IN PTCATALOG TCatalog, IN HKEY)
PTPROVIDER WSAAPI	WsTcFindProvider (IN PTCATALOG TCatalog, IN LPGUID ProviderId)
VOID WSAAPI	WsTcEnumerateCatalogItems (IN PTCATALOG Catalog, IN PTCATALOG_ENUMERATE_PROC Callback, IN PVOID Context)
VOID WSAAPI	WsTcEntryDereference (IN PTCATALOG_ENTRY CatalogEntry)
PTCATALOG WSAAPI	WsTcAllocate (VOID)
VOID WSAAPI	WsTcDelete (IN PTCATALOG Catalog)
DWORD WSAAPI	WsTcGetEntryFromTriplet (IN PTCATALOG TCatalog, IN INT AddressFamily, IN INT SocketType, IN INT Protocol, IN DWORD StartId, IN PTCATALOG_ENTRY *CatalogEntry)
VOID WSAAPI	WsTcUpdateProtocolList (IN PTCATALOG TCatalog, PLIST_ENTRY ProtocolList)
VOID WSAAPI	WsTcEntryDelete (IN PTCATALOG_ENTRY CatalogEntry)
DWORD WSAAPI	WsTcGetEntryFromCatalogEntryId (IN PTCATALOG TCatalog, IN DWORD CatalogEntryId, IN PTCATALOG_ENTRY *CatalogEntry)
DWORD WSAAPI	WsTcLoadProvider (IN PTCATALOG TCatalog, IN PTCATALOG_ENTRY CatalogEntry)
DWORD WSAAPI	WsTcInitializeFromRegistry (IN PTCATALOG TCatalog, HKEY, PVOID)
INT WSAAPI	WsSockStartup (VOID)
VOID WSAAPI	WsSockCleanup (VOID)
BOOL WSAAPI	WsSockDeleteSockets (IN LPVOID Context, IN PWAH_HANDLE Handle)
VOID WSAAPI	WsSockDereference (IN PWSSOCKET Socket)
PWSSOCKET WSAAPI	WsSockAllocate (VOID)
INT WSAAPI	WsSockInitialize (IN PWSSOCKET Socket, IN PTCATALOG_ENTRY CatalogEntry)
INT WSAAPI	WsSockAssociateHandle (IN PWSSOCKET Socket, IN SOCKET Handle, IN BOOLEAN IsProvider)
INT WSAAPI	WsSockDisassociateHandle (IN PWSSOCKET Socket)
INT WSAAPI	WsSockAddApiReference (IN SOCKET Handle)
PTCATALOG WSAAPI	WsProcGetTCatalog (IN PWSPROCESS Process)
BOOL WSAAPI	WsProcDetachSocket (IN PWSPROCESS Process, IN PWAH_HANDLE Handle)
INT WSAAPI	WsProcGetAsyncHelper (IN PWSPROCESS Process, OUT PHANDLE Handle)
VOID WSAAPI	WsProcDelete (IN PWSPROCESS Process)
INT WSAAPI	WsProcStartup (VOID)
PNSCATALOG WSAAPI	WsProcGetNsCatalog (IN PWSPROCESS Process)
VOID WSAAPI	WsProcSetVersion (IN PWSPROCESS Process, IN WORD VersionRequested)
VOID WSAAPI	WsAsyncQueueRequest (IN PWSASYNCBLOCK AsyncBlock)
BOOL WSAAPI	WsAsyncCheckAndInitThread (VOID)
INT WSAAPI	WsAsyncCancelRequest (IN HANDLE TaskHandle)
PWSASYNCBLOCK WSAAPI	WsAsyncAllocateBlock (IN SIZE_T ExtraLength)
VOID WSAAPI	WsAsyncTerminateThread (VOID)
VOID WSAAPI	WsAsyncGlobalTerminate (VOID)
VOID WSAAPI	WsAsyncGlobalInitialize (VOID)
FORCEINLINE PWSPROCESS	WsGetProcess (VOID)
FORCEINLINE DWORD	WsQuickProlog (VOID)
FORCEINLINE DWORD	WsQuickPrologTid (LPWSATHREADID *Tid)

Variables
HINSTANCE	WsDllHandle
HANDLE	WsSockHeap
PWAH_HANDLE_TABLE	WsSockHandleTable
PWSPROCESS	CurrentWsProcess
DWORD	GlobalTlsIndex
BOOLEAN	WsAsyncThreadInitialized
PWS_SOCK_POST_ROUTINE	WsSockPostRoutine

Macro Definition Documentation

MAXALIASES

#define MAXALIASES   35

Definition at line 11 of file ws2_32p.h.

TlsIndex

#define TlsIndex   GlobalTlsIndex

Definition at line 277 of file ws2_32p.h.

WINSOCK_ROOT

#define WINSOCK_ROOT   "System\\CurrentControlSet\\Services\\WinSock2\\Parameters"

Definition at line 10 of file ws2_32p.h.

Typedef Documentation

ENUM_CONTEXT

typedef struct _ENUM_CONTEXT ENUM_CONTEXT

NSCATALOG

typedef struct _NSCATALOG NSCATALOG

NSCATALOG_ENTRY

typedef struct _NSCATALOG_ENTRY NSCATALOG_ENTRY

NSPROVIDER

typedef struct _NSPROVIDER NSPROVIDER

NSPROVIDER_ENUM_CONTEXT

typedef struct _NSPROVIDER_ENUM_CONTEXT NSPROVIDER_ENUM_CONTEXT

NSQUERY

typedef struct _NSQUERY NSQUERY

NSQUERY_PROVIDER

typedef struct _NSQUERY_PROVIDER NSQUERY_PROVIDER

PENUM_CONTEXT

typedef struct _ENUM_CONTEXT * PENUM_CONTEXT

PNS_PROVIDER

typedef struct _NSPROVIDER * PNS_PROVIDER

PNSCATALOG

typedef struct _NSCATALOG * PNSCATALOG

PNSCATALOG_ENTRY

typedef struct _NSCATALOG_ENTRY * PNSCATALOG_ENTRY

PNSCATALOG_ENUMERATE_PROC

typedef BOOL(WINAPI * PNSCATALOG_ENUMERATE_PROC) (IN PVOID Context, IN PNSCATALOG_ENTRY Entry)

Definition at line 252 of file ws2_32p.h.

PNSPROVIDER_ENUM_CONTEXT

typedef struct _NSPROVIDER_ENUM_CONTEXT * PNSPROVIDER_ENUM_CONTEXT

PNSQUERY

typedef struct _NSQUERY * PNSQUERY

PNSQUERY_PROVIDER

typedef struct _NSQUERY_PROVIDER * PNSQUERY_PROVIDER

PPROTOCOL_ENUM_CONTEXT

typedef struct _PROTOCOL_ENUM_CONTEXT * PPROTOCOL_ENUM_CONTEXT

PPROVIDER_ENUM_CONTEXT

typedef struct _PROVIDER_ENUM_CONTEXT * PPROVIDER_ENUM_CONTEXT

PROTOCOL_ENUM_CONTEXT

typedef struct _PROTOCOL_ENUM_CONTEXT PROTOCOL_ENUM_CONTEXT

PROVIDER_ENUM_CONTEXT

typedef struct _PROVIDER_ENUM_CONTEXT PROVIDER_ENUM_CONTEXT

PTCATALOG

typedef struct _TCATALOG * PTCATALOG

PTCATALOG_ENTRY

typedef struct _TCATALOG_ENTRY * PTCATALOG_ENTRY

PTCATALOG_ENUMERATE_PROC

typedef BOOL(WINAPI * PTCATALOG_ENUMERATE_PROC) (IN PVOID Context, IN PTCATALOG_ENTRY Entry)

Definition at line 258 of file ws2_32p.h.

PTPROVIDER

typedef struct _TPROVIDER * PTPROVIDER

PWS_BUFFER

typedef struct _WS_BUFFER * PWS_BUFFER

PWS_SOCK_POST_ROUTINE

typedef BOOL(WINAPI * PWS_SOCK_POST_ROUTINE) (IN HWND hWnd, IN UINT wMsg, IN WPARAM wParam, IN LPARAM lParam)

Definition at line 264 of file ws2_32p.h.

PWSASYNCBLOCK

typedef struct _WSASYNCBLOCK * PWSASYNCBLOCK

PWSASYNCCONTEXT

typedef struct _WSASYNCCONTEXT * PWSASYNCCONTEXT

PWSPROCESS

typedef struct _WSPROCESS * PWSPROCESS

PWSPROTO_BUFFER

typedef struct _WSPROTO_BUFFER * PWSPROTO_BUFFER

PWSSOCKET

typedef struct _WSSOCKET * PWSSOCKET

PWSTHREAD

typedef struct _WSTHREAD * PWSTHREAD

TCATALOG

typedef struct _TCATALOG TCATALOG

TCATALOG_ENTRY

typedef struct _TCATALOG_ENTRY TCATALOG_ENTRY

TPROVIDER

typedef struct _TPROVIDER TPROVIDER

WS_BUFFER

typedef struct _WS_BUFFER WS_BUFFER

WSASYNCBLOCK

typedef struct _WSASYNCBLOCK WSASYNCBLOCK

WSASYNCCONTEXT

typedef struct _WSASYNCCONTEXT WSASYNCCONTEXT

WSASYNCOPS

typedef enum _WSASYNCOPS WSASYNCOPS

WSPROCESS

typedef struct _WSPROCESS WSPROCESS

WSPROTO_BUFFER

typedef struct _WSPROTO_BUFFER WSPROTO_BUFFER

WSSOCKET

typedef struct _WSSOCKET WSSOCKET

WSTHREAD

typedef struct _WSTHREAD WSTHREAD

Enumeration Type Documentation

_WSASYNCOPS

enum _WSASYNCOPS

Enumerator
WsAsyncGetHostByAddr
WsAsyncGetHostByName
WsAsyncGetProtoByName
WsAsyncGetProtoByNumber
WsAsyncGetServByName
WsAsyncGetServByPort
WsAsyncTerminate

Definition at line 13 of file ws2_32p.h.

{
    WsAsyncGetHostByAddr,
    WsAsyncGetHostByName,
    WsAsyncGetProtoByName,
    WsAsyncGetProtoByNumber,
    WsAsyncGetServByName,
    WsAsyncGetServByPort,
    WsAsyncTerminate,
} WSASYNCOPS;

Function Documentation

AnsiDupFromUnicode()

LPSTR WSAAPI AnsiDupFromUnicode

(

IN LPCWSTR

UnicodeString

)

Definition at line 20 of file qshelpr.c.

{
    INT Length = 0;
    BOOL GoOn = TRUE;
    LPSTR DuplicatedString = NULL;
    INT ReturnValue;
 
    /* Start a loop (which should only run twice) */
    while (GoOn)
    {
        /* Call the conversion function */
        ReturnValue = WideCharToMultiByte(CP_ACP,
                                          0,
                                          UnicodeString,
                                          -1,
                                          DuplicatedString,
                                          Length,
                                          NULL,
                                          NULL);
        if (ReturnValue > Length)
        {
            /* This is the first loop, and we have the real size now */
            Length = ReturnValue;
 
            /* Allocate buffer for it */
            DuplicatedString = HeapAlloc(WsSockHeap, 0, Length);
            if (!DuplicatedString) GoOn = FALSE;
        }
        else if (ReturnValue > 0)
        {
            /* The second loop was successful and we have the string */
            GoOn = FALSE;
        }
        else
        {
            /* Some weird error happened */
            if (DuplicatedString) HeapFree(WsSockHeap, 0, DuplicatedString);
            DuplicatedString = NULL;
            GoOn = FALSE;
        }
    }
 
    /* Return the duplicate */
    return DuplicatedString;
}

Referenced by ConvertAddrinfoFromUnicodeToAnsi(), and MapUnicodeQuerySetToAnsi().

CopyQuerySetW()

INT WSAAPI CopyQuerySetW	(	IN LPWSAQUERYSETW	UnicodeSet,
		OUT LPWSAQUERYSETW *	UnicodeCopy
	)

Definition at line 1050 of file qshelpr.c.

{
    SIZE_T SetSize;
 
    /* Get the size */
    SetSize = WSAComputeQuerySetSizeW(UnicodeSet);
 
    /* Allocate memory for copy */
    *UnicodeCopy = HeapAlloc(WsSockHeap, 0, SetSize);
    if (!(*UnicodeCopy)) return WSA_NOT_ENOUGH_MEMORY;
 
    /* Build a copy and return */
    return WSABuildQuerySetBufferW(UnicodeSet, SetSize, *UnicodeCopy);
}

Referenced by WsNqLookupServiceBegin().

MapAnsiQuerySetToUnicode()

INT WSAAPI MapAnsiQuerySetToUnicode	(	IN LPWSAQUERYSETA	AnsiSet,
		IN OUT PSIZE_T	SetSize,
		OUT LPWSAQUERYSETW	UnicodeSet
	)

Definition at line 808 of file qshelpr.c.

{
    INT ErrorCode = ERROR_SUCCESS;
    SIZE_T AnsiSize, UnicodeSize;
    LPWSAQUERYSETA AnsiCopy = NULL;
    LPWSAQUERYSETW UnicodeCopy;
    LPWSTR ServiceCopy = NULL, CommentCopy = NULL;
    LPWSTR ContextCopy = NULL, QueryCopy = NULL;
 
    /* Calculate the size of the Ansi version and allocate space for a copy */
    AnsiSize = WSAComputeQuerySetSizeA(AnsiSet);
    AnsiCopy = HeapAlloc(WsSockHeap, 0, AnsiSize);
    if (!AnsiCopy)
    {
        /* Fail, couldn't allocate memory */
        ErrorCode = WSA_NOT_ENOUGH_MEMORY;
        goto Exit;
    }
 
    /* Build the relative buffer version */
    ErrorCode = WSABuildQuerySetBufferA(AnsiSet, AnsiSize, AnsiCopy);
    if (ErrorCode != ERROR_SUCCESS) goto Exit;
 
    /* Re-use the ANSI version since the fields match */
    UnicodeCopy = (LPWSAQUERYSETW)AnsiCopy;
 
    /* Check if we have a service instance name */
    if (AnsiCopy->lpszServiceInstanceName)
    {
        /* Duplicate it into unicode form */
        ServiceCopy = UnicodeDupFromAnsi(AnsiCopy->lpszServiceInstanceName);
        if (!ServiceCopy)
        {
            /* Fail */
            ErrorCode = WSA_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
 
        /* Set the new string pointer */
        UnicodeCopy->lpszServiceInstanceName = ServiceCopy;
    }
 
    /* Check if we have a service instance name */
    if (AnsiCopy->lpszContext)
    {
        /* Duplicate it into unicode form */
        ContextCopy = UnicodeDupFromAnsi(AnsiCopy->lpszContext);
        if (!ContextCopy)
        {
            /* Fail */
            ErrorCode = WSA_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
 
        /* Set the new string pointer */
        UnicodeCopy->lpszContext = ContextCopy;
    }
 
    /* Check if we have a service instance name */
    if (AnsiCopy->lpszComment)
    {
        /* Duplicate it into unicode form */
        CommentCopy = UnicodeDupFromAnsi(AnsiCopy->lpszComment);
        if (!CommentCopy)
        {
            /* Fail */
            ErrorCode = WSA_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
 
        /* Set the new string pointer */
        UnicodeCopy->lpszComment = CommentCopy;
    }
 
    /* Check if we have a query name */
    if (AnsiCopy->lpszQueryString)
    {
        /* Duplicate it into unicode form */
        QueryCopy = UnicodeDupFromAnsi(AnsiCopy->lpszQueryString);
        if (!QueryCopy)
        {
            /* Fail */
            ErrorCode = WSA_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
 
        /* Set the new string pointer */
        UnicodeCopy->lpszQueryString = QueryCopy;
    }
 
    /* Now that we have the absolute unicode buffer, calculate its size */
    UnicodeSize = WSAComputeQuerySetSizeW(UnicodeCopy);
    if (UnicodeSize > *SetSize)
    {
        /* The buffer wasn't large enough; return how much we need */
        *SetSize = UnicodeSize;
        ErrorCode = WSAEFAULT;
        goto Exit;
    }
 
    /* Build the relative unicode buffer */
    ErrorCode = WSABuildQuerySetBufferW(UnicodeCopy, *SetSize, UnicodeSet);
 
Exit:
    /* Free the Ansi copy if we had one */
    if (AnsiCopy) HeapFree(WsSockHeap, 0, AnsiCopy);
 
    /* Free all the strings */
    if (ServiceCopy) HeapFree(WsSockHeap, 0, ServiceCopy);
    if (CommentCopy) HeapFree(WsSockHeap, 0, CommentCopy);
    if (ContextCopy) HeapFree(WsSockHeap, 0, ContextCopy);
    if (QueryCopy) HeapFree(WsSockHeap, 0, QueryCopy);
 
    /* Return error code */
    return ErrorCode;
}

Referenced by WSALookupServiceBeginA().

MapUnicodeProtocolInfoToAnsi()

INT WSAAPI MapUnicodeProtocolInfoToAnsi	(	IN LPWSAPROTOCOL_INFOW	UnicodeInfo,
		OUT LPWSAPROTOCOL_INFOA	AnsiInfo
	)

Definition at line 224 of file wsautil.c.

{
    INT ReturnValue;
 
    /* Copy all the data that doesn't need converting */
    RtlCopyMemory(AnsiInfo,
                  UnicodeInfo,
                  FIELD_OFFSET(WSAPROTOCOL_INFOA, szProtocol));
 
    /* Now convert the protocol string */
    ReturnValue = WideCharToMultiByte(CP_ACP,
                                      0,
                                      UnicodeInfo->szProtocol,
                                      -1,
                                      AnsiInfo->szProtocol,
                                      sizeof(AnsiInfo->szProtocol),
                                      NULL,
                                      NULL);
    if (!ReturnValue) return WSASYSCALLFAILURE;
 
    /* Return success */
    return ERROR_SUCCESS;
}

Referenced by getsockopt(), and WSADuplicateSocketA().

MapUnicodeQuerySetToAnsi()

INT WSAAPI MapUnicodeQuerySetToAnsi	(	IN LPWSAQUERYSETW	UnicodeSet,
		IN OUT PSIZE_T	SetSize,
		OUT LPWSAQUERYSETA	AnsiSet
	)

Definition at line 929 of file qshelpr.c.

{
    INT ErrorCode = ERROR_SUCCESS;
    SIZE_T UnicodeSize, AnsiSize;
    LPWSAQUERYSETW UnicodeCopy = NULL;
    LPWSAQUERYSETA AnsiCopy;
    LPSTR ServiceCopy = NULL, CommentCopy = NULL;
    LPSTR ContextCopy = NULL, QueryCopy = NULL;
 
    /* Calculate the size of the Ansi version and allocate space for a copy */
    UnicodeSize = WSAComputeQuerySetSizeW(UnicodeSet);
    UnicodeCopy = HeapAlloc(WsSockHeap, 0, UnicodeSize);
    if (!UnicodeCopy)
    {
        /* Fail, couldn't allocate memory */
        ErrorCode = WSA_NOT_ENOUGH_MEMORY;
        goto Exit;
    }
 
    /* Build the relative buffer version */
    ErrorCode = WSABuildQuerySetBufferW(UnicodeSet, UnicodeSize, UnicodeCopy);
    if (ErrorCode != ERROR_SUCCESS) goto Exit;
 
    /* Re-use the Unicode version since the fields match */
    AnsiCopy = (LPWSAQUERYSETA)UnicodeCopy;
 
    /* Check if we have a service instance name */
    if (UnicodeCopy->lpszServiceInstanceName)
    {
        /* Duplicate it into unicode form */
        ServiceCopy = AnsiDupFromUnicode(UnicodeCopy->lpszServiceInstanceName);
        if (!ServiceCopy)
        {
            /* Fail */
            ErrorCode = WSA_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
 
        /* Set the new string pointer */
        AnsiCopy->lpszServiceInstanceName = ServiceCopy;
    }
 
    /* Check if we have a service instance name */
    if (UnicodeCopy->lpszContext)
    {
        /* Duplicate it into unicode form */
        ContextCopy = AnsiDupFromUnicode(UnicodeCopy->lpszContext);
        if (!ContextCopy)
        {
            /* Fail */
            ErrorCode = WSA_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
 
        /* Set the new string pointer */
        AnsiCopy->lpszContext = ContextCopy;
    }
 
    /* Check if we have a service instance name */
    if (UnicodeCopy->lpszComment)
    {
        /* Duplicate it into unicode form */
        CommentCopy = AnsiDupFromUnicode(UnicodeCopy->lpszComment);
        if (!CommentCopy)
        {
            /* Fail */
            ErrorCode = WSA_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
 
        /* Set the new string pointer */
        AnsiCopy->lpszComment = CommentCopy;
    }
 
    /* Check if we have a query name */
    if (UnicodeCopy->lpszQueryString)
    {
        /* Duplicate it into unicode form */
        QueryCopy = AnsiDupFromUnicode(UnicodeCopy->lpszQueryString);
        if (!QueryCopy)
        {
            /* Fail */
            ErrorCode = WSA_NOT_ENOUGH_MEMORY;
            goto Exit;
        }
 
        /* Set the new string pointer */
        AnsiCopy->lpszQueryString = QueryCopy;
    }
 
    /* Now that we have the absolute unicode buffer, calculate its size */
    AnsiSize = WSAComputeQuerySetSizeA(AnsiCopy);
    if (AnsiSize > *SetSize)
    {
        /* The buffer wasn't large enough; return how much we need */
        *SetSize = AnsiSize;
        ErrorCode = WSAEFAULT;
        goto Exit;
    }
 
    /* Build the relative unicode buffer */
    ErrorCode = WSABuildQuerySetBufferA(AnsiCopy, *SetSize, AnsiSet);
 
Exit:
    /* Free the Ansi copy if we had one */
    if (UnicodeCopy) HeapFree(WsSockHeap, 0, UnicodeCopy);
 
    /* Free all the strings */
    if (ServiceCopy) HeapFree(WsSockHeap, 0, ServiceCopy);
    if (CommentCopy) HeapFree(WsSockHeap, 0, CommentCopy);
    if (ContextCopy) HeapFree(WsSockHeap, 0, ContextCopy);
    if (QueryCopy) HeapFree(WsSockHeap, 0, QueryCopy);
 
    /* Return error code */
    return ErrorCode;
}

Referenced by WSALookupServiceNextA().

UnicodeDupFromAnsi()

LPWSTR WSAAPI UnicodeDupFromAnsi

(

IN LPCSTR

AnsiString

)

Definition at line 68 of file qshelpr.c.

{
    INT Length = 0;
    BOOL GoOn = TRUE;
    LPWSTR DuplicatedString = NULL;
    INT ReturnValue;
 
    /* Start a loop (which should only run twice) */
    while (GoOn)
    {
        /* Call the conversion function */
        ReturnValue = MultiByteToWideChar(CP_ACP,
                                          0,
                                          AnsiString,
                                          -1,
                                          DuplicatedString,
                                          Length);
        if (ReturnValue > Length)
        {
            /* This is the first loop, and we have the real size now */
            Length = ReturnValue;
 
            /* Allocate buffer for it */
            DuplicatedString = HeapAlloc(WsSockHeap, 0, Length * sizeof(WCHAR));
            if (!DuplicatedString) GoOn = FALSE;
        }
        else if (ReturnValue > 0)
        {
            /* The second loop was successful and we have the string */
            GoOn = FALSE;
        }
        else
        {
            /* Some weird error happened */
            if (DuplicatedString) HeapFree(WsSockHeap, 0, DuplicatedString);
            DuplicatedString = NULL;
            GoOn = FALSE;
        }
    }
 
    /* Return the duplicate */
    return DuplicatedString;
}

Referenced by getaddrinfo(), and MapAnsiQuerySetToUnicode().

WsApiProlog()

INT WSAAPI WsApiProlog	(	OUT PWSPROCESS *	Process,
		OUT PWSTHREAD *	Thread
	)

Definition at line 91 of file wsautil.c.

{
    INT ErrorCode = WSANOTINITIALISED;
 
    /* Try to get the current process */
    if ((*Process = WsGetProcess()))
    {
        /* And the current thread */
        ErrorCode = WsThreadGetCurrentThread(*Process, Thread);
    }
 
    /* Return init status */
    return ErrorCode;
}

Referenced by connect(), gethostbyaddr(), gethostbyname(), getprotobyname(), getprotobynumber(), getservbyname(), getservbyport(), getsockopt(), inet_ntoa(), setsockopt(), socket(), WPUQueryBlockingCallback(), WSAAccept(), WSAAddressToStringA(), WSAAddressToStringW(), WSAAsyncGetHostByAddr(), WSAAsyncGetHostByName(), WSAAsyncGetProtoByName(), WSAAsyncGetProtoByNumber(), WSAAsyncGetServByName(), WSAAsyncGetServByPort(), WSACancelAsyncRequest(), WSACancelBlockingCall(), WSACleanup(), WSAIsBlocking(), WSAJoinLeaf(), WSALookupServiceBeginW(), WSALookupServiceEnd(), WSALookupServiceNextW(), WSARecvDisconnect(), WSASendDisconnect(), WSASetBlockingHook(), WSASocketW(), WSAStringToAddressA(), WSAStringToAddressW(), WSAUnhookBlockingHook(), WSCGetProviderPath(), WsSlowProlog(), and WsSlowPrologTid().

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().

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().

WSAttemptAutodialAddr()

BOOL WSAAPI WSAttemptAutodialAddr	(	IN CONST SOCKADDR FAR *	Name,
		IN INT	NameLength
	)

Definition at line 20 of file winsock.c.

{
    PSOCKADDR_IN Ip = (PSOCKADDR_IN)Name;
    PSOCKADDR_NB NetBios = (PSOCKADDR_NB)Name;
    AUTODIAL_ADDR AutodialAddress;
 
    /* Check the family type */
    switch (Name->sa_family)
    {
        case AF_INET:
            /* Normal IPv4, set the Autodial Address Data */
            AutodialAddress.Family = AutoDialIp;
            AutodialAddress.Ip4Address = Ip->sin_addr;
            break;
 
        case AF_NETBIOS:
            /* NetBIOS, set the Autodial Address Data*/
            AutodialAddress.Family = AutoDialNetBios;
            RtlCopyMemory(&AutodialAddress.NetBiosAddress,
                          NetBios->snb_name,
                          NETBIOS_NAME_LENGTH);
            break;
 
        default:
            /* Unsupported family type */
            return FALSE;
    }
 
    /* Call the public routine */
    return AcsHlpAttemptConnection(&AutodialAddress);
}

Referenced by connect().

WSAttemptAutodialName()

BOOL WSAAPI WSAttemptAutodialName

(

IN CONST LPWSAQUERYSETW

lpqsRestrictions

)

Definition at line 58 of file winsock.c.

{
    AUTODIAL_ADDR AutodialAddress;
    CHAR AnsiIp[17];
    LPGUID Guid = Restrictions->lpServiceClassId;
 
    /* Make sure we actually have a name */
    if (!Restrictions->lpszServiceInstanceName) return FALSE;
 
    /* Check if this is the Hostname GUID */
    if (!memcmp(Guid, &HostnameGuid, sizeof(GUID)))
    {
        /* It is. Set up the Autodial Address Data */
        AutodialAddress.Family = AutoDialIpHost;
        WideCharToMultiByte(CP_ACP,
                            0,
                            Restrictions->lpszServiceInstanceName,
                            -1,
                            AutodialAddress.HostName,
                            INTERNET_MAX_PATH_LENGTH - 1,
                            0,
                            0);
 
        /* Call the public routine */
        return AcsHlpAttemptConnection(&AutodialAddress);
    }
    else if (!memcmp(Guid, &AddressGuid, sizeof(GUID)))
    {
        /* It's actually the IP String GUID */
        AutodialAddress.Family = AutoDialIp;
 
        /* Convert the IP String to ANSI and then convert it to IP */
        WideCharToMultiByte(CP_ACP,
                            0,
                            Restrictions->lpszServiceInstanceName,
                            -1,
                            AnsiIp,
                            sizeof(AnsiIp) - 1,
                            0,
                            0);
        _strlwr(AnsiIp);
        AutodialAddress.Ip4Address.S_un.S_addr = inet_addr(AnsiIp);
 
        /* Make sure the IP is valid */
        if (AutodialAddress.Ip4Address.S_un.S_addr == -1) return FALSE;
 
        /* Call the public routine */
        return AcsHlpAttemptConnection(&AutodialAddress);
    }
    else
    {
        /* Unknown GUID type */
        return FALSE;
    }
}

Referenced by WsNqLookupServiceNext().

WsCheckCatalogState()

BOOL WSAAPI WsCheckCatalogState

(

IN HANDLE

Event

)

Definition at line 75 of file wsautil.c.

{
    DWORD Return;
 
    /* Wait for the object */
    Return = WaitForSingleObject(Event, 0);
 
    /* Check for the value */
    if (Return == WAIT_OBJECT_0) return TRUE;
 
    /* If it timedout or anything else, return false */
    return FALSE;
}

Referenced by WsNcRefreshFromRegistry(), WsProcGetNsCatalog(), WsProcGetTCatalog(), and WsTcRefreshFromRegistry().

WsCreateStartupSynchronization()

VOID WSAAPI WsCreateStartupSynchronization

(

VOID

)

Definition at line 28 of file startup.c.

{
    /* Initialize the startup lock */
    InitializeCriticalSection(&WsStartupLock);
}

Referenced by DllMain().

WsDestroyStartupSynchronization()

VOID WSAAPI WsDestroyStartupSynchronization

(

VOID

)

Definition at line 36 of file startup.c.

{
    /* Destroy the startup lock */
    DeleteCriticalSection(&WsStartupLock);
}

Referenced by DllMain().

WsGetProcess()

FORCEINLINE PWSPROCESS WsGetProcess

(

VOID

)

Definition at line 885 of file ws2_32p.h.

{
    return CurrentWsProcess;
}

Referenced by DllMain(), WPUModifyIFSHandle(), WSAEnumNameSpaceProvidersInternal(), WsApiProlog(), WSAStartup(), WsQuickProlog(), WsQuickPrologTid(), and WsSockFindIfsSocket().

WsNcAllocate()

PNSCATALOG WSAAPI WsNcAllocate

(

VOID

)

Definition at line 25 of file nscatalo.c.

{
    PNSCATALOG Catalog;
 
    /* Allocate the catalog */
    Catalog = HeapAlloc(WsSockHeap, HEAP_ZERO_MEMORY, sizeof(*Catalog));
 
    /* Return it */
    return Catalog;
}

Referenced by WsProcInitialize().

WsNcDelete()

VOID WSAAPI WsNcDelete

(

IN PNSCATALOG

Catalog

)

Definition at line 624 of file nscatalo.c.

{
    PLIST_ENTRY Entry;
    PNSCATALOG_ENTRY CatalogEntry;
 
    /* Check if we're initialized */
    if (!Catalog->CatalogList.Flink) return;
 
    /* Acquire lock */
    WsNcLock();
 
    /* Loop every entry */
    Entry = Catalog->CatalogList.Flink;
    while (Entry != &Catalog->CatalogList)
    {
        /* Get this entry */
        CatalogEntry = CONTAINING_RECORD(Entry, NSCATALOG_ENTRY, CatalogLink);
 
        /* Remove it and dereference it */
        WsNcRemoveCatalogItem(Catalog, CatalogEntry);
        WsNcEntryDereference(CatalogEntry);
 
        /* Move to the next entry */
        Entry = Catalog->CatalogList.Flink;
    }
 
    /* Check if the catalog key is opened */
    if (Catalog->CatalogKey)
    {
        /* Close it */
        RegCloseKey(Catalog->CatalogKey);
        Catalog->CatalogKey = NULL;
    }
 
    /* Release and delete the lock */
    WsNcUnlock();
    DeleteCriticalSection(&Catalog->Lock);
 
    /* Delete the object */
    HeapFree(WsSockHeap, 0, Catalog);
}

Referenced by WsProcDelete().

WsNcEntryAllocate()

PNSCATALOG_ENTRY WSAAPI WsNcEntryAllocate

(

VOID

)

Definition at line 17 of file nscatent.c.

{
    PNSCATALOG_ENTRY CatalogEntry;
 
    /* Allocate the catalog */
    CatalogEntry = HeapAlloc(WsSockHeap, HEAP_ZERO_MEMORY, sizeof(*CatalogEntry));
    if (CatalogEntry)
    {
        /* Set the default non-null members */
        CatalogEntry->RefCount = 1;
        CatalogEntry->Enabled = TRUE;
        CatalogEntry->AddressFamily = -1;
    }
 
    /* Return it */
    return CatalogEntry;
}

Referenced by WsNcRefreshFromRegistry().

WsNcEntryDereference()

VOID WSAAPI WsNcEntryDereference

(

IN PNSCATALOG_ENTRY

CatalogEntry

)

Definition at line 53 of file nscatent.c.

{
    /* Dereference and check if it's now 0 */
    if (!(InterlockedDecrement(&CatalogEntry->RefCount)))
    {
        /* We can delete the Provider now */
        WsNcEntryDelete(CatalogEntry);
    }
}

Referenced by WsNcDelete(), WsNcRefreshFromRegistry(), and WsNcUpdateNamespaceList().

WsNcEntryInitializeFromRegistry()

INT WSAAPI WsNcEntryInitializeFromRegistry	(	IN PNSCATALOG_ENTRY	CatalogEntry,
		IN HKEY	ParentKey,
		IN ULONG	UniqueId
	)

Definition at line 65 of file nscatent.c.

{
    INT ErrorCode;
    CHAR CatalogEntryName[13];
    HKEY EntryKey;
    ULONG RegType = REG_SZ;
    ULONG RegSize = MAX_PATH;
    ULONG RegValue;
 
    /* Convert to a 00000xxx string */
    sprintf(CatalogEntryName, "%0""12""i", (int)UniqueId);
 
    /* Open the Entry */
    ErrorCode = RegOpenKeyEx(ParentKey,
                             CatalogEntryName,
                             0,
                             KEY_READ,
                             &EntryKey);
    if (ErrorCode != ERROR_SUCCESS) return ErrorCode;
    /* Read the Library Path */
    ErrorCode = RegQueryValueExW(EntryKey,
                                 L"LibraryPath",
                                 0,
                                 &RegType,
                                 (LPBYTE)&CatalogEntry->DllPath,
                                 &RegSize);
    if (ErrorCode != ERROR_SUCCESS) goto out;
    /* Query Display String Size*/
    ErrorCode = RegQueryValueExW(EntryKey,
                                 L"DisplayString",
                                 0,
                                 NULL,
                                 NULL,
                                 &RegSize);
    if (ErrorCode != ERROR_SUCCESS) goto out;
    /* Allocate it */
    CatalogEntry->ProviderName = (LPWSTR)HeapAlloc(WsSockHeap, 0, RegSize);
 
    /* Read it */
    ErrorCode = RegQueryValueExW(EntryKey,
                                 L"DisplayString",
                                 0,
                                 &RegType,
                                 (LPBYTE)CatalogEntry->ProviderName,
                                 &RegSize);
    if (ErrorCode != ERROR_SUCCESS) goto out;
    /* Read the Provider Id */
    RegType = REG_BINARY;
    RegSize = sizeof(GUID);
    ErrorCode = RegQueryValueEx(EntryKey,
                                "ProviderId",
                                0,
                                &RegType,
                                (LPBYTE)&CatalogEntry->ProviderId,
                                &RegSize);
    if (ErrorCode != ERROR_SUCCESS) goto out;
    /* Read the Address Family */
    RegType = REG_DWORD;
    RegSize = sizeof(DWORD);
    ErrorCode = RegQueryValueEx(EntryKey,
                                "AddressFamily",
                                0,
                                &RegType,
                                (LPBYTE)&CatalogEntry->AddressFamily,
                                &RegSize);
    if (ErrorCode != ERROR_SUCCESS) goto out;
    /* Read the Namespace Id */
    ErrorCode = RegQueryValueEx(EntryKey,
                                "SupportedNamespace",
                                0,
                                &RegType,
                                (LPBYTE)&CatalogEntry->NamespaceId,
                                &RegSize);
    if (ErrorCode != ERROR_SUCCESS) goto out;
    /* Read the Enabled Flag */
    ErrorCode = RegQueryValueEx(EntryKey,
                                "Enabled",
                                0,
                                &RegType,
                                (LPBYTE)&RegValue,
                                &RegSize);
    if (ErrorCode != ERROR_SUCCESS) goto out;
    CatalogEntry->Enabled = RegValue != 0;
 
    /* Read the Version */
    ErrorCode = RegQueryValueEx(EntryKey,
                                "Version",
                                0,
                                &RegType,
                                (LPBYTE)&CatalogEntry->Version,
                                &RegSize);
    if (ErrorCode != ERROR_SUCCESS) goto out;
    /* Read the Support Service Class Info Flag */
    ErrorCode = RegQueryValueEx(EntryKey,
                                "StoresServiceClassInfo",
                                0,
                                &RegType,
                                (LPBYTE)&RegValue,
                                &RegSize);
    CatalogEntry->StoresServiceClassInfo = RegValue != 0;
out:
    /* Done */
    RegCloseKey(EntryKey);
    return ErrorCode;
}

Referenced by WsNcRefreshFromRegistry().

WsNcEntrySetProvider()

VOID WSAAPI WsNcEntrySetProvider	(	IN PNSCATALOG_ENTRY	Entry,
		IN PNS_PROVIDER	Provider
	)

Definition at line 175 of file nscatent.c.

{
    /* Reference the provider */
    InterlockedIncrement(&Provider->RefCount);
 
    /* Set it */
    Entry->Provider = Provider;
}

Referenced by WsNcLoadProvider().

WsNcEnumerateCatalogItems()

VOID WSAAPI WsNcEnumerateCatalogItems	(	IN PNSCATALOG	Catalog,
		IN PNSCATALOG_ENUMERATE_PROC	Callback,
		IN PVOID	Context
	)

Definition at line 371 of file nscatalo.c.

{
    PLIST_ENTRY Entry;
    PNSCATALOG_ENTRY CatalogEntry;
    BOOL GoOn = TRUE;
 
    /* Lock the catalog */
    WsNcLock();
 
    /* Loop the entries */
    Entry = Catalog->CatalogList.Flink;
    while (GoOn && (Entry != &Catalog->CatalogList))
    {
        /* Get the entry */
        CatalogEntry = CONTAINING_RECORD(Entry, NSCATALOG_ENTRY, CatalogLink);
 
        /* Move to the next one and call the callback */
        Entry = Entry->Flink;
        GoOn = Callback(Context, CatalogEntry);
    }
 
    /* Release the lock */
    WsNcUnlock();
}

Referenced by WSAEnumNameSpaceProvidersInternal(), WSCGetProviderPath(), WsNqLookupServiceBegin(), and WsProcDelete().

WsNcGetCatalogFromProviderId()

INT WSAAPI WsNcGetCatalogFromProviderId	(	IN PNSCATALOG	Catalog,
		IN LPGUID	ProviderId,
		OUT PNSCATALOG_ENTRY *	CatalogEntry
	)

Definition at line 517 of file nscatalo.c.

{
    INT ErrorCode = WSAEINVAL;
    PLIST_ENTRY NextEntry;
    PNSCATALOG_ENTRY Entry;
 
    /* Lock the catalog */
    WsNcLock();
 
    /* Match the Id with all the entries in the List */
    NextEntry = Catalog->CatalogList.Flink;
    while (NextEntry != &Catalog->CatalogList)
    {
        /* Get the Current Entry */
        Entry = CONTAINING_RECORD(NextEntry, NSCATALOG_ENTRY, CatalogLink);
        NextEntry = NextEntry->Flink;
 
        /* Check if this is the Catalog Entry ID we want */
        if (IsEqualGUID(&Entry->ProviderId, ProviderId))
        {
            /* If it doesn't already have a provider, load the provider */
            if (!Entry->Provider)
                ErrorCode = WsNcLoadProvider(Catalog, Entry);
 
            /* If we succeeded, reference the entry and return it */
            if (Entry->Provider /* || ErrorCode == ERROR_SUCCESS */)
            {
                InterlockedIncrement(&Entry->RefCount);
                *CatalogEntry = Entry;
                ErrorCode = ERROR_SUCCESS;
                break;
            }
        }
    }
 
    /* Release the lock and return */
    WsNcUnlock();
    return ErrorCode;
}

Referenced by WsNqLookupServiceBegin().

WsNcGetServiceClassInfo()

INT WSAAPI WsNcGetServiceClassInfo	(	IN PNSCATALOG	Catalog,
		IN OUT LPDWORD	BugSize,
		IN OUT LPWSASERVICECLASSINFOW	lpServiceClassInfo
	)

Definition at line 444 of file nscatalo.c.

{
    /* Not yet implemented in the spec? */
    SetLastError(ERROR_SUCCESS);
    return SOCKET_ERROR;
}

Referenced by WsNqLookupServiceBegin().

WsNcInitializeFromRegistry()

INT WSAAPI WsNcInitializeFromRegistry	(	IN PNSCATALOG	Catalog,
		IN HKEY	ParentKey,
		IN HANDLE	CatalogEvent
	)

Definition at line 211 of file nscatalo.c.

{
    INT ErrorCode = WSASYSCALLFAILURE;
 
    /* Open the catalog */
    if (WsNcOpen(Catalog, ParentKey))
    {
        /* Refresh it */
        ErrorCode = WsNcRefreshFromRegistry(Catalog, CatalogEvent);
    }
 
    /* Return the status */
    return ErrorCode;
}

Referenced by WsProcInitialize().

WsNcLoadProvider()

INT WSAAPI WsNcLoadProvider	(	IN PNSCATALOG	Catalog,
		IN PNSCATALOG_ENTRY	CatalogEntry
	)

Definition at line 400 of file nscatalo.c.

{
    INT ErrorCode = ERROR_SUCCESS;
    PNS_PROVIDER Provider;
 
    /* Lock the catalog */
    WsNcLock();
 
    /* Check if we have a provider already */
    if (!CatalogEntry->Provider)
    {
        /* Allocate a provider */
        if ((Provider = WsNpAllocate()))
        {
            /* Initialize it */
            ErrorCode = WsNpInitialize(Provider,
                                       CatalogEntry->DllPath,
                                       &CatalogEntry->ProviderId);
 
            /* Ensure success */
            if (ErrorCode == ERROR_SUCCESS)
            {
                /* Set the provider */
                WsNcEntrySetProvider(CatalogEntry, Provider);
            }
 
            /* Dereference it */
            WsNpDereference(Provider);
        }
        else
        {
            /* No memory */
            ErrorCode = WSA_NOT_ENOUGH_MEMORY;
        }
    }
 
    /* Release the lock and return */
    WsNcUnlock();
    return ErrorCode;
}

Referenced by WsNcGetCatalogFromProviderId(), and WsNqBeginEnumerationProc().

WsNcMatchProtocols()

BOOL WSAAPI WsNcMatchProtocols	(	IN DWORD	NameSpace,
		IN LONG	AddressFamily,
		IN LPWSAQUERYSETW	QuerySet
	)

Definition at line 561 of file nscatalo.c.

{
    DWORD ProtocolCount = QuerySet->dwNumberOfProtocols;
    LPAFPROTOCOLS AfpProtocols = QuerySet->lpafpProtocols;
    LONG Family;
 
    /* Check for valid family */
    if (AddressFamily != -1)
    {
        /* Check if it's the magic */
        if (AddressFamily == AF_UNSPEC) return TRUE;
        Family = AddressFamily;
    }
    else
    {
        /* No family given, check for namespace */
        if (NameSpace == NS_SAP)
        {
            /* Use IPX family */
            Family = AF_IPX;
        }
        else
        {
            /* Other namespace, it's valid */
            return TRUE;
        }
    }
 
    /* Now try to get a match */
    while (ProtocolCount--)
    {
        /* Check this protocol entry */
        if ((AfpProtocols->iAddressFamily == AF_UNSPEC) ||
            (AfpProtocols->iAddressFamily == Family))
        {
            /* Match found */
            return TRUE;
        }
 
        /* Move to the next one */
        AfpProtocols++;
    }
 
    /* No match */
    return FALSE;
}

Referenced by WsNqBeginEnumerationProc().

WsNcRefreshFromRegistry()

INT WSAAPI WsNcRefreshFromRegistry	(	IN PNSCATALOG	Catalog,
		IN HANDLE	CatalogEvent
	)

Definition at line 230 of file nscatalo.c.

{
    INT ErrorCode;
    BOOLEAN LocalEvent = FALSE;
    LIST_ENTRY LocalList;
    DWORD UniqueId;
    HKEY EntriesKey;
    DWORD CatalogEntries;
    PNSCATALOG_ENTRY CatalogEntry;
    BOOL NewChangesMade;
    PLIST_ENTRY Entry;
    DWORD RegType = REG_DWORD;
    DWORD RegSize = sizeof(DWORD);
    DWORD i;
 
    /* Check if we got an event */
    if (!CatalogEvent)
    {
        /* Create an event ourselves */
        CatalogEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
        if (!CatalogEvent) return WSASYSCALLFAILURE;
        LocalEvent = TRUE;
    }
 
    /* Lock the catalog */
    WsNcLock();
 
    /* Initialize our local list for the loop */
    InitializeListHead(&LocalList);
 
    /* Start looping */
    do
    {
        /* Setup notifications for the catalog entry */
        ErrorCode = WsSetupCatalogProtection(Catalog->CatalogKey,
                                             CatalogEvent,
                                             &UniqueId);
        if (ErrorCode != ERROR_SUCCESS) break;
 
        /* Check if we've changed till now */
        if (UniqueId == Catalog->UniqueId)
        {
            /* We haven't, so return */
            ErrorCode = ERROR_SUCCESS;
            break;
        }
 
        /* Now Open the Entries */
        ErrorCode = RegOpenKeyEx(Catalog->CatalogKey,
                                 "Catalog_Entries",
                                 0,
                                 MAXIMUM_ALLOWED,
                                 &EntriesKey);
        if (ErrorCode != ERROR_SUCCESS)
        {
            /* Critical failure */
            ErrorCode = WSASYSCALLFAILURE;
            break;
        }
 
        /* Find out how many there are */
        ErrorCode = RegQueryValueEx(Catalog->CatalogKey,
                                    "Num_Catalog_Entries",
                                    0,
                                    &RegType,
                                    (LPBYTE)&CatalogEntries,
                                    &RegSize);
        if (ErrorCode != ERROR_SUCCESS)
        {
            /* Critical failure */
            ErrorCode = WSASYSCALLFAILURE;
            break;
        }
 
        /* Initialize them all */
        for (i = 1; i <= CatalogEntries; i++)
        {
            /* Allocate a Catalog Entry Structure */
            CatalogEntry = WsNcEntryAllocate();
            if (!CatalogEntry)
            {
                /* Not enough memory, fail */
                ErrorCode = WSA_NOT_ENOUGH_MEMORY;
                break;
            }
 
            /* Initialize it from the Registry Key */
            ErrorCode = WsNcEntryInitializeFromRegistry(CatalogEntry,
                                                        EntriesKey,
                                                        i);
            if (ErrorCode != ERROR_SUCCESS)
            {
                /* We failed to get it, dereference the entry and leave */
                WsNcEntryDereference(CatalogEntry);
                break;
            }
 
            /* Insert it to our List */
            InsertTailList(&LocalList, &CatalogEntry->CatalogLink);
        }
 
        /* Close the catalog key */
        RegCloseKey(EntriesKey);
 
        /* Check if we changed during our read and if we have success */
        NewChangesMade = WsCheckCatalogState(CatalogEvent);
        if (!NewChangesMade && ErrorCode == ERROR_SUCCESS)
        {
            /* All is good, update the protocol list */
            WsNcUpdateNamespaceList(Catalog, &LocalList);
 
            /* Update and return */
            Catalog->UniqueId = UniqueId;
            break;
        }
 
        /* We failed and/or catalog data changed, free what we did till now */
        while (!IsListEmpty(&LocalList))
        {
            /* Get the LP Catalog Item */
            Entry = RemoveHeadList(&LocalList);
            CatalogEntry = CONTAINING_RECORD(Entry, NSCATALOG_ENTRY, CatalogLink);
 
            /* Dereference it */
            WsNcEntryDereference(CatalogEntry);
        }
    } while (NewChangesMade);
 
    /* Release the lock */
    WsNcUnlock();
 
    /* Close the event, if any was created by us */
    if (LocalEvent) CloseHandle(CatalogEvent);
 
    /* All Done */
    return ErrorCode;
}

Referenced by WsNcInitializeFromRegistry(), and WsProcGetNsCatalog().

WsNcUpdateNamespaceList()

VOID WSAAPI WsNcUpdateNamespaceList	(	IN PNSCATALOG	Catalog,
		IN PLIST_ENTRY	List
	)

Definition at line 455 of file nscatalo.c.

{
    LIST_ENTRY TempList;
    PNSCATALOG_ENTRY CatalogEntry, OldCatalogEntry;
    PLIST_ENTRY Entry;
 
    /* First move from our list to the old one */
    InsertHeadList(&Catalog->CatalogList, &TempList);
    RemoveEntryList(&Catalog->CatalogList);
    InitializeListHead(&Catalog->CatalogList);
 
    /* Loop every item on the list */
    while (!IsListEmpty(List))
    {
        /* Get the catalog entry */
        Entry = RemoveHeadList(List);
        CatalogEntry = CONTAINING_RECORD(Entry, NSCATALOG_ENTRY, CatalogLink);
 
        /* Check if this item is already on our list */
        Entry = TempList.Flink;
        while (Entry != &TempList)
        {
            /* Get the catalog entry */
            OldCatalogEntry = CONTAINING_RECORD(Entry, NSCATALOG_ENTRY, CatalogLink);
            Entry = Entry->Flink;
 
            /* Check if they match */
            if (IsEqualGUID(&CatalogEntry->ProviderId,
                            &OldCatalogEntry->ProviderId))
            {
                /* We have a match, use the old item instead */
                WsNcEntryDereference(CatalogEntry);
                CatalogEntry = OldCatalogEntry;
                RemoveEntryList(&CatalogEntry->CatalogLink);
 
                /* Decrease the number of protocols we have */
                Catalog->ItemCount--;
                break;
            }
        }
 
        /* Add this item */
        InsertTailList(&Catalog->CatalogList, &CatalogEntry->CatalogLink);
        Catalog->ItemCount++;
    }
 
    /* If there's anything left on the temporary list */
    while (!IsListEmpty(&TempList))
    {
        /* Get the entry */
        Entry = RemoveHeadList(&TempList);
        CatalogEntry = CONTAINING_RECORD(Entry, NSCATALOG_ENTRY, CatalogLink);
 
        /* Remove it */
        Catalog->ItemCount--;
        WsNcEntryDereference(CatalogEntry);
    }
}

Referenced by WsNcRefreshFromRegistry().

WSNoteSuccessfulHostentLookup()

VOID WSAAPI WSNoteSuccessfulHostentLookup	(	IN CONST CHAR FAR *	Name,
		IN CONST ULONG	Address
	)

Definition at line 119 of file winsock.c.

{
    AUTODIAL_ADDR AutodialAddress;
    AUTODIAL_CONN AutodialConnection;
 
    /* Make sure there actually is a name */
    if (!(Name) || !strlen(Name)) return;
 
    /* Setup the Address */
    AutodialAddress.Family = AutoDialIpHost;
    strcpy(AutodialAddress.HostName, Name);
 
    /* Setup the new connection */
    AutodialConnection.Family = ConnectionIp;
    AutodialConnection.Ip4Address = Address;
    AcsHlpNoteNewConnection(&AutodialAddress, &AutodialConnection);
}

Referenced by gethostbyname().

WsNpAllocate()

PNS_PROVIDER WSAAPI WsNpAllocate

(

VOID

)

Definition at line 63 of file nsprovid.c.

{
    PNS_PROVIDER Provider;
 
    /* Allocate the object */
    Provider = HeapAlloc(WsSockHeap, HEAP_ZERO_MEMORY, sizeof(*Provider));
    if (Provider)
    {
        /* Set non-null data */
        Provider->RefCount = 1;
        Provider->Service.cbSize = sizeof(NSP_ROUTINE);
    }
 
    /* Return it */
    return Provider;
}

Referenced by WsNcLoadProvider().

WsNpDelete()

VOID WSAAPI WsNpDelete

(

IN PNS_PROVIDER

Provider

)

Definition at line 161 of file nsprovid.c.

{
    /* Make sure we have a loaded handle */
    if (Provider->DllHandle)
    {
        /* Clean us up */
        WsNpNSPCleanup(Provider);
 
        /* Unload the library */
        FreeLibrary(Provider->DllHandle);
        Provider->DllHandle = NULL;
    }
 
    /* Delete us */
    HeapFree(WsSockHeap, 0, Provider);
}

Referenced by WsNpDereference().

WsNpDereference()

VOID WSAAPI WsNpDereference

(

IN PNS_PROVIDER

Provider

)

Definition at line 180 of file nsprovid.c.

{
    /* Decrease the reference count and check if it's zero */
    if (!InterlockedDecrement(&Provider->RefCount))
    {
        /* Delete us*/
        WsNpDelete(Provider);
    }
}

Referenced by WsNcEntryDelete(), WsNcLoadProvider(), and WsNqProvDelete().

WsNpInitialize()

DWORD WSAAPI WsNpInitialize	(	IN PNS_PROVIDER	Provider,
		IN LPWSTR	DllPath,
		IN LPGUID	ProviderGuid
	)

Definition at line 82 of file nsprovid.c.

{
    INT ErrorCode = ERROR_SUCCESS;
    LPNSPSTARTUP NSPStartupProc;
    CHAR AnsiPath[MAX_PATH], ExpandedDllPath[MAX_PATH];
 
    /* Convert the path to ANSI */
    WideCharToMultiByte(CP_ACP,
                        0,
                        DllName,
                        -1,
                        AnsiPath,
                        MAX_PATH,
                        NULL,
                        NULL);
 
    /* Expand the DLL Path */
    ExpandEnvironmentStringsA(AnsiPath,
                              ExpandedDllPath,
                              MAX_PATH);
 
    /* Load the DLL */
    Provider->DllHandle = LoadLibraryA(ExpandedDllPath);
    if (!Provider->DllHandle)
    {
        /* Fail */
        ErrorCode = WSAEPROVIDERFAILEDINIT;
        goto Fail;
    }
 
    /* Get the pointer to NSPStartup */
    NSPStartupProc = (LPNSPSTARTUP)GetProcAddress(Provider->DllHandle,
                                                  "NSPStartup");
    if (!NSPStartupProc)
    {
        /* Fail */
        ErrorCode = WSAEPROVIDERFAILEDINIT;
        goto Fail;
    }
 
    /* Call it */
    (*NSPStartupProc)(ProviderId, &Provider->Service);
 
    /* Save the provider ID */
    Provider->ProviderId = *ProviderId;
    return ErrorCode;
 
Fail:
    /* Bail out */
    if (Provider->DllHandle) FreeLibrary(Provider->DllHandle);
    Provider->DllHandle = NULL;
    return ErrorCode;
}

Referenced by WsNcLoadProvider().

WsNpLookupServiceBegin()

DWORD WSAAPI WsNpLookupServiceBegin	(	IN PNS_PROVIDER	Provider,
		IN LPWSAQUERYSETW	Restrictions,
		struct _WSAServiceClassInfoW *	,
		IN DWORD	ControlFlags,
		OUT PHANDLE	LookupHandle
	)

WsNpLookupServiceEnd()

DWORD WSAAPI WsNpLookupServiceEnd	(	IN PNS_PROVIDER	Provider,
		IN HANDLE	LookupHandle
	)

Definition at line 231 of file nsprovid.c.

{
    /* Call the NSP */
    return Provider->Service.NSPLookupServiceEnd(LookupHandle);
}

Referenced by WsNqProvLookupServiceEnd().

WsNpLookupServiceNext()

DWORD WSAAPI WsNpLookupServiceNext	(	IN PNS_PROVIDER	Provider,
		IN HANDLE	LookupHandle,
		IN DWORD	ControlFlags,
		OUT PDWORD	BufferLength,
		OUT LPWSAQUERYSETW	Results
	)

Definition at line 240 of file nsprovid.c.

{
    /* Call the NSP */
    return Provider->Service.NSPLookupServiceNext(LookupHandle,
                                                  ControlFlags,
                                                  BufferLength,
                                                  Results);
}

Referenced by WsNqProvLookupServiceNext().

WsNpNSPCleanup()

DWORD WSAAPI WsNpNSPCleanup

(

IN PNS_PROVIDER

Provider

)

Definition at line 140 of file nsprovid.c.

{
    INT ErrorCode = ERROR_SUCCESS;
    LPNSPCLEANUP lpNSPCleanup = NULL;
 
    /* Make sure we have a loaded handle */
    if (Provider->DllHandle)
    {
        /* Get the pointer and clear it */
        lpNSPCleanup = InterlockedExchangePointer((PVOID*)&Provider->Service.NSPCleanup,
                                                  NULL);
        /* If it's not NULL, call it */
        if (lpNSPCleanup) ErrorCode = lpNSPCleanup(&Provider->ProviderId);
    }
 
    /* Return */
    return ErrorCode;
}

Referenced by CleanupNamespaceProviders(), and WsNpDelete().

WsNqAddProvider()

BOOL WSAAPI WsNqAddProvider	(	IN PNSQUERY	NsQuery,
		IN PNS_PROVIDER	Provider
	)

Definition at line 552 of file nsquery.c.

{
    BOOL Success = TRUE;
    PNSQUERY_PROVIDER QueryProvider;
 
    /* Allocate a new Query Provider */
    if ((QueryProvider = WsNqProvAllocate()))
    {
        /* Initialize it */
        WsNqProvInitialize(QueryProvider, Provider);
 
        /* Insert it into the provider list */
        InsertTailList(&Query->ProviderList, &QueryProvider->QueryLink);
    }
    else
    {
        /* We failed */
        SetLastError(WSASYSCALLFAILURE);
        Success = FALSE;
    }
 
    /* Return */
    return Success;
}

Referenced by WsNqBeginEnumerationProc(), and WsNqLookupServiceBegin().

WsNqAllocate()

PNSQUERY WSAAPI WsNqAllocate

(

VOID

)

Definition at line 22 of file nsquery.c.

{
    PNSQUERY NsQuery;
 
    /* Allocate the object */
    NsQuery = HeapAlloc(WsSockHeap, HEAP_ZERO_MEMORY, sizeof(*NsQuery));
    if (NsQuery)
    {
        /* Set non-zero fields */
        NsQuery->Signature = ~0xBEADFACE;
        InitializeListHead(&NsQuery->ProviderList);
        NsQuery->TryAgain = TRUE;
    }
 
    /* Return it */
    return NsQuery;
}

Referenced by WSALookupServiceBeginW().

WsNqBeginEnumerationProc()

BOOL WSAAPI WsNqBeginEnumerationProc	(	PVOID	Context,
		PNSCATALOG_ENTRY	CatalogEntry
	)

Definition at line 117 of file nsquery.c.

{
    PNS_PROVIDER Provider;
    BOOLEAN GoOn = TRUE;
    PENUM_CONTEXT EnumContext = (PENUM_CONTEXT)Context;
    PNSQUERY NsQuery = EnumContext->NsQuery;
    DWORD NamespaceId = Entry->NamespaceId;
 
    /* Match the namespace ID, protocols and make sure it's enabled */
    if ((((EnumContext->lpqsRestrictions->dwNameSpace == NamespaceId) ||
          (EnumContext->lpqsRestrictions->dwNameSpace == NS_ALL)) &&
         (!(EnumContext->lpqsRestrictions->dwNumberOfProtocols) ||
           (WsNcMatchProtocols(NamespaceId,
                               Entry->AddressFamily,
                               EnumContext->lpqsRestrictions)))) &&
        (Entry->Enabled))
    {
        /* Get the provider */
        if (!(Provider = Entry->Provider))
        {
            /* None was loaded, load it */
            if (WsNcLoadProvider(EnumContext->Catalog, Entry) != ERROR_SUCCESS)
            {
                /* Return TRUE to continue enumerating */
                return TRUE;
            }
 
            /* Set the provider */
            Provider = Entry->Provider;
        }
 
        /* Add it to the query */
        if (!WsNqAddProvider(NsQuery, Provider))
        {
            /* We failed */
            EnumContext->ErrorCode = WSASYSCALLFAILURE;
            GoOn = FALSE;
        }
    }
 
    /* Return to caller */
    return GoOn;
}

Referenced by WsNqLookupServiceBegin().

WsNqDelete()

VOID WSAAPI WsNqDelete

(

IN PNSQUERY

NsQuery

)

Definition at line 74 of file nsquery.c.

{
    PNSQUERY_PROVIDER Provider;
    PLIST_ENTRY Entry;
 
    /* Make sure that we got initialized */
    if (!NsQuery->ProviderList.Flink) return;
 
    /* Loop the provider list */
    while (!IsListEmpty(&NsQuery->ProviderList))
    {
        /* Remove the entry */
        Entry = RemoveHeadList(&NsQuery->ProviderList);
 
        /* Get the provider */
        Provider = CONTAINING_RECORD(Entry, NSQUERY_PROVIDER, QueryLink);
 
        /* Delete it */
        WsNqProvDelete(Provider);
    }
 
    /* Remove the signature and delete the lock */
    NsQuery->Signature = ~0xBEADFACE;
    DeleteCriticalSection(&NsQuery->Lock);
 
    /* Free us */
    HeapFree(WsSockHeap, 0, NsQuery);
}

Referenced by WSALookupServiceBeginW(), and WsNqDereference().

WsNqDereference()

VOID WSAAPI WsNqDereference

(

IN PNSQUERY

Query

)

Definition at line 105 of file nsquery.c.

{
    /* Decrease the reference count and check if it's zero */
    if (!InterlockedDecrement(&Query->RefCount))
    {
        /* Delete us*/
        WsNqDelete(Query);
    }
}

Referenced by WSALookupServiceEnd(), and WSALookupServiceNextW().

WsNqInitialize()

DWORD WSAAPI WsNqInitialize

(

IN PNSQUERY

NsQuery

)

Definition at line 42 of file nsquery.c.

{
    /* Initialize the lock */
    InitializeCriticalSection(&Query->Lock);
 
    /* Set initial reference count and signature */
    Query->RefCount = 1;
    Query->Signature = 0xBEADFACE;
 
    /* Return success */
    return ERROR_SUCCESS;
}

Referenced by WSALookupServiceBeginW().

WsNqLookupServiceBegin()

DWORD WSAAPI WsNqLookupServiceBegin	(	IN PNSQUERY	NsQuery,
		IN LPWSAQUERYSETW	QuerySet,
		IN DWORD	ControlFlags,
		IN PNSCATALOG	Catalog
	)

Definition at line 347 of file nsquery.c.

{
    WSASERVICECLASSINFOW ClassInfo;
    LPWSASERVICECLASSINFOW pClassInfo = &ClassInfo;
    PNSQUERY_PROVIDER Provider, NextProvider;
    PLIST_ENTRY Entry;
    INT ErrorCode;
    DWORD ClassInfoSize;
    PNSCATALOG_ENTRY CatalogEntry = NULL;
    ENUM_CONTEXT EnumContext;
    BOOLEAN TryAgain;
 
    /* Check for RAS Auto-dial attempt */
    if (NsQuery->TryAgain)
    {
        /* Make a copy of the query set */
        ErrorCode = CopyQuerySetW(Restrictions, &NsQuery->QuerySet);
        TryAgain = (ErrorCode == ERROR_SUCCESS);
 
        /* Check if we'll try again */
        if (!TryAgain)
        {
            /* We won't, fail */
            SetLastError(ErrorCode);
            ErrorCode = SOCKET_ERROR;
            NsQuery->TryAgain = FALSE;
            goto Exit;
        }
 
        /* Cache the information for a restart */
        NsQuery->ControlFlags = ControlFlags;
        NsQuery->Catalog = Catalog;
    }
 
    /* Check if we have a specific ID */
    if (Restrictions->lpNSProviderId)
    {
        /* Get the catalog entry */
        ErrorCode = WsNcGetCatalogFromProviderId(Catalog,
                                                 Restrictions->lpNSProviderId,
                                                 &CatalogEntry);
        /* Check for failure */
        if (ErrorCode != ERROR_SUCCESS)
        {
            /* Fail */
            SetLastError(WSAEINVAL);
            ErrorCode = SOCKET_ERROR;
            goto Exit;
        }
        /* We succeeded, add this provider */
        else if (!WsNqAddProvider(NsQuery, CatalogEntry->Provider))
        {
            /* Fail */
            SetLastError(WSA_NOT_ENOUGH_MEMORY);
            ErrorCode = SOCKET_ERROR;
            goto Exit;
        }
    }
    else
    {
        /* Setup the lookup context */
        EnumContext.lpqsRestrictions = Restrictions;
        EnumContext.ErrorCode = ERROR_SUCCESS;
        EnumContext.NsQuery = NsQuery;
        EnumContext.Catalog = Catalog;
 
        /* Do a lookup for every entry */
        WsNcEnumerateCatalogItems(Catalog,
                                  WsNqBeginEnumerationProc,
                                  &EnumContext);
        ErrorCode = EnumContext.ErrorCode;
 
        /* Check for success */
        if (ErrorCode != ERROR_SUCCESS)
        {
            /* Fail */
            SetLastError(WSAEINVAL);
            ErrorCode = SOCKET_ERROR;
            goto Exit;
        }
    }
 
    /* Get the class information */
    ClassInfo.lpServiceClassId = Restrictions->lpServiceClassId;
    ErrorCode = WsNcGetServiceClassInfo(Catalog, &ClassInfoSize, pClassInfo);
 
    /* Check if more buffer space is needed */
    if ((ErrorCode == SOCKET_ERROR) && (GetLastError() == WSAEFAULT))
    {
        /* FIXME: The WS 2.2 spec hasn't been finalized yet on this... */
    }
    else
    {
        /* Assume success */
        ErrorCode = ERROR_SUCCESS;
    }
 
    /* Check if the provider list is empty */
    if (IsListEmpty(&NsQuery->ProviderList))
    {
        /* We don't have any providers to handle this! */
        ErrorCode = SOCKET_ERROR;
        SetLastError(WSASERVICE_NOT_FOUND);
        goto Exit;
    }
 
    /* Get the first provider and loop */
    Entry = NsQuery->ProviderList.Flink;
    NextProvider = CONTAINING_RECORD(Entry, NSQUERY_PROVIDER, QueryLink);
    while (NextProvider)
    {
        /* Call it */
        ErrorCode = WsNqProvLookupServiceBegin(NextProvider,
                                               Restrictions,
                                               pClassInfo,
                                               ControlFlags);
        /* Check for error */
        if (ErrorCode == SOCKET_ERROR)
        {
            /* Remove this provider, get the next one, delete the old one */
            Provider = NextProvider;
            NextProvider = WsNqNextProvider(NsQuery, NextProvider);
            RemoveEntryList(&Provider->QueryLink);
            WsNqProvDelete(Provider);
        }
        else
        {
            /* Get the next provider */
            NextProvider = WsNqNextProvider(NsQuery, NextProvider);
        }
    }
 
Exit:
    /* Check if we had an error somewhere */
    if (ErrorCode == SOCKET_ERROR)
    {
        /* Loop the list */
        while (!IsListEmpty(&NsQuery->ProviderList))
        {
            /* Remove this provider */
            Entry = RemoveHeadList(&NsQuery->ProviderList);
 
            /* Get the failed provider and delete it */
            Provider = CONTAINING_RECORD(Entry, NSQUERY_PROVIDER, QueryLink);
            WsNqProvDelete(Provider);
        }
    }
    else
    {
        /* Set the active provider */
        Entry = NsQuery->ProviderList.Flink;
        NsQuery->ActiveProvider = CONTAINING_RECORD(Entry,
                                                    NSQUERY_PROVIDER,
                                                    QueryLink);
    }
 
    /* Return */
    return ErrorCode;
}

Referenced by WSALookupServiceBeginW(), and WsNqLookupServiceNext().

WsNqLookupServiceEnd()

DWORD WSAAPI WsNqLookupServiceEnd

(

IN PNSQUERY

NsQuery

)

Definition at line 164 of file nsquery.c.

{
    PNSQUERY_PROVIDER Provider;
    PLIST_ENTRY Entry;
 
    /* Protect us from closure */
    WsNqLock();
    NsQuery->ShuttingDown = TRUE;
 
    /* Get the list and loop */
    Entry = NsQuery->ProviderList.Flink;
    while (Entry != &NsQuery->ProviderList)
    {
        /* Get the provider */
        Provider = CONTAINING_RECORD(Entry, NSQUERY_PROVIDER, QueryLink);
 
        /* Call its routine */
        WsNqProvLookupServiceEnd(Provider);
 
        /* Move to the next one */
        Entry = Entry->Flink;
    }
 
    /* Release lock and return success */
    WsNqUnlock();
    return ERROR_SUCCESS;
}

Referenced by WSALookupServiceEnd().

WsNqLookupServiceNext()

DWORD WSAAPI WsNqLookupServiceNext	(	PNSQUERY	NsQuery,
		DWORD	,
		PDWORD	,
		OUT LPWSAQUERYSETW	QuerySet
	)

Referenced by WSALookupServiceNextW().

WsNqNextProvider()

PNSQUERY_PROVIDER WSAAPI WsNqNextProvider	(	PNSQUERY	NsQuery,
		IN PNSQUERY_PROVIDER	Provider
	)

WsNqPreviousProvider()

PNSQUERY_PROVIDER WSAAPI WsNqPreviousProvider	(	IN PNSQUERY	Query,
		IN PNSQUERY_PROVIDER	Provider
	)

Definition at line 532 of file nsquery.c.

{
    PNSQUERY_PROVIDER PrevProvider = NULL;
    PLIST_ENTRY Entry;
 
    /* Get the last entry and get its provider */
    Entry = Provider->QueryLink.Blink;
    if (Entry != &Query->ProviderList)
    {
        /* Get the current provider */
        PrevProvider = CONTAINING_RECORD(Entry, NSQUERY_PROVIDER, QueryLink);
    }
 
    /* Return it */
    return PrevProvider;
}

Referenced by WsNqLookupServiceNext().

WsNqProvAllocate()

PNSQUERY_PROVIDER WSAAPI WsNqProvAllocate

(

VOID

)

Definition at line 17 of file nsprovid.c.

{
    PNSQUERY_PROVIDER Provider;
 
    /* Allocate the object */
    Provider = HeapAlloc(WsSockHeap, HEAP_ZERO_MEMORY, sizeof(*Provider));
 
    /* Return it */
    return Provider;
}

Referenced by WsNqAddProvider().

WsNqProvDelete()

VOID WSAAPI WsNqProvDelete

(

IN PNSQUERY_PROVIDER

QueryProvider

)

Definition at line 45 of file nsprovid.c.

{
    /* Check if we have a provider */
    if (QueryProvider->Provider)
    {
        /* Dereference it */
        WsNpDereference(QueryProvider->Provider);
 
        /* Clear it */
        QueryProvider->Provider = NULL;
    }
 
    /* Delete us */
    HeapFree(WsSockHeap, 0, QueryProvider);
}

Referenced by WsNqDelete(), WsNqLookupServiceBegin(), and WsNqLookupServiceNext().

WsNqProvInitialize()

DWORD WSAAPI WsNqProvInitialize	(	IN PNSQUERY_PROVIDER	QueryProvider,
		IN PNS_PROVIDER	Provider
	)

Definition at line 30 of file nsprovid.c.

{
    /* Reference the provider */
    InterlockedIncrement(&Provider->RefCount);
 
    /* Set it as our own */
    QueryProvider->Provider = Provider;
 
    /* Return success */
    return ERROR_SUCCESS;
}

Referenced by WsNqAddProvider().

WsNqProvLookupServiceBegin()

DWORD WSAAPI WsNqProvLookupServiceBegin	(	IN PNSQUERY_PROVIDER	QueryProvider,
		IN LPWSAQUERYSETW	QuerySet,
		IN LPWSASERVICECLASSINFOW	ServiceClassInfo,
		IN	DWORD
	)

Definition at line 216 of file nsprovid.c.

{
    /* Simply call the provider */
    return WsNpLookupServiceBegin(QueryProvider->Provider,
                                  Restrictions,
                                  ServiceClassInfo,
                                  ControlFlags,
                                  &QueryProvider->LookupHandle);
}

Referenced by WsNqLookupServiceBegin().

WsNqProvLookupServiceEnd()

DWORD WSAAPI WsNqProvLookupServiceEnd

(

IN PNSQUERY_PROVIDER

QueryProvider

)

Definition at line 192 of file nsprovid.c.

{
    /* Simply call the provider */
    return WsNpLookupServiceEnd(QueryProvider->Provider,
                                QueryProvider->LookupHandle);
}

Referenced by WsNqLookupServiceEnd(), and WsNqLookupServiceNext().

WsNqProvLookupServiceNext()

DWORD WSAAPI WsNqProvLookupServiceNext	(	IN PNSQUERY_PROVIDER	QueryProvider,
		DWORD	,
		PDWORD	,
		LPWSAQUERYSETW	QuerySet
	)

Referenced by WsNqLookupServiceNext().

WsNqValidateAndReference()

BOOL WSAAPI WsNqValidateAndReference

(

IN PNSQUERY

Query

)

Definition at line 57 of file nsquery.c.

{
    /* Check the signature first */
    if (Query->Signature != 0xBEADFACE) return FALSE;
 
    /* Validate the reference count */
    if (!Query->RefCount) return FALSE;
 
    /* Increase reference count */
    InterlockedIncrement(&Query->RefCount);
 
    /* Return success */
    return TRUE;
}

Referenced by WSALookupServiceEnd(), and WSALookupServiceNextW().

WsOpenRegistryRoot()

HKEY WSAAPI WsOpenRegistryRoot

(

VOID

)

Definition at line 17 of file wsautil.c.

{
    HKEY WinsockRootKey;
    INT ErrorCode;
    ULONG CreateDisposition;
 
    /* Open Registry Key */
    ErrorCode = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                             WINSOCK_ROOT,
                             0,
                             MAXIMUM_ALLOWED,
                             &WinsockRootKey);
 
    /* Check if it wasn't found */
    if (ErrorCode == ERROR_FILE_NOT_FOUND)
    {
        /* Create it */
        ErrorCode = RegCreateKeyEx(HKEY_LOCAL_MACHINE,
                                   WINSOCK_ROOT,
                                   0,
                                   NULL,
                                   REG_OPTION_NON_VOLATILE,
                                   KEY_ALL_ACCESS,
                                   NULL,
                                   &WinsockRootKey,
                                   &CreateDisposition);
    }
    else if (ErrorCode == ERROR_SUCCESS)
    {
        /* It already exists */
        CreateDisposition = REG_OPENED_EXISTING_KEY;
    }
 
    /* Check for failure */
    if (ErrorCode != ERROR_SUCCESS) return NULL;
 
    /* Check if we had to create a new key */
    if (CreateDisposition == REG_CREATED_NEW_KEY)
    {
        /* Write the Winsock Version */
        RegSetValueEx(WinsockRootKey,
                      "WinSock_Registry_Version",
                      0,
                      REG_SZ,
                      (BYTE*)"2.2",
                      4);
    }
    else
    {
        /* Read the Winsock Version */
    }
 
    /* Return the key */
    return WinsockRootKey;
}

Referenced by OpenInitializedCatalog(), WsProcInitialize(), and WsRasLoadHelperDll().

WsProcDelete()

VOID WSAAPI WsProcDelete

(

IN PWSPROCESS

Process

)

Definition at line 247 of file dprocess.c.

{
    /* Check if we didn't even initialize yet */
    if (!Process->LockReady) return;
 
    /* No more current process */
    CurrentWsProcess = NULL;
 
    /* If we have a socket table */
    if (WsSockHandleTable)
    {
        /* Enumerate the sockets with a delete callback */
        WahEnumerateHandleContexts(WsSockHandleTable,
                                   WsSockDeleteSockets,
                                   Process);
    }
 
    /* Close APC Helper */
    if (Process->ApcHelper) WahCloseApcHelper(Process->ApcHelper);
 
    /* Close handle helper */
    if (Process->HandleHelper) WahCloseHandleHelper(Process->HandleHelper);
 
    /* Check for notification helper */
    if (Process->NotificationHelper)
    {
        /* Close notification helper */
        WahCloseNotificationHandleHelper(Process->NotificationHelper);
    }
 
    /* Check if we have a protocol catalog*/
    if (Process->ProtocolCatalog)
    {
        /* Enumerate it to clean it up */
        WsTcEnumerateCatalogItems(Process->ProtocolCatalog,
                                  CleanupProtocolProviders,
                                  NULL);
 
        /* Delete it */
        WsTcDelete(Process->ProtocolCatalog);
        Process->ProtocolCatalog = NULL;
    }
 
    /* Check if we have a namespace catalog*/
    if (Process->NamespaceCatalog)
    {
        /* Enumerate it to clean it up */
        WsNcEnumerateCatalogItems(Process->NamespaceCatalog,
                                  CleanupNamespaceProviders,
                                  NULL);
 
        /* Delete it */
        WsNcDelete(Process->NamespaceCatalog);
        Process->NamespaceCatalog = NULL;
    }
 
    /* Delete the thread lock */
    DeleteCriticalSection(&Process->ThreadLock);
 
    /* Delete us */
    HeapFree(WsSockHeap, 0, Process);
}

Referenced by DllMain(), and WSACleanup().

WsProcDetachSocket()

BOOL WSAAPI WsProcDetachSocket	(	IN PWSPROCESS	Process,
		IN PWAH_HANDLE	Handle
	)

Definition at line 182 of file dprocess.c.

{
    PWSSOCKET Socket = (PWSSOCKET)Handle;
 
    /* Disassociate this socket from the table */
    WahRemoveHandleContext(WsSockHandleTable, Handle);
 
    /* If this is isn't an IFS socket */
    if (!Socket->Provider)
    {
        /* Check if we have an active handle helper */
        if (Process->HandleHelper)
        {
            /* Close it */
            WahCloseSocketHandle(Process->HandleHelper, (SOCKET)Socket->Handle);
        }
    }
 
    /* Remove a reference and return */
    WsSockDereference(Socket);
    return TRUE;
}

Referenced by WsSockDeleteSockets().

WsProcGetAsyncHelper()

INT WSAAPI WsProcGetAsyncHelper	(	IN PWSPROCESS	Process,
		OUT PHANDLE	Handle
	)

Definition at line 107 of file dprocess.c.

{
    /* Check if we have it already set up */
    if (Process->ApcHelper)
    {
        /* Just return it */
        *Handle = Process->ApcHelper;
        return ERROR_SUCCESS;
    }
    else
    {
        /* Open it for the first time */
        return WsProcOpenAsyncHelperDevice(Process, Handle);
    }
}

Referenced by WsThreadInitialize().

WsProcGetNsCatalog()

PNSCATALOG WSAAPI WsProcGetNsCatalog

(

IN PWSPROCESS

Process

)

Definition at line 166 of file dprocess.c.

{
    /* Check if the catalogs have been modified */
    if (WsCheckCatalogState(Process->NamespaceCatalogEvent))
    {
        /* Modification happened, reload them */
        WsNcRefreshFromRegistry(Process->NamespaceCatalog,
                                Process->NamespaceCatalogEvent);
    }
 
    /* Return it */
    return Process->NamespaceCatalog;
}

Referenced by WSAEnumNameSpaceProvidersInternal(), WSALookupServiceBeginW(), and WSCGetProviderPath().

WsProcGetTCatalog()

PTCATALOG WSAAPI WsProcGetTCatalog

(

IN PWSPROCESS

Process

)

Definition at line 150 of file dprocess.c.

{
    /* Check if the catalogs have been modified */
    if (WsCheckCatalogState(Process->ProtocolCatalogEvent))
    {
        /* Modification happened, reload them */
        WsTcRefreshFromRegistry(Process->ProtocolCatalog,
                                Process->ProtocolCatalogEvent);
    }
 
    /* Return it */
    return Process->ProtocolCatalog;
}

Referenced by WPUModifyIFSHandle(), WPUQueryBlockingCallback(), WSAAddressToStringA(), WSAAddressToStringW(), WSASocketW(), WSAStringToAddressA(), WSAStringToAddressW(), and WsSockFindIfsSocket().

WsProcSetVersion()

VOID WSAAPI WsProcSetVersion	(	IN PWSPROCESS	Process,
		IN WORD	VersionRequested
	)

Definition at line 312 of file dprocess.c.

{
    WORD Major, Minor;
    WORD OldMajor, OldMinor;
 
    /* Get the version data */
    Major = LOBYTE(VersionRequested);
    Minor = HIBYTE(VersionRequested);
    OldMajor = LOBYTE(Process->Version);
    OldMinor = HIBYTE(Process->Version);
 
    /* Check if we're going lower */
    if ((Major < OldMajor) || ((Major == OldMajor) && (Minor < OldMinor)))
    {
        /* Set the new version */
        Process->Version = VersionRequested;
    }
}

Referenced by WSAStartup().

WsProcStartup()

INT WSAAPI WsProcStartup

(

VOID

)

Definition at line 126 of file dprocess.c.

{
    INT ErrorCode = WSAEFAULT;
 
    /* Create a new process */
    CurrentWsProcess = WsProcAllocate();
 
    /* Initialize it */
    if (CurrentWsProcess)
    {
        /* Initialize the process */
        ErrorCode = WsProcInitialize(CurrentWsProcess);
    }
    else
    {
        /* No memory for the process object */
        ErrorCode = WSA_NOT_ENOUGH_MEMORY;
    }
 
    return ErrorCode;
}

Referenced by WSAStartup().

WsQuickProlog()

FORCEINLINE DWORD WsQuickProlog

(

VOID

)

Definition at line 892 of file ws2_32p.h.

{
    /* Try to see if we're initialized. If not, do the full prolog */
    return WsGetProcess() ? ERROR_SUCCESS : WsSlowProlog();
}

Referenced by bind(), closesocket(), getaddrinfo(), getnameinfo(), getpeername(), getsockname(), listen(), select(), shutdown(), WSAAsyncSelect(), WSAConnect(), WSADuplicateSocketW(), WSAEnumNetworkEvents(), WSAEventSelect(), WSAGetOverlappedResult(), WSAGetQOSByName(), WSAHtonl(), WSAHtons(), WSANtohl(), and WSANtohs().

WsQuickPrologTid()

FORCEINLINE DWORD WsQuickPrologTid

(

LPWSATHREADID *

Tid

)

Definition at line 900 of file ws2_32p.h.

{
    /* Try to see if we're initialized. If not, do the full prolog */
    if ((WsGetProcess()) && (*Tid = WsThreadGetThreadId(WsGetProcess())))
    {
        return ERROR_SUCCESS;
    }
    else
    {
        return WsSlowPrologTid(Tid);
    }
}

Referenced by recv(), recvfrom(), send(), sendto(), WSAIoctl(), WSARecv(), WSARecvFrom(), WSASend(), and WSASendTo().

WsRasInitializeAutodial()

VOID WSAAPI WsRasInitializeAutodial

(

VOID

)

Definition at line 47 of file rasdial.c.

{
    /* Initialize the autodial lock */
    InitializeCriticalSection(&WsRasHelperLock);
}

Referenced by DllMain().

WsRasUninitializeAutodial()

VOID WSAAPI WsRasUninitializeAutodial

(

VOID

)

Definition at line 55 of file rasdial.c.

{
    /* Acquire lock */
    WsRasLock();
 
    /* Free the library if it's loaded */
    if (WsRasDllHandle) FreeLibrary(WsRasDllHandle);
    WsRasDllHandle = NULL;
 
    /* Release and delete lock */
    WsRasUnlock();
    DeleteCriticalSection(&WsRasHelperLock);
}

Referenced by DllMain().

WsSetupCatalogProtection()

INT WSAAPI WsSetupCatalogProtection	(	IN HKEY	CatalogKey,
		IN HANDLE	CatalogEvent,
		OUT LPDWORD	UniqueId
	)

Definition at line 142 of file wsautil.c.

{
    INT ErrorCode;
    HKEY RegistryKey;
    DWORD NewUniqueId;
    CHAR KeyBuffer[32];
    DWORD RegType = REG_DWORD;
    DWORD RegSize = sizeof(DWORD);
 
    /* Start loop */
    do
    {
#if 0
        /* Ask for notifications */
        ErrorCode = RegNotifyChangeKeyValue(CatalogKey,
                                            FALSE,
                                            REG_NOTIFY_CHANGE_NAME,
                                            CatalogEvent,
                                            TRUE);
        if (ErrorCode != ERROR_SUCCESS)
        {
            /* Normalize error code */
            ErrorCode = WSASYSCALLFAILURE;
            break;
        }
#endif
 
        /* Read the current ID */
        ErrorCode = RegQueryValueEx(CatalogKey,
                                    "Serial_Access_Num",
                                    0,
                                    &RegType,
                                    (LPBYTE)&NewUniqueId,
                                    &RegSize);
        if (ErrorCode != ERROR_SUCCESS)
        {
            /* Critical failure */
            ErrorCode = WSASYSCALLFAILURE;
            break;
        }
 
        /* Try to open it for writing */
        sprintf(KeyBuffer, "%8.8lX", NewUniqueId);
        ErrorCode = RegOpenKeyEx(CatalogKey,
                                 KeyBuffer,
                                 0,
                                 MAXIMUM_ALLOWED,
                                 &RegistryKey);
 
        /* If the key doesn't exist or is being delete, that's ok for us */
        if ((ErrorCode == ERROR_FILE_NOT_FOUND) ||
            (ErrorCode == ERROR_KEY_DELETED))
        {
            /* Set success and return the new ID */
            ErrorCode = ERROR_SUCCESS;
            *UniqueId = NewUniqueId;
            break;
        }
        else if (ErrorCode != ERROR_SUCCESS)
        {
            /* Any other failure is bad */
            ErrorCode = WSASYSCALLFAILURE;
            break;
        }
 
        /* If we could actually open the key, someone is using it :/ */
        ErrorCode = RegCloseKey(RegistryKey);
 
        /* In case we break out prematurely */
        ErrorCode = WSANO_RECOVERY;
 
        /* Keep looping until they let go of the registry writing */
    } while (!WaitForSingleObject(CatalogEvent, 180 * 1000));
 
    /* Return error code */
    return ErrorCode;
}

Referenced by WsNcRefreshFromRegistry(), and WsTcRefreshFromRegistry().

WsSlowProlog()

INT WSAAPI WsSlowProlog

(

VOID

)

Definition at line 109 of file wsautil.c.

{
    PWSPROCESS Process;
    PWSTHREAD Thread;
 
    /* Call the prolog */
    return WsApiProlog(&Process, &Thread);
}

Referenced by WsQuickProlog().

WsSlowPrologTid()

INT WSAAPI WsSlowPrologTid

(

OUT LPWSATHREADID *

ThreadId

)

Definition at line 120 of file wsautil.c.

{
    PWSPROCESS Process;
    PWSTHREAD Thread;
    INT ErrorCode;
 
    /* Call the prolog */
    ErrorCode = WsApiProlog(&Process, &Thread);
 
    /* Check for success */
    if (ErrorCode == ERROR_SUCCESS)
    {
        /* Return the Thread ID */
        *ThreadId = &Thread->WahThreadId;
    }
 
    /* Return status */
    return ErrorCode;
}

Referenced by WsQuickPrologTid().

WsSockAddApiReference()

INT WSAAPI WsSockAddApiReference

(

IN SOCKET

Handle

)

Definition at line 159 of file dsocket.c.

{
    PWSSOCKET Socket;
 
    /* Get the Socket now */
    if ((Socket = WsSockGetSocketNoExport(Handle)))
    {
        /* Mark it as an API Socket */
        if (Socket) Socket->ApiSocket = TRUE;
 
        /* Remove a reference and return */
        WsSockDereference(Socket);
        return ERROR_SUCCESS;
    }
 
    /* Return error */
    return WSASYSCALLFAILURE;
}

Referenced by WSAAccept(), WSAJoinLeaf(), and WSASocketW().

WsSockAllocate()

PWSSOCKET WSAAPI WsSockAllocate

(

VOID

)

Definition at line 48 of file dsocket.c.

{
    PWSSOCKET Socket;
 
    /* Allocate the socket object */
    Socket = HeapAlloc(WsSockHeap, HEAP_ZERO_MEMORY, sizeof(*Socket));
    if (Socket)
    {
        /* Setup default non-zero values */
        Socket->RefCount = 2;
        Socket->Overlapped = TRUE;
    }
 
    /* Return it */
    return Socket;
}

Referenced by WPUModifyIFSHandle().

WsSockAssociateHandle()

INT WSAAPI WsSockAssociateHandle	(	IN PWSSOCKET	Socket,
		IN SOCKET	Handle,
		IN BOOLEAN	IsProvider
	)

Definition at line 225 of file dsocket.c.

{
    INT ErrorCode = ERROR_SUCCESS;
    PWSSOCKET OldSocket;
 
    /* Save the socket and provider */
    Socket->IsProvider = IsProvider;
    Socket->Handle = (HANDLE)Handle;
 
    /* Insert it into the handle table */
    OldSocket = (PWSSOCKET)WahInsertHandleContext(WsSockHandleTable,
                                                  (PWAH_HANDLE)Socket);
 
    /* Check if a socket already existed */
    if (OldSocket != Socket)
    {
        /* We'll dereference it */
        WsSockDereference(OldSocket);
    }
    else if (!OldSocket)
    {
        /* No memory to allocate it */
        ErrorCode = WSAENOBUFS;
    }
 
    /* Return */
    return ErrorCode;
}

Referenced by WPUModifyIFSHandle().

WsSockCleanup()

VOID WSAAPI WsSockCleanup

(

VOID

)

Definition at line 36 of file dsocket.c.

{
    /* Check if we have a socket table */
    if (WsSockHandleTable)
    {
        /* Destroy it */
        WahDestroyHandleContextTable(WsSockHandleTable);
    }
}

Referenced by DllMain().

WsSockDeleteSockets()

BOOL WSAAPI WsSockDeleteSockets	(	IN LPVOID	Context,
		IN PWAH_HANDLE	Handle
	)

Definition at line 180 of file dsocket.c.

{
    /* Call the detach routine */
    return WsProcDetachSocket((PWSPROCESS)Context, Handle);
}

Referenced by WsProcDelete().

WsSockDereference()

VOID WSAAPI WsSockDereference

(

IN PWSSOCKET

Socket

)

Definition at line 205 of file dsocket.c.

{
    /* Dereference and check if it's now 0 */
    if (!(InterlockedDecrement(&Socket->RefCount)))
    {
        /* We can delete the Provider now */
        WsSockDelete(Socket);
    }
}

Referenced by bind(), closesocket(), connect(), getpeername(), getsockname(), getsockopt(), listen(), recv(), recvfrom(), select(), send(), sendto(), setsockopt(), shutdown(), WPUModifyIFSHandle(), WSAAccept(), WSAAsyncSelect(), WSAConnect(), WSADuplicateSocketW(), WSAEnumNetworkEvents(), WSAEventSelect(), WSAGetOverlappedResult(), WSAGetQOSByName(), WSAHtonl(), WSAHtons(), WSAIoctl(), WSAJoinLeaf(), WSANtohl(), WSANtohs(), WSARecv(), WSARecvDisconnect(), WSARecvFrom(), WSASend(), WSASendDisconnect(), WSASendTo(), WsProcDetachSocket(), WsSockAddApiReference(), and WsSockAssociateHandle().

WsSockDisassociateHandle()

INT WSAAPI WsSockDisassociateHandle

(

IN PWSSOCKET

Socket

)

Definition at line 217 of file dsocket.c.

{
    /* Remove it from the list */
    return WahRemoveHandleContext(WsSockHandleTable, (PWAH_HANDLE)Socket);
}

Referenced by closesocket().

WsSockGetSocket()

PWSSOCKET WSAAPI WsSockGetSocket

(

IN SOCKET

Handle

)

Definition at line 140 of file dsocket.c.

{
    PWSSOCKET Socket;
 
    /* Let WAH do the translation */
    if ((WsSockHandleTable != NULL) &&
        (Socket = (PWSSOCKET)WahReferenceContextByHandle(WsSockHandleTable, (HANDLE)Handle)))
    {
        return Socket;
    }
    else
    {
        /* WAH didn't find it, use IFS */
        return WsSockFindIfsSocket(Handle);
    }
}

Referenced by bind(), closesocket(), connect(), getpeername(), getsockname(), getsockopt(), listen(), recv(), recvfrom(), select(), send(), sendto(), setsockopt(), shutdown(), WSAAccept(), WSAAsyncSelect(), WSAConnect(), WSADuplicateSocketW(), WSAEnumNetworkEvents(), WSAEventSelect(), WSAGetOverlappedResult(), WSAGetQOSByName(), WSAHtonl(), WSAHtons(), WSAIoctl(), WSAJoinLeaf(), WSANtohl(), WSANtohs(), WSARecv(), WSARecvDisconnect(), WSARecvFrom(), WSASend(), WSASendDisconnect(), and WSASendTo().

WsSockInitialize()

INT WSAAPI WsSockInitialize	(	IN PWSSOCKET	Socket,
		IN PTCATALOG_ENTRY	CatalogEntry
	)

Definition at line 67 of file dsocket.c.

{
    PWSTHREAD CurrentThread;
 
    /* Associate this catalog and reference it */
    Socket->CatalogEntry = CatalogEntry;
    InterlockedIncrement(&CatalogEntry->RefCount);
 
    /* Associate the Provider and Process Objects */
    Socket->Provider = CatalogEntry->Provider;
 
    /* Get the current Thread Object */
    if ((CurrentThread = TlsGetValue(TlsIndex)))
    {
        /* Set the overlapped mode */
        Socket->Overlapped = (CurrentThread->OpenType == 0);
    }
 
    /* Return status */
    return ERROR_SUCCESS;
}

Referenced by WPUModifyIFSHandle().

WsSockStartup()

INT WSAAPI WsSockStartup

(

VOID

)

Definition at line 21 of file dsocket.c.

{
    /* Check if we have a socket table */
    if (!WsSockHandleTable)
    {
        /* Create it */
        return WahCreateHandleContextTable(&WsSockHandleTable);
    }
 
    /* Nothing to do */
    return NO_ERROR;
}

Referenced by WSAStartup().

WsTcAllocate()

PTCATALOG WSAAPI WsTcAllocate

(

VOID

)

Definition at line 25 of file dcatalog.c.

{
    PTCATALOG Catalog;
 
    /* Allocate the object */
    Catalog = HeapAlloc(WsSockHeap, HEAP_ZERO_MEMORY, sizeof(*Catalog));
 
    /* Return it */
    return Catalog;
}

Referenced by OpenInitializedCatalog(), and WsProcInitialize().

WsTcDelete()

VOID WSAAPI WsTcDelete

(

IN PTCATALOG

Catalog

)

Definition at line 883 of file dcatalog.c.

{
    PLIST_ENTRY Entry;
    PTCATALOG_ENTRY CatalogEntry;
 
    /* Check if we're initialized */
    if (!Catalog->ProtocolList.Flink) return;
 
    /* Acquire lock */
    WsTcLock();
 
    /* Loop every entry */
    Entry = Catalog->ProtocolList.Flink;
    while (Entry != &Catalog->ProtocolList)
    {
        /* Get this entry */
        CatalogEntry = CONTAINING_RECORD(Entry, TCATALOG_ENTRY, CatalogLink);
 
        /* Remove it and dereference it */
        WsTcRemoveCatalogItem(Catalog, CatalogEntry);
        WsTcEntryDereference(CatalogEntry);
 
        /* Move to the next entry */
        Entry = Catalog->ProtocolList.Flink;
    }
 
    /* Check if the catalog key is opened */
    if (Catalog->CatalogKey)
    {
        /* Close it */
        RegCloseKey(Catalog->CatalogKey);
        Catalog->CatalogKey = NULL;
    }
 
    /* Release and delete the lock */
    WsTcUnlock();
    DeleteCriticalSection(&Catalog->Lock);
 
    /* Delete the object */
    HeapFree(WsSockHeap, 0, Catalog);
}

Referenced by WSCEnumProtocols(), and WsProcDelete().

WsTcEntryAllocate()

PTCATALOG_ENTRY WSAAPI WsTcEntryAllocate

(

VOID

)

Definition at line 17 of file dcatitem.c.

{
    PTCATALOG_ENTRY CatalogEntry;
 
    /* Allocate the catalog entry */
    CatalogEntry = HeapAlloc(WsSockHeap, HEAP_ZERO_MEMORY, sizeof(*CatalogEntry));
    if (CatalogEntry)
    {
        /* Set the default non-null members */
        CatalogEntry->RefCount = 1;
    }
 
    /* Return it */
    return CatalogEntry;
}

Referenced by WsTcRefreshFromRegistry().

WsTcEntryDelete()

VOID WSAAPI WsTcEntryDelete

(

IN PTCATALOG_ENTRY

CatalogEntry

)

Definition at line 35 of file dcatitem.c.

{
    /* Check if a provider is loaded */
    if (CatalogEntry->Provider)
    {
        /* Dereference it too */
        WsTpDereference(CatalogEntry->Provider);
        CatalogEntry->Provider = NULL;
    }
 
    /* Delete us */
    HeapFree(WsSockHeap, 0, CatalogEntry);
}

Referenced by WsTcEntryDereference().

WsTcEntryDereference()

VOID WSAAPI WsTcEntryDereference

(

IN PTCATALOG_ENTRY

CatalogEntry

)

Definition at line 51 of file dcatitem.c.

{
    /* Dereference and check if it's now 0 */
    if (!(InterlockedDecrement(&CatalogEntry->RefCount)))
    {
        /* We can delete the Provider now */
        WsTcEntryDelete(CatalogEntry);
    }
}

Referenced by WPUModifyIFSHandle(), WPUQueryBlockingCallback(), WSAAddressToStringA(), WSAAddressToStringW(), WSASocketW(), WSAStringToAddressA(), WSAStringToAddressW(), WsSockDelete(), WsTcDelete(), WsTcFindIfsProviderForSocket(), WsTcRefreshFromRegistry(), and WsTcUpdateProtocolList().

WsTcEntryInitializeFromRegistry()

DWORD WSAAPI WsTcEntryInitializeFromRegistry	(	IN PTCATALOG_ENTRY	CatalogEntry,
		IN	HKEY,
		unsigned long
	)

Referenced by WsTcRefreshFromRegistry().

WsTcEntrySetProvider()

VOID WSAAPI WsTcEntrySetProvider	(	IN PTCATALOG_ENTRY	CatalogEntry,
		IN PTPROVIDER	Provider
	)

Definition at line 121 of file dcatitem.c.

{
    /* Reference the provider */
    InterlockedIncrement(&Provider->RefCount);
 
    /* Set it */
    Entry->Provider = Provider;
}

Referenced by WsTcLoadProvider().

WsTcEnumerateCatalogItems()

VOID WSAAPI WsTcEnumerateCatalogItems	(	IN PTCATALOG	Catalog,
		IN PTCATALOG_ENUMERATE_PROC	Callback,
		IN PVOID	Context
	)

Definition at line 750 of file dcatalog.c.

{
    PLIST_ENTRY Entry;
    PTCATALOG_ENTRY CatalogEntry;
    BOOL GoOn = TRUE;
 
    /* Lock the catalog */
    WsTcLock();
 
    /* Loop the entries */
    Entry = Catalog->ProtocolList.Flink;
    while (GoOn && (Entry != &Catalog->ProtocolList))
    {
        /* Get the entry */
        CatalogEntry = CONTAINING_RECORD(Entry, TCATALOG_ENTRY, CatalogLink);
 
        /* Move to the next one and call the callback */
        Entry = Entry->Flink;
        GoOn = Callback(Context, CatalogEntry);
    }
 
    /* Release lock */
    WsTcUnlock();
}

Referenced by WSCEnumProtocols(), and WsProcDelete().

WsTcFindIfsProviderForSocket()

DWORD WSAAPI WsTcFindIfsProviderForSocket	(	IN PTCATALOG	TCatalog,
		SOCKET	Socket
	)

Referenced by WsSockFindIfsSocket().

WsTcFindProvider()

PTPROVIDER WSAAPI WsTcFindProvider	(	IN PTCATALOG	TCatalog,
		IN LPGUID	ProviderId
	)

Definition at line 596 of file dcatalog.c.

{
    PTPROVIDER Provider;
    PLIST_ENTRY Entry;
    PTCATALOG_ENTRY CatalogEntry;
 
    /* Loop the provider list */
    Entry = Catalog->ProtocolList.Flink;
    while (Entry != &Catalog->ProtocolList)
    {
        /* Get the entry */
        CatalogEntry = CONTAINING_RECORD(Entry, TCATALOG_ENTRY, CatalogLink);
 
        /* Move to the next one, get the provider */
        Entry = Entry->Flink;
        Provider = CatalogEntry->Provider;
 
        /* Check for a match */
        if (Provider &&
            IsEqualGUID(&CatalogEntry->ProtocolInfo.ProviderId, ProviderId))
        {
            /* Found a match */
            return Provider;
        }
    }
 
    /* No match here */
    return NULL;
}

Referenced by WsTcLoadProvider().

WsTcGetEntryFromAf()

DWORD WSAAPI WsTcGetEntryFromAf	(	IN PTCATALOG	TCatalog,
		IN INT	AddressFamily,
		IN PTCATALOG_ENTRY *	CatalogEntry
	)

Definition at line 403 of file dcatalog.c.

{
    INT ErrorCode = WSAEINVAL;
    PLIST_ENTRY NextEntry;
    PTCATALOG_ENTRY Entry;
 
    /* Assume failure */
    *CatalogEntry = NULL;
 
    /* Lock the catalog */
    WsTcLock();
 
    /* Match the Id with all the entries in the List */
    NextEntry = Catalog->ProtocolList.Flink;
    while (NextEntry != &Catalog->ProtocolList)
    {
        /* Get the Current Entry */
        Entry = CONTAINING_RECORD(NextEntry, TCATALOG_ENTRY, CatalogLink);
        NextEntry = NextEntry->Flink;
 
        /* Check if this is the Catalog Entry ID we want */
        if (Entry->ProtocolInfo.iAddressFamily == AddressFamily)
        {
            /* Check if it doesn't already have a provider */
            if (!Entry->Provider)
            {
                /* Match, load the Provider */
                ErrorCode = WsTcLoadProvider(Catalog, Entry);
 
                /* Make sure this didn't fail */
                if (ErrorCode != ERROR_SUCCESS) break;
            }
 
            /* Reference the entry and return it */
            InterlockedIncrement(&Entry->RefCount);
            *CatalogEntry = Entry;
            ErrorCode = ERROR_SUCCESS;
            break;
        }
    }
 
    /* Release the catalog */
    WsTcUnlock();
 
    /* Return */
    return ErrorCode;
}

Referenced by WSAAddressToStringA(), WSAAddressToStringW(), WSAStringToAddressA(), and WSAStringToAddressW().

WsTcGetEntryFromCatalogEntryId()

DWORD WSAAPI WsTcGetEntryFromCatalogEntryId	(	IN PTCATALOG	TCatalog,
		IN DWORD	CatalogEntryId,
		IN PTCATALOG_ENTRY *	CatalogEntry
	)

Definition at line 455 of file dcatalog.c.

{
    INT ErrorCode = WSAEINVAL;
    PLIST_ENTRY NextEntry;
    PTCATALOG_ENTRY Entry;
 
    /* Lock the catalog */
    WsTcLock();
 
    /* Match the Id with all the entries in the List */
    NextEntry = Catalog->ProtocolList.Flink;
    while (NextEntry != &Catalog->ProtocolList)
    {
        /* Get the Current Entry */
        Entry = CONTAINING_RECORD(NextEntry, TCATALOG_ENTRY, CatalogLink);
        NextEntry = NextEntry->Flink;
 
        /* Check if this is the Catalog Entry ID we want */
        if (Entry->ProtocolInfo.dwCatalogEntryId == CatalogEntryId)
        {
            /* Check if it doesn't already have a provider */
            if (!Entry->Provider)
            {
                /* Match, load the Provider */
                WsTcLoadProvider(Catalog, Entry);
            }
 
            /* Reference the entry and return it */
            InterlockedIncrement(&Entry->RefCount);
            *CatalogEntry = Entry;
            ErrorCode = ERROR_SUCCESS;
            break;
        }
    }
 
    /* Release the catalog */
    WsTcUnlock();
 
    /* Return */
    return ErrorCode;
}

Referenced by WPUModifyIFSHandle(), WPUQueryBlockingCallback(), WSAAddressToStringA(), WSAAddressToStringW(), WSASocketW(), WSAStringToAddressA(), and WSAStringToAddressW().

WsTcGetEntryFromTriplet()

DWORD WSAAPI WsTcGetEntryFromTriplet	(	IN PTCATALOG	TCatalog,
		IN INT	AddressFamily,
		IN INT	SocketType,
		IN INT	Protocol,
		IN DWORD	StartId,
		IN PTCATALOG_ENTRY *	CatalogEntry
	)

Definition at line 501 of file dcatalog.c.

{
    INT ErrorCode = WSAEINVAL;
    PLIST_ENTRY NextEntry;
    PTCATALOG_ENTRY Entry;
    DPRINT("WsTcGetEntryFromTriplet: %lx, %lx, %lx, %lx\n", af, type, protocol, StartId);
 
    /* Assume failure */
    *CatalogEntry = NULL;
 
    /* Lock the catalog */
    WsTcLock();
 
    NextEntry = Catalog->ProtocolList.Flink;
 
    /* Check if we are starting past 0 */
    if (StartId)
    {
        /* Loop the list */
        while (NextEntry != &Catalog->ProtocolList)
        {
            /* Get the Current Entry */
            Entry = CONTAINING_RECORD(NextEntry, TCATALOG_ENTRY, CatalogLink);
            NextEntry = NextEntry->Flink;
 
            /* Check if this is the ID where we are starting */
            if (Entry->ProtocolInfo.dwCatalogEntryId == StartId) break;
        }
    }
 
    /* Match the Id with all the entries in the List */
    while (NextEntry != &Catalog->ProtocolList)
    {
        /* Get the Current Entry */
        Entry = CONTAINING_RECORD(NextEntry, TCATALOG_ENTRY, CatalogLink);
        NextEntry = NextEntry->Flink;
 
        /* Check if Address Family Matches or if it's wildcard */
        if ((Entry->ProtocolInfo.iAddressFamily == af) || (af == AF_UNSPEC))
        {
            /* Check if Socket Type Matches or if it's wildcard */
            if ((Entry->ProtocolInfo.iSocketType == type) || (type == 0))
            {
                /* Check if Protocol is In Range or if it's wildcard */
                if (((Entry->ProtocolInfo.iProtocol <= protocol) &&
                    ((Entry->ProtocolInfo.iProtocol +
                      Entry->ProtocolInfo.iProtocolMaxOffset) >= protocol)) ||
                    (protocol == 0))
                {
                    /* Check if it doesn't already have a provider */
                    if (!Entry->Provider)
                    {
                        /* Match, load the Provider */
                        ErrorCode = WsTcLoadProvider(Catalog, Entry);
 
                        /* Make sure this didn't fail */
                        if (ErrorCode != ERROR_SUCCESS) break;
                    }
 
                    /* Reference the entry and return it */
                    InterlockedIncrement(&Entry->RefCount);
                    *CatalogEntry = Entry;
                    ErrorCode = ERROR_SUCCESS;
                    break;
                }
                else
                {
                    ErrorCode = WSAEPROTONOSUPPORT;
                }
            }
            else
            {
                ErrorCode = WSAESOCKTNOSUPPORT;
            }
        }
        else
        {
            ErrorCode = WSAEAFNOSUPPORT;
        }
    }
 
    /* Release the catalog */
    WsTcUnlock();
 
    /* Return */
    return ErrorCode;
}

Referenced by WSASocketW().

WsTcInitializeFromRegistry()

DWORD WSAAPI WsTcInitializeFromRegistry	(	IN PTCATALOG	TCatalog,
		HKEY	,
		PVOID
	)

Referenced by OpenInitializedCatalog(), and WsProcInitialize().

WsTcLoadProvider()

DWORD WSAAPI WsTcLoadProvider	(	IN PTCATALOG	TCatalog,
		IN PTCATALOG_ENTRY	CatalogEntry
	)

Definition at line 629 of file dcatalog.c.

{
    INT ErrorCode = ERROR_SUCCESS;
    PTPROVIDER Provider;
    DPRINT("WsTcLoadProvider: %p, %p\n", Catalog, CatalogEntry);
 
    /* Lock the catalog */
    WsTcLock();
 
    /* Check if we have a provider already */
    if (!CatalogEntry->Provider)
    {
        /* Try to find another instance */
        Provider = WsTcFindProvider(Catalog,
                                    &CatalogEntry->ProtocolInfo.ProviderId);
 
        /* Check if we found one now */
        if (Provider)
        {
            /* Set this one as the provider */
            WsTcEntrySetProvider(CatalogEntry, Provider);
            ErrorCode = ERROR_SUCCESS;
        }
        else
        {
            /* Nothing found, Allocate a provider */
            if ((Provider = WsTpAllocate()))
            {
                /* Initialize it */
                ErrorCode = WsTpInitialize(Provider,
                                           CatalogEntry->DllPath,
                                           &CatalogEntry->ProtocolInfo);
 
                /* Ensure success */
                if (ErrorCode == ERROR_SUCCESS)
                {
                    /* Set the provider */
                    WsTcEntrySetProvider(CatalogEntry, Provider);
                }
 
                /* Dereference it */
                WsTpDereference(Provider);
            }
            else
            {
                /* No memory */
                ErrorCode = WSA_NOT_ENOUGH_MEMORY;
            }
        }
    }
 
    /* Release the lock */
    WsTcUnlock();
    return ErrorCode;
}

Referenced by WsTcFindIfsProviderForSocket(), WsTcGetEntryFromAf(), WsTcGetEntryFromCatalogEntryId(), and WsTcGetEntryFromTriplet().

WsTcOpen()

BOOL WSAAPI WsTcOpen	(	IN PTCATALOG	TCatalog,
		IN	HKEY
	)

Definition at line 38 of file dcatalog.c.

{
    INT ErrorCode;
    DWORD CreateDisposition;
    HKEY CatalogKey, NewKey;
    //DWORD CatalogEntries = 0;
    DWORD RegType = REG_DWORD;
    DWORD RegSize = sizeof(DWORD);
    DWORD UniqueId = 0;
    DWORD NewData = 0;
    CHAR* CatalogKeyName;
 
    /* Initialize the catalog lock and namespace list */
    InitializeCriticalSection(&Catalog->Lock);
    InitializeListHead(&Catalog->ProtocolList);
 
    /* Read the catalog name */
    ErrorCode = RegQueryValueEx(ParentKey,
                                "Current_Protocol_Catalog",
                                0,
                                &RegType,
                                NULL,
                                &RegSize);
    if (ErrorCode == ERROR_FILE_NOT_FOUND)
    {
        static const CHAR DefaultCatalogName[] = "Protocol_Catalog9";
        RegSize = sizeof(DefaultCatalogName);
        CatalogKeyName = HeapAlloc(WsSockHeap, 0, RegSize);
        memcpy(CatalogKeyName, DefaultCatalogName, RegSize);
    }
    else
    {
        if (ErrorCode != ERROR_SUCCESS)
        {
            DPRINT1("Failed to get protocol catalog name: %d.\n", ErrorCode);
            return FALSE;
        }
 
        if (RegType != REG_SZ)
        {
            DPRINT1("Protocol catalog name is not a string (Type %d).\n", RegType);
            return FALSE;
        }
 
        CatalogKeyName = HeapAlloc(WsSockHeap, 0, RegSize);
 
        /* Read the catalog name */
        ErrorCode = RegQueryValueEx(ParentKey,
                                    "Current_Protocol_Catalog",
                                    0,
                                    &RegType,
                                    (LPBYTE)CatalogKeyName,
                                    &RegSize);
 
        /* Open the Catalog Key */
        ErrorCode = RegOpenKeyEx(ParentKey,
                                 CatalogKeyName,
                                 0,
                                 MAXIMUM_ALLOWED,
                                 &CatalogKey);
    }
 
    /* If we didn't find the key, create it */
    if (ErrorCode == ERROR_SUCCESS)
    {
        /* Fake that we opened an existing key */
        CreateDisposition = REG_OPENED_EXISTING_KEY;
    }
    else if (ErrorCode == ERROR_FILE_NOT_FOUND)
    {
        /* Create the Catalog Name */
        ErrorCode = RegCreateKeyEx(ParentKey,
                                   CatalogKeyName,
                                   0,
                                   NULL,
                                   REG_OPTION_NON_VOLATILE,
                                   KEY_ALL_ACCESS,
                                   NULL,
                                   &CatalogKey,
                                   &CreateDisposition);
    }
 
    HeapFree(WsSockHeap, 0, CatalogKeyName);
    RegType = REG_DWORD;
    RegSize = sizeof(DWORD);
 
    /* Fail if that didn't work */
    if (ErrorCode != ERROR_SUCCESS) return FALSE;
 
    /* Check if we had to create the key */
    if (CreateDisposition == REG_CREATED_NEW_KEY)
    {
        /* Write the count of entries (0 now) */
        ErrorCode = RegSetValueEx(CatalogKey,
                                  "Num_Catalog_Entries",
                                  0,
                                  REG_DWORD,
                                  (LPBYTE)&NewData,
                                  sizeof(NewData));
        if (ErrorCode != ERROR_SUCCESS)
        {
            /* Close the key and fail */
            RegCloseKey(CatalogKey);
            return FALSE;
        }
 
        /* Write the first catalog entry ID */
        NewData = 1001;
        ErrorCode = RegSetValueEx(CatalogKey,
                                  "Next_Catalog_Entry_ID",
                                  0,
                                  REG_DWORD,
                                  (LPBYTE)&NewData,
                                  sizeof(NewData));
        if (ErrorCode != ERROR_SUCCESS)
        {
            /* Close the key and fail */
            RegCloseKey(CatalogKey);
            return FALSE;
        }
 
        /* Write the first catalog entry Uniqe ID */
        NewData = 1;
        ErrorCode = RegSetValueEx(CatalogKey,
                                  "Serial_Access_Num",
                                  0,
                                  REG_DWORD,
                                  (LPBYTE)&NewData,
                                  sizeof(NewData));
        if (ErrorCode != ERROR_SUCCESS)
        {
            /* Close the key and fail */
            RegCloseKey(CatalogKey);
            return FALSE;
        }
 
        /* Create a key for this entry */
        ErrorCode = RegCreateKeyEx(CatalogKey,
                                   "Catalog_Entries",
                                   0,
                                   NULL,
                                   REG_OPTION_NON_VOLATILE,
                                   KEY_ALL_ACCESS,
                                   NULL,
                                   &NewKey,
                                   &CreateDisposition);
        if (ErrorCode != ERROR_SUCCESS)
        {
            /* Close the key and fail */
            RegCloseKey(CatalogKey);
            return FALSE;
        }
 
        /* Close the key since we don't need it */
        RegCloseKey(NewKey);
    }
    else
    {
        RegSize = sizeof(DWORD);
        /* Read the serial number */
        ErrorCode = RegQueryValueEx(CatalogKey,
                                    "Serial_Access_Num",
                                    0,
                                    &RegType,
                                    (LPBYTE)&UniqueId,
                                    &RegSize);
 
        /* Check if it's missing for some reason */
        if (ErrorCode != ERROR_SUCCESS)
        {
            /* Write the first catalog entry Unique ID */
            NewData = 1;
            ErrorCode = RegSetValueEx(CatalogKey,
                                      "Serial_Access_Num",
                                      0,
                                      REG_DWORD,
                                      (LPBYTE)&NewData,
                                      sizeof(NewData));
        }
    }
 
    /* Set the Catalog Key */
    Catalog->CatalogKey = CatalogKey;
    return TRUE;
}

Referenced by WsTcInitializeFromRegistry().

WsTcRefreshFromRegistry()

DWORD WSAAPI WsTcRefreshFromRegistry	(	IN PTCATALOG	TCatalog,
		PVOID
	)

Referenced by WsProcGetTCatalog().

WsTcUpdateProtocolList()

VOID WSAAPI WsTcUpdateProtocolList	(	IN PTCATALOG	TCatalog,
		PLIST_ENTRY	ProtocolList
	)

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().

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 *	Thread
	)

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().

WsTpAllocate()

PTPROVIDER WSAAPI WsTpAllocate

(

VOID

)

Definition at line 20 of file dprovide.c.

{
    PTPROVIDER Provider;
 
    /* Allocate the object */
    Provider = HeapAlloc(WsSockHeap, HEAP_ZERO_MEMORY, sizeof(*Provider));
    if (Provider)
    {
        /* Setup non-zero data */
        Provider->RefCount = 1;
    }
 
    /* Return it */
    return Provider;
}

Referenced by WsTcLoadProvider().

WsTpDelete()

VOID WSAAPI WsTpDelete

(

IN PTPROVIDER

Provider

)

Definition at line 122 of file dprovide.c.

{
    INT ErrorCode;
 
    /* Make sure we have a loaded handle */
    if (Provider->DllHandle)
    {
        /* Clean us up */
        WsTpWSPCleanup(Provider, &ErrorCode);
 
        /* Unload the library */
        FreeLibrary(Provider->DllHandle);
        Provider->DllHandle = NULL;
    }
 
    /* Delete us */
    HeapFree(WsSockHeap, 0, Provider);
}

Referenced by WsTpDereference().

WsTpDereference()

VOID WSAAPI WsTpDereference

(

IN PTPROVIDER

Provider

)

Definition at line 143 of file dprovide.c.

{
    /* Decrease the reference count and check if it's zero */
    if (!InterlockedDecrement(&Provider->RefCount))
    {
        /* Delete us*/
        WsTpDelete(Provider);
    }
}

Referenced by WsTcEntryDelete(), and WsTcLoadProvider().

WsTpInitialize()

DWORD WSAAPI WsTpInitialize	(	IN PTPROVIDER	Provider,
		IN LPSTR	DllName,
		LPWSAPROTOCOL_INFOW	ProtocolInfo
	)

Referenced by WsTcLoadProvider().

WsTpWSPCleanup()

DWORD WSAAPI WsTpWSPCleanup	(	IN PTPROVIDER	Provider,
		int *
	)

Referenced by CleanupProtocolProviders().

Variable Documentation

CurrentWsProcess

PWSPROCESS CurrentWsProcess

extern

Definition at line 15 of file dprocess.c.

Referenced by WsGetProcess(), WsProcDelete(), and WsProcStartup().

GlobalTlsIndex

DWORD GlobalTlsIndex

extern

Definition at line 23 of file dllmain.c.

Referenced by DllMain().

WsAsyncThreadInitialized

BOOLEAN WsAsyncThreadInitialized

extern

Definition at line 15 of file async.c.

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

WsDllHandle

HINSTANCE WsDllHandle

extern

Definition at line 22 of file dllmain.c.

Referenced by DllMain(), and WSAStartup().

WsSockHandleTable

PWAH_HANDLE_TABLE WsSockHandleTable

extern

Definition at line 15 of file dsocket.c.

Referenced by WsProcDelete(), WsProcDetachSocket(), WsSockAssociateHandle(), WsSockCleanup(), WsSockDisassociateHandle(), WsSockGetSocket(), WsSockGetSocketNoExport(), and WsSockStartup().

WsSockHeap

HANDLE WsSockHeap

extern

Definition at line 21 of file dllmain.c.

Referenced by AnsiDupFromUnicode(), ConvertAddrinfoFromUnicodeToAnsi(), CopyQuerySetW(), DllMain(), freeaddrinfo(), getaddrinfo(), GetAddrInfoW(), gethostbyaddr(), gethostbyname(), gethostname(), GetProtoOpenNetworkDatabase(), getservbyname(), getservbyport(), getxyDataEnt(), LookupAddressForName(), MapAnsiQuerySetToUnicode(), MapUnicodeQuerySetToAnsi(), NewAddrInfo(), UnicodeDupFromAnsi(), WSAAddressToStringA(), WSAEnumProtocolsA(), WSALookupServiceBeginA(), WSALookupServiceNextA(), WSAStringToAddressA(), WsAsyncAllocateBlock(), WsAsyncCheckAndInitThread(), WsAsyncFreeBlock(), WsAsyncThread(), WsNcAllocate(), WsNcDelete(), WsNcEntryAllocate(), WsNcEntryDelete(), WsNcEntryInitializeFromRegistry(), WsNcOpen(), WsNpAllocate(), WsNpDelete(), WsNqAllocate(), WsNqDelete(), WsNqProvAllocate(), WsNqProvDelete(), WsProcAllocate(), WsProcDelete(), WsSockAllocate(), WsSockDelete(), WsTcAllocate(), WsTcDelete(), WsTcEntryAllocate(), WsTcEntryDelete(), WsTcEntryInitializeFromRegistry(), WsTcOpen(), WsThreadAllocate(), WsThreadBlobToHostent(), WsThreadBlobToServent(), WsThreadDelete(), WsThreadGetProtoBuffer(), WsTpAllocate(), and WsTpDelete().

WsSockPostRoutine

PWS_SOCK_POST_ROUTINE WsSockPostRoutine

extern

Definition at line 18 of file startup.c.

Referenced by WPUPostMessage(), and WSApSetPostRoutine().