atom.c File Reference

#include <rtl.h>
#include <debug.h>

Include dependency graph for atom.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
NTSTATUS	RtlpInitAtomTableLock (PRTL_ATOM_TABLE AtomTable)
VOID	RtlpDestroyAtomTableLock (PRTL_ATOM_TABLE AtomTable)
BOOLEAN	RtlpLockAtomTable (PRTL_ATOM_TABLE AtomTable)
VOID	RtlpUnlockAtomTable (PRTL_ATOM_TABLE AtomTable)
BOOLEAN	RtlpCreateAtomHandleTable (PRTL_ATOM_TABLE AtomTable)
VOID	RtlpDestroyAtomHandleTable (PRTL_ATOM_TABLE AtomTable)
PRTL_ATOM_TABLE	RtlpAllocAtomTable (ULONG Size)
VOID	RtlpFreeAtomTable (PRTL_ATOM_TABLE AtomTable)
PRTL_ATOM_TABLE_ENTRY	RtlpAllocAtomTableEntry (ULONG Size)
VOID	RtlpFreeAtomTableEntry (PRTL_ATOM_TABLE_ENTRY Entry)
BOOLEAN	RtlpCreateAtomHandle (PRTL_ATOM_TABLE AtomTable, PRTL_ATOM_TABLE_ENTRY Entry)
VOID	RtlpFreeAtomHandle (PRTL_ATOM_TABLE AtomTable, PRTL_ATOM_TABLE_ENTRY Entry)
PRTL_ATOM_TABLE_ENTRY	RtlpGetAtomEntry (PRTL_ATOM_TABLE AtomTable, ULONG Index)
static PRTL_ATOM_TABLE_ENTRY	RtlpHashAtomName (IN PRTL_ATOM_TABLE AtomTable, IN PWSTR AtomName, OUT PRTL_ATOM_TABLE_ENTRY **HashLink)
static BOOLEAN	RtlpCheckIntegerAtom (PWSTR AtomName, PUSHORT AtomValue)
NTSTATUS NTAPI	RtlCreateAtomTable (IN ULONG TableSize, IN OUT PRTL_ATOM_TABLE *AtomTable)
NTSTATUS NTAPI	RtlDestroyAtomTable (IN PRTL_ATOM_TABLE AtomTable)
NTSTATUS NTAPI	RtlEmptyAtomTable (PRTL_ATOM_TABLE AtomTable, BOOLEAN DeletePinned)
NTSTATUS NTAPI	RtlAddAtomToAtomTable (IN PRTL_ATOM_TABLE AtomTable, IN PWSTR AtomName, OUT PRTL_ATOM Atom)
NTSTATUS NTAPI	RtlDeleteAtomFromAtomTable (IN PRTL_ATOM_TABLE AtomTable, IN RTL_ATOM Atom)
NTSTATUS NTAPI	RtlLookupAtomInAtomTable (IN PRTL_ATOM_TABLE AtomTable, IN PWSTR AtomName, OUT PRTL_ATOM Atom)
NTSTATUS NTAPI	RtlPinAtomInAtomTable (IN PRTL_ATOM_TABLE AtomTable, IN RTL_ATOM Atom)
NTSTATUS NTAPI	RtlQueryAtomInAtomTable (PRTL_ATOM_TABLE AtomTable, RTL_ATOM Atom, PULONG RefCount, PULONG PinCount, PWSTR AtomName, PULONG NameLength)
NTSTATUS NTAPI	RtlQueryAtomListInAtomTable (IN PRTL_ATOM_TABLE AtomTable, IN ULONG MaxAtomCount, OUT ULONG *AtomCount, OUT RTL_ATOM *AtomList)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file atom.c.

Function Documentation

RtlAddAtomToAtomTable()

NTSTATUS NTAPI RtlAddAtomToAtomTable	(	IN PRTL_ATOM_TABLE	AtomTable,
		IN PWSTR	AtomName,
		OUT PRTL_ATOM	Atom
	)

Definition at line 308 of file atom.c.

{
    USHORT AtomValue;
    PRTL_ATOM_TABLE_ENTRY *HashLink;
    PRTL_ATOM_TABLE_ENTRY Entry = NULL;
    NTSTATUS Status = STATUS_SUCCESS;
 
    DPRINT("RtlAddAtomToAtomTable (AtomTable %p AtomName %S Atom %p)\n",
           AtomTable, AtomName, Atom);
 
    if (RtlpCheckIntegerAtom (AtomName, &AtomValue))
    {
        /* integer atom */
        if (AtomValue >= 0xC000)
        {
            Status = STATUS_INVALID_PARAMETER;
        }
        else if (Atom != NULL)
        {
            *Atom = (RTL_ATOM)AtomValue;
        }
 
        return Status;
    }
 
    RtlpLockAtomTable(AtomTable);
 
    /* string atom, hash it and try to find an existing atom with the same name */
    Entry = RtlpHashAtomName(AtomTable, AtomName, &HashLink);
 
    if (Entry != NULL)
    {
        /* found another atom, increment the reference counter unless it's pinned */
 
        if (!(Entry->Flags & RTL_ATOM_IS_PINNED))
        {
            if (++Entry->ReferenceCount == 0)
            {
                /* FIXME - references overflowed, pin the atom? */
                Entry->Flags |= RTL_ATOM_IS_PINNED;
            }
        }
 
        if (Atom != NULL)
        {
            *Atom = (RTL_ATOM)Entry->Atom;
        }
    }
    else
    {
        /* couldn't find an existing atom, HashLink now points to either the
           HashLink pointer of the previous atom or to the bucket so we can
           simply add it to the list */
        if (HashLink != NULL)
        {
            ULONG AtomNameLen = (ULONG)wcslen(AtomName);
 
            if (AtomNameLen > RTL_MAXIMUM_ATOM_LENGTH)
            {
                Status = STATUS_INVALID_PARAMETER;
                goto end;
            }
 
            Entry = RtlpAllocAtomTableEntry(sizeof(RTL_ATOM_TABLE_ENTRY) -
                                            sizeof(Entry->Name) +
                                            (AtomNameLen + 1) * sizeof(WCHAR));
            if (Entry != NULL)
            {
                Entry->HashLink = NULL;
                Entry->ReferenceCount = 1;
                Entry->Flags = 0x0;
 
                Entry->NameLength = (UCHAR)AtomNameLen;
                RtlCopyMemory(Entry->Name,
                              AtomName,
                              (AtomNameLen + 1) * sizeof(WCHAR));
 
                if (RtlpCreateAtomHandle(AtomTable, Entry))
                {
                    /* append the atom to the list */
                    *HashLink = Entry;
 
                    if (Atom != NULL)
                    {
                        *Atom = (RTL_ATOM)Entry->Atom;
                    }
                }
                else
                {
                    RtlpFreeAtomTableEntry(Entry);
                    Status = STATUS_NO_MEMORY;
                }
            }
            else
            {
                Status = STATUS_NO_MEMORY;
            }
        }
        else
        {
            /* The caller supplied an empty atom name! */
            Status = STATUS_OBJECT_NAME_INVALID;
        }
    }
end:
    RtlpUnlockAtomTable(AtomTable);
 
    return Status;
}

RtlCreateAtomTable()

NTSTATUS NTAPI RtlCreateAtomTable	(	IN ULONG	TableSize,
		IN OUT PRTL_ATOM_TABLE *	AtomTable
	)

Definition at line 150 of file atom.c.

{
    PRTL_ATOM_TABLE Table;
    NTSTATUS Status;
 
    DPRINT("RtlCreateAtomTable(TableSize %lu AtomTable %p)\n",
           TableSize, AtomTable);
 
    if (*AtomTable != NULL)
    {
        return STATUS_SUCCESS;
    }
 
    /* Use default if size was incorrect */
    if (TableSize <= 1) TableSize = 37;
 
    /* allocate atom table */
    Table = RtlpAllocAtomTable(((TableSize - 1) * sizeof(PRTL_ATOM_TABLE_ENTRY)) +
                               sizeof(RTL_ATOM_TABLE));
    if (Table == NULL)
    {
        return STATUS_NO_MEMORY;
    }
 
    /* initialize atom table */
    Table->NumberOfBuckets = TableSize;
 
    Status = RtlpInitAtomTableLock(Table);
    if (!NT_SUCCESS(Status))
    {
        RtlpFreeAtomTable(Table);
        return Status;
    }
 
    if (!RtlpCreateAtomHandleTable(Table))
    {
        RtlpDestroyAtomTableLock(Table);
        RtlpFreeAtomTable(Table);
        return STATUS_NO_MEMORY;
    }
 
    *AtomTable = Table;
    return STATUS_SUCCESS;
}

RtlDeleteAtomFromAtomTable()

NTSTATUS NTAPI RtlDeleteAtomFromAtomTable	(	IN PRTL_ATOM_TABLE	AtomTable,
		IN RTL_ATOM	Atom
	)

Definition at line 426 of file atom.c.

{
    PRTL_ATOM_TABLE_ENTRY Entry;
    NTSTATUS Status = STATUS_SUCCESS;
 
    DPRINT("RtlDeleteAtomFromAtomTable (AtomTable %p Atom %x)\n",
           AtomTable, Atom);
 
    if (Atom >= 0xC000)
    {
        RtlpLockAtomTable(AtomTable);
 
        Entry = RtlpGetAtomEntry(AtomTable, (ULONG)((USHORT)Atom - 0xC000));
 
        if (Entry != NULL && Entry->Atom == (USHORT)Atom)
        {
            if (!(Entry->Flags & RTL_ATOM_IS_PINNED))
            {
                if (--Entry->ReferenceCount == 0)
                {
                    PRTL_ATOM_TABLE_ENTRY *HashLink;
 
                    /* it's time to delete the atom. we need to unlink it from
                       the list. The easiest way is to take the atom name and
                       hash it again, this way we get the pointer to either
                       the hash bucket or the previous atom that links to the
                       one we want to delete. This way we can easily bypass
                       this item. */
                    if (RtlpHashAtomName(AtomTable, Entry->Name, &HashLink) != NULL)
                    {
                        /* bypass this atom */
                        *HashLink = Entry->HashLink;
 
                        RtlpFreeAtomHandle(AtomTable, Entry);
 
                        RtlpFreeAtomTableEntry(Entry);
                    }
                    else
                    {
                        /* WTF?! This should never happen!!! */
                        ASSERT(FALSE);
                    }
                }
            }
            else
            {
                /* tried to delete a pinned atom, do nothing and return
                   STATUS_WAS_LOCKED, which is NOT a failure code! */
                Status = STATUS_WAS_LOCKED;
            }
        }
        else
        {
            Status = STATUS_INVALID_HANDLE;
        }
 
        RtlpUnlockAtomTable(AtomTable);
    }
 
    return Status;
}

RtlDestroyAtomTable()

NTSTATUS NTAPI RtlDestroyAtomTable

(

IN PRTL_ATOM_TABLE

AtomTable

)

Definition at line 203 of file atom.c.

{
    PRTL_ATOM_TABLE_ENTRY *CurrentBucket, *LastBucket;
    PRTL_ATOM_TABLE_ENTRY CurrentEntry, NextEntry;
 
    DPRINT("RtlDestroyAtomTable (AtomTable %p)\n", AtomTable);
 
    if (!RtlpLockAtomTable(AtomTable))
    {
        return (STATUS_INVALID_PARAMETER);
    }
 
    /* delete all atoms */
    LastBucket = AtomTable->Buckets + AtomTable->NumberOfBuckets;
    for (CurrentBucket = AtomTable->Buckets;
            CurrentBucket != LastBucket;
            CurrentBucket++)
    {
        NextEntry = *CurrentBucket;
        *CurrentBucket = NULL;
 
        while (NextEntry != NULL)
        {
            CurrentEntry = NextEntry;
            NextEntry = NextEntry->HashLink;
 
            /* no need to delete the atom handle, the handles will all be freed
               up when destroying the atom handle table! */
 
            RtlpFreeAtomTableEntry(CurrentEntry);
        }
    }
 
    RtlpDestroyAtomHandleTable(AtomTable);
 
    RtlpUnlockAtomTable(AtomTable);
 
    RtlpDestroyAtomTableLock(AtomTable);
 
    RtlpFreeAtomTable(AtomTable);
 
    return STATUS_SUCCESS;
}

Referenced by IntWinStaObjectDelete(), and main().

RtlEmptyAtomTable()

NTSTATUS NTAPI RtlEmptyAtomTable	(	PRTL_ATOM_TABLE	AtomTable,
		BOOLEAN	DeletePinned
	)

Definition at line 254 of file atom.c.

{
    PRTL_ATOM_TABLE_ENTRY *CurrentBucket, *LastBucket;
    PRTL_ATOM_TABLE_ENTRY CurrentEntry, NextEntry, *PtrEntry;
 
    DPRINT("RtlEmptyAtomTable (AtomTable %p DeletePinned %x)\n",
           AtomTable, DeletePinned);
 
    if (RtlpLockAtomTable(AtomTable) == FALSE)
    {
        return (STATUS_INVALID_PARAMETER);
    }
 
    /* delete all atoms */
    LastBucket = AtomTable->Buckets + AtomTable->NumberOfBuckets;
    for (CurrentBucket = AtomTable->Buckets;
         CurrentBucket != LastBucket;
         CurrentBucket++)
    {
        NextEntry = *CurrentBucket;
        PtrEntry = CurrentBucket;
 
        while (NextEntry != NULL)
        {
            CurrentEntry = NextEntry;
            NextEntry = NextEntry->HashLink;
 
            if (DeletePinned || !(CurrentEntry->Flags & RTL_ATOM_IS_PINNED))
            {
                *PtrEntry = NextEntry;
 
                RtlpFreeAtomHandle(AtomTable, CurrentEntry);
 
                RtlpFreeAtomTableEntry(CurrentEntry);
            }
            else
            {
                PtrEntry = &CurrentEntry->HashLink;
            }
        }
    }
 
    RtlpUnlockAtomTable(AtomTable);
 
    return STATUS_SUCCESS;
}

RtlLookupAtomInAtomTable()

NTSTATUS NTAPI RtlLookupAtomInAtomTable	(	IN PRTL_ATOM_TABLE	AtomTable,
		IN PWSTR	AtomName,
		OUT PRTL_ATOM	Atom
	)

Definition at line 495 of file atom.c.

{
    PRTL_ATOM_TABLE_ENTRY Entry, *HashLink;
    USHORT AtomValue;
    RTL_ATOM FoundAtom = 0;
    NTSTATUS Status = STATUS_SUCCESS;
 
    DPRINT("RtlLookupAtomInAtomTable (AtomTable %p AtomName %S Atom %p)\n",
           AtomTable, AtomName, Atom);
 
    if (RtlpCheckIntegerAtom (AtomName, &AtomValue))
    {
        /* integer atom */
        if (AtomValue >= 0xC000)
        {
            Status = STATUS_INVALID_PARAMETER;
        }
        else if (Atom != NULL)
        {
            *Atom = (RTL_ATOM)AtomValue;
        }
 
        return Status;
    }
 
    RtlpLockAtomTable(AtomTable);
    Status = STATUS_OBJECT_NAME_NOT_FOUND;
 
    /* string atom */
    Entry = RtlpHashAtomName(AtomTable, AtomName, &HashLink);
    if (Entry != NULL)
    {
        Status = STATUS_SUCCESS;
        FoundAtom = (RTL_ATOM)Entry->Atom;
    }
 
    RtlpUnlockAtomTable(AtomTable);
    if (NT_SUCCESS(Status) && Atom != NULL)
    {
        *Atom = FoundAtom;
    }
    return Status;
}

RtlpAllocAtomTable()

PRTL_ATOM_TABLE RtlpAllocAtomTable

(

ULONG

Size

)

Definition at line 409 of file libsupp.c.

{
   return (PRTL_ATOM_TABLE)RtlAllocateHeap(RtlGetProcessHeap(),
                                           HEAP_ZERO_MEMORY,
                                           Size);
}

Referenced by RtlCreateAtomTable().

RtlpAllocAtomTableEntry()

PRTL_ATOM_TABLE_ENTRY RtlpAllocAtomTableEntry

(

ULONG

Size

)

Definition at line 425 of file libsupp.c.

{
   return (PRTL_ATOM_TABLE_ENTRY)RtlAllocateHeap(RtlGetProcessHeap(),
                                                 HEAP_ZERO_MEMORY,
                                                 Size);
}

Referenced by RtlAddAtomToAtomTable().

RtlpCheckIntegerAtom()

static BOOLEAN RtlpCheckIntegerAtom ( PWSTR  AtomName, PUSHORT  AtomValue  )

static

Definition at line 86 of file atom.c.

{
    UNICODE_STRING AtomString;
    ULONG LongValue;
    USHORT LoValue;
    PWCHAR p;
 
    DPRINT("RtlpCheckIntegerAtom(AtomName '%S' AtomValue %p)\n",
           AtomName, AtomValue);
 
    if (!((ULONG_PTR)AtomName & 0xFFFF0000))
    {
        LoValue = (USHORT)((ULONG_PTR)AtomName & 0xFFFF);
 
        if (LoValue == 0)
            LoValue = 0xC000;
 
        if (AtomValue != NULL)
            *AtomValue = LoValue;
 
        return TRUE;
    }
 
    /*
     * AtomName cannot be NULL because this
     * case was caught by the previous test.
     */
    ASSERT(AtomName != NULL);
 
    if (*AtomName != L'#')
        return FALSE;
 
    p = AtomName;
    p++;
    while (*p)
    {
        if ((*p < L'0') || (*p > L'9'))
            return FALSE;
        p++;
    }
 
    p = AtomName;
    p++;
    RtlInitUnicodeString(&AtomString, p);
 
    DPRINT("AtomString: %wZ\n", &AtomString);
 
    RtlUnicodeStringToInteger(&AtomString, 10, &LongValue);
 
    DPRINT("LongValue: %lu\n", LongValue);
 
    *AtomValue = (USHORT)(LongValue & 0x0000FFFF);
 
    return TRUE;
}

Referenced by RtlAddAtomToAtomTable(), and RtlLookupAtomInAtomTable().

RtlpCreateAtomHandle()

BOOLEAN RtlpCreateAtomHandle	(	PRTL_ATOM_TABLE	AtomTable,
		PRTL_ATOM_TABLE_ENTRY	Entry
	)

Definition at line 455 of file libsupp.c.

{
   ULONG HandleIndex;
   PRTL_HANDLE_TABLE_ENTRY RtlHandle;
 
   RtlHandle = RtlAllocateHandle(&AtomTable->RtlHandleTable,
                                 &HandleIndex);
   if (RtlHandle != NULL)
   {
      PRTL_ATOM_HANDLE AtomHandle = (PRTL_ATOM_HANDLE)RtlHandle;
 
      /* FIXME - Handle Indexes >= 0xC000 ?! */
      if (HandleIndex < 0xC000)
      {
         Entry->HandleIndex = (USHORT)HandleIndex;
         Entry->Atom = 0xC000 + (USHORT)HandleIndex;
 
         AtomHandle->AtomEntry = Entry;
         AtomHandle->Handle.Flags = RTL_HANDLE_VALID;
 
         return TRUE;
      }
      else
      {
         /* set the valid flag, otherwise RtlFreeHandle will fail! */
         AtomHandle->Handle.Flags = RTL_HANDLE_VALID;
 
         RtlFreeHandle(&AtomTable->RtlHandleTable,
                       RtlHandle);
      }
   }
 
   return FALSE;
}

Referenced by RtlAddAtomToAtomTable().

RtlpCreateAtomHandleTable()

BOOLEAN RtlpCreateAtomHandleTable

(

PRTL_ATOM_TABLE

AtomTable

)

Definition at line 393 of file libsupp.c.

{
   RtlInitializeHandleTable(0xCFFF,
                            sizeof(RTL_ATOM_HANDLE),
                            &AtomTable->RtlHandleTable);
 
   return TRUE;
}

Referenced by RtlCreateAtomTable().

RtlpDestroyAtomHandleTable()

VOID RtlpDestroyAtomHandleTable

(

PRTL_ATOM_TABLE

AtomTable

)

Definition at line 403 of file libsupp.c.

{
   RtlDestroyHandleTable(&AtomTable->RtlHandleTable);
}

Referenced by RtlDestroyAtomTable().

RtlpDestroyAtomTableLock()

VOID RtlpDestroyAtomTableLock

(

PRTL_ATOM_TABLE

AtomTable

)

Definition at line 369 of file libsupp.c.

{
   RtlDeleteCriticalSection(&AtomTable->CriticalSection);
}

Referenced by RtlCreateAtomTable(), and RtlDestroyAtomTable().

RtlpFreeAtomHandle()

VOID RtlpFreeAtomHandle	(	PRTL_ATOM_TABLE	AtomTable,
		PRTL_ATOM_TABLE_ENTRY	Entry
	)

Definition at line 441 of file libsupp.c.

{
   PRTL_HANDLE_TABLE_ENTRY RtlHandleEntry;
 
   if (RtlIsValidIndexHandle(&AtomTable->RtlHandleTable,
                             (ULONG)Entry->HandleIndex,
                             &RtlHandleEntry))
   {
      RtlFreeHandle(&AtomTable->RtlHandleTable,
                    RtlHandleEntry);
   }
}

Referenced by RtlDeleteAtomFromAtomTable(), and RtlEmptyAtomTable().

RtlpFreeAtomTable()

VOID RtlpFreeAtomTable

(

PRTL_ATOM_TABLE

AtomTable

)

Definition at line 417 of file libsupp.c.

{
   RtlFreeHeap(RtlGetProcessHeap(),
               0,
               AtomTable);
}

Referenced by RtlCreateAtomTable(), and RtlDestroyAtomTable().

RtlpFreeAtomTableEntry()

VOID RtlpFreeAtomTableEntry

(

PRTL_ATOM_TABLE_ENTRY

Entry

)

Definition at line 433 of file libsupp.c.

{
   RtlFreeHeap(RtlGetProcessHeap(),
               0,
               Entry);
}

Referenced by RtlAddAtomToAtomTable(), RtlDeleteAtomFromAtomTable(), RtlDestroyAtomTable(), and RtlEmptyAtomTable().

RtlpGetAtomEntry()

PRTL_ATOM_TABLE_ENTRY RtlpGetAtomEntry	(	PRTL_ATOM_TABLE	AtomTable,
		ULONG	Index
	)

Definition at line 491 of file libsupp.c.

{
   PRTL_HANDLE_TABLE_ENTRY RtlHandle;
 
   if (RtlIsValidIndexHandle(&AtomTable->RtlHandleTable,
                             Index,
                             &RtlHandle))
   {
      PRTL_ATOM_HANDLE AtomHandle = (PRTL_ATOM_HANDLE)RtlHandle;
 
      return AtomHandle->AtomEntry;
   }
 
   return NULL;
}

Referenced by RtlDeleteAtomFromAtomTable(), RtlPinAtomInAtomTable(), and RtlQueryAtomInAtomTable().

RtlpHashAtomName()

static PRTL_ATOM_TABLE_ENTRY RtlpHashAtomName ( IN PRTL_ATOM_TABLE  AtomTable, IN PWSTR  AtomName, OUT PRTL_ATOM_TABLE_ENTRY **  HashLink  )

static

Definition at line 39 of file atom.c.

{
    UNICODE_STRING Name;
    ULONG Hash;
 
    RtlInitUnicodeString(&Name, AtomName);
 
    if (Name.Length != 0 &&
            NT_SUCCESS(RtlHashUnicodeString(&Name,
                                            TRUE,
                                            HASH_STRING_ALGORITHM_X65599,
                                            &Hash)))
    {
        PRTL_ATOM_TABLE_ENTRY Current;
        PRTL_ATOM_TABLE_ENTRY *Link;
 
        Link = &AtomTable->Buckets[Hash % AtomTable->NumberOfBuckets];
 
        /* search for an existing entry */
        Current = *Link;
        while (Current != NULL)
        {
            if (Current->NameLength == Name.Length / sizeof(WCHAR) &&
                !_wcsicmp(Current->Name, Name.Buffer))
            {
                *HashLink = Link;
                return Current;
            }
 
            Link = &Current->HashLink;
            Current = Current->HashLink;
        }
 
        /* no matching atom found, return the hash link */
        *HashLink = Link;
    }
    else
        *HashLink = NULL;
 
    return NULL;
}

Referenced by RtlAddAtomToAtomTable(), RtlDeleteAtomFromAtomTable(), and RtlLookupAtomInAtomTable().

RtlPinAtomInAtomTable()

NTSTATUS NTAPI RtlPinAtomInAtomTable	(	IN PRTL_ATOM_TABLE	AtomTable,
		IN RTL_ATOM	Atom
	)

Definition at line 546 of file atom.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
    DPRINT("RtlPinAtomInAtomTable (AtomTable %p Atom %x)\n",
           AtomTable, Atom);
 
    if (Atom >= 0xC000)
    {
        PRTL_ATOM_TABLE_ENTRY Entry;
 
        RtlpLockAtomTable(AtomTable);
 
        Entry = RtlpGetAtomEntry(AtomTable, (ULONG)((USHORT)Atom - 0xC000));
 
        if (Entry != NULL && Entry->Atom == (USHORT)Atom)
        {
            Entry->Flags |= RTL_ATOM_IS_PINNED;
        }
        else
        {
            Status = STATUS_INVALID_HANDLE;
        }
 
        RtlpUnlockAtomTable(AtomTable);
    }
 
    return Status;
}

RtlpInitAtomTableLock()

NTSTATUS RtlpInitAtomTableLock

(

PRTL_ATOM_TABLE

AtomTable

)

Definition at line 361 of file libsupp.c.

{
   RtlInitializeCriticalSection(&AtomTable->CriticalSection);
   return STATUS_SUCCESS;
}

Referenced by RtlCreateAtomTable().

RtlpLockAtomTable()

BOOLEAN RtlpLockAtomTable

(

PRTL_ATOM_TABLE

AtomTable

)

Definition at line 376 of file libsupp.c.

{
   RtlEnterCriticalSection(&AtomTable->CriticalSection);
   return TRUE;
}

Referenced by RtlAddAtomToAtomTable(), RtlDeleteAtomFromAtomTable(), RtlDestroyAtomTable(), RtlEmptyAtomTable(), RtlLookupAtomInAtomTable(), RtlPinAtomInAtomTable(), RtlQueryAtomInAtomTable(), and RtlQueryAtomListInAtomTable().

RtlpUnlockAtomTable()

VOID RtlpUnlockAtomTable

(

PRTL_ATOM_TABLE

AtomTable

)

Definition at line 384 of file libsupp.c.

{
   RtlLeaveCriticalSection(&AtomTable->CriticalSection);
}

Referenced by RtlAddAtomToAtomTable(), RtlDeleteAtomFromAtomTable(), RtlDestroyAtomTable(), RtlEmptyAtomTable(), RtlLookupAtomInAtomTable(), RtlPinAtomInAtomTable(), RtlQueryAtomInAtomTable(), and RtlQueryAtomListInAtomTable().

RtlQueryAtomInAtomTable()

NTSTATUS NTAPI RtlQueryAtomInAtomTable	(	PRTL_ATOM_TABLE	AtomTable,
		RTL_ATOM	Atom,
		PULONG	RefCount,
		PULONG	PinCount,
		PWSTR	AtomName,
		PULONG	NameLength
	)

Definition at line 600 of file atom.c.

{
    ULONG Length;
    BOOL Unlock = FALSE;
 
    union
    {
        /* A RTL_ATOM_TABLE_ENTRY has a "WCHAR Name[1]" entry at the end.
         * Make sure we reserve enough room to facilitate a 12 character name */
        RTL_ATOM_TABLE_ENTRY AtomTableEntry;
        WCHAR StringBuffer[sizeof(RTL_ATOM_TABLE_ENTRY) / sizeof(WCHAR) + 12];
    } NumberEntry;
    PRTL_ATOM_TABLE_ENTRY Entry;
    NTSTATUS Status = STATUS_SUCCESS;
 
    if (Atom < 0xC000)
    {
        /* Synthesize an entry */
        NumberEntry.AtomTableEntry.Atom = Atom;
        NumberEntry.AtomTableEntry.NameLength = swprintf(NumberEntry.AtomTableEntry.Name,
                                                L"#%lu",
                                                (ULONG)Atom);
        NumberEntry.AtomTableEntry.ReferenceCount = 1;
        NumberEntry.AtomTableEntry.Flags = RTL_ATOM_IS_PINNED;
        Entry = &NumberEntry.AtomTableEntry;
    }
    else
    {
        RtlpLockAtomTable(AtomTable);
        Unlock = TRUE;
 
        Entry = RtlpGetAtomEntry(AtomTable, (ULONG)((USHORT)Atom - 0xC000));
    }
 
    if (Entry != NULL && Entry->Atom == (USHORT)Atom)
    {
        DPRINT("Atom name: %wZ\n", &Entry->Name);
 
        if (RefCount != NULL)
        {
            *RefCount = Entry->ReferenceCount;
        }
 
        if (PinCount != NULL)
        {
            *PinCount = ((Entry->Flags & RTL_ATOM_IS_PINNED) != 0);
        }
 
        if (NULL != NameLength)
        {
            Length = Entry->NameLength * sizeof(WCHAR);
            if (NULL != AtomName)
            {
                if (*NameLength < Length + sizeof(WCHAR))
                {
                    if (*NameLength < 4)
                    {
                        *NameLength = Length;
                        Status = STATUS_BUFFER_TOO_SMALL;
                    }
                    else
                    {
                        Length = *NameLength - sizeof(WCHAR);
                    }
                }
                if (NT_SUCCESS(Status))
                {
                    RtlCopyMemory(AtomName, Entry->Name, Length);
                    AtomName[Length / sizeof(WCHAR)] = L'\0';
                    *NameLength = Length;
                }
            }
            else
            {
                *NameLength = Length;
            }
        }
        else if (NULL != AtomName)
        {
            Status = STATUS_INVALID_PARAMETER;
        }
    }
    else
    {
        Status = STATUS_INVALID_HANDLE;
    }
 
    if (Unlock) RtlpUnlockAtomTable(AtomTable);
 
    return Status;
}

RtlQueryAtomListInAtomTable()

NTSTATUS NTAPI RtlQueryAtomListInAtomTable	(	IN PRTL_ATOM_TABLE	AtomTable,
		IN ULONG	MaxAtomCount,
		OUT ULONG *	AtomCount,
		OUT RTL_ATOM *	AtomList
	)

Definition at line 704 of file atom.c.

{
    PRTL_ATOM_TABLE_ENTRY *CurrentBucket, *LastBucket;
    PRTL_ATOM_TABLE_ENTRY CurrentEntry;
    ULONG Atoms = 0;
    NTSTATUS Status = STATUS_SUCCESS;
 
    RtlpLockAtomTable(AtomTable);
 
    LastBucket = AtomTable->Buckets + AtomTable->NumberOfBuckets;
    for (CurrentBucket = AtomTable->Buckets;
         CurrentBucket != LastBucket;
         CurrentBucket++)
    {
        CurrentEntry = *CurrentBucket;
 
        while (CurrentEntry != NULL)
        {
            if (MaxAtomCount > 0)
            {
                *(AtomList++) = (RTL_ATOM)CurrentEntry->Atom;
                MaxAtomCount--;
            }
            else
            {
                /* buffer too small, but don't bail. we need to determine the
                   total number of atoms in the table! */
                Status = STATUS_INFO_LENGTH_MISMATCH;
            }
 
            Atoms++;
            CurrentEntry = CurrentEntry->HashLink;
        }
    }
 
    *AtomCount = Atoms;
 
    RtlpUnlockAtomTable(AtomTable);
 
    return Status;
}

Referenced by NtQueryInformationAtom().