?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tdf#151548 ContentControls: Add Delete()
[LibreOffice.git] / registry / source / regimpl.cxx
blob5f5bf335edb4f81a3b5dd049130066585b8d8f80
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 <cstddef>
24 #include <memory>
25 #include <set>
26 #include <string_view>
27 #include <vector>
28 #include <string.h>
29 #include <stdio.h>
30
31 #if defined(UNX)
32 #include <unistd.h>
33 #endif
34
35 #include <registry/reader.hxx>
36 #include <registry/refltype.hxx>
37 #include <registry/types.hxx>
38
39 #include "reflcnst.hxx"
40 #include "keyimpl.hxx"
41
42 #include <osl/thread.h>
43 #include <rtl/ustring.hxx>
44 #include <rtl/ustrbuf.hxx>
45 #include <osl/file.hxx>
46
47 using namespace osl;
48 using namespace store;
49
50
51 namespace {
52
53 void printString(std::u16string_view s) {
54 printf("\"");
55 for (std::size_t i = 0; i < s.size(); ++i) {
56 sal_Unicode c = s[i];
57 if (c == '"' || c == '\\') {
58 printf("\\%c", static_cast< char >(c));
59 } else if (s[i] >= ' ' && s[i] <= '~') {
60 printf("%c", static_cast< char >(c));
61 } else {
62 printf("\\u%04X", static_cast< unsigned int >(c));
63 }
64 }
65 printf("\"");
66 }
67
68 void printFieldOrReferenceFlag(
69 RTFieldAccess * flags, RTFieldAccess flag, char const * name, bool * first)
70 {
71 if ((*flags & flag) != RTFieldAccess::NONE) {
72 if (!*first) {
73 printf("|");
74 }
75 *first = false;
76 printf("%s", name);
77 *flags &= ~flag;
78 }
79 }
80
81 void printFieldOrReferenceFlags(RTFieldAccess flags) {
82 if (flags == RTFieldAccess::NONE) {
83 printf("none");
84 } else {
85 bool first = true;
86 printFieldOrReferenceFlag(
87 &flags, RTFieldAccess::READONLY, "readonly", &first);
88 printFieldOrReferenceFlag(
89 &flags, RTFieldAccess::OPTIONAL, "optional", &first);
90 printFieldOrReferenceFlag(
91 &flags, RTFieldAccess::MAYBEVOID, "maybevoid", &first);
92 printFieldOrReferenceFlag(&flags, RTFieldAccess::BOUND, "bound", &first);
93 printFieldOrReferenceFlag(
94 &flags, RTFieldAccess::CONSTRAINED, "constrained", &first);
95 printFieldOrReferenceFlag(
96 &flags, RTFieldAccess::TRANSIENT, "transient", &first);
97 printFieldOrReferenceFlag(
98 &flags, RTFieldAccess::MAYBEAMBIGUOUS, "maybeambiguous", &first);
99 printFieldOrReferenceFlag(
100 &flags, RTFieldAccess::MAYBEDEFAULT, "maybedefault", &first);
101 printFieldOrReferenceFlag(
102 &flags, RTFieldAccess::REMOVABLE, "removable", &first);
103 printFieldOrReferenceFlag(
104 &flags, RTFieldAccess::ATTRIBUTE, "attribute", &first);
105 printFieldOrReferenceFlag(
106 &flags, RTFieldAccess::PROPERTY, "property", &first);
107 printFieldOrReferenceFlag(&flags, RTFieldAccess::CONST, "const", &first);
108 printFieldOrReferenceFlag(
109 &flags, RTFieldAccess::READWRITE, "readwrite", &first);
110 printFieldOrReferenceFlag(
111 &flags, RTFieldAccess::PARAMETERIZED_TYPE, "parameterized type", &first);
112 printFieldOrReferenceFlag(
113 &flags, RTFieldAccess::PUBLISHED, "published", &first);
114 if (flags != RTFieldAccess::NONE) {
115 if (!first) {
116 printf("|");
117 }
118 printf("<invalid (0x%04X)>", static_cast< unsigned int >(flags));
119 }
120 }
121 }
122
123 void dumpType(typereg::Reader const & reader, OString const & indent) {
124 if (reader.isValid()) {
125 printf("version: %ld\n", static_cast< long >(reader.getVersion()));
126 printf("%sdocumentation: ", indent.getStr());
127 printString(reader.getDocumentation());
128 printf("\n");
129 printf("%sfile name: ", indent.getStr());
130 printString(reader.getFileName());
131 printf("\n");
132 printf("%stype class: ", indent.getStr());
133 if (reader.isPublished()) {
134 printf("published ");
135 }
136 switch (reader.getTypeClass()) {
137 case RT_TYPE_INTERFACE:
138 printf("interface");
139 break;
140
141 case RT_TYPE_MODULE:
142 printf("module");
143 break;
144
145 case RT_TYPE_STRUCT:
146 printf("struct");
147 break;
148
149 case RT_TYPE_ENUM:
150 printf("enum");
151 break;
152
153 case RT_TYPE_EXCEPTION:
154 printf("exception");
155 break;
156
157 case RT_TYPE_TYPEDEF:
158 printf("typedef");
159 break;
160
161 case RT_TYPE_SERVICE:
162 printf("service");
163 break;
164
165 case RT_TYPE_SINGLETON:
166 printf("singleton");
167 break;
168
169 case RT_TYPE_CONSTANTS:
170 printf("constants");
171 break;
172
173 default:
174 printf(
175 "<invalid (%ld)>", static_cast< long >(reader.getTypeClass()));
176 break;
177 }
178 printf("\n");
179 printf("%stype name: ", indent.getStr());
180 printString(reader.getTypeName());
181 printf("\n");
182 printf(
183 "%ssuper type count: %u\n", indent.getStr(),
184 static_cast< unsigned int >(reader.getSuperTypeCount()));
185 for (sal_uInt16 i = 0; i < reader.getSuperTypeCount(); ++i) {
186 printf(
187 "%ssuper type name %u: ", indent.getStr(),
188 static_cast< unsigned int >(i));
189 printString(reader.getSuperTypeName(i));
190 printf("\n");
191 }
192 printf(
193 "%sfield count: %u\n", indent.getStr(),
194 static_cast< unsigned int >(reader.getFieldCount()));
195 for (sal_uInt16 i = 0; i < reader.getFieldCount(); ++i) {
196 printf(
197 "%sfield %u:\n", indent.getStr(),
198 static_cast< unsigned int >(i));
199 printf("%s documentation: ", indent.getStr());
200 printString(reader.getFieldDocumentation(i));
201 printf("\n");
202 printf("%s file name: ", indent.getStr());
203 printString(reader.getFieldFileName(i));
204 printf("\n");
205 printf("%s flags: ", indent.getStr());
206 printFieldOrReferenceFlags(reader.getFieldFlags(i));
207 printf("\n");
208 printf("%s name: ", indent.getStr());
209 printString(reader.getFieldName(i));
210 printf("\n");
211 printf("%s type name: ", indent.getStr());
212 printString(reader.getFieldTypeName(i));
213 printf("\n");
214 printf("%s value: ", indent.getStr());
215 RTConstValue value(reader.getFieldValue(i));
216 switch (value.m_type) {
217 case RT_TYPE_NONE:
218 printf("none");
219 break;
220
221 case RT_TYPE_BOOL:
222 printf("boolean %s", value.m_value.aBool ? "true" : "false");
223 break;
224
225 case RT_TYPE_BYTE:
226 printf("byte %d", static_cast< int >(value.m_value.aByte));
227 break;
228
229 case RT_TYPE_INT16:
230 printf("short %d", static_cast< int >(value.m_value.aShort));
231 break;
232
233 case RT_TYPE_UINT16:
234 printf(
235 "unsigned short %u",
236 static_cast< unsigned int >(value.m_value.aUShort));
237 break;
238
239 case RT_TYPE_INT32:
240 printf("long %ld", static_cast< long >(value.m_value.aLong));
241 break;
242
243 case RT_TYPE_UINT32:
244 printf(
245 "unsigned long %lu",
246 static_cast< unsigned long >(value.m_value.aULong));
247 break;
248
249 case RT_TYPE_INT64:
250 // TODO: no portable way to print hyper values
251 printf("hyper");
252 break;
253
254 case RT_TYPE_UINT64:
255 // TODO: no portable way to print unsigned hyper values
256 printf("unsigned hyper");
257 break;
258
259 case RT_TYPE_FLOAT:
260 // TODO: no portable way to print float values
261 printf("float");
262 break;
263
264 case RT_TYPE_DOUBLE:
265 // TODO: no portable way to print double values
266 printf("double");
267 break;
268
269 case RT_TYPE_STRING:
270 printf("string ");
271 printString(value.m_value.aString);
272 break;
273
274 default:
275 printf("<invalid (%ld)>", static_cast< long >(value.m_type));
276 break;
277 }
278 printf("\n");
279 }
280 printf(
281 "%smethod count: %u\n", indent.getStr(),
282 static_cast< unsigned int >(reader.getMethodCount()));
283 for (sal_uInt16 i = 0; i < reader.getMethodCount(); ++i) {
284 printf(
285 "%smethod %u:\n", indent.getStr(),
286 static_cast< unsigned int >(i));
287 printf("%s documentation: ", indent.getStr());
288 printString(reader.getMethodDocumentation(i));
289 printf("\n");
290 printf("%s flags: ", indent.getStr());
291 switch (reader.getMethodFlags(i)) {
292 case RTMethodMode::ONEWAY:
293 printf("oneway");
294 break;
295
296 case RTMethodMode::TWOWAY:
297 printf("synchronous");
298 break;
299
300 case RTMethodMode::ATTRIBUTE_GET:
301 printf("attribute get");
302 break;
303
304 case RTMethodMode::ATTRIBUTE_SET:
305 printf("attribute set");
306 break;
307
308 default:
309 printf(
310 "<invalid (%ld)>",
311 static_cast< long >(reader.getMethodFlags(i)));
312 break;
313 }
314 printf("\n");
315 printf("%s name: ", indent.getStr());
316 printString(reader.getMethodName(i));
317 printf("\n");
318 printf("%s return type name: ", indent.getStr());
319 printString(reader.getMethodReturnTypeName(i));
320 printf("\n");
321 printf(
322 "%s parameter count: %u\n", indent.getStr(),
323 static_cast< unsigned int >(reader.getMethodParameterCount(i)));
324 // coverity[tainted_data] - cid#1215304 unhelpfully warns about untrusted loop bound
325 for (sal_uInt16 j = 0; j < reader.getMethodParameterCount(i); ++j)
326 {
327 printf(
328 "%s parameter %u:\n", indent.getStr(),
329 static_cast< unsigned int >(j));
330 printf("%s flags: ", indent.getStr());
331 RTParamMode flags = reader.getMethodParameterFlags(i, j);
332 bool rest = (flags & RT_PARAM_REST) != 0;
333 switch (flags & ~RT_PARAM_REST) {
334 case RT_PARAM_IN:
335 printf("in");
336 break;
337
338 case RT_PARAM_OUT:
339 printf("out");
340 break;
341
342 case RT_PARAM_INOUT:
343 printf("inout");
344 break;
345
346 default:
347 printf("<invalid (%ld)>", static_cast< long >(flags));
348 rest = false;
349 break;
350 }
351 if (rest) {
352 printf("|rest");
353 }
354 printf("\n");
355 printf("%s name: ", indent.getStr());
356 printString(reader.getMethodParameterName(i, j));
357 printf("\n");
358 printf("%s type name: ", indent.getStr());
359 printString(reader.getMethodParameterTypeName(i, j));
360 printf("\n");
361 }
362 printf(
363 "%s exception count: %u\n", indent.getStr(),
364 static_cast< unsigned int >(reader.getMethodExceptionCount(i)));
365 // coverity[tainted_data] - cid#1215304 unhelpfully warns about untrusted loop bound
366 for (sal_uInt16 j = 0; j < reader.getMethodExceptionCount(i); ++j)
367 {
368 printf(
369 "%s exception type name %u: ", indent.getStr(),
370 static_cast< unsigned int >(j));
371 printString(reader.getMethodExceptionTypeName(i, j));
372 printf("\n");
373 }
374 }
375 printf(
376 "%sreference count: %u\n", indent.getStr(),
377 static_cast< unsigned int >(reader.getReferenceCount()));
378 for (sal_uInt16 i = 0; i < reader.getReferenceCount(); ++i) {
379 printf(
380 "%sreference %u:\n", indent.getStr(),
381 static_cast< unsigned int >(i));
382 printf("%s documentation: ", indent.getStr());
383 printString(reader.getReferenceDocumentation(i));
384 printf("\n");
385 printf("%s flags: ", indent.getStr());
386 printFieldOrReferenceFlags(reader.getReferenceFlags(i));
387 printf("\n");
388 printf("%s sort: ", indent.getStr());
389 switch (reader.getReferenceSort(i)) {
390 case RTReferenceType::SUPPORTS:
391 printf("supports");
392 break;
393
394 case RTReferenceType::EXPORTS:
395 printf("exports");
396 break;
397
398 case RTReferenceType::TYPE_PARAMETER:
399 printf("type parameter");
400 break;
401
402 default:
403 printf(
404 "<invalid (%ld)>",
405 static_cast< long >(reader.getReferenceSort(i)));
406 break;
407 }
408 printf("\n");
409 printf("%s type name: ", indent.getStr());
410 printString(reader.getReferenceTypeName(i));
411 printf("\n");
412 }
413 } else {
414 printf("<invalid>\n");
415 }
416 }
417
418 }
419
420 ORegistry::ORegistry()
421 : m_refCount(1)
422 , m_readOnly(false)
423 , m_isOpen(false)
424 {
425 }
426
427 ORegistry::~ORegistry()
428 {
429 ORegKey* pRootKey = m_openKeyTable[ROOT];
430 if (pRootKey != nullptr)
431 (void) releaseKey(pRootKey);
432
433 if (m_file.isValid())
434 m_file.close();
435 }
436
437 RegError ORegistry::initRegistry(const OUString& regName, RegAccessMode accessMode, bool bCreate)
438 {
439 RegError eRet = RegError::INVALID_REGISTRY;
440 OStoreFile rRegFile;
441 storeAccessMode sAccessMode = storeAccessMode::ReadWrite;
442 storeError errCode;
443
444 if (bCreate)
445 {
446 sAccessMode = storeAccessMode::Create;
447 }
448 else if (accessMode & RegAccessMode::READONLY)
449 {
450 sAccessMode = storeAccessMode::ReadOnly;
451 m_readOnly = true;
452 }
453
454 if (regName.isEmpty() &&
455 storeAccessMode::Create == sAccessMode)
456 {
457 errCode = rRegFile.createInMemory();
458 }
459 else
460 {
461 errCode = rRegFile.create(regName, sAccessMode);
462 }
463
464 if (errCode)
465 {
466 switch (errCode)
467 {
468 case store_E_NotExists:
469 eRet = RegError::REGISTRY_NOT_EXISTS;
470 break;
471 case store_E_LockingViolation:
472 eRet = RegError::CANNOT_OPEN_FOR_READWRITE;
473 break;
474 default:
475 eRet = RegError::INVALID_REGISTRY;
476 break;
477 }
478 }
479 else
480 {
481 OStoreDirectory rStoreDir;
482 storeError _err = rStoreDir.create(rRegFile, OUString(), OUString(), sAccessMode);
483
484 if (_err == store_E_None)
485 {
486 m_file = rRegFile;
487 m_name = regName;
488 m_isOpen = true;
489
490 m_openKeyTable[ROOT] = new ORegKey(ROOT, this);
491 eRet = RegError::NO_ERROR;
492 }
493 else
494 eRet = RegError::INVALID_REGISTRY;
495 }
496
497 return eRet;
498 }
499
500 RegError ORegistry::closeRegistry()
501 {
502 REG_GUARD(m_mutex);
503
504 if (m_file.isValid())
505 {
506 (void) releaseKey(m_openKeyTable[ROOT]);
507 m_file.close();
508 m_isOpen = false;
509 return RegError::NO_ERROR;
510 } else
511 {
512 return RegError::REGISTRY_NOT_EXISTS;
513 }
514 }
515
516 RegError ORegistry::destroyRegistry(const OUString& regName)
517 {
518 REG_GUARD(m_mutex);
519
520 if (!regName.isEmpty())
521 {
522 std::unique_ptr<ORegistry> pReg(new ORegistry());
523
524 if (pReg->initRegistry(regName, RegAccessMode::READWRITE) == RegError::NO_ERROR)
525 {
526 pReg.reset();
527
528 OUString systemName;
529 if (FileBase::getSystemPathFromFileURL(regName, systemName) != FileBase::E_None)
530 systemName = regName;
531
532 OString name(OUStringToOString(systemName, osl_getThreadTextEncoding()));
533 if (unlink(name.getStr()) != 0)
534 {
535 return RegError::DESTROY_REGISTRY_FAILED;
536 }
537 } else
538 {
539 return RegError::DESTROY_REGISTRY_FAILED;
540 }
541 } else
542 {
543 if (m_refCount != 1 || isReadOnly())
544 {
545 return RegError::DESTROY_REGISTRY_FAILED;
546 }
547
548 if (m_file.isValid())
549 {
550 releaseKey(m_openKeyTable[ROOT]);
551 m_file.close();
552 m_isOpen = false;
553
554 if (!m_name.isEmpty())
555 {
556 OUString systemName;
557 if (FileBase::getSystemPathFromFileURL(m_name, systemName) != FileBase::E_None)
558 systemName = m_name;
559
560 OString name(OUStringToOString(systemName, osl_getThreadTextEncoding()));
561 if (unlink(name.getStr()) != 0)
562 {
563 return RegError::DESTROY_REGISTRY_FAILED;
564 }
565 }
566 } else
567 {
568 return RegError::REGISTRY_NOT_EXISTS;
569 }
570 }
571
572 return RegError::NO_ERROR;
573 }
574
575 RegError ORegistry::acquireKey (RegKeyHandle hKey)
576 {
577 ORegKey* pKey = static_cast< ORegKey* >(hKey);
578 if (!pKey)
579 return RegError::INVALID_KEY;
580
581 REG_GUARD(m_mutex);
582 pKey->acquire();
583
584 return RegError::NO_ERROR;
585 }
586
587 RegError ORegistry::releaseKey (RegKeyHandle hKey)
588 {
589 ORegKey* pKey = static_cast< ORegKey* >(hKey);
590 if (!pKey)
591 return RegError::INVALID_KEY;
592
593 REG_GUARD(m_mutex);
594 if (pKey->release() == 0)
595 {
596 m_openKeyTable.erase(pKey->getName());
597 delete pKey;
598 }
599 return RegError::NO_ERROR;
600 }
601
602 RegError ORegistry::createKey(RegKeyHandle hKey, std::u16string_view keyName,
603 RegKeyHandle* phNewKey)
604 {
605 ORegKey* pKey;
606
607 *phNewKey = nullptr;
608
609 if (keyName.empty())
610 return RegError::INVALID_KEYNAME;
611
612 REG_GUARD(m_mutex);
613
614 if (hKey)
615 pKey = static_cast<ORegKey*>(hKey);
616 else
617 pKey = m_openKeyTable[ROOT];
618
619 OUString sFullKeyName = pKey->getFullPath(keyName);
620
621 if (m_openKeyTable.count(sFullKeyName) > 0)
622 {
623 *phNewKey = m_openKeyTable[sFullKeyName];
624 static_cast<ORegKey*>(*phNewKey)->acquire();
625 static_cast<ORegKey*>(*phNewKey)->setDeleted(false);
626 return RegError::NO_ERROR;
627 }
628
629 OStoreDirectory rStoreDir;
630 OUStringBuffer sFullPath(sFullKeyName.getLength()+16);
631 OUString token;
632
633 sFullPath.append('/');
634
635 sal_Int32 nIndex = 0;
636 do
637 {
638 token = sFullKeyName.getToken(0, '/', nIndex);
639 if (!token.isEmpty())
640 {
641 if (rStoreDir.create(pKey->getStoreFile(), sFullPath.toString(), token, storeAccessMode::Create))
642 {
643 return RegError::CREATE_KEY_FAILED;
644 }
645
646 sFullPath.append(token);
647 sFullPath.append('/');
648 }
649 } while(nIndex != -1);
650
651
652 pKey = new ORegKey(sFullKeyName, this);
653 *phNewKey = pKey;
654 m_openKeyTable[sFullKeyName] = pKey;
655
656 return RegError::NO_ERROR;
657 }
658
659 RegError ORegistry::openKey(RegKeyHandle hKey, std::u16string_view keyName,
660 RegKeyHandle* phOpenKey)
661 {
662 ORegKey* pKey;
663
664 *phOpenKey = nullptr;
665
666 if (keyName.empty())
667 {
668 return RegError::INVALID_KEYNAME;
669 }
670
671 REG_GUARD(m_mutex);
672
673 if (hKey)
674 pKey = static_cast<ORegKey*>(hKey);
675 else
676 pKey = m_openKeyTable[ROOT];
677
678 OUString path(pKey->getFullPath(keyName));
679 KeyMap::iterator i(m_openKeyTable.find(path));
680 if (i == m_openKeyTable.end()) {
681 sal_Int32 n = path.lastIndexOf('/') + 1;
682 switch (OStoreDirectory().create(
683 pKey->getStoreFile(), path.copy(0, n), path.copy(n),
684 isReadOnly() ? storeAccessMode::ReadOnly : storeAccessMode::ReadWrite))
685 {
686 case store_E_NotExists:
687 return RegError::KEY_NOT_EXISTS;
688 case store_E_WrongFormat:
689 return RegError::INVALID_KEY;
690 default:
691 break;
692 }
693
694 std::unique_ptr< ORegKey > p(new ORegKey(path, this));
695 i = m_openKeyTable.insert(std::make_pair(path, p.get())).first;
696 // coverity[leaked_storage : FALSE] - ownership transferred to m_openKeyTable
697 p.release();
698 } else {
699 i->second->acquire();
700 }
701 *phOpenKey = i->second;
702 return RegError::NO_ERROR;
703 }
704
705 RegError ORegistry::closeKey(RegKeyHandle hKey)
706 {
707 ORegKey* pKey = static_cast< ORegKey* >(hKey);
708
709 REG_GUARD(m_mutex);
710
711 OUString const aKeyName (pKey->getName());
712 if (m_openKeyTable.count(aKeyName) <= 0)
713 return RegError::KEY_NOT_OPEN;
714
715 if (pKey->isModified())
716 {
717 ORegKey * pRootKey = getRootKey();
718 if (pKey != pRootKey)
719 {
720 // propagate "modified" state to RootKey.
721 pRootKey->setModified();
722 }
723 else
724 {
725 // closing modified RootKey, flush registry file.
726 (void) m_file.flush();
727 }
728 pKey->setModified(false);
729 (void) releaseKey(pRootKey);
730 }
731
732 return releaseKey(pKey);
733 }
734
735 RegError ORegistry::deleteKey(RegKeyHandle hKey, std::u16string_view keyName)
736 {
737 ORegKey* pKey = static_cast< ORegKey* >(hKey);
738 if (keyName.empty())
739 return RegError::INVALID_KEYNAME;
740
741 REG_GUARD(m_mutex);
742
743 if (!pKey)
744 pKey = m_openKeyTable[ROOT];
745
746 OUString sFullKeyName(pKey->getFullPath(keyName));
747 return eraseKey(m_openKeyTable[ROOT], sFullKeyName);
748 }
749
750 RegError ORegistry::eraseKey(ORegKey* pKey, std::u16string_view keyName)
751 {
752 RegError _ret = RegError::NO_ERROR;
753
754 if (keyName.empty())
755 {
756 return RegError::INVALID_KEYNAME;
757 }
758
759 OUString sFullKeyName(pKey->getName());
760 OUString sFullPath(sFullKeyName);
761 OUString sRelativKey;
762 size_t lastIndex = keyName.rfind('/');
763
764 if (lastIndex != std::u16string_view::npos)
765 {
766 sRelativKey += keyName.substr(lastIndex + 1);
767
768 if (sFullKeyName.getLength() > 1)
769 sFullKeyName += keyName;
770 else
771 sFullKeyName += keyName.substr(1);
772
773 sFullPath = sFullKeyName.copy(0, keyName.rfind('/') + 1);
774 } else
775 {
776 if (sFullKeyName.getLength() > 1)
777 sFullKeyName += ROOT;
778
779 sRelativKey += keyName;
780 sFullKeyName += keyName;
781
782 if (sFullPath.getLength() > 1)
783 sFullPath += ROOT;
784 }
785
786 ORegKey* pOldKey = nullptr;
787 _ret = pKey->openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pOldKey));
788 if (_ret != RegError::NO_ERROR)
789 return _ret;
790
791 _ret = deleteSubkeysAndValues(pOldKey);
792 if (_ret != RegError::NO_ERROR)
793 {
794 pKey->closeKey(pOldKey);
795 return _ret;
796 }
797
798 OUString tmpName = sRelativKey + ROOT;
799
800 OStoreFile sFile(pKey->getStoreFile());
801 if (sFile.isValid() && sFile.remove(sFullPath, tmpName))
802 {
803 return RegError::DELETE_KEY_FAILED;
804 }
805 pOldKey->setModified();
806
807 // set flag deleted !!!
808 pOldKey->setDeleted(true);
809
810 return pKey->closeKey(pOldKey);
811 }
812
813 RegError ORegistry::deleteSubkeysAndValues(ORegKey* pKey)
814 {
815 OStoreDirectory::iterator iter;
816 RegError _ret = RegError::NO_ERROR;
817 OStoreDirectory rStoreDir(pKey->getStoreDir());
818 storeError _err = rStoreDir.first(iter);
819
820 while (_err == store_E_None)
821 {
822 OUString const keyName(iter.m_pszName, iter.m_nLength);
823
824 if (iter.m_nAttrib & STORE_ATTRIB_ISDIR)
825 {
826 _ret = eraseKey(pKey, keyName);
827 if (_ret != RegError::NO_ERROR)
828 return _ret;
829 }
830 else
831 {
832 OUString sFullPath(pKey->getName());
833
834 if (sFullPath.getLength() > 1)
835 sFullPath += ROOT;
836
837 if (const_cast<OStoreFile&>(pKey->getStoreFile()).remove(sFullPath, keyName))
838 {
839 return RegError::DELETE_VALUE_FAILED;
840 }
841 pKey->setModified();
842 }
843
844 _err = rStoreDir.next(iter);
845 }
846
847 return RegError::NO_ERROR;
848 }
849
850 ORegKey* ORegistry::getRootKey()
851 {
852 m_openKeyTable[ROOT]->acquire();
853 return m_openKeyTable[ROOT];
854 }
855
856 RegError ORegistry::dumpRegistry(RegKeyHandle hKey) const
857 {
858 ORegKey *pKey = static_cast<ORegKey*>(hKey);
859 OUString sName;
860 RegError _ret = RegError::NO_ERROR;
861 OStoreDirectory::iterator iter;
862 OStoreDirectory rStoreDir(pKey->getStoreDir());
863 storeError _err = rStoreDir.first(iter);
864
865 OString regName(OUStringToOString(getName(), osl_getThreadTextEncoding()));
866 OString keyName(OUStringToOString(pKey->getName(), RTL_TEXTENCODING_UTF8));
867 fprintf(stdout, "Registry \"%s\":\n\n%s\n", regName.getStr(), keyName.getStr());
868
869 while (_err == store_E_None)
870 {
871 sName = OUString(iter.m_pszName, iter.m_nLength);
872
873 if (iter.m_nAttrib & STORE_ATTRIB_ISDIR)
874 {
875 _ret = dumpKey(pKey->getName(), sName, 1);
876 } else
877 {
878 _ret = dumpValue(pKey->getName(), sName, 1);
879 }
880
881 if (_ret != RegError::NO_ERROR)
882 {
883 return _ret;
884 }
885
886 _err = rStoreDir.next(iter);
887 }
888
889 return RegError::NO_ERROR;
890 }
891
892 RegError ORegistry::dumpValue(const OUString& sPath, const OUString& sName, sal_Int16 nSpc) const
893 {
894 OStoreStream rValue;
895 sal_uInt32 valueSize;
896 RegValueType valueType;
897 OUString sFullPath(sPath);
898 OString sIndent;
899 storeAccessMode accessMode = storeAccessMode::ReadWrite;
900
901 if (isReadOnly())
902 {
903 accessMode = storeAccessMode::ReadOnly;
904 }
905
906 for (int i= 0; i < nSpc; i++) sIndent += " ";
907
908 if (sFullPath.getLength() > 1)
909 {
910 sFullPath += ROOT;
911 }
912 if (rValue.create(m_file, sFullPath, sName, accessMode))
913 {
914 return RegError::VALUE_NOT_EXISTS;
915 }
916
917 std::vector<sal_uInt8> aBuffer(VALUE_HEADERSIZE);
918
919 sal_uInt32 rwBytes;
920 if (rValue.readAt(0, aBuffer.data(), VALUE_HEADERSIZE, rwBytes))
921 {
922 return RegError::INVALID_VALUE;
923 }
924 if (rwBytes != (VALUE_HEADERSIZE))
925 {
926 return RegError::INVALID_VALUE;
927 }
928
929 sal_uInt8 type = aBuffer[0];
930 valueType = static_cast<RegValueType>(type);
931 readUINT32(aBuffer.data() + VALUE_TYPEOFFSET, valueSize);
932
933 aBuffer.resize(valueSize);
934 if (rValue.readAt(VALUE_HEADEROFFSET, aBuffer.data(), valueSize, rwBytes))
935 {
936 return RegError::INVALID_VALUE;
937 }
938 if (rwBytes != valueSize)
939 {
940 return RegError::INVALID_VALUE;
941 }
942
943 const char* indent = sIndent.getStr();
944 switch (valueType)
945 {
946 case RegValueType::NOT_DEFINED:
947 fprintf(stdout, "%sValue: Type = VALUETYPE_NOT_DEFINED\n", indent);
948 break;
949 case RegValueType::LONG:
950 {
951 fprintf(stdout, "%sValue: Type = RegValueType::LONG\n", indent);
952 fprintf(
953 stdout, "%s Size = %lu\n", indent,
954 sal::static_int_cast< unsigned long >(valueSize));
955 fprintf(stdout, "%s Data = ", indent);
956
957 sal_Int32 value;
958 readINT32(aBuffer.data(), value);
959 fprintf(stdout, "%ld\n", sal::static_int_cast< long >(value));
960 }
961 break;
962 case RegValueType::STRING:
963 {
964 char* value = static_cast<char*>(std::malloc(valueSize));
965 readUtf8(aBuffer.data(), value, valueSize);
966 fprintf(stdout, "%sValue: Type = RegValueType::STRING\n", indent);
967 fprintf(
968 stdout, "%s Size = %lu\n", indent,
969 sal::static_int_cast< unsigned long >(valueSize));
970 fprintf(stdout, "%s Data = \"%s\"\n", indent, value);
971 std::free(value);
972 }
973 break;
974 case RegValueType::UNICODE:
975 {
976 sal_uInt32 size = (valueSize / 2) * sizeof(sal_Unicode);
977 fprintf(stdout, "%sValue: Type = RegValueType::UNICODE\n", indent);
978 fprintf(
979 stdout, "%s Size = %lu\n", indent,
980 sal::static_int_cast< unsigned long >(valueSize));
981 fprintf(stdout, "%s Data = ", indent);
982
983 std::unique_ptr<sal_Unicode[]> value(new sal_Unicode[size]);
984 readString(aBuffer.data(), value.get(), size);
985
986 OString uStr(value.get(), rtl_ustr_getLength(value.get()), RTL_TEXTENCODING_UTF8);
987 fprintf(stdout, "L\"%s\"\n", uStr.getStr());
988 }
989 break;
990 case RegValueType::BINARY:
991 {
992 fprintf(stdout, "%sValue: Type = RegValueType::BINARY\n", indent);
993 fprintf(
994 stdout, "%s Size = %lu\n", indent,
995 sal::static_int_cast< unsigned long >(valueSize));
996 fprintf(stdout, "%s Data = ", indent);
997 dumpType(
998 typereg::Reader(aBuffer.data(), valueSize),
999 sIndent + " ");
1000 }
1001 break;
1002 case RegValueType::LONGLIST:
1003 {
1004 sal_uInt32 offset = 4; // initial 4 bytes for the size of the array
1005 sal_uInt32 len = 0;
1006
1007 readUINT32(aBuffer.data(), len);
1008
1009 fprintf(stdout, "%sValue: Type = RegValueType::LONGLIST\n", indent);
1010 fprintf(
1011 stdout, "%s Size = %lu\n", indent,
1012 sal::static_int_cast< unsigned long >(valueSize));
1013 fprintf(
1014 stdout, "%s Len = %lu\n", indent,
1015 sal::static_int_cast< unsigned long >(len));
1016 fprintf(stdout, "%s Data = ", indent);
1017
1018 sal_Int32 longValue;
1019 for (sal_uInt32 i=0; i < len; i++)
1020 {
1021 readINT32(aBuffer.data() + offset, longValue);
1022
1023 if (offset > 4)
1024 fprintf(stdout, "%s ", indent);
1025
1026 fprintf(
1027 stdout, "%lu = %ld\n",
1028 sal::static_int_cast< unsigned long >(i),
1029 sal::static_int_cast< long >(longValue));
1030 offset += 4; // 4 Bytes for sal_Int32
1031 }
1032 }
1033 break;
1034 case RegValueType::STRINGLIST:
1035 {
1036 sal_uInt32 offset = 4; // initial 4 bytes for the size of the array
1037 sal_uInt32 sLen = 0;
1038 sal_uInt32 len = 0;
1039
1040 readUINT32(aBuffer.data(), len);
1041
1042 fprintf(stdout, "%sValue: Type = RegValueType::STRINGLIST\n", indent);
1043 fprintf(
1044 stdout, "%s Size = %lu\n", indent,
1045 sal::static_int_cast< unsigned long >(valueSize));
1046 fprintf(
1047 stdout, "%s Len = %lu\n", indent,
1048 sal::static_int_cast< unsigned long >(len));
1049 fprintf(stdout, "%s Data = ", indent);
1050
1051 for (sal_uInt32 i=0; i < len; i++)
1052 {
1053 readUINT32(aBuffer.data() + offset, sLen);
1054
1055 offset += 4; // 4 bytes (sal_uInt32) for the string size
1056
1057 char *pValue = static_cast<char*>(std::malloc(sLen));
1058 readUtf8(aBuffer.data() + offset, pValue, sLen);
1059
1060 if (offset > 8)
1061 fprintf(stdout, "%s ", indent);
1062
1063 fprintf(
1064 stdout, "%lu = \"%s\"\n",
1065 sal::static_int_cast< unsigned long >(i), pValue);
1066 std::free(pValue);
1067 offset += sLen;
1068 }
1069 }
1070 break;
1071 case RegValueType::UNICODELIST:
1072 {
1073 sal_uInt32 offset = 4; // initial 4 bytes for the size of the array
1074 sal_uInt32 sLen = 0;
1075 sal_uInt32 len = 0;
1076
1077 readUINT32(aBuffer.data(), len);
1078
1079 fprintf(stdout, "%sValue: Type = RegValueType::UNICODELIST\n", indent);
1080 fprintf(
1081 stdout, "%s Size = %lu\n", indent,
1082 sal::static_int_cast< unsigned long >(valueSize));
1083 fprintf(
1084 stdout, "%s Len = %lu\n", indent,
1085 sal::static_int_cast< unsigned long >(len));
1086 fprintf(stdout, "%s Data = ", indent);
1087
1088 OString uStr;
1089 for (sal_uInt32 i=0; i < len; i++)
1090 {
1091 readUINT32(aBuffer.data() + offset, sLen);
1092
1093 offset += 4; // 4 bytes (sal_uInt32) for the string size
1094
1095 sal_Unicode *pValue = static_cast<sal_Unicode*>(std::malloc((sLen / 2) * sizeof(sal_Unicode)));
1096 readString(aBuffer.data() + offset, pValue, sLen);
1097
1098 if (offset > 8)
1099 fprintf(stdout, "%s ", indent);
1100
1101 uStr = OString(pValue, rtl_ustr_getLength(pValue), RTL_TEXTENCODING_UTF8);
1102 fprintf(
1103 stdout, "%lu = L\"%s\"\n",
1104 sal::static_int_cast< unsigned long >(i),
1105 uStr.getStr());
1106
1107 offset += sLen;
1108
1109 std::free(pValue);
1110 }
1111 }
1112 break;
1113 }
1114
1115 fprintf(stdout, "\n");
1116
1117 return RegError::NO_ERROR;
1118 }
1119
1120 RegError ORegistry::dumpKey(const OUString& sPath, const OUString& sName, sal_Int16 nSpace) const
1121 {
1122 OStoreDirectory rStoreDir;
1123 OUString sFullPath(sPath);
1124 OString sIndent;
1125 storeAccessMode accessMode = storeAccessMode::ReadWrite;
1126 RegError _ret = RegError::NO_ERROR;
1127
1128 if (isReadOnly())
1129 {
1130 accessMode = storeAccessMode::ReadOnly;
1131 }
1132
1133 for (int i= 0; i < nSpace; i++) sIndent += " ";
1134
1135 if (sFullPath.getLength() > 1)
1136 sFullPath += ROOT;
1137
1138 storeError _err = rStoreDir.create(m_file, sFullPath, sName, accessMode);
1139
1140 if (_err == store_E_NotExists)
1141 return RegError::KEY_NOT_EXISTS;
1142 else if (_err == store_E_WrongFormat)
1143 return RegError::INVALID_KEY;
1144
1145 fprintf(stdout, "%s/ %s\n", sIndent.getStr(), OUStringToOString(sName, RTL_TEXTENCODING_UTF8).getStr());
1146
1147 OUString sSubPath(sFullPath);
1148 OUString sSubName;
1149 sSubPath += sName;
1150
1151 OStoreDirectory::iterator iter;
1152
1153 _err = rStoreDir.first(iter);
1154
1155 while (_err == store_E_None)
1156 {
1157 sSubName = OUString(iter.m_pszName, iter.m_nLength);
1158
1159 if (iter.m_nAttrib & STORE_ATTRIB_ISDIR)
1160 {
1161 _ret = dumpKey(sSubPath, sSubName, nSpace+2);
1162 } else
1163 {
1164 _ret = dumpValue(sSubPath, sSubName, nSpace+2);
1165 }
1166
1167 if (_ret != RegError::NO_ERROR)
1168 {
1169 return _ret;
1170 }
1171
1172 _err = rStoreDir.next(iter);
1173 }
1174
1175 return RegError::NO_ERROR;
1176 }
1177
1178 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE