src/s_network.c

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