src/bm_util.c

   1 /*
   2  * Copyright (c) 2019 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License")
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <cynara-client.h>
  19 #include <cynara-session.h>
  20 #include <cynara-creds-gdbus.h>
  21
  22 #include "bm_util.h"
  23 #include "bm_common.h"
  24
  25 static cynara *p_cynara;
  26 GDBusConnection* connection_obj = NULL;
  27
  28 GDBusErrorEntry bm_svc_errors[] = {
  29         {BATTERY_MONITOR_ERROR_NONE, BATTERY_MONITOR_SVC_ERROR_PREFIX".NoError"},
  30         {BATTERY_MONITOR_ERROR_OUT_OF_MEMORY, BATTERY_MONITOR_SVC_ERROR_PREFIX".OutOfMemory"},
  31         {BATTERY_MONITOR_ERROR_INVALID_PARAMETER, BATTERY_MONITOR_SVC_ERROR_PREFIX".InvalidParameter"},
  32         {BATTERY_MONITOR_ERROR_DUPLICATED, BATTERY_MONITOR_SVC_ERROR_PREFIX".Duplicated"},
  33         {BATTERY_MONITOR_ERROR_NO_DATA, BATTERY_MONITOR_SVC_ERROR_PREFIX".NoData"},
  34         {BATTERY_MONITOR_ERROR_NOT_INITIALIZED, BATTERY_MONITOR_SVC_ERROR_PREFIX".NotInitialized"},
  35         {BATTERY_MONITOR_ERROR_RECORD_NOT_FOUND, BATTERY_MONITOR_SVC_ERROR_PREFIX".RecordNotFound"},
  36         {BATTERY_MONITOR_ERROR_DB_FAILED, BATTERY_MONITOR_SVC_ERROR_PREFIX".DBFailed"},
  37         {BATTERY_MONITOR_ERROR_DB_NOT_OPENED, BATTERY_MONITOR_SVC_ERROR_PREFIX".DBNotOpened"},
  38         {BATTERY_MONITOR_ERROR_QUERY_SYNTAX_ERROR, BATTERY_MONITOR_SVC_ERROR_PREFIX".QuerySynTaxError"},
  39         {BATTERY_MONITOR_ERROR_ITERATOR_END, BATTERY_MONITOR_SVC_ERROR_PREFIX".IteratorEnd"},
  40         {BATTERY_MONITOR_ERROR_NOTI_FAILED, BATTERY_MONITOR_SVC_ERROR_PREFIX".NotiFalied"},
  41         {BATTERY_MONITOR_ERROR_PERMISSION_DENIED, BATTERY_MONITOR_SVC_ERROR_PREFIX".PermissionDenied"},
  42         {BATTERY_MONITOR_ERROR_NULL_POINTER, BATTERY_MONITOR_SVC_ERROR_PREFIX".NullPointer"},
  43         {BATTERY_MONITOR_ERROR_INTERNAL, BATTERY_MONITOR_SVC_ERROR_PREFIX".Internal"},
  44         {BATTERY_MONITOR_ERROR_PLUGIN_ADD, BATTERY_MONITOR_SVC_ERROR_PREFIX".PluginAdd"},
  45         {BATTERY_MONITOR_ERROR_PLUGIN_AVAILABLE, BATTERY_MONITOR_SVC_ERROR_PREFIX".PluginAvailable"},
  46         {BATTERY_MONITOR_ERROR_NOT_SUPPORTED, BATTERY_MONITOR_SVC_ERROR_PREFIX".NotSupported"},
  47         {BATTERY_MONITOR_ERROR_DATABASE_BUSY, BATTERY_MONITOR_SVC_ERROR_PREFIX".DatabaseBusy"},
  48 };
  49
  50 static guint bm_get_client_pid(GDBusMethodInvocation* invoc)
  51 {
  52         const char *name = NULL;
  53         name = g_dbus_method_invocation_get_sender(invoc);
  54         if (name == NULL) {
  55                 _ERR("g_dbus_method_invocation_get_sender failed");
  56                 return -1;
  57         }
  58
  59         _INFO("sender=[%s]", name);
  60
  61         guint pid = -1;
  62         GError *error = NULL;
  63         GVariant *_ret;
  64
  65         _INFO("calling GetConnectionUnixProcessID");
  66
  67         GDBusConnection* conn = g_dbus_method_invocation_get_connection(invoc);
  68         _ret = g_dbus_connection_call_sync(conn,
  69                         FREE_DESKTOP_BUS_NAME,
  70                         FREE_DESKTOP_OBJECT_PATH,
  71                         FREE_DESKTOP_INTERFACE_NAME,
  72                         FREE_DESKTOP_METHOD_NAME,
  73                         g_variant_new("(s)", name),
  74                         NULL,
  75                         G_DBUS_CALL_FLAGS_NONE,
  76                         -1,
  77                         NULL,
  78                         &error);
  79
  80         if (_ret != NULL) {
  81                 g_variant_get(_ret, "(u)", &pid);
  82                 g_variant_unref(_ret);
  83         }
  84
  85         _INFO("process Id = [%u]", pid);
  86         return pid;
  87 }
  88
  89 GQuark bm_error_quark(void)
  90 {
  91         static volatile gsize quark_volatile = 0;
  92
  93         g_dbus_error_register_error_domain(BATTERY_MONITOR_SVC_ERROR_DOMAIN, &quark_volatile,
  94                                                 bm_svc_errors, G_N_ELEMENTS(bm_svc_errors));
  95
  96         return (GQuark)quark_volatile;
  97 }
  98
  99 static int bm_check_privilege_by_cynara(const char *client, const char *session, const char *user,
 100                                                                 const char *privilege)
 101 {
 102         int ret;
 103         char err_buf[128] = {0,};
 104
 105         ret = cynara_check(p_cynara, client, session, user, privilege);
 106         switch (ret) {
 107         case CYNARA_API_ACCESS_ALLOWED:
 108                 _DBG("cynara_check success");
 109                 return BATTERY_MONITOR_ERROR_NONE;
 110         case CYNARA_API_ACCESS_DENIED:
 111                 _ERR("cynara_check permission deined, privilege=%s, error = CYNARA_API_ACCESS_DENIED",
 112                                                                                 privilege);
 113                 return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
 114         default:
 115                 cynara_strerror(ret, err_buf, sizeof(err_buf));
 116                 _ERR("cynara_check error : %s, privilege=%s, ret = %d", err_buf, privilege, ret);
 117                 return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
 118         }
 119 }
 120
 121 static int bm_get_information_for_cynara_check(GDBusMethodInvocation *invocation, char **client,
 122                                                         char **user, char **session)
 123 {
 124         GDBusConnection *gdbus_conn = NULL;
 125         char* sender = NULL;
 126         int ret = -1;
 127
 128         //get GDBusConnection
 129         gdbus_conn = g_dbus_method_invocation_get_connection(invocation);
 130         if (gdbus_conn == NULL) {
 131                 _ERR("g_dbus_method_invocation_get_connection failed");
 132                 return -1;
 133         }
 134
 135         //get sender(unique_name)
 136         sender = (char*) g_dbus_method_invocation_get_sender(invocation);
 137         if (sender == NULL) {
 138                 _ERR("g_dbus_method_invocation_get_sender failed");
 139                 return -1;
 140         }
 141
 142         ret = cynara_creds_gdbus_get_user(gdbus_conn, sender, USER_METHOD_DEFAULT, user);
 143         if (ret != CYNARA_API_SUCCESS) {
 144                 _ERR("cynara_creds_gdbus_get_user failed, ret = %d", ret);
 145                 return -1;
 146         }
 147
 148         ret = cynara_creds_gdbus_get_client(gdbus_conn, sender, CLIENT_METHOD_DEFAULT, client);
 149         if (ret != CYNARA_API_SUCCESS) {
 150                 _ERR("cynara_creds_gdbus_get_client failed, ret = %d", ret);
 151                 return -1;
 152         }
 153
 154         guint pid = bm_get_client_pid(invocation);
 155         _INFO("client Id = [%u]", pid);
 156
 157         *session = cynara_session_from_pid(pid);
 158         if (*session == NULL) {
 159                 _ERR("cynara_session_from_pid failed");
 160                 return -1;
 161         }
 162
 163         return BATTERY_MONITOR_ERROR_NONE;
 164 }
 165
 166 static int bm_check_privilege(GDBusMethodInvocation *invocation, const char* privilege)
 167 {
 168         int ret = -1;
 169         char *client = NULL;
 170         char *session = NULL;
 171         char *user = NULL;
 172
 173         ret = bm_get_information_for_cynara_check(invocation, &client, &user, &session);
 174         if (ret != BATTERY_MONITOR_ERROR_NONE) {
 175                 _ERR("__get_information_for_cynara_check failed");
 176                 g_free(client);
 177                 g_free(user);
 178                 BM_FREE(session);
 179
 180                 return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
 181         }
 182
 183         ret = bm_check_privilege_by_cynara(client, session, user, privilege);
 184         if (ret != BATTERY_MONITOR_ERROR_NONE) {
 185                 _ERR("__check_privilege_by_cynara failed, ret = %d", ret);
 186                 g_free(client);
 187                 g_free(user);
 188                 BM_FREE(session);
 189
 190                 return BATTERY_MONITOR_ERROR_PERMISSION_DENIED;
 191         }
 192
 193         g_free(client);
 194         g_free(user);
 195         BM_FREE(session);
 196
 197         return BATTERY_MONITOR_ERROR_NONE;
 198 }
 199
 200 int bm_check_privilege_battery(GDBusMethodInvocation *invocation)
 201 {
 202         return bm_check_privilege(invocation, BATTERY_MONITOR_PRIVILEGE);
 203 }
 204
 205 int initialize_cynara(void)
 206 {
 207         ENTER;
 208
 209         _INFO("initializing cyanara for battery-monitor");
 210
 211         int ret_val = CYNARA_API_SUCCESS;
 212
 213         ret_val = cynara_initialize(&p_cynara, NULL);
 214
 215         BM_RETURN_VAL((ret_val == CYNARA_API_SUCCESS), {}, \
 216                 BATTERY_MONITOR_ERROR_NOT_INITIALIZED, "cynara initialization failure");
 217
 218         ret_val = BATTERY_MONITOR_ERROR_NONE;
 219
 220         EXIT;
 221         return ret_val;
 222 }
 223
 224 void deinitialize_cynara(void)
 225 {
 226         ENTER;
 227
 228         _INFO("de-initializing cyanara");
 229
 230         cynara_finish(p_cynara);
 231
 232         EXIT;
 233         return;
 234 }
 235
 236 int bm_calc_individual_consumption(int resource_val, int total_consumption)
 237 {
 238         _DBG("resource consumption - [%d], total consumption - [%d]", \
 239                         resource_val, total_consumption);
 240
 241         if (resource_val == 0) {
 242                 _DBG("no consumption");
 243                 return 0;
 244         }
 245
 246         return (((long)resource_val*100)/total_consumption);
 247 }
 248
 249 double bm_calc_individual_mah_consumption(int resource_val, double mah_c)
 250 {
 251         if (resource_val == 0) {
 252                 _DBG("no consumption");
 253                 return 0;
 254         }
 255
 256         _DBG("resource consumption - [%d]", resource_val);
 257         return ((double)resource_val/mah_c);
 258 }
 259
 260 GVariant* bm_marshal_serialized_data(const bm_total_consumption_h data)
 261 {
 262         ENTER;
 263
 264         const bm_total_consumption_h in_data = data;
 265         GVariantBuilder builder;
 266
 267         g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT);
 268
 269         g_variant_builder_add(&builder, "{sv}", BATTERY_MONITOR_BLE_DATA_ID,
 270                                         g_variant_new_int32(in_data->ble_val));
 271
 272         g_variant_builder_add(&builder, "{sv}", BATTERY_MONITOR_WIFI_DATA_ID,
 273                                         g_variant_new_int32(in_data->wifi_val));
 274
 275         g_variant_builder_add(&builder, "{sv}", BATTERY_MONITOR_CPU_DATA_ID,
 276                                         g_variant_new_int32(in_data->cpu_val));
 277
 278         g_variant_builder_add(&builder, "{sv}", BATTERY_MONITOR_DP_DATA_ID,
 279                                         g_variant_new_int32(in_data->dp_val));
 280
 281         g_variant_builder_add(&builder, "{sv}", BATTERY_MONITOR_DN_DATA_ID,
 282                                         g_variant_new_int32(in_data->dn_val));
 283 #ifdef DISABLE_FEATURE_DATA_FROM_GPS_PLUGIN
 284         g_variant_builder_add(&builder, "{sv}", BATTERY_MONITOR_GPS_DATA_ID,
 285                                         g_variant_new_int32(in_data->gps_val));
 286 #endif /* DISABLE_FEATURE_DATA_FROM_GPS_PLUGIN */
 287         g_variant_builder_add(&builder, "{sv}", BATTERY_MONITOR_BATTERY_DATA_ID,
 288                                         g_variant_new_int32(in_data->bat_val));
 289
 290         EXIT;
 291         return g_variant_builder_end(&builder);
 292 }
 293
 294 const char *bm_get_resource_id_string(gint resource_id)
 295 {
 296         ENTER;
 297
 298         switch (resource_id) {
 299         BM_RESOURCE_ID_TO_STR(BM_PLUGIN_ID_BLE, BATTERY_MONITOR_BLE_DATA_ID)
 300         BM_RESOURCE_ID_TO_STR(BM_PLUGIN_ID_WIFI, BATTERY_MONITOR_WIFI_DATA_ID)
 301         BM_RESOURCE_ID_TO_STR(BM_PLUGIN_ID_CPU, BATTERY_MONITOR_CPU_DATA_ID)
 302         BM_RESOURCE_ID_TO_STR(BM_PLUGIN_ID_DISPLAY, BATTERY_MONITOR_DP_DATA_ID)
 303         BM_RESOURCE_ID_TO_STR(BM_PLUGIN_ID_DEVICE_NETWORK, BATTERY_MONITOR_DN_DATA_ID)
 304         BM_RESOURCE_ID_TO_STR(BM_PLUGIN_ID_GPS_SENSOR, BATTERY_MONITOR_GPS_DATA_ID)
 305 #ifdef DISABLE_FEATURE_DATA_FROM_GPS_PLUGIN
 306         BM_RESOURCE_ID_TO_STR(BM_PLUGIN_CONST_BATTERY, BATTERY_MONITOR_BATTERY_DATA_ID)
 307 #endif /* DISABLE_FEATURE_DATA_FROM_GPS_PLUGIN */
 308
 309         default:
 310                 EXIT;
 311                 return "UNKNOWN RESOURCE-ID";
 312         }
 313 }
 314
 315 int bm_set_dbus_connection_obj(GDBusConnection* conn)
 316 {
 317         BM_CHECK_INPUT_PARAM(conn);
 318
 319         connection_obj = conn;
 320
 321         return BATTERY_MONITOR_ERROR_NONE;
 322 }
 323
 324 GDBusConnection* bm_get_dbus_connection_obj(void)
 325 {
 326         if (connection_obj == NULL) {
 327                 _ERR("connection object not available");
 328                 return NULL;
 329         }
 330
 331         return connection_obj;
 332 }
 333
 334 void bm_data_free(gpointer data)
 335 {
 336         ENTER;
 337
 338         if (!data) {
 339                 _ERR("data handle is null");
 340                 return;
 341         }
 342
 343         _DBG("delete - app_id(%s)", (char *)data);
 344
 345         BM_FREE(data);
 346
 347         EXIT;
 348         return;
 349 }
 350
 351 void bm_atm_free(gpointer data)
 352 {
 353         ENTER;
 354
 355         if (!data) {
 356                 _ERR("data handle is null");
 357                 return;
 358         }
 359
 360         BM_FREE(data);
 361
 362         EXIT;
 363         return;
 364 }
 365
 366 void bm_appid_usage_free(appid_usage_s *data)
 367 {
 368         ENTER;
 369
 370         if (!data) {
 371                 _ERR("data handle is null");
 372                 return;
 373         }
 374
 375         BM_FREE(data->AppId);
 376         BM_FREE(data);
 377
 378         EXIT;
 379         return;
 380 }
 381
 382 void bm_resourceid_usage_free(resourceid_usage_s *data)
 383 {
 384         ENTER;
 385
 386         if (!data) {
 387                 _ERR("data handle is null");
 388                 return;
 389         }
 390
 391         BM_FREE(data->ResourceId);
 392         BM_FREE(data);
 393
 394         EXIT;
 395         return;
 396 }
 397
 398 long int bm_get_log_time(int bias)
 399 {
 400         ENTER;
 401
 402         long int ret = 0;
 403         time_t curr_time;
 404
 405         time(&curr_time);
 406         bias /= 1000;
 407         ret = (curr_time - bias);
 408
 409         EXIT;
 410         return ret;
 411 }
 412
 413 void bm_set_free_atm_st2_list(GSList *atm_list)
 414 {
 415         ENTER;
 416
 417         if (!atm_list) {
 418                 _WARN("atm-list is empty");
 419                 return;
 420         }
 421
 422         GSList *atm_list_iterator = NULL;
 423
 424         for (atm_list_iterator = atm_list; atm_list_iterator;
 425                         atm_list_iterator = atm_list_iterator->next) {
 426
 427                 app_time_map_st2 *atm_node = (app_time_map_st2 *)atm_list_iterator->data;
 428                 if (atm_node != NULL && atm_node->app_id)
 429                         BM_FREE(atm_node->app_id);
 430         }
 431
 432         /* free atm-list */
 433         g_slist_free_full(atm_list, free);
 434
 435         EXIT;
 436         return;
 437 }
 438
 439 void bm_set_free_atm_st1_list(GSList *atm_list)
 440 {
 441         ENTER;
 442
 443         if (!atm_list) {
 444                 _WARN("atm-list is empty");
 445                 return;
 446         }
 447
 448         GSList *atm_list_iterator = NULL;
 449
 450         for (atm_list_iterator = atm_list; atm_list_iterator;
 451                         atm_list_iterator = atm_list_iterator->next) {
 452
 453                 app_time_map_st1 *atm_node = (app_time_map_st1 *)atm_list_iterator->data;
 454                 if (atm_node != NULL && atm_node->app_id)
 455                         BM_FREE(atm_node->app_id);
 456         }
 457
 458         /* free atm-list */
 459         g_slist_free_full(atm_list, free);
 460
 461         EXIT;
 462         return;
 463 }
 464
 465 void bm_set_free_ble_data_handle(bm_bluetooth_st **bt_handle)
 466 {
 467         ENTER;
 468
 469         if (!(*bt_handle)) {
 470                 _ERR("data-handle not available");
 471                 return;
 472         }
 473
 474         bm_bluetooth_st *handle = *bt_handle;
 475
 476         GSList *atm_list = NULL, *data_list_iterator = NULL;
 477
 478         _DBG("inside data_handle");
 479
 480         if (!handle->bt_data_list) {
 481                 _ERR("data-list is null");
 482                 return;
 483         }
 484
 485         _DBG("inside data_list");
 486
 487         /* iterating over data-list */
 488         for (data_list_iterator = handle->bt_data_list; data_list_iterator;
 489                                 data_list_iterator = data_list_iterator->next) {
 490
 491                 atm_list = ((bm_bluetooth_st *)data_list_iterator->data)->atm_list;
 492                 if (!atm_list)
 493                         continue;
 494
 495                 bm_set_free_atm_st2_list(atm_list);
 496         }
 497
 498         _DBG("after atm_list free");
 499
 500         /* free data-list */
 501         g_slist_free_full(handle->bt_data_list, free);
 502
 503         _DBG("after data_list free");
 504
 505         /* free data-handle */
 506         BM_FREE(handle);
 507
 508         EXIT;
 509         return;
 510 }
 511
 512 void bm_set_free_wifi_data_handle(bm_wifi_st **wifi_handle)
 513 {
 514         ENTER;
 515
 516         if (!(*wifi_handle)) {
 517                 _ERR("data-handle not available");
 518                 return;
 519         }
 520
 521         bm_wifi_st *handle = *wifi_handle;
 522
 523         GSList *atm_list = NULL, *data_list_iterator = NULL;
 524
 525         _DBG("inside data_handle");
 526
 527         if (!handle->wifi_data_list) {
 528                 _ERR("data-list is null");
 529                 return;
 530         }
 531
 532         _DBG("inside data_list");
 533
 534         /* iterating over data-list */
 535         for (data_list_iterator = handle->wifi_data_list; data_list_iterator;
 536                                 data_list_iterator = data_list_iterator->next) {
 537
 538                 atm_list = ((bm_wifi_st *)data_list_iterator->data)->atm_list;
 539                 if (!atm_list)
 540                         continue;
 541
 542                 bm_set_free_atm_st2_list(atm_list);
 543         }
 544
 545         _DBG("after atm_list free");
 546
 547         /* free data-list */
 548         g_slist_free_full(handle->wifi_data_list, free);
 549
 550         _DBG("after data_list free");
 551
 552         /* free data-handle */
 553         BM_FREE(handle);
 554
 555         EXIT;
 556         return;
 557
 558 }
 559
 560 void bm_set_free_cpu_data_handle(bm_cpu_st **cpu_handle)
 561 {
 562         ENTER;
 563
 564         if (!(*cpu_handle)) {
 565                 _ERR("data-handle not available");
 566                 return;
 567         }
 568
 569         bm_cpu_st *handle = *cpu_handle;
 570
 571         GSList *atm_list = NULL, *data_list_iterator = NULL;
 572
 573         _DBG("inside data_handle");
 574
 575         if (!handle->cpu_data_list) {
 576                 _ERR("data-list is null");
 577                 return;
 578         }
 579
 580         _DBG("inside data_list");
 581
 582         /* iterating over data-list */
 583         for (data_list_iterator = handle->cpu_data_list; data_list_iterator;
 584                                 data_list_iterator = data_list_iterator->next) {
 585
 586                 atm_list = ((bm_cpu_st *)data_list_iterator->data)->atm_list;
 587                 if (!atm_list)
 588                         continue;
 589
 590                 bm_set_free_atm_st1_list(atm_list);
 591         }
 592
 593         _DBG("after atm_list free");
 594
 595         /* free data-list */
 596         g_slist_free_full(handle->cpu_data_list, free);
 597
 598         _DBG("after data_list free");
 599
 600         /* free data-handle */
 601         BM_FREE(handle);
 602
 603         EXIT;
 604         return;
 605 }
 606
 607 void bm_set_free_display_data_handle(bm_display_st **display_handle)
 608 {
 609         ENTER;
 610
 611         if (!(*display_handle)) {
 612                 _ERR("data-handle not available");
 613                 return;
 614         }
 615
 616         bm_display_st *handle = *display_handle;
 617
 618         GSList *atm_list = NULL;
 619         GSList *data_list_iterator = NULL;
 620
 621         _DBG("inside data_handle");
 622
 623         if (!handle->display_list) {
 624                 _ERR("data-list is null");
 625                 return;
 626         }
 627
 628         _DBG("inside data_list");
 629
 630         /* iterating over data-list */
 631         for (data_list_iterator = handle->display_list; data_list_iterator;
 632                                 data_list_iterator = data_list_iterator->next) {
 633
 634                 atm_list = ((bm_display_st *)data_list_iterator->data)->atm_list;
 635                 if (!atm_list)
 636                         continue;
 637
 638                 bm_set_free_atm_st1_list(atm_list);
 639         }
 640
 641         _DBG("after atm_list free");
 642
 643         /* free data-list */
 644         g_slist_free_full(handle->display_list, free);
 645
 646         _DBG("after data_list free");
 647
 648         /* free data-handle */
 649         BM_FREE(handle);
 650
 651         EXIT;
 652         return;
 653 }
 654
 655 void bm_set_free_device_network_data_handle(bm_device_network_st **dn_handle)
 656 {
 657         ENTER;
 658
 659         if (!(*dn_handle)) {
 660                 _ERR("data-handle not available");
 661                 return;
 662         }
 663
 664         bm_device_network_st *handle = *dn_handle;
 665
 666         GSList *atm_list = NULL, *data_list_iterator = NULL;
 667
 668         _DBG("inside data_handle");
 669
 670         if (!handle->dn_data_list) {
 671                 _ERR("data-list is null");
 672                 return;
 673         }
 674
 675         _DBG("inside data_list");
 676
 677         /* iterating over data-list */
 678         for (data_list_iterator = handle->dn_data_list; data_list_iterator;
 679                                 data_list_iterator = data_list_iterator->next) {
 680
 681                 atm_list = ((bm_device_network_st *)data_list_iterator->data)->atm_list;
 682                 if (!atm_list)
 683                         continue;
 684
 685                 bm_set_free_atm_st2_list(atm_list);
 686         }
 687
 688         _DBG("after atm_list free");
 689
 690         /* free data-list */
 691         g_slist_free_full(handle->dn_data_list, free);
 692
 693         _DBG("after data_list free");
 694
 695         /* free data-handle */
 696         BM_FREE(handle);
 697
 698         EXIT;
 699         return;
 700 }
 701
 702 #ifdef DISABLE_FEATURE_DATA_FROM_GPS_PLUGIN
 703 void bm_set_free_gps_sensor_data_handle(bm_gps_st **gps_handle)
 704 {
 705         ENTER;
 706
 707         if (!(*gps_handle)) {
 708                 _ERR("data-handle not available");
 709                 return;
 710         }
 711
 712         bm_gps_st *handle = *gps_handle;
 713
 714         GSList *atm_list = NULL, *data_list_iterator = NULL;
 715
 716         _DBG("inside data_handle");
 717
 718         if (!handle->gps_data_list) {
 719                 _ERR("data-list is null");
 720                 return;
 721         }
 722
 723         _DBG("inside data_list");
 724
 725         /* iterating over data-list */
 726         for (data_list_iterator = handle->gps_data_list; data_list_iterator;
 727                                 data_list_iterator = data_list_iterator->next) {
 728
 729                 atm_list = ((bm_gps_st *)data_list_iterator->data)->atm_list;
 730                 if (!atm_list)
 731                         continue;
 732
 733                 bm_set_free_atm_st1_list(atm_list);
 734         }
 735
 736         _DBG("after atm_list free");
 737
 738         /* free data-list */
 739         g_slist_free_full(handle->gps_data_list, free);
 740
 741         _DBG("after data_list free");
 742
 743         /* free data-handle */
 744         BM_FREE(handle);
 745
 746         EXIT;
 747         return;
 748 }
 749 #endif /* DISABLE_FEATURE_DATA_FROM_GPS_PLUGIN */
 750
 751 void bm_set_free_data_handles(bm_feature_data_h* data_hdl)
 752 {
 753         ENTER;
 754
 755         bm_set_free_ble_data_handle(&((*data_hdl)->bm_ble_handle));
 756         bm_set_free_wifi_data_handle(&((*data_hdl)->bm_wifi_handle));
 757         bm_set_free_cpu_data_handle(&((*data_hdl)->bm_cpu_handle));
 758         bm_set_free_display_data_handle(&((*data_hdl)->bm_display_handle));
 759         bm_set_free_device_network_data_handle(&((*data_hdl)->bm_dn_handle));
 760 #ifdef DISABLE_FEATURE_DATA_FROM_GPS_PLUGIN
 761         bm_set_free_gps_sensor_data_handle(&((*data_hdl)->bm_gps_handle));
 762 #endif /* DISABLE_FEATURE_DATA_FROM_GPS_PLUGIN */
 763
 764         BM_FREE(*data_hdl);
 765
 766         EXIT;
 767         return;
 768 }
 769
 770 void bm_set_free_gslist_appid_map(GSList *list)
 771 {
 772         ENTER;
 773         if (!list)
 774                 return;
 775
 776         GSList *iter;
 777         for (iter = list; iter != NULL; iter = g_slist_next(iter)) {
 778                 appid_map_s *amap_data = (appid_map_s *)iter->data;
 779                 BM_FREE(amap_data->AppId);
 780                 BM_FREE(amap_data);
 781         }
 782         g_slist_free(list);
 783         list = NULL;
 784
 785         EXIT;
 786         return;
 787 }