NativeLauncher/util/utils.cc

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   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
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16
  17 #include <dirent.h>
  18 #include <fcntl.h>
  19 #include <sys/stat.h>
  20 #include <unistd.h>
  21 #include <limits.h>
  22 #include <strings.h>
  23 #include <pkgmgr_installer_info.h>
  24 #include <sys/smack.h>
  25 #include <sys/prctl.h>
  26 #include <openssl/sha.h>
  27 #include <mntent.h>
  28
  29 #include <cstdlib>
  30 #include <cstring>
  31 #include <algorithm>
  32 #include <unordered_map>
  33 #include <vector>
  34 #include <iterator>
  35 #include <fstream>
  36 #include <sstream>
  37 #include <map>
  38 #include <iomanip>
  39
  40 #include "log.h"
  41 #include "utils.h"
  42 #include "path_manager.h"
  43
  44 static bool iCompare(const std::string& a, int aOffset, const std::string& b, int bOffset, int length)
  45 {
  46         return static_cast<int>(a.length()) - length >= aOffset &&
  47                 static_cast<int>(b.length()) - length >= bOffset &&
  48                 std::equal(b.begin() + bOffset, b.begin() + bOffset + length, a.begin() + aOffset,
  49                         [](unsigned char a, unsigned char b)
  50                         { return std::tolower(a) == std::tolower(b); });
  51 }
  52
  53 bool isManagedAssembly(const std::string& fileName)
  54 {
  55         return (iCompare(fileName, fileName.size()-4, ".dll", 0, 4) ||
  56                         iCompare(fileName, fileName.size()-4, ".exe", 0, 4)) &&
  57                         !isNativeImage(fileName);
  58 }
  59
  60 bool isNativeImage(const std::string& fileName)
  61 {
  62         return iCompare(fileName, fileName.size()-7, ".ni", 0, 3);
  63 }
  64
  65 std::string concatPath(const std::string& path1, const std::string& path2)
  66 {
  67         std::string path(path1);
  68         if (path.back() == PATH_SEPARATOR) {
  69                 path.append(path2);
  70         } else {
  71                 path += PATH_SEPARATOR;
  72                 path.append(path2);
  73         }
  74
  75         return path;
  76 }
  77
  78 void splitPath(const std::string& path, std::vector<std::string>& out)
  79 {
  80         std::istringstream ss(path);
  81         std::string token;
  82
  83         while (std::getline(ss, token, ':')) {
  84                 out.push_back(token);
  85         }
  86 }
  87
  88 std::string getAbsolutePath(const std::string& path)
  89 {
  90         std::string absPath;
  91         char *realPath = realpath(path.c_str(), NULL);
  92         if (realPath) {
  93                 absPath.assign(realPath);
  94                 free(realPath);
  95         }
  96
  97         return absPath;
  98 }
  99
 100 std::string getRootPath(const std::string& pkgId)
 101 {
 102         int ret = 0;
 103         char *path = 0;
 104         std::string rootPath;
 105
 106         pkgmgrinfo_pkginfo_h pkg_handle;
 107         ret = pkgmgrGetPkgInfo(pkgId, &pkg_handle);
 108         if (ret != 0) {
 109                 return rootPath;
 110         }
 111
 112         ret = pkgmgrinfo_pkginfo_get_root_path(pkg_handle, &path);
 113         if (ret != PMINFO_R_OK) {
 114                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
 115                 return rootPath;
 116         }
 117         rootPath = path;
 118         pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
 119
 120         return rootPath;
 121 }
 122
 123 std::string getExecName(const std::string& pkgId)
 124 {
 125         char *exec = NULL;
 126         char *appId = 0;
 127         std::string execName;
 128
 129         pkgmgrinfo_pkginfo_h pkg_handle;
 130         int ret = pkgmgrGetPkgInfo(pkgId, &pkg_handle);
 131         if (ret != 0) {
 132                 return execName;
 133         }
 134
 135         ret = pkgmgrinfo_pkginfo_get_mainappid(pkg_handle, &appId);
 136         if (ret != PMINFO_R_OK) {
 137                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
 138                 return execName;
 139         }
 140
 141         pkgmgrinfo_appinfo_h app_handle;
 142         ret = pkgmgrGetAppInfo(appId, &app_handle);
 143         if (ret != 0) {
 144                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
 145                 return execName;
 146         }
 147
 148         ret = pkgmgrinfo_appinfo_get_exec(app_handle, &exec);
 149         if (ret != PMINFO_R_OK) {
 150                 pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
 151                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
 152                 return execName;
 153         }
 154         execName = std::string(exec).substr(std::string(exec).rfind('/') + 1);
 155
 156         pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
 157         pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
 158
 159         return execName;
 160 }
 161
 162 std::string getAppType(const std::string& pkgId)
 163 {
 164         char *appId = 0;
 165         char *type = 0;
 166         std::string appType;
 167
 168         pkgmgrinfo_pkginfo_h pkg_handle;
 169         int ret = pkgmgrGetPkgInfo(pkgId, &pkg_handle);
 170         if (ret != 0) {
 171                 return appType;
 172         }
 173
 174         ret = pkgmgrinfo_pkginfo_get_mainappid(pkg_handle, &appId);
 175         if (ret != PMINFO_R_OK) {
 176                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
 177                 return appType;
 178         }
 179
 180         pkgmgrinfo_appinfo_h app_handle;
 181         ret = pkgmgrGetAppInfo(appId, &app_handle);
 182         if (ret != 0) {
 183                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
 184                 return appType;
 185         }
 186
 187         ret = pkgmgrinfo_appinfo_get_apptype(app_handle, &type);
 188         if (ret != PMINFO_R_OK) {
 189                 pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
 190                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
 191                 return appType;
 192         }
 193         appType = type;
 194
 195         pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
 196         pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
 197
 198         return appType;
 199 }
 200
 201 std::string getMetadataValue(const std::string& pkgId, const std::string& key)
 202 {
 203         char *value = NULL;
 204         char *appId = 0;
 205         std::string metadataValue;
 206
 207         pkgmgrinfo_pkginfo_h pkg_handle;
 208         int ret = pkgmgrGetPkgInfo(pkgId, &pkg_handle);
 209         if (ret != 0) {
 210                 return metadataValue;
 211         }
 212
 213         ret = pkgmgrinfo_pkginfo_get_mainappid(pkg_handle, &appId);
 214         if (ret != PMINFO_R_OK) {
 215                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
 216                 return metadataValue;
 217         }
 218
 219         pkgmgrinfo_appinfo_h app_handle;
 220         ret = pkgmgrGetAppInfo(appId, &app_handle);
 221         if (ret != 0) {
 222                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
 223                 return metadataValue;
 224         }
 225
 226         ret = pkgmgrinfo_appinfo_get_metadata_value(app_handle, key.c_str(), &value);
 227         if (ret != PMINFO_R_OK) {
 228                 pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
 229                 pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
 230                 return metadataValue;
 231         }
 232         metadataValue = std::string(value);
 233
 234         pkgmgrinfo_appinfo_destroy_appinfo(app_handle);
 235         pkgmgrinfo_pkginfo_destroy_pkginfo(pkg_handle);
 236
 237         return metadataValue;
 238 }
 239
 240 bool isReadOnlyArea(const std::string& path)
 241 {
 242         FILE *f = NULL;
 243         struct mntent *m = NULL;
 244
 245         // "/opt/usr" is mounted to "RW" only
 246         if (path.find("/opt/usr") != std::string::npos) {
 247                 return false;
 248         }
 249
 250         // check whether "/" is mounted to RO or not
 251         f = setmntent("/proc/mounts", "r");
 252         if (!f) {
 253                 // return true for fail case to generate NI files under RW area.
 254                 return true;
 255         }
 256
 257         while((m = getmntent(f))) {
 258                 if (m->mnt_dir != NULL && strcmp(m->mnt_dir, "/") == 0 &&
 259                         m->mnt_opts != NULL && strstr(m->mnt_opts, "ro,") != NULL) {
 260                         endmntent(f);
 261                         return true;
 262                 }
 263         }
 264         endmntent(f);
 265         return false;
 266
 267 }
 268
 269 std::string getBaseName(const std::string& path)
 270 {
 271         auto pos = path.find_last_of(PATH_SEPARATOR);
 272         if (pos != std::string::npos)
 273                 return path.substr(0, pos);
 274         else
 275                 return std::string(".");
 276         return path;
 277 }
 278
 279 std::string replaceAll(const std::string& str, const std::string& pattern, const std::string& replace)
 280 {
 281         std::string result = str;
 282         std::string::size_type pos = 0;
 283         std::string::size_type offset = 0;
 284
 285         while ((pos = result.find(pattern, offset)) != std::string::npos) {
 286                 result.replace(result.begin() + pos, result.begin() + pos + pattern.size(), replace);
 287                 offset = pos + replace.size();
 288         }
 289
 290         return result;
 291 }
 292
 293 std::string changeExtension(const std::string& path, const std::string& from, const std::string& to)
 294 {
 295         return path.substr(0, path.rfind(from)) + to;
 296 }
 297
 298 bool isFile(const std::string& path)
 299 {
 300         struct stat sb;
 301         return lstat(path.c_str(), &sb) == 0;
 302 }
 303
 304 bool isSymlinkFile(const std::string& path)
 305 {
 306         struct stat sb;
 307         if (lstat(path.c_str(), &sb) != 0) {
 308                 return false;
 309         }
 310         return (sb.st_mode & S_IFMT) == S_IFLNK;
 311 }
 312
 313 bool isDirectory(const std::string& path)
 314 {
 315         struct stat sb;
 316         if (stat(path.c_str(), &sb) != 0) {
 317                 return false;
 318         }
 319         return (sb.st_mode & S_IFMT) == S_IFDIR;
 320 }
 321
 322 std::string getAssemblyNameFromPath(const std::string& path)
 323 {
 324         std::string ret(getFileName(path));
 325
 326         if (ret.find_last_of(".") == std::string::npos)
 327                 return ret;
 328         ret.erase(ret.find_last_of("."));
 329
 330         if (ret.size() > 3 && std::equal(ret.begin() + ret.size() - 3, ret.end(), ".ni"))
 331                 ret.erase(ret.size() - 3);
 332
 333         return ret;
 334 }
 335
 336 void addAssembliesFromDirectories(const std::vector<std::string>& directories, std::string& list)
 337 {
 338         std::vector<std::string> assems;
 339         std::unordered_map<std::string, std::string> assemPaths;
 340
 341         auto reader = [&assems, &assemPaths](const std::string& path, const std::string& filename) {
 342                 if (isManagedAssembly(filename) || isNativeImage(filename)) {
 343                         std::string assem = getAssemblyNameFromPath(filename);
 344
 345                         if (assemPaths.count(assem) == 0) {
 346                                 assems.push_back(assem);
 347                                 assemPaths[assem] = path;
 348                         } else if (isManagedAssembly(assemPaths[assem]) && isNativeImage(filename)) {
 349                                 // Update only if a native image is found in the same directory.
 350                                 // For example, if we have two directories = { X, Y } where X contains A.dll and
 351                                 // Y contains both A.dll and A.ni.dll, always A.dll in X will be used.
 352                                 if (getBaseName(assemPaths[assem]).compare(getBaseName(path)) == 0)
 353                                         assemPaths[assem] = path;
 354                         }
 355                 }
 356         };
 357         for (auto& directory : directories)
 358                 scanFilesInDirectory(directory, reader, 0);
 359
 360         if (!list.empty() && list.back() != ':')
 361                 list.push_back(':');
 362
 363         for (auto& assem : assems)
 364                 list += assemPaths[assem] + ":";
 365
 366         if (list.back() == ':')
 367                 list.pop_back();
 368 }
 369
 370 void scanFilesInDirectory(const std::string& directory, FileReader reader, unsigned int depth)
 371 {
 372         DIR *dir;
 373         struct dirent* entry;
 374         bool isDir;
 375
 376         dir = opendir(directory.c_str());
 377
 378         if (dir == nullptr)
 379                 return;
 380
 381         std::vector<std::string> innerDirectories;
 382
 383         while ((entry = readdir(dir)) != nullptr) {
 384                 isDir = false;
 385                 std::string path = concatPath(directory, entry->d_name);
 386                 switch (entry->d_type) {
 387                         case DT_REG: break;
 388                         case DT_DIR:
 389                                 isDir = true;
 390                                 break;
 391                         // symlink is added to the list even if there is no original file.
 392                         // It used to remove broken symlinks related to TAC
 393                         case DT_LNK:
 394                                 break;
 395                         case DT_UNKNOWN:
 396                                 continue;
 397                         default:
 398                                 continue;
 399                 }
 400                 if (!isDir)
 401                         reader(path, entry->d_name);
 402                 else if (depth > 0 && strcmp(entry->d_name, ".") && strcmp(entry->d_name, ".."))
 403                         innerDirectories.push_back(path);
 404         }
 405
 406         if (depth > 0)
 407                 for (auto& d : innerDirectories)
 408                         scanFilesInDirectory(d, reader, depth - 1);
 409
 410         closedir(dir);
 411 }
 412
 413 void copySmackAndOwnership(const std::string& fromPath, const std::string& toPath, bool isSymlink)
 414 {
 415         char* label = NULL;
 416         struct stat info;
 417
 418         if (isSymlink) {
 419                 // change smack label for symbolic link.
 420                 if (smack_lgetlabel(fromPath.c_str(), &label, SMACK_LABEL_ACCESS) == 0) {
 421                         if (smack_lsetlabel(toPath.c_str(), label, SMACK_LABEL_ACCESS) < 0) {
 422                                 _SERR("Fail to set smack label");
 423                         }
 424                         free(label);
 425                 }
 426
 427                 // change owner and groupsfor symbolic link.
 428                 // change mode is skipped for symlink because permission of symlink file is meaningless.
 429                 if (!lstat(fromPath.c_str(), &info)) {
 430                         if (lchown(toPath.c_str(), info.st_uid, info.st_gid) == -1)
 431                                 _SERR("Failed to change owner and group name");
 432                 }
 433         } else {
 434                 // change smack label
 435                 if (smack_getlabel(fromPath.c_str(), &label, SMACK_LABEL_ACCESS) == 0) {
 436                         if (smack_setlabel(toPath.c_str(), label, SMACK_LABEL_ACCESS) < 0) {
 437                                 _SERR("Fail to set smack label");
 438                         }
 439                         free(label);
 440                 }
 441
 442                 // change owner, groups and mode for generated ni file.
 443                 if (!stat(fromPath.c_str(), &info)) {
 444                         if (chown(toPath.c_str(), info.st_uid, info.st_gid) == -1)
 445                                 _SERR("Failed to change owner and group name");
 446                         if (chmod(toPath.c_str(), info.st_mode) == -1)
 447                                 _SERR("Failed to change mode");
 448                 }
 449         }
 450 }
 451
 452 static bool setOwnership(const bf::path& path, uid_t uid, gid_t gid)
 453 {
 454         int fd = open(path.c_str(), O_RDONLY);
 455         if (fd < 0) {
 456                 _ERR("Can't open directory: %s", path.c_str());
 457                 return false;
 458         }
 459         int ret = fchown(fd, uid, gid);
 460         close(fd);
 461         if (ret != 0) {
 462                 _ERR("Failed to change owner of: %s", path.c_str());
 463                 return false;
 464         }
 465         return true;
 466 }
 467
 468 static bool setDirPermissions(const bf::path& path, bf::perms permissions)
 469 {
 470         bs::error_code error;
 471         bf::permissions(path, permissions, error);
 472         if (error) {
 473                 _ERR("Failed to set permissions for directory: %s, %s", path.c_str(), error.message().c_str());
 474                 return false;
 475         }
 476         return true;
 477 }
 478
 479 static bool setDirOwnershipAndPermissions(const bf::path& path, bf::perms permissions, uid_t uid, gid_t gid)
 480 {
 481         if (!setOwnership(path, uid, gid)) {
 482                 _ERR("Failed to change owner: %s, (uid: %d, gid: %d)", path.c_str(), uid, gid);
 483                 return false;
 484         }
 485         if (!setDirPermissions(path, permissions)) {
 486                 _ERR("Failed to change permission: %s, (%d)", path.c_str(), permissions);
 487                 return false;
 488         }
 489         return true;
 490 }
 491
 492 static bool copyOwnershipAndPermissions(const bf::path& path, const bf::path& path2)
 493 {
 494         if (!exist(path)) {
 495                 _ERR("Failed to copy ownership and permissions from %s to %s", path.c_str(), path2.c_str());
 496                 return false;
 497         }
 498         bs::error_code error;
 499         bf::perms permissions = bf::status(path, error).permissions();
 500         if (error) {
 501                 _ERR("Failed to copy ownership and permissions : %s", error.message().c_str());
 502                 return false;
 503         }
 504         struct stat stats;
 505         if (stat(path.c_str(), &stats) != 0) {
 506                 return false;
 507         }
 508         if (!setDirOwnershipAndPermissions(path2, permissions, stats.st_uid, stats.st_gid)) {
 509                 _ERR("Failed to copy ownership and permissions from %s to %s", path.c_str(), path2.c_str());
 510                 return false;
 511         }
 512         return true;
 513 }
 514
 515 bool exist(const bf::path& path)
 516 {
 517         bs::error_code error;
 518         int ret = bf::exists(path, error);
 519         if (error) {
 520                 if ((error.value() != bs::errc::success) && (error.value() != bs::errc::no_such_file_or_directory)) {
 521                         _ERR("Failed to check %s exists : %s", path.c_str(), error.message().c_str());
 522                 }
 523         }
 524         return ret;
 525 }
 526
 527 bool createDir(const bf::path& path)
 528 {
 529         if (exist(path)) {
 530                 return true;
 531         }
 532         bs::error_code error;
 533         bf::create_directories(path, error);
 534         if (error) {
 535                 _ERR("Failed to create directory: %s", error.message().c_str());
 536                 return false;
 537         }
 538         return true;
 539 }
 540
 541 bool copyDir(const bf::path& path1, const bf::path& path2, FSFlag flags)
 542 {
 543         try {
 544                 // Check whether the function call is valid
 545                 if (!exist(path1) || !bf::is_directory(path1)) {
 546                         _ERR("Source directory %s does not exist or is not a directory", path1.c_str());
 547                         return false;
 548                 }
 549                 if (!exist(path2)) {
 550                         // Create the destination directory
 551                         if (!createDir(path2)) {
 552                                 _ERR("Unable to create destination directory %s", path2.c_str());
 553                                 return false;
 554                         }
 555                         if (flags & FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS) {
 556                                 copyOwnershipAndPermissions(path1, path2);
 557                         }
 558                 } else {
 559                         if (!(flags & (FS_MERGE_SKIP | FS_MERGE_OVERWRITE))) {
 560                                 _ERR("Destination directory %s already exists", path2.c_str());
 561                                 return false;
 562                         }
 563                         if (flags & (FS_MERGE_OVERWRITE | FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS)) {
 564                                 copyOwnershipAndPermissions(path1, path2);
 565                         }
 566                 }
 567         } catch (const bf::filesystem_error& error) {
 568                 _ERR("Failed to copy directory: %s", error.what());
 569                 return false;
 570         }
 571
 572         // Iterate through the source directory
 573         try {
 574                 for (bf::directory_iterator file(path1); file != bf::directory_iterator(); ++file) {
 575                         bf::path current(file->path());
 576                         bf::path target = path2 / current.filename();
 577                         if (bf::is_symlink(bf::symlink_status(current))) {
 578                                 if ((flags & (FS_MERGE_SKIP | FS_MERGE_OVERWRITE)) && exist(target)) {
 579                                         continue;
 580                                 }
 581                                 bs::error_code error;
 582                                 bf::copy_symlink(current, target, error);
 583                                 if (error) {
 584                                         _ERR("Failed to copy symlink: %s, %s", current.c_str(), error.message().c_str());
 585                                         return false;
 586                                 }
 587                         } else if (bf::is_directory(current)) {
 588                                 // Found directory: Recursion
 589                                 if (!copyDir(current, target, flags)) {
 590                                         return false;
 591                                 }
 592                         } else {
 593                                 if ((flags & FS_MERGE_SKIP) && exist(target)) {
 594                                         continue;
 595                                 }
 596                                 bf::path destination = target;
 597                                 if (flags & FS_COMMIT_COPY_FILE) {
 598                                         destination = bf::unique_path(target.parent_path() / "%%%%-%%%%-%%%%-%%%%");
 599                                 }
 600                                 if (flags & FS_MERGE_OVERWRITE) {
 601                                         bf::copy_file(current, destination, bf::copy_option::overwrite_if_exists);
 602                                 } else {
 603                                         bf::copy_file(current, destination);
 604                                 }
 605                                 if (flags & FS_PRESERVE_OWNERSHIP_AND_PERMISSIONS) {
 606                                         copyOwnershipAndPermissions(current, destination);
 607                                 }
 608                                 if (flags & FS_COMMIT_COPY_FILE) {
 609                                         if (flags & FS_MERGE_OVERWRITE) {
 610                                                 bf::remove(target);
 611                                         }
 612                                         bf::rename(destination, target);
 613                                 }
 614                         }
 615                 }
 616         } catch (const bf::filesystem_error& error) {
 617                 _ERR("Failed to copy directory: %s", error.what());
 618                 return false;
 619         }
 620
 621         return true;
 622 }
 623
 624 bool copyFile(const bf::path& path1, const bf::path& path2)
 625 {
 626         bs::error_code error;
 627         if (!exist(path1)) {
 628                 return false;
 629         }
 630         bf::copy_file(path1, path2, bf::copy_option::overwrite_if_exists, error);
 631         if (error) {
 632                 _ERR("copy file %s due to error [%s]", path1.c_str(), error.message().c_str());
 633                 return false;
 634         }
 635         return true;
 636 }
 637
 638 bool moveFile(const bf::path& path1, const bf::path& path2)
 639 {
 640         if (!exist(path1) || exist(path2)) {
 641                 return false;
 642         }
 643         bs::error_code error;
 644         bf::rename(path1, path2, error);
 645         if (error) {
 646                 _ERR("Cannot move file: %s. Will copy/remove... with error [%s]", path1.c_str(), error.message().c_str());
 647                 bf::copy_file(path1, path2, bf::copy_option::overwrite_if_exists, error);
 648                 if (error) {
 649                         _ERR("Cannot copy file %s due to error [%s]", path1.c_str(), error.message().c_str());
 650                         return false;
 651                 }
 652                 bf::remove_all(path1, error);
 653                 if (error) {
 654                         _ERR("Cannot remove old file when coping: %s with error [%s]", path1.c_str(), error.message().c_str());
 655                         return false;
 656                 }
 657         }
 658         return true;
 659 }
 660
 661 bool removeFile(const bf::path& path)
 662 {
 663         if (!exist(path)) {
 664                 return true;
 665         }
 666         bs::error_code error;
 667         bf::remove(path, error);
 668         if (error) {
 669                 _ERR("Cannot remove: %s, %s", path.c_str(), error.message().c_str());
 670                 return false;
 671         }
 672         return true;
 673 }
 674
 675 bool removeAll(const bf::path& path)
 676 {
 677         if (!exist(path)) {
 678                 return true;
 679         }
 680         bs::error_code error;
 681         bf::remove_all(path, error);
 682         if (error) {
 683                 _ERR("Cannot remove: %s, %s", path.c_str(), error.message().c_str());
 684                 return false;
 685         }
 686         return true;
 687 }
 688
 689 void setCmdName(const std::string& name)
 690 {
 691         #define PRC_NAME_LENGTH         16
 692
 693         char processName[PRC_NAME_LENGTH] = {0, };
 694
 695         if (name.empty())
 696                 return;
 697
 698         memset(processName, '\0', PRC_NAME_LENGTH);
 699         snprintf(processName, PRC_NAME_LENGTH, "%s", name.c_str());
 700         prctl(PR_SET_NAME, processName);
 701 }
 702
 703 std::string getFileName(const std::string& path)
 704 {
 705         std::string ret(path);
 706         size_t index = ret.find_last_of(PATH_SEPARATOR);
 707         return index == std::string::npos ? ret : ret.substr(index + 1);
 708 }
 709
 710 std::string SHA256(const std::string& path)
 711 {
 712         std::string output = "";
 713         FILE *file = fopen(path.c_str(), "rb");
 714         if (!file) {
 715                 return output;
 716         }
 717
 718         unsigned char hash[SHA256_DIGEST_LENGTH];
 719         SHA256_CTX sha256;
 720         SHA256_Init(&sha256);
 721         int bytesRead = 0;
 722         const int bufSize = 32768;
 723         char *buffer = (char*)malloc(bufSize);
 724         if (!buffer) {
 725                 fclose(file);
 726                 return output;
 727         }
 728
 729         while ((bytesRead = fread(buffer, 1, bufSize, file))) {
 730                 SHA256_Update(&sha256, buffer, bytesRead);
 731         }
 732         SHA256_Final(hash, &sha256);
 733
 734         std::stringstream ss;
 735         for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
 736                 ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
 737         }
 738         output = ss.str();
 739
 740         fclose(file);
 741         free(buffer);
 742
 743         return output;
 744 }
 745
 746 int pkgmgrGetPkgInfo(const std::string& pkgId, pkgmgrinfo_pkginfo_h* handle)
 747 {
 748         uid_t uid = 0;
 749         int ret = 0;
 750
 751         if (pkgmgr_installer_info_get_target_uid(&uid) < 0) {
 752                 _ERR("Failed to get UID");
 753                 return -1;
 754         }
 755
 756         ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgId.c_str(), uid, handle);
 757         if (ret != PMINFO_R_OK) {
 758                 _ERR("Failed to get pkginfo (%d)", ret);
 759                 return -1;
 760         }
 761
 762         return 0;
 763 }
 764
 765 int pkgmgrGetAppInfo(const std::string& appId, pkgmgrinfo_appinfo_h* handle)
 766 {
 767         uid_t uid = 0;
 768         int ret = 0;
 769
 770         if (pkgmgr_installer_info_get_target_uid(&uid) < 0) {
 771                 _ERR("Failed to get UID");
 772                 return -1;
 773         }
 774
 775         ret = pkgmgrinfo_appinfo_get_usr_appinfo(appId.c_str(), uid, handle);
 776         if (ret != PMINFO_R_OK) {
 777                 _ERR("Failed to get appinfo (%d)", ret);
 778                 return -1;
 779         }
 780
 781         return 0;
 782 }
 783
 784 int pkgmgrMDFilterForeach(pkgmgrinfo_appinfo_metadata_filter_h handle,
 785                                          pkgmgrinfo_app_list_cb app_cb,
 786                                          void *user_data)
 787 {
 788         uid_t uid = 0;
 789         int ret = 0;
 790
 791         if (pkgmgr_installer_info_get_target_uid(&uid) < 0) {
 792                 _ERR("Failed to get UID");
 793                 return -1;
 794         }
 795
 796
 797         ret = pkgmgrinfo_appinfo_usr_metadata_filter_foreach(handle, app_cb, user_data, uid);
 798         if (ret != PMINFO_R_OK) {
 799                 _ERR("Failed to execute the metadata filter query (%d)", ret);
 800                 return -1;
 801         }
 802
 803         return 0;
 804 }
 805