Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*
3 : : * This file is part of the LibreOffice project.
4 : : *
5 : : * This Source Code Form is subject to the terms of the Mozilla Public
6 : : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : : *
9 : : * This file incorporates work covered by the following license notice:
10 : : *
11 : : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : : * contributor license agreements. See the NOTICE file distributed
13 : : * with this work for additional information regarding copyright
14 : : * ownership. The ASF licenses this file to you under the Apache
15 : : * License, Version 2.0 (the "License"); you may not use this file
16 : : * except in compliance with the License. You may obtain a copy of
17 : : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : : */
19 : :
20 : :
21 : : #include "regkey.hxx"
22 : :
23 : : #include <registry/registry.hxx>
24 : : #include <rtl/alloc.h>
25 : : #include "regimpl.hxx"
26 : : #include "keyimpl.hxx"
27 : :
28 : : using rtl::OUString;
29 : :
30 : : //*********************************************************************
31 : : // acquireKey
32 : : //
33 : 846708 : void REGISTRY_CALLTYPE acquireKey(RegKeyHandle hKey)
34 : : {
35 : 846708 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
36 [ + - ]: 846708 : if (pKey != 0)
37 : : {
38 : 846708 : ORegistry* pReg = pKey->getRegistry();
39 : 846708 : (void) pReg->acquireKey(pKey);
40 : : }
41 : 846708 : }
42 : :
43 : :
44 : : //*********************************************************************
45 : : // releaseKey
46 : : //
47 : 1966831 : void REGISTRY_CALLTYPE releaseKey(RegKeyHandle hKey)
48 : : {
49 : 1966831 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
50 [ + - ]: 1966831 : if (pKey != 0)
51 : : {
52 : 1966831 : ORegistry* pReg = pKey->getRegistry();
53 : 1966831 : (void) pReg->releaseKey(pKey);
54 : : }
55 : 1966831 : }
56 : :
57 : :
58 : : //*********************************************************************
59 : : // isKeyReadOnly
60 : : //
61 : 64 : sal_Bool REGISTRY_CALLTYPE isKeyReadOnly(RegKeyHandle hKey)
62 : : {
63 : 64 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
64 [ + - ]: 64 : return (pKey != 0) ? pKey->isReadOnly() : sal_False;
65 : : }
66 : :
67 : :
68 : : //*********************************************************************
69 : : // getKeyName
70 : : //
71 : 214240 : RegError REGISTRY_CALLTYPE getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName)
72 : : {
73 : 214240 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
74 [ + - ]: 214240 : if (pKey)
75 : : {
76 : 214240 : rtl_uString_assign( pKeyName, pKey->getName().pData );
77 : 214240 : return REG_NO_ERROR;
78 : : } else
79 : : {
80 : 0 : rtl_uString_new(pKeyName);
81 : 214240 : return REG_INVALID_KEY;
82 : : }
83 : : }
84 : :
85 : :
86 : : //*********************************************************************
87 : : // createKey
88 : : //
89 : 32280 : RegError REGISTRY_CALLTYPE createKey(RegKeyHandle hKey,
90 : : rtl_uString* keyName,
91 : : RegKeyHandle* phNewKey)
92 : : {
93 : 32280 : *phNewKey = 0;
94 : :
95 : 32280 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
96 [ - + ]: 32280 : if (!pKey)
97 : 0 : return REG_INVALID_KEY;
98 : :
99 [ - + ]: 32280 : if (pKey->isDeleted())
100 : 0 : return REG_INVALID_KEY;
101 : :
102 [ - + ]: 32280 : if (pKey->isReadOnly())
103 : 0 : return REG_REGISTRY_READONLY;
104 : :
105 [ + - ]: 32280 : return pKey->createKey(keyName, phNewKey);
106 : : }
107 : :
108 : : //*********************************************************************
109 : : // openKey
110 : : //
111 : 888352 : RegError REGISTRY_CALLTYPE openKey(RegKeyHandle hKey,
112 : : rtl_uString* keyName,
113 : : RegKeyHandle* phOpenKey)
114 : : {
115 : 888352 : *phOpenKey = 0;
116 : :
117 : 888352 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
118 [ - + ]: 888352 : if (!pKey)
119 : 0 : return REG_INVALID_KEY;
120 : :
121 [ - + ]: 888352 : if (pKey->isDeleted())
122 : 0 : return REG_INVALID_KEY;
123 : :
124 [ + - ]: 888352 : return pKey->openKey(keyName, phOpenKey);
125 : : }
126 : :
127 : : //*********************************************************************
128 : : // openSubKeys
129 : : //
130 : 30200 : RegError REGISTRY_CALLTYPE openSubKeys(RegKeyHandle hKey,
131 : : rtl_uString* keyName,
132 : : RegKeyHandle** pphSubKeys,
133 : : sal_uInt32* pnSubKeys)
134 : : {
135 : 30200 : *pphSubKeys = NULL;
136 : 30200 : *pnSubKeys = 0;
137 : :
138 : 30200 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
139 [ - + ]: 30200 : if (!pKey)
140 : 0 : return REG_INVALID_KEY;
141 : :
142 [ - + ]: 30200 : if (pKey->isDeleted())
143 : 0 : return REG_INVALID_KEY;
144 : :
145 [ + - ]: 30200 : return pKey->openSubKeys(keyName, pphSubKeys, pnSubKeys);
146 : : }
147 : :
148 : : //*********************************************************************
149 : : // closeSubKeys
150 : : //
151 : 1418 : RegError REGISTRY_CALLTYPE closeSubKeys(RegKeyHandle* phSubKeys,
152 : : sal_uInt32 nSubKeys)
153 : : {
154 [ + - ][ + + ]: 1418 : if (phSubKeys == 0 || nSubKeys == 0)
155 : 2 : return REG_INVALID_KEY;
156 : :
157 : 1416 : ORegistry* pReg = ((ORegKey*)(phSubKeys[0]))->getRegistry();
158 [ + + ]: 31716 : for (sal_uInt32 i = 0; i < nSubKeys; i++)
159 : : {
160 : 30300 : (void) pReg->closeKey(phSubKeys[i]);
161 : : }
162 : 1416 : rtl_freeMemory(phSubKeys);
163 : :
164 : 1418 : return REG_NO_ERROR;
165 : : }
166 : :
167 : : //*********************************************************************
168 : : // deleteKey
169 : : //
170 : 4 : RegError REGISTRY_CALLTYPE deleteKey(RegKeyHandle hKey,
171 : : rtl_uString* keyName)
172 : : {
173 : 4 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
174 [ - + ]: 4 : if (!pKey)
175 : 0 : return REG_INVALID_KEY;
176 : :
177 [ - + ]: 4 : if (pKey->isDeleted())
178 : 0 : return REG_INVALID_KEY;
179 : :
180 [ - + ]: 4 : if (pKey->isReadOnly())
181 : 0 : return REG_REGISTRY_READONLY;
182 : :
183 [ + - ]: 4 : return pKey->deleteKey(keyName);
184 : : }
185 : :
186 : : //*********************************************************************
187 : : // closeKey
188 : : //
189 : 94925 : RegError REGISTRY_CALLTYPE closeKey(RegKeyHandle hKey)
190 : : {
191 : 94925 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
192 [ - + ]: 94925 : if (!pKey)
193 : 0 : return REG_INVALID_KEY;
194 : :
195 : 94925 : return pKey->closeKey(hKey);
196 : : }
197 : :
198 : : //*********************************************************************
199 : : // setValue
200 : : //
201 : 31016 : RegError REGISTRY_CALLTYPE setValue(RegKeyHandle hKey,
202 : : rtl_uString* keyName,
203 : : RegValueType valueType,
204 : : RegValue pData,
205 : : sal_uInt32 valueSize)
206 : : {
207 : 31016 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
208 [ - + ]: 31016 : if (!pKey)
209 : 0 : return REG_INVALID_KEY;
210 : :
211 [ - + ]: 31016 : if (pKey->isDeleted())
212 : 0 : return REG_INVALID_KEY;
213 : :
214 [ - + ]: 31016 : if (pKey->isReadOnly())
215 : 0 : return REG_REGISTRY_READONLY;
216 : :
217 [ + - ]: 31016 : OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
218 [ - + ]: 31016 : if (keyName->length)
219 : : {
220 : 0 : ORegKey* pSubKey = 0;
221 [ # # ]: 0 : RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
222 [ # # ]: 0 : if (_ret1 != REG_NO_ERROR)
223 : 0 : return _ret1;
224 : :
225 [ # # ]: 0 : _ret1 = pSubKey->setValue(valueName, valueType, pData, valueSize);
226 [ # # ]: 0 : if (_ret1 != REG_NO_ERROR)
227 : : {
228 [ # # ]: 0 : RegError _ret2 = pKey->closeKey(pSubKey);
229 [ # # ]: 0 : if (_ret2)
230 : 0 : return _ret2;
231 : : else
232 : 0 : return _ret1;
233 : : }
234 : :
235 [ # # ]: 0 : return pKey->closeKey(pSubKey);
236 : : }
237 : :
238 [ + - ]: 31016 : return pKey->setValue(valueName, valueType, pData, valueSize);
239 : : }
240 : :
241 : : //*********************************************************************
242 : : // setLongValueList
243 : : //
244 : 0 : RegError REGISTRY_CALLTYPE setLongListValue(RegKeyHandle hKey,
245 : : rtl_uString* keyName,
246 : : sal_Int32* pValueList,
247 : : sal_uInt32 len)
248 : : {
249 : 0 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
250 [ # # ]: 0 : if (!pKey)
251 : 0 : return REG_INVALID_KEY;
252 : :
253 [ # # ]: 0 : if (pKey->isDeleted())
254 : 0 : return REG_INVALID_KEY;
255 : :
256 [ # # ]: 0 : if (pKey->isReadOnly())
257 : 0 : return REG_REGISTRY_READONLY;
258 : :
259 [ # # ]: 0 : OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
260 [ # # ]: 0 : if (keyName->length)
261 : : {
262 : 0 : ORegKey* pSubKey = 0;
263 [ # # ]: 0 : RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
264 [ # # ]: 0 : if (_ret1 != REG_NO_ERROR)
265 : 0 : return _ret1;
266 : :
267 [ # # ]: 0 : _ret1 = pSubKey->setLongListValue(valueName, pValueList, len);
268 [ # # ]: 0 : if (_ret1 != REG_NO_ERROR)
269 : : {
270 [ # # ]: 0 : RegError _ret2 = pKey->closeKey(pSubKey);
271 [ # # ]: 0 : if (_ret2 != REG_NO_ERROR)
272 : 0 : return _ret2;
273 : : else
274 : 0 : return _ret1;
275 : : }
276 : :
277 [ # # ]: 0 : return pKey->closeKey(pSubKey);
278 : : }
279 : :
280 [ # # ]: 0 : return pKey->setLongListValue(valueName, pValueList, len);
281 : : }
282 : :
283 : : //*********************************************************************
284 : : // setStringValueList
285 : : //
286 : 126 : RegError REGISTRY_CALLTYPE setStringListValue(RegKeyHandle hKey,
287 : : rtl_uString* keyName,
288 : : sal_Char** pValueList,
289 : : sal_uInt32 len)
290 : : {
291 : 126 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
292 [ - + ]: 126 : if (!pKey)
293 : 0 : return REG_INVALID_KEY;
294 : :
295 [ - + ]: 126 : if (pKey->isDeleted())
296 : 0 : return REG_INVALID_KEY;
297 : :
298 [ - + ]: 126 : if (pKey->isReadOnly())
299 : 0 : return REG_REGISTRY_READONLY;
300 : :
301 [ + - ]: 126 : OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
302 [ - + ]: 126 : if (keyName->length)
303 : : {
304 : 0 : ORegKey* pSubKey = 0;
305 [ # # ]: 0 : RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
306 [ # # ]: 0 : if (_ret1 != REG_NO_ERROR)
307 : 0 : return _ret1;
308 : :
309 [ # # ]: 0 : _ret1 = pSubKey->setStringListValue(valueName, pValueList, len);
310 [ # # ]: 0 : if (_ret1 != REG_NO_ERROR)
311 : : {
312 [ # # ]: 0 : RegError _ret2 = pKey->closeKey(pSubKey);
313 [ # # ]: 0 : if (_ret2 != REG_NO_ERROR)
314 : 0 : return _ret2;
315 : : else
316 : 0 : return _ret1;
317 : : }
318 : :
319 [ # # ]: 0 : return pKey->closeKey(pSubKey);
320 : : }
321 : :
322 [ + - ]: 126 : return pKey->setStringListValue(valueName, pValueList, len);
323 : : }
324 : :
325 : : //*********************************************************************
326 : : // setUnicodeValueList
327 : : //
328 : 0 : RegError REGISTRY_CALLTYPE setUnicodeListValue(RegKeyHandle hKey,
329 : : rtl_uString* keyName,
330 : : sal_Unicode** pValueList,
331 : : sal_uInt32 len)
332 : : {
333 : 0 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
334 [ # # ]: 0 : if (!pKey)
335 : 0 : return REG_INVALID_KEY;
336 : :
337 [ # # ]: 0 : if (pKey->isDeleted())
338 : 0 : return REG_INVALID_KEY;
339 : :
340 [ # # ]: 0 : if (pKey->isReadOnly())
341 : 0 : return REG_REGISTRY_READONLY;
342 : :
343 [ # # ]: 0 : OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
344 [ # # ]: 0 : if (keyName->length)
345 : : {
346 : 0 : ORegKey* pSubKey = 0;
347 [ # # ]: 0 : RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
348 [ # # ]: 0 : if (_ret1 != REG_NO_ERROR)
349 : 0 : return _ret1;
350 : :
351 [ # # ]: 0 : _ret1 = pSubKey->setUnicodeListValue(valueName, pValueList, len);
352 [ # # ]: 0 : if (_ret1 != REG_NO_ERROR)
353 : : {
354 [ # # ]: 0 : RegError _ret2 = pKey->closeKey(pSubKey);
355 [ # # ]: 0 : if (_ret2 != REG_NO_ERROR)
356 : 0 : return _ret2;
357 : : else
358 : 0 : return _ret1;
359 : : }
360 : :
361 [ # # ]: 0 : return pKey->closeKey(pSubKey);
362 : : }
363 : :
364 [ # # ]: 0 : return pKey->setUnicodeListValue(valueName, pValueList, len);
365 : : }
366 : :
367 : : //*********************************************************************
368 : : // getValueInfo
369 : : //
370 : 257151 : RegError REGISTRY_CALLTYPE getValueInfo(RegKeyHandle hKey,
371 : : rtl_uString* keyName,
372 : : RegValueType* pValueType,
373 : : sal_uInt32* pValueSize)
374 : : {
375 : 257151 : *pValueType = RG_VALUETYPE_NOT_DEFINED;
376 : 257151 : *pValueSize = 0;
377 : :
378 : 257151 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
379 [ - + ]: 257151 : if (!pKey)
380 : 0 : return REG_INVALID_KEY;
381 : :
382 [ - + ]: 257151 : if (pKey->isDeleted())
383 : 0 : return REG_INVALID_KEY;
384 : :
385 : : RegValueType valueType;
386 : : sal_uInt32 valueSize;
387 : :
388 [ + - ]: 257151 : OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
389 [ - + ]: 257151 : if (keyName->length)
390 : : {
391 : 0 : ORegKey* pSubKey = 0;
392 [ # # ]: 0 : RegError _ret = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
393 [ # # ]: 0 : if (_ret != REG_NO_ERROR)
394 : 0 : return _ret;
395 : :
396 [ # # ][ # # ]: 0 : if (pSubKey->getValueInfo(valueName, &valueType, &valueSize) != REG_NO_ERROR)
397 : : {
398 [ # # ]: 0 : (void) pKey->releaseKey(pSubKey);
399 : 0 : return REG_INVALID_VALUE;
400 : : }
401 : :
402 : 0 : *pValueType = valueType;
403 : 0 : *pValueSize = valueSize;
404 : :
405 [ # # ]: 0 : return pKey->releaseKey(pSubKey);
406 : : }
407 : :
408 : :
409 [ + - ][ + + ]: 257151 : if (pKey->getValueInfo(valueName, &valueType, &valueSize) != REG_NO_ERROR)
410 : : {
411 : 892 : return REG_INVALID_VALUE;
412 : : }
413 : :
414 : 256259 : *pValueType = valueType;
415 : 256259 : *pValueSize = valueSize;
416 : :
417 : 257151 : return REG_NO_ERROR;
418 : : }
419 : :
420 : : //*********************************************************************
421 : : // getValueInfo
422 : : //
423 : 186564 : RegError REGISTRY_CALLTYPE getValue(RegKeyHandle hKey,
424 : : rtl_uString* keyName,
425 : : RegValue pValue)
426 : : {
427 : 186564 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
428 [ - + ]: 186564 : if (!pKey)
429 : 0 : return REG_INVALID_KEY;
430 : :
431 [ - + ]: 186564 : if (pKey->isDeleted())
432 : 0 : return REG_INVALID_KEY;
433 : :
434 [ + - ]: 186564 : OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
435 [ - + ]: 186564 : if (keyName->length)
436 : : {
437 : 0 : ORegKey* pSubKey = 0;
438 [ # # ]: 0 : RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
439 [ # # ]: 0 : if (_ret1 != REG_NO_ERROR)
440 : 0 : return _ret1;
441 : :
442 [ # # ]: 0 : _ret1 = pSubKey->getValue(valueName, pValue);
443 [ # # ]: 0 : if (_ret1 != REG_NO_ERROR)
444 : : {
445 [ # # ]: 0 : (void) pKey->releaseKey(pSubKey);
446 : 0 : return _ret1;
447 : : }
448 : :
449 [ # # ]: 0 : return pKey->releaseKey(pSubKey);
450 : : }
451 : :
452 [ + - ]: 186564 : return pKey->getValue(valueName, pValue);
453 : : }
454 : :
455 : : //*********************************************************************
456 : : // getLongValueList
457 : : //
458 : 0 : RegError REGISTRY_CALLTYPE getLongListValue(RegKeyHandle hKey,
459 : : rtl_uString* keyName,
460 : : sal_Int32** pValueList,
461 : : sal_uInt32* pLen)
462 : : {
463 : : OSL_PRECOND((pValueList != 0) && (pLen != 0), "registry::getLongListValue(): invalid parameter");
464 : 0 : *pValueList = 0, *pLen = 0;
465 : :
466 : 0 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
467 [ # # ]: 0 : if (!pKey)
468 : 0 : return REG_INVALID_KEY;
469 : :
470 [ # # ]: 0 : if (pKey->isDeleted())
471 : 0 : return REG_INVALID_KEY;
472 : :
473 [ # # ]: 0 : OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
474 [ # # ]: 0 : if (keyName->length)
475 : : {
476 : 0 : ORegKey* pSubKey = 0;
477 [ # # ]: 0 : RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
478 [ # # ]: 0 : if (_ret1 != REG_NO_ERROR)
479 : 0 : return _ret1;
480 : :
481 [ # # ]: 0 : _ret1 = pSubKey->getLongListValue(valueName, pValueList, pLen);
482 [ # # ]: 0 : if (_ret1 != REG_NO_ERROR)
483 : : {
484 [ # # ]: 0 : (void) pKey->releaseKey(pSubKey);
485 : 0 : return _ret1;
486 : : }
487 : :
488 [ # # ]: 0 : return pKey->releaseKey(pSubKey);
489 : : }
490 : :
491 [ # # ]: 0 : return pKey->getLongListValue(valueName, pValueList, pLen);
492 : : }
493 : :
494 : : //*********************************************************************
495 : : // getStringValueList
496 : : //
497 : 0 : RegError REGISTRY_CALLTYPE getStringListValue(RegKeyHandle hKey,
498 : : rtl_uString* keyName,
499 : : sal_Char*** pValueList,
500 : : sal_uInt32* pLen)
501 : : {
502 : : OSL_PRECOND((pValueList != 0) && (pLen != 0), "registry::getStringListValue(): invalid parameter");
503 : 0 : *pValueList = 0, *pLen = 0;
504 : :
505 : 0 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
506 [ # # ]: 0 : if (!pKey)
507 : 0 : return REG_INVALID_KEY;
508 : :
509 [ # # ]: 0 : if (pKey->isDeleted())
510 : 0 : return REG_INVALID_KEY;
511 : :
512 [ # # ]: 0 : OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
513 [ # # ]: 0 : if (keyName->length)
514 : : {
515 : 0 : ORegKey* pSubKey = 0;
516 [ # # ]: 0 : RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
517 [ # # ]: 0 : if (_ret1 != REG_NO_ERROR)
518 : 0 : return _ret1;
519 : :
520 [ # # ]: 0 : _ret1 = pSubKey->getStringListValue(valueName, pValueList, pLen);
521 [ # # ]: 0 : if (_ret1 != REG_NO_ERROR)
522 : : {
523 [ # # ]: 0 : (void) pKey->releaseKey(pSubKey);
524 : 0 : return _ret1;
525 : : }
526 : :
527 [ # # ]: 0 : return pKey->releaseKey(pSubKey);
528 : : }
529 : :
530 [ # # ]: 0 : return pKey->getStringListValue(valueName, pValueList, pLen);
531 : : }
532 : :
533 : : //*********************************************************************
534 : : // getUnicodeListValue
535 : : //
536 : 0 : RegError REGISTRY_CALLTYPE getUnicodeListValue(RegKeyHandle hKey,
537 : : rtl_uString* keyName,
538 : : sal_Unicode*** pValueList,
539 : : sal_uInt32* pLen)
540 : : {
541 : : OSL_PRECOND((pValueList != 0) && (pLen != 0), "registry::getUnicodeListValue(): invalid parameter");
542 : 0 : *pValueList = 0, *pLen = 0;
543 : :
544 : 0 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
545 [ # # ]: 0 : if (!pKey)
546 : 0 : return REG_INVALID_KEY;
547 : :
548 [ # # ]: 0 : if (pKey->isDeleted())
549 : 0 : return REG_INVALID_KEY;
550 : :
551 [ # # ]: 0 : OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
552 [ # # ]: 0 : if (keyName->length)
553 : : {
554 : 0 : ORegKey* pSubKey = 0;
555 [ # # ]: 0 : RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
556 [ # # ]: 0 : if (_ret1 != REG_NO_ERROR)
557 : 0 : return _ret1;
558 : :
559 [ # # ]: 0 : _ret1 = pSubKey->getUnicodeListValue(valueName, pValueList, pLen);
560 [ # # ]: 0 : if (_ret1 != REG_NO_ERROR)
561 : : {
562 [ # # ]: 0 : (void) pKey->releaseKey(pSubKey);
563 : 0 : return _ret1;
564 : : }
565 : :
566 [ # # ]: 0 : return pKey->releaseKey(pSubKey);
567 : : }
568 : :
569 [ # # ]: 0 : return pKey->getUnicodeListValue(valueName, pValueList, pLen);
570 : : }
571 : :
572 : : //*********************************************************************
573 : : // freeValueList
574 : : //
575 : 0 : RegError REGISTRY_CALLTYPE freeValueList(RegValueType valueType,
576 : : RegValue pValueList,
577 : : sal_uInt32 len)
578 : : {
579 [ # # # # ]: 0 : switch (valueType)
580 : : {
581 : : case 5:
582 : : {
583 : 0 : rtl_freeMemory(pValueList);
584 : : }
585 : 0 : break;
586 : : case 6:
587 : : {
588 : 0 : sal_Char** pVList = (sal_Char**)pValueList;
589 [ # # ]: 0 : for (sal_uInt32 i=0; i < len; i++)
590 : : {
591 : 0 : rtl_freeMemory(pVList[i]);
592 : : }
593 : :
594 : 0 : rtl_freeMemory(pVList);
595 : : }
596 : 0 : break;
597 : : case 7:
598 : : {
599 : 0 : sal_Unicode** pVList = (sal_Unicode**)pValueList;
600 [ # # ]: 0 : for (sal_uInt32 i=0; i < len; i++)
601 : : {
602 : 0 : rtl_freeMemory(pVList[i]);
603 : : }
604 : :
605 : 0 : rtl_freeMemory(pVList);
606 : : }
607 : 0 : break;
608 : : default:
609 : 0 : return REG_INVALID_VALUE;
610 : : }
611 : :
612 : 0 : pValueList = NULL;
613 : 0 : return REG_NO_ERROR;
614 : : }
615 : :
616 : : //*********************************************************************
617 : : // createLink
618 : : //
619 : 0 : RegError REGISTRY_CALLTYPE createLink(
620 : : SAL_UNUSED_PARAMETER RegKeyHandle, SAL_UNUSED_PARAMETER rtl_uString*,
621 : : SAL_UNUSED_PARAMETER rtl_uString*)
622 : : {
623 : 0 : return REG_INVALID_LINK; // links are no longer supported
624 : : }
625 : :
626 : : //*********************************************************************
627 : : // deleteLink
628 : : //
629 : 0 : RegError REGISTRY_CALLTYPE deleteLink(
630 : : SAL_UNUSED_PARAMETER RegKeyHandle, SAL_UNUSED_PARAMETER rtl_uString*)
631 : : {
632 : 0 : return REG_INVALID_LINK; // links are no longer supported
633 : : }
634 : :
635 : : //*********************************************************************
636 : : // getKeyType
637 : : //
638 : 820 : RegError REGISTRY_CALLTYPE getKeyType(RegKeyHandle hKey,
639 : : rtl_uString* keyName,
640 : : RegKeyType* pKeyType)
641 : : {
642 : 820 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
643 [ - + ]: 820 : if (!pKey)
644 : 0 : return REG_INVALID_KEY;
645 : :
646 [ - + ]: 820 : if (pKey->isDeleted())
647 : 0 : return REG_INVALID_KEY;
648 : :
649 [ + - ]: 820 : return pKey->getKeyType(keyName, pKeyType);
650 : : }
651 : :
652 : : //*********************************************************************
653 : : // getLinkTarget
654 : : //
655 : 0 : RegError REGISTRY_CALLTYPE getLinkTarget(
656 : : SAL_UNUSED_PARAMETER RegKeyHandle, SAL_UNUSED_PARAMETER rtl_uString*,
657 : : SAL_UNUSED_PARAMETER rtl_uString**)
658 : : {
659 : 0 : return REG_INVALID_LINK; // links are no longer supported
660 : : }
661 : :
662 : : //*********************************************************************
663 : : // getName
664 : : //
665 : 267565 : RegError REGISTRY_CALLTYPE getResolvedKeyName(RegKeyHandle hKey,
666 : : rtl_uString* keyName,
667 : : SAL_UNUSED_PARAMETER sal_Bool,
668 : : rtl_uString** pResolvedName)
669 : : {
670 : 267565 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
671 [ - + ]: 267565 : if (!pKey)
672 : 0 : return REG_INVALID_KEY;
673 : :
674 [ - + ]: 267565 : if (pKey->isDeleted())
675 : 0 : return REG_INVALID_KEY;
676 : :
677 : 267565 : OUString resolvedName;
678 [ + - ]: 267565 : RegError _ret = pKey->getResolvedKeyName(keyName, resolvedName);
679 [ + - ]: 267565 : if (_ret == REG_NO_ERROR)
680 : 267565 : rtl_uString_assign(pResolvedName, resolvedName.pData);
681 : 267565 : return _ret;
682 : : }
683 : :
684 : : //*********************************************************************
685 : : // getKeyNames
686 : : //
687 : 18706 : RegError REGISTRY_CALLTYPE getKeyNames(RegKeyHandle hKey,
688 : : rtl_uString* keyName,
689 : : rtl_uString*** pSubKeyNames,
690 : : sal_uInt32* pnSubKeys)
691 : : {
692 : 18706 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
693 [ - + ]: 18706 : if (!pKey)
694 : 0 : return REG_INVALID_KEY;
695 : :
696 [ - + ]: 18706 : if (pKey->isDeleted())
697 : 0 : return REG_INVALID_KEY;
698 : :
699 [ + - ]: 18706 : return pKey->getKeyNames(keyName, pSubKeyNames, pnSubKeys);
700 : : }
701 : :
702 : : //*********************************************************************
703 : : // freeKeyNames
704 : : //
705 : 1686 : RegError REGISTRY_CALLTYPE freeKeyNames(rtl_uString** pKeyNames,
706 : : sal_uInt32 nKeys)
707 : : {
708 [ + + ]: 22458 : for (sal_uInt32 i=0; i < nKeys; i++)
709 : : {
710 : 20772 : rtl_uString_release(pKeyNames[i]);
711 : : }
712 : :
713 : 1686 : rtl_freeMemory(pKeyNames);
714 : :
715 : 1686 : return REG_NO_ERROR;
716 : : }
717 : :
718 : : //*********************************************************************
719 : : // C API
720 : : //
721 : :
722 : : //*********************************************************************
723 : : // reg_createKey
724 : : //
725 : 0 : RegError REGISTRY_CALLTYPE reg_createKey(RegKeyHandle hKey,
726 : : rtl_uString* keyName,
727 : : RegKeyHandle* phNewKey)
728 : : {
729 [ # # ]: 0 : if (!hKey)
730 : 0 : return REG_INVALID_KEY;
731 : :
732 : 0 : return createKey(hKey, keyName, phNewKey);
733 : : }
734 : :
735 : : //*********************************************************************
736 : : // reg_openKey
737 : : //
738 : 0 : RegError REGISTRY_CALLTYPE reg_openKey(RegKeyHandle hKey,
739 : : rtl_uString* keyName,
740 : : RegKeyHandle* phOpenKey)
741 : : {
742 [ # # ]: 0 : if (!hKey)
743 : 0 : return REG_INVALID_KEY;
744 : :
745 : 0 : return openKey(hKey, keyName, phOpenKey);
746 : : }
747 : :
748 : : //*********************************************************************
749 : : // reg_openSubKeys
750 : : //
751 : 0 : RegError REGISTRY_CALLTYPE reg_openSubKeys(RegKeyHandle hKey,
752 : : rtl_uString* keyName,
753 : : RegKeyHandle** pphSubKeys,
754 : : sal_uInt32* pnSubKeys)
755 : : {
756 [ # # ]: 0 : if (!hKey)
757 : 0 : return REG_INVALID_KEY;
758 : :
759 : 0 : return openSubKeys(hKey, keyName, pphSubKeys, pnSubKeys);
760 : : }
761 : :
762 : : //*********************************************************************
763 : : // reg_closeSubKeys
764 : : //
765 : 0 : RegError REGISTRY_CALLTYPE reg_closeSubKeys(RegKeyHandle* pphSubKeys,
766 : : sal_uInt32 nSubKeys)
767 : : {
768 [ # # ]: 0 : if (!pphSubKeys)
769 : 0 : return REG_INVALID_KEY;
770 : :
771 : 0 : return closeSubKeys(pphSubKeys, nSubKeys);
772 : : }
773 : :
774 : : //*********************************************************************
775 : : // reg_deleteKey
776 : : //
777 : 0 : RegError REGISTRY_CALLTYPE reg_deleteKey(RegKeyHandle hKey,
778 : : rtl_uString* keyName)
779 : : {
780 [ # # ]: 0 : if (!hKey)
781 : 0 : return REG_INVALID_KEY;
782 : :
783 : 0 : return deleteKey(hKey, keyName);
784 : : }
785 : :
786 : : //*********************************************************************
787 : : // reg_closeKey
788 : : //
789 : 0 : RegError REGISTRY_CALLTYPE reg_closeKey(RegKeyHandle hKey)
790 : : {
791 [ # # ]: 0 : if (!hKey)
792 : 0 : return REG_INVALID_KEY;
793 : :
794 : 0 : return closeKey(hKey);
795 : : }
796 : :
797 : :
798 : : //*********************************************************************
799 : : // reg_getKeyName
800 : : //
801 : 0 : RegError REGISTRY_CALLTYPE reg_getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName)
802 : : {
803 [ # # ]: 0 : if (hKey)
804 : : {
805 : 0 : rtl_uString_assign( pKeyName, ((ORegKey*)hKey)->getName().pData );
806 : 0 : return REG_NO_ERROR;
807 : : } else
808 : : {
809 : 0 : rtl_uString_new( pKeyName );
810 : 0 : return REG_INVALID_KEY;
811 : : }
812 : : }
813 : :
814 : : //*********************************************************************
815 : : // reg_setValue
816 : : //
817 : 0 : RegError REGISTRY_CALLTYPE reg_setValue(RegKeyHandle hKey,
818 : : rtl_uString* keyName,
819 : : RegValueType valueType,
820 : : RegValue pData,
821 : : sal_uInt32 valueSize)
822 : : {
823 [ # # ]: 0 : if (!hKey)
824 : 0 : return REG_INVALID_KEY;
825 : :
826 : 0 : return setValue(hKey, keyName, valueType, pData, valueSize);
827 : : }
828 : :
829 : : //*********************************************************************
830 : : // reg_setLongListValue
831 : : //
832 : 0 : RegError REGISTRY_CALLTYPE reg_setLongListValue(RegKeyHandle hKey,
833 : : rtl_uString* keyName,
834 : : sal_Int32* pValueList,
835 : : sal_uInt32 len)
836 : : {
837 [ # # ]: 0 : if (!hKey)
838 : 0 : return REG_INVALID_KEY;
839 : :
840 : 0 : return setLongListValue(hKey, keyName, pValueList, len);
841 : : }
842 : :
843 : : //*********************************************************************
844 : : // reg_setStringListValue
845 : : //
846 : 0 : RegError REGISTRY_CALLTYPE reg_setStringListValue(RegKeyHandle hKey,
847 : : rtl_uString* keyName,
848 : : sal_Char** pValueList,
849 : : sal_uInt32 len)
850 : : {
851 [ # # ]: 0 : if (!hKey)
852 : 0 : return REG_INVALID_KEY;
853 : :
854 : 0 : return setStringListValue(hKey, keyName, pValueList, len);
855 : : }
856 : :
857 : : //*********************************************************************
858 : : // reg_setUnicodeListValue
859 : : //
860 : 0 : RegError REGISTRY_CALLTYPE reg_setUnicodeListValue(RegKeyHandle hKey,
861 : : rtl_uString* keyName,
862 : : sal_Unicode** pValueList,
863 : : sal_uInt32 len)
864 : : {
865 [ # # ]: 0 : if (!hKey)
866 : 0 : return REG_INVALID_KEY;
867 : :
868 : 0 : return setUnicodeListValue(hKey, keyName, pValueList, len);
869 : : }
870 : :
871 : : //*********************************************************************
872 : : // reg_getValueInfo
873 : : //
874 : 0 : RegError REGISTRY_CALLTYPE reg_getValueInfo(RegKeyHandle hKey,
875 : : rtl_uString* keyName,
876 : : RegValueType* pValueType,
877 : : sal_uInt32* pValueSize)
878 : : {
879 [ # # ]: 0 : if (!hKey)
880 : 0 : return REG_INVALID_KEY;
881 : :
882 : 0 : return getValueInfo(hKey, keyName, pValueType, pValueSize);
883 : : }
884 : :
885 : : //*********************************************************************
886 : : // reg_getValueInfo
887 : : //
888 : 0 : RegError REGISTRY_CALLTYPE reg_getValue(RegKeyHandle hKey,
889 : : rtl_uString* keyName,
890 : : RegValue pData)
891 : : {
892 [ # # ]: 0 : if (!hKey)
893 : 0 : return REG_INVALID_KEY;
894 : :
895 : 0 : return getValue(hKey, keyName, pData);
896 : : }
897 : :
898 : : //*********************************************************************
899 : : // reg_getLongListValue
900 : : //
901 : 0 : RegError REGISTRY_CALLTYPE reg_getLongListValue(RegKeyHandle hKey,
902 : : rtl_uString* keyName,
903 : : sal_Int32** pValueList,
904 : : sal_uInt32* pLen)
905 : : {
906 [ # # ]: 0 : if (!hKey)
907 : 0 : return REG_INVALID_KEY;
908 : :
909 : 0 : return getLongListValue(hKey, keyName, pValueList, pLen);
910 : : }
911 : :
912 : : //*********************************************************************
913 : : // reg_getStringListValue
914 : : //
915 : 0 : RegError REGISTRY_CALLTYPE reg_getStringListValue(RegKeyHandle hKey,
916 : : rtl_uString* keyName,
917 : : sal_Char*** pValueList,
918 : : sal_uInt32* pLen)
919 : : {
920 [ # # ]: 0 : if (!hKey)
921 : 0 : return REG_INVALID_KEY;
922 : :
923 : 0 : return getStringListValue(hKey, keyName, pValueList, pLen);
924 : : }
925 : :
926 : : //*********************************************************************
927 : : // reg_getUnicodeListValue
928 : : //
929 : 0 : RegError REGISTRY_CALLTYPE reg_getUnicodeListValue(RegKeyHandle hKey,
930 : : rtl_uString* keyName,
931 : : sal_Unicode*** pValueList,
932 : : sal_uInt32* pLen)
933 : : {
934 [ # # ]: 0 : if (!hKey)
935 : 0 : return REG_INVALID_KEY;
936 : :
937 : 0 : return getUnicodeListValue(hKey, keyName, pValueList, pLen);
938 : : }
939 : :
940 : : //*********************************************************************
941 : : // reg_freeValueList
942 : : //
943 : 0 : RegError REGISTRY_CALLTYPE reg_freeValueList(RegValueType valueType,
944 : : RegValue pValueList,
945 : : sal_uInt32 len)
946 : : {
947 [ # # ]: 0 : if (pValueList)
948 : 0 : return freeValueList(valueType, pValueList, len);
949 : : else
950 : 0 : return REG_INVALID_VALUE;
951 : : }
952 : :
953 : : //*********************************************************************
954 : : // reg_getKeyType
955 : : //
956 : 0 : RegError REGISTRY_CALLTYPE reg_getKeyType(RegKeyHandle hKey,
957 : : rtl_uString* keyName,
958 : : RegKeyType* pKeyType)
959 : : {
960 [ # # ]: 0 : if (!hKey)
961 : 0 : return REG_INVALID_KEY;
962 : :
963 : 0 : return getKeyType(hKey, keyName, pKeyType);
964 : : }
965 : :
966 : : //*********************************************************************
967 : : // reg_getResolvedKeyName
968 : : //
969 : 0 : RegError REGISTRY_CALLTYPE reg_getResolvedKeyName(RegKeyHandle hKey,
970 : : rtl_uString* keyName,
971 : : sal_Bool firstLinkOnly,
972 : : rtl_uString** pResolvedName)
973 : : {
974 [ # # ]: 0 : if (!hKey)
975 : 0 : return REG_INVALID_KEY;
976 : :
977 : 0 : return getResolvedKeyName(hKey, keyName, firstLinkOnly, pResolvedName);
978 : : }
979 : :
980 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
