?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Branch libreoffice-5-0-4
[LibreOffice.git] / registry / source / regimpl.cxx
blob6af272039128c2e145516432bce47b264f2aed70
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 "regimpl.hxx"
22
23 #include <memory>
24 #include <string.h>
25 #include <stdio.h>
26
27 #if defined(UNX)
28 #include <unistd.h>
29 #endif
30 #ifdef __MINGW32__
31 #include <unistd.h>
32 #endif
33
34 #include <registry/reflread.hxx>
35
36 #include <registry/reflwrit.hxx>
37
38 #include "registry/reader.hxx"
39 #include "registry/refltype.hxx"
40 #include "registry/types.hxx"
41 #include "registry/version.h"
42
43 #include "reflcnst.hxx"
44 #include "keyimpl.hxx"
45
46 #include <osl/thread.h>
47 #include <rtl/alloc.h>
48 #include <rtl/ustring.hxx>
49 #include <rtl/ustrbuf.hxx>
50 #include <osl/file.hxx>
51
52 using namespace osl;
53 using namespace store;
54
55
56 namespace {
57
58 void printString(OUString const & s) {
59 printf("\"");
60 for (sal_Int32 i = 0; i < s.getLength(); ++i) {
61 sal_Unicode c = s[i];
62 if (c == '"' || c == '\\') {
63 printf("\\%c", static_cast< char >(c));
64 } else if (s[i] >= ' ' && s[i] <= '~') {
65 printf("%c", static_cast< char >(c));
66 } else {
67 printf("\\u%04X", static_cast< unsigned int >(c));
68 }
69 }
70 printf("\"");
71 }
72
73 void printFieldOrReferenceFlag(
74 RTFieldAccess * flags, RTFieldAccess flag, char const * name, bool * first)
75 {
76 if ((*flags & flag) != RTFieldAccess::NONE) {
77 if (!*first) {
78 printf("|");
79 }
80 *first = false;
81 printf("%s", name);
82 *flags &= ~flag;
83 }
84 }
85
86 void printFieldOrReferenceFlags(RTFieldAccess flags) {
87 if (flags == RTFieldAccess::NONE) {
88 printf("none");
89 } else {
90 bool first = true;
91 printFieldOrReferenceFlag(
92 &flags, RTFieldAccess::READONLY, "readonly", &first);
93 printFieldOrReferenceFlag(
94 &flags, RTFieldAccess::OPTIONAL, "optional", &first);
95 printFieldOrReferenceFlag(
96 &flags, RTFieldAccess::MAYBEVOID, "maybevoid", &first);
97 printFieldOrReferenceFlag(&flags, RTFieldAccess::BOUND, "bound", &first);
98 printFieldOrReferenceFlag(
99 &flags, RTFieldAccess::CONSTRAINED, "constrained", &first);
100 printFieldOrReferenceFlag(
101 &flags, RTFieldAccess::TRANSIENT, "transient", &first);
102 printFieldOrReferenceFlag(
103 &flags, RTFieldAccess::MAYBEAMBIGUOUS, "maybeambiguous", &first);
104 printFieldOrReferenceFlag(
105 &flags, RTFieldAccess::MAYBEDEFAULT, "maybedefault", &first);
106 printFieldOrReferenceFlag(
107 &flags, RTFieldAccess::REMOVABLE, "removable", &first);
108 printFieldOrReferenceFlag(
109 &flags, RTFieldAccess::ATTRIBUTE, "attribute", &first);
110 printFieldOrReferenceFlag(
111 &flags, RTFieldAccess::PROPERTY, "property", &first);
112 printFieldOrReferenceFlag(&flags, RTFieldAccess::CONST, "const", &first);
113 printFieldOrReferenceFlag(
114 &flags, RTFieldAccess::READWRITE, "readwrite", &first);
115 printFieldOrReferenceFlag(
116 &flags, RTFieldAccess::PARAMETERIZED_TYPE, "parameterized type", &first);
117 printFieldOrReferenceFlag(
118 &flags, RTFieldAccess::PUBLISHED, "published", &first);
119 if (flags != RTFieldAccess::NONE) {
120 if (!first) {
121 printf("|");
122 }
123 printf("<invalid (0x%04X)>", static_cast< unsigned int >(flags));
124 }
125 }
126 }
127
128 void dumpType(typereg::Reader const & reader, OString const & indent) {
129 if (reader.isValid()) {
130 printf("version: %ld\n", static_cast< long >(reader.getVersion()));
131 printf("%sdocumentation: ", indent.getStr());
132 printString(reader.getDocumentation());
133 printf("\n");
134 printf("%sfile name: ", indent.getStr());
135 printString(reader.getFileName());
136 printf("\n");
137 printf("%stype class: ", indent.getStr());
138 if (reader.isPublished()) {
139 printf("published ");
140 }
141 switch (reader.getTypeClass()) {
142 case RT_TYPE_INTERFACE:
143 printf("interface");
144 break;
145
146 case RT_TYPE_MODULE:
147 printf("module");
148 break;
149
150 case RT_TYPE_STRUCT:
151 printf("struct");
152 break;
153
154 case RT_TYPE_ENUM:
155 printf("enum");
156 break;
157
158 case RT_TYPE_EXCEPTION:
159 printf("exception");
160 break;
161
162 case RT_TYPE_TYPEDEF:
163 printf("typedef");
164 break;
165
166 case RT_TYPE_SERVICE:
167 printf("service");
168 break;
169
170 case RT_TYPE_SINGLETON:
171 printf("singleton");
172 break;
173
174 case RT_TYPE_CONSTANTS:
175 printf("constants");
176 break;
177
178 default:
179 printf(
180 "<invalid (%ld)>", static_cast< long >(reader.getTypeClass()));
181 break;
182 }
183 printf("\n");
184 printf("%stype name: ", indent.getStr());
185 printString(reader.getTypeName());
186 printf("\n");
187 printf(
188 "%ssuper type count: %u\n", indent.getStr(),
189 static_cast< unsigned int >(reader.getSuperTypeCount()));
190 for (sal_uInt16 i = 0; i < reader.getSuperTypeCount(); ++i) {
191 printf(
192 "%ssuper type name %u: ", indent.getStr(),
193 static_cast< unsigned int >(i));
194 printString(reader.getSuperTypeName(i));
195 printf("\n");
196 }
197 printf(
198 "%sfield count: %u\n", indent.getStr(),
199 static_cast< unsigned int >(reader.getFieldCount()));
200 for (sal_uInt16 i = 0; i < reader.getFieldCount(); ++i) {
201 printf(
202 "%sfield %u:\n", indent.getStr(),
203 static_cast< unsigned int >(i));
204 printf("%s documentation: ", indent.getStr());
205 printString(reader.getFieldDocumentation(i));
206 printf("\n");
207 printf("%s file name: ", indent.getStr());
208 printString(reader.getFieldFileName(i));
209 printf("\n");
210 printf("%s flags: ", indent.getStr());
211 printFieldOrReferenceFlags(reader.getFieldFlags(i));
212 printf("\n");
213 printf("%s name: ", indent.getStr());
214 printString(reader.getFieldName(i));
215 printf("\n");
216 printf("%s type name: ", indent.getStr());
217 printString(reader.getFieldTypeName(i));
218 printf("\n");
219 printf("%s value: ", indent.getStr());
220 RTConstValue value(reader.getFieldValue(i));
221 switch (value.m_type) {
222 case RT_TYPE_NONE:
223 printf("none");
224 break;
225
226 case RT_TYPE_BOOL:
227 printf("boolean %s", value.m_value.aBool ? "true" : "false");
228 break;
229
230 case RT_TYPE_BYTE:
231 printf("byte %d", static_cast< int >(value.m_value.aByte));
232 break;
233
234 case RT_TYPE_INT16:
235 printf("short %d", static_cast< int >(value.m_value.aShort));
236 break;
237
238 case RT_TYPE_UINT16:
239 printf(
240 "unsigned short %u",
241 static_cast< unsigned int >(value.m_value.aUShort));
242 break;
243
244 case RT_TYPE_INT32:
245 printf("long %ld", static_cast< long >(value.m_value.aLong));
246 break;
247
248 case RT_TYPE_UINT32:
249 printf(
250 "unsigned long %lu",
251 static_cast< unsigned long >(value.m_value.aULong));
252 break;
253
254 case RT_TYPE_INT64:
255 // TODO: no portable way to print hyper values
256 printf("hyper");
257 break;
258
259 case RT_TYPE_UINT64:
260 // TODO: no portable way to print unsigned hyper values
261 printf("unsigned hyper");
262 break;
263
264 case RT_TYPE_FLOAT:
265 // TODO: no portable way to print float values
266 printf("float");
267 break;
268
269 case RT_TYPE_DOUBLE:
270 // TODO: no portable way to print double values
271 printf("double");
272 break;
273
274 case RT_TYPE_STRING:
275 printf("string ");
276 printString(value.m_value.aString);
277 break;
278
279 default:
280 printf("<invalid (%ld)>", static_cast< long >(value.m_type));
281 break;
282 }
283 printf("\n");
284 }
285 printf(
286 "%smethod count: %u\n", indent.getStr(),
287 static_cast< unsigned int >(reader.getMethodCount()));
288 for (sal_uInt16 i = 0; i < reader.getMethodCount(); ++i) {
289 printf(
290 "%smethod %u:\n", indent.getStr(),
291 static_cast< unsigned int >(i));
292 printf("%s documentation: ", indent.getStr());
293 printString(reader.getMethodDocumentation(i));
294 printf("\n");
295 printf("%s flags: ", indent.getStr());
296 switch (reader.getMethodFlags(i)) {
297 case RTMethodMode::ONEWAY:
298 printf("oneway");
299 break;
300
301 case RTMethodMode::TWOWAY:
302 printf("synchronous");
303 break;
304
305 case RTMethodMode::ATTRIBUTE_GET:
306 printf("attribute get");
307 break;
308
309 case RTMethodMode::ATTRIBUTE_SET:
310 printf("attribute set");
311 break;
312
313 default:
314 printf(
315 "<invalid (%ld)>",
316 static_cast< long >(reader.getMethodFlags(i)));
317 break;
318 }
319 printf("\n");
320 printf("%s name: ", indent.getStr());
321 printString(reader.getMethodName(i));
322 printf("\n");
323 printf("%s return type name: ", indent.getStr());
324 printString(reader.getMethodReturnTypeName(i));
325 printf("\n");
326 printf(
327 "%s parameter count: %u\n", indent.getStr(),
328 static_cast< unsigned int >(reader.getMethodParameterCount(i)));
329 // coverity[tainted_data] cid#1215304 unhelpfully warns about an
330 // untrusted loop bound here:
331 for (sal_uInt16 j = 0; j < reader.getMethodParameterCount(i); ++j)
332 {
333 printf(
334 "%s parameter %u:\n", indent.getStr(),
335 static_cast< unsigned int >(j));
336 printf("%s flags: ", indent.getStr());
337 RTParamMode flags = reader.getMethodParameterFlags(i, j);
338 bool rest = (flags & RT_PARAM_REST) != 0;
339 switch (flags & ~RT_PARAM_REST) {
340 case RT_PARAM_IN:
341 printf("in");
342 break;
343
344 case RT_PARAM_OUT:
345 printf("out");
346 break;
347
348 case RT_PARAM_INOUT:
349 printf("inout");
350 break;
351
352 default:
353 printf("<invalid (%ld)>", static_cast< long >(flags));
354 rest = false;
355 break;
356 }
357 if (rest) {
358 printf("|rest");
359 }
360 printf("\n");
361 printf("%s name: ", indent.getStr());
362 printString(reader.getMethodParameterName(i, j));
363 printf("\n");
364 printf("%s type name: ", indent.getStr());
365 printString(reader.getMethodParameterTypeName(i, j));
366 printf("\n");
367 }
368 printf(
369 "%s exception count: %u\n", indent.getStr(),
370 static_cast< unsigned int >(reader.getMethodExceptionCount(i)));
371 // coverity[tainted_data] cid#1215304 unhelpfully warns about an
372 // untrusted loop bound here:
373 for (sal_uInt16 j = 0; j < reader.getMethodExceptionCount(i); ++j)
374 {
375 printf(
376 "%s exception type name %u: ", indent.getStr(),
377 static_cast< unsigned int >(j));
378 printString(reader.getMethodExceptionTypeName(i, j));
379 printf("\n");
380 }
381 }
382 printf(
383 "%sreference count: %u\n", indent.getStr(),
384 static_cast< unsigned int >(reader.getReferenceCount()));
385 for (sal_uInt16 i = 0; i < reader.getReferenceCount(); ++i) {
386 printf(
387 "%sreference %u:\n", indent.getStr(),
388 static_cast< unsigned int >(i));
389 printf("%s documentation: ", indent.getStr());
390 printString(reader.getReferenceDocumentation(i));
391 printf("\n");
392 printf("%s flags: ", indent.getStr());
393 printFieldOrReferenceFlags(reader.getReferenceFlags(i));
394 printf("\n");
395 printf("%s sort: ", indent.getStr());
396 switch (reader.getReferenceSort(i)) {
397 case RTReferenceType::SUPPORTS:
398 printf("supports");
399 break;
400
401 case RTReferenceType::EXPORTS:
402 printf("exports");
403 break;
404
405 case RTReferenceType::TYPE_PARAMETER:
406 printf("type parameter");
407 break;
408
409 default:
410 printf(
411 "<invalid (%ld)>",
412 static_cast< long >(reader.getReferenceSort(i)));
413 break;
414 }
415 printf("\n");
416 printf("%s type name: ", indent.getStr());
417 printString(reader.getReferenceTypeName(i));
418 printf("\n");
419 }
420 } else {
421 printf("<invalid>\n");
422 }
423 }
424
425 }
426
427
428 // ORegistry()
429
430 ORegistry::ORegistry()
431 : m_refCount(1)
432 , m_readOnly(false)
433 , m_isOpen(false)
434 , ROOT( "/" )
435 {
436 }
437
438
439 // ~ORegistry()
440
441 ORegistry::~ORegistry()
442 {
443 ORegKey* pRootKey = m_openKeyTable[ROOT];
444 if (pRootKey != 0)
445 (void) releaseKey(pRootKey);
446
447 if (m_file.isValid())
448 m_file.close();
449 }
450
451
452
453 // initRegistry
454
455 RegError ORegistry::initRegistry(const OUString& regName, RegAccessMode accessMode, bool bCreate)
456 {
457 RegError eRet = RegError::INVALID_REGISTRY;
458 OStoreFile rRegFile;
459 storeAccessMode sAccessMode = REG_MODE_OPEN;
460 storeError errCode;
461
462 if (bCreate)
463 {
464 sAccessMode = REG_MODE_CREATE;
465 }
466 else if (accessMode & RegAccessMode::READONLY)
467 {
468 sAccessMode = REG_MODE_OPENREAD;
469 m_readOnly = true;
470 }
471
472 if (regName.isEmpty() &&
473 store_AccessCreate == sAccessMode)
474 {
475 errCode = rRegFile.createInMemory();
476 }
477 else
478 {
479 errCode = rRegFile.create(regName, sAccessMode, REG_PAGESIZE);
480 }
481
482 if (errCode)
483 {
484 switch (errCode)
485 {
486 case store_E_NotExists:
487 eRet = RegError::REGISTRY_NOT_EXISTS;
488 break;
489 case store_E_LockingViolation:
490 eRet = RegError::CANNOT_OPEN_FOR_READWRITE;
491 break;
492 default:
493 eRet = RegError::INVALID_REGISTRY;
494 break;
495 }
496 }
497 else
498 {
499 OStoreDirectory rStoreDir;
500 storeError _err = rStoreDir.create(rRegFile, OUString(), OUString(), sAccessMode);
501
502 if ( _err == store_E_None )
503 {
504 m_file = rRegFile;
505 m_name = regName;
506 m_isOpen = true;
507
508 m_openKeyTable[ROOT] = new ORegKey(ROOT, this);
509 eRet = RegError::NO_ERROR;
510 }
511 else
512 eRet = RegError::INVALID_REGISTRY;
513 }
514
515 return eRet;
516 }
517
518
519
520 // closeRegistry
521
522 RegError ORegistry::closeRegistry()
523 {
524 REG_GUARD(m_mutex);
525
526 if (m_file.isValid())
527 {
528 (void) releaseKey(m_openKeyTable[ROOT]);
529 m_file.close();
530 m_isOpen = false;
531 return RegError::NO_ERROR;
532 } else
533 {
534 return RegError::REGISTRY_NOT_EXISTS;
535 }
536 }
537
538
539
540 // destroyRegistry
541
542 RegError ORegistry::destroyRegistry(const OUString& regName)
543 {
544 REG_GUARD(m_mutex);
545
546 if (!regName.isEmpty())
547 {
548 std::unique_ptr<ORegistry> pReg(new ORegistry());
549
550 if (pReg->initRegistry(regName, RegAccessMode::READWRITE) == RegError::NO_ERROR)
551 {
552 pReg.reset();
553
554 OUString systemName;
555 if ( FileBase::getSystemPathFromFileURL(regName, systemName) != FileBase::E_None )
556 systemName = regName;
557
558 OString name( OUStringToOString(systemName, osl_getThreadTextEncoding()) );
559 if (unlink(name.getStr()) != 0)
560 {
561 return RegError::DESTROY_REGISTRY_FAILED;
562 }
563 } else
564 {
565 return RegError::DESTROY_REGISTRY_FAILED;
566 }
567 } else
568 {
569 if (m_refCount != 1 || isReadOnly())
570 {
571 return RegError::DESTROY_REGISTRY_FAILED;
572 }
573
574 if (m_file.isValid())
575 {
576 releaseKey(m_openKeyTable[ROOT]);
577 m_file.close();
578 m_isOpen = false;
579
580 if (!m_name.isEmpty())
581 {
582 OUString systemName;
583 if ( FileBase::getSystemPathFromFileURL(m_name, systemName) != FileBase::E_None )
584 systemName = m_name;
585
586 OString name( OUStringToOString(systemName, osl_getThreadTextEncoding()) );
587 if (unlink(name.getStr()) != 0)
588 {
589 return RegError::DESTROY_REGISTRY_FAILED;
590 }
591 }
592 } else
593 {
594 return RegError::REGISTRY_NOT_EXISTS;
595 }
596 }
597
598 return RegError::NO_ERROR;
599 }
600
601
602 // acquireKey
603
604 RegError ORegistry::acquireKey (RegKeyHandle hKey)
605 {
606 ORegKey* pKey = static_cast< ORegKey* >(hKey);
607 if (!pKey)
608 return RegError::INVALID_KEY;
609
610 REG_GUARD(m_mutex);
611 pKey->acquire();
612
613 return RegError::NO_ERROR;
614 }
615
616
617 // releaseKey
618
619 RegError ORegistry::releaseKey (RegKeyHandle hKey)
620 {
621 ORegKey* pKey = static_cast< ORegKey* >(hKey);
622 if (!pKey)
623 return RegError::INVALID_KEY;
624
625 REG_GUARD(m_mutex);
626 if (pKey->release() == 0)
627 {
628 m_openKeyTable.erase(pKey->getName());
629 delete pKey;
630 }
631 return RegError::NO_ERROR;
632 }
633
634
635 // createKey
636
637 RegError ORegistry::createKey(RegKeyHandle hKey, const OUString& keyName,
638 RegKeyHandle* phNewKey)
639 {
640 ORegKey* pKey;
641
642 *phNewKey = NULL;
643
644 if ( keyName.isEmpty() )
645 return RegError::INVALID_KEYNAME;
646
647 REG_GUARD(m_mutex);
648
649 if (hKey)
650 pKey = static_cast<ORegKey*>(hKey);
651 else
652 pKey = m_openKeyTable[ROOT];
653
654 OUString sFullKeyName = pKey->getFullPath(keyName);
655
656 if (m_openKeyTable.count(sFullKeyName) > 0)
657 {
658 *phNewKey = m_openKeyTable[sFullKeyName];
659 static_cast<ORegKey*>(*phNewKey)->acquire();
660 static_cast<ORegKey*>(*phNewKey)->setDeleted(false);
661 return RegError::NO_ERROR;
662 }
663
664 OStoreDirectory rStoreDir;
665 OUStringBuffer sFullPath(sFullKeyName.getLength());
666 OUString token;
667
668 sFullPath.append('/');
669
670 sal_Int32 nIndex = 0;
671 do
672 {
673 token = sFullKeyName.getToken( 0, '/', nIndex );
674 if (!token.isEmpty())
675 {
676 if (rStoreDir.create(pKey->getStoreFile(), sFullPath.getStr(), token, KEY_MODE_CREATE))
677 {
678 return RegError::CREATE_KEY_FAILED;
679 }
680
681 sFullPath.append(token);
682 sFullPath.append('/');
683 }
684 } while( nIndex != -1 );
685
686
687 pKey = new ORegKey(sFullKeyName, this);
688 *phNewKey = pKey;
689 m_openKeyTable[sFullKeyName] = pKey;
690
691 return RegError::NO_ERROR;
692 }
693
694
695
696 // openKey
697
698 RegError ORegistry::openKey(RegKeyHandle hKey, const OUString& keyName,
699 RegKeyHandle* phOpenKey)
700 {
701 ORegKey* pKey;
702
703 *phOpenKey = NULL;
704
705 if ( keyName.isEmpty() )
706 {
707 return RegError::INVALID_KEYNAME;
708 }
709
710 REG_GUARD(m_mutex);
711
712 if (hKey)
713 pKey = static_cast<ORegKey*>(hKey);
714 else
715 pKey = m_openKeyTable[ROOT];
716
717 OUString path(pKey->getFullPath(keyName));
718 KeyMap::iterator i(m_openKeyTable.find(path));
719 if (i == m_openKeyTable.end()) {
720 sal_Int32 n = path.lastIndexOf('/') + 1;
721 switch (OStoreDirectory().create(
722 pKey->getStoreFile(), path.copy(0, n), path.copy(n),
723 isReadOnly() ? KEY_MODE_OPENREAD : KEY_MODE_OPEN))
724 {
725 case store_E_NotExists:
726 return RegError::KEY_NOT_EXISTS;
727 case store_E_WrongFormat:
728 return RegError::INVALID_KEY;
729 default:
730 break;
731 }
732
733 std::unique_ptr< ORegKey > p(new ORegKey(path, this));
734 i = m_openKeyTable.insert(std::make_pair(path, p.get())).first;
735 p.release();
736 } else {
737 i->second->acquire();
738 }
739 *phOpenKey = i->second;
740 return RegError::NO_ERROR;
741 }
742
743
744
745 // closeKey
746
747 RegError ORegistry::closeKey(RegKeyHandle hKey)
748 {
749 ORegKey* pKey = static_cast< ORegKey* >(hKey);
750
751 REG_GUARD(m_mutex);
752
753 OUString const aKeyName (pKey->getName());
754 if (!(m_openKeyTable.count(aKeyName) > 0))
755 return RegError::KEY_NOT_OPEN;
756
757 if (pKey->isModified())
758 {
759 ORegKey * pRootKey = getRootKey();
760 if (pKey != pRootKey)
761 {
762 // propagate "modified" state to RootKey.
763 pRootKey->setModified();
764 }
765 else
766 {
767 // closing modified RootKey, flush registry file.
768 OSL_TRACE("registry::ORegistry::closeKey(): flushing modified RootKey");
769 (void) m_file.flush();
770 }
771 pKey->setModified(false);
772 (void) releaseKey(pRootKey);
773 }
774
775 return releaseKey(pKey);
776 }
777
778
779 // deleteKey
780
781 RegError ORegistry::deleteKey(RegKeyHandle hKey, const OUString& keyName)
782 {
783 ORegKey* pKey = static_cast< ORegKey* >(hKey);
784 if ( keyName.isEmpty() )
785 return RegError::INVALID_KEYNAME;
786
787 REG_GUARD(m_mutex);
788
789 if (!pKey)
790 pKey = m_openKeyTable[ROOT];
791
792 OUString sFullKeyName(pKey->getFullPath(keyName));
793 return eraseKey(m_openKeyTable[ROOT], sFullKeyName);
794 }
795
796 RegError ORegistry::eraseKey(ORegKey* pKey, const OUString& keyName)
797 {
798 RegError _ret = RegError::NO_ERROR;
799
800 if ( keyName.isEmpty() )
801 {
802 return RegError::INVALID_KEYNAME;
803 }
804
805 OUString sFullKeyName(pKey->getName());
806 OUString sFullPath(sFullKeyName);
807 OUString sRelativKey;
808 sal_Int32 lastIndex = keyName.lastIndexOf('/');
809
810 if ( lastIndex >= 0 )
811 {
812 sRelativKey += keyName.copy(lastIndex + 1);
813
814 if (sFullKeyName.getLength() > 1)
815 sFullKeyName += keyName;
816 else
817 sFullKeyName += keyName.copy(1);
818
819 sFullPath = sFullKeyName.copy(0, keyName.lastIndexOf('/') + 1);
820 } else
821 {
822 if (sFullKeyName.getLength() > 1)
823 sFullKeyName += ROOT;
824
825 sRelativKey += keyName;
826 sFullKeyName += keyName;
827
828 if (sFullPath.getLength() > 1)
829 sFullPath += ROOT;
830 }
831
832 ORegKey* pOldKey = 0;
833 _ret = pKey->openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pOldKey));
834 if (_ret != RegError::NO_ERROR)
835 return _ret;
836
837 _ret = deleteSubkeysAndValues(pOldKey);
838 if (_ret != RegError::NO_ERROR)
839 {
840 pKey->closeKey(pOldKey);
841 return _ret;
842 }
843
844 OUString tmpName(sRelativKey);
845 tmpName += ROOT;
846
847 OStoreFile sFile(pKey->getStoreFile());
848 if ( sFile.isValid() && sFile.remove(sFullPath, tmpName) )
849 {
850 return RegError::DELETE_KEY_FAILED;
851 }
852 pOldKey->setModified();
853
854 // set flag deleted !!!
855 pOldKey->setDeleted(true);
856
857 return pKey->closeKey(pOldKey);
858 }
859
860
861 // deleteSubKeysAndValues
862
863 RegError ORegistry::deleteSubkeysAndValues(ORegKey* pKey)
864 {
865 OStoreDirectory::iterator iter;
866 RegError _ret = RegError::NO_ERROR;
867 OStoreDirectory rStoreDir(pKey->getStoreDir());
868 storeError _err = rStoreDir.first(iter);
869
870 while ( _err == store_E_None )
871 {
872 OUString const keyName = iter.m_pszName;
873
874 if (iter.m_nAttrib & STORE_ATTRIB_ISDIR)
875 {
876 _ret = eraseKey(pKey, keyName);
877 if (_ret != RegError::NO_ERROR)
878 return _ret;
879 }
880 else
881 {
882 OUString sFullPath(pKey->getName());
883
884 if (sFullPath.getLength() > 1)
885 sFullPath += ROOT;
886
887 if ( ((OStoreFile&)pKey->getStoreFile()).remove(sFullPath, keyName) )
888 {
889 return RegError::DELETE_VALUE_FAILED;
890 }
891 pKey->setModified();
892 }
893
894 _err = rStoreDir.next(iter);
895 }
896
897 return RegError::NO_ERROR;
898 }
899
900
901
902 // loadKey
903
904 RegError ORegistry::loadKey(RegKeyHandle hKey, const OUString& regFileName,
905 bool bWarnings, bool bReport)
906 {
907 RegError _ret = RegError::NO_ERROR;
908 ORegKey* pKey = static_cast< ORegKey* >(hKey);
909
910 std::unique_ptr< ORegistry > pReg (new ORegistry());
911 _ret = pReg->initRegistry(regFileName, RegAccessMode::READONLY);
912 if (_ret != RegError::NO_ERROR)
913 return _ret;
914 ORegKey* pRootKey = pReg->getRootKey();
915
916 REG_GUARD(m_mutex);
917
918 OStoreDirectory::iterator iter;
919 OStoreDirectory rStoreDir(pRootKey->getStoreDir());
920 storeError _err = rStoreDir.first(iter);
921
922 while ( _err == store_E_None )
923 {
924 OUString const keyName = iter.m_pszName;
925
926 if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR )
927 {
928 _ret = loadAndSaveKeys(pKey, pRootKey, keyName, 0, bWarnings, bReport);
929 }
930 else
931 {
932 _ret = loadAndSaveValue(pKey, pRootKey, keyName, 0, bWarnings, bReport);
933 }
934
935 if (_ret == RegError::MERGE_ERROR)
936 break;
937 if (_ret == RegError::MERGE_CONFLICT && bWarnings)
938 break;
939
940 _err = rStoreDir.next(iter);
941 }
942
943 rStoreDir = OStoreDirectory();
944 (void) pReg->releaseKey(pRootKey);
945 return _ret;
946 }
947
948
949
950 // saveKey
951
952 RegError ORegistry::saveKey(RegKeyHandle hKey, const OUString& regFileName,
953 bool bWarnings, bool bReport)
954 {
955 RegError _ret = RegError::NO_ERROR;
956 ORegKey* pKey = static_cast< ORegKey* >(hKey);
957
958 std::unique_ptr< ORegistry > pReg (new ORegistry());
959 _ret = pReg->initRegistry(regFileName, RegAccessMode::READWRITE, true/*bCreate*/);
960 if (_ret != RegError::NO_ERROR)
961 return _ret;
962 ORegKey* pRootKey = pReg->getRootKey();
963
964 REG_GUARD(m_mutex);
965
966 OStoreDirectory::iterator iter;
967 OStoreDirectory rStoreDir(pKey->getStoreDir());
968 storeError _err = rStoreDir.first(iter);
969
970 while ( _err == store_E_None )
971 {
972 OUString const keyName = iter.m_pszName;
973
974 if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR )
975 {
976 _ret = loadAndSaveKeys(pRootKey, pKey, keyName,
977 pKey->getName().getLength(),
978 bWarnings, bReport);
979 }
980 else
981 {
982 _ret = loadAndSaveValue(pRootKey, pKey, keyName,
983 pKey->getName().getLength(),
984 bWarnings, bReport);
985 }
986
987 if (_ret != RegError::NO_ERROR)
988 break;
989
990 _err = rStoreDir.next(iter);
991 }
992
993 (void) pReg->releaseKey(pRootKey);
994 return _ret;
995 }
996
997
998
999 // loadAndSaveValue()
1000
1001 RegError ORegistry::loadAndSaveValue(ORegKey* pTargetKey,
1002 ORegKey* pSourceKey,
1003 const OUString& valueName,
1004 sal_uInt32 nCut,
1005 bool bWarnings,
1006 bool bReport)
1007 {
1008 OStoreStream rValue;
1009 sal_uInt8* pBuffer;
1010 RegValueType valueType;
1011 sal_uInt32 valueSize;
1012 sal_uInt32 nSize;
1013 storeAccessMode sourceAccess = VALUE_MODE_OPEN;
1014 OUString sTargetPath(pTargetKey->getName());
1015 OUString sSourcePath(pSourceKey->getName());
1016
1017 if (pSourceKey->isReadOnly())
1018 {
1019 sourceAccess = VALUE_MODE_OPENREAD;
1020 }
1021
1022 if (nCut)
1023 {
1024 sTargetPath = sSourcePath.copy(nCut);
1025 } else
1026 {
1027 if (sTargetPath.getLength() > 1)
1028 {
1029 if (sSourcePath.getLength() > 1)
1030 sTargetPath += sSourcePath;
1031 } else
1032 sTargetPath = sSourcePath;
1033 }
1034
1035 if (sTargetPath.getLength() > 1) sTargetPath += ROOT;
1036 if (sSourcePath.getLength() > 1) sSourcePath += ROOT;
1037
1038 if (rValue.create(pSourceKey->getStoreFile(), sSourcePath, valueName, sourceAccess))
1039 {
1040 return RegError::VALUE_NOT_EXISTS;
1041 }
1042
1043 pBuffer = static_cast<sal_uInt8*>(rtl_allocateMemory(VALUE_HEADERSIZE));
1044
1045 sal_uInt32 rwBytes;
1046 if (rValue.readAt(0, pBuffer, VALUE_HEADERSIZE, rwBytes))
1047 {
1048 rtl_freeMemory(pBuffer);
1049 return RegError::INVALID_VALUE;
1050 }
1051 if (rwBytes != VALUE_HEADERSIZE)
1052 {
1053 rtl_freeMemory(pBuffer);
1054 return RegError::INVALID_VALUE;
1055 }
1056
1057 RegError _ret = RegError::NO_ERROR;
1058 sal_uInt8 type = *pBuffer;
1059 valueType = (RegValueType)type;
1060 readUINT32(pBuffer+VALUE_TYPEOFFSET, valueSize);
1061 rtl_freeMemory(pBuffer);
1062
1063 nSize = VALUE_HEADERSIZE + valueSize;
1064 pBuffer = static_cast<sal_uInt8*>(rtl_allocateMemory(nSize));
1065
1066 if (rValue.readAt(0, pBuffer, nSize, rwBytes))
1067 {
1068 rtl_freeMemory(pBuffer);
1069 return RegError::INVALID_VALUE;
1070 }
1071 if (rwBytes != nSize)
1072 {
1073 rtl_freeMemory(pBuffer);
1074 return RegError::INVALID_VALUE;
1075 }
1076
1077 OStoreFile rTargetFile(pTargetKey->getStoreFile());
1078
1079 if (!rValue.create(rTargetFile, sTargetPath, valueName, VALUE_MODE_OPEN))
1080 {
1081 if (valueType == RegValueType::BINARY)
1082 {
1083 _ret = checkBlop(
1084 rValue, sTargetPath, valueSize, pBuffer+VALUE_HEADEROFFSET,
1085 bReport);
1086 if (_ret != RegError::NO_ERROR)
1087 {
1088 if (_ret == RegError::MERGE_ERROR ||
1089 (_ret == RegError::MERGE_CONFLICT && bWarnings))
1090 {
1091 rtl_freeMemory(pBuffer);
1092 return _ret;
1093 }
1094 } else
1095 {
1096 rtl_freeMemory(pBuffer);
1097 return _ret;
1098 }
1099 }
1100 }
1101
1102 // write
1103 if (rValue.create(rTargetFile, sTargetPath, valueName, VALUE_MODE_CREATE))
1104 {
1105 rtl_freeMemory(pBuffer);
1106 return RegError::INVALID_VALUE;
1107 }
1108 if (rValue.writeAt(0, pBuffer, nSize, rwBytes))
1109 {
1110 rtl_freeMemory(pBuffer);
1111 return RegError::INVALID_VALUE;
1112 }
1113
1114 if (rwBytes != nSize)
1115 {
1116 rtl_freeMemory(pBuffer);
1117 return RegError::INVALID_VALUE;
1118 }
1119 pTargetKey->setModified();
1120
1121 rtl_freeMemory(pBuffer);
1122 return _ret;
1123 }
1124
1125
1126
1127 // checkblop()
1128
1129 RegError ORegistry::checkBlop(OStoreStream& rValue,
1130 const OUString& sTargetPath,
1131 sal_uInt32 srcValueSize,
1132 sal_uInt8* pSrcBuffer,
1133 bool bReport)
1134 {
1135 RegistryTypeReader reader(pSrcBuffer, srcValueSize, false);
1136
1137 if (reader.getTypeClass() == RT_TYPE_INVALID)
1138 {
1139 return RegError::INVALID_VALUE;
1140 }
1141
1142 sal_uInt8* pBuffer = static_cast<sal_uInt8*>(rtl_allocateMemory(VALUE_HEADERSIZE));
1143 RegValueType valueType;
1144 sal_uInt32 valueSize;
1145 sal_uInt32 rwBytes;
1146 OString targetPath( OUStringToOString(sTargetPath, RTL_TEXTENCODING_UTF8) );
1147
1148 if (!rValue.readAt(0, pBuffer, VALUE_HEADERSIZE, rwBytes) &&
1149 (rwBytes == VALUE_HEADERSIZE))
1150 {
1151 sal_uInt8 type = *pBuffer;
1152 valueType = (RegValueType)type;
1153 readUINT32(pBuffer+VALUE_TYPEOFFSET, valueSize);
1154 rtl_freeMemory(pBuffer);
1155
1156 if (valueType == RegValueType::BINARY)
1157 {
1158 pBuffer = static_cast<sal_uInt8*>(rtl_allocateMemory(valueSize));
1159 if (!rValue.readAt(VALUE_HEADEROFFSET, pBuffer, valueSize, rwBytes) &&
1160 (rwBytes == valueSize))
1161 {
1162 RegistryTypeReader reader2(pBuffer, valueSize, false);
1163
1164 if ((reader.getTypeClass() != reader2.getTypeClass())
1165 || reader2.getTypeClass() == RT_TYPE_INVALID)
1166 {
1167 rtl_freeMemory(pBuffer);
1168
1169 if (bReport)
1170 {
1171 fprintf(stdout, "ERROR: values of blop from key \"%s\" has different types.\n",
1172 targetPath.getStr());
1173 }
1174 return RegError::MERGE_ERROR;
1175 }
1176
1177 if (reader.getTypeClass() == RT_TYPE_MODULE)
1178 {
1179 if (reader.getFieldCount() > 0 &&
1180 reader2.getFieldCount() > 0)
1181 {
1182 mergeModuleValue(rValue, reader, reader2);
1183
1184 rtl_freeMemory(pBuffer);
1185 return RegError::NO_ERROR;
1186 } else
1187 if (reader2.getFieldCount() > 0)
1188 {
1189 rtl_freeMemory(pBuffer);
1190 return RegError::NO_ERROR;
1191 } else
1192 {
1193 rtl_freeMemory(pBuffer);
1194 return RegError::MERGE_CONFLICT;
1195 }
1196 } else
1197 {
1198 rtl_freeMemory(pBuffer);
1199
1200 if (bReport)
1201 {
1202 fprintf(stderr, "WARNING: value of key \"%s\" already exists.\n",
1203 targetPath.getStr());
1204 }
1205 return RegError::MERGE_CONFLICT;
1206 }
1207 } else
1208 {
1209 rtl_freeMemory(pBuffer);
1210 if (bReport)
1211 {
1212 fprintf(stderr, "ERROR: values of key \"%s\" contains bad data.\n",
1213 targetPath.getStr());
1214 }
1215 return RegError::MERGE_ERROR;
1216 }
1217 } else
1218 {
1219 rtl_freeMemory(pBuffer);
1220 if (bReport)
1221 {
1222 fprintf(stderr, "ERROR: values of key \"%s\" has different types.\n",
1223 targetPath.getStr());
1224 }
1225 return RegError::MERGE_ERROR;
1226 }
1227 } else
1228 {
1229 rtl_freeMemory(pBuffer);
1230 return RegError::INVALID_VALUE;
1231 }
1232 }
1233
1234 static sal_uInt32 checkTypeReaders(RegistryTypeReader& reader1,
1235 RegistryTypeReader& reader2,
1236 std::set< OUString >& nameSet)
1237 {
1238 sal_uInt32 count=0;
1239 sal_uInt16 i;
1240 for (i=0 ; i < reader1.getFieldCount(); i++)
1241 {
1242 nameSet.insert(reader1.getFieldName(i));
1243 count++;
1244 }
1245 for (i=0 ; i < reader2.getFieldCount(); i++)
1246 {
1247 if (nameSet.find(reader2.getFieldName(i)) == nameSet.end())
1248 {
1249 nameSet.insert(reader2.getFieldName(i));
1250 count++;
1251 }
1252 }
1253 return count;
1254 }
1255
1256
1257 // mergeModuleValue()
1258
1259 RegError ORegistry::mergeModuleValue(OStoreStream& rTargetValue,
1260 RegistryTypeReader& reader,
1261 RegistryTypeReader& reader2)
1262 {
1263 std::set< OUString > nameSet;
1264 sal_uInt32 count = checkTypeReaders(reader, reader2, nameSet);
1265
1266 if (count != reader.getFieldCount())
1267 {
1268 sal_uInt16 index = 0;
1269
1270 RegistryTypeWriter writer(reader.getTypeClass(),
1271 reader.getTypeName(),
1272 reader.getSuperTypeName(),
1273 (sal_uInt16)count,
1274 0,
1275 0);
1276
1277 for (sal_uInt16 i=0 ; i < reader.getFieldCount(); i++)
1278 {
1279 writer.setFieldData(index,
1280 reader.getFieldName(i),
1281 reader.getFieldType(i),
1282 reader.getFieldDoku(i),
1283 reader.getFieldFileName(i),
1284 reader.getFieldAccess(i),
1285 reader.getFieldConstValue(i));
1286 index++;
1287 }
1288 for (sal_uInt16 i=0 ; i < reader2.getFieldCount(); i++)
1289 {
1290 if (nameSet.find(reader2.getFieldName(i)) == nameSet.end())
1291 {
1292 writer.setFieldData(index,
1293 reader2.getFieldName(i),
1294 reader2.getFieldType(i),
1295 reader2.getFieldDoku(i),
1296 reader2.getFieldFileName(i),
1297 reader2.getFieldAccess(i),
1298 reader2.getFieldConstValue(i));
1299 index++;
1300 }
1301 }
1302
1303 const sal_uInt8* pBlop = writer.getBlop();
1304 sal_uInt32 aBlopSize = writer.getBlopSize();
1305
1306 sal_uInt8 type = (sal_uInt8)RegValueType::BINARY;
1307 sal_uInt8* pBuffer = static_cast<sal_uInt8*>(rtl_allocateMemory(VALUE_HEADERSIZE + aBlopSize));
1308
1309 memcpy(pBuffer, &type, 1);
1310 writeUINT32(pBuffer+VALUE_TYPEOFFSET, aBlopSize);
1311 memcpy(pBuffer+VALUE_HEADEROFFSET, pBlop, aBlopSize);
1312
1313 sal_uInt32 rwBytes;
1314 if (rTargetValue.writeAt(0, pBuffer, VALUE_HEADERSIZE+aBlopSize, rwBytes))
1315 {
1316 rtl_freeMemory(pBuffer);
1317 return RegError::INVALID_VALUE;
1318 }
1319
1320 if (rwBytes != VALUE_HEADERSIZE+aBlopSize)
1321 {
1322 rtl_freeMemory(pBuffer);
1323 return RegError::INVALID_VALUE;
1324 }
1325
1326 rtl_freeMemory(pBuffer);
1327 }
1328 return RegError::NO_ERROR;
1329 }
1330
1331
1332 // loadAndSaveKeys()
1333
1334 RegError ORegistry::loadAndSaveKeys(ORegKey* pTargetKey,
1335 ORegKey* pSourceKey,
1336 const OUString& keyName,
1337 sal_uInt32 nCut,
1338 bool bWarnings,
1339 bool bReport)
1340 {
1341 RegError _ret = RegError::NO_ERROR;
1342 OUString sRelPath(pSourceKey->getName().copy(nCut));
1343 OUString sFullPath;
1344
1345 if(pTargetKey->getName().getLength() > 1)
1346 sFullPath += pTargetKey->getName();
1347 sFullPath += sRelPath;
1348 if (sRelPath.getLength() > 1 || sFullPath.isEmpty())
1349 sFullPath += ROOT;
1350
1351 OUString sFullKeyName = sFullPath;
1352 sFullKeyName += keyName;
1353
1354 OStoreDirectory rStoreDir;
1355 if (rStoreDir.create(pTargetKey->getStoreFile(), sFullPath, keyName, KEY_MODE_CREATE))
1356 {
1357 return RegError::CREATE_KEY_FAILED;
1358 }
1359
1360 if (m_openKeyTable.count(sFullKeyName) > 0)
1361 {
1362 m_openKeyTable[sFullKeyName]->setDeleted(false);
1363 }
1364
1365 ORegKey* pTmpKey = 0;
1366 _ret = pSourceKey->openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pTmpKey));
1367 if (_ret != RegError::NO_ERROR)
1368 return _ret;
1369
1370 OStoreDirectory::iterator iter;
1371 OStoreDirectory rTmpStoreDir(pTmpKey->getStoreDir());
1372 storeError _err = rTmpStoreDir.first(iter);
1373
1374 while ( _err == store_E_None)
1375 {
1376 OUString const sName = iter.m_pszName;
1377
1378 if (iter.m_nAttrib & STORE_ATTRIB_ISDIR)
1379 {
1380 _ret = loadAndSaveKeys(pTargetKey, pTmpKey,
1381 sName, nCut, bWarnings, bReport);
1382 } else
1383 {
1384 _ret = loadAndSaveValue(pTargetKey, pTmpKey,
1385 sName, nCut, bWarnings, bReport);
1386 }
1387
1388 if (_ret == RegError::MERGE_ERROR)
1389 break;
1390 if (_ret == RegError::MERGE_CONFLICT && bWarnings)
1391 break;
1392
1393 _err = rTmpStoreDir.next(iter);
1394 }
1395
1396 pSourceKey->releaseKey(pTmpKey);
1397 return _ret;
1398 }
1399
1400
1401
1402 // getRootKey()
1403
1404 ORegKey* ORegistry::getRootKey()
1405 {
1406 m_openKeyTable[ROOT]->acquire();
1407 return m_openKeyTable[ROOT];
1408 }
1409
1410
1411
1412 // dumpRegistry()
1413
1414 RegError ORegistry::dumpRegistry(RegKeyHandle hKey) const
1415 {
1416 ORegKey *pKey = static_cast<ORegKey*>(hKey);
1417 OUString sName;
1418 RegError _ret = RegError::NO_ERROR;
1419 OStoreDirectory::iterator iter;
1420 OStoreDirectory rStoreDir(pKey->getStoreDir());
1421 storeError _err = rStoreDir.first(iter);
1422
1423 OString regName( OUStringToOString( getName(), osl_getThreadTextEncoding() ) );
1424 OString keyName( OUStringToOString( pKey->getName(), RTL_TEXTENCODING_UTF8 ) );
1425 fprintf(stdout, "Registry \"%s\":\n\n%s\n", regName.getStr(), keyName.getStr());
1426
1427 while ( _err == store_E_None )
1428 {
1429 sName = iter.m_pszName;
1430
1431 if (iter.m_nAttrib & STORE_ATTRIB_ISDIR)
1432 {
1433 _ret = dumpKey(pKey->getName(), sName, 1);
1434 } else
1435 {
1436 _ret = dumpValue(pKey->getName(), sName, 1);
1437 }
1438
1439 if (_ret != RegError::NO_ERROR)
1440 {
1441 return _ret;
1442 }
1443
1444 _err = rStoreDir.next(iter);
1445 }
1446
1447 return RegError::NO_ERROR;
1448 }
1449
1450
1451 // dumpValue()
1452
1453 RegError ORegistry::dumpValue(const OUString& sPath, const OUString& sName, sal_Int16 nSpc) const
1454 {
1455 OStoreStream rValue;
1456 sal_uInt8* pBuffer;
1457 sal_uInt32 valueSize;
1458 RegValueType valueType;
1459 OUString sFullPath(sPath);
1460 OString sIndent;
1461 storeAccessMode accessMode = VALUE_MODE_OPEN;
1462
1463 if (isReadOnly())
1464 {
1465 accessMode = VALUE_MODE_OPENREAD;
1466 }
1467
1468 for (int i= 0; i < nSpc; i++) sIndent += " ";
1469
1470 if (sFullPath.getLength() > 1)
1471 {
1472 sFullPath += ROOT;
1473 }
1474 if (rValue.create(m_file, sFullPath, sName, accessMode))
1475 {
1476 return RegError::VALUE_NOT_EXISTS;
1477 }
1478
1479 pBuffer = static_cast<sal_uInt8*>(rtl_allocateMemory(VALUE_HEADERSIZE));
1480
1481 sal_uInt32 rwBytes;
1482 if (rValue.readAt(0, pBuffer, VALUE_HEADERSIZE, rwBytes))
1483 {
1484 rtl_freeMemory(pBuffer);
1485 return RegError::INVALID_VALUE;
1486 }
1487 if (rwBytes != (VALUE_HEADERSIZE))
1488 {
1489 rtl_freeMemory(pBuffer);
1490 return RegError::INVALID_VALUE;
1491 }
1492
1493 sal_uInt8 type = *pBuffer;
1494 valueType = (RegValueType)type;
1495 readUINT32(pBuffer+VALUE_TYPEOFFSET, valueSize);
1496
1497 pBuffer = static_cast<sal_uInt8*>(rtl_allocateMemory(valueSize));
1498 if (rValue.readAt(VALUE_HEADEROFFSET, pBuffer, valueSize, rwBytes))
1499 {
1500 rtl_freeMemory(pBuffer);
1501 return RegError::INVALID_VALUE;
1502 }
1503 if (rwBytes != valueSize)
1504 {
1505 rtl_freeMemory(pBuffer);
1506 return RegError::INVALID_VALUE;
1507 }
1508
1509 const sal_Char* indent = sIndent.getStr();
1510 switch (valueType)
1511 {
1512 case RegValueType::NOT_DEFINED:
1513 fprintf(stdout, "%sValue: Type = VALUETYPE_NOT_DEFINED\n", indent);
1514 break;
1515 case RegValueType::LONG:
1516 {
1517 fprintf(stdout, "%sValue: Type = RegValueType::LONG\n", indent);
1518 fprintf(
1519 stdout, "%s Size = %lu\n", indent,
1520 sal::static_int_cast< unsigned long >(valueSize));
1521 fprintf(stdout, "%s Data = ", indent);
1522
1523 sal_Int32 value;
1524 readINT32(pBuffer, value);
1525 fprintf(stdout, "%ld\n", sal::static_int_cast< long >(value));
1526 }
1527 break;
1528 case RegValueType::STRING:
1529 {
1530 sal_Char* value = static_cast<sal_Char*>(rtl_allocateMemory(valueSize));
1531 readUtf8(pBuffer, value, valueSize);
1532 fprintf(stdout, "%sValue: Type = RegValueType::STRING\n", indent);
1533 fprintf(
1534 stdout, "%s Size = %lu\n", indent,
1535 sal::static_int_cast< unsigned long >(valueSize));
1536 fprintf(stdout, "%s Data = \"%s\"\n", indent, value);
1537 rtl_freeMemory(value);
1538 }
1539 break;
1540 case RegValueType::UNICODE:
1541 {
1542 sal_uInt32 size = (valueSize / 2) * sizeof(sal_Unicode);
1543 fprintf(stdout, "%sValue: Type = RegValueType::UNICODE\n", indent);
1544 fprintf(
1545 stdout, "%s Size = %lu\n", indent,
1546 sal::static_int_cast< unsigned long >(valueSize));
1547 fprintf(stdout, "%s Data = ", indent);
1548
1549 sal_Unicode* value = new sal_Unicode[size];
1550 readString(pBuffer, value, size);
1551
1552 OString uStr = OUStringToOString(value, RTL_TEXTENCODING_UTF8);
1553 fprintf(stdout, "L\"%s\"\n", uStr.getStr());
1554 delete[] value;
1555 }
1556 break;
1557 case RegValueType::BINARY:
1558 {
1559 fprintf(stdout, "%sValue: Type = RegValueType::BINARY\n", indent);
1560 fprintf(
1561 stdout, "%s Size = %lu\n", indent,
1562 sal::static_int_cast< unsigned long >(valueSize));
1563 fprintf(stdout, "%s Data = ", indent);
1564 dumpType(
1565 typereg::Reader(
1566 pBuffer, valueSize, false, TYPEREG_VERSION_1),
1567 sIndent + " ");
1568 }
1569 break;
1570 case RegValueType::LONGLIST:
1571 {
1572 sal_uInt32 offset = 4; // initial 4 bytes for the size of the array
1573 sal_uInt32 len = 0;
1574
1575 readUINT32(pBuffer, len);
1576
1577 fprintf(stdout, "%sValue: Type = RegValueType::LONGLIST\n", indent);
1578 fprintf(
1579 stdout, "%s Size = %lu\n", indent,
1580 sal::static_int_cast< unsigned long >(valueSize));
1581 fprintf(
1582 stdout, "%s Len = %lu\n", indent,
1583 sal::static_int_cast< unsigned long >(len));
1584 fprintf(stdout, "%s Data = ", indent);
1585
1586 sal_Int32 longValue;
1587 for (sal_uInt32 i=0; i < len; i++)
1588 {
1589 readINT32(pBuffer+offset, longValue);
1590
1591 if (offset > 4)
1592 fprintf(stdout, "%s ", indent);
1593
1594 fprintf(
1595 stdout, "%lu = %ld\n",
1596 sal::static_int_cast< unsigned long >(i),
1597 sal::static_int_cast< long >(longValue));
1598 offset += 4; // 4 Bytes fuer sal_Int32
1599 }
1600 }
1601 break;
1602 case RegValueType::STRINGLIST:
1603 {
1604 sal_uInt32 offset = 4; // initial 4 bytes for the size of the array
1605 sal_uInt32 sLen = 0;
1606 sal_uInt32 len = 0;
1607
1608 readUINT32(pBuffer, len);
1609
1610 fprintf(stdout, "%sValue: Type = RegValueType::STRINGLIST\n", indent);
1611 fprintf(
1612 stdout, "%s Size = %lu\n", indent,
1613 sal::static_int_cast< unsigned long >(valueSize));
1614 fprintf(
1615 stdout, "%s Len = %lu\n", indent,
1616 sal::static_int_cast< unsigned long >(len));
1617 fprintf(stdout, "%s Data = ", indent);
1618
1619 for (sal_uInt32 i=0; i < len; i++)
1620 {
1621 readUINT32(pBuffer+offset, sLen);
1622
1623 offset += 4; // 4 Bytes (sal_uInt32) fuer die Groesse des strings in Bytes
1624
1625 sal_Char *pValue = static_cast<sal_Char*>(rtl_allocateMemory(sLen));
1626 readUtf8(pBuffer+offset, pValue, sLen);
1627
1628 if (offset > 8)
1629 fprintf(stdout, "%s ", indent);
1630
1631 fprintf(
1632 stdout, "%lu = \"%s\"\n",
1633 sal::static_int_cast< unsigned long >(i), pValue);
1634 rtl_freeMemory(pValue);
1635 offset += sLen;
1636 }
1637 }
1638 break;
1639 case RegValueType::UNICODELIST:
1640 {
1641 sal_uInt32 offset = 4; // initial 4 bytes for the size of the array
1642 sal_uInt32 sLen = 0;
1643 sal_uInt32 len = 0;
1644
1645 readUINT32(pBuffer, len);
1646
1647 fprintf(stdout, "%sValue: Type = RegValueType::UNICODELIST\n", indent);
1648 fprintf(
1649 stdout, "%s Size = %lu\n", indent,
1650 sal::static_int_cast< unsigned long >(valueSize));
1651 fprintf(
1652 stdout, "%s Len = %lu\n", indent,
1653 sal::static_int_cast< unsigned long >(len));
1654 fprintf(stdout, "%s Data = ", indent);
1655
1656 OString uStr;
1657 for (sal_uInt32 i=0; i < len; i++)
1658 {
1659 readUINT32(pBuffer+offset, sLen);
1660
1661 offset += 4; // 4 Bytes (sal_uInt32) fuer die Groesse des strings in Bytes
1662
1663 sal_Unicode *pValue = static_cast<sal_Unicode*>(rtl_allocateMemory((sLen / 2) * sizeof(sal_Unicode)));
1664 readString(pBuffer+offset, pValue, sLen);
1665
1666 if (offset > 8)
1667 fprintf(stdout, "%s ", indent);
1668
1669 uStr = OUStringToOString(pValue, RTL_TEXTENCODING_UTF8);
1670 fprintf(
1671 stdout, "%lu = L\"%s\"\n",
1672 sal::static_int_cast< unsigned long >(i),
1673 uStr.getStr());
1674
1675 offset += sLen;
1676
1677 rtl_freeMemory(pValue);
1678 }
1679 }
1680 break;
1681 }
1682
1683 fprintf(stdout, "\n");
1684
1685 rtl_freeMemory(pBuffer);
1686 return RegError::NO_ERROR;
1687 }
1688
1689
1690 // dumpKey()
1691
1692 RegError ORegistry::dumpKey(const OUString& sPath, const OUString& sName, sal_Int16 nSpace) const
1693 {
1694 OStoreDirectory rStoreDir;
1695 OUString sFullPath(sPath);
1696 OString sIndent;
1697 storeAccessMode accessMode = KEY_MODE_OPEN;
1698 RegError _ret = RegError::NO_ERROR;
1699
1700 if (isReadOnly())
1701 {
1702 accessMode = KEY_MODE_OPENREAD;
1703 }
1704
1705 for (int i= 0; i < nSpace; i++) sIndent += " ";
1706
1707 if (sFullPath.getLength() > 1)
1708 sFullPath += ROOT;
1709
1710 storeError _err = rStoreDir.create(m_file, sFullPath, sName, accessMode);
1711
1712 if (_err == store_E_NotExists)
1713 return RegError::KEY_NOT_EXISTS;
1714 else if (_err == store_E_WrongFormat)
1715 return RegError::INVALID_KEY;
1716
1717 fprintf(stdout, "%s/ %s\n", sIndent.getStr(), OUStringToOString(sName, RTL_TEXTENCODING_UTF8).getStr());
1718
1719 OUString sSubPath(sFullPath);
1720 OUString sSubName;
1721 sSubPath += sName;
1722
1723 OStoreDirectory::iterator iter;
1724
1725 _err = rStoreDir.first(iter);
1726
1727 while ( _err == store_E_None)
1728 {
1729 sSubName = iter.m_pszName;
1730
1731 if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR )
1732 {
1733 _ret = dumpKey(sSubPath, sSubName, nSpace+2);
1734 } else
1735 {
1736 _ret = dumpValue(sSubPath, sSubName, nSpace+2);
1737 }
1738
1739 if (_ret != RegError::NO_ERROR)
1740 {
1741 return _ret;
1742 }
1743
1744 _err = rStoreDir.next(iter);
1745 }
1746
1747 return RegError::NO_ERROR;
1748 }
1749
1750 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE