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