2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
4 // Licensed under the Apache License, Version 2.0 (the License);
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
8 // http://www.apache.org/licenses/LICENSE-2.0
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
18 * @file FIo_RegistryCore.cpp
19 * @brief This is the implementation file for _RegistryCore class.
24 #include <unique_ptr.h>
28 #include <FBaseInteger.h>
29 #include <FBaseDouble.h>
30 #include <FBaseFloat.h>
31 #include <FBaseUuId.h>
32 #include <FBaseByteBuffer.h>
33 #include <FBaseColIEnumerator.h>
34 #include <FBaseUtilStringTokenizer.h>
35 #include <FBaseResult.h>
36 #include <FBaseSysLog.h>
37 #include <FBaseColAllElementsDeleter.h>
39 #include <FIoRegistry.h>
41 #include <FBase_StringConverter.h>
42 #include <FBase_LocalizedNumParser.h>
43 #include <FBase_NativeError.h>
44 #include <FApp_AppInfo.h>
45 #include "FIo_FileImpl.h"
46 #include "FIo_NormalRegistry.h"
47 #include "FIo_SecureRegistry.h"
48 #include "FIo_RegistryCore.h"
49 #include "FIo_SecureIoUtil.h"
52 using namespace Tizen::Base;
53 using namespace Tizen::Base::Utility;
54 using namespace Tizen::Base::Collection;
56 namespace Tizen { namespace Io
59 static const size_t _MAX_REG_OPENMODE_LENGTH = 2;
61 #define _REGISTRY_SECTION_MARKER_CHAR L'#'
62 #define _REGISTRY_SECTION_VALUE_ASSIGNMENT_MARKER_CHAR L'='
64 class _RegistrySection
68 ~_RegistrySection(void);
71 LinkedList __entryList;
72 friend class _RegistryCore;
75 _RegistrySection::~_RegistrySection(void)
77 __entryList.RemoveAll(true);
88 _RegistryCore::_RegistryCore(void)
101 _RegistryCore::~_RegistryCore(void)
107 _RegistryCore::VerifyRegistryOpenMode(const char* pOpenMode)
109 if (pOpenMode == null)
111 SysLog(NID_IO, "[E_INVALID_ARG] The specified openMode is null.");
115 if (strlen(pOpenMode) > _MAX_REG_OPENMODE_LENGTH)
117 SysLog(NID_IO, "[E_INVALID_ARG] The specified openMode (%s) is invalid.", pOpenMode);
121 switch (pOpenMode[0])
135 SysLog(NID_IO, "[E_INVALID_ARG] The specified openMode (%s) is invalid.", pOpenMode);
139 switch (pOpenMode[1])
144 if (pOpenMode[2] == '\0')
152 SysLog(NID_IO, "[E_INVALID_ARG] The specified openMode (%s) is invalid.", pOpenMode);
156 SysLog(NID_IO, "[E_INVALID_ARG] The specified openMode (%s) is invalid.", pOpenMode);
164 _RegistryCore::Parse(void)
166 result r = E_SUCCESS;
168 bool sectionFound = false;
171 unique_ptr<char[]> pEntryName(null);
172 unique_ptr<char[]> pEntryValue(null);
173 int firstTokenPos = 0;
176 if (_pBuffer == null)
178 SysLog(NID_IO, "The buffer is empty.");
182 String inputStr = String((char*)_pBuffer);
183 StringTokenizer lineTok(inputStr, L"\n");
185 r = lineTok.GetNextToken(line);
187 while (r == E_SUCCESS)
190 if (line.GetLength() == 0)
192 r = lineTok.GetNextToken(line);
196 // find registry section marker
197 line.GetCharAt(0, ch);
198 if (ch == _REGISTRY_SECTION_MARKER_CHAR)
202 // skip '#' and "\n' at the end
203 r = line.SubString(1, line.GetLength() - 1, sectionName);
204 SysTryCatch(NID_IO, !IsFailed(r), , r, "[%s] Propagated.", GetErrorMessage(r));
206 // if End of the document follows section name without newline character.
207 sectionName.GetCharAt(sectionName.GetLength() - 1, ch);
210 sectionName.SetLength(sectionName.GetLength() - 1); //Remove '\n'
213 // for compatibility check if line contains '\r' at the end
214 sectionName.GetCharAt(sectionName.GetLength() - 1, ch);
217 sectionName.SetLength(sectionName.GetLength() - 1); //Remove '\r'
220 //TODO: check if remaining data in sectionName is valid or not
221 //after removing '#', '\n', and '\r', sectionName should contain at least 1 valid character
223 sectionName.GetLength() > 0, r = E_PARSING_FAILED, E_PARSING_FAILED,
224 "[E_PARSING_FAILED] Section length cannot be <2.");
226 unique_ptr<char[]> pSectionName(_StringConverter::CopyToCharArrayN(sectionName));
227 SysTryCatch(NID_IO, pSectionName != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
228 "[E_OUT_OF_MEMORY] The memory is insufficient.");
230 if (!_RegistryCore::CheckSectionName(pSectionName.get()))
232 SysTryCatch(NID_IO, false, r = E_PARSING_FAILED, E_PARSING_FAILED,
233 "[E_PARSING_FAILED] Section name could not be parsed.");
236 r = _RegistryCore::AddSection(_sectionList, sectionName);
237 SysTryCatch(NID_IO, !IsFailed(r) || r == E_SECTION_ALREADY_EXIST, , r, "[%s] Propagating to caller...", GetErrorMessage(r));
239 else // not a section.. but may belongs to a section (entry)
241 // ignores blank lines
242 line.GetCharAt(0, ch);
243 if ((ch == L'\n') || (ch == L'\r'))
245 r = lineTok.GetNextToken(line);
250 // Need to check for tabs, spaces in the beginning of each line
252 // if no section found till now.. ignore
253 if (sectionFound == false)
255 r = lineTok.GetNextToken(line);
259 // if End of the document follows entry value without newline character.
260 line.GetCharAt(line.GetLength() - 1, ch);
263 line.SetLength(line.GetLength() - 1); //Remove '\n'
266 line.GetCharAt(line.GetLength() - 1, ch);
269 line.SetLength(line.GetLength() - 1); //Remove '\r'
272 String entryName("");
275 // we will have sectionitem=value (or) sectionitem= (or) sectionitem
276 // as our string. Break this into entry and value
277 StringTokenizer strTok(line, L"=");
279 // extract entry name
280 if (strTok.HasMoreTokens())
282 line.IndexOf(L'=', 0, firstTokenPos); // position of first occurance of '=' in a line
283 if (firstTokenPos == 0)
285 // entryName should not be empty. i.e., "=value" or just '=' is invalid case
286 SysTryCatch(NID_IO, false, r = E_PARSING_FAILED, E_PARSING_FAILED,
287 "[E_PARSING_FAILED] Entry name cannot be empty.");
291 strTok.GetNextToken(entryName);
294 else // missing '=' in entry line or entry line does not seem to contain "xxx=xxx" format
296 SysTryCatch(NID_IO, false, r = E_PARSING_FAILED, E_PARSING_FAILED, "[E_PARSING_FAILED] invalid entry Line found.");
299 // check if entry name contains invalid chars
300 pEntryName.reset(_StringConverter::CopyToCharArrayN(entryName));
301 SysTryCatch(NID_IO, pEntryName, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
302 "[E_OUT_OF_MEMORY] The memory is insufficient.");
304 if (!_RegistryCore::CheckEntryName(pEntryName.get()))
306 SysTryCatch(NID_IO, false, r = E_PARSING_FAILED, E_PARSING_FAILED,
307 "[E_PARSING_FAILED] Entry name could not be parsed.");
310 if (line.GetLength() > firstTokenPos + 1)
312 line.SubString(firstTokenPos + 1, entryVal); // extract entry value
315 // check if entry value contains invalid chars
316 pEntryValue.reset(_StringConverter::CopyToCharArrayN(entryVal));
317 SysTryCatch(NID_IO, pEntryValue, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
318 "[E_OUT_OF_MEMORY] The memory is insufficient.");
320 length = strlen(pEntryValue.get());
323 if (!_RegistryCore::CheckEntryValue(pEntryValue.get()))
325 SysTryCatch(NID_IO, false, r = E_PARSING_FAILED, E_PARSING_FAILED,
326 "[E_PARSING_FAILED] Entry value could not be parsed.");
330 // add the entry and value
331 r = _RegistryCore::AddValue(_sectionList, sectionName, entryName, entryVal);
332 SysTryCatch(NID_IO, !IsFailed(r), , r, "[%s] Propagated.", GetErrorMessage(r));
334 r = lineTok.GetNextToken(line);
337 if (r == E_OUT_OF_RANGE)
345 if (r == E_PARSING_FAILED && Tizen::App::_AppInfo::IsOspCompat() == false)
347 r = E_INVALID_FORMAT;
350 SysLog(NID_IO, "[%s] exception occurred.", GetErrorMessage(r));
355 _RegistryCore::Load(const String& regPath, const char* pOpenMode)
357 result r = E_SUCCESS;
358 delete[] _pBuffer; //clear existing buffer
362 // open registry file
363 unique_ptr<_FileImpl> pFileImpl(new (std::nothrow) _FileImpl());
364 SysTryReturnResult(NID_IO, pFileImpl != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
366 r = pFileImpl->Construct(regPath, pOpenMode, null);
367 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Constructing the file has failed.", GetErrorMessage(r));
369 // reset the section list to be sure that its empty
370 _sectionList.RemoveAll(true);
372 if (_truncate == false)
374 // load the registry file
375 r = pFileImpl->ReadN((char**)&_pBuffer, _length);
382 __pFileImpl = pFileImpl.release();
388 _RegistryCore::AddSection(const String& sectionName)
390 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
392 result r = E_SUCCESS;
393 bool sectionFound = false;
395 // Get section information
396 unique_ptr<IEnumerator> pEnum(_sectionList.GetEnumeratorN());
399 return GetLastResult();
402 while (pEnum->MoveNext() == E_SUCCESS)
404 _RegistrySection* pRegSection = dynamic_cast <_RegistrySection*>(pEnum->GetCurrent());
405 SysTryReturn(NID_IO, pRegSection != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
406 GetErrorMessage(GetLastResult()));
408 if (pRegSection->__sectionName == sectionName)
415 if (sectionFound == true)
417 SysLog(NID_IO, "[E_SECTION_ALREADY_EXIST] The registry file has the duplicated section name.");
418 return E_SECTION_ALREADY_EXIST;
421 // create a key with section name
422 unique_ptr<_RegistrySection> pRegSection(new (std::nothrow) _RegistrySection());
423 SysTryReturnResult(NID_IO, pRegSection != null, E_OUT_OF_MEMORY,
424 "The memory is insufficient.");
426 pRegSection->__sectionName = sectionName;
428 // add new section and section-entry map
429 r = _sectionList.Add(*(pRegSection.release()));
430 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
437 _RegistryCore::RemoveSection(const String& sectionName)
439 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
441 result r = E_SUCCESS;
442 _RegistrySection* pRegSection = null;
443 bool sectionFound = false;
445 if (_sectionList.GetCount() == 0)
447 return E_SECTION_NOT_FOUND;
450 // Get section information
451 unique_ptr<IEnumerator> pEnum(_sectionList.GetEnumeratorN());
454 return GetLastResult();
457 while (pEnum->MoveNext() == E_SUCCESS)
459 pRegSection = dynamic_cast< _RegistrySection* >(pEnum->GetCurrent());
460 SysTryReturn(NID_IO, pRegSection != null, GetLastResult(), GetLastResult(), "[%s] Propagating.",
461 GetErrorMessage(GetLastResult()));
463 if (pRegSection->__sectionName == sectionName)
470 if (sectionFound == false)
472 return E_SECTION_NOT_FOUND;
475 r = _sectionList.Remove(*pRegSection, true);
476 SysTryReturnResult(NID_IO, !IsFailed(r), E_IO, "system error");
483 _RegistryCore::GetSectionListN(IList** pRetList)
485 result r = E_SUCCESS;
486 unique_ptr<IEnumerator> pEnum(null);
487 _RegistrySection* pSection = null;
489 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
490 SysTryReturnResult(NID_IO, pRetList != null, E_INVALID_ARG, "pList cannot be null.");
492 // construct an array list to be returned
493 unique_ptr<ArrayList, AllElementsDeleter> pSectionList(new (std::nothrow) ArrayList());
494 SysTryReturnResult(NID_IO, pSectionList != null, E_OUT_OF_MEMORY,
495 "The memory is insufficient.");
497 r = pSectionList->Construct();
498 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
500 // if no sectons, return empty list
501 if (_sectionList.GetCount() == 0)
503 *pRetList = pSectionList.release();
507 // copy from class section list to the new list and return
508 pEnum.reset(_sectionList.GetEnumeratorN());
509 SysTryReturn(NID_IO, pEnum != null, GetLastResult(), GetLastResult(), "[%s] Section list is empty.", GetErrorMessage(GetLastResult()));
511 while (pEnum->MoveNext() == E_SUCCESS)
513 pSection = dynamic_cast <_RegistrySection*>(pEnum->GetCurrent());
514 SysTryReturn(NID_IO, pSection != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
515 GetErrorMessage(GetLastResult()));
517 unique_ptr<String> pSectionName(new (std::nothrow) String(pSection->__sectionName));
518 SysTryReturnResult(NID_IO, pSectionName != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
520 r = pSectionList->Add(*(pSectionName.release()));
521 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
524 *pRetList = pSectionList.release();
530 _RegistryCore::GetEntryList(const String& sectionName, Collection::HashMap& retMap)
532 result r = E_SUCCESS;
533 unique_ptr<IEnumerator> pEnum(null);
534 unique_ptr<String> pKeyEntryStr(null);
535 unique_ptr<String> pKeyValStr(null);
536 bool sectionFound = false;
537 _RegistrySection* pRegSection = null;
538 _RegistryEntry* pRegEntry = null;
540 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
542 if (_sectionList.GetCount() == 0)
544 return E_SECTION_NOT_FOUND;
547 // Get section information
548 pEnum.reset(_sectionList.GetEnumeratorN());
549 SysTryReturnResult(NID_IO, pEnum != null, E_SYSTEM, "Section list is empty.");
551 while (pEnum->MoveNext() == E_SUCCESS)
553 pRegSection = dynamic_cast <_RegistrySection*>(pEnum->GetCurrent());
554 SysTryReturn(NID_IO, pRegSection != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
555 GetErrorMessage(GetLastResult()));
557 if (pRegSection->__sectionName == sectionName)
564 if (sectionFound == false)
566 return E_SECTION_NOT_FOUND;
569 // copy from item list to the new list and return
570 pEnum.reset((pRegSection->__entryList).GetEnumeratorN());
571 SysTryReturn(NID_IO, pEnum != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
572 GetErrorMessage(GetLastResult()));
574 while (pEnum->MoveNext() == E_SUCCESS)
576 pRegEntry = dynamic_cast <_RegistryEntry*>(pEnum->GetCurrent());
577 SysTryReturn(NID_IO, pRegEntry != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
578 GetErrorMessage(GetLastResult()));
580 pKeyEntryStr.reset(new (std::nothrow) String((pRegEntry->entryName)));
581 SysTryCatch(NID_IO, pKeyEntryStr != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
582 "[E_OUT_OF_MEMORY] The memory is insufficient.");
583 pKeyValStr.reset(new (std::nothrow) String((pRegEntry->entryValue)));
584 SysTryCatch(NID_IO, pKeyValStr != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
585 "[E_OUT_OF_MEMORY] The memory is insufficient.");
587 r = retMap.Add(*(pKeyEntryStr.release()), *(pKeyValStr.release()));
588 SysTryCatch(NID_IO, !IsFailed(r), , r, "[%s] Propagated.", GetErrorMessage(r));
594 retMap.RemoveAll(true);
600 _RegistryCore::GetEntryListN(const String& sectionName, HashMap** pRetList)
602 result r = E_SUCCESS;
604 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
605 SysTryReturnResult(NID_IO, pRetList != null, E_INVALID_ARG, "pRetList cannot be null.");
607 // construct an array list to be returned
608 unique_ptr<HashMap, AllElementsDeleter> pEntryList(new (std::nothrow) HashMap());
609 SysTryReturnResult(NID_IO, pEntryList != null, E_OUT_OF_MEMORY,
610 "The memory is insufficient.");
611 r = pEntryList->Construct();
612 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
613 r = GetEntryList(sectionName, *(pEntryList.get()));
614 *pRetList = pEntryList.release();
620 _RegistryCore::GetAllEntriesN(const String& sectionName)
622 result r = E_SUCCESS;
623 HashMap* pMap = null;
625 r = GetEntryListN(sectionName, &pMap);
626 SysTryCatch(NID_IO, !IsFailed(r), , r, "[%s] Propagated.", GetErrorMessage(r));
628 SetLastResult(E_SUCCESS);
637 _RegistryCore::GetAllEntryNamesN(const String& sectionName)
639 result r = E_SUCCESS;
641 unique_ptr<ArrayList, AllElementsDeleter> pEntryList(new (std::nothrow) ArrayList());
642 SysTryReturn(NID_IO, pEntryList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
644 r = pEntryList->Construct();
645 SysTryReturn(NID_IO, !IsFailed(r), null, r, "[%s] Propagated.", GetErrorMessage(r));
647 unique_ptr<IMap, AllElementsDeleter> pMap(this->GetAllEntriesN(sectionName));
648 SysTryReturn(NID_IO, pMap != null, null, GetLastResult(), "[%s] Getting all entries was failed.",
649 GetErrorMessage(GetLastResult()));
651 unique_ptr<IMapEnumerator> pMapEnum(pMap->GetMapEnumeratorN());
652 SysTryReturn(NID_IO, pMapEnum, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
653 while (pMapEnum->MoveNext() == E_SUCCESS)
655 String* pKey = dynamic_cast< String* >(pMapEnum->GetKey());
656 SysTryReturn(NID_IO, pKey != null, null, E_IO, "[E_OUT_OF_MEMORY] The system error occurred.");
658 String* pEntryName = new (std::nothrow) String(*pKey);
659 SysTryReturn(NID_IO, pEntryName != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
661 r = pEntryList->Add(*pEntryName);
662 SysTryReturn(NID_IO, !IsFailed(r), null, r, "[%s] Propagated.", GetErrorMessage(r));
665 SetLastResult(E_SUCCESS);
666 return pEntryList.release();
670 _RegistryCore::GetValue(const String& sectionName, const String& entryName, String& valStr)
672 bool sectionFound = false;
673 bool entryFound = false;
674 _RegistrySection* pRegSection = null;
675 _RegistryEntry* pRegEntry = null;
677 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
679 if (_sectionList.GetCount() == 0)
681 return E_SECTION_NOT_FOUND;
684 // Get section information
685 unique_ptr<IEnumerator> pEnum(_sectionList.GetEnumeratorN());
688 return GetLastResult();
691 while (pEnum->MoveNext() == E_SUCCESS)
693 pRegSection = dynamic_cast <_RegistrySection*>(pEnum->GetCurrent());
694 SysTryReturn(NID_IO, pRegSection != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
695 GetErrorMessage(GetLastResult()));
697 if (pRegSection->__sectionName == sectionName)
704 if (sectionFound == false)
706 return E_SECTION_NOT_FOUND;
709 pEnum.reset(pRegSection->__entryList.GetEnumeratorN());
712 return GetLastResult();
715 while (pEnum->MoveNext() == E_SUCCESS)
717 pRegEntry = dynamic_cast <_RegistryEntry*>(pEnum->GetCurrent());
718 SysTryReturn(NID_IO, pRegEntry != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
719 GetErrorMessage(GetLastResult()));
721 if (pRegEntry->entryName == entryName)
723 valStr = pRegEntry->entryValue;
729 SysTryLog(NID_IO, entryFound, "Entry not found");
731 return((entryFound == true) ? E_SUCCESS : E_KEY_NOT_FOUND);
735 _RegistryCore::AddValue(const String& sectionName, const String& entryName, const String& valStr)
737 result r = E_SUCCESS;
738 bool sectionFound = false;
739 bool entryFound = false;
740 _RegistrySection* pRegSection = null;
743 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
745 // Get section information
746 unique_ptr<IEnumerator> pEnum(_sectionList.GetEnumeratorN());
749 return GetLastResult();
752 while (pEnum->MoveNext() == E_SUCCESS)
754 pRegSection = dynamic_cast <_RegistrySection*>(pEnum->GetCurrent());
755 SysTryReturn(NID_IO, pRegSection != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
756 GetErrorMessage(GetLastResult()));
758 if (pRegSection->__sectionName == sectionName)
765 if (sectionFound == false)
767 return E_SECTION_NOT_FOUND;
770 pEnum.reset(pRegSection->__entryList.GetEnumeratorN());
773 return GetLastResult();
776 while (pEnum->MoveNext() == E_SUCCESS)
778 _RegistryEntry* pRegEntry = dynamic_cast <_RegistryEntry*>(pEnum->GetCurrent());
779 SysTryReturn(NID_IO, pRegEntry != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
780 GetErrorMessage(GetLastResult()));
782 if (pRegEntry->entryName == entryName)
789 if (entryFound == true)
791 return E_KEY_ALREADY_EXIST;
794 unique_ptr<_RegistryEntry> pRegEntry(new (std::nothrow) _RegistryEntry());
795 SysTryReturnResult(NID_IO, pRegEntry != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
797 unique_ptr<char[]> pEntryName(_StringConverter::CopyToCharArrayN(entryName));
798 SysTryReturnResult(NID_IO, pEntryName != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
800 length = strlen(pEntryName.get());
801 if (!_RegistryCore::CheckEntryName(pEntryName.get()))
803 SysTryReturnResult(NID_IO, false, E_PARSING_FAILED, "Entry name could not be parsed.");
806 unique_ptr<char[]> pEntryValue(_StringConverter::CopyToCharArrayN(valStr));
807 SysTryReturnResult(NID_IO, pEntryValue != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
809 length = strlen(pEntryValue.get());
810 if (length > 0 && !_RegistryCore::CheckEntryValue(pEntryValue.get()))
812 SysTryReturnResult(NID_IO, false, E_PARSING_FAILED, "Entry value could not be parsed.");
815 pRegEntry->entryName = entryName;
816 pRegEntry->entryValue = valStr;
818 r = pRegSection->__entryList.Add(*(pRegEntry.release()));
819 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
826 _RegistryCore::SetValue(const String& sectionName, const String& entryName, const String& valStr)
828 result r = E_SUCCESS;
829 bool sectionFound = false;
830 bool entryFound = false;
831 _RegistryEntry* pRegEntry = null;
832 _RegistrySection* pRegSection = null;
836 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
838 if (_sectionList.GetCount() == 0)
840 return E_SECTION_NOT_FOUND;
843 // Get section information
844 unique_ptr<IEnumerator> pEnum(_sectionList.GetEnumeratorN());
847 return GetLastResult();
850 while (pEnum->MoveNext() == E_SUCCESS)
852 pRegSection = dynamic_cast< _RegistrySection* >(pEnum->GetCurrent());
853 SysTryReturn(NID_IO, pRegSection != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
854 GetErrorMessage(GetLastResult()));
856 if (pRegSection->__sectionName == sectionName)
863 if (sectionFound == false)
865 return E_SECTION_NOT_FOUND;
868 pEnum.reset(pRegSection->__entryList.GetEnumeratorN());
871 return GetLastResult();
874 while (pEnum->MoveNext() == E_SUCCESS)
876 pRegEntry = dynamic_cast< _RegistryEntry* >(pEnum->GetCurrent());
877 SysTryReturn(NID_IO, pRegEntry != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
878 GetErrorMessage(GetLastResult()));
880 if (pRegEntry->entryName == entryName)
888 if (entryFound == false)
890 return E_KEY_NOT_FOUND;
893 if (valStr.GetLength() > 0)
895 unique_ptr<char[]> pEntryValue(_StringConverter::CopyToCharArrayN(valStr));
896 SysTryReturnResult(NID_IO, pEntryValue != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
898 length = strlen(pEntryValue.get());
899 if (!_RegistryCore::CheckEntryValue(pEntryValue.get()))
901 return E_PARSING_FAILED;
905 pRegEntry->entryValue = valStr;
906 r = pRegSection->__entryList.SetAt(*pRegEntry, entryIndex);
907 SysTryReturnResult(NID_IO, !IsFailed(r), E_IO, "system error");
914 _RegistryCore::RemoveValue(const String& sectionName, const String& entryName)
916 result r = E_SUCCESS;
917 bool sectionFound = false;
918 bool entryFound = false;
919 _RegistryEntry* pRegEntry = null;
920 _RegistrySection* pRegSection = null;
922 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
924 if (_sectionList.GetCount() <= 0)
926 return E_SECTION_NOT_FOUND;
929 // Get section information
930 unique_ptr<IEnumerator> pEnum(_sectionList.GetEnumeratorN());
933 return E_SECTION_NOT_FOUND;
936 while (pEnum->MoveNext() == E_SUCCESS)
938 pRegSection = dynamic_cast <_RegistrySection*>(pEnum->GetCurrent());
939 SysTryReturn(NID_IO, pRegSection != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
940 GetErrorMessage(GetLastResult()));
942 if (pRegSection->__sectionName == sectionName)
949 if (sectionFound == false)
951 return E_SECTION_NOT_FOUND;
954 pEnum.reset(pRegSection->__entryList.GetEnumeratorN());
957 return E_SECTION_NOT_FOUND;
960 while (pEnum->MoveNext() == E_SUCCESS)
962 pRegEntry = dynamic_cast <_RegistryEntry*>(pEnum->GetCurrent());
963 SysTryReturn(NID_IO, pRegEntry != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
964 GetErrorMessage(GetLastResult()));
966 if (pRegEntry->entryName == entryName)
973 if (entryFound == false)
975 return E_KEY_NOT_FOUND;
978 r = pRegSection->__entryList.Remove(*pRegEntry, true);
979 SysTryReturnResult(NID_IO, !IsFailed(r), E_IO, "system error");
986 _RegistryCore::Flush(void)
992 _RegistryCore::Write(void)
994 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
996 if (_pBuffer == null)
998 SysLog(NID_IO, "The buffer is empty.");
1002 result r = __pFileImpl->Seek(FILESEEKPOSITION_BEGIN, 0);
1003 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
1005 r = __pFileImpl->Truncate(0);
1006 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
1008 r = __pFileImpl->Write(_pBuffer, _length);
1009 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
1011 r = __pFileImpl->Flush();
1012 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
1018 _RegistryCore::PrepareToWrite(void)
1020 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
1022 result r = E_SUCCESS;
1023 _RegistryEntry* pRegEntry = null;
1024 _RegistrySection* pRegSection = null;
1027 delete[] _pBuffer; //clear existing buffer
1031 if (_write == false)
1033 SysLog(NID_IO, "[E_ILLEGAL_ACCESS] Registry cannot be flushed as it was opened in read only mode.");
1034 return E_ILLEGAL_ACCESS;
1037 // if no sections, do nothing
1038 if (_sectionList.GetCount() == 0)
1040 unique_ptr<char[]> pFilePath(_StringConverter::CopyToCharArrayN(_regPath));
1041 int res = truncate(pFilePath.get(), 0);
1042 SysTryReturnResult(NID_IO, res == 0, __ConvertNativeErrorToResult(errno),
1043 "Failed to truncate. errno: %d (%s)", errno, strerror(errno));
1047 // write the registry map to a file
1048 // Get section information
1049 unique_ptr<IEnumerator> pSectionEnum(_sectionList.GetEnumeratorN());
1050 SysTryReturn(NID_IO, pSectionEnum != null, GetLastResult(), GetLastResult(), "[%s] Section list is empty.",
1051 GetErrorMessage(GetLastResult()));
1053 while (pSectionEnum->MoveNext() == E_SUCCESS)
1056 pRegSection = dynamic_cast <_RegistrySection*>(pSectionEnum->GetCurrent());
1057 SysTryReturn(NID_IO, pRegSection != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
1058 GetErrorMessage(GetLastResult()));
1060 // write section name to file
1061 r = inputBuffer.Append(String(L"#" + pRegSection->__sectionName + String(L'\n')));
1062 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
1064 // read the entries for this section
1065 unique_ptr<IEnumerator> pEntryEnum(pRegSection->__entryList.GetEnumeratorN());
1066 SysTryReturn(NID_IO, pSectionEnum != null, GetLastResult(), GetLastResult(), "[%s] Entry list is empty.",
1067 GetErrorMessage(GetLastResult()));
1069 while (pEntryEnum->MoveNext() == E_SUCCESS)
1071 pRegEntry = dynamic_cast <_RegistryEntry*>(pEntryEnum->GetCurrent());
1072 SysTryReturn(NID_IO, pRegEntry != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
1073 GetErrorMessage(GetLastResult()));
1075 // write entry name to file
1076 r = inputBuffer.Append(pRegEntry->entryName + String(L"=" + pRegEntry->entryValue + String(L'\n')));
1077 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
1082 _pBuffer = (byte*)_StringConverter::CopyToCharArrayN(inputBuffer);
1083 SysTryReturn(NID_IO, _pBuffer != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
1084 GetErrorMessage(GetLastResult()));
1086 _length = strlen((char*)_pBuffer);
1092 _RegistryCore::GetSectionIndex(const String& sectionName)
1094 bool sectionFound = false;
1095 _RegistrySection* pRegSection = null;
1098 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
1099 SysTryReturn(NID_IO, sectionName.GetLength() > 0, -1, E_INVALID_ARG,
1100 "[E_INVALID_ARG] sectionName.GetLength() <= 0");
1102 SysTryReturn(NID_IO, _sectionList.GetCount() > 0, -1, E_SECTION_NOT_FOUND, "[E_SECTION_NOT_FOUND] Section not found.");
1104 // Get section information
1105 unique_ptr<IEnumerator> pEnum(_sectionList.GetEnumeratorN());
1106 SysTryReturn(NID_IO, pEnum != null, GetLastResult(), GetLastResult(), "[%s] Section list is empty.",
1107 GetErrorMessage(GetLastResult()));
1109 while (pEnum->MoveNext() == E_SUCCESS)
1111 pRegSection = dynamic_cast <_RegistrySection*>(pEnum->GetCurrent());
1112 SysTryReturn(NID_IO, pRegSection != null, -1, GetLastResult(), "[%s] Propagated.",
1113 GetErrorMessage(GetLastResult()));
1115 if (pRegSection->__sectionName == sectionName)
1117 sectionFound = true;
1123 if (sectionFound == false)
1125 return E_SECTION_NOT_FOUND;
1128 SetLastResult(E_SUCCESS);
1133 _RegistryCore::Removekey(const String& sectionName, const String& keyName)
1135 result r = E_SUCCESS;
1136 int sectionIndex = -1;
1137 int entryIndex = -1;
1139 sectionIndex = GetSectionIndex(sectionName);
1140 r = GetLastResult();
1141 SysTryReturnVoidResult(NID_IO, !IsFailed(r), r, "[%s] Propagated.", GetErrorMessage(r));
1143 entryIndex = GetEntryIndex(sectionIndex, keyName);
1144 r = GetLastResult();
1145 SysTryReturnVoidResult(NID_IO, !IsFailed(r), r, "[%s] Propagated.", GetErrorMessage(r));
1147 RemoveEntry(sectionIndex, entryIndex);
1148 r = GetLastResult();
1149 SysTryReturnVoidResult(NID_IO, !IsFailed(r), r, "[%s] Propagated.", GetErrorMessage(r));
1151 SetLastResult(E_SUCCESS);
1156 _RegistryCore::GetAllSectionCount(void)
1158 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
1160 SetLastResult(E_SUCCESS);
1161 return _sectionList.GetCount();
1165 _RegistryCore::GetAllEntryCount(int sectionIndex)
1167 _RegistrySection* pRegSection = null;
1170 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
1171 SysTryReturn(NID_IO, sectionIndex >= 0, 0, E_INVALID_ARG, "[E_INVALID_ARG] sectionIndex < 0.");
1172 listSize = _sectionList.GetCount();
1173 SysTryReturn(NID_IO, listSize > 0, 0, E_SECTION_NOT_FOUND, "[E_INVALID_ARG] section listSize <= 0.");
1174 SysTryReturn(NID_IO, sectionIndex >= listSize, 0, E_SECTION_NOT_FOUND,
1175 "[E_INVALID_ARG] sectionIndex > listSize.");
1177 pRegSection = (_RegistrySection*) GetSectionByIndex(sectionIndex);
1178 SysTryReturn(NID_IO, pRegSection != null, 0, E_SECTION_NOT_FOUND,
1179 "[E_SECTION_NOT_FOUND] section was not found.");
1181 SetLastResult(E_SUCCESS);
1182 return pRegSection->__entryList.GetCount();
1186 _RegistryCore::RemoveEntry(int sectionIndex, int entryIndex)
1188 result r = E_SUCCESS;
1190 int entryListSize = 0;
1191 _RegistrySection* pRegSection = null;
1193 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
1194 SysTryReturnVoidResult(NID_IO, sectionIndex >= 0, E_INVALID_ARG, "[E_INVALID_ARG] sectionIndex < 0.");
1195 SysTryReturnVoidResult(NID_IO, entryIndex >= 0, E_INVALID_ARG, "[E_INVALID_ARG] entryIndex < 0.");
1197 listSize = _sectionList.GetCount();
1198 SysTryReturnVoidResult(NID_IO, listSize > 0, E_SECTION_NOT_FOUND,
1199 "[E_SECTION_NOT_FOUND] section listSize <= 0.");
1200 SysTryReturnVoidResult(NID_IO, sectionIndex < listSize, E_SECTION_NOT_FOUND,
1201 "[E_SECTION_NOT_FOUND] sectionIndex >= listSize.");
1203 pRegSection = (_RegistrySection*) GetSectionByIndex(sectionIndex);
1204 SysTryReturnVoidResult(NID_IO, pRegSection != null, E_SECTION_NOT_FOUND,
1205 "[E_SECTION_NOT_FOUND] Section at index (%d) not found.", sectionIndex);
1207 r = GetLastResult();
1208 SysTryReturnVoidResult(NID_IO, !IsFailed(r), r,"[%s] Propagated.", GetErrorMessage(r));
1210 entryListSize = pRegSection->__entryList.GetCount();
1211 SysTryReturnVoidResult(NID_IO, (entryListSize > 0 || entryIndex < entryListSize), E_KEY_NOT_FOUND,
1212 "[E_KEY_NOT_FOUND] entryListSize is 0 or entryIndex >= entryListSize.");
1214 r = pRegSection->__entryList.RemoveAt(entryIndex, true);
1215 SysTryReturnVoidResult(NID_IO, !IsFailed(r), r, "[%s] Propagated.", GetErrorMessage(r));
1217 SetLastResult(E_SUCCESS);
1221 _RegistryCore::ModifyEntryValue(int sectionIndex, int entryIndex, _RegValueType type, const void* pValue, int size)
1223 SetLastResult(E_UNSUPPORTED_OPERATION);
1227 _RegistryCore::GetEntryIndex(int sectionIndex, const String& entryName)
1229 _RegistrySection* pRegSection = null;
1230 _RegistryEntry* pRegEntry = null;
1232 bool entryFound = false;
1233 int entryIndex = -1;
1235 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
1236 SysTryReturn(NID_IO, sectionIndex >= 0, -1, E_INVALID_ARG, "[E_INVALID_ARG]sectionIndex < 0.");
1237 SysTryReturn(NID_IO, entryName.GetLength() > 0, -1, E_INVALID_ARG, "[E_INVALID_ARG]entryName length < 0.");
1239 listSize = _sectionList.GetCount();
1240 SysTryReturn(NID_IO, listSize > 0, -1, E_SECTION_NOT_FOUND,
1241 "[E_SECTION_NOT_FOUND]Registry section list is empty.");
1242 SysTryReturn(NID_IO, sectionIndex < listSize, -1, E_SECTION_NOT_FOUND,
1243 "[E_SECTION_NOT_FOUND]sectionIndex >= listSize.");
1245 pRegSection = (_RegistrySection*) GetSectionByIndex(sectionIndex);
1246 SysTryReturn(NID_IO, pRegSection != null, -1, E_SECTION_NOT_FOUND,
1247 "[E_SECTION_NOT_FOUND] Section at index (%d) not found.", sectionIndex);
1249 // read the entries for this section
1250 unique_ptr<IEnumerator> pEntryEnum(pRegSection->__entryList.GetEnumeratorN());
1251 SysTryReturn(NID_IO, pEntryEnum != null, -1, GetLastResult(), "[%s] Entry list is empty.",
1252 GetErrorMessage(GetLastResult()));
1255 while (pEntryEnum->MoveNext() == E_SUCCESS)
1257 pRegEntry = dynamic_cast <_RegistryEntry*>(pEntryEnum->GetCurrent());
1258 SysTryReturn(NID_IO, pRegEntry != null, -1, GetLastResult(), "[%s] Propagated.",
1259 GetErrorMessage(GetLastResult()));
1261 if (entryName == pRegEntry->entryName)
1269 SysTryReturn(NID_IO, entryFound != false, -1, E_KEY_NOT_FOUND, "[E_KEY_NOT_FOUND] entry was not found.");
1271 SetLastResult(E_SUCCESS);
1276 _RegistryCore::GetEntryName(int sectionIndex, int entryIndex)
1278 _RegistrySection* pRegSection = null;
1279 _RegistryEntry* pRegEntry = null;
1284 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
1285 SysTryReturn(NID_IO, sectionIndex >= 0, empty, E_INVALID_ARG, "[E_INVALID_ARG]sectionIndex < 0.");
1286 SysTryReturn(NID_IO, entryIndex >= 0, empty, E_INVALID_ARG, "[E_INVALID_ARG]entryIndex < 0.");
1288 listSize = _sectionList.GetCount();
1289 SysTryReturn(NID_IO, listSize > 0, empty, E_SECTION_NOT_FOUND,
1290 "[E_SECTION_NOT_FOUND]Registry section list is empty.");
1291 SysTryReturn(NID_IO, sectionIndex < listSize, empty, E_SECTION_NOT_FOUND,
1292 "[E_SECTION_NOT_FOUND]sectionIndex >= listSize.");
1294 pRegSection = (_RegistrySection*) GetSectionByIndex(sectionIndex);
1295 SysTryReturn(NID_IO, pRegSection != null, empty, E_SECTION_NOT_FOUND,
1296 "[E_SECTION_NOT_FOUND] Section at index (%d) not found.", sectionIndex);
1298 // read the entries for this section
1299 unique_ptr<IEnumerator> pEntryEnum(pRegSection->__entryList.GetEnumeratorN());
1300 SysTryReturn(NID_IO, pEntryEnum != null, empty, GetLastResult(), "[%s] Entry list is empty.",
1301 GetErrorMessage(GetLastResult()));
1303 tmpIndex = entryIndex;
1304 while (pEntryEnum->MoveNext() == E_SUCCESS)
1308 pRegEntry = dynamic_cast <_RegistryEntry*>(pEntryEnum->GetCurrent());
1309 SysTryReturn(NID_IO, pRegEntry != null, empty, GetLastResult(), "[%s] Propagated.",
1310 GetErrorMessage(GetLastResult()));
1317 SysTryReturn(NID_IO, pRegEntry != null, empty, E_KEY_NOT_FOUND, "[E_KEY_NOT_FOUND] entry was not found.");
1319 SetLastResult(E_SUCCESS);
1320 return pRegEntry->entryName;
1324 _RegistryCore::GetEntryValue(int sectionIndex, int entryIndex, _RegValueType type, void* pValue, int* pSize)
1326 _RegistrySection* pRegSection = null;
1327 _RegistryEntry* pRegEntry = null;
1328 result r = E_SUCCESS;
1330 int tmpEntryIndex = -1;
1331 int entryListSize = 0;
1332 String strValueEncoded;
1334 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
1335 SysTryReturnVoidResult(NID_IO, sectionIndex >= 0, E_INVALID_ARG, "[E_INVALID_ARG]sectionIndex < 0.");
1336 SysTryReturnVoidResult(NID_IO, type >= 0 && type <= REG_VALUE_TYPE_MAX, E_INVALID_ARG,
1337 "[E_INVALID_ARG] invalid registry type.");
1338 SysTryReturnVoidResult(NID_IO, pValue != null, E_INVALID_ARG, "[E_INVALID_ARG]pValue is null.");
1339 SysTryReturnVoidResult(NID_IO, pSize != null, E_INVALID_ARG, "[E_INVALID_ARG]pSize is null.");
1340 SysTryReturnVoidResult(NID_IO, *pSize > 0, E_INVALID_ARG, "[E_INVALID_ARG] *pSize < 0.");
1342 listSize = _sectionList.GetCount();
1343 SysTryReturnVoidResult(NID_IO, listSize > 0, E_SECTION_NOT_FOUND,
1344 "[E_SECTION_NOT_FOUND]Registry section list is empty.");
1345 SysTryReturnVoidResult(NID_IO, sectionIndex < listSize, E_SECTION_NOT_FOUND,
1346 "[E_SECTION_NOT_FOUND]sectionIndex >= listSize.");
1348 pRegSection = (_RegistrySection*) GetSectionByIndex(sectionIndex);
1349 SysTryReturnVoidResult(NID_IO, pRegSection != null, E_SECTION_NOT_FOUND,
1350 "[E_SECTION_NOT_FOUND] section at index (%d) is not available.", sectionIndex);
1352 entryListSize = pRegSection->__entryList.GetCount();
1353 SysTryReturnVoidResult(NID_IO, entryListSize > 0, E_KEY_NOT_FOUND, "[E_KEY_NOT_FOUND]Entry list is empty.");
1354 SysTryReturnVoidResult(NID_IO, entryIndex < entryListSize, E_KEY_NOT_FOUND, "[E_KEY_NOT_FOUND]Entry not found.");
1356 // read the entries for this section
1357 unique_ptr< IEnumerator > pEntryEnum(pRegSection->__entryList.GetEnumeratorN());
1358 SysTryReturnVoidResult(NID_IO, pEntryEnum != null, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND]Entry list is empty.");
1360 tmpEntryIndex = entryIndex;
1361 while (pEntryEnum->MoveNext() == E_SUCCESS)
1363 if (entryIndex == 0)
1365 pRegEntry = dynamic_cast <_RegistryEntry*>(pEntryEnum->GetCurrent());
1366 SysTryReturnVoidResult(NID_IO, pRegEntry != null, GetLastResult(), "[%s] Propagated.",
1367 GetErrorMessage(GetLastResult()));
1375 SysTryReturnVoidResult(NID_IO, pRegEntry != null, E_KEY_NOT_FOUND,
1376 "[E_KEY_NOT_FOUND] Entry was not found.");
1378 strValueEncoded = pRegEntry->entryValue;
1380 DecodeData(strValueEncoded, type, pValue, pSize);
1381 r = GetLastResult();
1382 SysTryReturnVoidResult(NID_IO, !IsFailed(r), E_PARSING_FAILED, "[%s] Propagated.", GetErrorMessage(r));
1384 SetLastResult(E_SUCCESS);
1389 _RegistryCore::GetSectionName(int sectionIndex)
1391 _RegistrySection* pRegSection = null;
1392 result r = E_SUCCESS;
1394 String sectionName("");
1396 SysAssertf(_constructed == true, "Not yet constructed. Construct() should be called before use.\n");
1397 SysTryReturn(NID_IO, sectionIndex >= 0, sectionName, E_INVALID_ARG, "[E_INVALID_ARG]sectionIndex < 0.");
1399 listSize = _sectionList.GetCount();
1400 SysTryReturn(NID_IO, listSize > 0, sectionName, E_SECTION_NOT_FOUND,
1401 "[E_SECTION_NOT_FOUND]Registry section list is empty.");
1402 SysTryReturn(NID_IO, sectionIndex < listSize, sectionName, E_SECTION_NOT_FOUND,
1403 "[E_SECTION_NOT_FOUND]sectionIndex >= listSize.");
1405 pRegSection = (_RegistrySection*) GetSectionByIndex(sectionIndex);
1406 SysTryReturn(NID_IO, pRegSection != null, sectionName, E_SECTION_NOT_FOUND,
1407 "[E_SECTION_NOT_FOUND] sectionIndex is not available.");
1409 r = GetLastResult();
1410 SysTryReturn(NID_IO, !IsFailed(r), sectionName, r, "[%s] Propagated.", GetErrorMessage(r));
1412 SetLastResult(E_SUCCESS);
1413 return pRegSection->__sectionName;
1417 _RegistryCore::GetSectionByIndex(int sectionIndex)
1419 _RegistrySection* pRegSection = null;
1420 int index = sectionIndex;
1422 // Get section information
1423 unique_ptr<IEnumerator> pEnum(_sectionList.GetEnumeratorN());
1424 SysTryReturn(NID_IO, pEnum != null, null, GetLastResult(),
1425 "[%s] section list is empty.", GetErrorMessage(GetLastResult()));
1427 while (pEnum->MoveNext() == E_SUCCESS)
1431 pRegSection = dynamic_cast< _RegistrySection* >(pEnum->GetCurrent());
1432 SysTryReturn(NID_IO, pRegSection != null, null, GetLastResult(), "[%s] Propagated.",
1433 GetErrorMessage(GetLastResult()));
1440 SysTryReturn(NID_IO, pRegSection != null, null, E_SECTION_NOT_FOUND,
1441 "[E_SECTION_NOT_FOUND] Section was not found.");
1443 SetLastResult(E_SUCCESS);
1449 _RegistryCore::DecodeData(const String& strValueEncoded, _RegValueType type, void* pValue, int* pSize)
1451 SysAssert(strValueEncoded.GetLength() > 0);
1454 SysAssert(pSize && *pSize > 0);
1456 SysTryReturnVoidResult(NID_IO, pValue != null, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument.");
1457 SysTryReturnVoidResult(NID_IO, pSize != null, E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument.");
1461 case REG_VALUE_TYPE_INT: // (-2147483647 - 1) ~ 2147483647
1464 result r = E_SUCCESS;
1466 if (*pSize != sizeof(int))
1468 SetLastResult(E_INVALID_ARG);
1472 r = Integer::Parse(strValueEncoded, retIntVal);
1473 SysTryReturnVoidResult(NID_IO, !IsFailed(r), E_PARSING_FAILED, "[%s] Propagated.", GetErrorMessage(r));
1475 *(int*) pValue = retIntVal;
1479 case REG_VALUE_TYPE_REAL: // Holds signed IEEE 64-bit (8-byte) double-precision floating-point numbers
1480 // ranging in value from -1.79769313486231570E+308 through -4.94065645841246544E-324
1481 // for negative values and from 4.94065645841246544E-324 through 1.79769313486231570E+308
1482 // for positive values.
1484 double retDoubleVal = 0;
1486 if (*pSize != sizeof(double))
1488 SetLastResult(E_INVALID_ARG);
1492 retDoubleVal = _LocalizedNumParser::ToDouble(strValueEncoded, "C");
1493 result r = GetLastResult();
1494 SysTryReturnVoidResult(NID_IO, r == E_SUCCESS, E_PARSING_FAILED, "[%s] Propagated.", GetErrorMessage(r));
1496 *(double*) pValue = retDoubleVal;
1501 case REG_VALUE_TYPE_STRING:
1503 // if(*pSize != sizeof(String))
1505 // SetLastResult(E_INVALID_ARG);
1508 *(String*) pValue = strValueEncoded;
1512 case REG_VALUE_TYPE_BINARY:
1514 SetLastResult(E_PARSING_FAILED);
1518 case REG_VALUE_TYPE_UUID:
1521 result r = E_SUCCESS;
1523 r = UuId::Parse(strValueEncoded, retUuIdVal);
1524 SysTryReturnVoidResult(NID_IO, !IsFailed(r), E_PARSING_FAILED, "[%s] Propagated.", GetErrorMessage(r));
1526 *(UuId*) pValue = retUuIdVal;
1530 case REG_VALUE_TYPE_UUIDSET:
1532 SetLastResult(E_PARSING_FAILED);
1537 SysAssert(0); // should not happen!
1541 SetLastResult(E_SUCCESS);
1546 _RegistryCore::AddSection(LinkedList& sectionList, const String& sectionName)
1548 result r = E_SUCCESS;
1549 bool sectionFound = false;
1551 // Get section information
1552 unique_ptr<IEnumerator> pEnum(sectionList.GetEnumeratorN());
1555 return GetLastResult();
1558 while (pEnum->MoveNext() == E_SUCCESS)
1560 _RegistrySection* pRegSection = dynamic_cast <_RegistrySection*>(pEnum->GetCurrent());
1561 SysTryReturn(NID_IO, pRegSection != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
1562 GetErrorMessage(GetLastResult()));
1564 if (pRegSection->__sectionName == sectionName)
1566 sectionFound = true;
1571 if (sectionFound == true)
1573 SysLog(NID_IO, "[E_SECTION_ALREADY_EXIST] The registry file has the duplicated section name.");
1574 return E_SECTION_ALREADY_EXIST;
1577 // create a key with section name
1578 unique_ptr<_RegistrySection> pRegSection(new (std::nothrow) _RegistrySection());
1580 SysTryReturnResult(NID_IO, pRegSection != null, E_OUT_OF_MEMORY,
1581 "The memory is insufficient.");
1583 pRegSection->__sectionName = sectionName;
1585 // add new section and section-entry map
1586 r = sectionList.Add(*(pRegSection.release()));
1587 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
1593 _RegistryCore::AddValue(LinkedList& sectionList, const String& sectionName, const String& entryName, const String& valStr)
1595 result r = E_SUCCESS;
1596 bool sectionFound = false;
1597 bool entryFound = false;
1598 _RegistrySection* pRegSection = null;
1600 // Get section information
1601 unique_ptr<IEnumerator> pEnum(sectionList.GetEnumeratorN());
1604 return GetLastResult();
1607 while (pEnum->MoveNext() == E_SUCCESS)
1609 pRegSection = dynamic_cast <_RegistrySection*>(pEnum->GetCurrent());
1610 SysTryReturn(NID_IO, pRegSection != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
1611 GetErrorMessage(GetLastResult()));
1613 if (pRegSection->__sectionName == sectionName)
1615 sectionFound = true;
1620 if (sectionFound == false)
1622 return E_SECTION_NOT_FOUND;
1625 pEnum.reset(pRegSection->__entryList.GetEnumeratorN());
1628 return GetLastResult();
1631 while (pEnum->MoveNext() == E_SUCCESS)
1633 _RegistryEntry* pRegEntry = dynamic_cast <_RegistryEntry*>(pEnum->GetCurrent());
1634 SysTryReturn(NID_IO, pRegEntry != null, GetLastResult(), GetLastResult(), "[%s] Propagated.",
1635 GetErrorMessage(GetLastResult()));
1637 if (pRegEntry->entryName == entryName)
1644 if (entryFound == true)
1646 return E_KEY_ALREADY_EXIST;
1649 unique_ptr<_RegistryEntry> pRegEntry(new (std::nothrow) _RegistryEntry());
1650 SysTryReturnResult(NID_IO, pRegEntry != null, E_OUT_OF_MEMORY,
1651 "The memory is insufficient.");
1653 pRegEntry->entryName = entryName;
1654 pRegEntry->entryValue = valStr;
1656 r = pRegSection->__entryList.Add(*(pRegEntry.release()));
1657 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
1663 _RegistryCore::CheckSectionName(char* pSectionName)
1670 if (pSectionName == null)
1675 pFrom = pSectionName;
1676 length = strlen(pSectionName);
1677 pTo = pSectionName + (length - 1);
1679 if (!pFrom || !pTo || pFrom > pTo)
1684 for (pTemp = pFrom; pTemp <= pTo; pTemp++)
1686 if (*pTemp == '\0' || *pTemp == '\n' || *pTemp == '#' || *pTemp == '=')
1696 _RegistryCore::CheckEntryName(char* pEntryName)
1703 if (pEntryName == null)
1709 length = strlen(pEntryName);
1710 pTo = pEntryName + (length - 1);
1712 if (!pFrom || !pTo || pFrom > pTo)
1717 for (pTemp = pFrom; pTemp <= pTo; pTemp++)
1719 if (*pTemp == '\0' || *pTemp == '\n' || *pTemp == '#' || *pTemp == '=')
1729 _RegistryCore::CheckEntryValue(char* pEntryVal)
1736 if (pEntryVal == null)
1742 length = strlen(pEntryVal);
1743 pTo = pEntryVal + (length - 1);
1745 if (!pFrom || !pTo || pFrom > pTo)
1750 for (pTemp = pFrom; pTemp <= pTo; pTemp++)
1752 if (*pTemp == '\0' || *pTemp == '\n')
1762 _RegistryCore::ConvertToSecureRegistry(const String& plainRegPath, const String& secureRegPath, const ByteBuffer* pKey)
1764 result r = E_SUCCESS;
1766 if (File::IsFileExist(secureRegPath))
1768 r = GetLastResult();
1771 r = E_FILE_ALREADY_EXIST;
1772 SysLog(NID_IO, "[E_FILE_ALREADY_EXIST] The secure registry already exists.");
1776 SysLog(NID_IO, "[%s]Propagated.", GetErrorMessage(r));
1781 unique_ptr<_NormalRegistry> pNormalReg(new (std::nothrow) _NormalRegistry());
1782 SysTryReturnResult(NID_IO, pNormalReg != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
1784 r = pNormalReg->Load(plainRegPath, "r");
1785 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
1787 unique_ptr<_SecureRegistry> pSecureReg(new (std::nothrow) _SecureRegistry());
1788 SysTryReturnResult(NID_IO, pSecureReg != null, E_OUT_OF_MEMORY, "The memory is insufficient.");
1790 r = pSecureReg->Construct(secureRegPath, "w+", pKey);
1791 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
1793 if (pNormalReg->_pBuffer != null && pNormalReg->_length > 0)
1795 pSecureReg->_pBuffer = pNormalReg->_pBuffer;
1796 pSecureReg->_length = pNormalReg->_length;
1798 pNormalReg->_pBuffer = null;
1799 pNormalReg->_length = 0;
1801 r = pSecureReg->Parse();
1802 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
1805 r = pSecureReg->Flush();
1806 SysTryReturn(NID_IO, !IsFailed(r), r, r, "[%s] Propagated.", GetErrorMessage(r));
1812 _RegistryCore::LockN(FileLockType lockType)
1814 SysAssertf(_constructed == true && __pFileImpl != null, "Not yet constructed. Construct() should be called before use.\n");
1815 return __pFileImpl->LockN(lockType);
1819 _RegistryCore::TryToLockN(FileLockType lockType)
1821 SysAssertf(_constructed == true && __pFileImpl != null, "Not yet constructed. Construct() should be called before use.\n");
1822 return __pFileImpl->TryToLockN(lockType);