src/s_network.c

   1 /**\r
   2  * tel-plugin-samsung\r
   3  *\r
   4  * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved\r
   5  *\r
   6  * Contact: Ja-young Gu <jygu@samsung.com>\r
   7  *\r
   8  * PROPRIETARY/CONFIDENTIAL\r
   9  *\r
  10  * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").\r
  11  * You shall not disclose such Confidential Information and shall\r
  12  * use it only in accordance with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.\r
  13  * SAMSUNG make no representations or warranties about the suitability\r
  14  * of the software, either express or implied, including but not\r
  15  * limited to the implied warranties of merchantability, fitness for a particular purpose, or non-infringement.\r
  16  * SAMSUNG shall not be liable for any damages suffered by licensee as\r
  17  * a result of using, modifying or distributing this software or its derivatives.\r
  18  */\r
  19 \r
  20 #include <stdio.h>\r
  21 #include <stdlib.h>\r
  22 #include <string.h>\r
  23 \r
  24 #include <glib.h>\r
  25 \r
  26 #include <tcore.h>\r
  27 #include <hal.h>\r
  28 #include <core_object.h>\r
  29 #include <plugin.h>\r
  30 #include <queue.h>\r
  31 #include <co_network.h>\r
  32 #include <co_ps.h>\r
  33 #include <server.h>\r
  34 #include <storage.h>\r
  35 #include <util.h>\r
  36 #include <at.h>\r
  37 \r
  38 #include "s_common.h"\r
  39 #include "s_network.h"\r
  40 \r
  41 #define AT_CREG_STAT_NOT_REG    0 /* not registered, MT is not currently searching a new operator to register to */\r
  42 #define AT_CREG_STAT_REG_HOME   1 /* registered, home network */\r
  43 #define AT_CREG_STAT_SEARCHING  2 /* not registered, but MT is currently searching a new operator to register to */\r
  44 #define AT_CREG_STAT_REG_DENIED 3 /* registration denied */\r
  45 #define AT_CREG_STAT_UNKNOWN    4 /* unknown */\r
  46 #define AT_CREG_STAT_REG_ROAM   5 /* registered, roaming */\r
  47 \r
  48 #define AT_COPS_MODE_AUTOMATIC  0 /* automatic (<oper> field is ignored) */\r
  49 #define AT_COPS_MODE_MANUAL     1 /* manual (<oper> field shall be present, and <AcT> optionally) */\r
  50 #define AT_COPS_MODE_DEREGISTER 2 /* deregister from network */\r
  51 #define AT_COPS_MODE_SET_ONLY   3 /* set only <format> */\r
  52 #define AT_COPS_MODE_MANUAL_AUTOMATIC 4 /*automatic - manual*/\r
  53 \r
  54 #define AT_COPS_FORMAT_LONG_ALPHANUMERIC        0 /* long format alphanumeric <oper> */\r
  55 #define AT_COPS_FORMAT_SHORT_ALPHANUMERIC       1 /* short format alphanumeric <oper> */\r
  56 #define AT_COPS_FORMAT_NUMERIC                  2 /* numeric <oper> */\r
  57 \r
  58 #define AT_COPS_ACT_GSM                 0       /* GSM */\r
  59 #define AT_COPS_ACT_GSM_COMPACT         1       /* GSM Compact */\r
  60 #define AT_COPS_ACT_UTRAN               2       /* UTRAN */\r
  61 #define AT_COPS_ACT_GSM_EGPRS           3       /* GSM w/EGPRS */\r
  62 #define AT_COPS_ACT_UTRAN_HSDPA         4       /* UTRAN w/HSDPA */\r
  63 #define AT_COPS_ACT_UTRAN_HSUPA         5       /* UTRAN w/HSUPA */\r
  64 #define AT_COPS_ACT_UTRAN_HSDPA_HSUPA   6       /* UTRAN w/HSDPA and HSUPA */\r
  65 #define AT_COPS_ACT_E_UTRAN             7       /* E-UTRAN */\r
  66 \r
  67 #define AT_GSM_XBANDSEL_AUTOMATIC 0 \r
  68 #define AT_GSM_XBANDSEL_1800 1800\r
  69 #define AT_GSM_XBANDSEL_1900 1900\r
  70 #define AT_GSM_XBANDSEL_900 900\r
  71 #define AT_GSM_XBANDSEL_850 850\r
  72 #define AT_GSM_XBANDSEL_450 450\r
  73 #define AT_GSM_XBANDSEL_480 480\r
  74 #define AT_GSM_XBANDSEL_750 750\r
  75 #define AT_GSM_XBANDSEL_380 380\r
  76 #define AT_GSM_XBANDSEL_410 410\r
  77 \r
  78 #define AT_XRAT_GSM 0\r
  79 #define AT_XRAT_DUAL 1\r
  80 #define AT_XRAT_UMTS 2\r
  81 \r
  82 #define MAX_NETWORKS_PREF_PLMN_SUPPORT 150\r
  83 #define MAX_NETWORKS_MANUAL_SEARCH_SUPPORT 20\r
  84 \r
  85 static unsigned int lookup_tbl_net_status[] = {\r
  86                 [AT_CREG_STAT_NOT_REG] = NETWORK_SERVICE_DOMAIN_STATUS_NO,\r
  87                 [AT_CREG_STAT_REG_HOME] = NETWORK_SERVICE_DOMAIN_STATUS_FULL,\r
  88                 [AT_CREG_STAT_SEARCHING] = NETWORK_SERVICE_DOMAIN_STATUS_SEARCH,\r
  89                 [AT_CREG_STAT_REG_DENIED] = NETWORK_SERVICE_DOMAIN_STATUS_EMERGENCY,\r
  90                 [AT_CREG_STAT_UNKNOWN] = NETWORK_SERVICE_DOMAIN_STATUS_NO,\r
  91                 [AT_CREG_STAT_REG_ROAM] = NETWORK_SERVICE_DOMAIN_STATUS_FULL,\r
  92 };\r
  93 \r
  94 static unsigned int lookup_tbl_access_technology[] = {\r
  95         [AT_COPS_ACT_GSM]               = NETWORK_ACT_GSM,\r
  96         [AT_COPS_ACT_GSM_COMPACT]       = NETWORK_ACT_GSM,\r
  97         [AT_COPS_ACT_UTRAN]             = NETWORK_ACT_UTRAN,\r
  98         [AT_COPS_ACT_GSM_EGPRS]         = NETWORK_ACT_EGPRS,\r
  99         [AT_COPS_ACT_UTRAN_HSDPA]       = NETWORK_ACT_UTRAN,\r
 100         [AT_COPS_ACT_UTRAN_HSUPA]       = NETWORK_ACT_UTRAN,\r
 101         [AT_COPS_ACT_UTRAN_HSDPA_HSUPA] = NETWORK_ACT_UTRAN,\r
 102         [AT_COPS_ACT_E_UTRAN]           = NETWORK_ACT_GSM_UTRAN,\r
 103 };\r
 104 \r
 105 static gboolean get_serving_network(CoreObject *o, UserRequest *ur);\r
 106 \r
 107 \r
 108 static void on_confirmation_network_message_send(TcorePending *p, gboolean result, void *user_data)\r
 109 {\r
 110         dbg("on_confirmation_modem_message_send - msg out from queue.\n");\r
 111 \r
 112         if (result == FALSE) {\r
 113                 /* Fail */\r
 114                 dbg("SEND FAIL");\r
 115         }\r
 116         else {\r
 117                 dbg("SEND OK");\r
 118         }\r
 119 }\r
 120 \r
 121 static void nwk_prepare_and_send_pending_request(TcorePlugin *plugin, char *co_name, const char *at_cmd, const char* prefix,enum tcore_at_command_type at_cmd_type, UserRequest *ur, TcorePendingResponseCallback callback)\r
 122 {\r
 123         TcoreATRequest *req = NULL;\r
 124         TcoreHal *hal;\r
 125         CoreObject *o= NULL;\r
 126         TcorePending *pending = NULL;\r
 127         TReturn ret;\r
 128         \r
 129         o = tcore_plugin_ref_core_object(plugin, co_name);\r
 130         hal = tcore_object_get_hal(o);\r
 131         \r
 132         pending = tcore_pending_new(o, 0);\r
 133         req = tcore_at_request_new(at_cmd, prefix, at_cmd_type);\r
 134 \r
 135         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
 136 \r
 137         tcore_pending_set_request_data(pending, 0, req);\r
 138         tcore_pending_set_response_callback(pending, callback, req->cmd);\r
 139         tcore_pending_link_user_request(pending, ur);\r
 140         tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);\r
 141 \r
 142         ret = tcore_hal_send_request(hal, pending);\r
 143         return;\r
 144 }\r
 145 \r
 146 \r
 147 static void _insert_mcc_mnc_oper_list(TcorePlugin *p, CoreObject *o)\r
 148 {\r
 149         Server *s;\r
 150         Storage *strg;\r
 151         void *handle;\r
 152         char query[255] = {     0, };\r
 153         GHashTableIter iter;\r
 154         gpointer key, value;\r
 155         GHashTable *result = NULL, *row = NULL;\r
 156         struct tcore_network_operator_info *noi = NULL;\r
 157         int count = 0;\r
 158 \r
 159         s = tcore_plugin_ref_server(p);\r
 160         strg = tcore_server_find_storage(s, "database");\r
 161 \r
 162         handle = tcore_storage_create_handle(strg, "/opt/dbspace/.mcc_mnc_oper_list.db");\r
 163         if (!handle) {\r
 164                 dbg("fail to create database handle");\r
 165                 return;\r
 166         }\r
 167 \r
 168         snprintf(query, 255, "select country, mcc, mnc, oper from mcc_mnc_oper_list");\r
 169 \r
 170         result = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,\r
 171                         (GDestroyNotify) g_hash_table_destroy);\r
 172 \r
 173         tcore_storage_read_query_database(strg, handle, query, NULL, result, 4);\r
 174 \r
 175         g_hash_table_iter_init(&iter, result);\r
 176         while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) {\r
 177                 row = value;\r
 178 \r
 179                 noi = calloc(sizeof(struct tcore_network_operator_info), 1);\r
 180 \r
 181                 snprintf(noi->mcc, 4, "%s", (char *)g_hash_table_lookup(row, "1"));\r
 182                 snprintf(noi->mnc, 4, "%s",  (char *)g_hash_table_lookup(row, "2"));\r
 183                 snprintf(noi->name, 41, "%s",  (char *)g_hash_table_lookup(row, "3"));\r
 184                 snprintf(noi->country, 4, "%s",  (char *)g_hash_table_lookup(row, "0"));\r
 185 \r
 186                 tcore_network_operator_info_add(o, noi);\r
 187 \r
 188                 count++;\r
 189         }\r
 190 \r
 191         dbg("count = %d", count);\r
 192 \r
 193         g_hash_table_destroy(result);\r
 194 \r
 195         tcore_storage_remove_handle(strg, handle);\r
 196 }\r
 197 \r
 198 static enum telephony_network_service_type _get_service_type(enum telephony_network_service_type prev_type,\r
 199                 int domain, int act, int cs_status, int ps_status)\r
 200 {\r
 201         enum telephony_network_service_type ret;\r
 202 \r
 203         ret = prev_type;\r
 204 \r
 205         switch (act) {\r
 206                 case NETWORK_ACT_UNKNOWN:\r
 207                         ret = NETWORK_SERVICE_TYPE_UNKNOWN;\r
 208                         break;\r
 209 \r
 210                 case NETWORK_ACT_GSM:\r
 211                         if (prev_type == NETWORK_SERVICE_TYPE_2_5G_EDGE && domain == NETWORK_SERVICE_DOMAIN_CS)\r
 212                                 ret = NETWORK_SERVICE_TYPE_2_5G_EDGE;\r
 213                         else\r
 214                                 ret = NETWORK_SERVICE_TYPE_2G;\r
 215                         break;\r
 216 \r
 217                 case NETWORK_ACT_EGPRS:\r
 218                         return NETWORK_SERVICE_TYPE_2_5G_EDGE;\r
 219                         break;\r
 220 \r
 221                 case NETWORK_ACT_UMTS:\r
 222                         ret = NETWORK_SERVICE_TYPE_3G;\r
 223                         break;\r
 224 \r
 225         }\r
 226 \r
 227         if (cs_status == NETWORK_SERVICE_DOMAIN_STATUS_NO && ps_status == NETWORK_SERVICE_DOMAIN_STATUS_NO) {\r
 228                 ret = NETWORK_SERVICE_TYPE_NO_SERVICE;\r
 229         }\r
 230         else if (cs_status == NETWORK_SERVICE_DOMAIN_STATUS_SEARCH || ps_status == NETWORK_SERVICE_DOMAIN_STATUS_SEARCH) \r
 231         {\r
 232                 if (cs_status == NETWORK_SERVICE_DOMAIN_STATUS_FULL || ps_status == NETWORK_SERVICE_DOMAIN_STATUS_FULL) \r
 233                 {\r
 234                         /* no change */\r
 235                 }\r
 236                 else \r
 237                 {\r
 238                         ret = NETWORK_SERVICE_TYPE_SEARCH;\r
 239                 }\r
 240         }\r
 241         else if (cs_status == NETWORK_SERVICE_DOMAIN_STATUS_EMERGENCY || ps_status == NETWORK_SERVICE_DOMAIN_STATUS_EMERGENCY) \r
 242         {\r
 243                 if (cs_status == NETWORK_SERVICE_DOMAIN_STATUS_FULL || ps_status == NETWORK_SERVICE_DOMAIN_STATUS_FULL) \r
 244                 {\r
 245                         /* no change */\r
 246                 }\r
 247                 else \r
 248                 {\r
 249                         ret = NETWORK_SERVICE_TYPE_EMERGENCY;\r
 250                 }\r
 251         }\r
 252 \r
 253         return ret;\r
 254 }\r
 255 \r
 256 static void _ps_set(TcorePlugin *p, int status)\r
 257 {\r
 258         GSList *co_list = NULL;\r
 259 \r
 260         co_list = tcore_plugin_get_core_objects_bytype(p, CORE_OBJECT_TYPE_PS);\r
 261         do {\r
 262                 CoreObject *o = NULL;\r
 263                 o = (CoreObject *) co_list->data;\r
 264                 if (!o)\r
 265                         break;\r
 266 \r
 267                 if (status == NETWORK_SERVICE_DOMAIN_STATUS_FULL) {\r
 268                         tcore_ps_set_online(o, TRUE);\r
 269                 }\r
 270                 else {\r
 271                         tcore_ps_set_online(o, FALSE);\r
 272                 }\r
 273         } while ((co_list = g_slist_next(co_list)));\r
 274 \r
 275         g_slist_free(co_list);\r
 276 }\r
 277 \r
 278 static void on_timeout_search_network(TcorePending *p, void *user_data)\r
 279 {\r
 280         UserRequest *ur;\r
 281         struct tresp_network_search resp;\r
 282 \r
 283         dbg("TIMEOUT !!!!! pending=%p", p);\r
 284 \r
 285         memset(&resp, 0, sizeof(struct tresp_network_search));\r
 286 \r
 287         resp.list_count = 0;\r
 288 \r
 289         ur = tcore_pending_ref_user_request(p);\r
 290         if (ur) {\r
 291                 tcore_user_request_send_response(ur, TRESP_NETWORK_SEARCH, sizeof(struct tresp_network_search), &resp);\r
 292         }\r
 293 }\r
 294 \r
 295 static void on_response_set_plmn_selection_mode(TcorePending *p, int data_len, const void *data, void *user_data)\r
 296 {\r
 297         UserRequest *ur;\r
 298         const TcoreATResponse *atResp = data;\r
 299        //GSList *tokens = NULL;\r
 300         //char * line = NULL;\r
 301         struct tresp_network_set_plmn_selection_mode resp = {0};\r
 302         \r
 303         if(atResp->success > 0)\r
 304         {\r
 305                 dbg("RESPONSE OK");\r
 306                 resp.result = TCORE_RETURN_SUCCESS;\r
 307         }\r
 308         else\r
 309         {\r
 310                 dbg("RESPONSE NOK");\r
 311                 resp.result = TCORE_RETURN_FAILURE;\r
 312         }\r
 313 \r
 314         ur = tcore_pending_ref_user_request(p);\r
 315         if (ur) {\r
 316                 tcore_user_request_send_response(ur, TRESP_NETWORK_SET_PLMN_SELECTION_MODE, sizeof(struct tresp_network_set_plmn_selection_mode), &resp);\r
 317         }\r
 318 }\r
 319 \r
 320 static void on_response_get_plmn_selection_mode(TcorePending *p, int data_len, const void *data, void *user_data)\r
 321 {\r
 322         UserRequest *ur;\r
 323         struct tresp_network_get_plmn_selection_mode resp = {0};\r
 324         const TcoreATResponse *atResp = data;\r
 325        GSList *tokens = NULL;\r
 326         char * line = NULL;\r
 327         int mode = 0;\r
 328 \r
 329         resp.result = TCORE_RETURN_FAILURE;\r
 330 \r
 331         if(atResp->success > 0)\r
 332         {\r
 333                 dbg("RESPONSE OK");\r
 334                 /* Format of output \r
 335                 +COPS: <mode>[,<format>,<oper>[,< AcT>]]\r
 336                 */\r
 337                 \r
 338                 if(atResp->lines)\r
 339                         {\r
 340                                 line = (char*)atResp->lines->data;\r
 341                                 tokens = tcore_at_tok_new(line);\r
 342                                 if (g_slist_length(tokens) < 1){\r
 343                                 msg("invalid message");\r
 344                                 goto OUT;\r
 345                                 }\r
 346                                 mode = atoi(tcore_at_tok_nth(tokens, 0));\r
 347                                 dbg("mode = %d", mode);\r
 348                         \r
 349                                 switch(mode) {\r
 350                                         case AT_COPS_MODE_AUTOMATIC:\r
 351                                                 resp.mode = NETWORK_SELECT_MODE_GLOBAL_AUTOMATIC;\r
 352                                                 break;\r
 353                                         case AT_COPS_MODE_MANUAL:\r
 354                                         case AT_COPS_MODE_MANUAL_AUTOMATIC:\r
 355                                                 resp.mode = NETWORK_SELECT_MODE_GSM_MANUAL;\r
 356                                                 break;\r
 357                                         case AT_COPS_MODE_DEREGISTER:\r
 358                                         case AT_COPS_MODE_SET_ONLY:\r
 359                                                 resp.result = TCORE_RETURN_FAILURE;\r
 360                                         goto OUT;\r
 361                                 }\r
 362                         resp.result = TCORE_RETURN_SUCCESS;\r
 363                         }\r
 364         }\r
 365         else\r
 366         {\r
 367                 dbg("RESPONSE NOK");\r
 368                 resp.result = TCORE_RETURN_FAILURE;\r
 369         }\r
 370 \r
 371 OUT:\r
 372         ur = tcore_pending_ref_user_request(p);\r
 373         if (ur) {\r
 374                 tcore_user_request_send_response(ur, TRESP_NETWORK_GET_PLMN_SELECTION_MODE, sizeof(struct tresp_network_get_plmn_selection_mode), &resp);\r
 375         }\r
 376 \r
 377         if(tokens != NULL)\r
 378                 tcore_at_tok_free(tokens);\r
 379 \r
 380         return;\r
 381 \r
 382 }\r
 383 \r
 384 static void on_response_search_network(TcorePending *p, int data_len, const void *data, void *user_data)\r
 385 {\r
 386         UserRequest *ur;\r
 387         struct tresp_network_search resp;\r
 388         int i = 0;\r
 389         char* line=NULL;\r
 390         const TcoreATResponse *atResp = data;\r
 391        GSList *tokens = NULL;\r
 392        GSList *network_token = NULL;\r
 393         int AcT=0;\r
 394         char* temp_plmn_info =NULL;\r
 395         char *pResp = NULL;\r
 396         int num_network_avail = 0;\r
 397 \r
 398         memset(&resp, 0, sizeof(struct tresp_network_search));\r
 399         resp.result = TCORE_RETURN_FAILURE;\r
 400         resp.list_count = 0;\r
 401 \r
 402         if(atResp->success > 0)\r
 403         {\r
 404                 dbg("RESPONSE OK");\r
 405                 if(atResp->lines) {\r
 406                         line = (char*)atResp->lines->data;\r
 407                         tokens = tcore_at_tok_new(line);\r
 408                         num_network_avail = g_slist_length(tokens);\r
 409                         dbg(" length of tokens is %d\n", num_network_avail);\r
 410                         if (num_network_avail < 1) {\r
 411                                 msg("invalid message");\r
 412                                 goto OUT;\r
 413                         }\r
 414                 }\r
 415                                         \r
 416                 resp.result = TCORE_RETURN_SUCCESS;\r
 417                 /*\r
 418                  *      +COPS: [list of supported (<stat>,long alphanumeric <oper>,short alphanumeric <oper>,numeric <oper>[,<AcT>])s]\r
 419                  *             [,,(list of supported <mode>s),(list of supported <format>s)]\r
 420                 */\r
 421                         \r
 422                 /* (2,"IND airtel","airtel","40445",2,),(1,"IND airtel","airtel","40445",0,),(3,"TATA DOCOMO","TATA DO","405034",2,) */\r
 423                         \r
 424                 for(i=0; ((i<num_network_avail) && (i<MAX_NETWORKS_MANUAL_SEARCH_SUPPORT)); i++)\r
 425                         {\r
 426                         /* (2,"IND airtel","airtel","40445",2,) */\r
 427                         network_token = tcore_at_tok_new(g_slist_nth_data(tokens, i));\r
 428 \r
 429                         pResp = (tcore_at_tok_nth(network_token, 0));\r
 430                         if(pResp != NULL){\r
 431                                 dbg("status : %s",pResp);\r
 432                                 resp.list[i].status = (enum telephony_network_plmn_status)atoi(pResp);\r
 433                         }\r
 434 \r
 435                         if ((pResp = tcore_at_tok_nth(network_token, 1)))\r
 436                         { /* Long Aplha name */\r
 437                                 dbg("Long Aplha name : %s",pResp);\r
 438                                 \r
 439                                 if(strlen(pResp) > 0)\r
 440                                         /* Strip off starting quote & ending quote */\r
 441                                         strncpy(resp.list[i].name, pResp+1, strlen(pResp)-2);\r
 442                         }\r
 443                         else if ((pResp = tcore_at_tok_nth(network_token, 2)))\r
 444                         { \r
 445                                 dbg("Short Aplha name : %s",pResp);\r
 446                                 /* Short Aplha name */\r
 447                                 /* Strip off starting quote & ending quote */\r
 448                                 if(strlen(pResp) > 0)\r
 449                                         strncpy(resp.list[i].name, pResp+1, strlen(pResp)-2);\r
 450                         }\r
 451 \r
 452                         /* PLMN ID */\r
 453                         pResp = tcore_at_tok_nth(network_token, 3);\r
 454                         if(pResp != NULL)\r
 455                         {\r
 456                                 dbg("PLMN ID : %s",pResp);\r
 457                                 if(strlen(pResp) > 0){\r
 458                                         temp_plmn_info = malloc((strlen(pResp) - 2)+1); /* 1 extra character for NULL storage */\r
 459                                         memset(temp_plmn_info, 0x00, strlen(pResp) -2+1);\r
 460                                         \r
 461                                         /* Strip off starting quotes & ending quotes */\r
 462                                         strncpy(temp_plmn_info, pResp+1, strlen(pResp)-2);\r
 463                                 }\r
 464                         }\r
 465 \r
 466                         memcpy(resp.list[i].plmn, temp_plmn_info, 6);\r
 467                         if (resp.list[i].plmn[5] == '#')\r
 468                                 resp.list[i].plmn[5] = '\0';\r
 469 \r
 470                         /* Parse Access Technology */\r
 471                         if((pResp = tcore_at_tok_nth(tokens, 4)))\r
 472                         {\r
 473                                 if(strlen(pResp) > 0){\r
 474                                         AcT = atoi(pResp);\r
 475                                 \r
 476                                         if (0 == AcT)\r
 477                                                 resp.list[i].act = NETWORK_ACT_GSM;\r
 478                                         else if(2 == AcT)\r
 479                                                 resp.list[i].act = NETWORK_ACT_UMTS;\r
 480                                 }\r
 481                         }\r
 482 \r
 483                         dbg("Operator [%d] :: stat = %d, Name =%s, plmnId = %s, AcT=%d\n", resp.list_count, resp.list[i].status, resp.list[i].name, resp.list[i].plmn, resp.list[i].act);\r
 484                         resp.list_count++;\r
 485 \r
 486                         tcore_at_tok_free(network_token);\r
 487                         free(temp_plmn_info);\r
 488                 }\r
 489         }\r
 490         else\r
 491         {\r
 492                         dbg("RESPONSE NOK");\r
 493                         resp.result = TCORE_RETURN_FAILURE;\r
 494         }\r
 495 \r
 496 OUT:\r
 497         ur = tcore_pending_ref_user_request(p);\r
 498         if (ur) {\r
 499                 tcore_user_request_send_response(ur, TRESP_NETWORK_SEARCH, sizeof(struct tresp_network_search), &resp);\r
 500         }\r
 501         tcore_at_tok_free(tokens);\r
 502         return;\r
 503 }\r
 504 \r
 505 static void on_response_set_umts_band(TcorePending *p, int data_len, const void *data, void *user_data)\r
 506 {\r
 507         const TcoreATResponse *atResp = data;\r
 508 \r
 509         dbg("On Response Set UMTS Band");\r
 510         \r
 511         if(atResp->success > 0) {\r
 512                 dbg("Response OK");\r
 513         }\r
 514         else {\r
 515                 dbg("Response NOK");\r
 516         }\r
 517 \r
 518         dbg("Wait for response of XRAT before sending final band setting response to AP");\r
 519         return;\r
 520 }\r
 521 \r
 522 \r
 523 static void on_response_set_gsm_band(TcorePending *p, int data_len, const void *data, void *user_data)\r
 524 {\r
 525         const TcoreATResponse *atResp = data;\r
 526 \r
 527         dbg("On Response Set GSM Band");\r
 528         if(atResp->success > 0){\r
 529                 dbg("Response OK");\r
 530         }\r
 531         else{\r
 532                 dbg("Response NOK");\r
 533         }\r
 534 \r
 535         dbg("Wait for response of XRAT before sending final band setting response to AP");\r
 536         return;\r
 537 }\r
 538 \r
 539 static void on_response_get_umts_band(TcorePending *p, int data_len, const void *data, void *user_data)\r
 540 {\r
 541         const TcoreATResponse *atResp = data;\r
 542         GSList *tokens = NULL;\r
 543         const char *line=NULL;\r
 544         int total_umts_bands = 0;\r
 545         int i = 0;\r
 546         char *band_token = NULL;\r
 547         char umts_band[20] = {0};\r
 548         char umts_band_1 = 0;\r
 549         char umts_band_2 = 0;\r
 550         char umts_band_5 = 0;\r
 551         UserRequest *ur = NULL;\r
 552         struct tresp_network_get_band resp = {0};\r
 553         \r
 554         dbg("Entry on_response_get_umts_band");\r
 555 \r
 556         resp.mode = NETWORK_BAND_MODE_PREFERRED;\r
 557         resp.result = TCORE_RETURN_SUCCESS;\r
 558 \r
 559         if(atResp->success > 0)\r
 560         {\r
 561                 dbg("RESPONSE OK");\r
 562                 if(atResp->lines) {\r
 563                         line = (char*)atResp->lines->data;\r
 564                         tokens = tcore_at_tok_new(line);\r
 565                         total_umts_bands = g_slist_length(tokens);\r
 566                         dbg("Total UMTS bands enabled are : %d\n", total_umts_bands);\r
 567                         if (total_umts_bands < 1) {\r
 568                                 goto OUT;\r
 569                         }\r
 570                 }\r
 571         }\r
 572         else\r
 573         {\r
 574                 dbg("RESPONSE NOK");\r
 575                 goto OUT;\r
 576         }\r
 577 \r
 578         for (i = 0; i<total_umts_bands; i++)\r
 579         {\r
 580                 band_token = tcore_at_tok_nth(tokens, i);\r
 581 \r
 582                 if(band_token == NULL)\r
 583                         continue;\r
 584                 \r
 585                 memset(umts_band, 0x00, sizeof(umts_band));\r
 586 \r
 587                 if(atoi(band_token) == 0){ /* 0 means UMTS automatic */\r
 588                         umts_band_1 = umts_band_2 = umts_band_5 = TRUE;\r
 589                         break;\r
 590                 }\r
 591                 \r
 592                 /* Strip off starting quotes & ending quotes */\r
 593                 strncpy(umts_band, band_token+1, strlen(band_token)-2);\r
 594 \r
 595                 if (!strcmp(umts_band, "UMTS_BAND_I")) {\r
 596                         umts_band_1 = TRUE;\r
 597                 }\r
 598                 else if (!strcmp(umts_band, "UMTS_BAND_II")){\r
 599                         umts_band_2 = TRUE;\r
 600                 }\r
 601                 else if (!strcmp(umts_band, "UMTS_BAND_II")){\r
 602                         umts_band_5 = TRUE;\r
 603                 }\r
 604                 else{\r
 605                          /* Telephony is not interest */\r
 606                          dbg("Telephony is not interested in %s band", umts_band);\r
 607                 }\r
 608         }\r
 609 \r
 610 OUT:\r
 611         if((umts_band_1) && (umts_band_2) && (umts_band_5)){\r
 612                 resp.band = NETWORK_BAND_TYPE_WCDMA;\r
 613         }\r
 614         else if (umts_band_1){\r
 615                 resp.band = NETWORK_BAND_TYPE_WCDMA2100;\r
 616         }\r
 617         else if (umts_band_2){\r
 618                 resp.band = NETWORK_BAND_TYPE_WCDMA1900;\r
 619         }\r
 620         else if (umts_band_5){\r
 621                 resp.band = NETWORK_BAND_TYPE_WCDMA850;\r
 622         }\r
 623         else{\r
 624                 resp.result = TCORE_RETURN_FAILURE;\r
 625         }\r
 626         \r
 627         dbg("Final resp.band sent to TS = %d", resp.band);\r
 628 \r
 629         ur = tcore_pending_ref_user_request(p);\r
 630         if (ur) {\r
 631                 tcore_user_request_send_response(ur, TRESP_NETWORK_GET_BAND, sizeof(struct tresp_network_get_band), &resp);\r
 632         }\r
 633         \r
 634         if(tokens != NULL)\r
 635                 tcore_at_tok_free(tokens);\r
 636         \r
 637         dbg("Exit on_response_get_umts_band");\r
 638         return;\r
 639 }\r
 640 \r
 641 static void on_response_get_gsm_band(TcorePending *p, int data_len, const void *data, void *user_data)\r
 642 {\r
 643         struct tresp_network_get_band resp = {0};\r
 644         const TcoreATResponse *atResp = data;\r
 645        GSList *tokens = NULL;\r
 646         int total_gsm_bands = 0;\r
 647         const char *line=NULL;\r
 648         int i = 0;\r
 649         char *band_token = NULL;\r
 650         UserRequest *ur = NULL;\r
 651         int gsm_850 = 0;\r
 652         int gsm_900 = 0;\r
 653         int gsm_1800 = 0;\r
 654         int gsm_1900 = 0;\r
 655         \r
 656         dbg("Entry on_response_get_gsm_band");\r
 657         \r
 658         resp.mode = NETWORK_BAND_MODE_PREFERRED;\r
 659         resp.result = TCORE_RETURN_SUCCESS;\r
 660                 \r
 661         if(atResp->success > 0)\r
 662         {\r
 663                 dbg("RESPONSE OK");\r
 664                 if(atResp->lines) {\r
 665                         line = (char*)atResp->lines->data;\r
 666                         tokens = tcore_at_tok_new(line);\r
 667                         total_gsm_bands = g_slist_length(tokens);\r
 668                         dbg("Total GSM bands enabled are : %d\n", total_gsm_bands);\r
 669                         if (total_gsm_bands < 1)\r
 670                                 goto OUT;\r
 671                 }\r
 672         }\r
 673 \r
 674         for (i = 0; i<total_gsm_bands; i++)\r
 675         {\r
 676                 band_token = tcore_at_tok_nth(tokens, i);\r
 677 \r
 678                 if(band_token == NULL)\r
 679                         continue;\r
 680 \r
 681                 if(atoi(band_token) == 0){ /* 0 means GSM automatic */\r
 682                         gsm_850 = gsm_900 = gsm_1800 = gsm_1900 = TRUE;\r
 683                         break;\r
 684                 }\r
 685                 \r
 686                 switch(atoi(band_token)) {\r
 687                         case AT_GSM_XBANDSEL_850:\r
 688                                 gsm_850 = TRUE;\r
 689                                 break;\r
 690 \r
 691                         case AT_GSM_XBANDSEL_900:\r
 692                                 gsm_900 = TRUE;\r
 693                                 break;\r
 694 \r
 695                         case AT_GSM_XBANDSEL_1800:\r
 696                                 gsm_1800 = TRUE;\r
 697                                 break;\r
 698                                 \r
 699                         case AT_GSM_XBANDSEL_1900:\r
 700                                 gsm_1900 = TRUE;\r
 701                                 break;\r
 702                                                 \r
 703                         default:\r
 704                                 break;\r
 705                 }\r
 706         }\r
 707         \r
 708 OUT:\r
 709 \r
 710         if(gsm_850 && gsm_900 && gsm_1800 && gsm_1900) {\r
 711                 resp.band = NETWORK_BAND_TYPE_GSM;\r
 712         }\r
 713         else if (gsm_850 && gsm_1900) {\r
 714                 resp.band = NETWORK_BAND_TYPE_GSM_850_1900;\r
 715         }\r
 716         else if (gsm_900 && gsm_1800) {\r
 717                 resp.band = NETWORK_BAND_TYPE_GSM_900_1800;\r
 718         }\r
 719         else if (gsm_1900) {\r
 720                 resp.band = NETWORK_BAND_TYPE_GSM1900;\r
 721         }\r
 722         else if (gsm_850) {\r
 723                 resp.band = NETWORK_BAND_TYPE_GSM850;\r
 724         }\r
 725         else if (gsm_1800) {\r
 726                 resp.band = NETWORK_BAND_TYPE_GSM1800;\r
 727         }\r
 728         else if (gsm_900) {\r
 729                 resp.band = NETWORK_BAND_TYPE_GSM900;\r
 730         }\r
 731         else{\r
 732                 resp.result = TCORE_RETURN_FAILURE;\r
 733         }\r
 734 \r
 735         dbg("Final resp.band sent to TS = %d", resp.band);\r
 736 \r
 737         ur = tcore_pending_ref_user_request(p);\r
 738         if (ur) {\r
 739                 tcore_user_request_send_response(ur, TRESP_NETWORK_GET_BAND, sizeof(struct tresp_network_get_band), &resp);\r
 740         }\r
 741 \r
 742         if(tokens != NULL)\r
 743                 tcore_at_tok_free(tokens);\r
 744         \r
 745         dbg("Exit on_response_get_gsm_band");\r
 746         return;\r
 747 }\r
 748 \r
 749 \r
 750 static void on_response_get_xrat(TcorePending *p, int data_len, const void *data, void *user_data)\r
 751 {\r
 752         TcoreHal *h = NULL;\r
 753         UserRequest *ur = NULL;\r
 754 \r
 755         TcoreATRequest *atreq;\r
 756         char*cmd_str = NULL;\r
 757         UserRequest *dup_ur = NULL;\r
 758         const TcoreATResponse *atResp = data;\r
 759         const char *line=NULL;\r
 760         char *pResp = NULL;\r
 761         GSList *tokens = NULL;\r
 762         TcorePending *pending = NULL;\r
 763         CoreObject *o = NULL;\r
 764         int cp_xrat = 0;\r
 765         struct tresp_network_get_band resp = {0};\r
 766 \r
 767         dbg("Enter on_response_get_xrat !!");\r
 768 \r
 769         resp.mode = NETWORK_BAND_MODE_PREFERRED;\r
 770 \r
 771         ur = tcore_pending_ref_user_request(p);\r
 772         h = tcore_object_get_hal(tcore_pending_ref_core_object(p));\r
 773         o = tcore_pending_ref_core_object(p);\r
 774 \r
 775         if(atResp->success > 0)\r
 776         {\r
 777                 dbg("RESPONSE OK");\r
 778                 if(atResp->lines) {\r
 779                         line = (char*)atResp->lines->data;\r
 780                         tokens = tcore_at_tok_new(line);\r
 781                         if ( g_slist_length(tokens) < 1){\r
 782                                 msg("invalid message");\r
 783                                 goto OUT;\r
 784                         }\r
 785                 }\r
 786 \r
 787                 if((pResp = tcore_at_tok_nth(tokens, 0))){\r
 788                         cp_xrat = atoi(pResp);\r
 789 \r
 790                         if((cp_xrat == AT_XRAT_DUAL)){ /* mode is Dual, send reply to Telephony */\r
 791                                 resp.result = TCORE_RETURN_SUCCESS;\r
 792                                 resp.band = NETWORK_BAND_TYPE_ANY;\r
 793                                 \r
 794                                 ur = tcore_pending_ref_user_request(p);\r
 795                                 if (ur) {\r
 796                                         tcore_user_request_send_response(ur, TRESP_NETWORK_GET_BAND, sizeof(struct tresp_network_get_band), &resp);\r
 797                                 }\r
 798                                 goto OUT;\r
 799                         }\r
 800                         else if((cp_xrat == AT_XRAT_UMTS)){\r
 801                                 /* Get UMTS Band Information */\r
 802                                 dup_ur = tcore_user_request_ref(ur); /* duplicate user request for AT+XUBANDSEL */\r
 803                                 cmd_str = g_strdup_printf("AT+XUBANDSEL?");\r
 804                                 atreq = tcore_at_request_new(cmd_str, "+XUBANDSEL", TCORE_AT_SINGLELINE);\r
 805                                 pending = tcore_pending_new(o, 0);\r
 806                                 tcore_pending_set_request_data(pending, 0, atreq);\r
 807                                 tcore_pending_set_response_callback(pending, on_response_get_umts_band, NULL);\r
 808                                 tcore_pending_link_user_request(pending, ur);\r
 809                                 tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);\r
 810                                 tcore_hal_send_request(h, pending);\r
 811                         }\r
 812                         else if((cp_xrat == AT_XRAT_UMTS)){\r
 813                                 /* Get GSM Band Information */\r
 814                                 dup_ur = tcore_user_request_ref(ur); /* duplicate user request for AT+XBANDSEL */\r
 815                                 cmd_str = g_strdup_printf("AT+XBANDSEL?");\r
 816                                 atreq = tcore_at_request_new(cmd_str, "+XBANDSEL", TCORE_AT_SINGLELINE);\r
 817                                 pending = tcore_pending_new(o, 0);\r
 818                                 tcore_pending_set_request_data(pending, 0, atreq);\r
 819                                 tcore_pending_set_response_callback(pending, on_response_get_gsm_band, NULL);\r
 820                                 tcore_pending_link_user_request(pending, dup_ur);\r
 821                                 tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);\r
 822                                 tcore_hal_send_request(h, pending);\r
 823                         }\r
 824                 }\r
 825         }\r
 826         else {\r
 827                 dbg("RESPONSE NOK");\r
 828                 \r
 829                 resp.result = TCORE_RETURN_FAILURE;\r
 830                 resp.band = NETWORK_BAND_TYPE_ANY;\r
 831                 \r
 832                 ur = tcore_pending_ref_user_request(p);\r
 833                 if (ur) {\r
 834                         tcore_user_request_send_response(ur, TRESP_NETWORK_GET_BAND, sizeof(struct tresp_network_get_band), &resp);\r
 835                 }\r
 836         }\r
 837 OUT:\r
 838         \r
 839         if(tokens != NULL)\r
 840                 tcore_at_tok_free(tokens);\r
 841         \r
 842         dbg("Exit on_response_get_xrat !!");\r
 843         \r
 844         return;\r
 845 }\r
 846 \r
 847 \r
 848 static void on_response_set_xrat(TcorePending *p, int data_len, const void *data, void *user_data)\r
 849 {\r
 850         UserRequest *ur = NULL;\r
 851         struct tresp_network_set_band resp = {0};\r
 852         const TcoreATResponse *atResp = data;\r
 853 \r
 854         dbg("On Response Set XRAT");\r
 855         \r
 856         if(atResp->success > 0){\r
 857                 dbg("Response OK");\r
 858                 resp.result = TCORE_RETURN_SUCCESS;\r
 859         }else{\r
 860                 dbg("Response NOK");\r
 861                 resp.result = TCORE_RETURN_FAILURE;\r
 862         }\r
 863 \r
 864         ur = tcore_pending_ref_user_request(p);\r
 865         if (ur) {\r
 866                 tcore_user_request_send_response(ur, TRESP_NETWORK_SET_BAND, sizeof(struct tresp_network_set_band), &resp);\r
 867         }\r
 868 \r
 869         return;\r
 870 }\r
 871 \r
 872 static void on_response_set_preferred_plmn(TcorePending *p, int data_len, const void *data, void *user_data)\r
 873 {\r
 874         UserRequest *ur = NULL;\r
 875         struct tresp_network_set_preferred_plmn resp = {0};\r
 876         const TcoreATResponse *atResp = data;\r
 877 \r
 878         dbg("ENTER on_response_set_preferred_plmn");\r
 879 \r
 880         if(atResp->success > 0)\r
 881         {\r
 882                 dbg("Response OK");\r
 883                 resp.result = TCORE_RETURN_SUCCESS;\r
 884         }else\r
 885         {\r
 886                 dbg("Response NOK");\r
 887                 resp.result = TCORE_RETURN_FAILURE;\r
 888         }\r
 889         \r
 890         ur = tcore_pending_ref_user_request(p);\r
 891         if (ur) {\r
 892                 tcore_user_request_send_response(ur, TRESP_NETWORK_SET_PREFERRED_PLMN, sizeof(struct tresp_network_set_preferred_plmn), &resp);\r
 893         }\r
 894 \r
 895         dbg("Exit on_response_set_preferred_plmn");\r
 896         return;\r
 897 }\r
 898 \r
 899 static void on_response_get_nitz_name(TcorePending *p, int data_len, const void *data, void *user_data)\r
 900 {\r
 901 \r
 902         \r
 903         const TcoreATResponse *atResp = data;\r
 904         GSList *tokens = NULL;\r
 905         const char *line=NULL;\r
 906         CoreObject *o = NULL;\r
 907         struct tnoti_network_identity noti;\r
 908         int nol = 0;\r
 909         int count = 0;\r
 910         int net_name_type = 0;\r
 911         char *pResp = NULL;\r
 912         \r
 913         dbg("Entry on_response_get_nitz_name (+XCOPS)");\r
 914         o  = tcore_pending_ref_core_object(p);\r
 915         if(atResp->success > 0)\r
 916         {\r
 917                 dbg("RESPONSE OK");\r
 918 \r
 919                 if(atResp->lines) {\r
 920                         nol = g_slist_length(atResp->lines);\r
 921                         if(nol > 3){\r
 922                                 msg("invalid message");\r
 923                                 goto OUT;\r
 924                         }\r
 925 \r
 926                         for(count =0; count < nol; count++){\r
 927                                 //parse each line \r
 928                                 line = g_slist_nth_data(atResp->lines, count);\r
 929                                 tokens = tcore_at_tok_new(line);\r
 930                                 dbg("line %d start---------------",count);\r
 931 \r
 932                                 if ((pResp = tcore_at_tok_nth(tokens, 0))){\r
 933                                         net_name_type = atoi(pResp);\r
 934                                         dbg("Net name type  : %d", net_name_type);\r
 935                                         \r
 936                                         switch(net_name_type)\r
 937                                         {\r
 938                                                 case 0: /* plmn_id (mcc, mnc) */\r
 939                                                         if ((pResp = tcore_at_tok_nth(tokens, 1))){\r
 940                                                                 strncpy(noti.plmn, pResp+1, strlen(pResp)-2); /* skip quotes (") while copying */\r
 941                                                         }\r
 942                                                         break;\r
 943 \r
 944                                                  case 5: /* Short Nitz name*/\r
 945                                                         if ((pResp = tcore_at_tok_nth(tokens, 1))){\r
 946                                                                 strncpy(noti.short_name, pResp+1, strlen(pResp)-2); /* skip quotes (") while copying */\r
 947                                                         }\r
 948                                                         break;\r
 949 \r
 950                                                 case 6: /* Full Nitz name */\r
 951                                                         if ((pResp = tcore_at_tok_nth(tokens, 1))){\r
 952                                                                 strncpy(noti.full_name, pResp+1, strlen(pResp)-2); /* skip quotes (") while copying */\r
 953                                                         }\r
 954                                                         break;\r
 955 \r
 956                                                 default:\r
 957                                                         break;\r
 958                                         }\r
 959                                 }\r
 960                                 if(tokens != NULL)\r
 961                                         tcore_at_tok_free(tokens);\r
 962                         }\r
 963                         \r
 964                         tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), o, TNOTI_NETWORK_IDENTITY,\r
 965                                 sizeof(struct tnoti_network_identity), &noti);\r
 966                 }\r
 967         }\r
 968         else{\r
 969                 dbg("RESPONSE NOK");\r
 970         }\r
 971 \r
 972 OUT:\r
 973         dbg("Exit on_response_get_nitz_name");\r
 974 \r
 975 }\r
 976 \r
 977 static void on_response_get_preferred_plmn(TcorePending *p, int data_len, const void *data, void *user_data)\r
 978 {\r
 979         UserRequest *ur;\r
 980         int i = 0;\r
 981         char* line=NULL;\r
 982         const TcoreATResponse *atResp = data;\r
 983        GSList *tokens = NULL;\r
 984         char temp_plmn_info[17] = {0};\r
 985         char *pResp = NULL;\r
 986         int plmn_format = 0;\r
 987         \r
 988         struct tresp_network_get_preferred_plmn resp = {0};\r
 989         int total_lines = 0;\r
 990         int GSM_AcT2 = 0, GSM_Compact_AcT2= 0, UTRAN_AcT2 = 0;\r
 991 \r
 992         dbg("Entry on_response_get_preferred_plmn");\r
 993 \r
 994         if(atResp->success > 0)\r
 995         {\r
 996                 dbg("RESPONSE OK");\r
 997                 if(atResp->lines) {\r
 998                         total_lines = g_slist_length(atResp->lines);\r
 999                         dbg("Total number of network present in Preferred PLMN list is %d\n", total_lines);\r
1000 \r
1001                         if (total_lines < 1) {\r
1002                                 msg("invalid message");\r
1003                                 goto OUT;\r
1004                         }\r
1005 \r
1006                         if (total_lines >= MAX_NETWORKS_PREF_PLMN_SUPPORT)\r
1007                                 total_lines = MAX_NETWORKS_PREF_PLMN_SUPPORT;\r
1008                         \r
1009 /*\r
1010 +COPL: <index1>,<format>,<oper1>[,<GSM_AcT1>,<GSM_Compact_AcT1>,<UTRAN_AcT1>,<E-UTRAN_AcT1>] [<CR><LF>\r
1011 +CPOL: <index2>,<format>,<oper2>[,<GSM_AcT2>,<GSM_Compact_AcT2>,<UTRAN_AcT2>,<E-UTRAN_AcT2>]\r
1012 */\r
1013 \r
1014                         resp.result = TCORE_RETURN_SUCCESS;\r
1015 \r
1016                         for (i=0; i<total_lines; i++) {\r
1017                                 /* Take each line response at a time & parse it */\r
1018                                 line = tcore_at_tok_nth(atResp->lines, i);\r
1019                                 tokens = tcore_at_tok_new(line);\r
1020 \r
1021                                 /* <index2>,<format>,<oper2>[,<GSM_AcT2>,<GSM_Compact_AcT2>,<UTRAN_AcT2>,<E-UTRAN_AcT2>] */\r
1022 \r
1023                                 /* EF Index */\r
1024                                 if ((pResp = tcore_at_tok_nth(tokens, 0)))\r
1025                                 {\r
1026                                         dbg("Index : %s",pResp);                                        \r
1027                                         resp.list[i].ef_index = atoi(pResp);\r
1028                                 }\r
1029                                 /* Format */\r
1030                                 if((pResp = tcore_at_tok_nth(tokens, 1)))\r
1031                                 {\r
1032                                         dbg("format : %s",pResp);\r
1033                                         plmn_format = atoi(pResp);\r
1034                                 }\r
1035 \r
1036                                 /* Operator PLMN ID */\r
1037                                 if((pResp = tcore_at_tok_nth(tokens, 2)))\r
1038                                 {\r
1039                                         dbg("plmn ID : %s",pResp);\r
1040 \r
1041                                         if(strlen(pResp) > 0){\r
1042                                                 strncpy(temp_plmn_info, pResp+1, (strlen(pResp))-2);\r
1043                                         \r
1044                                                 //Get only PLMN ID\r
1045                                                 if (plmn_format == 2)\r
1046                                                 {\r
1047                                                         //cp_plmn = util_hexStringToBytes(temp_plmn_info);\r
1048                                                 \r
1049                                                         if (strncmp((char *)temp_plmn_info, "000000", 6) == 0)\r
1050                                                                 continue;\r
1051                                 \r
1052                                                         memcpy(resp.list[i].plmn, temp_plmn_info, 6);\r
1053                                                         if (resp.list[i].plmn[5] == '#')\r
1054                                                                 resp.list[i].plmn[5] = '\0';\r
1055 \r
1056                                                         //free(cp_plmn);\r
1057                                                 }\r
1058                                         }\r
1059                                 }\r
1060 \r
1061                                 if((pResp = tcore_at_tok_nth(tokens, 3))){\r
1062                                         dbg("GSM_AcT2  : %s",pResp);\r
1063                                         GSM_AcT2 = atoi(pResp);\r
1064                                 }\r
1065                                         \r
1066                                 if((pResp = tcore_at_tok_nth(tokens, 4))){\r
1067                                         dbg("GSM_Compact AcT2  : %s",pResp);\r
1068                                         GSM_Compact_AcT2 = atoi(pResp);\r
1069                                 }\r
1070         \r
1071                                 if((pResp = tcore_at_tok_nth(tokens, 5))){\r
1072                                         dbg("UTRAN_AcT2  : %s",pResp);\r
1073                                         UTRAN_AcT2 = atoi(pResp);\r
1074                                 }\r
1075 \r
1076                                 if(UTRAN_AcT2 && (GSM_AcT2 ||GSM_Compact_AcT2))\r
1077                                         resp.list[i].act = NETWORK_ACT_GSM_UTRAN;\r
1078                                 else if (UTRAN_AcT2)\r
1079                                         resp.list[i].act = NETWORK_ACT_UMTS;\r
1080                                 else if (GSM_AcT2 || GSM_Compact_AcT2)\r
1081                                         resp.list[i].act = NETWORK_ACT_GPRS;\r
1082 \r
1083                                 (resp.list_count)++;\r
1084 \r
1085                                 tcore_at_tok_free(tokens);\r
1086                         }\r
1087                 }\r
1088         }\r
1089 OUT:\r
1090         ur = tcore_pending_ref_user_request(p);\r
1091         if (ur) {\r
1092                 tcore_user_request_send_response(ur, TRESP_NETWORK_GET_PREFERRED_PLMN, sizeof(struct tresp_network_get_preferred_plmn), &resp);\r
1093         }\r
1094         dbg("Exit");\r
1095         return;\r
1096 }\r
1097 \r
1098 static void on_response_get_serving_network(TcorePending *p, int data_len, const void *data, void *user_data)\r
1099 {\r
1100         const TcoreATResponse* resp = data;\r
1101         UserRequest *ur;\r
1102         struct tresp_network_get_serving_network Tresp = {0};\r
1103         char plmn[7] = {0};\r
1104         char *long_plmn_name = NULL;\r
1105         char *short_plmn_name = NULL;\r
1106         CoreObject *o;\r
1107         GSList *tokens=NULL;\r
1108         const char *line;\r
1109         int network_mode = -1;\r
1110         int plmn_format = -1;\r
1111         int AcT = -1;\r
1112         struct tnoti_network_identity noti; \r
1113         char *pResp = NULL;\r
1114         int nol, count =0;\r
1115 \r
1116         o = tcore_pending_ref_core_object(p);\r
1117 \r
1118         if(resp->success <= 0){\r
1119                 dbg("RESPONSE NOK");\r
1120 \r
1121                 ur = tcore_pending_ref_user_request(p);\r
1122                 if (ur) {\r
1123                         Tresp.result = TCORE_RETURN_FAILURE;            \r
1124                         tcore_user_request_send_response(ur, TRESP_NETWORK_GET_SERVING_NETWORK, sizeof(struct tresp_network_get_serving_network), &Tresp);\r
1125                 }\r
1126 \r
1127                 return;\r
1128         }else{\r
1129         dbg("RESPONSE OK");\r
1130                 nol = g_slist_length(resp->lines);\r
1131                 dbg("nol : %d", nol);\r
1132 \r
1133                 for(count =0; count < nol; count++){\r
1134                         //parse each line \r
1135                                 line = g_slist_nth_data(resp->lines, count);\r
1136                 tokens = tcore_at_tok_new(line);\r
1137                         dbg("line %d start---------------",count);\r
1138                         //mode\r
1139                 if((pResp = tcore_at_tok_nth(tokens, 0))){\r
1140                         dbg("mode  : %s",pResp);\r
1141                         network_mode = atoi(pResp);\r
1142                 }\r
1143 \r
1144                         //format (optional)                     \r
1145                 if((pResp = tcore_at_tok_nth(tokens, 1)))\r
1146                 {\r
1147                         dbg("format  : %s",pResp);\r
1148                                         if(strlen(pResp)>0)\r
1149                         plmn_format = atoi(pResp);\r
1150                 }\r
1151 \r
1152                         //plmn \r
1153                 switch(plmn_format)\r
1154                 {\r
1155                         case AT_COPS_FORMAT_LONG_ALPHANUMERIC: \r
1156                                 if((pResp = tcore_at_tok_nth(tokens, 2)))\r
1157                                 {               \r
1158                                         dbg("long PLMN  : %s",pResp);\r
1159                                         if(strlen(pResp) > 0){\r
1160                                                 long_plmn_name = malloc((strlen(pResp) - 2)+1); /* 1 extra character for NULL storage */\r
1161                                                 memset(long_plmn_name, 0x00, strlen(pResp) -2+1);\r
1162                                                 /* Strip off starting quotes & ending quotes */\r
1163                                                 strncpy(long_plmn_name, pResp+1, strlen(pResp)-2);\r
1164 \r
1165                                                 //set network name into po\r
1166                                                 tcore_network_set_network_name(o,TCORE_NETWORK_NAME_TYPE_FULL,long_plmn_name);\r
1167                                         }\r
1168                                 }\r
1169                                 break;\r
1170                 \r
1171                                 case AT_COPS_FORMAT_SHORT_ALPHANUMERIC:\r
1172                                         if((pResp = tcore_at_tok_nth(tokens, 2)))\r
1173                                         {\r
1174                                                 dbg("short PLMN  : %s",pResp);\r
1175                                                 if(strlen(pResp)>0){\r
1176                                                         short_plmn_name = malloc((strlen(pResp) - 2)+1); /* 1 extra character for NULL storage */\r
1177                                                         memset(short_plmn_name, 0x00, strlen(pResp) -2+1);\r
1178                                                         /* Strip off starting quotes & ending quotes */\r
1179                                                         strncpy(short_plmn_name, pResp+1, strlen(pResp)-2);\r
1180                                                         \r
1181                                                         //set network name into po                                                      \r
1182                                                         tcore_network_set_network_name(o,TCORE_NETWORK_NAME_TYPE_SHORT,short_plmn_name);                                                        \r
1183                                                 }\r
1184                                         }                                       \r
1185                                 break;\r
1186 \r
1187                                 case AT_COPS_FORMAT_NUMERIC:\r
1188                                         if((pResp = tcore_at_tok_nth(tokens, 2)))\r
1189                                         {\r
1190                                                 dbg("numeric : %s", pResp);\r
1191                                                 if(strlen(pResp)>0){\r
1192                                                         memset(plmn, 0, 7);\r
1193                                                         /* Strip off starting quotes & ending quotes */\r
1194                                                         strncpy(plmn, pResp+1, strlen(pResp)-2);                                                        \r
1195                                                         tcore_network_set_plmn(o,plmn);\r
1196                                                 }\r
1197                                         }\r
1198                                 break;\r
1199         \r
1200                                 default:\r
1201                                 break;\r
1202                         }\r
1203 \r
1204                         //act \r
1205                         if((pResp = tcore_at_tok_nth(tokens, 3)))\r
1206                         {               \r
1207                                 dbg("AcT  : %s",pResp);\r
1208                                 if(strlen(pResp)>0){\r
1209                                         AcT = atoi(pResp);\r
1210                                         tcore_network_set_access_technology(o, lookup_tbl_access_technology[AcT]);\r
1211                                 }\r
1212                         }\r
1213 \r
1214                         tcore_at_tok_free(tokens);\r
1215                 }\r
1216 \r
1217                 memcpy(Tresp.plmn, plmn, 7);\r
1218                 tcore_network_get_access_technology(o, &(Tresp.act)); \r
1219                 tcore_network_get_lac(o, &(Tresp.gsm.lac)); \r
1220 \r
1221                 ur = tcore_pending_ref_user_request(p);\r
1222                 if (ur) {\r
1223                         Tresp.result = TCORE_RETURN_SUCCESS;            \r
1224                         tcore_user_request_send_response(ur, TRESP_NETWORK_GET_SERVING_NETWORK, sizeof(struct tresp_network_get_serving_network), &Tresp);\r
1225                 }\r
1226                 else\r
1227                 {\r
1228                         /* Network change noti */\r
1229                         struct tnoti_network_change network_change;\r
1230 \r
1231                         memset(&network_change, 0, sizeof(struct tnoti_network_change));\r
1232                         memcpy(network_change.plmn, plmn, 7);\r
1233                         tcore_network_get_access_technology(o, &(network_change.act));\r
1234                         tcore_network_get_lac(o, &(network_change.gsm.lac));\r
1235 \r
1236                         tcore_server_send_notification(tcore_plugin_ref_server(tcore_pending_ref_plugin(p)), tcore_pending_ref_core_object(p),\r
1237                                 TNOTI_NETWORK_CHANGE, sizeof(struct tnoti_network_change), &network_change);\r
1238                         dbg("dbg.. network_change.plmn  : %s",network_change.plmn);\r
1239                         dbg("dbg.. network_change.act  : %d",network_change.act);                                               \r
1240                         dbg("dbg.. network_change.gsm.lac  : %d",network_change.gsm.lac);\r
1241 \r
1242                         if((AT_COPS_MODE_DEREGISTER !=network_mode) &&\r
1243                                 (AT_COPS_MODE_SET_ONLY != network_mode)){\r
1244                                 /*Network identity noti*/\r
1245                                 memset(&noti, 0x0, sizeof(struct tnoti_network_change));\r
1246                                 if(long_plmn_name)\r
1247                                         memcpy(noti.full_name, long_plmn_name, MIN(33, strlen(long_plmn_name)) );\r
1248                                 if(short_plmn_name)\r
1249                                         memcpy(noti.short_name, short_plmn_name, MIN(17, strlen(long_plmn_name)) );\r
1250                                 memcpy(noti.plmn, plmn,7);\r
1251                                 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), \r
1252                                         o, TNOTI_NETWORK_IDENTITY,      sizeof(struct tnoti_network_identity), &noti);                  \r
1253                                 dbg("dbg.. noti.short_name  : %s",noti.short_name);\r
1254                                 dbg("dbg.. noti.full_name  : %s",noti.full_name);                                               \r
1255                                 dbg("dbg.. noti.plmn  : %s",noti.plmn); \r
1256                         }\r
1257                 }\r
1258 \r
1259                 if(long_plmn_name)\r
1260                         free(long_plmn_name);\r
1261                 if(short_plmn_name)\r
1262                         free(short_plmn_name);\r
1263         }\r
1264 \r
1265         return;\r
1266 \r
1267 }\r
1268 \r
1269 static gboolean on_event_ps_network_regist(CoreObject *o, const void *data, void *user_data)\r
1270 {\r
1271         struct tnoti_network_registration_status regist_status;\r
1272         enum telephony_network_service_domain_status cs_status;\r
1273         enum telephony_network_service_domain_status ps_status;\r
1274         enum telephony_network_service_type service_type;\r
1275         enum telephony_network_access_technology act = NETWORK_ACT_UNKNOWN;\r
1276         struct tnoti_network_location_cellinfo net_lac_cell_info = {0};\r
1277         struct tnoti_ps_protocol_status noti = {0};\r
1278         unsigned char svc_domain = NETWORK_SERVICE_DOMAIN_PS;\r
1279         int stat= 0, AcT=0;\r
1280         unsigned int lac=0xffff, ci=0xffff;\r
1281         unsigned int rac = 0xffff;\r
1282         GSList* tokens = NULL;\r
1283         char* pResp;\r
1284         char *line = NULL;\r
1285         GSList *lines = NULL;\r
1286 \r
1287         lines = (GSList*)data;\r
1288         if (1 != g_slist_length(lines)) {\r
1289                 dbg("unsolicited msg but multiple line");\r
1290             goto OUT;\r
1291         }\r
1292         line  = (char*)(lines->data);\r
1293         dbg("+CGREG NOTI RECEIVED");\r
1294 \r
1295 /*\r
1296 +CREG: <stat> [[,<lac>,<ci>[AcT]]\r
1297 \r
1298 Possible values of <stat> can be\r
1299 0 Not registered, ME is not currently searching a new operator to register to\r
1300 1 Registered, home network\r
1301 2 Not registered, but ME is currently searching a new operator to register\r
1302 3 Registration denied\r
1303 4 Unknown\r
1304 5 Registered, in roaming\r
1305 \r
1306 <lac>\r
1307 string type; two byte location area code in hexadecimal format (e.g. �00C3�)\r
1308 \r
1309 <ci>\r
1310 string type; four byte cell ID in hexadecimal format (e.g. �0000A13F�)\r
1311 \r
1312 <ACT>\r
1313 0 GSM\r
1314 2 UTRAN\r
1315 3 GSM w/EGPRS\r
1316 4 UTRAN w/HSDPA\r
1317 5 UTRAN w/HSUPA\r
1318 6 UTRAN w/HSDPA and HSUPA\r
1319 Note: <Act> is supporting from R7 and above Protocol Stack.\r
1320 \r
1321 <rac>: is R7 and above feature, string type; one byte routing area code in hexadecimal format.\r
1322 */\r
1323         if (line!=NULL)\r
1324         {\r
1325                 tokens = tcore_at_tok_new(line);\r
1326                 if(g_slist_length(tokens) < 1) {\r
1327                         msg("invalid message");\r
1328                         goto OUT;\r
1329                 }\r
1330 \r
1331                 if(!(pResp = g_slist_nth_data(tokens, 0)))\r
1332                 {\r
1333                         dbg("No  STAT in +CGREG");\r
1334                         goto OUT;\r
1335                 }\r
1336                 else\r
1337                 {\r
1338                         stat = atoi(pResp);     \r
1339                         if((pResp = g_slist_nth_data(tokens, 1)))\r
1340                                 lac = atoi(pResp);\r
1341 \r
1342                         if((pResp = g_slist_nth_data(tokens, 2)))\r
1343                                 ci = atoi(pResp);\r
1344                         else\r
1345                                 dbg("No ci in +CGREG");\r
1346                                 \r
1347                         if((pResp = g_slist_nth_data(tokens, 3)))\r
1348                                 AcT = atoi(pResp);\r
1349                         else\r
1350                                 dbg("No AcT in +CGREG");\r
1351                         \r
1352                         if((pResp = g_slist_nth_data(tokens, 4)))\r
1353                                 rac = atoi(pResp);\r
1354                         else\r
1355                                 dbg("No rac in +CGREG");\r
1356                 }\r
1357 \r
1358 \r
1359                 dbg("stat=%d, lac=0x%lx, ci=0x%lx, Act=%d, rac = 0x%x", stat, lac, ci, AcT, rac);\r
1360 \r
1361                 ps_status = lookup_tbl_net_status[stat];\r
1362                 \r
1363                 tcore_network_set_service_status(o, TCORE_NETWORK_SERVICE_DOMAIN_TYPE_PACKET, ps_status);\r
1364                 _ps_set(tcore_object_ref_plugin(o), ps_status);\r
1365                         \r
1366                 tcore_network_get_service_status(o, TCORE_NETWORK_SERVICE_DOMAIN_TYPE_CIRCUIT, &cs_status);\r
1367 \r
1368                 act = lookup_tbl_access_technology[AcT];\r
1369                 tcore_network_set_access_technology(o, act);\r
1370 \r
1371                 if (stat == AT_CREG_STAT_REG_ROAM)\r
1372                         tcore_network_set_roaming_state(o, TRUE);\r
1373                 else\r
1374                         tcore_network_set_roaming_state(o, FALSE);\r
1375 \r
1376                 tcore_network_get_service_type(o, &service_type);\r
1377                 dbg("prev_service_type = 0x%x", service_type);\r
1378                 service_type = _get_service_type(service_type, svc_domain, act, cs_status, ps_status);\r
1379                 dbg("new_service_type = 0x%x", service_type);\r
1380                 tcore_network_set_service_type(o, service_type);\r
1381 \r
1382                 tcore_network_set_lac(o, lac);\r
1383                 tcore_network_set_cell_id(o, ci);\r
1384                 tcore_network_set_rac(o, rac);\r
1385 \r
1386                 net_lac_cell_info.lac = lac;\r
1387                 net_lac_cell_info.cell_id = ci;\r
1388 \r
1389                 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), o, TNOTI_NETWORK_LOCATION_CELLINFO,\r
1390                                 sizeof(struct tnoti_network_location_cellinfo), &net_lac_cell_info);\r
1391 \r
1392                 regist_status.cs_domain_status = cs_status;\r
1393                 regist_status.ps_domain_status = ps_status;\r
1394                 regist_status.service_type = service_type;\r
1395                 regist_status.roaming_status = tcore_network_get_roaming_state(o);\r
1396 \r
1397                 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), o,\r
1398                                 TNOTI_NETWORK_REGISTRATION_STATUS, sizeof(struct tnoti_network_registration_status), &regist_status);\r
1399 \r
1400                 if(service_type == NETWORK_SERVICE_TYPE_HSDPA)\r
1401                         noti.status = TELEPHONY_HSDPA_ON;\r
1402                 else\r
1403                         noti.status = TELEPHONY_HSDPA_OFF;\r
1404                 \r
1405                 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), o, TNOTI_PS_PROTOCOL_STATUS,\r
1406                 sizeof(struct tnoti_ps_protocol_status), &noti);\r
1407 \r
1408                 /* Get PLMN ID needed to application */\r
1409                 //get_serving_network(o, NULL);\r
1410 \r
1411 \r
1412         }\r
1413         else\r
1414         {\r
1415                 dbg("Response NOK");\r
1416         }\r
1417 \r
1418 OUT:\r
1419         if(NULL!=tokens)\r
1420                 tcore_at_tok_free(tokens);\r
1421         return TRUE;\r
1422 }\r
1423 \r
1424 static gboolean on_event_cs_network_regist(CoreObject *o, const void *event_info, void *user_data)\r
1425 {\r
1426         GSList *lines = NULL;\r
1427         char *line = NULL;\r
1428         struct tnoti_network_registration_status regist_status;\r
1429         enum telephony_network_service_domain_status cs_status;\r
1430         enum telephony_network_service_domain_status ps_status;\r
1431         enum telephony_network_service_type service_type;\r
1432         enum telephony_network_access_technology act = NETWORK_ACT_UNKNOWN;\r
1433         struct tnoti_network_location_cellinfo net_lac_cell_info = {0};\r
1434 \r
1435         \r
1436         unsigned char svc_domain = NETWORK_SERVICE_DOMAIN_CS;\r
1437         int stat= 0, AcT=0;\r
1438         unsigned int lac=0xffff, ci=0xffff;\r
1439         GSList* tokens = NULL;\r
1440         char* pResp;\r
1441 \r
1442         lines = (GSList*)event_info;\r
1443         if (1 != g_slist_length(lines)) {\r
1444                 dbg("unsolicited msg but multiple line");\r
1445             goto OUT;\r
1446         }\r
1447         line  = (char*)(lines->data);\r
1448 \r
1449         dbg("+CREG NOTI RECEIVED");\r
1450 \r
1451 /*\r
1452 +CREG: <stat> [[,<lac>,<ci>[AcT]]\r
1453 \r
1454 Possible values of <stat> can be\r
1455 0 Not registered, ME is not currently searching a new operator to register to\r
1456 1 Registered, home network\r
1457 2 Not registered, but ME is currently searching a new operator to register\r
1458 3 Registration denied\r
1459 4 Unknown\r
1460 5 Registered, in roaming\r
1461 \r
1462 <lac>\r
1463 string type; two byte location area code in hexadecimal format (e.g. �00C3�)\r
1464 \r
1465 <ci>\r
1466 string type; four byte cell ID in hexadecimal format (e.g. �0000A13F�)\r
1467 \r
1468 <ACT>\r
1469 0 GSM\r
1470 2 UTRAN\r
1471 3 GSM w/EGPRS\r
1472 4 UTRAN w/HSDPA\r
1473 5 UTRAN w/HSUPA\r
1474 6 UTRAN w/HSDPA and HSUPA\r
1475 Note: <Act> is supporting from R7 and above Protocol Stack.\r
1476 */\r
1477         if (line!=NULL)\r
1478         {\r
1479                 tokens = tcore_at_tok_new(line);\r
1480                 if(g_slist_length(tokens) < 1) {\r
1481                         msg("invalid message");\r
1482                         goto OUT;\r
1483                 }\r
1484 \r
1485                 if(!(pResp = g_slist_nth_data(tokens, 0)))\r
1486                 {\r
1487                         dbg("No  STAT in +CREG");\r
1488                         goto OUT;\r
1489                 }\r
1490                 else\r
1491                 {\r
1492                         stat = atoi(pResp);     \r
1493                         if((pResp = g_slist_nth_data(tokens, 1)))\r
1494                                 lac = atoi(pResp);\r
1495 \r
1496                         if((pResp = g_slist_nth_data(tokens, 2)))\r
1497                                 ci = atoi(pResp);\r
1498                         else\r
1499                                 dbg("No ci in +CREG");\r
1500                                 \r
1501                         if((pResp = g_slist_nth_data(tokens, 3)))\r
1502                                 AcT = atoi(pResp);\r
1503                         else\r
1504                                 dbg("No AcT in +CREG");\r
1505                 }\r
1506 \r
1507 \r
1508                 dbg("stat=%d, lac=0x%lx, ci=0x%lx, Act=%d", stat, lac, ci, AcT);\r
1509 \r
1510                 cs_status = lookup_tbl_net_status[stat];\r
1511                 tcore_network_set_service_status(o, TCORE_NETWORK_SERVICE_DOMAIN_TYPE_CIRCUIT, cs_status);\r
1512 \r
1513         //      tcore_network_get_service_status(o, TCORE_NETWORK_SERVICE_DOMAIN_TYPE_CIRCUIT, &cs_status);\r
1514                 tcore_network_get_service_status(o, TCORE_NETWORK_SERVICE_DOMAIN_TYPE_PACKET, &ps_status);\r
1515 \r
1516                 act = lookup_tbl_access_technology[AcT];\r
1517                 tcore_network_set_access_technology(o, act);\r
1518 \r
1519                 if (stat == AT_CREG_STAT_REG_ROAM)\r
1520                         tcore_network_set_roaming_state(o, TRUE);\r
1521                 else\r
1522                         tcore_network_set_roaming_state(o, FALSE);\r
1523 \r
1524                 tcore_network_get_service_type(o, &service_type);\r
1525                 dbg("prev_service_type = 0x%x", service_type);\r
1526                 service_type = _get_service_type(service_type, svc_domain, act, cs_status, ps_status);\r
1527                 dbg("new_service_type = 0x%x", service_type);\r
1528                 tcore_network_set_service_type(o, service_type);\r
1529 \r
1530                 tcore_network_set_lac(o, lac);\r
1531                 tcore_network_set_cell_id(o, ci);\r
1532 \r
1533                 net_lac_cell_info.lac = lac;\r
1534                 net_lac_cell_info.cell_id = ci;\r
1535 \r
1536                 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), o, TNOTI_NETWORK_LOCATION_CELLINFO,\r
1537                                 sizeof(struct tnoti_network_location_cellinfo), &net_lac_cell_info);\r
1538 \r
1539                 regist_status.cs_domain_status = cs_status;\r
1540                 regist_status.ps_domain_status = ps_status;\r
1541                 regist_status.service_type = service_type;\r
1542                 regist_status.roaming_status = tcore_network_get_roaming_state(o);\r
1543 \r
1544                 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), o,\r
1545                                 TNOTI_NETWORK_REGISTRATION_STATUS, sizeof(struct tnoti_network_registration_status), &regist_status);\r
1546 \r
1547                 /* Get PLMN ID needed to application */\r
1548                 if((NETWORK_SERVICE_DOMAIN_STATUS_FULL == cs_status )||\r
1549                         NETWORK_SERVICE_DOMAIN_STATUS_FULL ==ps_status )\r
1550                 get_serving_network(o, NULL);\r
1551         }\r
1552         else\r
1553         {\r
1554                 dbg("Response NOK");\r
1555         }\r
1556 \r
1557 OUT:\r
1558         if(NULL!=tokens)\r
1559                 tcore_at_tok_free(tokens);\r
1560         return TRUE;\r
1561 \r
1562 }\r
1563 \r
1564 static gboolean on_event_network_icon_info(CoreObject *o, const void *event_info, void *user_data)\r
1565 {\r
1566         struct tnoti_network_icon_info net_icon_info = {0};\r
1567         char *line = NULL;\r
1568         char * rssiToken = NULL;\r
1569         char *batteryToken = NULL;\r
1570         GSList* tokens = NULL;\r
1571         GSList *lines = NULL;\r
1572 \r
1573         lines = (GSList*)event_info;\r
1574         if (1 != g_slist_length(lines)) {\r
1575                 dbg("unsolicited msg but multiple line");\r
1576             goto OUT;\r
1577         }\r
1578         line = (char*)(lines->data);\r
1579         dbg("+XCIEV Network Icon Info Noti Recieve");\r
1580         memset(&net_icon_info, 0, sizeof(struct tnoti_network_icon_info));\r
1581 \r
1582         if(line != NULL)\r
1583         {\r
1584                 dbg("Response OK");\r
1585         \r
1586                 tokens = tcore_at_tok_new(line);\r
1587                 if (g_slist_length(tokens) != 2) {\r
1588                         msg("invalid message");\r
1589                         goto OUT;\r
1590                 }\r
1591 \r
1592                 rssiToken = (char *)g_slist_nth_data(tokens, 0);\r
1593 \r
1594                 if (strlen(rssiToken)>0)\r
1595                 {\r
1596                         net_icon_info.type = NETWORK_ICON_INFO_RSSI;\r
1597                         net_icon_info.rssi= atoi(g_slist_nth_data(tokens, 0));\r
1598                         dbg("rssi level : %d",net_icon_info.rssi);\r
1599                 }\r
1600                 \r
1601                 batteryToken = (char *)g_slist_nth_data(tokens,1);\r
1602                 if (strlen(batteryToken)>0)\r
1603                 {\r
1604                         net_icon_info.type = NETWORK_ICON_INFO_BATTERY;\r
1605                         net_icon_info.battery= atoi(g_slist_nth_data(tokens, 1));\r
1606                         dbg("battery level : %d",net_icon_info.battery);\r
1607                 }\r
1608                 \r
1609                 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), o, TNOTI_NETWORK_ICON_INFO,\r
1610                                 sizeof(struct tnoti_network_icon_info), &net_icon_info);\r
1611         }\r
1612         else\r
1613         {\r
1614                 dbg("Response NOK");            \r
1615         }\r
1616 \r
1617 \r
1618 OUT:\r
1619         if(NULL!=tokens)\r
1620                 tcore_at_tok_free(tokens);\r
1621         \r
1622         return TRUE;\r
1623         \r
1624 }\r
1625 \r
1626 static gboolean on_event_network_ds_time_info(CoreObject *o, const void *event_info, void *user_data)\r
1627 {\r
1628 /*\r
1629 +CTZDST<dst>\r
1630 <dst> daylight savings time value:\r
1631 0 No adjustment for Daylight Saving Time\r
1632 1 +1 hour adjustment for Daylight Saving Time\r
1633 2 +2 hours adjustment for Daylight Saving Time\r
1634 */\r
1635         return TRUE;\r
1636 }\r
1637 \r
1638 \r
1639 static gboolean on_event_network_ctzv_time_info(CoreObject *o, const void *event_info, void *user_data)\r
1640 {\r
1641         struct tnoti_network_timeinfo net_time_info = {0};\r
1642         char *line = NULL;\r
1643         GSList* tokens = NULL;\r
1644         char *time= NULL;\r
1645         char *time_zone = NULL;\r
1646         GSList *lines = NULL;\r
1647         char ptime_param[20] = {0};\r
1648         UserRequest *ur = NULL;\r
1649         dbg("Enter : on_event_network_ctzv_time_info");\r
1650 \r
1651         lines = (GSList*)event_info;\r
1652         if (1 != g_slist_length(lines)) {\r
1653                 dbg("unsolicited msg but multiple line");\r
1654             goto OUT;\r
1655         }\r
1656         line  = (char*)(lines->data);\r
1657 \r
1658 /*\r
1659 +CTZV: <tz>,<time>\r
1660 <tz> integer value indicating the time zone (e.g. -22 or +34)\r
1661 <time> string type value; format is “yy/MM/dd,hh:mms”, wherein characters indicates year, month, day, hour,\r
1662 minutes, seconds.\r
1663 */\r
1664         dbg("Network time info (+CTZV) recieved");\r
1665         \r
1666         if (line != NULL)\r
1667         {\r
1668                 dbg("Response OK");\r
1669                 dbg("noti line is %s", line);\r
1670                 \r
1671                 tokens = tcore_at_tok_new(line);\r
1672                 \r
1673                 if(g_slist_length(tokens) < 2) {\r
1674                         msg("invalid message");\r
1675                         goto OUT;\r
1676                 }\r
1677 \r
1678                 if ((time_zone = g_slist_nth_data(tokens, 0))){\r
1679                         net_time_info.gmtoff = atoi(time_zone) * 15; /* TZ in minutes */\r
1680                 }\r
1681 \r
1682                 if (tcore_network_get_plmn(o) != NULL)\r
1683                         strcpy(net_time_info.plmn, tcore_network_get_plmn(o));\r
1684                 \r
1685                 if ((time = g_slist_nth_data(tokens, 1)) && (strlen(time) >18)){\r
1686                         strncpy(ptime_param, time+1, 2); /* skip past initial quote (") */\r
1687                         net_time_info.year = atoi(ptime_param); \r
1688                                 \r
1689                         strncpy(ptime_param, time+4, 2); /* skip slash (/) after year param */\r
1690                         net_time_info.month = atoi(ptime_param);\r
1691                                 \r
1692                         strncpy(ptime_param, time+7, 2); /* skip past slash (/) after month param */\r
1693                         net_time_info.day = atoi(ptime_param);\r
1694                         \r
1695                         strncpy(ptime_param, time+10, 2); /* skip past comma (,) after day param */\r
1696                         net_time_info.hour = atoi(ptime_param);\r
1697                         \r
1698                         strncpy(ptime_param, time+13, 2); /* skip past colon (:) after hour param */\r
1699                         net_time_info.minute = atoi(ptime_param);\r
1700                         \r
1701                         strncpy(ptime_param, time+16, 2); /* skip past colon (:) after minute param */\r
1702                         net_time_info.second = atoi(ptime_param);\r
1703                 }\r
1704                 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), o, TNOTI_NETWORK_TIMEINFO, sizeof(struct tnoti_network_timeinfo), &net_time_info);\r
1705 \r
1706                 dbg("new pending(AT+XOPS=0/5/6 for Nitz PLMN name)");\r
1707 \r
1708                 /* Get NITZ name and plmn_id via AT+XCOPS = 0/5/6 */\r
1709                 nwk_prepare_and_send_pending_request(tcore_object_ref_plugin(o), "umts_network", "AT+XCOPS=0;+XCOPS=5;+XCOPS=6", "+XCOPS", TCORE_AT_MULTILINE, ur, on_response_get_nitz_name);\r
1710         }\r
1711         else\r
1712         {       \r
1713                 dbg("line is  NULL");\r
1714         }\r
1715         \r
1716 OUT:\r
1717         if(NULL!=tokens)\r
1718                 tcore_at_tok_free(tokens);\r
1719 \r
1720         dbg("Exit: on_event_network_ctzv_time_info");\r
1721         return TRUE;\r
1722 }\r
1723 \r
1724 static void on_sim_resp_hook_get_netname(UserRequest *ur, enum tcore_response_command command, unsigned int data_len,\r
1725                 const void *data, void *user_data)\r
1726 {\r
1727         const struct tresp_sim_read *resp = data;\r
1728         CoreObject *o = user_data;\r
1729 \r
1730         if (command == TRESP_SIM_GET_SPN) {\r
1731                 dbg("OK SPN GETTING!!");\r
1732                 dbg("resp->result = 0x%x", resp->result);\r
1733                 dbg("resp->data.spn.display_condition = 0x%x", resp->data.spn.display_condition);\r
1734                 dbg("resp->data.spn.spn = [%s]", resp->data.spn.spn);\r
1735 \r
1736                 tcore_network_set_network_name(o, TCORE_NETWORK_NAME_TYPE_SPN, (const char *)resp->data.spn.spn);\r
1737 \r
1738                 /**\r
1739                  * display condition\r
1740                  *  bit[0]: 0 = display of registered PLMN name not required when registered PLMN is either HPLMN or a PLMN in the service provider PLMN list\r
1741                  *          1 = display of registered PLMN name required when registered PLMN is either HPLMN or a PLMN in the service provider PLMN list\r
1742                  *  bit[1]: 0 = display of the service provider name is required when registered PLMN is neither HPLMN nor a PLMN in the service provider PLMN list\r
1743                  *          1 = display of the service provider name is not required when registered PLMN is neither HPLMN nor a PLMN in the service provider PLMN list\r
1744                  */\r
1745                 if (resp->data.spn.display_condition & 0x01) {\r
1746                         tcore_network_set_network_name_priority(o, TCORE_NETWORK_NAME_PRIORITY_NETWORK);\r
1747                 }\r
1748                 if ((resp->data.spn.display_condition & 0x02) == 0) {\r
1749                         tcore_network_set_network_name_priority(o, TCORE_NETWORK_NAME_PRIORITY_SPN);\r
1750                 }\r
1751                 if ((resp->data.spn.display_condition & 0x03) == 0x01) {\r
1752                         tcore_network_set_network_name_priority(o, TCORE_NETWORK_NAME_PRIORITY_ANY);\r
1753                 }\r
1754         }\r
1755 }\r
1756 \r
1757 static enum tcore_hook_return on_hook_sim_init(Server *s, CoreObject *source, enum tcore_notification_command command,\r
1758                 unsigned int data_len, void *data, void *user_data)\r
1759 {\r
1760         const struct tnoti_sim_status *sim = data;\r
1761         UserRequest *ur = NULL;\r
1762 \r
1763         if (sim->sim_status == SIM_STATUS_INIT_COMPLETED) {\r
1764                 ur = tcore_user_request_new(NULL, NULL);\r
1765                 tcore_user_request_set_command(ur, TREQ_SIM_GET_SPN);\r
1766                 tcore_user_request_set_response_hook(ur, on_sim_resp_hook_get_netname, user_data);\r
1767                 tcore_object_dispatch_request(source, ur);\r
1768         }\r
1769 \r
1770         return TCORE_HOOK_RETURN_CONTINUE;\r
1771 }\r
1772 \r
1773 static TReturn search_network(CoreObject *o, UserRequest *ur)\r
1774 {\r
1775         TcoreHal *h = NULL;\r
1776         TcorePending *pending = NULL;\r
1777         TcoreATRequest *atreq = NULL;\r
1778 \r
1779         char*cmd_str = NULL;\r
1780         dbg("search_network - ENTER!!");\r
1781         \r
1782         if (!o || !ur)\r
1783                 return TCORE_RETURN_EINVAL;\r
1784 \r
1785         h = tcore_object_get_hal(o);\r
1786         pending = tcore_pending_new(o, 0);\r
1787 \r
1788         cmd_str = g_strdup_printf("AT+COPS=?");\r
1789         atreq = tcore_at_request_new(cmd_str, "+COPS", TCORE_AT_SINGLELINE);\r
1790         \r
1791         tcore_pending_set_request_data(pending, 0, atreq);\r
1792         tcore_pending_set_timeout(pending, 60);\r
1793         tcore_pending_set_priority(pending, TCORE_PENDING_PRIORITY_DEFAULT);\r
1794         tcore_pending_set_response_callback(pending, on_response_search_network, NULL);\r
1795         tcore_pending_set_timeout_callback(pending, on_timeout_search_network, NULL);\r
1796         tcore_pending_link_user_request(pending, ur);\r
1797         tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);\r
1798 \r
1799         tcore_hal_send_request(h, pending);\r
1800 \r
1801         return TCORE_RETURN_SUCCESS;\r
1802 }\r
1803 \r
1804 static TReturn set_plmn_selection_mode(CoreObject *o, UserRequest *ur)\r
1805 {\r
1806         TcoreHal *h = NULL;\r
1807         TcorePending *pending = NULL;\r
1808         TcoreATRequest *atreq;\r
1809         char*cmd_str = NULL;\r
1810         int format = 0; /* default value for long alphanumeric */\r
1811         int mode = 0;\r
1812         char plmn[7] = {0};\r
1813         int act = 0;\r
1814         \r
1815         const struct treq_network_set_plmn_selection_mode *req_data;\r
1816 \r
1817 \r
1818         dbg("set_plmn_selection_mode - ENTER!!");\r
1819 \r
1820         if (!o || !ur)\r
1821                 return TCORE_RETURN_EINVAL;\r
1822 \r
1823         req_data = tcore_user_request_ref_data(ur, NULL);\r
1824         h = tcore_object_get_hal(o);\r
1825         pending = tcore_pending_new(o, 0);\r
1826 \r
1827         // Command Format - AT+COPS=[<mode>[,<format>[,<oper>[,< AcT>]]]]       \r
1828         /* oper parameter format\r
1829                 - 0 <oper> format presentations are set to long alphanumeric. If Network name not available it displays combination of Mcc and MNC in string format.\r
1830                 - 1 <oper> format presentation is set to short alphanumeric.\r
1831                 - 2 <oper> format presentations set to numeric.\r
1832         */\r
1833 \r
1834         if((req_data->act == NETWORK_ACT_GSM ) || (req_data->act == NETWORK_ACT_EGPRS ))\r
1835                 act = 0;\r
1836         else\r
1837                 act = 2;\r
1838 \r
1839         switch(req_data->mode) {\r
1840                 case NETWORK_SELECT_MODE_GSM_MANUAL:\r
1841                 {\r
1842                         mode = AT_COPS_MODE_MANUAL;\r
1843                         format = AT_COPS_FORMAT_NUMERIC;\r
1844 \r
1845                         memset(plmn, 0, 7);\r
1846                         memcpy(plmn, req_data->plmn, 6);\r
1847 \r
1848                         if (strlen(req_data->plmn) == 6) {\r
1849                                 if(plmn[5] =='#')\r
1850                                         plmn[5] = 0;\r
1851                         }\r
1852 \r
1853                         cmd_str = g_strdup_printf("AT+COPS=%d,%d,\"%s\",%d", mode, format, plmn, act);\r
1854                 }\r
1855                 break;\r
1856                 \r
1857                 case NETWORK_SELECT_MODE_GLOBAL_AUTOMATIC:\r
1858                 default:\r
1859                         cmd_str = g_strdup("AT+COPS=0");\r
1860                         break;\r
1861         }\r
1862 \r
1863         \r
1864         atreq = tcore_at_request_new(cmd_str, "+COPS", TCORE_AT_NO_RESULT);\r
1865 \r
1866         tcore_pending_set_request_data(pending, 0, atreq);\r
1867         tcore_pending_set_response_callback(pending, on_response_set_plmn_selection_mode, NULL);\r
1868         tcore_pending_link_user_request(pending, ur);\r
1869         tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);\r
1870 \r
1871 \r
1872         tcore_hal_send_request(h, pending);\r
1873 \r
1874         return TCORE_RETURN_SUCCESS;\r
1875 }\r
1876 \r
1877 static TReturn get_plmn_selection_mode(CoreObject *o, UserRequest *ur)\r
1878 {\r
1879         TcoreHal *h = NULL;\r
1880         TcorePending *pending = NULL;\r
1881         TcoreATRequest *atreq;\r
1882         char*cmd_str = NULL;\r
1883 \r
1884         dbg("get_plmn_selection_mode - ENTER!!");\r
1885 \r
1886         if (!o || !ur)\r
1887                 return TCORE_RETURN_EINVAL;\r
1888 \r
1889         h = tcore_object_get_hal(o);\r
1890         pending = tcore_pending_new(o, 0);\r
1891 \r
1892         cmd_str = g_strdup_printf("AT+COPS?");\r
1893         atreq = tcore_at_request_new(cmd_str, "+COPS", TCORE_AT_SINGLELINE);\r
1894 \r
1895         tcore_pending_set_request_data(pending, 0, atreq);\r
1896         tcore_pending_set_response_callback(pending, on_response_get_plmn_selection_mode, NULL);\r
1897         tcore_pending_link_user_request(pending, ur);\r
1898         tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);\r
1899 \r
1900         tcore_hal_send_request(h, pending);\r
1901 \r
1902         return TCORE_RETURN_SUCCESS;\r
1903 }\r
1904 \r
1905 \r
1906 static TReturn set_band(CoreObject *o, UserRequest *ur)\r
1907 {\r
1908         TcoreHal *h = NULL;\r
1909         TcorePending *pending = NULL;\r
1910         TcorePending *pending_gsm = NULL;\r
1911         TcorePending *pending_umts = NULL;\r
1912         TcoreATRequest *atreq;\r
1913         char*cmd_str = NULL;\r
1914         const struct treq_network_set_band *req_data;\r
1915         gboolean set_gsm_band = 0;\r
1916         gboolean set_umts_band = 0;\r
1917         int gsm_band = 255;\r
1918         int gsm_band2 = 255;\r
1919         char *umts_band = NULL;\r
1920         UserRequest *dup_ur_gsm = NULL;\r
1921         UserRequest *dup_ur_umts = NULL;\r
1922         \r
1923         dbg("set_band - ENTER!!");\r
1924 \r
1925         if (!o || !ur)\r
1926                 return TCORE_RETURN_EINVAL;\r
1927 \r
1928         req_data = tcore_user_request_ref_data(ur, NULL);\r
1929         h = tcore_object_get_hal(o);\r
1930 \r
1931         dbg("set_band - called with band = %d", req_data->band);\r
1932 \r
1933         switch (req_data->band)\r
1934         {\r
1935                 case NETWORK_BAND_TYPE_GSM850:\r
1936                         gsm_band = AT_GSM_XBANDSEL_850;\r
1937                         set_gsm_band = TRUE;\r
1938                         break;\r
1939 \r
1940                 case NETWORK_BAND_TYPE_GSM_900_1800:\r
1941                         gsm_band = AT_GSM_XBANDSEL_900; \r
1942                         gsm_band2 = AT_GSM_XBANDSEL_1800;\r
1943                         set_gsm_band = TRUE;\r
1944                         break;\r
1945 \r
1946                 case NETWORK_BAND_TYPE_GSM1900:\r
1947                         gsm_band = AT_GSM_XBANDSEL_1900;\r
1948                         set_gsm_band = TRUE;\r
1949                         break;\r
1950                         \r
1951                 case NETWORK_BAND_TYPE_GSM1800:\r
1952                         gsm_band = AT_GSM_XBANDSEL_1800;\r
1953                         set_gsm_band = TRUE;\r
1954                         break;\r
1955                         \r
1956                 case NETWORK_BAND_TYPE_GSM_850_1900:\r
1957                         gsm_band = AT_GSM_XBANDSEL_850;\r
1958                         gsm_band2 = AT_GSM_XBANDSEL_1900;\r
1959                         set_gsm_band = TRUE;\r
1960                         break; \r
1961                         \r
1962                 case NETWORK_BAND_TYPE_ANY:\r
1963                         gsm_band = AT_GSM_XBANDSEL_AUTOMATIC;\r
1964                         set_umts_band = TRUE;\r
1965                         set_gsm_band = TRUE;\r
1966                         break;\r
1967 \r
1968                 case NETWORK_BAND_TYPE_WCDMA:\r
1969                         set_umts_band = TRUE;\r
1970                         break;\r
1971                         \r
1972                 case NETWORK_BAND_TYPE_WCDMA2100:\r
1973                         umts_band = "UMTS_BAND_I";\r
1974                         set_umts_band = TRUE;\r
1975                         break;\r
1976                         \r
1977                 case NETWORK_BAND_TYPE_WCDMA1900:\r
1978                         umts_band = "UMTS_BAND_II";\r
1979                         set_umts_band = TRUE;\r
1980                         break;\r
1981                         \r
1982                 case NETWORK_BAND_TYPE_WCDMA850:\r
1983                         umts_band = "UMTS_BAND_V";\r
1984                         set_umts_band = TRUE;\r
1985                         break;\r
1986 \r
1987                 default:\r
1988                         break;\r
1989         }\r
1990 \r
1991         dbg("set_band > set_umts_band = %d, set_gsm_band = %d", set_umts_band, set_gsm_band);\r
1992 \r
1993         if(set_umts_band == TRUE)\r
1994         {\r
1995                 if((req_data->band == NETWORK_BAND_TYPE_WCDMA) || (req_data->band == NETWORK_BAND_TYPE_ANY))\r
1996                         cmd_str = g_strdup_printf("AT+XUBANDSEL=0");\r
1997                 else    \r
1998                         cmd_str = g_strdup_printf("AT+XUBANDSEL=%s", umts_band);\r
1999                 \r
2000                 atreq = tcore_at_request_new(cmd_str, "+XUBANDSEL", TCORE_AT_NO_RESULT);\r
2001                 pending_umts = tcore_pending_new(o, 0);\r
2002 \r
2003                 tcore_pending_set_request_data(pending_umts, 0, atreq);\r
2004                 tcore_pending_set_timeout(pending_umts, 0);\r
2005                 tcore_pending_set_priority(pending_umts, TCORE_PENDING_PRIORITY_DEFAULT);\r
2006                 tcore_pending_set_response_callback(pending_umts, on_response_set_umts_band, NULL);\r
2007                 \r
2008                 /* duplicate user request for UMTS Band setting AT command for same UR */\r
2009                 dup_ur_umts = tcore_user_request_ref(ur);\r
2010                 tcore_pending_link_user_request(pending_umts, dup_ur_umts);\r
2011                 tcore_pending_set_send_callback(pending_umts, on_confirmation_network_message_send, NULL);\r
2012 \r
2013                 tcore_hal_send_request(h, pending_umts);\r
2014         }\r
2015         \r
2016         if(set_gsm_band == TRUE)\r
2017         {\r
2018                 dbg("Entered set_gsm_band");\r
2019                 if (gsm_band2 == 255)\r
2020                         cmd_str = g_strdup_printf("AT+XBANDSEL=%d", gsm_band);\r
2021                 else\r
2022                         cmd_str = g_strdup_printf("AT+XBANDSEL=%d,%d", gsm_band, gsm_band2);\r
2023 \r
2024                 dbg("Command string: %s",cmd_str);\r
2025                 atreq = tcore_at_request_new(cmd_str, "+XBANDSEL", TCORE_AT_NO_RESULT);\r
2026                 pending_gsm = tcore_pending_new(o, 0);\r
2027 \r
2028                 tcore_pending_set_request_data(pending_gsm, 0, atreq);\r
2029                 tcore_pending_set_timeout(pending_gsm, 0);\r
2030                 tcore_pending_set_priority(pending_gsm, TCORE_PENDING_PRIORITY_DEFAULT);\r
2031                 tcore_pending_set_response_callback(pending_gsm, on_response_set_gsm_band, NULL);\r
2032 \r
2033                 /* duplicate user request for GSM Band setting AT command for same UR */\r
2034                 dup_ur_gsm = tcore_user_request_ref(ur);\r
2035                 tcore_pending_link_user_request(pending_gsm, dup_ur_gsm);\r
2036                 tcore_pending_set_send_callback(pending_gsm, on_confirmation_network_message_send, NULL);\r
2037 \r
2038                 tcore_hal_send_request(h, pending_gsm);\r
2039         }\r
2040 \r
2041         /* Lock device to specific RAT as requested by application */\r
2042 /*\r
2043 AT+XRAT=<Act>[,<PreferredAct>]\r
2044 <AcT> indicates the radio access technology and may be\r
2045 0 GSM single mode\r
2046 1 GSM / UMTS Dual mode\r
2047 2 UTRAN (UMTS)\r
2048 */\r
2049         if ((set_umts_band == TRUE) && (set_gsm_band == TRUE)){\r
2050                 cmd_str = g_strdup_printf("AT+XRAT=%d", AT_XRAT_DUAL);\r
2051         }\r
2052         else if (set_umts_band == TRUE){\r
2053                 cmd_str = g_strdup_printf("AT+XRAT=%d", AT_XRAT_UMTS);\r
2054         }\r
2055         else{\r
2056                 cmd_str = g_strdup_printf("AT+XRAT=%d", AT_XRAT_GSM);\r
2057         }\r
2058         atreq = tcore_at_request_new(cmd_str, "+XRAT", TCORE_AT_NO_RESULT);\r
2059         pending = tcore_pending_new(o, 0);\r
2060 \r
2061         tcore_pending_set_request_data(pending, 0, atreq);\r
2062         tcore_pending_set_timeout(pending, 0);\r
2063         tcore_pending_set_priority(pending, TCORE_PENDING_PRIORITY_DEFAULT);\r
2064         tcore_pending_set_response_callback(pending, on_response_set_xrat, NULL);\r
2065         tcore_pending_link_user_request(pending, ur);\r
2066         tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);\r
2067 \r
2068         tcore_hal_send_request(h, pending);\r
2069 \r
2070         return TCORE_RETURN_SUCCESS;\r
2071 }\r
2072 \r
2073 static TReturn get_band(CoreObject *o, UserRequest *ur)\r
2074 {\r
2075         TcoreHal *h = NULL;\r
2076         TcorePending *pending = NULL;\r
2077 \r
2078         TcoreATRequest *atreq;\r
2079         char*cmd_str = NULL;\r
2080         dbg("get_band - ENTER!!");\r
2081 \r
2082         if (!o || !ur)\r
2083                 return TCORE_RETURN_EINVAL;\r
2084 \r
2085         h = tcore_object_get_hal(o);\r
2086         \r
2087         /* Get RAT Information Information. Based on RAT read response, we will get specific RAT bands only */\r
2088         cmd_str = g_strdup_printf("AT+XRAT?");\r
2089         atreq = tcore_at_request_new(cmd_str, "+XRAT", TCORE_AT_SINGLELINE);\r
2090         pending = tcore_pending_new(o, 0);\r
2091         tcore_pending_set_request_data(pending, 0, atreq);\r
2092         tcore_pending_set_response_callback(pending, on_response_get_xrat, NULL);\r
2093         tcore_pending_link_user_request(pending, ur);\r
2094         tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);\r
2095         tcore_hal_send_request(h, pending);\r
2096         \r
2097         return TCORE_RETURN_SUCCESS;\r
2098 }\r
2099 \r
2100 static TReturn set_preferred_plmn(CoreObject *o, UserRequest *ur)\r
2101 {\r
2102         TcoreHal *h = NULL;\r
2103         TcorePlugin *p = NULL;\r
2104         TcorePending *pending = NULL;\r
2105         TcoreATRequest *atreq = NULL;\r
2106         const struct treq_network_set_preferred_plmn *req_data = NULL;\r
2107         char*cmd_str = NULL;\r
2108         int format = 2; /* Alway use numeric format, as application gives data in this default format */\r
2109         int gsm_act = 0;\r
2110         int gsm_compact_act = 0;\r
2111         int utran_act = 0;\r
2112 \r
2113         if (!o || !ur)\r
2114                 return TCORE_RETURN_EINVAL;\r
2115 \r
2116         req_data = tcore_user_request_ref_data(ur, NULL);\r
2117 \r
2118         dbg("Entry set_preferred_plmn");\r
2119         \r
2120         p = tcore_object_ref_plugin(o);\r
2121         h = tcore_object_get_hal(o);    \r
2122 \r
2123 /*\r
2124 AT+CPOL=\r
2125 [<index>][,<format>[,<oper>[,<GSM_AcT>,\r
2126 <GSM_Compact_AcT>,<UTRAN_AcT>]]]\r
2127  */\r
2128  \r
2129         if((req_data->act == NETWORK_ACT_GSM) || (req_data->act == NETWORK_ACT_GPRS) || (req_data->act == NETWORK_ACT_EGPRS))\r
2130                 gsm_act = TRUE;\r
2131         else if ((req_data->act == NETWORK_ACT_UMTS) || (req_data->act == NETWORK_ACT_UTRAN))\r
2132                 utran_act = TRUE;\r
2133         else if (req_data->act == NETWORK_ACT_GSM_UTRAN)\r
2134                 gsm_act= utran_act = TRUE;\r
2135         \r
2136         cmd_str = g_strdup_printf("AT+CPOL=%d,%d,\"%s\",%d, %d,%d",req_data->ef_index, format, req_data->plmn, gsm_act, gsm_compact_act, utran_act);\r
2137         atreq = tcore_at_request_new(cmd_str, "+CPOL", TCORE_AT_NO_RESULT);\r
2138         \r
2139         tcore_pending_set_request_data(pending, 0, atreq);\r
2140         tcore_pending_set_response_callback(pending, on_response_set_preferred_plmn, NULL);\r
2141         tcore_pending_link_user_request(pending, ur);\r
2142         tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);\r
2143 \r
2144         tcore_hal_send_request(h, pending);\r
2145 \r
2146         dbg("Exit set_preferred_plmn");\r
2147         return TCORE_RETURN_SUCCESS; \r
2148 }\r
2149 \r
2150 static TReturn get_preferred_plmn(CoreObject *o, UserRequest *ur)\r
2151 {\r
2152         \r
2153         TcoreHal *h = NULL;\r
2154         TcorePending *pending = NULL;\r
2155         TcoreATRequest *atreq = NULL;\r
2156 \r
2157         char*cmd_str = NULL;\r
2158 \r
2159         dbg("get_preferred_plmn - ENTER!!");\r
2160 \r
2161         if (!o || !ur)\r
2162                 return TCORE_RETURN_EINVAL;\r
2163 \r
2164         h = tcore_object_get_hal(o);\r
2165         pending = tcore_pending_new(o, 0);\r
2166 \r
2167         cmd_str = g_strdup_printf("AT+CPOL?");\r
2168         atreq = tcore_at_request_new(cmd_str, "+CPOL", TCORE_AT_MULTILINE);\r
2169         \r
2170         tcore_pending_set_request_data(pending, 0, atreq);\r
2171         tcore_pending_set_response_callback(pending, on_response_get_preferred_plmn, NULL);\r
2172         tcore_pending_link_user_request(pending, ur);\r
2173         tcore_pending_set_send_callback(pending, on_confirmation_network_message_send, NULL);\r
2174 \r
2175         tcore_hal_send_request(h, pending);\r
2176 \r
2177         dbg("get_preferred_plmn - EXIT!!");\r
2178 \r
2179         return TCORE_RETURN_SUCCESS;\r
2180 }\r
2181 \r
2182 static TReturn get_serving_network(CoreObject *o, UserRequest *ur)\r
2183 {\r
2184         dbg("get_serving_network - ENTER!!");\r
2185         \r
2186         if (!o)\r
2187                 return TCORE_RETURN_EINVAL;\r
2188 \r
2189         dbg("new pending(AT+COPS?)");\r
2190 \r
2191         nwk_prepare_and_send_pending_request(tcore_object_ref_plugin(o), "umts_network", "AT+COPS=3,2;+COPS?;+COPS=3,0;+COPS?", "+COPS", TCORE_AT_MULTILINE, ur, on_response_get_serving_network);\r
2192         return TCORE_RETURN_SUCCESS;\r
2193 }\r
2194 \r
2195 static struct tcore_network_operations network_ops = {\r
2196                 .search                                 = search_network,\r
2197                 .set_plmn_selection_mode        = set_plmn_selection_mode,\r
2198                 .get_plmn_selection_mode        = get_plmn_selection_mode,\r
2199                 .set_service_domain             = NULL,\r
2200                 .get_service_domain             = NULL,\r
2201                 .set_band                               = set_band,\r
2202                 .get_band                               = get_band,\r
2203                 .set_preferred_plmn             = set_preferred_plmn,\r
2204                 .get_preferred_plmn             = get_preferred_plmn,\r
2205                 .set_order                              = NULL,\r
2206                 .get_order                              = NULL,\r
2207                 .set_power_on_attach            = NULL,\r
2208                 .get_power_on_attach            = NULL,\r
2209                 .set_cancel_manual_search       = NULL,\r
2210                 .get_serving_network            = get_serving_network,\r
2211 };\r
2212 \r
2213 gboolean s_network_init(TcorePlugin *p, TcoreHal *h)\r
2214 {\r
2215         CoreObject *o = NULL;\r
2216 \r
2217         o = tcore_network_new(p, "umts_network", &network_ops, h);\r
2218         if (!o)\r
2219                 return FALSE;\r
2220 \r
2221         tcore_object_add_callback(o,"+CREG", on_event_cs_network_regist, NULL);\r
2222         tcore_object_add_callback(o,"+CGREG", on_event_ps_network_regist, NULL);\r
2223         tcore_object_add_callback(o, "+XCIEV", on_event_network_icon_info, NULL);\r
2224 \r
2225         /* +CTZV: <tz>,<time> */\r
2226         tcore_object_add_callback(o, "+CTZV", on_event_network_ctzv_time_info, NULL);\r
2227         /* +CTZDST: <dst> */ \r
2228         tcore_object_add_callback(o, "+CTZDST", on_event_network_ds_time_info, NULL);\r
2229 \r
2230         tcore_server_add_notification_hook(tcore_plugin_ref_server(p), TNOTI_SIM_STATUS, on_hook_sim_init, o);\r
2231 \r
2232         _insert_mcc_mnc_oper_list(p, o);\r
2233 \r
2234         return TRUE;\r
2235 }\r
2236 \r
2237 void s_network_exit(TcorePlugin *p)\r
2238 {\r
2239         CoreObject *o;\r
2240 \r
2241         o = tcore_plugin_ref_core_object(p, "umts_network");\r
2242 \r
2243         tcore_network_free(o);\r
2244 }\r