Rewrite clear GW in C.
[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     HKEY hkey = NULL;
179
180     if ( strcmp(string, "HKEY_CLASSES_ROOT") == 0 )
181     {
182         hkey = HKEY_CLASSES_ROOT;
183     }
184     if ( strcmp(string, "HKEY_CURRENT_USER") == 0 )
185     {
186         hkey = HKEY_CURRENT_USER;
187     }
188     if ( strcmp(string, "HKEY_LOCAL_MACHINE") == 0 )
189     {
190         hkey = HKEY_LOCAL_MACHINE;
191     }
192     if ( strcmp(string, "HKEY_USERS") == 0 )
193     {
194         hkey = HKEY_USERS;
195     }
196     if ( strcmp(string, "HKEY_DYN_DATA") == 0 )
197     {
198         hkey = HKEY_DYN_DATA;
199     }
200     if ( strcmp(string, "HKEY_CURRENT_CONFIG") == 0 )
201     {
202         hkey = HKEY_CURRENT_CONFIG;
203     }
204
205     return hkey;
206 }
207 /*--------------------------------------------------------------------------*/
208 BOOL WindowsQueryRegistryNumberOfElementsInList(char *ParamIn1, char *ParamIn2, int *Number)
209 {
210     BOOL bOK = TRUE;
211
212     HKEY hKeyToOpen;
213     HKEY hTestKey;
214     DWORD OpensKeyOptions = 0;
215
216     DWORD retCode = 0;
217
218     TCHAR    achClass[PATH_MAX] = TEXT("");  // buffer for class name
219     DWORD    cchClassName = PATH_MAX;    // size of class string
220     DWORD    cSubKeys = 0;               // number of subkeys
221     DWORD    cbMaxSubKey = 0;            // longest subkey size
222     DWORD    cchMaxClass = 0;            // longest class string
223     DWORD    cValues = 0;                // number of values for key
224     DWORD    cchMaxValue = 0;            // longest value name
225     DWORD    cbMaxValueData = 0;         // longest value data
226     DWORD    cbSecurityDescriptor = 0;  // size of security descriptor
227     FILETIME ftLastWriteTime;      // last write time
228
229     hKeyToOpen = GetHkeyrootFromString(ParamIn1);
230
231 #ifdef _WIN64 /* Scilab x64 on x64 windows */
232     OpensKeyOptions = KEY_READ  | KEY_WOW64_64KEY;
233     if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &hTestKey) != ERROR_SUCCESS )
234     {
235         OpensKeyOptions = KEY_READ  | KEY_WOW64_32KEY;
236         if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &hTestKey) != ERROR_SUCCESS )
237         {
238             return FALSE;
239         }
240     }
241 #else
242     if (IsWow64()) /* Scilab 32 bits on x64 windows */
243     {
244         OpensKeyOptions = KEY_READ  | KEY_WOW64_64KEY;
245         if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &hTestKey) != ERROR_SUCCESS )
246         {
247             OpensKeyOptions = KEY_READ  | KEY_WOW64_32KEY;
248             if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &hTestKey) != ERROR_SUCCESS )
249             {
250                 return FALSE;
251             }
252         }
253     }
254     else /* Scilab 32 bits on windows 32 bits */
255     {
256         OpensKeyOptions = KEY_READ ;
257         if ( RegOpenKeyEx(hKeyToOpen, ParamIn2, 0, OpensKeyOptions, &hTestKey) != ERROR_SUCCESS )
258         {
259             return FALSE;
260         }
261     }
262 #endif
263     retCode = RegQueryInfoKey(
264                   hTestKey,                // key handle
265                   achClass,                // buffer for class name
266                   &cchClassName,           // size of class string
267                   NULL,                    // reserved
268                   &cSubKeys,               // number of subkeys
269                   &cbMaxSubKey,            // longest subkey size
270                   &cchMaxClass,            // longest class string
271                   &cValues,                // number of values for this key
272                   &cchMaxValue,            // longest value name
273                   &cbMaxValueData,         // longest value data
274                   &cbSecurityDescriptor,   // security descriptor
275                   &ftLastWriteTime);       // last write time
276
277     if (retCode != ERROR_SUCCESS)
278     {
279         bOK = FALSE;
280     }
281     else
282     {
283         *Number = cValues;
284     }
285
286     RegCloseKey(hKeyToOpen);
287
288     return bOK;
289 }
290 /*--------------------------------------------------------------------------*/