source: trunk/gsinstaller/registry.cpp@ 1475

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

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

    reply = RegCreateKeyEx( key, name, NULL, 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, NULL, KEY_QUERY_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, NULL, 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, NULL, 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, NULL, 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;
}