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