Coding style applied according to style checkersubmit/tizen/20160418.104308accepted/tizen/wearable/20160418.235737accepted/tizen/tv/20160418.235750accepted/tizen/mobile/20160418.235742accepted/tizen/ivi/20160418.235747accepted/tizen/common/20160418.142113

Checker/Guide in http://10.113.136.204/confluence/pages/viewpage.action?pageId=44567756

Change-Id: Ie1c934dcc898b72a68b7a56d43eea4a3298b509c
Signed-off-by: Kyungwook Tak <k.tak@samsung.com>

24 files changed, 957 insertions, 911 deletions

diff --git a/src/manager/initial-values/BufferHandler.cpp b/src/manager/initial-values/BufferHandler.cpp
index 38a7be35..cca06b20 100644
--- a/src/manager/initial-values/BufferHandler.cpp
+++ b/src/manager/initial-values/BufferHandler.cpp
@@ -28,7 +28,7 @@
 #include <base64.h>
 
 namespace {
-const char * const XML_ATTR_IV  = "IV";
+const char *const XML_ATTR_IV  = "IV";
 }
 
 namespace CKM {
@@ -39,53 +39,53 @@ BufferHandler::~BufferHandler() {}
 
 void BufferHandler::Start(const XML::Parser::Attributes &attr)
 {
-    // get key type
-    if (attr.find(XML_ATTR_IV) != attr.end()) {
-        std::string IVstring = attr.at(XML_ATTR_IV);
-        Base64Decoder base64;
-        base64.reset();
-        base64.append(RawBuffer(IVstring.begin(), IVstring.end()));
-        base64.finalize();
-        m_IV = base64.get();
-    }
+	// get key type
+	if (attr.find(XML_ATTR_IV) != attr.end()) {
+		std::string IVstring = attr.at(XML_ATTR_IV);
+		Base64Decoder base64;
+		base64.reset();
+		base64.append(RawBuffer(IVstring.begin(), IVstring.end()));
+		base64.finalize();
+		m_IV = base64.get();
+	}
 }
 
 
-void BufferHandler::Characters(const std::string & data)
+void BufferHandler::Characters(const std::string &data)
 {
-    m_data.reserve(m_data.size() + data.size());
-    m_data.insert(m_data.end(), data.begin(), data.end());
+	m_data.reserve(m_data.size() + data.size());
+	m_data.insert(m_data.end(), data.begin(), data.end());
 }
 
 void BufferHandler::End()
 {
-    // decoding section
-    switch (m_encoding) {
-    // PEM requires that "----- END" section comes right after "\n" character
-    case PEM:
-    {
-        std::string trimmed = XML::trimEachLine(std::string(m_data.begin(), m_data.end()));
-        m_data = RawBuffer(trimmed.begin(), trimmed.end());
-        break;
-    }
+	// decoding section
+	switch (m_encoding) {
+	// PEM requires that "----- END" section comes right after "\n" character
+	case PEM: {
+		std::string trimmed = XML::trimEachLine(std::string(m_data.begin(),
+												m_data.end()));
+		m_data = RawBuffer(trimmed.begin(), trimmed.end());
+		break;
+	}
 
-    // Base64 decoder also does not accept any whitespaces
-    case DER:
-    case BASE64:
-    case ENCRYPTED:
-    {
-        std::string trimmed = XML::trimEachLine(std::string(m_data.begin(), m_data.end()));
-        Base64Decoder base64;
-        base64.reset();
-        base64.append(RawBuffer(trimmed.begin(), trimmed.end()));
-        base64.finalize();
-        m_data = base64.get();
-        break;
-    }
+	// Base64 decoder also does not accept any whitespaces
+	case DER:
+	case BASE64:
+	case ENCRYPTED: {
+		std::string trimmed = XML::trimEachLine(std::string(m_data.begin(),
+												m_data.end()));
+		Base64Decoder base64;
+		base64.reset();
+		base64.append(RawBuffer(trimmed.begin(), trimmed.end()));
+		base64.finalize();
+		m_data = base64.get();
+		break;
+	}
 
-    default:
-        break;
-    }
+	default:
+		break;
+	}
 }
 
 }
diff --git a/src/manager/initial-values/BufferHandler.h b/src/manager/initial-values/BufferHandler.h
index 2a44f450..572244db 100644
--- a/src/manager/initial-values/BufferHandler.h
+++ b/src/manager/initial-values/BufferHandler.h
@@ -33,34 +33,37 @@ namespace InitialValues {
 
 class BufferHandler : public XML::Parser::ElementHandler {
 public:
-    typedef std::shared_ptr<BufferHandler> BufferHandlerPtr;
+	typedef std::shared_ptr<BufferHandler> BufferHandlerPtr;
 
-    BufferHandler(EncodingType type);
-    virtual ~BufferHandler();
+	BufferHandler(EncodingType type);
+	virtual ~BufferHandler();
 
-    virtual void Start(const XML::Parser::Attributes &);
-    virtual void Characters(const std::string & data);
-    virtual void End();
+	virtual void Start(const XML::Parser::Attributes &);
+	virtual void Characters(const std::string &data);
+	virtual void End();
 
-    const RawBuffer & getData() const
-    {
-        return m_data;
-    }
-    bool isEncrypted() const
-    {
-        if (m_encoding == EncodingType::ENCRYPTED)
-            return true;
-        return false;
-    }
-    const RawBuffer & getIV() const
-    {
-        return m_IV;
-    }
+	const RawBuffer &getData() const
+	{
+		return m_data;
+	}
+
+	bool isEncrypted() const
+	{
+		if (m_encoding == EncodingType::ENCRYPTED)
+			return true;
+
+		return false;
+	}
+
+	const RawBuffer &getIV() const
+	{
+		return m_IV;
+	}
 
 private:
-    EncodingType        m_encoding;
-    RawBuffer           m_IV;
-    RawBuffer           m_data;
+	EncodingType m_encoding;
+	RawBuffer m_IV;
+	RawBuffer m_data;
 };
 
 }
diff --git a/src/manager/initial-values/CertHandler.cpp b/src/manager/initial-values/CertHandler.cpp
index e7d37125..61e7ce97 100644
--- a/src/manager/initial-values/CertHandler.cpp
+++ b/src/manager/initial-values/CertHandler.cpp
@@ -31,7 +31,7 @@ CertHandler::~CertHandler() {}
 
 DataType CertHandler::getDataType() const
 {
-    return DataType::CERTIFICATE;
+	return DataType::CERTIFICATE;
 }
 
 }
diff --git a/src/manager/initial-values/CertHandler.h b/src/manager/initial-values/CertHandler.h
index 8e246d20..6729c613 100644
--- a/src/manager/initial-values/CertHandler.h
+++ b/src/manager/initial-values/CertHandler.h
@@ -31,11 +31,11 @@ namespace InitialValues {
 
 class CertHandler : public InitialValueHandler {
 public:
-    explicit CertHandler(CKMLogic & db_logic, const CKM::RawBuffer &encryptedKey)
-        : InitialValueHandler(db_logic, encryptedKey) {}
-    virtual ~CertHandler();
+	explicit CertHandler(CKMLogic &db_logic, const CKM::RawBuffer &encryptedKey)
+		: InitialValueHandler(db_logic, encryptedKey) {}
+	virtual ~CertHandler();
 
-    virtual DataType getDataType() const;
+	virtual DataType getDataType() const;
 };
 
 }
diff --git a/src/manager/initial-values/DataHandler.cpp b/src/manager/initial-values/DataHandler.cpp
index b4d5945d..487750fe 100644
--- a/src/manager/initial-values/DataHandler.cpp
+++ b/src/manager/initial-values/DataHandler.cpp
@@ -31,7 +31,7 @@ DataHandler::~DataHandler() {}
 
 DataType DataHandler::getDataType() const
 {
-    return DataType::BINARY_DATA;
+	return DataType::BINARY_DATA;
 }
 
 }
diff --git a/src/manager/initial-values/DataHandler.h b/src/manager/initial-values/DataHandler.h
index bab8316f..6970496f 100644
--- a/src/manager/initial-values/DataHandler.h
+++ b/src/manager/initial-values/DataHandler.h
@@ -31,11 +31,11 @@ namespace InitialValues {
 
 class DataHandler : public InitialValueHandler {
 public:
-    explicit DataHandler(CKMLogic & db_logic, const CKM::RawBuffer &encryptedKey) :
-        InitialValueHandler(db_logic, encryptedKey) {}
-    virtual ~DataHandler();
+	explicit DataHandler(CKMLogic &db_logic, const CKM::RawBuffer &encryptedKey) :
+		InitialValueHandler(db_logic, encryptedKey) {}
+	virtual ~DataHandler();
 
-    virtual DataType getDataType() const;
+	virtual DataType getDataType() const;
 };
 
 }
diff --git a/src/manager/initial-values/EncodingType.h b/src/manager/initial-values/EncodingType.h
index d40e2dd2..2868831f 100644
--- a/src/manager/initial-values/EncodingType.h
+++ b/src/manager/initial-values/EncodingType.h
@@ -27,12 +27,12 @@ namespace CKM {
 namespace InitialValues {
 
 enum EncodingType {
-    PEM,
-    DER,
-    ASCII,
-    BASE64,
-    // encrypted
-    ENCRYPTED
+	PEM,
+	DER,
+	ASCII,
+	BASE64,
+	// encrypted
+	ENCRYPTED
 };
 
 }
diff --git a/src/manager/initial-values/InitialValueHandler.cpp b/src/manager/initial-values/InitialValueHandler.cpp
index d4d01bdb..c4bcd929 100644
--- a/src/manager/initial-values/InitialValueHandler.cpp
+++ b/src/manager/initial-values/InitialValueHandler.cpp
@@ -29,9 +29,9 @@
 #include <ckm/ckm-type.h>
 
 namespace {
-const char * const XML_ATTR_NAME        = "name";
-const char * const XML_ATTR_PASSWORD    = "password";
-const char * const XML_ATTR_EXPORTABLE  = "exportable";
+const char *const XML_ATTR_NAME        = "name";
+const char *const XML_ATTR_PASSWORD    = "password";
+const char *const XML_ATTR_EXPORTABLE  = "exportable";
 }
 
 namespace CKM {
@@ -39,76 +39,82 @@ namespace InitialValues {
 
 void InitialValueHandler::Start(const XML::Parser::Attributes &attr)
 {
-    // get name
-    if (attr.find(XML_ATTR_NAME) != attr.end())
-        m_name = Alias(attr.at(XML_ATTR_NAME));
-
-    // get password
-    if (attr.find(XML_ATTR_PASSWORD) != attr.end())
-        m_password = Password(attr.at(XML_ATTR_PASSWORD).c_str());
-
-    // get exportable
-    if (attr.find(XML_ATTR_EXPORTABLE) != attr.end()) {
-        std::string flagVal = attr.at(XML_ATTR_EXPORTABLE);
-        std::transform(flagVal.begin(), flagVal.end(), flagVal.begin(), ::tolower);
-        std::istringstream is(flagVal);
-        is >> std::boolalpha >> m_exportable;
-    }
+	// get name
+	if (attr.find(XML_ATTR_NAME) != attr.end())
+		m_name = Alias(attr.at(XML_ATTR_NAME));
+
+	// get password
+	if (attr.find(XML_ATTR_PASSWORD) != attr.end())
+		m_password = Password(attr.at(XML_ATTR_PASSWORD).c_str());
+
+	// get exportable
+	if (attr.find(XML_ATTR_EXPORTABLE) != attr.end()) {
+		std::string flagVal = attr.at(XML_ATTR_EXPORTABLE);
+		std::transform(flagVal.begin(), flagVal.end(), flagVal.begin(), ::tolower);
+		std::istringstream is(flagVal);
+		is >> std::boolalpha >> m_exportable;
+	}
 }
 
 void InitialValueHandler::End()
 {
-    if (!m_bufferHandler) {
-        LogError("Invalid data with name: " << m_name << ", reason: no key data!");
-        return;
-    }
-    // save data
-    Policy policy(m_password, m_exportable);
-
-    Crypto::DataEncryption de;
-    if (m_bufferHandler->isEncrypted()) {
-        de.encryptedKey = m_encryptedKey;
-        de.iv = m_bufferHandler->getIV();
-    }
-
-    int ec = m_db_logic.importInitialData(m_name,
-                                          Crypto::Data(getDataType(), m_bufferHandler->getData()),
-                                          de,
-                                          policy);
-
-    if (CKM_API_SUCCESS != ec) {
-        LogError("Saving type: " << getDataType() << " with params: name(" <<
-            m_name << "), exportable(" << m_exportable<< ") failed, code: " << ec);
-        return;
-    }
-
-    // save permissions
-    for (const auto & permission : m_permissions) {
-        ec = m_db_logic.setPermissionHelper(
-                Credentials(CKMLogic::SYSTEM_DB_UID, OWNER_ID_SYSTEM),
-                m_name,
-                OWNER_ID_SYSTEM,
-                permission->getAccessor(),
-                Permission::READ);
-        if (CKM_API_SUCCESS != ec) {
-            LogError("Saving permission to: " << m_name <<
-              " with params: accessor(" << permission->getAccessor() <<
-              ") failed, code: " << ec);
-        }
-    }
+	if (!m_bufferHandler) {
+		LogError("Invalid data with name: " << m_name << ", reason: no key data!");
+		return;
+	}
+
+	// save data
+	Policy policy(m_password, m_exportable);
+
+	Crypto::DataEncryption de;
+
+	if (m_bufferHandler->isEncrypted()) {
+		de.encryptedKey = m_encryptedKey;
+		de.iv = m_bufferHandler->getIV();
+	}
+
+	int ec = m_db_logic.importInitialData(m_name,
+										  Crypto::Data(getDataType(), m_bufferHandler->getData()),
+										  de,
+										  policy);
+
+	if (CKM_API_SUCCESS != ec) {
+		LogError("Saving type: " << getDataType() << " with params: name(" <<
+				 m_name << "), exportable(" << m_exportable << ") failed, code: " << ec);
+		return;
+	}
+
+	// save permissions
+	for (const auto &permission : m_permissions) {
+		ec = m_db_logic.setPermissionHelper(
+				 Credentials(CKMLogic::SYSTEM_DB_UID, OWNER_ID_SYSTEM),
+				 m_name,
+				 OWNER_ID_SYSTEM,
+				 permission->getAccessor(),
+				 Permission::READ);
+
+		if (CKM_API_SUCCESS != ec) {
+			LogError("Saving permission to: " << m_name <<
+					 " with params: accessor(" << permission->getAccessor() <<
+					 ") failed, code: " << ec);
+		}
+	}
 }
 
-BufferHandler::BufferHandlerPtr InitialValueHandler::CreateBufferHandler(EncodingType type)
+BufferHandler::BufferHandlerPtr InitialValueHandler::CreateBufferHandler(
+	EncodingType type)
 {
-    m_bufferHandler = std::make_shared<BufferHandler>(type);
-    return m_bufferHandler;
+	m_bufferHandler = std::make_shared<BufferHandler>(type);
+	return m_bufferHandler;
 }
 
-PermissionHandler::PermissionHandlerPtr InitialValueHandler::CreatePermissionHandler()
+PermissionHandler::PermissionHandlerPtr
+InitialValueHandler::CreatePermissionHandler()
 {
-    PermissionHandler::PermissionHandlerPtr newPermission = std::make_shared<PermissionHandler>();
-    m_permissions.push_back(newPermission);
-    return newPermission;
+	PermissionHandler::PermissionHandlerPtr newPermission =
+		std::make_shared<PermissionHandler>();
+	m_permissions.push_back(newPermission);
+	return newPermission;
 }
 
 }
diff --git a/src/manager/initial-values/InitialValueHandler.h b/src/manager/initial-values/InitialValueHandler.h
index 29043d46..5a73ee92 100644
--- a/src/manager/initial-values/InitialValueHandler.h
+++ b/src/manager/initial-values/InitialValueHandler.h
@@ -37,28 +37,29 @@ namespace InitialValues {
 
 class InitialValueHandler : public NoCharactersHandler {
 public:
-    typedef std::shared_ptr<InitialValueHandler> InitialValueHandlerPtr;
+	typedef std::shared_ptr<InitialValueHandler> InitialValueHandlerPtr;
 
-    explicit InitialValueHandler(CKMLogic & db_logic, const CKM::RawBuffer &encryptedKey)
-        : m_exportable(false), m_db_logic(db_logic), m_encryptedKey(encryptedKey) {}
-    virtual ~InitialValueHandler() {}
+	explicit InitialValueHandler(CKMLogic &db_logic,
+								 const CKM::RawBuffer &encryptedKey)
+		: m_exportable(false), m_db_logic(db_logic), m_encryptedKey(encryptedKey) {}
+	virtual ~InitialValueHandler() {}
 
-    BufferHandler::BufferHandlerPtr CreateBufferHandler(EncodingType type);
-    PermissionHandler::PermissionHandlerPtr CreatePermissionHandler();
-    virtual void Start(const XML::Parser::Attributes &);
-    virtual void End();
+	BufferHandler::BufferHandlerPtr CreateBufferHandler(EncodingType type);
+	PermissionHandler::PermissionHandlerPtr CreatePermissionHandler();
+	virtual void Start(const XML::Parser::Attributes &);
+	virtual void End();
 
 protected:
-    virtual DataType getDataType() const = 0;
+	virtual DataType getDataType() const = 0;
 
-    Alias      m_name;
-    Password   m_password;
-    bool       m_exportable;
-    CKMLogic & m_db_logic;
-    const CKM::RawBuffer & m_encryptedKey;
+	Alias      m_name;
+	Password   m_password;
+	bool       m_exportable;
+	CKMLogic &m_db_logic;
+	const CKM::RawBuffer &m_encryptedKey;
 
-    BufferHandler::BufferHandlerPtr m_bufferHandler;
-    std::vector<PermissionHandler::PermissionHandlerPtr> m_permissions;
+	BufferHandler::BufferHandlerPtr m_bufferHandler;
+	std::vector<PermissionHandler::PermissionHandlerPtr> m_permissions;
 };
 
 }
diff --git a/src/manager/initial-values/InitialValuesFile.cpp b/src/manager/initial-values/InitialValuesFile.cpp
index d13e8218..854567e5 100644
--- a/src/manager/initial-values/InitialValuesFile.cpp
+++ b/src/manager/initial-values/InitialValuesFile.cpp
@@ -34,222 +34,203 @@
 
 namespace {
 const int          XML_CURRENT_VERSION      = 1;
-const char * const XML_TAG_INITIAL_VALUES   = "InitialValues";
-const char * const XML_TAG_ENCRYPTION_KEY   = "EncryptionKey";
-const char * const XML_TAG_KEY              = "Key";
-const char * const XML_TAG_DATA             = "Data";
-const char * const XML_TAG_CERT             = "Cert";
-const char * const XML_TAG_PEM              = "PEM";
-const char * const XML_TAG_DER              = "DER";
-const char * const XML_TAG_ASCII            = "ASCII";
-const char * const XML_TAG_BASE64           = "Base64";
-const char * const XML_TAG_ENCRYPTED_DER    = "EncryptedDER";
-const char * const XML_TAG_ENCRYPTED_ASCII  = "EncryptedASCII";
-const char * const XML_TAG_ENCRYPTED_BINARY = "EncryptedBinary";
-const char * const XML_TAG_PERMISSION       = "Permission";
-const char * const XML_ATTR_VERSION         = "version";
+const char *const XML_TAG_INITIAL_VALUES   = "InitialValues";
+const char *const XML_TAG_ENCRYPTION_KEY   = "EncryptionKey";
+const char *const XML_TAG_KEY              = "Key";
+const char *const XML_TAG_DATA             = "Data";
+const char *const XML_TAG_CERT             = "Cert";
+const char *const XML_TAG_PEM              = "PEM";
+const char *const XML_TAG_DER              = "DER";
+const char *const XML_TAG_ASCII            = "ASCII";
+const char *const XML_TAG_BASE64           = "Base64";
+const char *const XML_TAG_ENCRYPTED_DER    = "EncryptedDER";
+const char *const XML_TAG_ENCRYPTED_ASCII  = "EncryptedASCII";
+const char *const XML_TAG_ENCRYPTED_BINARY = "EncryptedBinary";
+const char *const XML_TAG_PERMISSION       = "Permission";
+const char *const XML_ATTR_VERSION         = "version";
 }
 
 namespace CKM {
 namespace InitialValues {
 
 InitialValuesFile::InitialValuesFile(const std::string &XML_filename,
-                                     CKMLogic & db_logic)
-        : m_parser(XML_filename), m_db_logic(db_logic),
-          m_header(std::make_shared<HeaderHandler>(*this)),
-          m_encryptionKeyHandler(std::make_shared<EncryptionKeyHandler>(*this))
+									 CKMLogic &db_logic)
+	: m_parser(XML_filename), m_db_logic(db_logic),
+	  m_header(std::make_shared<HeaderHandler>(*this)),
+	  m_encryptionKeyHandler(std::make_shared<EncryptionKeyHandler>(*this))
 {
-    m_parser.RegisterErrorCb(InitialValuesFile::Error);
-    m_parser.RegisterElementCb(XML_TAG_INITIAL_VALUES,
-            [this]() -> XML::Parser::ElementHandlerPtr
-            {
-                return m_header;
-            },
-            [this](const XML::Parser::ElementHandlerPtr &) {});
-    m_parser.RegisterElementCb(XML_TAG_ENCRYPTION_KEY,
-            [this]() -> XML::Parser::ElementHandlerPtr
-            {
-                return m_encryptionKeyHandler;
-            },
-            [this](const XML::Parser::ElementHandlerPtr &)
-            {
-                m_encryptedAESkey = m_encryptionKeyHandler->getEncryptedKey();
-            });
+	m_parser.RegisterErrorCb(InitialValuesFile::Error);
+	m_parser.RegisterElementCb(XML_TAG_INITIAL_VALUES,
+	[this]() -> XML::Parser::ElementHandlerPtr {
+		return m_header;
+	},
+	[this](const XML::Parser::ElementHandlerPtr &) {});
+	m_parser.RegisterElementCb(XML_TAG_ENCRYPTION_KEY,
+	[this]() -> XML::Parser::ElementHandlerPtr {
+		return m_encryptionKeyHandler;
+	},
+	[this](const XML::Parser::ElementHandlerPtr &) {
+		m_encryptedAESkey = m_encryptionKeyHandler->getEncryptedKey();
+	});
 }
 
 void InitialValuesFile::registerElementListeners()
 {
-    m_parser.RegisterElementCb(XML_TAG_KEY,
-            [this]() -> XML::Parser::ElementHandlerPtr
-            {
-                return GetObjectHandler(ObjectType::KEY, m_encryptedAESkey);
-            },
-            [this](const XML::Parser::ElementHandlerPtr &)
-            {
-                ReleaseObjectHandler(ObjectType::KEY);
-            });
-    m_parser.RegisterElementCb(XML_TAG_CERT,
-            [this]() -> XML::Parser::ElementHandlerPtr
-            {
-                return GetObjectHandler(ObjectType::CERT, m_encryptedAESkey);
-            },
-            [this](const XML::Parser::ElementHandlerPtr &)
-            {
-                ReleaseObjectHandler(ObjectType::CERT);
-            });
-    m_parser.RegisterElementCb(XML_TAG_DATA,
-            [this]() -> XML::Parser::ElementHandlerPtr
-            {
-                return GetObjectHandler(ObjectType::DATA, m_encryptedAESkey);
-            },
-            [this](const XML::Parser::ElementHandlerPtr &)
-            {
-                ReleaseObjectHandler(ObjectType::DATA);
-            });
-
-    m_parser.RegisterElementCb(XML_TAG_PEM,
-            [this]() -> XML::Parser::ElementHandlerPtr
-            {
-                return GetBufferHandler(EncodingType::PEM);
-            },
-            [this](const XML::Parser::ElementHandlerPtr &)
-            {
-                ReleaseBufferHandler(EncodingType::PEM);
-            });
-    m_parser.RegisterElementCb(XML_TAG_DER,
-            [this]() -> XML::Parser::ElementHandlerPtr
-            {
-                return GetBufferHandler(EncodingType::DER);
-            },
-            [this](const XML::Parser::ElementHandlerPtr &)
-            {
-                ReleaseBufferHandler(EncodingType::DER);
-            });
-    m_parser.RegisterElementCb(XML_TAG_ASCII,
-            [this]() -> XML::Parser::ElementHandlerPtr
-            {
-                return GetBufferHandler(EncodingType::ASCII);
-            },
-            [this](const XML::Parser::ElementHandlerPtr &)
-            {
-                ReleaseBufferHandler(EncodingType::ASCII);
-            });
-    m_parser.RegisterElementCb(XML_TAG_BASE64,
-            [this]() -> XML::Parser::ElementHandlerPtr
-            {
-                return GetBufferHandler(EncodingType::BASE64);
-            },
-            [this](const XML::Parser::ElementHandlerPtr &)
-            {
-                ReleaseBufferHandler(EncodingType::BASE64);
-            });
-    m_parser.RegisterElementCb(XML_TAG_ENCRYPTED_DER,
-            [this]() -> XML::Parser::ElementHandlerPtr
-            {
-                return GetBufferHandler(EncodingType::ENCRYPTED);
-            },
-            [this](const XML::Parser::ElementHandlerPtr &)
-            {
-                ReleaseBufferHandler(EncodingType::ENCRYPTED);
-            });
-    m_parser.RegisterElementCb(XML_TAG_ENCRYPTED_ASCII,
-            [this]() -> XML::Parser::ElementHandlerPtr
-            {
-                return GetBufferHandler(EncodingType::ENCRYPTED);
-            },
-            [this](const XML::Parser::ElementHandlerPtr &)
-            {
-                ReleaseBufferHandler(EncodingType::ENCRYPTED);
-            });
-    m_parser.RegisterElementCb(XML_TAG_ENCRYPTED_BINARY,
-            [this]() -> XML::Parser::ElementHandlerPtr
-            {
-                return GetBufferHandler(EncodingType::ENCRYPTED);
-            },
-            [this](const XML::Parser::ElementHandlerPtr &)
-            {
-                ReleaseBufferHandler(EncodingType::ENCRYPTED);
-            });
-    m_parser.RegisterElementCb(XML_TAG_PERMISSION,
-            [this]() -> XML::Parser::ElementHandlerPtr
-            {
-                return GetPermissionHandler();
-            },
-            [this](const XML::Parser::ElementHandlerPtr &)
-            {
-                ReleasePermissionHandler();
-            });
+	m_parser.RegisterElementCb(XML_TAG_KEY,
+	[this]() -> XML::Parser::ElementHandlerPtr {
+		return GetObjectHandler(ObjectType::KEY, m_encryptedAESkey);
+	},
+	[this](const XML::Parser::ElementHandlerPtr &) {
+		ReleaseObjectHandler(ObjectType::KEY);
+	});
+	m_parser.RegisterElementCb(XML_TAG_CERT,
+	[this]() -> XML::Parser::ElementHandlerPtr {
+		return GetObjectHandler(ObjectType::CERT, m_encryptedAESkey);
+	},
+	[this](const XML::Parser::ElementHandlerPtr &) {
+		ReleaseObjectHandler(ObjectType::CERT);
+	});
+	m_parser.RegisterElementCb(XML_TAG_DATA,
+	[this]() -> XML::Parser::ElementHandlerPtr {
+		return GetObjectHandler(ObjectType::DATA, m_encryptedAESkey);
+	},
+	[this](const XML::Parser::ElementHandlerPtr &) {
+		ReleaseObjectHandler(ObjectType::DATA);
+	});
+
+	m_parser.RegisterElementCb(XML_TAG_PEM,
+	[this]() -> XML::Parser::ElementHandlerPtr {
+		return GetBufferHandler(EncodingType::PEM);
+	},
+	[this](const XML::Parser::ElementHandlerPtr &) {
+		ReleaseBufferHandler(EncodingType::PEM);
+	});
+	m_parser.RegisterElementCb(XML_TAG_DER,
+	[this]() -> XML::Parser::ElementHandlerPtr {
+		return GetBufferHandler(EncodingType::DER);
+	},
+	[this](const XML::Parser::ElementHandlerPtr &) {
+		ReleaseBufferHandler(EncodingType::DER);
+	});
+	m_parser.RegisterElementCb(XML_TAG_ASCII,
+	[this]() -> XML::Parser::ElementHandlerPtr {
+		return GetBufferHandler(EncodingType::ASCII);
+	},
+	[this](const XML::Parser::ElementHandlerPtr &) {
+		ReleaseBufferHandler(EncodingType::ASCII);
+	});
+	m_parser.RegisterElementCb(XML_TAG_BASE64,
+	[this]() -> XML::Parser::ElementHandlerPtr {
+		return GetBufferHandler(EncodingType::BASE64);
+	},
+	[this](const XML::Parser::ElementHandlerPtr &) {
+		ReleaseBufferHandler(EncodingType::BASE64);
+	});
+	m_parser.RegisterElementCb(XML_TAG_ENCRYPTED_DER,
+	[this]() -> XML::Parser::ElementHandlerPtr {
+		return GetBufferHandler(EncodingType::ENCRYPTED);
+	},
+	[this](const XML::Parser::ElementHandlerPtr &) {
+		ReleaseBufferHandler(EncodingType::ENCRYPTED);
+	});
+	m_parser.RegisterElementCb(XML_TAG_ENCRYPTED_ASCII,
+	[this]() -> XML::Parser::ElementHandlerPtr {
+		return GetBufferHandler(EncodingType::ENCRYPTED);
+	},
+	[this](const XML::Parser::ElementHandlerPtr &) {
+		ReleaseBufferHandler(EncodingType::ENCRYPTED);
+	});
+	m_parser.RegisterElementCb(XML_TAG_ENCRYPTED_BINARY,
+	[this]() -> XML::Parser::ElementHandlerPtr {
+		return GetBufferHandler(EncodingType::ENCRYPTED);
+	},
+	[this](const XML::Parser::ElementHandlerPtr &) {
+		ReleaseBufferHandler(EncodingType::ENCRYPTED);
+	});
+	m_parser.RegisterElementCb(XML_TAG_PERMISSION,
+	[this]() -> XML::Parser::ElementHandlerPtr {
+		return GetPermissionHandler();
+	},
+	[this](const XML::Parser::ElementHandlerPtr &) {
+		ReleasePermissionHandler();
+	});
 }
 
 void InitialValuesFile::Error(const XML::Parser::ErrorType errorType,
-                              const std::string & log_msg)
+							  const std::string &log_msg)
 {
-    switch (errorType) {
-    case XML::Parser::VALIDATION_ERROR:
-        LogWarning("validating error: " << log_msg);
-        break;
-    case XML::Parser::PARSE_WARNING:
-        LogWarning("parsing warning: " << log_msg);
-        break;
-    case XML::Parser::PARSE_ERROR:
-        LogWarning("parsing error: " << log_msg);
-        break;
-    }
+	switch (errorType) {
+	case XML::Parser::VALIDATION_ERROR:
+		LogWarning("validating error: " << log_msg);
+		break;
+
+	case XML::Parser::PARSE_WARNING:
+		LogWarning("parsing warning: " << log_msg);
+		break;
+
+	case XML::Parser::PARSE_ERROR:
+		LogWarning("parsing error: " << log_msg);
+		break;
+	}
 }
 
 int InitialValuesFile::Validate(const std::string &XSD_file)
 {
-    return m_parser.Validate(XSD_file);
+	return m_parser.Validate(XSD_file);
 }
 
 int InitialValuesFile::Parse()
 {
-    int ec = m_parser.Parse();
-    if (!m_header || !m_header->isCorrectVersion()) {
-        LogError("bypassing XML file: " << m_filename << " - wrong file version!");
-        ec = XML::Parser::ERROR_INVALID_VERSION;
-    }
-    return ec;
+	int ec = m_parser.Parse();
+
+	if (!m_header || !m_header->isCorrectVersion()) {
+		LogError("bypassing XML file: " << m_filename << " - wrong file version!");
+		ec = XML::Parser::ERROR_INVALID_VERSION;
+	}
+
+	return ec;
 }
 
-XML::Parser::ElementHandlerPtr InitialValuesFile::GetObjectHandler(ObjectType type,
-                                                                   const CKM::RawBuffer &encryptedKey)
+XML::Parser::ElementHandlerPtr InitialValuesFile::GetObjectHandler(
+	ObjectType type,
+	const CKM::RawBuffer &encryptedKey)
 {
-    switch (type) {
-    case KEY:
-        m_currentHandler = std::make_shared<KeyHandler>(m_db_logic, encryptedKey);
-        break;
+	switch (type) {
+	case KEY:
+		m_currentHandler = std::make_shared<KeyHandler>(m_db_logic, encryptedKey);
+		break;
 
-    case CERT:
-        m_currentHandler = std::make_shared<CertHandler>(m_db_logic, encryptedKey);
-        break;
+	case CERT:
+		m_currentHandler = std::make_shared<CertHandler>(m_db_logic, encryptedKey);
+		break;
 
-    case DATA:
-        m_currentHandler = std::make_shared<DataHandler>(m_db_logic, encryptedKey);
-        break;
+	case DATA:
+		m_currentHandler = std::make_shared<DataHandler>(m_db_logic, encryptedKey);
+		break;
 
-    default:
-        m_currentHandler.reset();
-        break;
-    }
+	default:
+		m_currentHandler.reset();
+		break;
+	}
 
-    return m_currentHandler;
+	return m_currentHandler;
 }
 
 void InitialValuesFile::ReleaseObjectHandler(ObjectType /*type*/)
 {
-    m_currentHandler.reset();
+	m_currentHandler.reset();
 }
 
 
 
 
-XML::Parser::ElementHandlerPtr InitialValuesFile::GetBufferHandler(EncodingType type)
+XML::Parser::ElementHandlerPtr InitialValuesFile::GetBufferHandler(
+	EncodingType type)
 {
-    if ( !m_currentHandler )
-        return XML::Parser::ElementHandlerPtr();
+	if (!m_currentHandler)
+		return XML::Parser::ElementHandlerPtr();
 
-    return m_currentHandler->CreateBufferHandler(type);
+	return m_currentHandler->CreateBufferHandler(type);
 }
 void InitialValuesFile::ReleaseBufferHandler(EncodingType /*type*/)
 {
@@ -258,56 +239,60 @@ void InitialValuesFile::ReleaseBufferHandler(EncodingType /*type*/)
 
 XML::Parser::ElementHandlerPtr InitialValuesFile::GetPermissionHandler()
 {
-    if ( !m_currentHandler )
-        return XML::Parser::ElementHandlerPtr();
+	if (!m_currentHandler)
+		return XML::Parser::ElementHandlerPtr();
 
-    return m_currentHandler->CreatePermissionHandler();
+	return m_currentHandler->CreatePermissionHandler();
 }
 void InitialValuesFile::ReleasePermissionHandler()
 {
 }
 
 
-InitialValuesFile::EncryptionKeyHandler::EncryptionKeyHandler(InitialValuesFile & parent) : m_parent(parent) {}
-void InitialValuesFile::EncryptionKeyHandler::Characters(const std::string &data)
+InitialValuesFile::EncryptionKeyHandler::EncryptionKeyHandler(
+	InitialValuesFile  &parent) : m_parent(parent) {}
+void InitialValuesFile::EncryptionKeyHandler::Characters(
+	const std::string &data)
 {
-    m_encryptedKey.reserve(m_encryptedKey.size() + data.size());
-    m_encryptedKey.insert(m_encryptedKey.end(), data.begin(), data.end());
+	m_encryptedKey.reserve(m_encryptedKey.size() + data.size());
+	m_encryptedKey.insert(m_encryptedKey.end(), data.begin(), data.end());
 };
 
 void InitialValuesFile::EncryptionKeyHandler::End()
 {
-    std::string trimmed = XML::trimEachLine(std::string(m_encryptedKey.begin(), m_encryptedKey.end()));
-    Base64Decoder base64;
-    base64.reset();
-    base64.append(RawBuffer(trimmed.begin(), trimmed.end()));
-    base64.finalize();
-    m_encryptedKey = base64.get();
+	std::string trimmed = XML::trimEachLine(std::string(m_encryptedKey.begin(),
+											m_encryptedKey.end()));
+	Base64Decoder base64;
+	base64.reset();
+	base64.append(RawBuffer(trimmed.begin(), trimmed.end()));
+	base64.finalize();
+	m_encryptedKey = base64.get();
 };
 
 CKM::RawBuffer InitialValuesFile::EncryptionKeyHandler::getEncryptedKey() const
 {
-    return m_encryptedKey;
+	return m_encryptedKey;
 }
 
-InitialValuesFile::HeaderHandler::HeaderHandler(InitialValuesFile & parent) :
-    m_version(-1), m_parent(parent)
+InitialValuesFile::HeaderHandler::HeaderHandler(InitialValuesFile &parent) :
+	m_version(-1), m_parent(parent)
 {
 }
 
-void InitialValuesFile::HeaderHandler::Start(const XML::Parser::Attributes & attr)
+void InitialValuesFile::HeaderHandler::Start(const XML::Parser::Attributes
+		&attr)
 {
-    // get key type
-    if (attr.find(XML_ATTR_VERSION) != attr.end()) {
-        m_version = atoi(attr.at(XML_ATTR_VERSION).c_str());
+	// get key type
+	if (attr.find(XML_ATTR_VERSION) != attr.end()) {
+		m_version = atoi(attr.at(XML_ATTR_VERSION).c_str());
 
-        if (isCorrectVersion())
-            m_parent.registerElementListeners();
-    }
+		if (isCorrectVersion())
+			m_parent.registerElementListeners();
+	}
 }
 bool InitialValuesFile::HeaderHandler::isCorrectVersion() const
 {
-    return m_version == XML_CURRENT_VERSION;
+	return m_version == XML_CURRENT_VERSION;
 }
 
 }
diff --git a/src/manager/initial-values/InitialValuesFile.h b/src/manager/initial-values/InitialValuesFile.h
index bd450910..a11747b3 100644
--- a/src/manager/initial-values/InitialValuesFile.h
+++ b/src/manager/initial-values/InitialValuesFile.h
@@ -38,70 +38,71 @@ namespace InitialValues {
 
 class InitialValuesFile {
 public:
-    InitialValuesFile(const std::string &XML_filename,
-                      CKMLogic & db_logic);
+	InitialValuesFile(const std::string &XML_filename,
+					  CKMLogic &db_logic);
 
-    int Validate(const std::string &XSD_file);
-    int Parse();
+	int Validate(const std::string &XSD_file);
+	int Parse();
 
 protected:
-    enum ObjectType {
-        KEY,
-        CERT,
-        DATA
-    };
+	enum ObjectType {
+		KEY,
+		CERT,
+		DATA
+	};
 
-    XML::Parser::ElementHandlerPtr GetObjectHandler(ObjectType type, const CKM::RawBuffer &encryptedKey);
-    void ReleaseObjectHandler(ObjectType type);
+	XML::Parser::ElementHandlerPtr GetObjectHandler(ObjectType type,
+			const CKM::RawBuffer &encryptedKey);
+	void ReleaseObjectHandler(ObjectType type);
 
-    XML::Parser::ElementHandlerPtr GetBufferHandler(EncodingType type);
-    void ReleaseBufferHandler(EncodingType type);
+	XML::Parser::ElementHandlerPtr GetBufferHandler(EncodingType type);
+	void ReleaseBufferHandler(EncodingType type);
 
-    XML::Parser::ElementHandlerPtr GetPermissionHandler();
-    void ReleasePermissionHandler();
+	XML::Parser::ElementHandlerPtr GetPermissionHandler();
+	void ReleasePermissionHandler();
 
 private:
-    class HeaderHandler : public XML::Parser::ElementHandler {
-    public:
-        explicit HeaderHandler(InitialValuesFile & parent);
-        virtual void Start(const XML::Parser::Attributes & attr);
-        virtual void Characters(const std::string &) {}
-        virtual void End() {}
-
-        bool isCorrectVersion() const;
-
-    private:
-        int m_version;
-        InitialValuesFile & m_parent;
-    };
-
-    class EncryptionKeyHandler : public XML::Parser::ElementHandler {
-    public:
-        explicit EncryptionKeyHandler(InitialValuesFile & parent);
-        virtual void Start(const XML::Parser::Attributes &) {}
-        virtual void Characters(const std::string &data);
-        virtual void End();
-
-        CKM::RawBuffer getEncryptedKey() const;
-
-    private:
-        CKM::RawBuffer m_encryptedKey;
-        InitialValuesFile & m_parent;
-    };
-
-    std::string m_filename;
-    XML::Parser m_parser;
-    InitialValueHandler::InitialValueHandlerPtr m_currentHandler;
-    CKMLogic & m_db_logic;
-    typedef std::shared_ptr<HeaderHandler> HeaderHandlerPtr;
-    typedef std::shared_ptr<EncryptionKeyHandler> EncryptionKeyHandlerPtr;
-    HeaderHandlerPtr m_header;
-    EncryptionKeyHandlerPtr m_encryptionKeyHandler;
-    CKM::RawBuffer m_encryptedAESkey;
-
-    void registerElementListeners();
-    static void Error(const XML::Parser::ErrorType errorType,
-                      const std::string & logMsg);
+	class HeaderHandler : public XML::Parser::ElementHandler {
+	public:
+		explicit HeaderHandler(InitialValuesFile &parent);
+		virtual void Start(const XML::Parser::Attributes &attr);
+		virtual void Characters(const std::string &) {}
+		virtual void End() {}
+
+		bool isCorrectVersion() const;
+
+	private:
+		int m_version;
+		InitialValuesFile &m_parent;
+	};
+
+	class EncryptionKeyHandler : public XML::Parser::ElementHandler {
+	public:
+		explicit EncryptionKeyHandler(InitialValuesFile &parent);
+		virtual void Start(const XML::Parser::Attributes &) {}
+		virtual void Characters(const std::string &data);
+		virtual void End();
+
+		CKM::RawBuffer getEncryptedKey() const;
+
+	private:
+		CKM::RawBuffer m_encryptedKey;
+		InitialValuesFile &m_parent;
+	};
+
+	std::string m_filename;
+	XML::Parser m_parser;
+	InitialValueHandler::InitialValueHandlerPtr m_currentHandler;
+	CKMLogic &m_db_logic;
+	typedef std::shared_ptr<HeaderHandler> HeaderHandlerPtr;
+	typedef std::shared_ptr<EncryptionKeyHandler> EncryptionKeyHandlerPtr;
+	HeaderHandlerPtr m_header;
+	EncryptionKeyHandlerPtr m_encryptionKeyHandler;
+	CKM::RawBuffer m_encryptedAESkey;
+
+	void registerElementListeners();
+	static void Error(const XML::Parser::ErrorType errorType,
+					  const std::string &logMsg);
 };
 
 }
diff --git a/src/manager/initial-values/KeyHandler.cpp b/src/manager/initial-values/KeyHandler.cpp
index ef358e82..4a98cb09 100644
--- a/src/manager/initial-values/KeyHandler.cpp
+++ b/src/manager/initial-values/KeyHandler.cpp
@@ -28,14 +28,14 @@
 #include <ckm/ckm-type.h>
 
 namespace {
-const char * const XML_ATTR_TYPE    = "type";
-const char * const XML_ATTR_TYPE_VAL_RSA_PRV    =   "RSA_PRV";
-const char * const XML_ATTR_TYPE_VAL_RSA_PUB    =   "RSA_PUB";
-const char * const XML_ATTR_TYPE_VAL_DSA_PRV    =   "DSA_PRV";
-const char * const XML_ATTR_TYPE_VAL_DSA_PUB    =   "DSA_PUB";
-const char * const XML_ATTR_TYPE_VAL_ECDSA_PRV  =   "ECDSA_PRV";
-const char * const XML_ATTR_TYPE_VAL_ECDSA_PUB  =   "ECDSA_PUB";
-const char * const XML_ATTR_TYPE_VAL_AES        =   "AES";
+const char *const XML_ATTR_TYPE    = "type";
+const char *const XML_ATTR_TYPE_VAL_RSA_PRV    =   "RSA_PRV";
+const char *const XML_ATTR_TYPE_VAL_RSA_PUB    =   "RSA_PUB";
+const char *const XML_ATTR_TYPE_VAL_DSA_PRV    =   "DSA_PRV";
+const char *const XML_ATTR_TYPE_VAL_DSA_PUB    =   "DSA_PUB";
+const char *const XML_ATTR_TYPE_VAL_ECDSA_PRV  =   "ECDSA_PRV";
+const char *const XML_ATTR_TYPE_VAL_ECDSA_PUB  =   "ECDSA_PUB";
+const char *const XML_ATTR_TYPE_VAL_AES        =   "AES";
 }
 
 namespace CKM {
@@ -45,29 +45,34 @@ KeyHandler::~KeyHandler() {}
 
 void KeyHandler::Start(const XML::Parser::Attributes &attr)
 {
-    InitialValueHandler::Start(attr);
+	InitialValueHandler::Start(attr);
 
-    // get key type
-    if (attr.find(XML_ATTR_TYPE) != attr.end())
-        m_keyType = KeyHandler::parseType(attr.at(XML_ATTR_TYPE));
+	// get key type
+	if (attr.find(XML_ATTR_TYPE) != attr.end())
+		m_keyType = KeyHandler::parseType(attr.at(XML_ATTR_TYPE));
 }
 
-KeyType KeyHandler::parseType(const std::string & typeStr)
+KeyType KeyHandler::parseType(const std::string &typeStr)
 {
-    if      (typeStr == XML_ATTR_TYPE_VAL_RSA_PRV)      return KeyType::KEY_RSA_PRIVATE;
-    else if (typeStr == XML_ATTR_TYPE_VAL_RSA_PUB)      return KeyType::KEY_RSA_PUBLIC;
-    else if (typeStr == XML_ATTR_TYPE_VAL_DSA_PRV)      return KeyType::KEY_DSA_PRIVATE;
-    else if (typeStr == XML_ATTR_TYPE_VAL_DSA_PUB)      return KeyType::KEY_DSA_PUBLIC;
-    else if (typeStr == XML_ATTR_TYPE_VAL_ECDSA_PRV)    return KeyType::KEY_ECDSA_PRIVATE;
-    else if (typeStr == XML_ATTR_TYPE_VAL_ECDSA_PUB)    return KeyType::KEY_ECDSA_PUBLIC;
-    else if (typeStr == XML_ATTR_TYPE_VAL_AES)          return KeyType::KEY_AES;
-    else // should not happen
-        throw std::runtime_error("error: invalid value discovered as key type");
+	if (typeStr == XML_ATTR_TYPE_VAL_RSA_PRV)      return KeyType::KEY_RSA_PRIVATE;
+	else if (typeStr == XML_ATTR_TYPE_VAL_RSA_PUB)      return
+			KeyType::KEY_RSA_PUBLIC;
+	else if (typeStr == XML_ATTR_TYPE_VAL_DSA_PRV)      return
+			KeyType::KEY_DSA_PRIVATE;
+	else if (typeStr == XML_ATTR_TYPE_VAL_DSA_PUB)      return
+			KeyType::KEY_DSA_PUBLIC;
+	else if (typeStr == XML_ATTR_TYPE_VAL_ECDSA_PRV)    return
+			KeyType::KEY_ECDSA_PRIVATE;
+	else if (typeStr == XML_ATTR_TYPE_VAL_ECDSA_PUB)    return
+			KeyType::KEY_ECDSA_PUBLIC;
+	else if (typeStr == XML_ATTR_TYPE_VAL_AES)          return KeyType::KEY_AES;
+	else // should not happen
+		throw std::runtime_error("error: invalid value discovered as key type");
 }
 
 DataType KeyHandler::getDataType() const
 {
-    return DataType(m_keyType);
+	return DataType(m_keyType);
 }
 
 }
diff --git a/src/manager/initial-values/KeyHandler.h b/src/manager/initial-values/KeyHandler.h
index 9f374135..5f630b45 100644
--- a/src/manager/initial-values/KeyHandler.h
+++ b/src/manager/initial-values/KeyHandler.h
@@ -32,18 +32,18 @@ namespace InitialValues {
 
 class KeyHandler : public InitialValueHandler {
 public:
-    explicit KeyHandler(CKMLogic & db_logic, const CKM::RawBuffer &encryptedKey) :
-        InitialValueHandler(db_logic, encryptedKey), m_keyType(KeyType::KEY_NONE) {}
-    virtual ~KeyHandler();
+	explicit KeyHandler(CKMLogic &db_logic, const CKM::RawBuffer &encryptedKey) :
+		InitialValueHandler(db_logic, encryptedKey), m_keyType(KeyType::KEY_NONE) {}
+	virtual ~KeyHandler();
 
-    virtual void Start(const XML::Parser::Attributes &);
+	virtual void Start(const XML::Parser::Attributes &);
 
-    virtual DataType getDataType() const;
+	virtual DataType getDataType() const;
 
 protected:
-    static KeyType parseType(const std::string & typeStr);
+	static KeyType parseType(const std::string &typeStr);
 
-    KeyType m_keyType;
+	KeyType m_keyType;
 };
 
 }
diff --git a/src/manager/initial-values/NoCharactersHandler.cpp b/src/manager/initial-values/NoCharactersHandler.cpp
index 0ee9ff93..e43c130e 100644
--- a/src/manager/initial-values/NoCharactersHandler.cpp
+++ b/src/manager/initial-values/NoCharactersHandler.cpp
@@ -28,12 +28,15 @@
 namespace CKM {
 namespace InitialValues {
 
-void NoCharactersHandler::Characters(const std::string & data)
+void NoCharactersHandler::Characters(const std::string &data)
 {
-    auto f = find_if(data.begin(), data.end(), [](char c){ return std::isspace(c) == 0;});
-    if (f != data.end())
-        throw std::runtime_error(
-                "error: value handler detected raw data outside data-specific tag");
+	auto f = find_if(data.begin(), data.end(), [](char c) {
+		return std::isspace(c) == 0;
+	});
+
+	if (f != data.end())
+		throw std::runtime_error(
+			"error: value handler detected raw data outside data-specific tag");
 }
 
 NoCharactersHandler::~NoCharactersHandler()
diff --git a/src/manager/initial-values/NoCharactersHandler.h b/src/manager/initial-values/NoCharactersHandler.h
index 63f16c8d..c581703f 100644
--- a/src/manager/initial-values/NoCharactersHandler.h
+++ b/src/manager/initial-values/NoCharactersHandler.h
@@ -29,9 +29,9 @@ namespace InitialValues {
 
 class NoCharactersHandler : public XML::Parser::ElementHandler {
 public:
-    void Characters(const std::string & data);
+	void Characters(const std::string &data);
 
-    virtual ~NoCharactersHandler();
+	virtual ~NoCharactersHandler();
 };
 
 } // namespace InitialValues
diff --git a/src/manager/initial-values/PermissionHandler.cpp b/src/manager/initial-values/PermissionHandler.cpp
index 80ff0317..0a7f523c 100644
--- a/src/manager/initial-values/PermissionHandler.cpp
+++ b/src/manager/initial-values/PermissionHandler.cpp
@@ -24,7 +24,7 @@
 #include <PermissionHandler.h>
 
 namespace {
-const char * const XML_ATTR_ACCESSOR    = "accessor";
+const char *const XML_ATTR_ACCESSOR    = "accessor";
 }
 
 namespace CKM {
@@ -32,11 +32,11 @@ namespace InitialValues {
 
 PermissionHandler::~PermissionHandler() {}
 
-void PermissionHandler::Start(const XML::Parser::Attributes & attr)
+void PermissionHandler::Start(const XML::Parser::Attributes &attr)
 {
-    // get accessor label
-    if (attr.find(XML_ATTR_ACCESSOR) != attr.end())
-        m_accessor = Label(attr.at(XML_ATTR_ACCESSOR));
+	// get accessor label
+	if (attr.find(XML_ATTR_ACCESSOR) != attr.end())
+		m_accessor = Label(attr.at(XML_ATTR_ACCESSOR));
 }
 
 void PermissionHandler::End()
diff --git a/src/manager/initial-values/PermissionHandler.h b/src/manager/initial-values/PermissionHandler.h
index 5d1f44b0..d84ecb29 100644
--- a/src/manager/initial-values/PermissionHandler.h
+++ b/src/manager/initial-values/PermissionHandler.h
@@ -32,20 +32,20 @@ namespace InitialValues {
 
 class PermissionHandler : public NoCharactersHandler {
 public:
-    typedef std::shared_ptr<PermissionHandler> PermissionHandlerPtr;
+	typedef std::shared_ptr<PermissionHandler> PermissionHandlerPtr;
 
-    virtual ~PermissionHandler();
+	virtual ~PermissionHandler();
 
-    virtual void Start(const XML::Parser::Attributes &);
-    virtual void End();
+	virtual void Start(const XML::Parser::Attributes &);
+	virtual void End();
 
-    const Label & getAccessor() const
-    {
-        return m_accessor;
-    }
+	const Label &getAccessor() const
+	{
+		return m_accessor;
+	}
 
 private:
-    Label   m_accessor;
+	Label m_accessor;
 };
 
 }
diff --git a/src/manager/initial-values/SWKeyFile.cpp b/src/manager/initial-values/SWKeyFile.cpp
index e8605506..bacad902 100644
--- a/src/manager/initial-values/SWKeyFile.cpp
+++ b/src/manager/initial-values/SWKeyFile.cpp
@@ -29,124 +29,126 @@
 
 namespace {
 const int          XML_SW_KEY_CURRENT_VERSION   = 1;
-const char * const XML_TAG_DEVICE_KEY           = "DeviceKey";
-const char * const XML_TAG_RSA_KEY              = "RSAPrivateKey";
-const char * const XML_TAG_PEM                  = "PEM";
-const char * const XML_TAG_DER                  = "DERBase64";
-const char * const XML_TAG_BASE64               = "Base64";
-const char * const XML_ATTR_VERSION             = "version";
+const char *const XML_TAG_DEVICE_KEY           = "DeviceKey";
+const char *const XML_TAG_RSA_KEY              = "RSAPrivateKey";
+const char *const XML_TAG_PEM                  = "PEM";
+const char *const XML_TAG_DER                  = "DERBase64";
+const char *const XML_TAG_BASE64               = "Base64";
+const char *const XML_ATTR_VERSION             = "version";
 }
 
 namespace CKM {
 namespace InitialValues {
 
 SWKeyFile::SWKeyFile(const std::string &XML_filename) :
-    m_parser(XML_filename),
-    m_header(std::make_shared<HeaderHandler>(*this)),
-    m_RSAKeyHandler(std::make_shared<RSAKeyHandler>(*this))
+	m_parser(XML_filename),
+	m_header(std::make_shared<HeaderHandler>(*this)),
+	m_RSAKeyHandler(std::make_shared<RSAKeyHandler>(*this))
 {
-    m_parser.RegisterErrorCb(SWKeyFile::Error);
-    m_parser.RegisterElementCb(XML_TAG_DEVICE_KEY,
-            [this]() -> XML::Parser::ElementHandlerPtr
-            {
-                return m_header;
-            },
-            [this](const XML::Parser::ElementHandlerPtr &) {});
+	m_parser.RegisterErrorCb(SWKeyFile::Error);
+	m_parser.RegisterElementCb(XML_TAG_DEVICE_KEY,
+	[this]() -> XML::Parser::ElementHandlerPtr {
+		return m_header;
+	},
+	[this](const XML::Parser::ElementHandlerPtr &) {});
 }
 
 void SWKeyFile::registerElementListeners()
 {
-    m_parser.RegisterElementCb(XML_TAG_RSA_KEY,
-            [this]() -> XML::Parser::ElementHandlerPtr
-            {
-                return m_RSAKeyHandler;
-            },
-            [this](const XML::Parser::ElementHandlerPtr &)
-            {
-                m_deviceKey = m_RSAKeyHandler->getPrivKey();
-            });
+	m_parser.RegisterElementCb(XML_TAG_RSA_KEY,
+	[this]() -> XML::Parser::ElementHandlerPtr {
+		return m_RSAKeyHandler;
+	},
+	[this](const XML::Parser::ElementHandlerPtr &) {
+		m_deviceKey = m_RSAKeyHandler->getPrivKey();
+	});
 }
 
 void SWKeyFile::Error(const XML::Parser::ErrorType errorType,
-                      const std::string & log_msg)
+					  const std::string &log_msg)
 {
-    switch (errorType) {
-    case XML::Parser::VALIDATION_ERROR:
-        LogWarning("validating error: " << log_msg);
-        break;
-    case XML::Parser::PARSE_WARNING:
-        LogWarning("parsing warning: " << log_msg);
-        break;
-    case XML::Parser::PARSE_ERROR:
-        LogWarning("parsing error: " << log_msg);
-        break;
-    }
+	switch (errorType) {
+	case XML::Parser::VALIDATION_ERROR:
+		LogWarning("validating error: " << log_msg);
+		break;
+
+	case XML::Parser::PARSE_WARNING:
+		LogWarning("parsing warning: " << log_msg);
+		break;
+
+	case XML::Parser::PARSE_ERROR:
+		LogWarning("parsing error: " << log_msg);
+		break;
+	}
 }
 
 int SWKeyFile::Validate(const std::string &XSD_file)
 {
-    return m_parser.Validate(XSD_file);
+	return m_parser.Validate(XSD_file);
 }
 
 int SWKeyFile::Parse()
 {
-    int ec = m_parser.Parse();
-    if (!m_header || !m_header->isCorrectVersion()) {
-        LogError("bypassing XML file: " << m_filename << " - wrong file version!");
-        ec = XML::Parser::ERROR_INVALID_VERSION;
-    }
-    return ec;
+	int ec = m_parser.Parse();
+
+	if (!m_header || !m_header->isCorrectVersion()) {
+		LogError("bypassing XML file: " << m_filename << " - wrong file version!");
+		ec = XML::Parser::ERROR_INVALID_VERSION;
+	}
+
+	return ec;
 }
 
 
 
-SWKeyFile::RSAKeyHandler::RSAKeyHandler(SWKeyFile & parent)
-  : m_parent(parent)
+SWKeyFile::RSAKeyHandler::RSAKeyHandler(SWKeyFile &parent)
+	: m_parent(parent)
 {
 }
 
 void SWKeyFile::RSAKeyHandler::Characters(const std::string &data)
 {
-    //m_encryptedKey.reserve(m_encryptedKey.size() + data.size());
-    //m_encryptedKey.insert(m_encryptedKey.end(), data.begin(), data.end());
-    std::copy(data.begin(), data.end(), std::back_inserter(m_encryptedKey));
+	//m_encryptedKey.reserve(m_encryptedKey.size() + data.size());
+	//m_encryptedKey.insert(m_encryptedKey.end(), data.begin(), data.end());
+	std::copy(data.begin(), data.end(), std::back_inserter(m_encryptedKey));
 }
 
 void SWKeyFile::RSAKeyHandler::End()
 {
-//    std::string trimmed = XML::trimEachLine(std::string(m_encryptedKey.begin(), m_encryptedKey.end()));
+	//    std::string trimmed = XML::trimEachLine(std::string(m_encryptedKey.begin(), m_encryptedKey.end()));
 
-    Base64Decoder base64;
-    base64.reset();
-    base64.append(XML::removeWhiteChars(m_encryptedKey));
-    base64.finalize();
-    m_encryptedKey = base64.get();
+	Base64Decoder base64;
+	base64.reset();
+	base64.append(XML::removeWhiteChars(m_encryptedKey));
+	base64.finalize();
+	m_encryptedKey = base64.get();
 };
 
 Crypto::GObjShPtr SWKeyFile::RSAKeyHandler::getPrivKey()
 {
-    return std::make_shared<Crypto::SW::AKey>(m_encryptedKey, DataType::KEY_RSA_PRIVATE);
+	return std::make_shared<Crypto::SW::AKey>(m_encryptedKey,
+			DataType::KEY_RSA_PRIVATE);
 }
 
-SWKeyFile::HeaderHandler::HeaderHandler(SWKeyFile & parent) :
-    m_version(-1), m_parent(parent)
+SWKeyFile::HeaderHandler::HeaderHandler(SWKeyFile &parent) :
+	m_version(-1), m_parent(parent)
 {
 }
 
-void SWKeyFile::HeaderHandler::Start(const XML::Parser::Attributes & attr)
+void SWKeyFile::HeaderHandler::Start(const XML::Parser::Attributes &attr)
 {
-    // get key type
-    if (attr.find(XML_ATTR_VERSION) != attr.end()) {
-        m_version = atoi(attr.at(XML_ATTR_VERSION).c_str());
+	// get key type
+	if (attr.find(XML_ATTR_VERSION) != attr.end()) {
+		m_version = atoi(attr.at(XML_ATTR_VERSION).c_str());
 
-        if (isCorrectVersion())
-            m_parent.registerElementListeners();
-    }
+		if (isCorrectVersion())
+			m_parent.registerElementListeners();
+	}
 }
 
 bool SWKeyFile::HeaderHandler::isCorrectVersion() const
 {
-    return m_version == XML_SW_KEY_CURRENT_VERSION;
+	return m_version == XML_SW_KEY_CURRENT_VERSION;
 }
 
 }
diff --git a/src/manager/initial-values/SWKeyFile.h b/src/manager/initial-values/SWKeyFile.h
index 8768ade1..e5642857 100644
--- a/src/manager/initial-values/SWKeyFile.h
+++ b/src/manager/initial-values/SWKeyFile.h
@@ -33,62 +33,62 @@
 #include <base64.h>
 #include <generic-backend/gobj.h>
 #include <dpl/log/log.h>
+
 namespace CKM {
 namespace InitialValues {
 
-
 class SWKeyFile {
 public:
-    explicit SWKeyFile(const std::string &XML_filename);
+	explicit SWKeyFile(const std::string &XML_filename);
 
-    int Validate(const std::string &XSD_file);
-    int Parse();
+	int Validate(const std::string &XSD_file);
+	int Parse();
 
-    Crypto::GObjShPtr getPrivKey()
-    {
-        return m_deviceKey;
-    }
+	Crypto::GObjShPtr getPrivKey()
+	{
+		return m_deviceKey;
+	}
 
 private:
-    class HeaderHandler : public XML::Parser::ElementHandler {
-    public:
-        explicit HeaderHandler(SWKeyFile & parent);
-        virtual void Start(const XML::Parser::Attributes & attr);
-        virtual void Characters(const std::string &) {}
-        virtual void End() {}
+	class HeaderHandler : public XML::Parser::ElementHandler {
+	public:
+		explicit HeaderHandler(SWKeyFile &parent);
+		virtual void Start(const XML::Parser::Attributes &attr);
+		virtual void Characters(const std::string &) {}
+		virtual void End() {}
 
-        bool isCorrectVersion() const;
+		bool isCorrectVersion() const;
 
-    private:
-        int m_version;
-        SWKeyFile & m_parent;
-    };
+	private:
+		int m_version;
+		SWKeyFile &m_parent;
+	};
 
-    class RSAKeyHandler : public XML::Parser::ElementHandler {
-    public:
-        explicit RSAKeyHandler(SWKeyFile & parent);
-        virtual void Start(const XML::Parser::Attributes &) {}
-        virtual void Characters(const std::string &data);
-        virtual void End();
+	class RSAKeyHandler : public XML::Parser::ElementHandler {
+	public:
+		explicit RSAKeyHandler(SWKeyFile &parent);
+		virtual void Start(const XML::Parser::Attributes &) {}
+		virtual void Characters(const std::string &data);
+		virtual void End();
 
-        Crypto::GObjShPtr getPrivKey();
+		Crypto::GObjShPtr getPrivKey();
 
-    private:
-        CKM::RawBuffer m_encryptedKey;
-        SWKeyFile & m_parent;
-    };
+	private:
+		CKM::RawBuffer m_encryptedKey;
+		SWKeyFile &m_parent;
+	};
 
-    std::string m_filename;
-    XML::Parser m_parser;
-    typedef std::shared_ptr<HeaderHandler> HeaderHandlerPtr;
-    typedef std::shared_ptr<RSAKeyHandler> RSAKeyHandlerPtr;
-    HeaderHandlerPtr m_header;
-    RSAKeyHandlerPtr m_RSAKeyHandler;
-    Crypto::GObjShPtr m_deviceKey;
+	std::string m_filename;
+	XML::Parser m_parser;
+	typedef std::shared_ptr<HeaderHandler> HeaderHandlerPtr;
+	typedef std::shared_ptr<RSAKeyHandler> RSAKeyHandlerPtr;
+	HeaderHandlerPtr m_header;
+	RSAKeyHandlerPtr m_RSAKeyHandler;
+	Crypto::GObjShPtr m_deviceKey;
 
-    void registerElementListeners();
-    static void Error(const XML::Parser::ErrorType errorType,
-                      const std::string & logMsg);
+	void registerElementListeners();
+	static void Error(const XML::Parser::ErrorType errorType,
+					  const std::string &logMsg);
 };
 
 }
diff --git a/src/manager/initial-values/initial-value-loader.cpp b/src/manager/initial-values/initial-value-loader.cpp
index ac1e4316..4cdfb2d8 100644
--- a/src/manager/initial-values/initial-value-loader.cpp
+++ b/src/manager/initial-values/initial-value-loader.cpp
@@ -26,8 +26,8 @@
 #include <InitialValuesFile.h>
 
 namespace {
-const char * const INIT_VALUES_XSD          = RO_DATA_DIR "/initial_values.xsd";
-const char * const INIT_VALUES_FILE_SUFFIX  = ".xml";
+const char *const INIT_VALUES_XSD          = RO_DATA_DIR "/initial_values.xsd";
+const char *const INIT_VALUES_FILE_SUFFIX  = ".xml";
 } // namespace anonymous
 
 namespace CKM {
@@ -35,35 +35,40 @@ namespace InitialValues {
 
 void LoadFiles(CKMLogic &logic)
 {
-    try {
-        std::vector<std::string> filesToParse;
+	try {
+		std::vector<std::string> filesToParse;
 
-        forEachFile(INITIAL_VALUES_DIR, [&filesToParse](const std::string &filename) {
-            std::string lowercaseFilename = filename;
-            std::transform(lowercaseFilename.begin(), lowercaseFilename.end(), lowercaseFilename.begin(), ::tolower);
+		forEachFile(INITIAL_VALUES_DIR, [&filesToParse](const std::string & filename) {
+			std::string lowercaseFilename = filename;
+			std::transform(lowercaseFilename.begin(), lowercaseFilename.end(),
+						   lowercaseFilename.begin(), ::tolower);
 
-            if (lowercaseFilename.find(INIT_VALUES_FILE_SUFFIX) == std::string::npos)
-                return;
+			if (lowercaseFilename.find(INIT_VALUES_FILE_SUFFIX) == std::string::npos)
+				return;
 
-            filesToParse.emplace_back(std::string(INITIAL_VALUES_DIR) + "/" + filename);
-        });
+			filesToParse.emplace_back(std::string(INITIAL_VALUES_DIR) + "/" + filename);
+		});
 
-        // parse
-        for (const auto & file : filesToParse) {
-            InitialValues::InitialValuesFile xmlFile(file.c_str(), logic);
-            int rc = xmlFile.Validate(INIT_VALUES_XSD);
-            if (rc == XML::Parser::PARSE_SUCCESS) {
-                rc = xmlFile.Parse();
-                if (rc != XML::Parser::PARSE_SUCCESS)
-                    LogError("invalid initial values file: " << file << ", parsing code: " << rc);
-            } else {
-                LogError("invalid initial values file: " << file << ", validation code: " << rc);
-            }
-            unlink(file.c_str());
-        }
-    } catch (...) {
-        LogError("The implementation of exception handling in xml parser is broken!");
-    }
+		// parse
+		for (const auto &file : filesToParse) {
+			InitialValues::InitialValuesFile xmlFile(file.c_str(), logic);
+			int rc = xmlFile.Validate(INIT_VALUES_XSD);
+
+			if (rc == XML::Parser::PARSE_SUCCESS) {
+				rc = xmlFile.Parse();
+
+				if (rc != XML::Parser::PARSE_SUCCESS)
+					LogError("invalid initial values file: " << file << ", parsing code: " << rc);
+			} else {
+				LogError("invalid initial values file: " << file << ", validation code: " <<
+						 rc);
+			}
+
+			unlink(file.c_str());
+		}
+	} catch (...) {
+		LogError("The implementation of exception handling in xml parser is broken!");
+	}
 }
 
 } // namespace InitialValues
diff --git a/src/manager/initial-values/parser.cpp b/src/manager/initial-values/parser.cpp
index 170e9b52..6b393d4b 100644
--- a/src/manager/initial-values/parser.cpp
+++ b/src/manager/initial-values/parser.cpp
@@ -37,207 +37,238 @@ namespace XML {
 namespace {
 
 struct LibXmlCleanup {
-    ~LibXmlCleanup() { xmlCleanupParser(); }
+	~LibXmlCleanup()
+	{
+		xmlCleanupParser();
+	}
 } cleanup;
 
 } // namespace anonymous
 
 Parser::Parser(const std::string &XML_filename) :
-    m_errorCb(0)
+	m_errorCb(0)
 {
-    m_XMLfile = XML_filename;
-    memset(&m_saxHandler, 0, sizeof(m_saxHandler));
-    m_saxHandler.startElement = &Parser::StartElement;
-    m_saxHandler.endElement = &Parser::EndElement;
-    m_saxHandler.characters = &Parser::Characters;
-    m_saxHandler.error = &Parser::Error;
-    m_saxHandler.warning = &Parser::Warning;
+	m_XMLfile = XML_filename;
+	memset(&m_saxHandler, 0, sizeof(m_saxHandler));
+	m_saxHandler.startElement = &Parser::StartElement;
+	m_saxHandler.endElement = &Parser::EndElement;
+	m_saxHandler.characters = &Parser::Characters;
+	m_saxHandler.error = &Parser::Error;
+	m_saxHandler.warning = &Parser::Warning;
 }
 Parser::~Parser()
 {
 }
 
+using SchemaParserCtxt =
+	std::unique_ptr<xmlSchemaParserCtxt, void(*)(xmlSchemaParserCtxtPtr)>;
+using Schema = std::unique_ptr<xmlSchema, void(*)(xmlSchemaPtr)>;
+using SchemaValidCtxt =
+	std::unique_ptr<xmlSchemaValidCtxt, void(*)(xmlSchemaValidCtxtPtr)>;
 int Parser::Validate(const std::string &XSD_schema)
 {
-    if (XSD_schema.empty()) {
-        LogError("no XSD file path given");
-        return ERROR_INVALID_ARGUMENT;
-    }
-
-    int retCode;
-    std::unique_ptr<xmlSchemaParserCtxt, void(*)(xmlSchemaParserCtxtPtr)>
-            parserCtxt(xmlSchemaNewParserCtxt(XSD_schema.c_str()),
-                       [](xmlSchemaParserCtxtPtr ctx){ xmlSchemaFreeParserCtxt(ctx); });
-    if (!parserCtxt) {
-        LogError("XSD file path is invalid");
-        return ERROR_INVALID_ARGUMENT;
-    }
-
-    std::unique_ptr<xmlSchema, void(*)(xmlSchemaPtr)>
-        schema(xmlSchemaParse(parserCtxt.get()),
-                       [](xmlSchemaPtr schemaPtr){ xmlSchemaFree(schemaPtr); });
-    if (!schema) {
-        LogError("Parsing XSD file failed");
-        return ERROR_XSD_PARSE_FAILED;
-    }
-
-
-    std::unique_ptr<xmlSchemaValidCtxt, void(*)(xmlSchemaValidCtxtPtr)>
-        validCtxt(xmlSchemaNewValidCtxt(schema.get()),
-                       [](xmlSchemaValidCtxtPtr validCtxPtr){ xmlSchemaFreeValidCtxt(validCtxPtr); });
-    if (!validCtxt) {
-        LogError("Internal parser error");
-        return ERROR_INTERNAL;
-    }
-
-    xmlSetStructuredErrorFunc(NULL, NULL);
-    xmlSetGenericErrorFunc(this, &Parser::ErrorValidate);
-    xmlThrDefSetStructuredErrorFunc(NULL, NULL);
-    xmlThrDefSetGenericErrorFunc(this, &Parser::ErrorValidate);
-
-    retCode = xmlSchemaValidateFile(validCtxt.get(), m_XMLfile.c_str(), 0);
-    if (0 != retCode) {
-        LogWarning("Validating XML file failed, ec: " << retCode);
-        retCode = ERROR_XML_VALIDATION_FAILED;
-    } else {
-        retCode = PARSE_SUCCESS;
-    }
-
-    return retCode;
+	if (XSD_schema.empty()) {
+		LogError("no XSD file path given");
+		return ERROR_INVALID_ARGUMENT;
+	}
+
+	int retCode;
+	SchemaParserCtxt parserCtxt(xmlSchemaNewParserCtxt(XSD_schema.c_str()),
+	[](xmlSchemaParserCtxtPtr ctx) {
+		xmlSchemaFreeParserCtxt(ctx);
+	});
+
+	if (!parserCtxt) {
+		LogError("XSD file path is invalid");
+		return ERROR_INVALID_ARGUMENT;
+	}
+
+	Schema schema(xmlSchemaParse(parserCtxt.get()), [](xmlSchemaPtr schemaPtr) {
+		xmlSchemaFree(schemaPtr);
+	});
+
+	if (!schema) {
+		LogError("Parsing XSD file failed");
+		return ERROR_XSD_PARSE_FAILED;
+	}
+
+	SchemaValidCtxt validCtxt(xmlSchemaNewValidCtxt(schema.get()), [](
+	xmlSchemaValidCtxtPtr validCtxPtr) {
+		xmlSchemaFreeValidCtxt(validCtxPtr);
+	});
+
+	if (!validCtxt) {
+		LogError("Internal parser error");
+		return ERROR_INTERNAL;
+	}
+
+	xmlSetStructuredErrorFunc(NULL, NULL);
+	xmlSetGenericErrorFunc(this, &Parser::ErrorValidate);
+	xmlThrDefSetStructuredErrorFunc(NULL, NULL);
+	xmlThrDefSetGenericErrorFunc(this, &Parser::ErrorValidate);
+
+	retCode = xmlSchemaValidateFile(validCtxt.get(), m_XMLfile.c_str(), 0);
+
+	if (0 != retCode) {
+		LogWarning("Validating XML file failed, ec: " << retCode);
+		retCode = ERROR_XML_VALIDATION_FAILED;
+	} else {
+		retCode = PARSE_SUCCESS;
+	}
+
+	return retCode;
 }
 
 int Parser::Parse()
 {
-    if (m_elementListenerMap.empty()) {
-        LogError("Can not parse XML file: no registered element callbacks.");
-        return ERROR_INVALID_ARGUMENT;
-    }
-    int retCode = xmlSAXUserParseFile(&m_saxHandler, this, m_XMLfile.c_str());
-    if (0 != retCode) {
-        LogWarning("Parsing XML file failed, ec: " << retCode);
-        return ERROR_XML_PARSE_FAILED;
-    }
-    // if error detected while parsing
-    if (m_elementListenerMap.empty()) {
-        LogError("Critical error detected while parsing.");
-        return ERROR_INTERNAL;
-    }
-    return PARSE_SUCCESS;
+	if (m_elementListenerMap.empty()) {
+		LogError("Can not parse XML file: no registered element callbacks.");
+		return ERROR_INVALID_ARGUMENT;
+	}
+
+	int retCode = xmlSAXUserParseFile(&m_saxHandler, this, m_XMLfile.c_str());
+
+	if (0 != retCode) {
+		LogWarning("Parsing XML file failed, ec: " << retCode);
+		return ERROR_XML_PARSE_FAILED;
+	}
+
+	// if error detected while parsing
+	if (m_elementListenerMap.empty()) {
+		LogError("Critical error detected while parsing.");
+		return ERROR_INTERNAL;
+	}
+
+	return PARSE_SUCCESS;
 }
 
 int Parser::RegisterErrorCb(const ErrorCb newCb)
 {
-    if (m_errorCb) {
-        LogError("Callback already registered!");
-        return ERROR_CALLBACK_PRESENT;
-    }
-    m_errorCb = newCb;
-    return PARSE_SUCCESS;
+	if (m_errorCb) {
+		LogError("Callback already registered!");
+		return ERROR_CALLBACK_PRESENT;
+	}
+
+	m_errorCb = newCb;
+	return PARSE_SUCCESS;
 }
 
-int Parser::RegisterElementCb(const char * elementName,
-                              const StartCb startCb,
-                              const EndCb endCb)
+int Parser::RegisterElementCb(const char *elementName,
+							  const StartCb startCb,
+							  const EndCb endCb)
 {
-    if (!elementName)
-        return ERROR_INVALID_ARGUMENT;
+	if (!elementName)
+		return ERROR_INVALID_ARGUMENT;
 
-    std::string key(elementName);
+	std::string key(elementName);
 
-    if (m_elementListenerMap.find(elementName) != m_elementListenerMap.end()) {
-        LogError("Callback for element " << elementName << " already registered!");
-        return ERROR_CALLBACK_PRESENT;
-    }
+	if (m_elementListenerMap.find(elementName) != m_elementListenerMap.end()) {
+		LogError("Callback for element " << elementName << " already registered!");
+		return ERROR_CALLBACK_PRESENT;
+	}
 
-    m_elementListenerMap[key] = {startCb, endCb};
-    return PARSE_SUCCESS;
+	m_elementListenerMap[key] = {startCb, endCb};
+	return PARSE_SUCCESS;
 }
 
 void Parser::StartElement(const xmlChar *name,
-                          const xmlChar **attrs)
+						  const xmlChar **attrs)
 {
-    std::string key(reinterpret_cast<const char*>(name));
-    if (m_elementListenerMap.find(key) == m_elementListenerMap.end())
-        return;
-
-    ElementHandlerPtr newHandler;
-    const ElementListener & current = m_elementListenerMap[key];
-    if (current.startCb) {
-        Attributes attribs;
-        {
-            size_t numAttrs = 0;
-            std::string key;
-            while (attrs && attrs[numAttrs]) {
-                const char *attrChr = reinterpret_cast<const char*>(attrs[numAttrs]);
-                if ((numAttrs%2) == 0)
-                    key = std::string(attrChr);
-                else
-                    attribs[key] = std::string(attrChr);
-                numAttrs++;
-            }
-        }
-
-        newHandler = current.startCb();
-        if (newHandler)
-            newHandler->Start(attribs);
-    }
-    // always put a handler, even if it's empty. This will not break
-    // the sequence of queued elements when popping from the queue.
-    m_elementHandlerStack.push(newHandler);
+	std::string key(reinterpret_cast<const char *>(name));
+
+	if (m_elementListenerMap.find(key) == m_elementListenerMap.end())
+		return;
+
+	ElementHandlerPtr newHandler;
+	const ElementListener &current = m_elementListenerMap[key];
+
+	if (current.startCb) {
+		Attributes attribs;
+
+		size_t numAttrs = 0;
+		std::string _key;
+
+		while (attrs && attrs[numAttrs]) {
+			const char *attrChr = reinterpret_cast<const char *>(attrs[numAttrs]);
+
+			if ((numAttrs % 2) == 0)
+				_key = std::string(attrChr);
+			else
+				attribs[_key] = std::string(attrChr);
+
+			numAttrs++;
+		}
+
+		newHandler = current.startCb();
+
+		if (newHandler)
+			newHandler->Start(attribs);
+	}
+
+	// always put a handler, even if it's empty. This will not break
+	// the sequence of queued elements when popping from the queue.
+	m_elementHandlerStack.push(newHandler);
 }
 
 void Parser::EndElement(const xmlChar *name)
 {
-    std::string key(reinterpret_cast<const char*>(name));
-    if (m_elementListenerMap.find(key) == m_elementListenerMap.end())
-        return;
+	std::string key(reinterpret_cast<const char *>(name));
+
+	if (m_elementListenerMap.find(key) == m_elementListenerMap.end())
+		return;
 
-    // this should never ever happen
-    if (m_elementHandlerStack.empty())
-        throw std::runtime_error("internal error: element queue desynchronized!");
+	// this should never ever happen
+	if (m_elementHandlerStack.empty())
+		throw std::runtime_error("internal error: element queue desynchronized!");
 
-    ElementHandlerPtr &currentHandler = m_elementHandlerStack.top();
-    if (currentHandler)
-        currentHandler->End();
+	ElementHandlerPtr &currentHandler = m_elementHandlerStack.top();
 
-    const ElementListener & current = m_elementListenerMap[key];
-    if (current.endCb)
-        current.endCb(currentHandler);
+	if (currentHandler)
+		currentHandler->End();
 
-    m_elementHandlerStack.pop();
+	const ElementListener &current = m_elementListenerMap[key];
+
+	if (current.endCb)
+		current.endCb(currentHandler);
+
+	m_elementHandlerStack.pop();
 }
 
 void Parser::Characters(const xmlChar *ch, size_t chLen)
 {
-    std::string chars(reinterpret_cast<const char*>(ch), chLen);
-    if (chars.empty())
-        return;
-
-    if (!m_elementHandlerStack.empty()) {
-        ElementHandlerPtr &currentHandler = m_elementHandlerStack.top();
-        if (currentHandler)
-            currentHandler->Characters(chars);
-    }
+	std::string chars(reinterpret_cast<const char *>(ch), chLen);
+
+	if (chars.empty())
+		return;
+
+	if (!m_elementHandlerStack.empty()) {
+		ElementHandlerPtr &currentHandler = m_elementHandlerStack.top();
+
+		if (currentHandler)
+			currentHandler->Characters(chars);
+	}
 }
 
 void Parser::Error(const ErrorType errorType, const char *msg, va_list &args)
 {
-    if (!m_errorCb)
-        return;
-
-    va_list args2;
-    try {
-        va_copy(args2, args);
-        std::vector<char> buf(1 + std::vsnprintf(NULL, 0, msg, args));
-        std::vsnprintf(buf.data(), buf.size(), msg, args2);
-        m_errorCb(errorType, trim(std::string(buf.begin(), buf.end())));
-    } catch (...) {
-        LogError("Error callback throwed an exception.");
-        // if an error handler throwed exception,
-        // do not call further callbacks
-        m_elementListenerMap.clear();
-    }
-    va_end(args2);
+	if (!m_errorCb)
+		return;
+
+	va_list args2;
+
+	try {
+		va_copy(args2, args);
+		std::vector<char> buf(1 + std::vsnprintf(NULL, 0, msg, args));
+		std::vsnprintf(buf.data(), buf.size(), msg, args2);
+		m_errorCb(errorType, trim(std::string(buf.begin(), buf.end())));
+	} catch (...) {
+		LogError("Error callback throwed an exception.");
+		// if an error handler throwed exception,
+		// do not call further callbacks
+		m_elementListenerMap.clear();
+	}
+
+	va_end(args2);
 }
 
 //
@@ -245,73 +276,76 @@ void Parser::Error(const ErrorType errorType, const char *msg, va_list &args)
 //
 void Parser::CallbackHelper(std::function<void(void)> func)
 {
-    try {
-        func();
-        return;
-    } catch (const std::exception &e) {
-        LogError("parser error: " << e.what());
-        if (m_errorCb)
-            m_errorCb(PARSE_ERROR, e.what());
-    } catch (...) {
-        LogError("unknown parser error");
-        if (m_errorCb)
-            m_errorCb(PARSE_ERROR, "unknown parser error");
-    }
-    // raise error flag - unregister listeners
-    m_elementListenerMap.clear();
+	try {
+		func();
+		return;
+	} catch (const std::exception &e) {
+		LogError("parser error: " << e.what());
+
+		if (m_errorCb)
+			m_errorCb(PARSE_ERROR, e.what());
+	} catch (...) {
+		LogError("unknown parser error");
+
+		if (m_errorCb)
+			m_errorCb(PARSE_ERROR, "unknown parser error");
+	}
+
+	// raise error flag - unregister listeners
+	m_elementListenerMap.clear();
 }
 void Parser::StartElement(void *userData,
-                          const xmlChar *name,
-                          const xmlChar **attrs)
+						  const xmlChar *name,
+						  const xmlChar **attrs)
 {
-    Parser *parser = static_cast<Parser *>(userData);
-    parser->CallbackHelper([&parser, &name, &attrs] { parser->StartElement(name, attrs); });
+	Parser *parser = static_cast<Parser *>(userData);
+	parser->CallbackHelper([&parser, &name, &attrs] { parser->StartElement(name, attrs); });
 }
 void Parser::EndElement(void *userData,
-                        const xmlChar *name)
+						const xmlChar *name)
 {
-    Parser *parser = static_cast<Parser *>(userData);
-    parser->CallbackHelper([&parser, &name] { parser->EndElement(name); });
+	Parser *parser = static_cast<Parser *>(userData);
+	parser->CallbackHelper([&parser, &name] { parser->EndElement(name); });
 }
 void Parser::Characters(void *userData,
-                        const xmlChar *ch,
-                        int len)
+						const xmlChar *ch,
+						int len)
 {
-    Parser *parser = static_cast<Parser *>(userData);
-    parser->CallbackHelper([&parser, &ch, &len] { parser->Characters(ch, static_cast<size_t>(len)); });
+	Parser *parser = static_cast<Parser *>(userData);
+	parser->CallbackHelper([&parser, &ch, &len] { parser->Characters(ch, static_cast<size_t>(len)); });
 }
 
 void Parser::ErrorValidate(void *userData,
-                           const char *msg,
-                           ...)
+						   const char *msg,
+						   ...)
 {
-    va_list args;
-    va_start(args, msg);
-    Parser *parser = static_cast<Parser *>(userData);
-    parser->Error(VALIDATION_ERROR, msg, args);
-    va_end(args);
+	va_list args;
+	va_start(args, msg);
+	Parser *parser = static_cast<Parser *>(userData);
+	parser->Error(VALIDATION_ERROR, msg, args);
+	va_end(args);
 }
 
 void Parser::Error(void *userData,
-                   const char *msg,
-                   ...)
+				   const char *msg,
+				   ...)
 {
-    va_list args;
-    va_start(args, msg);
-    Parser *parser = static_cast<Parser *>(userData);
-    parser->Error(PARSE_ERROR, msg, args);
-    va_end(args);
+	va_list args;
+	va_start(args, msg);
+	Parser *parser = static_cast<Parser *>(userData);
+	parser->Error(PARSE_ERROR, msg, args);
+	va_end(args);
 }
 
 void Parser::Warning(void *userData,
-                     const char *msg,
-                     ...)
+					 const char *msg,
+					 ...)
 {
-    va_list args;
-    va_start(args, msg);
-    Parser &parser = *(static_cast<Parser *>(userData));
-    parser.Error(PARSE_WARNING, msg, args);
-    va_end(args);
+	va_list args;
+	va_start(args, msg);
+	Parser &parser = *(static_cast<Parser *>(userData));
+	parser.Error(PARSE_WARNING, msg, args);
+	va_end(args);
 }
 //
 // -------------------------- end of static wrappers --------------------------
diff --git a/src/manager/initial-values/parser.h b/src/manager/initial-values/parser.h
index ab80f0eb..072b911a 100644
--- a/src/manager/initial-values/parser.h
+++ b/src/manager/initial-values/parser.h
@@ -37,92 +37,92 @@ namespace XML {
 
 class Parser {
 public:
-    enum ErrorCode {
-        PARSE_SUCCESS                  =   0,
-        ERROR_UNKNOWN                  =   -1000,
-        ERROR_XML_VALIDATION_FAILED    =   -1001,
-        ERROR_XSD_PARSE_FAILED         =   -1002,
-        ERROR_XML_PARSE_FAILED         =   -1003,
-        ERROR_INVALID_ARGUMENT         =   -1004,
-        ERROR_CALLBACK_PRESENT         =   -1005,
-        ERROR_INVALID_VERSION          =   -1006,
-        ERROR_INTERNAL                 =   -1007,
-        ERROR_NO_MEMORY                =   -1008
-    };
-
-    explicit Parser(const std::string &XML_filename);
-    virtual ~Parser();
-
-    int Validate(const std::string &XSD_schema);
-    int Parse();
-
-    enum ErrorType {
-        VALIDATION_ERROR,
-        PARSE_ERROR,
-        PARSE_WARNING
-    };
-    typedef std::function<void (const ErrorType, const std::string &)> ErrorCb;
-    int RegisterErrorCb(const ErrorCb newCb);
-
-    typedef std::map<std::string, std::string> Attributes;
-    class ElementHandler {
-    public:
-        virtual ~ElementHandler() {}
-
-        // methods below may throw std::exception to invalidate the parsing process
-        // and remove all element listeners.
-        // In this case, parsing error code returned to the user after std::exception.
-        virtual void Start(const Attributes &) = 0;
-        virtual void Characters(const std::string & data) = 0;
-        virtual void End() = 0;
-    };
-    typedef std::shared_ptr<ElementHandler> ElementHandlerPtr;
-
-    typedef std::function<ElementHandlerPtr ()> StartCb;
-    typedef std::function<void (const ElementHandlerPtr &)> EndCb;
-    int RegisterElementCb(const char * elementName,
-                          const StartCb startCb,
-                          const EndCb endCb);
+	enum ErrorCode {
+		PARSE_SUCCESS                  =   0,
+		ERROR_UNKNOWN                  =   -1000,
+		ERROR_XML_VALIDATION_FAILED    =   -1001,
+		ERROR_XSD_PARSE_FAILED         =   -1002,
+		ERROR_XML_PARSE_FAILED         =   -1003,
+		ERROR_INVALID_ARGUMENT         =   -1004,
+		ERROR_CALLBACK_PRESENT         =   -1005,
+		ERROR_INVALID_VERSION          =   -1006,
+		ERROR_INTERNAL                 =   -1007,
+		ERROR_NO_MEMORY                =   -1008
+	};
+
+	explicit Parser(const std::string &XML_filename);
+	virtual ~Parser();
+
+	int Validate(const std::string &XSD_schema);
+	int Parse();
+
+	enum ErrorType {
+		VALIDATION_ERROR,
+		PARSE_ERROR,
+		PARSE_WARNING
+	};
+	typedef std::function<void (const ErrorType, const std::string &)> ErrorCb;
+	int RegisterErrorCb(const ErrorCb newCb);
+
+	typedef std::map<std::string, std::string> Attributes;
+	class ElementHandler {
+	public:
+		virtual ~ElementHandler() {}
+
+		// methods below may throw std::exception to invalidate the parsing process
+		// and remove all element listeners.
+		// In this case, parsing error code returned to the user after std::exception.
+		virtual void Start(const Attributes &) = 0;
+		virtual void Characters(const std::string &data) = 0;
+		virtual void End() = 0;
+	};
+	typedef std::shared_ptr<ElementHandler> ElementHandlerPtr;
+
+	typedef std::function<ElementHandlerPtr()> StartCb;
+	typedef std::function<void (const ElementHandlerPtr &)> EndCb;
+	int RegisterElementCb(const char *elementName,
+						  const StartCb startCb,
+						  const EndCb endCb);
 
 protected:
-    void StartElement(const xmlChar *name,
-                      const xmlChar **attrs);
-    void EndElement(const xmlChar *name);
-    void Characters(const xmlChar *ch, size_t chLen);
-    void Error(const ErrorType errorType, const char *msg, va_list &);
+	void StartElement(const xmlChar *name,
+					  const xmlChar **attrs);
+	void EndElement(const xmlChar *name);
+	void Characters(const xmlChar *ch, size_t chLen);
+	void Error(const ErrorType errorType, const char *msg, va_list &);
 
 private:
-    static void StartElement(void *userData,
-                             const xmlChar *name,
-                             const xmlChar **attrs);
-    static void EndElement(void *userData,
-                           const xmlChar *name);
-    static void Characters(void *userData,
-                           const xmlChar *ch,
-                           int len);
-    static void ErrorValidate(void *userData,
-                              const char *msg,
-                              ...);
-    static void Error(void *userData,
-                      const char *msg,
-                      ...);
-    static void Warning(void *userData,
-                        const char *msg,
-                        ...);
+	static void StartElement(void *userData,
+							 const xmlChar *name,
+							 const xmlChar **attrs);
+	static void EndElement(void *userData,
+						   const xmlChar *name);
+	static void Characters(void *userData,
+						   const xmlChar *ch,
+						   int len);
+	static void ErrorValidate(void *userData,
+							  const char *msg,
+							  ...);
+	static void Error(void *userData,
+					  const char *msg,
+					  ...);
+	static void Warning(void *userData,
+						const char *msg,
+						...);
 
 private:
-    xmlSAXHandler           m_saxHandler;
-    std::string             m_XMLfile;
-    ErrorCb                 m_errorCb;
-
-    struct ElementListener {
-        StartCb     startCb;
-        EndCb       endCb;
-    };
-    std::map<std::string, ElementListener> m_elementListenerMap;
-    std::stack<ElementHandlerPtr> m_elementHandlerStack;
-
-    void CallbackHelper(std::function<void(void)> func);
+	xmlSAXHandler           m_saxHandler;
+	std::string             m_XMLfile;
+	ErrorCb                 m_errorCb;
+
+	struct ElementListener {
+		StartCb     startCb;
+		EndCb       endCb;
+	};
+	std::map<std::string, ElementListener> m_elementListenerMap;
+	std::stack<ElementHandlerPtr> m_elementHandlerStack;
+
+	void CallbackHelper(std::function<void(void)> func);
 };
 
 }
diff --git a/src/manager/initial-values/xml-utils.cpp b/src/manager/initial-values/xml-utils.cpp
index e7a3a909..5e10b432 100644
--- a/src/manager/initial-values/xml-utils.cpp
+++ b/src/manager/initial-values/xml-utils.cpp
@@ -26,24 +26,24 @@
 #include <xml-utils.h>
 
 namespace {
-const char * const WHITESPACE       = " \n\r\t\v";
-const char * const LINE_WHITESPACE  = " \r\t\v";
+const char *const WHITESPACE       = " \n\r\t\v";
+const char *const LINE_WHITESPACE  = " \r\t\v";
 
-std::string trim_left(const std::string& s, const char *whitespaces)
+std::string trim_left(const std::string &s, const char *whitespaces)
 {
-    size_t startpos = s.find_first_not_of(whitespaces);
-    return (startpos == std::string::npos) ? "" : s.substr(startpos);
+	size_t startpos = s.find_first_not_of(whitespaces);
+	return (startpos == std::string::npos) ? "" : s.substr(startpos);
 }
 
-std::string trim_right(const std::string& s, const char *whitespaces)
+std::string trim_right(const std::string &s, const char *whitespaces)
 {
-    size_t endpos = s.find_last_not_of(whitespaces);
-    return (endpos == std::string::npos) ? "" : s.substr(0, endpos+1);
+	size_t endpos = s.find_last_not_of(whitespaces);
+	return (endpos == std::string::npos) ? "" : s.substr(0, endpos + 1);
 }
 
-std::string trim(const std::string& s, const char *whitespaces)
+std::string trim(const std::string &s, const char *whitespaces)
 {
-    return trim_right(trim_left(s, whitespaces), whitespaces);
+	return trim_right(trim_left(s, whitespaces), whitespaces);
 }
 
 }
@@ -52,45 +52,46 @@ namespace CKM {
 namespace XML {
 
 template <typename T>
-T removeChars(const T& input, const char *what)
+T removeChars(const T &input, const char *what)
 {
-    T out(input);
-    auto endit = std::remove_if(out.begin(), out.end(),
-        [what](char c)
-        {
-            for (const char *ptr = what; *ptr; ++ptr)
-                if (*ptr == c)
-                    return true;
-            return false;
-        });
-
-    out.erase(endit, out.end());
-    return out;
+	T out(input);
+	auto endit = std::remove_if(out.begin(), out.end(),
+	[what](char c) {
+		for (const char *ptr = what; *ptr; ++ptr)
+			if (*ptr == c)
+				return true;
+
+		return false;
+	});
+
+	out.erase(endit, out.end());
+	return out;
 }
 
 RawBuffer removeWhiteChars(const RawBuffer &buffer)
 {
-    return removeChars(buffer, WHITESPACE);
+	return removeChars(buffer, WHITESPACE);
 }
 
-std::string trimEachLine(const std::string& input)
+std::string trimEachLine(const std::string &input)
 {
-    std::stringstream ss(input);
-    std::stringstream output;
-    std::string line;
+	std::stringstream ss(input);
+	std::stringstream output;
+	std::string line;
 
-    while (std::getline(ss, line, '\n')) {
-        auto afterTrim = ::trim(line, LINE_WHITESPACE);
-        if (!afterTrim.empty())
-            output << afterTrim << std::endl;
-    }
+	while (std::getline(ss, line, '\n')) {
+		auto afterTrim = ::trim(line, LINE_WHITESPACE);
 
-    return output.str();
+		if (!afterTrim.empty())
+			output << afterTrim << std::endl;
+	}
+
+	return output.str();
 }
 
 std::string trim(const std::string &s)
 {
-    return removeChars(s, WHITESPACE);
+	return removeChars(s, WHITESPACE);
 }
 
 } // namespace XML
diff --git a/src/manager/initial-values/xml-utils.h b/src/manager/initial-values/xml-utils.h
index 94385954..cd7cdd39 100644
--- a/src/manager/initial-values/xml-utils.h
+++ b/src/manager/initial-values/xml-utils.h
@@ -29,7 +29,7 @@ namespace CKM {
 namespace XML {
 
 RawBuffer removeWhiteChars(const RawBuffer &buffer);
-std::string trim(const std::string& s);
+std::string trim(const std::string &s);
 std::string trimEachLine(const std::string &s);
 
 }