lbs-server/src/server.c

   1 /*
   2  * lbs-server
   3  *
   4  * Copyright (c) 2011-2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Youngae Kang <youngae.kang@samsung.com>, Minjune Kim <sena06.kim@samsung.com>
   7  *          Genie Kim <daejins.kim@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  */
  21
  22 #include <stdio.h>
  23 #include <signal.h>
  24 #include <stdlib.h>
  25
  26 #include <unistd.h>
  27 #include <sys/types.h>
  28 #include <sys/wait.h>
  29 #include <fcntl.h>
  30 #include <errno.h>
  31 #include <pthread.h>
  32 #include <string.h>
  33
  34 #include "server.h"
  35 #include "gps_plugin_data_types.h"
  36 #include "gps_plugin_intf.h"
  37 #include "nmea_logger.h"
  38 #include "data_connection.h"
  39 #include "setting.h"
  40 #include "gps_plugin_module.h"
  41 #include "debug_util.h"
  42 #include "last_position.h"
  43 #include "dump_log.h"
  44
  45 #include "nps_plugin_module.h"
  46 #include "nps_plugin_intf.h"
  47
  48 #ifdef _TIZEN_PUBLIC_
  49 #include <msg.h>
  50 #include <msg_transport.h>
  51 #include <pmapi.h>
  52 #endif
  53
  54 #include <vconf.h>
  55 #include <vconf-keys.h>
  56 #include <dlog.h>
  57
  58 #include <glib.h>
  59 #include <glib-object.h>
  60 #if !GLIB_CHECK_VERSION (2, 31, 0)
  61 #include <glib/gthread.h>
  62 #endif
  63
  64 #define REPLAY_MODULE   "replay"
  65
  66 #define PLATFORM_PATH   "/sys/devices/platform"
  67 #define BRCM4752_PATH   PLATFORM_PATH"/bcm4752"
  68 #define BRCM47520_PATH  PLATFORM_PATH"/bcm47520"
  69 #define BRCM47511_PATH  PLATFORM_PATH"/bcm47511"
  70 #define BRCM47522_PATH  PLATFORM_PATH"/bcm47522"
  71 #define CSR_PATH                PLATFORM_PATH"/gsd4t"
  72 #define QCOM8210_PATH   PLATFORM_PATH"/msm8210_gps"
  73 #define QCOM8x30_PATH   PLATFORM_PATH"/msm8x30_gps"
  74 #define QCOM9x15_PATH   PLATFORM_PATH"/msm9x15_gps"
  75 #define QCOM8974_PATH   PLATFORM_PATH"/msm8974_gps"
  76 #define QCOM8226_PATH   PLATFORM_PATH"/msm8226_gps"
  77 #define QCOM8916_PATH   PLATFORM_PATH"/msm8916_gps"
  78
  79 #define MPS_TO_KMPH             3.6             /* 1 m/s = 3.6 km/h */
  80
  81 struct gps_callbacks g_update_cb;
  82 void *g_user_data;
  83
  84 typedef struct {
  85         void *handle;
  86         char *name;
  87 } gps_plugin_handler_t;
  88
  89 typedef struct {
  90         void *handle;
  91 } nps_plugin_handler_t;
  92
  93 typedef struct {
  94         gps_session_state_t session_state;
  95         int dnet_used;
  96         gboolean logging_enabled;
  97         gboolean replay_enabled;
  98
  99 #ifdef _TIZEN_PUBLIC_
 100         pthread_t msg_thread;   /* Register SUPL NI cb to msg server Thread */
 101         pthread_t popup_thread; /* Register SUPL NI cb to msg server Thread */
 102         int msg_thread_status;
 103 #endif
 104
 105         gps_plugin_handler_t gps_plugin;
 106
 107         pos_data_t *pos_data;
 108         batch_data_t *batch_data;
 109         sv_data_t *sv_data;
 110         nmea_data_t *nmea_data;
 111 } gps_server_t;
 112
 113 gps_server_t *g_gps_server = NULL;
 114
 115 nps_plugin_handler_t g_nps_plugin;
 116
 117 static void __nps_plugin_handler_deinit(void)
 118 {
 119         if (g_nps_plugin.handle != NULL) {
 120                 g_nps_plugin.handle = NULL;
 121         }
 122 }
 123
 124 static int _gps_server_gps_event_cb(gps_event_info_t *gps_event_info, void *user_data);
 125
 126 static void _gps_nmea_changed_cb(keynode_t *key, void *data)
 127 {
 128         gps_server_t *server = (gps_server_t *)data;
 129         int int_val;
 130         if (setting_get_int(VCONFKEY_LOCATION_NMEA_LOGGING, &int_val) == FALSE) {
 131                 LOG_GPS(DBG_ERR, "//ERROR!! get VCONFKEY_LOCATION_NMEA_LOGGING setting");
 132                 int_val = 0;
 133         }
 134         server->logging_enabled = (int_val == 1) ? TRUE : FALSE;
 135         return;
 136 }
 137
 138 static gboolean get_replay_enabled()
 139 {
 140         int int_val;
 141         gboolean ret;
 142
 143         if (setting_get_int(VCONFKEY_LOCATION_REPLAY_ENABLED, &int_val) == FALSE) {
 144                 LOG_GPS(DBG_ERR, "//ERROR get VCONFKEY_LOCATION_REPLAY_ENABLED setting");
 145                 int_val = 0;
 146         }
 147
 148         ret = (int_val == 1) ? TRUE : FALSE;
 149
 150         return ret;
 151 }
 152
 153 static void reload_plugin_module(gps_server_t *server)
 154 {
 155         char *module_name;
 156         gps_failure_reason_t ReasonCode = GPS_FAILURE_CAUSE_NORMAL;
 157
 158         if (server->replay_enabled == TRUE) {
 159                 module_name = REPLAY_MODULE;
 160         } else {
 161                 module_name = server->gps_plugin.name;
 162         }
 163
 164         LOG_GPS(DBG_LOW, "replay_enabled:%d, Loading plugin.name: %s", server->replay_enabled, module_name);
 165
 166         if (!get_plugin_module()->deinit(&ReasonCode)) {
 167                 LOG_GPS(DBG_ERR, "Fail to GPS plugin deinit");
 168         } else {
 169                 unload_plugin_module(&server->gps_plugin.handle);
 170                 if (!load_plugin_module(module_name, &server->gps_plugin.handle)) {
 171                         LOG_GPS(DBG_ERR, "Fail to load %s plugin", module_name);
 172                 } else {
 173                         if (!get_plugin_module()->init(_gps_server_gps_event_cb, (void *)server)) {
 174                                 LOG_GPS(DBG_ERR, "Fail to %s plugin init", module_name);
 175                                 return;
 176                         }
 177                 }
 178         }
 179 }
 180
 181 static void _gps_replay_changed_cb(keynode_t *key, void *data)
 182 {
 183         gps_server_t *server = (gps_server_t *)data;
 184         server->replay_enabled = get_replay_enabled();
 185         reload_plugin_module(server);
 186
 187         return;
 188 }
 189
 190 static int _gps_server_get_gps_state()
 191 {
 192         int val;
 193
 194         if (setting_get_int(VCONFKEY_LOCATION_GPS_STATE, &val) == FALSE) {
 195                 val = POSITION_OFF;
 196         }
 197
 198         return val;
 199 }
 200
 201 static void _gps_server_set_gps_state(int gps_state)
 202 {
 203         int ret;
 204
 205         switch (gps_state) {
 206                 case POSITION_CONNECTED:
 207                         ret = setting_set_int(VCONFKEY_LOCATION_GPS_STATE, POSITION_CONNECTED);
 208                         gps_dump_log("GPS state : POSITION_CONNECTED", NULL);
 209                         break;
 210                 case POSITION_SEARCHING:
 211                         ret = setting_set_int(VCONFKEY_LOCATION_GPS_STATE, POSITION_SEARCHING);
 212                         gps_dump_log("GPS state : POSITION_SEARCHING", NULL);
 213                         break;
 214                 case POSITION_OFF:
 215                         ret = setting_set_int(VCONFKEY_LOCATION_GPS_STATE, POSITION_OFF);
 216                         gps_dump_log("GPS state : POSITION_OFF", NULL);
 217                         break;
 218                 default:
 219                         ret = setting_set_int(VCONFKEY_LOCATION_GPS_STATE, POSITION_OFF);
 220                         break;
 221         }
 222
 223         if (ret == TRUE) {
 224                 LOG_GPS(DBG_LOW, "Succeed to set VCONFKEY_LOCATION_GPS_STATE");
 225         } else {
 226                 LOG_GPS(DBG_ERR, "Fail to set VCONF_LOCATION_GPS_STATE");
 227         }
 228 }
 229
 230 int request_change_pos_update_interval_standalone_gps(unsigned int interval)
 231 {
 232         LOG_GPS(DBG_INFO, "request_change_pos_update_interval_standalone_gps. interval[%u]", interval);
 233         gboolean status = TRUE;
 234         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 235         gps_server_t *server = g_gps_server;
 236
 237         if (server->session_state == GPS_SESSION_STARTING || server->session_state == GPS_SESSION_STARTED) {
 238                 gps_action_change_interval_data_t gps_change_interval_data;
 239                 gps_change_interval_data.interval = (int)interval;
 240                 status = get_plugin_module()->request(GPS_ACTION_CHANGE_INTERVAL, &gps_change_interval_data, &reason_code);
 241                 LOG_GPS(DBG_INFO, "requested go GPS module done. gps_change_interval_data.interval [%d]", gps_change_interval_data.interval);
 242
 243                 if (status == FALSE) {
 244                         LOG_GPS(DBG_ERR, "Main: sending GPS_ACTION_CHANGE_INTERVAL Fail !");
 245                         return FALSE;
 246                 }
 247                 LOG_GPS(DBG_INFO, "Main: sending GPS_ACTION_CHANGE_INTERVAL OK !");
 248                 return TRUE;
 249         }
 250         return FALSE;
 251 }
 252
 253 int request_start_session(int interval)
 254 {
 255         LOG_GPS(DBG_INFO, "GPS start with interval [%d]", interval);
 256
 257         gboolean status = TRUE;
 258         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 259         gps_server_t *server = g_gps_server;
 260         gps_action_start_data_t gps_start_data;
 261
 262         if (server->session_state != GPS_SESSION_STOPPED && server->session_state != GPS_SESSION_STOPPING) {
 263                 LOG_GPS(DBG_WARN, "Main: GPS Session Already Started!");
 264                 return TRUE;
 265         }
 266
 267         server->session_state = GPS_SESSION_STARTING;
 268         LOG_GPS(DBG_LOW, "==GPSSessionState[%d]", server->session_state);
 269         gps_start_data.interval = interval;
 270         status = get_plugin_module()->request(GPS_ACTION_START_SESSION, &gps_start_data, &reason_code);
 271
 272         if (status == FALSE) {
 273                 LOG_GPS(DBG_ERR, "Main: sending GPS_ACTION_START_SESSION Fail !");
 274                 return FALSE;
 275         }
 276
 277         LOG_GPS(DBG_INFO, "Main: sending GPS_ACTION_START_SESSION OK !");
 278
 279         setting_ignore_key_changed(VCONFKEY_LOCATION_REPLAY_ENABLED, _gps_replay_changed_cb);
 280
 281         return TRUE;
 282 }
 283
 284 int request_stop_session()
 285 {
 286         gboolean status = TRUE;
 287         gboolean cur_replay_enabled = FALSE;
 288         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 289         gps_server_t *server = g_gps_server;
 290
 291         LOG_GPS(DBG_LOW, "Main: Stop GPS Session, ==GPSSessionState[%d]", server->session_state);
 292         if (server->session_state == GPS_SESSION_STARTED || server->session_state == GPS_SESSION_STARTING) {
 293                 status = get_plugin_module()->request(GPS_ACTION_STOP_SESSION, NULL, &reason_code);
 294                 if (status) {
 295                         server->session_state = GPS_SESSION_STOPPING;
 296                         LOG_GPS(DBG_LOW, "==GPSSessionState[%d]", server->session_state);
 297                         cur_replay_enabled = get_replay_enabled();
 298                         if (server->replay_enabled != cur_replay_enabled) {
 299                                 server->replay_enabled = cur_replay_enabled;
 300                                 reload_plugin_module(server);
 301                         }
 302                         setting_notify_key_changed(VCONFKEY_LOCATION_REPLAY_ENABLED, _gps_replay_changed_cb, (void *)server);
 303                 } else {
 304                         LOG_GPS(DBG_ERR, "plugin->request to LBS_GPS_STOP_SESSION Failed, reasonCode =%d", reason_code);
 305                 }
 306         } else {
 307                 /* If request is not sent, keep the client registed */
 308                 LOG_GPS(DBG_LOW, "LBS_GPS_STOP_SESSION is not sent because the GPS state is not started, keep the client registed");
 309         }
 310         return status;
 311 }
 312
 313 int request_start_batch_session(int batch_interval, int batch_period)
 314 {
 315         LOG_GPS(DBG_INFO, "Batch: GPS start with interval[%d]", batch_interval);
 316
 317         gboolean status = TRUE;
 318         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 319         gps_server_t *server = g_gps_server;
 320         gps_action_start_data_t gps_start_data;
 321
 322         if (server->session_state != GPS_SESSION_STOPPED && server->session_state != GPS_SESSION_STOPPING) {
 323                 LOG_GPS(DBG_WARN, "Batch: GPS Session Already Started!");
 324                 return TRUE;
 325         }
 326
 327         server->session_state = GPS_SESSION_STARTING;
 328         LOG_GPS(DBG_LOW, "==GPSSessionState[%d]", server->session_state);
 329         gps_start_data.interval = batch_interval;
 330         gps_start_data.period = batch_period;
 331         status = get_plugin_module()->request(GPS_ACTION_START_BATCH, &gps_start_data, &reason_code);
 332
 333         if (status == FALSE) {
 334                 LOG_GPS(DBG_ERR, "Batch: sending GPS_ACTION_START_SESSION Fail !");
 335                 return FALSE;
 336         }
 337
 338         LOG_GPS(DBG_INFO, "Batch: sending GPS_ACTION_START_SESSION OK !");
 339
 340         setting_ignore_key_changed(VCONFKEY_LOCATION_REPLAY_ENABLED, _gps_replay_changed_cb);
 341
 342         return TRUE;
 343 }
 344
 345 int request_stop_batch_session()
 346 {
 347         gboolean status = TRUE;
 348         gboolean cur_replay_enabled = FALSE;
 349         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 350         gps_server_t *server = g_gps_server;
 351
 352         LOG_GPS(DBG_LOW, "Batch: Stop GPS Session, ==GPSSessionState[%d]", server->session_state);
 353         if (server->session_state == GPS_SESSION_STARTED || server->session_state == GPS_SESSION_STARTING) {
 354                 status = get_plugin_module()->request(GPS_ACTION_STOP_BATCH, NULL, &reason_code);
 355                 if (status) {
 356                         server->session_state = GPS_SESSION_STOPPING;
 357                         LOG_GPS(DBG_LOW, "==GPSSessionState[%d]", server->session_state);
 358                         cur_replay_enabled = get_replay_enabled();
 359                         if (server->replay_enabled != cur_replay_enabled) {
 360                                 server->replay_enabled = cur_replay_enabled;
 361                                 reload_plugin_module(server);
 362                         }
 363                         setting_notify_key_changed(VCONFKEY_LOCATION_REPLAY_ENABLED, _gps_replay_changed_cb, (void *)server);
 364                 } else {
 365                         LOG_GPS(DBG_ERR, "plugin->request to LBS_GPS_STOP_SESSION Failed, reasonCode =%d", reason_code);
 366                 }
 367         } else {
 368                 /* If request is not sent, keep the client registed */
 369                 LOG_GPS(DBG_LOW, " LBS_GPS_STOP_SESSION is not sent because the GPS state is not started, keep the client registed ");
 370         }
 371         return status;
 372 }
 373
 374 int request_add_geofence(int fence_id, double latitude, double longitude, int radius, int last_state, int monitor_states, int notification_responsiveness, int unknown_timer)
 375 {
 376         gboolean status = FALSE;
 377         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 378         geofence_action_data_t action_data;
 379
 380         action_data.geofence.geofence_id = fence_id;
 381         action_data.geofence.latitude = latitude;
 382         action_data.geofence.longitude = longitude;
 383         action_data.geofence.radius = radius;
 384         action_data.last_state = last_state;
 385         action_data.monitor_states = monitor_states;
 386         /* Default value : temp */
 387         action_data.notification_responsiveness_ms = 5000;
 388         action_data.unknown_timer_ms = 30000;
 389         /*action_data.notification_responsiveness_ms = notification_responsiveness; */
 390         /*action_data.unknown_timer_ms = unknown_timer; */
 391
 392         LOG_GPS(DBG_LOW, "request_add_geofence with geofence_id [%d]", fence_id);
 393         status = get_plugin_module()->request(GPS_ACTION_ADD_GEOFENCE, &action_data, &reason_code);
 394
 395         return status;
 396 }
 397
 398 int request_delete_geofence(int fence_id)
 399 {
 400         gboolean status = FALSE;
 401         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 402
 403         LOG_GPS(DBG_LOW, "request_delete_geofence with geofence_id [%d]", fence_id);
 404         status = get_plugin_module()->request(GPS_ACTION_DELETE_GEOFENCE, &fence_id, &reason_code);
 405
 406         return status;
 407 }
 408
 409 int request_pause_geofence(int fence_id)
 410 {
 411         gboolean status = FALSE;
 412         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 413
 414         LOG_GPS(DBG_LOW, "request_pause_geofence with geofence_id [%d]", fence_id);
 415         status = get_plugin_module()->request(GPS_ACTION_PAUSE_GEOFENCE, &fence_id, &reason_code);
 416
 417         return status;
 418 }
 419
 420 int request_resume_geofence(int fence_id, int monitor_states)
 421 {
 422         gboolean status = FALSE;
 423         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 424         geofence_action_data_t action_data;
 425
 426         action_data.geofence.geofence_id = fence_id;
 427         action_data.monitor_states = monitor_states;
 428
 429         LOG_GPS(DBG_LOW, "request_resume_geofence with geofence_id [%d]", fence_id);
 430         status = get_plugin_module()->request(GPS_ACTION_RESUME_GEOFENCE, &action_data, &reason_code);
 431
 432         return status;
 433 }
 434
 435 int request_delete_gps_data()
 436 {
 437         gboolean status = TRUE;
 438         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 439
 440         status = get_plugin_module()->request(GPS_ACTION_DELETE_GPS_DATA, NULL, &reason_code);
 441
 442         if (status == FALSE) {
 443                 LOG_GPS(DBG_ERR, "Fail : GPS_ACTION_DELETE_GPS_DATA [%d]", reason_code);
 444                 return FALSE;
 445         }
 446
 447         LOG_GPS(DBG_LOW, "Success to GPS_ACTION_DELETE_GPS_DATA");
 448         return TRUE;
 449 }
 450
 451 int get_nmea_from_server(int *timestamp, char **nmea_data)
 452 {
 453         LOG_GPS(DBG_INFO, "ENTER >>>");
 454
 455         gps_server_t *server = g_gps_server;
 456
 457         if (server->session_state == GPS_SESSION_STARTING || server->session_state == GPS_SESSION_STARTED) {
 458                 *timestamp = (int) server->nmea_data->timestamp;
 459                 *nmea_data = g_strndup(server->nmea_data->data, server->nmea_data->len);
 460         }
 461         LOG_GPS(DBG_LOW, "=== timestmap: %d, nmea_data: %s", *timestamp, *nmea_data);
 462         return TRUE;
 463 }
 464
 465 static void _gps_plugin_handler_init(gps_server_t *server, char *module_name)
 466 {
 467         if (module_name == NULL) {
 468                 LOG_GPS(DBG_ERR, "Fail : module_name is NULL");
 469                 return;
 470         }
 471
 472         server->gps_plugin.handle = NULL;
 473         server->gps_plugin.name = (char *)malloc(strlen(module_name) + 1);
 474         g_return_if_fail(server->gps_plugin.name);
 475
 476         g_strlcpy(server->gps_plugin.name, module_name, strlen(module_name) + 1);
 477 }
 478
 479 static void _gps_plugin_handler_deinit(gps_server_t *server)
 480 {
 481         if (server->gps_plugin.handle != NULL) {
 482                 server->gps_plugin.handle = NULL;
 483         }
 484
 485         if (server->gps_plugin.name != NULL) {
 486                 free(server->gps_plugin.name);
 487                 server->gps_plugin.name = NULL;
 488         }
 489 }
 490
 491 static void _gps_get_nmea_replay_mode(gps_server_t *server)
 492 {
 493         int int_val = 0;
 494
 495         if (setting_get_int(VCONFKEY_LOCATION_NMEA_LOGGING, &int_val) == FALSE) {
 496                 LOG_GPS(DBG_ERR, "//ERROR!! get VCONFKEY_LOCATION_NMEA_LOGGING setting");
 497                 int_val = 0;
 498         }
 499         server->logging_enabled = (int_val == 1) ? TRUE : FALSE;
 500
 501         if (setting_get_int(VCONFKEY_LOCATION_REPLAY_ENABLED, &int_val) == FALSE) {
 502                 LOG_GPS(DBG_ERR, "//ERROR!! get VCONFKEY_LOCATION_REPLAY_ENABLED setting");
 503                 int_val = 0;
 504         }
 505         server->replay_enabled = (int_val == 1) ? TRUE : FALSE;
 506 }
 507
 508 static void _gps_notify_params(gps_server_t *server)
 509 {
 510         setting_notify_key_changed(VCONFKEY_LOCATION_NMEA_LOGGING, _gps_nmea_changed_cb, (void *)server);
 511         setting_notify_key_changed(VCONFKEY_LOCATION_REPLAY_ENABLED, _gps_replay_changed_cb, (void *)server);
 512 }
 513
 514 static void _gps_ignore_params()
 515 {
 516         setting_ignore_key_changed(VCONFKEY_LOCATION_NMEA_LOGGING, _gps_nmea_changed_cb);
 517         setting_ignore_key_changed(VCONFKEY_LOCATION_REPLAY_ENABLED, _gps_replay_changed_cb);
 518 }
 519
 520 static void _gps_server_start_event(gps_server_t *server)
 521 {
 522         LOG_GPS(DBG_LOW, "==GPSSessionState [%d] -> [%d]", server->session_state, GPS_SESSION_STARTED);
 523         server->session_state = GPS_SESSION_STARTED;
 524
 525         if (server->logging_enabled) {
 526                 LOG_GPS(DBG_LOW, "NMEA STARTED");
 527                 start_nmea_log();
 528         }
 529
 530         if (server->pos_data == NULL) {
 531                 server->pos_data = (pos_data_t *) malloc(sizeof(pos_data_t));
 532                 if (server->pos_data == NULL) {
 533                         LOG_GPS(DBG_WARN, "//callback: server->pos_data re-malloc Failed!!");
 534                 } else {
 535                         memset(server->pos_data, 0x00, sizeof(pos_data_t));
 536                 }
 537         }
 538         if (server->batch_data == NULL) {
 539                 server->batch_data = (batch_data_t *) malloc(sizeof(batch_data_t));
 540                 if (server->batch_data == NULL) {
 541                         LOG_GPS(DBG_WARN, "//callback: server->batch_data re-malloc Failed!!");
 542                 } else {
 543                         memset(server->batch_data, 0x00, sizeof(batch_data_t));
 544                 }
 545         }
 546         if (server->sv_data == NULL) {
 547                 server->sv_data = (sv_data_t *) malloc(sizeof(sv_data_t));
 548                 if (server->sv_data == NULL) {
 549                         LOG_GPS(DBG_WARN, "//callback: server->sv_data re-malloc Failed!!");
 550                 } else {
 551                         memset(server->sv_data, 0x00, sizeof(sv_data_t));
 552                 }
 553         }
 554         if (server->nmea_data == NULL) {
 555                 server->nmea_data = (nmea_data_t *) malloc(sizeof(nmea_data_t));
 556                 if (server->nmea_data == NULL) {
 557                         LOG_GPS(DBG_WARN, "//callback: server->nmea_data re-malloc Failed!!");
 558                 } else {
 559                         memset(server->nmea_data, 0x00, sizeof(nmea_data_t));
 560                 }
 561         }
 562
 563         _gps_server_set_gps_state(POSITION_SEARCHING);
 564 #ifdef _TIZEN_PUBLIC_
 565         pm_lock_state(LCD_OFF, STAY_CUR_STATE, 0);
 566 #endif
 567 }
 568
 569 static void _gps_server_stop_event(gps_server_t *server)
 570 {
 571         LOG_GPS(DBG_LOW, "==GPSSessionState [%d] -> [%d]", server->session_state, GPS_SESSION_STOPPED);
 572         server->session_state = GPS_SESSION_STOPPED;
 573
 574         _gps_server_set_gps_state(POSITION_OFF);
 575 #ifdef _TIZEN_PUBLIC_
 576         pm_unlock_state(LCD_OFF, PM_RESET_TIMER);
 577 #endif
 578
 579         if (server->logging_enabled) {
 580                 LOG_GPS(DBG_LOW, "NMEA STOPPED");
 581                 stop_nmea_log();
 582         }
 583 }
 584
 585 static void _report_pos_event(gps_server_t *server, gps_event_info_t *gps_event)
 586 {
 587         if (server->pos_data != NULL) {
 588                 memset(server->pos_data, 0x00, sizeof(pos_data_t)); /* Moved: the address of server->pos_data sometimes returns 0 when stopping GPS */
 589                 memcpy(server->pos_data, &(gps_event->event_data.pos_ind.pos), sizeof(pos_data_t));
 590                 /* change m/s to km/h */
 591                 server->pos_data->speed = server->pos_data->speed * MPS_TO_KMPH;
 592                 gps_set_position(server->pos_data);
 593                 g_update_cb.pos_cb(server->pos_data, gps_event->event_data.pos_ind.error, g_user_data);
 594         } else {
 595                 LOG_GPS(DBG_ERR, "server->pos_data is NULL");
 596         }
 597 }
 598
 599 static void _report_batch_event(gps_server_t *server, gps_event_info_t *gps_event)
 600 {
 601         if (server->batch_data != NULL) {
 602                 memset(server->batch_data, 0x00, sizeof(batch_data_t));
 603                 memcpy(server->batch_data, &(gps_event->event_data.batch_ind.batch), sizeof(batch_data_t));
 604                 g_update_cb.batch_cb(server->batch_data, g_user_data);
 605         } else {
 606                 LOG_GPS(DBG_ERR, "server->batch_data is NULL");
 607         }
 608 }
 609
 610 static void _report_sv_event(gps_server_t *server, gps_event_info_t *gps_event)
 611 {
 612         if (server->sv_data != NULL) {
 613                 memset(server->sv_data, 0x00, sizeof(sv_data_t));
 614                 memcpy(server->sv_data, &(gps_event->event_data.sv_ind.sv), sizeof(sv_data_t));
 615                 g_update_cb.sv_cb(server->sv_data, g_user_data);
 616         } else {
 617                 LOG_GPS(DBG_ERR, "server->sv_data is NULL");
 618         }
 619 }
 620
 621 static void _report_nmea_event(gps_server_t *server, gps_event_info_t *gps_event)
 622 {
 623         if (server->nmea_data == NULL) {
 624                 LOG_GPS(DBG_ERR, "server->nmea_data is NULL");
 625                 return;
 626         }
 627
 628         if (server->nmea_data->data) {
 629                 free(server->nmea_data->data);
 630                 server->nmea_data->data = NULL;
 631         }
 632
 633         /*LOG_GPS(DBG_LOW, "server->nmea_data->len : [%d]", gps_event->event_data.nmea_ind.nmea.len); */
 634         server->nmea_data->len = gps_event->event_data.nmea_ind.nmea.len;
 635         server->nmea_data->data = (char *)malloc(server->nmea_data->len);
 636         if (server->nmea_data->data == NULL) {
 637                 LOG_GPS(DBG_ERR, "Fail to malloc of server->nmea_data->data");
 638                 return;
 639         }
 640         memset(server->nmea_data->data, 0x00, server->nmea_data->len);
 641         memcpy(server->nmea_data->data, gps_event->event_data.nmea_ind.nmea.data, server->nmea_data->len);
 642         g_update_cb.nmea_cb(server->nmea_data, g_user_data);
 643
 644         if (server->logging_enabled) {
 645                 int nmea_len;
 646                 char *p_nmea_data;
 647                 nmea_len = gps_event->event_data.nmea_ind.nmea.len;
 648                 p_nmea_data = gps_event->event_data.nmea_ind.nmea.data;
 649                 write_nmea_log(p_nmea_data, nmea_len);
 650         }
 651 }
 652
 653 static int _gps_server_open_data_connection(gps_server_t *server)
 654 {
 655         LOG_GPS(DBG_LOW, "Enter _gps_server_open_data_connection");
 656
 657         server->dnet_used++;
 658
 659         if (server->dnet_used > 1) {
 660                 LOG_GPS(DBG_LOW, "dnet_used : count[ %d ]", server->dnet_used);
 661                 return TRUE;
 662         } else {
 663                 LOG_GPS(DBG_LOW, "First open the data connection");
 664         }
 665
 666         unsigned char result;
 667
 668         result = start_pdp_connection();
 669
 670         if (result == TRUE) {
 671                 LOG_GPS(DBG_LOW, "//Open PDP Conn for SUPL Success.");
 672         } else {
 673                 LOG_GPS(DBG_ERR, "//Open PDP Conn for SUPL Fail.");
 674                 return FALSE;
 675         }
 676         return TRUE;
 677 }
 678
 679 static int _gps_server_close_data_connection(gps_server_t *server)
 680 {
 681         LOG_GPS(DBG_LOW, "Enter _gps_server_close_data_connection");
 682
 683         if (server->dnet_used > 0) {
 684                 server->dnet_used--;
 685         }
 686
 687         if (server->dnet_used != 0) {
 688                 LOG_GPS(DBG_LOW, "Cannot stop the data connection! [ dnet_used : %d ]", server->dnet_used);
 689                 return TRUE;
 690         } else {
 691                 LOG_GPS(DBG_LOW, "Close the data connection");
 692         }
 693
 694         unsigned char result;
 695
 696         result = stop_pdp_connection();
 697         if (result == TRUE) {
 698                 LOG_GPS(DBG_LOW, "Close PDP Conn for SUPL Success.");
 699         } else {
 700                 LOG_GPS(DBG_ERR, "//Close PDP Conn for SUPL Fail.");
 701                 return FALSE;
 702         }
 703
 704         return TRUE;
 705 }
 706
 707 static int _gps_server_resolve_dns(char *domain)
 708 {
 709         LOG_GPS(DBG_LOW, "Enter _gps_server_resolve_dns");
 710
 711         unsigned char result;
 712         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 713         unsigned int ipaddr;
 714         int port;
 715
 716         result = query_dns(domain, &ipaddr, &port);
 717         if (result == TRUE) {
 718                 LOG_GPS(DBG_LOW, "Success to resolve domain name [ %s ] / ipaddr [ %u ]", domain, ipaddr);
 719                 get_plugin_module()->request(GPS_INDI_SUPL_DNSQUERY, (void *)(&ipaddr), &reason_code);
 720         } else {
 721                 ipaddr = 0;
 722                 LOG_GPS(DBG_ERR, "Fail to resolve domain name [ %s ] / ipaddr [ %u ]", domain, ipaddr);
 723                 get_plugin_module()->request(GPS_INDI_SUPL_DNSQUERY, (void *)(&ipaddr), &reason_code);
 724                 return FALSE;
 725         }
 726
 727         return TRUE;
 728 }
 729
 730 static void _gps_server_send_facttest_result(double snr_data, int prn, unsigned short result)
 731 {
 732 }
 733
 734 static void _report_geofence_transition(int geofence_id, geofence_zone_state_t transition, double latitude, double longitude, double altitude, double speed, double bearing, double hor_accuracy)
 735 {
 736         gps_update_geofence_transition(geofence_id, transition, latitude, longitude, altitude, speed, bearing, hor_accuracy, (void *)g_user_data);
 737 }
 738
 739 static void _report_geofence_service_status(int status)
 740 {
 741         gps_update_geofence_service_status(status, (void *)g_user_data);
 742 }
 743
 744 static void _gps_server_send_geofence_result(geofence_event_e event, int geofence_id, int result)
 745 {
 746         if (result != 0) {
 747                 LOG_GPS(DBG_ERR, "result is [%d]", result);
 748                 return;
 749         }
 750
 751         switch (event) {
 752                 case GEOFENCE_ADD_FENCE:
 753                         LOG_GPS(DBG_LOW, "Geofence ID[%d], Success ADD_GEOFENCE", geofence_id);
 754                         break;
 755                 case GEOFENCE_DELETE_FENCE:
 756                         LOG_GPS(DBG_LOW, "Geofence ID[%d], Success DELETE_GEOFENCE", geofence_id);
 757                         break;
 758                 case GEOFENCE_PAUSE_FENCE:
 759                         LOG_GPS(DBG_LOW, "Geofence ID[%d], Success PAUSE_GEOFENCE", geofence_id);
 760                         break;
 761                 case GEOFENCE_RESUME_FENCE:
 762                         LOG_GPS(DBG_LOW, "Geofence ID[%d], Success RESUME_GEOFENCE", geofence_id);
 763                         break;
 764                 default:
 765                         break;
 766         }
 767 }
 768
 769 static int _gps_server_gps_event_cb(gps_event_info_t *gps_event_info, void *user_data)
 770 {
 771         /*FUNC_ENTRANCE_SERVER; */
 772         gps_server_t *server = (gps_server_t *)user_data;
 773         int result = TRUE;
 774         if (gps_event_info == NULL) {
 775                 LOG_GPS(DBG_WARN, "//NULL pointer variable passed");
 776                 return result;
 777         }
 778
 779         switch (gps_event_info->event_id) {
 780                 case GPS_EVENT_START_SESSION:
 781                         LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_START_SESSION :::::::::::::::");
 782                         if (gps_event_info->event_data.start_session_rsp.error == GPS_ERR_NONE) {
 783                                 _gps_server_start_event(server);
 784                         } else {
 785                                 LOG_GPS(DBG_ERR, "//Start Session Failed, error : %d",
 786                                                 gps_event_info->event_data.start_session_rsp.error);
 787                         }
 788                         break;
 789                 case GPS_EVENT_SET_OPTION: {
 790                                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_SET_OPTION :::::::::::::::");
 791                                 if (gps_event_info->event_data.set_option_rsp.error != GPS_ERR_NONE) {
 792                                         LOG_GPS(DBG_ERR, "//Set Option Failed, error : %d",
 793                                                         gps_event_info->event_data.set_option_rsp.error);
 794                                 }
 795                         }
 796                         break;
 797
 798                 case GPS_EVENT_STOP_SESSION:
 799                         LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_STOP_SESSION :::::::::::::::");
 800                         if (gps_event_info->event_data.stop_session_rsp.error == GPS_ERR_NONE) {
 801                                 _gps_server_close_data_connection(server);
 802                                 _gps_server_stop_event(server);
 803                         } else {
 804                                 LOG_GPS(DBG_ERR, "//Stop Session Failed, error : %d",
 805                                                 gps_event_info->event_data.stop_session_rsp.error);
 806                         }
 807
 808                         break;
 809                 case GPS_EVENT_CHANGE_INTERVAL:
 810                         LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_CHANGE_INTERVAL :::::::::::::::");
 811                         if (gps_event_info->event_data.change_interval_rsp.error == GPS_ERR_NONE) {
 812                                 LOG_GPS(DBG_LOW, "Change interval success.");
 813                         } else {
 814                                 LOG_GPS(DBG_ERR, "//Change interval Failed, error : %d",
 815                                                 gps_event_info->event_data.change_interval_rsp.error);
 816                         }
 817                         break;
 818                 case GPS_EVENT_REPORT_POSITION:
 819                         LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_POSITION :::::::::::::::");
 820                         if (gps_event_info->event_data.pos_ind.error == GPS_ERR_NONE) {
 821                                 _report_pos_event(server, gps_event_info);
 822                         } else {
 823                                 LOG_GPS(DBG_ERR, "GPS_EVENT_POSITION Failed, error : %d", gps_event_info->event_data.pos_ind.error);
 824                         }
 825                         break;
 826                 case GPS_EVENT_REPORT_BATCH:
 827                         LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_BATCH :::::::::::::::");
 828                         if (gps_event_info->event_data.batch_ind.error == GPS_ERR_NONE) {
 829                                 _report_batch_event(server, gps_event_info);
 830                         } else {
 831                                 LOG_GPS(DBG_ERR, "GPS_EVENT_BATCH Failed, error : %d", gps_event_info->event_data.batch_ind.error);
 832                         }
 833                         break;
 834                 case GPS_EVENT_REPORT_SATELLITE:
 835                         if (gps_event_info->event_data.sv_ind.error == GPS_ERR_NONE) {
 836                                 if (gps_event_info->event_data.sv_ind.sv.pos_valid) {
 837                                         if (_gps_server_get_gps_state() != POSITION_CONNECTED)
 838                                                 _gps_server_set_gps_state(POSITION_CONNECTED);
 839                                 } else {
 840                                         LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_SATELLITE :::::::::::::::");
 841                                         if (_gps_server_get_gps_state() != POSITION_SEARCHING)
 842                                                 _gps_server_set_gps_state(POSITION_SEARCHING);
 843                                 }
 844                                 _report_sv_event(server, gps_event_info);
 845                         } else {
 846                                 LOG_GPS(DBG_ERR, "GPS_EVENT_SATELLITE Failed, error : %d", gps_event_info->event_data.sv_ind.error);
 847                         }
 848                         break;
 849                 case GPS_EVENT_REPORT_NMEA:
 850                         if (_gps_server_get_gps_state() != POSITION_CONNECTED) {
 851                                 /*LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_NMEA :::::::::::::::"); */
 852                         }
 853
 854                         if (gps_event_info->event_data.nmea_ind.error == GPS_ERR_NONE) {
 855                                 _report_nmea_event(server, gps_event_info);
 856                         } else {
 857                                 LOG_GPS(DBG_ERR, "GPS_EVENT_NMEA Failed, error : %d", gps_event_info->event_data.nmea_ind.error);
 858                         }
 859                         break;
 860                 case GPS_EVENT_ERR_CAUSE:
 861                         break;
 862                 case GPS_EVENT_AGPS_VERIFICATION_INDI:
 863                         break;
 864                 case GPS_EVENT_GET_IMSI:
 865                         break;
 866                 case GPS_EVENT_GET_REF_LOCATION:
 867                         break;
 868                 case GPS_EVENT_OPEN_DATA_CONNECTION: {
 869                                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_OPEN_DATA_CONNECTION :::::::::::::::");
 870                                 result = _gps_server_open_data_connection(server);
 871                         }
 872                         break;
 873                 case GPS_EVENT_CLOSE_DATA_CONNECTION: {
 874                                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_CLOSE_DATA_CONNECTION :::::::::::::::");
 875                                 result = _gps_server_close_data_connection(server);
 876                         }
 877                         break;
 878                 case GPS_EVENT_DNS_LOOKUP_IND:
 879                         LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_DNS_LOOKUP_IND :::::::::::::::");
 880                         if (gps_event_info->event_data.dns_query_ind.error == GPS_ERR_NONE) {
 881                                 result = _gps_server_resolve_dns(gps_event_info->event_data.dns_query_ind.domain_name);
 882                         } else {
 883                                 result = FALSE;
 884                         }
 885                         if (result == TRUE) {
 886                                 LOG_GPS(DBG_LOW, "Success to get the DNS Query about [ %s ]",
 887                                                 gps_event_info->event_data.dns_query_ind.domain_name);
 888                         }
 889                         break;
 890                 case GPS_EVENT_FACTORY_TEST:
 891                         LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_FACTORY_TEST :::::::::::::::");
 892                         if (gps_event_info->event_data.factory_test_rsp.error == GPS_ERR_NONE) {
 893                                 LOG_GPS(DBG_LOW, "[LBS server] Response Factory test result success");
 894                                 _gps_server_send_facttest_result(gps_event_info->event_data.factory_test_rsp.snr,
 895                                                                                                  gps_event_info->event_data.factory_test_rsp.prn, TRUE);
 896                         } else {
 897                                 LOG_GPS(DBG_ERR, "//[LBS server] Response Factory test result ERROR");
 898                                 _gps_server_send_facttest_result(gps_event_info->event_data.factory_test_rsp.snr,
 899                                                                                                  gps_event_info->event_data.factory_test_rsp.prn, FALSE);
 900                         }
 901                         break;
 902                 case GPS_EVENT_GEOFENCE_TRANSITION:
 903                         LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_GEOFENCE_TRANSITION :::::::::::::::");
 904                         _report_geofence_transition(gps_event_info->event_data.geofence_transition_ind.geofence_id,
 905                                                                                 gps_event_info->event_data.geofence_transition_ind.state,
 906                                                                                 gps_event_info->event_data.geofence_transition_ind.pos.latitude,
 907                                                                                 gps_event_info->event_data.geofence_transition_ind.pos.longitude,
 908                                                                                 gps_event_info->event_data.geofence_transition_ind.pos.altitude,
 909                                                                                 gps_event_info->event_data.geofence_transition_ind.pos.speed,
 910                                                                                 gps_event_info->event_data.geofence_transition_ind.pos.bearing,
 911                                                                                 gps_event_info->event_data.geofence_transition_ind.pos.hor_accuracy);
 912                         break;
 913                 case GPS_EVENT_GEOFENCE_STATUS:
 914                         LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_GEOFENCE_STATUS :::::::::::::::");
 915                         _report_geofence_service_status(gps_event_info->event_data.geofence_status_ind.status);
 916                         break;
 917                 case GPS_EVENT_ADD_GEOFENCE:
 918                         LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_ADD_GEOFENCE :::::::::::::::");
 919                         _gps_server_send_geofence_result(GEOFENCE_ADD_FENCE,
 920                                                                                          gps_event_info->event_data.geofence_event_rsp.geofence_id,
 921                                                                                          gps_event_info->event_data.geofence_event_rsp.error);
 922                         break;
 923                 case GPS_EVENT_DELETE_GEOFENCE:
 924                         LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_DELETE_GEOFENCE :::::::::::::::");
 925                         _gps_server_send_geofence_result(GEOFENCE_DELETE_FENCE,
 926                                                                                          gps_event_info->event_data.geofence_event_rsp.geofence_id,
 927                                                                                          gps_event_info->event_data.geofence_event_rsp.error);
 928                         break;
 929                 case GPS_EVENT_PAUSE_GEOFENCE:
 930                         LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_PAUSE_GEOFENCE :::::::::::::::");
 931                         _gps_server_send_geofence_result(GEOFENCE_PAUSE_FENCE,
 932                                                                                          gps_event_info->event_data.geofence_event_rsp.geofence_id,
 933                                                                                          gps_event_info->event_data.geofence_event_rsp.error);
 934                         break;
 935                 case GPS_EVENT_RESUME_GEOFENCE:
 936                         LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_RESUME_GEOFENCE :::::::::::::::");
 937                         _gps_server_send_geofence_result(GEOFENCE_RESUME_FENCE,
 938                                                                                          gps_event_info->event_data.geofence_event_rsp.geofence_id,
 939                                                                                          gps_event_info->event_data.geofence_event_rsp.error);
 940                         break;
 941                 default:
 942                         LOG_GPS(DBG_WARN, "//Error: Isettingalid Event Type %d", gps_event_info->event_id);
 943                         break;
 944         }
 945         return result;
 946 }
 947
 948 #ifndef _TIZEN_PUBLIC_
 949 int request_supl_ni_session(const char *header, const char *body, int size)
 950 {
 951         agps_supl_ni_info_t info;
 952         gps_failure_reason_t reason_code;
 953
 954         info.msg_body = (char *)body;
 955         info.msg_size = size;
 956         info.status = TRUE;
 957
 958         if (!get_plugin_module()->request(GPS_ACTION_REQUEST_SUPL_NI, &info, &reason_code)) {
 959                 LOG_GPS(DBG_ERR, "Failed to request SUPL NI (code:%d)", reason_code);
 960                 return FALSE;
 961         }
 962
 963         return TRUE;
 964 }
 965 #else
 966 static void *request_supl_ni_session(void *data)
 967 {
 968         gps_ni_data_t *ni_data = (gps_ni_data_t *) data;
 969         agps_supl_ni_info_t info;
 970         gps_failure_reason_t reason_code;
 971
 972         info.msg_body = (char *)ni_data->msg_body;
 973         info.msg_size = ni_data->msg_size;
 974         info.status = TRUE;
 975
 976         if (!get_plugin_module()->request(GPS_ACTION_REQUEST_SUPL_NI, &info, &reason_code)) {
 977                 LOG_GPS(DBG_ERR, "Failed to request SUPL NI (code:%d)", reason_code);
 978         }
 979
 980         free(ni_data);
 981
 982         return NULL;
 983 }
 984
 985 static void _gps_supl_networkinit_smscb(msg_handle_t hMsgHandle, msg_struct_t msg, void *user_param)
 986 {
 987         LOG_GPS(DBG_ERR, "_gps_supl_networkinit_smscb is called");
 988         gps_server_t *server = (gps_server_t *)user_param;
 989
 990         gps_ni_data_t *new_message = NULL;
 991
 992         new_message = (gps_ni_data_t *)malloc(sizeof(gps_ni_data_t));
 993         memset(new_message, 0x00, sizeof(gps_ni_data_t));
 994         msg_get_int_value(msg, MSG_MESSAGE_DATA_SIZE_INT, &new_message->msg_size);
 995         msg_get_str_value(msg, MSG_MESSAGE_SMS_DATA_STR, new_message->msg_body, new_message->msg_size);
 996
 997         pthread_attr_t attr;
 998         pthread_attr_init(&attr);
 999         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
1000
1001         if (pthread_create(&server->popup_thread, &attr, request_supl_ni_session, new_message) != 0) {
1002                 LOG_GPS(DBG_WARN, "Can not make pthread......");
1003         }
1004 }
1005
1006 static void _gps_supl_networkinit_wappushcb(msg_handle_t hMsgHandle, const char *pPushHeader, const char *pPushBody,
1007                 int pushBodyLen, void *user_param)
1008 {
1009         gps_server_t *server = (gps_server_t *)user_param;
1010         char *str;
1011
1012         LOG_GPS(DBG_ERR, "_gps_supl_networkinit_wappushcb is called");
1013
1014         if (strstr(pPushHeader, "application/vnd.omaloc-supl-init") != NULL) {
1015                 str = strstr(pPushHeader, "X-Wap-Application-Id:");
1016
1017                 if (strncmp(str + 22, "x-oma-application:ulp.ua", 24) != 0) {
1018                         LOG_GPS(DBG_ERR, "Wrong Application-ID");
1019                         return;
1020                 }
1021         }
1022
1023         gps_ni_data_t *new_message = NULL;
1024
1025         new_message = (gps_ni_data_t *) malloc(sizeof(gps_ni_data_t));
1026         new_message->msg_body = (char *)pPushBody;
1027         new_message->msg_size = pushBodyLen;
1028
1029         pthread_attr_t attr;
1030         pthread_attr_init(&attr);
1031         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
1032
1033         if (pthread_create(&server->popup_thread, &attr, request_supl_ni_session, new_message) != 0) {
1034                 LOG_GPS(DBG_WARN, "Can not make pthread......");
1035         }
1036 }
1037
1038 static void *_gps_register_msgfwcb(void *data)
1039 {
1040         gps_server_t *server = (gps_server_t *)data;
1041         msg_handle_t msgHandle = NULL;
1042         msg_error_t err = MSG_SUCCESS;
1043
1044         int setValue = 0;
1045         int ret;
1046
1047         int cnt = 60;
1048
1049         while (cnt > 0) {
1050                 ret = vconf_get_bool(VCONFKEY_MSG_SERVER_READY, &setValue);
1051
1052                 if (ret == -1) {
1053                         LOG_GPS(DBG_WARN, "Fail to get VCONFKEY_MSG_SERVER_READY");
1054                         return NULL;
1055                 }
1056
1057                 if (setValue) {
1058                         LOG_GPS(DBG_LOW, "MSG server is READY!!");
1059                         cnt = -1;
1060                 } else {
1061                         sleep(5);
1062                         cnt--;
1063                         if (cnt == 0) {
1064                                 LOG_GPS(DBG_WARN, "Never connect to MSG Server for 300 secs.");
1065                                 return NULL;
1066                         }
1067                 }
1068         }
1069
1070         err = msg_open_msg_handle(&msgHandle);
1071
1072         if (err != MSG_SUCCESS) {
1073                 LOG_GPS(DBG_WARN, "Fail to MsgOpenMsgHandle. Error type = [ %d ]", err);
1074                 return NULL;
1075         }
1076
1077         err = msg_reg_sms_message_callback(msgHandle, &_gps_supl_networkinit_smscb, 7275, (void *)server);
1078
1079         if (err != MSG_SUCCESS) {
1080                 LOG_GPS(DBG_WARN, "Fail to MsgRegSmsMessageCallback. Error type = [ %d ]", err);
1081                 return NULL;
1082         }
1083
1084         err = msg_reg_lbs_message_callback(msgHandle, &_gps_supl_networkinit_wappushcb, (void *)server);
1085
1086         if (err != MSG_SUCCESS) {
1087                 LOG_GPS(DBG_WARN, "Fail to MsgRegLBSMessageCallback. Error type = [ %d ]", err);
1088                 return NULL;
1089         }
1090
1091         LOG_GPS(DBG_LOW, "Success to lbs_register_msgfwcb");
1092         return NULL;
1093
1094 }
1095 #endif
1096
1097 void check_plugin_module(char *module_name)
1098 {
1099         if (get_replay_enabled() == TRUE) {
1100                 g_strlcpy(module_name, "replay", strlen("replay") + 1);
1101                 LOG_GPS(DBG_LOW, "REPLAY_ENABELD is TRUE");
1102         } else if (access(BRCM4752_PATH, F_OK) == 0 || access(BRCM47520_PATH, F_OK) == 0 ||
1103                                 access(BRCM47522_PATH, F_OK) == 0) {
1104                 g_strlcpy(module_name, "brcm", strlen("brcm") + 1);
1105         } else if (access(BRCM47511_PATH, F_OK) == 0) {
1106                 g_strlcpy(module_name, "brcm-legacy", strlen("brcm-legacy") + 1);
1107         } else if (access(CSR_PATH, F_OK) == 0) {
1108                 g_strlcpy(module_name, "csr", strlen("csr") + 1);
1109         } else if (access(QCOM8x30_PATH, F_OK) == 0 || access(QCOM9x15_PATH, F_OK) == 0 ||
1110                                 access(QCOM8974_PATH, F_OK) == 0 || access(QCOM8210_PATH, F_OK) == 0 ||
1111                                 access(QCOM8226_PATH, F_OK) == 0 || access(QCOM8916_PATH, F_OK) == 0) {
1112                 g_strlcpy(module_name, "qcom", strlen("qcom") + 1);
1113         } else {
1114                 g_strlcpy(module_name, "replay", strlen("replay") + 1);
1115         }
1116
1117         LOG_GPS(DBG_LOW, "module name : %s", module_name);
1118 }
1119
1120 static gps_server_t *_initialize_gps_data(void)
1121 {
1122         g_gps_server = (gps_server_t *) malloc(sizeof(gps_server_t));
1123         if (g_gps_server == NULL) {
1124                 LOG_GPS(DBG_ERR, "Failed to alloc g_gps_server");
1125                 return NULL;
1126         }
1127         memset(g_gps_server, 0x00, sizeof(gps_server_t));
1128
1129         g_gps_server->session_state = GPS_SESSION_STOPPED;
1130         g_gps_server->dnet_used = 0;
1131         g_gps_server->logging_enabled = FALSE;
1132         g_gps_server->replay_enabled = FALSE;
1133 #ifdef _TIZEN_PUBLIC_
1134         g_gps_server->msg_thread = 0;
1135         g_gps_server->popup_thread = 0;
1136 #endif
1137
1138         memset(&g_gps_server->gps_plugin, 0x00, sizeof(gps_plugin_handler_t));
1139
1140         if (g_gps_server->pos_data == NULL) {
1141                 g_gps_server->pos_data = (pos_data_t *) malloc(sizeof(pos_data_t));
1142                 if (g_gps_server->pos_data == NULL) {
1143                         LOG_GPS(DBG_ERR, "Failed to alloc g_gps_server->pos_data");
1144                         return NULL;
1145                 } else {
1146                         memset(g_gps_server->pos_data, 0x00, sizeof(pos_data_t));
1147                 }
1148         }
1149
1150         if (g_gps_server->batch_data == NULL) {
1151                 g_gps_server->batch_data = (batch_data_t *) malloc(sizeof(batch_data_t));
1152                 if (g_gps_server->batch_data == NULL) {
1153                         LOG_GPS(DBG_ERR, "Failed to alloc g_gps_server->batch_data");
1154                         return NULL;
1155                 } else {
1156                         memset(g_gps_server->batch_data, 0x00, sizeof(batch_data_t));
1157                 }
1158         }
1159
1160         if (g_gps_server->sv_data == NULL) {
1161                 g_gps_server->sv_data = (sv_data_t *) malloc(sizeof(sv_data_t));
1162                 if (g_gps_server->sv_data == NULL) {
1163                         LOG_GPS(DBG_ERR, "Failed to alloc g_gps_server->sv_data");
1164                         return NULL;
1165                 } else {
1166                         memset(g_gps_server->sv_data, 0x00, sizeof(sv_data_t));
1167                 }
1168         }
1169
1170         if (g_gps_server->nmea_data == NULL) {
1171                 g_gps_server->nmea_data = (nmea_data_t *) malloc(sizeof(nmea_data_t));
1172                 if (g_gps_server->nmea_data == NULL) {
1173                         LOG_GPS(DBG_ERR, "Failed to alloc g_gps_server->nmea_data");
1174                         return NULL;
1175                 } else {
1176                         memset(g_gps_server->nmea_data, 0x00, sizeof(nmea_data_t));
1177                 }
1178         }
1179
1180         return g_gps_server;
1181 }
1182
1183 static void _deinitialize_gps_data(void)
1184 {
1185         if (g_gps_server->pos_data != NULL) {
1186                 free(g_gps_server->pos_data);
1187                 g_gps_server->pos_data = NULL;
1188         }
1189
1190         if (g_gps_server->batch_data != NULL) {
1191                 free(g_gps_server->batch_data);
1192                 g_gps_server->batch_data = NULL;
1193         }
1194
1195         if (g_gps_server->sv_data != NULL) {
1196                 free(g_gps_server->sv_data);
1197                 g_gps_server->sv_data = NULL;
1198         }
1199
1200         if (g_gps_server->nmea_data != NULL) {
1201                 if (g_gps_server->nmea_data->data != NULL) {
1202                         free(g_gps_server->nmea_data->data);
1203                         g_gps_server->nmea_data->data = NULL;
1204                 }
1205                 free(g_gps_server->nmea_data);
1206                 g_gps_server->nmea_data = NULL;
1207         }
1208
1209         if (g_gps_server != NULL) {
1210                 free(g_gps_server);
1211                 g_gps_server = NULL;
1212         }
1213 }
1214
1215 int initialize_server(int argc, char **argv)
1216 {
1217         FUNC_ENTRANCE_SERVER;
1218
1219         gps_server_t *server;
1220         char module_name[16];
1221
1222         server = _initialize_gps_data();
1223         if (server == NULL)
1224                 return -1;
1225         check_plugin_module(module_name);
1226         _gps_plugin_handler_init(server, module_name);
1227         _gps_get_nmea_replay_mode(server);
1228         _gps_notify_params(server);
1229
1230         if (!load_plugin_module(server->gps_plugin.name, &server->gps_plugin.handle)) {
1231                 LOG_GPS(DBG_ERR, "Fail to load plugin module.");
1232                 return -1;
1233         }
1234
1235         if (!get_plugin_module()->init(_gps_server_gps_event_cb, (void *)server)) {
1236                 LOG_GPS(DBG_WARN, "Fail to gps module initialization");
1237                 return -1;
1238         }
1239
1240 #ifdef _TIZEN_PUBLIC_
1241         if (pthread_create(&g_gps_server->msg_thread, NULL, _gps_register_msgfwcb, g_gps_server) != 0) {
1242                 LOG_GPS(DBG_WARN, "Can not make pthread......");
1243         }
1244 #endif
1245
1246         LOG_GPS(DBG_LOW, "Initialization-gps is completed.");
1247
1248         if (!nps_load_plugin_module(&g_nps_plugin.handle)) {
1249                 LOG_NPS(DBG_ERR, "Fail to load lbs_server_NPS plugin module.");
1250                 __nps_plugin_handler_deinit();
1251                 return 0; /* TBD: how to deal with this error situation */
1252         }
1253
1254         LOG_NPS(DBG_LOW, "Initialization-nps is completed.");
1255
1256         return 0;
1257 }
1258
1259 int deinitialize_server()
1260 {
1261         gps_failure_reason_t ReasonCode = GPS_FAILURE_CAUSE_NORMAL;
1262
1263 #ifdef _TIZEN_PUBLIC_
1264         pthread_join(g_gps_server->msg_thread, (void *)&g_gps_server->msg_thread_status);
1265 #endif
1266
1267         _gps_ignore_params();
1268
1269         if (!get_plugin_module()->deinit(&ReasonCode)) {
1270                 LOG_GPS(DBG_WARN, "Fail to gps module de-initialization");
1271         }
1272         unload_plugin_module(g_gps_server->gps_plugin.handle);
1273
1274         _gps_plugin_handler_deinit(g_gps_server);
1275         _deinitialize_gps_data();
1276
1277         nps_unload_plugin_module(g_nps_plugin.handle);
1278         __nps_plugin_handler_deinit();
1279
1280         return 0;
1281 }
1282
1283 int register_update_callbacks(struct gps_callbacks *gps_callback, void *user_data)
1284 {
1285         g_update_cb = *gps_callback;
1286         g_user_data = user_data;
1287         return 0;
1288 }