const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
GVariant *parameters, gpointer user_data);
+static void __handle_p2p_tether_on(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data);
+
+static void __handle_p2p_tether_off(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data);
+
static void __handle_usb_tether_on(GDBusConnection *connection, const gchar *sender_name,
const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
GVariant *parameters, gpointer user_data);
{0, SIGNAL_NAME_NET_CLOSED, __handle_net_closed},
{0, SIGNAL_NAME_WIFI_TETHER_ON, __handle_wifi_tether_on},
{0, SIGNAL_NAME_WIFI_TETHER_OFF, __handle_wifi_tether_off},
+ {0, SIGNAL_NAME_P2P_TETHER_ON, __handle_p2p_tether_on},
+ {0, SIGNAL_NAME_P2P_TETHER_OFF, __handle_p2p_tether_off},
{0, SIGNAL_NAME_USB_TETHER_ON, __handle_usb_tether_on},
{0, SIGNAL_NAME_USB_TETHER_OFF, __handle_usb_tether_off},
{0, SIGNAL_NAME_BT_TETHER_ON, __handle_bt_tether_on},
static int retry = 0;
static int is_dualband_support = DUAL_BAND_NONE;
-static __thread tethering_request_table_t request_table[TETHERING_TYPE_MAX];
static void __reset_dualband_support(void)
{
{
if (tethering_is_enabled(tethering, TETHERING_TYPE_USB) ||
tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) ||
- tethering_is_enabled(tethering, TETHERING_TYPE_WIFI_SHARING) ||
tethering_is_enabled(tethering, TETHERING_TYPE_BT) ||
tethering_is_enabled(tethering, TETHERING_TYPE_P2P))
return true;
if (ptr == NULL)
return false;
- if (!g_strcmp0(ptr, ""))
+ if (!g_strcmp0(ptr, "")) {
+ free(ptr);
return false;
+ }
if (!g_utf8_validate(ptr, -1, (const char **)&ptr_tmp))
*ptr_tmp = '\0';
return err;
}
+static tethering_type_e __convert_to_tethering_type(mobile_ap_type_e type)
+{
+ switch (type) {
+ case MOBILE_AP_TYPE_USB:
+ return TETHERING_TYPE_USB;
+ case MOBILE_AP_TYPE_WIFI:
+ return TETHERING_TYPE_WIFI;
+ case MOBILE_AP_TYPE_BT:
+ return TETHERING_TYPE_BT;
+ case MOBILE_AP_TYPE_P2P:
+ return TETHERING_TYPE_P2P;
+ default:
+ return TETHERING_TYPE_MAX;
+ }
+}
+
+static void __invoke_enable_cb(__tethering_h *th, tethering_type_e type, bool is_requested)
+{
+ if (th == NULL || th->enabled_cb[type] == NULL) {
+ ERR("th or enabled_cb is NULL");
+ return;
+ }
+
+ tethering_enabled_cb ecb = NULL;
+ void *data = NULL;
+
+ if (!_tethering_check_handle(th)) {
+ DBG("Tethering handle is not valid now, ignore it.");
+ return;
+ }
+
+ ecb = th->enabled_cb[type];
+ data = th->enabled_user_data[type];
+ ecb(TETHERING_ERROR_NONE, type, is_requested, data);
+}
+
+static int __get_disabled_cause_by_interface_error(tethering_type_e type)
+{
+ switch (type) {
+ case TETHERING_TYPE_USB:
+ return TETHERING_DISABLED_BY_USB_DISCONNECTION;
+ case TETHERING_TYPE_WIFI:
+ return TETHERING_DISABLED_BY_WIFI_ON;
+ case TETHERING_TYPE_BT:
+ return TETHERING_DISABLED_BY_BT_OFF;
+ default:
+ return TETHERING_DISABLED_BY_OTHERS;
+ }
+}
+
+static void __invoke_disabled_cb(__tethering_h *th, tethering_type_e type, GVariant *parameters)
+{
+ if (th == NULL || th->disabled_cb[type] == NULL) {
+ ERR("th or disabled_cb is NULL");
+ return;
+ }
+
+ tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
+ tethering_disabled_cb dcb = NULL;
+ void *data = NULL;
+ char *buf = NULL;
+
+ if (!_tethering_check_handle(th)) {
+ DBG("Tethering handle is not valid now, ignore it.");
+ return;
+ }
+
+ dcb = th->disabled_cb[type];
+ data = th->disabled_user_data[type];
+
+ g_variant_get(parameters, "(s)", &buf);
+ if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
+ code = __get_disabled_cause_by_interface_error(type);
+ else if (!g_strcmp0(buf, SIGNAL_MSG_TIMEOUT))
+ code = TETHERING_DISABLED_BY_TIMEOUT;
+
+ dcb(TETHERING_ERROR_NONE, type, code, data);
+ g_free(buf);
+}
+
+static void __invoke_disabled_cbs(__tethering_h *th, tethering_disabled_cause_e code)
+{
+ if (th == NULL) {
+ ERR("th is NULL");
+ return;
+ }
+
+ if (!_tethering_check_handle(th)) {
+ DBG("Tethering handle is not valid now, ignore it.");
+ return;
+ }
+
+ for (tethering_type_e type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
+ tethering_disabled_cb dcb = th->disabled_cb[type];
+ if (dcb == NULL)
+ continue;
+ void *data = th->disabled_user_data[type];
+ dcb(TETHERING_ERROR_NONE, type, code, data);
+ }
+}
+
static void __handle_dhcp(GDBusConnection *connection, const gchar *sender_name,
const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
+ TETHERING_LOCK;
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
+ if (user_data == NULL) {
+ ERR("parameter(user_data) is NULL");
+ TETHERING_UNLOCK;
+ return;
+ }
__tethering_h *th = (__tethering_h *)user_data;
bool opened = false;
goto DONE;
}
- if (ap_type == MOBILE_AP_TYPE_USB)
- type = TETHERING_TYPE_USB;
- else if (ap_type == MOBILE_AP_TYPE_WIFI) {
- if (request_table[TETHERING_TYPE_WIFI_SHARING].flag)
- type = TETHERING_TYPE_WIFI_SHARING;
- else
- type = TETHERING_TYPE_WIFI;
- } else if (ap_type == MOBILE_AP_TYPE_BT)
- type = TETHERING_TYPE_BT;
- else if (ap_type == MOBILE_AP_TYPE_P2P)
- type = TETHERING_TYPE_P2P;
- else {
+ type = __convert_to_tethering_type(ap_type);
+ if (type == TETHERING_TYPE_MAX) {
ERR("Not supported tethering type [%d]\n", ap_type);
goto DONE;
}
g_free(ip);
g_free(mac);
g_free(name);
+
+ TETHERING_UNLOCK;
DBG("-\n");
}
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
-
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
-
- __tethering_h *th = (__tethering_h *)user_data;
- tethering_type_e type = 0;
- tethering_disabled_cb dcb = NULL;
- void *data = NULL;
- tethering_disabled_cause_e code = TETHERING_DISABLED_BY_NETWORK_CLOSE;
-
+ TETHERING_LOCK;
SINFO("Tethering Disabled by network close !");
-
- for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
- dcb = th->disabled_cb[type];
- if (dcb == NULL)
- continue;
- data = th->disabled_user_data[type];
-
- dcb(TETHERING_ERROR_NONE, type, code, data);
- }
-
+ __invoke_disabled_cbs((__tethering_h *)user_data, TETHERING_DISABLED_BY_NETWORK_CLOSE);
+ TETHERING_UNLOCK;
DBG("-\n");
}
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
-
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
-
- __tethering_h *th = (__tethering_h *)user_data;
- tethering_type_e type = TETHERING_TYPE_WIFI;
- bool is_requested = false;
- tethering_enabled_cb ecb = NULL;
- void *data = NULL;
-
- ecb = th->enabled_cb[type];
- if (ecb == NULL)
- return;
- data = th->enabled_user_data[type];
-
- ecb(TETHERING_ERROR_NONE, type, is_requested, data);
+ TETHERING_LOCK;
+ __invoke_enable_cb((__tethering_h *)user_data, TETHERING_TYPE_WIFI, false);
+ TETHERING_UNLOCK;
DBG("-\n");
}
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
+ TETHERING_LOCK;
+ __invoke_disabled_cb((__tethering_h *)user_data, TETHERING_TYPE_WIFI, parameters);
+ TETHERING_UNLOCK;
+ DBG("-\n");
+}
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
-
- __tethering_h *th = (__tethering_h *)user_data;
- tethering_type_e type = TETHERING_TYPE_WIFI;
- tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
- tethering_disabled_cb dcb = NULL;
- void *data = NULL;
- char *buf = NULL;
-
- dcb = th->disabled_cb[type];
- if (dcb == NULL)
- return;
- data = th->disabled_user_data[type];
- g_variant_get(parameters, "(s)", &buf);
- if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
- code = TETHERING_DISABLED_BY_WIFI_ON;
- else if (!g_strcmp0(buf, SIGNAL_MSG_TIMEOUT))
- code = TETHERING_DISABLED_BY_TIMEOUT;
-
- g_free(buf);
- dcb(TETHERING_ERROR_NONE, type, code, data);
+static void __handle_p2p_tether_on(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data)
+{
+ DBG("+\n");
+ TETHERING_LOCK;
+ __invoke_enable_cb((__tethering_h *)user_data, TETHERING_TYPE_P2P, false);
+ TETHERING_UNLOCK;
+ DBG("-\n");
+}
+static void __handle_p2p_tether_off(GDBusConnection *connection, const gchar *sender_name,
+ const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
+ GVariant *parameters, gpointer user_data)
+{
+ DBG("+\n");
+ TETHERING_LOCK;
+ __invoke_disabled_cb((__tethering_h *)user_data, TETHERING_TYPE_P2P, parameters);
+ TETHERING_UNLOCK;
DBG("-\n");
}
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
-
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
-
- __tethering_h *th = (__tethering_h *)user_data;
- tethering_type_e type = TETHERING_TYPE_USB;
- bool is_requested = false;
- tethering_enabled_cb ecb = NULL;
- void *data = NULL;
-
- ecb = th->enabled_cb[type];
- if (ecb == NULL)
- return;
- data = th->enabled_user_data[type];
-
- ecb(TETHERING_ERROR_NONE, type, is_requested, data);
+ TETHERING_LOCK;
+ __invoke_enable_cb((__tethering_h *)user_data, TETHERING_TYPE_USB, false);
+ TETHERING_UNLOCK;
DBG("-\n");
}
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
-
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
-
- __tethering_h *th = (__tethering_h *)user_data;
- tethering_type_e type = TETHERING_TYPE_USB;
- tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
- tethering_disabled_cb dcb = NULL;
- void *data = NULL;
- char *buf = NULL;
-
- dcb = th->disabled_cb[type];
- if (dcb == NULL)
- return;
- data = th->disabled_user_data[type];
-
- g_variant_get(parameters, "(s)", &buf);
- if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
- code = TETHERING_DISABLED_BY_USB_DISCONNECTION;
-
- dcb(TETHERING_ERROR_NONE, type, code, data);
- g_free(buf);
+ TETHERING_LOCK;
+ __invoke_disabled_cb((__tethering_h *)user_data, TETHERING_TYPE_USB, parameters);
+ TETHERING_UNLOCK;
DBG("-\n");
}
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
-
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
-
- __tethering_h *th = (__tethering_h *)user_data;
- tethering_type_e type = TETHERING_TYPE_BT;
- bool is_requested = false;
- tethering_enabled_cb ecb = NULL;
- void *data = NULL;
-
- ecb = th->enabled_cb[type];
- if (ecb == NULL)
- return;
- data = th->enabled_user_data[type];
-
- ecb(TETHERING_ERROR_NONE, type, is_requested, data);
+ TETHERING_LOCK;
+ __invoke_enable_cb((__tethering_h *)user_data, TETHERING_TYPE_BT, false);
+ TETHERING_UNLOCK;
DBG("-\n");
}
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
-
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
-
- __tethering_h *th = (__tethering_h *)user_data;
- tethering_type_e type = TETHERING_TYPE_BT;
- tethering_disabled_cause_e code = TETHERING_DISABLED_BY_OTHERS;
- tethering_disabled_cb dcb = NULL;
- void *data = NULL;
- char *buf = NULL;
-
- dcb = th->disabled_cb[type];
- if (dcb == NULL)
- return;
- data = th->disabled_user_data[type];
- g_variant_get(parameters, "(s)", &buf);
- if (!g_strcmp0(buf, SIGNAL_MSG_NOT_AVAIL_INTERFACE))
- code = TETHERING_DISABLED_BY_BT_OFF;
- else if (!g_strcmp0(buf, SIGNAL_MSG_TIMEOUT))
- code = TETHERING_DISABLED_BY_TIMEOUT;
-
- dcb(TETHERING_ERROR_NONE, type, code, data);
-
- g_free(buf);
+ TETHERING_LOCK;
+ __invoke_disabled_cb((__tethering_h *)user_data, TETHERING_TYPE_BT, parameters);
+ TETHERING_UNLOCK;
DBG("-\n");
}
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
-
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
-
- __tethering_h *th = (__tethering_h *)user_data;
- tethering_type_e type = 0;
- tethering_disabled_cb dcb = NULL;
- void *data = NULL;
- tethering_disabled_cause_e code = TETHERING_DISABLED_BY_TIMEOUT;
-
- for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
- dcb = th->disabled_cb[type];
- if (dcb == NULL)
- continue;
- data = th->disabled_user_data[type];
-
- dcb(TETHERING_ERROR_NONE, type, code, data);
- }
+ TETHERING_LOCK;
+ __invoke_disabled_cbs((__tethering_h *)user_data, TETHERING_DISABLED_BY_TIMEOUT);
+ TETHERING_UNLOCK;
DBG("-\n");
}
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
-
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
-
- __tethering_h *th = (__tethering_h *)user_data;
- tethering_type_e type = 0;
- tethering_disabled_cb dcb = NULL;
- void *data = NULL;
- tethering_disabled_cause_e code = TETHERING_DISABLED_BY_LOW_BATTERY;
-
- for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
- dcb = th->disabled_cb[type];
- if (dcb == NULL)
- continue;
- data = th->disabled_user_data[type];
-
- dcb(TETHERING_ERROR_NONE, type, code, data);
- }
+ TETHERING_LOCK;
+ __invoke_disabled_cbs((__tethering_h *)user_data, TETHERING_DISABLED_BY_LOW_BATTERY);
+ TETHERING_UNLOCK;
DBG("-\n");
}
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
-
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
-
- __tethering_h *th = (__tethering_h *)user_data;
- tethering_type_e type = 0;
- tethering_disabled_cb dcb = NULL;
- void *data = NULL;
- tethering_disabled_cause_e code = TETHERING_DISABLED_BY_FLIGHT_MODE;
-
- for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
- dcb = th->disabled_cb[type];
- if (dcb == NULL)
- continue;
- data = th->disabled_user_data[type];
-
- dcb(TETHERING_ERROR_NONE, type, code, data);
- }
+ TETHERING_LOCK;
+ __invoke_disabled_cbs((__tethering_h *)user_data, TETHERING_DISABLED_BY_FLIGHT_MODE);
+ TETHERING_UNLOCK;
DBG("-\n");
}
{
DBG("+\n");
+ TETHERING_LOCK;
+
+ if (user_data == NULL) {
+ ERR("parameter(user_data) is NULL");
+ TETHERING_UNLOCK;
+ return;
+ }
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
__tethering_h *th = (__tethering_h *)user_data;
tethering_wifi_security_type_changed_cb scb = NULL;
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;
else {
SERR("Unknown type : %s\n", buf);
g_free(buf);
+ TETHERING_UNLOCK;
return;
}
g_free(buf);
scb(security_type, data);
+ TETHERING_UNLOCK;
return;
}
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
+ TETHERING_LOCK;
+
+ if (user_data == NULL) {
+ ERR("parameter(user_data) is NULL");
+ TETHERING_UNLOCK;
+ return;
+ }
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
__tethering_h *th = (__tethering_h *)user_data;
tethering_wifi_ssid_visibility_changed_cb scb = NULL;
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;
}
scb(visible, data);
g_free(buf);
+
+ TETHERING_UNLOCK;
DBG("-\n");
}
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
+ TETHERING_LOCK;
+
+ if (user_data == NULL) {
+ ERR("parameter(user_data) is NULL");
+ TETHERING_UNLOCK;
+ return;
+ }
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
__tethering_h *th = (__tethering_h *)user_data;
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");
}
gpointer user_data)
{
INFO("+\n");
+ TETHERING_LOCK;
+
+ if (user_data == NULL) {
+ ERR("parameter(user_data) is NULL");
+ TETHERING_UNLOCK;
+ return;
+ }
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
GError *g_error = NULL;
GVariant *g_var;
guint info;
- tethering_type_e type = 0;
+ tethering_type_e type = TETHERING_TYPE_WIFI;
tethering_error_e error;
__tethering_h *th = (__tethering_h *)user_data;
- if (request_table[TETHERING_TYPE_WIFI_SHARING].flag)
- type = TETHERING_TYPE_WIFI_SHARING;
- else
- type = TETHERING_TYPE_WIFI;
-
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) {
++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;
g_error_free(g_error);
} else {
g_variant_get(g_var, "(u)", &info);
+ g_variant_unref(g_var);
error = __get_error(info);
}
retry = 0;
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");
}
gpointer user_data)
{
DBG("+\n");
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
+ TETHERING_LOCK;
+
+ if (user_data == NULL) {
+ ERR("parameter(user_data) is NULL");
+ TETHERING_UNLOCK;
+ return;
+ }
+
GError *g_error = NULL;
GVariant *g_var;
guint info;
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) {
++retry < TETHERING_ERROR_RECOVERY_MAX) {
g_error_free(g_error);
tethering_enable((tethering_h)th, TETHERING_TYPE_BT);
+ TETHERING_UNLOCK;
DBG("-\n");
return;
}
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");
}
gpointer user_data)
{
DBG("+\n");
+ TETHERING_LOCK;
+
+ if (user_data == NULL) {
+ ERR("parameter(user_data) is NULL");
+ TETHERING_UNLOCK;
+ return;
+ }
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
__tethering_h *th = (__tethering_h *)user_data;
GError *g_error = NULL;
GVariant *g_var;
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) {
++retry < TETHERING_ERROR_RECOVERY_MAX) {
g_error_free(g_error);
tethering_enable((tethering_h)th, TETHERING_TYPE_USB);
+ TETHERING_UNLOCK;
DBG("-\n");
return;
}
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");
}
gpointer user_data)
{
DBG("+\n");
+ TETHERING_LOCK;
+
+ if (user_data == NULL) {
+ ERR("parameter(user_data) is NULL");
+ TETHERING_UNLOCK;
+ return;
+ }
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
__tethering_h *th = (__tethering_h *)user_data;
GError *g_error = NULL;
GVariant *g_var;
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) {
++retry < TETHERING_ERROR_RECOVERY_MAX) {
g_error_free(g_error);
tethering_enable((tethering_h)th, TETHERING_TYPE_P2P);
+ TETHERING_UNLOCK;
DBG("-\n");
return;
}
retry = 0;
if (!ecb) {
+ TETHERING_UNLOCK;
DBG("-\n");
return;
}
ecb(error, TETHERING_TYPE_P2P, true, data);
+
+ TETHERING_UNLOCK;
DBG("-\n");
}
gpointer user_data)
{
INFO("+\n");
+ TETHERING_LOCK;
+
+ if (user_data == NULL) {
+ ERR("parameter(user_data) is NULL");
+ TETHERING_UNLOCK;
+ return;
+ }
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
GError *g_error = NULL;
GVariant *g_var;
guint info, event_type;
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);
ERR("Invalid event\n");
break;
}
+
+ TETHERING_UNLOCK;
INFO("-\n");
}
gpointer user_data)
{
DBG("+\n");
+ TETHERING_LOCK;
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
+ if (user_data == NULL) {
+ ERR("parameter(user_data) is NULL");
+ TETHERING_UNLOCK;
+ return;
+ }
GError *g_error = NULL;
GVariant *g_var;
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);
}
if (th->data_usage_cb == NULL) {
ERR("There is no data_usage_cb\n");
+ TETHERING_UNLOCK;
return;
}
if (flag) {
th->data_usage_cb = NULL;
th->data_usage_user_data = NULL;
+ TETHERING_UNLOCK;
DBG("-\n");
}
gpointer user_data)
{
DBG("+\n");
+ TETHERING_LOCK;
+
+ if (user_data == NULL) {
+ ERR("parameter(user_data) is NULL");
+ TETHERING_UNLOCK;
+ return;
+ }
- _retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
GError *g_error = NULL;
GVariant *g_var;
guint info;
__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);
if (th->settings_reloaded_cb == NULL) {
DBG("There is no settings_reloaded_cb\n-\n");
+ TETHERING_UNLOCK;
return;
}
th->settings_reloaded_cb = NULL;
th->settings_reloaded_user_data = NULL;
+
+ TETHERING_UNLOCK;
DBG("-\n");
}
}
}
- INFO("ssid: %s security: %d mode: %s channel: %d visibility: %s\n",
- set->ssid, set->sec_type, set->mode, set->channel,
- (set->visibility) ? "true" : "false");
+ if (strlen(th->ip_address))
+ g_strlcpy(set->ip_address, th->ip_address, sizeof(set->ip_address));
+ else
+ g_strlcpy(set->ip_address, TETHERING_WIFI_GATEWAY, sizeof(set->ip_address));
+
+ INFO("ssid: %s security: %d mode: %s "
+ "channel: %d visibility: %s ip_address: [%s]\n",
+ set->ssid, set->sec_type, set->mode, set->channel,
+ (set->visibility) ? "true" : "false",
+ set->ip_address);
INFO("-\n");
return TETHERING_ERROR_NONE;
}
-static bool __check_precondition(tethering_type_e type)
+static bool __check_precondition(__tethering_h *th, tethering_type_e type)
{
int dnet_status = 0;
int cellular_state = 0;
vconf_get_int(VCONFKEY_NETWORK_STATUS, &dnet_status);
if ((dnet_status == VCONFKEY_NETWORK_WIFI
&& type != TETHERING_TYPE_WIFI)
- || (dnet_status == VCONFKEY_NETWORK_ETHERNET
- && type != TETHERING_TYPE_WIFI_SHARING))
+ || (th->wifi_sharing && dnet_status == VCONFKEY_NETWORK_WIFI
+ && type == TETHERING_TYPE_WIFI)
+ || dnet_status == VCONFKEY_NETWORK_ETHERNET)
return TRUE;
ERR("Network is not available!");
return TETHERING_ERROR_NONE;
}
+static GVariant *__get_wifi_settings_dbus_params(const char *wifi_tether_type, _softap_settings_t *set)
+{
+ GVariantBuilder *builder = NULL;
+ GVariant *params = NULL;
+
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ if (builder == NULL) {
+ ERR("Failed to create builder");
+ return NULL;
+ }
+
+ g_variant_builder_add(builder, "{sv}",
+ "ssid",
+ g_variant_new_string(set->ssid));
+
+ if (set->sec_type != TETHERING_WIFI_SECURITY_TYPE_NONE)
+ g_variant_builder_add(builder, "{sv}",
+ "passphrase",
+ g_variant_new_string(set->key));
+
+ if (!g_strcmp0(set->mode, "b")) {
+ g_variant_builder_add(builder, "{sv}",
+ "mode", g_variant_new_int32(0));
+ } else if (!g_strcmp0(set->mode, "g")) {
+ g_variant_builder_add(builder, "{sv}",
+ "mode", g_variant_new_int32(1));
+ } else if (!g_strcmp0(set->mode, "n")) {
+ g_variant_builder_add(builder, "{sv}",
+ "mode", g_variant_new_int32(2));
+ } else if (!g_strcmp0(set->mode, "ac")) {
+ g_variant_builder_add(builder, "{sv}",
+ "mode", g_variant_new_int32(3));
+ } else {
+ /* Do Nothing */
+ }
+
+ g_variant_builder_add(builder, "{sv}",
+ "visibility",
+ g_variant_new_boolean(set->visibility));
+
+ g_variant_builder_add(builder, "{sv}",
+ "channel",
+ g_variant_new_int32(set->channel));
+
+ g_variant_builder_add(builder, "{sv}",
+ "sec_type",
+ g_variant_new_int32(set->sec_type));
+
+ g_variant_builder_add(builder, "{sv}",
+ "mac_filter",
+ g_variant_new_boolean(set->mac_filter));
+
+ g_variant_builder_add(builder, "{sv}",
+ "max_sta",
+ g_variant_new_int32(set->max_connected));
+
+ g_variant_builder_add(builder, "{sv}",
+ "address_type",
+ g_variant_new_int32(TETHERING_ADDRESS_FAMILY_IPV4));
+
+ g_variant_builder_add(builder, "{sv}",
+ "txpower",
+ g_variant_new_int32(set->txpower));
+
+ if (strlen(set->ip_address))
+ g_variant_builder_add(builder, "{sv}",
+ "ip_address",
+ g_variant_new_string(set->ip_address));
+
+ if (wifi_tether_type)
+ g_variant_builder_add(builder, "{sv}",
+ "tether_type",
+ g_variant_new_string(wifi_tether_type));
+
+ params = g_variant_new("(@a{sv})", g_variant_builder_end(builder));
+ g_variant_builder_unref(builder);
+
+ return params;
+}
+
/**
* @internal
* @brief Enables the tethering, asynchronously.
INFO("+ type : %d\n", type);
CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
- else if (type == TETHERING_TYPE_WIFI || type == TETHERING_TYPE_WIFI_SHARING)
- CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+ else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
_retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
#endif /* TIZEN_TV_EXT */
- if (__check_precondition(type) == FALSE) {
+ if (__check_precondition(th, type) == FALSE) {
INFO("-\n");
g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
return TETHERING_ERROR_OPERATION_FAILED;
(GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
break;
- case TETHERING_TYPE_WIFI:
- case TETHERING_TYPE_WIFI_SHARING: {
- _softap_settings_t set = {"", "", "", 0, false};
+ case TETHERING_TYPE_WIFI: {
+ GVariant *params = NULL;
+ _softap_settings_t set;
+ memset(&set, 0, sizeof(_softap_settings_t));
ret = __prepare_wifi_settings(tethering, &set);
if (ret != TETHERING_ERROR_NONE) {
g_dbus_connection_signal_unsubscribe(connection,
sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
- SINFO("ssid %s, key %s, channel %d, mode %s, txpower %d, security %d max_device %d\n",
- set.ssid, set.key, set.channel, set.mode, set.txpower, set.sec_type,
- set.max_connected);
+ SINFO("ssid %s, key %s, channel %d, mode %s, "
+ "txpower %d, security %d, max_device %d, "
+ "ip_address [%s]\n",
+ set.ssid, set.key, set.channel, set.mode,
+ set.txpower, set.sec_type,
+ set.max_connected, set.ip_address);
- char key[TETHERING_WIFI_KEY_MAX_LEN + 1] = {0, };
- if (type == TETHERING_TYPE_WIFI_SHARING) {
- g_strlcpy(key, "wifi_sharing", TETHERING_WIFI_KEY_MAX_LEN);
- request_table[TETHERING_TYPE_WIFI_SHARING].flag = true;
- } else {
- g_strlcpy(key, "wifi_tether", TETHERING_WIFI_KEY_MAX_LEN);
- request_table[TETHERING_TYPE_WIFI].flag = true;
- }
+ if (th->wifi_sharing)
+ params = __get_wifi_settings_dbus_params("wifi_sharing", &set);
+ else
+ params = __get_wifi_settings_dbus_params("wifi_tether", &set);
- g_dbus_proxy_call(proxy, "enable_wifi_tethering",
- g_variant_new("(ssssiiiiiii)", key, set.ssid, set.key, set.mode,
- set.channel, set.visibility, set.mac_filter, set.max_connected,
- set.sec_type, set.txpower, TETHERING_ADDRESS_FAMILY_IPV4),
+ g_dbus_proxy_call(proxy, "enable_wifi_tethering", params,
G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
- (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
+ (GAsyncReadyCallback) __wifi_enabled_cfm_cb,
+ (gpointer)tethering);
break;
}
break;
case TETHERING_TYPE_P2P: {
- _softap_settings_t p2p_set = {"", "", "", 0, false};
+ _softap_settings_t p2p_set;
+ memset(&p2p_set, 0, sizeof(_softap_settings_t));
+
ret = __prepare_wifi_settings(tethering, &p2p_set);
if (ret != TETHERING_ERROR_NONE) {
ERR("p2p settings initialization failed\n");
}
case TETHERING_TYPE_ALL: {
- _softap_settings_t set = {"", "", "", 0, false};
+ GVariant *params = NULL;
+ _softap_settings_t set;
+ memset(&set, 0, sizeof(_softap_settings_t));
ret = __prepare_wifi_settings(tethering, &set);
if (ret != TETHERING_ERROR_NONE) {
g_dbus_connection_signal_unsubscribe(connection,
sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
- g_dbus_proxy_call(proxy, "enable_wifi_tethering",
- g_variant_new("(ssssiiiiiii)", "wifi_tether", set.ssid, set.key, set.mode,
- set.channel, set.visibility, set.mac_filter, set.max_connected,
- set.sec_type, set.txpower, TETHERING_ADDRESS_FAMILY_IPV4),
+ if (th->wifi_sharing)
+ params = __get_wifi_settings_dbus_params("wifi_sharing", &set);
+ else
+ params = __get_wifi_settings_dbus_params("wifi_tether", &set);
+
+ g_dbus_proxy_call(proxy, "enable_wifi_tethering", params,
G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
- (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
+ (GAsyncReadyCallback) __wifi_enabled_cfm_cb,
+ (gpointer)tethering);
/* TETHERING_TYPE_BT */
g_dbus_connection_signal_unsubscribe(connection,
g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
- if (__check_precondition(type) == FALSE) {
+ if (__check_precondition(th, type) == FALSE) {
DBG("-\n");
g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
return TETHERING_ERROR_OPERATION_FAILED;
break;
}
- case TETHERING_TYPE_WIFI:
- case TETHERING_TYPE_WIFI_SHARING: {
- _softap_settings_t set = {"", "", "", 0, false, false, 0, 0};
+ case TETHERING_TYPE_WIFI: {
+ GVariant *params = NULL;
+ _softap_settings_t set;
+ memset(&set, 0, sizeof(_softap_settings_t));
ret = __prepare_wifi_settings(tethering, &set);
if (ret != TETHERING_ERROR_NONE) {
set.ssid, set.key, set.channel, set.mode, set.txpower, set.sec_type,
set.max_connected);
- char key[TETHERING_WIFI_KEY_MAX_LEN + 1] = {0, };
- if (type == TETHERING_TYPE_WIFI_SHARING) {
- g_strlcpy(key, "wifi_sharing", TETHERING_WIFI_KEY_MAX_LEN);
- request_table[TETHERING_TYPE_WIFI_SHARING].flag = true;
- } else {
- g_strlcpy(key, "wifi_tether", TETHERING_WIFI_KEY_MAX_LEN);
- request_table[TETHERING_TYPE_WIFI].flag = true;
- }
+ char key[TETHERING_WIFI_KEY_MAX_LEN + 1] = "wifi_tether";
+ if (th->wifi_sharing)
+ g_strlcpy(key, "wifi_sharing", TETHERING_WIFI_KEY_MAX_LEN + 1);
+
+ SINFO("enable_wifi_tethering key: %s", key);
+ if (th->wifi_sharing)
+ params = __get_wifi_settings_dbus_params("wifi_sharing", &set);
+ else
+ params = __get_wifi_settings_dbus_params("wifi_tether", &set);
- g_dbus_proxy_call(proxy, "enable_wifi_tethering",
- g_variant_new("(ssssiiiiiii)", key, set.ssid, set.key, set.mode,
- set.channel, set.visibility, set.mac_filter, set.max_connected,
- set.sec_type, set.txpower, TETHERING_ADDRESS_FAMILY_IPV6),
+ g_dbus_proxy_call(proxy, "enable_wifi_tethering", params,
G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
- (GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
+ (GAsyncReadyCallback) __wifi_enabled_cfm_cb,
+ (gpointer)tethering);
break;
}
break;
case TETHERING_TYPE_WIFI:
- case TETHERING_TYPE_WIFI_SHARING:
DBG("Disable wifi tethering..");
g_dbus_connection_signal_unsubscribe(connection,
sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
break;
case TETHERING_TYPE_WIFI:
- case TETHERING_TYPE_WIFI_SHARING:
-
g_dbus_connection_signal_unsubscribe(connection,
sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
break;
case TETHERING_TYPE_WIFI:
- case TETHERING_TYPE_WIFI_SHARING:
vconf_type = VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI;
break;
_retvm_if(*ip_address == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
"Not enough memory\n");
+ if (type == TETHERING_TYPE_WIFI) {
+ __tethering_h *th = (__tethering_h *)tethering;
+ g_strlcpy(th->ip_address, *ip_address, sizeof(th->ip_address));
+ }
+
+ return TETHERING_ERROR_NONE;
+}
+
+/**
+ * @brief Sets the local IP address.
+ * @since_tizen 6.5
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/tethering.admin
+ * @remarks API is only available for TETHERING_TYPE_WIFI.
+ * @param[in] tethering The tethering handle
+ * @param[in] type The tethering type
+ * @param[in] address_family The address family of IP address (currently, #TETHERING_ADDRESS_FAMILY_IPV4 is only supported)
+ * @param[out] ip_address The local IP address
+ * @return 0 on success, otherwise negative error value
+ * @retval #TETHERING_ERROR_NONE Successful
+ * @retval #TETHERING_ERROR_INVALID_PARAMETER Invalid parameter
+ * @retval #TETHERING_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #TETHERING_ERROR_OPERATION_FAILED Operation failed
+ * @see tethering_enable()
+ */
+int tethering_set_ip_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, const char *ip_address)
+{
+ CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+ if (type == TETHERING_TYPE_WIFI)
+ CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+ else
+ return TETHERING_ERROR_INVALID_PARAMETER;
+
+ _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+ "parameter(tethering) is NULL\n");
+ _retvm_if(ip_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+ "parameter(ip_address) is NULL\n");
+
+ __tethering_h *th = (__tethering_h *)tethering;
+ int ip_len = 0;
+
+ if (address_family == TETHERING_ADDRESS_FAMILY_IPV4) {
+ ip_len = strlen(ip_address);
+ if (ip_len < TETHERING_IPV4_ADDRESS_MIN_LEN ||
+ ip_len > TETHERING_IPV4_ADDRESS_MAX_LEN) {
+ ERR("parameter(ip_address) is too short or long\n");
+ return TETHERING_ERROR_INVALID_PARAMETER;
+ }
+ g_strlcpy(th->ip_address, ip_address, sizeof(th->ip_address));
+ } else {
+ /* IPv6 is not supported yet. */
+ ERR("IPv6 address is not supported yet\n");
+ return TETHERING_ERROR_OPERATION_FAILED;
+ }
+
return TETHERING_ERROR_NONE;
}
else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
- _retvm_if(tethering_is_enabled(tethering, type) == false,
- TETHERING_ERROR_NOT_ENABLED,
- "tethering type[%d] is not enabled\n", type);
_retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
"parameter(tethering) is NULL\n");
_retvm_if(gateway_address == NULL, TETHERING_ERROR_INVALID_PARAMETER,
"parameter(gateway_address) is NULL\n");
+ _retvm_if(tethering_is_enabled(tethering, type) == false,
+ TETHERING_ERROR_NOT_ENABLED,
+ "tethering type[%d] is not enabled\n", type);
- char gateway_buf[TETHERING_STR_INFO_LEN] = {0, };
+ __tethering_h *th = (__tethering_h *)tethering;
- _retvm_if(!__get_gateway_addr(type, gateway_buf, sizeof(gateway_buf)),
- TETHERING_ERROR_OPERATION_FAILED,
- "getting gateway address is failed\n");
+ if (type == TETHERING_TYPE_WIFI && strlen(th->ip_address)) {
+ *gateway_address = strdup(th->ip_address);
- *gateway_address = strdup(gateway_buf);
+ } else {
+ char gateway_buf[TETHERING_STR_INFO_LEN] = {0, };
+
+ _retvm_if(!__get_gateway_addr(type, gateway_buf,
+ sizeof(gateway_buf)),
+ TETHERING_ERROR_OPERATION_FAILED,
+ "getting gateway address is failed\n");
+
+ *gateway_address = strdup(gateway_buf);
+ }
return TETHERING_ERROR_NONE;
}
API int tethering_is_dualband_supported(tethering_h tethering, tethering_type_e type, bool *supported)
{
CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
- if (type == TETHERING_TYPE_WIFI || type == TETHERING_TYPE_WIFI_SHARING)
- CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+ CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
_retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
"parameter(tethering) is NULL\n");
{
CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
- else if (type == TETHERING_TYPE_WIFI || type == TETHERING_TYPE_WIFI_SHARING)
- CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+ else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
_retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
while (g_variant_iter_loop(inner_iter, "{sv}", &key, &value)) {
if (g_strcmp0(key, "Type") == 0) {
interface = g_variant_get_int32(value);
- if (interface == MOBILE_AP_TYPE_USB)
- client.interface = TETHERING_TYPE_USB;
- else if (interface == MOBILE_AP_TYPE_WIFI) {
- if (request_table[TETHERING_TYPE_WIFI_SHARING].flag)
- client.interface = TETHERING_TYPE_WIFI_SHARING;
- else
- client.interface = TETHERING_TYPE_WIFI;
-
- } else if (interface == MOBILE_AP_TYPE_BT)
- client.interface = TETHERING_TYPE_BT;
- else if (interface == MOBILE_AP_TYPE_P2P)
- client.interface = TETHERING_TYPE_P2P;
- else {
+ tethering_type_e converted_type = __convert_to_tethering_type(interface);
+ if (converted_type == TETHERING_TYPE_MAX) {
ERR("Invalid interface\n");
g_free(key);
g_variant_unref(value);
break;
+ } else {
+ client.interface = converted_type;
}
+
DBG("interface is %d\n", client.interface);
if (client.interface != type && (TETHERING_TYPE_ALL != type)) {
g_free(key);
INFO("+ type: %d\n", type);
CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
- else if (type == TETHERING_TYPE_WIFI || type == TETHERING_TYPE_WIFI_SHARING)
- CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+ else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
_retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
{
CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
- else if (type == TETHERING_TYPE_WIFI || type == TETHERING_TYPE_WIFI_SHARING)
- CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+ else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
_retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
INFO("+ type: %d\n", type);
CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
- else if (type == TETHERING_TYPE_WIFI || type == TETHERING_TYPE_WIFI_SHARING)
- CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+ else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
_retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
{
CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
- else if (type == TETHERING_TYPE_WIFI || type == TETHERING_TYPE_WIFI_SHARING)
- CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+ else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
_retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
INFO("+ type: %d\n", type);
CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
- else if (type == TETHERING_TYPE_WIFI || type == TETHERING_TYPE_WIFI_SHARING)
- CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+ else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
_retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
{
CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE);
- else if (type == TETHERING_TYPE_WIFI || type == TETHERING_TYPE_WIFI_SHARING)
- CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+ else if (type == TETHERING_TYPE_WIFI) CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
_retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
ret = TETHERING_ERROR_OPERATION_FAILED;
g_error_free(error);
+ free(p_ssid);
return ret;
}
__tethering_h *th = (__tethering_h *)tethering;
#ifdef TIZEN_TV_EXT
GDBusProxy *proxy = th->client_bus_proxy;
- GVariant *parameters;
+ GVariant *parameters = NULL;
GError *error = NULL;
- int ch, vconf_channel;
+ int ch = -1;
+ int vconf_channel = -1;
tethering_error_e ret = TETHERING_ERROR_NONE;
parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_tethering_channel",
"parameter(callback) is NULL\n");
__tethering_h *th = (__tethering_h *)tethering;
- _softap_settings_t set = {"", "", "", 0, false};
+ _softap_settings_t set;
GDBusProxy *proxy = th->client_bus_proxy;
int ret = 0;
+ memset(&set, 0, sizeof(_softap_settings_t));
+
DBG("+\n");
if (th->settings_reloaded_cb) {
parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_interfaces",
NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
- if (!parameters && error) {
+ if (error) {
ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
projects / platform / core / api / tethering.git / blobdiff