root/swishctl/src/regkey.cpp

/*
 * $Id$
 *
 * SwishCtl - SWISH-E API ActiveX Control
 * Copyright (c) 2003 Peoples Resource Centre Wellington NZ
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/* - - - - - - - - - - - - - - - - - - - - - - - - - - -
 * RegKey Starts
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "stdafx.h"
#include <string>
using namespace std;

#include "regkey.h"

RegKey::RegKey(HKEY startkey)
{
        hkey=NULL; 
        this->startkey = startkey;
}

bool RegKey::CreateKey(const char *keyname)
{
        if ( ! keyname ) return false;
        if (hkey) RegCloseKey(hkey);

        LONG res = RegCreateKeyEx(startkey,  keyname, 
                        0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, 0, &hkey, 0 ) ;

        return res == ERROR_SUCCESS;
}

bool RegKey::OpenKey(const char *keyname, REGSAM samdesired )
{
        if ( ! keyname ) return false;
        if (hkey) RegCloseKey(hkey);
#if 0
        LONG res = RegOpenKeyEx (startkey, 
                                                        (const char *)keyname, 
                                                        0, 
                                                        samdesired, 
                                                        &hkey);
#endif
        DWORD disposition;
        LONG res = RegCreateKeyEx(
          startkey,                // handle to an open key
          (const char *)keyname,         // address of subkey name
          0,           // reserved
          NULL,           // address of class string
          REG_OPTION_NON_VOLATILE,          // special options flag
          samdesired,        // desired security access
          NULL,
                                                                // address of key security structure
          &hkey,          // address of buffer for opened handle
          &disposition   // address of disposition value buffer
        );
 
        return res == ERROR_SUCCESS;
}

bool RegKey::OpenKey(const char *keyname)
{
        return OpenKey(keyname, KEY_ALL_ACCESS );
}

bool RegKey::SetValue(const char *valuename, const char *value)
{
        if ( ! valuename || ! value ) return false;
        LONG res = RegSetValueEx( hkey, valuename, 0, REG_SZ,
                                                          (const unsigned char *)value, lstrlen(value)+1);
        return res == ERROR_SUCCESS;
}


string RegKey::QueryValue(const char *valuename)
{
        DWORD dwType = REG_SZ;

        if (! hkey ) return NULL; // can I do this ?

        LPBYTE lpData = NULL;
        DWORD cbData = 0;

        LONG res = RegQueryValueEx(     hkey, valuename, 0, &dwType, NULL, &cbData );
        
//      if ( res != ERROR_MORE_DATA ) { // this should be true but isn't
//              ::MessageBox( NULL, "ERROR_MORE_DATA should have been seen...", 
//                      "Whatever", MB_OK );
//              return NULL;    
//      } 

        lpData = (LPBYTE) malloc( cbData );

        if ( !lpData ) {
                ::MessageBox( NULL, "Out of memory error occured in QueryValue function.", 
                        "SwishCtl Error", MB_OK | MB_ICONINFORMATION);

                return *(new string());
        }

        res = RegQueryValueEx(  hkey, valuename, 0, &dwType, lpData, &cbData );
        
        if (res != ERROR_SUCCESS) {
                free( lpData );
                return *(new string());
        }

        string *temp = new string( (char *)lpData ) ;
        free( lpData );

        return *temp;
}

RegKey::~RegKey()
{
        if ( hkey )     ::RegCloseKey(hkey);
}

bool RegKey::DeleteKey(const char *subkey)
{
        return ::RegDeleteKey(hkey, subkey ) == ERROR_SUCCESS;
}

/* - - - - - - - - - - - - - - - - - - - - - - - - - - -
 * RegKey ends
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - */