2 * Copyright (c) 2019 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the License);
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an AS IS BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 #include <json/json.h>
20 #include <pkgmgr-info.h>
21 #include <pkgmgr_installer_info.h>
25 #include "tac_common.h"
26 #include "db_manager.h"
31 #define LOG_TAG "DOTNET_INSTALLER_PLUGIN"
34 #define __STR(x) __XSTR(x)
35 static const char* __DOTNET_DIR = __STR(DOTNET_DIR);
39 static sqlite3 *tac_db = NULL;
40 static sqlite3 *tlc_db = NULL;
41 std::vector<std::string> restore_nuget;
42 std::vector<std::string> restore_library;
44 static void cleanupDirectory()
46 std::vector<std::string> removeNuget;
48 for (auto& nuget : bf::recursive_directory_iterator(__DOTNET_DIR)) {
50 std::string nugetPath = nuget.path().string();
51 for (auto& restore : restore_nuget) {
52 if (!bf::is_directory(nugetPath) || nugetPath.find(TLC_LIBRARIES_DIR) != std::string::npos) {
56 if (!strcmp(nugetPath.c_str(), restore.c_str()) ||
57 !strcmp(nugetPath.c_str(), restore.substr(0, restore.rfind('/')).c_str())) {
63 removeNuget.push_back(nugetPath);
67 for (auto& rm : removeNuget) {
69 fprintf(stderr, "Failed to remove of %s\n", rm.c_str());
73 } catch (const bf::filesystem_error& error) {
74 fprintf(stderr, "Failed to recursive directory: %s\n", error.what());
79 // callback function of "pkgmgrinfo_appinfo_metadata_filter_foreach"
80 static int tac_restoreDBCb(pkgmgrinfo_appinfo_h handle, void *userData)
88 int ret = pkgmgrinfo_appinfo_get_pkgid(handle, &pkgId);
89 if (ret != PMINFO_R_OK) {
90 fprintf(stderr, "Failed to get pkgid\n");
94 enableTACPackage(std::string(pkgId));
96 ret = pkgmgrinfo_appinfo_get_root_path(handle, &root);
97 if (ret != PMINFO_R_OK) {
98 fprintf(stderr, "Failed to get root path\n");
101 rootPath = std::string(root);
103 ret = pkgmgrinfo_appinfo_get_exec(handle, &exec);
104 if (ret != PMINFO_R_OK) {
105 fprintf(stderr, "Failed to get exec name\n");
108 execName = std::string(exec).substr(std::string(exec).rfind('/') + 1);
110 std::vector<std::string> parserData;
111 std::string binDir = concatPath(rootPath, "bin");
112 std::string tacDir = concatPath(binDir, TAC_SYMLINK_SUB_DIR);
113 for (auto& npAssembly : depsJsonParser(rootPath, execName)) {
114 std::string nugetPackage = npAssembly.substr(0, npAssembly.rfind(':'));
115 std::string assemblyName = npAssembly.substr(npAssembly.rfind(':') + 1);
116 if (bf::exists(tacDir) && bf::exists(concatPath(tacDir, assemblyName))) {
117 parserData.push_back(nugetPackage);
120 std::sort(parserData.begin(), parserData.end());
121 parserData.erase(unique(parserData.begin(), parserData.end()), parserData.end());
123 for (auto& nuget : parserData) {
125 std::string name = nuget.substr(0, nuget.find('/'));
126 std::string version = nuget.substr(nuget.rfind('/') + 1);
127 char *sql = sqlite3_mprintf(
128 "INSERT INTO TAC (PKGID, NUGET, NAME, VERSION) " \
129 "VALUES (%Q, %Q, %Q, %Q);", pkgId, nuget.c_str(), name.c_str(), version.c_str());
130 insertDB(tac_db, sql);
131 restore_nuget.push_back(concatPath(__DOTNET_DIR, nuget));
139 tac_error_e tac_restoreDB()
141 if (!removeFile(TAC_APP_LIST_RESTORE_DB)) {
142 fprintf(stderr, "Failed to remove of %s\n", TAC_APP_LIST_RESTORE_DB);
143 return TAC_ERROR_UNKNOWN;
146 std::string dbRestoreJournal = TAC_APP_LIST_RESTORE_DB + std::string("-journal");
147 if (!removeFile(dbRestoreJournal)) {
148 fprintf(stderr, "Failed to remove of %s\n", dbRestoreJournal.c_str());
149 return TAC_ERROR_UNKNOWN;
152 tac_db = createDB(TAC_APP_LIST_RESTORE_DB, CREATE_TAC_DB_TABLE);
154 fprintf(stderr, "Sqlite create error\n");
155 return TAC_ERROR_UNKNOWN;
157 sqlite3_exec(tac_db, "BEGIN;", NULL, NULL, NULL);
159 pkgmgrinfo_appinfo_metadata_filter_h handle;
160 int ret = pkgmgrinfo_appinfo_metadata_filter_create(&handle);
161 if (ret != PMINFO_R_OK) {
162 return TAC_ERROR_UNKNOWN;
165 ret = pkgmgrinfo_appinfo_metadata_filter_add(handle, TAC_METADATA_KEY, METADATA_VALUE);
166 if (ret != PMINFO_R_OK) {
167 pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
168 return TAC_ERROR_UNKNOWN;
171 ret = pkgmgrinfo_appinfo_metadata_filter_foreach(handle, tac_restoreDBCb, NULL);
172 if (ret != PMINFO_R_OK) {
173 fprintf(stderr, "Failed pkgmgrinfo_appinfo_metadata_filter_foreach\n");
174 pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
175 return TAC_ERROR_UNKNOWN;
177 fprintf(stdout, "Success pkgmgrinfo_appinfo_metadata_filter_foreach\n");
179 pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
186 const uid_t g_uid = 301; // app_fw
187 const gid_t g_gid = 301; // app_fw
189 if (!copyFile(TAC_APP_LIST_RESTORE_DB, TAC_APP_LIST_DB)) {
190 fprintf(stderr, "Failed to copy of %s\n", TAC_APP_LIST_DB);
191 return TAC_ERROR_UNKNOWN;
193 if (!removeFile(TAC_APP_LIST_RESTORE_DB)) {
194 fprintf(stderr, "Failed to remove of %s\n", TAC_APP_LIST_RESTORE_DB);
195 return TAC_ERROR_UNKNOWN;
197 if (chown(TAC_APP_LIST_DB, g_uid, g_gid) == -1) {
198 fprintf(stderr, "Failed to change owner and group name\n");
201 std::string dbJournal = TAC_APP_LIST_DB + std::string("-journal");
202 if (!copyFile(dbRestoreJournal, dbJournal)) {
203 fprintf(stderr, "Failed to copy of %s\n", dbJournal.c_str());
204 return TAC_ERROR_UNKNOWN;
206 if (!removeFile(dbRestoreJournal)) {
207 fprintf(stderr, "Failed to remove of %s\n", dbRestoreJournal.c_str());
208 return TAC_ERROR_UNKNOWN;
210 if (chown(dbJournal.c_str(), g_uid, g_gid) == -1) {
211 fprintf(stderr, "Failed to change owner and group name\n");
216 return TAC_ERROR_NONE;
219 tac_error_e disableTACPackage(const std::string& pkgId)
221 std::string rootPath = getRootPath(pkgId);
222 if (rootPath.empty()) {
223 fprintf(stderr, "Failed to get root path from [%s]\n", pkgId.c_str());
224 return TAC_ERROR_INVALID_PACKAGE;
227 std::string binDir = concatPath(rootPath, "bin");
228 std::string tacDir = concatPath(binDir, TAC_SYMLINK_SUB_DIR);
229 std::string binNIDir = concatPath(binDir, APP_NI_SUB_DIR);
230 if (bf::exists(tacDir)) {
232 for (auto& symlinkAssembly : bf::recursive_directory_iterator(tacDir)) {
233 std::string symPath = symlinkAssembly.path().string();
234 std::string fileName = symlinkAssembly.path().filename().string();
235 if (bf::is_symlink(symPath)) {
236 std::string originPath = bf::read_symlink(symPath).string();
237 if (!isNativeImage(symPath)) {
238 std::string dllPath = concatPath(binDir, fileName);
239 if (!copyFile(originPath, dllPath)) {
240 fprintf(stderr, "Failed to copy of %s\n", dllPath.c_str());
241 return TAC_ERROR_UNKNOWN;
243 copySmackAndOwnership(binDir.c_str(), concatPath(binDir, fileName).c_str());
245 std::string niPath = concatPath(binNIDir, fileName);
246 if (!copyFile(originPath, niPath)) {
247 fprintf(stderr, "Failed to copy of %s\n", niPath.c_str());
248 return TAC_ERROR_UNKNOWN;
250 copySmackAndOwnership(binDir.c_str(), niPath.c_str());
254 if (!removeAll(tacDir)) {
255 fprintf(stderr, "Failed to remove of %s\n", tacDir.c_str());
256 return TAC_ERROR_UNKNOWN;
258 } catch (const bf::filesystem_error& error) {
259 fprintf(stderr, "Failed to recursive directory: %s\n", error.what());
260 return TAC_ERROR_UNKNOWN;
263 return TAC_ERROR_NONE;
266 tac_error_e enableTACPackage(const std::string& pkgId)
268 std::string rootPath = getRootPath(pkgId);
269 if (rootPath.empty()) {
270 fprintf(stderr, "Failed to get root path from [%s]\n", pkgId.c_str());
271 return TAC_ERROR_INVALID_PACKAGE;
274 std::string execName = getExecName(pkgId);
275 if (execName.empty()) {
276 fprintf(stderr, "Failed to get exec name from [%s]\n", pkgId.c_str());
277 return TAC_ERROR_INVALID_PACKAGE;
280 std::string metaValue = getMetadataValue(pkgId, TAC_METADATA_KEY);
281 if (metaValue.empty()) {
282 fprintf(stderr, "Failed to get metadata from [%s]\n", pkgId.c_str());
283 return TAC_ERROR_INVALID_PACKAGE;
286 if (!strcmp(metaValue.c_str(), "true")) {
287 std::string binDir = concatPath(rootPath, "bin");
288 std::string tacDir = concatPath(binDir, TAC_SYMLINK_SUB_DIR);
289 std::string binNIDir = concatPath(binDir, APP_NI_SUB_DIR);
290 if (!bf::exists(tacDir)) {
291 if (!createDir(tacDir)) {
292 fprintf(stderr, "Cannot create directory: %s\n", tacDir.c_str());
293 return TAC_ERROR_UNKNOWN;
295 copySmackAndOwnership(binDir.c_str(), tacDir.c_str());
297 std::vector<std::string> enableNuget;
298 for (auto& npAssembly : depsJsonParser(rootPath, execName)) {
299 std::string nugetPackage = npAssembly.substr(0, npAssembly.rfind(':'));
300 std::string assemblyName = npAssembly.substr(npAssembly.rfind(':') + 1);
301 std::string nugetPath = concatPath(__DOTNET_DIR, nugetPackage);
302 if (bf::exists(nugetPath)) {
303 std::string originPath = concatPath(nugetPath, assemblyName);
304 if (bf::exists(originPath)) {
305 enableNuget.push_back(originPath);
310 for (auto& originPath : enableNuget) {
311 if (bf::exists(originPath)) {
312 std::string fileName = originPath.substr(originPath.rfind('/') + 1);
313 std::string NIFileName = fileName.substr(0, fileName.rfind(".dll")) + ".ni.dll";
314 if (bf::exists(binNIDir)) {
315 std::string originNIPath = originPath.substr(0, originPath.rfind(".dll")) + ".ni.dll";
316 if (bf::exists(originNIPath)) {
317 bf::create_symlink(originNIPath, concatPath(tacDir, NIFileName));
318 fprintf(stdout, "%s symbolic link file generated successfully.\n", concatPath(tacDir, NIFileName).c_str());
319 copySmackAndOwnership(tacDir.c_str(), concatPath(tacDir, NIFileName).c_str(), true);
321 if (!removeFile(concatPath(binNIDir, NIFileName))) {
322 fprintf(stderr, "Failed to remove of %s\n", concatPath(binNIDir, NIFileName).c_str());
323 return TAC_ERROR_UNKNOWN;
327 bf::create_symlink(originPath, concatPath(tacDir, fileName));
328 fprintf(stdout, "%s symbolic link file generated successfully.\n", concatPath(tacDir, fileName).c_str());
329 copySmackAndOwnership(tacDir.c_str(), concatPath(tacDir, fileName).c_str(), true);
331 if (!removeFile(concatPath(binDir, fileName))) {
332 fprintf(stderr, "Failed to remove of %s\n", concatPath(binDir, fileName).c_str());
333 return TAC_ERROR_UNKNOWN;
337 if (enableNuget.empty()) {
338 if (!removeAll(tacDir)) {
339 fprintf(stderr, "Failed to remove of %s\n", tacDir.c_str());
345 fprintf(stderr, "The metadata key is missing or the metadata value is false of [%s]\n", pkgId.c_str());
347 return TAC_ERROR_NONE;
350 //Parser the .deps.json file to get nuget information.
351 std::vector<std::string> depsJsonParser(const std::string& rootPath, const std::string& execName)
353 std::vector<std::string> parserData;
354 std::string depsJsonName = execName.substr(0, execName.rfind(".dll")) + ".deps.json";
355 std::string depsJsonPath = concatPath(rootPath, depsJsonName);
357 if (bf::exists(depsJsonPath)) {
358 std::ifstream ifs(depsJsonPath);
359 Json::CharReaderBuilder reader;
363 if (!Json::parseFromStream(reader, ifs, &root, &error)) {
364 _ERR("Failed to parse of deps.json");
368 const Json::Value runtimeTargetName = root["runtimeTarget"]["name"];
369 const Json::Value nugetPackages = root["targets"][runtimeTargetName.asString().c_str()];
370 std::vector<std::string> appDependencies;
371 for (auto& nuget : nugetPackages.getMemberNames()) {
372 if (strstr(nuget.c_str(), (execName.substr(0, execName.find(".Tizen."))).c_str()) != NULL ||
373 strstr(nuget.c_str(), (execName.substr(0, execName.find(".dll"))).c_str()) != NULL) {
374 const Json::Value assemblies = nugetPackages[nuget.c_str()]["runtime"];
375 if (assemblies != Json::nullValue) {
376 const Json::Value dependencies = nugetPackages[nuget.c_str()]["dependencies"];
377 for (auto& dependency : dependencies.getMemberNames()) {
378 appDependencies.push_back(dependency);
383 for (auto& nuget : nugetPackages.getMemberNames()) {
384 //Skip the nuget package related to Tizen
385 if (strstr(nuget.c_str(), TIZEN_DOTNET_NUGET) == NULL &&
386 strstr(nuget.c_str(), TIZEN_DOTNET_SDK_NUGET) == NULL &&
387 strstr(nuget.c_str(), (execName.substr(0, execName.find(".Tizen."))).c_str()) == NULL &&
388 strstr(nuget.c_str(), (execName.substr(0, execName.find(".dll"))).c_str()) == NULL) {
389 const Json::Value assemblies = nugetPackages[nuget.c_str()]["runtime"];
390 if (assemblies != Json::nullValue) {
391 const Json::Value dependencies = nugetPackages[nuget.c_str()]["dependencies"];
392 bool hasDependency = false;
393 for (auto& dependency : dependencies.getMemberNames()) {
394 //Skip the nugget package that is dependent on another nuget package
395 if (strstr(dependency.c_str(), TIZEN_DOTNET_NUGET) == NULL &&
396 strstr(dependency.c_str(), NET_STANDARD_LIBRARY_NUGET) == NULL) {
397 hasDependency = true;
398 for (auto& ad : appDependencies) {
399 if (!strcmp(ad.c_str(), dependency.c_str())) {
400 hasDependency = true;
403 hasDependency = false;
406 if (hasDependency) break;
409 if (!hasDependency) {
410 // handle assembly even though that is included in the TPA.
411 for (auto& assembly : assemblies.getMemberNames()) {
412 std::string assemblyName = assembly.substr(assembly.rfind('/') + 1);
413 parserData.push_back(nuget + ":" + assemblyName);
414 _INFO("Nuget : [%s] / Assembly : [%s]", nuget.c_str(), assemblyName.c_str());
420 appDependencies.clear();
424 } catch (const Json::LogicError& error) {
425 _ERR("Failed to parse Json: %s", error.what());
430 std::vector<std::string> getLibrariesInfo(const std::string& rootPath)
432 std::vector<std::string> LibrariesInfo;
433 std::vector<std::string> unusedDir;
434 std::string runtimesDir = concatPath(rootPath, "bin/runtimes");
435 if (!bf::exists(runtimesDir))
436 return LibrariesInfo;
439 sprintf(buffer, "(tizen|linux|unix|base|any)(.\\d.\\d.\\d)?(-%s)?", ARCHITECTURE_IDENTIFIER);
440 std::regex pattern(buffer);
443 for (auto& path : bf::recursive_directory_iterator(runtimesDir)) {
444 std::string filepath = path.path().string();
445 std::size_t pos = filepath.rfind("/runtimes/");
446 if (pos != std::string::npos) {
447 std::string targetDir = filepath.substr(pos + 10);
448 if (!std::regex_match(targetDir.substr(0, targetDir.find('/')), pattern)) {
449 if (isDirectory(filepath))
450 unusedDir.push_back(filepath);
454 if (filepath.rfind(".so") == std::string::npos)
457 std::string buffer = SHA256(filepath);
458 LibrariesInfo.push_back(filepath + ":" + buffer);
459 _INFO("Library : [%s] / SHA256 : [%s]", filepath.substr(filepath.rfind('/') + 1).c_str(), buffer.c_str());
461 } catch (const bf::filesystem_error& error) {
462 _ERR("Failed to recursive directory: %s", error.what());
465 for (auto& path : unusedDir) {
466 if (!removeAll(path)) {
467 _ERR("Failed to remove of %s", path.c_str());
472 return LibrariesInfo;
475 // callback function of "pkgmgrinfo_appinfo_metadata_filter_foreach"
476 static int tlc_restoreDBCb(pkgmgrinfo_appinfo_h handle, void *userData)
480 std::string rootPath;
482 int ret = pkgmgrinfo_appinfo_get_pkgid(handle, &pkgId);
483 if (ret != PMINFO_R_OK) {
484 fprintf(stderr, "Failed to get pkgid\n");
488 ret = pkgmgrinfo_appinfo_get_root_path(handle, &root);
489 if (ret != PMINFO_R_OK) {
490 fprintf(stderr, "Failed to get root path\n");
493 rootPath = std::string(root);
495 for (auto& librarySha : getLibrariesInfo(rootPath)) {
496 std::string library = librarySha.substr(0, librarySha.find(':'));
497 if (bf::exists(library)) {
498 std::string fileSha = library.substr(library.rfind('/') + 1) + ".." + librarySha.substr(librarySha.find(':') + 1);
499 char *sql = sqlite3_mprintf("INSERT INTO TLC (PKGID, LIBRARY) VALUES (%Q, %Q);", pkgId, fileSha.c_str());
500 insertDB(tlc_db, sql);
501 restore_library.push_back(fileSha);
508 tac_error_e tlc_restoreDB()
510 if (!removeFile(TLC_APP_LIST_RESTORE_DB)) {
511 fprintf(stderr, "Failed to remove of %s\n", TLC_APP_LIST_RESTORE_DB);
512 return TAC_ERROR_UNKNOWN;
515 std::string dbRestoreJournal = TLC_APP_LIST_RESTORE_DB + std::string("-journal");
516 if (!removeFile(dbRestoreJournal)) {
517 fprintf(stderr, "Failed to remove of %s\n", dbRestoreJournal.c_str());
518 return TAC_ERROR_UNKNOWN;
521 tlc_db = createDB(TLC_APP_LIST_RESTORE_DB, CREATE_TLC_DB_TABLE);
523 fprintf(stderr, "Sqlite create error\n");
524 return TAC_ERROR_UNKNOWN;
526 sqlite3_exec(tlc_db, "BEGIN;", NULL, NULL, NULL);
528 pkgmgrinfo_appinfo_metadata_filter_h handle;
529 int ret = pkgmgrinfo_appinfo_metadata_filter_create(&handle);
530 if (ret != PMINFO_R_OK) {
531 return TAC_ERROR_UNKNOWN;
534 ret = pkgmgrinfo_appinfo_metadata_filter_add(handle, TAC_METADATA_KEY, METADATA_VALUE);
535 if (ret != PMINFO_R_OK) {
536 pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
537 return TAC_ERROR_UNKNOWN;
540 ret = pkgmgrinfo_appinfo_metadata_filter_foreach(handle, tlc_restoreDBCb, NULL);
541 if (ret != PMINFO_R_OK) {
542 fprintf(stderr, "Failed pkgmgrinfo_appinfo_metadata_filter_foreach\n");
543 pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
544 return TAC_ERROR_UNKNOWN;
546 fprintf(stdout, "Success pkgmgrinfo_appinfo_metadata_filter_foreach\n");
548 pkgmgrinfo_appinfo_metadata_filter_destroy(handle);
555 const uid_t g_uid = 301; // app_fw
556 const gid_t g_gid = 301; // app_fw
558 if (!copyFile(TLC_APP_LIST_RESTORE_DB, TLC_APP_LIST_DB)) {
559 fprintf(stderr, "Failed to copy of %s\n", TLC_APP_LIST_DB);
560 return TAC_ERROR_UNKNOWN;
562 if (!removeFile(TLC_APP_LIST_RESTORE_DB)) {
563 fprintf(stderr, "Failed to remove of %s\n", TLC_APP_LIST_RESTORE_DB);
564 return TAC_ERROR_UNKNOWN;
566 if (chown(TLC_APP_LIST_DB, g_uid, g_gid) == -1) {
567 fprintf(stderr, "Failed to change owner and group name\n");
570 std::string dbJournal = TLC_APP_LIST_DB + std::string("-journal");
571 if (!copyFile(dbRestoreJournal, dbJournal)) {
572 fprintf(stderr, "Failed to copy of %s\n", dbJournal.c_str());
573 return TAC_ERROR_UNKNOWN;
575 if (!removeFile(dbRestoreJournal)) {
576 fprintf(stderr, "Failed to remove of %s\n", dbRestoreJournal.c_str());
577 return TAC_ERROR_UNKNOWN;
579 if (chown(dbJournal.c_str(), g_uid, g_gid) == -1) {
580 fprintf(stderr, "Failed to change owner and group name\n");
583 auto convert = [](const std::string& path, const std::string& filename) {
584 bool isExist = false;
585 for (auto& library : restore_library) {
586 if (!strcmp(filename.c_str(), library.c_str())) {
592 if (!removeFile(path)) {
593 _ERR("Failed to remove of %s", path.c_str());
598 scanFilesInDirectory(concatPath(__DOTNET_DIR, TLC_LIBRARIES_DIR), convert, 0);
600 return TAC_ERROR_NONE;