src/plugins/dm-private/slp-device-dm/src/plugin_slp_device_info.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 <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <sys/utsname.h>
  22 #include <vconf.h>
  23 #include <vconf-keys.h>
  24
  25 #include <tapi_common.h>
  26 #include <ITapiModem.h>
  27 #include <ITapiSim.h>
  28
  29 /*sync-agent*/
  30 #include <sync_agent.h>
  31
  32 #include "plugin_slp_device_info.h"
  33
  34 #ifndef OMADM_AGENT_LOG
  35 #undef LOG_TAG
  36 #define LOG_TAG "PLUGIN_DEVICE_SLP_DM"
  37 #endif
  38
  39 #define _D_SIZE_64_                     64
  40 #define _D_SIZE_128_                    128
  41
  42 /* todo : temporary definition */
  43 #define DTD_VERSION                     "1.2"
  44
  45 #define OPCO                                            "UK"
  46
  47 //#define FOTA_DOWNLOAD_DIR             "/opt/data/fota/download"
  48 //#define FOTA_SAVE_DIR                                 "/opt/data/fota/save"
  49 #define FOTA_DOWNLOAD_DIR               "/opt/usr/data/fota/download"
  50 #define FOTA_SAVE_DIR                                   "/opt/usr/data/fota/save"
  51 #define FOTA_SD_DOWNLOAD_DIR    "/opt/storage/sdcard/data/fota/download"
  52 #define FOTA_SD_SAVE_DIR                        "/opt/storage/sdcard/data/fota/save"
  53
  54 /* ========================================*/
  55 /* version information
  56  *      DTD version
  57  *      kernel version
  58  */
  59 /* ========================================*/
  60
  61 char *slp_device_info_get_dtd_version()
  62 {
  63         _EXTERN_FUNC_ENTER;
  64
  65         char *dtd_version = (char *)calloc(_D_SIZE_128_, sizeof(char));
  66         if (dtd_version == NULL) {
  67                 _DEBUG_INFO("CALLOC failed !!!");
  68                 _EXTERN_FUNC_EXIT;
  69                 return 0;
  70         }
  71         /*snprintf(dtd_version, _D_SIZE_128_ - 1, DTD_VERSION, strlen(DTD_VERSION)); */
  72         snprintf(dtd_version, _D_SIZE_128_ - 1, "%s", DTD_VERSION);
  73         _DEBUG_INFO("DTD version = %s\n", dtd_version);
  74
  75         _EXTERN_FUNC_EXIT;
  76         return dtd_version;
  77 }
  78
  79 char *slp_device_info_get_kernel_version()
  80 {
  81         _EXTERN_FUNC_ENTER;
  82
  83         char *kernel_version = (char *)calloc(_D_SIZE_128_, sizeof(char));
  84         if (kernel_version == NULL) {
  85                 _DEBUG_INFO("CALLOC failed !!!");
  86                 _EXTERN_FUNC_EXIT;
  87                 return 0;
  88         }
  89
  90         struct utsname buf;
  91         int uname_result = 0;
  92         uname_result = uname(&buf);
  93         if(uname_result != 0 ) {
  94                 snprintf(kernel_version, _D_SIZE_128_ - 1, "%s.%s", "K", "3.4.5");
  95
  96                 _DEBUG_INFO("uname failed - kernel_version [%s]", kernel_version);
  97                 _EXTERN_FUNC_EXIT;
  98                 return kernel_version;
  99         }
 100
 101         snprintf(kernel_version, _D_SIZE_128_ - 1, "%s.%s", "K", buf.release);
 102
 103         _DEBUG_INFO("sysname[%s], nodename[%s], release[%s], version[%s], machine[%s] \n", buf.sysname, buf.nodename, buf.release, buf.version, buf.machine);
 104         _EXTERN_FUNC_EXIT;
 105         return kernel_version;
 106 }
 107
 108 char *slp_device_info_get_msisdn_number()
 109 {
 110         _EXTERN_FUNC_ENTER;
 111
 112         char *get_str;
 113         char str_key_name[_D_SIZE_128_ * 2] = { 0, };
 114         snprintf(str_key_name, _D_SIZE_128_ * 2, "%s", VCONFKEY_TELEPHONY_SUBSCRIBER_NUMBER);
 115         get_str = vconf_get_str(str_key_name);
 116         _DEBUG_INFO("MSISDN_number = %s\n", get_str);
 117         _EXTERN_FUNC_EXIT;
 118         return get_str;
 119
 120 //      char *out_msisdn = 0;
 121 //      int MSISDN_LEN = 20;
 122 //    int err = SIM_ERROR_NONE;
 123 //    char *msisdn = 0;
 124 //
 125 //    out_msisdn = (char*)calloc(MSISDN_LEN, sizeof(char));
 126 //    if (out_msisdn == NULL)
 127 //      goto return_part;
 128 //
 129 //    err = sim_get_subscriber_number(&msisdn);
 130 //    if (!err && msisdn == NULL) {
 131 //        strncpy(out_msisdn, msisdn, MSISDN_LEN-1);
 132 //       free(msisdn);
 133 //    } else  {
 134 //        strncpy(out_msisdn, "", MSISDN_LEN-1);
 135 //    }
 136 //
 137 // return_part:
 138 //      _DEBUG_INFO("MSISDN = %s", msisdn);
 139 //    return msisdn;
 140 }
 141
 142 char *slp_device_info_get_mcc()
 143 {
 144         _EXTERN_FUNC_ENTER;
 145
 146         int mcc_len = 4;
 147         char *mcc = NULL;
 148         mcc = (char *)calloc(mcc_len, sizeof(char));
 149         if (mcc == NULL) {
 150                 goto return_part;
 151         }
 152
 153         int b_card_changed = 0;
 154         TapiHandle *handle;
 155         handle = tel_init(NULL);
 156         if (handle == NULL) {
 157                 _DEBUG_INFO("handle is NULL !!");
 158                 free(mcc);
 159                 mcc = NULL;
 160                 _EXTERN_FUNC_EXIT;
 161                 return NULL;
 162         }
 163         TelSimImsiInfo_t imsi;
 164         TapiResult_t err_code = TAPI_API_SUCCESS;
 165         TelSimCardStatus_t status = TAPI_SIM_STATUS_CARD_ERROR;
 166
 167         err_code = (TapiResult_t) tel_get_sim_init_info(handle, &status, &b_card_changed);
 168         if (err_code == TAPI_API_SUCCESS && status == TAPI_SIM_STATUS_SIM_INIT_COMPLETED) {
 169                 err_code = (TapiResult_t) tel_get_sim_imsi(handle, &imsi);
 170                 if (err_code == TAPI_API_SUCCESS) {
 171                         strncpy(mcc, imsi.szMcc, mcc_len);
 172                         _DEBUG_INFO("MCC = %s", mcc);
 173                         _EXTERN_FUNC_EXIT;
 174                         return mcc;
 175                 }
 176         }
 177
 178         strncpy(mcc, "0", mcc_len);
 179         _DEBUG_INFO("MCC = %s", mcc);
 180
 181         tel_deinit(handle);
 182
 183  return_part:
 184         _EXTERN_FUNC_EXIT;
 185
 186         return mcc;
 187 }
 188
 189 char *slp_device_info_get_csc()
 190 {
 191         _EXTERN_FUNC_ENTER;
 192
 193         _EXTERN_FUNC_EXIT;
 194         return strdup("VD2");
 195 }
 196
 197 /* ====================================
 198  * device directory information
 199  *              fota download directory
 200  *              fota save directory
 201  * =====================================*/
 202
 203 char *slp_device_info_get_fota_download_dir()
 204 {
 205         _EXTERN_FUNC_ENTER;
 206
 207         int ret = sync_agent_create_directory(FOTA_DOWNLOAD_DIR);
 208         if (ret == 0) {
 209                 _DEBUG_INFO("existed foler or create foler error");
 210         }
 211
 212         char *fota_download_dir = (char *)calloc(_D_SIZE_128_, sizeof(char));
 213         if (fota_download_dir == NULL) {
 214                 _DEBUG_INFO("CALLOC failed !!!");
 215                 _EXTERN_FUNC_EXIT;
 216                 return 0;
 217         }
 218         /*snprintf(FOTA_Download_Dir, _D_SIZE_128_ - 1, FOTA_DOWNLOAD_DIR, strlen(FOTA_DOWNLOAD_DIR)); */
 219         snprintf(fota_download_dir, _D_SIZE_128_ - 1, "%s", FOTA_DOWNLOAD_DIR);
 220
 221         _DEBUG_INFO("FOTA Download dir = %s\n", fota_download_dir);
 222         _EXTERN_FUNC_EXIT;
 223         return fota_download_dir;
 224
 225 }
 226
 227 char *slp_device_info_get_fota_save_dir()
 228 {
 229         _EXTERN_FUNC_ENTER;
 230
 231         int ret = sync_agent_create_directory(FOTA_SAVE_DIR);
 232         if (ret == 0) {
 233                 _DEBUG_INFO("existed foler or create foler error");
 234         }
 235
 236         char *fota_save_dir = (char *)calloc(_D_SIZE_128_, sizeof(char));
 237         if (fota_save_dir == NULL) {
 238                 _DEBUG_INFO("CALLOC failed !!!");
 239                 _EXTERN_FUNC_EXIT;
 240                 return 0;
 241         }
 242         /*snprintf(FOTA_Save_Dir, _D_SIZE_128_ - 1, FOTA_SAVE_DIR, strlen(FOTA_SAVE_DIR)); */
 243         snprintf(fota_save_dir, _D_SIZE_128_ - 1, "%s", FOTA_SAVE_DIR);
 244
 245         _DEBUG_INFO("FOTA save dir = %s\n", fota_save_dir);
 246         _EXTERN_FUNC_EXIT;
 247         return fota_save_dir;
 248 }
 249
 250 /* ====================================
 251  * device directory information
 252  *              fota sd card download directory
 253  *              fota sd card save directory
 254  * =====================================*/
 255
 256 char *slp_device_info_get_fota_sd_download_dir()
 257 {
 258         _EXTERN_FUNC_ENTER;
 259
 260         int ret = sync_agent_create_directory(FOTA_SD_DOWNLOAD_DIR);
 261         if (ret == 0) {
 262                 _DEBUG_INFO("existed foler or create foler error");
 263         }
 264
 265         char *fota_sd_download_dir = (char *)calloc(_D_SIZE_128_, sizeof(char));
 266         if (fota_sd_download_dir == NULL) {
 267                 _DEBUG_INFO("CALLOC failed !!!");
 268                 _EXTERN_FUNC_EXIT;
 269                 return 0;
 270         }
 271         /*snprintf(FOTA_SD_Download_Dir, _D_SIZE_128_ - 1, FOTA_SD_DOWNLOAD_DIR, strlen(FOTA_SD_DOWNLOAD_DIR)); */
 272         snprintf(fota_sd_download_dir, _D_SIZE_128_ - 1, "%s", FOTA_SD_DOWNLOAD_DIR);
 273
 274         _DEBUG_INFO("FOTA SD CARD Download dir = %s\n", fota_sd_download_dir);
 275         _EXTERN_FUNC_EXIT;
 276         return fota_sd_download_dir;
 277 }
 278
 279 char *slp_device_info_get_fota_sd_save_dir()
 280 {
 281         _EXTERN_FUNC_ENTER;
 282
 283         int ret = sync_agent_create_directory(FOTA_SD_SAVE_DIR);
 284         if (ret == 0) {
 285                 _DEBUG_INFO("existed foler or create foler error");
 286         }
 287
 288         char *fota_sd_save_dir = (char *)calloc(_D_SIZE_128_, sizeof(char));
 289         if (fota_sd_save_dir == NULL) {
 290                 _DEBUG_INFO("CALLOC failed !!!");
 291                 _EXTERN_FUNC_EXIT;
 292                 return 0;
 293         }
 294         /*snprintf(FOTA_SD_Save_Dir, _D_SIZE_128_ - 1, FOTA_SD_SAVE_DIR, strlen(FOTA_SD_SAVE_DIR)); */
 295         snprintf(fota_sd_save_dir, _D_SIZE_128_ - 1, "%s", FOTA_SD_SAVE_DIR);
 296
 297         _DEBUG_INFO("FOTA SD CARD save dir = %s\n", fota_sd_save_dir);
 298         _EXTERN_FUNC_EXIT;
 299         return fota_sd_save_dir;
 300 }
 301
 302 /* ====================================
 303  * device etc information
 304  * =====================================*/
 305
 306 char *slp_device_info_get_opco_info()
 307 {
 308         _EXTERN_FUNC_ENTER;
 309
 310         char *opcoInfo = (char *)calloc(_D_SIZE_128_, sizeof(char));
 311         if (opcoInfo == NULL) {
 312                 _DEBUG_INFO("CALLOC failed !!!");
 313                 _EXTERN_FUNC_EXIT;
 314                 return 0;
 315         }
 316         snprintf(opcoInfo, _D_SIZE_128_ - 1, "%s", OPCO);
 317         _DEBUG_INFO("Opco Info = %s\n", opcoInfo);
 318         _EXTERN_FUNC_EXIT;
 319         return opcoInfo;        /* prevent */
 320 }
 321
 322 char *slp_device_info_get_imsi_info()
 323 {
 324         _EXTERN_FUNC_ENTER;
 325
 326         _DEBUG_INFO("Start !!");
 327 /*
 328         TelSimImsiInfo_t sim_imsi_info;
 329         int err_code = -1;
 330
 331         char imsi_value[30] = { 0, };
 332
 333         TapiHandle *handle;
 334         handle = tel_init(NULL);
 335         if (handle == NULL) {
 336                 _DEBUG_INFO("handle is NULL !!");
 337                 _DEBUG_INFO("End !!");
 338                 _EXTERN_FUNC_EXIT;
 339                 return 0;
 340         } else {
 341                 _DEBUG_INFO("handle : %d", handle);
 342                 err_code = tel_get_sim_imsi(handle, &sim_imsi_info);
 343         }
 344
 345         if (err_code != TAPI_API_SUCCESS) {
 346                 _DEBUG_INFO("tel_get_sim_imsi() failed !!, err_code : 0x%02x", err_code);
 347                 _EXTERN_FUNC_EXIT;
 348                 return 0;
 349         } else {
 350                 _DEBUG_INFO("tel_get_sim_imsi() success !!");
 351
 352                 if (!strcmp(sim_imsi_info.szMcc, " ") && !strcmp(sim_imsi_info.szMnc, " ") && !strcmp(sim_imsi_info.szMsin, " ")) {
 353                         _DEBUG_INFO("mcc : %s", sim_imsi_info.szMcc);
 354                         _DEBUG_INFO("mnc : %s", sim_imsi_info.szMnc);
 355                         _DEBUG_INFO("msin : %s", sim_imsi_info.szMsin);
 356
 357                         snprintf(imsi_value, sizeof(imsi_value), "%s%s%s", sim_imsi_info.szMcc, sim_imsi_info.szMnc, sim_imsi_info.szMsin);
 358                         _DEBUG_INFO("IMSI : %s ( %d )", imsi_value, strlen(imsi_value));
 359
 360                         tel_deinit(handle);
 361
 362                         _DEBUG_INFO("End !!");
 363                         return strdup(imsi_value);
 364                 } else {
 365                         _DEBUG_INFO("invalid IMSI value !!");
 366                         tel_deinit(handle);
 367
 368                         _EXTERN_FUNC_EXIT;
 369                         return 0;
 370                 }
 371         }
 372 */
 373         return strdup("MccMncMsin");
 374         _EXTERN_FUNC_EXIT;
 375 }