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