* limitations under the License.
*/
+#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dbus/dbus.h>
#include <gio/gio.h>
#include <vconf.h>
-#include <openssl/evp.h>
-#include <openssl/sha.h>
#include <ckmc/ckmc-manager.h>
#include <tzplatform_config.h>
#include "tethering_private.h"
#define MAC_ADDR_LEN 18
#define MAX_BUF_SIZE 80
+#ifdef TIZEN_TV_EXT
+#define VCONFKEY_WIFI_TXPOWER "db/dnet/txpower" /**< VCONFKEY for TX Power */
+#define VCONFKEY_WIFI_CHANNEL "db/dnet/channel" /**< VCONFKEY for Channel */
+#define VCONFKEY_WIFI_SSID "db/dnet/ssid" /**< VCONFKEY for ssid */
+
+#define DBUS_DEFAULT_REPLY_TIMEOUT 15000
+#endif /* TIZEN_TV_EXT */
+
#define IPTABLES "/usr/sbin/iptables"
#define TABLE_NAT "nat"
#define TETH_NAT_PRE "teth_nat_pre"
#define FILTERING_MULTIPORT_RULE_STR "-t %s -A %s -p %s -m multiport --dport %d,%d -j %s"
#define FILTERING_RULE_STR "-t %s -A %s -p %s --dport %d -j %s"
+typedef enum {
+ DUAL_BAND_NONE = 0, //0
+ DUAL_BAND_2G = 1 << 0, //1
+ DUAL_BAND_5G = 1 << 1, //2
+ DUAL_BAND_MIN_INTERFACE = 1 << 2, //4
+ DUAL_BAND_ALL = 7, //7
+} supported_band_e;
+
static GSList *allowed_list = NULL;
static GSList *blocked_list = NULL;
static GSList *port_forwarding = NULL;
{0, SIGNAL_NAME_DHCP_STATUS, __handle_dhcp} };
static int retry = 0;
+static int is_dualband_support = DUAL_BAND_NONE;
+
+static void __reset_dualband_support(void)
+{
+ is_dualband_support = DUAL_BAND_NONE;
+}
+static void __set_dualband_support(int band)
+{
+ is_dualband_support |= band;
+ return;
+}
+
+static gboolean __is_dualband_support(void)
+{
+ return (is_dualband_support == DUAL_BAND_ALL) ? TRUE : FALSE;
+}
static void __send_dbus_signal(GDBusConnection *conn, const char *signal_name, const char *arg)
{
if (conn == NULL || signal_name == NULL)
- return; //LCOV_EXCL_LINE
+ return;
GVariant *message = NULL;
GError *error = NULL;
g_dbus_connection_emit_signal(conn, NULL, TETHERING_SERVICE_OBJECT_PATH,
TETHERING_SERVICE_INTERFACE, signal_name, message, &error);
if (error) {
- ERR("g_dbus_connection_emit_signal is failed because %s\n", error->message); //LCOV_EXCL_LINE
- g_error_free(error); //LCOV_EXCL_LINE
+ ERR("g_dbus_connection_emit_signal is failed because %s\n", error->message);
+ g_error_free(error);
}
- g_variant_unref(message);
}
static bool __any_tethering_is_enabled(tethering_h tethering)
{
if (security_type != TETHERING_WIFI_SECURITY_TYPE_NONE &&
security_type != TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK &&
- security_type != TETHERING_WIFI_SECURITY_TYPE_WPS) {
- ERR("Invalid param\n"); //LCOV_EXCL_LINE
+ security_type != TETHERING_WIFI_SECURITY_TYPE_WPS &&
+ security_type != TETHERING_WIFI_SECURITY_TYPE_SAE) {
+ ERR("Invalid param\n");
return TETHERING_ERROR_INVALID_PARAMETER;
}
if (vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_SECURITY, security_type) < 0) {
- ERR("vconf_set_int is failed\n"); //LCOV_EXCL_LINE
+ ERR("vconf_set_int is failed\n");
return TETHERING_ERROR_OPERATION_FAILED;
}
static tethering_error_e __get_security_type(tethering_wifi_security_type_e *security_type)
{
if (security_type == NULL) {
- ERR("Invalid param\n"); //LCOV_EXCL_LINE
+ ERR("Invalid param\n");
return TETHERING_ERROR_INVALID_PARAMETER;
}
if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_SECURITY,
(int *)security_type) < 0) {
- ERR("vconf_get_int is failed\n"); //LCOV_EXCL_LINE
+ ERR("vconf_get_int is failed\n");
return TETHERING_ERROR_OPERATION_FAILED;
}
if (ptr == NULL)
return false;
+ if (!g_strcmp0(ptr, ""))
+ return false;
+
if (!g_utf8_validate(ptr, -1, (const char **)&ptr_tmp))
*ptr_tmp = '\0';
static tethering_error_e __set_visible(const bool visible)
{
if (vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, visible ? 0 : 1) < 0) {
- ERR("vconf_set_int is failed\n"); //LCOV_EXCL_LINE
+ ERR("vconf_set_int is failed\n");
return TETHERING_ERROR_OPERATION_FAILED;
}
static tethering_error_e __get_visible(bool *visible)
{
if (visible == NULL) {
- ERR("Invalid param\n"); //LCOV_EXCL_LINE
+ ERR("Invalid param\n");
return TETHERING_ERROR_INVALID_PARAMETER;
}
int hide = 0;
if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, &hide) < 0) {
- ERR("vconf_get_int is failed\n"); //LCOV_EXCL_LINE
+ ERR("vconf_get_int is failed\n");
return TETHERING_ERROR_OPERATION_FAILED;
}
err = TETHERING_ERROR_NONE;
break;
- //LCOV_EXCL_START
case MOBILE_AP_ERROR_RESOURCE:
err = TETHERING_ERROR_OUT_OF_MEMORY;
break;
- //LCOV_EXCL_STOP
case MOBILE_AP_ERROR_INTERNAL:
err = TETHERING_ERROR_OPERATION_FAILED;
err = TETHERING_ERROR_INVALID_PARAMETER;
break;
- //LCOV_EXCL_START
case MOBILE_AP_ERROR_ALREADY_ENABLED:
err = TETHERING_ERROR_OPERATION_FAILED;
break;
case MOBILE_AP_ERROR_PERMISSION_DENIED:
err = TETHERING_ERROR_PERMISSION_DENIED;
break;
- //LCOV_EXCL_STOP
default:
ERR("Not defined error : %d\n", agent_error);
err = TETHERING_ERROR_OPERATION_FAILED;
return err;
}
-//LCOV_EXCL_START
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");
goto DONE;
}
+ SINFO("[%s] type %d, ip %s, mac %s, name %s, timestamp %d",
+ buf, ap_type, ip, mac, name, timestamp);
+
ccb = th->changed_cb[type];
if (ccb == NULL)
goto DONE;
g_free(ip);
g_free(mac);
g_free(name);
+
+ TETHERING_UNLOCK;
DBG("-\n");
}
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
+ TETHERING_LOCK;
_retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
void *data = NULL;
tethering_disabled_cause_e code = TETHERING_DISABLED_BY_NETWORK_CLOSE;
+ SINFO("Tethering Disabled by network close !");
+
for (type = TETHERING_TYPE_USB; type <= TETHERING_TYPE_BT; type++) {
dcb = th->disabled_cb[type];
if (dcb == NULL)
dcb(TETHERING_ERROR_NONE, type, code, data);
}
+ TETHERING_UNLOCK;
DBG("-\n");
}
-//LCOV_EXCL_STOP
static void __handle_wifi_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;
_retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
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");
}
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
+ TETHERING_LOCK;
_retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
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))
g_free(buf);
dcb(TETHERING_ERROR_NONE, type, code, data);
+ TETHERING_UNLOCK;
DBG("-\n");
}
-//LCOV_EXCL_START
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)
{
DBG("+\n");
+ TETHERING_LOCK;
_retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
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");
}
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
+ TETHERING_LOCK;
_retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
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);
dcb(TETHERING_ERROR_NONE, type, code, data);
g_free(buf);
+
+ TETHERING_UNLOCK;
DBG("-\n");
}
-//LCOV_EXCL_STOP
static void __handle_bt_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;
_retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
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");
}
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
+ TETHERING_LOCK;
_retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
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))
dcb(TETHERING_ERROR_NONE, type, code, data);
g_free(buf);
+
+ TETHERING_UNLOCK;
DBG("-\n");
}
-//LCOV_EXCL_START
static void __handle_no_data_timeout(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");
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)
dcb(TETHERING_ERROR_NONE, type, code, data);
}
+
+ TETHERING_UNLOCK;
DBG("-\n");
}
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
+ TETHERING_LOCK;
_retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
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)
dcb(TETHERING_ERROR_NONE, type, code, data);
}
+
+ TETHERING_UNLOCK;
DBG("-\n");
}
GVariant *parameters, gpointer user_data)
{
DBG("+\n");
+ TETHERING_LOCK;
_retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
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)
dcb(TETHERING_ERROR_NONE, type, code, data);
}
+
+ TETHERING_UNLOCK;
DBG("-\n");
}
-//LCOV_EXCL_STOP
static void __handle_security_type_changed(GDBusConnection *connection, const gchar *sender_name,
const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
{
DBG("+\n");
+ TETHERING_LOCK;
_retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
__tethering_h *th = (__tethering_h *)user_data;
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;
security_type = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK;
else if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_WPS_STR) == 0)
security_type = TETHERING_WIFI_SECURITY_TYPE_WPS;
+ else if (g_strcmp0(buf, TETHERING_WIFI_SECURITY_TYPE_SAE_STR) == 0)
+ security_type = TETHERING_WIFI_SECURITY_TYPE_SAE;
else {
- SERR("Unknown type : %s\n", buf); //LCOV_EXCL_LINE
+ SERR("Unknown type : %s\n", buf);
g_free(buf);
+ TETHERING_UNLOCK;
return;
}
g_free(buf);
scb(security_type, data);
+ TETHERING_UNLOCK;
return;
}
const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
GVariant *parameters, gpointer user_data)
{
- DBG("+\n"); //LCOV_EXCL_LINE
+ DBG("+\n");
+ TETHERING_LOCK;
_retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
__tethering_h *th = (__tethering_h *)user_data;
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) {
- DBG("-\n"); //LCOV_EXCL_LINE
+ TETHERING_UNLOCK;
+ DBG("-\n");
return;
}
g_variant_get(parameters, "(s)", &buf);
scb(visible, data);
g_free(buf);
- DBG("-\n"); //LCOV_EXCL_LINE
+
+ TETHERING_UNLOCK;
+ DBG("-\n");
}
static void __handle_passphrase_changed(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"); //LCOV_EXCL_LINE
+ DBG("+\n");
+ TETHERING_LOCK;
_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);
- DBG("-\n"); //LCOV_EXCL_LINE
+
+ TETHERING_UNLOCK;
+ DBG("-\n");
}
static void __wifi_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
gpointer user_data)
{
- INFO("+\n"); //LCOV_EXCL_LINE
+ INFO("+\n");
+ TETHERING_LOCK;
_retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
GError *g_error = NULL;
GVariant *g_var;
guint info;
+ tethering_type_e type = TETHERING_TYPE_WIFI;
tethering_error_e error;
__tethering_h *th = (__tethering_h *)user_data;
- tethering_enabled_cb ecb = th->enabled_cb[TETHERING_TYPE_WIFI];
- void *data = th->enabled_user_data[TETHERING_TYPE_WIFI];
- if (!_tethering_check_handle((tethering_h)user_data))
+ tethering_enabled_cb ecb = th->enabled_cb[type];
+ void *data = th->enabled_user_data[type];
+
+ 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) {
- //LCOV_EXCL_START
ERR("DBus error [%s]\n", g_error->message);
if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
++retry < TETHERING_ERROR_RECOVERY_MAX) {
g_error_free(g_error);
- tethering_enable((tethering_h)th, TETHERING_TYPE_WIFI);
+ tethering_enable((tethering_h)th, type);
+ TETHERING_UNLOCK;
return;
} else if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
error = TETHERING_ERROR_PERMISSION_DENIED;
else
error = TETHERING_ERROR_OPERATION_FAILED;
g_error_free(g_error);
- //LCOV_EXCL_STOP
} else {
g_variant_get(g_var, "(u)", &info);
error = __get_error(info);
}
retry = 0;
- INFO("cfm event : wifi tethering enable info : %d\n", error); //LCOV_EXCL_LINE
+ INFO("cfm event : wifi tethering enable info : %d\n", error);
sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_WIFI_TETHER_ON].name,
TETHERING_SERVICE_OBJECT_PATH, NULL, G_DBUS_SIGNAL_FLAGS_NONE,
sigs[E_SIGNAL_WIFI_TETHER_ON].cb, (gpointer)th, NULL);
+ SINFO("Tethering enabled event ! error(%d)", error);
+
if (!ecb) {
- INFO("-\n"); //LCOV_EXCL_LINE
+ TETHERING_UNLOCK;
+ INFO("-\n");
return;
}
- ecb(error, TETHERING_TYPE_WIFI, true, data);
+ ecb(error, type, true, data);
g_variant_unref(g_var);
- INFO("-\n"); //LCOV_EXCL_LINE
+
+ TETHERING_UNLOCK;
+ INFO("-\n");
}
static void __bt_enabled_cfm_cb(GObject *source_object, GAsyncResult *res,
gpointer user_data)
{
- DBG("+\n"); //LCOV_EXCL_LINE
+ DBG("+\n");
+ TETHERING_LOCK;
+
_retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
GError *g_error = NULL;
GVariant *g_var;
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) {
- //LCOV_EXCL_START
ERR("DBus error [%s]\n", g_error->message);
if (g_error->code == G_DBUS_ERROR_NO_REPLY &&
++retry < TETHERING_ERROR_RECOVERY_MAX) {
g_error_free(g_error);
tethering_enable((tethering_h)th, TETHERING_TYPE_BT);
+ TETHERING_UNLOCK;
DBG("-\n");
return;
}
else
error = TETHERING_ERROR_OPERATION_FAILED;
g_error_free(g_error);
- //LCOV_EXCL_STOP
} else {
g_variant_get(g_var, "(u)", &info);
g_variant_unref(g_var);
sigs[E_SIGNAL_BT_TETHER_ON].cb, (gpointer)th, NULL);
if (!ecb) {
- DBG("-\n"); //LCOV_EXCL_LINE
+ TETHERING_UNLOCK;
+ DBG("-\n");
return;
}
ecb(error, TETHERING_TYPE_BT, true, data);
+
+ TETHERING_UNLOCK;
DBG("-\n");
}
-//LCOV_EXCL_START
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;
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;
_retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
__tethering_h *th = (__tethering_h *)user_data;
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");
}
-//LCOV_EXCL_STOP
static void __disabled_cfm_cb(GObject *source_object, GAsyncResult *res,
gpointer user_data)
{
- INFO("+\n"); //LCOV_EXCL_LINE
+ INFO("+\n");
+ TETHERING_LOCK;
_retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
GError *g_error = NULL;
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) {
- //LCOV_EXCL_START
ERR("DBus error [%s]\n", g_error->message);
g_error_free(g_error);
+ TETHERING_UNLOCK;
return;
- //LCOV_EXCL_STOP
}
g_variant_get(g_var, "(uu)", &event_type, &info);
INFO("cfm event : %d info : %d\n", event_type, info);
dcb(error, type, code, data);
break;
- //LCOV_EXCL_START
case MOBILE_AP_DISABLE_USB_TETHERING_CFM:
sigs[E_SIGNAL_USB_TETHER_OFF].sig_id = g_dbus_connection_signal_subscribe(th->client_bus,
NULL, TETHERING_SERVICE_INTERFACE, sigs[E_SIGNAL_USB_TETHER_OFF].name,
default:
ERR("Invalid event\n");
break;
- //LCOV_EXCL_STOP
}
- INFO("-\n"); //LCOV_EXCL_LINE
+
+ TETHERING_UNLOCK;
+ INFO("-\n");
}
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");
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) {
- //LCOV_EXCL_START
ERR("DBus fail [%s]\n", g_error->message);
if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
tethering_error = TETHERING_ERROR_OPERATION_FAILED;
flag = true;
- //LCOV_EXCL_STOP
}
if (th->data_usage_cb == NULL) {
- ERR("There is no data_usage_cb\n"); //LCOV_EXCL_LINE
+ 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;
_retm_if(user_data == NULL, "parameter(user_data) is NULL\n");
GError *g_error = NULL;
__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); //LCOV_EXCL_LINE
+ ERR("DBus fail [%s]\n", g_error->message);
if (g_error->code == G_DBUS_ERROR_ACCESS_DENIED)
tethering_error = TETHERING_ERROR_PERMISSION_DENIED;
else
tethering_error = TETHERING_ERROR_OPERATION_FAILED;
g_error_free(g_error);
+ } else {
+ g_variant_get(g_var, "(u)", &info);
+ if (tethering_error == TETHERING_ERROR_NONE)
+ tethering_error = __get_error(info);
+ g_variant_unref(g_var);
}
+
if (th->settings_reloaded_cb == NULL) {
DBG("There is no settings_reloaded_cb\n-\n");
+ TETHERING_UNLOCK;
return;
}
- g_variant_get(g_var, "(u)", &info);
- if (tethering_error == TETHERING_ERROR_NONE)
- tethering_error = __get_error(info);
- g_variant_unref(g_var);
th->settings_reloaded_cb(tethering_error,
th->settings_reloaded_user_data);
th->settings_reloaded_cb = NULL;
th->settings_reloaded_user_data = NULL;
+
+ TETHERING_UNLOCK;
DBG("-\n");
}
_retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
switch (type) {
- //LCOV_EXCL_START
case TETHERING_TYPE_USB:
g_strlcpy(buf, TETHERING_USB_IF, len);
break;
- //LCOV_EXCL_STOP
case TETHERING_TYPE_WIFI:
g_strlcpy(buf, TETHERING_WIFI_IF, len);
break;
-
case TETHERING_TYPE_BT:
g_strlcpy(buf, TETHERING_BT_IF, len);
break;
-
- //LCOV_EXCL_START
+ case TETHERING_TYPE_P2P:
+ g_strlcpy(buf, TETHERING_P2P_IF, len);
+ break;
default:
ERR("Not supported type : %d\n", type);
return false;
- //LCOV_EXCL_STOP
}
return true;
}
_retvm_if(buf == NULL, false, "parameter(buf) is NULL\n");
switch (type) {
- //LCOV_EXCL_START
case TETHERING_TYPE_USB:
g_strlcpy(buf, TETHERING_USB_GATEWAY, len);
break;
- //LCOV_EXCL_STOP
case TETHERING_TYPE_WIFI:
g_strlcpy(buf, TETHERING_WIFI_GATEWAY, len);
break;
-
case TETHERING_TYPE_BT:
g_strlcpy(buf, TETHERING_BT_GATEWAY, len);
break;
- //LCOV_EXCL_START
+ case TETHERING_TYPE_P2P:
+ g_strlcpy(buf, TETHERING_P2P_GATEWAY, len);
+ break;
default:
ERR("Not supported type : %d\n", type);
return false;
- //LCOV_EXCL_STOP
}
return true;
}
static int __get_common_ssid(char *ssid, unsigned int size)
{
if (ssid == NULL) {
- ERR("ssid is null\n"); //LCOV_EXCL_LINE
+ ERR("ssid is null\n");
return TETHERING_ERROR_INVALID_PARAMETER;
}
- char *ptr = NULL;
- char *ptr_tmp = NULL;
+#ifdef TIZEN_TV_EXT
+ if (__get_ssid_from_vconf(VCONFKEY_WIFI_SSID, ssid, size))
+ return TETHERING_ERROR_NONE;
+ else
+ ERR("vconf key get failed for ssid or invalid ssid is found");
+#endif /* TIZEN_TV_EXT */
- ptr = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
- if (ptr == NULL) {
+ if (__get_ssid_from_vconf(VCONFKEY_SETAPPL_DEVICE_NAME_STR,
+ ssid, size) == false) {
ERR("vconf_get_str is failed and set default ssid");
g_strlcpy(ssid, TETHERING_DEFAULT_SSID, size);
- } else
- g_strlcpy(ssid, ptr, size);
-
- free(ptr);
-
- if (!g_utf8_validate(ssid, -1, (const char **)&ptr_tmp))
- *ptr_tmp = '\0';
+ }
return TETHERING_ERROR_NONE;
}
char *ptr = NULL;
if (th == NULL || set == NULL) {
- ERR("null parameter\n-\n"); //LCOV_EXCL_LINE
+ ERR("null parameter\n-\n");
return TETHERING_ERROR_INVALID_PARAMETER;
}
set->mac_filter = th->mac_filter;
set->max_connected = th->wifi_max_connected;
set->channel = th->channel;
+ set->txpower = th->txpower;
__get_wifi_mode_type(th->mode_type, &ptr);
if (ptr == NULL) {
NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
- //LCOV_EXCL_START
ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
g_error_free(error);
return ret;
- //LCOV_EXCL_STOP
}
if (parameters != NULL) {
g_variant_get(parameters, "(siu)", &passphrase, &len, &ret);
+ g_strlcpy(set->key, passphrase, sizeof(set->key) - 1);
+ g_free(passphrase);
g_variant_unref(parameters);
}
-
- g_strlcpy(set->key, passphrase, sizeof(set->key));
}
INFO("ssid: %s security: %d mode: %s channel: %d visibility: %s\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)
+ || (th->wifi_sharing && dnet_status == VCONFKEY_NETWORK_WIFI
+ && type == TETHERING_TYPE_WIFI)
|| dnet_status == VCONFKEY_NETWORK_ETHERNET)
return TRUE;
return FALSE;
}
+#ifdef TIZEN_TV_EXT
+static void __set_vconf_values_for_tv(__tethering_h *tethering)
+{
+ int ret, channel, txpower;
+ __tethering_h *th = tethering;
+
+ if (th == NULL)
+ return;
+
+ ret = vconf_get_int(VCONFKEY_WIFI_CHANNEL, &channel);
+ if (ret < 0) {
+ ERR("vconf key get failed for channel !!");
+ channel = TETHERING_WIFI_CHANNEL;
+ }
+
+ ret = vconf_get_int(VCONFKEY_WIFI_TXPOWER, &txpower);
+ if (ret < 0) {
+ ERR("vconf key get failed for txpower !!");
+ txpower = TETHERING_WIFI_MAX_TXPOWER;
+ }
+
+ th->channel = channel;
+ th->txpower = txpower;
+}
+#endif /* TIZEN_TV_EXT */
+
/**
* @internal
* @brief Creates the handle of tethering.
th->sec_type = TETHERING_WIFI_SECURITY_TYPE_WPA2_PSK;
th->visibility = true;
th->mac_filter = false;
+ th->wifi_sharing = false;
th->channel = TETHERING_WIFI_CHANNEL;
th->mode_type = TETHERING_WIFI_MODE_TYPE_G;
th->wifi_max_connected = TETHERING_WIFI_MAX_STA;
+ th->txpower = TETHERING_WIFI_MAX_TXPOWER;
if (__generate_initial_passphrase(th->passphrase,
sizeof(th->passphrase)) == 0) {
- //LCOV_EXCL_START
ERR("random passphrase generation failed\n");
free(th);
return TETHERING_ERROR_OPERATION_FAILED;
- //LCOV_EXCL_STOP
}
if (__get_common_ssid(ssid, sizeof(ssid)) != TETHERING_ERROR_NONE) {
- //LCOV_EXCL_START
ERR("common ssid get failed\n");
free(th);
return TETHERING_ERROR_OPERATION_FAILED;
- //LCOV_EXCL_STOP
}
+#ifdef TIZEN_TV_EXT
+ __set_vconf_values_for_tv(th);
+#endif /* TIZEN_TV_EXT */
+ SINFO("ssid: %s, key: %s, channel: %d, mode: %d, txpower: %d, security: %d max_device: %d\n",
+ ssid, th->passphrase, th->channel, th->mode_type, th->txpower, th->sec_type,
+ th->wifi_max_connected);
+
#if !GLIB_CHECK_VERSION(2, 36, 0)
g_type_init();
#endif
GCancellable *cancellable = g_cancellable_new();
th->client_bus = g_bus_get_sync(DBUS_BUS_SYSTEM, cancellable, &error);
if (error) {
- //LCOV_EXCL_START
ERR("Couldn't connect to the System bus[%s]", error->message);
g_error_free(error);
g_cancellable_cancel(cancellable);
g_object_unref(cancellable);
free(th);
return TETHERING_ERROR_OPERATION_FAILED;
- //LCOV_EXCL_STOP
}
th->cancellable = cancellable;
NULL, TETHERING_SERVICE_NAME, TETHERING_SERVICE_OBJECT_PATH,
TETHERING_SERVICE_INTERFACE, th->cancellable, &error);
if (!th->client_bus_proxy) {
- //LCOV_EXCL_START
if (error)
ERR("Couldn't create the proxy object because of %s\n", error->message);
g_cancellable_cancel(th->cancellable);
g_object_unref(th->client_bus);
free(th);
return TETHERING_ERROR_OPERATION_FAILED;
- //LCOV_EXCL_STOP
}
__connect_signals((tethering_h)th);
GDBusProxy *proxy = th->client_bus_proxy;
GDBusConnection *connection = th->client_bus;
+#ifdef TIZEN_TV_EXT
+ g_dbus_proxy_set_default_timeout(proxy, DBUS_DEFAULT_REPLY_TIMEOUT);
+#else /* TIZEN_TV_EXT */
g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
+#endif /* TIZEN_TV_EXT */
- if (__check_precondition(type) == FALSE) {
- //LCOV_EXCL_START
+ if (__check_precondition(th, type) == FALSE) {
INFO("-\n");
+ g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
return TETHERING_ERROR_OPERATION_FAILED;
- //LCOV_EXCL_STOP
}
switch (type) {
- //LCOV_EXCL_START
case TETHERING_TYPE_USB:
g_dbus_connection_signal_unsubscribe(connection,
sigs[E_SIGNAL_USB_TETHER_ON].sig_id);
G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
(GAsyncReadyCallback) __usb_enabled_cfm_cb, (gpointer)tethering);
break;
- //LCOV_EXCL_STOP
case TETHERING_TYPE_WIFI: {
_softap_settings_t set = {"", "", "", 0, false};
ret = __prepare_wifi_settings(tethering, &set);
if (ret != TETHERING_ERROR_NONE) {
- //LCOV_EXCL_START
ERR("softap settings initialization failed\n");
DBG("-\n");
return TETHERING_ERROR_OPERATION_FAILED;
- //LCOV_EXCL_STOP
}
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);
+
+ 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);
g_dbus_proxy_call(proxy, "enable_wifi_tethering",
- g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type, TETHERING_ADDRESS_FAMILY_IPV4),
+ 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_CALL_FLAGS_NONE, -1, th->cancellable,
(GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
break;
break;
- //LCOV_EXCL_START
case TETHERING_TYPE_P2P: {
_softap_settings_t p2p_set = {"", "", "", 0, false};
ret = __prepare_wifi_settings(tethering, &p2p_set);
if (ret != TETHERING_ERROR_NONE) {
ERR("p2p settings initialization failed\n");
+ g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
DBG("-\n");
return TETHERING_ERROR_OPERATION_FAILED;
}
ret = __prepare_wifi_settings(tethering, &set);
if (ret != TETHERING_ERROR_NONE) {
ERR("softap settings initialization failed\n");
+ g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
return TETHERING_ERROR_OPERATION_FAILED;
}
sigs[E_SIGNAL_WIFI_TETHER_ON].sig_id);
g_dbus_proxy_call(proxy, "enable_wifi_tethering",
- g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode,
+ 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, TETHERING_ADDRESS_FAMILY_IPV4),
+ set.sec_type, set.txpower, TETHERING_ADDRESS_FAMILY_IPV4),
G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
(GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
DBG("-\n");
return TETHERING_ERROR_INVALID_PARAMETER;
}
- //LCOV_EXCL_STOP
g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
INFO("-\n");
g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_INFINITE);
- if (__check_precondition(type) == FALSE) {
- //LCOV_EXCL_START
+ if (__check_precondition(th, type) == FALSE) {
DBG("-\n");
+ g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
return TETHERING_ERROR_OPERATION_FAILED;
- //LCOV_EXCL_STOP
}
switch (type) {
if (ret != TETHERING_ERROR_NONE) {
ERR("softap settings initialization failed\n");
DBG("-\n");
+ g_dbus_proxy_set_default_timeout(proxy, DBUS_TIMEOUT_USE_DEFAULT);
return TETHERING_ERROR_OPERATION_FAILED;
}
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("(sssiiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type, TETHERING_ADDRESS_FAMILY_IPV6),
+
+ 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);
+
+ 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);
+ 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_CALL_FLAGS_NONE, -1, th->cancellable,
(GAsyncReadyCallback) __wifi_enabled_cfm_cb, (gpointer)tethering);
break;
GDBusConnection *connection = th->client_bus;
switch (type) {
- //LCOV_EXCL_START
case TETHERING_TYPE_USB:
g_dbus_connection_signal_unsubscribe(connection,
sigs[E_SIGNAL_USB_TETHER_OFF].sig_id);
(GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
break;
- //LCOV_EXCL_STOP
case TETHERING_TYPE_WIFI:
-
g_dbus_connection_signal_unsubscribe(connection,
sigs[E_SIGNAL_WIFI_TETHER_OFF].sig_id);
+ SINFO("Disable Wi-Fi Tethering !");
+
g_dbus_proxy_call(proxy, "disable_wifi_tethering",
- g_variant_new("(i)", TETHERING_ADDRESS_FAMILY_IPV4),
+ g_variant_new("(ii)", TETHERING_ADDRESS_FAMILY_IPV4, th->mode_type),
G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
(GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
break;
(GAsyncReadyCallback) __disabled_cfm_cb, (gpointer)tethering);
break;
- //LCOV_EXCL_START
case TETHERING_TYPE_P2P:
g_dbus_proxy_call(proxy, "disable_p2p_tethering",
NULL, G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
ERR("Not supported tethering type [%d]\n", type);
DBG("-\n");
return TETHERING_ERROR_INVALID_PARAMETER;
- //LCOV_EXCL_STOP
}
INFO("-\n");
return TETHERING_ERROR_NONE;
API int tethering_get_mac_address(tethering_h tethering, tethering_type_e type, char **mac_address)
{
CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
- if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE); //LCOV_EXCL_LINE
+ if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_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); //LCOV_EXCL_LINE
+ else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
_retvm_if(tethering_is_enabled(tethering, type) == false,
TETHERING_ERROR_NOT_ENABLED,
_retvm_if(s < 0, TETHERING_ERROR_OPERATION_FAILED,
"getting socket is failed\n");
if (ioctl(s, SIOCGIFHWADDR, &ifr) < 0) {
- //LCOV_EXCL_START
ERR("getting mac is failed\n");
close(s);
return TETHERING_ERROR_OPERATION_FAILED;
- //LCOV_EXCL_STOP
}
close(s);
API int tethering_get_ip_address(tethering_h tethering, tethering_type_e type, tethering_address_family_e address_family, char **ip_address)
{
CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
- if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_FEATURE); //LCOV_EXCL_LINE
+ if (type == TETHERING_TYPE_USB) CHECK_FEATURE_SUPPORTED(TETHERING_USB_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); //LCOV_EXCL_LINE
+ else if (type == TETHERING_TYPE_BT) CHECK_FEATURE_SUPPORTED(TETHERING_BT_FEATURE);
_retvm_if(tethering_is_enabled(tethering, type) == false,
TETHERING_ERROR_NOT_ENABLED,
* @see tethering_is_enabled()
* @see tethering_enable()
*/
+
+API int tethering_is_dualband_supported(tethering_h tethering, tethering_type_e type, bool *supported)
+{
+ CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+ CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+
+ _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+ "parameter(tethering) is NULL\n");
+
+ __tethering_h *th = (__tethering_h *)tethering;
+ gchar *if_name = NULL;
+ gboolean Is2GBandSupported = FALSE;
+ gboolean Is5GBandSupported = FALSE;
+ GError *error = NULL;
+ GVariant *result = NULL;
+ GVariantIter *outer_iter = NULL;
+ GVariantIter *inner_iter = NULL;
+ GVariant *station = NULL;
+ GVariant *value = NULL;
+ gchar *key = NULL;
+ int count = 0;
+
+ DBG("+");
+ __reset_dualband_support();
+ result = g_dbus_proxy_call_sync(th->client_bus_proxy, "get_wifi_interfaces",
+ NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+
+ if (error) {
+ ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
+ g_error_free(error);
+ return TETHERING_ERROR_OPERATION_FAILED;
+ }
+ g_variant_get(result, "(a(a{sv}))", &outer_iter);
+ while (g_variant_iter_loop(outer_iter, "(@a{sv})", &station)) {
+ g_variant_get(station, "a{sv}", &inner_iter);
+ while (g_variant_iter_loop(inner_iter, "{sv}", &key, &value)) {
+ if (g_strcmp0(key, "IfName") == 0) {
+ g_variant_get(value, "s", &if_name);
+ SDBG("Interface Name is %s\n", if_name);
+ } else if (g_strcmp0(key, "Is2GBandSupported") == 0) {
+ Is2GBandSupported = g_variant_get_boolean(value);
+ SDBG("Is2GBandSupported is %d\n", Is2GBandSupported);
+ if (Is2GBandSupported)
+ __set_dualband_support(DUAL_BAND_2G);
+ } else if (g_strcmp0(key, "Is5GBandSupported") == 0) {
+ Is5GBandSupported = g_variant_get_boolean(value);
+ SDBG("Is5GBandSupported is %d\n", Is5GBandSupported);
+ if (Is5GBandSupported)
+ __set_dualband_support(DUAL_BAND_5G);
+ } else {
+ ERR("Key %s not required\n", key);
+ }
+ }
+ count++;
+
+ g_variant_iter_free(inner_iter);
+ }
+ if (count >= 2)
+ __set_dualband_support(DUAL_BAND_MIN_INTERFACE);
+ *supported = __is_dualband_support();
+ DBG("count:%d is dualband suppport: %d", count, *supported);
+ g_variant_iter_free(outer_iter);
+ g_variant_unref(result);
+ DBG("-\n");
+ return TETHERING_ERROR_NONE;
+}
API int tethering_foreach_connected_clients(tethering_h tethering, tethering_type_e type, tethering_connected_client_cb callback, void *user_data)
{
CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
"tethering is not enabled\n");
mobile_ap_type_e interface;
+ tethering_band_e band;
__tethering_h *th = (__tethering_h *)tethering;
__tethering_client_h client = {0, };
gchar *ip = NULL;
result = g_dbus_proxy_call_sync(th->client_bus_proxy, "get_station_info",
NULL, G_DBUS_CALL_FLAGS_NONE,
-1, th->cancellable, &error);
- if (error)
- ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message); //LCOV_EXCL_LINE
+
+ if (error) {
+ ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
+ g_error_free(error);
+ return TETHERING_ERROR_OPERATION_FAILED;
+ }
+
g_variant_get(result, "(a(a{sv}))", &outer_iter);
- //LCOV_EXCL_START
while (g_variant_iter_loop(outer_iter, "(@a{sv})", &station)) {
g_variant_get(station, "a{sv}", &inner_iter);
while (g_variant_iter_loop(inner_iter, "{sv}", &key, &value)) {
timestamp = g_variant_get_int32(value);
DBG("timestamp is %d\n", timestamp);
client.tm = (time_t)timestamp;
+ } else if (g_strcmp0(key, "Band") == 0) {
+ band = g_variant_get_int32(value);
+ client.band = (!band) ? TETHERING_WIFI_BAND_2G : TETHERING_WIFI_BAND_5G;
+ SDBG("band type %d\n", band);
} else {
ERR("Key %s not required\n", key);
}
mac = NULL;
g_variant_iter_free(inner_iter);
+ if ((th->mode_type == 0 || th->mode_type == 1) && client.band != TETHERING_WIFI_BAND_2G) //if band is not for 2g continue
+ continue;
+ if ((th->mode_type == 2 || th->mode_type == 3) && client.band != TETHERING_WIFI_BAND_5G) //if band is not for 5g continue
+ continue;
+ SDBG("mode_type: %d and client.band: %d ", th->mode_type, client.band);
if (callback((tethering_client_h)&client, user_data) == false) {
DBG("iteration is stopped\n");
g_free(client.hostname);
client.hostname = NULL;
g_variant_iter_free(outer_iter);
- g_variant_unref(station);
g_variant_unref(result);
DBG("-\n");
return TETHERING_ERROR_OPERATION_FAILED;
g_free(client.hostname);
client.hostname = NULL;
}
- //LCOV_EXCL_STOP
g_variant_iter_free(outer_iter);
- g_variant_unref(station);
g_variant_unref(result);
DBG("-\n");
return TETHERING_ERROR_NONE;
}
/* TETHERING_TYPE_ALL */
- for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
+ for (ti = TETHERING_TYPE_USB; ti < TETHERING_TYPE_MAX; ti++) {
th->enabled_cb[ti] = callback;
th->enabled_user_data[ti] = user_data;
}
}
/* TETHERING_TYPE_ALL */
- for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
+ for (ti = TETHERING_TYPE_USB; ti < TETHERING_TYPE_MAX; ti++) {
th->enabled_cb[ti] = NULL;
th->enabled_user_data[ti] = NULL;
}
}
/* TETHERING_TYPE_ALL */
- for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
+ for (ti = TETHERING_TYPE_USB; ti < TETHERING_TYPE_MAX; ti++) {
th->disabled_cb[ti] = callback;
th->disabled_user_data[ti] = user_data;
}
}
/* TETHERING_TYPE_ALL */
- for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
+ for (ti = TETHERING_TYPE_USB; ti < TETHERING_TYPE_MAX; ti++) {
th->disabled_cb[ti] = NULL;
th->disabled_user_data[ti] = NULL;
}
}
/* TETHERING_TYPE_ALL */
- for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
+ for (ti = TETHERING_TYPE_USB; ti < TETHERING_TYPE_MAX; ti++) {
th->changed_cb[ti] = callback;
th->changed_user_data[ti] = user_data;
}
}
/* TETHERING_TYPE_ALL */
- for (ti = TETHERING_TYPE_USB; ti <= TETHERING_TYPE_P2P; ti++) {
+ for (ti = TETHERING_TYPE_USB; ti < TETHERING_TYPE_MAX; ti++) {
th->changed_cb[ti] = NULL;
th->changed_user_data[ti] = NULL;
}
ret = __set_security_type(type);
if (ret == TETHERING_ERROR_NONE) {
-
switch (type) {
case TETHERING_WIFI_SECURITY_TYPE_NONE:
sec_str = TETHERING_WIFI_SECURITY_TYPE_OPEN_STR;
case TETHERING_WIFI_SECURITY_TYPE_WPS:
sec_str = TETHERING_WIFI_SECURITY_TYPE_WPS_STR;
break;
+ case TETHERING_WIFI_SECURITY_TYPE_SAE:
+ sec_str = TETHERING_WIFI_SECURITY_TYPE_SAE_STR;
+ break;
}
__send_dbus_signal(th->client_bus,
CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+ _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+ "parameter(tethering) is NULL\n");
_retvm_if(type == NULL, TETHERING_ERROR_INVALID_PARAMETER,
"parameter(type) is NULL\n");
_retvm_if(p_ssid == NULL, TETHERING_ERROR_OUT_OF_MEMORY,
"strdup is failed\n");
+#ifdef TIZEN_TV_EXT
+ GDBusProxy *proxy = th->client_bus_proxy;
+ GVariant *parameters;
+ GError *error = NULL;
+ tethering_error_e ret = TETHERING_ERROR_NONE;
+
+ parameters = g_dbus_proxy_call_sync(proxy, "set_wifi_tethering_ssid",
+ g_variant_new("(s)", ssid), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+
+ if (error) {
+ ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
+
+ if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ ret = TETHERING_ERROR_PERMISSION_DENIED;
+ else
+ ret = TETHERING_ERROR_OPERATION_FAILED;
+
+ g_error_free(error);
+ free(p_ssid);
+ return ret;
+ }
+
+ if (parameters != NULL) {
+ g_variant_get(parameters, "(u)", &ret);
+ g_variant_unref(parameters);
+ }
+
+ SINFO("set tethering ssid : %s", ssid);
+#endif /* TIZEN_TV_EXT */
+
if (th->ssid)
free(th->ssid);
th->ssid = p_ssid;
__tethering_h *th = (__tethering_h *)tethering;
char val[TETHERING_WIFI_SSID_MAX_LEN + 1] = {0, };
+#ifdef TIZEN_TV_EXT
+ if (__get_ssid_from_vconf(VCONFKEY_WIFI_SSID,
+ val, sizeof(val)) == true) {
+ *ssid = strdup(val);
+ SINFO("get tethering ssid : %s", *ssid);
+ return TETHERING_ERROR_NONE;
+ }
+#endif /* TIZEN_TV_EXT */
+
if (!tethering_is_enabled(NULL, TETHERING_TYPE_WIFI)) {
if (th->ssid != NULL) {
DBG("Private SSID is set\n");
}
if (*ssid == NULL) {
- ERR("strdup is failed\n"); //LCOV_EXCL_LINE
+ ERR("strdup is failed\n");
return TETHERING_ERROR_OUT_OF_MEMORY;
}
CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+ _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+ "parameter(tethering) is NULL\n");
_retvm_if(visible == NULL, TETHERING_ERROR_INVALID_PARAMETER,
"parameter(visible) is NULL\n");
g_variant_new("(s)", passphrase), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
- //LCOV_EXCL_START
ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
g_error_free(error);
return ret;
- //LCOV_EXCL_STOP
}
g_variant_get(parameters, "(u)", &ret);
NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
- //LCOV_EXCL_START
ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
g_error_free(error);
return ret;
- //LCOV_EXCL_STOP
}
if (parameters != NULL) {
"parameter(tethering) is NULL\n");
__tethering_h *th = (__tethering_h *)tethering;
+
+#ifdef TIZEN_TV_EXT
+ GDBusProxy *proxy = th->client_bus_proxy;
+ GVariant *parameters;
+ GError *error = NULL;
+ tethering_error_e ret = TETHERING_ERROR_NONE;
+
+ parameters = g_dbus_proxy_call_sync(proxy, "set_wifi_tethering_channel",
+ g_variant_new("(i)", channel), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+
+ if (error) {
+ ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
+
+ if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ ret = TETHERING_ERROR_PERMISSION_DENIED;
+ else
+ ret = TETHERING_ERROR_OPERATION_FAILED;
+
+ g_error_free(error);
+ return ret;
+ }
+
+ if (parameters != NULL) {
+ g_variant_get(parameters, "(u)", &ret);
+ g_variant_unref(parameters);
+ }
+
+ SINFO("set channel : %d", channel);
+#endif /* TIZEN_TV_EXT */
+
th->channel = channel;
return TETHERING_ERROR_NONE;
"parameter(channel) is NULL\n");
__tethering_h *th = (__tethering_h *)tethering;
+#ifdef TIZEN_TV_EXT
+ GDBusProxy *proxy = th->client_bus_proxy;
+ GVariant *parameters = NULL;
+ GError *error = NULL;
+ 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",
+ NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+
+ if (error) {
+ ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
+
+ if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ ret = TETHERING_ERROR_PERMISSION_DENIED;
+ else
+ ret = TETHERING_ERROR_OPERATION_FAILED;
+
+ g_error_free(error);
+ return ret;
+ }
+
+ if (parameters != NULL) {
+ g_variant_get(parameters, "(iu)", &ch, &ret);
+ g_variant_unref(parameters);
+ }
+
+ if (ch < 0) {
+ ERR("failed to get Hostapd channel, set th->channel");
+ *channel = th->channel;
+ } else
+ *channel = ch;
+
+ if (vconf_get_int(VCONFKEY_WIFI_CHANNEL, &vconf_channel) < 0)
+ ERR("Failed to get vconf key for channel");
+ else
+ *channel = vconf_channel;
+
+ SINFO("get tethering channel : %d", *channel);
+#else /* TIZEN_TV_EXT */
*channel = th->channel;
+#endif /* TIZEN_TV_EXT */
return TETHERING_ERROR_NONE;
}
DBG("+\n");
if (th->settings_reloaded_cb) {
- ERR("Operation in progress\n"); //LCOV_EXCL_LINE
+ ERR("Operation in progress\n");
return TETHERING_ERROR_OPERATION_FAILED;
}
ret = __prepare_wifi_settings(tethering, &set);
if (ret != TETHERING_ERROR_NONE) {
- ERR("softap settings initialization failed\n"); //LCOV_EXCL_LINE
+ ERR("softap settings initialization failed\n");
return TETHERING_ERROR_OPERATION_FAILED;
}
th->settings_reloaded_cb = callback;
th->settings_reloaded_user_data = user_data;
+ 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);
+
g_dbus_proxy_call(proxy, "reload_wifi_settings",
- g_variant_new("(sssiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type),
+ g_variant_new("(sssiiiiii)", set.ssid, set.key, set.mode, set.channel, set.visibility, set.mac_filter, set.max_connected, set.sec_type, set.txpower),
G_DBUS_CALL_FLAGS_NONE, -1, th->cancellable,
(GAsyncReadyCallback) __settings_reloaded_cb, (gpointer)tethering);
bool mac_exist = false;
char *p_mac = NULL;
- p_mac = strdup(mac);
- if (p_mac == NULL) {
- ERR("strdup failed\n"); //LCOV_EXCL_LINE
- return TETHERING_ERROR_OUT_OF_MEMORY;
- }
-
fp = fopen(filepath, "a+");
if (!fp) {
- ERR("fopen is failed\n"); //LCOV_EXCL_LINE
+ ERR("fopen is failed\n");
return TETHERING_ERROR_OPERATION_FAILED;
}
while (fgets(line, MAX_BUF_SIZE, fp) != NULL) {
if (strncmp(mac, line, 17) == 0) {
- DBG("MAC %s already exist in the list\n", mac); //LCOV_EXCL_LINE
+ DBG("MAC %s already exist in the list\n", mac);
mac_exist = true;
break;
}
}
if (!mac_exist) {
+ p_mac = strdup(mac);
+ if (p_mac == NULL) {
+ ERR("strdup failed\n");
+ fclose(fp);
+ return TETHERING_ERROR_OUT_OF_MEMORY;
+ }
+
fprintf(fp, "%s\n", mac);
if ((strcmp(filepath, ALLOWED_LIST) == 0))
allowed_list = g_slist_append(allowed_list, p_mac);
else if ((strcmp(filepath, BLOCKED_LIST) == 0))
blocked_list = g_slist_append(blocked_list, p_mac);
+ else
+ free(p_mac);
}
fclose(fp);
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
- //LCOV_EXCL_START
ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
result = TETHERING_ERROR_PERMISSION_DENIED;
th->dhcp_enabled = false;
return result;
- //LCOV_EXCL_STOP
}
g_variant_get(parameters, "(u)", &result);
g_variant_new("(ss)", rangestart, rangestop),
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
- //LCOV_EXCL_START
ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
th->dhcp_enabled = false;
return result;
- //LCOV_EXCL_STOP
}
g_variant_get(parameters, "(u)", &result);
TETHERING_ERROR_NOT_ENABLED,
"tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI);
__tethering_h *th = (__tethering_h *)tethering;
+ th->txpower = txpower;
g_dbus_proxy_call_sync(th->client_bus_proxy, "hostapd_set_txpower",
g_variant_new("(u)", txpower),
G_DBUS_CALL_FLAGS_NONE,
-1, th->cancellable, &error);
if (error) {
- //LCOV_EXCL_START
ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
g_clear_error(&error);
return TETHERING_ERROR_OPERATION_FAILED;
- //LCOV_EXCL_STOP
}
return TETHERING_ERROR_NONE;
}
_retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
"parameter(tethering) is NULL\n");
+ _retvm_if(txpower == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+ "parameter(txpower) is NULL\n");
_retvm_if(tethering_is_enabled(tethering, TETHERING_TYPE_WIFI) == false,
TETHERING_ERROR_NOT_ENABLED,
"tethering type[%d] is not enabled\n", TETHERING_TYPE_WIFI);
g_variant_get(result, "(u)", txpower);
g_variant_unref(result);
} else {
- //LCOV_EXCL_START
if (error)
ERR("g_dbus_proxy_call_sync is failed and error is %s\n", error->message);
g_clear_error(&error);
return TETHERING_ERROR_OPERATION_FAILED;
- //LCOV_EXCL_STOP
}
g_clear_error(&error);
return TETHERING_ERROR_NONE;
g_variant_new("(u)", mtu),
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
- //LCOV_EXCL_START
ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
g_error_free(error);
return result;
- //LCOV_EXCL_STOP
}
g_variant_get(parameters, "(u)", &result);
g_variant_new("(s)", mac),
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
- //LCOV_EXCL_START
ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
g_error_free(error);
return result;
- //LCOV_EXCL_STOP
}
g_variant_get(parameters, "(u)", &result);
g_variant_new("(b)", enable),
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
- //LCOV_EXCL_START
ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
g_error_free(error);
return result;
- //LCOV_EXCL_STOP
}
g_variant_get(parameters, "(u)", &result);
_retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
"parameter(tethering) is NULL\n");
+ _retvm_if(ifname == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+ "parameter(ifname) is NULL\n");
_retvm_if(protocol == NULL, TETHERING_ERROR_INVALID_PARAMETER,
"parameter(protocol) is NULL\n");
+ _retvm_if(org_ip == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+ "parameter(org_ip) is NULL\n");
+ _retvm_if(final_ip == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+ "parameter(final_ip) is NULL\n");
GVariant *parameters;
GError *error = NULL;
g_variant_new("(sssisi)", ifname, protocol, org_ip, org_port, final_ip, final_port),
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
- //LCOV_EXCL_START
ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
g_error_free(error);
return result;
- //LCOV_EXCL_STOP
}
g_variant_get(parameters, "(u)", &result);
list = strdup(cmd);
if (list == NULL) {
- ERR("strdup failed\n"); //LCOV_EXCL_LINE
+ ERR("strdup failed\n");
return TETHERING_ERROR_OUT_OF_MEMORY;
}
parameters = g_dbus_proxy_call_sync(proxy, "reset_port_forwarding_rule",
NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
- //LCOV_EXCL_START
ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
g_error_free(error);
return result;
- //LCOV_EXCL_STOP
}
g_variant_get(parameters, "(u)", &result);
return TETHERING_ERROR_NONE;
}
-API int tethering_wifi_is_port_forwarding_enabled(tethering_h tethering, bool* forwarding_enabled)
+API int tethering_wifi_is_port_forwarding_enabled(tethering_h tethering, bool *forwarding_enabled)
{
CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
g_variant_new("(b)", enable),
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
- //LCOV_EXCL_START
ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
g_error_free(error);
return result;
- //LCOV_EXCL_STOP
}
g_variant_get(parameters, "(u)", &result);
GVariant *parameters;
GError *error = NULL;
guint result;
- char cmd[MAX_BUF_SIZE] = { 0, };
char *list = NULL;
+ int ret;
__tethering_h *th = (__tethering_h *)tethering;
g_variant_new("(isb)", port, protocol, allow),
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
- //LCOV_EXCL_START
ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
g_error_free(error);
return result;
- //LCOV_EXCL_STOP
}
g_variant_get(parameters, "(u)", &result);
g_variant_unref(parameters);
if (allow)
- snprintf(cmd, sizeof(cmd), "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_ACCEPT);
+ ret = asprintf(&list, "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_ACCEPT);
else
- snprintf(cmd, sizeof(cmd), "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_DROP);
+ ret = asprintf(&list, "%s "FILTERING_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port, ACTION_DROP);
- DBG("cmd:%s", cmd);
-
- list = strdup(cmd);
- if (list == NULL) {
- ERR("strdup failed\n"); //LCOV_EXCL_LINE
+ if (ret == -1 || list == NULL) {
+ ERR("asprintf failed\n");
return TETHERING_ERROR_OUT_OF_MEMORY;
}
+ DBG("cmd:%s", list);
+
port_filtering = g_slist_append(port_filtering, list);
return TETHERING_ERROR_NONE;
GVariant *parameters;
GError *error = NULL;
guint result;
- char cmd[MAX_BUF_SIZE] = { 0, };
char *list = NULL;
+ int ret;
__tethering_h *th = (__tethering_h *)tethering;
g_variant_new("(iisb)", port1, port2, protocol, allow),
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
- //LCOV_EXCL_START
ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
g_error_free(error);
return result;
- //LCOV_EXCL_STOP
}
g_variant_get(parameters, "(u)", &result);
g_variant_unref(parameters);
if (allow)
- snprintf(cmd, sizeof(cmd), "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_ACCEPT);
+ ret = asprintf(&list, "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_ACCEPT);
else
- snprintf(cmd, sizeof(cmd), "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_DROP);
-
- DBG("cmd:%s", cmd);
+ ret = asprintf(&list, "%s "FILTERING_MULTIPORT_RULE_STR, IPTABLES, TABLE_FILTER, TETH_FILTER_FW, protocol, port1, port2, ACTION_DROP);
- list = strdup(cmd);
- if (list == NULL) {
- ERR("strdup failed\n"); //LCOV_EXCL_LINE
+ if (ret == -1 || list == NULL) {
+ ERR("asprintf failed\n");
return TETHERING_ERROR_OUT_OF_MEMORY;
}
+ DBG("cmd:%s", list);
+
custom_port_filtering = g_slist_append(custom_port_filtering, list);
return TETHERING_ERROR_NONE;
return TETHERING_ERROR_NONE;
}
-API int tethering_wifi_is_port_filtering_enabled(tethering_h tethering, bool* filtering_enabled)
+API int tethering_wifi_is_port_filtering_enabled(tethering_h tethering, bool *filtering_enabled)
{
CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
g_variant_new("(ib)", type, enable),
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
- //LCOV_EXCL_START
ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
g_error_free(error);
return result;
- //LCOV_EXCL_STOP
}
g_variant_get(parameters, "(u)", &result);
NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
- //LCOV_EXCL_START
ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
g_error_free(error);
return ret;
- //LCOV_EXCL_STOP
}
if (parameters != NULL) {
_retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
"parameter(tethering) is NULL");
+ _retvm_if(wps_pin == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+ "parameter(wps_pin) is NULL");
+
__tethering_h *th = (__tethering_h *)tethering;
GDBusProxy *proxy = th->client_bus_proxy;
GVariant *parameters = NULL;
g_variant_new("(s)", wps_pin), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
- //LCOV_EXCL_START
ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
g_error_free(error);
return ret;
- //LCOV_EXCL_STOP
}
if (parameters != NULL) {
return TETHERING_ERROR_NONE;
}
+API int tethering_wifi_is_sharing_supported(tethering_h tethering, bool *supported)
+{
+ CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+ CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+
+ _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+ "parameter(tethering) is NULL\n");
+ _retvm_if(supported == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+ "parameter(supported) is NULL\n");
+
+ /** Check if wifi-sharing is supported */
+ __tethering_h *th = (__tethering_h *)tethering;
+ GDBusProxy *proxy = th->client_bus_proxy;
+
+ int ret = TETHERING_ERROR_NONE;
+ int count = 0;
+ gchar *key = NULL;
+ GVariant *value = NULL;
+ GVariantIter *iter = NULL;
+ GVariantIter *sub_iter = NULL;
+ GVariant *parameters = NULL;
+ GError *error = NULL;
+
+ parameters = g_dbus_proxy_call_sync(proxy, "get_wifi_interfaces",
+ NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+
+ if (!parameters && error) {
+ ERR("g_dbus_proxy_call_sync failed because %s\n", error->message);
+
+ if (error->code == G_DBUS_ERROR_ACCESS_DENIED)
+ ret = TETHERING_ERROR_PERMISSION_DENIED;
+ else
+ ret = TETHERING_ERROR_OPERATION_FAILED;
+
+ g_error_free(error);
+ goto error;
+ }
+
+ g_variant_get(parameters, "(a(a{sv}))", &iter);
+ if (iter == NULL) {
+ g_variant_unref(parameters);
+ ret = TETHERING_ERROR_OPERATION_FAILED;
+ goto error;
+ }
+
+ while (g_variant_iter_loop(iter, "(a{sv})", &sub_iter)) {
+ while (g_variant_iter_loop(sub_iter, "{sv}", &key, &value)) {
+ if (g_strcmp0(key, "IfName") == 0) {
+ const gchar *interface = g_variant_get_string(value, NULL);
+ ERR("interface: %s\n", interface);
+ if (strncmp(interface, "wlan", 4) == 0)
+ count++;
+ }
+ }
+ }
+ g_variant_unref(parameters);
+
+ if (count > 1)
+ *supported = true;
+ else
+ *supported = false;
+
+error:
+ return ret;
+}
+
+API int tethering_wifi_set_sharing(tethering_h tethering, bool sharing)
+{
+ CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+ CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+
+ _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+ "parameter(tethering) is NULL\n");
+
+ __tethering_h *th = (__tethering_h *)tethering;
+ th->wifi_sharing = sharing;
+
+ return TETHERING_ERROR_NONE;
+}
+
+API int tethering_wifi_get_sharing(tethering_h tethering, bool *sharing)
+{
+ CHECK_FEATURE_SUPPORTED(TETHERING_FEATURE);
+ CHECK_FEATURE_SUPPORTED(TETHERING_WIFI_FEATURE);
+
+ _retvm_if(tethering == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+ "parameter(tethering) is NULL\n");
+ _retvm_if(sharing == NULL, TETHERING_ERROR_INVALID_PARAMETER,
+ "parameter(sharing) is NULL\n");
+
+ __tethering_h *th = (__tethering_h *)tethering;
+ *sharing = th->wifi_sharing;
+ return TETHERING_ERROR_NONE;
+}