/* (C) 2003-2007 Willem Jan Hengeveld <itsme@xs4all.nl>
 * Web: http://www.xs4all.nl/~itsme/
 *      http://wiki.xda-developers.com/
 *
 * $Id: pregdmp.cpp 1749 2008-03-11 17:12:13Z itsme $
 */
//*******************************************************************************************
//
// Filename : pregdmp.c
//
// Copyright (c) 1997 Microsoft Corporation. All rights reserved
//
//*******************************************************************************************
#include <windows.h>
#include <rapi.h>
#include <stdio.h>
#include "debug.h"
#include <string>
#include <vector>
typedef std::vector<std::string> StringList;
typedef std::vector<WCHAR> WSTRING;

bool fDebug= false;

#define MAX_NAME_BUF_SIZE   256
#define MAX_VALUE_BUF_SIZE  1024

void indent(int level)
{
    while(level--)
        putchar('\t');
}

void DumpChild(HKEY hKey, int level)
{
    // first dump values
    int k= 0;
    while(1)
    {
        DWORD cbName = MAX_NAME_BUF_SIZE;
        DWORD cbData = MAX_VALUE_BUF_SIZE;
        DWORD dwType; 

        // Throw a pair of NULLS on end of string so printfs don't run off the end of max size strings
        WCHAR Name[MAX_NAME_BUF_SIZE+2];
        memset(Name, 0, sizeof(Name));
        BYTE lpData[MAX_VALUE_BUF_SIZE+2];
        memset(lpData, 0, sizeof(lpData));

        LONG res= CeRegEnumValue(hKey, k, Name, &cbName, NULL, &dwType, lpData, &cbData);
        if (res==ERROR_NO_MORE_ITEMS)
            break;
        printf( "(%04ld) ", k++);       // <<< here is the loop variable
        indent(level+1);
        if (res!=ERROR_SUCCESS)
        {
            error(res, "ERROR");
            continue;
        }

        if (fDebug) {
            printf("T=%04x ", dwType);
            for (DWORD ii=0 ; ii<cbData ; ++ii)
                printf(" %02x", lpData[ii]);
            printf("\n");
        }

        printf("%ls = ", Name);
        switch(dwType) {
            case REG_DWORD:
                if (cbData!=sizeof(DWORD))
                    printf("DWORD of invalid size: %d\n", cbData);
                else
                    printf("0x%08lx", *(DWORD*)lpData);
                break;

            case REG_SZ:
                printf("\"%ls\"", lpData);
                break;

            case REG_MULTI_SZ:
                {
                printf("MULTI_SZ: \n");
                LPWSTR lpszString = (LPWSTR)lpData;
                while( 0 != *lpszString )
                {
                    indent(level+3);
                    printf("\"%ls\"\n", lpszString );
                    lpszString += wcslen( lpszString ) + 1;
                }
                break;
                }

            case REG_BINARY :
            default:
                if (dwType==REG_BINARY)
                    printf("hex: ");
                else
                    printf("hex(%d): ", dwType);
                for (DWORD n=0; n < cbData; n++)
                {
                    if (n)
                        printf(",");
                    printf("%02x", *(lpData+n));
                }
                break;
        }

        printf("\n");
    }

    // dump child keys
    int i=0; 
    while (1)
    {
        DWORD cbName = MAX_NAME_BUF_SIZE;
        WCHAR Name[MAX_NAME_BUF_SIZE+2];
        memset(Name, 0, sizeof(Name));
        LONG res =CeRegEnumKeyEx(hKey, i, Name, &cbName, NULL, NULL, NULL, NULL);
        if (res==ERROR_NO_MORE_ITEMS)
            break;
        printf( "<%04ld> ", i++);       // <<< here is the loop variable
        indent(level);
        if (res!=ERROR_SUCCESS)
        {
            error(res, "ERROR");
            continue;
        }

        printf("[%ls]\n", Name);

        HKEY hChildKey;
        res= CeRegOpenKeyEx(hKey, Name, 0, 0, &hChildKey);
        if (res != ERROR_SUCCESS)
        {
            error(res, "Failed to open subkey '%ls'", Name);
            continue;
        }
        DumpChild(hChildKey, level+1);
        CeRegCloseKey(hChildKey);
    }
}
void DumpKey(const std::string& key)
{
    HKEY hRoot;
    std::string path;
    std::string rootname;

    size_t slashpos= key.find_first_of("/\\");

    if (slashpos==0)
        slashpos= key.find_first_of("/\\", slashpos+1);

    if (stricmp(key.substr(0,slashpos).c_str(), "hkcr")==0)
    {
        hRoot= HKEY_CLASSES_ROOT;
        rootname= "HKEY_CLASSES_ROOT";
        if (slashpos==key.npos)
            path= "";
        else
            path= key.substr(slashpos+1);
    }
    else if (stricmp(key.substr(0,slashpos).c_str(), "hkcu")==0)
    {
        hRoot= HKEY_CURRENT_USER;
        rootname= "HKEY_CURRENT_USER";
        if (slashpos==key.npos)
            path= "";
        else
            path= key.substr(slashpos+1);
    }
    else if (stricmp(key.substr(0,slashpos).c_str(), "hklm")==0)
    {
        hRoot= HKEY_LOCAL_MACHINE;
        rootname= "HKEY_LOCAL_MACHINE";
        if (slashpos==key.npos)
            path= "";
        else
            path= key.substr(slashpos+1);
    }
    else {
        hRoot= HKEY_LOCAL_MACHINE;
        rootname= "HKEY_LOCAL_MACHINE";
        if (key.find_first_of("/\\")==0)
            path= key.substr(1);
        else
            path= key;
    }

    if (!path.empty())
    {
        WSTRING wpath; wpath.resize(path.size()+1);
        _snwprintf(&wpath[0], wpath.size(), L"%hs", path.c_str());
        LONG res= CeRegOpenKeyEx(hRoot, &wpath[0], 0, 0, &hRoot);
        if (res!=ERROR_SUCCESS)
        {
            error(res, "Failed to open key '%ls'", &wpath[0]);
            hRoot=NULL;
            return;
        }
        printf("%hs : %hs\n", rootname.c_str(), path.c_str());
    }
    else
    {
        printf("%hs\n", rootname.c_str());
    }
    DumpChild(hRoot, 1);

    return;
}

void usage()
{
    printf("(C) 2003-2008 Willem jan Hengeveld  itsme@xs4all.nl\n");
    printf("Usage: pregdmp [-d] [hklm|hkcr|hkcu]\\path\n");
}
int main(int argc, char *argv[])
{
    DebugStdOut();

    StringList keys;

    for (int i=1 ; i<argc ; i++)
    {
        if (argv[i][0]=='-') switch(argv[i][1])
        {
            case 'd':   fDebug= true; break;
            default:
                usage();
                return 1;
        }
        else 
            keys.push_back(std::string(argv[i]));
    }

    if (FAILED(CeRapiInit()))
    {
        printf( "Failed\n");
        return 1;
    }

    for (StringList::iterator i= keys.begin() ; i!=keys.end() ; ++i)
    {
        DumpKey(*i);
    }
    CeRapiUninit();

    return 0;
}