#include <gio/gio.h>
#include <tzplatform_config.h>
+#include <hal-wifi.h>
#include "wifi-direct-oem.h"
#include "wfd-plugin-log.h"
#include "dbus/wfd-plugin-supplicant-dbus.h"
#include "wfd-plugin-wpasupplicant.h"
-#if defined(TIZEN_FEATURE_ASP)
#define GLIST_ITER_START(arg_list, elem)\
GList *temp = NULL;\
temp = g_list_first(arg_list);\
temp = g_list_next(temp);\
#define GLIST_ITER_END() }
-#endif
#define NETCONFIG_SERVICE "net.netconfig"
#define NETCONFIG_WIFI_INTERFACE "net.netconfig.wifi"
#define NETCONFIG_DBUS_REPLY_TIMEOUT (10 * 1000)
#define CONF_FILE_PATH tzplatform_mkpath(TZ_SYS_ETC, "wpa_supplicant/wpa_supplicant.conf")
-
-#ifndef DEFAULT_MAC_FILE_PATH
-#define DEFAULT_MAC_FILE_PATH "/sys/class/net/p2p0/address"
-#endif
+#define MAX_FILE_PATH_LEN 256
static wfd_oem_ops_s supplicant_ops = {
+ .configure = ws_configure,
.init = ws_init,
.deinit = ws_deinit,
.activate = ws_activate,
.remove_persistent_group = ws_remove_persistent_group,
.set_persistent_reconnect = ws_set_persistent_reconnect,
-#ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
.start_service_discovery = ws_start_service_discovery,
.cancel_service_discovery = ws_cancel_service_discovery,
.serv_add = ws_serv_add,
.serv_del = ws_serv_del,
-#endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
.miracast_init = ws_miracast_init,
.set_display = ws_set_display,
.remove_all_network = ws_remove_all_network,
.get_wpa_status = ws_get_wpa_status,
-#if defined(TIZEN_FEATURE_ASP)
.advertise_service = ws_advertise_service,
.cancel_advertise_service = ws_cancel_advertise_service,
.seek_service = ws_seek_service,
.cancel_seek_service = ws_cancel_seek_service,
.asp_prov_disc_req = ws_asp_prov_disc_req,
-#endif /* TIZEN_FEATURE_ASP */
+
+ .set_eapol_ip_config = ws_set_eapol_ip_config,
.add_vsie = ws_add_vsie,
.get_vsie = ws_get_vsie,
.remove_vsie = ws_remove_vsie,
+ .set_supported_wps_mode = ws_set_supported_wps_mode,
+ .remove_persistent_device = ws_remove_persistent_device,
+ .remove_all_persistent_device = ws_remove_all_persistent_device,
+
+ .get_supported_channels = ws_get_supported_channels,
.extra_data = NULL
};
static ws_dbus_plugin_data_s *g_pd;
+static wfd_oem_config_s *config = NULL;
static int is_peer_joined_notified = 0;
static int is_peer_disconnected_notified = 0;
+static int wps_config_method = WFD_OEM_WPS_MODE_PBC|WFD_OEM_WPS_MODE_DISPLAY|WFD_OEM_WPS_MODE_KEYPAD;
-#ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
static GList *service_list;
-#endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
static GList *seek_list;
static int __ws_txt_to_mac(unsigned char *txt, unsigned char *mac)
return WS_DBUS_STR_DISPLAY;
case WFD_OEM_WPS_MODE_KEYPAD:
return WS_DBUS_STR_KEYPAD;
-#if defined(TIZEN_FEATURE_ASP)
case WFD_OEM_WPS_MODE_NONE:
case WFD_OEM_WPS_MODE_P2PS:
return WS_DBUS_STR_P2PS;
-#endif /* TIZEN_FEATURE_ASP */
default:
return "";
}
return 0;
}
-#ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
static int __ws_byte_to_hex(char *buf, int buf_size, unsigned char *data, int data_len)
{
int i;
if (serv_tmp->status != 0) {
WDP_LOGE("Service status is not success");
- free(serv_tmp);
+ g_free(serv_tmp);
return -1;
}
temp[i+1] = (char) __ws_hex_to_num(ptr, 2);
ptr += 2;
}
- strncat(query, temp, size + 1);
+ g_strlcat(query, temp, sizeof(query));
g_free(temp);
temp = NULL;
}
ptr += 6;
if (dns_type == 12) {
if (!strncmp(compr, "c011", 4))
- strncat(query, ".local.", 7);
+ g_strlcat(query, ".local.", sizeof(query));
else if (!strncmp(compr, "c00c", 4))
- strncat(query, "._tcp.local.", 12);
+ g_strlcat(query, "._tcp.local.", sizeof(query));
else if (!strncmp(compr, "c01c", 4))
- strncat(query, "._udp.local.", 12);
+ g_strlcat(query, "._udp.local.", sizeof(query));
}
}
}
temp[i+1] = (char) __ws_hex_to_num(ptr, 2);
ptr += 2;
}
- strncat(rdata, temp, size + 1);
+ g_strlcat(rdata, temp, sizeof(rdata));
g_free(temp);
temp = NULL;
}
return 0;
}
-#endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
+
+static void __extract_addr_from_path(char *peer_path, unsigned char *dev_addr)
+{
+ static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
+ char *loc = NULL;
+
+ if (!peer_path || !dev_addr)
+ return;
+
+ loc = strrchr(peer_path, '/');
+ if (loc != NULL)
+ __ws_mac_compact_to_normal(loc + 1, peer_dev);
+
+ __ws_txt_to_mac(peer_dev, dev_addr);
+ WDP_LOGD("dev addr [" MACSTR "]", MAC2STR(dev_addr));
+}
static void __ws_path_to_addr(char *peer_path,
unsigned char *dev_addr, GVariant *parameter)
{
__WDP_LOG_FUNC_ENTER__;
- static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
const char *path = NULL;
- char *loc = NULL;
g_variant_get(parameter, "(&o)", &path);
g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
WDP_LOGD("Retrive Added path [%s]", peer_path);
- loc = strrchr(peer_path, '/');
- if (loc != NULL)
- __ws_mac_compact_to_normal(loc + 1, peer_dev);
-
- __ws_txt_to_mac(peer_dev, dev_addr);
- WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(dev_addr));
+ __extract_addr_from_path(peer_path, dev_addr);
__WDP_LOG_FUNC_EXIT__;
return;
{
GVariantIter *iter = NULL;
int length = 0;
- int res = 1;
if (!dst || !src || size == 0) {
WDP_LOGE("Invalid parameter");
}
g_variant_iter_free(iter);
- if (length < size) {
- WDP_LOGE("array is shorter than size");
- res = -1;
- }
-
- return res;
+ return length;
}
static int __ws_byte_to_txt(const unsigned char *src, char **dst, int src_len)
tmp_dst = (unsigned char *)g_try_malloc0(length + 1);
if (!tmp_dst) {
WDP_LOGE("failed to allocate memory");
+ g_variant_iter_free(iter_copy);
return 0;
}
{
__WDP_LOG_FUNC_ENTER__;
FILE *fd = NULL;
- const char *file_path = DEFAULT_MAC_FILE_PATH;
+ char file_path[MAX_FILE_PATH_LEN] = {0, };
char local_mac[OEM_MACSTR_LEN] = {0, };
char *ptr = NULL;
int res = 0;
char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
errno = 0;
+ g_snprintf(file_path, sizeof(file_path),
+ "/sys/class/net/%s/address", config->p2p_ifname);
+
fd = fopen(file_path, "r");
if (!fd) {
strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
return 0;
}
+static void _ws_manage_group_iface_signal(const gchar *group_iface_obj_path,
+ gboolean is_created);
+
static void _ws_process_interface_removed(GDBusConnection *connection,
const gchar *sender, const gchar *object_path, const gchar *interface,
const gchar *signal, GVariant *parameters, gpointer user_data)
if (!g_strcmp0(g_pd->group_iface_path, interface_path)) {
WDP_LOGD("p2p group interface removed");
memset(g_pd->group_iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
- }
-#if defined(TIZEN_PROFILE_MOBILE)
- else if (!g_strcmp0(g_pd->iface_path, interface_path)) {
+ } else if (!g_strcmp0(g_pd->iface_path, interface_path)) {
WDP_LOGD("p2p interface removed");
wfd_oem_event_s event;
memset(g_pd->iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
}
-#endif /* TIZEN_PROFILE_MOBILE */
__WDP_LOG_FUNC_EXIT__;
}
const char *name = NULL;
g_variant_get(value, "&s", &name);
- g_strlcpy(peer->dev_name, name, WS_SSID_LEN);
+ g_strlcpy(peer->dev_name, name, WS_SSID_LEN + 1);
WDP_LOGD("Device name [%s]", peer->dev_name);
} else if (g_strcmp0(key, "config_method") == 0) {
if (!ISZEROMACADDR(peer->go_dev_addr))
peer->dev_role = WFD_OEM_DEV_ROLE_GC;
+
+ } else if (g_strcmp0(key, "VSIE") == 0) {
+ int vsie_len;
+ unsigned char vsie[OEM_VSIE_MAX_LEN] = {0,};
+
+ vsie_len = __ws_unpack_ay(vsie, value, OEM_VSIE_MAX_LEN);
+ if (vsie_len > 0) {
+ __ws_byte_to_txt(vsie, (char **)&(peer->vsie), vsie_len);
+ WDP_LOGD("VSIE [%s]", peer->vsie);
+ }
+
} else {
WDP_LOGD("Unknown value");
}
const char *name = NULL;
g_variant_get(value, "&s", &name);
- g_strlcpy(peer->name, name, WS_SSID_LEN);
+ g_strlcpy(peer->name, name, WS_SSID_LEN + 1);
WDP_LOGD("Device Name [%s]", peer->name);
} else if (g_strcmp0(key, "config_method") == 0) {
if (!ISZEROMACADDR(go_dev_addr))
peer->dev_role = WFD_OEM_DEV_ROLE_GC;
-#if defined(TIZEN_FEATURE_ASP)
+
} else if (g_strcmp0(key, "AdvertiseService") == 0) {
if (value != NULL && g_variant_get_size(value) != 0)
peer->has_asp_services = 1;
else
peer->has_asp_services = 0;
+
} else if (g_strcmp0(key, "AdvertiseASPService") == 0) {
if (value != NULL && g_variant_get_size(value) != 0)
peer->has_asp2_services = 1;
else
peer->has_asp2_services = 0;
-#endif /* TIZEN_FEATURE_ASP */
+ } else if (g_strcmp0(key, "VSIE") == 0) {
+ int vsie_len;
+ unsigned char vsie[OEM_VSIE_MAX_LEN] = {0,};
+
+ vsie_len = __ws_unpack_ay(vsie, value, OEM_VSIE_MAX_LEN);
+ if (vsie_len > 0) {
+ __ws_byte_to_txt(vsie, (char **)&(peer->vsie), vsie_len);
+ WDP_LOGD("VSIE [%s]", peer->vsie);
+ }
+
} else {
WDP_LOGD("Unknown value");
}
__WDP_LOG_FUNC_ENTER__;
GVariantIter *iter;
- static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
+ gboolean iter_res = TRUE;
const char *path = NULL;
- char *loc = NULL;
-#ifdef TIZEN_FEATURE_IP_OVER_EAPOL
int i = 0;
-#endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
g_variant_get(parameter, "(&oay)", &path, &iter);
g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
WDP_LOGD("Retrive Added path [%s]", peer_path);
- loc = strrchr(peer_path, '/');
- if (loc != NULL)
- __ws_mac_compact_to_normal(loc + 1, peer_dev);
- __ws_txt_to_mac(peer_dev, dev_addr);
- WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(dev_addr));
-#ifdef TIZEN_FEATURE_IP_OVER_EAPOL
- for (i = 0; i < OEM_IPADDR_LEN; i++)
- g_variant_iter_loop(iter, "y", &ip_addr[i]);
+ __extract_addr_from_path(peer_path, dev_addr);
+
+ for (i = 0; iter_res && i < OEM_IPADDR_LEN; i++)
+ iter_res = g_variant_iter_loop(iter, "y", &ip_addr[i]);
g_variant_iter_free(iter);
WDP_LOGD("peer ip [" IPSTR "]", IP2STR(ip_addr));
-#endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
__WDP_LOG_FUNC_EXIT__;
return;
}
+static gboolean __is_valid_plugin(void)
+{
+ gboolean is_valid = (g_pd && g_pd->callback);
+
+ if (!is_valid)
+ WDP_LOGD("Ignoring event");
+
+ return is_valid;
+}
+
+static wfd_oem_dev_data_s *__create_dev_data(void)
+{
+ wfd_oem_dev_data_s *dev_data =
+ (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
+ if (!dev_data) {
+ char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
+ strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
+ WDP_LOGF("Failed to allocate memory for event. [%s]",
+ error_buf);
+ }
+
+ return dev_data;
+}
+
+static void __set_event_data(int event_id, int edata_type, void *data, wfd_oem_event_s *event)
+{
+ if (!event)
+ return;
+
+ memset(event, 0x0, sizeof(wfd_oem_event_s));
+
+ event->edata = data;
+ event->edata_type = edata_type;
+ event->event_id = event_id;
+
+ return;
+}
+
+static void __destroy_dev_data(wfd_oem_dev_data_s *dev_data)
+{
+ if (!dev_data)
+ return;
+
+ if (dev_data->vsie)
+ g_free(dev_data->vsie);
+ g_free(dev_data);
+}
+
static void _ws_process_peer_joined(GDBusConnection *connection,
const gchar *sender, const gchar *object_path, const gchar *interface,
const gchar *signal, GVariant *parameters, gpointer user_data)
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
+ if (!__is_valid_plugin())
return;
- }
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- error_buf);
+ dev_data = __create_dev_data();
+ if (!dev_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_STA_CONNECTED;
+ __set_event_data(WFD_OEM_EVENT_STA_CONNECTED,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
__ws_parse_peer_joined(peer_path, event.dev_addr, event.ip_addr_peer, parameters);
is_peer_joined_notified = 1;
- g_free(edata);
+ __destroy_dev_data(dev_data);
+
__WDP_LOG_FUNC_EXIT__;
}
g_strlcpy(interface_path, i_path, DBUS_OBJECT_PATH_MAX);
WDP_LOGD("Retrive Added path [%s]", interface_path);
g_strlcpy(g_pd->group_iface_path, interface_path, DBUS_OBJECT_PATH_MAX);
+
dbus_property_get_all(interface_path, g_pd->g_dbus,
SUPPLICANT_IFACE, __ws_interface_property, event);
+ _ws_manage_group_iface_signal(interface_path, TRUE);
+
} else if (g_strcmp0(key, "role") == 0) {
const char *role = NULL;
g_variant_get(value, "b", &group->is_persistent);
WDP_LOGD("Is Persistent : [%s]", group->is_persistent ? "YES" : "NO");
-#ifdef TIZEN_FEATURE_IP_OVER_EAPOL
} else if (g_strcmp0(key, "IpAddr") == 0) {
if (__ws_unpack_ay(group->ip_addr, value, OEM_IPADDR_LEN))
if (__ws_unpack_ay(group->ip_addr_go, value, OEM_IPADDR_LEN))
WDP_LOGD("GO IP address [" IPSTR "]", IP2STR(group->ip_addr_go));
-#endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
} else if (g_strcmp0(key, "group_object") == 0) {
static char group_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
const char *g_path;
return;
}
-#ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
void __ws_extract_peer_service(wfd_oem_event_s *data, unsigned char *service_hex, int tlvs_len)
{
GList *services = NULL;
__WDP_LOG_FUNC_EXIT__;
}
-#endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
-#if defined(TIZEN_FEATURE_ASP)
static void __ws_extract_serviceaspresponse_details(const char *key, GVariant *value, void *user_data)
{
__WDP_LOG_FUNC_ENTER__;
}
__WDP_LOG_FUNC_EXIT__;
}
-#endif /* TIZEN_FEATURE_ASP */
static int _ws_flush(void)
{
return 0;
}
-#if defined(TIZEN_FEATURE_ASP)
int ws_get_advertise_service(const char *peer_path, GList **asp_services)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
GVariant *param = NULL;
GVariant *reply = NULL;
- GVariant *temp = NULL;
+ GVariant *temp1 = NULL;
+ GVariant *temp2 = NULL;
GError *error = NULL;
GVariantIter *iter = NULL;
wfd_oem_advertise_service_s *service;
* So, you need to remove tuple out side of variant and
* variant out side of byte array
* */
- temp = g_variant_get_child_value(reply, 0);
- temp = g_variant_get_child_value(temp, 0);
- g_variant_get(temp, "ay", &iter);
+ temp1 = g_variant_get_child_value(reply, 0);
+ temp2 = g_variant_get_child_value(temp1, 0);
+ g_variant_get(temp2, "ay", &iter);
if (iter == NULL) {
g_variant_unref(reply);
WDP_LOGE("Failed to get iterator");
return -1;
}
+ g_variant_unref(temp2);
+ g_variant_unref(temp1);
while (1) {
/* 4byte advertisement ID, 2 byte config method, 1byte length */
GDBusConnection *g_dbus = NULL;
GVariant *param = NULL;
GVariant *reply = NULL;
- GVariant *temp = NULL;
+ GVariant *temp1 = NULL;
+ GVariant *temp2 = NULL;
GError *error = NULL;
GVariantIter *iter = NULL;
wfd_oem_advertise_service_s *service;
* So, you need to remove tuple out side of variant and
* variant out side of byte array
* */
- temp = g_variant_get_child_value(reply, 0);
- temp = g_variant_get_child_value(temp, 0);
- g_variant_get(temp, "ay", &iter);
+ temp1 = g_variant_get_child_value(reply, 0);
+ temp2 = g_variant_get_child_value(temp1, 0);
+ g_variant_get(temp2, "ay", &iter);
if (iter == NULL) {
g_variant_unref(reply);
WDP_LOGE("Failed to get iterator");
return -1;
}
+ g_variant_unref(temp2);
+ g_variant_unref(temp1);
while (1) {
/* 4byte advertisement ID, 2 byte config method, 1byte length */
__WDP_LOG_FUNC_EXIT__;
return res;
}
-#endif /* TIZEN_FEATURE_ASP */
static void _ws_process_device_found_properties(GDBusConnection *connection,
const gchar *sender, const gchar *object_path, const gchar *interface,
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
- char *loc = NULL;
GVariantIter *iter = NULL;
const char *path = NULL;
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
+ if (!__is_valid_plugin())
return;
- }
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- error_buf);
+ dev_data = __create_dev_data();
+ if (!dev_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_PEER_FOUND;
+ __set_event_data(WFD_OEM_EVENT_PEER_FOUND,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
g_variant_get(parameters, "(&oa{sv})", &path, &iter);
g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
WDP_LOGD("Retrive Added path [%s]", peer_path);
- loc = strrchr(peer_path, '/');
- if (loc != NULL)
- __ws_mac_compact_to_normal(loc + 1, peer_dev);
- __ws_txt_to_mac(peer_dev, event.dev_addr);
- WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
+ __extract_addr_from_path(peer_path, event.dev_addr);
if (iter != NULL) {
gchar *key = NULL;
while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
CHECK_KEY_VALUE(key, value);
- __ws_peer_property(key, value, (void *) event.edata);
+ __ws_peer_property(key, value, (void *)event.edata);
}
g_variant_iter_free(iter);
}
-#if defined(TIZEN_FEATURE_ASP)
- if (edata->has_asp_services)
+ if (dev_data->has_asp_services)
ws_get_advertise_service(peer_path, (GList **)&(event.asp_services));
- if (edata->has_asp2_services)
+ if (dev_data->has_asp2_services)
ws_get_advertise_asp_service(peer_path, (GList **)&(event.asp2_services));
-#endif /* TIZEN_FEATURE_ASP */
if (g_pd->callback->peer_found_cb)
g_pd->callback->peer_found_cb(&event);
-#if defined(TIZEN_FEATURE_ASP)
if (event.asp_services != NULL) {
GList *l;
wfd_oem_advertise_service_s *service;
g_free(service);
}
}
-#endif /* TIZEN_FEATURE_ASP */
- g_free(event.edata);
+
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
const char *path = NULL;
const char *pin = NULL;
- char *loc = NULL;
-
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
+ if (!__is_valid_plugin())
return;
- }
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- error_buf);
+ dev_data = __create_dev_data();
+ if (!dev_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
+ __set_event_data(WFD_OEM_EVENT_PROV_DISC_REQ,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
event.wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
g_variant_get(parameters, "(&o&s)", &path, &pin);
g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
WDP_LOGD("Retrive Added path [%s]", peer_path);
- loc = strrchr(peer_path, '/');
- if (loc != NULL)
- __ws_mac_compact_to_normal(loc + 1, peer_dev);
- __ws_txt_to_mac(peer_dev, event.dev_addr);
- WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
+ __extract_addr_from_path(peer_path, event.dev_addr);
g_strlcpy(event.wps_pin, pin, WS_PINSTR_LEN + 1);
WDP_LOGD("Retrive pin [%s]", event.wps_pin);
if (g_pd->callback->prov_disc_req_cb)
g_pd->callback->prov_disc_req_cb(&event);
- g_free(event.edata);
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
const char *path = NULL;
const char *pin = NULL;
- char *loc = NULL;
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
+ if (!__is_valid_plugin())
return;
- }
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- error_buf);
+ dev_data = __create_dev_data();
+ if (!dev_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
+ __set_event_data(WFD_OEM_EVENT_PROV_DISC_RESP,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
event.wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
g_variant_get(parameters, "(&o&s)", &path, &pin);
g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
WDP_LOGD("Retrive Added path [%s]", peer_path);
- loc = strrchr(peer_path, '/');
- if (loc != NULL)
- __ws_mac_compact_to_normal(loc + 1, peer_dev);
- __ws_txt_to_mac(peer_dev, event.dev_addr);
- WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
+ __extract_addr_from_path(peer_path, event.dev_addr);
g_strlcpy(event.wps_pin, pin, WS_PINSTR_LEN + 1);
WDP_LOGD("Retrive pin [%s]", event.wps_pin);
if (g_pd->callback->prov_disc_resp_cb)
g_pd->callback->prov_disc_resp_cb(&event);
- g_free(event.edata);
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
-
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
+ if (!__is_valid_plugin())
return;
- }
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- error_buf);
+ dev_data = __create_dev_data();
+ if (!dev_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
+ __set_event_data(WFD_OEM_EVENT_PROV_DISC_REQ,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
event.wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
__ws_path_to_addr(peer_path, event.dev_addr, parameters);
if (g_pd->callback->prov_disc_req_cb)
g_pd->callback->prov_disc_req_cb(&event);
- g_free(event.edata);
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
+ if (!__is_valid_plugin())
return;
- }
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- error_buf);
+ dev_data = __create_dev_data();
+ if (!dev_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
+ __set_event_data(WFD_OEM_EVENT_PROV_DISC_RESP,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
+
event.wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
__ws_path_to_addr(peer_path, event.dev_addr, parameters);
if (g_pd->callback->prov_disc_resp_cb)
g_pd->callback->prov_disc_resp_cb(&event);
- g_free(event.edata);
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
+ if (!__is_valid_plugin())
return;
- }
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- error_buf);
+ dev_data = __create_dev_data();
+ if (!dev_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
-
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
+ __set_event_data(WFD_OEM_EVENT_PROV_DISC_REQ,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
event.wps_mode = WFD_OEM_WPS_MODE_PBC;
__ws_path_to_addr(peer_path, event.dev_addr, parameters);
if (g_pd->callback->prov_disc_req_cb)
g_pd->callback->prov_disc_req_cb(&event);
- g_free(event.edata);
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
+ if (!__is_valid_plugin())
return;
- }
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- error_buf);
+ dev_data = __create_dev_data();
+ if (!dev_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
-
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
+ __set_event_data(WFD_OEM_EVENT_PROV_DISC_RESP,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
event.wps_mode = WFD_OEM_WPS_MODE_PBC;
__ws_path_to_addr(peer_path, event.dev_addr, parameters);
if (g_pd->callback->prov_disc_resp_cb)
g_pd->callback->prov_disc_resp_cb(&event);
- g_free(event.edata);
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
-#if defined(TIZEN_FEATURE_ASP)
static void _ws_process_prov_disc_failure(GDBusConnection *connection,
const gchar *sender, const gchar *object_path, const gchar *interface,
const gchar *signal, GVariant *parameters, gpointer user_data)
__WDP_LOG_FUNC_EXIT__;
}
-#else
-static void _ws_process_prov_disc_failure(GDBusConnection *connection,
- const gchar *sender, const gchar *object_path, const gchar *interface,
- const gchar *signal, GVariant *parameters, gpointer user_data)
-{
- __WDP_LOG_FUNC_ENTER__;
- wfd_oem_event_s event;
- static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
- const char *path = NULL;
- int prov_status = 0;
- char *loc = NULL;
-
- DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
-
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
- return;
- }
-
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
-
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_PROV_DISC_FAIL;
-
- g_variant_get(parameters, "(&oi)", &path, &prov_status);
- g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
- WDP_LOGD("Retrive Added path [%s]", peer_path);
- WDP_LOGD("Retrive Failure stateus [%d]", prov_status);
-
- loc = strrchr(peer_path, '/');
- if (loc != NULL)
- __ws_mac_compact_to_normal(loc + 1, peer_dev);
- __ws_txt_to_mac(peer_dev, event.dev_addr);
- WDP_LOGE("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
-
- if (g_pd->callback->prov_disc_fail_cb)
- g_pd->callback->prov_disc_fail_cb(&event);
-
- __WDP_LOG_FUNC_EXIT__;
-}
-#endif /* TIZEN_FEATURE_ASP */
-
static void _ws_process_group_started(GDBusConnection *connection,
const gchar *sender, const gchar *object_path, const gchar *interface,
__WDP_LOG_FUNC_EXIT__;
}
+static void __set_wps_mode_for_event(int dev_passwd_id, wfd_oem_event_s *event)
+{
+ if (!event)
+ return;
+
+ WDP_LOGD("Retrive dev_passwd_id [%d]", dev_passwd_id);
+
+ if (dev_passwd_id == WS_DEV_PASSWD_ID_PUSH_BUTTON)
+ event->wps_mode = WFD_OEM_WPS_MODE_PBC;
+ else if (dev_passwd_id == WS_DEV_PASSWD_ID_REGISTRAR_SPECIFIED)
+ event->wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
+ else if (dev_passwd_id == WS_DEV_PASSWD_ID_USER_SPECIFIED)
+ event->wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
+ else
+ event->wps_mode = WFD_OEM_WPS_MODE_NONE;
+}
+
static void _ws_process_go_neg_request(GDBusConnection *connection,
const gchar *sender, const gchar *object_path, const gchar *interface,
const gchar *signal, GVariant *parameters, gpointer user_data)
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
const char *path = NULL;
- char * loc = NULL;
int dev_passwd_id = 0;
int device_go_intent = 0;
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
+ if (!__is_valid_plugin())
return;
- }
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- error_buf);
+ dev_data = __create_dev_data();
+ if (!dev_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
-
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_GO_NEG_REQ;
+ __set_event_data(WFD_OEM_EVENT_GO_NEG_REQ,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
g_variant_get(parameters, "(&oqy)", &path, &dev_passwd_id, &device_go_intent);
g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
WDP_LOGD("Retrive peer path [%s]", peer_path);
- WDP_LOGD("Retrive dev_passwd_id [%d]", dev_passwd_id);
+ __set_wps_mode_for_event(dev_passwd_id, &event);
WDP_LOGD("Retrive device_go_intent [%d]", device_go_intent);
+ dev_data->device_go_intent = device_go_intent;
- if (dev_passwd_id == WS_DEV_PASSWD_ID_PUSH_BUTTON)
- event.wps_mode = WFD_OEM_WPS_MODE_PBC;
- else if (dev_passwd_id == WS_DEV_PASSWD_ID_REGISTRAR_SPECIFIED)
- event.wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
- else if (dev_passwd_id == WS_DEV_PASSWD_ID_USER_SPECIFIED)
- event.wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
- else
- event.wps_mode = WFD_OEM_WPS_MODE_NONE;
- edata->device_go_intent = device_go_intent;
-
- loc = strrchr(peer_path, '/');
- if (loc != NULL)
- __ws_mac_compact_to_normal(loc + 1, peer_dev);
- __ws_txt_to_mac(peer_dev, event.dev_addr);
- WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
+ __extract_addr_from_path(peer_path, event.dev_addr);
dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
__ws_peer_property, event.edata);
if (g_pd->callback->go_neg_req_cb)
g_pd->callback->go_neg_req_cb(&event);
- g_free(event.edata);
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
g_dbus_connection_signal_unsubscribe(g_pd->g_dbus, ws_group_signal_map[i].sub_id);
ws_group_signal_map[i].sub_id = 0;
}
+
+ _ws_manage_group_iface_signal(interface, FALSE);
memset(g_pd->group_iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
_ws_flush();
__WDP_LOG_FUNC_EXIT__;
}
-#ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
static void _ws_process_service_discovery_response(GDBusConnection *connection,
const gchar *sender, const gchar *object_path, const gchar *interface,
const gchar *signal, GVariant *parameters, gpointer user_data)
__WDP_LOG_FUNC_EXIT__;
}
-#endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
-#if defined(TIZEN_FEATURE_ASP)
static void _ws_process_service_asp_response(GDBusConnection *connection,
const gchar *sender, const gchar *object_path, const gchar *interface,
const gchar *signal, GVariant *parameters, gpointer user_data)
__WDP_LOG_FUNC_EXIT__;
}
-#endif /* TIZEN_FEATURE_ASP */
static void _ws_process_persistent_group_added(GDBusConnection *connection,
const gchar *sender, const gchar *object_path, const gchar *interface,
__WDP_LOG_FUNC_EXIT__;
}
-#if defined(TIZEN_FEATURE_ASP)
static void _ws_process_asp_provision_start(GDBusConnection *connection,
const gchar *sender, const gchar *object_path, const gchar *interface,
const gchar *signal, GVariant *parameters, gpointer user_data)
__WDP_LOG_FUNC_EXIT__;
}
-#endif /* TIZEN_FEATURE_ASP */
static struct {
int sub_id;
"GroupFinished",
_ws_process_group_finished
},
-#ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
{
0,
SUPPLICANT_P2PDEVICE,
"ServiceDiscoveryResponse",
_ws_process_service_discovery_response
},
-#endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
-#if defined(TIZEN_FEATURE_ASP)
{
0,
SUPPLICANT_P2PDEVICE,
"ASPProvisionDone",
_ws_process_asp_provision_done
},
-#endif /* TIZEN_FEATURE_ASP */
{
0,
SUPPLICANT_P2PDEVICE,
}
};
+static struct {
+ int sub_id;
+ const char *interface;
+ const char *member;
+ void (*function) (GDBusConnection *connection,
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data);
+} ws_group_interface_signal_map[] = {
+ {
+ 0,
+ SUPPLICANT_IFACE,
+ "StaAuthorized",
+ _ws_process_sta_authorized
+ },
+ {
+ 0,
+ SUPPLICANT_IFACE,
+ "StaDeauthorized",
+ _ws_process_sta_deauthorized
+ },
+ {
+ 0,
+ NULL,
+ NULL,
+ NULL
+ }
+};
+
static void __register_p2pdevice_signal(GVariant *value, void *user_data)
{
__WDP_LOG_FUNC_ENTER__;
WDP_LOGD("Succeeded to CreateInterface");
__WDP_LOG_FUNC_EXIT__;
- return 0;
+ return res;
}
static int _ws_get_interface(const char *iface_name, handle_reply function, void *user_data)
return res;
}
-#if defined(TIZEN_PROFILE_MOBILE) && (TIZEN_WLAN_BOARD_SPRD)
static void __ws_remove_interface(GVariant *value, void *user_data)
{
__WDP_LOG_FUNC_ENTER__;
__WDP_LOG_FUNC_EXIT__;
return;
}
-#endif /* (TIZEN_PROFILE_MOBILE) && (TIZEN_WLAN_BOARD_SPRD) */
static int _ws_init_dbus_connection(void)
{
return -1;
}
+ if (!config) {
+ WDP_LOGE("no configurable data found");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
if (conn == NULL) {
WDP_LOGD("Subscribed supplicant iface signal [%s]", ws_supplicant_signal_map[i].member);
}
-#if defined(TIZEN_PROFILE_MOBILE) && (TIZEN_WLAN_BOARD_SPRD)
- if (_ws_get_interface(COMMON_IFACE_NAME, NULL, NULL) < 0)
- _ws_create_interface(COMMON_IFACE_NAME, NULL, NULL);
- if (_ws_get_interface(P2P_IFACE_NAME, __register_p2pdevice_signal, NULL) < 0)
- res = _ws_create_interface(P2P_IFACE_NAME, __register_p2pdevice_signal, NULL);
-#else /* (TIZEN_PROFILE_MOBILE) && (TIZEN_WLAN_BOARD_SPRD) */
- if (_ws_get_interface(COMMON_IFACE_NAME, __register_p2pdevice_signal, NULL) < 0)
- res = _ws_create_interface(COMMON_IFACE_NAME, __register_p2pdevice_signal, NULL);
-#endif /* (TIZEN_PROFILE_MOBILE) && (TIZEN_WLAN_BOARD_SPRD) */
+ if (g_strcmp0(config->ifname, config->p2p_ifname) != 0) {
+ if (_ws_get_interface(config->ifname, NULL, NULL) < 0)
+ res = _ws_create_interface(config->ifname, NULL, NULL);
+ if (_ws_get_interface(config->p2p_ifname, __register_p2pdevice_signal, NULL) < 0)
+ res = _ws_create_interface(config->p2p_ifname, __register_p2pdevice_signal, NULL);
+ } else {
+ if (_ws_get_interface(config->p2p_ifname, __register_p2pdevice_signal, NULL) < 0)
+ res = _ws_create_interface(config->p2p_ifname, __register_p2pdevice_signal, NULL);
+ }
if (res < 0)
WDP_LOGE("Failed to subscribe interface signal");
return 0;
}
+static void _ws_manage_group_iface_signal(const gchar *group_iface_obj_path,
+ gboolean is_created)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *connection;
+
+ if (!g_pd) {
+ WDP_LOGD("Ignore");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
+ if (!g_strcmp0(g_pd->iface_path, group_iface_obj_path)) {
+ WDP_LOGD("group iface is p2p iface, ignore");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
+ connection = g_pd->g_dbus;
+ int i;
+ if (is_created) {
+ /* subscribe Interface iface signal */
+ for (i = 0; ws_group_interface_signal_map[i].member != NULL; i++) {
+ ws_group_interface_signal_map[i].sub_id =
+ g_dbus_connection_signal_subscribe(connection,
+ SUPPLICANT_SERVICE, /* bus name */
+ ws_group_interface_signal_map[i].interface, /* interface */
+ ws_group_interface_signal_map[i].member, /* member */
+ group_iface_obj_path, /* object path */
+ NULL, /* arg0 */
+ G_DBUS_SIGNAL_FLAGS_NONE,
+ ws_group_interface_signal_map[i].function,
+ NULL, NULL);
+ WDP_LOGD("Subscribed Interface iface signal [%s]", ws_group_interface_signal_map[i].member);
+ }
+
+ } else {
+ for (i = 0; ws_group_interface_signal_map[i].member != NULL; i++) {
+ g_dbus_connection_signal_unsubscribe(connection, ws_group_interface_signal_map[i].sub_id);
+ ws_group_interface_signal_map[i].sub_id = 0;
+ }
+ }
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+}
+
int wfd_plugin_load(wfd_oem_ops_s **ops)
{
__WDP_LOG_FUNC_ENTER__;
}
memset(&ifr, 0, sizeof(ifr));
- strncpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
- ifr.ifr_name[IFNAMSIZ-1] = '\0';
+ g_strlcpy(ifr.ifr_name, if_name, IFNAMSIZ);
if (ioctl(fd, SIOCGIFFLAGS, &ifr) < 0) {
close(fd);
return 0;
}
+int ws_configure(wfd_oem_config_s *conf)
+{
+ __WDP_LOG_FUNC_ENTER__;
+
+ if (conf == NULL) {
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ if (config)
+ g_free(config);
+
+ config = (wfd_oem_config_s *) g_try_malloc0(sizeof(wfd_oem_config_s));
+ if (!config) {
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ memcpy(config, conf, sizeof(wfd_oem_config_s));
+
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
+
int ws_init(wfd_oem_event_cbs_s *event_cbs)
{
__WDP_LOG_FUNC_ENTER__;
g_pd = NULL;
}
+ if (config)
+ g_free(config);
+
__WDP_LOG_FUNC_EXIT__;
return 0;
}
return FALSE;
}
-static int __ws_p2p_firmware_start(void)
+static int __ws_p2p_firmware_start(const char *interface_name)
{
- gboolean rv = FALSE;
- const char *path = "/usr/bin/wlan.sh";
- char *const args[] = { "/usr/bin/wlan.sh", "p2p", NULL };
- char *const envs[] = { NULL };
+ GError *error = NULL;
+ GDBusConnection *conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
+ if (conn == NULL) {
+ WDP_LOGE("Failed to get system bus");
+ return -1;
+ }
- rv = _ws_util_execute_file(path, args, envs);
- if (rv != TRUE)
- return -1;
+ error = NULL;
+ GVariant *params = g_variant_new("(sb)", interface_name, FALSE);
+ GVariant *reply = g_dbus_connection_call_sync(
+ conn,
+ NETCONFIG_SERVICE, /* bus name */
+ NETCONFIG_WIFI_PATH, /* object path */
+ NETCONFIG_WIFI_INTERFACE, /* interface name */
+ "LoadDriver", /* method name */
+ params, /* GVariant *params */
+ NULL, /* reply_type */
+ G_DBUS_CALL_FLAGS_NONE, /* flags */
+ SUPPLICANT_TIMEOUT , /* timeout */
+ NULL, /* cancellable */
+ &error); /* error */
+
+ if (error != NULL) {
+ WDP_LOGE("Error! Failed to call method: [%s]", error->message);
+ g_error_free(error);
+ __WDP_LOG_FUNC_EXIT__;
+ }
+
+ if (reply)
+ g_variant_unref(reply);
+ g_object_unref(conn);
- WDP_LOGI("Successfully loaded p2p device driver");
return 0;
}
-static int __ws_p2p_firmware_stop(void)
+static int __ws_p2p_firmware_stop(const char *interface_name)
{
- gboolean rv = FALSE;
- const char *path = "/usr/bin/wlan.sh";
- char *const args[] = { "/usr/bin/wlan.sh", "stop", NULL };
- char *const envs[] = { NULL };
- rv = _ws_util_execute_file(path, args, envs);
- if (rv < 0)
+ int rv = 0;
+
+ rv = hal_wifi_get_backend();
+ if (rv < 0) {
+ WDP_LOGD("hal_wifi_get_backend() failed, ret: %d", rv);
return -1;
+ }
+
+ rv = hal_wifi_stop(interface_name);
+ if (rv < 0) {
+ WDP_LOGD("hal_wifi_stop() failed, ret: %d", rv);
+ return -1;
+ }
WDP_LOGI("Successfully removed p2p device driver");
return 0;
GVariantBuilder *type_builder = NULL;
dbus_method_param_s params;
- const char *primary_device_type = PRIMARY_DEVICE_TYPE;
+ unsigned char primary_device_type[8] = {
+ 0x00, 0x00, 0x00, 0x50,
+ 0xf2, 0x04, 0x00, 0x00
+ };
-#ifdef TIZEN_FEATURE_IP_OVER_EAPOL
- const char *ip_addr_go = DEFAULT_IP_GO;
- const char *ip_addr_mask = DEFAULT_IP_MASK;
- const char *ip_addr_start = DEFAULT_IP_START;
- const char *ip_addr_end = DEFAULT_IP_END;
-#endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
int i = 0;
int res = 0;
return -1;
}
+ if (!config) {
+ WDP_LOGE("no configurable data found");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ primary_device_type[1] = config->pri_dev_type;
+ primary_device_type[7] = config->sec_dev_type;
+
for (i = 0; i < WS_DEVTYPE_LEN; i++)
WDP_LOGD("device type[%02x]", primary_device_type[i]);
builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
g_variant_builder_add(builder, "{sv}", "DeviceName",
- g_variant_new_string(DEFAULT_DEVICE_NAME));
+ g_variant_new_string(config->device_name));
g_variant_builder_add(builder, "{sv}", "GOIntent",
- g_variant_new_uint32(DEFAULT_GO_INTENT));
+ g_variant_new_uint32(config->go_intent));
g_variant_builder_add(builder, "{sv}", "PersistentReconnect",
- g_variant_new_boolean(DEFAULT_PERSISTENT_RECONNECT));
+ g_variant_new_boolean(config->persistent_reconnect));
g_variant_builder_add(builder, "{sv}", "ListenRegClass",
- g_variant_new_uint32(DEFAULT_LISTEN_REG_CLASS));
+ g_variant_new_uint32(config->listen_reg_class));
g_variant_builder_add(builder, "{sv}", "ListenChannel",
- g_variant_new_uint32(DEFAULT_LISTEN_CHANNEL));
+ g_variant_new_uint32(config->listen_channel));
g_variant_builder_add(builder, "{sv}", "OperRegClass",
- g_variant_new_uint32(DEFAULT_OPER_REG_CLASS));
+ g_variant_new_uint32(config->operating_reg_class));
g_variant_builder_add(builder, "{sv}", "OperChannel",
- g_variant_new_uint32(DEFAULT_OPER_CHANNEL));
+ g_variant_new_uint32(config->operating_channel));
g_variant_builder_add(builder, "{sv}", "SsidPostfix",
- g_variant_new_string(DEFAULT_DEVICE_NAME));
+ g_variant_new_string(config->device_name));
g_variant_builder_add(builder, "{sv}", "NoGroupIface",
- g_variant_new_boolean(DEFAULT_NO_GROUP_IFACE));
+ g_variant_new_boolean(config->no_group_iface));
type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
for (i = 0; i < WS_DEVTYPE_LEN; i++)
g_variant_builder_add(builder, "{sv}", "PrimaryDeviceType",
g_variant_new("ay", type_builder));
g_variant_builder_unref(type_builder);
-#ifdef TIZEN_FEATURE_IP_OVER_EAPOL
- type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
- for (i = 0; i < OEM_IPADDR_LEN; i++)
- g_variant_builder_add(type_builder, "y", ip_addr_go[i]);
- g_variant_builder_add(builder, "{sv}", "IpAddrGO",
- g_variant_new("ay", type_builder));
- g_variant_builder_unref(type_builder);
-
- type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
- for (i = 0; i < OEM_IPADDR_LEN; i++)
- g_variant_builder_add(type_builder, "y", ip_addr_mask[i]);
- g_variant_builder_add(builder, "{sv}", "IpAddrMask",
- g_variant_new("ay", type_builder));
- g_variant_builder_unref(type_builder);
-
- type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
- for (i = 0; i < OEM_IPADDR_LEN; i++)
- g_variant_builder_add(type_builder, "y", ip_addr_start[i]);
- g_variant_builder_add(builder, "{sv}", "IpAddrStart",
- g_variant_new("ay", type_builder));
- g_variant_builder_unref(type_builder);
-
- type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
- for (i = 0; i < OEM_IPADDR_LEN; i++)
- g_variant_builder_add(type_builder, "y", ip_addr_end[i]);
- g_variant_builder_add(builder, "{sv}", "IpAddrEnd",
- g_variant_new("ay", type_builder));
- g_variant_builder_unref(type_builder);
-#endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
value = g_variant_new("a{sv}", builder);
g_variant_builder_unref(builder);
return -1;
}
+ if (!config) {
+ WDP_LOGE("no configurable data found");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
g_dbus = g_pd->g_dbus;
if (!g_dbus) {
WDP_LOGE("DBus connection is NULL");
dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
g_dbus);
- value = g_variant_new_string(DEFAULT_CONFIG_METHOD);
+ value = g_variant_new_string(config->config_methods);
param = g_variant_new("(ssv)", SUPPLICANT_WPS, "ConfigMethods", value);
params.params = param;
if (res < 0)
WDP_LOGE("Failed to send command to wpa_supplicant");
else
- WDP_LOGD("Succeeded to set config method(%s)", DEFAULT_CONFIG_METHOD);
+ WDP_LOGD("Succeeded to set config method(%s)", config->config_methods);
__WDP_LOG_FUNC_EXIT__;
return res;
return -1;
}
+ if (!config) {
+ WDP_LOGE("no configurable data found");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
res = __ws_p2p_supplicant_start();
if (res < 0) {
res = __ws_p2p_supplicant_stop();
while (retry_count < WS_CONN_RETRY_COUNT) {
/* load wlan driver */
if (concurrent == 0)
- res = __ws_p2p_firmware_start();
+ res = __ws_p2p_firmware_start(config->ifname);
if (res < 0) {
WDP_LOGE("Failed to load driver [ret=%d]", res);
return -1;
}
WDP_LOGI("P2P firmware started with error %d", res);
- if (__ws_check_net_interface(COMMON_IFACE_NAME) < 0) {
+ if (__ws_check_net_interface(config->ifname) < 0) {
usleep(150000); /* wait for 150ms */
concurrent = 0;
retry_count++;
}
if (retry_count >= WS_CONN_RETRY_COUNT) {
- WDP_LOGE("Driver loading is failed", res);
+ WDP_LOGE("Driver loading is failed [%d]", res);
__WDP_LOG_FUNC_EXIT__;
return -1;
}
if (res < 0) {
res = __ws_p2p_supplicant_stop();
WDP_LOGI("[/usr/sbin/p2p_supp.sh stop] returns %d", res);
- res = __ws_p2p_firmware_stop();
+ res = __ws_p2p_firmware_stop(config->ifname);
WDP_LOGI("P2P firmware stopped with error %d", res);
__WDP_LOG_FUNC_EXIT__;
return -1;
int ws_deactivate(int concurrent)
{
__WDP_LOG_FUNC_ENTER__;
-#if defined(TIZEN_FEATURE_ASP)
wfd_oem_asp_service_s *data = NULL;
-#endif /* TIZEN_FEATURE_ASP */
- int res = 0;
+ int res = -1;
if (!g_pd) {
WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
__WDP_LOG_FUNC_EXIT__;
- return -1;
+ return res;
+ }
+
+ if (!config) {
+ WDP_LOGE("no configurable data found");
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
}
if (!g_pd->activated) {
WDP_LOGE("Wi-Fi Direct is not activated");
__WDP_LOG_FUNC_EXIT__;
- return -1;
+ return res;
}
ws_stop_scan();
g_pd->concurrent = concurrent;
-#if defined(TIZEN_PROFILE_MOBILE) && (TIZEN_WLAN_BOARD_SPRD)
- _ws_get_interface(P2P_IFACE_NAME, __ws_remove_interface, NULL);
+
+ if (g_strcmp0(config->ifname, config->group_ifname) != 0)
+ _ws_get_interface(config->group_ifname, __ws_remove_interface, NULL);
if (concurrent == 0)
- _ws_get_interface(COMMON_IFACE_NAME, __ws_remove_interface, NULL);
-#endif /* (TIZEN_PROFILE_MOBILE) && (TIZEN_WLAN_BOARD_SPRD) */
+ _ws_get_interface(config->ifname, __ws_remove_interface, NULL);
_ws_deinit_dbus_connection();
if (concurrent == 0) {
res = __ws_p2p_supplicant_stop();
WDP_LOGI("[/usr/sbin/p2p_supp.sh stop] returns %d", res);
- res = __ws_p2p_firmware_stop();
+ res = __ws_p2p_firmware_stop(config->ifname);
WDP_LOGI("P2P firmware stopped with error %d", res);
}
g_pd->activated = FALSE;
-#if defined(TIZEN_FEATURE_ASP)
GLIST_ITER_START(seek_list, data)
if (data) {
}
GLIST_ITER_END()
-#endif /* TIZEN_FEATURE_ASP */
__WDP_LOG_FUNC_EXIT__;
return 0;
}
}
#endif
-#if defined(TIZEN_FEATURE_ASP)
static void __ws_add_seek_params(GVariantBuilder *builder)
{
GVariantBuilder *outter = NULL;
return;
}
-#endif /* TIZEN_FEATURE_ASP */
int ws_start_scan(wfd_oem_scan_param_s *param)
{
if (param->scan_type == WFD_OEM_SCAN_TYPE_SOCIAL)
g_variant_builder_add(builder, "{sv}", "DiscoveryType",
g_variant_new_string("social"));
-#if defined(TIZEN_FEATURE_ASP)
if (seek_list != NULL)
__ws_add_seek_params(builder);
-#endif /* TIZEN_FEATURE_ASP */
value = g_variant_new("(a{sv})", builder);
g_variant_builder_unref(builder);
__WDP_LOG_FUNC_EXIT__;
return 0;
}
+static wfd_oem_device_s *__create_oem_device(void)
+{
+ wfd_oem_device_s *device =
+ (wfd_oem_device_s *) g_try_malloc0(sizeof(wfd_oem_device_s));
+ if (!device) {
+ char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
+ strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
+ WDP_LOGF("Failed to allocate memory for event. [%s]",
+ error_buf);
+ }
+
+ return device;
+}
int ws_get_peer_info(unsigned char *peer_addr, wfd_oem_device_s **peer)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
- wfd_oem_device_s *ws_dev = NULL;
+ wfd_oem_device_s *device = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
int res = 0;
return -1;
}
- ws_dev = (wfd_oem_device_s *) g_try_malloc0(sizeof(wfd_oem_device_s));
- if (!ws_dev) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory device. [%s]",
- error_buf);
+ device = __create_oem_device();
+ if (!device) {
__WDP_LOG_FUNC_EXIT__;
return -1;
}
WDP_LOGD("get peer path [%s]", peer_path);
res = dbus_property_get_all(peer_path, g_dbus, SUPPLICANT_P2P_PEER,
- __ws_get_peer_property, ws_dev);
+ __ws_get_peer_property, device);
if (res < 0) {
- WDP_LOGE("Failed to send command to wpa_supplicant");
- g_free(ws_dev);
- __WDP_LOG_FUNC_EXIT__;
- return -1;
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ if (device->vsie)
+ g_free(device->vsie);
+ g_free(device);
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
} else {
WDP_LOGD("succeeded to get peer info");
- *peer = ws_dev;
+ *peer = device;
}
+
+ //Memory ownership of dev_data is transferred to method handler
+ //which uses this function.
+
__WDP_LOG_FUNC_EXIT__;
return 0;
}
int ws_get_supported_wps_mode(int *wps_mode)
{
__WDP_LOG_FUNC_ENTER__;
+ if (!wps_mode) {
+ WDP_LOGE("Invalid parameter");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+ *wps_mode = wps_config_method;
__WDP_LOG_FUNC_EXIT__;
return 0;
}
__WDP_LOG_FUNC_EXIT__;
return -1;
}
+ memset(&networks, 0x0, WS_MAX_PERSISTENT_COUNT * sizeof(ws_network_info_s));
dbus_property_get_all(g_pd->iface_path, g_dbus, SUPPLICANT_P2PDEVICE,
__ws_extract_p2pdevice_details, networks);
return res;
}
-#ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
static int __ws_compress_query(char *compressed, char *query, int qtype)
{
char *token = NULL;
data = (wfd_oem_service_s*) g_list_nth_data(service_list, count);
if (data && !strncmp(data->service_type, s_type, SERVICE_TYPE_LEN) &&
memcmp(data->dev_addr, mac_str, OEM_MACSTR_LEN - 1) == 0) {
- strncpy(query_id, data->query_id, OEM_QUERY_ID_LEN);
+ g_strlcpy(query_id, data->query_id, OEM_QUERY_ID_LEN + 1);
break;
}
}
return NULL;
}
- WDP_LOGD("query id :[0x%s]", query_id);
+ WDP_LOGD("query id :[%s]", query_id);
return data;
}
-void __add_service_query(GVariant *value, void *mac_addr)
+void __add_service_query(GVariant *value, void *user_data)
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_service_s *service = NULL;
long long unsigned ref = 0;
- unsigned char *mac_address = (unsigned char *)mac_addr;
- char mac_str[18] = {0, };
-
int res = 0;
+ if (!user_data)
+ return;
+
g_variant_get(value, "(t)", &ref);
service = (wfd_oem_service_s*) g_try_malloc0(sizeof(wfd_oem_service_s));
return;
}
- if (mac_address[0] == 0 && mac_address[1] == 0 && mac_address[2] == 0 &&
- mac_address[3] == 0 && mac_address[4] == 0 && mac_address[5] == 0) {
- g_snprintf(mac_str, WS_MACSTR_LEN , "%s", SERV_BROADCAST_ADDRESS);
- } else {
- g_snprintf(mac_str, WS_MACSTR_LEN, MACSTR, MAC2STR(mac_address));
- }
+ memcpy(service, user_data, sizeof(wfd_oem_service_s));
- g_strlcpy(service->dev_addr, mac_str, OEM_MACSTR_LEN);
- g_snprintf(service->query_id, OEM_QUERY_ID_LEN + 1, "0x%llx", ref);
+ g_snprintf(service->query_id, OEM_QUERY_ID_LEN + 1, "%llx", ref);
res = _check_service_query_exists(service);
if (res)
- free(service);
+ g_free(service);
else
service_list = g_list_append(service_list, service);
GDBusConnection *g_dbus = NULL;
GVariantBuilder *builder = NULL;
GVariant *value = NULL;
+ wfd_oem_service_s data = {0,};
dbus_method_param_s params;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
int i = 0;
builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
- if (mac_addr) {
+ if (mac_addr && !ISZEROMACADDR(mac_addr)) {
g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
COMPACT_MACSTR, g_pd->iface_path, MAC2STR(mac_addr));
WDP_LOGD("get peer path [%s]", peer_path);
g_variant_builder_add(query, "y", service_all[i]);
g_variant_builder_add(builder, "{sv}", "query", g_variant_new("ay", query));
g_variant_builder_unref(query);
+ g_strlcpy(data.service_type, SERV_DISC_REQ_ALL, OEM_SERVICE_TYPE_LEN + 1);
- } else if (service_type == WFD_OEM_SERVICE_TYPE_UPNP) {
+ } else if (service_type == WFD_OEM_SERVICE_TYPE_UPNP) {
g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("upnp"));
- g_variant_builder_add(builder, "{sv}", "version", g_variant_new_uint16(TRUE));
+ g_variant_builder_add(builder, "{sv}", "version", g_variant_new_int32(10));
+ g_variant_builder_add(builder, "{sv}", "service", g_variant_new_string("ssdp:all"));
+ g_strlcpy(data.service_type, SERV_DISC_REQ_UPNP, OEM_SERVICE_TYPE_LEN + 1);
} else if (service_type == WFD_OEM_SERVICE_TYPE_BONJOUR) {
query = g_variant_builder_new(G_VARIANT_TYPE("ay"));
for (i = 0; i < SERVICE_QUERY_LEN; i++)
g_variant_builder_add(query, "y", service_bonjour[i]);
- g_variant_builder_add(builder, "{sv}", "query", g_variant_new("ay", query));
+ g_variant_builder_add(builder, "{sv}", "tlv", g_variant_new("ay", query));
g_variant_builder_unref(query);
+ g_strlcpy(data.service_type, SERV_DISC_REQ_BONJOUR, OEM_SERVICE_TYPE_LEN + 1);
}
value = g_variant_new("(a{sv})", builder);
params.params = value;
DEBUG_G_VARIANT("Params : ", params.params);
- res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, __add_service_query, mac_addr);
+ if (ISZEROMACADDR(mac_addr))
+ snprintf(data.dev_addr, WS_MACSTR_LEN , "%s", SERV_BROADCAST_ADDRESS);
+ else
+ snprintf(data.dev_addr, WS_MACSTR_LEN, MACSTR, MAC2STR(mac_addr));
+
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, __add_service_query, &data);
if (res < 0)
WDP_LOGE("Failed to send command to wpa_supplicant");
else
char query_id[OEM_QUERY_ID_LEN + 1] = {0, };
char s_type[OEM_SERVICE_TYPE_LEN + 1] = {0, };
char mac_str[18] = {0, };
+ long long unsigned id;
int res = 0;
return -1;
}
- if (mac_addr[0] == 0 && mac_addr[1] == 0 && mac_addr[2] == 0 &&
- mac_addr[3] == 0 && mac_addr[4] == 0 && mac_addr[5] == 0) {
+ if (ISZEROMACADDR(mac_addr)) {
snprintf(mac_str, WS_MACSTR_LEN , "%s", SERV_BROADCAST_ADDRESS);
} else {
snprintf(mac_str, WS_MACSTR_LEN, MACSTR, MAC2STR(mac_addr));
switch (service_type) {
case WFD_OEM_SERVICE_TYPE_ALL:
- strncpy(s_type, SERV_DISC_REQ_ALL, OEM_SERVICE_TYPE_LEN);
+ g_strlcpy(s_type, SERV_DISC_REQ_ALL, OEM_SERVICE_TYPE_LEN + 1);
break;
case WFD_OEM_SERVICE_TYPE_BONJOUR:
- strncpy(s_type, SERV_DISC_REQ_BONJOUR, OEM_SERVICE_TYPE_LEN);
+ g_strlcpy(s_type, SERV_DISC_REQ_BONJOUR, OEM_SERVICE_TYPE_LEN + 1);
break;
case WFD_OEM_SERVICE_TYPE_UPNP:
- strncpy(s_type, SERV_DISC_REQ_UPNP, OEM_SERVICE_TYPE_LEN);
+ g_strlcpy(s_type, SERV_DISC_REQ_UPNP, OEM_SERVICE_TYPE_LEN + 1);
break;
default:
WDP_LOGE("Invalid Service type");
memset(¶ms, 0x0, sizeof(dbus_method_param_s));
dbus_set_method_param(¶ms, "ServiceDiscoveryCancelRequest", g_pd->iface_path, g_dbus);
-
- params.params = g_variant_new("(t)", strtoul(query_id, NULL, 16));
+ id = (long long unsigned)strtoul(query_id, NULL, 16);
+ params.params = g_variant_new("(t)", id);
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (res < 0)
} else if (service->protocol == WFD_OEM_SERVICE_TYPE_UPNP) {
g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("upnp"));
- g_variant_builder_add(builder, "{sv}", "version", g_variant_new_uint16(TRUE));
+ g_variant_builder_add(builder, "{sv}", "version", g_variant_new_int32(10));
g_variant_builder_add(builder, "{sv}", "service", g_variant_new_string(service->data.upnp.service));
}
} else if (service->protocol == WFD_OEM_SERVICE_TYPE_UPNP) {
g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("upnp"));
- g_variant_builder_add(builder, "{sv}", "version", g_variant_new_uint16(TRUE));
+ g_variant_builder_add(builder, "{sv}", "version", g_variant_new_int32(10));
g_variant_builder_add(builder, "{sv}", "service", g_variant_new_string(service->data.upnp.service));
}
__WDP_LOG_FUNC_EXIT__;
return 0;
}
-#endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
int _ws_disable_display()
{
return 0;
}
-#if defined(TIZEN_FEATURE_ASP)
int ws_advertise_service(wfd_oem_asp_service_s *service, int replace)
{
__WDP_LOG_FUNC_ENTER__;
__WDP_LOG_FUNC_EXIT__;
return res;
}
-#endif /* TIZEN_FEATURE_ASP */
+
+int ws_set_eapol_ip_config(int enable)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *g_dbus = NULL;
+
+ GVariant *value = NULL;
+ GVariant *param = NULL;
+ GVariantBuilder *builder = NULL;
+ GVariantBuilder *type_builder = NULL;
+ dbus_method_param_s params;
+ int res = 0;
+ int i = 0;
+ enum {
+ IP_GO,
+ IP_MASK,
+ IP_START,
+ IP_END,
+ };
+ unsigned char eapol_ip[IP_END + 1][OEM_IPADDR_LEN + 1] = {0,};
+
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ g_dbus = g_pd->g_dbus;
+ if (!g_dbus) {
+ WDP_LOGE("DBus connection is NULL");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
+
+ dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
+ g_dbus);
+
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+
+ memset(&eapol_ip, 0x0, (IP_END + 1) * (OEM_IPADDR_LEN + 1));
+ if (enable == 1) {
+ memcpy(eapol_ip[IP_GO], DEFAULT_IP_GO, OEM_IPADDR_LEN);
+ memcpy(eapol_ip[IP_MASK], DEFAULT_IP_MASK, OEM_IPADDR_LEN);
+ memcpy(eapol_ip[IP_START], DEFAULT_IP_START, OEM_IPADDR_LEN);
+ memcpy(eapol_ip[IP_END], DEFAULT_IP_END, OEM_IPADDR_LEN);
+ }
+
+ type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < OEM_IPADDR_LEN; i++)
+ g_variant_builder_add(type_builder, "y", eapol_ip[IP_GO][i]);
+ g_variant_builder_add(builder, "{sv}", "IpAddrGo",
+ g_variant_new("ay", type_builder));
+ g_variant_builder_unref(type_builder);
+
+ type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < OEM_IPADDR_LEN; i++)
+ g_variant_builder_add(type_builder, "y", eapol_ip[IP_MASK][i]);
+ g_variant_builder_add(builder, "{sv}", "IpAddrMask",
+ g_variant_new("ay", type_builder));
+ g_variant_builder_unref(type_builder);
+
+ type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < OEM_IPADDR_LEN; i++)
+ g_variant_builder_add(type_builder, "y", eapol_ip[IP_START][i]);
+ g_variant_builder_add(builder, "{sv}", "IpAddrStart",
+ g_variant_new("ay", type_builder));
+ g_variant_builder_unref(type_builder);
+
+ type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < OEM_IPADDR_LEN; i++)
+ g_variant_builder_add(type_builder, "y", eapol_ip[IP_END][i]);
+ g_variant_builder_add(builder, "{sv}", "IpAddrEnd",
+ g_variant_new("ay", type_builder));
+ g_variant_builder_unref(type_builder);
+
+ value = g_variant_new("a{sv}", builder);
+ g_variant_builder_unref(builder);
+
+ param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig", value);
+
+ params.params = param;
+
+ DEBUG_G_VARIANT("Params : ", param);
+ res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
+ if (res < 0) {
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ } else {
+ WDP_LOGI("Succeeded to set eapol IP");
+ }
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
+}
int ws_add_vsie(wfd_oem_vsie_frames_e frame_id, const char* vsie)
{
__WDP_LOG_FUNC_EXIT__;
return 0;
}
+
+int ws_set_supported_wps_mode(int wps_mode)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ char config_value[DBUS_OBJECT_PATH_MAX+1] = {0,};
+ int length = 0;
+ int new_wps_mode = wps_mode;
+ int res = 0;
+
+ if (!config) {
+ WDP_LOGE("no configurable data found");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ if (new_wps_mode == 0) {
+ WDP_LOGE("Reset to default value");
+ new_wps_mode = WFD_OEM_WPS_MODE_PBC|WFD_OEM_WPS_MODE_DISPLAY|WFD_OEM_WPS_MODE_KEYPAD;
+ }
+
+ if (new_wps_mode & WFD_OEM_WPS_MODE_KEYPAD) {
+ g_strlcat(config_value, "keypad ", sizeof(config_value));
+ length += 7;
+ }
+ if (new_wps_mode & WFD_OEM_WPS_MODE_PBC) {
+ g_strlcat(config_value, "virtual_push_button ", sizeof(config_value));
+ length += 20;
+ }
+ if (new_wps_mode & WFD_OEM_WPS_MODE_DISPLAY) {
+ g_strlcat(config_value, "physical_display ", sizeof(config_value));
+ length += 17;
+ }
+ config_value[length-1] = 0;
+ g_strlcpy(config->config_methods, config_value, OEM_CONFIG_METHOD_LEN);
+ WDP_LOGD("config_value = %s, length = %d", config_value, length-1);
+ res = __ws_set_config_methods();
+ if (res < 0) {
+ WDP_LOGE("Failed to set config method");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+ wps_config_method = new_wps_mode;
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
+
+static int _ws_remove_persistent_group_by_object_path(const char *object_path)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *g_dbus = NULL;
+ dbus_method_param_s params;
+ int res = 0;
+
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ g_dbus = g_pd->g_dbus;
+ if (!g_dbus) {
+ WDP_LOGE("DBus connection is NULL");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
+ dbus_set_method_param(¶ms, "RemovePersistentGroup",
+ g_pd->iface_path, g_dbus);
+ params.params = g_variant_new("(o)", object_path);
+
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
+ if (res < 0) {
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ ws_save_config();
+ WDP_LOGD("Succeeded to remove persistent group");;
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
+
+int ws_remove_persistent_device(unsigned char *mac_addr)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *g_dbus = NULL;
+ ws_network_info_s networks[WS_MAX_PERSISTENT_COUNT];
+ int i = 0;
+ int cnt = 0;
+ int need_delete = 0;
+ int res = 0;
+
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ g_dbus = g_pd->g_dbus;
+ if (!g_dbus) {
+ WDP_LOGE("DBus connection is NULL");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+ memset(&networks, 0x0, WS_MAX_PERSISTENT_COUNT * sizeof(ws_network_info_s));
+ dbus_property_get_all(g_pd->iface_path, g_dbus, SUPPLICANT_P2PDEVICE,
+ __ws_extract_p2pdevice_details, networks);
+
+ cnt = networks[0].total;
+
+ WDP_LOGD("Persistent Group Count=%d", cnt);
+ if (cnt > WS_MAX_PERSISTENT_COUNT) {
+ WDP_LOGE("Persistent group count exceeded or parsing error");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ for (i = 0 ; i < cnt ; i++) {
+ int j = 0;
+ need_delete = 0;
+
+ WDP_LOGD("----persistent group [%d]----", i);
+ WDP_LOGD("network_id [%d]", networks[i].network_id);
+ WDP_LOGD("ssid [%s]", networks[i].ssid);
+ WDP_LOGD("bssid ["MACSTR"]", MAC2STR(networks[i].bssid));
+ WDP_LOGD("p2p_client_num [%d]", networks[i].p2p_client_num);
+ for (j = 0; j < networks[i].p2p_client_num; j++) {
+ WDP_LOGD("p2p_client_list ["MACSTR"]", MAC2STR(networks[i].p2p_client_list[j]));
+ }
+
+ WDP_LOGD("mac_addr ["MACSTR"]", MAC2STR(mac_addr));
+
+ if (memcmp(mac_addr, networks[i].bssid, WS_MACADDR_LEN) == 0) {
+ WDP_LOGD("Persistent group owner found [%d: "MACSTR"]", networks[i].network_id, MAC2STR(mac_addr));
+ need_delete = 1;
+ }
+
+ if (need_delete == 0) {
+ for (j = 0; j < networks[i].p2p_client_num; j++) {
+ if (!memcmp(mac_addr, networks[i].p2p_client_list[j], WS_MACADDR_LEN)) {
+ WDP_LOGD("Persistent group client found [%d: "MACSTR"]", networks[i].network_id, MAC2STR(mac_addr));
+ need_delete = 1;
+ }
+ }
+ }
+
+ if (need_delete) {
+ res = _ws_remove_persistent_group_by_object_path(networks[i].persistent_path);
+ WDP_LOGI("persistent group deleted [%s]", networks[i].persistent_path);
+ if (res < 0) {
+ WDP_LOGE("Failed to _ws_remove_persistent_group_by_object_path");
+ } else {
+ WDP_LOGD("Succeeded to _ws_remove_persistent_group_by_object_path");
+ }
+ }
+ }
+
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
+}
+
+int ws_remove_all_persistent_device(void)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *g_dbus = NULL;
+ dbus_method_param_s params;
+ int res = 0;
+
+ g_dbus = g_pd->g_dbus;
+ if (!g_dbus) {
+ WDP_LOGE("DBus connection is NULL");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
+
+ dbus_set_method_param(¶ms, "RemoveAllPersistentGroups", g_pd->iface_path, g_dbus);
+ params.params = NULL;
+
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
+ if (res < 0) {
+ WDP_LOGE("Failed to RemoveAllPersistentGroups");
+ } else {
+ WDP_LOGD("Succeeded to RemoveAllPersistentGroups");
+ }
+
+ ws_save_config();
+ WDP_LOGD("Succeeded to remove all network");
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
+}
+
+static void __ws_get_supported_channels_reply(GVariant *reply, void *user_data)
+{
+ __WDP_LOG_FUNC_ENTER__;
+
+ GVariantIter *iter = NULL;
+ wfd_oem_supported_channels_s *data = (wfd_oem_supported_channels_s *)user_data;
+
+ if (reply) {
+ int channel = 0;
+
+ g_variant_get(reply, "(ai)", &iter);
+
+ while (g_variant_iter_loop(iter, "i", &channel))
+ data->channels[data->count++] = channel;
+
+ g_variant_iter_free (iter);
+
+ } else {
+ WDP_LOGE("Reply is NULL");
+ }
+ __WDP_LOG_FUNC_EXIT__;
+}
+
+int ws_get_supported_channels(wfd_oem_supported_channels_s *data)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ int res = 0;
+ dbus_method_param_s params;
+
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
+ memset(data, 0x0, sizeof(wfd_oem_supported_channels_s));
+
+ dbus_set_method_param(¶ms, "GetSupportedChannels", g_pd->iface_path, g_pd->g_dbus);
+ params.params = NULL;
+
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE,
+ __ws_get_supported_channels_reply, data);
+ if (res < 0) {
+ WDP_LOGE("Failed to GetSupportedChannels");
+ } else {
+ WDP_LOGD("Succeeded to GetSupportedChannels");
+ }
+
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
+}
projects / platform / core / connectivity / wifi-direct-manager.git / blobdiff