From dd56124a53e7ee4b7c422adf82af17e30bf799a8 Mon Sep 17 00:00:00 2001 From: Nishant Chaprana Date: Tue, 15 Dec 2020 12:39:49 +0530 Subject: [PATCH] Remove thread-scope variables for sharing handles between threads Change-Id: If5c78bfec5fde5695ce9b664eee895f402fa672c Signed-off-by: Nishant Chaprana --- include/tethering_private.h | 17 ++ packaging/capi-network-tethering.spec | 2 +- src/tethering.c | 220 ++++++++++++++++++++++++-- src/tethering_private.c | 44 +++++- 4 files changed, 262 insertions(+), 21 deletions(-) diff --git a/include/tethering_private.h b/include/tethering_private.h index e5797c1..c0b12a6 100644 --- a/include/tethering_private.h +++ b/include/tethering_private.h @@ -76,6 +76,23 @@ extern "C" { } \ } while (0) +/** + * To lock and unlock Mutex + */ + +#define TETHERING_LOCK \ + do { \ + _tethering_lock(); \ + } while(0) + +#define TETHERING_UNLOCK \ + do { \ + _tethering_unlock(); \ + } while(0) + +void _tethering_lock(void); +void _tethering_unlock(void); + /** * To check supported feature */ diff --git a/packaging/capi-network-tethering.spec b/packaging/capi-network-tethering.spec index bc7a90f..b5926e2 100644 --- a/packaging/capi-network-tethering.spec +++ b/packaging/capi-network-tethering.spec @@ -1,6 +1,6 @@ Name: capi-network-tethering Summary: Tethering Framework -Version: 1.1.4 +Version: 1.1.5 Release: 1 Group: System/Network License: Apache-2.0 diff --git a/src/tethering.c b/src/tethering.c index f330fb2..85f21f7 100755 --- a/src/tethering.c +++ b/src/tethering.c @@ -363,6 +363,7 @@ static void __handle_dhcp(GDBusConnection *connection, const gchar *sender_name, GVariant *parameters, gpointer user_data) { DBG("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); @@ -426,6 +427,8 @@ DONE: g_free(ip); g_free(mac); g_free(name); + + TETHERING_UNLOCK; DBG("-\n"); } @@ -434,6 +437,7 @@ static void __handle_net_closed(GDBusConnection *connection, const gchar *sender GVariant *parameters, gpointer user_data) { DBG("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); @@ -454,6 +458,7 @@ static void __handle_net_closed(GDBusConnection *connection, const gchar *sender dcb(TETHERING_ERROR_NONE, type, code, data); } + TETHERING_UNLOCK; DBG("-\n"); } @@ -462,6 +467,7 @@ static void __handle_wifi_tether_on(GDBusConnection *connection, const gchar *se GVariant *parameters, gpointer user_data) { DBG("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); @@ -471,12 +477,23 @@ static void __handle_wifi_tether_on(GDBusConnection *connection, const gchar *se tethering_enabled_cb ecb = NULL; void *data = NULL; + if (!_tethering_check_handle(th)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; + return; + } + ecb = th->enabled_cb[type]; - if (ecb == NULL) + if (ecb == NULL) { + TETHERING_UNLOCK; return; + } + data = th->enabled_user_data[type]; ecb(TETHERING_ERROR_NONE, type, is_requested, data); + + TETHERING_UNLOCK; DBG("-\n"); } @@ -485,6 +502,7 @@ static void __handle_wifi_tether_off(GDBusConnection *connection, const gchar *s GVariant *parameters, gpointer user_data) { DBG("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); @@ -495,9 +513,18 @@ static void __handle_wifi_tether_off(GDBusConnection *connection, const gchar *s void *data = NULL; char *buf = NULL; + if (!_tethering_check_handle(th)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; + return; + } + dcb = th->disabled_cb[type]; - if (dcb == NULL) + if (dcb == NULL) { + TETHERING_UNLOCK; return; + } + data = th->disabled_user_data[type]; g_variant_get(parameters, "(s)", &buf); if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE)) @@ -508,6 +535,7 @@ static void __handle_wifi_tether_off(GDBusConnection *connection, const gchar *s g_free(buf); dcb(TETHERING_ERROR_NONE, type, code, data); + TETHERING_UNLOCK; DBG("-\n"); } @@ -516,6 +544,7 @@ static void __handle_usb_tether_on(GDBusConnection *connection, const gchar *sen GVariant *parameters, gpointer user_data) { DBG("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); @@ -525,12 +554,23 @@ static void __handle_usb_tether_on(GDBusConnection *connection, const gchar *sen tethering_enabled_cb ecb = NULL; void *data = NULL; + if (!_tethering_check_handle(th)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; + return; + } + ecb = th->enabled_cb[type]; - if (ecb == NULL) + if (ecb == NULL) { + TETHERING_UNLOCK; return; + } + data = th->enabled_user_data[type]; ecb(TETHERING_ERROR_NONE, type, is_requested, data); + + TETHERING_UNLOCK; DBG("-\n"); } @@ -539,6 +579,7 @@ static void __handle_usb_tether_off(GDBusConnection *connection, const gchar *se GVariant *parameters, gpointer user_data) { DBG("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); @@ -549,9 +590,18 @@ static void __handle_usb_tether_off(GDBusConnection *connection, const gchar *se void *data = NULL; char *buf = NULL; + if (!_tethering_check_handle(th)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; + return; + } + dcb = th->disabled_cb[type]; - if (dcb == NULL) + if (dcb == NULL) { + TETHERING_UNLOCK; return; + } + data = th->disabled_user_data[type]; g_variant_get(parameters, "(s)", &buf); @@ -560,6 +610,8 @@ static void __handle_usb_tether_off(GDBusConnection *connection, const gchar *se dcb(TETHERING_ERROR_NONE, type, code, data); g_free(buf); + + TETHERING_UNLOCK; DBG("-\n"); } @@ -568,6 +620,7 @@ static void __handle_bt_tether_on(GDBusConnection *connection, const gchar *send GVariant *parameters, gpointer user_data) { DBG("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); @@ -577,12 +630,23 @@ static void __handle_bt_tether_on(GDBusConnection *connection, const gchar *send tethering_enabled_cb ecb = NULL; void *data = NULL; + if (!_tethering_check_handle(th)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; + return; + } + ecb = th->enabled_cb[type]; - if (ecb == NULL) + if (ecb == NULL) { + TETHERING_UNLOCK; return; + } + data = th->enabled_user_data[type]; ecb(TETHERING_ERROR_NONE, type, is_requested, data); + + TETHERING_UNLOCK; DBG("-\n"); } @@ -591,6 +655,7 @@ static void __handle_bt_tether_off(GDBusConnection *connection, const gchar *sen GVariant *parameters, gpointer user_data) { DBG("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); @@ -601,9 +666,18 @@ static void __handle_bt_tether_off(GDBusConnection *connection, const gchar *sen void *data = NULL; char *buf = NULL; + if (!_tethering_check_handle(th)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; + return; + } + dcb = th->disabled_cb[type]; - if (dcb == NULL) + if (dcb == NULL) { + TETHERING_UNLOCK; return; + } + data = th->disabled_user_data[type]; g_variant_get(parameters, "(s)", &buf); if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE)) @@ -614,6 +688,8 @@ static void __handle_bt_tether_off(GDBusConnection *connection, const gchar *sen dcb(TETHERING_ERROR_NONE, type, code, data); g_free(buf); + + TETHERING_UNLOCK; DBG("-\n"); } @@ -622,6 +698,7 @@ static void __handle_no_data_timeout(GDBusConnection *connection, const gchar *s GVariant *parameters, gpointer user_data) { DBG("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); @@ -631,6 +708,12 @@ static void __handle_no_data_timeout(GDBusConnection *connection, const gchar *s void *data = NULL; tethering_disabled_cause_e code = TETHERING_DISABLED_BY_TIMEOUT; + if (!_tethering_check_handle(th)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; + return; + } + for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) { dcb = th->disabled_cb[type]; if (dcb == NULL) @@ -639,6 +722,8 @@ static void __handle_no_data_timeout(GDBusConnection *connection, const gchar *s dcb(TETHERING_ERROR_NONE, type, code, data); } + + TETHERING_UNLOCK; DBG("-\n"); } @@ -647,6 +732,7 @@ static void __handle_low_battery_mode(GDBusConnection *connection, const gchar * GVariant *parameters, gpointer user_data) { DBG("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); @@ -656,6 +742,12 @@ static void __handle_low_battery_mode(GDBusConnection *connection, const gchar * void *data = NULL; tethering_disabled_cause_e code = TETHERING_DISABLED_BY_LOW_BATTERY; + if (!_tethering_check_handle(th)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; + return; + } + for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) { dcb = th->disabled_cb[type]; if (dcb == NULL) @@ -664,6 +756,8 @@ static void __handle_low_battery_mode(GDBusConnection *connection, const gchar * dcb(TETHERING_ERROR_NONE, type, code, data); } + + TETHERING_UNLOCK; DBG("-\n"); } @@ -672,6 +766,7 @@ static void __handle_flight_mode(GDBusConnection *connection, const gchar *sende GVariant *parameters, gpointer user_data) { DBG("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); @@ -681,6 +776,12 @@ static void __handle_flight_mode(GDBusConnection *connection, const gchar *sende void *data = NULL; tethering_disabled_cause_e code = TETHERING_DISABLED_BY_FLIGHT_MODE; + if (!_tethering_check_handle(th)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; + return; + } + for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) { dcb = th->disabled_cb[type]; if (dcb == NULL) @@ -689,6 +790,8 @@ static void __handle_flight_mode(GDBusConnection *connection, const gchar *sende dcb(TETHERING_ERROR_NONE, type, code, data); } + + TETHERING_UNLOCK; DBG("-\n"); } @@ -698,6 +801,7 @@ static void __handle_security_type_changed(GDBusConnection *connection, const gc { DBG("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); __tethering_h *th = (__tethering_h *)user_data; @@ -707,9 +811,17 @@ static void __handle_security_type_changed(GDBusConnection *connection, const gc tethering_wifi_security_type_e security_type; char *buf = NULL; + if (!_tethering_check_handle(th)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; + return; + } + scb = th->security_type_changed_cb; - if (scb == NULL) + if (scb == NULL) { + TETHERING_UNLOCK; return; + } g_variant_get(parameters, "(s)", &buf); data = th->security_type_user_data; @@ -724,11 +836,13 @@ static void __handle_security_type_changed(GDBusConnection *connection, const gc else { SERR("Unknown type : %s\n", buf); g_free(buf); + TETHERING_UNLOCK; return; } g_free(buf); scb(security_type, data); + TETHERING_UNLOCK; return; } @@ -737,6 +851,7 @@ static void __handle_ssid_visibility_changed(GDBusConnection *connection, const GVariant *parameters, gpointer user_data) { DBG("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); __tethering_h *th = (__tethering_h *)user_data; @@ -746,8 +861,15 @@ static void __handle_ssid_visibility_changed(GDBusConnection *connection, const bool visible = false; char *buf = NULL; + if (!_tethering_check_handle(th)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; + return; + } + scb = th->ssid_visibility_changed_cb; if (scb == NULL) { + TETHERING_UNLOCK; DBG("-\n"); return; } @@ -758,6 +880,8 @@ static void __handle_ssid_visibility_changed(GDBusConnection *connection, const scb(visible, data); g_free(buf); + + TETHERING_UNLOCK; DBG("-\n"); } @@ -766,6 +890,7 @@ static void __handle_passphrase_changed(GDBusConnection *connection, const gchar GVariant *parameters, gpointer user_data) { DBG("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); __tethering_h *th = (__tethering_h *)user_data; @@ -773,13 +898,23 @@ static void __handle_passphrase_changed(GDBusConnection *connection, const gchar tethering_wifi_passphrase_changed_cb pcb = NULL; void *data = NULL; + if (!_tethering_check_handle(th)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; + return; + } + pcb = th->passphrase_changed_cb; - if (pcb == NULL) + if (pcb == NULL) { + TETHERING_UNLOCK; return; + } data = th->passphrase_user_data; pcb(data); + + TETHERING_UNLOCK; DBG("-\n"); } @@ -787,6 +922,7 @@ static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, gpointer user_data) { INFO("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); GError *g_error = NULL; @@ -799,8 +935,11 @@ static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, tethering_enabled_cb ecb = th->enabled_cb[type]; void *data = th->enabled_user_data[type]; - if (!_tethering_check_handle((tethering_h)user_data)) + if (!_tethering_check_handle((tethering_h)user_data)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; return; + } g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error); if (g_error) { @@ -809,6 +948,7 @@ static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, ++retry < TETHERING_ERROR_RECOVERY_MAX) { g_error_free(g_error); tethering_enable((tethering_h)th, type); + TETHERING_UNLOCK; return; } else if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED) error = TETHERING_ERROR_PERMISSION_DENIED; @@ -831,11 +971,14 @@ static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, SINFO("Tethering enabled event ! error(%d)", error); if (!ecb) { + TETHERING_UNLOCK; INFO("-\n"); return; } ecb(error, type, true, data); g_variant_unref(g_var); + + TETHERING_UNLOCK; INFO("-\n"); } @@ -843,6 +986,8 @@ static void __bt_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, gpointer user_data) { DBG("+\n"); + TETHERING_LOCK; + _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); GError *g_error = NULL; GVariant *g_var; @@ -853,8 +998,11 @@ static void __bt_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_BT]; void *data = th->enabled_user_data[TETHERING_TYPE_BT]; - if (!_tethering_check_handle((tethering_h)user_data)) + if (!_tethering_check_handle((tethering_h)user_data)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; return; + } g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error); if (g_error) { @@ -863,6 +1011,7 @@ static void __bt_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, ++retry < TETHERING_ERROR_RECOVERY_MAX) { g_error_free(g_error); tethering_enable((tethering_h)th, TETHERING_TYPE_BT); + TETHERING_UNLOCK; DBG("-\n"); return; } @@ -884,11 +1033,14 @@ static void __bt_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, sigs[E_SIGNAL_BT_TETHER_ON].cb, (gpointer)th, NULL); if (!ecb) { + TETHERING_UNLOCK; DBG("-\n"); return; } ecb(error, TETHERING_TYPE_BT, true, data); + + TETHERING_UNLOCK; DBG("-\n"); } @@ -896,6 +1048,7 @@ static void __usb_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, gpointer user_data) { DBG("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); __tethering_h *th = (__tethering_h *)user_data; @@ -906,8 +1059,11 @@ static void __usb_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_USB]; void *data = th->enabled_user_data[TETHERING_TYPE_USB]; - if (!_tethering_check_handle((tethering_h)user_data)) + if (!_tethering_check_handle((tethering_h)user_data)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; return; + } g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error); if (g_error) { @@ -916,6 +1072,7 @@ static void __usb_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, ++retry < TETHERING_ERROR_RECOVERY_MAX) { g_error_free(g_error); tethering_enable((tethering_h)th, TETHERING_TYPE_USB); + TETHERING_UNLOCK; DBG("-\n"); return; } @@ -937,11 +1094,14 @@ static void __usb_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, sigs[E_SIGNAL_USB_TETHER_ON].cb, (gpointer)th, NULL); if (!ecb) { + TETHERING_UNLOCK; DBG("-\n"); return; } ecb(error, TETHERING_TYPE_USB, true, data); + + TETHERING_UNLOCK; DBG("-\n"); } @@ -949,6 +1109,7 @@ static void __p2p_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, gpointer user_data) { DBG("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); __tethering_h *th = (__tethering_h *)user_data; @@ -959,8 +1120,11 @@ static void __p2p_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_P2P]; void *data = th->enabled_user_data[TETHERING_TYPE_P2P]; - if (!_tethering_check_handle((tethering_h)user_data)) + if (!_tethering_check_handle((tethering_h)user_data)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; return; + } g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error); if (g_error) { @@ -969,6 +1133,7 @@ static void __p2p_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, ++retry < TETHERING_ERROR_RECOVERY_MAX) { g_error_free(g_error); tethering_enable((tethering_h)th, TETHERING_TYPE_P2P); + TETHERING_UNLOCK; DBG("-\n"); return; } @@ -985,11 +1150,14 @@ static void __p2p_enabled_cfm_cb(GObject *source_object, GAsyncResult *res, retry = 0; if (!ecb) { + TETHERING_UNLOCK; DBG("-\n"); return; } ecb(error, TETHERING_TYPE_P2P, true, data); + + TETHERING_UNLOCK; DBG("-\n"); } @@ -997,6 +1165,7 @@ static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res, gpointer user_data) { INFO("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); GError *g_error = NULL; @@ -1010,13 +1179,17 @@ static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res, tethering_disabled_cb dcb = NULL; void *data = NULL; - if (!_tethering_check_handle((tethering_h)user_data)) + if (!_tethering_check_handle((tethering_h)user_data)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; return; + } g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error); if (g_error) { ERR("DBus error [%s]\n", g_error->message); g_error_free(g_error); + TETHERING_UNLOCK; return; } g_variant_get(g_var, "(uu)", &event_type, &info); @@ -1101,6 +1274,8 @@ static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res, ERR("Invalid event\n"); break; } + + TETHERING_UNLOCK; INFO("-\n"); } @@ -1108,6 +1283,7 @@ static void __get_data_usage_cb(GObject *source_object, GAsyncResult *res, gpointer user_data) { DBG("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); @@ -1119,6 +1295,12 @@ static void __get_data_usage_cb(GObject *source_object, GAsyncResult *res, tethering_error_e tethering_error = TETHERING_ERROR_NONE; bool flag = false; + if (!_tethering_check_handle((tethering_h)user_data)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; + return; + } + g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error); if (g_error) { ERR("DBus fail [%s]\n", g_error->message); @@ -1131,6 +1313,7 @@ static void __get_data_usage_cb(GObject *source_object, GAsyncResult *res, } if (th->data_usage_cb == NULL) { ERR("There is no data_usage_cb\n"); + TETHERING_UNLOCK; return; } if (flag) { @@ -1144,6 +1327,7 @@ static void __get_data_usage_cb(GObject *source_object, GAsyncResult *res, th->data_usage_cb = NULL; th->data_usage_user_data = NULL; + TETHERING_UNLOCK; DBG("-\n"); } @@ -1151,6 +1335,7 @@ static void __settings_reloaded_cb(GObject *source_object, GAsyncResult *res, gpointer user_data) { DBG("+\n"); + TETHERING_LOCK; _retm_if(user_data == NULL, "parameter(user_data) is NULL\n"); GError *g_error = NULL; @@ -1159,6 +1344,12 @@ static void __settings_reloaded_cb(GObject *source_object, GAsyncResult *res, __tethering_h *th = (__tethering_h *)user_data; tethering_error_e tethering_error = TETHERING_ERROR_NONE; + if (!_tethering_check_handle((tethering_h)user_data)) { + DBG("Tethering handle is not valid now, ignore it."); + TETHERING_UNLOCK; + return; + } + g_var = g_dbus_proxy_call_finish(th->client_bus_proxy, res, &g_error); if (g_error) { ERR("DBus fail [%s]\n", g_error->message); @@ -1176,6 +1367,7 @@ static void __settings_reloaded_cb(GObject *source_object, GAsyncResult *res, if (th->settings_reloaded_cb == NULL) { DBG("There is no settings_reloaded_cb\n-\n"); + TETHERING_UNLOCK; return; } @@ -1184,6 +1376,8 @@ static void __settings_reloaded_cb(GObject *source_object, GAsyncResult *res, th->settings_reloaded_cb = NULL; th->settings_reloaded_user_data = NULL; + + TETHERING_UNLOCK; DBG("-\n"); } diff --git a/src/tethering_private.c b/src/tethering_private.c index b169250..aa81905 100755 --- a/src/tethering_private.c +++ b/src/tethering_private.c @@ -14,26 +14,47 @@ * limitations under the License. */ +#define _GNU_SOURCE +#include #include #include #include #include "tethering_private.h" -static __thread bool is_feature_checked[TETHERING_SUPPORTED_FEATURE_MAX] = {0, }; -static __thread bool feature_supported[TETHERING_SUPPORTED_FEATURE_MAX] = {0, }; -static __thread GSList *tethering_handle_list = NULL; +static pthread_mutex_t g_tethering_thread_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; +static bool is_feature_checked[TETHERING_SUPPORTED_FEATURE_MAX] = {0, }; +static bool feature_supported[TETHERING_SUPPORTED_FEATURE_MAX] = {0, }; +static GSList *tethering_handle_list = NULL; + +void _tethering_lock(void) +{ + pthread_mutex_lock(&g_tethering_thread_mutex); +} + +void _tethering_unlock(void) +{ + pthread_mutex_unlock(&g_tethering_thread_mutex); +} bool __check_feature_supported(const char *key, tethering_supported_feature_e feature) { + TETHERING_LOCK; + bool is_supported = false; + if (!is_feature_checked[feature]) { if (system_info_get_platform_bool(key, &feature_supported[feature]) < 0) { ERR("Get feature is failed"); + TETHERING_UNLOCK; return false; } is_feature_checked[feature] = true; } - return feature_supported[feature]; + + is_supported = feature_supported[feature]; + + TETHERING_UNLOCK; + return is_supported; } int _tethering_check_feature_supported(const char* feature, ...) @@ -75,19 +96,28 @@ int _tethering_check_feature_supported(const char* feature, ...) void _tethering_add_handle(tethering_h handle) { + TETHERING_LOCK; tethering_handle_list = g_slist_append(tethering_handle_list, handle); + TETHERING_UNLOCK; } void _tethering_remove_handle(tethering_h handle) { + TETHERING_LOCK; tethering_handle_list = g_slist_remove(tethering_handle_list, handle); + TETHERING_UNLOCK; } bool _tethering_check_handle(tethering_h handle) { - if (g_slist_find(tethering_handle_list, handle) != NULL) + TETHERING_LOCK; + + if (g_slist_find(tethering_handle_list, handle) != NULL) { + TETHERING_UNLOCK; return true; - else - return false; + } + + TETHERING_UNLOCK; + return false; } -- 2.34.1