test/smoke_tests/common/smoke_utils.cc

   1 // Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
   2 // Use of this source code is governed by an apache-2.0 license that can be
   3 // found in the LICENSE file.
   4
   5 #include "smoke_tests/common/smoke_utils.h"
   6
   7 #include <gum/gum-user.h>
   8 #include <gum/gum-user-service.h>
   9 #include <gum/common/gum-user-types.h>
  10 #include <manifest_parser/utils/version_number.h>
  11 #include <sys/smack.h>
  12 #include <vconf.h>
  13 #include <vconf-internal-keys.h>
  14
  15 #include <boost/filesystem/path.hpp>
  16 #include <gtest/gtest.h>
  17
  18 #include <common/installer/app_installer.h>
  19 #include <common/utils/paths.h>
  20 #include <common/pkgmgr_interface.h>
  21 #include <common/utils/pkgmgr_query.h>
  22 #include <common/tzip_interface.h>
  23
  24 #include "pkgmgr_parser_db.h"
  25
  26 #include <list>
  27 #include <memory>
  28 #include <string>
  29 #include <vector>
  30
  31 namespace bf = boost::filesystem;
  32 namespace bs = boost::system;
  33 namespace ci = common_installer;
  34 namespace bo = boost::program_options;
  35
  36 namespace {
  37
  38 const uid_t kDefaultUserUid = tzplatform_getuid(TZ_SYS_DEFAULT_USER);
  39 const gid_t kDefaultUserGid = tzplatform_getgid(TZ_SYS_DEFAULT_USER);
  40 const char kNormalUserName[] = "smokeuser";
  41 const char kSystemShareGroupName[] = "system_share";
  42 const char kMigrateTestDBName[] = "app2sd_migrate.db";
  43 // common entries
  44 const std::vector<std::string> kDBEntries = {
  45   {".pkgmgr_parser.db"},
  46   {".pkgmgr_parser.db-journal"},
  47   {".pkgmgr_cert.db"},
  48   {".pkgmgr_cert.db-journal"},
  49   {".app2sd.db"},
  50   {".app2sd.db-journal"},
  51 };
  52 // globaluser entries
  53 const char kGlobalManifestDir[] = "/opt/share/packages";
  54 const char kSkelDir[] = "/etc/skel/apps_rw";
  55 const char kPreloadApps[] = "/usr/apps";
  56 const char kPreloadManifestDir[] = "/usr/share/packages";
  57 const char kPreloadIcons[] = "/usr/share/icons";
  58 const char kData[] = "data";
  59 const char kShared[] = ".shared";
  60 const char kSharedTmp[] = ".shared_tmp";
  61
  62 enum RWDirectory {
  63   DATA,
  64   CACHE,
  65   SHARED_CACHE,
  66   SHARED_DATA,
  67   SHARED_TRUSTED
  68 };
  69
  70 const char* rwDirectories[] = {
  71   "data",
  72   "cache",
  73   "shared/cache",
  74   "shared/data",
  75   "shared/trusted",
  76 };
  77
  78 }  // namespace
  79
  80 namespace smoke_test {
  81
  82 const char kLegacyExtImageDir[] = "legacy_extimage_dir";
  83 const std::string& kDefaultUserIdStr = std::to_string(kDefaultUserUid);
  84 const uid_t kGlobalUserUid = tzplatform_getuid(TZ_SYS_GLOBALAPP_USER);
  85 const uid_t kGlobalUserGid = tzplatform_getgid(TZ_SYS_GLOBALAPP_USER);
  86 extern const bf::path kSdkDirectory = "/home/owner/share/tmp/sdk_tools";
  87
  88 ci::RequestMode ParseRequestMode(int argc,  char** argv) {
  89   bo::options_description desc("Available options");
  90   desc.add_options()
  91       ("request-mode", bo::value<std::string>(), "set request mode")
  92       ("global-request,g", "set request mode to global")
  93       ("user-request,u", "set request mode to user");
  94
  95   bo::variables_map vm;
  96   bo::store(bo::command_line_parser(argc, argv).
  97       options(desc).allow_unregistered().run(), vm);
  98   bo::notify(vm);
  99
 100   if (vm.count("global-request")) {
 101     std::cout << "Request mode was set to global." << std::endl;
 102     return ci::RequestMode::GLOBAL;
 103   }
 104   if (vm.count("user-request")) {
 105     std::cout << "Request mode was set to user." << std::endl;
 106     return ci::RequestMode::USER;
 107   }
 108   if (vm.count("request-mode")) {
 109     if (vm["request-mode"].as<std::string>() == "global") {
 110       std::cout << "Request mode was set to global." << std::endl;
 111       return ci::RequestMode::GLOBAL;
 112     }
 113     if (vm["request-mode"].as<std::string>() == "user") {
 114       std::cout << "Request mode was set to user." << std::endl;
 115       return ci::RequestMode::USER;
 116     }
 117     std::cout << "Cannot set request mode to "
 118               << vm["request-mode"].as<std::string>() << std::endl;
 119   }
 120   std::cout << "Request mode was set to global." << std::endl;
 121   return ci::RequestMode::GLOBAL;
 122 }
 123
 124 static bool AddUser(const char* user_name) {
 125   GumUser* user = nullptr;
 126   user = gum_user_create_sync(FALSE);
 127   if (user == nullptr)
 128     LOG(WARNING) << "Failed to create gum user! (user name: "
 129                  << user_name << ")";
 130   g_object_set(G_OBJECT(user), "username", user_name, "usertype",
 131       GUM_USERTYPE_NORMAL, NULL);
 132   gboolean rval = FALSE;
 133   rval = gum_user_add_sync(user);
 134   g_object_unref(user);
 135   return rval;
 136 }
 137
 138 static bool DeleteUser(const char* user_name, bool rem_home_dir) {
 139   bool rval = FALSE;
 140   GumUser* guser = gum_user_get_by_name_sync(user_name, FALSE);
 141   if (guser)
 142     rval = gum_user_delete_sync(guser, rem_home_dir);
 143   return rval;
 144 }
 145
 146 bool AddTestUser(User* test_user) {
 147   std::cout << "Adding test user: " << kNormalUserName << std::endl;
 148   AddUser(kNormalUserName);
 149   if (boost::optional<uid_t> uid = ci::GetUidByUserName(kNormalUserName)) {
 150     test_user->uid = *uid;
 151     std::cout << "User created properly: uid=" << *uid;
 152     if (boost::optional<gid_t> gid = ci::GetGidByUid(*uid)) {
 153       test_user->gid = *gid;
 154       std::cout << " gid=" << *gid;
 155     }
 156     std::cout << std::endl;
 157     return true;
 158   }
 159   LOG(ERROR) << "Adding test user failed";
 160   return false;
 161 }
 162
 163 bool DeleteTestUser() {
 164   std::cout << "Deleting test user: " << kNormalUserName << std::endl;
 165   uid_t test_uid;
 166   if (boost::optional<uid_t> uid = ci::GetUidByUserName(kNormalUserName))
 167     test_uid = *uid;
 168   else
 169     return false;
 170   DeleteUser(kNormalUserName, true);
 171   if (!ci::GetUidByUserName(kNormalUserName)) {
 172     std::cout << "User deleted properly: user_name=" << kNormalUserName
 173               << " uid=" << test_uid << std::endl;
 174     return true;
 175   }
 176   LOG(ERROR) << "Deleting test user failed";
 177   return false;
 178 }
 179
 180 bool TouchFile(const bf::path& path) {
 181   FILE* f = fopen(path.c_str(), "w+");
 182   if (!f)
 183     return false;
 184   fclose(f);
 185   return true;
 186 }
 187
 188 void AddDataFiles(const std::string& pkgid, uid_t uid) {
 189   if (uid == kGlobalUserUid) {
 190     ci::UserList list = ci::GetUserList();
 191     for (auto l : list) {
 192       auto pkg_path = GetPackageRoot(pkgid, std::get<0>(l));
 193       ASSERT_TRUE(TouchFile(pkg_path / "data" / "file1.txt"));
 194       ASSERT_TRUE(TouchFile(pkg_path / "data" / "file2.txt"));
 195     }
 196   } else {
 197     auto pkg_path = GetPackageRoot(pkgid, uid);
 198     ASSERT_TRUE(TouchFile(pkg_path / "data" / "file1.txt"));
 199     ASSERT_TRUE(TouchFile(pkg_path / "data" / "file2.txt"));
 200   }
 201 }
 202
 203 void RemoveAllRecoveryFiles(const std::string& prefix, uid_t uid) {
 204   bf::path root_path = ci::GetRootAppPath(false, uid);
 205   if (!bf::exists(root_path))
 206     return;
 207   for (auto& dir_entry : boost::make_iterator_range(
 208       bf::directory_iterator(root_path), bf::directory_iterator())) {
 209     if (bf::is_regular_file(dir_entry)) {
 210       if (dir_entry.path().string().find(prefix) != std::string::npos) {
 211         bs::error_code error;
 212         bf::remove(dir_entry.path(), error);
 213         if (error)
 214           LOG(ERROR) << "Failed to remove " << dir_entry.path()
 215                      << ": " << error.message();
 216       }
 217     }
 218   }
 219 }
 220
 221 bf::path FindRecoveryFile(const std::string& prefix, uid_t uid) {
 222   bf::path root_path = ci::GetRootAppPath(false, uid);
 223   if (!bf::exists(root_path))
 224     return {};
 225
 226   for (auto& dir_entry : boost::make_iterator_range(
 227       bf::directory_iterator(root_path), bf::directory_iterator())) {
 228     if (bf::is_regular_file(dir_entry)) {
 229       if (dir_entry.path().string().find(prefix) != std::string::npos) {
 230         return dir_entry.path();
 231       }
 232     }
 233   }
 234   return {};
 235 }
 236
 237 std::unique_ptr<ci::recovery::RecoveryFile> GetRecoverFileInfo(
 238     const bf::path& recovery_file_path) {
 239   return ci::recovery::RecoveryFile::OpenRecoveryFile(recovery_file_path);
 240 }
 241
 242 bf::path GetPackageRoot(const std::string& pkgid, uid_t uid) {
 243   bf::path root_path = ci::GetRootAppPath(false, uid);
 244   return root_path / pkgid;
 245 }
 246
 247 bool ValidateFileContentInPackage(const std::string& pkgid,
 248                                   const std::string& relative,
 249                                   const std::string& expected,
 250                                   const TestParameters& params) {
 251   bf::path file_path = ci::GetRootAppPath(params.is_readonly,
 252                                           params.test_user.uid);
 253   file_path = file_path / pkgid / relative;
 254   if (!bf::exists(file_path)) {
 255     LOG(ERROR) << file_path << " doesn't exist";
 256     return false;
 257   }
 258   FILE* handle = fopen(file_path.c_str(), "r");
 259   if (!handle) {
 260     LOG(ERROR) << file_path << " cannot be open";
 261     return false;
 262   }
 263   std::string content;
 264   std::array<char, 200> buffer;
 265   while (fgets(buffer.data(), buffer.size(), handle)) {
 266     content += buffer.data();
 267   }
 268   fclose(handle);
 269   return content == expected;
 270 }
 271
 272 static bool ValidatePackageRWFS(const std::string& pkgid, uid_t uid) {
 273   bf::path root_path = ci::GetRootAppPath(false, uid);
 274   bf::path package_path = root_path / pkgid;
 275   bf::path data_path = package_path / rwDirectories[DATA];
 276   bf::path cache_path = package_path / rwDirectories[CACHE];
 277   bf::path shared_data_path = package_path / rwDirectories[SHARED_DATA];
 278
 279   EXTENDED_ASSERT_TRUE(bf::exists(data_path));
 280   EXTENDED_ASSERT_TRUE(bf::exists(cache_path));
 281
 282   struct stat stats;
 283   stat(data_path.c_str(), &stats);
 284   // gid of RW dirs should be system_share
 285   boost::optional<gid_t> system_share =
 286       ci::GetGidByGroupName(kSystemShareGroupName);
 287   EXTENDED_ASSERT_EQ(uid, stats.st_uid);
 288   EXTENDED_ASSERT_EQ(*system_share, stats.st_gid);
 289   if (bf::exists(shared_data_path)) {
 290     stat(shared_data_path.c_str(), &stats);
 291     EXTENDED_ASSERT_EQ(uid, stats.st_uid);
 292     EXTENDED_ASSERT_EQ(*system_share, stats.st_gid);
 293   }
 294
 295   stat(cache_path.c_str(), &stats);
 296   EXTENDED_ASSERT_EQ(uid, stats.st_uid);
 297   EXTENDED_ASSERT_EQ(*system_share, stats.st_gid);
 298   return true;
 299 }
 300
 301 static bool ValidatePackageFS(const std::string& pkgid, const Apps& apps,
 302     const TestParameters& params) {
 303   bf::path root_path = ci::GetRootAppPath(params.is_readonly,
 304                                           params.test_user.uid);
 305   bf::path package_path = root_path / pkgid;
 306   bf::path shared_path = package_path / "shared";
 307   EXTENDED_ASSERT_TRUE(bf::exists(root_path));
 308   EXTENDED_ASSERT_TRUE(bf::exists(package_path));
 309   EXTENDED_ASSERT_TRUE(bf::exists(shared_path));
 310
 311   bf::path manifest_path =
 312       bf::path(getUserManifestPath(params.test_user.uid,
 313           params.is_readonly)) / (pkgid + ".xml");
 314   EXTENDED_ASSERT_TRUE(bf::exists(manifest_path));
 315
 316   for (auto& app : apps) {
 317     const std::string &exec = app.second;
 318     bf::path binary_path = package_path / "bin" / exec;
 319     EXTENDED_ASSERT_TRUE(bf::exists(binary_path));
 320   }
 321
 322   if (params.pkg_type == PackageType::WGT ||
 323       params.pkg_type == PackageType::HYBRID) {
 324     bf::path widget_root_path = package_path / "res" / "wgt";
 325     bf::path config_path = widget_root_path / "config.xml";
 326     EXTENDED_ASSERT_TRUE(bf::exists(widget_root_path));
 327     EXTENDED_ASSERT_TRUE(bf::exists(config_path));
 328
 329     bf::path private_tmp_path = package_path / "tmp";
 330     EXTENDED_ASSERT_TRUE(bf::exists(private_tmp_path));
 331   }
 332
 333   // backups should not exist
 334   bf::path package_backup = ci::GetBackupPathForPackagePath(package_path);
 335   bf::path manifest_backup = ci::GetBackupPathForManifestFile(manifest_path);
 336   EXTENDED_ASSERT_FALSE(bf::exists(package_backup));
 337   EXTENDED_ASSERT_FALSE(bf::exists(manifest_backup));
 338
 339   for (bf::recursive_directory_iterator iter(package_path);
 340       iter != bf::recursive_directory_iterator(); ++iter) {
 341     if (bf::is_symlink(symlink_status(iter->path())))
 342       continue;
 343     bool is_rw_dir = false;
 344     for (const auto rw_dir : rwDirectories) {
 345       bf::path rw_dir_path = rw_dir;
 346       is_rw_dir |= ci::MakeRelativePath(iter->path(), package_path)
 347           == rw_dir_path;
 348     }
 349     if (is_rw_dir || iter->path().filename() == ".mmc") {
 350       iter.no_push();
 351       continue;
 352     }
 353     struct stat stats;
 354     stat(iter->path().c_str(), &stats);
 355     EXTENDED_ASSERT_EQ(params.test_user.uid, stats.st_uid);
 356     EXTENDED_ASSERT_EQ(params.test_user.gid, stats.st_gid);
 357   }
 358   return true;
 359 }
 360
 361 bool ValidatePackage(const std::string& pkgid, const Apps& apps,
 362     const TestParameters& params) {
 363   ci::PkgQueryInterface pkg_query(pkgid, params.test_user.uid, true);
 364   EXTENDED_ASSERT_TRUE(pkg_query.IsPackageInstalled(
 365       ci::GetRequestMode(params.test_user.uid)));
 366   EXTENDED_ASSERT_TRUE(ValidatePackageFS(pkgid, apps, params));
 367   if (params.test_user.uid == kGlobalUserUid) {
 368     ci::UserList list = ci::GetUserList();
 369     for (auto& l : list)
 370       EXTENDED_ASSERT_TRUE(ValidatePackageRWFS(pkgid, std::get<0>(l)));
 371   } else {
 372     EXTENDED_ASSERT_TRUE(ValidatePackageRWFS(pkgid, params.test_user.uid));
 373   }
 374   return true;
 375 }
 376
 377 bool ValidateDataFiles(const std::string& pkgid, uid_t uid) {
 378   if (uid == kGlobalUserUid) {
 379     ci::UserList list = ci::GetUserList();
 380     for (auto l : list) {
 381       auto pkg_path = GetPackageRoot(pkgid, std::get<0>(l));
 382       EXTENDED_ASSERT_TRUE(bf::exists(pkg_path / "data" / "file1.txt"));
 383       EXTENDED_ASSERT_TRUE(bf::exists(pkg_path / "data" / "file2.txt"));
 384     }
 385   } else {
 386     auto pkg_path = GetPackageRoot(pkgid, uid);
 387     EXTENDED_ASSERT_TRUE(bf::exists(pkg_path / "data" / "file1.txt"));
 388     EXTENDED_ASSERT_TRUE(bf::exists(pkg_path / "data" / "file2.txt"));
 389   }
 390   return true;
 391 }
 392
 393 static bool ValidateExternalPackageFS(const std::string& pkgid,
 394     const Apps& apps, const TestParameters& params) {
 395   EXTENDED_ASSERT_EQ(app2ext_usr_enable_external_pkg(pkgid.c_str(),
 396       params.test_user.uid), 0);
 397   bf::path root_path = ci::GetRootAppPath(false, params.test_user.uid);
 398   if (params.pkg_type == PackageType::TPK) {
 399     EXTENDED_ASSERT_TRUE(bf::exists(root_path / pkgid / ".mmc" / "bin"));
 400     EXTENDED_ASSERT_TRUE(bf::exists(root_path / pkgid / ".mmc" / "lib"));
 401   }
 402   EXTENDED_ASSERT_TRUE(bf::exists(root_path / pkgid / ".mmc" / "res"));
 403   EXTENDED_ASSERT_TRUE(ValidatePackageFS(pkgid, apps, params));
 404   EXTENDED_ASSERT_EQ(app2ext_usr_disable_external_pkg(pkgid.c_str(),
 405       params.test_user.uid), 0);
 406   return true;
 407 }
 408
 409 bool ValidateExternalPackage(const std::string& pkgid, const Apps& apps,
 410     const TestParameters& params) {
 411   ci::PkgQueryInterface pkg_query(pkgid, params.test_user.uid, true);
 412   std::string storage = pkg_query.StorageForPkgId();
 413   bf::path ext_mount_path = ci::GetExternalCardPath();
 414   if (bf::is_empty(ext_mount_path)) {
 415     LOG(INFO) << "Sdcard not exists!";
 416     EXTENDED_ASSERT_EQ(storage, "installed_internal");
 417   } else {
 418     EXTENDED_ASSERT_EQ(storage, "installed_external");
 419   }
 420   EXTENDED_ASSERT_TRUE(ValidateExternalPackageFS(pkgid, apps, params));
 421   return true;
 422 }
 423
 424 bool ValidateExtendedPackage(const std::string& pkgid, const Apps& apps,
 425     const TestParameters& params) {
 426   ci::PkgQueryInterface pkg_query(pkgid, params.test_user.uid, true);
 427   std::string storage = pkg_query.StorageForPkgId();
 428   bf::path extended_path =
 429       bf::path(ci::GetExtendedRootAppPath(params.test_user.uid)) / pkgid;
 430   if (!bf::exists(extended_path)) {
 431     LOG(INFO) << "Extended storage not exists!";
 432     EXTENDED_ASSERT_EQ(storage, "installed_internal");
 433   } else {
 434     EXTENDED_ASSERT_EQ(storage, "installed_extended");
 435   }
 436   EXTENDED_ASSERT_TRUE(ValidatePackage(pkgid, apps, params));
 437   return true;
 438 }
 439
 440 static bool PackageCheckCleanup(const std::string& pkgid,
 441     const TestParameters& params) {
 442   bf::path root_path = ci::GetRootAppPath(params.is_readonly,
 443                                           params.test_user.uid);
 444   bf::path package_path = root_path / pkgid;
 445   EXTENDED_ASSERT_FALSE(bf::exists(package_path));
 446
 447   bf::path manifest_path = bf::path(getUserManifestPath(params.test_user.uid,
 448       params.is_readonly)) / (pkgid + ".xml");
 449   EXTENDED_ASSERT_FALSE(bf::exists(manifest_path));
 450
 451   // backups should not exist
 452   bf::path package_backup = ci::GetBackupPathForPackagePath(package_path);
 453   bf::path manifest_backup = ci::GetBackupPathForManifestFile(manifest_path);
 454   EXTENDED_ASSERT_FALSE(bf::exists(package_backup));
 455   EXTENDED_ASSERT_FALSE(bf::exists(manifest_backup));
 456   return true;
 457 }
 458
 459 bool CheckPackageNonExistance(const std::string& pkgid,
 460                               const TestParameters& params) {
 461   ci::PkgQueryInterface pkg_query(pkgid, params.test_user.uid, true);
 462   EXTENDED_ASSERT_FALSE(pkg_query.IsPackageInstalled(
 463       ci::GetRequestMode(params.test_user.uid)));
 464   EXTENDED_ASSERT_TRUE(PackageCheckCleanup(pkgid, params));
 465   if (params.test_user.uid == kGlobalUserUid) {
 466     bf::path skel_path(kSkelDir);
 467     EXTENDED_ASSERT_FALSE(bf::exists(skel_path / pkgid));
 468     EXTENDED_ASSERT_FALSE(bf::exists(skel_path / kShared / pkgid));
 469     EXTENDED_ASSERT_FALSE(bf::exists(skel_path / kSharedTmp / pkgid));
 470     ci::UserList list = ci::GetUserList();
 471     for (auto& l : list) {
 472       bf::path root_path = ci::GetRootAppPath(false, std::get<0>(l));
 473       EXTENDED_ASSERT_FALSE(bf::exists(root_path / kShared / pkgid));
 474       EXTENDED_ASSERT_FALSE(bf::exists(root_path / kSharedTmp / pkgid));
 475       bf::path package_path = root_path / pkgid;
 476       EXTENDED_ASSERT_FALSE(bf::exists(package_path));
 477     }
 478   }
 479   return true;
 480 }
 481
 482 bool CheckAvailableExternalPath() {
 483   bf::path ext_mount_path = ci::GetExternalCardPath();
 484   LOG(DEBUG) << "ext_mount_path :" << ext_mount_path;
 485   if (ext_mount_path.empty()) {
 486     LOG(ERROR) << "Sdcard not exists!";
 487     return false;
 488   }
 489   return true;
 490 }
 491
 492 bool CheckAvailableExtendedPath() {
 493   bf::path extended_path = bf::path(tzplatform_getenv(TZ_SYS_EXTENDEDSD));
 494   LOG(DEBUG) << "extended_path :" << extended_path;
 495   // TODO(jeremy.jang): It should be checked by libstorage API.
 496   if (!bf::exists(extended_path)) {
 497     LOG(ERROR) << "Extended storage not exists!";
 498     return false;
 499   }
 500   return true;
 501 }
 502
 503 bool CheckPackageReadonlyNonExistance(const std::string& pkgid,
 504                                       const TestParameters& params) {
 505   ci::PkgQueryInterface pkg_query(pkgid, params.test_user.uid, true);
 506   EXTENDED_ASSERT_FALSE(pkg_query.IsPackageInstalled(
 507       ci::GetRequestMode(params.test_user.uid)));
 508   EXTENDED_ASSERT_TRUE(PackageCheckCleanup(pkgid, params));
 509   return true;
 510 }
 511
 512 static bool CheckSharedDataExistanceForPath(const bf::path& apps_rw,
 513     const std::string& pkgid) {
 514   bf::path shared_data_path = apps_rw / pkgid / rwDirectories[SHARED_DATA];
 515   bf::path shared = apps_rw / kShared / pkgid / kData;
 516   bf::path shared_tmp = apps_rw / kSharedTmp / pkgid;
 517   EXTENDED_ASSERT_TRUE(bf::exists(shared_data_path));
 518   EXTENDED_ASSERT_TRUE(bf::exists(shared));
 519   EXTENDED_ASSERT_TRUE(bf::exists(shared_tmp));
 520   return true;
 521 }
 522
 523 static bool CheckSharedDataPermissions(const bf::path& apps_rw,
 524     const std::string& pkgid, uid_t uid) {
 525   bf::path shared_data_path = apps_rw / pkgid / rwDirectories[SHARED_DATA];
 526   bf::path shared = apps_rw / kShared / pkgid / kData;
 527   bf::path shared_tmp = apps_rw / kSharedTmp / pkgid;
 528   // gid of RW dirs should be system_share
 529   boost::optional<gid_t> system_share =
 530       ci::GetGidByGroupName(kSystemShareGroupName);
 531   struct stat stats;
 532   stat(shared_data_path.c_str(), &stats);
 533   EXTENDED_ASSERT_EQ(uid, stats.st_uid);
 534   EXTENDED_ASSERT_EQ(*system_share, stats.st_gid);
 535   stat(shared.c_str(), &stats);
 536   EXTENDED_ASSERT_EQ(uid, stats.st_uid);
 537   EXTENDED_ASSERT_EQ(*system_share, stats.st_gid);
 538   stat(shared_tmp.c_str(), &stats);
 539   EXTENDED_ASSERT_EQ(uid, stats.st_uid);
 540   EXTENDED_ASSERT_EQ(kDefaultUserGid, stats.st_gid);
 541   return true;
 542 }
 543
 544 bool CheckSharedDataExistance(const std::string& pkgid,
 545     const TestParameters& params) {
 546   if (params.test_user.uid == kGlobalUserUid) {
 547     bf::path skel_path(kSkelDir);
 548     EXTENDED_ASSERT_TRUE(CheckSharedDataExistanceForPath(kSkelDir, pkgid));
 549     ci::UserList list = ci::GetUserList();
 550     for (auto& l : list) {
 551       uid_t uid = std::get<0>(l);
 552       bf::path apps_rw = ci::GetRootAppPath(false, uid);
 553       EXTENDED_ASSERT_TRUE(CheckSharedDataExistanceForPath(apps_rw, pkgid));
 554       EXTENDED_ASSERT_TRUE(CheckSharedDataPermissions(apps_rw, pkgid, uid));
 555     }
 556   } else {
 557     bf::path apps_rw = ci::GetRootAppPath(false, params.test_user.uid);
 558     EXTENDED_ASSERT_TRUE(CheckSharedDataExistanceForPath(apps_rw, pkgid));
 559     EXTENDED_ASSERT_TRUE(
 560         CheckSharedDataPermissions(apps_rw, pkgid, params.test_user.uid));
 561   }
 562   return true;
 563 }
 564
 565 static bool CheckSharedDataNonExistanceForPath(const bf::path& apps_rw,
 566     const std::string pkgid) {
 567   bf::path shared_data_path = apps_rw / pkgid / rwDirectories[SHARED_DATA];
 568   bf::path shared = apps_rw / kShared / pkgid / kData;
 569   bf::path shared_tmp = apps_rw / kSharedTmp / pkgid;
 570   EXTENDED_ASSERT_FALSE(bf::exists(shared_data_path));
 571   EXTENDED_ASSERT_FALSE(bf::exists(shared));
 572   EXTENDED_ASSERT_FALSE(bf::exists(shared_tmp));
 573   return true;
 574 }
 575
 576 bool CheckSharedDataNonExistance(const std::string& pkgid,
 577     const TestParameters& params) {
 578   if (params.test_user.uid == kGlobalUserUid) {
 579     bf::path skel_path(kSkelDir);
 580     EXTENDED_ASSERT_TRUE(
 581         CheckSharedDataNonExistanceForPath(skel_path, pkgid));
 582
 583     ci::UserList list = ci::GetUserList();
 584     for (auto& l : list) {
 585       uid_t uid = std::get<0>(l);
 586       bf::path apps_rw = ci::GetRootAppPath(false, uid);
 587       EXTENDED_ASSERT_TRUE(CheckSharedDataNonExistanceForPath(apps_rw, pkgid));
 588     }
 589   } else {
 590     bf::path apps_rw = ci::GetRootAppPath(false, params.test_user.uid);
 591     EXTENDED_ASSERT_TRUE(CheckSharedDataNonExistanceForPath(apps_rw, pkgid));
 592   }
 593   return true;
 594 }
 595
 596 void BackendInterface::TestRollbackAfterEachStep(int argc, const char* argv[],
 597     std::function<bool()> validator) const {
 598   ci::Subprocess backend_helper = CreateSubprocess();
 599   ASSERT_EQ(backend_helper.RunFunc({[&]() -> int {
 600     TestPkgmgrInstaller pkgmgr_installer;
 601     std::shared_ptr<ci::AppQueryInterface> query_interface =
 602         CreateQueryInterface();
 603     auto pkgmgr =
 604         ci::PkgMgrInterface::Create(argc, const_cast<char**>(argv),
 605                                     &pkgmgr_installer,
 606                                     query_interface);
 607     if (!pkgmgr) {
 608       LOG(ERROR) << "Failed to initialize pkgmgr interface";
 609       return 1;
 610     }
 611     AppInstallerPtr backend;
 612     unsigned int insert_idx = 0;
 613     do {
 614       backend = CreateFailExpectedInstaller(pkgmgr, insert_idx);
 615       LOG(DEBUG) << "StepFail is inserted at: " << insert_idx;
 616       ci::AppInstaller::Result ret = backend->Run();
 617       if (ret != ci::AppInstaller::Result::ERROR) {
 618         LOG(ERROR) << "StepFail not executed";
 619         return 1;
 620       }
 621       if (!validator())
 622         break;
 623       insert_idx++;
 624     } while (insert_idx < backend->StepCount());
 625     if (insert_idx != backend->StepCount()) {
 626       LOG(ERROR) << "Fail to validate";
 627       return 1;
 628     }
 629
 630     return 0;
 631   }}), true);
 632   int status = backend_helper.Wait();
 633   ASSERT_NE(WIFEXITED(status), 0);
 634   ASSERT_EQ(WEXITSTATUS(status), 0);
 635 }
 636
 637 void BackendInterface::CrashAfterEachStep(std::vector<std::string>* args,
 638     std::function<bool(int iter)> validator, PackageType type) const {
 639   std::unique_ptr<const char*[]> argv(new const char*[args->size()]);
 640   for (size_t i = 0; i < args->size(); ++i) {
 641     argv[i] = args->at(i).c_str();
 642   }
 643   TestPkgmgrInstaller pkgmgr_installer;
 644   auto query_interface = CreateQueryInterface();
 645   auto pkgmgr =
 646       ci::PkgMgrInterface::Create(args->size(), const_cast<char**>(argv.get()),
 647                                   &pkgmgr_installer,
 648                                   query_interface);
 649   if (!pkgmgr) {
 650     LOG(ERROR) << "Failed to initialize pkgmgr interface";
 651     return;
 652   }
 653   auto backend = CreateFailExpectedInstaller(pkgmgr, 0);
 654   ASSERT_EQ(backend->Run(), ci::AppInstaller::Result::ERROR);
 655   int stepCount = backend->StepCount();
 656
 657   args->push_back("-idx");
 658   args->push_back(std::to_string(stepCount));
 659   int i;
 660   std::string prefix = (type == PackageType::TPK) ? "tpk" : "wgt";
 661   for (i = 0; i < stepCount; i++) {
 662     ci::Subprocess backend_crash(
 663         "/usr/bin/" + prefix + "-installer-ut/smoke-test-helper");
 664     args->back() = std::to_string(i);
 665     backend_crash.Run(*args);
 666     ASSERT_NE(backend_crash.Wait(), 0);
 667     if (!validator(i))
 668       break;
 669   }
 670   ASSERT_EQ(stepCount, i);
 671
 672   args->push_back("-type_clean");
 673   for (i = stepCount - 1; i >= 2; i--) {
 674     ci::Subprocess backend_crash(
 675         "/usr/bin/" + prefix + "-installer-ut/smoke-test-helper");
 676     auto it = args->end();
 677     it -= 2;
 678     *it = std::to_string(i);
 679     backend_crash.Run(*args);
 680     ASSERT_NE(backend_crash.Wait(), 0);
 681     if (!validator(i))
 682       break;
 683   }
 684   ASSERT_EQ(i , 1);
 685 }
 686
 687 BackendInterface::CommandResult BackendInterface::RunInstallersWithPkgmgr(
 688     ci::PkgMgrPtr pkgmgr) const {
 689   std::list<AppInstallerPtr> installers;
 690   for (int i = 0; i < pkgmgr->GetRequestInfoCount(); i++) {
 691     AppInstallerPtr installer;
 692     if (mode_ == RequestResult::FAIL && i == pkgmgr->GetRequestInfoCount() - 1)
 693       installer = factory_->CreateFailExpectedInstaller(i, pkgmgr);
 694     else
 695       installer = factory_->CreateInstaller(i, pkgmgr);
 696     if (!installer)
 697       LOG(ERROR) << "Failed to create installer";
 698     else
 699       installers.emplace_back(std::move(installer));
 700   }
 701
 702   // FIXME: I think we should not implement this logic here...
 703   CommandResult result = CommandResult::OK;
 704   std::list<AppInstallerPtr>::iterator it(installers.begin());
 705   for (; it != installers.end(); ++it) {
 706     result = (*it)->Process();
 707     if (result != CommandResult::OK)
 708       break;
 709   }
 710   if (it != installers.end() && result == CommandResult::ERROR) {
 711     do {
 712       CommandResult ret = (*it)->Undo();
 713       if (ret != CommandResult::OK && ret != CommandResult::ERROR)
 714         result = CommandResult::UNDO_ERROR;
 715     } while (it-- != installers.begin());
 716   } else {
 717     --it;
 718     do {
 719       if ((*it)->Clean() != CommandResult::OK)
 720         result = CommandResult::CLEANUP_ERROR;
 721     } while (it-- != installers.begin());
 722   }
 723   return result;
 724 }
 725
 726 BackendInterface::CommandResult BackendInterface::CallBackendWithRunner(
 727     int argc, const char* argv[]) const {
 728   TestPkgmgrInstaller pkgmgr_installer;
 729   auto pkgmgr = ci::PkgMgrInterface::Create(argc, const_cast<char**>(argv),
 730       &pkgmgr_installer);
 731   if (!pkgmgr) {
 732     LOG(ERROR) << "Failed to initialize pkgmgr interface";
 733     return BackendInterface::CommandResult::UNKNOWN;
 734   }
 735   return RunInstallersWithPkgmgr(pkgmgr);
 736 }
 737
 738 BackendInterface::CommandResult BackendInterface::Install(
 739     const std::vector<bf::path>& paths) const {
 740   std::vector<const char*> argv;
 741   argv.emplace_back("");
 742   argv.emplace_back("-i");
 743   for (const auto& p : paths)
 744     argv.emplace_back(p.string().c_str());
 745   return CallBackendWithRunner(argv.size(), argv.data());
 746 }
 747
 748 BackendInterface::CommandResult BackendInterface::Uninstall(
 749     const std::vector<std::string>& pkgids) const {
 750   std::vector<const char*> argv;
 751   argv.emplace_back("");
 752   argv.emplace_back("-d");
 753   for (const auto& p : pkgids)
 754     argv.emplace_back(p.c_str());
 755   return CallBackendWithRunner(argv.size(), argv.data());
 756 }
 757
 758 BackendInterface::CommandResult BackendInterface::InstallSuccess(
 759     const std::vector<bf::path>& paths) const {
 760   RequestResult tmp_mode = mode_;
 761   RequestResult &original_mode = const_cast<RequestResult&>(mode_);
 762   original_mode = RequestResult::NORMAL;
 763   if (Install(paths) != BackendInterface::CommandResult::OK) {
 764     LOG(ERROR) << "Failed to install application. Cannot update";
 765     return BackendInterface::CommandResult::UNKNOWN;
 766   }
 767   original_mode = tmp_mode;
 768   return BackendInterface::CommandResult::OK;
 769 }
 770
 771 BackendInterface::CommandResult BackendInterface::RunInstallerWithPkgrmgr(
 772     ci::PkgMgrPtr pkgmgr) const {
 773   std::unique_ptr<ci::AppInstaller> installer;
 774   switch (mode_) {
 775   case RequestResult::FAIL:
 776     installer = CreateFailExpectedInstaller(pkgmgr);
 777     break;
 778   default:
 779     installer = CreateInstaller(pkgmgr);
 780     break;
 781   }
 782   return installer->Run();
 783 }
 784
 785 BackendInterface::CommandResult BackendInterface::CallBackend(int argc,
 786     const char* argv[]) const {
 787   TestPkgmgrInstaller pkgmgr_installer;
 788   auto query_interface = CreateQueryInterface();
 789   auto pkgmgr = ci::PkgMgrInterface::Create(argc, const_cast<char**>(argv),
 790       &pkgmgr_installer, query_interface);
 791   if (!pkgmgr) {
 792     LOG(ERROR) << "Failed to initialize pkgmgr interface";
 793     return BackendInterface::CommandResult::UNKNOWN;
 794   }
 795   return RunInstallerWithPkgrmgr(pkgmgr);
 796 }
 797
 798 BackendInterface::CommandResult BackendInterface::Install(
 799     const bf::path& path) const {
 800   const char* argv[] = {"", "-i", path.c_str(), "-u", uid_str_.c_str()};
 801   return CallBackend(SIZEOFARRAY(argv), argv);
 802 }
 803
 804 BackendInterface::CommandResult BackendInterface::InstallPreload(
 805     const bf::path& path) const {
 806   const char* argv[] = {"", "-i", path.c_str(), "--preload"};
 807   return CallBackend(SIZEOFARRAY(argv), argv);
 808 }
 809
 810 BackendInterface::CommandResult BackendInterface::InstallWithStorage(
 811     const bf::path& path, StorageType type) const {
 812   int default_storage = 0;
 813   int storage = 0;
 814   switch (type) {
 815     case StorageType::EXTERNAL:
 816       storage = 1;
 817       break;
 818     case StorageType::EXTENDED:
 819       storage = 2;
 820       break;
 821     default:
 822       LOG(ERROR) << "Unknown storage type";
 823       break;
 824   }
 825   if (vconf_get_int(VCONFKEY_SETAPPL_DEFAULT_MEM_INSTALL_APPLICATIONS_INT,
 826       &default_storage) != 0) {
 827     LOG(ERROR) << "Failed to get value of "
 828         "VCONFKEY_SETAPPL_DEFAULT_MEM_INSTALL_APPLICATIONS_INT";
 829     return BackendInterface::CommandResult::ERROR;
 830   }
 831   if (vconf_set_int(VCONFKEY_SETAPPL_DEFAULT_MEM_INSTALL_APPLICATIONS_INT,
 832       storage) != 0) {
 833     LOG(ERROR) << "Failed to set value of "
 834         "VCONFKEY_SETAPPL_DEFAULT_MEM_INSTALL_APPLICATIONS_INT";
 835     return BackendInterface::CommandResult::ERROR;
 836   }
 837
 838   const char* argv[] = {"", "-i", path.c_str(), "-u", uid_str_.c_str()};
 839   BackendInterface::CommandResult result = CallBackend(SIZEOFARRAY(argv), argv);
 840
 841   if (vconf_set_int(VCONFKEY_SETAPPL_DEFAULT_MEM_INSTALL_APPLICATIONS_INT,
 842       default_storage) != 0) {
 843     LOG(ERROR) << "Failed to set value of "
 844         "VCONFKEY_SETAPPL_DEFAULT_MEM_INSTALL_APPLICATIONS_INT";
 845     return BackendInterface::CommandResult::ERROR;
 846   }
 847
 848   return result;
 849 }
 850
 851 BackendInterface::CommandResult BackendInterface::MigrateLegacyExternalImage(
 852     const std::string& pkgid,
 853     const bf::path& path,
 854     const bf::path& legacy_path) const {
 855   if (InstallWithStorage(path, StorageType::EXTERNAL) !=
 856       BackendInterface::CommandResult::OK) {
 857     LOG(ERROR) << "Failed to install application. Cannot perform Migrate";
 858     return BackendInterface::CommandResult::ERROR;
 859   }
 860
 861   bf::path ext_mount_path = ci::GetExternalCardPath();
 862   if (bf::is_empty(ext_mount_path)) {
 863     LOG(ERROR) << "Sdcard not exists!";
 864     return BackendInterface::CommandResult::ERROR;
 865   }
 866   bf::path app2sd_path = ext_mount_path / "app2sd";
 867
 868   char* image_name = app2ext_usr_getname_image(pkgid.c_str(),
 869                      kGlobalUserUid);
 870   if (!image_name) {
 871     LOG(ERROR) << "Failed to get external image name";
 872     return BackendInterface::CommandResult::ERROR;
 873   }
 874   bf::path org_image = app2sd_path / image_name;
 875   free(image_name);
 876
 877   bs::error_code error;
 878   bf::remove(org_image, error);
 879   if (error) {
 880     LOG(ERROR) << "Failed to remove org image";
 881     return BackendInterface::CommandResult::ERROR;
 882   }
 883
 884   bf::path db_path = tzplatform_getenv(TZ_SYS_DB);
 885   bf::path app2sd_db = db_path / ".app2sd.db";
 886   bf::path app2sd_db_journal = db_path / ".app2sd.db-journal";
 887   bf::remove(app2sd_db, error);
 888   if (error) {
 889     LOG(ERROR) << "Failed to remove app2sd db";
 890     return BackendInterface::CommandResult::ERROR;
 891   }
 892   bf::remove(app2sd_db_journal, error);
 893   if (error) {
 894     LOG(ERROR) << "Failed to remove app2sd journal db";
 895     return BackendInterface::CommandResult::ERROR;
 896   }
 897
 898   bf::path app2sd_migrate_db = legacy_path / kMigrateTestDBName;
 899   if (!ci::CopyFile(app2sd_migrate_db, app2sd_db)) {
 900     LOG(ERROR) << "Failed to copy test db";
 901     return BackendInterface::CommandResult::ERROR;
 902   }
 903
 904   bf::path legacy_src = legacy_path / pkgid;
 905   bf::path legacy_dst = app2sd_path / pkgid;
 906   if (!ci::CopyFile(legacy_src, legacy_dst)) {
 907     LOG(ERROR) << "Failed to copy test image";
 908     return BackendInterface::CommandResult::ERROR;
 909   }
 910   const char* argv[] = {"", "--migrate-extimg", pkgid.c_str(),
 911                        "-u", uid_str_.c_str()};
 912   return CallBackend(SIZEOFARRAY(argv), argv);
 913 }
 914
 915 BackendInterface::CommandResult BackendInterface::RDSUpdate(
 916     const bf::path& path,
 917     const std::string& pkgid) const {
 918   RequestResult tmp_mode = mode_;
 919   RequestResult &original_mode = const_cast<RequestResult&>(mode_);
 920   original_mode = RequestResult::NORMAL;
 921   if (Install(path) != BackendInterface::CommandResult::OK) {
 922     LOG(ERROR) << "Failed to install application. Cannot perform RDS";
 923     return BackendInterface::CommandResult::UNKNOWN;
 924   }
 925   const char* argv[] = {"", "-r", pkgid.c_str(), "-u",
 926                         uid_str_.c_str()};
 927   original_mode = tmp_mode;
 928   return CallBackend(SIZEOFARRAY(argv), argv);
 929 }
 930
 931 BackendInterface::CommandResult BackendInterface::EnablePackage(
 932     const std::string& pkgid) const {
 933   const char* argv[] = {"", "-A", pkgid.c_str(), "-u", uid_str_.c_str()};
 934   return CallBackend(SIZEOFARRAY(argv), argv);
 935 }
 936
 937 BackendInterface::CommandResult BackendInterface::DisablePackage(
 938     const std::string& pkgid) const {
 939   const char* argv[] = {"", "-D", pkgid.c_str(), "-u", uid_str_.c_str()};
 940   return CallBackend(SIZEOFARRAY(argv), argv);
 941 }
 942
 943 BackendInterface::CommandResult BackendInterface::Recover(
 944     const bf::path& recovery_file) const {
 945   const char* argv[] = {"", "-b", recovery_file.c_str(), "-u",
 946       uid_str_.c_str()};
 947   return CallBackend(SIZEOFARRAY(argv), argv);
 948 }
 949
 950 BackendInterface::CommandResult BackendInterface::ManifestDirectInstall(
 951     const std::string& pkgid) const {
 952   const char* argv[] = {"", "-y", pkgid.c_str(), "-u", uid_str_.c_str()};
 953   return CallBackend(SIZEOFARRAY(argv), argv);
 954 }
 955
 956 BackendInterface::CommandResult BackendInterface::Uninstall(
 957     const std::string& pkgid) const {
 958   const char* argv[] = {"", "-d", pkgid.c_str(), "-u", uid_str_.c_str()};
 959   return CallBackend(SIZEOFARRAY(argv), argv);
 960 }
 961
 962 BackendInterface::CommandResult BackendInterface::UninstallPreload(
 963     const std::string& pkgid) const {
 964   const char* argv[] = {"", "-d", pkgid.c_str(), "--preload",
 965       "--force-remove"};
 966   return CallBackend(SIZEOFARRAY(argv), argv);
 967 }
 968
 969 BackendInterface::CommandResult BackendInterface::InstallSuccess(
 970     const bf::path& path) const {
 971   RequestResult tmp_mode = mode_;
 972   RequestResult &original_mode = const_cast<RequestResult&>(mode_);
 973   original_mode = RequestResult::NORMAL;
 974   if (Install(path) != BackendInterface::CommandResult::OK) {
 975     LOG(ERROR) << "Failed to install application. Cannot update";
 976     return BackendInterface::CommandResult::UNKNOWN;
 977   }
 978   original_mode = tmp_mode;
 979   return BackendInterface::CommandResult::OK;
 980 }
 981
 982 BackendInterface::CommandResult BackendInterface::InstallPreloadSuccess(
 983     const bf::path& path) const {
 984   RequestResult tmp_mode = mode_;
 985   RequestResult &original_mode = const_cast<RequestResult&>(mode_);
 986   original_mode = RequestResult::NORMAL;
 987   if (InstallPreload(path) != BackendInterface::CommandResult::OK) {
 988     LOG(ERROR) << "Failed to install application. Cannot update";
 989     return BackendInterface::CommandResult::UNKNOWN;
 990   }
 991   original_mode = tmp_mode;
 992   return BackendInterface::CommandResult::OK;
 993 }
 994
 995 BackendInterface::CommandResult BackendInterface::MountInstall(
 996     const bf::path& path) const {
 997   const char* argv[] = {"", "-w", path.c_str(), "-u", uid_str_.c_str()};
 998   return CallBackend(SIZEOFARRAY(argv), argv);
 999 }
1000
1001 BackendInterface::CommandResult BackendInterface::MountInstallSuccess(
1002     const bf::path& path) const {
1003   RequestResult tmp_mode = mode_;
1004   RequestResult &original_mode = const_cast<RequestResult&>(mode_);
1005   original_mode = RequestResult::NORMAL;
1006   if (MountInstall(path) != BackendInterface::CommandResult::OK) {
1007     LOG(ERROR) << "Failed to mount-install application. Cannot mount-update";
1008     return BackendInterface::CommandResult::UNKNOWN;
1009   }
1010   original_mode = tmp_mode;
1011   return BackendInterface::CommandResult::OK;
1012 }
1013
1014 static boost::filesystem::path GetTrashPath(
1015     const boost::filesystem::path& path) {
1016   return path.string() + ".trash";
1017 }
1018
1019 BackendInterface::SubProcessResult BackendInterface::RunSubprocess(
1020     std::vector<std::string> args) const {
1021   args.push_back("-remove_plugin_steps");
1022   ci::Subprocess backend = CreateSubprocess();
1023   backend.RunWithArgs(args);
1024   int status = backend.Wait();
1025   if (WIFEXITED(status)) {
1026     if (WEXITSTATUS(status) == 0)
1027       return BackendInterface::SubProcessResult::SUCCESS;
1028     else
1029       return BackendInterface::SubProcessResult::FAIL;
1030   }
1031   return BackendInterface::SubProcessResult::UnKnown;
1032 }
1033
1034 BackendInterface::SubProcessResult BackendInterface::RunSubprocessAndKill(
1035     std::vector<std::string> args, useconds_t delay) const {
1036   args.push_back("-remove_plugin_steps");
1037   ci::Subprocess backend = CreateSubprocess();
1038   backend.RunWithArgs(args);
1039   usleep(delay);
1040   backend.Kill();
1041   int status = backend.Wait();
1042   if (WIFEXITED(status)) {
1043     if (WEXITSTATUS(status) == 0)
1044       return BackendInterface::SubProcessResult::SUCCESS;
1045     else
1046       return BackendInterface::SubProcessResult::FAIL;
1047   } else {
1048     if (WTERMSIG(status) == SIGKILL)
1049       return BackendInterface::SubProcessResult::KILLED;
1050     else
1051       return BackendInterface::SubProcessResult::UnKnown;
1052   }
1053 }
1054
1055 BackendInterface::SubProcessResult BackendInterface::InstallWithSubprocess(
1056     const bf::path& path) const {
1057   std::vector<std::string> args =
1058       { "-i", path.string(), "-u", uid_str_ };
1059   return RunSubprocess(args);
1060 }
1061
1062 BackendInterface::SubProcessResult BackendInterface::MountInstallWithSubprocess(
1063     const bf::path& path) const {
1064   std::vector<std::string> args =
1065       { "-w", path.string(), "-u", uid_str_ };
1066   return RunSubprocess(args);
1067 }
1068
1069 BackendInterface::SubProcessResult BackendInterface::RecoverWithSubprocess(
1070     const bf::path& path) const {
1071   std::vector<std::string> args =
1072       { "-b", path.string(), "-u", uid_str_ };
1073   return RunSubprocess(args);
1074 }
1075
1076 BackendInterface::SubProcessResult BackendInterface::UninstallWithSubprocess(
1077     const std::string& pkgid) const {
1078   std::vector<std::string> args = { "-d", pkgid, "-u", uid_str_ };
1079   return RunSubprocess(args);
1080 }
1081
1082 BackendInterface::SubProcessResult
1083 BackendInterface::InstallPreloadWithSubprocess(
1084     const boost::filesystem::path& path) const {
1085   std::vector<std::string> args = { "", "-i", path.string(), "--preload" };
1086   return RunSubprocess(args);
1087 }
1088
1089 BackendInterface::SubProcessResult
1090     BackendInterface::InstallWithSubprocessAndKill(
1091         const bf::path& path, useconds_t delay) const {
1092   std::vector<std::string> args =
1093       { "-i", path.string(), "-u", uid_str_ };
1094   return RunSubprocessAndKill(args, delay);
1095 }
1096
1097 BackendInterface::SubProcessResult
1098     BackendInterface::MountInstallWithSubprocessAndKill(
1099         const bf::path& path, useconds_t delay) const {
1100   std::vector<std::string> args =
1101       { "-w", path.string(), "-u", uid_str_ };
1102   return RunSubprocessAndKill(args, delay);
1103 }
1104
1105 BackendInterface::SubProcessResult
1106     BackendInterface::UninstallWithSubprocessAndKill(
1107         const std::string& pkgid, useconds_t delay) const {
1108   std::vector<std::string> args =
1109       { "-d", pkgid, "-u", uid_str_ };
1110   return RunSubprocessAndKill(args, delay);
1111 }
1112
1113 BackendInterface::SubProcessResult BackendInterface::InstallPkgsWithSubprocess(
1114     const std::vector<bf::path>& paths) const {
1115   std::vector<std::string> args;
1116   args.emplace_back("-i");
1117   for (const bf::path& p : paths)
1118     args.emplace_back(p.string());
1119   args.emplace_back("-u");
1120   args.emplace_back(uid_str_);
1121   return RunSubprocess(args);
1122 }
1123
1124 BackendInterface::SubProcessResult
1125     BackendInterface::MountInstallPkgsWithSubprocess(
1126     const std::vector<bf::path>& paths) const {
1127   std::vector<std::string> args;
1128   args.emplace_back("-w");
1129   for (const bf::path& p : paths)
1130     args.emplace_back(p.string());
1131   args.emplace_back("-u");
1132   args.emplace_back(uid_str_);
1133   return RunSubprocess(args);
1134 }
1135
1136 BackendInterface::SubProcessResult BackendInterface::RecoverPkgsWithSubprocess(
1137     const std::vector<bf::path>& paths) const {
1138   std::vector<std::string> args;
1139   args.emplace_back("-b");
1140   for (const bf::path& p : paths)
1141     args.emplace_back(p.string());
1142   args.emplace_back("-u");
1143   args.emplace_back(uid_str_);
1144   return RunSubprocess(args);
1145 }
1146
1147 BackendInterface::SubProcessResult
1148     BackendInterface::UninstallPkgsWithSubprocess(
1149         const std::vector<std::string>& pkgids) const {
1150   std::vector<std::string> args;
1151   args.emplace_back("-d");
1152   args.insert(args.end(), pkgids.begin(), pkgids.end());
1153   args.emplace_back("-u");
1154   args.emplace_back(uid_str_);
1155   return RunSubprocess(args);
1156 }
1157
1158 BackendInterface::SubProcessResult
1159     BackendInterface::InstallPkgsWithSubprocessAndKill(
1160         const std::vector<bf::path>& paths, useconds_t delay) const {
1161   std::vector<std::string> args;
1162   args.emplace_back("-i");
1163   for (const bf::path& p : paths)
1164     args.emplace_back(p.string());
1165   args.emplace_back("-u");
1166   args.emplace_back(uid_str_);
1167   return RunSubprocessAndKill(args, delay);
1168 }
1169
1170 BackendInterface::SubProcessResult
1171     BackendInterface::MountInstallPkgsWithSubprocessAndKill(
1172         const std::vector<bf::path>& paths, useconds_t delay) const {
1173   std::vector<std::string> args;
1174   args.emplace_back("-w");
1175   for (const bf::path& p : paths)
1176     args.emplace_back(p.string());
1177   args.emplace_back("-u");
1178   args.emplace_back(uid_str_);
1179   return RunSubprocessAndKill(args, delay);
1180 }
1181
1182 bool CopySmackAccess(const boost::filesystem::path& src,
1183                      const boost::filesystem::path& dst) {
1184   if (!bf::exists(src) && !bf::is_symlink(src)) {
1185     LOG(ERROR) << "Failed to copy smack access label";
1186     return false;
1187   }
1188   int ret;
1189   char* access_label = nullptr;
1190   ret = smack_lgetlabel(src.c_str(), &access_label, SMACK_LABEL_ACCESS);
1191   if (ret < 0) {
1192     LOG(ERROR) << "get access label from [" << src << "] fail";
1193     return false;
1194   }
1195   if (!access_label)
1196     return true;
1197   ret = smack_lsetlabel(dst.c_str(), access_label, SMACK_LABEL_ACCESS);
1198   free(access_label);
1199   if (ret < 0) {
1200     LOG(ERROR) << "set access label to [" << dst << "] fail";
1201     return false;
1202   }
1203   return true;
1204 }
1205
1206 bool CopySmackExec(const boost::filesystem::path& src,
1207                    const boost::filesystem::path& dst) {
1208   if (!bf::exists(src) && !bf::is_symlink(src)) {
1209     LOG(ERROR) << "Failed to copy smack exec label";
1210     return false;
1211   }
1212   int ret;
1213   char *exec_label = nullptr;
1214   ret = smack_lgetlabel(src.c_str(), &exec_label, SMACK_LABEL_EXEC);
1215   if (ret < 0) {
1216     LOG(ERROR) << "get exec label from [" << src << "] fail";
1217     return false;
1218   }
1219   if (!exec_label)
1220     return true;
1221   ret = smack_lsetlabel(dst.c_str(), exec_label, SMACK_LABEL_EXEC);
1222   free(exec_label);
1223   if (ret < 0) {
1224     LOG(ERROR) << "set exec label to [" << dst << "] fail";
1225     return false;
1226   }
1227   return true;
1228 }
1229
1230 bool CopySmackMmap(const boost::filesystem::path& src,
1231                    const boost::filesystem::path& dst) {
1232   if (!bf::exists(src) && !bf::is_symlink(src)) {
1233     LOG(ERROR) << "Failed to copy smack mmap label";
1234     return false;
1235   }
1236   int ret;
1237   char *mmap_label = nullptr;
1238   ret = smack_lgetlabel(src.c_str(), &mmap_label, SMACK_LABEL_MMAP);
1239   if (ret < 0) {
1240     LOG(ERROR) << "get mmap label from [" << src << "] fail";
1241     return false;
1242   }
1243   if (!mmap_label)
1244     return true;
1245   ret = smack_lsetlabel(dst.c_str(), mmap_label, SMACK_LABEL_MMAP);
1246   free(mmap_label);
1247   if (ret < 0) {
1248     LOG(ERROR) << "set mmap label to [" << dst << "] fail";
1249     return false;
1250   }
1251   return true;
1252 }
1253
1254 bool CopySmackTransmute(const boost::filesystem::path& src,
1255                         const boost::filesystem::path& dst) {
1256   if (!bf::exists(src)) {
1257     LOG(ERROR) << "Failed to copy smack tranmute label";
1258     return false;
1259   }
1260   int ret;
1261   char *transmute_label = nullptr;
1262   ret = smack_lgetlabel(src.c_str(), &transmute_label, SMACK_LABEL_TRANSMUTE);
1263   if (ret < 0) {
1264     LOG(ERROR) << "get access label from [" << src << "] fail";
1265     return false;
1266   }
1267   if (!transmute_label) {
1268     ret = smack_lsetlabel(dst.c_str(), "0", SMACK_LABEL_TRANSMUTE);
1269   } else {
1270     if (strcmp(transmute_label, "TRUE") == 0)
1271       ret = smack_lsetlabel(dst.c_str(), "1", SMACK_LABEL_TRANSMUTE);
1272     else
1273       ret = smack_lsetlabel(dst.c_str(), "0", SMACK_LABEL_TRANSMUTE);
1274     free(transmute_label);
1275     if (ret < 0) {
1276       LOG(ERROR) << "set access label to [" << dst << "] fail";
1277       return false;
1278     }
1279   }
1280
1281   return true;
1282 }
1283
1284 bool CopySmackLabels(const boost::filesystem::path& src,
1285                      const boost::filesystem::path& dst) {
1286   if (!CopySmackAccess(src, dst))
1287     return false;
1288   if (!CopySmackExec(src, dst))
1289     return false;
1290   if (!CopySmackMmap(src, dst))
1291     return false;
1292   if (!bf::is_symlink(src) && bf::is_directory(src)) {
1293     if (!CopySmackTransmute(src, dst))
1294       return false;
1295   }
1296   return true;
1297 }
1298
1299 bool CopyAndRemoveWithSmack(const bf::path& src, const bf::path& dst) {
1300   bs::error_code error;
1301   if (bf::exists(dst)) {
1302     try {
1303       bf::remove_all(dst, error);
1304     } catch (...) {
1305       std::cout << "Exception occurred during remove [" << dst.string()
1306                 << "], and skip this file"<< std::endl;
1307     }
1308     if (error) {
1309       if (!bf::is_directory(dst)) {
1310         LOG(ERROR) << "remove_all fail";
1311         return false;
1312       }
1313     }
1314   }
1315   try {
1316     if (bf::is_symlink(src)) {
1317       bf::copy_symlink(src, dst, error);
1318       if (error) {
1319         LOG(ERROR) << "Failed to copy symlink: " << src << ", "
1320                    << error.message();
1321         return false;
1322       }
1323       if (!CopySmackLabels(src, dst)) {
1324         LOG(ERROR) << "copy smack label from [" << src.string()
1325                    << "] to [" << dst.string() << "] fail";
1326         return false;
1327       }
1328     } else if (bf::is_directory(src)) {
1329       if (!bf::exists(dst)) {
1330         bf::create_directories(dst, error);
1331         if (error) {
1332           LOG(ERROR) << "create directories fail";
1333           return false;
1334         }
1335         ci::CopyOwnershipAndPermissions(src, dst);
1336         if (!CopySmackLabels(src, dst)) {
1337           LOG(ERROR) << "copy smack label from [" << src.string()
1338                      << "] to [" << dst.string() << "] fail";
1339           return false;
1340         }
1341       }
1342       bool success = true;
1343       for (bf::directory_iterator file(src);
1344           file != bf::directory_iterator();
1345           ++file) {
1346         bf::path current(file->path());
1347         bf::path target = dst / current.filename();
1348         success &= CopyAndRemoveWithSmack(current, target);
1349       }
1350       bf::remove_all(src);
1351       if (!success)
1352         return false;
1353     } else {
1354       bf::copy_file(src, dst);
1355       ci::CopyOwnershipAndPermissions(src, dst);
1356       if (!CopySmackLabels(src, dst)) {
1357         LOG(ERROR) << "copy smack label from [" << src.string()
1358                    << "] to [" << dst.string() << "] fail";
1359         return false;
1360       }
1361       bf::remove_all(src);
1362     }
1363   } catch (...) {
1364     std::cout << "Exception occurred during copy [" << src.string()
1365               << "], and skip this file"<< std::endl;
1366     return true;
1367   }
1368
1369   return true;
1370 }
1371
1372 bool BackupPathCopyAndRemove(const bf::path& path) {
1373   if (!bf::exists(path))
1374     return true;
1375
1376   bf::path backup_path = path.string() + ".bck";
1377   std::cout << "Backup path: " << path << " to " << backup_path << std::endl;
1378   if (!CopyAndRemoveWithSmack(path, backup_path)) {
1379     LOG(ERROR) << "Failed to setup test environment. Does some previous"
1380                << " test crashed? Path: "
1381                << backup_path << " should not exist.";
1382     return false;
1383   }
1384   return true;
1385 }
1386
1387 bool BackupPath(const bf::path& path) {
1388   bf::path trash_path = GetTrashPath(path);
1389   if (bf::exists(trash_path)) {
1390     LOG(ERROR) << trash_path << " exists. Please remove "
1391                << trash_path << " manually!";
1392     return false;
1393   }
1394   bf::path backup_path = path.string() + ".bck";
1395   std::cout << "Backup path: " << path << " to " << backup_path << std::endl;
1396   bs::error_code error;
1397   bf::remove_all(backup_path, error);
1398   if (error)
1399     LOG(ERROR) << "Remove failed: " << backup_path
1400                << " (" << error.message() << ")";
1401   if (bf::exists(path)) {
1402     bf::rename(path, backup_path, error);
1403     if (error) {
1404       LOG(ERROR) << "Failed to setup test environment. Does some previous"
1405                  << " test crashed? Path: "
1406                  << backup_path << " should not exist.";
1407       return false;
1408     }
1409     assert(!error);
1410     if (bf::is_directory(backup_path))
1411       bf::create_directory(path);
1412   }
1413   return true;
1414 }
1415
1416 void CreateDatabase() {
1417   pkgmgr_parser_create_and_initialize_db(kGlobalUserUid);
1418   pkgmgr_parser_create_and_initialize_db(getuid());
1419 }
1420
1421 bool RestorePathCopyAndRemove(const bf::path& path) {
1422   bf::path backup_path = path.string() + ".bck";
1423   if (!bf::exists(backup_path))
1424     return true;
1425
1426   std::cout << "Restore path: " << path << " from " << backup_path << std::endl;
1427   if (!CopyAndRemoveWithSmack(backup_path, path)) {
1428     LOG(ERROR) << "Failed to restore backup path: " << backup_path;
1429     return false;
1430   }
1431   return true;
1432 }
1433
1434 bool RestorePath(const bf::path& path) {
1435   bf::path backup_path = path.string() + ".bck";
1436   std::cout << "Restore path: " << path << " from " << backup_path << std::endl;
1437   bs::error_code error;
1438   bf::remove_all(path, error);
1439   if (error) {
1440     bf::path trash_path = GetTrashPath(path);
1441     LOG(ERROR) << "Remove failed: " << path << " (" << error.message() << ")";
1442     std::cout << "Moving " << path << " to " << trash_path << std::endl;
1443     bf::rename(path, trash_path, error);
1444     if (error)
1445       LOG(ERROR) << "Failed to move " << path << " to " << trash_path
1446                  << " (" << error.message() << ")";
1447     else
1448       LOG(ERROR) << trash_path << " should be removed manually!";
1449   }
1450   if (bf::exists(backup_path)) {
1451     bf::rename(backup_path, path, error);
1452     if (error) {
1453       LOG(ERROR) << "Failed to restore backup path: " << backup_path
1454                  << " (" << error.message() << ")";
1455       return false;
1456     }
1457   }
1458   return true;
1459 }
1460
1461 std::vector<bf::path> SetupBackupDirectories(uid_t test_uid) {
1462   std::vector<bf::path> entries;
1463   bf::path db_dir = bf::path(tzplatform_getenv(TZ_SYS_DB));
1464   if (test_uid != kGlobalUserUid)
1465     db_dir = db_dir / "user" / std::to_string(test_uid);
1466   for (auto e : kDBEntries) {
1467     bf::path path = db_dir / e;
1468     entries.emplace_back(path);
1469   }
1470
1471   if (getuid() == 0) {
1472     entries.emplace_back(kPreloadApps);
1473     entries.emplace_back(kPreloadManifestDir);
1474     entries.emplace_back(kPreloadIcons);
1475   }
1476
1477   if (test_uid == kGlobalUserUid) {
1478     entries.emplace_back(kSkelDir);
1479     entries.emplace_back(kGlobalManifestDir);
1480     ci::UserList list = ci::GetUserList();
1481     for (auto l : list) {
1482       bf::path apps = std::get<2>(l) / "apps_rw";
1483       entries.emplace_back(apps);
1484     }
1485   } else {
1486     tzplatform_set_user(test_uid);
1487     bf::path approot = tzplatform_getenv(TZ_USER_APPROOT);
1488     tzplatform_reset_user();
1489     entries.emplace_back(approot);
1490   }
1491
1492   bf::path apps_rw = ci::GetRootAppPath(false, test_uid);
1493   entries.emplace_back(apps_rw);
1494   entries.emplace_back(kSdkDirectory);
1495
1496   return entries;
1497 }
1498
1499 void UninstallAllAppsInDirectory(bf::path dir, bool is_preload,
1500     BackendInterface* backend) {
1501   if (bf::exists(dir)) {
1502     for (auto& dir_entry : boost::make_iterator_range(
1503         bf::directory_iterator(dir), bf::directory_iterator())) {
1504       if (dir_entry.path().string().find("smoke") != std::string::npos &&
1505           bf::is_directory(dir_entry)) {
1506         std::string package = dir_entry.path().filename().string();
1507         std::regex pkg_regex("smoke[a-zA-Z0-9]{5,}");
1508         if (std::regex_match(package, pkg_regex)) {
1509           BackendInterface::CommandResult result =
1510               BackendInterface::CommandResult::OK;
1511           if (is_preload)
1512             result = backend->UninstallPreload(
1513                 dir_entry.path().filename().string());
1514           else
1515             result = backend->Uninstall(
1516                 dir_entry.path().filename().string());
1517           if (result != BackendInterface::CommandResult::OK) {
1518             LOG(ERROR) << "Cannot uninstall smoke test app: "
1519                 << dir_entry.path().filename().string();
1520           }
1521         }
1522       }
1523     }
1524   }
1525 }
1526
1527 void UninstallAllSmokeApps(ci::RequestMode request_mode, uid_t test_uid,
1528     BackendInterface *backend) {
1529   std::cout << "Uninstalling all smoke apps" << std::endl;
1530   bf::path apps_rw = ci::GetRootAppPath(false, test_uid);
1531   UninstallAllAppsInDirectory(apps_rw, false, backend);
1532   if (getuid() == 0 && request_mode == ci::RequestMode::GLOBAL) {
1533     bf::path root_path = kPreloadApps;
1534     UninstallAllAppsInDirectory(root_path, true, backend);
1535   }
1536 }
1537
1538 int GetAppInstalledTime(const char* appid, uid_t uid) {
1539   int ret = 0;
1540   int installed_time = 0;
1541   pkgmgrinfo_appinfo_h handle = NULL;
1542   ret = pkgmgrinfo_appinfo_get_usr_appinfo(appid, uid, &handle);
1543   if (ret != PMINFO_R_OK)
1544     return -1;
1545   ret = pkgmgrinfo_appinfo_get_installed_time(handle, &installed_time);
1546   if (ret != PMINFO_R_OK) {
1547     pkgmgrinfo_appinfo_destroy_appinfo(handle);
1548     return -1;
1549   }
1550   pkgmgrinfo_appinfo_destroy_appinfo(handle);
1551   return installed_time;
1552 }
1553
1554 }  // namespace smoke_test