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.h"
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) != 0) {
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 == 0) {
88 0 : printf("none");
89 : } else {
90 0 : bool first = true;
91 : printFieldOrReferenceFlag(
92 0 : &flags, RT_ACCESS_READONLY, "readonly", &first);
93 : printFieldOrReferenceFlag(
94 0 : &flags, RT_ACCESS_OPTIONAL, "optional", &first);
95 : printFieldOrReferenceFlag(
96 0 : &flags, RT_ACCESS_MAYBEVOID, "maybevoid", &first);
97 0 : printFieldOrReferenceFlag(&flags, RT_ACCESS_BOUND, "bound", &first);
98 : printFieldOrReferenceFlag(
99 0 : &flags, RT_ACCESS_CONSTRAINED, "constrained", &first);
100 : printFieldOrReferenceFlag(
101 0 : &flags, RT_ACCESS_TRANSIENT, "transient", &first);
102 : printFieldOrReferenceFlag(
103 0 : &flags, RT_ACCESS_MAYBEAMBIGUOUS, "maybeambiguous", &first);
104 : printFieldOrReferenceFlag(
105 0 : &flags, RT_ACCESS_MAYBEDEFAULT, "maybedefault", &first);
106 : printFieldOrReferenceFlag(
107 0 : &flags, RT_ACCESS_REMOVABLE, "removable", &first);
108 : printFieldOrReferenceFlag(
109 0 : &flags, RT_ACCESS_ATTRIBUTE, "attribute", &first);
110 : printFieldOrReferenceFlag(
111 0 : &flags, RT_ACCESS_PROPERTY, "property", &first);
112 0 : printFieldOrReferenceFlag(&flags, RT_ACCESS_CONST, "const", &first);
113 : printFieldOrReferenceFlag(
114 0 : &flags, RT_ACCESS_READWRITE, "readwrite", &first);
115 : printFieldOrReferenceFlag(
116 0 : &flags, RT_ACCESS_PARAMETERIZED_TYPE, "parameterized type", &first);
117 : printFieldOrReferenceFlag(
118 0 : &flags, RT_ACCESS_PUBLISHED, "published", &first);
119 0 : if (flags != 0) {
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 RT_MODE_ONEWAY:
298 0 : printf("oneway");
299 0 : break;
300 :
301 : case RT_MODE_TWOWAY:
302 0 : printf("synchronous");
303 0 : break;
304 :
305 : case RT_MODE_ATTRIBUTE_GET:
306 0 : printf("attribute get");
307 0 : break;
308 :
309 : case RT_MODE_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 0 : for (sal_uInt16 j = 0; j < reader.getMethodParameterCount(i); ++j)
330 : {
331 : printf(
332 : "%s parameter %u:\n", indent.getStr(),
333 0 : static_cast< unsigned int >(j));
334 0 : printf("%s flags: ", indent.getStr());
335 0 : RTParamMode flags = reader.getMethodParameterFlags(i, j);
336 0 : bool rest = (flags & RT_PARAM_REST) != 0;
337 0 : switch (flags & ~RT_PARAM_REST) {
338 : case RT_PARAM_IN:
339 0 : printf("in");
340 0 : break;
341 :
342 : case RT_PARAM_OUT:
343 0 : printf("out");
344 0 : break;
345 :
346 : case RT_PARAM_INOUT:
347 0 : printf("inout");
348 0 : break;
349 :
350 : default:
351 0 : printf("<invalid (%ld)>", static_cast< long >(flags));
352 0 : rest = false;
353 0 : break;
354 : }
355 0 : if (rest) {
356 0 : printf("|rest");
357 : }
358 0 : printf("\n");
359 0 : printf("%s name: ", indent.getStr());
360 0 : printString(reader.getMethodParameterName(i, j));
361 0 : printf("\n");
362 0 : printf("%s type name: ", indent.getStr());
363 0 : printString(reader.getMethodParameterTypeName(i, j));
364 0 : printf("\n");
365 : }
366 : printf(
367 : "%s exception count: %u\n", indent.getStr(),
368 0 : static_cast< unsigned int >(reader.getMethodExceptionCount(i)));
369 0 : for (sal_uInt16 j = 0; j < reader.getMethodExceptionCount(i); ++j)
370 : {
371 : printf(
372 : "%s exception type name %u: ", indent.getStr(),
373 0 : static_cast< unsigned int >(j));
374 0 : printString(reader.getMethodExceptionTypeName(i, j));
375 0 : printf("\n");
376 : }
377 : }
378 : printf(
379 : "%sreference count: %u\n", indent.getStr(),
380 0 : static_cast< unsigned int >(reader.getReferenceCount()));
381 0 : for (sal_uInt16 i = 0; i < reader.getReferenceCount(); ++i) {
382 : printf(
383 : "%sreference %u:\n", indent.getStr(),
384 0 : static_cast< unsigned int >(i));
385 0 : printf("%s documentation: ", indent.getStr());
386 0 : printString(reader.getReferenceDocumentation(i));
387 0 : printf("\n");
388 0 : printf("%s flags: ", indent.getStr());
389 0 : printFieldOrReferenceFlags(reader.getReferenceFlags(i));
390 0 : printf("\n");
391 0 : printf("%s sort: ", indent.getStr());
392 0 : switch (reader.getReferenceSort(i)) {
393 : case RT_REF_SUPPORTS:
394 0 : printf("supports");
395 0 : break;
396 :
397 : case RT_REF_EXPORTS:
398 0 : printf("exports");
399 0 : break;
400 :
401 : case RT_REF_TYPE_PARAMETER:
402 0 : printf("type parameter");
403 0 : break;
404 :
405 : default:
406 : printf(
407 : "<invalid (%ld)>",
408 0 : static_cast< long >(reader.getReferenceSort(i)));
409 0 : break;
410 : }
411 0 : printf("\n");
412 0 : printf("%s type name: ", indent.getStr());
413 0 : printString(reader.getReferenceTypeName(i));
414 0 : printf("\n");
415 : }
416 : } else {
417 0 : printf("<invalid>\n");
418 : }
419 0 : }
420 :
421 : }
422 :
423 :
424 : // ORegistry()
425 :
426 304 : ORegistry::ORegistry()
427 : : m_refCount(1)
428 : , m_readOnly(false)
429 : , m_isOpen(false)
430 304 : , ROOT( "/" )
431 : {
432 304 : }
433 :
434 :
435 : // ~ORegistry()
436 :
437 600 : ORegistry::~ORegistry()
438 : {
439 300 : ORegKey* pRootKey = m_openKeyTable[ROOT];
440 300 : if (pRootKey != 0)
441 4 : (void) releaseKey(pRootKey);
442 :
443 300 : if (m_file.isValid())
444 4 : m_file.close();
445 300 : }
446 :
447 :
448 :
449 : // initRegistry
450 :
451 304 : RegError ORegistry::initRegistry(const OUString& regName, RegAccessMode accessMode)
452 : {
453 304 : RegError eRet = REG_INVALID_REGISTRY;
454 304 : OStoreFile rRegFile;
455 304 : storeAccessMode sAccessMode = REG_MODE_OPEN;
456 : storeError errCode;
457 :
458 304 : if (accessMode & REG_CREATE)
459 : {
460 296 : sAccessMode = REG_MODE_CREATE;
461 : }
462 8 : else if (accessMode & REG_READONLY)
463 : {
464 4 : sAccessMode = REG_MODE_OPENREAD;
465 4 : m_readOnly = true;
466 : }
467 :
468 304 : if (regName.isEmpty() &&
469 : store_AccessCreate == sAccessMode)
470 : {
471 4 : errCode = rRegFile.createInMemory();
472 : }
473 : else
474 : {
475 300 : errCode = rRegFile.create(regName, sAccessMode, REG_PAGESIZE);
476 : }
477 :
478 304 : if (errCode)
479 : {
480 8 : switch (errCode)
481 : {
482 : case store_E_NotExists:
483 8 : eRet = REG_REGISTRY_NOT_EXISTS;
484 8 : break;
485 : case store_E_LockingViolation:
486 0 : eRet = REG_CANNOT_OPEN_FOR_READWRITE;
487 0 : break;
488 : default:
489 0 : eRet = REG_INVALID_REGISTRY;
490 0 : break;
491 : }
492 : }
493 : else
494 : {
495 296 : OStoreDirectory rStoreDir;
496 296 : storeError _err = rStoreDir.create(rRegFile, OUString(), OUString(), sAccessMode);
497 :
498 296 : if ( _err == store_E_None )
499 : {
500 296 : m_file = rRegFile;
501 296 : m_name = regName;
502 296 : m_isOpen = true;
503 :
504 296 : m_openKeyTable[ROOT] = new ORegKey(ROOT, this);
505 296 : eRet = REG_NO_ERROR;
506 : }
507 : else
508 0 : eRet = REG_INVALID_REGISTRY;
509 : }
510 :
511 304 : return eRet;
512 : }
513 :
514 :
515 :
516 : // closeRegistry
517 :
518 288 : RegError ORegistry::closeRegistry()
519 : {
520 288 : REG_GUARD(m_mutex);
521 :
522 288 : if (m_file.isValid())
523 : {
524 288 : (void) releaseKey(m_openKeyTable[ROOT]);
525 288 : m_file.close();
526 288 : m_isOpen = false;
527 288 : return REG_NO_ERROR;
528 : } else
529 : {
530 0 : return REG_REGISTRY_NOT_EXISTS;
531 288 : }
532 : }
533 :
534 :
535 :
536 : // destroyRegistry
537 :
538 0 : RegError ORegistry::destroyRegistry(const OUString& regName)
539 : {
540 0 : REG_GUARD(m_mutex);
541 :
542 0 : if (!regName.isEmpty())
543 : {
544 0 : std::unique_ptr<ORegistry> pReg(new ORegistry());
545 :
546 0 : if (!pReg->initRegistry(regName, REG_READWRITE))
547 : {
548 0 : pReg.reset();
549 :
550 0 : OUString systemName;
551 0 : if ( FileBase::getSystemPathFromFileURL(regName, systemName) != FileBase::E_None )
552 0 : systemName = regName;
553 :
554 0 : OString name( OUStringToOString(systemName, osl_getThreadTextEncoding()) );
555 0 : if (unlink(name.getStr()) != 0)
556 : {
557 0 : return REG_DESTROY_REGISTRY_FAILED;
558 0 : }
559 : } else
560 : {
561 0 : return REG_DESTROY_REGISTRY_FAILED;
562 0 : }
563 : } else
564 : {
565 0 : if (m_refCount != 1 || isReadOnly())
566 : {
567 0 : return REG_DESTROY_REGISTRY_FAILED;
568 : }
569 :
570 0 : if (m_file.isValid())
571 : {
572 0 : releaseKey(m_openKeyTable[ROOT]);
573 0 : m_file.close();
574 0 : m_isOpen = false;
575 :
576 0 : if (!m_name.isEmpty())
577 : {
578 0 : OUString systemName;
579 0 : if ( FileBase::getSystemPathFromFileURL(m_name, systemName) != FileBase::E_None )
580 0 : systemName = m_name;
581 :
582 0 : OString name( OUStringToOString(systemName, osl_getThreadTextEncoding()) );
583 0 : if (unlink(name.getStr()) != 0)
584 : {
585 0 : return REG_DESTROY_REGISTRY_FAILED;
586 0 : }
587 : }
588 : } else
589 : {
590 0 : return REG_REGISTRY_NOT_EXISTS;
591 : }
592 : }
593 :
594 0 : return REG_NO_ERROR;
595 : }
596 :
597 :
598 : // acquireKey
599 :
600 396 : RegError ORegistry::acquireKey (RegKeyHandle hKey)
601 : {
602 396 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
603 396 : if (!pKey)
604 0 : return REG_INVALID_KEY;
605 :
606 396 : REG_GUARD(m_mutex);
607 396 : pKey->acquire();
608 :
609 396 : return REG_NO_ERROR;
610 : }
611 :
612 :
613 : // releaseKey
614 :
615 1892 : RegError ORegistry::releaseKey (RegKeyHandle hKey)
616 : {
617 1892 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
618 1892 : if (!pKey)
619 0 : return REG_INVALID_KEY;
620 :
621 1892 : REG_GUARD(m_mutex);
622 1892 : if (pKey->release() == 0)
623 : {
624 1150 : m_openKeyTable.erase(pKey->getName());
625 1150 : delete pKey;
626 : }
627 1892 : return REG_NO_ERROR;
628 : }
629 :
630 :
631 : // createKey
632 :
633 816 : RegError ORegistry::createKey(RegKeyHandle hKey, const OUString& keyName,
634 : RegKeyHandle* phNewKey)
635 : {
636 : ORegKey* pKey;
637 :
638 816 : *phNewKey = NULL;
639 :
640 816 : if ( keyName.isEmpty() )
641 0 : return REG_INVALID_KEYNAME;
642 :
643 816 : REG_GUARD(m_mutex);
644 :
645 816 : if (hKey)
646 816 : pKey = (ORegKey*)hKey;
647 : else
648 0 : pKey = m_openKeyTable[ROOT];
649 :
650 1632 : OUString sFullKeyName = pKey->getFullPath(keyName);
651 :
652 816 : if (m_openKeyTable.count(sFullKeyName) > 0)
653 : {
654 0 : *phNewKey = m_openKeyTable[sFullKeyName];
655 0 : ((ORegKey*)*phNewKey)->acquire();
656 0 : ((ORegKey*)*phNewKey)->setDeleted(false);
657 0 : return REG_NO_ERROR;
658 : }
659 :
660 1632 : OStoreDirectory rStoreDir;
661 1632 : OUStringBuffer sFullPath(sFullKeyName.getLength());
662 1632 : OUString token;
663 :
664 816 : sFullPath.append('/');
665 :
666 816 : sal_Int32 nIndex = 0;
667 2222 : do
668 : {
669 2222 : token = sFullKeyName.getToken( 0, '/', nIndex );
670 2222 : if (!token.isEmpty())
671 : {
672 1406 : if (rStoreDir.create(pKey->getStoreFile(), sFullPath.getStr(), token, KEY_MODE_CREATE))
673 : {
674 0 : return REG_CREATE_KEY_FAILED;
675 : }
676 :
677 1406 : sFullPath.append(token);
678 1406 : sFullPath.append('/');
679 : }
680 2222 : } while( nIndex != -1 );
681 :
682 :
683 816 : pKey = new ORegKey(sFullKeyName, this);
684 816 : *phNewKey = pKey;
685 816 : m_openKeyTable[sFullKeyName] = pKey;
686 :
687 1632 : return REG_NO_ERROR;
688 : }
689 :
690 :
691 :
692 : // openKey
693 :
694 82 : RegError ORegistry::openKey(RegKeyHandle hKey, const OUString& keyName,
695 : RegKeyHandle* phOpenKey)
696 : {
697 : ORegKey* pKey;
698 :
699 82 : *phOpenKey = NULL;
700 :
701 82 : if ( keyName.isEmpty() )
702 : {
703 0 : return REG_INVALID_KEYNAME;
704 : }
705 :
706 82 : REG_GUARD(m_mutex);
707 :
708 82 : if (hKey)
709 82 : pKey = (ORegKey*)hKey;
710 : else
711 0 : pKey = m_openKeyTable[ROOT];
712 :
713 164 : OUString path(pKey->getFullPath(keyName));
714 82 : KeyMap::iterator i(m_openKeyTable.find(path));
715 82 : if (i == m_openKeyTable.end()) {
716 64 : sal_Int32 n = path.lastIndexOf('/') + 1;
717 128 : switch (OStoreDirectory().create(
718 64 : pKey->getStoreFile(), path.copy(0, n), path.copy(n),
719 192 : isReadOnly() ? KEY_MODE_OPENREAD : KEY_MODE_OPEN))
720 : {
721 : case store_E_NotExists:
722 24 : return REG_KEY_NOT_EXISTS;
723 : case store_E_WrongFormat:
724 0 : return REG_INVALID_KEY;
725 : default:
726 52 : break;
727 : }
728 :
729 52 : std::unique_ptr< ORegKey > p(new ORegKey(path, this));
730 52 : i = m_openKeyTable.insert(std::make_pair(path, p.get())).first;
731 52 : p.release();
732 : } else {
733 18 : i->second->acquire();
734 : }
735 70 : *phOpenKey = i->second;
736 152 : return REG_NO_ERROR;
737 : }
738 :
739 :
740 :
741 : // closeKey
742 :
743 70 : RegError ORegistry::closeKey(RegKeyHandle hKey)
744 : {
745 70 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
746 :
747 70 : REG_GUARD(m_mutex);
748 :
749 140 : OUString const aKeyName (pKey->getName());
750 70 : if (!(m_openKeyTable.count(aKeyName) > 0))
751 0 : return REG_KEY_NOT_OPEN;
752 :
753 70 : if (pKey->isModified())
754 : {
755 22 : ORegKey * pRootKey = getRootKey();
756 22 : if (pKey != pRootKey)
757 : {
758 : // propagate "modified" state to RootKey.
759 18 : pRootKey->setModified();
760 : }
761 : else
762 : {
763 : // closing modified RootKey, flush registry file.
764 : OSL_TRACE("registry::ORegistry::closeKey(): flushing modified RootKey");
765 4 : (void) m_file.flush();
766 : }
767 22 : pKey->setModified(false);
768 22 : (void) releaseKey(pRootKey);
769 : }
770 :
771 140 : return releaseKey(pKey);
772 : }
773 :
774 :
775 : // deleteKey
776 :
777 4 : RegError ORegistry::deleteKey(RegKeyHandle hKey, const OUString& keyName)
778 : {
779 4 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
780 4 : if ( keyName.isEmpty() )
781 0 : return REG_INVALID_KEYNAME;
782 :
783 4 : REG_GUARD(m_mutex);
784 :
785 4 : if (!pKey)
786 0 : pKey = m_openKeyTable[ROOT];
787 :
788 8 : OUString sFullKeyName(pKey->getFullPath(keyName));
789 8 : return eraseKey(m_openKeyTable[ROOT], sFullKeyName);
790 : }
791 :
792 14 : RegError ORegistry::eraseKey(ORegKey* pKey, const OUString& keyName)
793 : {
794 14 : RegError _ret = REG_NO_ERROR;
795 :
796 14 : if ( keyName.isEmpty() )
797 : {
798 0 : return REG_INVALID_KEYNAME;
799 : }
800 :
801 14 : OUString sFullKeyName(pKey->getName());
802 28 : OUString sFullPath(sFullKeyName);
803 28 : OUString sRelativKey;
804 14 : sal_Int32 lastIndex = keyName.lastIndexOf('/');
805 :
806 14 : if ( lastIndex >= 0 )
807 : {
808 4 : sRelativKey += keyName.copy(lastIndex + 1);
809 :
810 4 : if (sFullKeyName.getLength() > 1)
811 0 : sFullKeyName += keyName;
812 : else
813 4 : sFullKeyName += keyName.copy(1);
814 :
815 4 : sFullPath = sFullKeyName.copy(0, keyName.lastIndexOf('/') + 1);
816 : } else
817 : {
818 10 : if (sFullKeyName.getLength() > 1)
819 10 : sFullKeyName += ROOT;
820 :
821 10 : sRelativKey += keyName;
822 10 : sFullKeyName += keyName;
823 :
824 10 : if (sFullPath.getLength() > 1)
825 10 : sFullPath += ROOT;
826 : }
827 :
828 14 : ORegKey* pOldKey = 0;
829 14 : _ret = pKey->openKey(keyName, (RegKeyHandle*)&pOldKey);
830 14 : if (_ret != REG_NO_ERROR)
831 0 : return _ret;
832 :
833 14 : _ret = deleteSubkeysAndValues(pOldKey);
834 14 : if (_ret != REG_NO_ERROR)
835 : {
836 0 : pKey->closeKey(pOldKey);
837 0 : return _ret;
838 : }
839 :
840 28 : OUString tmpName(sRelativKey);
841 14 : tmpName += ROOT;
842 :
843 28 : OStoreFile sFile(pKey->getStoreFile());
844 14 : if ( sFile.isValid() && sFile.remove(sFullPath, tmpName) )
845 : {
846 0 : return REG_DELETE_KEY_FAILED;
847 : }
848 14 : pOldKey->setModified();
849 :
850 : // set flag deleted !!!
851 14 : pOldKey->setDeleted(true);
852 :
853 28 : return pKey->closeKey(pOldKey);
854 : }
855 :
856 :
857 : // deleteSubKeysAndValues
858 :
859 14 : RegError ORegistry::deleteSubkeysAndValues(ORegKey* pKey)
860 : {
861 : OStoreDirectory::iterator iter;
862 14 : RegError _ret = REG_NO_ERROR;
863 14 : OStoreDirectory rStoreDir(pKey->getStoreDir());
864 14 : storeError _err = rStoreDir.first(iter);
865 :
866 14 : while ( _err == store_E_None )
867 : {
868 14 : OUString const keyName = iter.m_pszName;
869 :
870 14 : if (iter.m_nAttrib & STORE_ATTRIB_ISDIR)
871 : {
872 10 : _ret = eraseKey(pKey, keyName);
873 10 : if (_ret)
874 0 : return _ret;
875 : }
876 : else
877 : {
878 4 : OUString sFullPath(pKey->getName());
879 :
880 4 : if (sFullPath.getLength() > 1)
881 4 : sFullPath += ROOT;
882 :
883 4 : if ( ((OStoreFile&)pKey->getStoreFile()).remove(sFullPath, keyName) )
884 : {
885 0 : return REG_DELETE_VALUE_FAILED;
886 : }
887 4 : pKey->setModified();
888 : }
889 :
890 14 : _err = rStoreDir.next(iter);
891 14 : }
892 :
893 14 : return REG_NO_ERROR;
894 : }
895 :
896 :
897 :
898 : // loadKey
899 :
900 0 : RegError ORegistry::loadKey(RegKeyHandle hKey, const OUString& regFileName,
901 : bool bWarnings, bool bReport)
902 : {
903 0 : RegError _ret = REG_NO_ERROR;
904 0 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
905 :
906 0 : std::unique_ptr< ORegistry > pReg (new ORegistry());
907 0 : _ret = pReg->initRegistry(regFileName, REG_READONLY);
908 0 : if (_ret != REG_NO_ERROR)
909 0 : return _ret;
910 0 : ORegKey* pRootKey = pReg->getRootKey();
911 :
912 0 : REG_GUARD(m_mutex);
913 :
914 : OStoreDirectory::iterator iter;
915 0 : OStoreDirectory rStoreDir(pRootKey->getStoreDir());
916 0 : storeError _err = rStoreDir.first(iter);
917 :
918 0 : while ( _err == store_E_None )
919 : {
920 0 : OUString const keyName = iter.m_pszName;
921 :
922 0 : if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR )
923 : {
924 0 : _ret = loadAndSaveKeys(pKey, pRootKey, keyName, 0, bWarnings, bReport);
925 : }
926 : else
927 : {
928 0 : _ret = loadAndSaveValue(pKey, pRootKey, keyName, 0, bWarnings, bReport);
929 : }
930 :
931 0 : if (_ret == REG_MERGE_ERROR)
932 0 : break;
933 0 : if (_ret == REG_MERGE_CONFLICT && bWarnings)
934 0 : break;
935 :
936 0 : _err = rStoreDir.next(iter);
937 0 : }
938 :
939 0 : rStoreDir = OStoreDirectory();
940 0 : (void) pReg->releaseKey(pRootKey);
941 0 : return _ret;
942 : }
943 :
944 :
945 :
946 : // saveKey
947 :
948 0 : RegError ORegistry::saveKey(RegKeyHandle hKey, const OUString& regFileName,
949 : bool bWarnings, bool bReport)
950 : {
951 0 : RegError _ret = REG_NO_ERROR;
952 0 : ORegKey* pKey = static_cast< ORegKey* >(hKey);
953 :
954 0 : std::unique_ptr< ORegistry > pReg (new ORegistry());
955 0 : _ret = pReg->initRegistry(regFileName, REG_CREATE);
956 0 : if (_ret != REG_NO_ERROR)
957 0 : return _ret;
958 0 : ORegKey* pRootKey = pReg->getRootKey();
959 :
960 0 : REG_GUARD(m_mutex);
961 :
962 : OStoreDirectory::iterator iter;
963 0 : OStoreDirectory rStoreDir(pKey->getStoreDir());
964 0 : storeError _err = rStoreDir.first(iter);
965 :
966 0 : while ( _err == store_E_None )
967 : {
968 0 : OUString const keyName = iter.m_pszName;
969 :
970 0 : if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR )
971 : {
972 : _ret = loadAndSaveKeys(pRootKey, pKey, keyName,
973 0 : pKey->getName().getLength(),
974 0 : bWarnings, bReport);
975 : }
976 : else
977 : {
978 : _ret = loadAndSaveValue(pRootKey, pKey, keyName,
979 0 : pKey->getName().getLength(),
980 0 : bWarnings, bReport);
981 : }
982 :
983 0 : if (_ret != REG_NO_ERROR)
984 0 : break;
985 :
986 0 : _err = rStoreDir.next(iter);
987 0 : }
988 :
989 0 : (void) pReg->releaseKey(pRootKey);
990 0 : return _ret;
991 : }
992 :
993 :
994 :
995 : // loadAndSaveValue()
996 :
997 0 : RegError ORegistry::loadAndSaveValue(ORegKey* pTargetKey,
998 : ORegKey* pSourceKey,
999 : const OUString& valueName,
1000 : sal_uInt32 nCut,
1001 : bool bWarnings,
1002 : bool bReport)
1003 : {
1004 0 : OStoreStream rValue;
1005 : sal_uInt8* pBuffer;
1006 : RegValueType valueType;
1007 : sal_uInt32 valueSize;
1008 : sal_uInt32 nSize;
1009 0 : storeAccessMode sourceAccess = VALUE_MODE_OPEN;
1010 0 : OUString sTargetPath(pTargetKey->getName());
1011 0 : OUString sSourcePath(pSourceKey->getName());
1012 :
1013 0 : if (pSourceKey->isReadOnly())
1014 : {
1015 0 : sourceAccess = VALUE_MODE_OPENREAD;
1016 : }
1017 :
1018 0 : if (nCut)
1019 : {
1020 0 : sTargetPath = sSourcePath.copy(nCut);
1021 : } else
1022 : {
1023 0 : if (sTargetPath.getLength() > 1)
1024 : {
1025 0 : if (sSourcePath.getLength() > 1)
1026 0 : sTargetPath += sSourcePath;
1027 : } else
1028 0 : sTargetPath = sSourcePath;
1029 : }
1030 :
1031 0 : if (sTargetPath.getLength() > 1) sTargetPath += ROOT;
1032 0 : if (sSourcePath.getLength() > 1) sSourcePath += ROOT;
1033 :
1034 0 : if (rValue.create(pSourceKey->getStoreFile(), sSourcePath, valueName, sourceAccess))
1035 : {
1036 0 : return REG_VALUE_NOT_EXISTS;
1037 : }
1038 :
1039 0 : pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE);
1040 :
1041 : sal_uInt32 rwBytes;
1042 0 : if (rValue.readAt(0, pBuffer, VALUE_HEADERSIZE, rwBytes))
1043 : {
1044 0 : rtl_freeMemory(pBuffer);
1045 0 : return REG_INVALID_VALUE;
1046 : }
1047 0 : if (rwBytes != VALUE_HEADERSIZE)
1048 : {
1049 0 : rtl_freeMemory(pBuffer);
1050 0 : return REG_INVALID_VALUE;
1051 : }
1052 :
1053 0 : RegError _ret = REG_NO_ERROR;
1054 0 : sal_uInt8 type = *((sal_uInt8*)pBuffer);
1055 0 : valueType = (RegValueType)type;
1056 0 : readUINT32(pBuffer+VALUE_TYPEOFFSET, valueSize);
1057 0 : rtl_freeMemory(pBuffer);
1058 :
1059 0 : nSize = VALUE_HEADERSIZE + valueSize;
1060 0 : pBuffer = (sal_uInt8*)rtl_allocateMemory(nSize);
1061 :
1062 0 : if (rValue.readAt(0, pBuffer, nSize, rwBytes))
1063 : {
1064 0 : rtl_freeMemory(pBuffer);
1065 0 : return REG_INVALID_VALUE;
1066 : }
1067 0 : if (rwBytes != nSize)
1068 : {
1069 0 : rtl_freeMemory(pBuffer);
1070 0 : return REG_INVALID_VALUE;
1071 : }
1072 :
1073 0 : OStoreFile rTargetFile(pTargetKey->getStoreFile());
1074 :
1075 0 : if (!rValue.create(rTargetFile, sTargetPath, valueName, VALUE_MODE_OPEN))
1076 : {
1077 0 : if (valueType == RG_VALUETYPE_BINARY)
1078 : {
1079 : _ret = checkBlop(
1080 : rValue, sTargetPath, valueSize, pBuffer+VALUE_HEADEROFFSET,
1081 0 : bReport);
1082 0 : if (_ret)
1083 : {
1084 0 : if (_ret == REG_MERGE_ERROR ||
1085 0 : (_ret == REG_MERGE_CONFLICT && bWarnings))
1086 : {
1087 0 : rtl_freeMemory(pBuffer);
1088 0 : return _ret;
1089 : }
1090 : } else
1091 : {
1092 0 : rtl_freeMemory(pBuffer);
1093 0 : return _ret;
1094 : }
1095 : }
1096 : }
1097 :
1098 : // write
1099 0 : if (rValue.create(rTargetFile, sTargetPath, valueName, VALUE_MODE_CREATE))
1100 : {
1101 0 : rtl_freeMemory(pBuffer);
1102 0 : return REG_INVALID_VALUE;
1103 : }
1104 0 : if (rValue.writeAt(0, pBuffer, nSize, rwBytes))
1105 : {
1106 0 : rtl_freeMemory(pBuffer);
1107 0 : return REG_INVALID_VALUE;
1108 : }
1109 :
1110 0 : if (rwBytes != nSize)
1111 : {
1112 0 : rtl_freeMemory(pBuffer);
1113 0 : return REG_INVALID_VALUE;
1114 : }
1115 0 : pTargetKey->setModified();
1116 :
1117 0 : rtl_freeMemory(pBuffer);
1118 0 : return _ret;
1119 : }
1120 :
1121 :
1122 :
1123 : // checkblop()
1124 :
1125 0 : RegError ORegistry::checkBlop(OStoreStream& rValue,
1126 : const OUString& sTargetPath,
1127 : sal_uInt32 srcValueSize,
1128 : sal_uInt8* pSrcBuffer,
1129 : bool bReport)
1130 : {
1131 0 : RegistryTypeReader reader(pSrcBuffer, srcValueSize, false);
1132 :
1133 0 : if (reader.getTypeClass() == RT_TYPE_INVALID)
1134 : {
1135 0 : return REG_INVALID_VALUE;
1136 : }
1137 :
1138 0 : sal_uInt8* pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE);
1139 : RegValueType valueType;
1140 : sal_uInt32 valueSize;
1141 : sal_uInt32 rwBytes;
1142 0 : OString targetPath( OUStringToOString(sTargetPath, RTL_TEXTENCODING_UTF8) );
1143 :
1144 0 : if (!rValue.readAt(0, pBuffer, VALUE_HEADERSIZE, rwBytes) &&
1145 0 : (rwBytes == VALUE_HEADERSIZE))
1146 : {
1147 0 : sal_uInt8 type = *((sal_uInt8*)pBuffer);
1148 0 : valueType = (RegValueType)type;
1149 0 : readUINT32(pBuffer+VALUE_TYPEOFFSET, valueSize);
1150 0 : rtl_freeMemory(pBuffer);
1151 :
1152 0 : if (valueType == RG_VALUETYPE_BINARY)
1153 : {
1154 0 : pBuffer = (sal_uInt8*)rtl_allocateMemory(valueSize);
1155 0 : if (!rValue.readAt(VALUE_HEADEROFFSET, pBuffer, valueSize, rwBytes) &&
1156 0 : (rwBytes == valueSize))
1157 : {
1158 0 : RegistryTypeReader reader2(pBuffer, valueSize, false);
1159 :
1160 0 : if ((reader.getTypeClass() != reader2.getTypeClass())
1161 0 : || reader2.getTypeClass() == RT_TYPE_INVALID)
1162 : {
1163 0 : rtl_freeMemory(pBuffer);
1164 :
1165 0 : if (bReport)
1166 : {
1167 : fprintf(stdout, "ERROR: values of blop from key \"%s\" has different types.\n",
1168 0 : targetPath.getStr());
1169 : }
1170 0 : return REG_MERGE_ERROR;
1171 : }
1172 :
1173 0 : if (reader.getTypeClass() == RT_TYPE_MODULE)
1174 : {
1175 0 : if (reader.getFieldCount() > 0 &&
1176 0 : reader2.getFieldCount() > 0)
1177 : {
1178 0 : mergeModuleValue(rValue, reader, reader2);
1179 :
1180 0 : rtl_freeMemory(pBuffer);
1181 0 : return REG_NO_ERROR;
1182 : } else
1183 0 : if (reader2.getFieldCount() > 0)
1184 : {
1185 0 : rtl_freeMemory(pBuffer);
1186 0 : return REG_NO_ERROR;
1187 : } else
1188 : {
1189 0 : rtl_freeMemory(pBuffer);
1190 0 : return REG_MERGE_CONFLICT;
1191 : }
1192 : } else
1193 : {
1194 0 : rtl_freeMemory(pBuffer);
1195 :
1196 0 : if (bReport)
1197 : {
1198 : fprintf(stderr, "WARNING: value of key \"%s\" already exists.\n",
1199 0 : targetPath.getStr());
1200 : }
1201 0 : return REG_MERGE_CONFLICT;
1202 0 : }
1203 : } else
1204 : {
1205 0 : rtl_freeMemory(pBuffer);
1206 0 : if (bReport)
1207 : {
1208 : fprintf(stderr, "ERROR: values of key \"%s\" contains bad data.\n",
1209 0 : targetPath.getStr());
1210 : }
1211 0 : return REG_MERGE_ERROR;
1212 : }
1213 : } else
1214 : {
1215 0 : rtl_freeMemory(pBuffer);
1216 0 : if (bReport)
1217 : {
1218 : fprintf(stderr, "ERROR: values of key \"%s\" has different types.\n",
1219 0 : targetPath.getStr());
1220 : }
1221 0 : return REG_MERGE_ERROR;
1222 : }
1223 : } else
1224 : {
1225 0 : rtl_freeMemory(pBuffer);
1226 0 : return REG_INVALID_VALUE;
1227 0 : }
1228 : }
1229 :
1230 0 : static sal_uInt32 checkTypeReaders(RegistryTypeReader& reader1,
1231 : RegistryTypeReader& reader2,
1232 : std::set< OUString >& nameSet)
1233 : {
1234 0 : sal_uInt32 count=0;
1235 : sal_uInt16 i;
1236 0 : for (i=0 ; i < reader1.getFieldCount(); i++)
1237 : {
1238 0 : nameSet.insert(reader1.getFieldName(i));
1239 0 : count++;
1240 : }
1241 0 : for (i=0 ; i < reader2.getFieldCount(); i++)
1242 : {
1243 0 : if (nameSet.find(reader2.getFieldName(i)) == nameSet.end())
1244 : {
1245 0 : nameSet.insert(reader2.getFieldName(i));
1246 0 : count++;
1247 : }
1248 : }
1249 0 : return count;
1250 : }
1251 :
1252 :
1253 : // mergeModuleValue()
1254 :
1255 0 : RegError ORegistry::mergeModuleValue(OStoreStream& rTargetValue,
1256 : RegistryTypeReader& reader,
1257 : RegistryTypeReader& reader2)
1258 : {
1259 0 : std::set< OUString > nameSet;
1260 0 : sal_uInt32 count = checkTypeReaders(reader, reader2, nameSet);
1261 :
1262 0 : if (count != reader.getFieldCount())
1263 : {
1264 0 : sal_uInt16 index = 0;
1265 :
1266 : RegistryTypeWriter writer(reader.getTypeClass(),
1267 : reader.getTypeName(),
1268 : reader.getSuperTypeName(),
1269 : (sal_uInt16)count,
1270 : 0,
1271 0 : 0);
1272 :
1273 0 : for (sal_uInt16 i=0 ; i < reader.getFieldCount(); i++)
1274 : {
1275 : writer.setFieldData(index,
1276 : reader.getFieldName(i),
1277 : reader.getFieldType(i),
1278 : reader.getFieldDoku(i),
1279 : reader.getFieldFileName(i),
1280 0 : reader.getFieldAccess(i),
1281 0 : reader.getFieldConstValue(i));
1282 0 : index++;
1283 : }
1284 0 : for (sal_uInt16 i=0 ; i < reader2.getFieldCount(); i++)
1285 : {
1286 0 : if (nameSet.find(reader2.getFieldName(i)) == nameSet.end())
1287 : {
1288 : writer.setFieldData(index,
1289 : reader2.getFieldName(i),
1290 : reader2.getFieldType(i),
1291 : reader2.getFieldDoku(i),
1292 : reader2.getFieldFileName(i),
1293 0 : reader2.getFieldAccess(i),
1294 0 : reader2.getFieldConstValue(i));
1295 0 : index++;
1296 : }
1297 : }
1298 :
1299 0 : const sal_uInt8* pBlop = writer.getBlop();
1300 0 : sal_uInt32 aBlopSize = writer.getBlopSize();
1301 :
1302 0 : sal_uInt8 type = (sal_uInt8)RG_VALUETYPE_BINARY;
1303 0 : sal_uInt8* pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE + aBlopSize);
1304 :
1305 0 : memcpy(pBuffer, &type, 1);
1306 0 : writeUINT32(pBuffer+VALUE_TYPEOFFSET, aBlopSize);
1307 0 : memcpy(pBuffer+VALUE_HEADEROFFSET, pBlop, aBlopSize);
1308 :
1309 : sal_uInt32 rwBytes;
1310 0 : if (rTargetValue.writeAt(0, pBuffer, VALUE_HEADERSIZE+aBlopSize, rwBytes))
1311 : {
1312 0 : rtl_freeMemory(pBuffer);
1313 0 : return REG_INVALID_VALUE;
1314 : }
1315 :
1316 0 : if (rwBytes != VALUE_HEADERSIZE+aBlopSize)
1317 : {
1318 0 : rtl_freeMemory(pBuffer);
1319 0 : return REG_INVALID_VALUE;
1320 : }
1321 :
1322 0 : rtl_freeMemory(pBuffer);
1323 : }
1324 0 : return REG_NO_ERROR;
1325 : }
1326 :
1327 :
1328 : // loadAndSaveKeys()
1329 :
1330 0 : RegError ORegistry::loadAndSaveKeys(ORegKey* pTargetKey,
1331 : ORegKey* pSourceKey,
1332 : const OUString& keyName,
1333 : sal_uInt32 nCut,
1334 : bool bWarnings,
1335 : bool bReport)
1336 : {
1337 0 : RegError _ret = REG_NO_ERROR;
1338 0 : OUString sRelPath(pSourceKey->getName().copy(nCut));
1339 0 : OUString sFullPath;
1340 :
1341 0 : if(pTargetKey->getName().getLength() > 1)
1342 0 : sFullPath += pTargetKey->getName();
1343 0 : sFullPath += sRelPath;
1344 0 : if (sRelPath.getLength() > 1 || sFullPath.isEmpty())
1345 0 : sFullPath += ROOT;
1346 :
1347 0 : OUString sFullKeyName = sFullPath;
1348 0 : sFullKeyName += keyName;
1349 :
1350 0 : OStoreDirectory rStoreDir;
1351 0 : if (rStoreDir.create(pTargetKey->getStoreFile(), sFullPath, keyName, KEY_MODE_CREATE))
1352 : {
1353 0 : return REG_CREATE_KEY_FAILED;
1354 : }
1355 :
1356 0 : if (m_openKeyTable.count(sFullKeyName) > 0)
1357 : {
1358 0 : m_openKeyTable[sFullKeyName]->setDeleted(false);
1359 : }
1360 :
1361 0 : ORegKey* pTmpKey = 0;
1362 0 : _ret = pSourceKey->openKey(keyName, (RegKeyHandle*)&pTmpKey);
1363 0 : if (_ret != REG_NO_ERROR)
1364 0 : return _ret;
1365 :
1366 : OStoreDirectory::iterator iter;
1367 0 : OStoreDirectory rTmpStoreDir(pTmpKey->getStoreDir());
1368 0 : storeError _err = rTmpStoreDir.first(iter);
1369 :
1370 0 : while ( _err == store_E_None)
1371 : {
1372 0 : OUString const sName = iter.m_pszName;
1373 :
1374 0 : if (iter.m_nAttrib & STORE_ATTRIB_ISDIR)
1375 : {
1376 : _ret = loadAndSaveKeys(pTargetKey, pTmpKey,
1377 0 : sName, nCut, bWarnings, bReport);
1378 : } else
1379 : {
1380 : _ret = loadAndSaveValue(pTargetKey, pTmpKey,
1381 0 : sName, nCut, bWarnings, bReport);
1382 : }
1383 :
1384 0 : if (_ret == REG_MERGE_ERROR)
1385 0 : break;
1386 0 : if (_ret == REG_MERGE_CONFLICT && bWarnings)
1387 0 : break;
1388 :
1389 0 : _err = rTmpStoreDir.next(iter);
1390 0 : }
1391 :
1392 0 : pSourceKey->releaseKey(pTmpKey);
1393 0 : return _ret;
1394 : }
1395 :
1396 :
1397 :
1398 : // getRootKey()
1399 :
1400 330 : ORegKey* ORegistry::getRootKey()
1401 : {
1402 330 : m_openKeyTable[ROOT]->acquire();
1403 330 : return m_openKeyTable[ROOT];
1404 : }
1405 :
1406 :
1407 :
1408 : // dumpRegistry()
1409 :
1410 0 : RegError ORegistry::dumpRegistry(RegKeyHandle hKey) const
1411 : {
1412 0 : ORegKey *pKey = (ORegKey*)hKey;
1413 0 : OUString sName;
1414 0 : RegError _ret = REG_NO_ERROR;
1415 : OStoreDirectory::iterator iter;
1416 0 : OStoreDirectory rStoreDir(pKey->getStoreDir());
1417 0 : storeError _err = rStoreDir.first(iter);
1418 :
1419 0 : OString regName( OUStringToOString( getName(), osl_getThreadTextEncoding() ) );
1420 0 : OString keyName( OUStringToOString( pKey->getName(), RTL_TEXTENCODING_UTF8 ) );
1421 0 : fprintf(stdout, "Registry \"%s\":\n\n%s\n", regName.getStr(), keyName.getStr());
1422 :
1423 0 : while ( _err == store_E_None )
1424 : {
1425 0 : sName = iter.m_pszName;
1426 :
1427 0 : if (iter.m_nAttrib & STORE_ATTRIB_ISDIR)
1428 : {
1429 0 : _ret = dumpKey(pKey->getName(), sName, 1);
1430 : } else
1431 : {
1432 0 : _ret = dumpValue(pKey->getName(), sName, 1);
1433 : }
1434 :
1435 0 : if (_ret)
1436 : {
1437 0 : return _ret;
1438 : }
1439 :
1440 0 : _err = rStoreDir.next(iter);
1441 : }
1442 :
1443 0 : return REG_NO_ERROR;
1444 : }
1445 :
1446 :
1447 : // dumpValue()
1448 :
1449 0 : RegError ORegistry::dumpValue(const OUString& sPath, const OUString& sName, sal_Int16 nSpc) const
1450 : {
1451 0 : OStoreStream rValue;
1452 : sal_uInt8* pBuffer;
1453 : sal_uInt32 valueSize;
1454 : RegValueType valueType;
1455 0 : OUString sFullPath(sPath);
1456 0 : OString sIndent;
1457 0 : storeAccessMode accessMode = VALUE_MODE_OPEN;
1458 :
1459 0 : if (isReadOnly())
1460 : {
1461 0 : accessMode = VALUE_MODE_OPENREAD;
1462 : }
1463 :
1464 0 : for (int i= 0; i < nSpc; i++) sIndent += " ";
1465 :
1466 0 : if (sFullPath.getLength() > 1)
1467 : {
1468 0 : sFullPath += ROOT;
1469 : }
1470 0 : if (rValue.create(m_file, sFullPath, sName, accessMode))
1471 : {
1472 0 : return REG_VALUE_NOT_EXISTS;
1473 : }
1474 :
1475 0 : pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE);
1476 :
1477 : sal_uInt32 rwBytes;
1478 0 : if (rValue.readAt(0, pBuffer, VALUE_HEADERSIZE, rwBytes))
1479 : {
1480 0 : rtl_freeMemory(pBuffer);
1481 0 : return REG_INVALID_VALUE;
1482 : }
1483 0 : if (rwBytes != (VALUE_HEADERSIZE))
1484 : {
1485 0 : rtl_freeMemory(pBuffer);
1486 0 : return REG_INVALID_VALUE;
1487 : }
1488 :
1489 0 : sal_uInt8 type = *((sal_uInt8*)pBuffer);
1490 0 : valueType = (RegValueType)type;
1491 0 : readUINT32(pBuffer+VALUE_TYPEOFFSET, valueSize);
1492 :
1493 0 : pBuffer = (sal_uInt8*)rtl_allocateMemory(valueSize);
1494 0 : if (rValue.readAt(VALUE_HEADEROFFSET, pBuffer, valueSize, rwBytes))
1495 : {
1496 0 : rtl_freeMemory(pBuffer);
1497 0 : return REG_INVALID_VALUE;
1498 : }
1499 0 : if (rwBytes != valueSize)
1500 : {
1501 0 : rtl_freeMemory(pBuffer);
1502 0 : return REG_INVALID_VALUE;
1503 : }
1504 :
1505 0 : const sal_Char* indent = sIndent.getStr();
1506 0 : switch (valueType)
1507 : {
1508 : case 0:
1509 0 : fprintf(stdout, "%sValue: Type = VALUETYPE_NOT_DEFINED\n", indent);
1510 0 : break;
1511 : case 1:
1512 : {
1513 0 : fprintf(stdout, "%sValue: Type = RG_VALUETYPE_LONG\n", indent);
1514 : fprintf(
1515 : stdout, "%s Size = %lu\n", indent,
1516 0 : sal::static_int_cast< unsigned long >(valueSize));
1517 0 : fprintf(stdout, "%s Data = ", indent);
1518 :
1519 : sal_Int32 value;
1520 0 : readINT32(pBuffer, value);
1521 0 : fprintf(stdout, "%ld\n", sal::static_int_cast< long >(value));
1522 : }
1523 0 : break;
1524 : case 2:
1525 : {
1526 0 : sal_Char* value = (sal_Char*)rtl_allocateMemory(valueSize);
1527 0 : readUtf8(pBuffer, value, valueSize);
1528 0 : fprintf(stdout, "%sValue: Type = RG_VALUETYPE_STRING\n", indent);
1529 : fprintf(
1530 : stdout, "%s Size = %lu\n", indent,
1531 0 : sal::static_int_cast< unsigned long >(valueSize));
1532 0 : fprintf(stdout, "%s Data = \"%s\"\n", indent, value);
1533 0 : rtl_freeMemory(value);
1534 : }
1535 0 : break;
1536 : case 3:
1537 : {
1538 0 : sal_uInt32 size = (valueSize / 2) * sizeof(sal_Unicode);
1539 0 : fprintf(stdout, "%sValue: Type = RG_VALUETYPE_UNICODE\n", indent);
1540 : fprintf(
1541 : stdout, "%s Size = %lu\n", indent,
1542 0 : sal::static_int_cast< unsigned long >(valueSize));
1543 0 : fprintf(stdout, "%s Data = ", indent);
1544 :
1545 0 : sal_Unicode* value = new sal_Unicode[size];
1546 0 : readString(pBuffer, value, size);
1547 :
1548 0 : OString uStr = OUStringToOString(value, RTL_TEXTENCODING_UTF8);
1549 0 : fprintf(stdout, "L\"%s\"\n", uStr.getStr());
1550 0 : delete[] value;
1551 : }
1552 0 : break;
1553 : case 4:
1554 : {
1555 0 : fprintf(stdout, "%sValue: Type = RG_VALUETYPE_BINARY\n", indent);
1556 : fprintf(
1557 : stdout, "%s Size = %lu\n", indent,
1558 0 : sal::static_int_cast< unsigned long >(valueSize));
1559 0 : fprintf(stdout, "%s Data = ", indent);
1560 : dumpType(
1561 : typereg::Reader(
1562 : pBuffer, valueSize, false, TYPEREG_VERSION_1),
1563 0 : sIndent + " ");
1564 : }
1565 0 : break;
1566 : case 5:
1567 : {
1568 0 : sal_uInt32 offset = 4; // initial 4 bytes for the size of the array
1569 0 : sal_uInt32 len = 0;
1570 :
1571 0 : readUINT32(pBuffer, len);
1572 :
1573 0 : fprintf(stdout, "%sValue: Type = RG_VALUETYPE_LONGLIST\n", indent);
1574 : fprintf(
1575 : stdout, "%s Size = %lu\n", indent,
1576 0 : sal::static_int_cast< unsigned long >(valueSize));
1577 : fprintf(
1578 : stdout, "%s Len = %lu\n", indent,
1579 0 : sal::static_int_cast< unsigned long >(len));
1580 0 : fprintf(stdout, "%s Data = ", indent);
1581 :
1582 : sal_Int32 longValue;
1583 0 : for (sal_uInt32 i=0; i < len; i++)
1584 : {
1585 0 : readINT32(pBuffer+offset, longValue);
1586 :
1587 0 : if (offset > 4)
1588 0 : fprintf(stdout, "%s ", indent);
1589 :
1590 : fprintf(
1591 : stdout, "%lu = %ld\n",
1592 : sal::static_int_cast< unsigned long >(i),
1593 0 : sal::static_int_cast< long >(longValue));
1594 0 : offset += 4; // 4 Bytes fuer sal_Int32
1595 : }
1596 : }
1597 0 : break;
1598 : case 6:
1599 : {
1600 0 : sal_uInt32 offset = 4; // initial 4 bytes for the size of the array
1601 0 : sal_uInt32 sLen = 0;
1602 0 : sal_uInt32 len = 0;
1603 :
1604 0 : readUINT32(pBuffer, len);
1605 :
1606 0 : fprintf(stdout, "%sValue: Type = RG_VALUETYPE_STRINGLIST\n", indent);
1607 : fprintf(
1608 : stdout, "%s Size = %lu\n", indent,
1609 0 : sal::static_int_cast< unsigned long >(valueSize));
1610 : fprintf(
1611 : stdout, "%s Len = %lu\n", indent,
1612 0 : sal::static_int_cast< unsigned long >(len));
1613 0 : fprintf(stdout, "%s Data = ", indent);
1614 :
1615 : sal_Char *pValue;
1616 0 : for (sal_uInt32 i=0; i < len; i++)
1617 : {
1618 0 : readUINT32(pBuffer+offset, sLen);
1619 :
1620 0 : offset += 4; // 4 Bytes (sal_uInt32) fuer die Groesse des strings in Bytes
1621 :
1622 0 : pValue = (sal_Char*)rtl_allocateMemory(sLen);
1623 0 : readUtf8(pBuffer+offset, pValue, sLen);
1624 :
1625 0 : if (offset > 8)
1626 0 : fprintf(stdout, "%s ", indent);
1627 :
1628 : fprintf(
1629 : stdout, "%lu = \"%s\"\n",
1630 0 : sal::static_int_cast< unsigned long >(i), pValue);
1631 0 : rtl_freeMemory(pValue);
1632 0 : offset += sLen;
1633 : }
1634 : }
1635 0 : break;
1636 : case 7:
1637 : {
1638 0 : sal_uInt32 offset = 4; // initial 4 bytes for the size of the array
1639 0 : sal_uInt32 sLen = 0;
1640 0 : sal_uInt32 len = 0;
1641 :
1642 0 : readUINT32(pBuffer, len);
1643 :
1644 0 : fprintf(stdout, "%sValue: Type = RG_VALUETYPE_UNICODELIST\n", indent);
1645 : fprintf(
1646 : stdout, "%s Size = %lu\n", indent,
1647 0 : sal::static_int_cast< unsigned long >(valueSize));
1648 : fprintf(
1649 : stdout, "%s Len = %lu\n", indent,
1650 0 : sal::static_int_cast< unsigned long >(len));
1651 0 : fprintf(stdout, "%s Data = ", indent);
1652 :
1653 : sal_Unicode *pValue;
1654 0 : OString uStr;
1655 0 : for (sal_uInt32 i=0; i < len; i++)
1656 : {
1657 0 : readUINT32(pBuffer+offset, sLen);
1658 :
1659 0 : offset += 4; // 4 Bytes (sal_uInt32) fuer die Groesse des strings in Bytes
1660 :
1661 0 : pValue = (sal_Unicode*)rtl_allocateMemory((sLen / 2) * sizeof(sal_Unicode));
1662 0 : readString(pBuffer+offset, pValue, sLen);
1663 :
1664 0 : if (offset > 8)
1665 0 : fprintf(stdout, "%s ", indent);
1666 :
1667 0 : uStr = OUStringToOString(pValue, RTL_TEXTENCODING_UTF8);
1668 : fprintf(
1669 : stdout, "%lu = L\"%s\"\n",
1670 : sal::static_int_cast< unsigned long >(i),
1671 0 : uStr.getStr());
1672 :
1673 0 : offset += sLen;
1674 :
1675 0 : rtl_freeMemory(pValue);
1676 0 : }
1677 : }
1678 0 : break;
1679 : }
1680 :
1681 0 : fprintf(stdout, "\n");
1682 :
1683 0 : rtl_freeMemory(pBuffer);
1684 0 : return REG_NO_ERROR;
1685 : }
1686 :
1687 :
1688 : // dumpKey()
1689 :
1690 0 : RegError ORegistry::dumpKey(const OUString& sPath, const OUString& sName, sal_Int16 nSpace) const
1691 : {
1692 0 : OStoreDirectory rStoreDir;
1693 0 : OUString sFullPath(sPath);
1694 0 : OString sIndent;
1695 0 : storeAccessMode accessMode = KEY_MODE_OPEN;
1696 0 : RegError _ret = REG_NO_ERROR;
1697 :
1698 0 : if (isReadOnly())
1699 : {
1700 0 : accessMode = KEY_MODE_OPENREAD;
1701 : }
1702 :
1703 0 : for (int i= 0; i < nSpace; i++) sIndent += " ";
1704 :
1705 0 : if (sFullPath.getLength() > 1)
1706 0 : sFullPath += ROOT;
1707 :
1708 0 : storeError _err = rStoreDir.create(m_file, sFullPath, sName, accessMode);
1709 :
1710 0 : if (_err == store_E_NotExists)
1711 0 : return REG_KEY_NOT_EXISTS;
1712 0 : else if (_err == store_E_WrongFormat)
1713 0 : return REG_INVALID_KEY;
1714 :
1715 0 : fprintf(stdout, "%s/ %s\n", sIndent.getStr(), OUStringToOString(sName, RTL_TEXTENCODING_UTF8).getStr());
1716 :
1717 0 : OUString sSubPath(sFullPath);
1718 0 : OUString sSubName;
1719 0 : sSubPath += sName;
1720 :
1721 : OStoreDirectory::iterator iter;
1722 :
1723 0 : _err = rStoreDir.first(iter);
1724 :
1725 0 : while ( _err == store_E_None)
1726 : {
1727 0 : sSubName = iter.m_pszName;
1728 :
1729 0 : if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR )
1730 : {
1731 0 : _ret = dumpKey(sSubPath, sSubName, nSpace+2);
1732 : } else
1733 : {
1734 0 : _ret = dumpValue(sSubPath, sSubName, nSpace+2);
1735 : }
1736 :
1737 0 : if (_ret)
1738 : {
1739 0 : return _ret;
1740 : }
1741 :
1742 0 : _err = rStoreDir.next(iter);
1743 : }
1744 :
1745 0 : return REG_NO_ERROR;
1746 : }
1747 :
1748 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
