#include <gio/gio.h>
#include <tzplatform_config.h>
+#include <hal-wifi.h>
#include "wifi-direct-oem.h"
#include "wfd-plugin-log.h"
-#include "wfd-plugin-wpasupplicant.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)
-#if defined TIZEN_MOBILE
-#define DEFAULT_MAC_FILE_PATH tzplatform_mkpath(TZ_SYS_ETC, ".mac.info")
-#endif
-
-#if defined TIZEN_WIFI_MODULE_BUNDLE
-#define DEFAULT_MAC_FILE_PATH "/sys/class/net/wlan0/address"
-#endif
-
-#ifndef DEFAULT_MAC_FILE_PATH
-#define DEFAULT_MAC_FILE_PATH "/sys/class/net/p2p0/address"
-#endif
+#define CONF_FILE_PATH tzplatform_mkpath(TZ_SYS_ETC, "wpa_supplicant/wpa_supplicant.conf")
+#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 */
-#ifdef TIZEN_FEATURE_WIFI_DISPLAY
.miracast_init = ws_miracast_init,
.set_display = ws_set_display,
-#endif /* TIZEN_FEATURE_WIFI_DISPLAY */
.refresh = ws_refresh,
.save_config = ws_save_config,
.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 */
- };
-static ws_dbus_plugin_data_s *g_pd;
+ .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 void _supplicant_signal_cb(GDBusConnection *connection,
- const gchar *sender, const gchar *object_path, const gchar *interface,
- const gchar *signal, GVariant *parameters, gpointer user_data);
-
-static void _p2pdevice_signal_cb(GDBusConnection *connection,
- const gchar *sender, const gchar *object_path, const gchar *interface,
- const gchar *signal, GVariant *parameters, gpointer user_data);
-
-static void _group_signal_cb(GDBusConnection *connection,
- const gchar *sender, const gchar *object_path, const gchar *interface,
- const gchar *signal, GVariant *parameters, gpointer user_data);
-
-static void _interface_signal_cb(GDBusConnection *connection,
- const gchar *sender, const gchar *object_path, const gchar *interface,
- const gchar *signal, GVariant *parameters, gpointer user_data);
-
static int __ws_txt_to_mac(unsigned char *txt, unsigned char *mac)
{
int i = 0;
return 0;
}
-static char *__ws_wps_to_txt(int wps_mode)
+static const char *__ws_wps_to_txt(int wps_mode)
{
switch (wps_mode) {
case WFD_OEM_WPS_MODE_PBC:
return WS_DBUS_STR_PBC;
- break;
case WFD_OEM_WPS_MODE_DISPLAY:
return WS_DBUS_STR_DISPLAY;
- break;
case WFD_OEM_WPS_MODE_KEYPAD:
return WS_DBUS_STR_KEYPAD;
- break;
-#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 "";
- break;
}
}
-#ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
+
+static int __ws_hex_char_to_num(char c)
+{
+ if (c >= '0' && c <= '9')
+ return c - '0';
+
+ if (c >= 'a' && c <= 'f')
+ return c - 'a' + 10;
+
+ if (c >= 'A' && c <= 'F')
+ return c - 'A' + 10;
+
+ return -1;
+}
+
+static int __ws_hex_to_byte(const char *hex)
+{
+ int a, b;
+
+ a = __ws_hex_char_to_num(*hex++);
+ if (a < 0)
+ return -1;
+
+ b = __ws_hex_char_to_num(*hex++);
+ if (b < 0)
+ return -1;
+
+ return (a << 4) | b;
+}
+
+static int __ws_hex_str_to_bin(const char *hex, unsigned char *buf, size_t len)
+{
+ size_t i;
+ int a;
+ const char *ipos = hex;
+ unsigned char *opos = buf;
+
+ for (i = 0; i < len; i++) {
+ a = __ws_hex_to_byte(ipos);
+ if (a < 0)
+ return -1;
+
+ *opos++ = a;
+ ipos += 2;
+ }
+
+ return 0;
+}
+
static int __ws_byte_to_hex(char *buf, int buf_size, unsigned char *data, int data_len)
{
int i;
wfd_oem_new_service_s *serv_tmp = NULL;
char *ptr = NULL;
char *temp = NULL;
- int len = 0;
int i = 0;
if (!segment || !service) {
if (serv_tmp->status != 0) {
WDP_LOGE("Service status is not success");
- free(serv_tmp);
+ g_free(serv_tmp);
return -1;
}
int dns_type = 0;
while (*ptr != 0 && strncmp(ptr, "c0", 2)) {
- len = __ws_hex_to_num(ptr, 2);
+ unsigned long int size = 0;
+ char temp_str[3] = {0,};
+ memcpy(temp_str, ptr, 2);
+ size = strtoul(temp_str, NULL, 16);
ptr += 2;
- if (len && len <= 0xff) {
- temp = (char*) calloc(1, len+2);
+ if (size <= 0xff) {
+ temp = (char*) calloc(1, size + 2);
if (temp) {
temp[0] = '.';
- for (i = 0; i < len; i++) {
+ for (i = 0; i < size; i++) {
temp[i+1] = (char) __ws_hex_to_num(ptr, 2);
ptr += 2;
}
- strncat(query, temp, len+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));
}
}
}
serv_tmp->data.bonjour.query = strdup(query + 1);
while (*ptr != 0 && strncmp(ptr, "c0", 2)) {
- len = __ws_hex_to_num(ptr, 2);
+ unsigned long int size = 0;
+ char temp_str[3] = {0,};
+ memcpy(temp_str, ptr, 2);
+ size = strtoul(temp_str, NULL, 16);
ptr += 2;
- if (len && len <= 0xff) {
- temp = (char*) g_try_malloc0(len+2);
+ if (size <= 0xff) {
+ temp = (char*) g_try_malloc0(size + 2);
if (temp) {
temp[0] = '.';
- for (i = 0; i < len; i++) {
+ for (i = 0; i < size; i++) {
temp[i+1] = (char) __ws_hex_to_num(ptr, 2);
ptr += 2;
}
- strncat(rdata, temp, len+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 length;
+}
+
+static int __ws_byte_to_txt(const unsigned char *src, char **dst, int src_len)
+{
+ __WDP_LOG_FUNC_ENTER__;
+
+ int dst_length = 0;
+ int i = 0;
+ char *buf = NULL;
+
+ if (src_len <= 0) {
+ WDP_LOGE("Invalid parameter.");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
}
- return res;
+ *dst = (char *) g_try_malloc0((2*src_len)+1);
+ if (!(*dst)) {
+ WDP_LOGE("failed to allocate memory to buffer.");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ buf = (*dst);
+
+ for (i = 0; i < src_len; i++) {
+ snprintf(buf, 3, "%02x", src[i]);
+ buf += 2;
+ dst_length += 2;
+ }
+
+ __WDP_LOG_FUNC_EXIT__;
+ return dst_length;
+}
+
+static int __ws_unpack_ay_malloc(unsigned char **dst, GVariantIter *iter)
+{
+ GVariantIter *iter_copy = NULL;
+ int length = 0;
+ char tmp = 0;
+ unsigned char *tmp_dst = NULL;
+
+ if (!dst || *dst || !iter) {
+ WDP_LOGE("Invalid parameter");
+ return 0;
+ }
+
+ iter_copy = g_variant_iter_copy(iter);
+
+ while (g_variant_iter_loop(iter, "y", &tmp))
+ length++;
+ g_variant_iter_free(iter);
+
+ 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;
+ }
+
+ length = 0;
+ while (g_variant_iter_loop(iter_copy, "y", &tmp_dst[length]))
+ length++;
+ g_variant_iter_free(iter_copy);
+
+ if (length == 0) {
+ g_free(tmp_dst);
+ tmp_dst = NULL;
+ } else {
+ tmp_dst[length] = '\0';
+ }
+
+ *dst = tmp_dst;
+ WDP_LOGD("Length [%d]", length);
+ return length;
}
-#ifdef TIZEN_FEATURE_WIFI_DISPLAY
static int __parsing_wfd_info(unsigned char *wfd_dev_info,
wfd_oem_display_s* display)
{
__WDP_LOG_FUNC_EXIT__;
return 0;
}
-#endif /* TIZEN_FEATURE_WIFI_DISPLAY */
static int _ws_get_local_dev_mac(unsigned char *dev_mac)
{
__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) {
- WDP_LOGE("Failed to open MAC info file [%s] (%s)", file_path, strerror(errno));
+ strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
+ WDP_LOGE("Failed to open MAC info file [%s] (%s)", file_path, error_buf);
__WDP_LOG_FUNC_EXIT__;
return -1;
}
errno = 0;
ptr = fgets((char *)local_mac, WS_MACSTR_LEN, fd);
if (!ptr) {
- WDP_LOGE("Failed to read file or no data read(%s)", strerror(errno));
+ strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
+ WDP_LOGE("Failed to read file or no data read(%s)", error_buf);
fclose(fd);
__WDP_LOG_FUNC_EXIT__;
return -1;
return 0;
}
-static void _supplicant_signal_cb(GDBusConnection *connection,
+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 defined(TIZEN_DEBUG_DBUS_VALUE)
+ __WDP_LOG_FUNC_ENTER__;
+ static char interface_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
+ const char *path = NULL;
+
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
if (!g_pd) {
- WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ WDP_LOGD("Ignoring event");
+ __WDP_LOG_FUNC_EXIT__;
return;
}
- if (!g_strcmp0(signal, "InterfaceAdded")) {
- WDP_LOGD("InterfaceAdded");
-
- } else if (!g_strcmp0(signal, "InterfaceRemoved")) {
- WDP_LOGD("InterfaceRemoved");
- static char interface_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- const char *path = NULL;
-
- g_variant_get(parameters, "(&o)", &path);
- g_strlcpy(interface_path, path, DBUS_OBJECT_PATH_MAX);
-
- WDP_LOGD("Retrive removed path [%s]", interface_path);
+ g_variant_get(parameters, "(&o)", &path);
+ g_strlcpy(interface_path, path, DBUS_OBJECT_PATH_MAX);
- if (!g_strcmp0(g_pd->group_iface_path, interface_path)) {
+ WDP_LOGD("Retrive removed path [%s]", interface_path);
- WDP_LOGD("p2p group interface removed");
- memset(g_pd->group_iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
- }
-#if defined(TIZEN_WLAN_CONCURRENT_ENABLE) && defined(TIZEN_MOBILE)
- else if (!g_strcmp0(g_pd->iface_path, interface_path)) {
+ 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);
+ } else if (!g_strcmp0(g_pd->iface_path, interface_path)) {
- WDP_LOGD("p2p interface removed");
- wfd_oem_event_s event;
+ WDP_LOGD("p2p interface removed");
+ wfd_oem_event_s event;
- ws_deactivate(1);
+ ws_deactivate(1);
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
- event.event_id = WFD_OEM_EVENT_DEACTIVATED;
- g_pd->callback(g_pd->user_data, &event);
+ memset(&event, 0x0, sizeof(wfd_oem_event_s));
+ event.event_id = WFD_OEM_EVENT_DEACTIVATED;
+ if (g_pd->callback && g_pd->callback->deactivated_cb)
+ g_pd->callback->deactivated_cb(&event);
- memset(g_pd->iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
- }
-#endif /* TIZEN_WLAN_CONCURRENT_ENABLE && TIZEN_MOBILE */
- } else if (!g_strcmp0(signal, "PropertiesChanged")) {
- WDP_LOGD("PropertiesChanged");
+ memset(g_pd->iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
}
+ __WDP_LOG_FUNC_EXIT__;
}
+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_supplicant_signal_map[] = {
+ {
+ 0,
+ SUPPLICANT_INTERFACE,
+ "InterfaceRemoved",
+ _ws_process_interface_removed
+ },
+ {
+ 0,
+ NULL,
+ NULL,
+ NULL
+ }
+};
+
static void __ws_get_peer_property(const char *key, GVariant *value, void *user_data)
{
__WDP_LOG_FUNC_ENTER__;
__WDP_LOG_FUNC_EXIT__;
return;
}
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
+
CHECK_KEY_VALUE(key, value);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
if (g_strcmp0(key, "DeviceName") == 0) {
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) {
WDP_LOGD("Config method [0x%x]", peer->config_methods);
} else if (g_strcmp0(key, "level") == 0) {
+ int rssi = 0;
+
+ g_variant_get(value, "i", &rssi);
+ peer->rssi = rssi;
+ WDP_LOGD("Peer RSSI [%d]", peer->rssi);
} else if (g_strcmp0(key, "devicecapability") == 0) {
unsigned char devicecapability = 0;
}
} else if (g_strcmp0(key, "SecondaryDeviceTypes") == 0) {
} else if (g_strcmp0(key, "VendorExtension") == 0) {
-#ifdef TIZEN_FEATURE_WIFI_DISPLAY
} else if (g_strcmp0(key, "IEs") == 0) {
unsigned char ies[WFD_SUBELEM_LEN_DEV_INFO + 3] = {0,};
if (__ws_unpack_ay(ies, value, WFD_SUBELEM_LEN_DEV_INFO + 3))
__parsing_wfd_info(ies, &(peer->display));
-#endif /* TIZEN_FEATURE_WIFI_DISPLAY */
} else if (g_strcmp0(key, "DeviceAddress") == 0) {
if (__ws_unpack_ay(peer->dev_addr, value, WS_MACADDR_LEN))
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");
}
}
wfd_oem_dev_data_s *peer = (wfd_oem_dev_data_s *)user_data;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
+
CHECK_KEY_VALUE(key, value);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+
if (g_strcmp0(key, "DeviceName") == 0) {
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) {
WDP_LOGD("Config method [0x%x]", peer->config_methods);
} else if (g_strcmp0(key, "level") == 0) {
+ int rssi = 0;
+
+ g_variant_get(value, "i", &rssi);
+ peer->rssi = rssi;
+ WDP_LOGD("Peer RSSI [%d]", peer->rssi);
} else if (g_strcmp0(key, "devicecapability") == 0) {
unsigned char devicecapability = 0;
}
} else if (g_strcmp0(key, "SecondaryDeviceTypes") == 0) {
} else if (g_strcmp0(key, "VendorExtension") == 0) {
-#ifdef TIZEN_FEATURE_WIFI_DISPLAY
} else if (g_strcmp0(key, "IEs") == 0) {
unsigned char ies[WFD_SUBELEM_LEN_DEV_INFO + 3] = {0,};
if (__ws_unpack_ay(ies, value, WFD_SUBELEM_LEN_DEV_INFO + 3))
__parsing_wfd_info(ies, &(peer->display));
-#endif /* TIZEN_FEATURE_WIFI_DISPLAY */
} else if (g_strcmp0(key, "DeviceAddress") == 0) {
if (__ws_unpack_ay(peer->p2p_dev_addr, value, WS_MACADDR_LEN))
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) {
- WDP_LOGD("size [%d]", g_variant_get_size(value));
- if (g_variant_get_size(value) != 0)
+ if (value != NULL && g_variant_get_size(value) != 0)
peer->has_asp_services = 1;
else
peer->has_asp_services = 0;
-#endif /* TIZEN_FEATURE_ASP */
+ } 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;
+
+ } 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");
}
wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
if (!event)
return;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
+
CHECK_KEY_VALUE(key, value);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+
if (g_strcmp0(key, "Ifname") == 0) {
const char *ifname = NULL;
return;
wfd_oem_group_data_s *group = (wfd_oem_group_data_s *)event->edata;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
+
CHECK_KEY_VALUE(key, value);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+
if (g_strcmp0(key, "Role") == 0) {
const char *role = NULL;
return;
wfd_oem_invite_data_s *invitation = (wfd_oem_invite_data_s *)event->edata;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
+
CHECK_KEY_VALUE(key, value);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+
if (g_strcmp0(key, "sa") == 0) {
if (__ws_unpack_ay(invitation->sa, value, WS_MACADDR_LEN))
WDP_LOGD("SA [" MACSTR "]", MAC2STR(invitation->sa));
return;
}
-void __ws_extract_group_details(const char *key, GVariant *value, void *user_data)
+static void __ws_parse_peer_joined(char *peer_path,
+ unsigned char *dev_addr, unsigned char *ip_addr, GVariant *parameter)
{
__WDP_LOG_FUNC_ENTER__;
- wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
- if (!event || !event->edata)
- return;
- if (!g_pd) {
- WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
- return;
- }
+ GVariantIter *iter;
+ gboolean iter_res = TRUE;
+ const char *path = NULL;
+ int i = 0;
- wfd_oem_group_data_s *group = (wfd_oem_group_data_s *)event->edata;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- CHECK_KEY_VALUE(key, value);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
- if (g_strcmp0(key, "interface_object") == 0) {
- static char interface_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- const char *i_path = NULL;
+ g_variant_get(parameter, "(&oay)", &path, &iter);
+ g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
+ WDP_LOGD("Retrive Added path [%s]", peer_path);
- g_variant_get(value, "&o", &i_path);
- 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);
+ __extract_addr_from_path(peer_path, dev_addr);
- } else if (g_strcmp0(key, "role") == 0) {
- const char *role = NULL;
+ 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);
- g_variant_get(value, "&s", &role);
- WDP_LOGD("Role [%s]", role);
+ WDP_LOGD("peer ip [" IPSTR "]", IP2STR(ip_addr));
- if (!strncmp(role, "GO", 2))
- event->dev_role = WFD_OEM_DEV_ROLE_GO;
- else if (!strncmp(role, "client", 6))
- event->dev_role = WFD_OEM_DEV_ROLE_GC;
- } else if (g_strcmp0(key, "persistent") == 0) {
- g_variant_get(value, "b", &group->is_persistent);
- WDP_LOGD("Is Persistent : [%s]", group->is_persistent ? "YES" : "NO");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+}
-#ifdef TIZEN_FEATURE_IP_OVER_EAPOL
- } else if (g_strcmp0(key, "IpAddr") == 0) {
+static gboolean __is_valid_plugin(void)
+{
+ gboolean is_valid = (g_pd && g_pd->callback);
- if (__ws_unpack_ay(group->ip_addr, value, OEM_IPADDR_LEN))
- WDP_LOGD("IP address [" IPSTR "]", IP2STR(group->ip_addr));
+ if (!is_valid)
+ WDP_LOGD("Ignoring event");
- } else if (g_strcmp0(key, "IpAddrMask") == 0) {
+ return is_valid;
+}
- if (__ws_unpack_ay(group->ip_addr_mask, value, OEM_IPADDR_LEN))
- WDP_LOGD("IP mask [" IPSTR "]", IP2STR(group->ip_addr_mask));
+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);
+ }
- } else if (g_strcmp0(key, "IpAddrGo") == 0) {
+ return dev_data;
+}
- 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;
+static void __set_event_data(int event_id, int edata_type, void *data, wfd_oem_event_s *event)
+{
+ if (!event)
+ return;
- g_variant_get(value, "&o", &g_path);
- g_strlcpy(group_path, g_path, DBUS_OBJECT_PATH_MAX);
- WDP_LOGD("Retrive group path [%s]", group_path);
- dbus_property_get_all(group_path, g_pd->g_dbus, SUPPLICANT_P2P_GROUP,
- __ws_group_property, event);
+ memset(event, 0x0, sizeof(wfd_oem_event_s));
+
+ event->edata = data;
+ event->edata_type = edata_type;
+ event->event_id = event_id;
- g_pd->group_sub_id =
- g_dbus_connection_signal_subscribe(
- g_pd->g_dbus,
- SUPPLICANT_SERVICE, /* bus name */
- SUPPLICANT_P2P_GROUP, /* interface */
- NULL, /* member */
- group_path, /* object path */
- NULL, /* arg0 */
- G_DBUS_SIGNAL_FLAGS_NONE,
- _group_signal_cb,
- NULL, NULL);
- }
- __WDP_LOG_FUNC_EXIT__;
return;
}
-void __ws_extract_gonegfailaure_details(const char *key, GVariant *value, void *user_data)
+static void __destroy_dev_data(wfd_oem_dev_data_s *dev_data)
{
- __WDP_LOG_FUNC_ENTER__;
- wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
- if (!event || !event->edata)
+ if (!dev_data)
return;
- wfd_oem_conn_data_s *conn = (wfd_oem_conn_data_s *)event->edata;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- CHECK_KEY_VALUE(key, value);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
- if (g_strcmp0(key, "peer_object") == 0) {
- static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- const char *path;
-
- g_variant_get(value, "&o", &path);
- g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
- WDP_LOGD("Retrive peer path [%s]", peer_path);
+ if (dev_data->vsie)
+ g_free(dev_data->vsie);
+ g_free(dev_data);
+}
- } else if (g_strcmp0(key, "status") == 0) {
+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 *dev_data = NULL;
+ static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
+
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
+
+ if (!__is_valid_plugin())
+ return;
+
+ dev_data = __create_dev_data();
+ if (!dev_data) {
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
+ __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);
+
+ dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
+ __ws_peer_property, event.edata);
+
+ if (g_pd->callback->sta_connected_cb)
+ g_pd->callback->sta_connected_cb(&event);
+
+ is_peer_joined_notified = 1;
+
+ __destroy_dev_data(dev_data);
+
+ __WDP_LOG_FUNC_EXIT__;
+}
+
+static void _ws_process_peer_disconnected(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',};
+
+ 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_NONE;
+ event.event_id = WFD_OEM_EVENT_STA_DISCONNECTED;
+
+ __ws_path_to_addr(peer_path, event.dev_addr, parameters);
+
+ if (g_pd->callback->sta_disconnected_cb)
+ g_pd->callback->sta_disconnected_cb(&event);
+
+ is_peer_disconnected_notified = 1;
+ __WDP_LOG_FUNC_EXIT__;
+}
+
+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_signal_map[] = {
+ {
+ 0,
+ SUPPLICANT_P2P_GROUP,
+ "PeerJoined",
+ _ws_process_peer_joined
+ },
+ {
+ 0,
+ SUPPLICANT_P2P_GROUP,
+ "PeerDisconnected",
+ _ws_process_peer_disconnected
+ },
+ {
+ 0,
+ NULL,
+ NULL,
+ NULL
+ }
+};
+
+void __ws_extract_group_details(const char *key, GVariant *value, void *user_data)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
+ if (!event || !event->edata)
+ return;
+
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
+ wfd_oem_group_data_s *group = (wfd_oem_group_data_s *)event->edata;
+
+ CHECK_KEY_VALUE(key, value);
+
+ if (g_strcmp0(key, "interface_object") == 0) {
+ static char interface_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
+ const char *i_path = NULL;
+
+ g_variant_get(value, "&o", &i_path);
+ 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, "&s", &role);
+ WDP_LOGD("Role [%s]", role);
+
+ if (!strncmp(role, "GO", 2))
+ event->dev_role = WFD_OEM_DEV_ROLE_GO;
+ else if (!strncmp(role, "client", 6))
+ event->dev_role = WFD_OEM_DEV_ROLE_GC;
+ } else if (g_strcmp0(key, "persistent") == 0) {
+ g_variant_get(value, "b", &group->is_persistent);
+ WDP_LOGD("Is Persistent : [%s]", group->is_persistent ? "YES" : "NO");
+
+ } else if (g_strcmp0(key, "IpAddr") == 0) {
+
+ if (__ws_unpack_ay(group->ip_addr, value, OEM_IPADDR_LEN))
+ WDP_LOGD("IP address [" IPSTR "]", IP2STR(group->ip_addr));
+
+ } else if (g_strcmp0(key, "IpAddrMask") == 0) {
+
+ if (__ws_unpack_ay(group->ip_addr_mask, value, OEM_IPADDR_LEN))
+ WDP_LOGD("IP mask [" IPSTR "]", IP2STR(group->ip_addr_mask));
+
+ } else if (g_strcmp0(key, "IpAddrGo") == 0) {
+
+ if (__ws_unpack_ay(group->ip_addr_go, value, OEM_IPADDR_LEN))
+ WDP_LOGD("GO IP address [" IPSTR "]", IP2STR(group->ip_addr_go));
+ } else if (g_strcmp0(key, "group_object") == 0) {
+ static char group_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
+ const char *g_path;
+ int i = 0;
+
+ g_variant_get(value, "&o", &g_path);
+ g_strlcpy(group_path, g_path, DBUS_OBJECT_PATH_MAX);
+ WDP_LOGD("Retrive group path [%s]", group_path);
+ dbus_property_get_all(group_path, g_pd->g_dbus, SUPPLICANT_P2P_GROUP,
+ __ws_group_property, event);
+
+ for (i = 0; ws_group_signal_map[i].member != NULL; i++) {
+ ws_group_signal_map[i].sub_id =
+ g_dbus_connection_signal_subscribe(g_pd->g_dbus,
+ SUPPLICANT_SERVICE, /* bus name */
+ ws_group_signal_map[i].interface, /* interface */
+ ws_group_signal_map[i].member, /* member */
+ group_path, /* object path */
+ NULL, /* arg0 */
+ G_DBUS_SIGNAL_FLAGS_NONE,
+ ws_group_signal_map[i].function,
+ NULL, NULL);
+ WDP_LOGD("Subscribed Group iface signal [%s]", ws_group_signal_map[i].member);
+ }
+ }
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+}
+
+void __ws_extract_gonegfailaure_details(const char *key, GVariant *value, void *user_data)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
+ if (!event || !event->edata)
+ return;
+
+ wfd_oem_conn_data_s *conn = (wfd_oem_conn_data_s *)event->edata;
+
+ CHECK_KEY_VALUE(key, value);
+
+ if (g_strcmp0(key, "peer_object") == 0) {
+ static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
+ const char *path;
+
+ g_variant_get(value, "&o", &path);
+ g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
+ WDP_LOGD("Retrive peer path [%s]", peer_path);
+
+ } else if (g_strcmp0(key, "status") == 0) {
int status = 0;
g_variant_get(value, "i", &status);
return;
wfd_oem_conn_data_s *edata = (wfd_oem_conn_data_s *)event->edata;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
+
CHECK_KEY_VALUE(key, value);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+
if (g_strcmp0(key, "peer_object") == 0) {
} else if (g_strcmp0(key, "status") == 0) {
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;
if (!event)
return;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
+
CHECK_KEY_VALUE(key, value);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+
if (g_strcmp0(key, "peer_object") == 0) {
static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
const char *path = NULL;
__ws_mac_compact_to_normal(loc + 1, peer_dev);
__ws_txt_to_mac(peer_dev, event->dev_addr);
- } else if (g_strcmp0(key, "update_indicator")) {
+ } else if (g_strcmp0(key, "update_indicator") == 0) {
- } else if (g_strcmp0(key, "tlvs")) {
+ } else if (g_strcmp0(key, "tlvs") == 0) {
GVariantIter *iter = NULL;
unsigned char service_hex[WS_MAX_SERVICE_LEN];
int byte_length = 0;
__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__;
const char *path = NULL;
char *loc = NULL;
- g_variant_get(value, "o", &path);
+ g_variant_get(value, "&o", &path);
if (path == NULL)
return;
} else if (g_strcmp0(key, "svc_str") == 0) {
const char *svc_str = NULL;
- g_variant_get(value, "s", &svc_str);
+ g_variant_get(value, "&s", &svc_str);
if (svc_str != NULL)
service->service_type = g_strdup(svc_str);
WDP_LOGD("Retrive srv_name [%s]", service->service_type);
} else if (g_strcmp0(key, "info") == 0) {
const char *info = NULL;
- g_variant_get(value, "s", &info);
+ g_variant_get(value, "&s", &info);
if (info != NULL)
service->service_info = g_strdup(info);
WDP_LOGD("Retrive srv_info [%s]", service->service_info);
}
__WDP_LOG_FUNC_EXIT__;
}
-#endif /* TIZEN_FEATURE_ASP */
-static int _ws_flush()
+static int _ws_flush(void)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
return 0;
}
-static int _ws_cancel()
+static int _ws_cancel(void)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
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));
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;
}
param = g_variant_new("(ss)", SUPPLICANT_P2P_PEER, "AdvertiseService");
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(param);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", param);
reply = g_dbus_connection_call_sync(
g_dbus,
}
if (reply != NULL) {
-
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(reply);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Reply : ", reply);
/* replay will have the format <(<ay>,)>
* 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 */
seek = NULL;
}
GLIST_ITER_END()
+
if (seek != NULL && seek->service_info != NULL) {
WDP_LOGD("service info exists, service discovery will be performed");
} else {
WDP_LOGD("service info doesn't exists. Add service to list");
- service->search_id = seek->search_id;
+ if (seek)
+ service->search_id = seek->search_id;
*asp_services = g_list_append(*asp_services, service);
}
}
__WDP_LOG_FUNC_EXIT__;
return res;
}
-#endif /* TIZEN_FEATURE_ASP */
-static void _ws_process_device_found(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+
+int ws_get_advertise_asp_service(const char *peer_path, GList **asp_services)
{
__WDP_LOG_FUNC_ENTER__;
- wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
- static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
+ GDBusConnection *g_dbus = NULL;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+ GVariant *temp1 = NULL;
+ GVariant *temp2 = NULL;
+ GError *error = NULL;
+ GVariantIter *iter = NULL;
+ wfd_oem_advertise_service_s *service;
+ wfd_oem_asp_service_s *seek = NULL;
+ unsigned char desc[7];
+ unsigned int adv_id;
+ unsigned int config_method;
+ unsigned char length;
+ char *service_type = NULL;
+ char *instance_name = NULL;
+ unsigned char instance_length = 0;
+ int cnt;
+ int res = 0;
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- strerror(errno));
- __WDP_LOG_FUNC_EXIT__;
- return;
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ return -1;
}
- 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;
- __ws_path_to_addr(peer_path, event.dev_addr, parameters);
+ g_dbus = g_pd->g_dbus;
+ if (!g_dbus) {
+ WDP_LOGE("DBus connection is NULL");
+ return -1;
+ }
- dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
- __ws_peer_property, event.edata);
+ param = g_variant_new("(ss)", SUPPLICANT_P2P_PEER, "AdvertiseASPService");
+ DEBUG_G_VARIANT("Params : ", param);
-#if defined(TIZEN_FEATURE_ASP)
- if (edata->has_asp_services)
- ws_get_advertise_service(peer_path, (GList **)&(event.asp_services));
-#endif /* TIZEN_FEATURE_ASP */
+ reply = g_dbus_connection_call_sync(
+ g_dbus,
+ SUPPLICANT_SERVICE, /* bus name */
+ peer_path, /* object path */
+ DBUS_PROPERTIES_INTERFACE, /* interface name */
+ DBUS_PROPERTIES_METHOD_GET, /* method name */
+ param, /* GVariant *params */
+ NULL, /* reply_type */
+ G_DBUS_CALL_FLAGS_NONE, /* flags */
+ SUPPLICANT_TIMEOUT , /* timeout */
+ NULL, /* cancellable */
+ &error); /* error */
- g_pd->callback(g_pd->user_data, &event);
-#if defined(TIZEN_FEATURE_ASP)
- if (event.asp_services != NULL) {
- GList *l;
- wfd_oem_advertise_service_s *service;
- for (l = (GList *)event.asp_services; l != NULL; l = l->next) {
- service = (wfd_oem_advertise_service_s *)l->data;
- g_free(service->service_type);
- g_free(service);
- event.asp_services = g_list_remove(l, service);
- }
- g_list_free(l);
+ if (error != NULL) {
+ WDP_LOGE("Error! Failed to get peer advertise service: [%s]",
+ error->message);
+ g_error_free(error);
+ if (reply)
+ g_variant_unref(reply);
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
}
-#endif /* TIZEN_FEATURE_ASP */
- g_free(event.edata);
-
- __WDP_LOG_FUNC_EXIT__;
-}
-static void _ws_process_device_lost(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
-{
- __WDP_LOG_FUNC_ENTER__;
- wfd_oem_event_s event;
- static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
+ if (reply != NULL) {
+ DEBUG_G_VARIANT("Reply : ", reply);
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
+ /* replay will have the format <(<ay>,)>
+ * So, you need to remove tuple out side of variant and
+ * variant out side of byte array
+ * */
+ 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);
- event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
- event.event_id = WFD_OEM_EVENT_PEER_DISAPPEARED;
+ while (1) {
+ /* 4byte advertisement ID, 2 byte config method, 1byte length */
+
+ cnt = 0;
+ memset(desc, 0x0, 7);
+ while (cnt < 7 && g_variant_iter_loop(iter, "y", &desc[cnt]))
+ cnt++;
+
+ if (cnt != 7 || desc[6] == 0) {
+ WDP_LOGE("Invalid descriptor header length cnt [%d]", cnt);
+ g_variant_unref(reply);
+ return res;
+ }
+
+ adv_id = desc[3] << 24 | desc[2] << 16 | desc[1] << 8 | desc[0];
+ config_method = desc[4] << 8 | desc[4];
+ length = desc[6];
+ service_type = g_try_malloc0(length + 1);
+ if (service_type == NULL) {
+ WDP_LOGE("g_try_malloc0 failed");
+ g_variant_unref(reply);
+ return res;
+ }
+ WDP_LOGD("adv_id[%u] config_method[%u] length[%hhu]", adv_id, config_method, length);
+
+ cnt = 0;
+ while (cnt < length + 1 && g_variant_iter_loop(iter, "y", &service_type[cnt]))
+ cnt++;
+
+ if (cnt != length + 1) {
+ WDP_LOGE("Length doesn't matched with header value cnt [%d]", cnt);
+ g_variant_unref(reply);
+ g_free(service_type);
+ return res;
+ }
+
+ instance_length = (unsigned char)service_type[length];
+ service_type[length] = '\0';
+
+ if (instance_length != 0) {
+ instance_name = g_try_malloc0(instance_length + 1);
+ if (instance_name == NULL) {
+ WDP_LOGE("g_try_malloc0 failed");
+ g_variant_unref(reply);
+ g_free(service_type);
+ return res;
+ }
+ WDP_LOGD("instnace name length[%hhu]", instance_length);
+
+ cnt = 0;
+ while (cnt < instance_length && g_variant_iter_loop(iter, "y", &instance_name[cnt]))
+ cnt++;
+
+ if (cnt != instance_length) {
+ WDP_LOGE("Length doesn't matched with header value cnt [%d]", cnt);
+ g_variant_unref(reply);
+ g_free(service_type);
+ g_free(instance_name);
+ return res;
+ }
+ }
+
+ service = NULL;
+ service = (wfd_oem_advertise_service_s *)
+ g_try_malloc0(sizeof(wfd_oem_advertise_service_s));
+ if (service == NULL) {
+ WDP_LOGE("g_try_malloc0 failed");
+ g_variant_unref(reply);
+ g_free(service_type);
+ g_free(instance_name);
+ return res;
+ }
+ service->adv_id = adv_id;
+ service->config_method = config_method;
+ service->service_type_length = length;
+ service->service_type = service_type;
+ service->instance_name_length = instance_length;
+ service->instance_name = instance_name;
+
+GLIST_ITER_START(seek_list, seek)
+ if (g_strcmp0(seek->service_type, service->service_type) == 0) {
+ /* TODO: We need to support for instance name also hear */
+ WDP_LOGD("service type matched [%s] search_id [%llu]",
+ service->service_type, seek->search_id);
+ } else {
+ seek = NULL;
+ }
+GLIST_ITER_END()
+
+ if (seek != NULL && seek->service_info != NULL) {
+ WDP_LOGD("service info exists, service discovery will be performed");
+ } else {
+ WDP_LOGD("service info doesn't exists. Add service to list");
+ if (seek)
+ service->search_id = seek->search_id;
+ *asp_services = g_list_append(*asp_services, service);
+ }
+ }
+ g_variant_unref(reply);
+ }
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
+}
+
+static void _ws_process_device_found_properties(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 *dev_data = NULL;
+ static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
+ GVariantIter *iter = NULL;
+ const char *path = NULL;
+
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
+
+ if (!__is_valid_plugin())
+ return;
+
+ dev_data = __create_dev_data();
+ if (!dev_data) {
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
+ __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);
+
+ __extract_addr_from_path(peer_path, event.dev_addr);
+
+ if (iter != NULL) {
+ gchar *key = NULL;
+ GVariant *value = NULL;
+
+ while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
+ CHECK_KEY_VALUE(key, value);
+
+ __ws_peer_property(key, value, (void *)event.edata);
+ }
+ g_variant_iter_free(iter);
+ }
+
+ if (dev_data->has_asp_services)
+ ws_get_advertise_service(peer_path, (GList **)&(event.asp_services));
+ if (dev_data->has_asp2_services)
+ ws_get_advertise_asp_service(peer_path, (GList **)&(event.asp2_services));
+
+ if (g_pd->callback->peer_found_cb)
+ g_pd->callback->peer_found_cb(&event);
+
+ if (event.asp_services != NULL) {
+ GList *l;
+ wfd_oem_advertise_service_s *service;
+ for (l = (GList *)event.asp_services; l != NULL; l = l->next) {
+ service = (wfd_oem_advertise_service_s *)l->data;
+ event.asp_services = g_list_remove(l, service);
+ g_free(service->service_type);
+ g_free(service);
+ }
+ }
+ if (event.asp2_services != NULL) {
+ GList *l;
+ wfd_oem_advertise_service_s *service;
+ for (l = (GList *)event.asp2_services; l != NULL; l = l->next) {
+ service = (wfd_oem_advertise_service_s *)l->data;
+ event.asp_services = g_list_remove(l, service);
+ g_free(service->service_type);
+ g_free(service->instance_name);
+ g_free(service);
+ }
+ }
+
+ __destroy_dev_data(dev_data);
+
+ __WDP_LOG_FUNC_EXIT__;
+}
+
+static void _ws_process_device_lost(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',};
+
+ 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_NONE;
+ event.event_id = WFD_OEM_EVENT_PEER_DISAPPEARED;
__ws_path_to_addr(peer_path, event.dev_addr, parameters);
- g_pd->callback(g_pd->user_data, &event);
+ if (g_pd->callback->peer_disappeared_cb)
+ g_pd->callback->peer_disappeared_cb(&event);
+
__WDP_LOG_FUNC_EXIT__;
}
static void _ws_process_find_stoppped(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ 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;
+ 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_NONE;
event.event_id = WFD_OEM_EVENT_DISCOVERY_FINISHED;
- g_pd->callback(g_pd->user_data, &event);
+ if (g_pd->callback->discovery_finished_cb)
+ g_pd->callback->discovery_finished_cb(&event);
__WDP_LOG_FUNC_EXIT__;
}
static void _ws_process_prov_disc_req_display_pin(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ 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;
const char *pin = NULL;
- char *loc = NULL;
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- strerror(errno));
+ if (!__is_valid_plugin())
+ return;
+
+ 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);
dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
__ws_peer_property, event.edata);
- g_pd->callback(g_pd->user_data, &event);
- g_free(event.edata);
+ if (g_pd->callback->prov_disc_req_cb)
+ g_pd->callback->prov_disc_req_cb(&event);
+
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
static void _ws_process_prov_disc_resp_display_pin(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ 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;
const char *pin = NULL;
- char *loc = NULL;
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- strerror(errno));
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
+
+ if (!__is_valid_plugin())
+ return;
+
+ 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);
dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
__ws_peer_property, event.edata);
- g_pd->callback(g_pd->user_data, &event);
- g_free(event.edata);
+ if (g_pd->callback->prov_disc_resp_cb)
+ g_pd->callback->prov_disc_resp_cb(&event);
+
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
static void _ws_process_prov_disc_req_enter_pin(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ 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',};
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- strerror(errno));
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
+ if (!__is_valid_plugin())
+ return;
+
+ 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);
dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
__ws_peer_property, event.edata);
- g_pd->callback(g_pd->user_data, &event);
- g_free(event.edata);
+ if (g_pd->callback->prov_disc_req_cb)
+ g_pd->callback->prov_disc_req_cb(&event);
+
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
static void _ws_process_prov_disc_resp_enter_pin(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ 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',};
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- strerror(errno));
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
+
+ if (!__is_valid_plugin())
+ return;
+
+ 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);
dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
__ws_peer_property, event.edata);
- g_pd->callback(g_pd->user_data, &event);
- g_free(event.edata);
+ if (g_pd->callback->prov_disc_resp_cb)
+ g_pd->callback->prov_disc_resp_cb(&event);
+
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
static void _ws_process_prov_disc_pbc_req(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ 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',};
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- strerror(errno));
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
+
+ if (!__is_valid_plugin())
+ return;
+
+ 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);
dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
__ws_peer_property, event.edata);
- g_pd->callback(g_pd->user_data, &event);
- g_free(event.edata);
+ if (g_pd->callback->prov_disc_req_cb)
+ g_pd->callback->prov_disc_req_cb(&event);
+
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
static void _ws_process_prov_disc_pbc_resp(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ 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',};
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- strerror(errno));
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
+
+ if (!__is_valid_plugin())
+ return;
+
+ 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);
dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
__ws_peer_property, event.edata);
- g_pd->callback(g_pd->user_data, &event);
- g_free(event.edata);
+ if (g_pd->callback->prov_disc_resp_cb)
+ g_pd->callback->prov_disc_resp_cb(&event);
+
+ __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 *object_path, GVariant *parameters)
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
{
__WDP_LOG_FUNC_ENTER__;
GVariantIter *iter = NULL;
wfd_oem_event_s event;
wfd_oem_asp_prov_s *edata;
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
+
+ if (!g_pd || !g_pd->callback) {
+ WDP_LOGD("Ignoring event");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
edata = (wfd_oem_asp_prov_s *) g_try_malloc0(sizeof(wfd_oem_asp_prov_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]",
- strerror(errno));
+ error_buf);
__WDP_LOG_FUNC_EXIT__;
return;
}
WDP_LOGE("No Properties");
}
- g_pd->callback(g_pd->user_data, &event);
+ if (g_pd->callback->prov_disc_fail_cb)
+ g_pd->callback->prov_disc_fail_cb(&event);
if (event.edata_type == WFD_OEM_EDATA_TYPE_ASP_PROV)
g_free(edata->session_information);
__WDP_LOG_FUNC_EXIT__;
}
-#else
-static void _ws_process_prov_disc_failure(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
-{
- __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;
-
- 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));
-
- g_pd->callback(g_pd->user_data, &event);
-
- __WDP_LOG_FUNC_EXIT__;
-}
-#endif /* TIZEN_FEATURE_ASP */
-
static void _ws_process_group_started(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
{
__WDP_LOG_FUNC_ENTER__;
GVariantIter *iter = NULL;
wfd_oem_event_s event;
wfd_oem_group_data_s *edata = NULL;
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
+
+ if (!g_pd || !g_pd->callback) {
+ WDP_LOGD("Ignoring event");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
edata = (wfd_oem_group_data_s*)calloc(1, sizeof(wfd_oem_group_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]",
- strerror(errno));
+ error_buf);
__WDP_LOG_FUNC_EXIT__;
return;
}
WDP_LOGE("No properties");
}
- g_pd->callback(g_pd->user_data, &event);
+ if (g_pd->callback->group_created_cb)
+ g_pd->callback->group_created_cb(&event);
+
g_free(event.edata);
__WDP_LOG_FUNC_EXIT__;
}
static void _ws_process_go_neg_success(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
{
__WDP_LOG_FUNC_ENTER__;
GVariantIter *iter = NULL;
wfd_oem_event_s event;
wfd_oem_conn_data_s *edata = NULL;
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
+
+ if (!g_pd || !g_pd->callback) {
+ WDP_LOGD("Ignoring event");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
edata = (wfd_oem_conn_data_s*)calloc(1, sizeof(wfd_oem_conn_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]",
- strerror(errno));
+ error_buf);
__WDP_LOG_FUNC_EXIT__;
return;
}
WDP_LOGE("No properties");
}
- g_pd->callback(g_pd->user_data, &event);
+ if (g_pd->callback->go_neg_done_cb)
+ g_pd->callback->go_neg_done_cb(&event);
+
g_free(edata);
__WDP_LOG_FUNC_EXIT__;
}
static void _ws_process_go_neg_failure(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
{
__WDP_LOG_FUNC_ENTER__;
GVariantIter *iter = NULL;
wfd_oem_event_s event;
wfd_oem_conn_data_s *edata = NULL;
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
+
+ if (!g_pd || !g_pd->callback) {
+ WDP_LOGD("Ignoring event");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
edata = (wfd_oem_conn_data_s *) g_try_malloc0(sizeof(wfd_oem_conn_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]",
- strerror(errno));
+ error_buf);
__WDP_LOG_FUNC_EXIT__;
return;
}
WDP_LOGE("No properties");
}
- g_pd->callback(g_pd->user_data, &event);
+ if (g_pd->callback->go_neg_fail_cb)
+ g_pd->callback->go_neg_fail_cb(&event);
+
g_free(event.edata);
__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 *object_path, GVariant *parameters)
+ 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;
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- strerror(errno));
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
+
+ if (!__is_valid_plugin())
+ return;
+
+ 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);
- g_pd->callback(g_pd->user_data, &event);
- g_free(event.edata);
+ if (g_pd->callback->go_neg_req_cb)
+ g_pd->callback->go_neg_req_cb(&event);
+
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
static void _ws_process_invitation_received(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
{
__WDP_LOG_FUNC_ENTER__;
GVariantIter *iter = NULL;
wfd_oem_event_s event;
wfd_oem_invite_data_s *edata = NULL;
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
+
+ if (!g_pd || !g_pd->callback) {
+ WDP_LOGD("Ignoring event");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
edata = (wfd_oem_invite_data_s *) g_try_malloc0(sizeof(wfd_oem_invite_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]",
- strerror(errno));
+ error_buf);
__WDP_LOG_FUNC_EXIT__;
return;
}
}
memcpy(&(event.dev_addr), edata->sa, OEM_MACADDR_LEN);
- g_pd->callback(g_pd->user_data, &event);
+ if (g_pd->callback->invitation_req_cb)
+ g_pd->callback->invitation_req_cb(&event);
+
g_free(event.edata);
__WDP_LOG_FUNC_EXIT__;
}
static void _ws_process_invitation_result(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ 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;
+
+ 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));
__WDP_LOG_FUNC_EXIT__;
}
static void _ws_process_group_finished(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ 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;
+ int i = 0;
+
+ 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.event_id = WFD_OEM_EVENT_GROUP_DESTROYED;
event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
- g_dbus_connection_signal_unsubscribe(g_pd->g_dbus, g_pd->group_sub_id);
+ for (i = 0; ws_group_signal_map[i].member != NULL; i++) {
+ 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();
- g_pd->callback(g_pd->user_data, &event);
+ if (g_pd->callback->group_destroyed_cb)
+ g_pd->callback->group_destroyed_cb(&event);
__WDP_LOG_FUNC_EXIT__;
}
-#ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
static void _ws_process_service_discovery_response(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
{
__WDP_LOG_FUNC_ENTER__;
GVariantIter *iter = NULL;
wfd_oem_event_s event;
+ 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.event_id = WFD_OEM_EVENT_SERV_DISC_RESP;
WDP_LOGE("No Properties");
}
- g_pd->callback(g_pd->user_data, &event);
+ if (g_pd->callback->serv_disc_resp_cb)
+ g_pd->callback->serv_disc_resp_cb(&event);
if (event.edata_type == WFD_OEM_EDATA_TYPE_NEW_SERVICE)
g_list_free((GList*) event.edata);
__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 *object_path, GVariant *parameters)
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
{
__WDP_LOG_FUNC_ENTER__;
GVariantIter *iter = NULL;
wfd_oem_event_s event;
- wfd_oem_asp_service_s *service, *tmp;
+ wfd_oem_asp_service_s *service = NULL;
+ wfd_oem_asp_service_s *tmp = NULL;
+
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
+
+ if (!g_pd || !g_pd->callback) {
+ WDP_LOGD("Ignoring event");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
service = (wfd_oem_asp_service_s *) g_try_malloc0(sizeof(wfd_oem_asp_service_s));
if (!service) {
+ 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]",
- strerror(errno));
+ error_buf);
__WDP_LOG_FUNC_EXIT__;
return;
}
}
GLIST_ITER_END()
- if (tmp->service_info != NULL)
- g_pd->callback(g_pd->user_data, &event);
- else
+ if (tmp != NULL && tmp->service_info != NULL) {
+ if (g_pd->callback->asp_serv_resp_cb)
+ g_pd->callback->asp_serv_resp_cb(&event);
+ } else {
WDP_LOGD("service info is not required, don't notify to user");
+ }
g_free(service->service_type);
g_free(service->service_info);
__WDP_LOG_FUNC_EXIT__;
}
-#endif /* TIZEN_FEATURE_ASP */
static void _ws_process_persistent_group_added(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ 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;
+
+ 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));
__WDP_LOG_FUNC_EXIT__;
}
static void _ws_process_persistent_group_removed(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ 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;
+
+ 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));
__WDP_LOG_FUNC_EXIT__;
}
static void _ws_process_wps_failed(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
{
__WDP_LOG_FUNC_ENTER__;
GVariantIter *iter = NULL;
wfd_oem_event_s event;
const char *name = 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.event_id = WFD_OEM_EVENT_WPS_FAIL;
gchar *key = NULL;
GVariant *value = NULL;
- while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
+ while (g_variant_iter_loop(iter, "{sv}", &key, &value))
CHECK_KEY_VALUE(key, value);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
- }
+
g_variant_iter_free(iter);
}
- g_pd->callback(g_pd->user_data, &event);
+ if (g_pd->callback->wps_fail_cb)
+ g_pd->callback->wps_fail_cb(&event);
__WDP_LOG_FUNC_EXIT__;
}
static void _ws_process_group_formation_failure(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ 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;
+ 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.event_id = WFD_OEM_EVENT_GROUP_FORMATION_FAILURE;
event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
- g_pd->callback(g_pd->user_data, &event);
+ if (g_pd->callback->group_formation_failure_cb)
+ g_pd->callback->group_formation_failure_cb(&event);
__WDP_LOG_FUNC_EXIT__;
}
static void _ws_process_invitation_accepted(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
{
__WDP_LOG_FUNC_ENTER__;
GVariantIter *iter = NULL;
wfd_oem_event_s event;
+ 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.event_id = WFD_OEM_EVENT_INVITATION_ACCEPTED;
while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
CHECK_KEY_VALUE(key, value);
+
if (g_strcmp0(key, "sa") == 0)
if (__ws_unpack_ay(event.dev_addr, value, WS_MACADDR_LEN))
WDP_LOGI("[" MACSTR "]", MAC2STR(event.dev_addr));
}
}
- g_pd->callback(g_pd->user_data, &event);
+ if (g_pd->callback->invitation_accepted_cb)
+ g_pd->callback->invitation_accepted_cb(&event);
+
__WDP_LOG_FUNC_EXIT__;
}
-#if defined(TIZEN_FEATURE_ASP)
static void _ws_process_asp_provision_start(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
{
__WDP_LOG_FUNC_ENTER__;
GVariantIter *iter = NULL;
wfd_oem_event_s event;
wfd_oem_asp_prov_s *edata;
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
+
+ if (!g_pd || !g_pd->callback) {
+ WDP_LOGD("Ignoring event");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
edata = (wfd_oem_asp_prov_s *) g_try_malloc0(sizeof(wfd_oem_asp_prov_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]",
- strerror(errno));
+ error_buf);
__WDP_LOG_FUNC_EXIT__;
return;
}
WDP_LOGE("No Properties");
}
- g_pd->callback(g_pd->user_data, &event);
+ if (g_pd->callback->asp_prov_start_cb)
+ g_pd->callback->asp_prov_start_cb(&event);
if (event.edata_type == WFD_OEM_EDATA_TYPE_ASP_PROV)
g_free(edata->session_information);
}
static void _ws_process_asp_provision_done(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
{
__WDP_LOG_FUNC_ENTER__;
GVariantIter *iter = NULL;
wfd_oem_event_s event;
wfd_oem_asp_prov_s *edata;
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
+
+ if (!g_pd || !g_pd->callback) {
+ WDP_LOGD("Ignoring event");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
edata = (wfd_oem_asp_prov_s *) g_try_malloc0(sizeof(wfd_oem_asp_prov_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]",
- strerror(errno));
+ error_buf);
__WDP_LOG_FUNC_EXIT__;
return;
}
WDP_LOGE("No Properties");
}
- g_pd->callback(g_pd->user_data, &event);
+ if (g_pd->callback->asp_prov_done_cb)
+ g_pd->callback->asp_prov_done_cb(&event);
+
g_free(edata);
__WDP_LOG_FUNC_EXIT__;
}
-#endif /* TIZEN_FEATURE_ASP */
static struct {
+ int sub_id;
const char *interface;
const char *member;
- void (*function) (GDBusConnection *connection, const gchar *object_path,
- GVariant *parameters);
+ void (*function) (GDBusConnection *connection,
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data);
} ws_p2pdevice_signal_map[] = {
{
+ 0,
SUPPLICANT_P2PDEVICE,
- "DeviceFound",
- _ws_process_device_found
+ "DeviceFoundProperties",
+ _ws_process_device_found_properties
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"DeviceLost",
_ws_process_device_lost
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"FindStopped",
_ws_process_find_stoppped
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"ProvisionDiscoveryRequestDisplayPin",
_ws_process_prov_disc_req_display_pin
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"ProvisionDiscoveryResponseDisplayPin",
_ws_process_prov_disc_resp_display_pin
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"ProvisionDiscoveryRequestEnterPin",
_ws_process_prov_disc_req_enter_pin
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"ProvisionDiscoveryResponseEnterPin",
_ws_process_prov_disc_resp_enter_pin
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"ProvisionDiscoveryPBCRequest",
_ws_process_prov_disc_pbc_req
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"ProvisionDiscoveryPBCResponse",
_ws_process_prov_disc_pbc_resp
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"ProvisionDiscoveryFailure",
_ws_process_prov_disc_failure
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"GroupStarted",
_ws_process_group_started
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"GONegotiationSuccess",
_ws_process_go_neg_success
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"GONegotiationFailure",
_ws_process_go_neg_failure
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"GONegotiationRequest",
_ws_process_go_neg_request
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"InvitationReceived",
_ws_process_invitation_received
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"InvitationResult",
_ws_process_invitation_result
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"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,
"ServiceASPResponse",
_ws_process_service_asp_response
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"ASPProvisionStart",
_ws_process_asp_provision_start
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"ASPProvisionDone",
_ws_process_asp_provision_done
},
-#endif /* TIZEN_FEATURE_ASP */
{
+ 0,
SUPPLICANT_P2PDEVICE,
"PersistentGroupAdded",
_ws_process_persistent_group_added
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"PersistentGroupRemoved",
_ws_process_persistent_group_removed
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"WpsFailed",
_ws_process_wps_failed
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"GroupFormationFailure",
_ws_process_group_formation_failure
},
{
+ 0,
SUPPLICANT_P2PDEVICE,
"InvitationAccepted",
_ws_process_invitation_accepted
},
{
+ 0,
NULL,
NULL,
NULL
}
};
-static void _p2pdevice_signal_cb(GDBusConnection *connection,
+static void _ws_process_sta_authorized(GDBusConnection *connection,
const gchar *sender, const gchar *object_path, const gchar *interface,
const gchar *signal, GVariant *parameters, gpointer user_data)
{
- int i = 0;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
+ __WDP_LOG_FUNC_ENTER__;
+ wfd_oem_event_s event;
+ const gchar* mac_str = NULL;
+
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
- if (!g_pd) {
- WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ if (!g_pd || !g_pd->callback) {
+ WDP_LOGD("Ignoring event");
+ __WDP_LOG_FUNC_EXIT__;
return;
}
- for (i = 0; ws_p2pdevice_signal_map[i].member != NULL; i++) {
- if (!g_strcmp0(signal, ws_p2pdevice_signal_map[i].member) &&
- ws_p2pdevice_signal_map[i].function != NULL)
- ws_p2pdevice_signal_map[i].function(connection, object_path, parameters);
- }
-}
-
-
-static void _ws_process_sta_authorized(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
-{
- __WDP_LOG_FUNC_ENTER__;
- wfd_oem_event_s event;
- const gchar* mac_str = NULL;
-
if (is_peer_joined_notified) {
is_peer_joined_notified = 0;
__WDP_LOG_FUNC_EXIT__;
event.event_id = WFD_OEM_EVENT_STA_CONNECTED;
event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
- g_pd->callback(g_pd->user_data, &event);
+ if (g_pd->callback->sta_connected_cb)
+ g_pd->callback->sta_connected_cb(&event);
+
__WDP_LOG_FUNC_EXIT__;
}
static void _ws_process_sta_deauthorized(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+ 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;
const gchar* mac_str = NULL;
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
+
+ if (!g_pd || !g_pd->callback) {
+ WDP_LOGD("Ignoring event");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
if (is_peer_disconnected_notified) {
is_peer_disconnected_notified = 0;
__WDP_LOG_FUNC_EXIT__;
event.event_id = WFD_OEM_EVENT_STA_DISCONNECTED;
event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
- g_pd->callback(g_pd->user_data, &event);
+ if (g_pd->callback->sta_disconnected_cb)
+ g_pd->callback->sta_disconnected_cb(&event);
+
__WDP_LOG_FUNC_EXIT__;
}
static struct {
+ int sub_id;
const char *interface;
const char *member;
- void (*function) (GDBusConnection *connection, const gchar *object_path,
- GVariant *parameters);
+ void (*function) (GDBusConnection *connection,
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data);
} ws_interface_signal_map[] = {
{
- SUPPLICANT_INTERFACE,
+ 0,
+ SUPPLICANT_IFACE,
"StaAuthorized",
_ws_process_sta_authorized
},
{
- SUPPLICANT_INTERFACE,
+ 0,
+ SUPPLICANT_IFACE,
"StaDeauthorized",
_ws_process_sta_deauthorized
},
{
+ 0,
NULL,
NULL,
NULL
}
};
-static void _interface_signal_cb(GDBusConnection *connection,
- const gchar *sender, const gchar *object_path, const gchar *interface,
- const gchar *signal, GVariant *parameters, gpointer user_data)
+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__;
+ ws_dbus_plugin_data_s * pd_data;
+ static char interface_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
+ const char *path = NULL;
int i = 0;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
if (!g_pd) {
WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
return;
}
- for (i = 0; ws_interface_signal_map[i].member != NULL; i++) {
- if (!g_strcmp0(signal, ws_interface_signal_map[i].member) &&
- ws_interface_signal_map[i].function != NULL)
- ws_interface_signal_map[i].function(connection, object_path, parameters);
- }
-}
-
-
-static void __ws_parse_peer_joined(char *peer_path,
- unsigned char *dev_addr, unsigned char *ip_addr, GVariant *parameter)
-{
- __WDP_LOG_FUNC_ENTER__;
-
- GVariantIter *iter;
- static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
- 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]);
- 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 void _group_signal_cb(GDBusConnection *connection,
- const gchar *sender, const gchar *object_path, const gchar *interface,
- const gchar *signal, GVariant *parameters, gpointer user_data)
-{
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
-
- if (!g_pd) {
- WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
- return;
- }
-
- if (!g_strcmp0(signal, "PeerJoined")) {
-
- wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
-
- static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
-
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- strerror(errno));
- __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;
-
- __ws_parse_peer_joined(peer_path, event.dev_addr, event.ip_addr_peer, parameters);
-
- dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
- __ws_peer_property, event.edata);
-
- g_pd->callback(g_pd->user_data, &event);
- is_peer_joined_notified = 1;
-
- g_free(edata);
-
- } else if (!g_strcmp0(signal, "PeerDisconnected")) {
-
- wfd_oem_event_s event;
-
- static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
-
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
-
- event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
- event.event_id = WFD_OEM_EVENT_STA_DISCONNECTED;
-
- __ws_path_to_addr(peer_path, event.dev_addr, parameters);
-
- g_pd->callback(g_pd->user_data, &event);
- is_peer_disconnected_notified = 1;
- }
-}
-
-static void __register_p2pdevice_signal(GVariant *value, void *user_data)
-{
- __WDP_LOG_FUNC_ENTER__;
- ws_dbus_plugin_data_s * pd_data;
- static char interface_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- const char *path = NULL;
-
- if (!g_pd) {
- WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
- return;
- }
-
pd_data = (ws_dbus_plugin_data_s *)g_pd;
g_variant_get(value, "(&o)", &path);
WDP_LOGD("interface object path [%s]", interface_path);
/* subscribe Interface iface signal */
- WDP_LOGD("Register Interface iface signal");
- pd_data->p2pdevice_sub_id = g_dbus_connection_signal_subscribe(
- pd_data->g_dbus,
- SUPPLICANT_SERVICE, /* bus name */
- SUPPLICANT_IFACE, /* interface */
- NULL, /* member */
- NULL, /* object path */
- NULL, /* arg0 */
- G_DBUS_SIGNAL_FLAGS_NONE,
- _interface_signal_cb,
- NULL, NULL);
+ for (i = 0; ws_interface_signal_map[i].member != NULL; i++) {
+ ws_interface_signal_map[i].sub_id =
+ g_dbus_connection_signal_subscribe(pd_data->g_dbus,
+ SUPPLICANT_SERVICE, /* bus name */
+ ws_interface_signal_map[i].interface, /* interface */
+ ws_interface_signal_map[i].member, /* member */
+ pd_data->iface_path, /* object path */
+ NULL, /* arg0 */
+ G_DBUS_SIGNAL_FLAGS_NONE,
+ ws_interface_signal_map[i].function,
+ NULL, NULL);
+ WDP_LOGD("Subscribed Interface iface signal [%s]", ws_interface_signal_map[i].member);
+ }
/* subscribe P2PDevice iface signal */
- WDP_LOGD("register P2PDevice iface signal");
- pd_data->p2pdevice_sub_id = g_dbus_connection_signal_subscribe(
- pd_data->g_dbus,
- SUPPLICANT_SERVICE, /* bus name */
- SUPPLICANT_P2PDEVICE, /* interface */
- NULL, /* member */
- NULL, /* object path */
- NULL, /* arg0 */
- G_DBUS_SIGNAL_FLAGS_NONE,
- _p2pdevice_signal_cb,
- NULL, NULL);
+ for (i = 0; ws_p2pdevice_signal_map[i].member != NULL; i++) {
+ ws_p2pdevice_signal_map[i].sub_id =
+ g_dbus_connection_signal_subscribe(pd_data->g_dbus,
+ SUPPLICANT_SERVICE, /* bus name */
+ ws_p2pdevice_signal_map[i].interface, /* interface */
+ ws_p2pdevice_signal_map[i].member, /* member */
+ pd_data->iface_path, /* object path */
+ NULL, /* arg0 */
+ G_DBUS_SIGNAL_FLAGS_NONE,
+ ws_p2pdevice_signal_map[i].function,
+ NULL, NULL);
+ WDP_LOGD("Subscribed P2PDevice iface signal [%s]", ws_p2pdevice_signal_map[i].member);
+ }
+
__WDP_LOG_FUNC_EXIT__;
}
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));
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)
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;
}
SUPPLICANT_PATH, g_pd->g_dbus);
params.params = g_variant_new("(s)", iface_name);
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, SUPPLICANT_INTERFACE,
function, user_data);
return res;
}
-#if defined(TIZEN_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_MOBILE) && (TIZEN_WLAN_BOARD_SPRD) */
static int _ws_init_dbus_connection(void)
{
GDBusConnection *conn = NULL;
GError *error = NULL;
int res = 0;
+ int i = 0;
if (!g_pd) {
WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ if (!config) {
+ WDP_LOGE("no configurable data found");
+ __WDP_LOG_FUNC_EXIT__;
return -1;
}
g_pd->g_dbus = conn;
- WDP_LOGD("register supplicant signal");
- /* subscribe supplicant signal */
- g_pd->supp_sub_id = g_dbus_connection_signal_subscribe(
- g_pd->g_dbus,
- SUPPLICANT_SERVICE, /* bus name */
- SUPPLICANT_INTERFACE, /* interface */
- NULL, /* member */
- SUPPLICANT_PATH, /* object path */
- NULL, /* arg0 */
- G_DBUS_SIGNAL_FLAGS_NONE,
- _supplicant_signal_cb,
- NULL, NULL);
-#if defined(TIZEN_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_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_MOBILE) && (TIZEN_WLAN_BOARD_SPRD) */
+ for (i = 0; ws_supplicant_signal_map[i].member != NULL; i++) {
+ ws_supplicant_signal_map[i].sub_id =
+ g_dbus_connection_signal_subscribe(g_pd->g_dbus,
+ SUPPLICANT_SERVICE, /* bus name */
+ ws_supplicant_signal_map[i].interface, /* interface */
+ ws_supplicant_signal_map[i].member, /* member */
+ SUPPLICANT_PATH, /* object path */
+ NULL, /* arg0 */
+ G_DBUS_SIGNAL_FLAGS_NONE,
+ ws_supplicant_signal_map[i].function,
+ NULL, NULL);
+ WDP_LOGD("Subscribed supplicant iface signal [%s]", ws_supplicant_signal_map[i].member);
+ }
+
+ 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");
static int _ws_deinit_dbus_connection(void)
{
GDBusConnection *g_dbus = NULL;
+ int i = 0;
if (!g_pd) {
WDP_LOGE("Invalid parameter");
g_dbus = g_pd->g_dbus;
if (!g_dbus) {
WDP_LOGE("DBus connection is NULL");
+ __WDP_LOG_FUNC_EXIT__;
return -1;
}
- g_dbus_connection_signal_unsubscribe(g_dbus, g_pd->supp_sub_id);
- g_dbus_connection_signal_unsubscribe(g_dbus, g_pd->p2pdevice_sub_id);
- g_dbus_connection_signal_unsubscribe(g_dbus, g_pd->group_sub_id);
+ for (i = 0; ws_supplicant_signal_map[i].member != NULL; i++) {
+ g_dbus_connection_signal_unsubscribe(g_dbus, ws_supplicant_signal_map[i].sub_id);
+ ws_supplicant_signal_map[i].sub_id = 0;
+ }
+
+ for (i = 0; ws_interface_signal_map[i].member != NULL; i++) {
+ g_dbus_connection_signal_unsubscribe(g_dbus, ws_interface_signal_map[i].sub_id);
+ ws_interface_signal_map[i].sub_id = 0;
+ }
+
+ for (i = 0; ws_p2pdevice_signal_map[i].member != NULL; i++) {
+ g_dbus_connection_signal_unsubscribe(g_dbus, ws_p2pdevice_signal_map[i].sub_id);
+ ws_p2pdevice_signal_map[i].sub_id = 0;
+ }
+
+ for (i = 0; ws_group_signal_map[i].member != NULL; i++) {
+ g_dbus_connection_signal_unsubscribe(g_dbus, ws_group_signal_map[i].sub_id);
+ ws_group_signal_map[i].sub_id = 0;
+ }
- g_pd->group_iface_sub_id = 0;
- g_pd->p2pdevice_sub_id = 0;
- g_pd->group_sub_id = 0;
memset(g_pd->group_iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
memset(g_pd->iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
g_object_unref(g_dbus);
+ __WDP_LOG_FUNC_EXIT__;
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__;
if (!ops) {
WDP_LOGE("Invalid parameter");
+ __WDP_LOG_FUNC_EXIT__;
return -1;
}
*ops = &supplicant_ops;
+ __WDP_LOG_FUNC_EXIT__;
return 0;
}
return 0;
}
-#ifndef TIZEN_WIFI_MODULE_BUNDLE
static int __ws_check_net_interface(char* if_name)
{
struct ifreq ifr;
}
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);
- WDP_LOGE("ioctl error: SIOCGIFFLAGS: %s [ %s ]", strerror(errno), if_name); /* interface is not found. */
+ char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
+ strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
+ WDP_LOGE("ioctl error: SIOCGIFFLAGS: %s [ %s ]", error_buf, if_name); /* interface is not found. */
return -3;
}
}
return 0;
}
-#endif
-int ws_init(wfd_oem_event_cb callback, void *user_data)
+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__;
+ if (event_cbs == NULL) {
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
if (g_pd)
_ws_reset_plugin(g_pd);
errno = 0;
g_pd = (ws_dbus_plugin_data_s*) g_try_malloc0(sizeof(ws_dbus_plugin_data_s));
if (!g_pd) {
- WDP_LOGE("Failed to allocate memory for plugin data. [%s]", strerror(errno));
+ char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
+ strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
+ WDP_LOGE("Failed to allocate memory for plugin data. [%s]", error_buf);
return -1;
}
- g_pd->callback = callback;
- g_pd->user_data = user_data;
+ g_pd->callback = event_cbs;
g_pd->initialized = TRUE;
__WDP_LOG_FUNC_EXIT__;
return 0;
}
-int ws_deinit()
+int ws_deinit(void)
{
__WDP_LOG_FUNC_ENTER__;
g_pd = NULL;
}
+ if (config)
+ g_free(config);
+
__WDP_LOG_FUNC_EXIT__;
return 0;
}
int rv = 0;
errno = 0;
register unsigned int index = 0;
+ char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
while (args[index] != NULL) {
WDP_LOGD("[%s]", args[index]);
errno = 0;
if (execve(file_path, args, envs) == -1) {
- WDP_LOGE("Fail to execute command (%s)", strerror(errno));
+ strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
+ WDP_LOGE("Fail to execute command (%s)", error_buf);
exit(1);
}
} else if (pid > 0) {
return TRUE;
}
- WDP_LOGE("failed to fork (%s)", strerror(errno));
+ strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
+ WDP_LOGE("failed to fork (%s)", error_buf);
return FALSE;
}
-#ifndef TIZEN_WIFI_MODULE_BUNDLE
-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;
+ }
+
+ 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 */
- rv = _ws_util_execute_file(path, args, envs);
- if (rv != TRUE)
- return -1;
+ 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;
}
-#endif
static int __ws_p2p_supplicant_start(void)
{
}
#endif
-int __ws_init_p2pdevice()
+int __ws_init_p2pdevice(void)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
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;
if (!g_pd) {
WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ __WDP_LOG_FUNC_EXIT__;
+ 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]);
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));
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);
param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig", value);
params.params = param;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
if (res < 0)
return res;
}
-int __ws_set_config_methods()
+int __ws_set_config_methods(void)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
if (!g_pd) {
WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ __WDP_LOG_FUNC_EXIT__;
+ 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");
+ __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);
- 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;
if (!g_pd) {
WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ if (!config) {
+ WDP_LOGE("no configurable data found");
+ __WDP_LOG_FUNC_EXIT__;
return -1;
}
__WDP_LOG_FUNC_EXIT__;
return -1;
}
-#ifndef TIZEN_WIFI_MODULE_BUNDLE
+
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++;
break;
}
}
-#endif
+
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);
-#ifndef TIZEN_WIFI_MODULE_BUNDLE
- res = __ws_p2p_firmware_stop();
+ res = __ws_p2p_firmware_stop(config->ifname);
WDP_LOGI("P2P firmware stopped with error %d", res);
-#endif
__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");
- return -1;
+ __WDP_LOG_FUNC_EXIT__;
+ 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");
- return -1;
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
}
ws_stop_scan();
g_pd->concurrent = concurrent;
-#if defined(TIZEN_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_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);
-#ifndef TIZEN_WIFI_MODULE_BUNDLE
- res = __ws_p2p_firmware_stop();
+ res = __ws_p2p_firmware_stop(config->ifname);
WDP_LOGI("P2P firmware stopped with error %d", res);
-#endif
}
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) {
WDP_LOGE("Invalid parameter");
+ __WDP_LOG_FUNC_EXIT__;
return -1;
}
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));
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);
}
params.params = value;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (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));
g_variant_builder_unref(builder);
params.params = value;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (res < 0)
return res;
}
-int ws_stop_scan()
+int ws_stop_scan(void)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
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));
__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;
if (!peer_addr || !peer) {
WDP_LOGE("Invalid parameter");
+ __WDP_LOG_FUNC_EXIT__;
return -1;
}
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;
}
- ws_dev = (wfd_oem_device_s *) g_try_malloc0(sizeof(wfd_oem_device_s));
- if (!ws_dev) {
- WDP_LOGF("Failed to allocate memory device. [%s]",
- strerror(errno));
+ 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;
}
value = g_variant_new("(os)", peer_path, __ws_wps_to_txt(wps_mode));
params.params = value;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (res < 0)
g_variant_builder_unref(builder);
params.params = value;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (res < 0)
if (!peer_addr) {
WDP_LOGE("Invalid parameter");
+ __WDP_LOG_FUNC_EXIT__;
return -1;
}
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));
g_variant_builder_unref(builder);
params.params = value;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (res < 0)
value = g_variant_new("(o)", peer_path);
params.params = value;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (res < 0)
return 0;
}
-int ws_get_supported_wps_mode()
+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;
}
g_variant_builder_add(builder, "{sv}", "passphrase",
g_variant_new_string(param->passphrase));
+ if (param->ssid && strlen(param->ssid) > 0)
+ g_variant_builder_add(builder, "{sv}", "ssid",
+ g_variant_new_string(param->ssid));
+
if (param->freq)
g_variant_builder_add(builder, "{sv}", "frequency",
g_variant_new_int32(param->freq));
g_variant_builder_unref(builder);
params.params = value;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE,
__store_group_iface_path, g_pd);
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;
}
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));
g_variant_builder_unref(builder);
params.params = value;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (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;
}
g_variant_builder_unref(builder);
params.params = value;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, SUPPLICANT_WPS, NULL, NULL);
if (res < 0)
return 0;
}
-int ws_wps_cancel()
+int ws_wps_cancel(void)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
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));
if (!dev_name) {
WDP_LOGE("Invalid parameter");
+ __WDP_LOG_FUNC_EXIT__;
return -1;
}
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));
"P2PDeviceConfig", value);
params.params = param;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
if (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;
}
param = g_variant_new("(ss)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig");
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(param);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", param);
reply = g_dbus_connection_call_sync(
g_dbus,
GVariant *value = NULL;
while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
CHECK_KEY_VALUE(key, value);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+
if (g_strcmp0(key, "GOIntent") == 0)
g_variant_get(value, "u", go_intent);
}
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));
param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig", value);
params.params = param;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
if (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));
param = g_variant_new("(ssv)", SUPPLICANT_IFACE, "Country", value);
params.params = param;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
if (res < 0)
}
ws_network_info_s *network = (ws_network_info_s *)user_data;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
+
CHECK_KEY_VALUE(key, value);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+
if (g_strcmp0(key, "ssid") == 0) {
const char *ssid = NULL;
g_variant_get(value, "&s", &ssid);
void __ws_extract_p2pdevice_details(const char *key, GVariant *value, void *user_data)
{
__WDP_LOG_FUNC_ENTER__;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
CHECK_KEY_VALUE(key, value);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+
if (g_strcmp0(key, "PersistentGroups") == 0) {
GVariantIter *iter = NULL;
const char *path = NULL;
g_strlcpy(networks[num].persistent_path, path, DBUS_OBJECT_PATH_MAX);
loc = strrchr(networks[num].persistent_path, '/');
- networks[num].network_id = strtoul(loc+1, NULL, 10);
+ if (loc)
+ networks[num].network_id = strtoul(loc+1, NULL, 10);
WDP_LOGD("Retrive persistent path [%s]", networks[num].persistent_path);
dbus_property_get_all(networks[num].persistent_path, g_pd->g_dbus,
__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);
dbus_set_method_param(¶ms, "RemovePersistentGroup",
g_pd->iface_path, g_dbus);
params.params = g_variant_new("(o)", networks[i].persistent_path);
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (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));
param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig", value);
params.params = param;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
if (res < 0)
return res;
}
-#ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
static int __ws_compress_query(char *compressed, char *query, int qtype)
{
char *token = NULL;
} else if (qtype == WS_QTYPE_TXT) {
- token = strtok_r(rdata, ", ", &temp);
+ token = strtok_r(rdata, ",", &temp);
while (token) {
WDP_LOGD("Token: [%s]", token);
memcpy(&compressed[length], token, token_len);
length += token_len;
- token = strtok_r(NULL, ", ", &temp);
+ token = strtok_r(NULL, ",", &temp);
}
} else {
WDP_LOGD("RDATA is 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);
g_variant_builder_unref(builder);
params.params = value;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_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)
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));
} 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));
}
g_variant_builder_unref(builder);
params.params = value;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (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));
} 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));
}
g_variant_builder_unref(builder);
params.params = value;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (res < 0)
__WDP_LOG_FUNC_EXIT__;
return 0;
}
-#endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
-
-#ifdef TIZEN_FEATURE_WIFI_DISPLAY
int _ws_disable_display()
{
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));
param = g_variant_new("(ssv)", SUPPLICANT_INTERFACE, "WFDIEs", value);
params.params = param;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
if (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));
param = g_variant_new("(ssv)", SUPPLICANT_INTERFACE, "WFDIEs", value);
params.params = param;
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
if (res < 0)
__WDP_LOG_FUNC_EXIT__;
return res;
}
-#endif /* TIZEN_FEATURE_WIFI_DISPLAY */
-int ws_refresh()
+int ws_refresh(void)
{
__WDP_LOG_FUNC_ENTER__;
return 0;
}
-#if defined(TIZEN_FEATURE_ASP)
int ws_advertise_service(wfd_oem_asp_service_s *service, int replace)
{
__WDP_LOG_FUNC_ENTER__;
g_variant_builder_add(builder, "{sv}", "config_method", g_variant_new_uint32(config_method));
g_variant_builder_add(builder, "{sv}", "replace", g_variant_new_boolean(rep));
if (service->service_type != NULL)
- g_variant_builder_add(builder, "{sv}", "adv_str", g_variant_new_string(service->service_type));
+ g_variant_builder_add(builder, "{sv}", "adv_str",
+ g_variant_new_string(service->service_type));
if (service->service_info != NULL)
- g_variant_builder_add(builder, "{sv}", "svc_info", g_variant_new_string(service->service_info));
+ g_variant_builder_add(builder, "{sv}", "svc_info",
+ g_variant_new_string(service->service_info));
+ if (service->instance_name != NULL)
+ g_variant_builder_add(builder, "{sv}", "svc_instance",
+ g_variant_new_string(service->instance_name));
value = g_variant_new("(a{sv})", builder);
g_variant_builder_unref(builder);
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- WDP_LOGE("params [%s]", g_variant_print(value, TRUE));
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", value);
params.params = value;
value = g_variant_new("(a{sv})", builder);
g_variant_builder_unref(builder);
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- WDP_LOGD("params [%s]", g_variant_print(value, TRUE));
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", value);
params.params = value;
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
return;
}
-static wfd_oem_asp_service_s * __ws_get_seek(long long unsigned search_id)
+static wfd_oem_asp_service_s * __ws_get_seek(long long unsigned asp_search_id)
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_asp_service_s *seek = NULL;
for (list = seek_list; list != NULL; list = list->next) {
seek = list->data;
- if (seek && (seek->search_id == search_id)) {
+ if (seek && (seek->asp_search_id == asp_search_id)) {
WDP_LOGD("List found");
break;
} else {
for (list = seek_list; list != NULL; list = list->next) {
seek = list->data;
- if (seek && (seek->search_id == service->search_id)) {
+ if (seek && (seek->asp_search_id == service->asp_search_id)) {
WDP_LOGD("List remove");
seek_list = g_list_remove(seek_list, seek);
g_free(seek->service_type);
g_variant_builder_add(builder, "{sv}", "svc_info",
g_variant_new_string(service->service_info));
+ if (service->instance_name != NULL)
+ g_variant_builder_add(builder, "{sv}", "svc_instance",
+ g_variant_new_string(service->instance_name));
+
value = g_variant_new("(a{sv})", builder);
g_variant_builder_unref(builder);
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- WDP_LOGD("params [%s]", g_variant_print(value, TRUE));
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", value);
params.params = value;
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE,
return -1;
}
- seek = __ws_get_seek(service->search_id);
+ seek = __ws_get_seek(service->asp_search_id);
if (!seek) {
WDP_LOGE("seek data is NULL");
__WDP_LOG_FUNC_EXIT__;
params.params = g_variant_new("(t)", service->search_id);
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- WDP_LOGD("params [%s]", g_variant_print(params.params, TRUE));
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (res < 0)
dbus_set_method_param(¶ms, "ASPProvisionDiscoveryRequest", g_pd->iface_path, g_dbus);
- g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
- COMPACT_MACSTR, g_pd->iface_path, MAC2STR(asp_params->service_mac));
+ if (asp_params->deferring == 0)
+ g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
+ COMPACT_MACSTR, g_pd->iface_path, MAC2STR(asp_params->service_mac));
+ else
+ g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
+ COMPACT_MACSTR, g_pd->iface_path, MAC2STR(asp_params->session_mac));
WDP_LOGD("get peer path [%s]", peer_path);
builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
value = g_variant_new("(a{sv})", builder);
g_variant_builder_unref(builder);
-#if defined(TIZEN_DEBUG_DBUS_VALUE)
- WDP_LOGD("params [%s]", g_variant_print(value, TRUE));
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ DEBUG_G_VARIANT("Params : ", value);
params.params = value;
__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_ENTER__;
+ GDBusConnection *g_dbus = NULL;
+ GVariant *value = NULL;
+ GVariantBuilder *bytearray_builder = NULL;
+ dbus_method_param_s params;
+ int res = 0;
+ int i = 0;
+ size_t vsie_len = 0;
+
+ unsigned char *bytearray = NULL;
+ size_t bytearray_len = 0;
+
+ if (frame_id >= WFD_OEM_VSIE_FRAME_MAX ||
+ vsie == NULL) {
+ WDP_LOGE("Invalid parameter");
+ return -1;
+ }
+
+ 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;
+ }
+
+ vsie_len = strlen(vsie);
+ if (vsie_len == 0) {
+ WDP_LOGE("vsie length is zero");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ bytearray_len = (vsie_len % 2) ? ((vsie_len / 2) + 1) : (vsie_len / 2);
+
+ bytearray = (unsigned char *) g_try_malloc0(bytearray_len);
+ if (bytearray == NULL) {
+ WDP_LOGE("Failed to allocate memory to bytearray");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ if (__ws_hex_str_to_bin(vsie, bytearray, bytearray_len) < 0) {
+ WDP_LOGE("invalid vsie string");
+ g_free(bytearray);
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
+ dbus_set_method_param(¶ms, "VendorElemAdd", g_pd->iface_path,
+ g_dbus);
+
+ bytearray_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < bytearray_len; i++)
+ g_variant_builder_add(bytearray_builder, "y", bytearray[i]);
+
+ value = g_variant_new("(iay)", frame_id, bytearray_builder);
+ g_variant_builder_unref(bytearray_builder);
+
+ params.params = value;
+
+ res = dbus_method_call(¶ms, SUPPLICANT_IFACE, NULL, NULL);
+ if (res < 0) {
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ g_free(bytearray);
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ WDP_LOGD("Succeeded to add vsie: Frame ID [%d], VSIE [%s]", frame_id,
+ vsie);
+
+ g_free(bytearray);
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
+
+int ws_get_vsie(wfd_oem_vsie_frames_e frame_id, char **vsie)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *g_dbus = NULL;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+ GError *error = NULL;
+
+ if (frame_id >= WFD_OEM_VSIE_FRAME_MAX ||
+ vsie == NULL) {
+ WDP_LOGE("Invalid parameter");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ 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;
+ }
+
+ param = g_variant_new("(i)", frame_id);
+
+ reply = g_dbus_connection_call_sync(
+ g_pd->g_dbus,
+ SUPPLICANT_SERVICE, /* bus name */
+ g_pd->iface_path, /* object path */
+ SUPPLICANT_IFACE, /* interface name */
+ "VendorElemGet", /* method name */
+ param, /* 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 get vsie: [%s]", error->message);
+ g_error_free(error);
+ if (reply)
+ g_variant_unref(reply);
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ if (reply != NULL) {
+ DEBUG_G_VARIANT("Reply : ", reply);
+
+ GVariantIter *iter = NULL;
+ unsigned char *vsie_bytes = NULL;
+ int vsie_len = 0;
+
+ g_variant_get(reply, "(ay)", &iter);
+ if (iter == NULL) {
+ WDP_LOGD("vsie is not present");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ vsie_len = __ws_unpack_ay_malloc(&vsie_bytes, iter);
+ if (vsie_bytes == NULL) {
+ WDP_LOGD("vsie_bytes not allocated");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ __ws_byte_to_txt(vsie_bytes, vsie, vsie_len);
+ if (!vsie) {
+ g_free(vsie_bytes);
+ WDP_LOGE("vsie not allocated.");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ g_free(vsie_bytes);
+ }
+
+ WDP_LOGD("Succeeded to get vsie: Frame ID [%d], VSIE [%s]", frame_id,
+ *vsie);
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
+
+int ws_remove_vsie(wfd_oem_vsie_frames_e frame_id, const char *vsie)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *g_dbus = NULL;
+ GVariantBuilder *bytearray_builder = NULL;
+ GVariant *value = NULL;
+ dbus_method_param_s params;
+ int res = 0;
+ int i = 0;
+ size_t vsie_len = 0;
+
+ unsigned char *bytearray = NULL;
+ size_t bytearray_len = 0;
+
+ if (frame_id >= WFD_OEM_VSIE_FRAME_MAX ||
+ vsie == NULL) {
+ WDP_LOGE("Invalid parameter");
+ return -1;
+ }
+
+ 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;
+ }
+
+ vsie_len = strlen(vsie);
+ if (vsie_len == 0) {
+ WDP_LOGE("vsie length is zero");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ bytearray_len = (vsie_len % 2) ? ((vsie_len / 2) + 1) : (vsie_len / 2);
+
+ bytearray = (unsigned char *) g_try_malloc0(bytearray_len);
+ if (bytearray == NULL) {
+ WDP_LOGE("Failed to allocate memory to bytearray");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ if (__ws_hex_str_to_bin(vsie, bytearray, bytearray_len) < 0) {
+ WDP_LOGE("invalid vsie string");
+ g_free(bytearray);
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
+ dbus_set_method_param(¶ms, "VendorElemRem", g_pd->iface_path,
+ g_dbus);
+
+ bytearray_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < bytearray_len; i++)
+ g_variant_builder_add(bytearray_builder, "y", bytearray[i]);
+
+ value = g_variant_new("(iay)", frame_id, bytearray_builder);
+ g_variant_builder_unref(bytearray_builder);
+
+ params.params = value;
+
+ res = dbus_method_call(¶ms, SUPPLICANT_IFACE, NULL, NULL);
+ if (res < 0) {
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ g_free(bytearray);
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ WDP_LOGD("Succeeded to remove vsie: Frame ID [%d], VSIE [%s]", frame_id,
+ vsie);
+ g_free(bytearray);
+ __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