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