From: hb.min Date: Sun, 14 Apr 2013 08:43:17 +0000 (+0900) Subject: Add privilege-checker for Add-On SDK X-Git-Tag: submit/tizen/20130828.070518^2~13 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=1cd917af5bec3fe7310b2bff925fcb73822c32e0;p=platform%2Fcore%2Fsecurity%2Fprivilege-checker.git Add privilege-checker for Add-On SDK Change-Id: Icf786d58c13a489e0e9ca7710c2910da21b5afe2 Signed-off-by: hb.min --- diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..37cd985 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,73 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +PROJECT(privilege-checker) + +MESSAGE("build privilege-checker") + +SET(CMAKE_VERBOSE_MAKEFILE OFF) + +SET(CMAKE_INSTALL_PREFIX /usr) +SET(PREFIX ${CMAKE_INSTALL_PREFIX}) +SET(EXEC_PREFIX "\${prefix}") +SET(LIBDIR "\${prefix}/lib") +SET(INCLUDEDIR "\${prefix}/include") +SET(VERSION 0.0) + +SET(VERSION_MAJOR 0) +SET(VERSION "${VERSION_MAJOR}.0.1") + +INCLUDE(FindPkgConfig) +pkg_check_modules(pkgs REQUIRED + dlog + sqlite3 + libwbxml2 + glib-2.0 + ) + +FOREACH(flag ${pkgs_CFLAGS}) + SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") +ENDFOREACH(flag) + +SET(CMAKE_C_FLAGS_PROFILING " -g -pg") +SET(CMAKE_CXX_FLAGS_PROFILING " -std=c++0x -g -pg") +SET(CMAKE_C_FLAGS_DEBUG " -g") +SET(CMAKE_CXX_FLAGS_DEBUG " -std=c++0x -g") +SET(CMAKE_C_FLAGS_RELEASE " -g") +SET(CMAKE_CXX_FLAGS_RELEASE " -std=c++0x -g") +SET(CMAKE_C_FLAGS_CCOV " -g --coverage") +SET(CMAKE_CXX_FLAGS_CCOV " -std=c++0x -g --coverage") + +SET(src_dir "${CMAKE_SOURCE_DIR}/src") +SET(include_dir "${CMAKE_SOURCE_DIR}/include") +SET(xml_include_dir "/usr/include/libxml2") + +## Additional flag +ADD_DEFINITIONS("-fvisibility=hidden") +ADD_DEFINITIONS("-Wall -Werror") +ADD_DEFINITIONS("-DDLOG_ERROR_ENABLED") + +################################################################################################### +## for privilege-checker (executable) +INCLUDE_DIRECTORIES( + ${pkgs_INCLUDE_DIRS} + ${include_dir} + ${xml_include_dir} + ) +SET(PRIVILEGE_CHECKER_SOURCES + ${src_dir}/Parser.cpp + ${src_dir}/Main.cpp + ${src_dir}/Util.cpp + ${src_dir}/DbManager.cpp + ) +SET(PRIVILEGE_CHECKER_HEADERS +) +SET(PRIVILEGE_CHECKER_LDFLAGS " -module -avoid-version ") + +SET(PRIVILEGE_CHECKER_CFLAGS " ${CFLAGS} -fPIC ") + +ADD_DEFINITIONS("-DLOG_TAG=\"PRIVILEGE_CHECKER\"") +ADD_EXECUTABLE(privilege-checker ${PRIVILEGE_CHECKER_SOURCES}) +TARGET_LINK_LIBRARIES(privilege-checker ${pkgs_LDFLAGS} ${pkgs_LIBRARIES}) +SET_TARGET_PROPERTIES(privilege-checker PROPERTIES COMPILE_FLAGS "${PRIVILEGE_CHECKER_CFLAGS}") +################################################################################################### + +INSTALL(TARGETS privilege-checker DESTINATION bin) diff --git a/LICENSE.APLv2 b/LICENSE.APLv2 new file mode 100644 index 0000000..a795f06 --- /dev/null +++ b/LICENSE.APLv2 @@ -0,0 +1,204 @@ +Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/include/CheckerTypes.h b/include/CheckerTypes.h new file mode 100644 index 0000000..99fd2e0 --- /dev/null +++ b/include/CheckerTypes.h @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _PRIVIELG_CHECKER_TYPES_H_ +#define _PRIVIELG_CHECKER_TYPES_H_ + +#include +#include + +typedef struct _stringIfo +{ + xmlChar* pModule; + xmlChar* pNameId; + xmlChar* pDescId; +}StringInfo; + +typedef struct _privilegeInfo +{ + xmlChar* pId; + xmlChar* pPrivacy; + xmlChar* pPrivilegeLevel; + + StringInfo* pStringInfo; + +}PrivilegeInfo; + +typedef struct _privacyInfo +{ + xmlChar* pId; + StringInfo* pStringInfo; + +}PrivacyInfo; + + +enum { + PRIV_CHECKER_SUCCESS = 0, + PRIV_CHECKER_ERROR_XML_ERROR, + PRIV_CHECKER_ERROR_INVALID_ARG, + PRIV_CHECKER_ERROR_OUT_OF_MEMORY, + PRIV_CHECKER_ERROR_IO_ERROR, + PRIV_CHECKER_ERROR_NO_DATA, + PRIV_CHECKER_ERROR_DB_ERROR, + PRIV_CHECKER_ERROR_SYSTEM_ERROR, + PRIV_CHECKER_ERROR_UNKNOW, +}; + +const int MATCHED = 0; + +#endif //_PRIVIELG_CHECKER_TYPES_H_ diff --git a/include/DbManager.h b/include/DbManager.h new file mode 100644 index 0000000..6403a70 --- /dev/null +++ b/include/DbManager.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _PRIVILEGE_CHECKER_DB_MANAGER_H_ +#define _PRIVILEGE_CHECKER_DB_MANAGER_H_ + +#include +#include + +class DbManager +{ + +public: + static int InsertPrivacy(const PrivacyInfo* pPrivacyInfo); + static int InsertPrivilege(const PrivilegeInfo* pPrivilegeInfo); +private: + static int DeletePrivacy(const PrivacyInfo* pPrivacyInfo); + static int DeletePrivilege(const PrivilegeInfo* pPrivilegeInfo); + +}; + +#endif // _PRIVILEGE_CHECKER_DB_MANAGER_H_ diff --git a/include/Parser.h b/include/Parser.h new file mode 100644 index 0000000..87a3bab --- /dev/null +++ b/include/Parser.h @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _PRIVILEGE_CHECKER_PARSER_H_ +#define _PRIVILEGE_CHECKER_PARSER_H_ + +#include +#include +#include +#include +#include + +#include + +class Parser +{ + +public: + static int ParseExtendedPolicy(char *docName); + +private: + static int SetPrivilegeDb(PrivilegeInfo* pPrivilegeInfo); + static int SetPrivacyDb(PrivacyInfo* pPrivilegeInfo); + static int ParseStringInfo (xmlDocPtr stringInfoDoc, xmlNodePtr currentDoc, StringInfo** ppStringInfo); + static int ParsePrivilege (xmlDocPtr privilegeDoc, xmlNodePtr currentDoc); + static int ParsePrivilegeList (xmlDocPtr privilegeListDoc, xmlNodePtr currentDoc); + static int ParsePrivacyList (xmlDocPtr privacyListDoc, xmlNodePtr currentDoc); + +}; + +#endif // _PRIVILEGE_CHECKER_PARSER_H_ diff --git a/include/Util.h b/include/Util.h new file mode 100644 index 0000000..59d29fd --- /dev/null +++ b/include/Util.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef _UTILS_H_ +#define _UTILS_H_ + +#include +#include +#include +#include +#include +#include +#include +#include + +#define TryCatch(condition, expr, ...) \ + if (!(condition)) { \ + LOGE(__VA_ARGS__); \ + expr; \ + goto CATCH; \ + } else {;} + + +#define TryReturn(condition, expr, r, ...) \ + if ( !(condition) ) { \ + LOGE(__VA_ARGS__); \ + expr; \ + return r; \ + } else {;} + +auto StmtDeleter = [&](sqlite3_stmt* pPtr) { LOGI("sqlite3_finalize"); sqlite3_reset (pPtr); sqlite3_finalize(pPtr); }; +auto DbDeleter = [&](sqlite3* pPtr) { LOGI("sqlite3_close"); sqlite3_close(pPtr); }; + +class Util +{ +public: + static std::string toHash (std::string src); + static const char* GetErrorMessage(int errorNo); +}; +#endif //_UTILS_H_ diff --git a/packaging/privilege-checker.manifest b/packaging/privilege-checker.manifest new file mode 100644 index 0000000..f50f58c --- /dev/null +++ b/packaging/privilege-checker.manifest @@ -0,0 +1,11 @@ + + + + + + + + + + diff --git a/packaging/privilege-checker.spec b/packaging/privilege-checker.spec new file mode 100644 index 0000000..301b4ab --- /dev/null +++ b/packaging/privilege-checker.spec @@ -0,0 +1,64 @@ +Name: privilege-checker +Summary: Privilege Management +Version: 0.0.2 +Release: 3 +Group: System/Libraries +License: SAMSUNG +Source0: %{name}-%{version}.tar.gz +Source1: privilege-checker.manifest +BuildRequires: cmake +BuildRequires: pkgconfig(dlog) +BuildRequires: pkgconfig(sqlite3) +BuildRequires: pkgconfig(capi-base-common) +BuildRequires: pkgconfig(libwbxml2) + + +%description +Privilege Management + +%package -n privilege-checker-devel +summary: privilege-checker server +Group: Development/Libraries +Requires: privilege-checker = %{version}-%{release} + +%description -n privilege-checker-devel +privilege-checker devel + +%prep +%setup -q + +%build +#%{!?build_type:%define build_type "Release"} +echo cmake . -DPREFIX=%{_prefix} \ + -DEXEC_PREFIX=%{_exec_prefix} \ + -DLIBDIR=%{_libdir} \ + -DINCLUDEDIR=%{_includedir} \ + -DCMAKE_BUILD_TYPE=%{build_type} +cmake . -DPREFIX=%{_prefix} \ + -DEXEC_PREFIX=%{_exec_prefix} \ + -DLIBDIR=%{_libdir} \ + -DINCLUDEDIR=%{_includedir} \ + -DCMAKE_BUILD_TYPE=%{build_type} +make %{?jobs:-j%jobs} + +%install +rm -rf %{buildroot} +mkdir -p %{buildroot}/usr/share/license +cp LICENSE.APLv2 %{buildroot}/usr/share/license/privilege-checker +mkdir -p %{buildroot}/opt/dbspace +cp res/opt/dbspace/.privilegelist.db /%{buildroot}/opt/dbspace/ + +%make_install +install -D %{SOURCE1} %{buildroot}%{_datadir}/privilege-checker.manifest + + +%files -n privilege-checker +/usr/share/license/privilege-checker +/usr/bin/* +/opt/dbspace/.privilegelist.db +%manifest %{_datadir}/privilege-checker.manifest + +%clean +rm -rf %{buildroot} + + diff --git a/res/opt/dbspace/.privilegelist.db b/res/opt/dbspace/.privilegelist.db new file mode 100644 index 0000000..4a58ad1 Binary files /dev/null and b/res/opt/dbspace/.privilegelist.db differ diff --git a/src/DbManager.cpp b/src/DbManager.cpp new file mode 100644 index 0000000..4155ddb --- /dev/null +++ b/src/DbManager.cpp @@ -0,0 +1,283 @@ +/* + * Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include + +static const char PRIVACY_INFO_DB_PATH[] = "/opt/dbspace/.privacylist.db"; +static const char PRIVILEGE_INFO_DB_PATH[] = "/opt/dbspace/.privilegelist.db"; + +int +DbManager::InsertPrivacy(const PrivacyInfo* pPrivacyInfo) +{ + LOGI("enter"); + + int res = PRIV_CHECKER_SUCCESS; + int dbRes = SQLITE_OK; + + char query[256] = {0,}; + sprintf(query, "INSERT INTO PrivacyInfo values(?, ?, ?, ?)"); + + TryReturn(pPrivacyInfo != NULL, , PRIV_CHECKER_ERROR_INVALID_ARG, "[PRIV_CHECKER_ERROR_INVALID_ARG] pPrivacyInfo is null"); + TryReturn(pPrivacyInfo->pId != NULL, , PRIV_CHECKER_ERROR_INVALID_ARG, "[PRIV_CHECKER_ERROR_INVALID_ARG] PrivacyID is null"); + + res = DeletePrivacy(pPrivacyInfo); + TryReturn(res == PRIV_CHECKER_SUCCESS, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[PRIV_CHECKER_ERROR_DB_ERROR] Delete operation of privilege is failed."); + + LOGI("id: %s", pPrivacyInfo->pId); + + sqlite3* pDbHandlerTemp = NULL; + dbRes = sqlite3_open_v2(PRIVACY_INFO_DB_PATH, &pDbHandlerTemp, SQLITE_OPEN_READWRITE , NULL); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] DB open error. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + std::unique_ptr pDbHandler (pDbHandlerTemp, DbDeleter); + + sqlite3_stmt* pStmtTemp = NULL; + dbRes = sqlite3_prepare_v2(pDbHandler.get(), query, -1, & pStmtTemp, 0); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] DB prepare failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + std::unique_ptr pStmt(pStmtTemp, StmtDeleter); + + dbRes = sqlite3_bind_text(pStmt.get(), 1, (char*)(pPrivacyInfo->pId), -1, SQLITE_TRANSIENT); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] bind_text failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + if (pPrivacyInfo->pStringInfo != NULL) + { + TryReturn(pPrivacyInfo->pStringInfo->pModule != NULL, , PRIV_CHECKER_ERROR_INVALID_ARG, "[PRIV_CHECKER_ERROR_INVALID_ARG] String module of Privacy is null"); + TryReturn(pPrivacyInfo->pStringInfo->pNameId != NULL, , PRIV_CHECKER_ERROR_INVALID_ARG, "[PRIV_CHECKER_ERROR_INVALID_ARG] Name Id of Privacy is null"); + TryReturn(pPrivacyInfo->pStringInfo->pDescId != NULL, , PRIV_CHECKER_ERROR_INVALID_ARG, "[PRIV_CHECKER_ERROR_INVALID_ARG] Description Id of Privacy is null"); + + LOGI("str_module: %s", pPrivacyInfo->pStringInfo->pModule); + LOGI("str_name_id: %s", pPrivacyInfo->pStringInfo->pNameId); + LOGI("str_desc_id: %s", pPrivacyInfo->pStringInfo->pDescId); + + dbRes = sqlite3_bind_text(pStmt.get(), 2, (char*)(pPrivacyInfo->pStringInfo->pModule), -1, SQLITE_TRANSIENT); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] bind_text failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + dbRes = sqlite3_bind_text(pStmt.get(), 3, (char*)(pPrivacyInfo->pStringInfo->pNameId), -1, SQLITE_TRANSIENT); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] bind_text failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + dbRes = sqlite3_bind_text(pStmt.get(), 4, (char*)(pPrivacyInfo->pStringInfo->pDescId), -1, SQLITE_TRANSIENT); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] bind_text failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + } + else + { + LOGI("str_module does not exist."); + } + + dbRes = sqlite3_step(pStmt.get()); + TryReturn(dbRes == SQLITE_DONE, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] DB step failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + LOGI("leave"); + return 0; +} + +int +DbManager::InsertPrivilege(const PrivilegeInfo* pPrivilegeInfo) +{ + LOGI("enter"); + + int res = PRIV_CHECKER_SUCCESS; + int dbRes = SQLITE_OK; + + TryReturn(pPrivilegeInfo != NULL, , PRIV_CHECKER_ERROR_INVALID_ARG, "[PRIV_CHECKER_ERROR_INVALID_ARG] pPrivilegeInfo is null"); + TryReturn(pPrivilegeInfo->pId != NULL, , PRIV_CHECKER_ERROR_INVALID_ARG, "[PRIV_CHECKER_ERROR_INVALID_ARG] PrivilegeID is null"); + TryReturn(pPrivilegeInfo->pPrivilegeLevel != NULL, , PRIV_CHECKER_ERROR_INVALID_ARG, "[PRIV_CHECKER_ERROR_INVALID_ARG] Privilege level is null"); + + res = DeletePrivilege(pPrivilegeInfo); + TryReturn(res == PRIV_CHECKER_SUCCESS, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[PRIV_CHECKER_ERROR_DB_ERROR] Delete operation of privilege is failed."); + + LOGI("id: %s", pPrivilegeInfo->pId); + LOGI("privilege_level: %s", pPrivilegeInfo->pPrivilegeLevel); + + char query[256] = {0,}; + sprintf(query, "INSERT INTO PrivilegeInfo values(?, ?, ?, ?, ?)"); + + sqlite3* pPrivilegeDbHandlerTemp = NULL; + dbRes = sqlite3_open_v2(PRIVILEGE_INFO_DB_PATH, &pPrivilegeDbHandlerTemp, SQLITE_OPEN_READWRITE , NULL); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] DB open error. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + std::unique_ptr pPrivilegeDbHandler (pPrivilegeDbHandlerTemp, DbDeleter); + + sqlite3_stmt* pPrivilegeStmtTemp = NULL; + dbRes = sqlite3_prepare_v2(pPrivilegeDbHandler.get(), query, -1, & pPrivilegeStmtTemp, 0); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] DB prepare failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + std::unique_ptr pPrivilegeStmt(pPrivilegeStmtTemp, StmtDeleter); + + dbRes = sqlite3_bind_text(pPrivilegeStmt.get(), 1, (char*)(pPrivilegeInfo->pId), -1, SQLITE_TRANSIENT); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] bind_text failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + dbRes = sqlite3_bind_text(pPrivilegeStmt.get(), 2, (char*)(pPrivilegeInfo->pPrivilegeLevel), -1, SQLITE_TRANSIENT); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] bind_text failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + if (pPrivilegeInfo->pStringInfo != NULL) + { + TryReturn(pPrivilegeInfo->pStringInfo->pModule != NULL, , PRIV_CHECKER_ERROR_INVALID_ARG, "[PRIV_CHECKER_ERROR_INVALID_ARG] String module of Privilege is null"); + TryReturn(pPrivilegeInfo->pStringInfo->pNameId != NULL, , PRIV_CHECKER_ERROR_INVALID_ARG, "[PRIV_CHECKER_ERROR_INVALID_ARG] Name Id of Privilege is null"); + TryReturn(pPrivilegeInfo->pStringInfo->pDescId != NULL, , PRIV_CHECKER_ERROR_INVALID_ARG, "[PRIV_CHECKER_ERROR_INVALID_ARG] Description Id of Privilege is null"); + + LOGI("str_module: %s", pPrivilegeInfo->pStringInfo->pModule); + LOGI("str_name_id: %s", pPrivilegeInfo->pStringInfo->pNameId); + LOGI("str_desc_id: %s", pPrivilegeInfo->pStringInfo->pDescId); + + dbRes = sqlite3_bind_text(pPrivilegeStmt.get(), 3, (char*)(pPrivilegeInfo->pStringInfo->pModule), -1, SQLITE_TRANSIENT); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] bind_text failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + dbRes = sqlite3_bind_text(pPrivilegeStmt.get(), 4, (char*)(pPrivilegeInfo->pStringInfo->pNameId), -1, SQLITE_TRANSIENT); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] bind_text failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + dbRes = sqlite3_bind_text(pPrivilegeStmt.get(), 5, (char*)(pPrivilegeInfo->pStringInfo->pDescId), -1, SQLITE_TRANSIENT); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] bind_text failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + } + else + { + LOGI("str_module does not exist."); + } + + dbRes = sqlite3_step(pPrivilegeStmt.get()); + TryReturn(dbRes == SQLITE_DONE, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] DB step failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + if (pPrivilegeInfo->pPrivacy != NULL) + { + char queryPrivacy[256] = {0,}; + sprintf(queryPrivacy, "INSERT INTO PrivilegeToPrivacyTable values(?, ?)"); + + LOGI("privacy: %s", pPrivilegeInfo->pPrivacy); + + sqlite3* pDbHandlerTemp = NULL; + dbRes = sqlite3_open_v2(PRIVACY_INFO_DB_PATH, &pDbHandlerTemp, SQLITE_OPEN_READWRITE , NULL); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] DB open error. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + std::unique_ptr pDbHandler (pDbHandlerTemp, DbDeleter); + + sqlite3_stmt* pStmtTemp = NULL; + dbRes = sqlite3_prepare_v2(pDbHandler.get(), queryPrivacy, -1, & pStmtTemp, 0); + TryReturn(res == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] DB prepare failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + std::unique_ptr pStmt(pStmtTemp, StmtDeleter); + + dbRes = sqlite3_bind_text(pStmt.get(), 1, (char*)(pPrivilegeInfo->pId), -1, SQLITE_TRANSIENT); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] bind_text failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + dbRes = sqlite3_bind_text(pStmt.get(), 2, (char*)(pPrivilegeInfo->pPrivacy), -1, SQLITE_TRANSIENT); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] bind_text failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + dbRes = sqlite3_step(pStmt.get()); + TryReturn(dbRes == SQLITE_DONE, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] DB step failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + } + + LOGI("leave"); + + return res; +} + + +int +DbManager::DeletePrivacy(const PrivacyInfo* pPrivacyInfo) +{ + LOGI("enter"); + + int res = PRIV_CHECKER_SUCCESS; + int dbRes = SQLITE_OK; + + TryReturn(pPrivacyInfo != NULL, , PRIV_CHECKER_ERROR_INVALID_ARG, "[PRIV_CHECKER_ERROR_INVALID_ARG] pPrivacyInfo is null"); + TryReturn(pPrivacyInfo->pId != NULL, , PRIV_CHECKER_ERROR_INVALID_ARG, "[PRIV_CHECKER_ERROR_INVALID_ARG] PrivacyID is null"); + + LOGI("id: %s", pPrivacyInfo->pId); + + char query[256] = {0,}; + sprintf(query, "DELETE FROM PrivacyInfo WHERE PRIVACY_ID = '%s'", (char*)(pPrivacyInfo->pId)); + + sqlite3* pDbHandlerTemp = NULL; + dbRes = sqlite3_open_v2(PRIVACY_INFO_DB_PATH, &pDbHandlerTemp, SQLITE_OPEN_READWRITE , NULL); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] DB open error. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + std::unique_ptr pDbHandler (pDbHandlerTemp, DbDeleter); + + sqlite3_stmt* pStmtTemp = NULL; + dbRes = sqlite3_prepare_v2(pDbHandler.get(), query, -1, & pStmtTemp, 0); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] DB prepare failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + std::unique_ptr pStmt(pStmtTemp, StmtDeleter); + + dbRes = sqlite3_step(pStmt.get()); + TryReturn(dbRes == SQLITE_DONE, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] DB step failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + LOGI("leave"); + return 0; +} + +int +DbManager::DeletePrivilege(const PrivilegeInfo* pPrivilegeInfo) +{ + LOGI("enter"); + + int res = PRIV_CHECKER_SUCCESS; + int dbRes = SQLITE_OK; + + TryReturn(pPrivilegeInfo != NULL, , PRIV_CHECKER_ERROR_INVALID_ARG, "[PRIV_CHECKER_ERROR_INVALID_ARG] pPrivilegeInfo is null"); + TryReturn(pPrivilegeInfo->pId != NULL, , PRIV_CHECKER_ERROR_INVALID_ARG, "[PRIV_CHECKER_ERROR_INVALID_ARG] PrivilegeID is null"); + + LOGI("id: %s", pPrivilegeInfo->pId); + + char query[256] = {0,}; + sprintf(query, "DELETE FROM PrivilegeInfo WHERE PRIVILEGE_ID = '%s'", (char*)(pPrivilegeInfo->pId)); + + sqlite3* pPrivilegeDbHandlerTemp = NULL; + dbRes = sqlite3_open_v2(PRIVILEGE_INFO_DB_PATH, &pPrivilegeDbHandlerTemp, SQLITE_OPEN_READWRITE , NULL); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] DB open error. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + std::unique_ptr pPrivilegeDbHandler (pPrivilegeDbHandlerTemp, DbDeleter); + + sqlite3_stmt* pPrivilegeStmtTemp = NULL; + dbRes = sqlite3_prepare_v2(pPrivilegeDbHandler.get(), query, -1, & pPrivilegeStmtTemp, 0); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] DB prepare failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + std::unique_ptr pPrivilegeStmt(pPrivilegeStmtTemp, StmtDeleter); + + dbRes = sqlite3_step(pPrivilegeStmt.get()); + TryReturn(dbRes == SQLITE_DONE, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] DB step failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + if (pPrivilegeInfo->pPrivacy != NULL) + { + + LOGI("privacy: %s", pPrivilegeInfo->pPrivacy); + + char queryPrivacy[256] = {0,}; + sprintf(queryPrivacy, "DELETE FROM PrivilegeToPrivacyTable WHERE PRIVILEGE_ID = '%s'", (char*)(pPrivilegeInfo->pId)); + + sqlite3* pDbHandlerTemp = NULL; + dbRes = sqlite3_open_v2(PRIVACY_INFO_DB_PATH, &pDbHandlerTemp, SQLITE_OPEN_READWRITE , NULL); + TryReturn(dbRes == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] DB open error. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + std::unique_ptr pDbHandler (pDbHandlerTemp, DbDeleter); + + sqlite3_stmt* pStmtTemp = NULL; + dbRes = sqlite3_prepare_v2(pDbHandler.get(), queryPrivacy, -1, & pStmtTemp, 0); + TryReturn(res == SQLITE_OK, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] DB prepare failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + + std::unique_ptr pStmt(pStmtTemp, StmtDeleter); + + dbRes = sqlite3_step(pStmt.get()); + TryReturn(dbRes == SQLITE_DONE, res = PRIV_CHECKER_ERROR_DB_ERROR, PRIV_CHECKER_ERROR_DB_ERROR, "[%s] DB step failed. (%d)", Util::GetErrorMessage(PRIV_CHECKER_ERROR_DB_ERROR), dbRes); + } + + LOGI("leave"); + + return res; +} diff --git a/src/Main.cpp b/src/Main.cpp new file mode 100644 index 0000000..a075c4f --- /dev/null +++ b/src/Main.cpp @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +int +main(int argc, char **argv) { + + char *fileName; + + if (argc <= 1) { + printf("Usage: %s xml file name\n", argv[0]); + return(0); + } + + fileName = argv[1]; + Parser::ParseExtendedPolicy(fileName); + + return 1; +} diff --git a/src/Parser.cpp b/src/Parser.cpp new file mode 100644 index 0000000..2939f88 --- /dev/null +++ b/src/Parser.cpp @@ -0,0 +1,286 @@ +/* + * Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include + +using namespace std; + +int +Parser::SetPrivilegeDb(PrivilegeInfo* pPrivilegeInfo) +{ + LOGI("enter"); + int res = PRIV_CHECKER_SUCCESS; + + res = DbManager::InsertPrivilege(pPrivilegeInfo); + TryReturn(res == PRIV_CHECKER_SUCCESS, , res, "[%s] Propagated.", Util::GetErrorMessage(res)); + + LOGI("leave"); + return res; +} + +int +Parser::SetPrivacyDb(PrivacyInfo* pPrivacyInfo) +{ + LOGI("enter"); + int res = PRIV_CHECKER_SUCCESS; + + res = DbManager::InsertPrivacy(pPrivacyInfo); + TryReturn(res == PRIV_CHECKER_SUCCESS, , res, "[%s] Propagated.", Util::GetErrorMessage(res)); + + LOGI("leave"); + return res; +} + +int +Parser::ParseStringInfo (xmlDocPtr stringInfoDoc, xmlNodePtr currentDoc, StringInfo** ppStringInfo) +{ + LOGI("enter"); + int res = PRIV_CHECKER_SUCCESS; + + *ppStringInfo = (StringInfo*)calloc(1, sizeof(StringInfo)); + TryCatch(*ppStringInfo != NULL, res = PRIV_CHECKER_ERROR_OUT_OF_MEMORY, "[PRIV_CHECKER_ERROR_OUT_OF_MEMORY] The memory is insufficient."); + + currentDoc = currentDoc->xmlChildrenNode; + while (currentDoc != NULL) + { + if (currentDoc->type == XML_ELEMENT_NODE) + { + if ((!xmlStrcmp(currentDoc->name, (const xmlChar *)"str_module"))) + { + (*ppStringInfo)->pModule = xmlNodeListGetString(stringInfoDoc, currentDoc->xmlChildrenNode, 1); + } + else if ((!xmlStrcmp(currentDoc->name, (const xmlChar *)"str_name_id"))) + { + (*ppStringInfo)->pNameId = xmlNodeListGetString(stringInfoDoc, currentDoc->xmlChildrenNode, 1); + } + else if ((!xmlStrcmp(currentDoc->name, (const xmlChar *)"str_desc_id"))) + { + (*ppStringInfo)->pDescId = xmlNodeListGetString(stringInfoDoc, currentDoc->xmlChildrenNode, 1); + } + else + { + LOGE("[PRIV_CHECKER_ERROR_INVALID_ARG] Invalid policy type: %s", currentDoc->name); + res = PRIV_CHECKER_ERROR_INVALID_ARG; + goto CATCH; + } + } + currentDoc = currentDoc->next; + } + + + LOGI("leave"); + return res; + +CATCH: + + if (*ppStringInfo != NULL) + { + free(*ppStringInfo); + } + + LOGI("error!"); + return res; +} + +int +Parser::ParsePrivilege (xmlDocPtr privilegeDoc, xmlNodePtr currentDoc) +{ + LOGI("enter"); + int res = PRIV_CHECKER_SUCCESS; + + PrivilegeInfo* pPrivilegeInfo = (PrivilegeInfo*)calloc(1, sizeof(PrivilegeInfo)); + TryCatch(pPrivilegeInfo != NULL, res = PRIV_CHECKER_ERROR_OUT_OF_MEMORY, "[PRIV_CHECKER_ERROR_OUT_OF_MEMORY] The memory is insufficient."); + + currentDoc = currentDoc->xmlChildrenNode; + while (currentDoc != NULL) + { + if (currentDoc->type == XML_ELEMENT_NODE) + { + if ((!xmlStrcmp(currentDoc->name, (const xmlChar *)"id"))) + { + pPrivilegeInfo->pId = xmlNodeListGetString(privilegeDoc, currentDoc->xmlChildrenNode, 1); + } + else if ((!xmlStrcmp(currentDoc->name, (const xmlChar *)"privacy"))) + { + pPrivilegeInfo->pPrivacy = xmlNodeListGetString(privilegeDoc, currentDoc->xmlChildrenNode, 1); + } + else if ((!xmlStrcmp(currentDoc->name, (const xmlChar *)"privilege_level"))) + { + pPrivilegeInfo->pPrivilegeLevel = xmlNodeListGetString(privilegeDoc, currentDoc->xmlChildrenNode, 1); + } + else if ((!xmlStrcmp(currentDoc->name, (const xmlChar *)"string_info"))) + { + res = ParseStringInfo(privilegeDoc, currentDoc, &(pPrivilegeInfo->pStringInfo)); + TryCatch(res == PRIV_CHECKER_SUCCESS, , "[%s] Propagated.", Util::GetErrorMessage(res)); + } + else + { + LOGE("[PRIV_CHECKER_ERROR_INVALID_ARG] Invalid policy type: %s", currentDoc->name); + res = PRIV_CHECKER_ERROR_INVALID_ARG; + goto CATCH; + } + } + currentDoc = currentDoc->next; + } + + res = SetPrivilegeDb(pPrivilegeInfo); + TryCatch(res == PRIV_CHECKER_SUCCESS, , "[%s] Propagated.", Util::GetErrorMessage(res)); + + LOGI("leave"); + return res; + +CATCH: + + if (pPrivilegeInfo != NULL) + { + free(pPrivilegeInfo); + } + + LOGI("error!"); + return res; +} + +int +Parser::ParsePrivilegeList (xmlDocPtr privilegeListDoc, xmlNodePtr currentDoc) +{ + LOGI("enter"); + int res = PRIV_CHECKER_SUCCESS; + + currentDoc = currentDoc->xmlChildrenNode; + while (currentDoc != NULL) + { + if (currentDoc->type == XML_ELEMENT_NODE) + { + if ((!xmlStrcmp(currentDoc->name, (const xmlChar *)"privilege"))) + { + res = ParsePrivilege(privilegeListDoc, currentDoc); + TryReturn(res == PRIV_CHECKER_SUCCESS, , res, "[%s] Propagated.", Util::GetErrorMessage(res)); + } + else + { + LOGE("[PRIV_CHECKER_ERROR_INVALID_ARG] Invalid policy type: %s", currentDoc->name); + res = PRIV_CHECKER_ERROR_INVALID_ARG; + return res; + } + } + currentDoc = currentDoc->next; + } + + LOGI("leave"); + return res; +} + +int +Parser::ParsePrivacyList (xmlDocPtr privacyListDoc, xmlNodePtr currentDoc) +{ + LOGI("enter"); + int res = PRIV_CHECKER_SUCCESS; + + PrivacyInfo* pPrivacyInfo = (PrivacyInfo*)calloc(1, sizeof(PrivacyInfo)); + TryCatch(pPrivacyInfo != NULL, res = PRIV_CHECKER_ERROR_OUT_OF_MEMORY, "[PRIV_CHECKER_ERROR_OUT_OF_MEMORY] The memory is insufficient."); + + currentDoc = currentDoc->xmlChildrenNode; + while (currentDoc != NULL) + { + if (currentDoc->type == XML_ELEMENT_NODE) + { + if ((!xmlStrcmp(currentDoc->name, (const xmlChar *)"id"))) + { + pPrivacyInfo->pId = xmlNodeListGetString(privacyListDoc, currentDoc->xmlChildrenNode, 1); + } + else if ((!xmlStrcmp(currentDoc->name, (const xmlChar *)"string_info"))) + { + res = ParseStringInfo(privacyListDoc, currentDoc, &(pPrivacyInfo->pStringInfo)); + TryCatch(res == PRIV_CHECKER_SUCCESS, , "[%s] Propagated.", Util::GetErrorMessage(res)); + } + else + { + LOGE("[PRIV_CHECKER_ERROR_INVALID_ARG] Invalid policy type: %s", currentDoc->name); + res = PRIV_CHECKER_ERROR_INVALID_ARG; + goto CATCH; + } + } + currentDoc = currentDoc->next; + } + + res = SetPrivacyDb(pPrivacyInfo); + TryCatch(res == PRIV_CHECKER_SUCCESS, , "[%s] Propagated.", Util::GetErrorMessage(res)); + + LOGI("leave"); + return res; + +CATCH: + + LOGI("error!"); + return res; + +} + + +int +Parser::ParseExtendedPolicy(char *docName) +{ + LOGI("enter"); + int res = PRIV_CHECKER_SUCCESS; + xmlDocPtr doc; + xmlNodePtr currentDoc; + + doc = xmlParseFile(docName); + TryReturn(doc != NULL, , PRIV_CHECKER_ERROR_XML_ERROR, "[PRIV_CHECKER_ERROR_XML_ERROR] XML parsing is failed."); + + currentDoc = xmlDocGetRootElement(doc); + TryReturn(currentDoc != NULL, xmlFreeDoc(doc), PRIV_CHECKER_ERROR_XML_ERROR, "[PRIV_CHECKER_ERROR_XML_ERROR] Document is empty."); + + + TryReturn(xmlStrcmp(currentDoc->name, (const xmlChar *)"extended_policy") == MATCHED, xmlFreeDoc(doc), PRIV_CHECKER_ERROR_INVALID_ARG, + "[PRIV_CHECKER_ERROR_INVALID_ARG] Root node is not but <%s>", currentDoc->name); + + + currentDoc = currentDoc->xmlChildrenNode; + while (currentDoc != NULL) + { + if (currentDoc->type == XML_ELEMENT_NODE) + { + if ((!xmlStrcmp(currentDoc->name, (const xmlChar *)"privilege_list"))) + { + res = ParsePrivilegeList (doc, currentDoc); + TryReturn(res == PRIV_CHECKER_SUCCESS, xmlFreeDoc(doc), res, "[%s] Propagated.", Util::GetErrorMessage(res)); + } + else if ((!xmlStrcmp(currentDoc->name, (const xmlChar *)"privacy_list"))) + { + res = ParsePrivacyList (doc, currentDoc); + TryReturn(res == PRIV_CHECKER_SUCCESS, xmlFreeDoc(doc), res, "[%s] Propagated.", Util::GetErrorMessage(res)); + } + else + { + LOGE("[PRIV_CHECKER_ERROR_INVALID_ARG] Invalid policy type: %s", currentDoc->name); + xmlFreeDoc(doc); + return PRIV_CHECKER_ERROR_INVALID_ARG; + + } + } + currentDoc = currentDoc->next; + } + + xmlFreeDoc(doc); + + LOGI("leave"); + return res; +} + diff --git a/src/Util.cpp b/src/Util.cpp new file mode 100644 index 0000000..63e856a --- /dev/null +++ b/src/Util.cpp @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2013 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +const char* __errorMsgTable[] = +{ + "PRIV_CHECKER_SUCCESS", + "PRIV_CHECKER_ERROR_XML_ERROR", + "PRIV_CHECKER_ERROR_INVALID_ARG", + "PRIV_CHECKER_ERROR_OUT_OF_MEMORY", + "PRIV_CHECKER_ERROR_IO_ERROR", + "PRIV_CHECKER_ERROR_NO_DATA", + "PRIV_CHECKER_ERROR_DB_ERROR", + "PRIV_CHECKER_ERROR_SYSTEM_ERROR", + "PRIV_CHECKER_ERROR_UNKNOW", +}; + +std::string +Util::toHash(std::string src) +{ + return src; +} + +const char* +Util::GetErrorMessage(int errorNo) +{ + + if (errorNo < PRIV_CHECKER_ERROR_UNKNOW) + { + return __errorMsgTable[errorNo]; + } + else + return "PRIV_CHECKER_ERROR_UNKNOW"; +}