?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
docthemes: Save themes def. to a file when added to ColorSets
[LibreOffice.git] / comphelper / source / misc / backupfilehelper.cxx
blob9710eaa3d66f5624434d387d45cd89c3e956a2d2
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
10 #include <sal/config.h>
11 #include <rtl/ustring.hxx>
12 #include <rtl/bootstrap.hxx>
13 #include <sal/log.hxx>
14 #include <osl/file.hxx>
15 #include <comphelper/backupfilehelper.hxx>
16 #include <comphelper/DirectoryHelper.hxx>
17 #include <rtl/crc.h>
18 #include <algorithm>
19 #include <deque>
20 #include <memory>
21 #include <string_view>
22 #include <utility>
23 #include <vector>
24 #include <zlib.h>
25
26 #include <comphelper/processfactory.hxx>
27 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
28 #include <com/sun/star/ucb/CommandAbortedException.hpp>
29 #include <com/sun/star/ucb/CommandFailedException.hpp>
30 #include <com/sun/star/uno/Sequence.hxx>
31 #include <com/sun/star/uno/Reference.hxx>
32 #include <com/sun/star/deployment/DeploymentException.hpp>
33 #include <com/sun/star/deployment/ExtensionManager.hpp>
34 #include <com/sun/star/xml/dom/XDocumentBuilder.hpp>
35 #include <com/sun/star/xml/dom/DocumentBuilder.hpp>
36 #include <com/sun/star/xml/dom/XElement.hpp>
37 #include <com/sun/star/xml/dom/XNodeList.hpp>
38 #include <com/sun/star/xml/dom/XText.hpp>
39 #include <com/sun/star/xml/sax/XSAXSerializable.hpp>
40 #include <com/sun/star/xml/sax/Writer.hpp>
41 #include <com/sun/star/xml/sax/XWriter.hpp>
42 #include <com/sun/star/io/XStream.hpp>
43 #include <com/sun/star/io/TempFile.hpp>
44 #include <com/sun/star/io/XOutputStream.hpp>
45 #include <com/sun/star/beans/XPropertySet.hpp>
46 #include <cppuhelper/exc_hlp.hxx>
47
48 using namespace comphelper;
49 using namespace css;
50 using namespace css::xml::dom;
51
52 const sal_uInt32 BACKUP_FILE_HELPER_BLOCK_SIZE = 16384;
53
54 namespace
55 {
56 typedef std::shared_ptr< osl::File > FileSharedPtr;
57
58 sal_uInt32 createCrc32(FileSharedPtr const & rCandidate, sal_uInt32 nOffset)
59 {
60 sal_uInt32 nCrc32(0);
61
62 if (rCandidate && osl::File::E_None == rCandidate->open(osl_File_OpenFlag_Read))
63 {
64 sal_uInt8 aArray[BACKUP_FILE_HELPER_BLOCK_SIZE];
65 sal_uInt64 nBytesTransfer(0);
66 sal_uInt64 nSize(0);
67
68 rCandidate->getSize(nSize);
69
70 // set offset in source file - should be zero due to crc32 should
71 // only be needed to be created for new entries, gets loaded with old
72 // ones
73 if (osl::File::E_None == rCandidate->setPos(osl_Pos_Absolut, sal_Int64(nOffset)))
74 {
75 while (nSize != 0)
76 {
77 const sal_uInt64 nToTransfer(std::min(nSize, sal_uInt64(BACKUP_FILE_HELPER_BLOCK_SIZE)));
78
79 if (osl::File::E_None == rCandidate->read(static_cast<void*>(aArray), nToTransfer, nBytesTransfer) && nBytesTransfer == nToTransfer)
80 {
81 // add to crc and reduce size
82 nCrc32 = rtl_crc32(nCrc32, static_cast<void*>(aArray), static_cast<sal_uInt32>(nBytesTransfer));
83 nSize -= nToTransfer;
84 }
85 else
86 {
87 // error - reset to zero again
88 nSize = nCrc32 = 0;
89 }
90 }
91 }
92
93 rCandidate->close();
94 }
95
96 return nCrc32;
97 }
98
99 bool read_sal_uInt32(FileSharedPtr const & rFile, sal_uInt32& rTarget)
100 {
101 sal_uInt8 aArray[4];
102 sal_uInt64 nBaseRead(0);
103
104 // read rTarget
105 if (osl::File::E_None == rFile->read(static_cast<void*>(aArray), 4, nBaseRead) && 4 == nBaseRead)
106 {
107 rTarget = (sal_uInt32(aArray[0]) << 24) + (sal_uInt32(aArray[1]) << 16) + (sal_uInt32(aArray[2]) << 8) + sal_uInt32(aArray[3]);
108 return true;
109 }
110
111 return false;
112 }
113
114 bool write_sal_uInt32(oslFileHandle& rHandle, sal_uInt32 nSource)
115 {
116 sal_uInt8 aArray[4];
117 sal_uInt64 nBaseWritten(0);
118
119 // write nSource
120 aArray[0] = sal_uInt8((nSource & 0xff000000) >> 24);
121 aArray[1] = sal_uInt8((nSource & 0x00ff0000) >> 16);
122 aArray[2] = sal_uInt8((nSource & 0x0000ff00) >> 8);
123 aArray[3] = sal_uInt8(nSource & 0x000000ff);
124
125 return osl_File_E_None == osl_writeFile(rHandle, static_cast<const void*>(aArray), 4, &nBaseWritten) && 4 == nBaseWritten;
126 }
127
128 bool read_OString(FileSharedPtr const & rFile, OString& rTarget)
129 {
130 sal_uInt32 nLength(0);
131
132 if (!read_sal_uInt32(rFile, nLength))
133 {
134 return false;
135 }
136
137 sal_uInt64 nPos;
138 if (osl::File::E_None != rFile->getPos(nPos))
139 return false;
140
141 sal_uInt64 nSize;
142 if (osl::File::E_None != rFile->getSize(nSize))
143 return false;
144
145 const auto nRemainingSize = nSize - nPos;
146 if (nLength > nRemainingSize)
147 return false;
148
149 std::vector<char> aTarget(nLength);
150 sal_uInt64 nBaseRead(0);
151
152 // read rTarget
153 if (osl::File::E_None == rFile->read(static_cast<void*>(aTarget.data()), nLength, nBaseRead) && nLength == nBaseRead)
154 {
155 rTarget = OString(aTarget.data(), static_cast<sal_Int32>(nBaseRead));
156 return true;
157 }
158
159 return false;
160 }
161
162 bool write_OString(oslFileHandle& rHandle, const OString& rSource)
163 {
164 const sal_uInt32 nLength(rSource.getLength());
165
166 if (!write_sal_uInt32(rHandle, nLength))
167 {
168 return false;
169 }
170
171 sal_uInt64 nBaseWritten(0);
172
173 return osl_File_E_None == osl_writeFile(rHandle, static_cast<const void*>(rSource.getStr()), nLength, &nBaseWritten) && nLength == nBaseWritten;
174 }
175
176 OUString createFileURL(
177 std::u16string_view rURL, std::u16string_view rName, std::u16string_view rExt)
178 {
179 OUString aRetval;
180
181 if (!rURL.empty() && !rName.empty())
182 {
183 aRetval = OUString::Concat(rURL) + "/" + rName;
184
185 if (!rExt.empty())
186 {
187 aRetval += OUString::Concat(".") + rExt;
188 }
189 }
190
191 return aRetval;
192 }
193
194 OUString createPackURL(std::u16string_view rURL, std::u16string_view rName)
195 {
196 OUString aRetval;
197
198 if (!rURL.empty() && !rName.empty())
199 {
200 aRetval = OUString::Concat(rURL) + "/" + rName + ".pack";
201 }
202
203 return aRetval;
204 }
205 }
206
207 namespace
208 {
209 enum PackageRepository { USER, SHARED, BUNDLED };
210
211 class ExtensionInfoEntry
212 {
213 private:
214 OString maName; // extension name
215 PackageRepository maRepository; // user|shared|bundled
216 bool mbEnabled; // state
217
218 public:
219 ExtensionInfoEntry()
220 : maRepository(USER),
221 mbEnabled(false)
222 {
223 }
224
225 ExtensionInfoEntry(OString aName, bool bEnabled)
226 : maName(std::move(aName)),
227 maRepository(USER),
228 mbEnabled(bEnabled)
229 {
230 }
231
232 ExtensionInfoEntry(const uno::Reference< deployment::XPackage >& rxPackage)
233 : maName(OUStringToOString(rxPackage->getName(), RTL_TEXTENCODING_ASCII_US)),
234 maRepository(USER),
235 mbEnabled(false)
236 {
237 // check maRepository
238 const OString aRepName(OUStringToOString(rxPackage->getRepositoryName(), RTL_TEXTENCODING_ASCII_US));
239
240 if (aRepName == "shared")
241 {
242 maRepository = SHARED;
243 }
244 else if (aRepName == "bundled")
245 {
246 maRepository = BUNDLED;
247 }
248
249 // check mbEnabled
250 const beans::Optional< beans::Ambiguous< sal_Bool > > option(
251 rxPackage->isRegistered(uno::Reference< task::XAbortChannel >(),
252 uno::Reference< ucb::XCommandEnvironment >()));
253
254 if (option.IsPresent)
255 {
256 ::beans::Ambiguous< sal_Bool > const& reg = option.Value;
257
258 if (!reg.IsAmbiguous)
259 {
260 mbEnabled = reg.Value;
261 }
262 }
263 }
264
265 bool isSameExtension(const ExtensionInfoEntry& rComp) const
266 {
267 return (maRepository == rComp.maRepository && maName == rComp.maName);
268 }
269
270 bool operator<(const ExtensionInfoEntry& rComp) const
271 {
272 if (maRepository == rComp.maRepository)
273 {
274 if (maName == rComp.maName)
275 {
276 return mbEnabled < rComp.mbEnabled;
277 }
278 else
279 {
280 return 0 > maName.compareTo(rComp.maName);
281 }
282 }
283 else
284 {
285 return maRepository < rComp.maRepository;
286 }
287 }
288
289 bool read_entry(FileSharedPtr const & rFile)
290 {
291 // read maName
292 if (!read_OString(rFile, maName))
293 {
294 return false;
295 }
296
297 // read maRepository
298 sal_uInt32 nState(0);
299
300 if (read_sal_uInt32(rFile, nState))
301 {
302 maRepository = static_cast< PackageRepository >(nState);
303 }
304 else
305 {
306 return false;
307 }
308
309 // read mbEnabled
310 if (read_sal_uInt32(rFile, nState))
311 {
312 mbEnabled = static_cast< bool >(nState);
313 }
314 else
315 {
316 return false;
317 }
318
319 return true;
320 }
321
322 bool write_entry(oslFileHandle& rHandle) const
323 {
324 // write maName;
325 if (!write_OString(rHandle, maName))
326 {
327 return false;
328 }
329
330 // write maRepository
331 sal_uInt32 nState(maRepository);
332
333 if (!write_sal_uInt32(rHandle, nState))
334 {
335 return false;
336 }
337
338 // write mbEnabled
339 nState = static_cast< sal_uInt32 >(mbEnabled);
340
341 return write_sal_uInt32(rHandle, nState);
342 }
343
344 const OString& getName() const
345 {
346 return maName;
347 }
348
349 bool isEnabled() const
350 {
351 return mbEnabled;
352 }
353 };
354
355 typedef std::vector< ExtensionInfoEntry > ExtensionInfoEntryVector;
356
357 constexpr OUString gaRegPath { u"/registry/com.sun.star.comp.deployment.bundle.PackageRegistryBackend/backenddb.xml"_ustr };
358
359 class ExtensionInfo
360 {
361 private:
362 ExtensionInfoEntryVector maEntries;
363
364 public:
365 ExtensionInfo()
366 {
367 }
368
369 const ExtensionInfoEntryVector& getExtensionInfoEntryVector() const
370 {
371 return maEntries;
372 }
373
374 void reset()
375 {
376 // clear all data
377 maEntries.clear();
378 }
379
380 void createUsingXExtensionManager()
381 {
382 // clear all data
383 reset();
384
385 // create content from current extension configuration
386 uno::Sequence< uno::Sequence< uno::Reference< deployment::XPackage > > > xAllPackages;
387 const uno::Reference< uno::XComponentContext >& xContext = ::comphelper::getProcessComponentContext();
388 uno::Reference< deployment::XExtensionManager > m_xExtensionManager = deployment::ExtensionManager::get(xContext);
389
390 try
391 {
392 xAllPackages = m_xExtensionManager->getAllExtensions(uno::Reference< task::XAbortChannel >(),
393 uno::Reference< ucb::XCommandEnvironment >());
394 }
395 catch (const deployment::DeploymentException &)
396 {
397 return;
398 }
399 catch (const ucb::CommandFailedException &)
400 {
401 return;
402 }
403 catch (const ucb::CommandAbortedException &)
404 {
405 return;
406 }
407 catch (const lang::IllegalArgumentException & e)
408 {
409 css::uno::Any anyEx = cppu::getCaughtException();
410 throw css::lang::WrappedTargetRuntimeException( e.Message,
411 e.Context, anyEx );
412 }
413
414 for (const uno::Sequence< uno::Reference< deployment::XPackage > > & xPackageList : xAllPackages)
415 {
416 for (const uno::Reference< deployment::XPackage > & xPackage : xPackageList)
417 {
418 if (xPackage.is())
419 {
420 maEntries.emplace_back(xPackage);
421 }
422 }
423 }
424
425 if (!maEntries.empty())
426 {
427 // sort the list
428 std::sort(maEntries.begin(), maEntries.end());
429 }
430 }
431
432 private:
433 void visitNodesXMLRead(const uno::Reference< xml::dom::XElement >& rElement)
434 {
435 if (!rElement.is())
436 return;
437
438 const OUString aTagName(rElement->getTagName());
439
440 if (aTagName == "extension")
441 {
442 OUString aAttrUrl(rElement->getAttribute(u"url"_ustr));
443 const OUString aAttrRevoked(rElement->getAttribute(u"revoked"_ustr));
444
445 if (!aAttrUrl.isEmpty())
446 {
447 const sal_Int32 nIndex(aAttrUrl.lastIndexOf('/'));
448
449 if (nIndex > 0 && aAttrUrl.getLength() > nIndex + 1)
450 {
451 aAttrUrl = aAttrUrl.copy(nIndex + 1);
452 }
453
454 const bool bEnabled(aAttrRevoked.isEmpty() || !aAttrRevoked.toBoolean());
455 maEntries.emplace_back(
456 OUStringToOString(aAttrUrl, RTL_TEXTENCODING_ASCII_US),
457 bEnabled);
458 }
459 }
460 else
461 {
462 uno::Reference< xml::dom::XNodeList > aList = rElement->getChildNodes();
463
464 if (aList.is())
465 {
466 const sal_Int32 nLength(aList->getLength());
467
468 for (sal_Int32 a(0); a < nLength; a++)
469 {
470 const uno::Reference< xml::dom::XElement > aChild(aList->item(a), uno::UNO_QUERY);
471
472 if (aChild.is())
473 {
474 visitNodesXMLRead(aChild);
475 }
476 }
477 }
478 }
479 }
480
481 public:
482 void createUserExtensionRegistryEntriesFromXML(std::u16string_view rUserConfigWorkURL)
483 {
484 const OUString aPath(
485 OUString::Concat(rUserConfigWorkURL) + "/uno_packages/cache" + gaRegPath);
486 createExtensionRegistryEntriesFromXML(aPath);
487 }
488
489 void createSharedExtensionRegistryEntriesFromXML(std::u16string_view rUserConfigWorkURL)
490 {
491 const OUString aPath(
492 OUString::Concat(rUserConfigWorkURL) + "/extensions/shared" + gaRegPath);
493 createExtensionRegistryEntriesFromXML(aPath);
494 }
495
496 void createBundledExtensionRegistryEntriesFromXML(std::u16string_view rUserConfigWorkURL)
497 {
498 const OUString aPath(
499 OUString::Concat(rUserConfigWorkURL) + "/extensions/bundled" + gaRegPath);
500 createExtensionRegistryEntriesFromXML(aPath);
501 }
502
503
504 void createExtensionRegistryEntriesFromXML(const OUString& aPath)
505 {
506 if (DirectoryHelper::fileExists(aPath))
507 {
508 const uno::Reference< uno::XComponentContext >& xContext = ::comphelper::getProcessComponentContext();
509 uno::Reference< xml::dom::XDocumentBuilder > xBuilder(xml::dom::DocumentBuilder::create(xContext));
510 uno::Reference< xml::dom::XDocument > aDocument = xBuilder->parseURI(aPath);
511
512 if (aDocument.is())
513 {
514 visitNodesXMLRead(aDocument->getDocumentElement());
515 }
516 }
517
518 if (!maEntries.empty())
519 {
520 // sort the list
521 std::sort(maEntries.begin(), maEntries.end());
522 }
523 }
524
525 private:
526 static bool visitNodesXMLChange(
527 const OUString& rTagToSearch,
528 const uno::Reference< xml::dom::XElement >& rElement,
529 const ExtensionInfoEntryVector& rToBeEnabled,
530 const ExtensionInfoEntryVector& rToBeDisabled)
531 {
532 bool bChanged(false);
533
534 if (rElement.is())
535 {
536 const OUString aTagName(rElement->getTagName());
537
538 if (aTagName == rTagToSearch)
539 {
540 const OString aAttrUrl(OUStringToOString(rElement->getAttribute(u"url"_ustr), RTL_TEXTENCODING_ASCII_US));
541 const OUString aAttrRevoked(rElement->getAttribute(u"revoked"_ustr));
542 const bool bEnabled(aAttrRevoked.isEmpty() || !aAttrRevoked.toBoolean());
543
544 if (!aAttrUrl.isEmpty())
545 {
546 for (const auto& enable : rToBeEnabled)
547 {
548 if (-1 != aAttrUrl.indexOf(enable.getName()))
549 {
550 if (!bEnabled)
551 {
552 // needs to be enabled
553 rElement->removeAttribute(u"revoked"_ustr);
554 bChanged = true;
555 }
556 }
557 }
558
559 for (const auto& disable : rToBeDisabled)
560 {
561 if (-1 != aAttrUrl.indexOf(disable.getName()))
562 {
563 if (bEnabled)
564 {
565 // needs to be disabled
566 rElement->setAttribute(u"revoked"_ustr, u"true"_ustr);
567 bChanged = true;
568 }
569 }
570 }
571 }
572 }
573 else
574 {
575 uno::Reference< xml::dom::XNodeList > aList = rElement->getChildNodes();
576
577 if (aList.is())
578 {
579 const sal_Int32 nLength(aList->getLength());
580
581 for (sal_Int32 a(0); a < nLength; a++)
582 {
583 const uno::Reference< xml::dom::XElement > aChild(aList->item(a), uno::UNO_QUERY);
584
585 if (aChild.is())
586 {
587 bChanged |= visitNodesXMLChange(
588 rTagToSearch,
589 aChild,
590 rToBeEnabled,
591 rToBeDisabled);
592 }
593 }
594 }
595 }
596 }
597
598 return bChanged;
599 }
600
601 static void visitNodesXMLChangeOneCase(
602 const OUString& rUnoPackagReg,
603 const OUString& rTagToSearch,
604 const ExtensionInfoEntryVector& rToBeEnabled,
605 const ExtensionInfoEntryVector& rToBeDisabled)
606 {
607 if (!DirectoryHelper::fileExists(rUnoPackagReg))
608 return;
609
610 const uno::Reference< uno::XComponentContext >& xContext = ::comphelper::getProcessComponentContext();
611 uno::Reference< xml::dom::XDocumentBuilder > xBuilder = xml::dom::DocumentBuilder::create(xContext);
612 uno::Reference< xml::dom::XDocument > aDocument = xBuilder->parseURI(rUnoPackagReg);
613
614 if (!aDocument.is())
615 return;
616
617 if (!visitNodesXMLChange(
618 rTagToSearch,
619 aDocument->getDocumentElement(),
620 rToBeEnabled,
621 rToBeDisabled))
622 return;
623
624 // did change - write back
625 uno::Reference< xml::sax::XSAXSerializable > xSerializer(aDocument, uno::UNO_QUERY);
626
627 if (!xSerializer.is())
628 return;
629
630 // create a SAXWriter
631 uno::Reference< xml::sax::XWriter > const xSaxWriter = xml::sax::Writer::create(xContext);
632 uno::Reference< io::XTempFile > xTempFile = io::TempFile::create(xContext);
633 uno::Reference< io::XOutputStream > xOutStrm = xTempFile->getOutputStream();
634
635 // set output stream and do the serialization
636 xSaxWriter->setOutputStream(xOutStrm);
637 xSerializer->serialize(xSaxWriter, uno::Sequence< beans::StringPair >());
638
639 // get URL from temp file
640 OUString aTempURL = xTempFile->getUri();
641
642 // copy back file
643 if (aTempURL.isEmpty() || !DirectoryHelper::fileExists(aTempURL))
644 return;
645
646 if (DirectoryHelper::fileExists(rUnoPackagReg))
647 {
648 osl::File::remove(rUnoPackagReg);
649 }
650
651 #if OSL_DEBUG_LEVEL > 1
652 SAL_WARN_IF(osl::FileBase::E_None != osl::File::move(aTempURL, rUnoPackagReg), "comphelper.backupfilehelper", "could not copy back modified Extension configuration file");
653 #else
654 osl::File::move(aTempURL, rUnoPackagReg);
655 #endif
656 }
657
658 public:
659 static void changeEnableDisableStateInXML(
660 std::u16string_view rUserConfigWorkURL,
661 const ExtensionInfoEntryVector& rToBeEnabled,
662 const ExtensionInfoEntryVector& rToBeDisabled)
663 {
664 static constexpr OUString aRegPathFront(u"/uno_packages/cache/registry/com.sun.star.comp.deployment."_ustr);
665 static constexpr OUString aRegPathBack(u".PackageRegistryBackend/backenddb.xml"_ustr);
666 // first appearance to check
667 {
668 const OUString aUnoPackagReg(OUString::Concat(rUserConfigWorkURL) + aRegPathFront + "bundle" + aRegPathBack);
669
670 visitNodesXMLChangeOneCase(
671 aUnoPackagReg,
672 u"extension"_ustr,
673 rToBeEnabled,
674 rToBeDisabled);
675 }
676
677 // second appearance to check
678 {
679 const OUString aUnoPackagReg(OUString::Concat(rUserConfigWorkURL) + aRegPathFront + "configuration" + aRegPathBack);
680
681 visitNodesXMLChangeOneCase(
682 aUnoPackagReg,
683 u"configuration"_ustr,
684 rToBeEnabled,
685 rToBeDisabled);
686 }
687
688 // third appearance to check
689 {
690 const OUString aUnoPackagReg(OUString::Concat(rUserConfigWorkURL) + aRegPathFront + "script" + aRegPathBack);
691
692 visitNodesXMLChangeOneCase(
693 aUnoPackagReg,
694 u"script"_ustr,
695 rToBeEnabled,
696 rToBeDisabled);
697 }
698 }
699
700 bool read_entries(FileSharedPtr const & rFile)
701 {
702 // read NumExtensionEntries
703 sal_uInt32 nExtEntries(0);
704
705 if (!read_sal_uInt32(rFile, nExtEntries))
706 {
707 return false;
708 }
709
710 // coverity#1373663 Untrusted loop bound, check file size
711 // isn't utterly broken
712 sal_uInt64 nFileSize(0);
713 rFile->getSize(nFileSize);
714 if (nFileSize < nExtEntries)
715 return false;
716
717 for (sal_uInt32 a(0); a < nExtEntries; a++)
718 {
719 ExtensionInfoEntry aNewEntry;
720
721 if (aNewEntry.read_entry(rFile))
722 {
723 maEntries.push_back(aNewEntry);
724 }
725 else
726 {
727 return false;
728 }
729 }
730
731 return true;
732 }
733
734 bool write_entries(oslFileHandle& rHandle) const
735 {
736 const sal_uInt32 nExtEntries(maEntries.size());
737
738 if (!write_sal_uInt32(rHandle, nExtEntries))
739 {
740 return false;
741 }
742
743 for (const auto& a : maEntries)
744 {
745 if (!a.write_entry(rHandle))
746 {
747 return false;
748 }
749 }
750
751 return true;
752 }
753
754 bool createTempFile(OUString& rTempFileName)
755 {
756 oslFileHandle aHandle;
757 bool bRetval(false);
758
759 // create current configuration
760 if (maEntries.empty())
761 {
762 createUsingXExtensionManager();
763 }
764
765 // open target temp file and write current configuration to it - it exists until deleted
766 if (osl::File::E_None == osl::FileBase::createTempFile(nullptr, &aHandle, &rTempFileName))
767 {
768 bRetval = write_entries(aHandle);
769
770 // close temp file - it exists until deleted
771 osl_closeFile(aHandle);
772 }
773
774 return bRetval;
775 }
776
777 bool areThereEnabledExtensions() const
778 {
779 for (const auto& a : maEntries)
780 {
781 if (a.isEnabled())
782 {
783 return true;
784 }
785 }
786
787 return false;
788 }
789 };
790 }
791
792 namespace
793 {
794 class PackedFileEntry
795 {
796 private:
797 sal_uInt32 mnFullFileSize; // size in bytes of unpacked original file
798 sal_uInt32 mnPackFileSize; // size in bytes in file backup package (smaller if compressed, same if not)
799 sal_uInt32 mnOffset; // offset in File (zero identifies new file)
800 sal_uInt32 mnCrc32; // checksum
801 FileSharedPtr maFile; // file where to find the data (at offset)
802 bool const mbDoCompress; // flag if this file is scheduled to be compressed when written
803
804 bool copy_content_straight(oslFileHandle& rTargetHandle)
805 {
806 if (!maFile || osl::File::E_None != maFile->open(osl_File_OpenFlag_Read))
807 return false;
808
809 sal_uInt8 aArray[BACKUP_FILE_HELPER_BLOCK_SIZE];
810 sal_uInt64 nBytesTransfer(0);
811 sal_uInt64 nSize(getPackFileSize());
812
813 // set offset in source file - when this is zero, a new file is to be added
814 if (osl::File::E_None == maFile->setPos(osl_Pos_Absolut, sal_Int64(getOffset())))
815 {
816 while (nSize != 0)
817 {
818 const sal_uInt64 nToTransfer(std::min(nSize, sal_uInt64(BACKUP_FILE_HELPER_BLOCK_SIZE)));
819
820 if (osl::File::E_None != maFile->read(static_cast<void*>(aArray), nToTransfer, nBytesTransfer) || nBytesTransfer != nToTransfer)
821 {
822 break;
823 }
824
825 if (osl_File_E_None != osl_writeFile(rTargetHandle, static_cast<const void*>(aArray), nToTransfer, &nBytesTransfer) || nBytesTransfer != nToTransfer)
826 {
827 break;
828 }
829
830 nSize -= nToTransfer;
831 }
832 }
833
834 maFile->close();
835 return (0 == nSize);
836 }
837
838 bool copy_content_compress(oslFileHandle& rTargetHandle)
839 {
840 if (!maFile || osl::File::E_None != maFile->open(osl_File_OpenFlag_Read))
841 return false;
842
843 sal_uInt8 aArray[BACKUP_FILE_HELPER_BLOCK_SIZE];
844 sal_uInt8 aBuffer[BACKUP_FILE_HELPER_BLOCK_SIZE];
845 sal_uInt64 nBytesTransfer(0);
846 sal_uInt64 nSize(getPackFileSize());
847 z_stream zstream;
848 memset(&zstream, 0, sizeof(zstream));
849
850 if (Z_OK == deflateInit(&zstream, Z_BEST_COMPRESSION))
851 {
852 // set offset in source file - when this is zero, a new file is to be added
853 if (osl::File::E_None == maFile->setPos(osl_Pos_Absolut, sal_Int64(getOffset())))
854 {
855 bool bOkay(true);
856
857 while (bOkay && nSize != 0)
858 {
859 const sal_uInt64 nToTransfer(std::min(nSize, sal_uInt64(BACKUP_FILE_HELPER_BLOCK_SIZE)));
860
861 if (osl::File::E_None != maFile->read(static_cast<void*>(aArray), nToTransfer, nBytesTransfer) || nBytesTransfer != nToTransfer)
862 {
863 break;
864 }
865
866 zstream.avail_in = nToTransfer;
867 zstream.next_in = reinterpret_cast<unsigned char*>(aArray);
868
869 do {
870 zstream.avail_out = BACKUP_FILE_HELPER_BLOCK_SIZE;
871 zstream.next_out = reinterpret_cast<unsigned char*>(aBuffer);
872 #if !defined Z_PREFIX
873 const sal_Int64 nRetval(deflate(&zstream, nSize == nToTransfer ? Z_FINISH : Z_NO_FLUSH));
874 #else
875 const sal_Int64 nRetval(z_deflate(&zstream, nSize == nToTransfer ? Z_FINISH : Z_NO_FLUSH));
876 #endif
877 if (Z_STREAM_ERROR == nRetval)
878 {
879 bOkay = false;
880 }
881 else
882 {
883 const sal_uInt64 nAvailable(BACKUP_FILE_HELPER_BLOCK_SIZE - zstream.avail_out);
884
885 if (osl_File_E_None != osl_writeFile(rTargetHandle, static_cast<const void*>(aBuffer), nAvailable, &nBytesTransfer) || nBytesTransfer != nAvailable)
886 {
887 bOkay = false;
888 }
889 }
890 } while (bOkay && 0 == zstream.avail_out);
891
892 if (!bOkay)
893 {
894 break;
895 }
896
897 nSize -= nToTransfer;
898 }
899
900 #if !defined Z_PREFIX
901 deflateEnd(&zstream);
902 #else
903 z_deflateEnd(&zstream);
904 #endif
905 }
906 }
907
908 maFile->close();
909
910 // get compressed size and add to entry
911 if (mnFullFileSize == mnPackFileSize && mnFullFileSize == zstream.total_in)
912 {
913 mnPackFileSize = zstream.total_out;
914 }
915
916 return (0 == nSize);
917 }
918
919 bool copy_content_uncompress(oslFileHandle& rTargetHandle)
920 {
921 if (!maFile || osl::File::E_None != maFile->open(osl_File_OpenFlag_Read))
922 return false;
923
924 sal_uInt8 aArray[BACKUP_FILE_HELPER_BLOCK_SIZE];
925 sal_uInt8 aBuffer[BACKUP_FILE_HELPER_BLOCK_SIZE];
926 sal_uInt64 nBytesTransfer(0);
927 sal_uInt64 nSize(getPackFileSize());
928 z_stream zstream;
929 memset(&zstream, 0, sizeof(zstream));
930
931 if (Z_OK == inflateInit(&zstream))
932 {
933 // set offset in source file - when this is zero, a new file is to be added
934 if (osl::File::E_None == maFile->setPos(osl_Pos_Absolut, sal_Int64(getOffset())))
935 {
936 bool bOkay(true);
937
938 while (bOkay && nSize != 0)
939 {
940 const sal_uInt64 nToTransfer(std::min(nSize, sal_uInt64(BACKUP_FILE_HELPER_BLOCK_SIZE)));
941
942 if (osl::File::E_None != maFile->read(static_cast<void*>(aArray), nToTransfer, nBytesTransfer) || nBytesTransfer != nToTransfer)
943 {
944 break;
945 }
946
947 zstream.avail_in = nToTransfer;
948 zstream.next_in = reinterpret_cast<unsigned char*>(aArray);
949
950 do {
951 zstream.avail_out = BACKUP_FILE_HELPER_BLOCK_SIZE;
952 zstream.next_out = reinterpret_cast<unsigned char*>(aBuffer);
953 #if !defined Z_PREFIX
954 const sal_Int64 nRetval(inflate(&zstream, Z_NO_FLUSH));
955 #else
956 const sal_Int64 nRetval(z_inflate(&zstream, Z_NO_FLUSH));
957 #endif
958 if (Z_STREAM_ERROR == nRetval)
959 {
960 bOkay = false;
961 }
962 else
963 {
964 const sal_uInt64 nAvailable(BACKUP_FILE_HELPER_BLOCK_SIZE - zstream.avail_out);
965
966 if (osl_File_E_None != osl_writeFile(rTargetHandle, static_cast<const void*>(aBuffer), nAvailable, &nBytesTransfer) || nBytesTransfer != nAvailable)
967 {
968 bOkay = false;
969 }
970 }
971 } while (bOkay && 0 == zstream.avail_out);
972
973 if (!bOkay)
974 {
975 break;
976 }
977
978 nSize -= nToTransfer;
979 }
980
981 #if !defined Z_PREFIX
982 deflateEnd(&zstream);
983 #else
984 z_deflateEnd(&zstream);
985 #endif
986 }
987 }
988
989 maFile->close();
990 return (0 == nSize);
991 }
992
993
994 public:
995 // create new, uncompressed entry
996 PackedFileEntry(
997 sal_uInt32 nFullFileSize,
998 sal_uInt32 nCrc32,
999 FileSharedPtr xFile,
1000 bool bDoCompress)
1001 : mnFullFileSize(nFullFileSize),
1002 mnPackFileSize(nFullFileSize),
1003 mnOffset(0),
1004 mnCrc32(nCrc32),
1005 maFile(std::move(xFile)),
1006 mbDoCompress(bDoCompress)
1007 {
1008 }
1009
1010 // create entry to be loaded as header (read_header)
1011 PackedFileEntry()
1012 : mnFullFileSize(0),
1013 mnPackFileSize(0),
1014 mnOffset(0),
1015 mnCrc32(0),
1016 mbDoCompress(false)
1017 {
1018 }
1019
1020 sal_uInt32 getFullFileSize() const
1021 {
1022 return mnFullFileSize;
1023 }
1024
1025 sal_uInt32 getPackFileSize() const
1026 {
1027 return mnPackFileSize;
1028 }
1029
1030 sal_uInt32 getOffset() const
1031 {
1032 return mnOffset;
1033 }
1034
1035 void setOffset(sal_uInt32 nOffset)
1036 {
1037 mnOffset = nOffset;
1038 }
1039
1040 static sal_uInt32 getEntrySize()
1041 {
1042 return 12;
1043 }
1044
1045 sal_uInt32 getCrc32() const
1046 {
1047 return mnCrc32;
1048 }
1049
1050 bool read_header(FileSharedPtr const & rFile)
1051 {
1052 if (!rFile)
1053 {
1054 return false;
1055 }
1056
1057 maFile = rFile;
1058
1059 // read and compute full file size
1060 if (!read_sal_uInt32(rFile, mnFullFileSize))
1061 {
1062 return false;
1063 }
1064
1065 // read and compute entry crc32
1066 if (!read_sal_uInt32(rFile, mnCrc32))
1067 {
1068 return false;
1069 }
1070
1071 // read and compute packed size
1072 if (!read_sal_uInt32(rFile, mnPackFileSize))
1073 {
1074 return false;
1075 }
1076
1077 return true;
1078 }
1079
1080 bool write_header(oslFileHandle& rHandle) const
1081 {
1082 // write full file size
1083 if (!write_sal_uInt32(rHandle, mnFullFileSize))
1084 {
1085 return false;
1086 }
1087
1088 // write crc32
1089 if (!write_sal_uInt32(rHandle, mnCrc32))
1090 {
1091 return false;
1092 }
1093
1094 // write packed file size
1095 if (!write_sal_uInt32(rHandle, mnPackFileSize))
1096 {
1097 return false;
1098 }
1099
1100 return true;
1101 }
1102
1103 bool copy_content(oslFileHandle& rTargetHandle, bool bUncompress)
1104 {
1105 if (bUncompress)
1106 {
1107 if (getFullFileSize() == getPackFileSize())
1108 {
1109 // not compressed, just copy
1110 return copy_content_straight(rTargetHandle);
1111 }
1112 else
1113 {
1114 // compressed, need to uncompress on copy
1115 return copy_content_uncompress(rTargetHandle);
1116 }
1117 }
1118 else if (0 == getOffset())
1119 {
1120 if (mbDoCompress)
1121 {
1122 // compressed wanted, need to compress on copy
1123 return copy_content_compress(rTargetHandle);
1124 }
1125 else
1126 {
1127 // not compressed, straight copy
1128 return copy_content_straight(rTargetHandle);
1129 }
1130 }
1131 else
1132 {
1133 return copy_content_straight(rTargetHandle);
1134 }
1135 }
1136 };
1137 }
1138
1139 namespace
1140 {
1141 class PackedFile
1142 {
1143 private:
1144 const OUString maURL;
1145 std::deque< PackedFileEntry >
1146 maPackedFileEntryVector;
1147 bool mbChanged;
1148
1149 public:
1150 PackedFile(const OUString& rURL)
1151 : maURL(rURL),
1152 mbChanged(false)
1153 {
1154 FileSharedPtr aSourceFile = std::make_shared<osl::File>(rURL);
1155
1156 if (osl::File::E_None == aSourceFile->open(osl_File_OpenFlag_Read))
1157 {
1158 sal_uInt64 nBaseLen(0);
1159 aSourceFile->getSize(nBaseLen);
1160
1161 // we need at least File_ID and num entries -> 8byte
1162 if (8 < nBaseLen)
1163 {
1164 sal_uInt8 aArray[4];
1165 sal_uInt64 nBaseRead(0);
1166
1167 // read and check File_ID
1168 if (osl::File::E_None == aSourceFile->read(static_cast< void* >(aArray), 4, nBaseRead) && 4 == nBaseRead)
1169 {
1170 if ('P' == aArray[0] && 'A' == aArray[1] && 'C' == aArray[2] && 'K' == aArray[3])
1171 {
1172 // read and compute num entries in this file
1173 if (osl::File::E_None == aSourceFile->read(static_cast<void*>(aArray), 4, nBaseRead) && 4 == nBaseRead)
1174 {
1175 sal_uInt32 nEntries((sal_uInt32(aArray[0]) << 24) + (sal_uInt32(aArray[1]) << 16) + (sal_uInt32(aArray[2]) << 8) + sal_uInt32(aArray[3]));
1176
1177 // if there are entries (and less than max), read them
1178 if (nEntries >= 1 && nEntries <= 10)
1179 {
1180 for (sal_uInt32 a(0); a < nEntries; a++)
1181 {
1182 // create new entry, read header (size, crc and PackedSize),
1183 // set offset and source file
1184 PackedFileEntry aEntry;
1185
1186 if (aEntry.read_header(aSourceFile))
1187 {
1188 // add to local data
1189 maPackedFileEntryVector.push_back(aEntry);
1190 }
1191 else
1192 {
1193 // error
1194 nEntries = 0;
1195 }
1196 }
1197
1198 if (0 == nEntries)
1199 {
1200 // on read error clear local data
1201 maPackedFileEntryVector.clear();
1202 }
1203 else
1204 {
1205 // calculate and set offsets to file binary content
1206 sal_uInt32 nHeaderSize(8);
1207
1208 nHeaderSize += maPackedFileEntryVector.size() * PackedFileEntry::getEntrySize();
1209
1210 sal_uInt32 nOffset(nHeaderSize);
1211
1212 for (auto& b : maPackedFileEntryVector)
1213 {
1214 b.setOffset(nOffset);
1215 nOffset += b.getPackFileSize();
1216 }
1217 }
1218 }
1219 }
1220 }
1221 }
1222 }
1223
1224 aSourceFile->close();
1225 }
1226
1227 if (maPackedFileEntryVector.empty())
1228 {
1229 // on error or no data get rid of pack file
1230 osl::File::remove(maURL);
1231 }
1232 }
1233
1234 void flush()
1235 {
1236 bool bRetval(true);
1237
1238 if (maPackedFileEntryVector.empty())
1239 {
1240 // get rid of (now?) empty pack file
1241 osl::File::remove(maURL);
1242 }
1243 else if (mbChanged)
1244 {
1245 // need to create a new pack file, do this in a temp file to which data
1246 // will be copied from local file (so keep it here until this is done)
1247 oslFileHandle aHandle = nullptr;
1248 OUString aTempURL;
1249
1250 // open target temp file - it exists until deleted
1251 if (osl::File::E_None == osl::FileBase::createTempFile(nullptr, &aHandle, &aTempURL))
1252 {
1253 sal_uInt8 aArray[4];
1254 sal_uInt64 nBaseWritten(0);
1255
1256 aArray[0] = 'P';
1257 aArray[1] = 'A';
1258 aArray[2] = 'C';
1259 aArray[3] = 'K';
1260
1261 // write File_ID
1262 if (osl_File_E_None == osl_writeFile(aHandle, static_cast<const void*>(aArray), 4, &nBaseWritten) && 4 == nBaseWritten)
1263 {
1264 const sal_uInt32 nSize(maPackedFileEntryVector.size());
1265
1266 // write number of entries
1267 if (write_sal_uInt32(aHandle, nSize))
1268 {
1269 // write placeholder for headers. Due to the fact that
1270 // PackFileSize for newly added files gets set during
1271 // writing the content entry, write headers after content
1272 // is written. To do so, write placeholders here
1273 sal_uInt32 nWriteSize(0);
1274
1275 nWriteSize += maPackedFileEntryVector.size() * PackedFileEntry::getEntrySize();
1276
1277 aArray[0] = aArray[1] = aArray[2] = aArray[3] = 0;
1278
1279 for (sal_uInt32 a(0); bRetval && a < nWriteSize; a++)
1280 {
1281 if (osl_File_E_None != osl_writeFile(aHandle, static_cast<const void*>(aArray), 1, &nBaseWritten) || 1 != nBaseWritten)
1282 {
1283 bRetval = false;
1284 }
1285 }
1286
1287 if (bRetval)
1288 {
1289 // write contents - this may adapt PackFileSize for new
1290 // files
1291 for (auto& candidate : maPackedFileEntryVector)
1292 {
1293 if (!candidate.copy_content(aHandle, false))
1294 {
1295 bRetval = false;
1296 break;
1297 }
1298 }
1299 }
1300
1301 if (bRetval)
1302 {
1303 // seek back to header start (at position 8)
1304 if (osl_File_E_None != osl_setFilePos(aHandle, osl_Pos_Absolut, sal_Int64(8)))
1305 {
1306 bRetval = false;
1307 }
1308 }
1309
1310 if (bRetval)
1311 {
1312 // write headers
1313 for (const auto& candidate : maPackedFileEntryVector)
1314 {
1315 if (!candidate.write_header(aHandle))
1316 {
1317 // error
1318 bRetval = false;
1319 break;
1320 }
1321 }
1322 }
1323 }
1324 }
1325 }
1326
1327 // close temp file (in all cases) - it exists until deleted
1328 osl_closeFile(aHandle);
1329
1330 if (bRetval)
1331 {
1332 // copy over existing file by first deleting original
1333 // and moving the temp file to old original
1334 osl::File::remove(maURL);
1335 osl::File::move(aTempURL, maURL);
1336 }
1337
1338 // delete temp file (in all cases - it may be moved already)
1339 osl::File::remove(aTempURL);
1340 }
1341 }
1342
1343 bool tryPush(FileSharedPtr const & rFileCandidate, bool bCompress)
1344 {
1345 sal_uInt64 nFileSize(0);
1346
1347 if (rFileCandidate && osl::File::E_None == rFileCandidate->open(osl_File_OpenFlag_Read))
1348 {
1349 rFileCandidate->getSize(nFileSize);
1350 rFileCandidate->close();
1351 }
1352
1353 if (0 == nFileSize)
1354 {
1355 // empty file offered
1356 return false;
1357 }
1358
1359 bool bNeedToAdd(false);
1360 sal_uInt32 nCrc32(0);
1361
1362 if (maPackedFileEntryVector.empty())
1363 {
1364 // no backup yet, add as 1st backup
1365 bNeedToAdd = true;
1366 }
1367 else
1368 {
1369 // already backups there, check if different from last entry
1370 const PackedFileEntry& aLastEntry = maPackedFileEntryVector.back();
1371
1372 // check if file is different
1373 if (aLastEntry.getFullFileSize() != static_cast<sal_uInt32>(nFileSize))
1374 {
1375 // different size, different file
1376 bNeedToAdd = true;
1377 }
1378 else
1379 {
1380 // same size, check crc32
1381 nCrc32 = createCrc32(rFileCandidate, 0);
1382
1383 if (nCrc32 != aLastEntry.getCrc32())
1384 {
1385 // different crc, different file
1386 bNeedToAdd = true;
1387 }
1388 }
1389 }
1390
1391 if (bNeedToAdd)
1392 {
1393 // create crc32 if not yet done
1394 if (0 == nCrc32)
1395 {
1396 nCrc32 = createCrc32(rFileCandidate, 0);
1397 }
1398
1399 // create a file entry for a new file. Offset is set automatically
1400 // to 0 to mark the entry as new file entry
1401 maPackedFileEntryVector.emplace_back(
1402 static_cast< sal_uInt32 >(nFileSize),
1403 nCrc32,
1404 rFileCandidate,
1405 bCompress);
1406
1407 mbChanged = true;
1408 }
1409
1410 return bNeedToAdd;
1411 }
1412
1413 bool tryPop(oslFileHandle& rHandle)
1414 {
1415 if (maPackedFileEntryVector.empty())
1416 return false;
1417
1418 // already backups there, check if different from last entry
1419 PackedFileEntry& aLastEntry = maPackedFileEntryVector.back();
1420
1421 // here the uncompress flag has to be determined, true
1422 // means to add the file compressed, false means to add it
1423 // uncompressed
1424 bool bRetval = aLastEntry.copy_content(rHandle, true);
1425
1426 if (bRetval)
1427 {
1428 maPackedFileEntryVector.pop_back();
1429 mbChanged = true;
1430 }
1431
1432 return bRetval;
1433 }
1434
1435 void tryReduceToNumBackups(sal_uInt16 nNumBackups)
1436 {
1437 while (maPackedFileEntryVector.size() > nNumBackups)
1438 {
1439 maPackedFileEntryVector.pop_front();
1440 mbChanged = true;
1441 }
1442 }
1443
1444 bool empty() const
1445 {
1446 return maPackedFileEntryVector.empty();
1447 }
1448 };
1449 }
1450
1451 namespace comphelper
1452 {
1453 sal_uInt16 BackupFileHelper::mnMaxAllowedBackups = 10;
1454 bool BackupFileHelper::mbExitWasCalled = false;
1455 bool BackupFileHelper::mbSafeModeDirExists = false;
1456 OUString BackupFileHelper::maInitialBaseURL;
1457 OUString BackupFileHelper::maUserConfigBaseURL;
1458 OUString BackupFileHelper::maUserConfigWorkURL;
1459 OUString BackupFileHelper::maRegModName;
1460 OUString BackupFileHelper::maExt;
1461
1462 const OUString& BackupFileHelper::getInitialBaseURL()
1463 {
1464 if (maInitialBaseURL.isEmpty())
1465 {
1466 // try to access user layer configuration file URL, the one that
1467 // points to registrymodifications.xcu
1468 OUString conf(u"${CONFIGURATION_LAYERS}"_ustr);
1469 rtl::Bootstrap::expandMacros(conf);
1470 static constexpr OUString aTokenUser(u"user:"_ustr);
1471 sal_Int32 nStart(conf.indexOf(aTokenUser));
1472
1473 if (-1 != nStart)
1474 {
1475 nStart += aTokenUser.getLength();
1476 sal_Int32 nEnd(conf.indexOf(' ', nStart));
1477
1478 if (-1 == nEnd)
1479 {
1480 nEnd = conf.getLength();
1481 }
1482
1483 maInitialBaseURL = conf.copy(nStart, nEnd - nStart);
1484 (void)maInitialBaseURL.startsWith("!", &maInitialBaseURL);
1485 }
1486
1487 if (!maInitialBaseURL.isEmpty())
1488 {
1489 // split URL at extension and at last path separator
1490 maUserConfigBaseURL = DirectoryHelper::splitAtLastToken(
1491 DirectoryHelper::splitAtLastToken(maInitialBaseURL, '.', maExt), '/',
1492 maRegModName);
1493 }
1494
1495 if (!maUserConfigBaseURL.isEmpty())
1496 {
1497 // check if SafeModeDir exists
1498 mbSafeModeDirExists = DirectoryHelper::dirExists(maUserConfigBaseURL + "/" + getSafeModeName());
1499 }
1500
1501 maUserConfigWorkURL = maUserConfigBaseURL;
1502
1503 if (mbSafeModeDirExists)
1504 {
1505 // adapt work URL to do all repair op's in the correct directory
1506 maUserConfigWorkURL += "/" + getSafeModeName();
1507 }
1508 }
1509
1510 return maInitialBaseURL;
1511 }
1512
1513 const OUString& BackupFileHelper::getSafeModeName()
1514 {
1515 static constexpr OUString aSafeMode(u"SafeMode"_ustr);
1516
1517 return aSafeMode;
1518 }
1519
1520 BackupFileHelper::BackupFileHelper()
1521 : mnNumBackups(2),
1522 mnMode(1),
1523 mbActive(false),
1524 mbExtensions(true),
1525 mbCompress(true)
1526 {
1527 OUString sTokenOut;
1528
1529 // read configuration item 'SecureUserConfig' -> bool on/off
1530 if (rtl::Bootstrap::get(u"SecureUserConfig"_ustr, sTokenOut))
1531 {
1532 mbActive = sTokenOut.toBoolean();
1533 }
1534
1535 if (mbActive)
1536 {
1537 // ensure existence
1538 getInitialBaseURL();
1539
1540 // if not found, we are out of business (maExt may be empty)
1541 mbActive = !maInitialBaseURL.isEmpty() && !maUserConfigBaseURL.isEmpty() && !maRegModName.isEmpty();
1542 }
1543
1544 if (mbActive && rtl::Bootstrap::get(u"SecureUserConfigNumCopies"_ustr, sTokenOut))
1545 {
1546 const sal_uInt16 nConfigNumCopies(static_cast<sal_uInt16>(sTokenOut.toUInt32()));
1547
1548 // limit to range [1..mnMaxAllowedBackups]
1549 mnNumBackups = std::clamp(mnNumBackups, nConfigNumCopies, mnMaxAllowedBackups);
1550 }
1551
1552 if (mbActive && rtl::Bootstrap::get(u"SecureUserConfigMode"_ustr, sTokenOut))
1553 {
1554 const sal_uInt16 nMode(static_cast<sal_uInt16>(sTokenOut.toUInt32()));
1555
1556 // limit to range [0..2]
1557 mnMode = std::min(nMode, sal_uInt16(2));
1558 }
1559
1560 if (mbActive && rtl::Bootstrap::get(u"SecureUserConfigExtensions"_ustr, sTokenOut))
1561 {
1562 mbExtensions = sTokenOut.toBoolean();
1563 }
1564
1565 if (mbActive && rtl::Bootstrap::get(u"SecureUserConfigCompress"_ustr, sTokenOut))
1566 {
1567 mbCompress = sTokenOut.toBoolean();
1568 }
1569 }
1570
1571 void BackupFileHelper::setExitWasCalled()
1572 {
1573 mbExitWasCalled = true;
1574 }
1575
1576 void BackupFileHelper::reactOnSafeMode(bool bSafeMode)
1577 {
1578 // ensure existence of needed paths
1579 getInitialBaseURL();
1580
1581 if (maUserConfigBaseURL.isEmpty())
1582 return;
1583
1584 if (bSafeMode)
1585 {
1586 if (!mbSafeModeDirExists)
1587 {
1588 std::set< OUString > aExcludeList;
1589
1590 // do not move SafeMode directory itself
1591 aExcludeList.insert(getSafeModeName());
1592
1593 // init SafeMode by creating the 'SafeMode' directory and moving
1594 // all stuff there. All repairs will happen there. Both Dirs have to exist.
1595 // extend maUserConfigWorkURL as needed
1596 maUserConfigWorkURL = maUserConfigBaseURL + "/" + getSafeModeName();
1597
1598 osl::Directory::createPath(maUserConfigWorkURL);
1599 DirectoryHelper::moveDirContent(maUserConfigBaseURL, maUserConfigWorkURL, aExcludeList);
1600
1601 // switch local flag, maUserConfigWorkURL is already reset
1602 mbSafeModeDirExists = true;
1603 }
1604 }
1605 else
1606 {
1607 if (mbSafeModeDirExists)
1608 {
1609 // SafeMode has ended, return to normal mode by moving all content
1610 // from 'SafeMode' directory back to UserDirectory and deleting it.
1611 // Both Dirs have to exist
1612 std::set< OUString > aExcludeList;
1613
1614 DirectoryHelper::moveDirContent(maUserConfigWorkURL, maUserConfigBaseURL, aExcludeList);
1615 osl::Directory::remove(maUserConfigWorkURL);
1616
1617 // switch local flag and reset maUserConfigWorkURL
1618 mbSafeModeDirExists = false;
1619 maUserConfigWorkURL = maUserConfigBaseURL;
1620 }
1621 }
1622 }
1623
1624 void BackupFileHelper::tryPush()
1625 {
1626 // no push when SafeModeDir exists, it may be Office's exit after SafeMode
1627 // where SafeMode flag is already deleted, but SafeModeDir cleanup is not
1628 // done yet (is done at next startup)
1629 if (!mbActive || mbSafeModeDirExists)
1630 return;
1631
1632 const OUString aPackURL(getPackURL());
1633
1634 // ensure dir and file vectors
1635 fillDirFileInfo();
1636
1637 // process all files in question recursively
1638 if (!maDirs.empty() || !maFiles.empty())
1639 {
1640 tryPush_Files(
1641 maDirs,
1642 maFiles,
1643 maUserConfigWorkURL,
1644 aPackURL);
1645 }
1646 }
1647
1648 void BackupFileHelper::tryPushExtensionInfo()
1649 {
1650 // no push when SafeModeDir exists, it may be Office's exit after SafeMode
1651 // where SafeMode flag is already deleted, but SafeModeDir cleanup is not
1652 // done yet (is done at next startup)
1653 if (mbActive && mbExtensions && !mbSafeModeDirExists)
1654 {
1655 const OUString aPackURL(getPackURL());
1656
1657 tryPush_extensionInfo(aPackURL);
1658 }
1659 }
1660
1661 bool BackupFileHelper::isPopPossible()
1662 {
1663 bool bPopPossible(false);
1664
1665 if (mbActive)
1666 {
1667 const OUString aPackURL(getPackURL());
1668
1669 // ensure dir and file vectors
1670 fillDirFileInfo();
1671
1672 // process all files in question recursively
1673 if (!maDirs.empty() || !maFiles.empty())
1674 {
1675 bPopPossible = isPopPossible_files(
1676 maDirs,
1677 maFiles,
1678 maUserConfigWorkURL,
1679 aPackURL);
1680 }
1681 }
1682
1683 return bPopPossible;
1684 }
1685
1686 void BackupFileHelper::tryPop()
1687 {
1688 if (!mbActive)
1689 return;
1690
1691 bool bDidPop(false);
1692 const OUString aPackURL(getPackURL());
1693
1694 // ensure dir and file vectors
1695 fillDirFileInfo();
1696
1697 // process all files in question recursively
1698 if (!maDirs.empty() || !maFiles.empty())
1699 {
1700 bDidPop = tryPop_files(
1701 maDirs,
1702 maFiles,
1703 maUserConfigWorkURL,
1704 aPackURL);
1705 }
1706
1707 if (bDidPop)
1708 {
1709 // try removal of evtl. empty directory
1710 osl::Directory::remove(aPackURL);
1711 }
1712 }
1713
1714 bool BackupFileHelper::isPopPossibleExtensionInfo() const
1715 {
1716 bool bPopPossible(false);
1717
1718 if (mbActive && mbExtensions)
1719 {
1720 const OUString aPackURL(getPackURL());
1721
1722 bPopPossible = isPopPossible_extensionInfo(aPackURL);
1723 }
1724
1725 return bPopPossible;
1726 }
1727
1728 void BackupFileHelper::tryPopExtensionInfo()
1729 {
1730 if (!(mbActive && mbExtensions))
1731 return;
1732
1733 bool bDidPop(false);
1734 const OUString aPackURL(getPackURL());
1735
1736 bDidPop = tryPop_extensionInfo(aPackURL);
1737
1738 if (bDidPop)
1739 {
1740 // try removal of evtl. empty directory
1741 osl::Directory::remove(aPackURL);
1742 }
1743 }
1744
1745 bool BackupFileHelper::isTryDisableAllExtensionsPossible()
1746 {
1747 // check if there are still enabled extension which can be disabled,
1748 // but as we are now in SafeMode, use XML infos for this since the
1749 // extensions are not loaded from XExtensionManager
1750 class ExtensionInfo aExtensionInfo;
1751
1752 aExtensionInfo.createUserExtensionRegistryEntriesFromXML(maUserConfigWorkURL);
1753
1754 return aExtensionInfo.areThereEnabledExtensions();
1755 }
1756
1757 void BackupFileHelper::tryDisableAllExtensions()
1758 {
1759 // disable all still enabled extensions,
1760 // but as we are now in SafeMode, use XML infos for this since the
1761 // extensions are not loaded from XExtensionManager
1762 ExtensionInfo aCurrentExtensionInfo;
1763 const ExtensionInfoEntryVector aToBeEnabled{};
1764 ExtensionInfoEntryVector aToBeDisabled;
1765
1766 aCurrentExtensionInfo.createUserExtensionRegistryEntriesFromXML(maUserConfigWorkURL);
1767
1768 const ExtensionInfoEntryVector& rCurrentVector = aCurrentExtensionInfo.getExtensionInfoEntryVector();
1769
1770 for (const auto& rCurrentInfo : rCurrentVector)
1771 {
1772 if (rCurrentInfo.isEnabled())
1773 {
1774 aToBeDisabled.push_back(rCurrentInfo);
1775 }
1776 }
1777
1778 ExtensionInfo::changeEnableDisableStateInXML(maUserConfigWorkURL, aToBeEnabled, aToBeDisabled);
1779 }
1780
1781 bool BackupFileHelper::isTryDeinstallUserExtensionsPossible()
1782 {
1783 // check if there are User Extensions installed.
1784 class ExtensionInfo aExtensionInfo;
1785
1786 aExtensionInfo.createUserExtensionRegistryEntriesFromXML(maUserConfigWorkURL);
1787
1788 return !aExtensionInfo.getExtensionInfoEntryVector().empty();
1789 }
1790
1791 void BackupFileHelper::tryDeinstallUserExtensions()
1792 {
1793 // delete User Extension installs
1794 DirectoryHelper::deleteDirRecursively(maUserConfigWorkURL + "/uno_packages");
1795 }
1796
1797 bool BackupFileHelper::isTryResetSharedExtensionsPossible()
1798 {
1799 // check if there are shared Extensions installed
1800 class ExtensionInfo aExtensionInfo;
1801
1802 aExtensionInfo.createSharedExtensionRegistryEntriesFromXML(maUserConfigWorkURL);
1803
1804 return !aExtensionInfo.getExtensionInfoEntryVector().empty();
1805 }
1806
1807 void BackupFileHelper::tryResetSharedExtensions()
1808 {
1809 // reset shared extension info
1810 DirectoryHelper::deleteDirRecursively(maUserConfigWorkURL + "/extensions/shared");
1811 }
1812
1813 bool BackupFileHelper::isTryResetBundledExtensionsPossible()
1814 {
1815 // check if there are shared Extensions installed
1816 class ExtensionInfo aExtensionInfo;
1817
1818 aExtensionInfo.createBundledExtensionRegistryEntriesFromXML(maUserConfigWorkURL);
1819
1820 return !aExtensionInfo.getExtensionInfoEntryVector().empty();
1821 }
1822
1823 void BackupFileHelper::tryResetBundledExtensions()
1824 {
1825 // reset shared extension info
1826 DirectoryHelper::deleteDirRecursively(maUserConfigWorkURL + "/extensions/bundled");
1827 }
1828
1829 const std::vector< OUString >& BackupFileHelper::getCustomizationDirNames()
1830 {
1831 static std::vector< OUString > aDirNames =
1832 {
1833 u"config"_ustr, // UI config stuff
1834 u"registry"_ustr, // most of the registry stuff
1835 u"psprint"_ustr, // not really needed, can be abandoned
1836 u"store"_ustr, // not really needed, can be abandoned
1837 u"temp"_ustr, // not really needed, can be abandoned
1838 u"pack"_ustr // own backup dir
1839 };
1840
1841 return aDirNames;
1842 }
1843
1844 const std::vector< OUString >& BackupFileHelper::getCustomizationFileNames()
1845 {
1846 static std::vector< OUString > aFileNames =
1847 {
1848 u"registrymodifications.xcu"_ustr // personal registry stuff
1849 };
1850
1851 return aFileNames;
1852 }
1853
1854 namespace {
1855 uno::Reference<XElement> lcl_getConfigElement(const uno::Reference<XDocument>& xDocument, const OUString& rPath,
1856 const OUString& rKey, const OUString& rValue)
1857 {
1858 uno::Reference< XElement > itemElement = xDocument->createElement(u"item"_ustr);
1859 itemElement->setAttribute(u"oor:path"_ustr, rPath);
1860
1861 uno::Reference< XElement > propElement = xDocument->createElement(u"prop"_ustr);
1862 propElement->setAttribute(u"oor:name"_ustr, rKey);
1863 propElement->setAttribute(u"oor:op"_ustr, u"replace"_ustr); // Replace any other options
1864
1865 uno::Reference< XElement > valueElement = xDocument->createElement(u"value"_ustr);
1866 uno::Reference< XText > textElement = xDocument->createTextNode(rValue);
1867
1868 valueElement->appendChild(textElement);
1869 propElement->appendChild(valueElement);
1870 itemElement->appendChild(propElement);
1871
1872 return itemElement;
1873 }
1874 }
1875
1876 void BackupFileHelper::tryDisableHWAcceleration()
1877 {
1878 const OUString aRegistryModifications(maUserConfigWorkURL + "/registrymodifications.xcu");
1879 if (!DirectoryHelper::fileExists(aRegistryModifications))
1880 return;
1881
1882 const uno::Reference< uno::XComponentContext >& xContext = ::comphelper::getProcessComponentContext();
1883 uno::Reference< XDocumentBuilder > xBuilder = DocumentBuilder::create(xContext);
1884 uno::Reference< XDocument > xDocument = xBuilder->parseURI(aRegistryModifications);
1885 uno::Reference< XElement > xRootElement = xDocument->getDocumentElement();
1886
1887 xRootElement->appendChild(lcl_getConfigElement(xDocument, u"/org.openoffice.Office.Common/VCL"_ustr,
1888 u"DisableOpenGL"_ustr, u"true"_ustr));
1889 xRootElement->appendChild(lcl_getConfigElement(xDocument, u"/org.openoffice.Office.Common/Misc"_ustr,
1890 u"UseOpenCL"_ustr, u"false"_ustr));
1891 // Do not disable Skia entirely, just force its CPU-based raster mode.
1892 xRootElement->appendChild(lcl_getConfigElement(xDocument, u"/org.openoffice.Office.Common/VCL"_ustr,
1893 u"ForceSkia"_ustr, u"false"_ustr));
1894 xRootElement->appendChild(lcl_getConfigElement(xDocument, u"/org.openoffice.Office.Common/VCL"_ustr,
1895 u"ForceSkiaRaster"_ustr, u"true"_ustr));
1896
1897 OUString aTempURL;
1898 {
1899 // use the scope to make sure that the temp file gets properly closed before move
1900
1901 // write back
1902 uno::Reference< xml::sax::XSAXSerializable > xSerializer(xDocument, uno::UNO_QUERY);
1903
1904 if (!xSerializer.is())
1905 return;
1906
1907 // create a SAXWriter
1908 uno::Reference< xml::sax::XWriter > const xSaxWriter = xml::sax::Writer::create(xContext);
1909 uno::Reference< io::XTempFile > xTempFile = io::TempFile::create(xContext);
1910 xTempFile->setRemoveFile(false); // avoid removal of tempfile when leaving the scope
1911 uno::Reference< io::XOutputStream > xOutStrm = xTempFile->getOutputStream();
1912
1913 // set output stream and do the serialization
1914 xSaxWriter->setOutputStream(xOutStrm);
1915 xSerializer->serialize(xSaxWriter, uno::Sequence< beans::StringPair >());
1916
1917 // get URL from temp file
1918 aTempURL = xTempFile->getUri();
1919 }
1920
1921 // copy back file
1922 if (aTempURL.isEmpty() || !DirectoryHelper::fileExists(aTempURL))
1923 return;
1924
1925 if (DirectoryHelper::fileExists(aRegistryModifications))
1926 {
1927 osl::File::remove(aRegistryModifications);
1928 }
1929
1930 int result = osl::File::move(aTempURL, aRegistryModifications);
1931 SAL_WARN_IF(result != osl::FileBase::E_None, "comphelper.backupfilehelper", "could not copy back modified Extension configuration file");
1932 }
1933
1934 bool BackupFileHelper::isTryResetCustomizationsPossible()
1935 {
1936 // return true if not all of the customization selection dirs or files are deleted
1937 const std::vector< OUString >& rDirs = getCustomizationDirNames();
1938
1939 for (const auto& a : rDirs)
1940 {
1941 if (DirectoryHelper::dirExists(maUserConfigWorkURL + "/" + a))
1942 {
1943 return true;
1944 }
1945 }
1946
1947 const std::vector< OUString >& rFiles = getCustomizationFileNames();
1948
1949 for (const auto& b : rFiles)
1950 {
1951 if (DirectoryHelper::fileExists(maUserConfigWorkURL + "/" + b))
1952 {
1953 return true;
1954 }
1955 }
1956
1957 return false;
1958 }
1959
1960 void BackupFileHelper::tryResetCustomizations()
1961 {
1962 // delete all of the customization selection dirs
1963 const std::vector< OUString >& rDirs = getCustomizationDirNames();
1964
1965 for (const auto& a : rDirs)
1966 {
1967 DirectoryHelper::deleteDirRecursively(maUserConfigWorkURL + "/" + a);
1968 }
1969
1970 const std::vector< OUString >& rFiles = getCustomizationFileNames();
1971
1972 for (const auto& b : rFiles)
1973 {
1974 osl::File::remove(maUserConfigWorkURL + "/" + b);
1975 }
1976 }
1977
1978 void BackupFileHelper::tryResetUserProfile()
1979 {
1980 // completely delete the current UserProfile
1981 DirectoryHelper::deleteDirRecursively(maUserConfigWorkURL);
1982 }
1983
1984 const OUString& BackupFileHelper::getUserProfileURL()
1985 {
1986 return maUserConfigBaseURL;
1987 }
1988
1989 const OUString& BackupFileHelper::getUserProfileWorkURL()
1990 {
1991 return maUserConfigWorkURL;
1992 }
1993
1994 /////////////////// helpers ///////////////////////
1995
1996 OUString BackupFileHelper::getPackURL()
1997 {
1998 return OUString(maUserConfigWorkURL + "/pack");
1999 }
2000
2001 /////////////////// file push helpers ///////////////////////
2002
2003 bool BackupFileHelper::tryPush_Files(
2004 const std::set< OUString >& rDirs,
2005 const std::set< std::pair< OUString, OUString > >& rFiles,
2006 std::u16string_view rSourceURL, // source dir without trailing '/'
2007 const OUString& rTargetURL // target dir without trailing '/'
2008 )
2009 {
2010 bool bDidPush(false);
2011 osl::Directory::createPath(rTargetURL);
2012
2013 // process files
2014 for (const auto& file : rFiles)
2015 {
2016 bDidPush |= tryPush_file(
2017 rSourceURL,
2018 rTargetURL,
2019 file.first,
2020 file.second);
2021 }
2022
2023 // process dirs
2024 for (const auto& dir : rDirs)
2025 {
2026 OUString aNewSourceURL(OUString::Concat(rSourceURL) + "/" + dir);
2027 OUString aNewTargetURL(rTargetURL + "/" + dir);
2028 std::set< OUString > aNewDirs;
2029 std::set< std::pair< OUString, OUString > > aNewFiles;
2030
2031 DirectoryHelper::scanDirsAndFiles(
2032 aNewSourceURL,
2033 aNewDirs,
2034 aNewFiles);
2035
2036 if (!aNewDirs.empty() || !aNewFiles.empty())
2037 {
2038 bDidPush |= tryPush_Files(
2039 aNewDirs,
2040 aNewFiles,
2041 aNewSourceURL,
2042 aNewTargetURL);
2043 }
2044 }
2045
2046 if (!bDidPush)
2047 {
2048 // try removal of evtl. empty directory
2049 osl::Directory::remove(rTargetURL);
2050 }
2051
2052 return bDidPush;
2053 }
2054
2055 bool BackupFileHelper::tryPush_file(
2056 std::u16string_view rSourceURL, // source dir without trailing '/'
2057 std::u16string_view rTargetURL, // target dir without trailing '/'
2058 std::u16string_view rName, // filename
2059 std::u16string_view rExt // extension (or empty)
2060 )
2061 {
2062 const OUString aFileURL(createFileURL(rSourceURL, rName, rExt));
2063
2064 if (DirectoryHelper::fileExists(aFileURL))
2065 {
2066 const OUString aPackURL(createPackURL(rTargetURL, rName));
2067 PackedFile aPackedFile(aPackURL);
2068 FileSharedPtr aBaseFile = std::make_shared<osl::File>(aFileURL);
2069
2070 if (aPackedFile.tryPush(aBaseFile, mbCompress))
2071 {
2072 // reduce to allowed number and flush
2073 aPackedFile.tryReduceToNumBackups(mnNumBackups);
2074 aPackedFile.flush();
2075
2076 return true;
2077 }
2078 }
2079
2080 return false;
2081 }
2082
2083 /////////////////// file pop possibilities helper ///////////////////////
2084
2085 bool BackupFileHelper::isPopPossible_files(
2086 const std::set< OUString >& rDirs,
2087 const std::set< std::pair< OUString, OUString > >& rFiles,
2088 std::u16string_view rSourceURL, // source dir without trailing '/'
2089 std::u16string_view rTargetURL // target dir without trailing '/'
2090 )
2091 {
2092 bool bPopPossible(false);
2093
2094 // process files
2095 for (const auto& file : rFiles)
2096 {
2097 bPopPossible |= isPopPossible_file(
2098 rSourceURL,
2099 rTargetURL,
2100 file.first,
2101 file.second);
2102 }
2103
2104 // process dirs
2105 for (const auto& dir : rDirs)
2106 {
2107 OUString aNewSourceURL(OUString::Concat(rSourceURL) + "/" + dir);
2108 OUString aNewTargetURL(OUString::Concat(rTargetURL) + "/" + dir);
2109 std::set< OUString > aNewDirs;
2110 std::set< std::pair< OUString, OUString > > aNewFiles;
2111
2112 DirectoryHelper::scanDirsAndFiles(
2113 aNewSourceURL,
2114 aNewDirs,
2115 aNewFiles);
2116
2117 if (!aNewDirs.empty() || !aNewFiles.empty())
2118 {
2119 bPopPossible |= isPopPossible_files(
2120 aNewDirs,
2121 aNewFiles,
2122 aNewSourceURL,
2123 aNewTargetURL);
2124 }
2125 }
2126
2127 return bPopPossible;
2128 }
2129
2130 bool BackupFileHelper::isPopPossible_file(
2131 std::u16string_view rSourceURL, // source dir without trailing '/'
2132 std::u16string_view rTargetURL, // target dir without trailing '/'
2133 std::u16string_view rName, // filename
2134 std::u16string_view rExt // extension (or empty)
2135 )
2136 {
2137 const OUString aFileURL(createFileURL(rSourceURL, rName, rExt));
2138
2139 if (DirectoryHelper::fileExists(aFileURL))
2140 {
2141 const OUString aPackURL(createPackURL(rTargetURL, rName));
2142 PackedFile aPackedFile(aPackURL);
2143
2144 return !aPackedFile.empty();
2145 }
2146
2147 return false;
2148 }
2149
2150 /////////////////// file pop helpers ///////////////////////
2151
2152 bool BackupFileHelper::tryPop_files(
2153 const std::set< OUString >& rDirs,
2154 const std::set< std::pair< OUString, OUString > >& rFiles,
2155 std::u16string_view rSourceURL, // source dir without trailing '/'
2156 const OUString& rTargetURL // target dir without trailing '/'
2157 )
2158 {
2159 bool bDidPop(false);
2160
2161 // process files
2162 for (const auto& file : rFiles)
2163 {
2164 bDidPop |= tryPop_file(
2165 rSourceURL,
2166 rTargetURL,
2167 file.first,
2168 file.second);
2169 }
2170
2171 // process dirs
2172 for (const auto& dir : rDirs)
2173 {
2174 OUString aNewSourceURL(OUString::Concat(rSourceURL) + "/" + dir);
2175 OUString aNewTargetURL(rTargetURL + "/" + dir);
2176 std::set< OUString > aNewDirs;
2177 std::set< std::pair< OUString, OUString > > aNewFiles;
2178
2179 DirectoryHelper::scanDirsAndFiles(
2180 aNewSourceURL,
2181 aNewDirs,
2182 aNewFiles);
2183
2184 if (!aNewDirs.empty() || !aNewFiles.empty())
2185 {
2186 bDidPop |= tryPop_files(
2187 aNewDirs,
2188 aNewFiles,
2189 aNewSourceURL,
2190 aNewTargetURL);
2191 }
2192 }
2193
2194 if (bDidPop)
2195 {
2196 // try removal of evtl. empty directory
2197 osl::Directory::remove(rTargetURL);
2198 }
2199
2200 return bDidPop;
2201 }
2202
2203 bool BackupFileHelper::tryPop_file(
2204 std::u16string_view rSourceURL, // source dir without trailing '/'
2205 std::u16string_view rTargetURL, // target dir without trailing '/'
2206 std::u16string_view rName, // filename
2207 std::u16string_view rExt // extension (or empty)
2208 )
2209 {
2210 const OUString aFileURL(createFileURL(rSourceURL, rName, rExt));
2211
2212 if (!DirectoryHelper::fileExists(aFileURL))
2213 return false;
2214
2215 // try Pop for base file
2216 const OUString aPackURL(createPackURL(rTargetURL, rName));
2217 PackedFile aPackedFile(aPackURL);
2218
2219 if (aPackedFile.empty())
2220 return false;
2221
2222 oslFileHandle aHandle;
2223 OUString aTempURL;
2224
2225 // open target temp file - it exists until deleted
2226 if (osl::File::E_None != osl::FileBase::createTempFile(nullptr, &aHandle, &aTempURL))
2227 return false;
2228
2229 bool bRetval(aPackedFile.tryPop(aHandle));
2230
2231 // close temp file (in all cases) - it exists until deleted
2232 osl_closeFile(aHandle);
2233
2234 if (bRetval)
2235 {
2236 // copy over existing file by first deleting original
2237 // and moving the temp file to old original
2238 osl::File::remove(aFileURL);
2239 osl::File::move(aTempURL, aFileURL);
2240
2241 // reduce to allowed number and flush
2242 aPackedFile.tryReduceToNumBackups(mnNumBackups);
2243 aPackedFile.flush();
2244 }
2245
2246 // delete temp file (in all cases - it may be moved already)
2247 osl::File::remove(aTempURL);
2248
2249 return bRetval;
2250 }
2251
2252 /////////////////// ExtensionInfo helpers ///////////////////////
2253
2254 bool BackupFileHelper::tryPush_extensionInfo(
2255 std::u16string_view rTargetURL // target dir without trailing '/'
2256 )
2257 {
2258 ExtensionInfo aExtensionInfo;
2259 OUString aTempURL;
2260 bool bRetval(false);
2261
2262 // create current configuration and write to temp file - it exists until deleted
2263 if (aExtensionInfo.createTempFile(aTempURL))
2264 {
2265 const OUString aPackURL(createPackURL(rTargetURL, u"ExtensionInfo"));
2266 PackedFile aPackedFile(aPackURL);
2267 FileSharedPtr aBaseFile = std::make_shared<osl::File>(aTempURL);
2268
2269 if (aPackedFile.tryPush(aBaseFile, mbCompress))
2270 {
2271 // reduce to allowed number and flush
2272 aPackedFile.tryReduceToNumBackups(mnNumBackups);
2273 aPackedFile.flush();
2274 bRetval = true;
2275 }
2276 }
2277
2278 // delete temp file (in all cases)
2279 osl::File::remove(aTempURL);
2280 return bRetval;
2281 }
2282
2283 bool BackupFileHelper::isPopPossible_extensionInfo(
2284 std::u16string_view rTargetURL // target dir without trailing '/'
2285 )
2286 {
2287 // extensionInfo always exists internally, no test needed
2288 const OUString aPackURL(createPackURL(rTargetURL, u"ExtensionInfo"));
2289 PackedFile aPackedFile(aPackURL);
2290
2291 return !aPackedFile.empty();
2292 }
2293
2294 bool BackupFileHelper::tryPop_extensionInfo(
2295 std::u16string_view rTargetURL // target dir without trailing '/'
2296 )
2297 {
2298 // extensionInfo always exists internally, no test needed
2299 const OUString aPackURL(createPackURL(rTargetURL, u"ExtensionInfo"));
2300 PackedFile aPackedFile(aPackURL);
2301
2302 if (aPackedFile.empty())
2303 return false;
2304
2305 oslFileHandle aHandle;
2306 OUString aTempURL;
2307
2308 // open target temp file - it exists until deleted
2309 if (osl::File::E_None != osl::FileBase::createTempFile(nullptr, &aHandle, &aTempURL))
2310 return false;
2311
2312 bool bRetval(aPackedFile.tryPop(aHandle));
2313
2314 // close temp file (in all cases) - it exists until deleted
2315 osl_closeFile(aHandle);
2316
2317 if (bRetval)
2318 {
2319 // last config is in temp file, load it to ExtensionInfo
2320 ExtensionInfo aLoadedExtensionInfo;
2321 FileSharedPtr aBaseFile = std::make_shared<osl::File>(aTempURL);
2322
2323 if (osl::File::E_None == aBaseFile->open(osl_File_OpenFlag_Read))
2324 {
2325 if (aLoadedExtensionInfo.read_entries(aBaseFile))
2326 {
2327 // get current extension info, but from XML config files
2328 ExtensionInfo aCurrentExtensionInfo;
2329
2330 aCurrentExtensionInfo.createUserExtensionRegistryEntriesFromXML(maUserConfigWorkURL);
2331
2332 // now we have loaded last_working (aLoadedExtensionInfo) and
2333 // current (aCurrentExtensionInfo) ExtensionInfo and may react on
2334 // differences by de/activating these as needed
2335 const ExtensionInfoEntryVector& aUserEntries = aCurrentExtensionInfo.getExtensionInfoEntryVector();
2336 const ExtensionInfoEntryVector& rLoadedVector = aLoadedExtensionInfo.getExtensionInfoEntryVector();
2337 ExtensionInfoEntryVector aToBeDisabled;
2338 ExtensionInfoEntryVector aToBeEnabled;
2339
2340 for (const auto& rCurrentInfo : aUserEntries)
2341 {
2342 const ExtensionInfoEntry* pLoadedInfo = nullptr;
2343
2344 for (const auto& rLoadedInfo : rLoadedVector)
2345 {
2346 if (rCurrentInfo.isSameExtension(rLoadedInfo))
2347 {
2348 pLoadedInfo = &rLoadedInfo;
2349 break;
2350 }
2351 }
2352
2353 if (nullptr != pLoadedInfo)
2354 {
2355 // loaded info contains information about the Extension rCurrentInfo
2356 const bool bCurrentEnabled(rCurrentInfo.isEnabled());
2357 const bool bLoadedEnabled(pLoadedInfo->isEnabled());
2358
2359 if (bCurrentEnabled && !bLoadedEnabled)
2360 {
2361 aToBeDisabled.push_back(rCurrentInfo);
2362 }
2363 else if (!bCurrentEnabled && bLoadedEnabled)
2364 {
2365 aToBeEnabled.push_back(rCurrentInfo);
2366 }
2367 }
2368 else
2369 {
2370 // There is no loaded info about the Extension rCurrentInfo.
2371 // It needs to be disabled
2372 if (rCurrentInfo.isEnabled())
2373 {
2374 aToBeDisabled.push_back(rCurrentInfo);
2375 }
2376 }
2377 }
2378
2379 if (!aToBeDisabled.empty() || !aToBeEnabled.empty())
2380 {
2381 ExtensionInfo::changeEnableDisableStateInXML(maUserConfigWorkURL, aToBeEnabled, aToBeDisabled);
2382 }
2383
2384 bRetval = true;
2385 }
2386 }
2387
2388 // reduce to allowed number and flush
2389 aPackedFile.tryReduceToNumBackups(mnNumBackups);
2390 aPackedFile.flush();
2391 }
2392
2393 // delete temp file (in all cases - it may be moved already)
2394 osl::File::remove(aTempURL);
2395
2396 return bRetval;
2397 }
2398
2399 /////////////////// FileDirInfo helpers ///////////////////////
2400
2401 void BackupFileHelper::fillDirFileInfo()
2402 {
2403 if (!maDirs.empty() || !maFiles.empty())
2404 {
2405 // already done
2406 return;
2407 }
2408
2409 // Information about the configuration and the role/purpose of directories in
2410 // the UserConfiguration is taken from: https://wiki.documentfoundation.org/UserProfile
2411
2412 // fill dir and file info list to work with dependent on work mode
2413 switch (mnMode)
2414 {
2415 case 0:
2416 {
2417 // simple mode: add just registrymodifications
2418 // (the orig file in maInitialBaseURL)
2419 maFiles.insert(std::pair< OUString, OUString >(maRegModName, maExt));
2420 break;
2421 }
2422 case 1:
2423 {
2424 // defined mode: Add a selection of dirs containing User-Defined and thus
2425 // valuable configuration information.
2426 // This is clearly discussable in every single point and may be adapted/corrected
2427 // over time. Main focus is to secure User-Defined/adapted values
2428
2429 // add registrymodifications (the orig file in maInitialBaseURL)
2430 maFiles.insert(std::pair< OUString, OUString >(maRegModName, maExt));
2431
2432 // User-defined substitution table (Tools/AutoCorrect)
2433 maDirs.insert(u"autocorr"_ustr);
2434
2435 // User-Defined AutoText (Edit/AutoText)
2436 maDirs.insert(u"autotext"_ustr);
2437
2438 // User-defined Macros
2439 maDirs.insert(u"basic"_ustr);
2440
2441 // User-adapted toolbars for modules
2442 maDirs.insert(u"config"_ustr);
2443
2444 // Initial and User-defined Databases
2445 maDirs.insert(u"database"_ustr);
2446
2447 // most part of registry files
2448 maDirs.insert(u"registry"_ustr);
2449
2450 // User-Defined Scripts
2451 maDirs.insert(u"Scripts"_ustr);
2452
2453 // Template files
2454 maDirs.insert(u"template"_ustr);
2455
2456 // Custom Dictionaries
2457 maDirs.insert(u"wordbook"_ustr);
2458
2459 // Questionable - where and how is Extension stuff held and how
2460 // does this interact with enabled/disabled states which are extra handled?
2461 // Keep out of business until deeper evaluated
2462 //
2463 // maDirs.insert("extensions");
2464 // maDirs.insert("uno-packages");
2465 break;
2466 }
2467 case 2:
2468 {
2469 // whole directory. To do so, scan directory and exclude some dirs
2470 // from which we know they do not need to be secured explicitly. This
2471 // should already include registrymodifications, too.
2472 DirectoryHelper::scanDirsAndFiles(
2473 maUserConfigWorkURL,
2474 maDirs,
2475 maFiles);
2476
2477 // should not exist, but for the case an error occurred and it got
2478 // copied somehow, avoid further recursive copying/saving
2479 maDirs.erase(u"SafeMode"_ustr);
2480
2481 // not really needed, can be abandoned
2482 maDirs.erase(u"psprint"_ustr);
2483
2484 // not really needed, can be abandoned
2485 maDirs.erase(u"store"_ustr);
2486
2487 // not really needed, can be abandoned
2488 maDirs.erase(u"temp"_ustr);
2489
2490 // exclude own backup dir to avoid recursion
2491 maDirs.erase(u"pack"_ustr);
2492
2493 break;
2494 }
2495 }
2496 }
2497 }
2498
2499 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE