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