warwin32registry.cpp

ftpserver very good sample

#include "StdAfx.h"
#include "WarWin32Registry.h"   // class implemented

#ifndef WAR_INCLUDED_SHLWAPI_H
#   define WAR_INCLUDED_SHLWAPI_h
#   include "shlwapi.h"
#endif

#ifndef WAR_INCLUDED_TCHAR_H
#   define WAR_INCLUDED_TCHAR_H
#   include <tchar.h>
#endif

#if WAR_CRYPTO && !defined(WAR_OPENSSL_RSA_H_INCLUDED)
#   define WAR_OPENSSL_RSA_H_INCLUDED
#   include <openssl/rsa.h>
#endif

#if WAR_CRYPTO && !defined(WAR_OPENSSL_PEM_H_INCLUDED)
#   define WAR_OPENSSL_PEM_H_INCLUDED
#   include <openssl/pem.h>
#endif

#ifndef WAR_LOG_H
#   include "WarLog.h"
#endif

#define DEFAULT_REGKEY_BUFLEN (1024 * 4 * sizeof(TCHAR))
#define DEFAULT_NAME_BUFFER_LEN (512)

using namespace std;

/////////////////////////////// PUBLIC ///////////////////////////////////////

war_registrypath_t WarWin32Registry::mRootPath;

#define BL_LEN EVP_CIPHER_block_size(ctx.cipher)
#define BL_ALIGN(a) a += (BL_LEN - (a % BL_LEN))


//============================= LIFECYCLE ====================================

WarWin32Registry::WarWin32Registry()
: mNodeKey(0),
mRootKey(0)
{
}

WarWin32Registry::~WarWin32Registry()
{
    Reset();
}

//============================= OPERATORS ====================================
//============================= OPERATIONS ===================================

void WarWin32Registry::Open(const open_t& openVal, 
                            int regMode)
                            throw(WarException)
{
    mCrypto = openVal.GetReg().mCrypto;
    Open(openVal.GetReg().mRootKey, openVal.GetPath());
}

void WarWin32Registry::Open(HKEY keyRoot, 
                              const war_registrypath_t& regPath, 
                              int regMode)
                              throw(WarException)
{
    LONG status = 0;

    Reset();

    mPath = regPath.IsEmpty() ? mRootPath : regPath;

    if ((status = ::RegOpenKeyEx(
        keyRoot,
        mPath.GetPath(),
        0,
        regMode,
        &mNodeKey)) != ERROR_SUCCESS)
    {
        WarError sys_err(WAR_ERR_SYSTEM_ERROR, status);
        if (status == ERROR_FILE_NOT_FOUND)
            sys_err = WAR_ERR_NAME_DONT_EXIST;
        WarThrow(sys_err, NULL);
    }

    mRootKey = keyRoot;
}

void WarWin32Registry::Create(const open_t& openVal, 
                            bool doFailIfNotExist)
                            throw(WarException)
{
    mCrypto = openVal.GetReg().mCrypto;
    Create(openVal.GetReg().mRootKey, 
        openVal.GetPath(), doFailIfNotExist);
}

void WarWin32Registry::Create(HKEY keyRoot, 
        const war_registrypath_t& regPath,
        bool doFailIfNotExist)
        throw(WarException)
{
    DWORD key_disposition = 0;
    LONG status = 0;

    mPath = regPath.IsEmpty() ? mRootPath : regPath;

    Reset();

    if ((status = ::RegCreateKeyEx(
        keyRoot,
        mPath.GetPath(),
        0,
        NULL,
        REG_OPTION_NON_VOLATILE,
        KEY_WRITE | KEY_READ,
        NULL,
        &mNodeKey,
        &key_disposition)) != ERROR_SUCCESS)
    {
        WarThrow(WarSystemError(), NULL);
    }

    if (doFailIfNotExist 
        && (REG_OPENED_EXISTING_KEY == key_disposition))
    {
        Reset();
        WarThrow(WarError(WAR_ERR_OBJECT_EXIST), NULL);
    }

    mRootKey = keyRoot;
}

war_regstr_t 
WarWin32Registry::GetStrValue(war_registrypath_ccstr_t valueName,
                           war_registrypath_ccstr_t defaultValue,
                           bool doFailIfNotExist,
                           bool doDecrypt) const
                           throw(WarException)
{
    war_regstr_t return_val;
    LONG status;
    char byte_buffer[DEFAULT_REGKEY_BUFLEN];
    DWORD dw_len = sizeof(byte_buffer), dw_type = 0;

#if WAR_CRYPTO
    if (doDecrypt)
    {
        if (GetEncryptedStrValue(valueName, return_val))
            return return_val;
    }
#endif

    if ((status = ::RegQueryValueEx(mNodeKey, valueName, 
        0, &dw_type, (LPBYTE)byte_buffer, &dw_len)) != ERROR_SUCCESS)
    {
        if((ERROR_FILE_NOT_FOUND == status)
            && !doFailIfNotExist)
        {
            return defaultValue ? defaultValue : _T("");
        }
        WarThrow(WarError(WAR_ERR_SYSTEM_ERROR, status), NULL);
    }

    switch(dw_type)
    {
        //case REG_DWORD:
        case REG_DWORD_LITTLE_ENDIAN:
        case REG_DWORD_BIG_ENDIAN:
            {
                DWORD my_dw_value = *(DWORD *)byte_buffer;
                if (REG_DWORD_BIG_ENDIAN == dw_type)
                    my_dw_value = ::ntohl(my_dw_value);
                WarItoa(return_val, my_dw_value);
            }
            break;
        case REG_EXPAND_SZ:
            {
                char tmp_buffer[DEFAULT_REGKEY_BUFLEN];
                if (!ExpandEnvironmentStrings(
                    (TCHAR *)byte_buffer, 
                    (TCHAR *)tmp_buffer, 
                    DEFAULT_REGKEY_BUFLEN / sizeof(TCHAR)) )
                {
                    WarThrow(WarSystemError(), NULL);
                }
                return_val = (TCHAR *)tmp_buffer;
            }
            break;
        case REG_SZ:
            return_val = (TCHAR *)byte_buffer;
            break;
        case REG_NONE:
            break;
#if 0  //  REG_QWORD
        case REG_QWORD:
        //case REG_QWORD_LITTLE_ENDIAN:
            {
                QWORD my_dw_value = *(QWORD *)byte_buffer;
                WarItoa(return_val, my_dw_value);
            }
            break;
#endif // REG_QWORD
        default:
            WarThrow(WarError(WAR_ERR_INVALID_CASE_VALUE), NULL);
            break;
    }

    return return_val;
}

DWORD WarWin32Registry::GetIntValue(war_registrypath_ccstr_t valueName,
                               DWORD defaultValue,
                               bool doFailIfNotExist) const
                               throw(WarException)
{
    DWORD return_val;
    LONG status;
    char byte_buffer[DEFAULT_REGKEY_BUFLEN];
    DWORD dw_len = sizeof(byte_buffer), dw_type = 0;

    if ((status = ::RegQueryValueEx(mNodeKey, valueName, 
        0, &dw_type, (LPBYTE)byte_buffer, &dw_len)) != ERROR_SUCCESS)
    {
        if (doFailIfNotExist)
            WarThrow(WarError(WAR_ERR_SYSTEM_ERROR, status), NULL);
        return defaultValue;
    }

    switch(dw_type)
    {
        //case REG_DWORD:
        case REG_DWORD_LITTLE_ENDIAN:
        case REG_DWORD_BIG_ENDIAN:
            {
                DWORD my_dw_value = *(DWORD *)byte_buffer;
                if (REG_DWORD_BIG_ENDIAN == dw_type)
                    my_dw_value = ::ntohl(my_dw_value);
                return_val = my_dw_value;
            }
            break;
        default:
            WarThrow(WarError(WAR_ERR_INVALID_CASE_VALUE), NULL);
            break;
    }

    return return_val;
}

WarWin32Registry::regstr_list_t 
WarWin32Registry::GetStrListValue(war_registrypath_ccstr_t valueName,
        regstr_list_t& defaultValue,
        bool doFailIfNotExist) const 
        throw(WarException)
{
    regstr_list_t return_val;
    war_regstr_t str_val;
    LONG status;
    char byte_buffer[DEFAULT_REGKEY_BUFLEN];
    DWORD dw_len = sizeof(byte_buffer), dw_type = 0;

    if ((status = ::RegQueryValueEx(mNodeKey, valueName, 
        0, &dw_type, (LPBYTE)byte_buffer, &dw_len)) != ERROR_SUCCESS)
    {
        WarThrow(WarError(WAR_ERR_SYSTEM_ERROR, status), NULL);
    }

    switch(dw_type)
    {
        //case REG_DWORD:
        case REG_DWORD_LITTLE_ENDIAN:
        case REG_DWORD_BIG_ENDIAN:
            {
                DWORD my_dw_value = *(DWORD *)byte_buffer;
                if (REG_DWORD_BIG_ENDIAN == dw_type)
                    my_dw_value = ::ntohl(my_dw_value);
                WarItoa(str_val, my_dw_value);
                return_val.push_back(str_val);
            }
            break;
        case REG_EXPAND_SZ:
            {
                char tmp_buffer[DEFAULT_REGKEY_BUFLEN];
                if (!ExpandEnvironmentStrings(
                    (TCHAR *)byte_buffer, 
                    (TCHAR *)tmp_buffer, 
                    DEFAULT_REGKEY_BUFLEN / sizeof(TCHAR)) )
                {
                    WarThrow(WarSystemError(), NULL);
                }
                str_val = (TCHAR *)tmp_buffer;
                return_val.push_back(str_val);
            }
            break;
        case REG_SZ:
            str_val = (TCHAR *)byte_buffer;
            return_val.push_back(str_val);
            break;
        case REG_MULTI_SZ:
            {
                for(TCHAR *p = (TCHAR *)byte_buffer; *p; *p++)
                {
                    return_val.push_back(war_regstr_t(p));
                    p += return_val.back().size();
                }
            }
            break;
        case REG_NONE:
            break;
#if defined(REG_QWORD) && defined(HAVE_QWORD)
        case REG_QWORD:
        //case REG_QWORD_LITTLE_ENDIAN:
            {
                QWORD my_dw_value = *(QWORD *)byte_buffer;
                WarItoa(str_val, my_dw_value);
                return_val.push_back(str_val);
            }
            break;
#endif // REG_QWORD
        default:
            WarThrow(WarError(WAR_ERR_INVALID_CASE_VALUE), NULL);
            break;
    }

    return return_val;
}

static char *last_encr_buf;

void WarWin32Registry::SetValue(war_registrypath_ccstr_t valueName, 
                                const war_regstr_t& newValue,
                                bool doEncrypt) const
                                throw(WarException)
{
    LONG status = 0;
    CONST BYTE * new_value;
    size_t bytes = 0;
    
#if WAR_CRYPTO
    war_registrypath_t cr_path;
    war_regstr_t encr_value;

    if (doEncrypt)
    {
        // Delete the unencrypted version, if it exists
        try
        {
            DeleteValue(valueName);
        }
        catch(WarException& ex)
        {
            if (ex.LocalError() != WAR_ERR_OBJECT_NOT_FOUND)
                throw ex;
        }