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 6190 : void REGISTRY_CALLTYPE acquireKey(RegKeyHandle hKey)
33 : {
34 6190 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
35 6190 : if (pKey != 0)
36 : {
37 6190 : ORegistry* pReg = pKey->getRegistry();
38 6190 : (void) pReg->acquireKey(pKey);
39 : }
40 6190 : }
41 :
42 :
43 : //*********************************************************************
44 : // releaseKey
45 : //
46 53274 : void REGISTRY_CALLTYPE releaseKey(RegKeyHandle hKey)
47 : {
48 53274 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
49 53274 : if (pKey != 0)
50 : {
51 53274 : ORegistry* pReg = pKey->getRegistry();
52 53274 : (void) pReg->releaseKey(pKey);
53 : }
54 53274 : }
55 :
56 :
57 : //*********************************************************************
58 : // isKeyReadOnly
59 : //
60 1 : sal_Bool REGISTRY_CALLTYPE isKeyReadOnly(RegKeyHandle hKey)
61 : {
62 1 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
63 1 : return (pKey != 0) ? pKey->isReadOnly() : sal_False;
64 : }
65 :
66 :
67 : //*********************************************************************
68 : // getKeyName
69 : //
70 304 : RegError REGISTRY_CALLTYPE getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName)
71 : {
72 304 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
73 304 : if (pKey)
74 : {
75 304 : rtl_uString_assign( pKeyName, pKey->getName().pData );
76 304 : 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 27114 : RegError REGISTRY_CALLTYPE createKey(RegKeyHandle hKey,
89 : rtl_uString* keyName,
90 : RegKeyHandle* phNewKey)
91 : {
92 27114 : *phNewKey = 0;
93 :
94 27114 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
95 27114 : if (!pKey)
96 0 : return REG_INVALID_KEY;
97 :
98 27114 : if (pKey->isDeleted())
99 0 : return REG_INVALID_KEY;
100 :
101 27114 : if (pKey->isReadOnly())
102 0 : return REG_REGISTRY_READONLY;
103 :
104 27114 : return pKey->createKey(keyName, phNewKey);
105 : }
106 :
107 : //*********************************************************************
108 : // openKey
109 : //
110 14538 : RegError REGISTRY_CALLTYPE openKey(RegKeyHandle hKey,
111 : rtl_uString* keyName,
112 : RegKeyHandle* phOpenKey)
113 : {
114 14538 : *phOpenKey = 0;
115 :
116 14538 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
117 14538 : if (!pKey)
118 0 : return REG_INVALID_KEY;
119 :
120 14538 : if (pKey->isDeleted())
121 0 : return REG_INVALID_KEY;
122 :
123 14538 : return pKey->openKey(keyName, phOpenKey);
124 : }
125 :
126 : //*********************************************************************
127 : // openSubKeys
128 : //
129 7 : RegError REGISTRY_CALLTYPE openSubKeys(RegKeyHandle hKey,
130 : rtl_uString* keyName,
131 : RegKeyHandle** pphSubKeys,
132 : sal_uInt32* pnSubKeys)
133 : {
134 7 : *pphSubKeys = NULL;
135 7 : *pnSubKeys = 0;
136 :
137 7 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
138 7 : if (!pKey)
139 0 : return REG_INVALID_KEY;
140 :
141 7 : if (pKey->isDeleted())
142 0 : return REG_INVALID_KEY;
143 :
144 7 : return pKey->openSubKeys(keyName, pphSubKeys, pnSubKeys);
145 : }
146 :
147 : //*********************************************************************
148 : // closeSubKeys
149 : //
150 7 : RegError REGISTRY_CALLTYPE closeSubKeys(RegKeyHandle* phSubKeys,
151 : sal_uInt32 nSubKeys)
152 : {
153 7 : if (phSubKeys == 0 || nSubKeys == 0)
154 1 : return REG_INVALID_KEY;
155 :
156 6 : ORegistry* pReg = ((ORegKey*)(phSubKeys[0]))->getRegistry();
157 14 : for (sal_uInt32 i = 0; i < nSubKeys; i++)
158 : {
159 8 : (void) pReg->closeKey(phSubKeys[i]);
160 : }
161 6 : rtl_freeMemory(phSubKeys);
162 :
163 6 : return REG_NO_ERROR;
164 : }
165 :
166 : //*********************************************************************
167 : // deleteKey
168 : //
169 2 : RegError REGISTRY_CALLTYPE deleteKey(RegKeyHandle hKey,
170 : rtl_uString* keyName)
171 : {
172 2 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
173 2 : if (!pKey)
174 0 : return REG_INVALID_KEY;
175 :
176 2 : if (pKey->isDeleted())
177 0 : return REG_INVALID_KEY;
178 :
179 2 : if (pKey->isReadOnly())
180 0 : return REG_REGISTRY_READONLY;
181 :
182 2 : return pKey->deleteKey(keyName);
183 : }
184 :
185 : //*********************************************************************
186 : // closeKey
187 : //
188 20 : RegError REGISTRY_CALLTYPE closeKey(RegKeyHandle hKey)
189 : {
190 20 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
191 20 : if (!pKey)
192 0 : return REG_INVALID_KEY;
193 :
194 20 : return pKey->closeKey(hKey);
195 : }
196 :
197 : //*********************************************************************
198 : // setValue
199 : //
200 27103 : RegError REGISTRY_CALLTYPE setValue(RegKeyHandle hKey,
201 : rtl_uString* keyName,
202 : RegValueType valueType,
203 : RegValue pData,
204 : sal_uInt32 valueSize)
205 : {
206 27103 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
207 27103 : if (!pKey)
208 0 : return REG_INVALID_KEY;
209 :
210 27103 : if (pKey->isDeleted())
211 0 : return REG_INVALID_KEY;
212 :
213 27103 : if (pKey->isReadOnly())
214 0 : return REG_REGISTRY_READONLY;
215 :
216 27103 : OUString valueName("value");
217 27103 : 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 27103 : 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 1 : RegError REGISTRY_CALLTYPE setStringListValue(RegKeyHandle hKey,
286 : rtl_uString* keyName,
287 : sal_Char** pValueList,
288 : sal_uInt32 len)
289 : {
290 1 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
291 1 : if (!pKey)
292 0 : return REG_INVALID_KEY;
293 :
294 1 : if (pKey->isDeleted())
295 0 : return REG_INVALID_KEY;
296 :
297 1 : if (pKey->isReadOnly())
298 0 : return REG_REGISTRY_READONLY;
299 :
300 1 : OUString valueName("value");
301 1 : 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 1 : 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 14529 : RegError REGISTRY_CALLTYPE getValueInfo(RegKeyHandle hKey,
370 : rtl_uString* keyName,
371 : RegValueType* pValueType,
372 : sal_uInt32* pValueSize)
373 : {
374 14529 : *pValueType = RG_VALUETYPE_NOT_DEFINED;
375 14529 : *pValueSize = 0;
376 :
377 14529 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
378 14529 : if (!pKey)
379 0 : return REG_INVALID_KEY;
380 :
381 14529 : if (pKey->isDeleted())
382 0 : return REG_INVALID_KEY;
383 :
384 : RegValueType valueType;
385 : sal_uInt32 valueSize;
386 :
387 14529 : OUString valueName("value");
388 14529 : 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 14529 : if (pKey->getValueInfo(valueName, &valueType, &valueSize) != REG_NO_ERROR)
409 : {
410 16 : return REG_INVALID_VALUE;
411 : }
412 :
413 14513 : *pValueType = valueType;
414 14513 : *pValueSize = valueSize;
415 :
416 14513 : return REG_NO_ERROR;
417 : }
418 :
419 : //*********************************************************************
420 : // getValueInfo
421 : //
422 14510 : RegError REGISTRY_CALLTYPE getValue(RegKeyHandle hKey,
423 : rtl_uString* keyName,
424 : RegValue pValue)
425 : {
426 14510 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
427 14510 : if (!pKey)
428 0 : return REG_INVALID_KEY;
429 :
430 14510 : if (pKey->isDeleted())
431 0 : return REG_INVALID_KEY;
432 :
433 14510 : OUString valueName("value");
434 14510 : 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 14510 : 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 : OSL_PRECOND((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 : //*********************************************************************
533 : // getUnicodeListValue
534 : //
535 0 : RegError REGISTRY_CALLTYPE getUnicodeListValue(RegKeyHandle hKey,
536 : rtl_uString* keyName,
537 : sal_Unicode*** pValueList,
538 : sal_uInt32* pLen)
539 : {
540 : OSL_PRECOND((pValueList != 0) && (pLen != 0), "registry::getUnicodeListValue(): invalid parameter");
541 0 : *pValueList = 0, *pLen = 0;
542 :
543 0 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
544 0 : if (!pKey)
545 0 : return REG_INVALID_KEY;
546 :
547 0 : if (pKey->isDeleted())
548 0 : return REG_INVALID_KEY;
549 :
550 0 : OUString valueName("value");
551 0 : if (keyName->length)
552 : {
553 0 : ORegKey* pSubKey = 0;
554 0 : RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
555 0 : if (_ret1 != REG_NO_ERROR)
556 0 : return _ret1;
557 :
558 0 : _ret1 = pSubKey->getUnicodeListValue(valueName, pValueList, pLen);
559 0 : if (_ret1 != REG_NO_ERROR)
560 : {
561 0 : (void) pKey->releaseKey(pSubKey);
562 0 : return _ret1;
563 : }
564 :
565 0 : return pKey->releaseKey(pSubKey);
566 : }
567 :
568 0 : return pKey->getUnicodeListValue(valueName, pValueList, pLen);
569 : }
570 :
571 : //*********************************************************************
572 : // freeValueList
573 : //
574 0 : RegError REGISTRY_CALLTYPE freeValueList(RegValueType valueType,
575 : RegValue pValueList,
576 : sal_uInt32 len)
577 : {
578 0 : switch (valueType)
579 : {
580 : case 5:
581 : {
582 0 : rtl_freeMemory(pValueList);
583 : }
584 0 : break;
585 : case 6:
586 : {
587 0 : sal_Char** pVList = (sal_Char**)pValueList;
588 0 : for (sal_uInt32 i=0; i < len; i++)
589 : {
590 0 : rtl_freeMemory(pVList[i]);
591 : }
592 :
593 0 : rtl_freeMemory(pVList);
594 : }
595 0 : break;
596 : case 7:
597 : {
598 0 : sal_Unicode** pVList = (sal_Unicode**)pValueList;
599 0 : for (sal_uInt32 i=0; i < len; i++)
600 : {
601 0 : rtl_freeMemory(pVList[i]);
602 : }
603 :
604 0 : rtl_freeMemory(pVList);
605 : }
606 0 : break;
607 : default:
608 0 : return REG_INVALID_VALUE;
609 : }
610 :
611 0 : pValueList = NULL;
612 0 : return REG_NO_ERROR;
613 : }
614 :
615 : //*********************************************************************
616 : // createLink
617 : //
618 0 : RegError REGISTRY_CALLTYPE createLink(
619 : SAL_UNUSED_PARAMETER RegKeyHandle, SAL_UNUSED_PARAMETER rtl_uString*,
620 : SAL_UNUSED_PARAMETER rtl_uString*)
621 : {
622 0 : return REG_INVALID_LINK; // links are no longer supported
623 : }
624 :
625 : //*********************************************************************
626 : // deleteLink
627 : //
628 0 : RegError REGISTRY_CALLTYPE deleteLink(
629 : SAL_UNUSED_PARAMETER RegKeyHandle, SAL_UNUSED_PARAMETER rtl_uString*)
630 : {
631 0 : return REG_INVALID_LINK; // links are no longer supported
632 : }
633 :
634 : //*********************************************************************
635 : // getKeyType
636 : //
637 7 : RegError REGISTRY_CALLTYPE getKeyType(RegKeyHandle hKey,
638 : rtl_uString* keyName,
639 : RegKeyType* pKeyType)
640 : {
641 7 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
642 7 : if (!pKey)
643 0 : return REG_INVALID_KEY;
644 :
645 7 : if (pKey->isDeleted())
646 0 : return REG_INVALID_KEY;
647 :
648 7 : return pKey->getKeyType(keyName, pKeyType);
649 : }
650 :
651 : //*********************************************************************
652 : // getLinkTarget
653 : //
654 0 : RegError REGISTRY_CALLTYPE getLinkTarget(
655 : SAL_UNUSED_PARAMETER RegKeyHandle, SAL_UNUSED_PARAMETER rtl_uString*,
656 : SAL_UNUSED_PARAMETER rtl_uString**)
657 : {
658 0 : return REG_INVALID_LINK; // links are no longer supported
659 : }
660 :
661 : //*********************************************************************
662 : // getName
663 : //
664 0 : RegError REGISTRY_CALLTYPE getResolvedKeyName(RegKeyHandle hKey,
665 : rtl_uString* keyName,
666 : SAL_UNUSED_PARAMETER sal_Bool,
667 : rtl_uString** pResolvedName)
668 : {
669 0 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
670 0 : if (!pKey)
671 0 : return REG_INVALID_KEY;
672 :
673 0 : if (pKey->isDeleted())
674 0 : return REG_INVALID_KEY;
675 :
676 0 : OUString resolvedName;
677 0 : RegError _ret = pKey->getResolvedKeyName(keyName, resolvedName);
678 0 : if (_ret == REG_NO_ERROR)
679 0 : rtl_uString_assign(pResolvedName, resolvedName.pData);
680 0 : return _ret;
681 : }
682 :
683 : //*********************************************************************
684 : // getKeyNames
685 : //
686 8823 : RegError REGISTRY_CALLTYPE getKeyNames(RegKeyHandle hKey,
687 : rtl_uString* keyName,
688 : rtl_uString*** pSubKeyNames,
689 : sal_uInt32* pnSubKeys)
690 : {
691 8823 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
692 8823 : if (!pKey)
693 0 : return REG_INVALID_KEY;
694 :
695 8823 : if (pKey->isDeleted())
696 0 : return REG_INVALID_KEY;
697 :
698 8823 : return pKey->getKeyNames(keyName, pSubKeyNames, pnSubKeys);
699 : }
700 :
701 : //*********************************************************************
702 : // freeKeyNames
703 : //
704 452 : RegError REGISTRY_CALLTYPE freeKeyNames(rtl_uString** pKeyNames,
705 : sal_uInt32 nKeys)
706 : {
707 15011 : for (sal_uInt32 i=0; i < nKeys; i++)
708 : {
709 14559 : rtl_uString_release(pKeyNames[i]);
710 : }
711 :
712 452 : rtl_freeMemory(pKeyNames);
713 :
714 452 : return REG_NO_ERROR;
715 : }
716 :
717 : //*********************************************************************
718 : // C API
719 : //
720 :
721 : //*********************************************************************
722 : // reg_createKey
723 : //
724 0 : RegError REGISTRY_CALLTYPE reg_createKey(RegKeyHandle hKey,
725 : rtl_uString* keyName,
726 : RegKeyHandle* phNewKey)
727 : {
728 0 : if (!hKey)
729 0 : return REG_INVALID_KEY;
730 :
731 0 : return createKey(hKey, keyName, phNewKey);
732 : }
733 :
734 : //*********************************************************************
735 : // reg_openKey
736 : //
737 0 : RegError REGISTRY_CALLTYPE reg_openKey(RegKeyHandle hKey,
738 : rtl_uString* keyName,
739 : RegKeyHandle* phOpenKey)
740 : {
741 0 : if (!hKey)
742 0 : return REG_INVALID_KEY;
743 :
744 0 : return openKey(hKey, keyName, phOpenKey);
745 : }
746 :
747 : //*********************************************************************
748 : // reg_openSubKeys
749 : //
750 0 : RegError REGISTRY_CALLTYPE reg_openSubKeys(RegKeyHandle hKey,
751 : rtl_uString* keyName,
752 : RegKeyHandle** pphSubKeys,
753 : sal_uInt32* pnSubKeys)
754 : {
755 0 : if (!hKey)
756 0 : return REG_INVALID_KEY;
757 :
758 0 : return openSubKeys(hKey, keyName, pphSubKeys, pnSubKeys);
759 : }
760 :
761 : //*********************************************************************
762 : // reg_closeSubKeys
763 : //
764 0 : RegError REGISTRY_CALLTYPE reg_closeSubKeys(RegKeyHandle* pphSubKeys,
765 : sal_uInt32 nSubKeys)
766 : {
767 0 : if (!pphSubKeys)
768 0 : return REG_INVALID_KEY;
769 :
770 0 : return closeSubKeys(pphSubKeys, nSubKeys);
771 : }
772 :
773 : //*********************************************************************
774 : // reg_deleteKey
775 : //
776 0 : RegError REGISTRY_CALLTYPE reg_deleteKey(RegKeyHandle hKey,
777 : rtl_uString* keyName)
778 : {
779 0 : if (!hKey)
780 0 : return REG_INVALID_KEY;
781 :
782 0 : return deleteKey(hKey, keyName);
783 : }
784 :
785 : //*********************************************************************
786 : // reg_closeKey
787 : //
788 0 : RegError REGISTRY_CALLTYPE reg_closeKey(RegKeyHandle hKey)
789 : {
790 0 : if (!hKey)
791 0 : return REG_INVALID_KEY;
792 :
793 0 : return closeKey(hKey);
794 : }
795 :
796 :
797 : //*********************************************************************
798 : // reg_getKeyName
799 : //
800 0 : RegError REGISTRY_CALLTYPE reg_getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName)
801 : {
802 0 : if (hKey)
803 : {
804 0 : rtl_uString_assign( pKeyName, ((ORegKey*)hKey)->getName().pData );
805 0 : return REG_NO_ERROR;
806 : } else
807 : {
808 0 : rtl_uString_new( pKeyName );
809 0 : return REG_INVALID_KEY;
810 : }
811 : }
812 :
813 : //*********************************************************************
814 : // reg_setValue
815 : //
816 0 : RegError REGISTRY_CALLTYPE reg_setValue(RegKeyHandle hKey,
817 : rtl_uString* keyName,
818 : RegValueType valueType,
819 : RegValue pData,
820 : sal_uInt32 valueSize)
821 : {
822 0 : if (!hKey)
823 0 : return REG_INVALID_KEY;
824 :
825 0 : return setValue(hKey, keyName, valueType, pData, valueSize);
826 : }
827 :
828 : //*********************************************************************
829 : // reg_setLongListValue
830 : //
831 0 : RegError REGISTRY_CALLTYPE reg_setLongListValue(RegKeyHandle hKey,
832 : rtl_uString* keyName,
833 : sal_Int32* pValueList,
834 : sal_uInt32 len)
835 : {
836 0 : if (!hKey)
837 0 : return REG_INVALID_KEY;
838 :
839 0 : return setLongListValue(hKey, keyName, pValueList, len);
840 : }
841 :
842 : //*********************************************************************
843 : // reg_setStringListValue
844 : //
845 0 : RegError REGISTRY_CALLTYPE reg_setStringListValue(RegKeyHandle hKey,
846 : rtl_uString* keyName,
847 : sal_Char** pValueList,
848 : sal_uInt32 len)
849 : {
850 0 : if (!hKey)
851 0 : return REG_INVALID_KEY;
852 :
853 0 : return setStringListValue(hKey, keyName, pValueList, len);
854 : }
855 :
856 : //*********************************************************************
857 : // reg_setUnicodeListValue
858 : //
859 0 : RegError REGISTRY_CALLTYPE reg_setUnicodeListValue(RegKeyHandle hKey,
860 : rtl_uString* keyName,
861 : sal_Unicode** pValueList,
862 : sal_uInt32 len)
863 : {
864 0 : if (!hKey)
865 0 : return REG_INVALID_KEY;
866 :
867 0 : return setUnicodeListValue(hKey, keyName, pValueList, len);
868 : }
869 :
870 : //*********************************************************************
871 : // reg_getValueInfo
872 : //
873 0 : RegError REGISTRY_CALLTYPE reg_getValueInfo(RegKeyHandle hKey,
874 : rtl_uString* keyName,
875 : RegValueType* pValueType,
876 : sal_uInt32* pValueSize)
877 : {
878 0 : if (!hKey)
879 0 : return REG_INVALID_KEY;
880 :
881 0 : return getValueInfo(hKey, keyName, pValueType, pValueSize);
882 : }
883 :
884 : //*********************************************************************
885 : // reg_getValueInfo
886 : //
887 0 : RegError REGISTRY_CALLTYPE reg_getValue(RegKeyHandle hKey,
888 : rtl_uString* keyName,
889 : RegValue pData)
890 : {
891 0 : if (!hKey)
892 0 : return REG_INVALID_KEY;
893 :
894 0 : return getValue(hKey, keyName, pData);
895 : }
896 :
897 : //*********************************************************************
898 : // reg_getLongListValue
899 : //
900 0 : RegError REGISTRY_CALLTYPE reg_getLongListValue(RegKeyHandle hKey,
901 : rtl_uString* keyName,
902 : sal_Int32** pValueList,
903 : sal_uInt32* pLen)
904 : {
905 0 : if (!hKey)
906 0 : return REG_INVALID_KEY;
907 :
908 0 : return getLongListValue(hKey, keyName, pValueList, pLen);
909 : }
910 :
911 : //*********************************************************************
912 : // reg_getStringListValue
913 : //
914 0 : RegError REGISTRY_CALLTYPE reg_getStringListValue(RegKeyHandle hKey,
915 : rtl_uString* keyName,
916 : sal_Char*** pValueList,
917 : sal_uInt32* pLen)
918 : {
919 0 : if (!hKey)
920 0 : return REG_INVALID_KEY;
921 :
922 0 : return getStringListValue(hKey, keyName, pValueList, pLen);
923 : }
924 :
925 : //*********************************************************************
926 : // reg_getUnicodeListValue
927 : //
928 0 : RegError REGISTRY_CALLTYPE reg_getUnicodeListValue(RegKeyHandle hKey,
929 : rtl_uString* keyName,
930 : sal_Unicode*** pValueList,
931 : sal_uInt32* pLen)
932 : {
933 0 : if (!hKey)
934 0 : return REG_INVALID_KEY;
935 :
936 0 : return getUnicodeListValue(hKey, keyName, pValueList, pLen);
937 : }
938 :
939 : //*********************************************************************
940 : // reg_freeValueList
941 : //
942 0 : RegError REGISTRY_CALLTYPE reg_freeValueList(RegValueType valueType,
943 : RegValue pValueList,
944 : sal_uInt32 len)
945 : {
946 0 : if (pValueList)
947 0 : return freeValueList(valueType, pValueList, len);
948 : else
949 0 : return REG_INVALID_VALUE;
950 : }
951 :
952 : //*********************************************************************
953 : // reg_getKeyType
954 : //
955 0 : RegError REGISTRY_CALLTYPE reg_getKeyType(RegKeyHandle hKey,
956 : rtl_uString* keyName,
957 : RegKeyType* pKeyType)
958 : {
959 0 : if (!hKey)
960 0 : return REG_INVALID_KEY;
961 :
962 0 : return getKeyType(hKey, keyName, pKeyType);
963 : }
964 :
965 : //*********************************************************************
966 : // reg_getResolvedKeyName
967 : //
968 0 : RegError REGISTRY_CALLTYPE reg_getResolvedKeyName(RegKeyHandle hKey,
969 : rtl_uString* keyName,
970 : sal_Bool firstLinkOnly,
971 : rtl_uString** pResolvedName)
972 : {
973 0 : if (!hKey)
974 0 : return REG_INVALID_KEY;
975 :
976 0 : return getResolvedKeyName(hKey, keyName, firstLinkOnly, pResolvedName);
977 : }
978 :
979 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
