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 <registry/registry.h>
22 : #include <registry/registry.hxx>
23 :
24 : #include <osl/process.h>
25 :
26 : #include "keyimpl.hxx"
27 : #include "regimpl.hxx"
28 : #include "regkey.hxx"
29 :
30 : #if defined(WIN32) || defined(WNT)
31 : #include <io.h>
32 : #endif
33 :
34 : #include <string.h>
35 : #if defined(UNX)
36 : #include <stdlib.h>
37 : #include <unistd.h>
38 : #endif
39 :
40 : extern "C" {
41 :
42 :
43 : // acquire
44 :
45 1576 : static void REGISTRY_CALLTYPE acquire(RegHandle hReg)
46 : {
47 1576 : ORegistry* pReg = (ORegistry*) hReg;
48 :
49 1576 : if (pReg != NULL)
50 1576 : pReg->acquire();
51 1576 : }
52 :
53 :
54 :
55 : // release
56 :
57 1564 : static void REGISTRY_CALLTYPE release(RegHandle hReg)
58 : {
59 1564 : ORegistry* pReg = (ORegistry*) hReg;
60 :
61 1564 : if (pReg)
62 : {
63 1564 : if (pReg->release() == 0)
64 : {
65 288 : delete pReg;
66 288 : hReg = NULL;
67 : }
68 : }
69 1564 : }
70 :
71 :
72 :
73 : // getName
74 :
75 0 : static RegError REGISTRY_CALLTYPE getName(RegHandle hReg, rtl_uString** pName)
76 : {
77 : ORegistry* pReg;
78 :
79 0 : if (hReg)
80 : {
81 0 : pReg = (ORegistry*)hReg;
82 0 : if ( pReg->isOpen() )
83 : {
84 0 : rtl_uString_assign(pName, pReg->getName().pData);
85 0 : return REG_NO_ERROR;
86 : } else
87 : {
88 0 : rtl_uString_new(pName);
89 0 : return REG_REGISTRY_NOT_OPEN;
90 : }
91 : }
92 :
93 0 : rtl_uString_new(pName);
94 0 : return REG_INVALID_REGISTRY;
95 : }
96 :
97 :
98 :
99 : // isReadOnly
100 :
101 0 : static sal_Bool REGISTRY_CALLTYPE isReadOnly(RegHandle hReg)
102 : {
103 0 : if (hReg)
104 0 : return ((ORegistry*)hReg)->isReadOnly();
105 : else
106 0 : return sal_False;
107 : }
108 :
109 :
110 :
111 : // createRegistry
112 :
113 296 : static RegError REGISTRY_CALLTYPE createRegistry(rtl_uString* registryName,
114 : RegHandle* phRegistry)
115 : {
116 : RegError ret;
117 :
118 296 : ORegistry* pReg = new ORegistry();
119 296 : if ((ret = pReg->initRegistry(registryName, REG_CREATE)))
120 : {
121 0 : delete pReg;
122 0 : *phRegistry = NULL;
123 0 : return ret;
124 : }
125 :
126 296 : *phRegistry = pReg;
127 :
128 296 : return REG_NO_ERROR;
129 : }
130 :
131 :
132 : // openRootKey
133 :
134 308 : static RegError REGISTRY_CALLTYPE openRootKey(RegHandle hReg,
135 : RegKeyHandle* phRootKey)
136 : {
137 : ORegistry* pReg;
138 :
139 308 : if (hReg)
140 : {
141 308 : pReg = (ORegistry*)hReg;
142 308 : if (!pReg->isOpen())
143 0 : return REG_REGISTRY_NOT_OPEN;
144 : } else
145 : {
146 0 : phRootKey = NULL;
147 0 : return REG_INVALID_REGISTRY;
148 : }
149 :
150 308 : *phRootKey = pReg->getRootKey();
151 :
152 308 : return REG_NO_ERROR;
153 : }
154 :
155 :
156 :
157 : // openRegistry
158 :
159 8 : static RegError REGISTRY_CALLTYPE openRegistry(rtl_uString* registryName,
160 : RegHandle* phRegistry,
161 : RegAccessMode accessMode)
162 : {
163 : RegError _ret;
164 :
165 8 : ORegistry* pReg = new ORegistry();
166 8 : if ((_ret = pReg->initRegistry(registryName, accessMode)))
167 : {
168 8 : *phRegistry = NULL;
169 8 : delete pReg;
170 8 : return _ret;
171 : }
172 :
173 :
174 0 : *phRegistry = pReg;
175 :
176 0 : return REG_NO_ERROR;
177 : }
178 :
179 :
180 : // closeRegistry
181 :
182 292 : static RegError REGISTRY_CALLTYPE closeRegistry(RegHandle hReg)
183 : {
184 : ORegistry *pReg;
185 :
186 292 : if (hReg)
187 : {
188 292 : pReg = (ORegistry*)hReg;
189 292 : if (!pReg->isOpen())
190 0 : return REG_REGISTRY_NOT_OPEN;
191 :
192 292 : RegError ret = REG_NO_ERROR;
193 292 : if (pReg->release() == 0)
194 : {
195 4 : delete(pReg);
196 4 : hReg = NULL;
197 : }
198 : else
199 288 : ret = pReg->closeRegistry();
200 :
201 292 : return ret;
202 : } else
203 : {
204 0 : return REG_INVALID_REGISTRY;
205 : }
206 : }
207 :
208 :
209 :
210 : // destroyRegistry
211 :
212 0 : static RegError REGISTRY_CALLTYPE destroyRegistry(RegHandle hReg,
213 : rtl_uString* registryName)
214 : {
215 : ORegistry *pReg;
216 :
217 0 : if (hReg)
218 : {
219 0 : pReg = (ORegistry*)hReg;
220 0 : if (!pReg->isOpen())
221 0 : return REG_INVALID_REGISTRY;
222 :
223 0 : RegError ret = pReg->destroyRegistry(registryName);
224 0 : if (!ret)
225 : {
226 0 : if (!registryName->length)
227 : {
228 0 : delete(pReg);
229 0 : hReg = NULL;
230 : }
231 : }
232 0 : return ret;
233 : } else
234 : {
235 0 : return REG_INVALID_REGISTRY;
236 : }
237 : }
238 :
239 :
240 :
241 : // loadRegKey
242 :
243 0 : static RegError REGISTRY_CALLTYPE loadKey(RegHandle hReg,
244 : RegKeyHandle hKey,
245 : rtl_uString* keyName,
246 : rtl_uString* regFileName)
247 : {
248 :
249 0 : ORegistry* pReg = static_cast< ORegistry* >(hReg);
250 0 : if (!pReg)
251 0 : return REG_INVALID_REGISTRY;
252 :
253 0 : if (!pReg->isOpen())
254 0 : return REG_REGISTRY_NOT_OPEN;
255 :
256 0 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
257 0 : if (!pKey)
258 0 : return REG_INVALID_KEY;
259 :
260 0 : if (pKey->getRegistry() != pReg)
261 0 : return REG_INVALID_KEY;
262 0 : if (pKey->isDeleted())
263 0 : return REG_INVALID_KEY;
264 0 : if (pKey->isReadOnly())
265 0 : return REG_REGISTRY_READONLY;
266 :
267 :
268 0 : ORegKey* pNewKey = 0;
269 0 : RegError _ret = pKey->openKey(keyName, (RegKeyHandle*)&pNewKey);
270 0 : if (_ret == REG_NO_ERROR)
271 : {
272 0 : pKey->releaseKey(pNewKey);
273 0 : pKey->deleteKey(keyName);
274 : }
275 :
276 0 : _ret = pKey->createKey(keyName, (RegKeyHandle*)&pNewKey);
277 0 : if (_ret != REG_NO_ERROR)
278 0 : return _ret;
279 :
280 0 : _ret = pReg->loadKey(pNewKey, regFileName);
281 0 : if (_ret != REG_NO_ERROR)
282 : {
283 0 : pKey->releaseKey(pNewKey);
284 0 : pKey->deleteKey(keyName);
285 0 : return _ret;
286 : }
287 :
288 0 : return pKey->closeKey(pNewKey);
289 : }
290 :
291 :
292 : // saveKey
293 :
294 0 : static RegError REGISTRY_CALLTYPE saveKey(RegHandle hReg,
295 : RegKeyHandle hKey,
296 : rtl_uString* keyName,
297 : rtl_uString* regFileName)
298 : {
299 :
300 0 : ORegistry* pReg = static_cast< ORegistry* >(hReg);
301 0 : if (!pReg)
302 0 : return REG_INVALID_REGISTRY;
303 :
304 0 : if (!pReg->isOpen())
305 0 : return REG_REGISTRY_NOT_OPEN;
306 :
307 0 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
308 0 : if (!pKey)
309 0 : return REG_INVALID_KEY;
310 :
311 0 : if (pKey->getRegistry() != pReg)
312 0 : return REG_INVALID_KEY;
313 0 : if (pKey->isDeleted())
314 0 : return REG_INVALID_KEY;
315 :
316 0 : ORegKey* pNewKey = 0;
317 0 : RegError _ret = pKey->openKey(keyName, (RegKeyHandle*)&pNewKey);
318 0 : if (_ret != REG_NO_ERROR)
319 0 : return _ret;
320 :
321 0 : _ret = pReg->saveKey(pNewKey, regFileName);
322 0 : if (_ret != REG_NO_ERROR)
323 : {
324 0 : (void) pKey->releaseKey(pNewKey);
325 0 : return _ret;
326 : }
327 :
328 0 : return pKey->releaseKey(pNewKey);
329 : }
330 :
331 :
332 : // mergeKey
333 :
334 0 : static RegError REGISTRY_CALLTYPE mergeKey(RegHandle hReg,
335 : RegKeyHandle hKey,
336 : rtl_uString* keyName,
337 : rtl_uString* regFileName,
338 : sal_Bool bWarnings,
339 : sal_Bool bReport)
340 : {
341 0 : ORegistry* pReg = static_cast< ORegistry* >(hReg);
342 0 : if (!pReg)
343 0 : return REG_INVALID_REGISTRY;
344 0 : if (!pReg->isOpen())
345 0 : return REG_REGISTRY_NOT_OPEN;
346 :
347 0 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
348 0 : if (!pKey)
349 0 : return REG_INVALID_KEY;
350 0 : if (pKey->getRegistry() != pReg)
351 0 : return REG_INVALID_KEY;
352 0 : if (pKey->isDeleted())
353 0 : return REG_INVALID_KEY;
354 0 : if (pKey->isReadOnly())
355 0 : return REG_REGISTRY_READONLY;
356 :
357 0 : if (keyName->length)
358 : {
359 0 : ORegKey* pNewKey = 0;
360 0 : RegError _ret = pKey->createKey(keyName, (RegKeyHandle*)&pNewKey);
361 0 : if (_ret != REG_NO_ERROR)
362 0 : return _ret;
363 :
364 0 : _ret = pReg->loadKey(pNewKey, regFileName, bWarnings, bReport);
365 0 : if (_ret != REG_NO_ERROR && (_ret != REG_MERGE_CONFLICT || bWarnings))
366 : {
367 0 : if (pNewKey != pKey)
368 0 : (void) pKey->closeKey(pNewKey);
369 : else
370 0 : (void) pKey->releaseKey(pNewKey);
371 0 : return _ret;
372 : }
373 :
374 0 : return (pNewKey != pKey) ? pKey->closeKey(pNewKey) : pKey->releaseKey(pNewKey);
375 : }
376 :
377 0 : return pReg->loadKey(pKey, regFileName, bWarnings, bReport);
378 : }
379 :
380 :
381 : // dumpRegistry
382 :
383 0 : static RegError REGISTRY_CALLTYPE dumpRegistry(RegHandle hReg,
384 : RegKeyHandle hKey)
385 : {
386 0 : ORegistry* pReg = static_cast< ORegistry* >(hReg);
387 0 : if (!pReg)
388 0 : return REG_INVALID_REGISTRY;
389 0 : if (!pReg->isOpen())
390 0 : return REG_REGISTRY_NOT_OPEN;
391 :
392 0 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
393 0 : if (!pKey)
394 0 : return REG_INVALID_KEY;
395 0 : if (pKey->getRegistry() != pReg)
396 0 : return REG_INVALID_KEY;
397 0 : if (pKey->isDeleted())
398 0 : return REG_INVALID_KEY;
399 :
400 0 : return pReg->dumpRegistry(hKey);
401 : }
402 :
403 :
404 : // initRegistry_Api
405 :
406 1822 : REG_DLLPUBLIC Registry_Api* REGISTRY_CALLTYPE initRegistry_Api(void)
407 : {
408 : static Registry_Api aApi= {&acquire,
409 : &release,
410 : &isReadOnly,
411 : &openRootKey,
412 : &getName,
413 : &createRegistry,
414 : &openRegistry,
415 : &closeRegistry,
416 : &destroyRegistry,
417 : &loadKey,
418 : &saveKey,
419 : &mergeKey,
420 : &dumpRegistry,
421 : &acquireKey,
422 : &releaseKey,
423 : &isKeyReadOnly,
424 : &getKeyName,
425 : &createKey,
426 : &openKey,
427 : &openSubKeys,
428 : &closeSubKeys,
429 : &deleteKey,
430 : &closeKey,
431 : &setValue,
432 : &setLongListValue,
433 : &setStringListValue,
434 : &setUnicodeListValue,
435 : &getValueInfo,
436 : &getValue,
437 : &getLongListValue,
438 : &getStringListValue,
439 : &getUnicodeListValue,
440 : &freeValueList,
441 : &createLink,
442 : &deleteLink,
443 : &getKeyType,
444 : &getLinkTarget,
445 : &getResolvedKeyName,
446 : &getKeyNames,
447 : &freeKeyNames};
448 :
449 1822 : return (&aApi);
450 : }
451 :
452 : }
453 :
454 :
455 : // reg_loadRegKey
456 :
457 0 : REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_loadKey(RegKeyHandle hKey,
458 : rtl_uString* keyName,
459 : rtl_uString* regFileName)
460 : {
461 : ORegKey *pKey;
462 :
463 0 : if (hKey)
464 0 : pKey = (ORegKey*)hKey;
465 : else
466 0 : return REG_INVALID_KEY;
467 :
468 0 : return loadKey(pKey->getRegistry(), hKey, keyName, regFileName);
469 : }
470 :
471 :
472 : // reg_saveKey
473 :
474 0 : REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_saveKey(RegKeyHandle hKey,
475 : rtl_uString* keyName,
476 : rtl_uString* regFileName)
477 : {
478 : ORegKey *pKey;
479 :
480 0 : if (hKey)
481 0 : pKey = (ORegKey*)hKey;
482 : else
483 0 : return REG_INVALID_KEY;
484 :
485 0 : return saveKey(pKey->getRegistry(), hKey, keyName, regFileName);
486 : }
487 :
488 :
489 : // reg_mergeKey
490 :
491 0 : REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_mergeKey(RegKeyHandle hKey,
492 : rtl_uString* keyName,
493 : rtl_uString* regFileName,
494 : sal_Bool bWarnings,
495 : sal_Bool bReport)
496 : {
497 : ORegKey *pKey;
498 :
499 0 : if (hKey)
500 0 : pKey = (ORegKey*)hKey;
501 : else
502 0 : return REG_INVALID_KEY;
503 :
504 0 : return mergeKey(pKey->getRegistry(), hKey, keyName, regFileName, bWarnings, bReport);
505 : }
506 :
507 :
508 : // reg_createRegistry
509 :
510 0 : REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_createRegistry(rtl_uString* registryName,
511 : RegHandle* phRegistry)
512 : {
513 : RegError ret;
514 :
515 0 : ORegistry* pReg = new ORegistry();
516 0 : if ((ret = pReg->initRegistry(registryName, REG_CREATE)))
517 : {
518 0 : delete pReg;
519 0 : *phRegistry = NULL;
520 0 : return ret;
521 : }
522 :
523 0 : *phRegistry = pReg;
524 :
525 0 : return REG_NO_ERROR;
526 : }
527 :
528 :
529 : // reg_openRootKey
530 :
531 0 : REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_openRootKey(RegHandle hRegistry,
532 : RegKeyHandle* phRootKey)
533 : {
534 0 : return openRootKey(hRegistry, phRootKey);
535 : }
536 :
537 :
538 :
539 : // reg_getName
540 :
541 0 : REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_getName(RegHandle hRegistry, rtl_uString** pName)
542 : {
543 0 : return getName(hRegistry, pName);
544 : }
545 :
546 :
547 :
548 : // reg_isReadOnly
549 :
550 0 : REG_DLLPUBLIC sal_Bool REGISTRY_CALLTYPE reg_isReadOnly(RegHandle hRegistry)
551 : {
552 0 : return isReadOnly(hRegistry);
553 : }
554 :
555 :
556 :
557 : // reg_openRegistry
558 :
559 0 : REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_openRegistry(rtl_uString* registryName,
560 : RegHandle* phRegistry,
561 : RegAccessMode accessMode)
562 : {
563 : RegError _ret;
564 :
565 0 : ORegistry* pReg = new ORegistry();
566 0 : if ((_ret = pReg->initRegistry(registryName, accessMode)))
567 : {
568 0 : delete pReg;
569 0 : *phRegistry = NULL;
570 0 : return _ret;
571 : }
572 :
573 0 : *phRegistry = pReg;
574 :
575 0 : return REG_NO_ERROR;
576 : }
577 :
578 :
579 : // reg_closeRegistry
580 :
581 0 : REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_closeRegistry(RegHandle hRegistry)
582 : {
583 : ORegistry* pReg;
584 :
585 0 : if (hRegistry)
586 : {
587 0 : pReg = (ORegistry*)hRegistry;
588 0 : delete(pReg);
589 0 : return REG_NO_ERROR;
590 : } else
591 : {
592 0 : return REG_REGISTRY_NOT_OPEN;
593 : }
594 : }
595 :
596 :
597 :
598 : // reg_destroyRegistry
599 :
600 0 : REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_destroyRegistry(RegHandle hRegistry,
601 : rtl_uString* registryName)
602 : {
603 0 : return destroyRegistry(hRegistry, registryName);
604 : }
605 :
606 :
607 :
608 : // reg_dumpRegistry
609 :
610 0 : REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_dumpRegistry(RegKeyHandle hKey)
611 : {
612 : ORegKey *pKey;
613 :
614 0 : if (hKey)
615 0 : pKey = (ORegKey*)hKey;
616 : else
617 0 : return REG_INVALID_KEY;
618 :
619 0 : return dumpRegistry(pKey->getRegistry(), hKey);
620 : }
621 :
622 :
623 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
