src/common/external_storage.cc

   1 // Copyright (c) 2015 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 "common/external_storage.h"
   6
   7 #include <glib.h>
   8
   9 #include <manifest_parser/utils/logging.h>
  10
  11 #include "common/utils/byte_size_literals.h"
  12 #include "common/utils/file_util.h"
  13
  14 namespace bf = boost::filesystem;
  15
  16 namespace {
  17
  18 const char kWgtType[] = "wgt";
  19 const char kExternalDirForWgt[] = "res";
  20
  21 const std::vector<std::string> kExternalDirsForTpk = {
  22   "bin",
  23   "lib",
  24   "res"
  25 };
  26
  27 int64_t SizeInMB(int64_t size) {
  28   return (size + 1_MB - 1) / 1_MB;
  29 }
  30
  31 }  // namespace
  32
  33 namespace common_installer {
  34
  35 ExternalStorage::ExternalStorage(RequestType type,
  36     const std::string& pkgid, const std::string& package_type,
  37     const boost::filesystem::path& application_root, uid_t uid)
  38     : type_(type),
  39       pkgid_(pkgid),
  40       package_type_(package_type),
  41       application_root_(application_root),
  42       uid_(uid),
  43       handle_(nullptr) {
  44   if (package_type_ == kWgtType) {
  45     external_dirs_.push_back(kExternalDirForWgt);
  46   } else {
  47     external_dirs_ = kExternalDirsForTpk;
  48   }
  49   move_type_ = -1;
  50 }
  51
  52 ExternalStorage::ExternalStorage(RequestType type,
  53     const std::string& pkgid, const std::string& package_type,
  54     const boost::filesystem::path& application_root, uid_t uid,
  55     bool is_external_move)
  56     : type_(type),
  57       pkgid_(pkgid),
  58       package_type_(package_type),
  59       application_root_(application_root),
  60       uid_(uid),
  61       handle_(nullptr) {
  62   if (package_type_ == kWgtType) {
  63     external_dirs_.push_back(kExternalDirForWgt);
  64   } else {
  65     external_dirs_ = kExternalDirsForTpk;
  66   }
  67   if (is_external_move)
  68     move_type_ = APP2EXT_MOVE_TO_EXT;
  69   else
  70     move_type_ = APP2EXT_MOVE_TO_PHONE;
  71 }
  72
  73 ExternalStorage::~ExternalStorage() {
  74   if (handle_)
  75     app2ext_deinit(handle_);
  76 }
  77
  78 bool ExternalStorage::Finalize(bool success) {
  79   int ret = APP2EXT_STATUS_SUCCESS;
  80   switch (type_) {
  81   case RequestType::Install:
  82     ret = handle_->interface.client_usr_post_install(pkgid_.c_str(),
  83         success ? APP2EXT_STATUS_SUCCESS : APP2EXT_STATUS_FAILED, uid_);
  84     break;
  85   case RequestType::Update:
  86   case RequestType::Delta:
  87     ret = handle_->interface.client_usr_post_upgrade(pkgid_.c_str(),
  88         success ? APP2EXT_STATUS_SUCCESS : APP2EXT_STATUS_FAILED, uid_);
  89     break;
  90   case RequestType::Uninstall:
  91     ret = handle_->interface.client_usr_post_uninstall(pkgid_.c_str(), uid_);
  92     break;
  93   case RequestType::Move:
  94     ret = handle_->interface.client_usr_post_move(pkgid_.c_str(),
  95                                static_cast<app2ext_move_type_t>(move_type_),
  96                                uid_);
  97     break;
  98   default:
  99     assert(false && "Not supported installation mode");
 100   }
 101   return ret == APP2EXT_STATUS_SUCCESS;
 102 }
 103
 104 bool ExternalStorage::Commit() {
 105   return Finalize(true);
 106 }
 107
 108 bool ExternalStorage::Abort() {
 109   return Finalize(false);
 110 }
 111
 112 const std::vector<std::string>& ExternalStorage::external_dirs() const {
 113   return external_dirs_;
 114 }
 115
 116 bool ExternalStorage::Initialize(
 117     const boost::filesystem::path& space_requirement) {
 118   // external size in MB, set any-non zero size as default
 119   int external_size = 1;
 120
 121   if (!space_requirement.empty()) {
 122     if (package_type_ == kWgtType) {
 123       for (auto& dir : kExternalDirsForTpk) {
 124         bf::path requirement = space_requirement / dir;
 125         if (!bf::exists(requirement))
 126           continue;
 127         external_size +=
 128             SizeInMB(GetDirectorySize(requirement));
 129       }
 130     } else {
 131       // for wgt whole content of package goes to res/
 132       external_size =
 133           SizeInMB(GetDirectorySize(space_requirement));
 134     }
 135   }
 136
 137   if (external_size == 0)
 138     external_size = 1;
 139
 140   handle_ = app2ext_init(APP2EXT_SD_CARD);
 141   if (!handle_) {
 142     LOG(ERROR) << "app2ext_init() failed";
 143     return false;
 144   }
 145
 146   GList* glist = nullptr;
 147   for (auto& dir : external_dirs_) {
 148     app2ext_dir_details* dir_detail = reinterpret_cast<app2ext_dir_details*>(
 149         calloc(1, sizeof(app2ext_dir_details)));
 150     dir_detail->name = strdup(dir.c_str());
 151     dir_detail->type = APP2EXT_DIR_RO;
 152     glist = g_list_append(glist, dir_detail);
 153   }
 154
 155   int ret = 0;
 156   switch (type_) {
 157   case RequestType::Install:
 158     ret = handle_->interface.client_usr_force_clean(pkgid_.c_str(), uid_);
 159     if (ret) {
 160       LOG(ERROR) << "force_clean failed";
 161       break;
 162     }
 163     ret = handle_->interface.client_usr_pre_install(pkgid_.c_str(), glist,
 164                                                     external_size, uid_);
 165     break;
 166   case RequestType::Update:
 167   case RequestType::Delta:
 168     ret = handle_->interface.client_usr_pre_upgrade(pkgid_.c_str(), glist,
 169                                                     external_size, uid_);
 170     break;
 171   case RequestType::Move:
 172     if (move_type_ == -1) {
 173       LOG(ERROR) << "Invalid request [" << move_type_ << "]";
 174       ret = -1;
 175       break;
 176     }
 177
 178     // try umount before move
 179     ret = handle_->interface.client_usr_disable(pkgid_.c_str(), uid_);
 180
 181     ret = handle_->interface.client_usr_pre_move(pkgid_.c_str(), glist,
 182                                static_cast<app2ext_move_type_t>(move_type_),
 183                                uid_);
 184     break;
 185   case RequestType::Uninstall:
 186     ret = handle_->interface.client_usr_pre_uninstall(pkgid_.c_str(), uid_);
 187     break;
 188   case RequestType::Clear:
 189   case RequestType::Reinstall:
 190   case RequestType::Recovery:
 191   case RequestType::ManifestDirectInstall:
 192   case RequestType::ManifestDirectUpdate:
 193   case RequestType::MountInstall:
 194   case RequestType::MountUpdate:
 195     LOG(ERROR) << "Installation type is not supported by external installation";
 196     ret = -1;
 197     break;
 198   default:
 199     assert(false && "Invalid installation mode");
 200   }
 201
 202   g_list_free_full(glist, [](gpointer data) {
 203       app2ext_dir_details* dir_detail =
 204           reinterpret_cast<app2ext_dir_details*>(data);
 205       free(dir_detail->name);
 206       free(dir_detail);
 207     });
 208   return ret == 0;
 209 }
 210
 211 std::unique_ptr<ExternalStorage> ExternalStorage::MoveInstalledStorage(
 212     RequestType type, const boost::filesystem::path& application_root,
 213     const std::string& pkgid, const std::string& package_type,
 214     uid_t uid, bool is_external_move) {
 215
 216   std::unique_ptr<ExternalStorage> external_storage(
 217     new ExternalStorage(type, pkgid, package_type, application_root, uid,
 218                        is_external_move));
 219   if (!external_storage->Initialize(application_root)) {
 220     LOG(WARNING) << "Cannot initialize external storage for move";
 221     return nullptr;
 222   }
 223
 224   return external_storage;
 225 }
 226
 227 std::unique_ptr<ExternalStorage> ExternalStorage::AcquireExternalStorage(
 228     RequestType type, const boost::filesystem::path& application_root,
 229     const std::string& pkgid, const std::string& package_type,
 230     const boost::filesystem::path& space_requirement,
 231     uid_t uid) {
 232   std::unique_ptr<ExternalStorage> external_storage(
 233       new ExternalStorage(type, pkgid, package_type, application_root, uid));
 234   if (!external_storage->Initialize(space_requirement)) {
 235     LOG(WARNING) << "Cannot initialize external storage for request";
 236     return nullptr;
 237   }
 238   return external_storage;
 239 }
 240
 241 }  // namespace common_installer