new home directory
[feisty_meow.git] / nucleus / library / application / registry_config.cpp
1 /*
2 *  Name   : registry_configurator                                             *
3 *  Author : Chris Koeritz                                                     *
4 **
5 * Copyright (c) 2004-$now By Author.  This program is free software; you can  *
6 * redistribute it and/or modify it under the terms of the GNU General Public  *
7 * License as published by the Free Software Foundation; either version 2 of   *
8 * the License or (at your option) any later version.  This is online at:      *
9 *     http://www.fsf.org/copyleft/gpl.html                                    *
10 * Please send any updates to: fred@gruntose.com                               *
11 */
12
13 #include "registry_config.h"
14
15 #include <basis/astring.h>
16 #include <basis/functions.h>
17 #include <basis/utf_conversion.h>
18 #include <structures/static_memory_gremlin.h>
19 #include <structures/string_array.h>
20 #include <structures/string_table.h>
21
22 using namespace basis;
23 using namespace filesystem;
24 using namespace structures;
25
26 #ifdef _MSC_VER
27
28   // this implementation only works on windows currently.
29 //hmmm: i suppose we could fake it with an ini file.
30
31   #include <shlwapi.h>
32 #endif
33
34 #undef LOG
35 #ifdef DEBUG_REGISTRY_CONFIGURATOR
36   #define LOG(s) CLASS_EMERGENCY_LOG(program_wide_logger::get(), s)
37 #else
38   #define LOG(s) {}
39 #endif
40
41 //#define DEBUG_REGISTRY_CONFIGURATOR
42   // uncomment for noisy version.
43
44 namespace configuration {
45
46 const int MAXIMUM_ENTRY_SIZE = 256 * KILOBYTE;
47   // arbitrary maximum for entries we'll read.
48
49 const int MAXIMUM_NAME_SIZE = 16384;
50   // the longest that value names can be in the registry.
51
52 // a default we hope never to see in the registry.
53 //SAFE_STATIC_CONST(astring, registry_configurator::reg_str_fake_default,
54  //   ("bogus_never_should_see"));
55 const astring &registry_configurator::reg_str_fake_default()
56 {
57   static astring _hidden = "bogus_never_should_see";
58   return _hidden;
59 }
60
61 registry_configurator::registry_configurator(registry_hives hive,
62       treatment_of_defaults behavior)
63 : configurator(behavior),
64   _hive(hive)
65 {}
66
67 registry_configurator::~registry_configurator()
68 {}
69
70 #ifndef __WIN32__
71 // fake the platform dependent names.
72 void *HKEY_CLASSES_ROOT = NULL;
73 void *HKEY_CURRENT_USER = NULL;
74 void *HKEY_LOCAL_MACHINE = NULL;
75 void *HKEY_USERS = NULL;
76 void *HKEY_CURRENT_CONFIG = NULL;
77 #endif
78
79 void *registry_configurator::translate_hive(registry_hives hive)
80 {
81   switch (hive) {
82     case hkey_classes_root: return HKEY_CLASSES_ROOT;
83     case hkey_current_user: return HKEY_CURRENT_USER;
84     case hkey_local_machine: return HKEY_LOCAL_MACHINE;
85     case hkey_users: return HKEY_USERS;
86     case hkey_current_config: return HKEY_CURRENT_CONFIG;
87     default: return 0;
88   }
89 }
90
91 astring registry_configurator::fix_section(const astring &section)
92 {
93   astring to_return = section;
94   for (int i = 0; i < to_return.length(); i++) {
95     if (to_return[i] == '/')
96       to_return[i] = '\\';
97   }
98   return to_return;
99 }
100
101 bool registry_configurator::put(const astring &section_in, const astring &entry,
102     const astring &to_store)
103 {
104   FUNCDEF("put");
105   astring section = fix_section(section_in);
106   if (!to_store.length()) return delete_entry(section, entry);
107   else if (!section.length()) return false;
108
109 #ifdef _MSC_VER
110   HKEY key;
111   long ret = RegOpenKeyEx((HKEY)translate_hive(_hive),
112       to_unicode_temp(section), 0, KEY_WRITE, &key);
113   if (ret != ERROR_SUCCESS) {
114     LOG("failed to open the key, trying to create it.");
115     DWORD dispose;  // the disposition of the call (created or existing).
116     ret = RegCreateKeyEx((HKEY)translate_hive(_hive),
117         to_unicode_temp(section), 0, NULL_POINTER, REG_OPTION_NON_VOLATILE,
118         KEY_ALL_ACCESS, NULL_POINTER, &key, &dispose);
119     if (ret != ERROR_SUCCESS) {
120       LOG("failed to create the key!!");
121       return false;
122     }
123   }
124
125   bool to_return = true;
126   ret = RegSetValueEx(key, to_unicode_temp(entry), 0, REG_SZ,
127       (byte *)to_store.s(), to_store.length() + 1);
128   if (ret != ERROR_SUCCESS) {
129     LOG(astring("failed to write the entry!"));
130     to_return = false;
131   }
132
133   RegCloseKey(key);
134   return to_return;
135 #else
136   return false;
137 #endif
138 }
139
140 bool registry_configurator::get(const astring &section_in, const astring &entry,
141     astring &found)
142 {
143   FUNCDEF("get");
144   found = "";
145   if (!section_in) return false;
146   if (!entry) {}  // not a problem.
147   astring section = fix_section(section_in);
148 #ifdef _MSC_VER
149   HKEY key;
150   long ret = RegOpenKeyEx((HKEY)translate_hive(_hive),
151       to_unicode_temp(section), 0, KEY_QUERY_VALUE, &key);
152   if (ret != ERROR_SUCCESS) {
153     LOG("failed to open the key!");
154     return false;
155   }
156
157   DWORD type_seen;
158   byte *data_seen = new byte[MAXIMUM_ENTRY_SIZE];
159   DWORD length = MAXIMUM_ENTRY_SIZE - 1;
160   ret = RegQueryValueEx(key, to_unicode_temp(entry), 0, &type_seen, data_seen,
161       &length);
162   if (ret != ERROR_SUCCESS) {
163     LOG(astring("failed to read the entry!"));
164     return false;
165   }
166
167   if (type_seen != REG_SZ) {
168     LOG(astring("entry found was not of string type!"));
169     RegCloseKey(key);
170     return false;
171   }
172
173   data_seen[MAXIMUM_ENTRY_SIZE - 1] = '\0';
174     // force last character to be null if data happened to be too big.
175   found = astring((char *)data_seen);
176
177   delete [] data_seen;
178
179   RegCloseKey(key);
180   return true;
181 #else
182   return false;
183 #endif
184 }
185
186 bool registry_configurator::get_section(const astring &section_in,
187     string_table &info)
188 {
189   FUNCDEF("get_section");
190   info.reset();
191   if (!section_in.length()) return false;
192   astring section = fix_section(section_in);
193 #ifdef _MSC_VER
194   HKEY key;
195   long ret = RegOpenKeyEx((HKEY)translate_hive(_hive),
196       to_unicode_temp(section), 0, KEY_QUERY_VALUE, &key);
197   if (ret != ERROR_SUCCESS) {
198     LOG("failed to open the key!");
199     return false;
200   }
201
202   DWORD type_seen;
203   byte *data_seen = new byte[MAXIMUM_ENTRY_SIZE];
204   flexichar *name_seen = new flexichar[MAXIMUM_NAME_SIZE];
205   DWORD name_length;
206   for (DWORD index = 0; true; index++) {
207     DWORD length = MAXIMUM_ENTRY_SIZE - 1;
208     name_length = MAXIMUM_NAME_SIZE - 1;
209     LONG ret = RegEnumValue(key, index, name_seen, &name_length, 0,
210         &type_seen, data_seen, &length);
211     if (ret != ERROR_SUCCESS) break;  // no entry at that index.
212     if (type_seen == REG_SZ) {
213       // found an entry successfully and it's the right type.
214       astring name = from_unicode_temp(name_seen);
215       astring content = from_unicode_temp((flexichar *)data_seen);
216       info.add(name, content);
217     }
218   }
219
220   delete [] data_seen;
221   delete [] name_seen;
222
223   RegCloseKey(key);
224
225   return true;
226 #else
227   return false;
228 #endif
229 }
230
231 bool registry_configurator::section_exists(const astring &section_in)
232 {
233   FUNCDEF("section_exists");
234   if (!section_in.length()) return false;
235   astring section = fix_section(section_in);
236 #ifdef _MSC_VER
237   HKEY key;
238   long ret = RegOpenKeyEx((HKEY)translate_hive(_hive),
239       to_unicode_temp(section), 0, KEY_QUERY_VALUE, &key);
240   if (ret != ERROR_SUCCESS) {
241     LOG("failed to open the key!");
242     return false;
243   }
244   RegCloseKey(key);
245   return true;
246 #else
247   return false;
248 #endif
249 }
250
251 bool registry_configurator::delete_section(const astring &section_in)
252 {
253   FUNCDEF("delete_section");
254   if (!section_in.length()) return false;
255   astring section = fix_section(section_in);
256 //if the key doesn't exist, should that be a failure?
257 #ifdef _MSC_VER
258   long ret = SHDeleteKey((HKEY)translate_hive(_hive),
259       to_unicode_temp(section));
260   if (ret != ERROR_SUCCESS) {
261     LOG("failed to delete the key!");
262     return false;
263   }
264   return true;
265 #else
266   return false;
267 #endif
268 }
269
270 bool registry_configurator::delete_entry(const astring &section_in,
271     const astring &entry)
272 {
273   FUNCDEF("delete_entry");
274   if (!section_in.length()) return false;
275   astring section = fix_section(section_in);
276   if (!entry) {}  // no problem.
277
278 #ifdef _MSC_VER
279   HKEY key;
280   long ret = RegOpenKeyEx((HKEY)translate_hive(_hive),
281       to_unicode_temp(section), 0, KEY_SET_VALUE, &key);
282   if (ret != ERROR_SUCCESS) {
283     LOG("failed to open the key!");
284     return false;
285   }
286
287   bool to_return = true;
288   ret = RegDeleteValue(key, to_unicode_temp(entry));
289   if (ret != ERROR_SUCCESS) {
290     LOG(astring("failed to delete the entry!"));
291     to_return = false;
292   }
293
294   RegCloseKey(key);
295   return to_return;
296 #else
297   return false;
298 #endif
299 }
300
301 bool registry_configurator::put_section(const astring &section_in,
302     const string_table &info)
303 {
304   if (!section_in) return false;
305   astring section = fix_section(section_in);
306   bool failures = false;
307   for (int i = 0; i < info.symbols(); i++) {
308     bool worked = put(section, info.name(i), info[i]);
309     if (!worked) failures = true;
310   }
311   return !failures;
312 }
313
314 } // namespace
315