#include <unistd.h>
#include <limits.h>
#include <strings.h>
+#include <pkgmgr-info.h>
+#include <pkgmgr_installer_info.h>
+#include <sys/smack.h>
+#include <json/json.h>
#include <cstdlib>
#include <cstring>
#include <unordered_map>
#include <vector>
#include <iterator>
+#include <fstream>
#include <sstream>
#include <map>
return iCompare(fileName, fileName.size()-7, ".ni", 0, 3);
}
+bool cmdOptionExists(char** begin, char** end, const std::string& option)
+{
+ return std::find(begin, end, option) != end;
+}
+
std::string readSelfPath()
{
char buff[PATH_MAX];
return absPath;
}
+int getRootPath(std::string pkgId, std::string& rootPath)
+{
+ int ret = 0;
+ char *path = 0;
+ uid_t uid = 0;
+
+ if (pkgmgr_installer_info_get_target_uid(&uid) < 0) {
+ _ERR("Failed to get UID");
+ return -1;
+ }
+
+ pkgmgrinfo_pkginfo_h handle;
+ if (uid == 0) {
+ ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgId.c_str(), &handle);
+ if (ret != PMINFO_R_OK) {
+ return -1;
+ }
+ } else {
+ ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgId.c_str(), uid, &handle);
+ if (ret != PMINFO_R_OK) {
+ return -1;
+ }
+ }
+
+ ret = pkgmgrinfo_pkginfo_get_root_path(handle, &path);
+ if (ret != PMINFO_R_OK) {
+ pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
+ return -1;
+ }
+ rootPath = path;
+ pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
+ return 0;
+}
+
+int getExecName(std::string pkgId, std::string& execName)
+{
+ char *exec = NULL;
+ char *appId = 0;
+
+ pkgmgrinfo_pkginfo_h pkg_handle;
+ int ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgId.c_str(), &pkg_handle);
+ if (ret != PMINFO_R_OK) {
+ return -1;
+ }
+ ret = pkgmgrinfo_pkginfo_get_mainappid(pkg_handle, &appId);
+ if (ret != PMINFO_R_OK) {
+ pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
+ return -1;
+ }
+
+ pkgmgrinfo_appinfo_h app_handle;
+ ret = pkgmgrinfo_appinfo_get_appinfo(appId, &app_handle);
+ if (ret != PMINFO_R_OK) {
+ pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
+ return -1;
+ }
+ ret = pkgmgrinfo_appinfo_get_exec(app_handle, &exec);
+ if (ret != PMINFO_R_OK) {
+ pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
+ pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
+ return -1;
+ }
+ execName = std::string(exec).substr(std::string(exec).rfind('/') + 1);
+
+ pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
+ pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
+ return 0;
+}
+
+int getMetadataValue(std::string pkgId, std::string metadataKey, std::string& metadataValue)
+{
+ char *value = NULL;
+ char *appId = 0;
+
+ pkgmgrinfo_pkginfo_h pkg_handle;
+ int ret = pkgmgrinfo_pkginfo_get_pkginfo(pkgId.c_str(), &pkg_handle);
+ if (ret != PMINFO_R_OK) {
+ return -1;
+ }
+ ret = pkgmgrinfo_pkginfo_get_mainappid(pkg_handle, &appId);
+ if (ret != PMINFO_R_OK) {
+ pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
+ return -1;
+ }
+
+ pkgmgrinfo_appinfo_h app_handle;
+ ret = pkgmgrinfo_appinfo_get_appinfo(appId, &app_handle);
+ if (ret != PMINFO_R_OK) {
+ pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
+ return -1;
+ }
+ ret = pkgmgrinfo_appinfo_get_metadata_value(app_handle, metadataKey.c_str(), &value);
+ if (ret != PMINFO_R_OK) {
+ pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
+ pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
+ //Does not return error because the metadata key may not exist.
+ return 0;
+ }
+ metadataValue = std::string(value);
+
+ pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
+ pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
+ return 0;
+}
+
std::string baseName(const std::string& path)
{
auto pos = path.find_last_of(PATH_SEPARATOR);
return path;
}
+std::string replaceAll(const std::string &str, const std::string &pattern, const std::string &replace)
+{
+ std::string result = str;
+ std::string::size_type pos = 0;
+ std::string::size_type offset = 0;
+
+ while ((pos = result.find(pattern, offset)) != std::string::npos) {
+ result.replace(result.begin() + pos, result.begin() + pos + pattern.size(), replace);
+ offset = pos + replace.size();
+ }
+
+ return result;
+}
+
bool isFileExist(const std::string& path)
{
struct stat sb;
return stat(path.c_str(), &sb) == 0;
}
+uintptr_t getFileSize(const std::string& path)
+{
+ struct stat sb;
+
+ if (stat(path.c_str(), &sb) == 0) {
+ return sb.st_size;
+ }
+
+ return 0;
+}
+
std::string stripNiDLL(const std::string& path)
{
std::string niPath(path);
struct dirent* entry;
bool isDir;
- if (strstr(directory.c_str(), "TAC.Release") != NULL)
- return; // skip nitool --regen-all-app (--r2r)
+ if (strstr(directory.c_str(), TAC_SYMLINK_SUB_DIR) != NULL)
+ return;
dir = opendir(directory.c_str());
closedir(dir);
}
+void updateAssemblyInfo(const std::string& getPath, const std::string& setPath, bool isSymlink)
+{
+ char* label = NULL;
+ struct stat info;
+
+ if (isSymlink) {
+ // change smack label for symbolic link.
+ if (smack_lgetlabel(getPath.c_str(), &label, SMACK_LABEL_ACCESS) == 0) {
+ if (smack_lsetlabel(setPath.c_str(), label, SMACK_LABEL_ACCESS) < 0) {
+ fprintf(stderr, "Fail to set smack label\n");
+ }
+ free(label);
+ }
+
+ // change owner and groups for symbolic link.
+ if (!stat(getPath.c_str(), &info)) {
+ if (lchown(setPath.c_str(), info.st_uid, info.st_gid) == -1)
+ fprintf(stderr, "Failed to change owner and group name\n");
+ }
+ } else {
+ // change smack label
+ if (smack_getlabel(getPath.c_str(), &label, SMACK_LABEL_ACCESS) == 0) {
+ if (smack_setlabel(setPath.c_str(), label, SMACK_LABEL_ACCESS) < 0) {
+ fprintf(stderr, "Fail to set smack label\n");
+ }
+ free(label);
+ }
+
+ // change owner and groups for generated ni file.
+ if (!stat(getPath.c_str(), &info)) {
+ if (chown(setPath.c_str(), info.st_uid, info.st_gid) == -1)
+ fprintf(stderr, "Failed to change owner and group name\n");
+ }
+ }
+}
+
static bool setOwnership(const bf::path& path, uid_t uid, gid_t gid) {
int fd = open(path.c_str(), O_RDONLY);
if (fd < 0) {
return true;
}
-static bool copyOwnershipAndPermissions(const bf::path& path, const bf::path& dst) {
+static bool copyOwnershipAndPermissions(const bf::path& path, const bf::path& path2) {
if (!bf::exists(path)) {
- _ERR("Failed to copy ownership and permissions from %s to %s", path.c_str(), dst.c_str());
+ _ERR("Failed to copy ownership and permissions from %s to %s", path.c_str(), path2.c_str());
return false;
}
bf::perms permissions = bf::status(path).permissions();
if (stat(path.c_str(), &stats) != 0) {
return false;
}
- if (!setDirOwnershipAndPermissions(dst, permissions, stats.st_uid, stats.st_gid)) {
- _ERR("Failed to copy ownership and permissions from %s to %s", path.c_str(), dst.c_str());
+ if (!setDirOwnershipAndPermissions(path2, permissions, stats.st_uid, stats.st_gid)) {
+ _ERR("Failed to copy ownership and permissions from %s to %s", path.c_str(), path2.c_str());
return false;
}
return true;
return true;
}
-bool copyDir(const bf::path& path, const bf::path& dst, FSFlag flags, bool skip_symlink) {
+bool copyDir(const bf::path& path1, const bf::path& path2, FSFlag flags) {
try {
// Check whether the function call is valid
- if (!bf::exists(path) || !bf::is_directory(path)) {
- _ERR("Source directory %s does not exist or is not a directory", path.c_str());
+ if (!bf::exists(path1) || !bf::is_directory(path1)) {
+ _ERR("Source directory %s does not exist or is not a directory", path1.c_str());
return false;
}
- if (!bf::exists(dst)) {
+ if (!bf::exists(path2)) {
// Create the destination directory
- if (!createDir(dst)) {
- _ERR("Unable to create destination directory %s", dst.c_str());
+ if (!createDir(path2)) {
+ _ERR("Unable to create destination directory %s", path2.c_str());
return false;
}
if (flags & FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS) {
- copyOwnershipAndPermissions(path, dst);
+ copyOwnershipAndPermissions(path1, path2);
}
} else {
if (!(flags & (FS_MERGE_SKIP | FS_MERGE_OVERWRITE))) {
- _ERR("Destination directory %s already exists", dst.c_str());
+ _ERR("Destination directory %s already exists", path2.c_str());
return false;
}
if (flags & (FS_MERGE_OVERWRITE | FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS)) {
- copyOwnershipAndPermissions(path, dst);
+ copyOwnershipAndPermissions(path1, path2);
}
}
} catch (const bf::filesystem_error& error) {
}
// Iterate through the source directory
- for (bf::directory_iterator file(path); file != bf::directory_iterator(); ++file) {
+ for (bf::directory_iterator file(path1); file != bf::directory_iterator(); ++file) {
try {
bf::path current(file->path());
- bf::path target = dst / current.filename();
+ bf::path target = path2 / current.filename();
if (bf::is_symlink(symlink_status(current))) {
- if (skip_symlink) {
- continue;
- }
if ((flags & (FS_MERGE_SKIP | FS_MERGE_OVERWRITE)) && bf::exists(target)) {
continue;
}
}
} else if (bf::is_directory(current)) {
// Found directory: Recursion
- if (!copyDir(current, target, flags, skip_symlink)) {
+ if (!copyDir(current, target, flags)) {
return false;
}
} else {
return true;
}
-bool copyFile(const bf::path& path, const bf::path& dst) {
+bool copyFile(const bf::path& path1, const bf::path& path2) {
bs::error_code error;
- bf::copy_file(path, dst, bf::copy_option::overwrite_if_exists, error);
+ if (!bf::exists(path1)) {
+ return false;
+ }
+ bf::copy_file(path1, path2, bf::copy_option::overwrite_if_exists, error);
if (error) {
- _ERR("copy file %s due to error [%s]", path.c_str(), error.message().c_str());
+ _ERR("copy file %s due to error [%s]", path1.c_str(), error.message().c_str());
return false;
}
return true;
}
-bool moveFile(const bf::path& path, const bf::path& dst, bool force) {
- if (!force && bf::exists(dst)) {
+bool moveFile(const bf::path& path1, const bf::path& path2) {
+ if (!bf::exists(path1) || bf::exists(path2)) {
return false;
}
bs::error_code error;
- bf::rename(path, dst, error);
+ bf::rename(path1, path2, error);
if (error) {
- _ERR("Cannot move file: %s. Will copy/remove... with error [%s]", path.c_str(), error.message().c_str());
- bf::copy_file(path, dst, bf::copy_option::overwrite_if_exists, error);
+ _ERR("Cannot move file: %s. Will copy/remove... with error [%s]", path1.c_str(), error.message().c_str());
+ bf::copy_file(path1, path2, bf::copy_option::overwrite_if_exists, error);
if (error) {
- _ERR("Cannot copy file %s due to error [%s]", path.c_str(), error.message().c_str());
+ _ERR("Cannot copy file %s due to error [%s]", path1.c_str(), error.message().c_str());
return false;
}
- bf::remove_all(path, error);
+ bf::remove_all(path1, error);
if (error) {
- _ERR("Cannot remove old file when coping: %s with error [%s]", path.c_str(), error.message().c_str());
+ _ERR("Cannot remove old file when coping: %s with error [%s]", path1.c_str(), error.message().c_str());
return false;
}
}
return false;
}
return true;
+}
+
+//Parser the .deps.json file to get nuget information.
+std::vector<std::string> depsJsonParser(std::string rootPath, std::string execName, std::string tpaList)
+{
+ std::vector<std::string> tpaAssemblies;
+ splitPath(tpaList, tpaAssemblies);
+
+ std::vector<std::string> parserData;
+ std::string depsJsonName = execName.substr(0, execName.rfind(".dll")) + ".deps.json";
+ std::string depsJsonPath = concatPath(rootPath, depsJsonName);
+ try {
+ if (bf::exists(depsJsonPath)) {
+ std::ifstream ifs(depsJsonPath);
+ Json::CharReaderBuilder reader;
+ Json::Value root;
+ std::string error;
+ if (ifs.is_open()) {
+ if (!Json::parseFromStream(reader, ifs, &root, &error)) {
+ _ERR("Failed to parse of deps.json");
+ ifs.close();
+ tpaAssemblies.clear();
+ return parserData;
+ }
+ const Json::Value runtimeTargetName = root["runtimeTarget"]["name"];
+ const Json::Value nugetPackages = root["targets"][runtimeTargetName.asString().c_str()];
+ std::vector<std::string> appDependencies;
+ for (auto& nuget : nugetPackages.getMemberNames()) {
+ if (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) {
+ const Json::Value assemblies = nugetPackages[nuget.c_str()]["runtime"];
+ if (assemblies != Json::nullValue) {
+ const Json::Value dependencies = nugetPackages[nuget.c_str()]["dependencies"];
+ for (auto& dependency : dependencies.getMemberNames()) {
+ appDependencies.push_back(dependency);
+ }
+ }
+ }
+ }
+ for (auto& nuget : nugetPackages.getMemberNames()) {
+ //Skip the nuget package related to Tizen
+ 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) {
+ const Json::Value assemblies = nugetPackages[nuget.c_str()]["runtime"];
+ if (assemblies != Json::nullValue) {
+ const Json::Value dependencies = nugetPackages[nuget.c_str()]["dependencies"];
+ bool hasDependency = false;
+ for (auto& dependency : dependencies.getMemberNames()) {
+ //Skip the nugget package that is dependent on another nuget package
+ if (strstr(dependency.c_str(), TIZEN_DOTNET_NUGET) == NULL &&
+ strstr(dependency.c_str(), NET_STANDARD_LIBRARY_NUGET) == NULL) {
+ hasDependency = true;
+ for (auto& ad : appDependencies) {
+ if (!strcmp(ad.c_str(), dependency.c_str())) {
+ hasDependency = true;
+ break;
+ } else {
+ hasDependency = false;
+ }
+ }
+ if (hasDependency) break;
+ }
+ }
+ if (!hasDependency) {
+ bool isExistTpaAssembly = false;
+ for (auto& assembly : assemblies.getMemberNames()) {
+ std::string assemblyName = assembly.substr(assembly.rfind('/') + 1);
+ //Skip the assembly present in the TPA list
+ for (auto& tpa : tpaAssemblies) {
+ if (!strcmp(replaceAll(tpa, ".ni.dll", ".dll").c_str(), assembly.c_str())) {
+ isExistTpaAssembly = true;
+ break;
+ }
+ }
+ if (isExistTpaAssembly) break;
+ }
+ if (!isExistTpaAssembly) {
+ for (auto& assembly : assemblies.getMemberNames()) {
+ std::string assemblyName = assembly.substr(assembly.rfind('/') + 1);
+ parserData.push_back(nuget + ":" + assemblyName);
+ _INFO("Nuget : [%s] / Assembly : [%s]", nuget.c_str(), assemblyName.c_str());
+ }
+ }
+ }
+ }
+ }
+ }
+ appDependencies.clear();
+ ifs.close();
+ }
+ }
+ } catch (const Json::LogicError& error) {
+ _ERR("Failed to parse Json: %s", error.what());
+ }
+ tpaAssemblies.clear();
+ return parserData;
}
\ No newline at end of file