#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 __thread tethering_request_table_t request_table[TETHERING_TYPE_MAX];
+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)
{
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 (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)
+ else if (ap_type == MOBILE_AP_TYPE_WIFI)
+ 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;
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];
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!");
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;
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: {
+ case TETHERING_TYPE_WIFI: {
_softap_settings_t set = {"", "", "", 0, false};
ret = __prepare_wifi_settings(tethering, &set);
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);
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,
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: {
+ case TETHERING_TYPE_WIFI: {
_softap_settings_t set = {"", "", "", 0, false, false, 0, 0};
ret = __prepare_wifi_settings(tethering, &set);
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_SHARING].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);
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,
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;
* @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);
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,
"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;
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)
+ else if (interface == MOBILE_AP_TYPE_WIFI)
+ 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;
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);
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,
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;
+}