src/backend/backend.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file        backend.cpp
  19  */
  20
  21 #include <new>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25 #include <string.h>
  26 #include <errno.h>
  27
  28 #include <appcore-common.h>
  29 #include <pkgmgr_installer.h>
  30
  31 #include <FIoFile.h>
  32 #include <FAppPkgPackageInfo.h>
  33 #include <FAppPkg_PackageManagerImpl.h>
  34
  35 #include "InstallerManager.h"
  36
  37 using namespace Tizen::App;
  38 using namespace Tizen::App::Package;
  39 using namespace Tizen::Base;
  40 using namespace Tizen::Io;
  41
  42 extern "C" void Osp_Initialize();
  43 static bool __osp_installer_report_result(const PackageId& packageId, int errorType);
  44
  45 static pkgmgr_installer *_pi = null;
  46
  47 int
  48 main(int argc, char **argv)
  49 {
  50         int ret = 0;
  51         const char *pkg_info = null;
  52         char* pkg_path = null;
  53         const char* pOptional = null;
  54         String path;
  55         String optionalData;
  56         PackageId packageId;
  57         int errorType = 0;
  58         pkgmgr_installer *pi = null;
  59         int req_type = 0;
  60
  61         appcore_set_i18n(null, null);
  62
  63         Osp_Initialize();
  64
  65         String buf;
  66         for (int i = 0; i < argc; i++)
  67         {
  68                 const char* pStr = argv[i];
  69                 if (pStr)
  70                 {
  71                         AppLog(" # argv[%d] = [%s]", i, pStr);
  72
  73                         std::unique_ptr< String > pCmd(new (std::nothrow) String(pStr));
  74                         TryReturn(pCmd, 0, "pCmd is null.");
  75
  76                         buf.Append(*pCmd.get());
  77                         if (i != argc - 1)
  78                         {
  79                                 buf.Append(" ");
  80                         }
  81                 }
  82         }
  83
  84         int emul = 0;
  85
  86 #ifdef _OSP_EMUL_
  87         emul = 1;
  88 #endif
  89         fprintf(stderr, "  ## osp-installer: %s[%s] cmd=[%ls]\n", OSP_INSTALLER_VERSION, emul?"Emulator":"Target", buf.GetPointer());
  90
  91         if (argc == TEST_ARG_COUNT)
  92         {
  93                 errorType = InstallerManager::ReqeustByTest();
  94                 goto CATCH;
  95         }
  96         else if (argc == COMMAND_ARG_COUNT)
  97         {
  98                 errorType = InstallerManager::RequestByCommand(argc, argv);
  99                 goto CATCH;
 100         }
 101
 102         pi = pkgmgr_installer_new();
 103         _pi = pi;
 104
 105         pkgmgr_installer_receive_request(pi, argc, argv);
 106
 107         req_type = pkgmgr_installer_get_request_type(pi);
 108         if (PKGMGR_REQ_INVALID >= req_type)
 109         {
 110                 goto CATCH;
 111         }
 112
 113         pkg_info = pkgmgr_installer_get_request_info(pi);
 114         pkg_path = (const_cast<char*>(pkg_info));
 115         AppLog(" # path = [%s]", pkg_path);
 116
 117         path = pkg_path;
 118
 119         switch (req_type)
 120         {
 121         case PKGMGR_REQ_INSTALL:
 122                 {
 123                         pOptional = pkgmgr_installer_get_optional_data(pi);
 124                         if (pOptional)
 125                         {
 126                                 optionalData = pOptional;
 127                                 AppLog(" # optional = [%ls]", optionalData.GetPointer());
 128                         }
 129                         else
 130                         {
 131                                 FileAttributes attr;
 132                                 result r = File::GetAttributes(path, attr);
 133                                 if (IsFailed(r))
 134                                 {
 135                                         AppLog("GetAttributes() failed. [%ls]", path.GetPointer());
 136                                         goto CATCH;
 137                                 }
 138
 139                                 if (attr.IsDirectory())
 140                                 {
 141                                         if (path.EndsWith("/") == true)
 142                                         {
 143                                                 int length = path.GetLength();
 144                                                 path.Remove(length - 1, 1);
 145                                         }
 146
 147                                         path.SubString(path.GetLength() - PACKAGE_ID_LENGTH, PACKAGE_ID_LENGTH, packageId);
 148                                 }
 149                                 else
 150                                 {
 151                                         std::unique_ptr< PackageInfo > pPackageInfo(_PackageManagerImpl::GetInstance()->GetPackageInfoFromFileN(path));
 152                                         if (pPackageInfo)
 153                                         {
 154                                                 packageId = pPackageInfo->GetId();
 155                                         }
 156                                 }
 157
 158                                 optionalData = packageId;
 159                                 AppLog(" # path = [%ls] -> optionalData = [%ls]", path.GetPointer(), optionalData.GetPointer());
 160                         }
 161
 162                         errorType = InstallerManager::Request(path, INSTALLER_OPERATION_INSTALL, INSTALLER_OPTION_NORMAL, pi, &optionalData);
 163
 164 //              if (errorType != 0)
 165 //                      {
 166 //                              manager.RemoveGarbage(path);
 167 //                      }
 168
 169                         __osp_installer_report_result(packageId, errorType);
 170                 }
 171                 break;
 172
 173         case PKGMGR_REQ_UNINSTALL:
 174                 {
 175                         bool isCscPackage = false;
 176                         PackageId reqeustPackageId;
 177                         path.SubString(0, PACKAGE_ID_LENGTH, reqeustPackageId);
 178                         AppLog("reqeustPackage = %ls", reqeustPackageId.GetPointer());
 179
 180                         String originPath;
 181                         if (InstallerManager::IsUninstallUpdates(reqeustPackageId, originPath, isCscPackage) == true)
 182                         {
 183                                 AppLog("originPath = [%ls], isCscPackage = [%s]", originPath.GetPointer(), isCscPackage?"true":"false");
 184                                 optionalData = reqeustPackageId;
 185
 186                                 if (isCscPackage == false)
 187                                 {
 188                                         errorType = InstallerManager::Request(originPath, INSTALLER_OPERATION_INSTALL, INSTALLER_OPTION_RESET_PRELOADED, _pi, &optionalData);
 189                                 }
 190                                 else
 191                                 {
 192                                         InstallerOption option = INSTALLER_OPTION_RESET_PRELOADED;
 193                                         option = (InstallerOption)(option | INSTALLER_OPTION_CSC);
 194
 195                                         errorType = InstallerManager::RequestCsc(originPath, option, _pi);
 196                                 }
 197                         }
 198                         else
 199                         {
 200                                 ret = InstallerManager::Request(reqeustPackageId, INSTALLER_OPERATION_UNINSTALL, INSTALLER_OPTION_NORMAL, _pi);
 201                         }
 202
 203                         __osp_installer_report_result(reqeustPackageId, errorType);
 204                 }
 205                 break;
 206
 207         case PKGMGR_REQ_REINSTALL:
 208                 {
 209                         PackageId rdsPackageId;
 210
 211                         path.SubString(0, PACKAGE_ID_LENGTH, rdsPackageId);
 212
 213                         AppLog("rdsPackage = %ls", rdsPackageId.GetPointer());
 214                         ret = InstallerManager::Request(rdsPackageId, INSTALLER_OPERATION_REINSTALL, INSTALLER_OPTION_NORMAL, _pi, &rdsPackageId);
 215
 216                         __osp_installer_report_result(rdsPackageId, errorType);
 217                 }
 218                 break;
 219
 220         case PKGMGR_REQ_MOVE:
 221                 {
 222                         if (_pi != 0)
 223                         {
 224                                 int moveType = -1;
 225                                 moveType = pkgmgr_installer_get_move_type(_pi);
 226
 227                                 InstallerManager::RequestMove(path, moveType);
 228                         }
 229                         else
 230                         {
 231                                 AppLog("_pi is null");
 232                         }
 233                 }
 234                 break;
 235
 236         default:
 237                 ret = -1;
 238                 break;
 239         }
 240
 241         if (ret == -1)
 242         {
 243                 goto CATCH;
 244         }
 245
 246 CATCH:
 247
 248         return errorType;
 249 }
 250
 251 bool
 252 __osp_installer_report_result(const PackageId& packageId, int errorType)
 253 {
 254         AppLog("------------------------------------------");
 255         AppLog("osp_installer_report_result");
 256         AppLog(" # request_type = [%d]", pkgmgr_installer_get_request_type(_pi));
 257         AppLog(" # request_info = [%s]", pkgmgr_installer_get_request_info(_pi));
 258         AppLog(" # session = [%s]", pkgmgr_installer_get_session_id(_pi));
 259         if (packageId.IsEmpty() == false)
 260         {
 261                 AppLog(" # package = [%ls]", packageId.GetPointer());
 262         }
 263         AppLog(" # errorType = [%d]", errorType);
 264         AppLog("------------------------------------------");
 265
 266         if (_pi == 0)
 267         {
 268                 AppLog("_pi is null");
 269                 return false;
 270         }
 271
 272         pkgmgr_installer_free(_pi);
 273         _pi = null;
 274
 275         return true;
 276 }