unused/win95/winregs.c

   1 /*
   2 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   3 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   4 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   5 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   6 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   7 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   8 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
   9 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  10 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  11 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  12 */
  13
  14
  15 #pragma off (unreferenced)
  16 static char rcsid[] = "$Id: winregs.c,v 1.1.1.1 2001-01-19 03:30:15 bradleyb Exp $";
  17 #pragma on (unreferenced)
  18
  19 #define WIN95
  20 #define _WIN32
  21 #define WIN32_LEAN_AND_MEAN
  22 #include <windows.h>
  23 #include <string.h>
  24
  25 #include "error.h"
  26 #include "mono.h"
  27 #include "winregs.h"
  28
  29
  30 static HKEY hRootKey=HKEY_LOCAL_MACHINE;
  31
  32
  33 void registry_setpath(HKEY hKey)
  34 {
  35         hRootKey = HKEY_LOCAL_MACHINE;
  36 }
  37
  38
  39
  40 registry_handle *registry_open(const char *path)
  41 {
  42         char *regtoken;
  43         int keys;
  44         int i;
  45         char *regpath;
  46         long lres;
  47         registry_handle *handle;
  48
  49 //      Find number of keys
  50         regpath = (char *)malloc(strlen(path)+1);
  51         if (!regpath) return NULL;
  52
  53         strcpy(regpath, path);
  54
  55         i = 0;
  56         regtoken = strtok(regpath, "\\");
  57         if (!regtoken) {
  58                 free(regpath);
  59                 return NULL;
  60         }
  61
  62         while (regtoken)
  63         {
  64                 i++;
  65                 regtoken = strtok(NULL, "\\");
  66         }
  67
  68         keys = i;
  69         handle = (registry_handle*)malloc(sizeof(registry_handle));
  70         handle->keys = keys;
  71         handle->hKey = (HKEY *)malloc(sizeof(HKEY)*keys);
  72         if (!handle->hKey) {
  73                 free(handle);
  74                 return NULL;
  75         }
  76
  77         memset(handle->hKey, 0, sizeof(HKEY)*keys);
  78
  79 //      Create keys
  80         i = 0;
  81         strcpy(regpath, path);
  82         regtoken = strtok(regpath, "\\");
  83
  84         if (regtoken) mprintf((0, "%s\\", regtoken));
  85
  86         lres = RegOpenKeyEx(hRootKey, regtoken, 0, KEY_EXECUTE | KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE, &handle->hKey[i]);
  87         if (lres != ERROR_SUCCESS)
  88                 goto RegistryOpen_Cleanup;
  89
  90         regtoken = strtok(NULL, "\\");
  91         i++;
  92         if (regtoken) mprintf((0, "%s\\", regtoken));
  93
  94
  95         while (regtoken)
  96         {
  97                 lres = RegOpenKeyEx(handle->hKey[i-1], regtoken, 0, KEY_EXECUTE | KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE, &handle->hKey[i]);
  98                 if (lres != ERROR_SUCCESS)
  99                         goto RegistryOpen_Cleanup;
 100
 101                 regtoken = strtok(NULL, "\\");
 102                 if (regtoken) mprintf((0, "%s\\", regtoken));
 103                 i++;
 104         }
 105
 106         free(regpath);
 107
 108         mprintf((0, "\n"));
 109
 110         return handle;
 111
 112 RegistryOpen_Cleanup:
 113         for (i = handle->keys-1; i >=0; i--)
 114                 if (handle->hKey[i])  {
 115                         RegCloseKey(handle->hKey[i]);
 116                         handle->hKey[i]=0;
 117                 }
 118
 119         free(handle->hKey);
 120         free(handle);
 121         free(regpath);
 122         return NULL;
 123 }
 124
 125
 126 int registry_getint(registry_handle *handle, const char *label, int *val)
 127 {
 128         long lres;
 129         DWORD type, size;
 130
 131         *val = 0;
 132         size = sizeof(int);
 133         lres = RegQueryValueEx(handle->hKey[handle->keys-1], label, NULL,
 134                                 &type, (LPBYTE)val, &size);
 135         if (lres != ERROR_SUCCESS) return 0;
 136         if (type != REG_DWORD) return 0;
 137
 138         return 1;
 139 }
 140
 141
 142 int registry_getstring(registry_handle *handle, const char *label, char *str, int bufsize)
 143 {
 144         long lres;
 145         DWORD type, size;
 146
 147         size = bufsize;
 148         lres = RegQueryValueEx(handle->hKey[handle->keys-1], label, NULL, &type,
 149                                 (LPBYTE)str, &size);
 150
 151         if (lres != ERROR_SUCCESS) return 0;
 152         if (type != REG_SZ && type != REG_EXPAND_SZ) return 0;
 153
 154         return 1;
 155 }
 156
 157
 158
 159 int registry_close(registry_handle *handle)
 160 {
 161         int i;
 162
 163         for (i = handle->keys-1; i >=0; i--)
 164                 if (handle->hKey[i])  {
 165                         RegCloseKey(handle->hKey[i]);
 166                         handle->hKey[i]=0;
 167                 }
 168
 169         free(handle->hKey);
 170         free(handle);
 171
 172         return 1;
 173 }
 174
 175
 176
 177
 178
 179 /*
 180 int registry_create(const char *name)
 181 {
 182         HANDLE hSubKey, hGroupKey, hOurKey;
 183         DWORD disp;
 184         int result;
 185
 186         result = RegOpenKeyEx(HKEY_CURRENT_USER,  REG_DIR_PARENT, 0, KEY_ALL_ACCESS,
 187                                                                 &hSubKey);
 188         if (result!=ERROR_SUCCESS) return 0;
 189         result = RegOpenKeyEx(hSubKey, REG_DIR_GROUP, 0, KEY_ALL_ACCESS, &hGroupKey);
 190         if (result!=ERROR_SUCCESS) {
 191                 result = RegCreateKeyEx(hSubKey, REG_DIR_GROUP, 0, NULL, 0, KEY_ALL_ACCESS, NULL,
 192                                                         &hGroupKey, &disp);
 193                 if (result!=ERROR_SUCCESS) {
 194                         RegCloseKey(hSubKey);
 195                         return 0;
 196                 }
 197                 result = RegCreateKeyEx(hGroupKey, name, 0, NULL, 0, KEY_ALL_ACCESS, NULL,
 198                                                         &hOurKey, &disp);
 199                 if (result !=ERROR_SUCCESS) {
 200                         RegCloseKey(hGroupKey);
 201                         RegCloseKey(hSubKey);
 202                         return 0;
 203                 }
 204         }
 205         RegCloseKey(hOurKey);
 206         RegCloseKey(hGroupKey);
 207         RegCloseKey(hSubKey);
 208         return 1;
 209 }
 210
 211
 212 int registry_delete(const char *name)
 213 {
 214         Int3();
 215         return 0;
 216 }
 217
 218
 219 int registry_open(const char *name)
 220 {
 221         HANDLE hKey;
 222         int result;
 223         char path[256];
 224
 225         Assert(hMyRegKey == NULL);
 226
 227         strcpy(path, REG_DIR_PATH);
 228         strcat(path, name);
 229
 230         result = RegOpenKeyEx(HKEY_CURRENT_USER, path, 0, 0, &hKey);
 231         if (result != ERROR_SUCCESS) return 0;
 232
 233         hMyRegKey = hKey;
 234
 235         return 1;
 236 }
 237
 238
 239 int registry_close()
 240 {
 241         Assert(hMyRegKey != NULL);
 242         RegCloseKey(hMyRegKey);
 243         hMyRegKey = NULL;
 244         return 1;
 245 }
 246
 247
 248
 249 int registry_addint(const char *valname, int val)
 250 {
 251         int result;
 252
 253         result = RegSetValueEx(hMyRegKey, valname, 0, REG_DWORD, &val, sizeof(val));
 254
 255         if (result != ERROR_SUCCESS) return 0;
 256         return 1;
 257 }
 258
 259
 260 int registry_addstring(const char *valname, const char *str)
 261 {
 262         int result;
 263
 264         result = RegSetValueEx(hMyRegKey, valname, 0, REG_SZ, str, lstrlen(str));
 265
 266         if (result != ERROR_SUCCESS) return 0;
 267         return 1;
 268 }
 269 */