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 #include "HybridInstaller.h"
  37
  38 using namespace Tizen::App;
  39 using namespace Tizen::App::Package;
  40 using namespace Tizen::Base;
  41 using namespace Tizen::Io;
  42
  43 extern "C" void Osp_Initialize();
  44 static bool __osp_installer_report_result(const PackageId& packageId, int errorType);
  45
  46 static pkgmgr_installer *_pi = null;
  47
  48 int
  49 main(int argc, char **argv)
  50 {
  51         int ret = 0;
  52         int errorType = 0;
  53         int reqType = 0;
  54         int emul = 0;
  55         const char* pPkgInfo = null;
  56         const char* pPkgPath = null;
  57         const char* pOptional = null;
  58         const char* pStoreClientId = null;
  59         String path;
  60         String optionalData;
  61         PackageId packageId;
  62
  63         appcore_set_i18n(null, null);
  64         Osp_Initialize();
  65
  66         String buf;
  67         for (int i = 0; i < argc; i++)
  68         {
  69                 const char* pStr = argv[i];
  70                 if (pStr)
  71                 {
  72                         AppLog(" # argv[%d] = [%s]", i, pStr);
  73
  74                         std::unique_ptr< String > pCmd(new (std::nothrow) String(pStr));
  75                         TryReturn(pCmd, 0, "pCmd is null.");
  76
  77                         buf.Append(*pCmd.get());
  78                         if (i != argc - 1)
  79                         {
  80                                 buf.Append(" ");
  81                         }
  82                 }
  83         }
  84
  85 #ifdef _OSP_EMUL_
  86         emul = 1;
  87 #endif
  88         fprintf(stderr, "  ## osp-installer: %s device=[%s] cmd=[%ls]\n", OSP_INSTALLER_VERSION, emul?"Emulator":"Target", buf.GetPointer());
  89
  90         if (argc == TEST_ARG_COUNT)
  91         {
  92                 errorType = InstallerManager::ReqeustByTest();
  93                 goto CATCH;
  94         }
  95         else if (argc <= COMMAND_ARG_COUNT && (!(argv[1][2] == 'v' || argv[1][1] == 'v')))
  96         {
  97                 errorType = InstallerManager::RequestByCommand(argc, argv);
  98                 goto CATCH;
  99         }
 100         else if (argv[1][2] == 'v')
 101         {
 102                 if (argv[3] && argv[3][1] == 'p')
 103                 {
 104                         if(argv[4])
 105                         {
 106                                 errorType = InstallerManager::RequestHybrid(argv[1][1], argv[2], atoi(argv[4]));
 107                         }
 108                         else
 109                         {
 110                                 errorType = INSTALLER_ERROR_SIGNATURE_NOT_FOUND;
 111
 112                                 AppLog("stdout is updated by errorType [%d]", errorType);
 113                                 fprintf(stdout, "%d", errorType);
 114
 115                                 goto CATCH;
 116                         }
 117                 }
 118                 else
 119                 {
 120                         errorType = InstallerManager::RequestHybrid(argv[1][1], argv[2]);
 121                 }
 122                 goto CATCH;
 123         }
 124         else if(argv[1][1] == 'v')
 125         {
 126                 if (argv[3] && argv[3][1] == 'p')
 127                 {
 128                         if(argv[4])
 129                         {
 130                                 errorType = InstallerManager::RequestHybrid(argv[1][1], argv[2], atoi(argv[4]));
 131                         }
 132                         else
 133                         {
 134                                 errorType = INSTALLER_ERROR_SIGNATURE_NOT_FOUND;
 135
 136                                 AppLog("stdout is updated by errorType [%d]", errorType);
 137                                 fprintf(stdout, "%d", errorType);
 138
 139                                 goto CATCH;
 140                         }
 141                 }
 142                 else
 143                 {
 144                         errorType = InstallerManager::RequestHybrid(argv[1][2], argv[2]);
 145                 }
 146                 goto CATCH;
 147         }
 148
 149         _pi = pkgmgr_installer_new();
 150
 151         pkgmgr_installer_receive_request(_pi, argc, argv);
 152
 153         reqType = pkgmgr_installer_get_request_type(_pi);
 154         if (PKGMGR_REQ_INVALID >= reqType)
 155         {
 156                 goto CATCH;
 157         }
 158
 159         pPkgInfo = pkgmgr_installer_get_request_info(_pi);
 160         pPkgPath = (const_cast<char*>(pPkgInfo));
 161         AppLog(" # path = [%s]", pPkgPath);
 162
 163         path = pPkgPath;
 164
 165         switch (reqType)
 166         {
 167         case PKGMGR_REQ_INSTALL:
 168                 {
 169                         pOptional = pkgmgr_installer_get_optional_data(_pi);
 170                         if (pOptional)
 171                         {
 172                                 optionalData = pOptional;
 173                                 AppLog(" # optional = [%ls]", optionalData.GetPointer());
 174                         }
 175                         else
 176                         {
 177                                 FileAttributes attr;
 178                                 result r = File::GetAttributes(path, attr);
 179                                 if (IsFailed(r))
 180                                 {
 181                                         AppLog("GetAttributes() failed. [%ls]", path.GetPointer());
 182                                         goto CATCH;
 183                                 }
 184
 185                                 if (attr.IsDirectory())
 186                                 {
 187                                         if (path.EndsWith("/") == true)
 188                                         {
 189                                                 int length = path.GetLength();
 190                                                 path.Remove(length - 1, 1);
 191                                         }
 192
 193                                         path.SubString(path.GetLength() - PACKAGE_ID_LENGTH, PACKAGE_ID_LENGTH, packageId);
 194                                 }
 195                                 else
 196                                 {
 197                                         std::unique_ptr< PackageInfo > pPackageInfo(_PackageManagerImpl::GetInstance()->GetPackageInfoFromFileN(path));
 198                                         if (pPackageInfo)
 199                                         {
 200                                                 packageId = pPackageInfo->GetId();
 201                                         }
 202                                 }
 203
 204                                 optionalData = packageId;
 205                                 AppLog(" # path = [%ls] -> optionalData = [%ls]", path.GetPointer(), optionalData.GetPointer());
 206                         }
 207
 208                         pStoreClientId = pkgmgr_installer_get_caller_pkgid(_pi);
 209                         if (pStoreClientId)
 210                         {
 211                                 PackageId StoreClientId = pStoreClientId;
 212                                 optionalData.Append(":StoreClientId=");
 213                                 optionalData.Append(StoreClientId);
 214                                 AppLog(" # optionalData = [%ls]", optionalData.GetPointer());
 215                         }
 216
 217                         errorType = InstallerManager::Request(path, INSTALLER_OPERATION_INSTALL, INSTALLER_OPTION_NORMAL, _pi, &optionalData);
 218
 219 //              if (errorType != 0)
 220 //                      {
 221 //                              manager.RemoveGarbage(path);
 222 //                      }
 223
 224                         __osp_installer_report_result(packageId, errorType);
 225                 }
 226                 break;
 227
 228         case PKGMGR_REQ_UNINSTALL:
 229                 {
 230                         bool isCscPackage = false;
 231                         String originPath;
 232                         PackageId reqeustPackageId;
 233                         path.SubString(0, PACKAGE_ID_LENGTH, reqeustPackageId);
 234                         AppLog("reqeustPackage = %ls", reqeustPackageId.GetPointer());
 235
 236                         if (InstallerManager::IsUninstallUpdates(reqeustPackageId, originPath, isCscPackage) == true)
 237                         {
 238                                 AppLog("originPath = [%ls], isCscPackage = [%s]", originPath.GetPointer(), isCscPackage?"true":"false");
 239                                 optionalData = reqeustPackageId;
 240
 241                                 errorType = InstallerManager::Request(reqeustPackageId, INSTALLER_OPERATION_UNINSTALL, INSTALLER_OPTION_NORMAL, _pi);
 242
 243                                 if (isCscPackage == false)
 244                                 {
 245                                         errorType = InstallerManager::Request(originPath, INSTALLER_OPERATION_INSTALL, INSTALLER_OPTION_RESET_PRELOADED, _pi, &optionalData);
 246                                 }
 247                                 else
 248                                 {
 249                                         InstallerOption option = INSTALLER_OPTION_RESET_PRELOADED;
 250                                         option = (InstallerOption)(option | INSTALLER_OPTION_CSC);
 251
 252                                         errorType = InstallerManager::RequestCsc(originPath, option, _pi);
 253                                 }
 254                         }
 255                         else
 256                         {
 257                                 errorType = InstallerManager::Request(reqeustPackageId, INSTALLER_OPERATION_UNINSTALL, INSTALLER_OPTION_NORMAL, _pi);
 258                         }
 259
 260                         __osp_installer_report_result(reqeustPackageId, errorType);
 261                 }
 262                 break;
 263
 264         case PKGMGR_REQ_REINSTALL:
 265                 {
 266                         PackageId rdsPackageId;
 267
 268                         path.SubString(0, PACKAGE_ID_LENGTH, rdsPackageId);
 269
 270                         AppLog("rdsPackage = %ls", rdsPackageId.GetPointer());
 271                         ret = InstallerManager::Request(rdsPackageId, INSTALLER_OPERATION_REINSTALL, INSTALLER_OPTION_NORMAL, _pi, &rdsPackageId);
 272
 273                         __osp_installer_report_result(rdsPackageId, errorType);
 274                 }
 275                 break;
 276
 277         case PKGMGR_REQ_MOVE:
 278                 {
 279                         if (_pi != 0)
 280                         {
 281                                 int moveType = -1;
 282                                 moveType = pkgmgr_installer_get_move_type(_pi);
 283
 284                                 InstallerManager::RequestMove(path, moveType, _pi);
 285                         }
 286                         else
 287                         {
 288                                 AppLog("_pi is null");
 289                         }
 290                 }
 291                 break;
 292
 293         default:
 294                 ret = -1;
 295                 break;
 296         }
 297
 298         if (ret == -1)
 299         {
 300                 goto CATCH;
 301         }
 302
 303 CATCH:
 304
 305         return errorType;
 306 }
 307
 308 bool
 309 __osp_installer_report_result(const PackageId& packageId, int errorType)
 310 {
 311         AppLog("------------------------------------------");
 312         AppLog("osp_installer_report_result");
 313         AppLog(" # request_type = [%d]", pkgmgr_installer_get_request_type(_pi));
 314         AppLog(" # request_info = [%s]", pkgmgr_installer_get_request_info(_pi));
 315         AppLog(" # session = [%s]", pkgmgr_installer_get_session_id(_pi));
 316         if (packageId.IsEmpty() == false)
 317         {
 318                 AppLog(" # package = [%ls]", packageId.GetPointer());
 319         }
 320         AppLog(" # errorType = [%d]", errorType);
 321         AppLog("------------------------------------------");
 322
 323         if (_pi == 0)
 324         {
 325                 AppLog("_pi is null");
 326                 return false;
 327         }
 328
 329         pkgmgr_installer_free(_pi);
 330         _pi = null;
 331
 332         return true;
 333 }