winqueryreg can list subkey with argument "key"
[scilab.git] / scilab / modules / windows_tools / sci_gateway / c / sci_winqueryreg.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) INRIA - Allan CORNET
4  * Copyright (C) 2011 - DIGITEO - 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 #include "gw_windows_tools.h"
15 #include "registry.h"
16 #include "api_scilab.h"
17 #include "MALLOC.h"
18 #include "Scierror.h"
19 #include "localization.h"
20 #include "PATH_MAX.h"
21 #include "freeArrayOfString.h"
22 /*--------------------------------------------------------------------------*/
23 int sci_winqueryreg(char *fname, unsigned long l)
24 {
25     SciErr sciErr;
26     int *piAddressVarOne = NULL;
27     int *piAddressVarTwo = NULL;
28     int *piAddressVarThree = NULL;
29
30     char *pStrParamOne = NULL;
31     char *pStrParamTwo = NULL;
32     char *pStrParamThree = NULL;
33
34     char *pStrOutput = NULL;
35     int iOutput = 0;
36
37     Rhs = Max(0, Rhs);
38     CheckRhs(2, 3);
39     CheckLhs(0, 1);
40
41     if (Rhs == 3)
42     {
43         sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddressVarThree);
44         if (sciErr.iErr)
45         {
46             printError(&sciErr, 0);
47             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
48             return 0;
49         }
50
51         if (!isStringType(pvApiCtx, piAddressVarThree))
52         {
53             Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 3);
54             return 0;
55         }
56
57         if (!isScalar(pvApiCtx, piAddressVarThree))
58         {
59             Scierror(999, _("%s: Wrong size for input argument #%d: String expected.\n"), fname, 3);
60             return 0;
61         }
62
63         if (getAllocatedSingleString(pvApiCtx, piAddressVarThree, &pStrParamThree) != 0)
64         {
65             Scierror(999, _("%s: Memory allocation error.\n"), fname);
66             return 0;
67         }
68     }
69
70     sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddressVarOne);
71     if (sciErr.iErr)
72     {
73         printError(&sciErr, 0);
74         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
75         return 0;
76     }
77
78     if (!isStringType(pvApiCtx, piAddressVarOne))
79     {
80         Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 1);
81         return 0;
82     }
83
84     if (!isScalar(pvApiCtx, piAddressVarOne))
85     {
86         Scierror(999, _("%s: Wrong size for input argument #%d: String expected.\n"), fname, 1);
87         return 0;
88     }
89
90     sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddressVarTwo);
91     if (sciErr.iErr)
92     {
93         printError(&sciErr, 0);
94         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
95         return 0;
96     }
97
98     if (!isStringType(pvApiCtx, piAddressVarTwo))
99     {
100         Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, 2);
101         return 0;
102     }
103
104     if (!isScalar(pvApiCtx, piAddressVarTwo))
105     {
106         Scierror(999, _("%s: Wrong size for input argument #%d: String expected.\n"), fname, 2);
107         return 0;
108     }
109
110     if (getAllocatedSingleString(pvApiCtx, piAddressVarTwo, &pStrParamTwo) != 0)
111     {
112         if (pStrParamThree)
113         {
114             freeAllocatedSingleString(pStrParamThree);
115             pStrParamThree = NULL;
116         }
117         Scierror(999, _("%s: Memory allocation error.\n"), fname);
118         return 0;
119     }
120
121     if (getAllocatedSingleString(pvApiCtx, piAddressVarOne, &pStrParamOne) != 0)
122     {
123         if (pStrParamThree)
124         {
125             freeAllocatedSingleString(pStrParamThree);
126             pStrParamThree = NULL;
127         }
128
129         if (pStrParamTwo)
130         {
131             freeAllocatedSingleString(pStrParamTwo);
132             pStrParamTwo = NULL;
133         }
134
135         Scierror(999, _("%s: Memory allocation error.\n"), fname);
136         return 0;
137     }
138
139     if (Rhs == 3)
140     {
141         BOOL bKey = strcmp(pStrParamOne, "key") == 0;
142         BOOL bValue = strcmp(pStrParamOne, "name") == 0;
143
144         if (bValue || bKey)
145         {
146             int NumbersElm = 0;
147             if (bValue)
148             {
149                 WindowsQueryRegistryNumberOfValuesInList(pStrParamTwo, pStrParamThree, &NumbersElm);
150             }
151             else
152             {
153                 WindowsQueryRegistryNumberOfKeysInList(pStrParamTwo, pStrParamThree, &NumbersElm);
154             }
155
156             if (NumbersElm)
157             {
158                 BOOL bResult = FALSE;
159 #define MAX_ELMT_REGLIST 255
160                 char **ListKeysName = NULL;
161                 int i = 0;
162
163                 if (NumbersElm > MAX_ELMT_REGLIST)
164                 {
165                     NumbersElm = MAX_ELMT_REGLIST;
166                 }
167                 ListKeysName = (char **)MALLOC(sizeof(char*) * NumbersElm);
168                 for (i = 0; i < NumbersElm; i++)
169                 {
170                     ListKeysName[i] = NULL;
171                 }
172
173                 if (bValue)
174                 {
175                     bResult = WindowsQueryRegistryValuesList(pStrParamTwo, pStrParamThree, NumbersElm, ListKeysName);
176                 }
177                 else
178                 {
179                     bResult = WindowsQueryRegistryKeysList(pStrParamTwo, pStrParamThree, NumbersElm, ListKeysName);
180                 }
181
182                 if (bResult)
183                 {
184                     int nOne = 1;
185                     sciErr = createMatrixOfString(pvApiCtx, Rhs + 1, NumbersElm, nOne, ListKeysName);
186                     if (sciErr.iErr)
187                     {
188                         printError(&sciErr, 0);
189                         Scierror(999, _("%s: Memory allocation error.\n"), fname);
190                     }
191                     else
192                     {
193                         LhsVar(1) = Rhs + 1;
194                         PutLhsVar();
195                     }
196                 }
197                 else
198                 {
199                     Scierror(999, _("%s: Cannot open Windows registry.\n"), fname);
200                 }
201                 freeArrayOfString(ListKeysName, NumbersElm);
202             }
203             else
204             {
205                 createEmptyMatrix(pvApiCtx, Rhs + 1);
206                 LhsVar(1) = Rhs + 1;
207                 PutLhsVar();
208             }
209
210             if (pStrParamThree)
211             {
212                 freeAllocatedSingleString(pStrParamThree);
213                 pStrParamThree = NULL;
214             }
215
216             if (pStrParamTwo)
217             {
218                 freeAllocatedSingleString(pStrParamTwo);
219                 pStrParamTwo = NULL;
220             }
221
222             if (pStrParamOne)
223             {
224                 freeAllocatedSingleString(pStrParamOne);
225                 pStrParamOne = NULL;
226             }
227             return 0;
228         }
229     }
230
231     pStrOutput = (char*)MALLOC(PATH_MAX * sizeof(char));
232     if (pStrOutput)
233     {
234         BOOL OuputIsREG_SZ = FALSE;
235         BOOL TestWinQuery = WindowsQueryRegistry(pStrParamOne, pStrParamTwo, pStrParamThree, pStrOutput, &iOutput, &OuputIsREG_SZ);
236         if ( TestWinQuery )
237         {
238             if (OuputIsREG_SZ)
239             {
240                 createSingleString(pvApiCtx, Rhs + 1, pStrOutput);
241             }
242             else
243             {
244                 createScalarDouble(pvApiCtx, Rhs + 1, (double)iOutput);
245             }
246
247             LhsVar(1) = Rhs + 1;
248             PutLhsVar();
249         }
250         else
251         {
252             Scierror(999, _("%s: Cannot query value of this type.\n"), fname);
253         }
254
255         FREE( pStrOutput);
256         pStrOutput = NULL;
257     }
258     else
259     {
260         Scierror(999, _("%s: Memory allocation error.\n"), fname);
261     }
262
263     if (pStrParamThree)
264     {
265         freeAllocatedSingleString(pStrParamThree);
266         pStrParamThree = NULL;
267     }
268
269     if (pStrParamTwo)
270     {
271         freeAllocatedSingleString(pStrParamTwo);
272         pStrParamTwo = NULL;
273     }
274
275     if (pStrParamOne)
276     {
277         freeAllocatedSingleString(pStrParamOne);
278         pStrParamOne = NULL;
279     }
280
281     return 0;
282
283 }
284 /*--------------------------------------------------------------------------*/