2 * Copyright (c) 2016 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.
23 #include <pkgmgr_installer_info.h>
24 #include <sys/smack.h>
25 #include <sys/prctl.h>
27 #include <openssl/evp.h>
28 #include <openssl/crypto.h>
35 #include <unordered_map>
45 #include "path_manager.h"
46 #include "r2r_checker.h"
48 static bool iCompare(const std::string& a, int aOffset, const std::string& b, int bOffset, int length)
50 return static_cast<int>(a.length()) - length >= aOffset &&
51 static_cast<int>(b.length()) - length >= bOffset &&
52 std::equal(b.begin() + bOffset, b.begin() + bOffset + length, a.begin() + aOffset,
53 [](unsigned char a, unsigned char b)
54 { return std::tolower(a) == std::tolower(b); });
57 bool isManagedAssembly(const std::string& fileName)
59 return iCompare(fileName, fileName.size()-4, ".dll", 0, 4) && !isR2RImage(fileName);
62 std::string concatPath(const std::string& path1, const std::string& path2)
64 std::string path(path1);
65 if (path.back() == PATH_SEPARATOR) {
68 path += PATH_SEPARATOR;
75 void splitPath(const std::string& path, std::vector<std::string>& out)
77 std::istringstream ss(path);
80 while (std::getline(ss, token, ':')) {
87 std::string getAbsolutePath(const std::string& path)
90 char *realPath = realpath(path.c_str(), NULL);
92 absPath.assign(realPath);
99 std::string getRootPath(const std::string& pkgId)
103 std::string rootPath;
105 pkgmgrinfo_pkginfo_h pkg_handle;
106 ret = pkgmgrGetPkgInfo(pkgId, &pkg_handle);
111 ret = pkgmgrinfo_pkginfo_get_root_path(pkg_handle, &path);
112 if (ret != PMINFO_R_OK) {
113 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
117 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
122 std::string getExecName(const std::string& pkgId)
126 std::string execName;
128 pkgmgrinfo_pkginfo_h pkg_handle;
129 int ret = pkgmgrGetPkgInfo(pkgId, &pkg_handle);
134 ret = pkgmgrinfo_pkginfo_get_mainappid(pkg_handle, &appId);
135 if (ret != PMINFO_R_OK) {
136 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
140 pkgmgrinfo_appinfo_h app_handle;
141 ret = pkgmgrGetAppInfo(appId, &app_handle);
143 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
147 ret = pkgmgrinfo_appinfo_get_exec(app_handle, &exec);
148 if (ret != PMINFO_R_OK) {
149 pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
150 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
153 execName = std::string(exec).substr(std::string(exec).rfind('/') + 1);
155 pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
156 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
161 std::string getAppType(const std::string& pkgId)
167 pkgmgrinfo_pkginfo_h pkg_handle;
168 int ret = pkgmgrGetPkgInfo(pkgId, &pkg_handle);
173 ret = pkgmgrinfo_pkginfo_get_mainappid(pkg_handle, &appId);
174 if (ret != PMINFO_R_OK) {
175 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
179 pkgmgrinfo_appinfo_h app_handle;
180 ret = pkgmgrGetAppInfo(appId, &app_handle);
182 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
186 ret = pkgmgrinfo_appinfo_get_apptype(app_handle, &type);
187 if (ret != PMINFO_R_OK) {
188 pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
189 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
194 pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
195 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
200 std::string getMetadataValue(const std::string& pkgId, const std::string& key)
204 std::string metadataValue;
206 pkgmgrinfo_pkginfo_h pkg_handle;
207 int ret = pkgmgrGetPkgInfo(pkgId, &pkg_handle);
209 return metadataValue;
212 ret = pkgmgrinfo_pkginfo_get_mainappid(pkg_handle, &appId);
213 if (ret != PMINFO_R_OK) {
214 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
215 return metadataValue;
218 pkgmgrinfo_appinfo_h app_handle;
219 ret = pkgmgrGetAppInfo(appId, &app_handle);
221 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
222 return metadataValue;
225 ret = pkgmgrinfo_appinfo_get_metadata_value(app_handle, key.c_str(), &value);
226 if (ret != PMINFO_R_OK) {
227 pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
228 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
229 return metadataValue;
231 metadataValue = std::string(value);
233 pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
234 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
236 return metadataValue;
239 bool isReadOnlyArea(const std::string& path)
242 struct mntent *m = NULL;
244 // "/opt/usr" is mounted to "RW" only
245 if (path.find("/opt/usr") != std::string::npos) {
249 // check whether "/" is mounted to RO or not
250 f = setmntent("/proc/mounts", "r");
252 // return true for fail case to generate NI files under RW area.
256 while((m = getmntent(f))) {
257 if (m->mnt_dir != NULL && strcmp(m->mnt_dir, "/") == 0 &&
258 m->mnt_opts != NULL && strstr(m->mnt_opts, "ro,") != NULL) {
268 std::string getBaseName(const std::string& path)
270 auto pos = path.find_last_of(PATH_SEPARATOR);
271 if (pos != std::string::npos)
272 return path.substr(0, pos);
274 return std::string(".");
278 std::string replaceAll(const std::string& str, const std::string& pattern, const std::string& replace)
280 std::string result = str;
281 std::string::size_type pos = 0;
282 std::string::size_type offset = 0;
284 while ((pos = result.find(pattern, offset)) != std::string::npos) {
285 result.replace(result.begin() + pos, result.begin() + pos + pattern.size(), replace);
286 offset = pos + replace.size();
292 std::string changeExtension(const std::string& path, const std::string& from, const std::string& to)
294 return path.substr(0, path.rfind(from)) + to;
297 bool isFile(const std::string& path)
300 return lstat(path.c_str(), &sb) == 0;
303 bool isSymlinkFile(const std::string& path)
306 if (lstat(path.c_str(), &sb) != 0) {
309 return (sb.st_mode & S_IFMT) == S_IFLNK;
312 bool isDirectory(const std::string& path)
315 if (stat(path.c_str(), &sb) != 0) {
318 return (sb.st_mode & S_IFMT) == S_IFDIR;
321 std::string getAssemblyNameFromPath(const std::string& path)
323 std::string ret(getFileName(path));
325 if (ret.find_last_of(".") == std::string::npos)
327 ret.erase(ret.find_last_of("."));
329 if (ret.size() > 3 && std::equal(ret.begin() + ret.size() - 3, ret.end(), ".ni"))
330 ret.erase(ret.size() - 3);
335 void addAssembliesFromDirectories(const std::vector<std::string>& directories, std::string& list)
337 std::vector<std::string> assems;
338 std::unordered_map<std::string, std::string> assemPaths;
340 auto reader = [&assems, &assemPaths](const std::string& path, const std::string& filename) {
341 if (isManagedAssembly(filename) || isR2RImage(filename)) {
342 std::string assem = getAssemblyNameFromPath(filename);
344 if (assemPaths.count(assem) == 0) {
345 assems.push_back(assem);
346 assemPaths[assem] = path;
347 } else if (isManagedAssembly(assemPaths[assem]) && isR2RImage(filename)) {
348 // Update only if a native image is found in the same directory.
349 // For example, if we have two directories = { X, Y } where X contains A.dll and
350 // Y contains both A.dll and A.ni.dll, always A.dll in X will be used.
351 if (getBaseName(assemPaths[assem]).compare(getBaseName(path)) == 0)
352 assemPaths[assem] = path;
356 for (auto& directory : directories)
357 scanFilesInDirectory(directory, reader, 0);
359 if (!list.empty() && list.back() != ':')
362 for (auto& assem : assems)
363 list += assemPaths[assem] + ":";
365 if (list.back() == ':')
369 void scanFilesInDirectory(const std::string& directory, FileReader reader, unsigned int depth)
372 struct dirent* entry;
375 dir = opendir(directory.c_str());
380 std::vector<std::string> innerDirectories;
382 while ((entry = readdir(dir)) != nullptr) {
384 std::string path = concatPath(directory, entry->d_name);
385 switch (entry->d_type) {
390 // symlink is added to the list even if there is no original file.
391 // It used to remove broken symlinks related to TAC
400 reader(path, entry->d_name);
401 else if (depth > 0 && strcmp(entry->d_name, ".") && strcmp(entry->d_name, ".."))
402 innerDirectories.push_back(path);
406 for (auto& d : innerDirectories)
407 scanFilesInDirectory(d, reader, depth - 1);
412 void copySmackAndOwnership(const std::string& fromPath, const std::string& toPath, bool isSymlink)
418 // change smack label for symbolic link.
419 if (smack_lgetlabel(fromPath.c_str(), &label, SMACK_LABEL_ACCESS) == 0) {
420 if (smack_lsetlabel(toPath.c_str(), label, SMACK_LABEL_ACCESS) < 0) {
421 _SERR("Fail to set smack label");
426 // change owner and groupsfor symbolic link.
427 // change mode is skipped for symlink because permission of symlink file is meaningless.
428 if (!lstat(fromPath.c_str(), &info)) {
429 if (lchown(toPath.c_str(), info.st_uid, info.st_gid) == -1)
430 _SERR("Failed to change owner and group name");
433 // change smack label
434 if (smack_getlabel(fromPath.c_str(), &label, SMACK_LABEL_ACCESS) == 0) {
435 if (smack_setlabel(toPath.c_str(), label, SMACK_LABEL_ACCESS) < 0) {
436 _SERR("Fail to set smack label");
441 // change owner, groups and mode for generated ni file.
442 if (!stat(fromPath.c_str(), &info)) {
443 if (chown(toPath.c_str(), info.st_uid, info.st_gid) == -1)
444 _SERR("Failed to change owner and group name");
445 if (chmod(toPath.c_str(), info.st_mode) == -1)
446 _SERR("Failed to change mode");
451 static bool setOwnership(const bf::path& path, uid_t uid, gid_t gid)
453 int fd = open(path.c_str(), O_RDONLY);
455 _ERR("Can't open directory: %s", path.c_str());
458 int ret = fchown(fd, uid, gid);
461 _ERR("Failed to change owner of: %s", path.c_str());
467 static bool setDirPermissions(const bf::path& path, bf::perms permissions)
469 bs::error_code error;
470 bf::permissions(path, permissions, error);
472 _ERR("Failed to set permissions for directory: %s, %s", path.c_str(), error.message().c_str());
478 static bool setDirOwnershipAndPermissions(const bf::path& path, bf::perms permissions, uid_t uid, gid_t gid)
480 if (!setOwnership(path, uid, gid)) {
481 _ERR("Failed to change owner: %s, (uid: %d, gid: %d)", path.c_str(), uid, gid);
484 if (!setDirPermissions(path, permissions)) {
485 _ERR("Failed to change permission: %s, (%d)", path.c_str(), permissions);
491 static bool copyOwnershipAndPermissions(const bf::path& path, const bf::path& path2)
494 _ERR("Failed to copy ownership and permissions from %s to %s", path.c_str(), path2.c_str());
497 bs::error_code error;
498 bf::perms permissions = bf::status(path, error).permissions();
500 _ERR("Failed to copy ownership and permissions : %s", error.message().c_str());
504 if (stat(path.c_str(), &stats) != 0) {
507 if (!setDirOwnershipAndPermissions(path2, permissions, stats.st_uid, stats.st_gid)) {
508 _ERR("Failed to copy ownership and permissions from %s to %s", path.c_str(), path2.c_str());
514 bool exist(const bf::path& path)
516 bs::error_code error;
517 int ret = bf::exists(path, error);
519 if ((error.value() != bs::errc::success) && (error.value() != bs::errc::no_such_file_or_directory)) {
520 _ERR("Failed to check %s exists : %s", path.c_str(), error.message().c_str());
526 bool createDir(const bf::path& path)
531 bs::error_code error;
532 bf::create_directories(path, error);
534 _ERR("Failed to create directory: %s", error.message().c_str());
540 bool copyDir(const bf::path& path1, const bf::path& path2, FSFlag flags)
543 // Check whether the function call is valid
544 if (!exist(path1) || !bf::is_directory(path1)) {
545 _ERR("Source directory %s does not exist or is not a directory", path1.c_str());
549 // Create the destination directory
550 if (!createDir(path2)) {
551 _ERR("Unable to create destination directory %s", path2.c_str());
554 if (flags & FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS) {
555 copyOwnershipAndPermissions(path1, path2);
558 if (!(flags & (FS_MERGE_SKIP | FS_MERGE_OVERWRITE))) {
559 _ERR("Destination directory %s already exists", path2.c_str());
562 if (flags & (FS_MERGE_OVERWRITE | FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS)) {
563 copyOwnershipAndPermissions(path1, path2);
566 } catch (const bf::filesystem_error& error) {
567 _ERR("Failed to copy directory: %s", error.what());
571 // Iterate through the source directory
573 for (bf::directory_iterator file(path1); file != bf::directory_iterator(); ++file) {
574 bf::path current(file->path());
575 bf::path target = path2 / current.filename();
576 if (bf::is_symlink(bf::symlink_status(current))) {
577 if ((flags & (FS_MERGE_SKIP | FS_MERGE_OVERWRITE)) && exist(target)) {
580 bs::error_code error;
581 bf::copy_symlink(current, target, error);
583 _ERR("Failed to copy symlink: %s, %s", current.c_str(), error.message().c_str());
586 } else if (bf::is_directory(current)) {
587 // Found directory: Recursion
588 if (!copyDir(current, target, flags)) {
592 if ((flags & FS_MERGE_SKIP) && exist(target)) {
595 bf::path destination = target;
596 if (flags & FS_COMMIT_COPY_FILE) {
597 destination = bf::unique_path(target.parent_path() / "%%%%-%%%%-%%%%-%%%%");
599 if (flags & FS_MERGE_OVERWRITE) {
600 bf::copy_file(current, destination, bf::copy_option::overwrite_if_exists);
602 bf::copy_file(current, destination);
604 if (flags & FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS) {
605 copyOwnershipAndPermissions(current, destination);
607 if (flags & FS_COMMIT_COPY_FILE) {
608 if (flags & FS_MERGE_OVERWRITE) {
611 bf::rename(destination, target);
615 } catch (const bf::filesystem_error& error) {
616 _ERR("Failed to copy directory: %s", error.what());
623 bool copyFile(const bf::path& path1, const bf::path& path2)
625 bs::error_code error;
629 bf::copy_file(path1, path2, bf::copy_option::overwrite_if_exists, error);
631 _ERR("copy file %s due to error [%s]", path1.c_str(), error.message().c_str());
637 bool moveFile(const bf::path& path1, const bf::path& path2)
639 if (!exist(path1) || exist(path2)) {
642 bs::error_code error;
643 bf::rename(path1, path2, error);
645 _ERR("Cannot move file: %s. Will copy/remove... with error [%s]", path1.c_str(), error.message().c_str());
646 bf::copy_file(path1, path2, bf::copy_option::overwrite_if_exists, error);
648 _ERR("Cannot copy file %s due to error [%s]", path1.c_str(), error.message().c_str());
651 bf::remove_all(path1, error);
653 _ERR("Cannot remove old file when coping: %s with error [%s]", path1.c_str(), error.message().c_str());
660 bool removeFile(const bf::path& path)
665 bs::error_code error;
666 bf::remove(path, error);
668 _ERR("Cannot remove: %s, %s", path.c_str(), error.message().c_str());
674 bool removeAll(const bf::path& path)
679 bs::error_code error;
680 bf::remove_all(path, error);
682 _ERR("Cannot remove: %s, %s", path.c_str(), error.message().c_str());
688 void setCmdName(const std::string& name)
690 #define PRC_NAME_LENGTH 16
692 char processName[PRC_NAME_LENGTH] = {0, };
697 memset(processName, '\0', PRC_NAME_LENGTH);
698 snprintf(processName, PRC_NAME_LENGTH, "%s", name.c_str());
699 prctl(PR_SET_NAME, processName);
702 std::string getFileName(const std::string& path)
704 std::string ret(path);
705 size_t index = ret.find_last_of(PATH_SEPARATOR);
706 return index == std::string::npos ? ret : ret.substr(index + 1);
709 std::string SHA256(const std::string& path)
712 const int bufSize = 32768;
714 unsigned int digest_len = 0;
715 unsigned char* digest = NULL;
717 std::stringstream ss;
718 EVP_MD_CTX *mdctx = NULL;
719 std::string output = "";
721 FILE *file = fopen(path.c_str(), "rb");
726 char *buffer = (char*)malloc(bufSize);
731 mdctx = EVP_MD_CTX_new();
733 _ERR("Message Digest Context creation NULL");
737 digest = (unsigned char*)OPENSSL_malloc(EVP_MD_size(EVP_sha256()));
739 _ERR("Memory Allocation for SHA256 failed");
743 if (!EVP_DigestInit_ex(mdctx, EVP_sha256(), NULL)) {
744 _ERR("Message Digest init failed");
748 while ((bytesRead = fread(buffer, 1, bufSize, file))) {
749 if (!EVP_DigestUpdate(mdctx, buffer, bytesRead)) {
750 _ERR("Message Digest update failed");
755 if (!EVP_DigestFinal_ex(mdctx, digest, &digest_len)) {
756 _ERR("Message Digest Finalization falied");
760 for (unsigned int i = 0; i < digest_len; i++) {
761 ss << std::hex << std::setw(2) << std::setfill('0') << (int)digest[i];
766 EVP_MD_CTX_free(mdctx);
768 OPENSSL_free(digest);
777 int pkgmgrGetPkgInfo(const std::string& pkgId, pkgmgrinfo_pkginfo_h* handle)
782 if (pkgmgr_installer_info_get_target_uid(&uid) < 0) {
783 _ERR("Failed to get UID");
787 ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgId.c_str(), uid, handle);
788 if (ret != PMINFO_R_OK) {
789 _ERR("Failed to get pkginfo (%d)", ret);
796 int pkgmgrGetAppInfo(const std::string& appId, pkgmgrinfo_appinfo_h* handle)
801 if (pkgmgr_installer_info_get_target_uid(&uid) < 0) {
802 _ERR("Failed to get UID");
806 ret = pkgmgrinfo_appinfo_get_usr_appinfo(appId.c_str(), uid, handle);
807 if (ret != PMINFO_R_OK) {
808 _ERR("Failed to get appinfo (%d)", ret);
815 int pkgmgrMDFilterForeach(pkgmgrinfo_appinfo_metadata_filter_h handle,
816 pkgmgrinfo_app_list_cb app_cb,
822 if (pkgmgr_installer_info_get_target_uid(&uid) < 0) {
823 _ERR("Failed to get UID");
828 ret = pkgmgrinfo_appinfo_usr_metadata_filter_foreach(handle, app_cb, user_data, uid);
829 if (ret != PMINFO_R_OK) {
830 _ERR("Failed to execute the metadata filter query (%d)", ret);
837 void printHWClockLog(const char* format, ...)
839 char buf[1024] = {0,};
842 va_start(ap, format);
843 vsnprintf(buf, sizeof(buf), format, ap);
846 prctl(PR_TASK_PERF_USER_TRACE, buf, strlen(buf));
849 const char* getNCDBStartupHook()
851 return "/home/owner/share/tmp/sdk_tools/netcoredbg/ncdbhook.dll";
854 bool isNCDBStartupHookProvided()
857 env = getenv("DOTNET_STARTUP_HOOKS");
861 // Note, `DOTNET_STARTUP_HOOKS` env could provide list of dlls with ':' delimiter,
862 // for example: "/path1/name1.dll:/path2/name2.dll"
865 const char *ncdbCur = getNCDBStartupHook();
866 while (*ncdbCur != '\0' && *env != '\0' && *env != ':')
868 if (*ncdbCur != *env)
874 if (*ncdbCur == '\0' && (*env == '\0' || *env == ':'))
877 while (*env != '\0' && *env != ':')