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 104305 : void REGISTRY_CALLTYPE acquireKey(RegKeyHandle hKey)
34 : {
35 104305 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
36 104305 : if (pKey != 0)
37 : {
38 104305 : ORegistry* pReg = pKey->getRegistry();
39 104305 : (void) pReg->acquireKey(pKey);
40 : }
41 104305 : }
42 :
43 :
44 : //*********************************************************************
45 : // releaseKey
46 : //
47 382192 : void REGISTRY_CALLTYPE releaseKey(RegKeyHandle hKey)
48 : {
49 382192 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
50 382192 : if (pKey != 0)
51 : {
52 382192 : ORegistry* pReg = pKey->getRegistry();
53 382192 : (void) pReg->releaseKey(pKey);
54 : }
55 382192 : }
56 :
57 :
58 : //*********************************************************************
59 : // isKeyReadOnly
60 : //
61 0 : sal_Bool REGISTRY_CALLTYPE isKeyReadOnly(RegKeyHandle hKey)
62 : {
63 0 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
64 0 : return (pKey != 0) ? pKey->isReadOnly() : sal_False;
65 : }
66 :
67 :
68 : //*********************************************************************
69 : // getKeyName
70 : //
71 34595 : RegError REGISTRY_CALLTYPE getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName)
72 : {
73 34595 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
74 34595 : if (pKey)
75 : {
76 34595 : rtl_uString_assign( pKeyName, pKey->getName().pData );
77 34595 : return REG_NO_ERROR;
78 : } else
79 : {
80 0 : rtl_uString_new(pKeyName);
81 0 : return REG_INVALID_KEY;
82 : }
83 : }
84 :
85 :
86 : //*********************************************************************
87 : // createKey
88 : //
89 26122 : RegError REGISTRY_CALLTYPE createKey(RegKeyHandle hKey,
90 : rtl_uString* keyName,
91 : RegKeyHandle* phNewKey)
92 : {
93 26122 : *phNewKey = 0;
94 :
95 26122 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
96 26122 : if (!pKey)
97 0 : return REG_INVALID_KEY;
98 :
99 26122 : if (pKey->isDeleted())
100 0 : return REG_INVALID_KEY;
101 :
102 26122 : if (pKey->isReadOnly())
103 0 : return REG_REGISTRY_READONLY;
104 :
105 26122 : return pKey->createKey(keyName, phNewKey);
106 : }
107 :
108 : //*********************************************************************
109 : // openKey
110 : //
111 448744 : RegError REGISTRY_CALLTYPE openKey(RegKeyHandle hKey,
112 : rtl_uString* keyName,
113 : RegKeyHandle* phOpenKey)
114 : {
115 448744 : *phOpenKey = 0;
116 :
117 448744 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
118 448744 : if (!pKey)
119 0 : return REG_INVALID_KEY;
120 :
121 448744 : if (pKey->isDeleted())
122 0 : return REG_INVALID_KEY;
123 :
124 448744 : return pKey->openKey(keyName, phOpenKey);
125 : }
126 :
127 : //*********************************************************************
128 : // openSubKeys
129 : //
130 14773 : RegError REGISTRY_CALLTYPE openSubKeys(RegKeyHandle hKey,
131 : rtl_uString* keyName,
132 : RegKeyHandle** pphSubKeys,
133 : sal_uInt32* pnSubKeys)
134 : {
135 14773 : *pphSubKeys = NULL;
136 14773 : *pnSubKeys = 0;
137 :
138 14773 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
139 14773 : if (!pKey)
140 0 : return REG_INVALID_KEY;
141 :
142 14773 : if (pKey->isDeleted())
143 0 : return REG_INVALID_KEY;
144 :
145 14773 : return pKey->openSubKeys(keyName, pphSubKeys, pnSubKeys);
146 : }
147 :
148 : //*********************************************************************
149 : // closeSubKeys
150 : //
151 456 : RegError REGISTRY_CALLTYPE closeSubKeys(RegKeyHandle* phSubKeys,
152 : sal_uInt32 nSubKeys)
153 : {
154 456 : if (phSubKeys == 0 || nSubKeys == 0)
155 0 : return REG_INVALID_KEY;
156 :
157 456 : ORegistry* pReg = ((ORegKey*)(phSubKeys[0]))->getRegistry();
158 15216 : for (sal_uInt32 i = 0; i < nSubKeys; i++)
159 : {
160 14760 : (void) pReg->closeKey(phSubKeys[i]);
161 : }
162 456 : rtl_freeMemory(phSubKeys);
163 :
164 456 : return REG_NO_ERROR;
165 : }
166 :
167 : //*********************************************************************
168 : // deleteKey
169 : //
170 0 : RegError REGISTRY_CALLTYPE deleteKey(RegKeyHandle hKey,
171 : rtl_uString* keyName)
172 : {
173 0 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
174 0 : if (!pKey)
175 0 : return REG_INVALID_KEY;
176 :
177 0 : if (pKey->isDeleted())
178 0 : return REG_INVALID_KEY;
179 :
180 0 : if (pKey->isReadOnly())
181 0 : return REG_REGISTRY_READONLY;
182 :
183 0 : return pKey->deleteKey(keyName);
184 : }
185 :
186 : //*********************************************************************
187 : // closeKey
188 : //
189 17320 : RegError REGISTRY_CALLTYPE closeKey(RegKeyHandle hKey)
190 : {
191 17320 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
192 17320 : if (!pKey)
193 0 : return REG_INVALID_KEY;
194 :
195 17320 : return pKey->closeKey(hKey);
196 : }
197 :
198 : //*********************************************************************
199 : // setValue
200 : //
201 26122 : RegError REGISTRY_CALLTYPE setValue(RegKeyHandle hKey,
202 : rtl_uString* keyName,
203 : RegValueType valueType,
204 : RegValue pData,
205 : sal_uInt32 valueSize)
206 : {
207 26122 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
208 26122 : if (!pKey)
209 0 : return REG_INVALID_KEY;
210 :
211 26122 : if (pKey->isDeleted())
212 0 : return REG_INVALID_KEY;
213 :
214 26122 : if (pKey->isReadOnly())
215 0 : return REG_REGISTRY_READONLY;
216 :
217 26122 : OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
218 26122 : 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 26122 : 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 0 : RegError REGISTRY_CALLTYPE setStringListValue(RegKeyHandle hKey,
287 : rtl_uString* keyName,
288 : sal_Char** pValueList,
289 : sal_uInt32 len)
290 : {
291 0 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
292 0 : if (!pKey)
293 0 : return REG_INVALID_KEY;
294 :
295 0 : if (pKey->isDeleted())
296 0 : return REG_INVALID_KEY;
297 :
298 0 : if (pKey->isReadOnly())
299 0 : return REG_REGISTRY_READONLY;
300 :
301 0 : OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
302 0 : 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 0 : 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 65850 : RegError REGISTRY_CALLTYPE getValueInfo(RegKeyHandle hKey,
371 : rtl_uString* keyName,
372 : RegValueType* pValueType,
373 : sal_uInt32* pValueSize)
374 : {
375 65850 : *pValueType = RG_VALUETYPE_NOT_DEFINED;
376 65850 : *pValueSize = 0;
377 :
378 65850 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
379 65850 : if (!pKey)
380 0 : return REG_INVALID_KEY;
381 :
382 65850 : if (pKey->isDeleted())
383 0 : return REG_INVALID_KEY;
384 :
385 : RegValueType valueType;
386 : sal_uInt32 valueSize;
387 :
388 65850 : OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
389 65850 : 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 65850 : if (pKey->getValueInfo(valueName, &valueType, &valueSize) != REG_NO_ERROR)
410 : {
411 4 : return REG_INVALID_VALUE;
412 : }
413 :
414 65846 : *pValueType = valueType;
415 65846 : *pValueSize = valueSize;
416 :
417 65846 : return REG_NO_ERROR;
418 : }
419 :
420 : //*********************************************************************
421 : // getValueInfo
422 : //
423 61699 : RegError REGISTRY_CALLTYPE getValue(RegKeyHandle hKey,
424 : rtl_uString* keyName,
425 : RegValue pValue)
426 : {
427 61699 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
428 61699 : if (!pKey)
429 0 : return REG_INVALID_KEY;
430 :
431 61699 : if (pKey->isDeleted())
432 0 : return REG_INVALID_KEY;
433 :
434 61699 : OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
435 61699 : 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 61699 : 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 0 : RegError REGISTRY_CALLTYPE getKeyType(RegKeyHandle hKey,
639 : rtl_uString* keyName,
640 : RegKeyType* pKeyType)
641 : {
642 0 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
643 0 : if (!pKey)
644 0 : return REG_INVALID_KEY;
645 :
646 0 : if (pKey->isDeleted())
647 0 : return REG_INVALID_KEY;
648 :
649 0 : 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 9617 : RegError REGISTRY_CALLTYPE getResolvedKeyName(RegKeyHandle hKey,
666 : rtl_uString* keyName,
667 : SAL_UNUSED_PARAMETER sal_Bool,
668 : rtl_uString** pResolvedName)
669 : {
670 9617 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
671 9617 : if (!pKey)
672 0 : return REG_INVALID_KEY;
673 :
674 9617 : if (pKey->isDeleted())
675 0 : return REG_INVALID_KEY;
676 :
677 9617 : OUString resolvedName;
678 9617 : RegError _ret = pKey->getResolvedKeyName(keyName, resolvedName);
679 9617 : if (_ret == REG_NO_ERROR)
680 9617 : rtl_uString_assign(pResolvedName, resolvedName.pData);
681 9617 : return _ret;
682 : }
683 :
684 : //*********************************************************************
685 : // getKeyNames
686 : //
687 8506 : RegError REGISTRY_CALLTYPE getKeyNames(RegKeyHandle hKey,
688 : rtl_uString* keyName,
689 : rtl_uString*** pSubKeyNames,
690 : sal_uInt32* pnSubKeys)
691 : {
692 8506 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
693 8506 : if (!pKey)
694 0 : return REG_INVALID_KEY;
695 :
696 8506 : if (pKey->isDeleted())
697 0 : return REG_INVALID_KEY;
698 :
699 8506 : return pKey->getKeyNames(keyName, pSubKeyNames, pnSubKeys);
700 : }
701 :
702 : //*********************************************************************
703 : // freeKeyNames
704 : //
705 246 : RegError REGISTRY_CALLTYPE freeKeyNames(rtl_uString** pKeyNames,
706 : sal_uInt32 nKeys)
707 : {
708 8759 : for (sal_uInt32 i=0; i < nKeys; i++)
709 : {
710 8513 : rtl_uString_release(pKeyNames[i]);
711 : }
712 :
713 246 : rtl_freeMemory(pKeyNames);
714 :
715 246 : 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: */
|
