winqueryreg supports standard shortcuts names for windows registry roots ( HKLM,...
[scilab.git] / scilab / modules / windows_tools / src / c / registry.c
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) INRIA - Allan CORNET
4 * Copyright (C) DIGITEO - 2011 - Allan CORNET
5 *
6 * This file must be used under the terms of the CeCILL.
7 * This source file is licensed as described in the file COPYING, which
8 * you should have received as part of this distribution.  The terms
9 * are also available at
10 * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11 *
12 */
13
14 /*--------------------------------------------------------------------------*/
15 #include "registry.h"
16 #include "PATH_MAX.h"
17 #include "MALLOC.h"
18 #include "GetWindowsVersion.h"
19 #include "strdup_windows.h"
20 /*--------------------------------------------------------------------------*/
21 #define MAX_KEY_LENGTH 255
22 #define MAX_VALUE_NAME 16383
23 /*--------------------------------------------------------------------------*/
24 BOOL WindowsQueryRegistry(char *ParamIn1, char *ParamIn2, char *ParamIn3, char *ParamOut1, int *ParamOut2, BOOL *OuputIsREG_SZ)
25 {
26     BOOL bOK = TRUE;
27     HKEY key;
28     HKEY hKeyToOpen = NULL;
29     DWORD OpensKeyOptions = 0;
30     DWORD type = 0;
31
32     hKeyToOpen = GetHkeyrootFromString(ParamIn1);
33
34 #ifdef _WIN64 /* Scilab x64 on x64 windows */
35     OpensKeyOptions = KEY_QUERY_VALUE | KEY_WOW64_64KEY;
36     if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &key) != ERROR_SUCCESS)
37     {
38         OpensKeyOptions = KEY_QUERY_VALUE | KEY_WOW64_32KEY;
39         if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &key) != ERROR_SUCCESS)
40         {
41             return FALSE;
42         }
43     }
44 #else
45     if (IsWow64()) /* Scilab 32 bits on x64 windows */
46     {
47         OpensKeyOptions = KEY_QUERY_VALUE | KEY_WOW64_64KEY;
48         if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &key) != ERROR_SUCCESS)
49         {
50             OpensKeyOptions = KEY_QUERY_VALUE | KEY_WOW64_32KEY;
51             if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &key) != ERROR_SUCCESS)
52             {
53                 return FALSE;
54             }
55         }
56     }
57     else /* Scilab 32 bits on windows 32 bits */
58     {
59         OpensKeyOptions = KEY_QUERY_VALUE;
60         if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &key) != ERROR_SUCCESS)
61         {
62             return FALSE;
63         }
64     }
65 #endif
66
67     if ( RegQueryValueEx(key, ParamIn3, NULL, &type, NULL, NULL) == ERROR_SUCCESS )
68     {
69         if ( (type == REG_EXPAND_SZ) || (type == REG_SZ) )
70         {
71             DWORD Length = PATH_MAX;
72             char Line[PATH_MAX];
73             if (RegQueryValueEx(key, ParamIn3, NULL, &type, (LPBYTE)&Line, &Length) == ERROR_SUCCESS )
74             {
75                 wsprintf(ParamOut1, "%s", Line);
76                 *OuputIsREG_SZ = TRUE;
77             }
78         }
79         else
80         {
81             DWORD size = 4;
82             int Num = 0;
83             if (RegQueryValueEx(key, ParamIn3, NULL, &type, (LPBYTE)&Num, &size) == ERROR_SUCCESS )
84             {
85                 *ParamOut2 = Num;
86                 *OuputIsREG_SZ = FALSE;
87             }
88         }
89     }
90     else
91     {
92         bOK = FALSE;
93     }
94
95     RegCloseKey(key);
96
97     return bOK;
98 }
99 /*--------------------------------------------------------------------------*/
100 BOOL WindowsQueryRegistryList(char *ParamIn1, char *ParamIn2, int dimMax, char **ListKeys)
101 {
102     BOOL bOK = TRUE;
103     HKEY key;
104     HKEY hKeyToOpen = NULL;
105     DWORD OpensKeyOptions = 0;
106     int i = 0;
107
108     hKeyToOpen = GetHkeyrootFromString(ParamIn1);
109
110 #ifdef _WIN64 /* Scilab x64 on x64 windows */
111     OpensKeyOptions = KEY_READ  | KEY_WOW64_64KEY;
112     if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &key) != ERROR_SUCCESS )
113     {
114         OpensKeyOptions = KEY_READ  | KEY_WOW64_32KEY;
115         if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &key) != ERROR_SUCCESS )
116         {
117             return FALSE;
118         }
119     }
120 #else
121     if (IsWow64())  /* Scilab 32 bits on x64 windows */
122     {
123         OpensKeyOptions = KEY_READ  | KEY_WOW64_64KEY;
124         if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &key) != ERROR_SUCCESS )
125         {
126             OpensKeyOptions = KEY_READ  | KEY_WOW64_32KEY;
127             if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &key) != ERROR_SUCCESS )
128             {
129                 return FALSE;
130             }
131         }
132     }
133     else /* Scilab 32 bits on windows 32 bits */
134     {
135         OpensKeyOptions = KEY_READ ;
136         if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &key) != ERROR_SUCCESS )
137         {
138             return FALSE;
139         }
140     }
141
142 #endif
143
144     for (i = 0; i < dimMax; i++)
145     {
146         TCHAR achKey[MAX_KEY_LENGTH];
147         DWORD cbName = MAX_KEY_LENGTH;
148         DWORD Type = 0;
149         DWORD retCode = 0;
150
151         retCode = RegEnumValue(key, i,
152                                achKey,
153                                &cbName,
154                                NULL,
155                                &Type,
156                                NULL,
157                                NULL);
158
159         if (retCode != ERROR_SUCCESS)
160         {
161             bOK = FALSE;
162             RegCloseKey(key);
163             return bOK;
164         }
165         else
166         {
167             ListKeys[i] = strdup(achKey);
168         }
169     }
170
171     RegCloseKey(key);
172
173     return bOK;
174 }
175 /*--------------------------------------------------------------------------*/
176 HKEY GetHkeyrootFromString(char *string)
177 {
178     if ( strcmp(string, "HKEY_CLASSES_ROOT") == 0 || strcmp(string, "HKCR") == 0)
179     {
180         return HKEY_CLASSES_ROOT;
181     }
182
183     if ( strcmp(string, "HKEY_CURRENT_USER") == 0 || strcmp(string, "HKCU") == 0 )
184     {
185         return HKEY_CURRENT_USER;
186     }
187
188     if ( strcmp(string, "HKEY_LOCAL_MACHINE") == 0 || strcmp(string, "HKLM") == 0 )
189     {
190         return HKEY_LOCAL_MACHINE;
191     }
192
193     if ( strcmp(string, "HKEY_USERS") == 0 || strcmp(string, "HKU") == 0 )
194     {
195         return HKEY_USERS;
196     }
197
198     if ( strcmp(string, "HKEY_DYN_DATA") == 0 || strcmp(string, "HKDD") == 0 )
199     {
200         return HKEY_DYN_DATA;
201     }
202
203     if ( strcmp(string, "HKEY_CURRENT_CONFIG") == 0 || strcmp(string, "HKCC") == 0 )
204     {
205         return HKEY_CURRENT_CONFIG;
206     }
207
208     return NULL;
209 }
210 /*--------------------------------------------------------------------------*/
211 BOOL WindowsQueryRegistryNumberOfElementsInList(char *ParamIn1, char *ParamIn2, int *Number)
212 {
213     BOOL bOK = TRUE;
214
215     HKEY hKeyToOpen;
216     HKEY hTestKey;
217     DWORD OpensKeyOptions = 0;
218
219     DWORD retCode = 0;
220
221     TCHAR    achClass[PATH_MAX] = TEXT("");  // buffer for class name
222     DWORD    cchClassName = PATH_MAX;    // size of class string
223     DWORD    cSubKeys = 0;               // number of subkeys
224     DWORD    cbMaxSubKey = 0;            // longest subkey size
225     DWORD    cchMaxClass = 0;            // longest class string
226     DWORD    cValues = 0;                // number of values for key
227     DWORD    cchMaxValue = 0;            // longest value name
228     DWORD    cbMaxValueData = 0;         // longest value data
229     DWORD    cbSecurityDescriptor = 0;  // size of security descriptor
230     FILETIME ftLastWriteTime;      // last write time
231
232     hKeyToOpen = GetHkeyrootFromString(ParamIn1);
233
234 #ifdef _WIN64 /* Scilab x64 on x64 windows */
235     OpensKeyOptions = KEY_READ  | KEY_WOW64_64KEY;
236     if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &hTestKey) != ERROR_SUCCESS )
237     {
238         OpensKeyOptions = KEY_READ  | KEY_WOW64_32KEY;
239         if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &hTestKey) != ERROR_SUCCESS )
240         {
241             return FALSE;
242         }
243     }
244 #else
245     if (IsWow64()) /* Scilab 32 bits on x64 windows */
246     {
247         OpensKeyOptions = KEY_READ  | KEY_WOW64_64KEY;
248         if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &hTestKey) != ERROR_SUCCESS )
249         {
250             OpensKeyOptions = KEY_READ  | KEY_WOW64_32KEY;
251             if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &hTestKey) != ERROR_SUCCESS )
252             {
253                 return FALSE;
254             }
255         }
256     }
257     else /* Scilab 32 bits on windows 32 bits */
258     {
259         OpensKeyOptions = KEY_READ ;
260         if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &hTestKey) != ERROR_SUCCESS )
261         {
262             return FALSE;
263         }
264     }
265 #endif
266     retCode = RegQueryInfoKey(
267                   hTestKey,                // key handle
268                   achClass,                // buffer for class name
269                   &cchClassName,           // size of class string
270                   NULL,                    // reserved
271                   &cSubKeys,               // number of subkeys
272                   &cbMaxSubKey,            // longest subkey size
273                   &cchMaxClass,            // longest class string
274                   &cValues,                // number of values for this key
275                   &cchMaxValue,            // longest value name
276                   &cbMaxValueData,         // longest value data
277                   &cbSecurityDescriptor,   // security descriptor
278                   &ftLastWriteTime);       // last write time
279
280     if (retCode != ERROR_SUCCESS)
281     {
282         bOK = FALSE;
283     }
284     else
285     {
286         *Number = cValues;
287     }
288
289     RegCloseKey(hKeyToOpen);
290
291     return bOK;
292 }
293 /*--------------------------------------------------------------------------*/