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