src/windows/lib/registry.c

   1 /*
   2  * Copyright (c) 1997 Cygnus Solutions
   3  *
   4  * Author:  Michael Graff
   5  */
   6
   7 #include <stdlib.h>
   8 #include <windows.h>
   9 #include <windowsx.h>
  10
  11 #include "registry.h"
  12
  13 HKEY
  14 registry_open(HKEY hkey, char *base, REGSAM sam)
  15 {
  16         HKEY    k = INVALID_HANDLE_VALUE;
  17         DWORD   err;
  18
  19         /*
  20          * if the base path is null, return the already open key in hkey
  21          */
  22         if (base == NULL)
  23                 return hkey;
  24
  25         err = RegOpenKeyEx(hkey, base, 0, sam, &hkey);
  26         if (err != ERROR_SUCCESS)
  27                 return INVALID_HANDLE_VALUE;
  28
  29         return hkey;
  30 }
  31
  32 void
  33 registry_close(HKEY hkey)
  34 {
  35         CloseHandle(hkey);
  36 }
  37
  38 HKEY
  39 registry_key_create(HKEY hkey, char *sub, REGSAM sam)
  40 {
  41         HKEY    key;
  42         DWORD   err;
  43         DWORD   disp;
  44
  45         err = RegCreateKeyEx(hkey, sub, 0, 0, REG_OPTION_NON_VOLATILE, sam,
  46                              NULL, &key, &disp);
  47         if (err != ERROR_SUCCESS)
  48                 return INVALID_HANDLE_VALUE;
  49
  50         return key;
  51 }
  52
  53 int
  54 registry_key_delete(HKEY hkey, char *sub)
  55 {
  56         DWORD err;
  57
  58         err = RegDeleteKey(hkey, sub);
  59         if (err != ERROR_SUCCESS)
  60                 return -1;
  61
  62         return 0;
  63 }
  64
  65 int
  66 registry_string_get(HKEY hkey, char *sub, char **val)
  67 {
  68         DWORD   err;
  69         DWORD   type;
  70         DWORD   datasize;
  71
  72         err = RegQueryValueEx(hkey, sub, 0, &type, 0, &datasize);
  73         if (err != ERROR_SUCCESS || type != REG_SZ) {
  74                 *val = NULL;
  75                 return -1;
  76         }
  77
  78         *val = malloc(datasize);
  79         if (*val == NULL)
  80                 return -1;
  81
  82         err = RegQueryValueEx(hkey, sub, 0, &type, *val, &datasize);
  83         if (err != ERROR_SUCCESS) {
  84                 free(*val);
  85                 *val = NULL;
  86                 return -1;
  87         }
  88
  89         return 0;
  90 }
  91
  92 int
  93 registry_dword_get(HKEY hkey, char *sub, DWORD *val)
  94 {
  95         DWORD   err;
  96         DWORD   type;
  97         DWORD   datasize;
  98
  99         err = RegQueryValueEx(hkey, sub, 0, &type, 0, &datasize);
 100         if (err != ERROR_SUCCESS || type != REG_DWORD) {
 101                 *val = 0;
 102                 return -1;
 103         }
 104
 105         err = RegQueryValueEx(hkey, sub, 0, &type, (BYTE *)val, &datasize);
 106         if (err != ERROR_SUCCESS) {
 107                 *val = 0;
 108                 return -1;
 109         }
 110
 111         return 0;
 112 }
 113
 114 int
 115 registry_string_set(HKEY hkey, char *sub, char *x)
 116 {
 117         DWORD   err;
 118
 119         err = RegSetValueEx(hkey, sub, 0, REG_SZ, (BYTE *)x, (DWORD)strlen(x) + 1);
 120         if (err != ERROR_SUCCESS)
 121                 return -1;
 122
 123         return 0;
 124 }
 125
 126 int
 127 registry_dword_set(HKEY hkey, char *sub, DWORD x)
 128 {
 129         DWORD   err;
 130
 131         err = RegSetValueEx(hkey, sub, 0, REG_DWORD, (CONST BYTE *)&x, sizeof(DWORD));
 132         if (err != ERROR_SUCCESS)
 133                 return -1;
 134
 135         return 0;
 136 }
 137
 138 int
 139 registry_keyval_dword_set(HKEY hkey, char *base, char *sub, DWORD val)
 140 {
 141         HKEY   k;
 142         int    err;
 143
 144         k = registry_open(hkey, base, KEY_WRITE);
 145         if (k == INVALID_HANDLE_VALUE)
 146                 return -1;
 147
 148         err = registry_dword_set(k, sub, val);
 149
 150         registry_close(k);
 151
 152         return err;
 153 }
 154
 155 int
 156 registry_keyval_dword_get(HKEY hkey, char *base, char *sub, DWORD *val)
 157 {
 158         HKEY   k;
 159         int    err;
 160
 161         k = registry_open(hkey, base, KEY_READ);
 162         if (k == INVALID_HANDLE_VALUE)
 163                 return -1;
 164
 165         err = registry_dword_get(k, sub, val);
 166
 167         registry_close(k);
 168
 169         return err;
 170 }
 171
 172 int
 173 registry_keyval_string_get(HKEY hkey, char *base, char *sub, char **val)
 174 {
 175         HKEY   k;
 176         int    err;
 177
 178         k = registry_open(hkey, base, KEY_READ);
 179         if (k == INVALID_HANDLE_VALUE) {
 180                 *val = NULL;
 181                 return -1;
 182         }
 183
 184         err = registry_string_get(k, sub, val);
 185
 186         registry_close(k);
 187
 188         return err;
 189 }
 190
 191 int
 192 registry_keyval_string_set(HKEY hkey, char *base, char *sub, char *val)
 193 {
 194         HKEY   k;
 195         int    err;
 196
 197         k = registry_open(hkey, base, KEY_WRITE);
 198         if (k == INVALID_HANDLE_VALUE)
 199                 return -1;
 200
 201         err = registry_string_set(k, sub, val);
 202
 203         registry_close(k);
 204
 205         return err;
 206 }
 207
 208 int
 209 registry_value_delete(HKEY hkey, char *sub)
 210 {
 211         if (RegDeleteValue(hkey, sub))
 212                 return -1;
 213
 214         return 0;
 215 }
 216
 217 int
 218 registry_keyval_delete(HKEY hkey, char *base, char *sub)
 219 {
 220         HKEY   k;
 221         int    err;
 222
 223         k = registry_open(hkey, base, KEY_WRITE);
 224         if (k == INVALID_HANDLE_VALUE)
 225                 return -1;
 226
 227         err = registry_value_delete(k, sub);
 228
 229         registry_close(k);
 230
 231         return err;
 232 }