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