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