src/plugins/dm-private/slp-device-dm/src/plugin_slp_device_ctrl.c

   1 /*
   2  * oma-dm-agent
   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 #include <stdbool.h>
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <stdlib.h>
  22 #include <unistd.h>
  23 #include <wait.h>
  24 #include <errno.h>
  25 #include <vconf.h>
  26 #include <vconf-keys.h>
  27 /*#include "package-manager.h"*/
  28
  29 /*sync-agent*/
  30 #include <sync_agent.h>
  31
  32 #include "plugin_slp_device_ctrl.h"
  33
  34 #ifndef OMADM_AGENT_LOG
  35 #undef LOG_TAG
  36 #define LOG_TAG "PLUGIN_DEVICE_SLP_DM"
  37 #endif
  38
  39 #define RB_ERR_CODE_MAX_COUNT 16
  40
  41 typedef struct _type_Redbend_OMADM_Table {
  42         int result_code;
  43         char *str_meanning;
  44         char *result_redbend;
  45         char *str_redbend;
  46 } type_redbend_omadm_table_s;
  47
  48 type_redbend_omadm_table_s redbend_omadm_table[RB_ERR_CODE_MAX_COUNT] = {
  49         {200, "Successful", "0", "S_RB_SUCCESS"},
  50         {410, "Firmware Update Failed", "1", "E_RB_*"}, // juhaki.park
  51         {402, "Corrupted Firmware Update Package", "8000000D", "E_RB_PKG_CORRUPTED"},
  52         {403, "Firmware Update Package - Device Mismatch", "80000002", "E_RB_BAD_PARAMS"},
  53         {403, "Firmware Update Package - Device Mismatch", "80000011", "E_RB_WRONG_UPI_VER"},
  54         {403, "Firmware Update Package - Device Mismatch", "80000012", "E_RB_WRONG_UPI_UPDATE"},
  55         {403, "Firmware Update Package - Device Mismatch", "80000013", "E_RB_UPDATE_SECTOR_SIG"},
  56         {404, "Failed Firmware Update Package Validation", "8001001A", "E_RB_NON_DP_FORMAT_NOT_SUPPORTED"},
  57         {404, "Failed Firmware Update Package Validation", "80010025", "E_RB_INVALID_DP_HEADER"},
  58         {404, "Failed Firmware Update Package Validation", "80010026", "E_RB_INVALID_DP_WRONG_SIGNATURE"},
  59         {404, "Failed Firmware Update Package Validation", "80010027", "E_RB_INVALID_DP"},
  60         {405, "Firmware Update Package Not Acceptable", "8000000B", "E_RB_PKG_TOO_SHORT"},
  61         {405, "Firmware Update Package Not Acceptable", "8000000C", "E_RB_PKG_TOO_LONG"},
  62         {405, "Firmware Update Package Not Acceptable", "8000000E", "E_RB_PKG_NOT_AUTHORIZED"},
  63         {410, "Firmware Update Failed", "**", "E_RB_*"},
  64         {502, "Firmware update fails due to device out of memory", "8000001E", "E_RB_NOT_ENOUGH_RAM"},
  65
  66 /*{0, NULL, NULL, NULL},*/
  67 };
  68
  69 static int _system_command(const char *command);
  70 /*static int __get_mobile_tracker_status();*/
  71 /*static int __return_pkgmgr_cb(pkg_request_id req_id, const char *pkg_type, const char *pkg_name, const char *key, const char *val, const void *pmsg, void *data);*/
  72
  73 int slp_device_ctrl_set_fota_flag()
  74 {
  75         _EXTERN_FUNC_ENTER;
  76
  77         /*
  78            2010.09.08 document base
  79            ("echo fota_enable > /sys/devices/platform/s3c_samsung_fota/samsung_fota_config");
  80            _DEBUG_INFO("echo fota_enable > /sys/devices/platform/s3c_samsung_fota/samsung_fota_config \n");
  81            2011.03.23 document base
  82            ("/bin/change-booting-mode.sh --fota /opt/data/fota");
  83          */
  84
  85         _DEBUG_INFO("/bin/change-booting-mode.sh --fota /opt/data/fota/save \n");
  86         int ret = _system_command("/bin/change-booting-mode.sh --fota /opt/data/fota/save");
  87         if (ret != -1) {
  88                 _EXTERN_FUNC_EXIT;
  89                 return 1;
  90         } else {
  91                 _EXTERN_FUNC_EXIT;
  92                 return 0;
  93         }
  94 /*error:
  95         return 0;*/
  96 }
  97
  98 int slp_device_ctrl_get_fota_update_result()
  99 {
 100         _EXTERN_FUNC_ENTER;
 101
 102         int update_result = 400;
 103         FILE *file_des;
 104         long lSize = 0;         /*prevent */
 105         size_t result;
 106         file_des = fopen("/opt/result", "rb");
 107         int j = 0;
 108         bool match_found = false;
 109         if (file_des == NULL) {
 110                 _DEBUG_INFO("fopen fail - result file \n");
 111                 _EXTERN_FUNC_EXIT;
 112                 return 400;
 113         }
 114         fseek(file_des, 0, SEEK_END);
 115         lSize = ftell(file_des);
 116         if (lSize < 0) {
 117                 _DEBUG_INFO("ftell nagative return ");
 118                 if (file_des != NULL)
 119                         fclose(file_des);
 120                 _EXTERN_FUNC_EXIT;
 121                 return 400;
 122         }
 123         rewind(file_des);
 124         char *str_result = NULL;
 125         str_result = (char *)calloc(1, lSize + 1);
 126         if (str_result == NULL) {
 127                 if (file_des != NULL)
 128                         fclose(file_des);
 129                 _DEBUG_INFO("malloc fail \n");
 130                 _EXTERN_FUNC_EXIT;
 131                 return 400;
 132         }
 133
 134         result = fread(str_result, 1, lSize, file_des);
 135         if ((result != lSize) || (str_result == NULL)) {
 136                 if (file_des != NULL)
 137                         fclose(file_des);
 138                 _DEBUG_INFO("read fail or str_result == NULL \n");
 139
 140                 if (str_result != NULL)
 141                         free(str_result);
 142
 143                 _EXTERN_FUNC_EXIT;
 144                 return 400;
 145         }
 146         if (str_result[lSize - 1] == '\n')
 147                 str_result[lSize - 1] = 0;
 148
 149         for (j = 0; j < RB_ERR_CODE_MAX_COUNT; j++) {
 150                 if (strlen(str_result) == strlen(redbend_omadm_table[j].result_redbend)) {
 151                         if ((strcmp(str_result, redbend_omadm_table[j].result_redbend) == 0)) {
 152                                 update_result = redbend_omadm_table[j].result_code;
 153                                 match_found = true;
 154                                 _DEBUG_INFO("Redbend[%s] \n", redbend_omadm_table[j].str_redbend);
 155                                 break;  /* If existing error code, break-out from the for-loop. */
 156                         }
 157                 }
 158                 if (!match_found)
 159                         update_result = 410;
 160         }
 161
 162         if (str_result != NULL)
 163                 free(str_result);
 164
 165         if (file_des != NULL)
 166                 fclose(file_des);
 167
 168         _DEBUG_INFO("update_result - %d \n", update_result);
 169         _EXTERN_FUNC_EXIT;
 170         return update_result;
 171 }
 172
 173 int slp_device_ctrl_reboot()
 174 {
 175         _EXTERN_FUNC_ENTER;
 176
 177         int ret = _system_command("/sbin/reboot");
 178         if (ret != -1) {
 179                 _EXTERN_FUNC_EXIT;
 180                 return 1;
 181         }
 182
 183         /*will be insert.. // tel_process_power_command(TAPI_PHONE_POWER_RESET); ?? */
 184         _EXTERN_FUNC_EXIT;
 185         return 0;
 186 }
 187
 188 int slp_device_ctrl_fully_lock()
 189 {
 190         _EXTERN_FUNC_ENTER;
 191
 192         /*if (__get_mobile_tracker_status() == 0 ) {
 193            _DEBUG_INFO("mobile tracker status OFF \n");
 194            return 0;
 195            }
 196
 197            ("/opt/apps/deb.com.samsung.pwlock/bin/pwlock 1 &");
 198            ("/bin/sync"); */
 199
 200         _EXTERN_FUNC_EXIT;
 201         return 1;
 202 }
 203
 204 int slp_device_ctrl_partially_lock()
 205 {
 206         _EXTERN_FUNC_ENTER;
 207
 208         /*if (__get_mobile_tracker_status() == 0 ) {
 209            _DEBUG_INFO("mobile tracker status OFF \n");
 210            return 0;
 211            }
 212
 213            ("/opt/apps/deb.com.samsung.pwlock/bin/pwlock 1 &");
 214            ("/bin/sync"); */
 215
 216         _EXTERN_FUNC_EXIT;
 217         return 1;
 218 }
 219
 220 int slp_device_ctrl_unlock()
 221 {
 222         _EXTERN_FUNC_ENTER;
 223
 224         /*if (__get_mobile_tracker_status() == 0 ) {
 225            _DEBUG_INFO("mobile tracker status OFF \n");
 226            return 0;
 227            }
 228
 229            ("killall -9 pwlock");
 230            ("/bin/sync"); */
 231         _EXTERN_FUNC_EXIT;
 232         return 1;
 233 }
 234
 235 int slp_device_ctrl_factory_reset()
 236 {
 237         _EXTERN_FUNC_ENTER;
 238
 239         /*if (__get_mobile_tracker_status() == 0 ) {
 240            _DEBUG_INFO("mobile tracker status OFF \n");
 241            return 0;
 242            }
 243            ("/usr/bin/factory-reset.sh"); // */
 244
 245         _EXTERN_FUNC_EXIT;
 246         return 1;
 247 }
 248
 249 /* static function */
 250 static int _system_command(const char *command)
 251 {
 252         _INNER_FUNC_ENTER;
 253
 254         int pid = 0, status = 0;
 255         char *const environ[] = { NULL };
 256
 257         retvm_if((command) == NULL, -1, "command is NULL!!");
 258
 259         pid = fork();
 260         if (pid == -1) {
 261                 _DEBUG_TRACE("ERROR : fork failed to create a process\n");
 262                 _INNER_FUNC_EXIT;
 263                 return -1;
 264
 265         } else if (pid == 0) {
 266                 char *argv[4];
 267                 argv[0] = "sh";
 268                 argv[1] = "-c";
 269                 argv[2] = (char *)command;
 270                 argv[3] = 0;
 271
 272                 execve("/bin/sh", argv, environ);
 273                 abort();
 274         } else {
 275                 do {
 276                         if (waitpid(pid, &status, 0) == -1) {
 277                                 if (errno != EINTR) {
 278                                         return -1;
 279                                 }
 280
 281                         } else {
 282                                 _INNER_FUNC_EXIT;
 283                                 return status;
 284                         }
 285
 286                 } while (1);
 287         }
 288         _INNER_FUNC_EXIT;
 289         return -1;
 290 }
 291
 292 /* TODO : holding ( wait until the MDM module is completed ) */
 293 /*int Execute_Dev_App_Install(char *file_name, char *application_id)
 294 {
 295     if( file_name == NULL )
 296                 return 0;
 297
 298     _DEBUG_INFO("file_name[%s] \n", file_name);
 299     int result = 0 ;
 300
 301     int req_id = 0;
 302     char *descriptor = NULL;
 303     char abs_setup_file[256] = {0,};
 304     ecore_init();
 305       snprintf(abs_setup_file,sizeof(abs_setup_file),"%s", file_name );
 306       _DEBUG_INFO("[%s] , [%s] \n", abs_setup_file, file_name );
 307     result = package_manager_install_application(&req_id, descriptor, abs_setup_file, PKG_QUIET PKG_DEFAULT, 0, NULL);
 308     LOGTRACE("package_manager_install_application result[%d]\n", result);
 309     if( result < PKG_COMMON_OK) {
 310                 LOGTRACE("Install failed! result[%d] \n", result );
 311                 snprintf(app_ID, PKG_TYPE_STRING_LEN_MAX+PKG_NAME_STRING_LEN_MAX+PKG_VERSION_STRING_LEN_MAX +2 , "%s" , pFile_name );
 312       //pthread_mutex_unlock(&wait_mutex);
 313                 //return 0;
 314     }
 315     else{
 316                 ecore_main_loop_begin();
 317                 snprintf(app_ID, PKG_TYPE_STRING_LEN_MAX+PKG_NAME_STRING_LEN_MAX+PKG_VERSION_STRING_LEN_MAX +2, "%s" , g_pkg_info.pkg_name );
 318     }
 319
 320     ("/bin/sync");
 321
 322     if( result == PKG_COMMON_OK ) {
 323       _DEBUG_INFO("package_manager_install_application() Success !!\n");
 324       result = 0;
 325
 326     } else {
 327       _DEBUG_INFO("package_manager_install_application() Success !!\n");
 328       result = 1;
 329     }
 330
 331     return result ;  // 1(OK),0(FAIL)
 332 }*/
 333
 334 /*int Execute_Dev_App_UnInstall(char *application_id)
 335 {
 336     int result = 0 ;
 337
 338     if( app_ID == NULL )
 339                 return 0 ; // 1(OK),0(FAIL)
 340     LOGTRACE("app_ID[%s] \n", app_ID);
 341
 342     if( strlen(app_ID) >= 256 ) // Prevent defect
 343     {
 344                 LOGTRACE("strlen[app_ID] >= 256 \n");
 345                 return 0 ; // 1(OK),0(FAIL)
 346     }
 347
 348 #if defined(_D_SLP_PKGMGR_)
 349     int req_id = 0;
 350     char *descriptor = NULL;
 351     char pkg_type[16] = {0,};
 352     memcpy(pkg_type,app_ID,3);
 353
 354     ecore_init();
 355     result = package_manager_uninstall_application(&req_id, pkg_type, app_ID , PKG_QUIET PKG_DEFAULT, return_pkgmgr_cb, NULL);
 356     if( result < PKG_COMMON_OK)
 357     {
 358                 LOGTRACE("Uninstall failed! result[%d] \n", result);
 359                 //return 1;
 360     }
 361     else {
 362                 ecore_main_loop_begin();
 363     }
 364 #endif
 365
 366     ("/bin/sync");
 367     if( result == PKG_COMMON_OK ) {
 368                 char return_char[512] = {0,};
 369                 snprintf(return_char,510,"%s,success,%s", (char*)_D_APP_UNINSTALL_,app_ID ); // Prevent defect
 370                 QUEUE_sendto ( _D_SYNCML_DM_SERVICE_SOCKET_PATH , (void*) return_char , strlen(return_char) );
 371     }
 372     else{
 373      char return_char[512] = {0,};
 374      snprintf(return_char,510,"%s,fail,%s", (char*)_D_APP_UNINSTALL_,app_ID ); // Prevent defect
 375      QUEUE_sendto ( _D_SYNCML_DM_SERVICE_SOCKET_PATH , (void*) return_char , strlen(return_char) );
 376     }
 377
 378     return result ;  // 1(OK),0(FAIL)
 379 }*/
 380
 381 /*int Execute_Dev_App_Activate(char *applicaton_id, int activate_status)
 382 {
 383     int result = 0 ;
 384
 385     if( app_ID == NULL )
 386                 return 0 ; // 1(OK),0(FAIL)
 387     LOGTRACE("appID[%s] activate[%d] \n", app_ID, activate);
 388
 389     if( strlen(app_ID) >= 256 ) // Prevent defect
 390     {
 391                 LOGTRACE("strlen[app_ID] >= 256 \n");
 392                 return 0 ; // 1(OK),0(FAIL)
 393     }
 394
 395 #if defined(_D_SLP_PKGMGR_)
 396     int req_id = 0;
 397     char *descriptor = NULL;
 398     char pkg_type[16] = {0,};
 399     memcpy(pkg_type,app_ID,3);
 400
 401     ecore_init();
 402     result = package_manager_activate_application(&req_id, pkg_type, app_ID , activate, return_pkgmgr_cb, NULL);
 403     if( result < PKG_COMMON_OK)
 404     {
 405                 LOGTRACE("Uninstall failed! result[%d] \n", result);
 406                 //return 1;
 407     }
 408     else {
 409                 ecore_main_loop_begin();
 410     }
 411 #endif
 412
 413     ("/bin/sync");
 414     if( result == PKG_COMMON_OK ) {
 415                 char return_char[512] = {0,};
 416                 if( activate ) {
 417                         snprintf(return_char,510,"%s,success,%s", (char*)_D_APP_ACTIVE_,app_ID ); // prevent defect
 418                 }
 419                 else {
 420                         snprintf(return_char,510,"%s,success,%s", (char*)_D_APP_INACTIVE_,app_ID ); // prevent defect
 421                 }
 422
 423                 QUEUE_sendto ( _D_SYNCML_DM_SERVICE_SOCKET_PATH , (void*) return_char , strlen(return_char) );
 424         }
 425     else{
 426                 char return_char[512] = {0,};
 427                 if( activate ){
 428                         snprintf(return_char,510,"%s,fail,%s", (char*)_D_APP_ACTIVE_,app_ID ); // prevent defect
 429                 }
 430                 else {
 431                         snprintf(return_char,510,"%s,fail,%s", (char*)_D_APP_INACTIVE_,app_ID ); // prevent defect
 432                 }
 433                 QUEUE_sendto ( _D_SYNCML_DM_SERVICE_SOCKET_PATH , (void*) return_char , strlen(return_char) );
 434         }
 435
 436         return result ;  // 1(OK),0(FAIL)
 437 }*/
 438
 439 /*static int __return_pkgmgr_cb(pkg_request_id req_id, const char *pkg_type, const char *pkg_name, const char *key, const char *val, const void *pmsg, void *data)
 440 {
 441       LOGTRACE("return_cb req_id[%d] pkg_type[%s] pkg_name[%s] key[%s] val[%s]\n", req_id, pkg_type, pkg_name, key, val);
 442 //    printf("return_cb req_id[%d] pkg_type[%s] pkg_name[%s] key[%s] val[%s]\n", req_id, pkg_type, pkg_name, key, val);
 443
 444       if( strncmp(key, "end", strlen("end") ) == 0) {
 445                 snprintf(g_pkg_info.pkg_type, PKG_TYPE_STRING_LEN_MAX, "%s", pkg_type);
 446                 snprintf(g_pkg_info.pkg_name, PKG_NAME_STRING_LEN_MAX, "%s", pkg_name);
 447                 //snprintf(g_pkg_info.pkg_version, PKG_VERSION_STRING_LEN_MAX, "%s", val);
 448                 //exit(0); ==> exit ���� �׳� process ��ü�� �׾� ����..
 449                 ecore_main_loop_quit(); // ==> ecore_main_loop_begin() ���� �κ��� ����
 450                 //pthread_cond_signal(&wait_cond); // sending signal
 451       }
 452     else if( strncmp(key, "install_percent", strlen("install_percent") ) == 0) {
 453                 LOGTRACE("install_percent[%s] \n", val);
 454     }
 455       return 0; // Prevent defect 25315
 456 }*/
 457
 458 /*static int __get_mobile_tracker_status()
 459 {
 460         char str_key_name[128] = { 0, };
 461         int int_key = 0;
 462
 463         memset(str_key_name, 0, sizeof(str_key_name));
 464         snprintf(str_key_name, sizeof(str_key_name), "%s", VCONFKEY_SETAPPL_STATE_MOBILE_TRACKER_BOOL); //db/setting/mobile_tracker
 465
 466         if (!vconf_get_bool(str_key_name, &int_key)) {
 467                 _DEBUG_VERBOSE("%s success , int_key : %d \n", VCONFKEY_SETAPPL_STATE_MOBILE_TRACKER_BOOL, int_key);
 468         } else {
 469                 _DEBUG_VERBOSE("%s failed \n", VCONFKEY_SETAPPL_STATE_MOBILE_TRACKER_BOOL);
 470         }
 471
 472         _DEBUG_VERBOSE(" %s vconf %d value \n", VCONFKEY_SETAPPL_STATE_MOBILE_TRACKER_BOOL, int_key);
 473         return int_key;
 474 }*/