frontend/src/rpm-appcore-intf.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 <pthread.h>
  25 #include <string.h>
  26 //#include <device/power.h>
  27
  28 #include "rpm-frontend.h"
  29 #include "rpm-installer-util.h"
  30 #include "rpm-installer.h"
  31 #include <pkgmgr_installer.h>
  32
  33 #define CONFIG_PATH             "/usr/etc/rpm-installer-config.ini"
  34 static void __ri_start_processing(void *user_data);
  35 static int __ri_is_signature_verification_enabled();
  36
  37 int ret_val = -1;
  38 /*flag to check whether signature verification is on/off*/
  39 int sig_enable = 0;
  40 int broadcast_disable = 0;
  41 extern char scrolllabel[256];
  42 extern ri_frontend_data front_data;
  43 pkgmgr_installer *pi = NULL;
  44
  45
  46 static int __ri_is_signature_verification_enabled()
  47 {
  48         char buffer[1024] = {'\0'};
  49         char *p = NULL;
  50         FILE *fi = NULL;
  51         int len = 0;
  52         int ret = 0;
  53         fi = fopen(CONFIG_PATH, "r");
  54         if (fi == NULL) {
  55                 _LOGE("Failed to open config file [%s]\n", CONFIG_PATH);
  56                 return 0;
  57         }
  58         while (fgets(buffer, 1024, fi) != NULL) {
  59                 /* buffer will be like signature=off\n\0*/
  60                 if (strncmp(buffer, "signature", strlen("signature")) == 0) {
  61                         len = strlen(buffer);
  62                         /*remove newline character*/
  63                         buffer[len - 1] = '\0';
  64                         p = strchr(buffer, '=');
  65                         if (p) {
  66                                 p++;
  67                                 if (strcmp(p, "on") == 0)
  68                                         ret = 1;
  69                                 else
  70                                         ret = 0;
  71                         }
  72                 } else {
  73                         continue;
  74                 }
  75         }
  76         fclose(fi);
  77         return ret;
  78 }
  79
  80
  81 static void __ri_start_processing(void *user_data)
  82 {
  83         int ret = 0;
  84         if (user_data == NULL) {
  85                 _LOGE("arg supplied is NULL \n");
  86                 return;
  87         }
  88         ri_frontend_data *data = (ri_frontend_data *) user_data;
  89         ret = _ri_cmdline_process(data);
  90         ret_val = ret;
  91         _ri_cmdline_destroy(data);
  92
  93 }
  94
  95 int main(int argc, char *argv[])
  96 {
  97         int i = 0;
  98         int ret = 0;
  99         char *errstr = NULL;
 100         ri_frontend_cmdline_arg *data = NULL;
 101         struct stat st;
 102
 103         _LOGD("------------------------------------------------");
 104         _LOGD(" [START] rpm-installer: version=[%s]", RPM_INSTALLER_VERSION);
 105         _LOGD("------------------------------------------------");
 106
 107         // hybrid
 108         ret = _ri_parse_hybrid(argc, argv);
 109         if (ret == RPM_INSTALLER_SUCCESS) {
 110                 _LOGD("------------------------------------------------");
 111                 _LOGD(" [END] rpm-installer: _ri_parse_hybrid() succeed.");
 112                 _LOGD("------------------------------------------------");
 113                 fprintf(stdout, "%d", ret);
 114                 return 0;
 115         }
 116
 117         for (i = 0; i < argc; i++)
 118         {
 119                 const char* pStr = argv[i];
 120                 if (pStr)
 121                 {
 122                         _LOGD("argv[%d] = [%s]", i, pStr);
 123                 }
 124         }
 125
 126         // power_lock
 127 //      ret = device_power_request_lock(POWER_LOCK_CPU, 0);
 128 //      _LOGD("device_power_lock_state(POWER_LOCK_CPU, 0), ret = [%d]", ret);
 129
 130         /* Initialize the xml parser */
 131         xmlInitParser();
 132         // _LOGD("xml parser initialized");
 133
 134         /*get signature verification config*/
 135         sig_enable = __ri_is_signature_verification_enabled();
 136         _LOGD("signature verification mode is [%s]", sig_enable?"on":"off");
 137
 138         data = (ri_frontend_cmdline_arg *) calloc(1,
 139                                                   sizeof
 140                                                   (ri_frontend_cmdline_arg));
 141         if (data == NULL) {
 142                 _LOGE("Not Enough Memory\n");
 143                 ret = RPM_INSTALLER_ERR_NOT_ENOUGH_MEMORY;
 144                 goto ERROR;
 145         }
 146         data->keyid = NULL;
 147         data->pkgid = NULL;
 148         data->req_cmd = INVALID_CMD;
 149         data->move_type = -1;
 150
 151         /* We need to use pkgmgr_installer_receive request()
 152            to parse the arguments */
 153         if ((ret =
 154              _ri_parse_cmdline(argc, argv, data)) != RPM_INSTALLER_SUCCESS) {
 155                 _LOGE("_ri_parse_cmdline failed \n");
 156                 goto ERROR;
 157         }
 158
 159 #if 0
 160         /*
 161         Check for converted wgt package.
 162         */
 163         if(strstr(data->pkgid,".wgt") != NULL){
 164                 _LOGD("[%s] is eflwgt package.\n", data->pkgid);
 165                 if(data->req_cmd == INSTALL_CMD){
 166                         data->req_cmd = EFLWGT_INSTALL_CMD;
 167                         ret = _ri_process_wgt_package(&data->pkgid);
 168                         if(ret != RPM_INSTALLER_SUCCESS){
 169                                 _ri_error_no_to_string(ret, &errstr);
 170                                 _LOGE("ERROR:[%s]",errstr);
 171                                 goto ERROR;
 172                         }
 173                 }else{
 174                         ret = RPM_INSTALLER_ERR_CMD_NOT_SUPPORTED;
 175                         _ri_error_no_to_string(ret,&errstr);
 176                         _LOGE("ERROR:[%s]",errstr);
 177                         goto ERROR;
 178                 }
 179         }
 180 #endif
 181
 182         if (strstr(data->keyid, "change-state") != NULL) {
 183                 _LOGE("change-state for [%s]\n", data->pkgid);
 184                 if (data->req_cmd == INSTALL_CMD) {
 185                         data->req_cmd = ENABLE_CMD;
 186                 } else if (data->req_cmd == DELETE_CMD) {
 187                         data->req_cmd = DISABLE_CMD;
 188                 } else {
 189                         ret = RPM_INSTALLER_ERR_CMD_NOT_SUPPORTED;
 190                         _ri_error_no_to_string(ret,&errstr);
 191                         _LOGE("ERROR:[%s]",errstr);
 192                         goto ERROR;
 193                 }
 194         }
 195
 196         /*installation for coretpk*/
 197         if ((strstr(argv[0], "coretpk") != NULL)
 198                         && (data->req_cmd == INSTALL_CMD)) {
 199                 if (stat(data->pkgid, &st)) {
 200                         ret = RPM_INSTALLER_ERR_UNKNOWN;
 201                         _ri_error_no_to_string(ret, &errstr);
 202                         _LOGE("ERROR:[%s]",errstr);
 203                         goto ERROR;
 204                 }
 205
 206                 if (S_ISDIR(st.st_mode)) {
 207                         _LOGD("[%s] is directory for tpk.\n", data->pkgid);
 208                         data->req_cmd = CORETPK_DIRECTORY_INSTALL_CMD;
 209                 } else {
 210                         _LOGD("[%s] is tpk package.\n", data->pkgid);
 211                         data->req_cmd = CORETPK_INSTALL_CMD;
 212                 }
 213         }
 214
 215         front_data.args = data;
 216         front_data.security_cookie = NULL;
 217         front_data.error = NULL;
 218
 219         __ri_start_processing(&front_data);
 220
 221         ret = ret_val;
 222         if ((strstr(data->keyid, ".tpk") != NULL) || (strstr(data->pkgid,".wgt") != NULL)) {
 223                 if(!ret_val) {
 224                         _LOGD("sync() start");
 225                         sync();
 226                         _LOGD("sync() end");
 227                 }
 228         }
 229
 230
 231 ERROR:
 232 //      device_power_release_lock(POWER_LOCK_CPU);
 233
 234         if (pi) {
 235                 pkgmgr_installer_free(pi);
 236                 pi = NULL;
 237         }
 238
 239         if (data) {
 240                 free(data);
 241                 data = NULL;
 242         }
 243
 244         xmlCleanupParser();
 245         _LOGD("------------------------------------------------");
 246         _LOGD(" [END] rpm-installer: result=[%d]", ret);
 247         _LOGD("------------------------------------------------");
 248
 249
 250         return ret;
 251
 252 }