frontend/src/rpm-cmdline.c

   1 /*
   2  * rpm-installer
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
   7  * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <getopt.h>
  26 #include <pthread.h>
  27 #include <stdio.h>
  28 #include <pkgmgr_installer.h>
  29 #include <security-server.h>
  30 #include <tzplatform_config.h>
  31 #include "rpm-frontend.h"
  32 #include "rpm-installer-util.h"
  33 #include "rpm-installer.h"
  34 #include "coretpk-installer.h"
  35
  36 #define _FIX_POP_UP_
  37 extern struct appdata ad;
  38 extern int ret_val;
  39 extern pkgmgr_installer *pi;
  40 ri_frontend_data front_data;
  41 char scrolllabel[256];
  42 int move_type;
  43 #define BUF_SIZE 1024
  44 #define OTP_USR_APPS tzplatform_getenv(TZ_USER_APP)
  45
  46 static void __ri_show_usage(char **arg);
  47 static int __ri_process_request(ri_frontend_cmdline_arg *fdata);
  48
  49 static void __ri_show_usage(char **arg)
  50 {
  51
  52         int i = 0;
  53         char buffer[256];
  54         char buff[256] = "";
  55         while (arg[i] != NULL) {
  56                 snprintf(buffer, 256, "%s %s", buff, arg[i]);
  57                 strncpy(buff, buffer, 255);
  58                 i++;
  59         }
  60
  61         _LOGD("%s\n", buffer);
  62         _LOGD(
  63                "\nrpm-backend usage\n   rpm-backend -k <keyid>  <command> <pkgid | pkg_path> [-q] \n\n");
  64         _LOGD("<Commands> \n");
  65         _LOGD(
  66                "\t -i <package file path>         : install package file \n");
  67         _LOGD(
  68                "\t -k <keyid>                   : key id file \n");
  69         _LOGD(
  70                "\t -r : (recover). Must ignore specific package name or path \n");
  71         _LOGD(
  72                "\t -d <package name>            : delete a package with package name \n");
  73         _LOGD(
  74                "\t -q : (quiet) run in background without any user interaction \n");
  75         _LOGD(
  76                "\t -s : (smack) apply smack rule and set smack label\n");
  77 }
  78
  79 int _ri_parse_hybrid(int argc, char **argv)
  80 {
  81         int i = 0;
  82
  83         if (argv[1] != NULL) {
  84                 if (!strcmp(argv[1], "-iv")) {
  85                         _LOGE("Hybrid Installation start\n");
  86
  87                         for (i = 0; i < argc; i++) {
  88                                 const char* arg_str = argv[i];
  89                                 if (arg_str)
  90                                         _LOGE("argv[%d] = [%s]\n", i, arg_str);
  91                         }
  92
  93                         if (_coretpk_installer_request_hybrid(argv[1][1], argv[2], atoi(argv[4])) == 0) {
  94                                 return RPM_INSTALLER_SUCCESS;
  95                         } else {
  96                                 return RPM_INSTALLER_ERR_INTERNAL;
  97                         }
  98                 } else if (!strcmp(argv[1], "-uv")) {
  99                         _LOGE("Hybrid Uninstallation start\n");
 100                         return RPM_INSTALLER_SUCCESS;
 101                 }
 102         }
 103
 104         return RPM_INSTALLER_ERR_WRONG_PARAM;
 105 }
 106
 107 int _ri_parse_cmdline(int argc, char **argv, ri_frontend_cmdline_arg *data)
 108 {
 109         int req_cmd = INVALID_CMD;
 110         const char *pkgid = NULL;
 111         const char *pkeyid = NULL;
 112         int ret = 0;
 113         int move_type = -1;
 114         pi = pkgmgr_installer_new();
 115         if (!pi) {
 116                 _LOGE(
 117                        "Failure in creating the pkgmgr_installer object \n");
 118                 return RPM_INSTALLER_ERR_WRONG_PARAM;
 119         }
 120         ret = pkgmgr_installer_receive_request(pi, argc, argv);
 121         if (ret) {
 122                 _LOGE("pkgmgr_installer_receive_request failed \n");
 123                 return RPM_INSTALLER_ERR_WRONG_PARAM;
 124         }
 125         ret = pkgmgr_installer_get_request_type(pi);
 126         switch (ret) {
 127         case PKGMGR_REQ_INSTALL:
 128                 req_cmd = INSTALL_CMD;
 129                 break;
 130         case PKGMGR_REQ_REINSTALL:
 131                 req_cmd = CORETPK_REINSTALL_CMD;
 132                 break;
 133         case PKGMGR_REQ_UNINSTALL:
 134                 req_cmd = DELETE_CMD;
 135                 break;
 136         case PKGMGR_REQ_RECOVER:
 137                 req_cmd = RECOVER_CMD;
 138                 break;
 139         case PKGMGR_REQ_CLEAR:
 140                 req_cmd = CLEARDATA_CMD;
 141                 break;
 142         case PKGMGR_REQ_MOVE:
 143                 req_cmd = MOVE_CMD;
 144                 break;
 145         case PKGMGR_REQ_SMACK:
 146                 req_cmd = SMACK_CMD;
 147                 break;
 148         case PKGMGR_REQ_PERM:
 149                 goto PARSEERROR;
 150         case PKGMGR_REQ_INVALID:
 151                 req_cmd = INVALID_CMD;
 152                 goto PARSEERROR;
 153         default:
 154                 goto PARSEERROR;
 155         }
 156         if (req_cmd != RECOVER_CMD) {
 157                 pkgid = pkgmgr_installer_get_request_info(pi);
 158                 if (!pkgid) {
 159                         _LOGE(
 160                                "pkgmgr_installer_get_request_info failed \n");
 161                         return RPM_INSTALLER_ERR_WRONG_PARAM;
 162                 }
 163                 pkeyid = pkgmgr_installer_get_session_id(pi);
 164                 if (!pkeyid) {
 165                         _LOGE("pkgmgr_installer_get_session_id failed \n");
 166                         return RPM_INSTALLER_ERR_WRONG_PARAM;
 167                 }
 168                 move_type = pkgmgr_installer_get_move_type(pi);
 169         }
 170 //Logically dead code,the value of req_cmd never satisfies the condition
 171 #if 0
 172         if ((req_cmd < INSTALL_CMD) ||(req_cmd > RPM_CMD_MAX)) {
 173                 _LOGE("invalid command \n");
 174                 goto PARSEERROR;
 175         }
 176 #endif
 177         data->req_cmd = req_cmd;
 178         data->pkgid = (char *)pkgid;
 179         data->keyid = (char *)pkeyid;
 180         data->move_type = move_type;
 181         data->clientid = (char *)pkgmgr_installer_get_caller_pkgid(pi);
 182
 183         return RPM_INSTALLER_SUCCESS;
 184
 185  PARSEERROR:
 186         _LOGE("Error in parsing input parameter\n");
 187         __ri_show_usage(argv);
 188         return RPM_INSTALLER_ERR_WRONG_PARAM;
 189
 190 }
 191
 192 static int __ri_is_core_tpk_app(char *pkgid)
 193 {
 194         char pkgpath[BUF_SIZE] = {'\0'};
 195
 196         snprintf(pkgpath, BUF_SIZE, "%s/%s/tizen-manifest.xml", OTP_USR_APPS, pkgid);
 197
 198         if (access(pkgpath, R_OK) == 0) {
 199                 _LOGE("This is a core tpk app.");
 200                 return 0;
 201         } else {
 202                 _LOGE("This is not a core tpk app.");
 203                 return -1;
 204         }
 205 }
 206
 207 static int __ri_process_request(ri_frontend_cmdline_arg *data)
 208 {
 209         int ret = 0;
 210         if (!data)
 211                 return RPM_INSTALLER_ERR_WRONG_PARAM;
 212         char *pkgid = NULL;
 213         char *keyid = NULL;
 214         if (data->req_cmd != RECOVER_CMD) {
 215                 pkgid = strdup(data->pkgid);
 216                 if (PM_UNLIKELY(pkgid == NULL)) {
 217                         _LOGE("strdup failed\n");
 218                         return RPM_INSTALLER_ERR_WRONG_PARAM;
 219                 }
 220                 keyid = strdup(data->keyid);
 221                 if (PM_UNLIKELY(keyid == NULL)) {
 222                         _LOGE("strdup failed\n");
 223                         free(pkgid);
 224                         pkgid = NULL;
 225                         return RPM_INSTALLER_ERR_WRONG_PARAM;
 226                 }
 227         }
 228
 229         if (pkgid == NULL) {
 230                 _LOGE("pkgid is null\n");
 231                 return -1;
 232         }
 233
 234         switch (data->req_cmd) {
 235         case INSTALL_CMD:
 236                 _LOGD("rpm-backend -i %s\n", pkgid);
 237                 ret = _rpm_backend_interface(keyid, pkgid, "install", data->clientid);
 238                 break;
 239         case DELETE_CMD:
 240                 if (__ri_is_core_tpk_app(pkgid) == 0) {
 241                         _LOGD("------------------------------------------------");
 242                         _LOGD("uninstallation: tpk, pkgid=[%s]", pkgid);
 243                         _LOGD("------------------------------------------------");
 244                         ret = _coretpk_backend_interface("coretpk-uninstall", data);
 245                 } else {
 246                         _LOGD("uninstallation for rpm [%s]", pkgid);
 247                         ret = _rpm_backend_interface(keyid, pkgid, "remove", NULL);
 248                 }
 249                 break;
 250         case CLEARDATA_CMD:
 251                 _LOGD("rpm-backend -c %s\n", pkgid);
 252                 ret = _rpm_backend_interface(keyid, pkgid, "cleardata", NULL);
 253                 break;
 254         case MOVE_CMD:
 255                 if (__ri_is_core_tpk_app(pkgid) == 0) {
 256                         _LOGD("coretpk-move %s\n", pkgid);
 257                         ret = _coretpk_backend_interface("coretpk-move", data);
 258                 } else {
 259                         _LOGD("rpm-backend -m %s -t %d\n", pkgid, data->move_type);
 260                         move_type = data->move_type;
 261                         ret = _rpm_backend_interface(keyid, pkgid, "move", NULL);
 262                 }
 263                 break;
 264         case RECOVER_CMD:
 265                 _LOGD("rpm-backend -r \n");
 266                 ret = _rpm_backend_interface(keyid, pkgid, "recover", NULL);
 267                 break;
 268         case SMACK_CMD:
 269                 _LOGD("rpm-backend -s %s", pkgid);
 270                 ret = _rpm_backend_interface(keyid, pkgid, "smack", NULL);
 271                 break;
 272         case EFLWGT_INSTALL_CMD:
 273                 _LOGD("eflwgt-install %s\n", pkgid);
 274                 ret = _rpm_backend_interface(keyid, pkgid, "eflwgt-install", data->clientid);
 275                 break;
 276         case CORETPK_INSTALL_CMD:
 277                 _LOGD("------------------------------------------------");
 278                 _LOGD("installation: tpk, arg=[%s]", pkgid);
 279                 _LOGD("------------------------------------------------");
 280                 ret = _coretpk_backend_interface("coretpk-install", data);
 281                 break;
 282         case CORETPK_REINSTALL_CMD:
 283                 _LOGD("coretpk-reinstall %s\n", pkgid);
 284                 ret = _coretpk_backend_interface("coretpk-reinstall", data);
 285                 break;
 286         case CORETPK_DIRECTORY_INSTALL_CMD:
 287                 _LOGD("coretpk-directory_install %s\n", pkgid);
 288                 ret = _coretpk_backend_interface("coretpk-directory-install", data);
 289                 break;
 290         case ENABLE_CMD:
 291                 _LOGD("rpm enable %s\n", pkgid);
 292                 ret = _rpm_backend_interface(keyid, pkgid, "rpm-enable", NULL);
 293                 break;
 294         case DISABLE_CMD:
 295                 _LOGD("rpm disable %s\n", pkgid);
 296                 ret = _rpm_backend_interface(keyid, pkgid, "rpm-disable", NULL);
 297                 break;
 298         default:
 299                 _LOGE("Error Never Come Here as Error is already checked\n");
 300         }
 301
 302         if (keyid) {
 303                 free(keyid);
 304                 keyid = NULL;
 305         }
 306         if (pkgid) {
 307                 free(pkgid);
 308                 pkgid = NULL;
 309         }
 310
 311         return ret;
 312 }
 313
 314 void _ri_stat_cb(const char *pkgid, const char *key, const char *val)
 315 {
 316
 317         if (NULL == pkgid || NULL == key || NULL == val) {
 318                 _LOGE("Either pkgid/key/val is NULL\n");
 319                 return;         /*TODO: handle error. */
 320         }
 321
 322         char pkgid_modified[PATH_MAX] = {0};
 323         char delims[] = "/";
 324         char *result = NULL;
 325         char *pkgid_tmp = NULL;
 326         char *saveptr = NULL;
 327
 328         memcpy(pkgid_modified, pkgid, strlen(pkgid));
 329
 330         result = strtok_r(pkgid_modified, delims, &saveptr);
 331         while (result != NULL) {
 332                 pkgid_tmp = result;
 333                 result = strtok_r(NULL, delims, &saveptr);
 334         }
 335
 336         if (strcmp(key, "install_percent") == 0) {
 337                 return;
 338         } else if (strcmp(key, "error") == 0) {
 339                 /* Store the error to be display to the user */
 340                 front_data.error = strdup(val);
 341         } else if (strcmp(key, "end") == 0) {
 342
 343                 char requesttype[32];
 344                 switch (front_data.args->req_cmd) {
 345                 case INSTALL_CMD:
 346                         snprintf(requesttype, sizeof(requesttype),
 347                                 "installation");
 348                         break;
 349                 case DELETE_CMD:
 350                         snprintf(requesttype, sizeof(requesttype), "deletion");
 351                         break;
 352                 case CLEARDATA_CMD:
 353                         snprintf(requesttype, sizeof(requesttype),
 354                                  "clear data");
 355                         break;
 356                 case MOVE_CMD:
 357                         snprintf(requesttype, sizeof(requesttype),
 358                                  "move");
 359                         break;
 360                 default:
 361                         snprintf(requesttype, sizeof(requesttype), "recovery");
 362                         break;
 363                 }
 364
 365                 if (front_data.error) {
 366                         /* Error Happened */
 367                         snprintf(scrolllabel, sizeof(scrolllabel),
 368                                  "%s :: %s:: %s:: %s", requesttype, pkgid_tmp,
 369                                  "error",
 370                                  front_data.error);
 371                         _LOGE("%s\n", scrolllabel);
 372                         ret_val = _ri_string_to_error_no(front_data.error);
 373                         _LOGE("%d\n", ret_val);
 374
 375                 } else {
 376                         snprintf(scrolllabel, sizeof(scrolllabel),
 377                                  " %s :: %s :: %s", requesttype, pkgid_tmp,
 378                                 "success");
 379                         _LOGD("%s\n", scrolllabel);
 380                         ret_val = 0;
 381                 }
 382         }
 383 }
 384
 385 int _ri_cmdline_process(ri_frontend_data *data)
 386 {
 387         int ret = 0;
 388         ri_frontend_cmdline_arg *fdata = data->args;
 389         /*rpm-installer is invoked by pkgmgr-server hence server should do cookie validation*/
 390         ret = __ri_process_request(fdata);
 391         if (ret != RPM_INSTALLER_SUCCESS) {
 392                 _LOGE("__ri_process_request: Error\n");
 393                 return ret;
 394         }
 395         return RPM_INSTALLER_SUCCESS;
 396 }
 397
 398 int _ri_cmdline_destroy(ri_frontend_data *data)
 399 {
 400         if (data == NULL)
 401                 return 0;
 402
 403         if (data->security_cookie){
 404                 free(data->security_cookie);
 405                 data->security_cookie = NULL;
 406         }
 407
 408         return 0;
 409
 410 }