source: trunk/gsinstaller/registry.cpp@ 3177

#include "registry.h"
#include <stdlib.h>

BOOL registry_createkey(HKEY key, const char *name, PHKEY keyout)
{ 
  LONG reply;
  DWORD disposition;

  reply = RegCreateKeyEx(key, name, 0, NULL,
             REG_OPTION_NON_VOLATILE,
             KEY_ALL_ACCESS, NULL,
             keyout, &disposition);
  if (reply != ERROR_SUCCESS)
    { 
      return FALSE;
    }
  return TRUE;
}

BOOL registry_openkey(HKEY key, const char *name, PHKEY keyout)
{
  LONG reply;

  reply = RegOpenKeyEx(key, name, 0, KEY_QUERY_VALUE | KEY_SET_VALUE, keyout);
  if (reply != ERROR_SUCCESS)
    {
      return FALSE;
    }
  return TRUE;
}

BOOL registry_deletekey(HKEY key, const char *name)
{   
  if (RegDeleteKey(key, name) != ERROR_SUCCESS)
    {
      return FALSE;
    }
  return TRUE;
}

BOOL registry_closekey(HKEY key)
{
  LONG reply;
  reply = RegCloseKey(key);
  if (reply != ERROR_SUCCESS)
  {
    return FALSE;
  }
  return TRUE;
}

BOOL registry_keyExists(HKEY key, const char *name)
{
  HKEY local;
  
  if (!registry_openkey(key, name, &local))
  {
    return FALSE;
  }
  registry_closekey(local);
  return TRUE;
}

BOOL registry_ensureKeyExists(HKEY key, const char *name)
{ 
  HKEY local;

  if (!registry_openkey(key, name, &local))
    {
      if (!registry_createkey(key, name, &local))
    {
      return FALSE;
    }
    }
  registry_closekey(local);
  return TRUE;
}

BOOL registry_deleteitem(HKEY key, const char *name)
{
  if (RegDeleteValue(key, name) != ERROR_SUCCESS)
    {
      return FALSE;
    }
  return TRUE;
}

BOOL registry_setstring(HKEY key, const char *name, const char *value)
{
  LONG reply;
  
  reply = RegSetValueEx(key, (LPCTSTR) name, 0, REG_SZ, (CONST BYTE *) value, strlen(value) + 1);
  if (reply != ERROR_SUCCESS)
  {
    return FALSE;
  }
  return TRUE;
}

BOOL registry_setlong(HKEY key, char *name, LONG value)
{
  LONG  reply;
  DWORD word;
  
  word = (DWORD) value;
  reply = RegSetValueEx(key, (LPCTSTR) name, 0, REG_DWORD, (CONST BYTE *) &word, sizeof(DWORD));
  if (reply != ERROR_SUCCESS)
  {
    return FALSE;
  }
  return TRUE;
}

BOOL registry_setblock(HKEY key, char *name, char *data, int size)
{
  LONG  reply;
  
  reply = RegSetValueEx(key, name, 0, REG_BINARY, (CONST BYTE *) data, size);
  if (reply != ERROR_SUCCESS)
  {
    // display_error();
    return FALSE;
  }
  return TRUE;
}

BOOL registry_setint(HKEY key, char *name, int value)
{ 
  return registry_setlong(key, name, (LONG) value);
}

BOOL registry_getstring(HKEY key, char *name, char **string)
{
  LONG reply;
  DWORD type;
  DWORD size;
  BYTE  buffer[128];
  int   tries = 0;

  do
    {
      reply = RegQueryValueEx(key, name, NULL, &type, buffer, &size);
      if (reply != ERROR_SUCCESS)
    {
      //display_error();
      //sprintf(buffer, "%x {%s}", key, name);
      //MessageBox(0, buffer, name, MB_OK);
    }
      tries ++;
    } while (reply != ERROR_SUCCESS && tries < 3);
  
  if (reply != ERROR_SUCCESS)
  {
    return FALSE;
  }

  *string = (char *) malloc(size);
  if (*string == NULL)
  {
    return FALSE;
  }
  strcpy(*string, (char *) buffer);
  return TRUE;
}

BOOL registry_getint(HKEY key, char *name, int *out)
{
  DWORD type;
  DWORD size;
  LONG  reply;

  reply = RegQueryValueEx(key, (LPTSTR) name, NULL, &type, (LPBYTE) out, &size);
  if (reply != ERROR_SUCCESS)
  {
    return FALSE;
  }
  return TRUE;
}

BOOL registry_getlong(HKEY key, char *name, LONG *out)
{
  DWORD type;
  DWORD size;
  LONG  reply;
  DWORD got;

  size = sizeof(DWORD);

  reply = RegQueryValueEx(key, name, NULL, &type, (LPBYTE) &got, &size);
  if (reply != ERROR_SUCCESS)
  {
    return FALSE;
  }
  *out = (LONG) got;
  return TRUE;
}

int registry_getblock(HKEY key, char *name, char *data, int size)
{
  DWORD type;
  DWORD lsize;
  LONG  reply;
  
  lsize = size;

  reply = RegQueryValueEx(key, name, NULL, &type, (LPBYTE) data, &lsize);
  if (reply != ERROR_SUCCESS)
  {
    return -1;
  }
  return lsize;
}

BOOL registry_fetchlong(char *keystr, LONG *lptr)
{
  HKEY key;
  
  if (!registry_openkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
    {
      return FALSE;
    }
  if (!registry_getlong(key, keystr, lptr))
    {   
      return FALSE;
    }
  if (registry_closekey(key) == FALSE)
  { 
    return FALSE;
  }
  return TRUE;
}

BOOL registry_fetchblock(char *keystr, char *data, int size)
{
  HKEY key;
  int read;

  if (!registry_openkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
    {
      return FALSE;
    }
  read = registry_getblock(key, keystr, data, size);
  if (read < 0)
    {   
      return FALSE;
    }
  if (registry_closekey(key) == FALSE)
  { 
    return FALSE;
  }
  return TRUE;
}

BOOL registry_storelong(char *keystr, LONG value)
{
  HKEY key;

  if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
  {
    return FALSE;
  }
  if (!registry_setlong(key, keystr, value))
  {
    return FALSE;
  }
  if (!registry_closekey(key))
  {
    return FALSE;
  }
  return TRUE;
}

BOOL registry_storeint(char *keystr, int value)
{ 
  HKEY key;
  
  if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
  {
    return FALSE;
  }
  if (!registry_setint(key, keystr, value))
  {
    return FALSE;
  }
  if (!registry_closekey(key))
  {
    return FALSE;
  }
  return TRUE;
}

BOOL registry_storeblock(char *keystr, char *data, int size)
{
  HKEY key;

  if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
  {
    return FALSE;
  }
  if (!registry_setblock(key, keystr, data, size))
  {
    return FALSE;
  }
  if (!registry_closekey(key))
  {
    return FALSE;
  }
  return TRUE;
}

BOOL registry_storestring(char *keystr, char *value)
{
  HKEY key;
  
  if (!registry_createkey(HKEY_LOCAL_MACHINE, "Software\\Kudlian Soft\\ReTreeval", &key))
  {
    return FALSE;
  }
  if (!registry_setstring(key, keystr, value))
  {
    return FALSE;
  }
  if (!registry_closekey(key))
  {
    return FALSE;
  }
  return TRUE;
}