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