regproc.c

ReactOS是一些高手根据Windows XP的内核编写出的类XP。内核实现机理和API函数调用几乎相同。甚至可以兼容XP的程序。喜欢研究系统内核的人可以看一看。

            fseek(reg_file, 0L, SEEK_SET);
            processRegLines(reg_file, doSetValue);
        }
        fclose(reg_file);
        return TRUE;
    }
    return FALSE;
}

/******************************************************************************
 * Recursive function which removes the registry key with all subkeys.
 */
static void delete_branch(HKEY key,
                   CHAR **reg_key_name_buf, DWORD *reg_key_name_len)
{
    HKEY branch_key;
    DWORD max_sub_key_len;
    DWORD subkeys;
    DWORD curr_len;
    LONG ret;
    long int i;

    if (RegOpenKeyA(key, *reg_key_name_buf, &branch_key) != ERROR_SUCCESS) {
        REGPROC_print_error();
    }

    /* get size information and resize the buffers if necessary */
    if (RegQueryInfoKey(branch_key, NULL, NULL, NULL,
                        &subkeys, &max_sub_key_len,
                        NULL, NULL, NULL, NULL, NULL, NULL
                       ) != ERROR_SUCCESS) {
        REGPROC_print_error();
    }
    curr_len = (DWORD) strlen(*reg_key_name_buf);
    REGPROC_resize_char_buffer(reg_key_name_buf, reg_key_name_len,
                               max_sub_key_len + curr_len + 1);

    (*reg_key_name_buf)[curr_len] = '\\';
    for (i = subkeys - 1; i >= 0; i--) {
        DWORD buf_len = *reg_key_name_len - curr_len;

        ret = RegEnumKeyExA(branch_key, i, *reg_key_name_buf + curr_len + 1,
                            &buf_len, NULL, NULL, NULL, NULL);
        if (ret != ERROR_SUCCESS &&
                ret != ERROR_MORE_DATA &&
                ret != ERROR_NO_MORE_ITEMS) {
            REGPROC_print_error();
        } else {
            delete_branch(key, reg_key_name_buf, reg_key_name_len);
        }
    }
    (*reg_key_name_buf)[curr_len] = '\0';
    RegCloseKey(branch_key);
    RegDeleteKeyA(key, *reg_key_name_buf);
}

/******************************************************************************
 * Removes the registry key with all subkeys. Parses full key name.
 *
 * Parameters:
 * reg_key_name - full name of registry branch to delete. Ignored if is NULL,
 *      empty, points to register key class, does not exist.
 */
void delete_registry_key(CHAR *reg_key_name)
{
    CHAR *branch_name;
    DWORD branch_name_len;
    HKEY reg_key_class;
    HKEY branch_key;

    if (!reg_key_name || !reg_key_name[0])
        return;
    /* open the specified key */
    reg_key_class = getRegClass(reg_key_name);
    if (reg_key_class == (HKEY)ERROR_INVALID_PARAMETER) {
        fprintf(stderr,"%s: Incorrect registry class specification in '%s'\n",
                getAppName(), reg_key_name);
        exit(1);
    }
    branch_name = getRegKeyName(reg_key_name);
    CHECK_ENOUGH_MEMORY(branch_name);
    branch_name_len = (DWORD) strlen(branch_name);
    if (!branch_name[0]) {
        fprintf(stderr,"%s: Can't delete registry class '%s'\n",
                getAppName(), reg_key_name);
        exit(1);
    }
    if (RegOpenKeyA(reg_key_class, branch_name, &branch_key) == ERROR_SUCCESS) {
        /* check whether the key exists */
        RegCloseKey(branch_key);
        delete_branch(reg_key_class, &branch_name, &branch_name_len);
    }
    HeapFree(GetProcessHeap(), 0, branch_name);
}

/******************************************************************************
 * Sets the application name. Then application name is used in the error
 * reporting.
 */
void setAppName(const CHAR *name)
{
    app_name = name;
}

const CHAR *getAppName(void)
{
    return app_name;
}

LONG RegCopyKey(HKEY hDestKey, LPCTSTR lpDestSubKey, HKEY hSrcKey, LPCTSTR lpSrcSubKey)
{
    LONG lResult;
    DWORD dwDisposition;
    HKEY hDestSubKey = NULL;
    HKEY hSrcSubKey = NULL;
    DWORD dwIndex, dwType, cbName, cbData;
    TCHAR szSubKey[256];
    TCHAR szValueName[256];
    BYTE szValueData[512];

    FILETIME ft;

    /* open the source subkey, if specified */
    if (lpSrcSubKey)
    {
        lResult = RegOpenKeyEx(hSrcKey, lpSrcSubKey, 0, KEY_ALL_ACCESS, &hSrcSubKey);
        if (lResult)
            goto done;
        hSrcKey = hSrcSubKey;
    }

    /* create the destination subkey */
    lResult = RegCreateKeyEx(hDestKey, lpDestSubKey, 0, NULL, 0, KEY_WRITE, NULL,
        &hDestSubKey, &dwDisposition);
    if (lResult)
        goto done;

    /* copy all subkeys */
    dwIndex = 0;
    do
    {
        cbName = sizeof(szSubKey) / sizeof(szSubKey[0]);
        lResult = RegEnumKeyEx(hSrcKey, dwIndex++, szSubKey, &cbName, NULL, NULL, NULL, &ft);
        if (lResult == ERROR_SUCCESS)
        {
            lResult = RegCopyKey(hDestSubKey, szSubKey, hSrcKey, szSubKey);
            if (lResult)
                goto done;
        }
    }
    while(lResult == ERROR_SUCCESS);

    /* copy all subvalues */
    dwIndex = 0;
    do
    {
        cbName = sizeof(szValueName) / sizeof(szValueName[0]);
        cbData = sizeof(szValueData) / sizeof(szValueData[0]);
        lResult = RegEnumValue(hSrcKey, dwIndex++, szValueName, &cbName, NULL, &dwType, szValueData, &cbData);
        if (lResult == ERROR_SUCCESS)
        {
            lResult = RegSetValueEx(hDestSubKey, szValueName, 0, dwType, szValueData, cbData);
            if (lResult)
                goto done;
        }
    }
    while(lResult == ERROR_SUCCESS);

    lResult = ERROR_SUCCESS;

done:
    if (hSrcSubKey)
        RegCloseKey(hSrcSubKey);
    if (hDestSubKey)
        RegCloseKey(hDestSubKey);
    if (lResult != ERROR_SUCCESS)
        SHDeleteKey(hDestKey, lpDestSubKey);
    return lResult;

}

LONG RegMoveKey(HKEY hDestKey, LPCTSTR lpDestSubKey, HKEY hSrcKey, LPCTSTR lpSrcSubKey)
{
    LONG lResult;

    if (!lpSrcSubKey)
        return ERROR_INVALID_FUNCTION;

    lResult = RegCopyKey(hDestKey, lpDestSubKey, hSrcKey, lpSrcSubKey);
    if (lResult == ERROR_SUCCESS)
        SHDeleteKey(hSrcKey, lpSrcSubKey);

    return lResult;
}

LONG RegRenameKey(HKEY hKey, LPCTSTR lpSubKey, LPCTSTR lpNewName)
{
    LPCTSTR s;
    LPTSTR lpNewSubKey = NULL;
    LONG Ret = 0;

	if (!lpSubKey)
		return Ret;

    s = _tcsrchr(lpSubKey, _T('\\'));
    if (s)
    {
        s++;
        lpNewSubKey = (LPTSTR) HeapAlloc(GetProcessHeap(), 0, (s - lpSubKey + _tcslen(lpNewName) + 1) * sizeof(TCHAR));
        if (lpNewSubKey != NULL)
        {
            memcpy(lpNewSubKey, lpSubKey, (s - lpSubKey) * sizeof(TCHAR));
            _tcscpy(lpNewSubKey + (s - lpSubKey), lpNewName);
            lpNewName = lpNewSubKey;
        }
        else
            return ERROR_NOT_ENOUGH_MEMORY;
    }
    
    Ret = RegMoveKey(hKey, lpNewName, hKey, lpSubKey);

    if (lpNewSubKey)
    {
        HeapFree(GetProcessHeap(), 0, lpNewSubKey);
    }
    return Ret;
}

LONG RegRenameValue(HKEY hKey, LPCTSTR lpSubKey, LPCTSTR lpDestValue, LPCTSTR lpSrcValue)
{
    LONG lResult;
    HKEY hSubKey = NULL;
    DWORD dwType, cbData;
    BYTE data[512];

    if (lpSubKey)
    {
        lResult = RegOpenKey(hKey, lpSubKey, &hSubKey);
        if (lResult != ERROR_SUCCESS)
            goto done;
        hKey = hSubKey;
    }

    cbData = sizeof(data);
    lResult = RegQueryValueEx(hKey, lpSrcValue, NULL, &dwType, data, &cbData);
    if (lResult != ERROR_SUCCESS)
        goto done;

    lResult = RegSetValueEx(hKey, lpDestValue, 0, dwType, data, cbData);
    if (lResult != ERROR_SUCCESS)
        goto done;

    RegDeleteValue(hKey, lpSrcValue);

done:
    if (hSubKey)
        RegCloseKey(hSubKey);
    return lResult;
}

LONG RegQueryStringValue(HKEY hKey, LPCTSTR lpSubKey, LPCTSTR lpValueName, LPTSTR pszBuffer, DWORD dwBufferLen)
{
    LONG lResult;
    HKEY hSubKey = NULL;
    DWORD cbData, dwType;

    if (lpSubKey)
    {
        lResult = RegOpenKey(hKey, lpSubKey, &hSubKey);
        if (lResult != ERROR_SUCCESS)
            goto done;
        hKey = hSubKey;
    }

    cbData = (dwBufferLen - 1) * sizeof(*pszBuffer);
    lResult = RegQueryValueEx(hKey, lpValueName, NULL, &dwType, (LPBYTE) pszBuffer, &cbData);
    if (lResult != ERROR_SUCCESS)
        goto done;
    if (dwType != REG_SZ)
    {
        lResult = -1;
        goto done;
    }

    pszBuffer[cbData / sizeof(*pszBuffer)] = '\0';

done:
    if (lResult != ERROR_SUCCESS)
        pszBuffer[0] = '\0';
    if (hSubKey)
        RegCloseKey(hSubKey);
    return lResult;
}

/******************************************************************************
 * Searching
 */

static LONG RegNextKey(HKEY hKey, LPTSTR lpSubKey, size_t iSubKeyLength)
{
    LONG lResult;
    LPTSTR s;
    LPCTSTR pszOriginalKey;
    TCHAR szKeyName[256];
    HKEY hSubKey, hBaseKey;
    DWORD dwIndex = 0;
    DWORD cbName;
    FILETIME ft;
    BOOL bFoundKey = FALSE;

    /* Try accessing a subkey */
    if (RegOpenKeyEx(hKey, lpSubKey, 0, KEY_ALL_ACCESS, &hSubKey) == ERROR_SUCCESS)
    {
        cbName = (DWORD) iSubKeyLength - _tcslen(lpSubKey) - 1;
        lResult = RegEnumKeyEx(hSubKey, 0, lpSubKey + _tcslen(lpSubKey) + 1,
            &cbName, NULL, NULL, NULL, &ft);
        RegCloseKey(hSubKey);
        
        if (lResult == ERROR_SUCCESS)
        {
            lpSubKey[_tcslen(lpSubKey)] = '\\';
            bFoundKey = TRUE;
        }
    }

    if (!bFoundKey)
    {
        /* Go up and find the next sibling key */
        do
        {
            s = _tcsrchr(lpSubKey, '\\');
            if (s)
            {
                *s = '\0';
                pszOriginalKey = s + 1;

                hBaseKey = NULL;
                RegOpenKeyEx(hKey, lpSubKey, 0, KEY_ALL_ACCESS, &hBaseKey);
            }
            else
            {
                pszOriginalKey = lpSubKey;
                hBaseKey = hKey;
            }

            if (hBaseKey)
            {
                dwIndex = 0;
                do
                {
                    lResult = RegEnumKey(hBaseKey, dwIndex++, szKeyName, sizeof(szKeyName) / sizeof(szKeyName[0]));
                }
                while((lResult == ERROR_SUCCESS) && _tcscmp(szKeyName, pszOriginalKey));

                if (lResult == ERROR_SUCCESS)
                {
                    lResult = RegEnumKey(hBaseKey, dwIndex++, szKeyName, sizeof(szKeyName) / sizeof(szKeyName[0]));
                    if (lResult == ERROR_SUCCESS)
                    {
                        bFoundKey = TRUE;
                        _sntprintf(lpSubKey + _tcslen(lpSubKey), iSubKeyLength - _tcslen(lpSubKey), _T("\\%s"), szKeyName);
                    }
                }
                RegCloseKey(hBaseKey);
            }
        }
        while(!bFoundKey);
    }
    return bFoundKey ? ERROR_SUCCESS : ERROR_NO_MORE_ITEMS;
}

static BOOL RegSearchCompare(LPCTSTR s1, LPCTSTR s2, DWORD dwSearchFlags)
{
    BOOL bResult;
    if (dwSearchFlags & RSF_WHOLESTRING)
    {
        if (dwSearchFlags & RSF_MATCHCASE)
            bResult = !_tcscmp(s1, s2);
        else
            bResult = !_tcsicmp(s1, s2);
    }
    else
    {
        if (dwSearchFlags & RSF_MATCHCASE)
            bResult = (_tcsstr(s1, s2) != NULL);
        else
        {
            /* My kingdom for _tcsistr() */
            bResult = FALSE;
            while(*s1)
            {
                if (!_tcsnicmp(s1, s2, _tcslen(s2)))
                {
                    bResult = TRUE;
                    break;
                }
                s1++;
            }
        }
    }
    return bResult;
}

LONG RegSearch(HKEY hKey, LPTSTR lpSubKey, size_t iSubKeyLength,
    LPCTSTR pszSearchString, DWORD dwValueIndex,    
    DWORD dwSearchFlags, BOOL (*pfnCallback)(LPVOID), LPVOID lpParam)
{
    LONG lResult;
    LPCTSTR s;

    UNREFERENCED_PARAMETER(dwValueIndex);

    if (dwSearchFlags & (RSF_LOOKATVALUES | RSF_LOOKATDATA))
        return ERROR_CALL_NOT_IMPLEMENTED;    /* NYI */

    do
    {
        if (pfnCallback)
        {
            if (pfnCallback(lpParam))
                return ERROR_OPERATION_ABORTED;
        }

        lResult = RegNextKey(hKey, lpSubKey, iSubKeyLength);
        if (lResult != ERROR_SUCCESS)
            return lResult;

        s = _tcsrchr(lpSubKey, '\\');
        s = s ? s + 1 : lpSubKey;
    }
    while(!(dwSearchFlags & RSF_LOOKATKEYS) || !RegSearchCompare(s, pszSearchString, dwSearchFlags));

    return ERROR_SUCCESS;
}

/******************************************************************************
 * Key naming and parsing
 */

BOOL RegKeyGetName(LPTSTR pszDest, size_t iDestLength, HKEY hRootKey, LPCTSTR lpSubKey)
{
    LPCTSTR pszRootKey;

    if (hRootKey == HKEY_CLASSES_ROOT)
        pszRootKey = TEXT("HKEY_CLASSES_ROOT");
    else if (hRootKey == HKEY_CURRENT_USER)
        pszRootKey = TEXT("HKEY_CURRENT_USER");
    else if (hRootKey == HKEY_LOCAL_MACHINE)
        pszRootKey = TEXT("HKEY_LOCAL_MACHINE");
    else if (hRootKey == HKEY_USERS)
        pszRootKey = TEXT("HKEY_USERS");
    else if (hRootKey == HKEY_CURRENT_CONFIG)
        pszRootKey = TEXT("HKEY_CURRENT_CONFIG");
    else if (hRootKey == HKEY_DYN_DATA)
        pszRootKey = TEXT("HKEY_DYN_DATA");
    else
        return FALSE;

    if (lpSubKey[0])
        _sntprintf(pszDest, iDestLength, TEXT("%s\\%s"), pszRootKey, lpSubKey);
    else
        _sntprintf(pszDest, iDestLength, TEXT("%s"), pszRootKey);
    return TRUE;
}