dcatalog.c File Reference

#include <ws2_32.h>
#include <debug.h>

Include dependency graph for dcatalog.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	WsTcLock()   EnterCriticalSection(&Catalog->Lock)
#define	WsTcUnlock()   LeaveCriticalSection(&Catalog->Lock)

Functions
PTCATALOG WSAAPI	WsTcAllocate (VOID)
BOOL WSAAPI	WsTcOpen (IN PTCATALOG Catalog, IN HKEY ParentKey)
DWORD WSAAPI	WsTcInitializeFromRegistry (IN PTCATALOG Catalog, IN HKEY ParentKey, IN HANDLE CatalogEvent)
DWORD WSAAPI	WsTcRefreshFromRegistry (IN PTCATALOG Catalog, IN HANDLE CatalogEvent)
DWORD WSAAPI	WsTcGetEntryFromAf (IN PTCATALOG Catalog, IN INT AddressFamily, IN PTCATALOG_ENTRY *CatalogEntry)
DWORD WSAAPI	WsTcGetEntryFromCatalogEntryId (IN PTCATALOG Catalog, IN DWORD CatalogEntryId, IN PTCATALOG_ENTRY *CatalogEntry)
DWORD WSAAPI	WsTcGetEntryFromTriplet (IN PTCATALOG Catalog, IN INT af, IN INT type, IN INT protocol, IN DWORD StartId, IN PTCATALOG_ENTRY *CatalogEntry)
PTPROVIDER WSAAPI	WsTcFindProvider (IN PTCATALOG Catalog, IN LPGUID ProviderId)
DWORD WSAAPI	WsTcLoadProvider (IN PTCATALOG Catalog, IN PTCATALOG_ENTRY CatalogEntry)
VOID WSAAPI	WsTcUpdateProtocolList (IN PTCATALOG Catalog, IN PLIST_ENTRY List)
VOID WSAAPI	WsTcEnumerateCatalogItems (IN PTCATALOG Catalog, IN PTCATALOG_ENUMERATE_PROC Callback, IN PVOID Context)
DWORD WSAAPI	WsTcFindIfsProviderForSocket (IN PTCATALOG Catalog, IN SOCKET Handle)
VOID WSAAPI	WsTcRemoveCatalogItem (IN PTCATALOG Catalog, IN PTCATALOG_ENTRY Entry)
VOID WSAAPI	WsTcDelete (IN PTCATALOG Catalog)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file dcatalog.c.

WsTcLock

#define WsTcLock

(

)

EnterCriticalSection(&Catalog->Lock)

Definition at line 18 of file dcatalog.c.

WsTcUnlock

#define WsTcUnlock

(

)

LeaveCriticalSection(&Catalog->Lock)

Definition at line 19 of file dcatalog.c.

Function Documentation

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

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	Catalog,
		IN SOCKET	Handle
	)

Definition at line 779 of file dcatalog.c.

{
    PTPROVIDER Provider;
    IN SOCKET NewHandle;
    INT Error;
    INT OptionLength;
    PLIST_ENTRY Entry;
    WSAPROTOCOL_INFOW ProtocolInfo;
    DWORD UniqueId;
    INT ErrorCode;
    PTCATALOG_ENTRY CatalogEntry;

    /* Get the catalog lock */
    WsTcLock();

    /* Loop as long as the catalog changes */
CatalogChanged:

    /* Loop every provider */
    Entry = Catalog->ProtocolList.Flink;
    while (Entry != &Catalog->ProtocolList)
    {
        /* Get the catalog entry */
        CatalogEntry = CONTAINING_RECORD(Entry, TCATALOG_ENTRY, CatalogLink);

        /* Move to the next entry */
        Entry = Entry->Flink;

        /* Skip it if it doesn't support IFS */
        if (!(CatalogEntry->ProtocolInfo.dwServiceFlags1 & XP1_IFS_HANDLES)) continue;

        /* Check if we need to load it */
        if (!(Provider = CatalogEntry->Provider))
        {
            /* Load it */
            ErrorCode = WsTcLoadProvider(Catalog, CatalogEntry);

            /* Skip it if we failed to load it */
            if (ErrorCode != ERROR_SUCCESS) continue;

            /* Get the provider again */
            Provider = CatalogEntry->Provider;
        }

        /* Reference the entry and get our unique id */
        InterlockedIncrement(&CatalogEntry->RefCount);
        UniqueId = Catalog->UniqueId;

        /* Release the lock now */
        WsTcUnlock();

        /* Get the catalog entry ID */
        OptionLength = sizeof(ProtocolInfo);
        ErrorCode = Provider->Service.lpWSPGetSockOpt(Handle,
                                                      SOL_SOCKET,
                                                      SO_PROTOCOL_INFOW,
                                                      (PCHAR)&ProtocolInfo,
                                                      &OptionLength,
                                                      &Error);

        /* Dereference the entry and check the result */
        WsTcEntryDereference(CatalogEntry);
        if (ErrorCode != ERROR_SUCCESS)
        {
            /* Lock and make sure this provider is still valid */
            WsTcLock();
            if (UniqueId == Catalog->UniqueId) continue;

            /* It changed! We need to start over */
            goto CatalogChanged;
        }

        /* Now get the IFS handle */
        NewHandle = WPUModifyIFSHandle(ProtocolInfo.dwCatalogEntryId,
                                       Handle,
                                       &Error);

        /* Check if the socket is invalid */
        if (NewHandle == INVALID_SOCKET) return WSAENOTSOCK;

        /* We succeeded, get out of here */
        return ERROR_SUCCESS;
    }

    /* Unrecognized socket if we get here: note, we still have the lock */
    WsTcUnlock();
    return WSAENOTSOCK;
}

WsTcFindProvider()

PTPROVIDER WSAAPI WsTcFindProvider	(	IN PTCATALOG	Catalog,
		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	Catalog,
		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	Catalog,
		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	Catalog,
		IN INT	af,
		IN INT	type,
		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	Catalog,
		IN HKEY	ParentKey,
		IN HANDLE	CatalogEvent
	)

Definition at line 227 of file dcatalog.c.

{
    INT ErrorCode = WSASYSCALLFAILURE;

    /* Open the catalog */
    if (WsTcOpen(Catalog, ParentKey))
    {
        /* Refresh it */
        ErrorCode = WsTcRefreshFromRegistry(Catalog, CatalogEvent);
    }

    /* Return the status */
    return ErrorCode;
}

WsTcLoadProvider()

DWORD WSAAPI WsTcLoadProvider	(	IN PTCATALOG	Catalog,
		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	Catalog,
		IN HKEY	ParentKey
	)

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	Catalog,
		IN HANDLE	CatalogEvent
	)

Definition at line 246 of file dcatalog.c.

{
    INT ErrorCode;
    BOOLEAN LocalEvent = FALSE;
    LIST_ENTRY LocalList;
    DWORD UniqueId;
    HKEY EntriesKey;
    DWORD CatalogEntries;
    PTCATALOG_ENTRY CatalogEntry;
    DWORD NextCatalogEntry;
    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 */
    WsTcLock();

    /* 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;
        }

        /* Get the next entry */
        ErrorCode = RegQueryValueEx(Catalog->CatalogKey,
                                    "Next_Catalog_Entry_ID",
                                    0,
                                    &RegType,
                                    (LPBYTE)&NextCatalogEntry,
                                    &RegSize);
        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 = WsTcEntryAllocate();
            if (!CatalogEntry)
            {
                /* Not enough memory, fail */
                ErrorCode = WSA_NOT_ENOUGH_MEMORY;
                break;
            }

            /* Initialize it from the Registry Key */
            ErrorCode = WsTcEntryInitializeFromRegistry(CatalogEntry,
                                                        EntriesKey,
                                                        i);
            if (ErrorCode != ERROR_SUCCESS)
            {
                /* We failed to get it, dereference the entry and leave */
                WsTcEntryDereference(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 */
            WsTcUpdateProtocolList(Catalog, &LocalList);

            /* Update and return */
            Catalog->UniqueId = UniqueId;
            Catalog->NextId = NextCatalogEntry;
            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, TCATALOG_ENTRY, CatalogLink);

            /* Dereference it */
            WsTcEntryDereference(CatalogEntry);
        }
    } while (NewChangesMade);

    /* Release the lock */
    WsTcUnlock();

    /* Close the event, if any was created by us */
    if (LocalEvent) CloseHandle(CatalogEvent);

    /* All Done */
    return ErrorCode;
}

Referenced by WsTcInitializeFromRegistry().

WsTcRemoveCatalogItem()

VOID WSAAPI WsTcRemoveCatalogItem	(	IN PTCATALOG	Catalog,
		IN PTCATALOG_ENTRY	Entry
	)

Definition at line 871 of file dcatalog.c.

{
    /* Remove the entry from the list */
    RemoveEntryList(&Entry->CatalogLink);

    /* Decrease our count */
    Catalog->ItemCount--;
}

Referenced by WsTcDelete().

WsTcUpdateProtocolList()

VOID WSAAPI WsTcUpdateProtocolList	(	IN PTCATALOG	Catalog,
		IN PLIST_ENTRY	List
	)

Definition at line 688 of file dcatalog.c.

{
    LIST_ENTRY TempList;
    PTCATALOG_ENTRY CatalogEntry, OldCatalogEntry;
    PLIST_ENTRY Entry;

    /* First move from our list to the old one */
    InsertHeadList(&Catalog->ProtocolList, &TempList);
    RemoveEntryList(&Catalog->ProtocolList);
    InitializeListHead(&Catalog->ProtocolList);

    /* Loop every item in the list */
    while (!IsListEmpty(List))
    {
        /* Get the catalog entry */
        Entry = RemoveHeadList(List);
        CatalogEntry = CONTAINING_RECORD(Entry, TCATALOG_ENTRY, CatalogLink);

        /* Check if this item is already in our list */
        Entry = TempList.Flink;
        while (Entry != &TempList)
        {
            /* Get the catalog entry */
            OldCatalogEntry = CONTAINING_RECORD(Entry, TCATALOG_ENTRY, CatalogLink);
            Entry = Entry->Flink;

            /* Check if they match */
            if (CatalogEntry->ProtocolInfo.dwCatalogEntryId ==
                OldCatalogEntry->ProtocolInfo.dwCatalogEntryId)
            {
                /* We have a match, use the old item instead */
                WsTcEntryDereference(CatalogEntry);
                CatalogEntry = OldCatalogEntry;
                RemoveEntryList(&CatalogEntry->CatalogLink);

                /* Decrease the number of protocols we have */
                Catalog->ItemCount--;
                break;
            }
        }

        /* Add this item */
        InsertTailList(&Catalog->ProtocolList, &CatalogEntry->CatalogLink);
        Catalog->ItemCount++;
    }

    /* If there's anything left in the temporary list */
    while (!IsListEmpty(&TempList))
    {
        /* Get the entry */
        Entry = RemoveHeadList(&TempList);
        CatalogEntry = CONTAINING_RECORD(Entry, TCATALOG_ENTRY, CatalogLink);

        /* Remove it */
        Catalog->ItemCount--;
        WsTcEntryDereference(CatalogEntry);
    }
}

Referenced by WsTcRefreshFromRegistry().