+/*
+ * Copyright (c) 2019 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 <fstream>
+#include <pkgmgr-info.h>
+#include <pkgmgr_installer_info.h>
+#include <json/json.h>
+
+#include "log.h"
+#include "utils.h"
+#include "ni_common.h"
+#include "tac_common.h"
+#include "db_manager.h"
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "DOTNET_INSTALLER_PLUGIN"
+
+#define __XSTR(x) #x
+#define __STR(x) __XSTR(x)
+static const char* __TAC_DIR = __STR(TAC_DIR);
+#undef __STR
+#undef __XSTR
+
+static sqlite3 *tac_db = NULL;
+std::vector<std::string> restoreNuget;
+std::vector<std::string> enableNuget;
+
+void cleanupDirectory()
+{
+ std::vector<std::string> removeNuget;
+ for (auto& nuget : bf::recursive_directory_iterator(__TAC_DIR)) {
+ bool isExist = false;
+ for (auto& restore : restoreNuget) {
+ if (!bf::is_directory(nuget.path())) {
+ isExist = true;
+ }
+ if (strstr(nuget.path().c_str(), restore.c_str()) != NULL) {
+ isExist = true;
+ break;
+ }
+ }
+ if (!isExist) {
+ removeNuget.push_back(nuget.path().string());
+ }
+ }
+
+ for (auto& rm : removeNuget) {
+ if (!removeAll(rm)) {
+ _ERR("Failed to remove of %s", rm.c_str());
+ }
+ }
+ removeNuget.clear();
+}
+
+void depsJsonParser(std::string pkgId, std::string depsJsonPath, std::string execName, bool isRestore)
+{
+ std::ifstream ifs(depsJsonPath);
+ Json::CharReaderBuilder reader;
+ Json::Value root;
+ std::string error;
+ if (ifs.is_open()) {
+ if (!Json::parseFromStream(reader, ifs, &root, &error)) {
+ _INFO("Failed to parse of deps.json");
+ ifs.close();
+ return;
+ }
+ const Json::Value runtimeTargetName = root["runtimeTarget"]["name"];
+ const Json::Value nugetPackages = root["targets"][runtimeTargetName.asString().c_str()];
+ for (auto& nuget : nugetPackages.getMemberNames()) {
+ if (strstr(nuget.c_str(), TIZEN_DOTNET_NUGET) != NULL ||
+ strstr(nuget.c_str(), TIZEN_DOTNET_SDK_NUGET) != NULL ||
+ strstr(nuget.c_str(), (execName.substr(0, execName.find(".Tizen."))).c_str()) != NULL ||
+ strstr(nuget.c_str(), (execName.substr(0, execName.find(".dll"))).c_str()) != NULL) {
+ continue;
+ } else {
+ const Json::Value assemblies = nugetPackages[nuget.c_str()]["runtime"];
+ if (assemblies != Json::nullValue) {
+ const Json::Value dependencies = nugetPackages[nuget.c_str()]["dependencies"];
+ bool isDependency = false;
+ for (auto& dependency : dependencies.getMemberNames()) {
+ if (strstr(dependency.c_str(), TIZEN_DOTNET_NUGET) != NULL ||
+ strstr(dependency.c_str(), NET_STANDARD_LIBRARY_NUGET) != NULL) {
+ continue;
+ } else {
+ isDependency = true;
+ }
+ }
+ if (!isDependency) {
+ _INFO("PackageId : [%s] / Nuget package : [%s]", pkgId.c_str(), nuget.c_str());
+ std::string name = nuget.substr(0, nuget.find('/'));
+ std::string version = nuget.substr(nuget.rfind('/') + 1);
+ std::string sql = "INSERT INTO TAC (PKGID, NUGET, NAME, VERSION) " \
+ "VALUES ('" + pkgId + "', '" + nuget + "', '" + name + "', '" + version + "');";
+ if (isRestore) {
+ if (tac_db) {
+ dbInsert(tac_db, TAC_APP_LIST_RESTORE_DB, sql);
+ restoreNuget.push_back(concatPath(__TAC_DIR, name));
+ }
+ } else {
+ std::string nugetPath = concatPath(__TAC_DIR, nuget);
+ if (bf::exists(nugetPath)) {
+ for (auto& assembly : assemblies.getMemberNames()) {
+ std::string assemblyName = assembly.substr(assembly.rfind('/') + 1);
+ std::string originPath = concatPath(nugetPath, assemblyName);
+ if (bf::exists(originPath)) {
+ enableNuget.push_back(originPath);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ ifs.close();
+ }
+}
+
+// callback function of "pkgmgrinfo_appinfo_metadata_filter_foreach"
+static int restoreDBCb(pkgmgrinfo_appinfo_h handle, void *userData)
+{
+ char *pkgId = NULL;
+ char *root = NULL;
+ char *exec = NULL;
+ std::string rootPath;
+ std::string execName;
+
+ int ret = pkgmgrinfo_appinfo_get_pkgid(handle, &pkgId);
+ if (ret != PMINFO_R_OK) {
+ fprintf(stderr, "Failed to get pkgid\n");
+ return -1;
+ }
+
+ ret = pkgmgrinfo_appinfo_get_root_path(handle, &root);
+ if (ret != PMINFO_R_OK) {
+ fprintf(stderr, "Failed to get root path\n");
+ return -1;
+ }
+ rootPath = root;
+
+ ret = pkgmgrinfo_appinfo_get_exec(handle, &exec);
+ if (ret != PMINFO_R_OK) {
+ fprintf(stderr, "Failed to get exec name\n");
+ return -1;
+ }
+ execName = std::string(exec).substr(std::string(exec).rfind('/') + 1);
+
+ std::string depsJsonName = execName.substr(0, execName.rfind(".dll")) + ".deps.json";
+ std::string depsJsonPath = concatPath(rootPath, depsJsonName);
+ if (bf::exists(depsJsonPath)) {
+ depsJsonParser(pkgId, depsJsonPath, execName, true);
+ }
+ return 0;
+}
+
+tac_error_e restoreTACDB()
+{
+ if (!removeFile(TAC_APP_LIST_RESTORE_DB)) {
+ fprintf(stderr, "Failed to remove of %s", TAC_APP_LIST_RESTORE_DB);
+ return TAC_ERROR_UNKNOWN;
+ }
+
+ std::string dbRestoreJournal = TAC_APP_LIST_RESTORE_DB + std::string("-journal");
+ if (!removeFile(dbRestoreJournal)) {
+ fprintf(stderr, "Failed to remove of %s", dbRestoreJournal.c_str());
+ return TAC_ERROR_UNKNOWN;
+ }
+
+ tac_db = dbCreate(TAC_APP_LIST_RESTORE_DB);
+ if (tac_db) {
+ if (!dbOpen(tac_db, TAC_APP_LIST_RESTORE_DB)) {
+ return TAC_ERROR_UNKNOWN;
+ }
+ } else {
+ return TAC_ERROR_UNKNOWN;
+ }
+
+ pkgmgrinfo_appinfo_metadata_filter_h handle;
+ int ret = pkgmgrinfo_appinfo_metadata_filter_create(&handle);
+ if (ret != PMINFO_R_OK) {
+ return TAC_ERROR_UNKNOWN;
+ }
+
+ ret = pkgmgrinfo_appinfo_metadata_filter_add(handle, TAC_METADATA_KEY, METADATA_VALUE);
+ if (ret != PMINFO_R_OK) {
+ pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
+ return TAC_ERROR_UNKNOWN;
+ }
+
+ ret = pkgmgrinfo_appinfo_metadata_filter_foreach(handle, restoreDBCb, NULL);
+ if (ret != PMINFO_R_OK) {
+ fprintf(stderr, "Failed pkgmgrinfo_appinfo_metadata_filter_foreach\n");
+ pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
+ return TAC_ERROR_UNKNOWN;
+ }
+ fprintf(stderr, "Success pkgmgrinfo_appinfo_metadata_filter_foreach\n");
+
+ pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
+
+ if (tac_db) {
+ dbClose(tac_db);
+ tac_db = NULL;
+ }
+
+ if (!copyFile(TAC_APP_LIST_RESTORE_DB, TAC_APP_LIST_DB)) {
+ fprintf(stderr, "Failed to move of %s", TAC_APP_LIST_DB);
+ return TAC_ERROR_UNKNOWN;
+ }
+ if (!removeFile(TAC_APP_LIST_RESTORE_DB)) {
+ fprintf(stderr, "Failed to remove of %s", TAC_APP_LIST_RESTORE_DB);
+ return TAC_ERROR_UNKNOWN;
+ }
+
+ std::string dbJournal = TAC_APP_LIST_DB + std::string("-journal");
+ if (!copyFile(dbRestoreJournal, dbJournal)) {
+ fprintf(stderr, "Failed to move of %s", dbJournal.c_str());
+ return TAC_ERROR_UNKNOWN;
+ }
+ if (!removeFile(dbRestoreJournal)) {
+ fprintf(stderr, "Failed to remove of %s", dbRestoreJournal.c_str());
+ return TAC_ERROR_UNKNOWN;
+ }
+
+ cleanupDirectory();
+ return TAC_ERROR_NONE;
+}
+
+tac_error_e resetTACPackage(const std::string& pkgId)
+{
+ std::string pkgRoot;
+ if (getRootPath(pkgId, pkgRoot) < 0) {
+ return TAC_ERROR_INVALID_PACKAGE;
+ }
+
+ std::vector<std::string> tacNativeImage;
+ std::string binDir = concatPath(pkgRoot, "bin");
+ std::string tacDir = concatPath(binDir, TAC_SYMLINK_SUB_DIR);
+ if (bf::exists(tacDir)) {
+ for (auto& symlinkAssembly : bf::recursive_directory_iterator(tacDir)) {
+ std::string symPath = symlinkAssembly.path().string();
+ if (bf::is_symlink(symPath)) {
+ if (isNativeImage(symPath)) {
+ tacNativeImage.push_back(symPath);
+ }
+ }
+ }
+ for (auto& path : tacNativeImage) {
+ if (!removeFile(path)) {
+ fprintf(stderr, "Failed to remove of %s", path.c_str());
+ return TAC_ERROR_UNKNOWN;
+ }
+ }
+ }
+ tacNativeImage.clear();
+ return TAC_ERROR_NONE;
+}
+
+tac_error_e createTACPackage(const std::string& pkgId)
+{
+ std::string pkgRoot;
+ if (getRootPath(pkgId, pkgRoot) < 0) {
+ return TAC_ERROR_INVALID_PACKAGE;
+ }
+
+ std::string binDir = concatPath(pkgRoot, "bin");
+ std::string tacDir = concatPath(binDir, TAC_SYMLINK_SUB_DIR);
+ std::string binNIDir = concatPath(binDir, APP_NI_SUB_DIR);
+ if (bf::exists(tacDir)) {
+ for (auto& symlinkAssembly : bf::recursive_directory_iterator(tacDir)) {
+ std::string symPath = symlinkAssembly.path().string();
+ if (bf::is_symlink(symPath)) {
+ if (!isNativeImage(symPath)) {
+ std::string originPath = bf::read_symlink(symPath).string();
+ std::string originNiPath = originPath.substr(0, originPath.rfind(".dll")) + ".ni.dll";
+ if (!bf::exists(originNiPath)) {
+ if(createNiDll(originPath, false, false) != NI_ERROR_NONE) {
+ fprintf(stderr, "Failed to create NI file [%s]\n", originPath.c_str());
+ return TAC_ERROR_UNKNOWN;
+ }
+ }
+ std::string symNIPath = symPath.substr(0, symPath.rfind(".dll")) + ".ni.dll";
+ if (!bf::exists(symNIPath)) {
+ bf::create_symlink(originNiPath, symNIPath);
+ fprintf(stderr, "%s symbolic link file generated successfully.\n", symNIPath.c_str());
+ updateAssemblyInfo(tacDir.c_str(), symNIPath.c_str(), true);
+
+ std::string NIFileName = symNIPath.substr(symNIPath.rfind('/') + 1);
+ if (!removeFile(concatPath(binNIDir, NIFileName))) {
+ fprintf(stderr, "Failed to remove of %s\n", concatPath(binNIDir, NIFileName).c_str());
+ return TAC_ERROR_UNKNOWN;
+ }
+ }
+ }
+ }
+ }
+ }
+ return TAC_ERROR_NONE;
+}
+
+tac_error_e regenerateTAC()
+{
+ const std::string tacDir[] = {__TAC_DIR};
+ removeNiUnderDirs(tacDir, 1);
+
+ auto convert = [](const std::string& path, std::string name) {
+ if (strstr(path.c_str(), TAC_APP_LIST_DB) != NULL ||
+ strstr(path.c_str(), TAC_APP_LIST_RESTORE_DB) != NULL ||
+ strstr(path.c_str(), TAC_SHA_256_INFO) != NULL)
+ return;
+ if(createNiDll(path, false, false) != NI_ERROR_NONE) {
+ fprintf(stderr, "Failed to create NI file [%s]\n", path.c_str());
+ return;
+ }
+ };
+ scanFilesInDir(tacDir[0], convert, -1);
+ return TAC_ERROR_NONE;
+}
+
+tac_error_e disableTACPackage(const std::string& pkgId)
+{
+ std::string pkgRoot;
+ if (getRootPath(pkgId, pkgRoot) < 0) {
+ return TAC_ERROR_INVALID_PACKAGE;
+ }
+
+ std::string binDir = concatPath(pkgRoot, "bin");
+ std::string tacDir = concatPath(binDir, TAC_SYMLINK_SUB_DIR);
+ std::string binNIDir = concatPath(binDir, APP_NI_SUB_DIR);
+ if (bf::exists(tacDir)) {
+ for (auto& symlinkAssembly : bf::recursive_directory_iterator(tacDir)) {
+ std::string symPath = symlinkAssembly.path().string();
+ std::string fileName = symlinkAssembly.path().filename().string();
+ if (bf::is_symlink(symPath)) {
+ std::string originPath = bf::read_symlink(symPath).string();
+ if (!isNativeImage(symPath)) {
+ if (!copyFile(originPath, concatPath(binDir, fileName))) {
+ fprintf(stderr, "Failed to copy of %s\n", concatPath(binDir, fileName).c_str());
+ return TAC_ERROR_UNKNOWN;
+ }
+ updateAssemblyInfo(binDir.c_str(), concatPath(binDir, fileName).c_str());
+ } else {
+ if (!copyFile(originPath, concatPath(binNIDir, fileName))) {
+ fprintf(stderr, "Failed to copy of %s\n", concatPath(binNIDir, fileName).c_str());
+ return TAC_ERROR_UNKNOWN;
+ }
+ updateAssemblyInfo(binDir.c_str(), concatPath(binNIDir, fileName).c_str());
+ }
+ }
+ }
+ }
+ if (!removeAll(tacDir)) {
+ fprintf(stderr, "Failed to remove of %s\n", tacDir.c_str());
+ return TAC_ERROR_UNKNOWN;
+ }
+ return TAC_ERROR_NONE;
+}
+
+tac_error_e enableTACPackage(const std::string& pkgId)
+{
+ std::string pkgRoot;
+ if (getRootPath(pkgId, pkgRoot) < 0) {
+ return TAC_ERROR_INVALID_PACKAGE;
+ }
+
+ std::string execName;
+ if (getExecName(pkgId, execName) < 0) {
+ return TAC_ERROR_INVALID_PACKAGE;
+ }
+
+ std::string metaValue;
+ if (getMetadataValue(pkgId, TAC_METADATA_KEY, metaValue) < 0) {
+ return TAC_ERROR_INVALID_PACKAGE;
+ }
+
+ if (!strcmp(metaValue.c_str(), "true")) {
+ std::string binDir = concatPath(pkgRoot, "bin");
+ std::string tacDir = concatPath(binDir, TAC_SYMLINK_SUB_DIR);
+ std::string binNIDir = concatPath(binDir, APP_NI_SUB_DIR);
+ if (!bf::exists(tacDir)) {
+ if (!createDir(tacDir)) {
+ fprintf(stderr, "Cannot create directory: %s\n", tacDir.c_str());
+ return TAC_ERROR_UNKNOWN;
+ }
+ updateAssemblyInfo(binDir.c_str(), tacDir.c_str());
+
+ std::string depsJsonName = execName.substr(0, execName.rfind(".dll")) + ".deps.json";
+ std::string depsJsonPath = concatPath(pkgRoot, depsJsonName);
+ if (bf::exists(depsJsonPath)) {
+ depsJsonParser(pkgId, depsJsonPath, execName, false);
+ }
+
+ for (auto& originPath : enableNuget) {
+ if (bf::exists(originPath)) {
+ std::string fileName = originPath.substr(originPath.rfind('/') + 1);
+ std::string NIFileName = fileName.substr(0, fileName.rfind(".dll")) + ".ni.dll";
+ if (bf::exists(binNIDir)) {
+ std::string originNIPath = originPath.substr(0, originPath.rfind(".dll")) + ".ni.dll";
+ if (bf::exists(originNIPath)) {
+ bf::create_symlink(originNIPath, concatPath(tacDir, NIFileName));
+ fprintf(stderr, "%s symbolic link file generated successfully.\n", concatPath(tacDir, NIFileName).c_str());
+ updateAssemblyInfo(tacDir.c_str(), concatPath(tacDir, NIFileName).c_str(), true);
+
+ if (!removeFile(concatPath(binNIDir, NIFileName))) {
+ fprintf(stderr, "Failed to remove of %s\n", concatPath(binNIDir, NIFileName).c_str());
+ return TAC_ERROR_UNKNOWN;
+ }
+ }
+ }
+ bf::create_symlink(originPath, concatPath(tacDir, fileName));
+ fprintf(stderr, "%s symbolic link file generated successfully.\n", concatPath(tacDir, fileName).c_str());
+ updateAssemblyInfo(tacDir.c_str(), concatPath(tacDir, fileName).c_str(), true);
+
+ if (!removeFile(concatPath(binDir, fileName))) {
+ fprintf(stderr, "Failed to remove of %s\n", concatPath(binDir, fileName).c_str());
+ return TAC_ERROR_UNKNOWN;
+ }
+ }
+ }
+ if (enableNuget.empty()) {
+ if (!removeAll(tacDir)) {
+ _ERR("Failed to remove of %s", tacDir.c_str());
+ }
+ }
+ }
+ } else {
+ fprintf(stderr, "The metadata key is missing or the metadata value is false of [%s]\n", pkgId.c_str());
+ }
+ return TAC_ERROR_NONE;
+}
projects / platform / core / dotnet / launcher.git / commitdiff