stringtable.c File Reference

#include "setupapi_private.h"

Include dependency graph for stringtable.c:

Go to the source code of this file.

Classes
struct	_TABLE_SLOT
struct	_STRING_TABLE

Macros
#define	TABLE_DEFAULT_SIZE   256

Typedefs
typedef struct _TABLE_SLOT	TABLE_SLOT
typedef struct _TABLE_SLOT *	PTABLE_SLOT
typedef struct _STRING_TABLE	STRING_TABLE
typedef struct _STRING_TABLE *	PSTRING_TABLE

Functions
HSTRING_TABLE WINAPI	pSetupStringTableInitialize (VOID)
HSTRING_TABLE WINAPI	pSetupStringTableInitializeEx (DWORD dwMaxExtraDataSize, DWORD dwReserved)
VOID WINAPI	pSetupStringTableDestroy (HSTRING_TABLE hStringTable)
DWORD WINAPI	pSetupStringTableAddString (HSTRING_TABLE hStringTable, LPWSTR lpString, DWORD dwFlags)
DWORD WINAPI	pSetupStringTableAddStringEx (HSTRING_TABLE hStringTable, LPWSTR lpString, DWORD dwFlags, LPVOID lpExtraData, DWORD dwExtraDataSize)
HSTRING_TABLE WINAPI	pSetupStringTableDuplicate (HSTRING_TABLE hStringTable)
BOOL WINAPI	pSetupStringTableGetExtraData (HSTRING_TABLE hStringTable, DWORD dwId, LPVOID lpExtraData, DWORD dwExtraDataSize)
DWORD WINAPI	pSetupStringTableLookUpString (HSTRING_TABLE hStringTable, LPWSTR lpString, DWORD dwFlags)
DWORD WINAPI	pSetupStringTableLookUpStringEx (HSTRING_TABLE hStringTable, LPWSTR lpString, DWORD dwFlags, LPVOID lpExtraData, DWORD dwReserved)
BOOL WINAPI	pSetupStringTableSetExtraData (HSTRING_TABLE hStringTable, DWORD dwId, LPVOID lpExtraData, DWORD dwExtraDataSize)
LPWSTR WINAPI	pSetupStringTableStringFromId (HSTRING_TABLE hStringTable, DWORD dwId)
BOOL WINAPI	pSetupStringTableStringFromIdEx (HSTRING_TABLE hStringTable, DWORD dwId, LPWSTR lpBuffer, LPDWORD lpBufferLength)

Macro Definition Documentation

TABLE_DEFAULT_SIZE

#define TABLE_DEFAULT_SIZE   256

Definition at line 23 of file stringtable.c.

Typedef Documentation

PSTRING_TABLE

typedef struct _STRING_TABLE * PSTRING_TABLE

PTABLE_SLOT

typedef struct _TABLE_SLOT * PTABLE_SLOT

STRING_TABLE

typedef struct _STRING_TABLE STRING_TABLE

TABLE_SLOT

typedef struct _TABLE_SLOT TABLE_SLOT

Function Documentation

pSetupStringTableAddString()

DWORD WINAPI pSetupStringTableAddString	(	HSTRING_TABLE	hStringTable,
		LPWSTR	lpString,
		DWORD	dwFlags
	)

Definition at line 196 of file stringtable.c.

{
    PSTRING_TABLE pStringTable;
    DWORD i;
 
    TRACE("%p %s %x\n", hStringTable, debugstr_w(lpString), dwFlags);
 
    pStringTable = (PSTRING_TABLE)hStringTable;
    if (pStringTable == NULL)
    {
        ERR("Invalid hStringTable!\n");
        return (DWORD)-1;
    }
 
    /* Search for existing string in the string table */
    for (i = 0; i < pStringTable->dwMaxSlots; i++)
    {
        if (pStringTable->pSlots[i].pString != NULL)
        {
            if (dwFlags & 1)
            {
                if (!lstrcmpW(pStringTable->pSlots[i].pString, lpString))
                {
                    return i + 1;
                }
            }
            else
            {
                if (!lstrcmpiW(pStringTable->pSlots[i].pString, lpString))
                {
                    return i + 1;
                }
            }
        }
    }
 
    /* Check for filled slot table */
    if (pStringTable->dwUsedSlots == pStringTable->dwMaxSlots)
    {
        PTABLE_SLOT pNewSlots;
        DWORD dwNewMaxSlots;
 
        /* FIXME: not thread safe */
        dwNewMaxSlots = pStringTable->dwMaxSlots * 2;
        pNewSlots = MyMalloc(sizeof(TABLE_SLOT) * dwNewMaxSlots);
        if (pNewSlots == NULL)
            return (DWORD)-1;
        memset(&pNewSlots[pStringTable->dwMaxSlots], 0, sizeof(TABLE_SLOT) * (dwNewMaxSlots - pStringTable->dwMaxSlots));
        memcpy(pNewSlots, pStringTable->pSlots, sizeof(TABLE_SLOT) * pStringTable->dwMaxSlots);
        pNewSlots = InterlockedExchangePointer((PVOID*)&pStringTable->pSlots, pNewSlots);
        MyFree(pNewSlots);
        pStringTable->dwMaxSlots = dwNewMaxSlots;
 
        return pSetupStringTableAddString(hStringTable, lpString, dwFlags);
    }
 
    /* Search for an empty slot */
    for (i = 0; i < pStringTable->dwMaxSlots; i++)
    {
        if (pStringTable->pSlots[i].pString == NULL)
        {
            pStringTable->pSlots[i].pString = MyMalloc((lstrlenW(lpString) + 1) * sizeof(WCHAR));
            if (pStringTable->pSlots[i].pString == NULL)
            {
                TRACE("Couldn't allocate memory for a new string!\n");
                return (DWORD)-1;
            }
 
            lstrcpyW(pStringTable->pSlots[i].pString, lpString);
 
            pStringTable->dwUsedSlots++;
 
            return i + 1;
        }
    }
 
    TRACE("Couldn't find an empty slot!\n");
 
    return (DWORD)-1;
}

Referenced by CM_Connect_MachineW(), CM_Create_DevNode_ExW(), CM_Get_Child_Ex(), CM_Get_Parent_Ex(), CM_Get_Sibling_Ex(), CM_Locate_DevNode_ExW(), PnpGetLocalHandles(), and pSetupStringTableAddString().

pSetupStringTableAddStringEx()

DWORD WINAPI pSetupStringTableAddStringEx	(	HSTRING_TABLE	hStringTable,
		LPWSTR	lpString,
		DWORD	dwFlags,
		LPVOID	lpExtraData,
		DWORD	dwExtraDataSize
	)

Definition at line 303 of file stringtable.c.

{
    PSTRING_TABLE pStringTable;
    DWORD i;
 
    TRACE("%p %s %lx\n", (PVOID)hStringTable, debugstr_w(lpString), dwFlags);
 
    pStringTable = (PSTRING_TABLE)hStringTable;
    if (pStringTable == NULL)
    {
        ERR("Invalid hStringTable!\n");
        return (DWORD)-1;
    }
 
    /* Search for existing string in the string table */
    for (i = 0; i < pStringTable->dwMaxSlots; i++)
    {
        if (pStringTable->pSlots[i].pString != NULL)
        {
            if (dwFlags & 1)
            {
                if (!lstrcmpW(pStringTable->pSlots[i].pString, lpString))
                {
                    return i + 1;
                }
            }
            else
            {
                if (!lstrcmpiW(pStringTable->pSlots[i].pString, lpString))
                {
                    return i + 1;
                }
            }
        }
    }
 
    /* Check for filled slot table */
    if (pStringTable->dwUsedSlots == pStringTable->dwMaxSlots)
    {
        FIXME("Resize the string table!\n");
        return (DWORD)-1;
    }
 
    /* Search for an empty slot */
    for (i = 0; i < pStringTable->dwMaxSlots; i++)
    {
        if (pStringTable->pSlots[i].pString == NULL)
        {
            pStringTable->pSlots[i].pString = MyMalloc((lstrlenW(lpString) + 1) * sizeof(WCHAR));
            if (pStringTable->pSlots[i].pString == NULL)
            {
                TRACE("Couldn't allocate memory for a new string!\n");
                return (DWORD)-1;
            }
 
            lstrcpyW(pStringTable->pSlots[i].pString, lpString);
 
            pStringTable->pSlots[i].pData = MyMalloc(dwExtraDataSize);
            if (pStringTable->pSlots[i].pData == NULL)
            {
                TRACE("Couldn't allocate memory for a new extra data!\n");
                MyFree(pStringTable->pSlots[i].pString);
                pStringTable->pSlots[i].pString = NULL;
                return (DWORD)-1;
            }
 
            memcpy(pStringTable->pSlots[i].pData,
                   lpExtraData,
                   dwExtraDataSize);
            pStringTable->pSlots[i].dwSize = dwExtraDataSize;
 
            pStringTable->dwUsedSlots++;
 
            return i + 1;
        }
    }
 
    TRACE("Couldn't find an empty slot!\n");
 
    return (DWORD)-1;
}

pSetupStringTableDestroy()

VOID WINAPI pSetupStringTableDestroy

(

HSTRING_TABLE

hStringTable

)

Definition at line 145 of file stringtable.c.

{
    PSTRING_TABLE pStringTable;
    DWORD i;
 
    TRACE("%p\n", hStringTable);
 
    pStringTable = (PSTRING_TABLE)hStringTable;
    if (pStringTable == NULL)
        return;
 
    if (pStringTable->pSlots != NULL)
    {
        for (i = 0; i < pStringTable->dwMaxSlots; i++)
        {
            MyFree(pStringTable->pSlots[i].pString);
            pStringTable->pSlots[i].pString = NULL;
 
            MyFree(pStringTable->pSlots[i].pData);
            pStringTable->pSlots[i].pData = NULL;
            pStringTable->pSlots[i].dwSize = 0;
        }
 
        MyFree(pStringTable->pSlots);
    }
 
    MyFree(pStringTable);
}

Referenced by CM_Connect_MachineW(), CM_Disconnect_Machine(), PnpGetLocalHandles(), and PnpUnbindLocalBindingHandle().

pSetupStringTableDuplicate()

HSTRING_TABLE WINAPI pSetupStringTableDuplicate

(

HSTRING_TABLE

hStringTable

)

Definition at line 404 of file stringtable.c.

{
    PSTRING_TABLE pSourceTable;
    PSTRING_TABLE pDestinationTable;
    DWORD i;
    DWORD length;
 
    TRACE("%p\n", hStringTable);
 
    pSourceTable = (PSTRING_TABLE)hStringTable;
    if (pSourceTable == NULL)
    {
        ERR("Invalid hStringTable!\n");
        return (HSTRING_TABLE)NULL;
    }
 
    pDestinationTable = MyMalloc(sizeof(STRING_TABLE));
    if (pDestinationTable == NULL)
    {
        ERR("Could not allocate a new string table!\n");
        return (HSTRING_TABLE)NULL;
    }
 
    memset(pDestinationTable, 0, sizeof(STRING_TABLE));
 
    pDestinationTable->pSlots = MyMalloc(sizeof(TABLE_SLOT) * pSourceTable->dwMaxSlots);
    if (pDestinationTable->pSlots == NULL)
    {
        MyFree(pDestinationTable);
        return (HSTRING_TABLE)NULL;
    }
 
    memset(pDestinationTable->pSlots, 0, sizeof(TABLE_SLOT) * pSourceTable->dwMaxSlots);
 
    pDestinationTable->dwUsedSlots = 0;
    pDestinationTable->dwMaxSlots = pSourceTable->dwMaxSlots;
 
    for (i = 0; i < pSourceTable->dwMaxSlots; i++)
    {
        if (pSourceTable->pSlots[i].pString != NULL)
        {
            length = (lstrlenW(pSourceTable->pSlots[i].pString) + 1) * sizeof(WCHAR);
            pDestinationTable->pSlots[i].pString = MyMalloc(length);
            if (pDestinationTable->pSlots[i].pString != NULL)
            {
                memcpy(pDestinationTable->pSlots[i].pString,
                       pSourceTable->pSlots[i].pString,
                       length);
                pDestinationTable->dwUsedSlots++;
            }
 
            if (pSourceTable->pSlots[i].pData != NULL)
            {
                length = pSourceTable->pSlots[i].dwSize;
                pDestinationTable->pSlots[i].pData = MyMalloc(length);
                if (pDestinationTable->pSlots[i].pData)
                {
                    memcpy(pDestinationTable->pSlots[i].pData,
                           pSourceTable->pSlots[i].pData,
                           length);
                    pDestinationTable->pSlots[i].dwSize = length;
                }
            }
        }
    }
 
    return (HSTRING_TABLE)pDestinationTable;
}

pSetupStringTableGetExtraData()

BOOL WINAPI pSetupStringTableGetExtraData	(	HSTRING_TABLE	hStringTable,
		DWORD	dwId,
		LPVOID	lpExtraData,
		DWORD	dwExtraDataSize
	)

Definition at line 490 of file stringtable.c.

{
    PSTRING_TABLE pStringTable;
 
    TRACE("%p %x %p %u\n",
          hStringTable, dwId, lpExtraData, dwExtraDataSize);
 
    pStringTable = (PSTRING_TABLE)hStringTable;
    if (pStringTable == NULL)
    {
        ERR("Invalid hStringTable!\n");
        return FALSE;
    }
 
    if (dwId == 0 || dwId > pStringTable->dwMaxSlots)
    {
        ERR("Invalid Slot id!\n");
        return FALSE;
    }
 
    if (pStringTable->pSlots[dwId - 1].dwSize < dwExtraDataSize)
    {
        ERR("Data size is too large!\n");
        return FALSE;
    }
 
    memcpy(lpExtraData,
           pStringTable->pSlots[dwId - 1].pData,
           dwExtraDataSize);
 
    return TRUE;
}

pSetupStringTableInitialize()

HSTRING_TABLE WINAPI pSetupStringTableInitialize

(

VOID

)

Definition at line 54 of file stringtable.c.

{
    PSTRING_TABLE pStringTable;
 
    TRACE("\n");
 
    pStringTable = MyMalloc(sizeof(STRING_TABLE));
    if (pStringTable == NULL)
    {
        ERR("Invalid hStringTable!\n");
        return NULL;
    }
 
    memset(pStringTable, 0, sizeof(STRING_TABLE));
 
    pStringTable->pSlots = MyMalloc(sizeof(TABLE_SLOT) * TABLE_DEFAULT_SIZE);
    if (pStringTable->pSlots == NULL)
    {
        MyFree(pStringTable);
        return NULL;
    }
 
    memset(pStringTable->pSlots, 0, sizeof(TABLE_SLOT) * TABLE_DEFAULT_SIZE);
 
    pStringTable->dwUsedSlots = 0;
    pStringTable->dwMaxSlots = TABLE_DEFAULT_SIZE;
    pStringTable->dwMaxDataSize = 0;
 
    TRACE("Done\n");
 
    return (HSTRING_TABLE)pStringTable;
}

Referenced by CM_Connect_MachineW(), and PnpGetLocalHandles().

pSetupStringTableInitializeEx()

HSTRING_TABLE WINAPI pSetupStringTableInitializeEx	(	DWORD	dwMaxExtraDataSize,
		DWORD	dwReserved
	)

Definition at line 102 of file stringtable.c.

{
    PSTRING_TABLE pStringTable;
 
    TRACE("\n");
 
    pStringTable = MyMalloc(sizeof(STRING_TABLE));
    if (pStringTable == NULL) return NULL;
 
    memset(pStringTable, 0, sizeof(STRING_TABLE));
 
    pStringTable->pSlots = MyMalloc(sizeof(TABLE_SLOT) * TABLE_DEFAULT_SIZE);
    if (pStringTable->pSlots == NULL)
    {
        MyFree(pStringTable);
        return NULL;
    }
 
    memset(pStringTable->pSlots, 0, sizeof(TABLE_SLOT) * TABLE_DEFAULT_SIZE);
 
    pStringTable->dwUsedSlots = 0;
    pStringTable->dwMaxSlots = TABLE_DEFAULT_SIZE;
    pStringTable->dwMaxDataSize = dwMaxExtraDataSize;
 
    TRACE("Done\n");
 
    return (HSTRING_TABLE)pStringTable;
}

pSetupStringTableLookUpString()

DWORD WINAPI pSetupStringTableLookUpString	(	HSTRING_TABLE	hStringTable,
		LPWSTR	lpString,
		DWORD	dwFlags
	)

Definition at line 543 of file stringtable.c.

{
    PSTRING_TABLE pStringTable;
    DWORD i;
 
    TRACE("%p %s %x\n", hStringTable, debugstr_w(lpString), dwFlags);
 
    pStringTable = (PSTRING_TABLE)hStringTable;
    if (pStringTable == NULL)
    {
        ERR("Invalid hStringTable!\n");
        return (DWORD)-1;
    }
 
    /* Search for existing string in the string table */
    for (i = 0; i < pStringTable->dwMaxSlots; i++)
    {
        if (pStringTable->pSlots[i].pString != NULL)
        {
            if (dwFlags & 1)
            {
                if (!lstrcmpW(pStringTable->pSlots[i].pString, lpString))
                    return i + 1;
            }
            else
            {
                if (!lstrcmpiW(pStringTable->pSlots[i].pString, lpString))
                    return i + 1;
            }
        }
    }
 
    return (DWORD)-1;
}

pSetupStringTableLookUpStringEx()

DWORD WINAPI pSetupStringTableLookUpStringEx	(	HSTRING_TABLE	hStringTable,
		LPWSTR	lpString,
		DWORD	dwFlags,
		LPVOID	lpExtraData,
		DWORD	dwReserved
	)

Definition at line 599 of file stringtable.c.

{
    PSTRING_TABLE pStringTable;
    DWORD i;
 
    TRACE("%p %s %x %p, %x\n", hStringTable, debugstr_w(lpString), dwFlags,
          lpExtraData, dwReserved);
 
    pStringTable = (PSTRING_TABLE)hStringTable;
    if (pStringTable == NULL)
    {
        ERR("Invalid hStringTable!\n");
        return ~0u;
    }
 
    /* Search for existing string in the string table */
    for (i = 0; i < pStringTable->dwMaxSlots; i++)
    {
        if (pStringTable->pSlots[i].pString != NULL)
        {
            if (dwFlags & 1)
            {
                if (!lstrcmpW(pStringTable->pSlots[i].pString, lpString))
                {
                    if (lpExtraData)
                        memcpy(lpExtraData, pStringTable->pSlots[i].pData, dwReserved);
                    return i + 1;
                }
            }
            else
            {
                if (!lstrcmpiW(pStringTable->pSlots[i].pString, lpString))
                {
                    if (lpExtraData)
                        memcpy(lpExtraData, pStringTable->pSlots[i].pData, dwReserved);
                    return i + 1;
                }
            }
        }
    }
    return ~0u;
}

pSetupStringTableSetExtraData()

BOOL WINAPI pSetupStringTableSetExtraData	(	HSTRING_TABLE	hStringTable,
		DWORD	dwId,
		LPVOID	lpExtraData,
		DWORD	dwExtraDataSize
	)

Definition at line 663 of file stringtable.c.

{
    PSTRING_TABLE pStringTable;
 
    TRACE("%p %x %p %u\n",
          hStringTable, dwId, lpExtraData, dwExtraDataSize);
 
    pStringTable = (PSTRING_TABLE)hStringTable;
    if (pStringTable == NULL)
    {
        ERR("Invalid hStringTable!\n");
        return FALSE;
    }
 
    if (dwId == 0 || dwId > pStringTable->dwMaxSlots)
    {
        ERR("Invalid Slot id!\n");
        return FALSE;
    }
 
    if (pStringTable->dwMaxDataSize < dwExtraDataSize)
    {
        ERR("Data size is too large!\n");
        return FALSE;
    }
 
    pStringTable->pSlots[dwId - 1].pData = MyMalloc(dwExtraDataSize);
    if (pStringTable->pSlots[dwId - 1].pData == NULL)
    {
        ERR("\n");
        return FALSE;
    }
 
    memcpy(pStringTable->pSlots[dwId - 1].pData,
           lpExtraData,
           dwExtraDataSize);
    pStringTable->pSlots[dwId - 1].dwSize = dwExtraDataSize;
 
    return TRUE;
}

pSetupStringTableStringFromId()

LPWSTR WINAPI pSetupStringTableStringFromId	(	HSTRING_TABLE	hStringTable,
		DWORD	dwId
	)

Definition at line 722 of file stringtable.c.

{
    PSTRING_TABLE pStringTable;
    static WCHAR empty[] = {0};
 
    TRACE("%p %x\n", hStringTable, dwId);
 
    pStringTable = (PSTRING_TABLE)hStringTable;
    if (pStringTable == NULL)
    {
        ERR("Invalid hStringTable!\n");
        return NULL;
    }
 
    if (dwId == 0 || dwId > pStringTable->dwMaxSlots)
        return empty;
 
    return pStringTable->pSlots[dwId - 1].pString;
}

Referenced by CM_Add_Empty_Log_Conf_Ex(), CM_Add_ID_ExW(), CM_Create_DevNode_ExW(), CM_Delete_DevNode_Key_Ex(), CM_Disable_DevNode_Ex(), CM_Enable_DevNode_Ex(), CM_Free_Log_Conf_Ex(), CM_Get_Child_Ex(), CM_Get_Depth_Ex(), CM_Get_Device_ID_Size_Ex(), CM_Get_DevNode_Custom_Property_ExW(), CM_Get_DevNode_Registry_Property_ExW(), CM_Get_DevNode_Status_Ex(), CM_Get_First_Log_Conf_Ex(), CM_Get_Log_Conf_Priority_Ex(), CM_Get_Next_Log_Conf_Ex(), CM_Get_Next_Res_Des_Ex(), CM_Get_Parent_Ex(), CM_Get_Sibling_Ex(), CM_Move_DevNode_Ex(), CM_Open_DevNode_Key_Ex(), CM_Query_And_Remove_SubTree_ExW(), CM_Query_Arbitrator_Free_Data_Ex(), CM_Query_Arbitrator_Free_Size_Ex(), CM_Query_Resource_Conflict_List(), CM_Reenumerate_DevNode_Ex(), CM_Register_Device_Driver_Ex(), CM_Register_Device_Interface_ExW(), CM_Request_Device_Eject_ExW(), CM_Set_DevNode_Problem_Ex(), CM_Set_DevNode_Registry_Property_ExW(), CM_Setup_DevNode_Ex(), and CM_Uninstall_DevNode_Ex().

pSetupStringTableStringFromIdEx()

BOOL WINAPI pSetupStringTableStringFromIdEx	(	HSTRING_TABLE	hStringTable,
		DWORD	dwId,
		LPWSTR	lpBuffer,
		LPDWORD	lpBufferLength
	)

Definition at line 760 of file stringtable.c.

{
    PSTRING_TABLE pStringTable;
    DWORD dwLength;
    BOOL bResult = FALSE;
 
    TRACE("%p %x %p %p\n", hStringTable, dwId, lpBuffer, lpBufferLength);
 
    pStringTable = (PSTRING_TABLE)hStringTable;
    if (pStringTable == NULL)
    {
        ERR("Invalid hStringTable!\n");
        *lpBufferLength = 0;
        return FALSE;
    }
 
    if (dwId == 0 || dwId > pStringTable->dwMaxSlots ||
        pStringTable->pSlots[dwId - 1].pString == NULL)
    {
        WARN("Invalid string ID!\n");
        *lpBufferLength = 0;
        return FALSE;
    }
 
    dwLength = (lstrlenW(pStringTable->pSlots[dwId - 1].pString) + 1);
    if (dwLength <= *lpBufferLength)
    {
        lstrcpyW(lpBuffer, pStringTable->pSlots[dwId - 1].pString);
        bResult = TRUE;
    }
 
    *lpBufferLength = dwLength;
 
    return bResult;
}

Referenced by CM_Get_Device_ID_ExW().