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 <string.h>
22 :
23 : #include "keyimpl.hxx"
24 :
25 : #include "reflcnst.hxx"
26 : #include "rtl/alloc.h"
27 : #include "rtl/ustrbuf.hxx"
28 :
29 : using namespace store;
30 :
31 : namespace { static char const VALUE_PREFIX[] = "$VL_"; }
32 :
33 : //*********************************************************************
34 : // ORegKey()
35 : //
36 84403 : ORegKey::ORegKey(const OUString& keyName, ORegistry* pReg)
37 : : m_refCount(1)
38 : , m_name(keyName)
39 : , m_bDeleted(0)
40 : , m_bModified(0)
41 84403 : , m_pRegistry(pReg)
42 : {
43 84403 : }
44 :
45 : //*********************************************************************
46 : // ~ORegKey()
47 : //
48 84403 : ORegKey::~ORegKey()
49 : {
50 : OSL_POSTCOND(m_refCount == 0, "registry::ORegKey::dtor(): refcount not zero.");
51 84403 : }
52 :
53 : //*********************************************************************
54 : // releaseKey
55 : //
56 26721 : RegError ORegKey::releaseKey(RegKeyHandle hKey)
57 : {
58 26721 : return m_pRegistry->releaseKey(hKey);
59 : }
60 :
61 : //*********************************************************************
62 : // createKey
63 : //
64 32403 : RegError ORegKey::createKey(const OUString& keyName, RegKeyHandle* phNewKey)
65 : {
66 32403 : return m_pRegistry->createKey(this, keyName, phNewKey);
67 : }
68 :
69 :
70 : //*********************************************************************
71 : // openKey
72 : //
73 41274 : RegError ORegKey::openKey(const OUString& keyName, RegKeyHandle* phOpenKey)
74 : {
75 41274 : return m_pRegistry->openKey(this, keyName, phOpenKey);
76 : }
77 :
78 :
79 : //*********************************************************************
80 : // openSubKeys
81 : //
82 7 : RegError ORegKey::openSubKeys(const OUString& keyName, RegKeyHandle** phOpenSubKeys, sal_uInt32* pnSubKeys)
83 : {
84 7 : RegError _ret = REG_NO_ERROR;
85 :
86 7 : *phOpenSubKeys = 0;
87 7 : *pnSubKeys = 0;
88 :
89 7 : ORegKey* pKey = this;
90 7 : if ( !keyName.isEmpty() )
91 : {
92 0 : _ret = openKey(keyName, (RegKeyHandle*)&pKey);
93 0 : if (_ret != REG_NO_ERROR)
94 0 : return _ret;
95 : }
96 :
97 7 : sal_uInt32 nSubKeys = pKey->countSubKeys();
98 7 : *pnSubKeys = nSubKeys;
99 :
100 : ORegKey** pSubKeys;
101 7 : pSubKeys = (ORegKey**)rtl_allocateZeroMemory(nSubKeys * sizeof(ORegKey*));
102 :
103 : OStoreDirectory::iterator iter;
104 7 : OStoreDirectory rStoreDir(pKey->getStoreDir());
105 7 : storeError _err = rStoreDir.first(iter);
106 :
107 7 : nSubKeys = 0;
108 22 : while ( _err == store_E_None )
109 : {
110 8 : if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR )
111 : {
112 8 : OUString const sSubKeyName = iter.m_pszName;
113 :
114 8 : ORegKey* pOpenSubKey = 0;
115 8 : _ret = pKey->openKey(sSubKeyName, (RegKeyHandle*)&pOpenSubKey);
116 8 : if (_ret != REG_NO_ERROR)
117 : {
118 0 : *phOpenSubKeys = NULL;
119 0 : *pnSubKeys = 0;
120 0 : rtl_freeMemory(pSubKeys); // @@@ leaking 'pSubKeys[0...nSubkeys-1]'
121 0 : return _ret; // @@@ leaking 'pKey'
122 : }
123 :
124 8 : pSubKeys[nSubKeys] = pOpenSubKey;
125 :
126 8 : nSubKeys++;
127 : }
128 :
129 8 : _err = rStoreDir.next(iter);
130 : }
131 :
132 7 : *phOpenSubKeys = (RegKeyHandle*)pSubKeys;
133 7 : if (!keyName.isEmpty())
134 : {
135 0 : (void) releaseKey(pKey);
136 : }
137 7 : return REG_NO_ERROR;
138 : }
139 :
140 :
141 : //*********************************************************************
142 : // getKeyNames
143 : //
144 8823 : RegError ORegKey::getKeyNames(const OUString& keyName,
145 : rtl_uString*** pSubKeyNames,
146 : sal_uInt32* pnSubKeys)
147 : {
148 8823 : RegError _ret = REG_NO_ERROR;
149 :
150 8823 : *pSubKeyNames = 0;
151 8823 : *pnSubKeys = 0;
152 :
153 8823 : ORegKey* pKey = this;
154 8823 : if (!keyName.isEmpty())
155 : {
156 0 : _ret = openKey(keyName, (RegKeyHandle*)&pKey);
157 0 : if (_ret != REG_NO_ERROR)
158 0 : return _ret;
159 : }
160 :
161 8823 : sal_uInt32 nSubKeys = pKey->countSubKeys();
162 8823 : *pnSubKeys = nSubKeys;
163 :
164 8823 : rtl_uString** pSubKeys = 0;
165 8823 : pSubKeys = (rtl_uString**)rtl_allocateZeroMemory(nSubKeys * sizeof(rtl_uString*));
166 :
167 : OStoreDirectory::iterator iter;
168 8823 : OStoreDirectory rStoreDir(pKey->getStoreDir());
169 8823 : storeError _err = rStoreDir.first(iter);
170 :
171 8823 : nSubKeys = 0;
172 :
173 41006 : while ( _err == store_E_None )
174 : {
175 23360 : if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR)
176 : {
177 14559 : OUString const sSubKeyName = iter.m_pszName;
178 :
179 29118 : OUString sFullKeyName(pKey->getName());
180 14559 : if (sFullKeyName.getLength() > 1)
181 14554 : sFullKeyName += m_pRegistry->ROOT;
182 14559 : sFullKeyName += sSubKeyName;
183 :
184 14559 : rtl_uString_newFromString(&pSubKeys[nSubKeys], sFullKeyName.pData);
185 :
186 29118 : nSubKeys++;
187 : }
188 :
189 23360 : _err = rStoreDir.next(iter);
190 : }
191 :
192 8823 : *pSubKeyNames = pSubKeys;
193 8823 : if (!keyName.isEmpty())
194 : {
195 0 : releaseKey(pKey);
196 : }
197 8823 : return REG_NO_ERROR;
198 : }
199 :
200 :
201 : //*********************************************************************
202 : // closeKey
203 : //
204 5316 : RegError ORegKey::closeKey(RegKeyHandle hKey)
205 : {
206 5316 : return (m_pRegistry->closeKey(hKey));
207 : }
208 :
209 :
210 : //*********************************************************************
211 : // deleteKey
212 : //
213 2 : RegError ORegKey::deleteKey(const OUString& keyName)
214 : {
215 2 : return (m_pRegistry->deleteKey(this, keyName));
216 : }
217 :
218 :
219 : //*********************************************************************
220 : // getValueType
221 : //
222 14529 : RegError ORegKey::getValueInfo(const OUString& valueName, RegValueType* pValueType, sal_uInt32* pValueSize) const
223 : {
224 14529 : OStoreStream rValue;
225 : sal_uInt8* pBuffer;
226 14529 : storeAccessMode accessMode = VALUE_MODE_OPEN;
227 :
228 14529 : if (m_pRegistry->isReadOnly())
229 : {
230 14515 : accessMode = VALUE_MODE_OPENREAD;
231 : }
232 :
233 29058 : OUString sImplValueName( RTL_CONSTASCII_USTRINGPARAM(VALUE_PREFIX) );
234 14529 : sImplValueName += valueName;
235 :
236 29058 : REG_GUARD(m_pRegistry->m_mutex);
237 :
238 14529 : if ( rValue.create(m_pRegistry->getStoreFile(), m_name + m_pRegistry->ROOT, sImplValueName, accessMode) )
239 : {
240 16 : *pValueType = RG_VALUETYPE_NOT_DEFINED;
241 16 : *pValueSize = 0;
242 16 : return REG_VALUE_NOT_EXISTS;
243 : }
244 :
245 14513 : pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE);
246 :
247 : sal_uInt32 readBytes;
248 14513 : if ( rValue.readAt(0, pBuffer, VALUE_HEADERSIZE, readBytes) )
249 : {
250 0 : rtl_freeMemory(pBuffer);
251 0 : return REG_INVALID_VALUE;
252 : }
253 14513 : if (readBytes != VALUE_HEADERSIZE)
254 : {
255 0 : rtl_freeMemory(pBuffer);
256 0 : return REG_INVALID_VALUE;
257 : }
258 :
259 : sal_uInt32 size;
260 14513 : sal_uInt8 type = *((sal_uInt8*)pBuffer);
261 14513 : readUINT32(pBuffer+VALUE_TYPEOFFSET, size);
262 :
263 14513 : *pValueType = (RegValueType)type;
264 : // if (*pValueType == RG_VALUETYPE_UNICODE)
265 : // {
266 : // *pValueSize = (size / 2) * sizeof(sal_Unicode);
267 : // } else
268 : // {
269 14513 : if (*pValueType > 4)
270 : {
271 0 : rtl_freeMemory(pBuffer);
272 0 : pBuffer = (sal_uInt8*)rtl_allocateMemory(4);
273 0 : rValue.readAt(VALUE_HEADEROFFSET, pBuffer, 4, readBytes);
274 :
275 0 : readUINT32(pBuffer, size);
276 : }
277 :
278 14513 : *pValueSize = size;
279 : // }
280 :
281 14513 : rtl_freeMemory(pBuffer);
282 29042 : return REG_NO_ERROR;
283 : }
284 :
285 :
286 : //*********************************************************************
287 : // setValue
288 : //
289 27103 : RegError ORegKey::setValue(const OUString& valueName, RegValueType vType, RegValue value, sal_uInt32 vSize)
290 : {
291 27103 : OStoreStream rValue;
292 : sal_uInt8* pBuffer;
293 :
294 27103 : if (m_pRegistry->isReadOnly())
295 : {
296 0 : return REG_REGISTRY_READONLY;
297 : }
298 :
299 27103 : if (vType > 4)
300 : {
301 0 : return REG_INVALID_VALUE;
302 : }
303 :
304 54206 : OUString sImplValueName( RTL_CONSTASCII_USTRINGPARAM(VALUE_PREFIX) );
305 27103 : sImplValueName += valueName;
306 :
307 54206 : REG_GUARD(m_pRegistry->m_mutex);
308 :
309 27103 : if ( rValue.create(getStoreFile(), m_name + m_pRegistry->ROOT , sImplValueName, VALUE_MODE_CREATE) )
310 : {
311 0 : return REG_SET_VALUE_FAILED;
312 : }
313 :
314 27103 : sal_uInt32 size = vSize;
315 :
316 27103 : sal_uInt8 type = (sal_uInt8)vType;
317 27103 : pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE + size);
318 27103 : memcpy(pBuffer, &type, 1);
319 :
320 27103 : writeUINT32(pBuffer+VALUE_TYPEOFFSET, size);
321 :
322 27103 : switch (vType)
323 : {
324 : case RG_VALUETYPE_NOT_DEFINED:
325 0 : memcpy(pBuffer+VALUE_HEADEROFFSET, value, size);
326 0 : break;
327 : case RG_VALUETYPE_LONG:
328 0 : writeINT32(pBuffer+VALUE_HEADEROFFSET, *((sal_Int32*)value));
329 0 : break;
330 : case RG_VALUETYPE_STRING:
331 4 : writeUtf8(pBuffer+VALUE_HEADEROFFSET, (const sal_Char*)value);
332 4 : break;
333 : case RG_VALUETYPE_UNICODE:
334 0 : writeString(pBuffer+VALUE_HEADEROFFSET, (const sal_Unicode*)value);
335 0 : break;
336 : case RG_VALUETYPE_BINARY:
337 27099 : memcpy(pBuffer+VALUE_HEADEROFFSET, value, size);
338 27099 : break;
339 : default:
340 : OSL_ASSERT(false);
341 0 : break;
342 : }
343 :
344 : sal_uInt32 writenBytes;
345 27103 : if ( rValue.writeAt(0, pBuffer, VALUE_HEADERSIZE+size, writenBytes) )
346 : {
347 0 : rtl_freeMemory(pBuffer);
348 0 : return REG_SET_VALUE_FAILED;
349 : }
350 27103 : if (writenBytes != (VALUE_HEADERSIZE+size))
351 : {
352 0 : rtl_freeMemory(pBuffer);
353 0 : return REG_SET_VALUE_FAILED;
354 : }
355 27103 : setModified();
356 :
357 27103 : rtl_freeMemory(pBuffer);
358 54206 : return REG_NO_ERROR;
359 : }
360 :
361 : //*********************************************************************
362 : // setLongListValue
363 : //
364 0 : RegError ORegKey::setLongListValue(const OUString& valueName, sal_Int32* pValueList, sal_uInt32 len)
365 : {
366 0 : OStoreStream rValue;
367 : sal_uInt8* pBuffer;
368 :
369 0 : if (m_pRegistry->isReadOnly())
370 : {
371 0 : return REG_REGISTRY_READONLY;
372 : }
373 :
374 0 : OUString sImplValueName( RTL_CONSTASCII_USTRINGPARAM(VALUE_PREFIX) );
375 0 : sImplValueName += valueName;
376 :
377 0 : REG_GUARD(m_pRegistry->m_mutex);
378 :
379 0 : if (rValue.create(getStoreFile(), m_name + m_pRegistry->ROOT, sImplValueName, VALUE_MODE_CREATE) )
380 : {
381 0 : return REG_SET_VALUE_FAILED;
382 : }
383 :
384 0 : sal_uInt32 size = 4; // 4 Bytes (sal_uInt32) fuer die Laenge
385 :
386 0 : size += len * 4;
387 :
388 0 : sal_uInt8 type = (sal_uInt8)RG_VALUETYPE_LONGLIST;
389 0 : pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE + size);
390 0 : memcpy(pBuffer, &type, 1);
391 :
392 0 : writeUINT32(pBuffer+VALUE_TYPEOFFSET, size);
393 0 : writeUINT32(pBuffer+VALUE_HEADEROFFSET, len);
394 :
395 0 : sal_uInt32 offset = 4; // initial 4 Bytes fuer die Laenge des Arrays
396 :
397 0 : for (sal_uInt32 i=0; i < len; i++)
398 : {
399 0 : writeINT32(pBuffer+VALUE_HEADEROFFSET+offset, pValueList[i]);
400 0 : offset += 4;
401 : }
402 :
403 : sal_uInt32 writenBytes;
404 0 : if ( rValue.writeAt(0, pBuffer, VALUE_HEADERSIZE+size, writenBytes) )
405 : {
406 0 : rtl_freeMemory(pBuffer);
407 0 : return REG_SET_VALUE_FAILED;
408 : }
409 0 : if (writenBytes != (VALUE_HEADEROFFSET+size))
410 : {
411 0 : rtl_freeMemory(pBuffer);
412 0 : return REG_SET_VALUE_FAILED;
413 : }
414 0 : setModified();
415 :
416 0 : rtl_freeMemory(pBuffer);
417 0 : return REG_NO_ERROR;
418 : }
419 :
420 : //*********************************************************************
421 : // setStringListValue
422 : //
423 1 : RegError ORegKey::setStringListValue(const OUString& valueName, sal_Char** pValueList, sal_uInt32 len)
424 : {
425 1 : OStoreStream rValue;
426 : sal_uInt8* pBuffer;
427 :
428 1 : if (m_pRegistry->isReadOnly())
429 : {
430 0 : return REG_REGISTRY_READONLY;
431 : }
432 :
433 2 : OUString sImplValueName( RTL_CONSTASCII_USTRINGPARAM(VALUE_PREFIX) );
434 1 : sImplValueName += valueName;
435 :
436 2 : REG_GUARD(m_pRegistry->m_mutex);
437 :
438 1 : if (rValue.create(getStoreFile(), m_name + m_pRegistry->ROOT, sImplValueName, VALUE_MODE_CREATE) )
439 : {
440 0 : return REG_SET_VALUE_FAILED;
441 : }
442 :
443 1 : sal_uInt32 size = 4; // 4 Bytes (sal_uInt32) fuer die Laenge
444 :
445 : sal_uInt32 i;
446 2 : for (i=0; i < len; i++)
447 : {
448 1 : size += 4 + strlen(pValueList[i]) + 1;
449 : }
450 :
451 1 : sal_uInt8 type = (sal_uInt8)RG_VALUETYPE_STRINGLIST;
452 1 : pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE + size);
453 1 : memcpy(pBuffer, &type, 1);
454 :
455 1 : writeUINT32(pBuffer+VALUE_TYPEOFFSET, size);
456 1 : writeUINT32(pBuffer+VALUE_HEADEROFFSET, len);
457 :
458 1 : sal_uInt32 offset = 4; // initial 4 Bytes fuer die Laenge des Arrays;
459 1 : sal_uInt32 sLen = 0;
460 :
461 2 : for (i=0; i < len; i++)
462 : {
463 1 : sLen = strlen(pValueList[i]) + 1;
464 1 : writeUINT32(pBuffer+VALUE_HEADEROFFSET+offset, sLen);
465 :
466 1 : offset += 4;
467 1 : writeUtf8(pBuffer+VALUE_HEADEROFFSET+offset, pValueList[i]);
468 1 : offset += sLen;
469 : }
470 :
471 : sal_uInt32 writenBytes;
472 1 : if ( rValue.writeAt(0, pBuffer, VALUE_HEADERSIZE+size, writenBytes) )
473 : {
474 0 : rtl_freeMemory(pBuffer);
475 0 : return REG_SET_VALUE_FAILED;
476 : }
477 1 : if (writenBytes != (VALUE_HEADERSIZE+size))
478 : {
479 0 : rtl_freeMemory(pBuffer);
480 0 : return REG_SET_VALUE_FAILED;
481 : }
482 1 : setModified();
483 :
484 1 : rtl_freeMemory(pBuffer);
485 2 : return REG_NO_ERROR;
486 : }
487 :
488 : //*********************************************************************
489 : // setUnicodeListValue
490 : //
491 0 : RegError ORegKey::setUnicodeListValue(const OUString& valueName, sal_Unicode** pValueList, sal_uInt32 len)
492 : {
493 0 : OStoreStream rValue;
494 : sal_uInt8* pBuffer;
495 :
496 0 : if (m_pRegistry->isReadOnly())
497 : {
498 0 : return REG_REGISTRY_READONLY;
499 : }
500 :
501 0 : OUString sImplValueName( RTL_CONSTASCII_USTRINGPARAM(VALUE_PREFIX) );
502 0 : sImplValueName += valueName;
503 :
504 0 : REG_GUARD(m_pRegistry->m_mutex);
505 :
506 0 : if (rValue.create(getStoreFile(), m_name + m_pRegistry->ROOT, sImplValueName, VALUE_MODE_CREATE) )
507 : {
508 0 : return REG_SET_VALUE_FAILED;
509 : }
510 :
511 0 : sal_uInt32 size = 4; // 4 Bytes (sal_uInt32) fuer die Laenge
512 :
513 : sal_uInt32 i;
514 0 : for (i=0; i < len; i++)
515 : {
516 0 : size += 4 + ((rtl_ustr_getLength(pValueList[i]) +1) * 2);
517 : }
518 :
519 0 : sal_uInt8 type = (sal_uInt8)RG_VALUETYPE_UNICODELIST;
520 0 : pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE + size);
521 0 : memcpy(pBuffer, &type, 1);
522 :
523 0 : writeUINT32(pBuffer+VALUE_TYPEOFFSET, size);
524 0 : writeUINT32(pBuffer+VALUE_HEADEROFFSET, len);
525 :
526 0 : sal_uInt32 offset = 4; // initial 4 Bytes fuer die Laenge des Arrays;
527 0 : sal_uInt32 sLen = 0;
528 :
529 0 : for (i=0; i < len; i++)
530 : {
531 0 : sLen = (rtl_ustr_getLength(pValueList[i]) + 1) * 2;
532 0 : writeUINT32(pBuffer+VALUE_HEADEROFFSET+offset, sLen);
533 :
534 0 : offset += 4;
535 0 : writeString(pBuffer+VALUE_HEADEROFFSET+offset, pValueList[i]);
536 0 : offset += sLen;
537 : }
538 :
539 : sal_uInt32 writenBytes;
540 0 : if ( rValue.writeAt(0, pBuffer, VALUE_HEADERSIZE+size, writenBytes) )
541 : {
542 0 : rtl_freeMemory(pBuffer);
543 0 : return REG_SET_VALUE_FAILED;
544 : }
545 0 : if (writenBytes != (VALUE_HEADERSIZE+size))
546 : {
547 0 : rtl_freeMemory(pBuffer);
548 0 : return REG_SET_VALUE_FAILED;
549 : }
550 0 : setModified();
551 :
552 0 : rtl_freeMemory(pBuffer);
553 0 : return REG_NO_ERROR;
554 : }
555 :
556 : //*********************************************************************
557 : // getValue
558 : //
559 14510 : RegError ORegKey::getValue(const OUString& valueName, RegValue value) const
560 : {
561 14510 : OStoreStream rValue;
562 : sal_uInt8* pBuffer;
563 : RegValueType valueType;
564 : sal_uInt32 valueSize;
565 14510 : storeAccessMode accessMode = VALUE_MODE_OPEN;
566 :
567 14510 : if (m_pRegistry->isReadOnly())
568 : {
569 14507 : accessMode = VALUE_MODE_OPENREAD;
570 : }
571 :
572 29020 : OUString sImplValueName( RTL_CONSTASCII_USTRINGPARAM(VALUE_PREFIX) );
573 14510 : sImplValueName += valueName;
574 :
575 29020 : REG_GUARD(m_pRegistry->m_mutex);
576 :
577 14510 : if (rValue.create(getStoreFile(), m_name + m_pRegistry->ROOT, sImplValueName, accessMode) )
578 : {
579 0 : return REG_VALUE_NOT_EXISTS;
580 : }
581 :
582 14510 : pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE);
583 :
584 : sal_uInt32 readBytes;
585 14510 : if ( rValue.readAt(0, pBuffer, VALUE_HEADERSIZE, readBytes) )
586 : {
587 0 : rtl_freeMemory(pBuffer);
588 0 : return REG_INVALID_VALUE;
589 : }
590 14510 : if (readBytes != VALUE_HEADERSIZE)
591 : {
592 0 : rtl_freeMemory(pBuffer);
593 0 : return REG_INVALID_VALUE;
594 : }
595 :
596 14510 : sal_uInt8 type = *((sal_uInt8*)pBuffer);
597 14510 : valueType = (RegValueType)type;
598 14510 : readUINT32(pBuffer+VALUE_TYPEOFFSET, valueSize);
599 :
600 14510 : rtl_freeMemory(pBuffer);
601 :
602 14510 : if (valueType > 4)
603 : {
604 0 : return REG_INVALID_VALUE;
605 : }
606 :
607 14510 : pBuffer = (sal_uInt8*)rtl_allocateMemory(valueSize);
608 :
609 14510 : if ( rValue.readAt(VALUE_HEADEROFFSET, pBuffer, valueSize, readBytes) )
610 : {
611 0 : rtl_freeMemory(pBuffer);
612 0 : return REG_INVALID_VALUE;
613 : }
614 14510 : if (readBytes != valueSize)
615 : {
616 0 : rtl_freeMemory(pBuffer);
617 0 : return REG_INVALID_VALUE;
618 : }
619 :
620 14510 : switch (valueType)
621 : {
622 : case RG_VALUETYPE_NOT_DEFINED:
623 0 : memcpy(value, pBuffer, valueSize);
624 0 : break;
625 : case RG_VALUETYPE_LONG:
626 0 : readINT32(pBuffer, *((sal_Int32*)value));
627 0 : break;
628 : case RG_VALUETYPE_STRING:
629 3 : readUtf8(pBuffer, (sal_Char*)value, valueSize);
630 3 : break;
631 : case RG_VALUETYPE_UNICODE:
632 0 : readString(pBuffer, (sal_Unicode*)value, valueSize);
633 0 : break;
634 : case RG_VALUETYPE_BINARY:
635 14507 : memcpy(value, pBuffer, valueSize);
636 14507 : break;
637 : case RG_VALUETYPE_LONGLIST:
638 : case RG_VALUETYPE_STRINGLIST:
639 : case RG_VALUETYPE_UNICODELIST:
640 0 : memcpy(value, pBuffer, valueSize);
641 0 : break;
642 : }
643 :
644 :
645 14510 : rtl_freeMemory(pBuffer);
646 29020 : return REG_NO_ERROR;
647 : }
648 :
649 : //*********************************************************************
650 : // getLongListValue
651 : //
652 0 : RegError ORegKey::getLongListValue(const OUString& valueName, sal_Int32** pValueList, sal_uInt32* pLen) const
653 : {
654 0 : OStoreStream rValue;
655 : sal_uInt8* pBuffer;
656 : RegValueType valueType;
657 : sal_uInt32 valueSize;
658 0 : storeAccessMode accessMode = VALUE_MODE_OPEN;
659 :
660 0 : if (m_pRegistry->isReadOnly())
661 : {
662 0 : accessMode = VALUE_MODE_OPENREAD;
663 : }
664 :
665 0 : OUString sImplValueName( RTL_CONSTASCII_USTRINGPARAM(VALUE_PREFIX) );
666 0 : sImplValueName += valueName;
667 :
668 0 : REG_GUARD(m_pRegistry->m_mutex);
669 :
670 0 : if (rValue.create(getStoreFile(), m_name + m_pRegistry->ROOT, sImplValueName, accessMode) )
671 : {
672 0 : pValueList = NULL;
673 0 : *pLen = 0;
674 0 : return REG_VALUE_NOT_EXISTS;
675 : }
676 :
677 0 : pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE);
678 :
679 : sal_uInt32 readBytes;
680 0 : if ( rValue.readAt(0, pBuffer, VALUE_HEADERSIZE, readBytes) )
681 : {
682 0 : pValueList = NULL;
683 0 : *pLen = 0;
684 0 : rtl_freeMemory(pBuffer);
685 0 : return REG_INVALID_VALUE;
686 : }
687 0 : if (readBytes != VALUE_HEADERSIZE)
688 : {
689 0 : pValueList = NULL;
690 0 : *pLen = 0;
691 0 : rtl_freeMemory(pBuffer);
692 0 : return REG_INVALID_VALUE;
693 : }
694 :
695 0 : sal_uInt8 type = *((sal_uInt8*)pBuffer);
696 0 : valueType = (RegValueType)type;
697 :
698 0 : if (valueType != RG_VALUETYPE_LONGLIST)
699 : {
700 0 : pValueList = NULL;
701 0 : *pLen = 0;
702 0 : rtl_freeMemory(pBuffer);
703 0 : return REG_INVALID_VALUE;
704 : }
705 :
706 0 : readUINT32(pBuffer+VALUE_TYPEOFFSET, valueSize);
707 :
708 0 : rtl_freeMemory(pBuffer);
709 :
710 0 : pBuffer = (sal_uInt8*)rtl_allocateMemory(valueSize);
711 :
712 0 : if ( rValue.readAt(VALUE_HEADEROFFSET, pBuffer, valueSize, readBytes) )
713 : {
714 0 : pValueList = NULL;
715 0 : *pLen = 0;
716 0 : rtl_freeMemory(pBuffer);
717 0 : return REG_INVALID_VALUE;
718 : }
719 0 : if (readBytes != valueSize)
720 : {
721 0 : pValueList = NULL;
722 0 : *pLen = 0;
723 0 : rtl_freeMemory(pBuffer);
724 0 : return REG_INVALID_VALUE;
725 : }
726 :
727 0 : sal_uInt32 len = 0;
728 0 : readUINT32(pBuffer, len);
729 :
730 0 : *pLen = len;
731 0 : sal_Int32* pVList = (sal_Int32*)rtl_allocateZeroMemory(len * sizeof(sal_Int32));
732 :
733 0 : sal_uInt32 offset = 4; // initial 4 Bytes fuer die Laenge des Arrays;
734 :
735 0 : for (sal_uInt32 i=0; i < len; i++)
736 : {
737 0 : readINT32(pBuffer+offset, pVList[i]);
738 0 : offset += 4;
739 : }
740 :
741 0 : *pValueList = pVList;
742 0 : rtl_freeMemory(pBuffer);
743 0 : return REG_NO_ERROR;
744 : }
745 :
746 : //*********************************************************************
747 : // getStringListValue
748 : //
749 0 : RegError ORegKey::getStringListValue(const OUString& valueName, sal_Char*** pValueList, sal_uInt32* pLen) const
750 : {
751 0 : OStoreStream rValue;
752 : sal_uInt8* pBuffer;
753 : RegValueType valueType;
754 : sal_uInt32 valueSize;
755 0 : storeAccessMode accessMode = VALUE_MODE_OPEN;
756 :
757 0 : if (m_pRegistry->isReadOnly())
758 : {
759 0 : accessMode = VALUE_MODE_OPENREAD;
760 : }
761 :
762 0 : OUString sImplValueName( RTL_CONSTASCII_USTRINGPARAM(VALUE_PREFIX) );
763 0 : sImplValueName += valueName;
764 :
765 0 : REG_GUARD(m_pRegistry->m_mutex);
766 :
767 0 : if ( rValue.create(getStoreFile(), m_name + m_pRegistry->ROOT, sImplValueName, accessMode) )
768 : {
769 0 : pValueList = NULL;
770 0 : *pLen = 0;
771 0 : return REG_VALUE_NOT_EXISTS;
772 : }
773 :
774 0 : pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE);
775 :
776 : sal_uInt32 readBytes;
777 0 : if ( rValue.readAt(0, pBuffer, VALUE_HEADERSIZE, readBytes) )
778 : {
779 0 : pValueList = NULL;
780 0 : *pLen = 0;
781 0 : rtl_freeMemory(pBuffer);
782 0 : return REG_INVALID_VALUE;
783 : }
784 0 : if (readBytes != VALUE_HEADERSIZE)
785 : {
786 0 : pValueList = NULL;
787 0 : *pLen = 0;
788 0 : rtl_freeMemory(pBuffer);
789 0 : return REG_INVALID_VALUE;
790 : }
791 :
792 0 : sal_uInt8 type = *((sal_uInt8*)pBuffer);
793 0 : valueType = (RegValueType)type;
794 :
795 0 : if (valueType != RG_VALUETYPE_STRINGLIST)
796 : {
797 0 : pValueList = NULL;
798 0 : *pLen = 0;
799 0 : rtl_freeMemory(pBuffer);
800 0 : return REG_INVALID_VALUE;
801 : }
802 :
803 0 : readUINT32(pBuffer+VALUE_TYPEOFFSET, valueSize);
804 :
805 0 : rtl_freeMemory(pBuffer);
806 :
807 0 : pBuffer = (sal_uInt8*)rtl_allocateMemory(valueSize);
808 :
809 0 : if ( rValue.readAt(VALUE_HEADEROFFSET, pBuffer, valueSize, readBytes) )
810 : {
811 0 : pValueList = NULL;
812 0 : *pLen = 0;
813 0 : rtl_freeMemory(pBuffer);
814 0 : return REG_INVALID_VALUE;
815 : }
816 0 : if (readBytes != valueSize)
817 : {
818 0 : pValueList = NULL;
819 0 : *pLen = 0;
820 0 : rtl_freeMemory(pBuffer);
821 0 : return REG_INVALID_VALUE;
822 : }
823 :
824 0 : sal_uInt32 len = 0;
825 0 : readUINT32(pBuffer, len);
826 :
827 0 : *pLen = len;
828 0 : sal_Char** pVList = (sal_Char**)rtl_allocateZeroMemory(len * sizeof(sal_Char*));
829 :
830 0 : sal_uInt32 offset = 4; // initial 4 Bytes fuer die Laenge des Arrays;
831 0 : sal_uInt32 sLen = 0;
832 :
833 : sal_Char *pValue;
834 0 : for (sal_uInt32 i=0; i < len; i++)
835 : {
836 0 : readUINT32(pBuffer+offset, sLen);
837 :
838 0 : offset += 4;
839 :
840 0 : pValue = (sal_Char*)rtl_allocateMemory(sLen);
841 0 : readUtf8(pBuffer+offset, pValue, sLen);
842 0 : pVList[i] = pValue;
843 :
844 0 : offset += sLen;
845 : }
846 :
847 0 : *pValueList = pVList;
848 0 : rtl_freeMemory(pBuffer);
849 0 : return REG_NO_ERROR;
850 : }
851 :
852 : //*********************************************************************
853 : // getUnicodeListValue
854 : //
855 0 : RegError ORegKey::getUnicodeListValue(const OUString& valueName, sal_Unicode*** pValueList, sal_uInt32* pLen) const
856 : {
857 0 : OStoreStream rValue;
858 : sal_uInt8* pBuffer;
859 : RegValueType valueType;
860 : sal_uInt32 valueSize;
861 0 : storeAccessMode accessMode = VALUE_MODE_OPEN;
862 :
863 0 : if (m_pRegistry->isReadOnly())
864 : {
865 0 : accessMode = VALUE_MODE_OPENREAD;
866 : }
867 :
868 0 : OUString sImplValueName( RTL_CONSTASCII_USTRINGPARAM(VALUE_PREFIX) );
869 0 : sImplValueName += valueName;
870 :
871 0 : REG_GUARD(m_pRegistry->m_mutex);
872 :
873 0 : if ( rValue.create(getStoreFile(), m_name + m_pRegistry->ROOT, sImplValueName, accessMode) )
874 : {
875 0 : pValueList = NULL;
876 0 : *pLen = 0;
877 0 : return REG_VALUE_NOT_EXISTS;
878 : }
879 :
880 0 : pBuffer = (sal_uInt8*)rtl_allocateMemory(VALUE_HEADERSIZE);
881 :
882 : sal_uInt32 readBytes;
883 0 : if ( rValue.readAt(0, pBuffer, VALUE_HEADERSIZE, readBytes) )
884 : {
885 0 : pValueList = NULL;
886 0 : *pLen = 0;
887 0 : rtl_freeMemory(pBuffer);
888 0 : return REG_INVALID_VALUE;
889 : }
890 0 : if (readBytes != VALUE_HEADERSIZE)
891 : {
892 0 : pValueList = NULL;
893 0 : *pLen = 0;
894 0 : rtl_freeMemory(pBuffer);
895 0 : return REG_INVALID_VALUE;
896 : }
897 :
898 0 : sal_uInt8 type = *((sal_uInt8*)pBuffer);
899 0 : valueType = (RegValueType)type;
900 :
901 0 : if (valueType != RG_VALUETYPE_UNICODELIST)
902 : {
903 0 : pValueList = NULL;
904 0 : *pLen = 0;
905 0 : rtl_freeMemory(pBuffer);
906 0 : return REG_INVALID_VALUE;
907 : }
908 :
909 0 : readUINT32(pBuffer+VALUE_TYPEOFFSET, valueSize);
910 :
911 0 : rtl_freeMemory(pBuffer);
912 :
913 0 : pBuffer = (sal_uInt8*)rtl_allocateMemory(valueSize);
914 :
915 0 : if ( rValue.readAt(VALUE_HEADEROFFSET, pBuffer, valueSize, readBytes) )
916 : {
917 0 : pValueList = NULL;
918 0 : *pLen = 0;
919 0 : rtl_freeMemory(pBuffer);
920 0 : return REG_INVALID_VALUE;
921 : }
922 0 : if (readBytes != valueSize)
923 : {
924 0 : pValueList = NULL;
925 0 : *pLen = 0;
926 0 : rtl_freeMemory(pBuffer);
927 0 : return REG_INVALID_VALUE;
928 : }
929 :
930 0 : sal_uInt32 len = 0;
931 0 : readUINT32(pBuffer, len);
932 :
933 0 : *pLen = len;
934 0 : sal_Unicode** pVList = (sal_Unicode**)rtl_allocateZeroMemory(len * sizeof(sal_Unicode*));
935 :
936 0 : sal_uInt32 offset = 4; // initial 4 Bytes fuer die Laenge des Arrays;
937 0 : sal_uInt32 sLen = 0;
938 :
939 : sal_Unicode *pValue;
940 0 : for (sal_uInt32 i=0; i < len; i++)
941 : {
942 0 : readUINT32(pBuffer+offset, sLen);
943 :
944 0 : offset += 4;
945 :
946 0 : pValue = (sal_Unicode*)rtl_allocateMemory((sLen / 2) * sizeof(sal_Unicode));
947 0 : readString(pBuffer+offset, pValue, sLen);
948 0 : pVList[i] = pValue;
949 :
950 0 : offset += sLen;
951 : }
952 :
953 0 : *pValueList = pVList;
954 0 : rtl_freeMemory(pBuffer);
955 0 : return REG_NO_ERROR;
956 : }
957 :
958 : //*********************************************************************
959 : // getKeyType()
960 : //
961 7 : RegError ORegKey::getKeyType(const OUString& name, RegKeyType* pKeyType) const
962 : {
963 7 : *pKeyType = RG_KEYTYPE;
964 :
965 7 : REG_GUARD(m_pRegistry->m_mutex);
966 :
967 7 : if ( !name.isEmpty() )
968 : {
969 7 : ORegKey* pThis = const_cast< ORegKey* >(this);
970 :
971 7 : RegKeyHandle hKey = 0;
972 7 : RegError _ret = pThis->openKey(name, &hKey);
973 7 : if (_ret != REG_NO_ERROR)
974 0 : return _ret;
975 7 : (void) pThis->releaseKey(hKey);
976 : }
977 :
978 7 : return REG_NO_ERROR;
979 : }
980 :
981 0 : RegError ORegKey::getResolvedKeyName(const OUString& keyName,
982 : OUString& resolvedName)
983 : {
984 0 : if (keyName.isEmpty())
985 0 : return REG_INVALID_KEYNAME;
986 :
987 0 : resolvedName = getFullPath(keyName);
988 0 : return REG_NO_ERROR;
989 : }
990 :
991 : //*********************************************************************
992 : // countSubKeys()
993 : //
994 8830 : sal_uInt32 ORegKey::countSubKeys()
995 : {
996 8830 : REG_GUARD(m_pRegistry->m_mutex);
997 :
998 : OStoreDirectory::iterator iter;
999 17660 : OStoreDirectory rStoreDir = getStoreDir();
1000 8830 : storeError _err = rStoreDir.first(iter);
1001 8830 : sal_uInt32 count = 0;
1002 :
1003 41028 : while ( _err == store_E_None )
1004 : {
1005 23368 : if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR )
1006 : {
1007 14567 : count++;
1008 : }
1009 :
1010 23368 : _err = rStoreDir.next(iter);
1011 : }
1012 :
1013 17660 : return count;
1014 : }
1015 :
1016 49670 : OStoreDirectory ORegKey::getStoreDir()
1017 : {
1018 49670 : OStoreDirectory rStoreDir;
1019 99340 : OUString fullPath;
1020 99340 : OUString relativName;
1021 49670 : storeAccessMode accessMode = KEY_MODE_OPEN;
1022 :
1023 49670 : if ( m_name.equals(m_pRegistry->ROOT) )
1024 : {
1025 5301 : fullPath = OUString();
1026 5301 : relativName = OUString();
1027 : } else
1028 : {
1029 44369 : fullPath = m_name.copy(0, m_name.lastIndexOf('/') + 1);
1030 44369 : relativName = m_name.copy(m_name.lastIndexOf('/') + 1);
1031 : }
1032 :
1033 49670 : if (m_pRegistry->isReadOnly())
1034 : {
1035 49633 : accessMode = KEY_MODE_OPENREAD;
1036 : }
1037 :
1038 49670 : rStoreDir.create(getStoreFile(), fullPath, relativName, accessMode);
1039 :
1040 99340 : return rStoreDir;
1041 : }
1042 :
1043 73679 : OUString ORegKey::getFullPath(OUString const & path) const {
1044 : OSL_ASSERT(!m_name.isEmpty() && !path.isEmpty());
1045 73679 : OUStringBuffer b(m_name);
1046 73679 : if (!b.isEmpty() && b[b.getLength() - 1] == '/') {
1047 37724 : if (path[0] == '/') {
1048 27109 : b.append(path.getStr() + 1, path.getLength() - 1);
1049 : } else {
1050 10615 : b.append(path);
1051 : }
1052 : } else {
1053 35955 : if (path[0] != '/') {
1054 35946 : b.append(sal_Unicode('/'));
1055 : }
1056 35955 : b.append(path);
1057 : }
1058 73679 : return b.makeStringAndClear();
1059 : }
1060 :
1061 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
