#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,
-#endif /* TIZEN_FEATURE_ASP */
- };
+ .asp_prov_disc_req = ws_asp_prov_disc_req,
-static ws_dbus_plugin_data_s *g_pd;
+ .set_eapol_ip_config = ws_set_eapol_ip_config,
-#ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
-static GList *service_list;
-#endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
+ .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,
-static GList *seek_list;
+ .get_supported_channels = ws_get_supported_channels,
-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);
+ .extra_data = NULL
+};
-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 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;
-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 GList *service_list;
+static GList *seek_list;
static int __ws_txt_to_mac(unsigned char *txt, unsigned char *mac)
{
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");
return -1;
}
- while (g_variant_iter_loop (iter, "y", &dst[length])) {
+ while (g_variant_iter_loop(iter, "y", &dst[length])) {
length++;
- if(length >= size)
+ if (length >= size)
break;
}
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 )
+ wfd_oem_display_s* display)
{
__WDP_LOG_FUNC_ENTER__;
WDP_LOGD("type [%d],availability [%d],hdcp_support [%d],ctrl_port [%d] "
"max_tput[%d]", display->type, display->availability,
- display->hdcp_support, display->port,display->max_tput);
+ display->hdcp_support, display->port, display->max_tput);
__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_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__;
wfd_oem_device_s *peer = (wfd_oem_device_s *)user_data;
- if(!peer) {
+ if (!peer) {
__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, "PrimaryDeviceType") == 0) {
unsigned char primarydevicetype[WS_DEVTYPE_LEN] = {0,};
- if(__ws_unpack_ay(primarydevicetype, value, WS_DEVTYPE_LEN)) {
+ if (__ws_unpack_ay(primarydevicetype, value, WS_DEVTYPE_LEN)) {
peer->pri_dev_type = primarydevicetype[1];
peer->sec_dev_type = primarydevicetype[WS_DEVTYPE_LEN -1];
}
} 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))
+ 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 (__ws_unpack_ay(peer->go_dev_addr, value, WS_MACADDR_LEN))
WDP_LOGD("GODevice address [" MACSTR "]", MAC2STR(peer->go_dev_addr));
- if(!ISZEROMACADDR(peer->go_dev_addr))
+ if (!ISZEROMACADDR(peer->go_dev_addr))
peer->dev_role = WFD_OEM_DEV_ROLE_GC;
-#if defined(TIZEN_FEATURE_ASP)
- } else if (g_strcmp0(key, "AdvertiseService") == 0) {
- //TODO : parsing AdvertiseService
-#endif /* TIZEN_FEATURE_ASP */
+
+ } else if (g_strcmp0(key, "VSIE") == 0) {
+ int vsie_len;
+ unsigned char vsie[OEM_VSIE_MAX_LEN] = {0,};
+
+ vsie_len = __ws_unpack_ay(vsie, value, OEM_VSIE_MAX_LEN);
+ if (vsie_len > 0) {
+ __ws_byte_to_txt(vsie, (char **)&(peer->vsie), vsie_len);
+ WDP_LOGD("VSIE [%s]", peer->vsie);
+ }
+
} else {
WDP_LOGD("Unknown value");
}
static void __ws_peer_property(const char *key, GVariant *value, void *user_data)
{
__WDP_LOG_FUNC_ENTER__;
- if(!user_data) {
+ if (!user_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
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))
+ 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 (__ws_unpack_ay(go_dev_addr, value, WS_MACADDR_LEN))
WDP_LOGD("[" MACSTR "]", MAC2STR(go_dev_addr));
- if(!ISZEROMACADDR(go_dev_addr))
+ 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) {
- //TODO : parsing AdvertiseService
-#endif /* TIZEN_FEATURE_ASP */
+ if (value != NULL && g_variant_get_size(value) != 0)
+ peer->has_asp_services = 1;
+ else
+ peer->has_asp_services = 0;
+
+ } else if (g_strcmp0(key, "AdvertiseASPService") == 0) {
+ if (value != NULL && g_variant_get_size(value) != 0)
+ peer->has_asp2_services = 1;
+ else
+ peer->has_asp2_services = 0;
+
+ } else if (g_strcmp0(key, "VSIE") == 0) {
+ int vsie_len;
+ unsigned char vsie[OEM_VSIE_MAX_LEN] = {0,};
+
+ vsie_len = __ws_unpack_ay(vsie, value, OEM_VSIE_MAX_LEN);
+ if (vsie_len > 0) {
+ __ws_byte_to_txt(vsie, (char **)&(peer->vsie), vsie_len);
+ WDP_LOGD("VSIE [%s]", peer->vsie);
+ }
+
} else {
WDP_LOGD("Unknown value");
}
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
- if(!event)
+ 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;
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
- if(!event || !event->edata)
+ if (!event || !event->edata)
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;
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
- if(!event || !event->edata)
+ if (!event || !event->edata)
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;
- }
-
-#ifdef TIZEN_FEATURE_IP_OVER_EAPOL
- wfd_oem_group_data_s *group = (wfd_oem_group_data_s *)event->edata;
-#endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
-#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(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);
- } else if (g_strcmp0(key, "role") == 0) {
- const char *role = NULL;
+ GVariantIter *iter;
+ gboolean iter_res = TRUE;
+ const char *path = NULL;
+ int i = 0;
- g_variant_get(value, "&s", &role);
- WDP_LOGD("Role [%s]", role);
+ g_variant_get(parameter, "(&oay)", &path, &iter);
+ g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
+ WDP_LOGD("Retrive Added path [%s]", peer_path);
- 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;
-#ifdef TIZEN_FEATURE_IP_OVER_EAPOL
- } else if (g_strcmp0(key, "IpAddr") == 0) {
+ __extract_addr_from_path(peer_path, dev_addr);
- if (__ws_unpack_ay(group->ip_addr, value, OEM_IPADDR_LEN))
- WDP_LOGD("IP address [" IPSTR "]", IP2STR(group->ip_addr));
+ for (i = 0; iter_res && i < OEM_IPADDR_LEN; i++)
+ iter_res = g_variant_iter_loop(iter, "y", &ip_addr[i]);
+ g_variant_iter_free(iter);
- } else if (g_strcmp0(key, "IpAddrMask") == 0) {
+ WDP_LOGD("peer ip [" IPSTR "]", IP2STR(ip_addr));
- if (__ws_unpack_ay(group->ip_addr_mask, value, OEM_IPADDR_LEN))
- WDP_LOGD("IP mask [" IPSTR "]", IP2STR(group->ip_addr_mask));
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+}
- } else if (g_strcmp0(key, "IpAddrGo") == 0) {
+static gboolean __is_valid_plugin(void)
+{
+ gboolean is_valid = (g_pd && g_pd->callback);
- 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;
+ if (!is_valid)
+ WDP_LOGD("Ignoring event");
- 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);
+ return is_valid;
+}
- 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);
+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);
}
- __WDP_LOG_FUNC_EXIT__;
- return;
+
+ return dev_data;
}
-void __ws_extract_gonegfailaure_details(const char *key, GVariant *value, void *user_data)
+static void __set_event_data(int event_id, int edata_type, void *data, wfd_oem_event_s *event)
{
- __WDP_LOG_FUNC_ENTER__;
- wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
- if(!event || !event->edata)
+ if (!event)
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);
+ memset(event, 0x0, sizeof(wfd_oem_event_s));
- } else if (g_strcmp0(key, "status") == 0) {
- int status = 0;
+ event->edata = data;
+ event->edata_type = edata_type;
+ event->event_id = event_id;
- g_variant_get(value, "i", &status);
- WDP_LOGD("Retrive status [%d]", status);
- conn->status = status;
- }
- __WDP_LOG_FUNC_EXIT__;
return;
}
-void __ws_extract_gonegsuccess_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 *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) {
+ if (dev_data->vsie)
+ g_free(dev_data->vsie);
+ g_free(dev_data);
+}
+
+static void _ws_process_peer_joined(GDBusConnection *connection,
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ wfd_oem_event_s event;
+ wfd_oem_dev_data_s *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);
+
+ } 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);
+ WDP_LOGD("Retrive status [%d]", status);
+ conn->status = status;
+ }
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+}
+
+void __ws_extract_gonegsuccess_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 *edata = (wfd_oem_conn_data_s *)event->edata;
+
+ CHECK_KEY_VALUE(key, value);
+
+ if (g_strcmp0(key, "peer_object") == 0) {
+
+ } else if (g_strcmp0(key, "status") == 0) {
} else if (g_strcmp0(key, "passphrase") == 0) {
} else if (g_strcmp0(key, "role_go") == 0) {
- //local device role
+ /* local device role */
const char *role = NULL;
g_variant_get(value, "&s", &role);
} else if (g_strcmp0(key, "peer_device_addr") == 0) {
- if(__ws_unpack_ay(edata->peer_device_addr, value, WS_MACADDR_LEN))
+ if (__ws_unpack_ay(edata->peer_device_addr, value, WS_MACADDR_LEN))
WDP_LOGD("Device address[" MACSTR "]", MAC2STR(edata->peer_device_addr));
- } else if(g_strcmp0(key, "peer_interface_addr") == 0) {
+ } else if (g_strcmp0(key, "peer_interface_addr") == 0) {
- if(__ws_unpack_ay(edata->peer_intf_addr, value, WS_MACADDR_LEN))
+ if (__ws_unpack_ay(edata->peer_intf_addr, value, WS_MACADDR_LEN))
WDP_LOGD("Interface address [" MACSTR "]", MAC2STR(edata->peer_intf_addr));
} else if (g_strcmp0(key, "wps_method") == 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;
int length = 0;
int res = 0;
- while(ptr + 2 < WS_MAX_SERVICE_LEN &&
+ while (ptr + 2 < WS_MAX_SERVICE_LEN &&
(length = (service_hex[ptr+1]*256) + service_hex[ptr]) > 0) {
segment = (char*) g_try_malloc0(length*2+1);
- if(segment) {
+ if (segment) {
__ws_byte_to_hex(segment, length * 2 + 1, &service_hex[ptr + 3], length);
res = __ws_segment_to_service(segment, &new_service);
if (res < 0) {
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
- if(!event)
+ 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;
char *loc = NULL;
g_variant_get(value, "&o", &path);
- if(path == NULL)
+ if (path == NULL)
return;
WDP_LOGD("Retrive Added path [%s]", path);
- loc = strrchr(path,'/');
- if(loc != NULL)
+ loc = strrchr(path, '/');
+ if (loc != 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;
}
memset(service_hex, 0x0, WS_MAX_SERVICE_LEN);
- while (g_variant_iter_loop (iter, "y", &service_hex[byte_length]))
+ while (g_variant_iter_loop(iter, "y", &service_hex[byte_length]))
byte_length++;
g_variant_iter_free(iter);
__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__;
wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
- if(!event || !event->edata)
+ if (!event || !event->edata)
return;
wfd_oem_asp_service_s *service = (wfd_oem_asp_service_s *)event->edata;
const char *path = NULL;
char *loc = NULL;
- g_variant_get(value, "o", &path);
- if(path == NULL)
+ g_variant_get(value, "&o", &path);
+ if (path == NULL)
return;
WDP_LOGD("Retrive Added path [%s]", path);
- loc = strrchr(path,'/');
- if(loc != NULL)
+ loc = strrchr(path, '/');
+ if (loc != NULL)
__ws_mac_compact_to_normal(loc + 1, peer_dev);
__ws_txt_to_mac(peer_dev, event->dev_addr);
} else if (g_strcmp0(key, "svc_str") == 0) {
const char *svc_str = NULL;
- g_variant_get(value, "s", &svc_str);
- if(svc_str != NULL)
- service->service_name = g_strdup(svc_str);
- WDP_LOGD("Retrive srv_name [%s]", service->service_name);
+ 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);
- if(info != NULL)
+ 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 void __ws_extract_asp_provision_start_details(const char *key, GVariant *value, void *user_data)
{
__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");
+ wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
+ wfd_oem_asp_prov_s *asp_params = NULL;
+ if (!event || !event->edata) {
__WDP_LOG_FUNC_EXIT__;
- return -1;
+ return;
}
- 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));
+ asp_params = (wfd_oem_asp_prov_s *)event->edata;
- dbus_set_method_param(¶ms, "Flush", g_pd->iface_path, g_dbus);
- params.params = NULL;
+ if (g_strcmp0(key, "peer_object") == 0) {
+ static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
+ const char *path = NULL;
+ char *loc = NULL;
- res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
- if (res < 0)
- WDP_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to flush");
+ g_variant_get(value, "&o", &path);
+ if (path == NULL) {
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
- __WDP_LOG_FUNC_EXIT__;
- return 0;
-}
+ WDP_LOGD("Retrive Added path [%s]", path);
+ loc = strrchr(path, '/');
+ if (loc != NULL)
+ __ws_mac_compact_to_normal(loc + 1, peer_dev);
+ __ws_txt_to_mac(peer_dev, event->dev_addr);
-static int _ws_cancel()
-{
- __WDP_LOG_FUNC_ENTER__;
- GDBusConnection *g_dbus = NULL;
- dbus_method_param_s params;
- int res = 0;
+ } else if (g_strcmp0(key, "adv_id") == 0) {
+ g_variant_get(value, "u", &asp_params->adv_id);
+ WDP_LOGD("Retrive adv_id [%u]", asp_params->adv_id);
- if (!g_pd) {
- WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
- return -1;
- }
+ } else if (g_strcmp0(key, "ses_id") == 0) {
+ g_variant_get(value, "u", &asp_params->session_id);
+ WDP_LOGD("Retrive session id [%u]", asp_params->session_id);
+ } else if (g_strcmp0(key, "dev_passwd_id") == 0) {
+ g_variant_get(value, "i", &event->wps_mode);
+ WDP_LOGD("Retrive dev_passwd_id [%d]", event->wps_mode);
- g_dbus = g_pd->g_dbus;
- if (!g_dbus) {
- WDP_LOGE("DBus connection is NULL");
- return -1;
- }
- memset(¶ms, 0x0, sizeof(dbus_method_param_s));
+ } else if (g_strcmp0(key, "conncap") == 0) {
+ g_variant_get(value, "u", &asp_params->network_role);
+ WDP_LOGD("Retrive conncap [%x]", asp_params->network_role);
- dbus_set_method_param(¶ms, "Cancel", g_pd->iface_path , g_dbus);
- params.params = NULL;
+ } else if (g_strcmp0(key, "adv_mac") == 0) {
+ if (__ws_unpack_ay(asp_params->service_mac, value, WS_MACADDR_LEN))
+ WDP_LOGD("Adv address[" MACSTR "]", MAC2STR(asp_params->service_mac));
- res = dbus_method_call(¶ms, SUPPLICANT_WPS, NULL, NULL);
- if (res < 0)
- WDP_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to cancel");
+ } else if (g_strcmp0(key, "ses_mac") == 0) {
+ if (__ws_unpack_ay(asp_params->session_mac, value, WS_MACADDR_LEN))
+ WDP_LOGD("session address[" MACSTR "]", MAC2STR(asp_params->session_mac));
+ } else if (g_strcmp0(key, "session_info") == 0) {
+ const char *session_info = NULL;
+ g_variant_get(value, "&s", &session_info);
+ if (session_info != NULL)
+ asp_params->session_information = g_strdup(session_info);
+ WDP_LOGD("Retrive session_info [%s]", asp_params->session_information);
+ }
__WDP_LOG_FUNC_EXIT__;
- return 0;
}
-static void _ws_process_device_found(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+static void __ws_extract_asp_provision_done_details(const char *key, GVariant *value, void *user_data)
{
__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',};
-
- 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));
+ wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
+ wfd_oem_asp_prov_s *asp_params = NULL;
+ if (!event || !event->edata) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_PEER_FOUND;
+ asp_params = (wfd_oem_asp_prov_s *)event->edata;
- __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);
+ if (g_strcmp0(key, "peer_object") == 0) {
+ static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
+ const char *path = NULL;
+ char *loc = NULL;
- g_pd->callback(g_pd->user_data, &event);
- g_free(event.edata);
-
- __WDP_LOG_FUNC_EXIT__;
-}
+ g_variant_get(value, "&o", &path);
+ if (path == NULL) {
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
-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',};
+ WDP_LOGD("Retrive Added path [%s]", path);
+ loc = strrchr(path, '/');
+ if (loc != NULL)
+ __ws_mac_compact_to_normal(loc + 1, peer_dev);
+ __ws_txt_to_mac(peer_dev, event->dev_addr);
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
+ WDP_LOGD("peer address[" MACSTR "]", MAC2STR(event->dev_addr));
- event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
- event.event_id = WFD_OEM_EVENT_PEER_DISAPPEARED;
+ } else if (g_strcmp0(key, "adv_id") == 0) {
+ g_variant_get(value, "u", &asp_params->adv_id);
+ WDP_LOGD("Retrive adv_id [%u]", asp_params->adv_id);
- __ws_path_to_addr(peer_path, event.dev_addr, parameters);
+ } else if (g_strcmp0(key, "ses_id") == 0) {
+ g_variant_get(value, "u", &asp_params->session_id);
+ WDP_LOGD("Retrive session id [%u]", asp_params->session_id);
- g_pd->callback(g_pd->user_data, &event);
+ } else if (g_strcmp0(key, "dev_passwd_id") == 0) {
+ g_variant_get(value, "i", &event->wps_mode);
+ WDP_LOGD("Retrive dev_passwd_id [%d]", event->wps_mode);
- __WDP_LOG_FUNC_EXIT__;
-}
+ } else if (g_strcmp0(key, "conncap") == 0) {
+ g_variant_get(value, "u", &asp_params->network_role);
+ WDP_LOGD("Retrive network role [%x]", asp_params->network_role);
-static void _ws_process_find_stoppped(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
-{
- __WDP_LOG_FUNC_ENTER__;
- wfd_oem_event_s event;
+ } else if (g_strcmp0(key, "status") == 0) {
+ g_variant_get(value, "u", &asp_params->status);
+ WDP_LOGD("Retrive status [%x]", asp_params->status);
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
+ } else if (g_strcmp0(key, "persist") == 0) {
+ g_variant_get(value, "u", &asp_params->persistent_group_id);
+ asp_params->persist = 1;
+ WDP_LOGD("Retrive persist [%u]", asp_params->persistent_group_id);
- event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
- event.event_id = WFD_OEM_EVENT_DISCOVERY_FINISHED;
+ } else if (g_strcmp0(key, "adv_mac") == 0) {
+ if (__ws_unpack_ay(asp_params->service_mac, value, WS_MACADDR_LEN))
+ WDP_LOGD("Adv address[" MACSTR "]", MAC2STR(asp_params->service_mac));
- g_pd->callback(g_pd->user_data, &event);
+ } else if (g_strcmp0(key, "ses_mac") == 0) {
+ if (__ws_unpack_ay(asp_params->session_mac, value, WS_MACADDR_LEN))
+ WDP_LOGD("session address[" MACSTR "]", MAC2STR(asp_params->session_mac));
+ } else if (g_strcmp0(key, "group_mac") == 0) {
+ if (__ws_unpack_ay(asp_params->group_mac, value, WS_MACADDR_LEN))
+ WDP_LOGD("group address[" MACSTR "]", MAC2STR(asp_params->group_mac));
+ }
__WDP_LOG_FUNC_EXIT__;
}
-static void _ws_process_prov_disc_req_display_pin(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+static void __ws_extract_provision_fail_details(const char *key, GVariant *value, void *user_data)
{
__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',};
- 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));
+ wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
+ wfd_oem_asp_prov_s *asp_params = NULL;
+ if (!event || !event->edata) {
__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;
- event.wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
+ asp_params = (wfd_oem_asp_prov_s *)event->edata;
- 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);
+ if (g_strcmp0(key, "peer_object") == 0) {
+ static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
+ const char *path = NULL;
+ char *loc = NULL;
- 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));
+ g_variant_get(value, "&o", &path);
+ if (path == NULL) {
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
- g_strlcpy(event.wps_pin, pin, WS_PINSTR_LEN + 1);
- WDP_LOGD("Retrive pin [%s]", event.wps_pin);
+ WDP_LOGD("Retrive Added path [%s]", path);
+ loc = strrchr(path, '/');
+ if (loc != NULL)
+ __ws_mac_compact_to_normal(loc + 1, peer_dev);
+ __ws_txt_to_mac(peer_dev, event->dev_addr);
- dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
- __ws_peer_property, event.edata);
+ } else if (g_strcmp0(key, "adv_id") == 0) {
+ g_variant_get(value, "u", &asp_params->adv_id);
+ WDP_LOGD("Retrive adv_id [%d]", asp_params->adv_id);
- g_pd->callback(g_pd->user_data, &event);
- g_free(event.edata);
+ } else if (g_strcmp0(key, "status") == 0) {
+ g_variant_get(value, "i", &asp_params->status);
+ WDP_LOGD("Retrive status [%d]", asp_params->status);
+ } else if (g_strcmp0(key, "deferred_session_resp") == 0) {
+ const char *session_info = NULL;
+ g_variant_get(value, "&s", &session_info);
+ if (session_info != NULL)
+ asp_params->session_information = g_strdup(session_info);
+ WDP_LOGD("Retrive deferred_session_resp [%s]", asp_params->session_information);
+ }
__WDP_LOG_FUNC_EXIT__;
}
-static void _ws_process_prov_disc_resp_display_pin(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+static int _ws_flush(void)
{
__WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *g_dbus = NULL;
+ dbus_method_param_s params;
+ int res = 0;
- wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = 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));
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
__WDP_LOG_FUNC_EXIT__;
- return;
+ 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_PROV_DISC_RESP;
- 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));
- g_strlcpy(event.wps_pin, pin, WS_PINSTR_LEN + 1);
- WDP_LOGD("Retrive pin [%s]", event.wps_pin);
+ 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_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
- __ws_peer_property, event.edata);
+ dbus_set_method_param(¶ms, "Flush", g_pd->iface_path, g_dbus);
+ params.params = NULL;
- g_pd->callback(g_pd->user_data, &event);
- g_free(event.edata);
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to flush");
__WDP_LOG_FUNC_EXIT__;
+ return 0;
}
-static void _ws_process_prov_disc_req_enter_pin(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+static int _ws_cancel(void)
{
__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;
+ dbus_method_param_s params;
+ 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));
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
__WDP_LOG_FUNC_EXIT__;
- return;
+ 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_PROV_DISC_REQ;
- event.wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
- __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");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
- __ws_peer_property, event.edata);
+ dbus_set_method_param(¶ms, "Cancel", g_pd->iface_path , g_dbus);
+ params.params = NULL;
- g_pd->callback(g_pd->user_data, &event);
- g_free(event.edata);
+ res = dbus_method_call(¶ms, SUPPLICANT_WPS, NULL, NULL);
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to cancel");
__WDP_LOG_FUNC_EXIT__;
+ return 0;
}
-static void _ws_process_prov_disc_resp_enter_pin(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+int ws_get_advertise_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 *value;
+ 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_PROV_DISC_RESP;
- event.wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
+ g_dbus = g_pd->g_dbus;
+ if (!g_dbus) {
+ WDP_LOGE("DBus connection is NULL");
+ return -1;
+ }
- __ws_path_to_addr(peer_path, event.dev_addr, parameters);
+ param = g_variant_new("(ss)", SUPPLICANT_P2P_PEER, "AdvertiseService");
+ DEBUG_G_VARIANT("Params : ", param);
- dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
- __ws_peer_property, event.edata);
+ 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);
- g_free(event.edata);
+ 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;
+ }
- __WDP_LOG_FUNC_EXIT__;
-}
+ if (reply != NULL) {
+ 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
+ * */
+ 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);
-static void _ws_process_prov_disc_pbc_req(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
-{
- __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',};
+ while (1) {
+ /* 4byte advertisement ID, 2 byte config method, 1byte length */
- 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));
+ cnt = 0;
+ memset(desc, 0x0, 7);
+ while (cnt < 7 && g_variant_iter_loop(iter, "y", &desc[cnt]))
+ cnt++;
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
- event.wps_mode = WFD_OEM_WPS_MODE_PBC;
+ if (cnt != 7 || desc[6] == 0) {
+ WDP_LOGE("Invalid descriptor header length cnt [%d]", cnt);
+ g_variant_unref(reply);
+ return res;
+ }
- __ws_path_to_addr(peer_path, event.dev_addr, parameters);
+ adv_id = desc[3] << 24 | desc[2] << 16 | desc[1] << 8 | desc[0];
+ config_method = desc[4] << 8 | desc[4];
+ length = desc[6];
+ value = NULL;
+ value = g_try_malloc0(length + 1);
+ if (value == 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);
- dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
- __ws_peer_property, event.edata);
+ cnt = 0;
+ while (cnt < length && g_variant_iter_loop(iter, "y", &value[cnt]))
+ cnt++;
- g_pd->callback(g_pd->user_data, &event);
- g_free(event.edata);
+ if (cnt != length) {
+ WDP_LOGE("Length doesn't matched with header value cnt [%d]", cnt);
+ g_variant_unref(reply);
+ g_free(value);
+ 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(value);
+ return res;
+ }
+ service->adv_id = adv_id;
+ service->config_method = config_method;
+ service->service_type_length = length;
+ service->service_type = value;
+
+GLIST_ITER_START(seek_list, seek)
+ if (g_strcmp0(seek->service_type, service->service_type) == 0) {
+ 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_prov_disc_pbc_resp(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_PROV_DISC_RESP;
- event.wps_mode = WFD_OEM_WPS_MODE_PBC;
+ g_dbus = g_pd->g_dbus;
+ if (!g_dbus) {
+ WDP_LOGE("DBus connection is NULL");
+ return -1;
+ }
- __ws_path_to_addr(peer_path, event.dev_addr, parameters);
+ param = g_variant_new("(ss)", SUPPLICANT_P2P_PEER, "AdvertiseASPService");
+ DEBUG_G_VARIANT("Params : ", param);
- dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
- __ws_peer_property, event.edata);
+ 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);
- g_free(event.edata);
+ 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;
+ }
+
+ if (reply != NULL) {
+ 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
+ * */
+ 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 */
+
+ 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_prov_disc_failure(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+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',};
- static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
+ GVariantIter *iter = NULL;
const char *path = NULL;
- int prov_status = 0;
- char *loc = NULL;
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_PROV_DISC_FAIL;
+ 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, "(&oi)", &path, &prov_status);
+ 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);
- 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);
+ __extract_addr_from_path(peer_path, event.dev_addr);
- __WDP_LOG_FUNC_EXIT__;
-}
+ if (iter != NULL) {
+ gchar *key = NULL;
+ GVariant *value = NULL;
-static void _ws_process_group_started(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
-{
- __WDP_LOG_FUNC_ENTER__;
- GVariantIter *iter = NULL;
- wfd_oem_event_s event;
- wfd_oem_group_data_s *edata = NULL;
+ while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
+ CHECK_KEY_VALUE(key, value);
- edata = (wfd_oem_group_data_s*)calloc(1, sizeof(wfd_oem_group_data_s));
- if (!edata) {
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- strerror(errno));
- __WDP_LOG_FUNC_EXIT__;
- return;
+ __ws_peer_property(key, value, (void *)event.edata);
+ }
+ g_variant_iter_free(iter);
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_GROUP;
- event.event_id = WFD_OEM_EVENT_GROUP_CREATED;
+ 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(parameters != NULL){
- g_variant_get(parameters, "(a{sv})", &iter);
+ if (g_pd->callback->peer_found_cb)
+ g_pd->callback->peer_found_cb(&event);
- if (iter != NULL) {
- dbus_property_foreach(iter, __ws_extract_group_details, &event);
- g_variant_iter_free(iter);
+ 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);
}
- } else {
- WDP_LOGE("No properties");
}
- g_pd->callback(g_pd->user_data, &event);
- g_free(event.edata);
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
-static void _ws_process_go_neg_success(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+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__;
- GVariantIter *iter = NULL;
wfd_oem_event_s event;
- wfd_oem_conn_data_s *edata = NULL;
+ static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- edata = (wfd_oem_conn_data_s*)calloc(1, sizeof(wfd_oem_conn_data_s));
- if (!edata) {
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- strerror(errno));
+ 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 = edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_CONN;
- event.event_id = WFD_OEM_EVENT_GO_NEG_DONE;
+ event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
+ event.event_id = WFD_OEM_EVENT_PEER_DISAPPEARED;
- if (parameters != NULL){
- g_variant_get(parameters, "(a{sv})", &iter);
+ __ws_path_to_addr(peer_path, event.dev_addr, parameters);
- if (iter != NULL) {
- dbus_property_foreach(iter, __ws_extract_gonegsuccess_details, &event);
- g_variant_iter_free(iter);
- }
- } else {
- WDP_LOGE("No properties");
- }
+ if (g_pd->callback->peer_disappeared_cb)
+ g_pd->callback->peer_disappeared_cb(&event);
- g_pd->callback(g_pd->user_data, &event);
- g_free(edata);
__WDP_LOG_FUNC_EXIT__;
}
-static void _ws_process_go_neg_failure(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+static void _ws_process_find_stoppped(GDBusConnection *connection,
+ 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;
- edata = (wfd_oem_conn_data_s *) g_try_malloc0(sizeof(wfd_oem_conn_data_s));
- if (!edata) {
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- strerror(errno));
+ 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 = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_GO_NEG_FAIL;
- if (parameters != NULL) {
- g_variant_get(parameters, "(a{sv})", &iter);
+ memset(&event, 0x0, sizeof(wfd_oem_event_s));
- if (iter != NULL) {
- dbus_property_foreach(iter, __ws_extract_gonegfailaure_details, &event);
- g_variant_iter_free(iter);
- }
- } else {
- WDP_LOGE("No properties");
- }
+ event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
+ event.event_id = WFD_OEM_EVENT_DISCOVERY_FINISHED;
- g_pd->callback(g_pd->user_data, &event);
- g_free(event.edata);
+ if (g_pd->callback->discovery_finished_cb)
+ g_pd->callback->discovery_finished_cb(&event);
__WDP_LOG_FUNC_EXIT__;
}
-static void _ws_process_go_neg_request(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+static void _ws_process_prov_disc_req_display_pin(GDBusConnection *connection,
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
const char *path = NULL;
- char * loc = NULL;
+ const char *pin = NULL;
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- int dev_passwd_id = 0;
- int device_go_intent = 0;
+ if (!__is_valid_plugin())
+ return;
- 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));
+ 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_PROV_DISC_REQ,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
+ event.wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
- g_variant_get(parameters, "(&oqy)", &path, &dev_passwd_id, &device_go_intent);
+ 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);
- WDP_LOGD("Retrive peer path [%s]", peer_path);
- WDP_LOGD("Retrive dev_passwd_id [%d]", dev_passwd_id);
- WDP_LOGD("Retrive device_go_intent [%d]", 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;
+ __extract_addr_from_path(peer_path, event.dev_addr);
- 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));
+ 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_invitation_received(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+
+static void _ws_process_prov_disc_resp_display_pin(GDBusConnection *connection,
+ 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;
+ wfd_oem_dev_data_s *dev_data = NULL;
+ static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
+ const char *path = NULL;
+ const char *pin = NULL;
- edata = (wfd_oem_invite_data_s *) g_try_malloc0(sizeof(wfd_oem_invite_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_INVITE;
- event.event_id = WFD_OEM_EVENT_INVITATION_REQ;
+ __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;
- if (parameters != NULL) {
- g_variant_get(parameters, "(a{sv})", &iter);
+ 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);
- if (iter != NULL) {
- dbus_property_foreach(iter, __ws_extract_invitation_details, &event);
- g_variant_iter_free(iter);
- }
- } else {
- WDP_LOGE("No properties");
- }
- memcpy(&(event.dev_addr), edata->sa, OEM_MACADDR_LEN);
+ __extract_addr_from_path(peer_path, event.dev_addr);
- g_pd->callback(g_pd->user_data, &event);
- g_free(event.edata);
+ g_strlcpy(event.wps_pin, pin, WS_PINSTR_LEN + 1);
+ WDP_LOGD("Retrive pin [%s]", event.wps_pin);
- __WDP_LOG_FUNC_EXIT__;
-}
+ dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
+ __ws_peer_property, event.edata);
-static void _ws_process_invitation_result(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
-{
- __WDP_LOG_FUNC_ENTER__;
- wfd_oem_event_s event;
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
+ if (g_pd->callback->prov_disc_resp_cb)
+ g_pd->callback->prov_disc_resp_cb(&event);
-// g_pd->callback(g_pd->user_data, event);
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
-static void _ws_process_group_finished(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+static void _ws_process_prov_disc_req_enter_pin(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',};
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
-
- event.event_id = WFD_OEM_EVENT_GROUP_DESTROYED;
- event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
+ if (!__is_valid_plugin())
+ return;
- g_dbus_connection_signal_unsubscribe(g_pd->g_dbus, g_pd->group_sub_id);
- memset(g_pd->group_iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
- _ws_flush();
+ dev_data = __create_dev_data();
+ if (!dev_data) {
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
+ __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);
- g_pd->callback(g_pd->user_data, &event);
+ dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
+ __ws_peer_property, 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__;
}
-#ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
-static void _ws_process_service_discovery_response(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+static void _ws_process_prov_disc_resp_enter_pin(GDBusConnection *connection,
+ 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_dev_data_s *dev_data = NULL;
+ static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- event.event_id = WFD_OEM_EVENT_SERV_DISC_RESP;
+ if (!__is_valid_plugin())
+ return;
- if(parameters != NULL) {
- g_variant_get(parameters, "(a{sv})", &iter);
- if(iter != NULL) {
- dbus_property_foreach(iter, __ws_extract_servicediscoveryresponse_details, &event);
- event.edata_type = WFD_OEM_EDATA_TYPE_NEW_SERVICE;
- g_variant_iter_free(iter);
- }
- } else {
- WDP_LOGE("No Properties");
+ dev_data = __create_dev_data();
+ if (!dev_data) {
+ __WDP_LOG_FUNC_EXIT__;
+ return;
}
- g_pd->callback(g_pd->user_data, &event);
+ __set_event_data(WFD_OEM_EVENT_PROV_DISC_RESP,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
- if (event.edata_type == WFD_OEM_EDATA_TYPE_NEW_SERVICE)
- g_list_free((GList*) event.edata);
+ 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);
+
+ 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__;
}
-#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)
+static void _ws_process_prov_disc_pbc_req(GDBusConnection *connection,
+ 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_dev_data_s *dev_data = NULL;
+ static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- service = (wfd_oem_asp_service_s *) g_try_malloc0(sizeof(wfd_oem_asp_service_s));
- if (!service) {
- 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));
+ __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;
- event.edata = (void*) service;
- event.edata_type = WFD_OEM_EDATA_TYPE_ASP_SERVICE;
- event.event_id = WFD_OEM_EVENT_ASP_SERV_RESP;
+ __ws_path_to_addr(peer_path, event.dev_addr, parameters);
- if(parameters != NULL) {
- g_variant_get(parameters, "(a{sv})", &iter);
- if(iter != NULL) {
- dbus_property_foreach(iter, __ws_extract_serviceaspresponse_details, &event);
- g_variant_iter_free(iter);
- }
- } else {
- WDP_LOGE("No Properties");
- }
-GLIST_ITER_START(seek_list, tmp)
- if(tmp->tran_id == service->tran_id) {
- WDP_LOGD("srv_trans_id matched [%d] search_id [%llu]"
- ,tmp->tran_id, tmp->search_id);
- service->search_id = tmp->search_id;
- break;
- } else {
- tmp = NULL;
- }
-GLIST_ITER_END()
- g_pd->callback(g_pd->user_data, &event);
+ dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
+ __ws_peer_property, event.edata);
- g_free(service->service_name);
- g_free(service->service_info);
- g_free(service);
+ 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__;
}
-#endif /* TIZEN_FEATURE_ASP */
-static void _ws_process_persistent_group_added(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+static void _ws_process_prov_disc_pbc_resp(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;
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
+ 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_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);
+ 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_persistent_group_removed(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+static void _ws_process_prov_disc_failure(GDBusConnection *connection,
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
{
__WDP_LOG_FUNC_ENTER__;
+ 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]",
+ error_buf);
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
memset(&event, 0x0, sizeof(wfd_oem_event_s));
-// g_pd->callback(g_pd->user_data, &event);
+ event.edata = (void*) edata;
+ event.event_id = WFD_OEM_EVENT_PROV_DISC_FAIL;
+
+ if (parameters != NULL) {
+ g_variant_get(parameters, "(a{sv})", &iter);
+ if (iter != NULL) {
+ dbus_property_foreach(iter, __ws_extract_provision_fail_details, &event);
+ event.edata_type = WFD_OEM_EDATA_TYPE_ASP_PROV;
+ g_variant_iter_free(iter);
+ }
+ } else {
+ WDP_LOGE("No Properties");
+ }
+
+ 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);
+ g_free(edata);
__WDP_LOG_FUNC_EXIT__;
}
-static void _ws_process_wps_failed(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+static void _ws_process_group_started(GDBusConnection *connection,
+ 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;
-
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
+ wfd_oem_group_data_s *edata = NULL;
- event.event_id = WFD_OEM_EVENT_WPS_FAIL;
- event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
+ DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- g_variant_get(parameters, "(&sa{sv})", &name, &iter);
+ if (!g_pd || !g_pd->callback) {
+ WDP_LOGD("Ignoring event");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
- WDP_LOGD("code [%s]", name);
+ 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]",
+ error_buf);
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+ memset(&event, 0x0, sizeof(wfd_oem_event_s));
- if (iter != NULL) {
+ event.edata = (void*) edata;
+ event.edata_type = WFD_OEM_EDATA_TYPE_GROUP;
+ event.event_id = WFD_OEM_EVENT_GROUP_CREATED;
- gchar *key = NULL;
- GVariant *value = NULL;
+ if (parameters != NULL) {
+ g_variant_get(parameters, "(a{sv})", &iter);
- 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 (iter != NULL) {
+ dbus_property_foreach(iter, __ws_extract_group_details, &event);
+ g_variant_iter_free(iter);
}
- g_variant_iter_free(iter);
+ } else {
+ 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_group_formation_failure(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+static void _ws_process_go_neg_success(GDBusConnection *connection,
+ 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]",
+ error_buf);
+ __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;
+ event.edata = edata;
+ event.edata_type = WFD_OEM_EDATA_TYPE_CONN;
+ event.event_id = WFD_OEM_EVENT_GO_NEG_DONE;
+
+ if (parameters != NULL) {
+ g_variant_get(parameters, "(a{sv})", &iter);
+
+ if (iter != NULL) {
+ dbus_property_foreach(iter, __ws_extract_gonegsuccess_details, &event);
+ g_variant_iter_free(iter);
+ }
+ } else {
+ WDP_LOGE("No properties");
+ }
+
+ if (g_pd->callback->go_neg_done_cb)
+ g_pd->callback->go_neg_done_cb(&event);
- g_pd->callback(g_pd->user_data, &event);
+ g_free(edata);
__WDP_LOG_FUNC_EXIT__;
}
-static void _ws_process_invitation_accepted(GDBusConnection *connection,
- const gchar *object_path, GVariant *parameters)
+static void _ws_process_go_neg_failure(GDBusConnection *connection,
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
{
__WDP_LOG_FUNC_ENTER__;
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]",
+ error_buf);
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
memset(&event, 0x0, sizeof(wfd_oem_event_s));
- event.event_id = WFD_OEM_EVENT_INVITATION_ACCEPTED;
- event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
+ event.edata = (void*) edata;
+ event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
+ event.event_id = WFD_OEM_EVENT_GO_NEG_FAIL;
if (parameters != NULL) {
g_variant_get(parameters, "(a{sv})", &iter);
if (iter != NULL) {
- gchar *key = NULL;
- GVariant *value = NULL;
-
- 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));
- }
+ dbus_property_foreach(iter, __ws_extract_gonegfailaure_details, &event);
g_variant_iter_free(iter);
}
+ } else {
+ 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 struct {
- const char *interface;
- const char *member;
- void (*function) (GDBusConnection *connection,const gchar *object_path,
- GVariant *parameters);
-} ws_p2pdevice_signal_map[] = {
- {
- SUPPLICANT_P2PDEVICE,
- "DeviceFound",
- _ws_process_device_found
- },
- {
- SUPPLICANT_P2PDEVICE,
- "DeviceLost",
- _ws_process_device_lost
+static void __set_wps_mode_for_event(int dev_passwd_id, wfd_oem_event_s *event)
+{
+ if (!event)
+ return;
+
+ WDP_LOGD("Retrive dev_passwd_id [%d]", dev_passwd_id);
+
+ if (dev_passwd_id == WS_DEV_PASSWD_ID_PUSH_BUTTON)
+ event->wps_mode = WFD_OEM_WPS_MODE_PBC;
+ else if (dev_passwd_id == WS_DEV_PASSWD_ID_REGISTRAR_SPECIFIED)
+ event->wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
+ else if (dev_passwd_id == WS_DEV_PASSWD_ID_USER_SPECIFIED)
+ event->wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
+ else
+ event->wps_mode = WFD_OEM_WPS_MODE_NONE;
+}
+
+static void _ws_process_go_neg_request(GDBusConnection *connection,
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ wfd_oem_event_s event;
+ wfd_oem_dev_data_s *dev_data = NULL;
+ static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
+ const char *path = NULL;
+ int dev_passwd_id = 0;
+ int device_go_intent = 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_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);
+ __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;
+
+ __extract_addr_from_path(peer_path, event.dev_addr);
+
+ dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
+ __ws_peer_property, event.edata);
+
+ if (g_pd->callback->go_neg_req_cb)
+ g_pd->callback->go_neg_req_cb(&event);
+
+ __destroy_dev_data(dev_data);
+
+ __WDP_LOG_FUNC_EXIT__;
+}
+static void _ws_process_invitation_received(GDBusConnection *connection,
+ 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]",
+ error_buf);
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+ memset(&event, 0x0, sizeof(wfd_oem_event_s));
+
+ event.edata = (void*) edata;
+ event.edata_type = WFD_OEM_EDATA_TYPE_INVITE;
+ event.event_id = WFD_OEM_EVENT_INVITATION_REQ;
+
+ if (parameters != NULL) {
+ g_variant_get(parameters, "(a{sv})", &iter);
+
+ if (iter != NULL) {
+ dbus_property_foreach(iter, __ws_extract_invitation_details, &event);
+ g_variant_iter_free(iter);
+ }
+ } else {
+ WDP_LOGE("No properties");
+ }
+ memcpy(&(event.dev_addr), edata->sa, OEM_MACADDR_LEN);
+
+ 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 *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 *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;
+
+ 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;
+ }
+ memset(g_pd->group_iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
+ _ws_flush();
+
+ if (g_pd->callback->group_destroyed_cb)
+ g_pd->callback->group_destroyed_cb(&event);
+
+ __WDP_LOG_FUNC_EXIT__;
+}
+
+static void _ws_process_service_discovery_response(GDBusConnection *connection,
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
+{
+ __WDP_LOG_FUNC_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;
+
+ if (parameters != NULL) {
+ g_variant_get(parameters, "(a{sv})", &iter);
+ if (iter != NULL) {
+ dbus_property_foreach(iter, __ws_extract_servicediscoveryresponse_details, &event);
+ event.edata_type = WFD_OEM_EDATA_TYPE_NEW_SERVICE;
+ g_variant_iter_free(iter);
+ }
+ } else {
+ WDP_LOGE("No Properties");
+ }
+
+ 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__;
+}
+
+static void _ws_process_service_asp_response(GDBusConnection *connection,
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ GVariantIter *iter = NULL;
+ wfd_oem_event_s event;
+ 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]",
+ error_buf);
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+ memset(&event, 0x0, sizeof(wfd_oem_event_s));
+
+ event.edata = (void*) service;
+ event.edata_type = WFD_OEM_EDATA_TYPE_ASP_SERVICE;
+ event.event_id = WFD_OEM_EVENT_ASP_SERV_RESP;
+
+ if (parameters != NULL) {
+ g_variant_get(parameters, "(a{sv})", &iter);
+ if (iter != NULL) {
+ dbus_property_foreach(iter, __ws_extract_serviceaspresponse_details, &event);
+ g_variant_iter_free(iter);
+ }
+ } else {
+ WDP_LOGE("No Properties");
+ }
+GLIST_ITER_START(seek_list, tmp)
+ if (tmp->tran_id == service->tran_id) {
+ WDP_LOGD("srv_trans_id matched [%d] search_id [%llu]"
+ , tmp->tran_id, tmp->search_id);
+ service->search_id = tmp->search_id;
+ break;
+ } else {
+ tmp = NULL;
+ }
+GLIST_ITER_END()
+
+ 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);
+ g_free(service);
+
+ __WDP_LOG_FUNC_EXIT__;
+}
+
+static void _ws_process_persistent_group_added(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;
+
+ 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 *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 *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;
+ event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
+
+ g_variant_get(parameters, "(&sa{sv})", &name, &iter);
+
+ WDP_LOGD("code [%s]", name);
+
+ if (iter != NULL) {
+
+ gchar *key = NULL;
+ GVariant *value = NULL;
+
+ while (g_variant_iter_loop(iter, "{sv}", &key, &value))
+ CHECK_KEY_VALUE(key, value);
+
+ g_variant_iter_free(iter);
+ }
+
+ 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 *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;
+
+ 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 *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;
+ event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
+
+ if (parameters != NULL) {
+ g_variant_get(parameters, "(a{sv})", &iter);
+
+ if (iter != NULL) {
+ gchar *key = NULL;
+ GVariant *value = NULL;
+
+ 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_variant_iter_free(iter);
+ }
+ }
+
+ if (g_pd->callback->invitation_accepted_cb)
+ g_pd->callback->invitation_accepted_cb(&event);
+
+ __WDP_LOG_FUNC_EXIT__;
+}
+
+static void _ws_process_asp_provision_start(GDBusConnection *connection,
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data)
+{
+ __WDP_LOG_FUNC_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]",
+ error_buf);
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+ memset(&event, 0x0, sizeof(wfd_oem_event_s));
+
+ event.edata = (void*) edata;
+ event.event_id = WFD_OEM_EVENT_ASP_PROV_START;
+
+ if (parameters != NULL) {
+ g_variant_get(parameters, "(a{sv})", &iter);
+ if (iter != NULL) {
+ dbus_property_foreach(iter, __ws_extract_asp_provision_start_details, &event);
+ event.edata_type = WFD_OEM_EDATA_TYPE_ASP_PROV;
+ g_variant_iter_free(iter);
+ }
+ } else {
+ WDP_LOGE("No Properties");
+ }
+
+ 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);
+ g_free(edata);
+
+ __WDP_LOG_FUNC_EXIT__;
+}
+
+static void _ws_process_asp_provision_done(GDBusConnection *connection,
+ 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]",
+ error_buf);
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+ memset(&event, 0x0, sizeof(wfd_oem_event_s));
+
+ event.edata = (void*) edata;
+ event.event_id = WFD_OEM_EVENT_ASP_PROV_DONE;
+
+ if (parameters != NULL) {
+ g_variant_get(parameters, "(a{sv})", &iter);
+ if (iter != NULL) {
+ dbus_property_foreach(iter, __ws_extract_asp_provision_done_details, &event);
+ event.edata_type = WFD_OEM_EDATA_TYPE_ASP_PROV;
+ g_variant_iter_free(iter);
+ }
+ } else {
+ WDP_LOGE("No Properties");
+ }
+
+ if (g_pd->callback->asp_prov_done_cb)
+ g_pd->callback->asp_prov_done_cb(&event);
+
+ g_free(edata);
+
+ __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_p2pdevice_signal_map[] = {
+ {
+ 0,
+ SUPPLICANT_P2PDEVICE,
+ "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
},
-#endif /* TIZEN_FEATURE_ASP */
{
+ 0,
+ SUPPLICANT_P2PDEVICE,
+ "ASPProvisionStart",
+ _ws_process_asp_provision_start
+ },
+ {
+ 0,
+ SUPPLICANT_P2PDEVICE,
+ "ASPProvisionDone",
+ _ws_process_asp_provision_done
+ },
+ {
+ 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);
+
+ if (!g_pd || !g_pd->callback) {
+ WDP_LOGD("Ignoring event");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
+ if (is_peer_joined_notified) {
+ is_peer_joined_notified = 0;
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
+ memset(&event, 0x0, sizeof(wfd_oem_event_s));
+ g_variant_get(parameters, "(&s)", &mac_str);
+ __ws_txt_to_mac((unsigned char *)mac_str, event.intf_addr);
+
+ event.event_id = WFD_OEM_EVENT_STA_CONNECTED;
+ event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
+
+ 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 *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);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+
+ 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__;
+ return;
+ }
+
+ memset(&event, 0x0, sizeof(wfd_oem_event_s));
+ g_variant_get(parameters, "(&s)", &mac_str);
+ __ws_txt_to_mac((unsigned char *)mac_str, event.intf_addr);
+
+ event.event_id = WFD_OEM_EVENT_STA_DISCONNECTED;
+ event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
+
+ 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 *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data);
+} ws_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 (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
+ pd_data = (ws_dbus_plugin_data_s *)g_pd;
+
+ g_variant_get(value, "(&o)", &path);
+ g_strlcpy(interface_path, path, DBUS_OBJECT_PATH_MAX);
+ g_strlcpy(pd_data->iface_path, path, DBUS_OBJECT_PATH_MAX);
+
+ WDP_LOGD("interface object path [%s]", interface_path);
+
+ /* subscribe Interface iface signal */
+ 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 */
+ 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__;
+}
+
+static int _ws_create_interface(const char *iface_name, handle_reply function, void *user_data)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *g_dbus = NULL;
+ GVariantBuilder *builder = 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, "CreateInterface", SUPPLICANT_PATH, g_dbus);
+
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "Ifname", g_variant_new_string(iface_name));
+ g_variant_builder_add(builder, "{sv}", "ConfigFile", g_variant_new_string(CONF_FILE_PATH));
+ params.params = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
+ res = dbus_method_call(¶ms, SUPPLICANT_INTERFACE, function, user_data);
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to CreateInterface");
+
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
+}
+
+static int _ws_get_interface(const char *iface_name, handle_reply function, void *user_data)
+{
+ __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;
+ }
+
+ dbus_set_method_param(¶ms, SUPPLICANT_METHOD_GETINTERFACE,
+ SUPPLICANT_PATH, g_pd->g_dbus);
+
+ params.params = g_variant_new("(s)", iface_name);
+ DEBUG_G_VARIANT("Params : ", params.params);
+
+ res = dbus_method_call(¶ms, SUPPLICANT_INTERFACE,
+ function, user_data);
+
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to get interface");
+
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
+}
+
+static void __ws_remove_interface(GVariant *value, void *user_data)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *g_dbus = NULL;
+ dbus_method_param_s params;
+ const char *path = NULL;
+ static char interface_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
+ int res = 0;
if (!g_pd) {
WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
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);
+ g_dbus = g_pd->g_dbus;
+ if (!g_dbus) {
+ WDP_LOGE("DBus connection is NULL");
+ return;
}
-}
+ g_variant_get(value, "(&o)", &path);
+ g_strlcpy(interface_path, path, DBUS_OBJECT_PATH_MAX);
+ WDP_LOGD("interface object path [%s]", interface_path);
+
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
-static void __ws_parse_peer_joined(char *peer_path,
- unsigned char *dev_addr, unsigned char *ip_addr, GVariant *parameter)
+ dbus_set_method_param(¶ms, "RemoveInterface", SUPPLICANT_PATH, g_dbus);
+ params.params = g_variant_new("(o)", interface_path);
+
+ res = dbus_method_call(¶ms, SUPPLICANT_INTERFACE, NULL, NULL);
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to RemoveInterface");
+
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+}
+
+static int _ws_init_dbus_connection(void)
{
__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
+ GDBusConnection *conn = NULL;
+ GError *error = NULL;
+ int res = 0;
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);
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
- 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);
+ if (!config) {
+ WDP_LOGE("no configurable data found");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
- WDP_LOGD("peer ip [" IPSTR "]", IP2STR(ip_addr));
-#endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
+ conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
+
+ if (conn == NULL) {
+ if (error != NULL) {
+ WDP_LOGE("Error! Failed to connect to the D-BUS daemon: [%s]",
+ error->message);
+ g_error_free(error);
+ }
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ g_pd->g_dbus = conn;
+
+ 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");
+ else
+ WDP_LOGI("Successfully register signal filters");
__WDP_LOG_FUNC_EXIT__;
- return;
+ return res;
}
-
-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 int _ws_deinit_dbus_connection(void)
{
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ GDBusConnection *g_dbus = NULL;
+ int i = 0;
if (!g_pd) {
- WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
- return;
+ WDP_LOGE("Invalid parameter");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
}
- if (!g_strcmp0(signal,"PeerJoined")) {
+ g_dbus = g_pd->g_dbus;
+ if (!g_dbus) {
+ WDP_LOGE("DBus connection is NULL");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
- wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ 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;
+ }
- static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\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;
+ }
- 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));
+ 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;
+ }
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_STA_CONNECTED;
+ 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;
+ }
- __ws_parse_peer_joined(peer_path, event.dev_addr, event.ip_addr_peer, parameters);
+ memset(g_pd->group_iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
+ memset(g_pd->iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
- dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
- __ws_peer_property, event.edata);
+ g_object_unref(g_dbus);
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
- g_pd->callback(g_pd->user_data, &event);
- g_free(edata);
+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;
+ }
- } else if (!g_strcmp0(signal,"PeerDisconnected")) {
+ *ops = &supplicant_ops;
- wfd_oem_event_s event;
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
- static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
+static int _ws_reset_plugin(ws_dbus_plugin_data_s *f_pd)
+{
+ __WDP_LOG_FUNC_ENTER__;
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
+ if (!f_pd) {
+ WDP_LOGE("Invalid parameter");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ _ws_deinit_dbus_connection();
+
+ if (f_pd->activated)
+ ws_deactivate(f_pd->concurrent);
+
+ g_free(f_pd);
+
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
+
+static int __ws_check_net_interface(char* if_name)
+{
+ struct ifreq ifr;
+ int fd;
+
+ if (if_name == NULL) {
+ WDP_LOGE("Invalid param");
+ return -1;
+ }
+
+ fd = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (fd < 0) {
+ WDP_LOGE("socket create error: %d", fd);
+ return -2;
+ }
- event.edata_type = WFD_OEM_EDATA_TYPE_NONE;
- event.event_id = WFD_OEM_EVENT_STA_DISCONNECTED;
+ memset(&ifr, 0, sizeof(ifr));
+ g_strlcpy(ifr.ifr_name, if_name, IFNAMSIZ);
+
+ if (ioctl(fd, SIOCGIFFLAGS, &ifr) < 0) {
+ close(fd);
+ 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;
+ }
- __ws_path_to_addr(peer_path, event.dev_addr, parameters);
+ close(fd);
- g_pd->callback(g_pd->user_data, &event);
+ if (ifr.ifr_flags & IFF_UP) {
+ WDP_LOGD("%s interface is up", if_name);
+ return 1;
+ } else if (!(ifr.ifr_flags & IFF_UP)) {
+ WDP_LOGD("%s interface is down", if_name);
+ return 0;
}
+ return 0;
}
-static void __register_p2pdevice_signal(GVariant *value, void *user_data)
+int ws_configure(wfd_oem_config_s *conf)
{
__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;
+ if (conf == NULL) {
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
}
- pd_data = (ws_dbus_plugin_data_s *)g_pd;
+ if (config)
+ g_free(config);
- g_variant_get(value, "(&o)", &path);
- g_strlcpy(interface_path, path, DBUS_OBJECT_PATH_MAX);
- g_strlcpy(pd_data->iface_path, path, DBUS_OBJECT_PATH_MAX);
+ 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_LOGD("interface object path [%s]", interface_path);
- /* subscribe interface p2p 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);
__WDP_LOG_FUNC_EXIT__;
+ return 0;
}
-static int _ws_create_interface(const char *iface_name, handle_reply function, void *user_data)
+int ws_init(wfd_oem_event_cbs_s *event_cbs)
{
__WDP_LOG_FUNC_ENTER__;
- GDBusConnection *g_dbus = NULL;
- GVariantBuilder *builder = NULL;
- dbus_method_param_s params;
- int res = 0;
+ 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("ws_dbus_plugin_data_s is not created yet");
+ 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_dbus = g_pd->g_dbus;
- if (!g_dbus) {
- WDP_LOGE("DBus connection is NULL");
- return -1;
+ g_pd->callback = event_cbs;
+ g_pd->initialized = TRUE;
+
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
+
+int ws_deinit(void)
+{
+ __WDP_LOG_FUNC_ENTER__;
+
+ if (g_pd) {
+ _ws_reset_plugin(g_pd);
+ g_pd = NULL;
}
- memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- dbus_set_method_param(¶ms, "CreateInterface", SUPPLICANT_PATH, g_dbus);
+ if (config)
+ g_free(config);
- builder = g_variant_builder_new(G_VARIANT_TYPE ("a{sv}"));
- g_variant_builder_add(builder, "{sv}", "Ifname", g_variant_new_string(iface_name));
- g_variant_builder_add(builder, "{sv}", "ConfigFile", g_variant_new_string(CONF_FILE_PATH));
- params.params = g_variant_new("(a{sv})", builder);
- g_variant_builder_unref(builder);
- res = dbus_method_call(¶ms, SUPPLICANT_INTERFACE, function, user_data);
- if (res < 0)
- WDP_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to CreateInterface");
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
+
+gboolean _ws_util_execute_file(const char *file_path,
+ char *const args[], char *const envs[])
+{
+ pid_t pid = 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]);
+ index++;
+ }
+
+ if (!(pid = fork())) {
+ WDP_LOGD("pid(%d), ppid(%d)", getpid(), getppid());
+ WDP_LOGD("Inside child, exec (%s) command", file_path);
+
+ errno = 0;
+ if (execve(file_path, args, envs) == -1) {
+ strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
+ WDP_LOGE("Fail to execute command (%s)", error_buf);
+ exit(1);
+ }
+ } else if (pid > 0) {
+ if (waitpid(pid, &rv, 0) == -1)
+ WDP_LOGD("wait pid (%u) rv (%d)", pid, rv);
+ if (WIFEXITED(rv))
+ WDP_LOGD("exited, rv=%d", WEXITSTATUS(rv));
+ else if (WIFSIGNALED(rv))
+ WDP_LOGD("killed by signal %d", WTERMSIG(rv));
+ else if (WIFSTOPPED(rv))
+ WDP_LOGD("stopped by signal %d", WSTOPSIG(rv));
+ else if (WIFCONTINUED(rv))
+ WDP_LOGD("continued");
- __WDP_LOG_FUNC_EXIT__;
- return 0;
+ return TRUE;
+ }
+
+ strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
+ WDP_LOGE("failed to fork (%s)", error_buf);
+ return FALSE;
}
-static int _ws_get_interface(const char *iface_name, handle_reply function, void *user_data)
+static int __ws_p2p_firmware_start(const char *interface_name)
{
- __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");
- return -1;
- }
+ gboolean rv = FALSE;
+ const char *path = "/usr/bin/wlan.sh";
+ char *const args[] = { "/usr/bin/wlan.sh", "p2p", (char *)interface_name, NULL };
+ char *const envs[] = { NULL };
- g_dbus = g_pd->g_dbus;
- if (!g_dbus) {
- WDP_LOGE("DBus connection is NULL");
+ rv = _ws_util_execute_file(path, args, envs);
+ if (rv != TRUE)
return -1;
- }
-
- dbus_set_method_param(¶ms, SUPPLICANT_METHOD_GETINTERFACE,
- 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 */
-
- res = dbus_method_call(¶ms, SUPPLICANT_INTERFACE,
- function, user_data);
+ WDP_LOGI("Successfully loaded p2p device driver");
+ return 0;
+}
- if (res < 0)
- WDP_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to get interface");
+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", (char *)interface_name, NULL };
+ char *const envs[] = { NULL };
+ rv = _ws_util_execute_file(path, args, envs);
+ if (rv < 0)
+ return -1;
- __WDP_LOG_FUNC_EXIT__;
- return res;
+ WDP_LOGI("Successfully removed p2p device driver");
+ return 0;
}
-#if defined (TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD)
-static void __ws_remove_interface(GVariant *value, void *user_data)
+static int __ws_p2p_supplicant_start(void)
{
- __WDP_LOG_FUNC_ENTER__;
- GDBusConnection *g_dbus = NULL;
- dbus_method_param_s params;
- const char *path = NULL;
- static char interface_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- int res = 0;
+ gboolean rv = FALSE;
+ const char *path = "/usr/sbin/p2p_supp.sh";
+ char *const args[] = { "/usr/sbin/p2p_supp.sh", "start_dbus", NULL };
+ char *const envs[] = { NULL };
- if (!g_pd) {
- WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
- return;
- }
+ rv = _ws_util_execute_file(path, args, envs);
- g_dbus = g_pd->g_dbus;
- if (!g_dbus) {
- WDP_LOGE("DBus connection is NULL");
- return;
+ if (rv != TRUE) {
+ WDP_LOGE("Failed to start p2p_supp.sh");
+ return -1;
}
- g_variant_get(value, "(&o)", &path);
- g_strlcpy(interface_path, path, DBUS_OBJECT_PATH_MAX);
- WDP_LOGD("interface object path [%s]", interface_path);
+ WDP_LOGI("Successfully started p2p_supp.sh");
+ return 0;
+}
- memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- dbus_set_method_param(¶ms, "RemoveInterface", SUPPLICANT_PATH, g_dbus);
- params.params = g_variant_new("(o)", interface_path);
+static int __ws_p2p_supplicant_stop(void)
+{
+ gboolean rv = FALSE;
+ const char *path = "/usr/sbin/p2p_supp.sh";
+ char *const args[] = { "/usr/sbin/p2p_supp.sh", "stop", NULL };
+ char *const envs[] = { NULL };
- res = dbus_method_call(¶ms, SUPPLICANT_INTERFACE, NULL, NULL);
- if (res < 0)
- WDP_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to RemoveInterface");
+ rv = _ws_util_execute_file(path, args, envs);
- __WDP_LOG_FUNC_EXIT__;
- return;
-}
-#endif /* (TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD) */
+ if (rv != TRUE) {
+ WDP_LOGE("Failed to stop p2p_supp.sh");
+ return -1;
+ }
-static int _ws_init_dbus_connection(void)
+ WDP_LOGI("Successfully stopped p2p_supp.sh");
+ return 0;
+}
+#if 0
+static int __ws_p2p_on(void)
{
- __WDP_LOG_FUNC_ENTER__;
- GDBusConnection *conn = NULL;
- GError *error = NULL;
- int res = 0;
+ DBusError error;
+ DBusMessage *reply = NULL;
+ DBusMessage *message = NULL;
+ DBusConnection *connection = NULL;
- if (!g_pd) {
- WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
- return -1;
+ connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
+ if (connection == NULL) {
+ WDP_LOGE("Failed to get system bus");
+ return -EIO;
}
- conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
+ message = dbus_message_new_method_call(NETCONFIG_SERVICE,
+ NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE, "LoadP2pDriver");
+ if (message == NULL) {
+ WDP_LOGE("Failed DBus method call");
+ dbus_connection_unref(connection);
+ return -EIO;
+ }
- if (conn == NULL) {
- if(error != NULL){
- WDP_LOGE("Error! Failed to connect to the D-BUS daemon: [%s]",
- error->message);
- g_error_free(error);
+ dbus_error_init(&error);
+
+ reply = dbus_connection_send_with_reply_and_block(connection, message,
+ NETCONFIG_DBUS_REPLY_TIMEOUT, &error);
+ if (dbus_error_is_set(&error) == TRUE) {
+ if (NULL != strstr(error.message, ".AlreadyExists")) {
+ /* p2p already enabled */
+ } else {
+ WDP_LOGE("dbus_connection_send_with_reply_and_block() failed. "
+ "DBus error [%s: %s]", error.name, error.message);
+
+ dbus_error_free(&error);
}
- __WDP_LOG_FUNC_EXIT__;
- return -1;
- }
- g_pd->g_dbus = conn;
+ dbus_error_free(&error);
+ }
- 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) */
+ if (reply != NULL)
+ dbus_message_unref(reply);
- if (res < 0)
- WDP_LOGE("Failed to subscribe interface signal");
- else
- WDP_LOGI("Successfully register signal filters");
+ dbus_message_unref(message);
+ dbus_connection_unref(connection);
- __WDP_LOG_FUNC_EXIT__;
- return res;
+ return 0;
}
-static int _ws_deinit_dbus_connection(void)
+static int __ws_p2p_off(void)
{
- GDBusConnection *g_dbus = NULL;
+ DBusError error;
+ DBusMessage *reply = NULL;
+ DBusMessage *message = NULL;
+ DBusConnection *connection = NULL;
- if (!g_pd) {
- WDP_LOGE("Invalid parameter");
- __WDP_LOG_FUNC_EXIT__;
- return -1;
+ connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
+ if (connection == NULL) {
+ WDP_LOGE("Failed to get system bus");
+ return -EIO;
}
- g_dbus = g_pd->g_dbus;
- if (!g_dbus) {
- WDP_LOGE("DBus connection is NULL");
- return -1;
+ message = dbus_message_new_method_call(NETCONFIG_SERVICE,
+ NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE, "RemoveP2pDriver");
+ if (message == NULL) {
+ WDP_LOGE("Failed DBus method call");
+ dbus_connection_unref(connection);
+ return -EIO;
}
- 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);
+ dbus_error_init(&error);
- 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);
+ reply = dbus_connection_send_with_reply_and_block(connection, message,
+ NETCONFIG_DBUS_REPLY_TIMEOUT, &error);
+ if (dbus_error_is_set(&error) == TRUE) {
+ if (NULL != strstr(error.message, ".AlreadyExists")) {
+ /* p2p already disabled */
+ } else {
+ WDP_LOGE("dbus_connection_send_with_reply_and_block() failed. "
+ "DBus error [%s: %s]", error.name, error.message);
- g_object_unref(g_dbus);
- return 0;
-}
+ dbus_error_free(&error);
+ }
-int wfd_plugin_load(wfd_oem_ops_s **ops)
-{
- if (!ops) {
- WDP_LOGE("Invalid parameter");
- return -1;
+ dbus_error_free(&error);
}
- *ops = &supplicant_ops;
+ if (reply != NULL)
+ dbus_message_unref(reply);
+
+ dbus_message_unref(message);
+ dbus_connection_unref(connection);
return 0;
}
+#endif
-static int _ws_reset_plugin(ws_dbus_plugin_data_s *f_pd)
+int __ws_init_p2pdevice(void)
{
__WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *g_dbus = NULL;
- if (!f_pd) {
- WDP_LOGE("Invalid parameter");
+ GVariant *value = NULL;
+ GVariant *param = NULL;
+ GVariantBuilder *builder = NULL;
+ GVariantBuilder *type_builder = NULL;
+ dbus_method_param_s params;
+
+ unsigned char primary_device_type[8] = {
+ 0x00, 0x00, 0x00, 0x50,
+ 0xf2, 0x04, 0x00, 0x00
+ };
+
+ 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;
}
- _ws_deinit_dbus_connection();
+ if (!config) {
+ WDP_LOGE("no configurable data found");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
- if (f_pd->activated)
- ws_deactivate(f_pd->concurrent);
+ primary_device_type[1] = config->pri_dev_type;
+ primary_device_type[7] = config->sec_dev_type;
- g_free(f_pd);
+ for (i = 0; i < WS_DEVTYPE_LEN; i++)
+ WDP_LOGD("device type[%02x]", primary_device_type[i]);
- __WDP_LOG_FUNC_EXIT__;
- return 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));
-#ifndef TIZEN_WIFI_MODULE_BUNDLE
-static int __ws_check_net_interface(char* if_name)
-{
- struct ifreq ifr;
- int fd;
+ dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
+ g_dbus);
- if (if_name == NULL) {
- WDP_LOGE("Invalid param");
- return -1;
- }
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "DeviceName",
+ g_variant_new_string(config->device_name));
- fd = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
- if (fd < 0) {
- WDP_LOGE("socket create error: %d", fd);
- return -2;
- }
+ g_variant_builder_add(builder, "{sv}", "GOIntent",
+ g_variant_new_uint32(config->go_intent));
- memset(&ifr, 0, sizeof(ifr));
- strncpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
- ifr.ifr_name[IFNAMSIZ-1] = '\0';
+ g_variant_builder_add(builder, "{sv}", "PersistentReconnect",
+ g_variant_new_boolean(config->persistent_reconnect));
- if (ioctl(fd, SIOCGIFFLAGS, &ifr) < 0) {
- close(fd);
- WDP_LOGE("ioctl error: SIOCGIFFLAGS: %s [ %s ]", strerror(errno), if_name); /* interface is not found. */
- return -3;
- }
+ g_variant_builder_add(builder, "{sv}", "ListenRegClass",
+ g_variant_new_uint32(config->listen_reg_class));
- close(fd);
+ g_variant_builder_add(builder, "{sv}", "ListenChannel",
+ g_variant_new_uint32(config->listen_channel));
- if (ifr.ifr_flags & IFF_UP) {
- WDP_LOGD("%s interface is up", if_name);
- return 1;
- } else if (!(ifr.ifr_flags & IFF_UP)) {
- WDP_LOGD("%s interface is down", if_name);
- return 0;
- }
- return 0;
-}
-#endif
+ g_variant_builder_add(builder, "{sv}", "OperRegClass",
+ g_variant_new_uint32(config->operating_reg_class));
-int ws_init(wfd_oem_event_cb callback, void *user_data)
-{
- __WDP_LOG_FUNC_ENTER__;
+ g_variant_builder_add(builder, "{sv}", "OperChannel",
+ g_variant_new_uint32(config->operating_channel));
- if (g_pd)
- _ws_reset_plugin(g_pd);
+ g_variant_builder_add(builder, "{sv}", "SsidPostfix",
+ g_variant_new_string(config->device_name));
- 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));
- return -1;
- }
+ g_variant_builder_add(builder, "{sv}", "NoGroupIface",
+ g_variant_new_boolean(config->no_group_iface));
- g_pd->callback = callback;
- g_pd->user_data = user_data;
- g_pd->initialized = TRUE;
+ type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < WS_DEVTYPE_LEN; i++)
+ g_variant_builder_add(type_builder, "y", primary_device_type[i]);
+ g_variant_builder_add(builder, "{sv}", "PrimaryDeviceType",
+ 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 : ", params.params);
+ res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to initialize p2pdevice");
__WDP_LOG_FUNC_EXIT__;
- return 0;
+ return res;
}
-int ws_deinit()
+int __ws_set_config_methods(void)
{
__WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *g_dbus = NULL;
- if (g_pd) {
- _ws_reset_plugin(g_pd);
- g_pd = NULL;
- }
+ GVariant *value = NULL;
+ GVariant *param = NULL;
- __WDP_LOG_FUNC_EXIT__;
- return 0;
-}
+ dbus_method_param_s params;
+ int res = 0;
-gboolean _ws_util_execute_file(const char *file_path,
- char *const args[], char *const envs[])
-{
- pid_t pid = 0;
- int rv = 0;
- errno = 0;
- register unsigned int index = 0;
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
- while (args[index] != NULL) {
- WDP_LOGD("[%s]", args[index]);
- index++;
+ if (!config) {
+ WDP_LOGE("no configurable data found");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
}
- if (!(pid = fork())) {
- WDP_LOGD("pid(%d), ppid(%d)", getpid(), getppid());
- WDP_LOGD("Inside child, exec (%s) command", file_path);
+ 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));
- errno = 0;
- if (execve(file_path, args, envs) == -1) {
- WDP_LOGE("Fail to execute command (%s)", strerror(errno));
- exit(1);
- }
- } else if (pid > 0) {
- if (waitpid(pid, &rv, 0) == -1)
- WDP_LOGD("wait pid (%u) rv (%d)", pid, rv);
- if (WIFEXITED(rv)) {
- WDP_LOGD("exited, rv=%d", WEXITSTATUS(rv));
- } else if (WIFSIGNALED(rv)) {
- WDP_LOGD("killed by signal %d", WTERMSIG(rv));
- } else if (WIFSTOPPED(rv)) {
- WDP_LOGD("stopped by signal %d", WSTOPSIG(rv));
- } else if (WIFCONTINUED(rv)) {
- WDP_LOGD("continued");
- }
+ dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
+ g_dbus);
- return TRUE;
- }
+ value = g_variant_new_string(config->config_methods);
- WDP_LOGE("failed to fork (%s)", strerror(errno));
- return FALSE;
+ param = g_variant_new("(ssv)", SUPPLICANT_WPS, "ConfigMethods", value);
+ params.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_LOGD("Succeeded to set config method(%s)", config->config_methods);
+
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
}
-#ifndef TIZEN_WIFI_MODULE_BUNDLE
-static int __ws_p2p_firmware_start(void)
+int ws_activate(int concurrent)
{
- GError *error = NULL;
- GVariant *reply = NULL;
- GVariant *param = NULL;
- GDBusConnection *connection = NULL;
- const char *device = "p2p";
+ __WDP_LOG_FUNC_ENTER__;
+ int res = 0;
+ int retry_count = 0;
- connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
- if (connection == NULL) {
- if(error != NULL){
- WDP_LOGE("Error! Failed to connect to the D-BUS daemon: [%s]",
- error->message);
- g_error_free(error);
- }
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
__WDP_LOG_FUNC_EXIT__;
return -1;
}
- param = g_variant_new("(s)", device);
-
- reply = g_dbus_connection_call_sync (connection,
- NETCONFIG_SERVICE, /* bus name */
- NETCONFIG_WIFI_PATH, /* object path */
- NETCONFIG_WIFI_INTERFACE ".Firmware", /* interface name */
- "Start", /* method name */
- param, /* GVariant *params */
- NULL, /* reply_type */
- G_DBUS_CALL_FLAGS_NONE, /* flags */
- NETCONFIG_DBUS_REPLY_TIMEOUT , /* timeout */
- NULL, /* cancellable */
- &error); /* error */
-
- if(error != NULL){
- if(strstr(error->message, ".AlreadyExists") != NULL) {
- WDP_LOGD("p2p already enabled");
- g_error_free(error);
- } else {
- WDP_LOGE("Error! Failed to call net-config method: [%s]",
- error->message);
- g_error_free(error);
- if(reply)
- g_variant_unref(reply);
- g_object_unref(connection);
- __WDP_LOG_FUNC_EXIT__;
- return -1;
- }
+ if (!config) {
+ WDP_LOGE("no configurable data found");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
}
- if(reply)
- g_variant_unref(reply);
- g_object_unref(connection);
- return 0;
-}
-
-static int __ws_p2p_firmware_stop(void)
-{
- GError *error = NULL;
- GVariant *reply = NULL;
- GVariant *param = NULL;
- GDBusConnection *connection = NULL;
- const char *device = "p2p";
- connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
- if (connection == NULL) {
- if(error != NULL){
- WDP_LOGE("Error! Failed to connect to the D-BUS daemon: [%s]",
- error->message);
- g_error_free(error);
- }
+ res = __ws_p2p_supplicant_start();
+ if (res < 0) {
+ res = __ws_p2p_supplicant_stop();
+ WDP_LOGI("P2P supplicant stopped with error %d", res);
__WDP_LOG_FUNC_EXIT__;
return -1;
}
- param = g_variant_new("(s)", device);
-
- reply = g_dbus_connection_call_sync (connection,
- NETCONFIG_SERVICE, /* bus name */
- NETCONFIG_WIFI_PATH, /* object path */
- NETCONFIG_WIFI_INTERFACE ".Firmware", /* interface name */
- "Stop", /* method name */
- param, /* GVariant *params */
- NULL, /* reply_type */
- G_DBUS_CALL_FLAGS_NONE, /* flags */
- NETCONFIG_DBUS_REPLY_TIMEOUT , /* timeout */
- NULL, /* cancellable */
- &error); /* error */
- if(error != NULL){
- if(strstr(error->message, ".AlreadyExists") != NULL) {
- WDP_LOGD("p2p already disabled");
- g_error_free(error);
+ while (retry_count < WS_CONN_RETRY_COUNT) {
+ /* load wlan driver */
+ if (concurrent == 0)
+ 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(config->ifname) < 0) {
+ usleep(150000); /* wait for 150ms */
+ concurrent = 0;
+ retry_count++;
+ WDP_LOGE("interface is not up: retry, %d", retry_count);
} else {
- WDP_LOGE("Error! Failed to call net-config method: [%s]",
- error->message);
- g_error_free(error);
- if(reply)
- g_variant_unref(reply);
- g_object_unref(connection);
- __WDP_LOG_FUNC_EXIT__;
- return -1;
+ break;
}
}
- if(reply)
- g_variant_unref(reply);
- g_object_unref(connection);
- return 0;
-}
-#endif
-static int __ws_p2p_supplicant_start(void)
-{
- gboolean rv = FALSE;
- const char *path = "/usr/sbin/p2p_supp.sh";
- char *const args[] = { "/usr/sbin/p2p_supp.sh", "start_dbus", NULL };
- char *const envs[] = { NULL };
+ if (retry_count >= WS_CONN_RETRY_COUNT) {
+ WDP_LOGE("Driver loading is failed [%d]", res);
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+ if (retry_count > 0) {
+ /* Give driver marginal time to config net */
+ WDP_LOGE("Driver loading is done. Wait marginal time for driver");
+ sleep(1); /* 1s */
+ }
- rv = _ws_util_execute_file(path, args, envs);
+ g_pd->concurrent = concurrent;
- if (rv != TRUE) {
- WDP_LOGE("Failed to start p2p_supp.sh");
+ res = _ws_init_dbus_connection();
+ if (res < 0) {
+ res = __ws_p2p_supplicant_stop();
+ WDP_LOGI("[/usr/sbin/p2p_supp.sh stop] returns %d", res);
+ res = __ws_p2p_firmware_stop(config->ifname);
+ WDP_LOGI("P2P firmware stopped with error %d", res);
+ __WDP_LOG_FUNC_EXIT__;
return -1;
}
- WDP_LOGI("Successfully started p2p_supp.sh");
+ g_pd->activated = TRUE;
+ __ws_init_p2pdevice();
+ __ws_set_config_methods();
+ seek_list = NULL;
+
+ __WDP_LOG_FUNC_EXIT__;
return 0;
}
-
-static int __ws_p2p_supplicant_stop(void)
+int ws_deactivate(int concurrent)
{
- gboolean rv = FALSE;
- const char *path = "/usr/sbin/p2p_supp.sh";
- char *const args[] = { "/usr/sbin/p2p_supp.sh", "stop", NULL };
- char *const envs[] = { NULL };
-
- rv = _ws_util_execute_file(path, args, envs);
+ __WDP_LOG_FUNC_ENTER__;
+ wfd_oem_asp_service_s *data = NULL;
+ int res = -1;
- if (rv != TRUE) {
- WDP_LOGE("Failed to stop p2p_supp.sh");
- return -1;
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
}
- WDP_LOGI("Successfully stopped p2p_supp.sh");
- return 0;
-}
-#if 0
-static int __ws_p2p_on(void)
-{
- DBusError error;
- DBusMessage *reply = NULL;
- DBusMessage *message = NULL;
- DBusConnection *connection = NULL;
-
- connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
- if (connection == NULL) {
- WDP_LOGE("Failed to get system bus");
- return -EIO;
+ if (!config) {
+ WDP_LOGE("no configurable data found");
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
}
- message = dbus_message_new_method_call(NETCONFIG_SERVICE,
- NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE, "LoadP2pDriver");
- if (message == NULL) {
- WDP_LOGE("Failed DBus method call");
- dbus_connection_unref(connection);
- return -EIO;
+ if (!g_pd->activated) {
+ WDP_LOGE("Wi-Fi Direct is not activated");
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
}
- dbus_error_init(&error);
+ ws_stop_scan();
- reply = dbus_connection_send_with_reply_and_block(connection, message,
- NETCONFIG_DBUS_REPLY_TIMEOUT, &error);
- if (dbus_error_is_set(&error) == TRUE) {
- if (NULL != strstr(error.message, ".AlreadyExists")) {
- // p2p already enabled
- } else {
- WDP_LOGE("dbus_connection_send_with_reply_and_block() failed. "
- "DBus error [%s: %s]", error.name, error.message);
+ g_pd->concurrent = concurrent;
- dbus_error_free(&error);
- }
+ 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(config->ifname, __ws_remove_interface, NULL);
- dbus_error_free(&error);
+ _ws_deinit_dbus_connection();
+
+ if (concurrent == 0) {
+ res = __ws_p2p_supplicant_stop();
+ WDP_LOGI("[/usr/sbin/p2p_supp.sh stop] returns %d", res);
+ res = __ws_p2p_firmware_stop(config->ifname);
+ WDP_LOGI("P2P firmware stopped with error %d", res);
}
+ g_pd->activated = FALSE;
- if (reply != NULL)
- dbus_message_unref(reply);
+ GLIST_ITER_START(seek_list, data)
- dbus_message_unref(message);
- dbus_connection_unref(connection);
+ if (data) {
+ temp = g_list_next(seek_list);
+ seek_list = g_list_remove(seek_list, data);
+ g_free(data->service_type);
+ g_free(data->service_info);
+ g_free(data);
+ }
+ GLIST_ITER_END()
+ __WDP_LOG_FUNC_EXIT__;
return 0;
}
-static int __ws_p2p_off(void)
+#if 0
+static gboolean _retry_start_scan(gpointer data)
{
- DBusError error;
- DBusMessage *reply = NULL;
- DBusMessage *message = NULL;
- DBusConnection *connection = NULL;
-
- connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
- if (connection == NULL) {
- WDP_LOGE("Failed to get system bus");
- return -EIO;
- }
-
- message = dbus_message_new_method_call(NETCONFIG_SERVICE,
- NETCONFIG_WIFI_PATH, NETCONFIG_WIFI_INTERFACE, "RemoveP2pDriver");
- if (message == NULL) {
- WDP_LOGE("Failed DBus method call");
- dbus_connection_unref(connection);
- return -EIO;
- }
+ __WDP_LOG_FUNC_ENTER__;
- dbus_error_init(&error);
+ WDP_LOGD("Succeeded to start scan");
- reply = dbus_connection_send_with_reply_and_block(connection, message,
- NETCONFIG_DBUS_REPLY_TIMEOUT, &error);
- if (dbus_error_is_set(&error) == TRUE) {
- if (NULL != strstr(error.message, ".AlreadyExists")) {
- // p2p already disabled
- } else {
- WDP_LOGE("dbus_connection_send_with_reply_and_block() failed. "
- "DBus error [%s: %s]", error.name, error.message);
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
+#endif
- dbus_error_free(&error);
- }
+static void __ws_add_seek_params(GVariantBuilder *builder)
+{
+ GVariantBuilder *outter = NULL;
+ GVariantBuilder *inner = NULL;
+ wfd_oem_asp_service_s *data = NULL;
+ int len = 0;
+ int i = 0;
- dbus_error_free(&error);
+ if (seek_list == NULL || g_list_length(seek_list) == 0) {
+ WDP_LOGD("seek list is NULL");
+ return;
}
+ WDP_LOGD("seek list length [%d]", g_list_length(seek_list));
- if (reply != NULL)
- dbus_message_unref(reply);
+ outter = g_variant_builder_new(G_VARIANT_TYPE("aay"));
- dbus_message_unref(message);
- dbus_connection_unref(connection);
+GLIST_ITER_START(seek_list, data)
+ if (data && data->service_type) {
+ len = strlen(data->service_type) + 1;
+ WDP_LOGD("data [%s] len [%d]", data->service_type, len);
+ inner = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < len; i++)
+ g_variant_builder_add(inner, "y", data->service_type[i]);
+ g_variant_builder_add(outter, "ay", inner);
+ g_variant_builder_unref(inner);
+ }
+GLIST_ITER_END()
+ g_variant_builder_add(builder, "{sv}", "Seek", g_variant_new("aay", outter));
+ g_variant_builder_unref(outter);
- return 0;
+ return;
}
-#endif
-int __ws_init_p2pdevice()
+int ws_start_scan(wfd_oem_scan_param_s *param)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
-
- GVariant *value = NULL;
- GVariant *param = NULL;
GVariantBuilder *builder = NULL;
- GVariantBuilder *type_builder = NULL;
+ GVariant *value = NULL;
dbus_method_param_s params;
-
- const char *primary_device_type = PRIMARY_DEVICE_TYPE;
-
-#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 (!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;
- }
-
- 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));
- dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
- g_dbus);
+ if (param->scan_mode == WFD_OEM_SCAN_MODE_ACTIVE) {
+
+ dbus_set_method_param(¶ms, "Find", g_pd->iface_path, g_dbus);
+
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
- g_variant_builder_add (builder, "{sv}", "DeviceName",
- g_variant_new_string(DEFAULT_DEVICE_NAME));
+ if (param->scan_time)
+ g_variant_builder_add(builder, "{sv}", "Timeout",
+ g_variant_new_int32(param->scan_time));
+ if (param->scan_type == WFD_OEM_SCAN_TYPE_SOCIAL)
+ g_variant_builder_add(builder, "{sv}", "DiscoveryType",
+ g_variant_new_string("social"));
+ if (seek_list != NULL)
+ __ws_add_seek_params(builder);
- g_variant_builder_add (builder, "{sv}", "GOIntent",
- g_variant_new_uint32(DEFAULT_GO_INTENT));
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
+ } else {
- g_variant_builder_add (builder, "{sv}", "PersistentReconnect",
- g_variant_new_boolean(DEFAULT_PERSISTENT_RECONNECT));
+ dbus_set_method_param(¶ms, "Listen", g_pd->iface_path, g_dbus);
+ value = g_variant_new("(i)", param->scan_time);
+ }
- g_variant_builder_add (builder, "{sv}", "ListenRegClass",
- g_variant_new_uint32(DEFAULT_LISTEN_REG_CLASS));
+ params.params = value;
+ DEBUG_G_VARIANT("Params : ", params.params);
- g_variant_builder_add (builder, "{sv}", "ListenChannel",
- g_variant_new_uint32(DEFAULT_LISTEN_CHANNEL));
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to start scan");
- g_variant_builder_add (builder, "{sv}", "OperRegClass",
- g_variant_new_uint32(DEFAULT_OPER_REG_CLASS));
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
+}
- g_variant_builder_add (builder, "{sv}", "OperChannel",
- g_variant_new_uint32(DEFAULT_OPER_CHANNEL));
+int ws_restart_scan(int freq)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *g_dbus = NULL;
+ GVariantBuilder *builder = NULL;
+ GVariant *value = NULL;
+ dbus_method_param_s params;
+ int res = 0;
- g_variant_builder_add (builder, "{sv}", "SsidPostfix",
- g_variant_new_string(DEFAULT_DEVICE_NAME));
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
- g_variant_builder_add (builder, "{sv}", "NoGroupIface",
- g_variant_new_boolean(DEFAULT_NO_GROUP_IFACE));
+ 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));
- type_builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
- for(i = 0; i < WS_DEVTYPE_LEN; i++)
- g_variant_builder_add(type_builder, "y", primary_device_type[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);
+ dbus_set_method_param(¶ms, "Find", g_pd->iface_path, g_dbus);
- param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig", value);
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "Timeout", g_variant_new_int32(2));
+ g_variant_builder_add(builder, "{sv}", "DiscoveryType",
+ g_variant_new_string("social"));
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
- params.params = param;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ params.params = value;
+ DEBUG_G_VARIANT("Params : ", params.params);
- res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (res < 0)
WDP_LOGE("Failed to send command to wpa_supplicant");
else
- WDP_LOGD("Succeeded to initialize p2pdevice");
+ WDP_LOGD("Succeeded to start scan");
+
__WDP_LOG_FUNC_EXIT__;
return res;
}
-int __ws_set_config_methods()
+int ws_stop_scan(void)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
-
- GVariant *value = NULL;
- GVariant *param = 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, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
- g_dbus);
-
- value = g_variant_new_string(DEFAULT_CONFIG_METHOD);
-
- param = g_variant_new("(ssv)", SUPPLICANT_WPS, "ConfigMethods", value);
- params.params = param;
+ dbus_set_method_param(¶ms, "StopFind", g_pd->iface_path, g_dbus);
+ params.params = NULL;
- res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (res < 0)
- WDP_LOGE("Failed to send command to wpa_supplicant");
+ 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 stop scan");
__WDP_LOG_FUNC_EXIT__;
return res;
}
-int ws_activate(int concurrent)
+int ws_get_visibility(int *visibility)
+{
+ __WDP_LOG_FUNC_ENTER__;
+
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
+
+int ws_set_visibility(int visibility)
+{
+ __WDP_LOG_FUNC_ENTER__;
+
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
+
+int ws_get_scan_result(GList **peers, int *peer_count)
+{
+ __WDP_LOG_FUNC_ENTER__;
+
+ __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 *device = NULL;
+ static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
int res = 0;
- int retry_count = 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;
}
- res = __ws_p2p_supplicant_start();
- if (res < 0) {
- res = __ws_p2p_supplicant_stop();
- WDP_LOGI("P2P supplicant stopped with error %d", res);
+ g_dbus = g_pd->g_dbus;
+ if (!g_dbus) {
+ WDP_LOGE("DBus connection is NULL");
__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();
- 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) {
- usleep(150000); // wait for 150ms
- concurrent = 0;
- retry_count++;
- WDP_LOGE("interface is not up: retry, %d", retry_count);
- } else {
- break;
- }
- }
-#endif
- if (retry_count >= WS_CONN_RETRY_COUNT) {
- WDP_LOGE("Driver loading is failed", res);
+ device = __create_oem_device();
+ if (!device) {
__WDP_LOG_FUNC_EXIT__;
return -1;
}
- if (retry_count > 0) {
- // Give driver marginal time to config net
- WDP_LOGE("Driver loading is done. Wait marginal time for driver");
- sleep(1); // 1s
- }
- g_pd->concurrent = concurrent;
+ g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
+ COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
+
+ WDP_LOGD("get peer path [%s]", peer_path);
+
+ res = dbus_property_get_all(peer_path, g_dbus, SUPPLICANT_P2P_PEER,
+ __ws_get_peer_property, device);
- res = _ws_init_dbus_connection();
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();
- WDP_LOGI("P2P firmware stopped with error %d", res);
-#endif
+ 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 = device;
}
- g_pd->activated = TRUE;
- __ws_init_p2pdevice();
- __ws_set_config_methods();
- seek_list = NULL;
+ //Memory ownership of dev_data is transferred to method handler
+ //which uses this function.
__WDP_LOG_FUNC_EXIT__;
return 0;
}
-int ws_deactivate(int concurrent)
+int ws_prov_disc_req(unsigned char *peer_addr, wfd_oem_wps_mode_e wps_mode, int join)
{
__WDP_LOG_FUNC_ENTER__;
-#if defined(TIZEN_FEATURE_ASP)
- wfd_oem_asp_service_s *data = NULL;
-#endif /* TIZEN_FEATURE_ASP */
+ GDBusConnection *g_dbus = NULL;
+ GVariant *value = NULL;
+ dbus_method_param_s params;
+ static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
int res = 0;
- if (!g_pd) {
- WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ if (!peer_addr) {
+ WDP_LOGE("Invalid parameter");
+ __WDP_LOG_FUNC_EXIT__;
return -1;
}
- if (!g_pd->activated) {
- WDP_LOGE("Wi-Fi Direct is not activated");
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ __WDP_LOG_FUNC_EXIT__;
return -1;
}
- 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(concurrent == 0)
- _ws_get_interface(COMMON_IFACE_NAME, __ws_remove_interface, NULL);
-#endif /* (TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD) */
-
- _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();
- WDP_LOGI("P2P firmware stopped with error %d", res);
-#endif
+ g_dbus = g_pd->g_dbus;
+ if (!g_dbus) {
+ WDP_LOGE("DBus connection is NULL");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
}
- g_pd->activated = FALSE;
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
-#if defined(TIZEN_FEATURE_ASP)
- GLIST_ITER_START(seek_list, data)
+ dbus_set_method_param(¶ms, "ProvisionDiscoveryRequest", g_pd->iface_path, g_dbus);
- if (data) {
- temp = g_list_next(seek_list);
- seek_list = g_list_remove(seek_list, data);
- g_free(data->service_name);
- g_free(data);
- }
+ g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
+ COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
+ WDP_LOGD("get peer path [%s]", peer_path);
- GLIST_ITER_END()
-#endif /* TIZEN_FEATURE_ASP */
- __WDP_LOG_FUNC_EXIT__;
- return 0;
-}
+ value = g_variant_new("(os)", peer_path, __ws_wps_to_txt(wps_mode));
-#if 0
-static gboolean _retry_start_scan(gpointer data)
-{
- __WDP_LOG_FUNC_ENTER__;
+ params.params = value;
+ DEBUG_G_VARIANT("Params : ", params.params);
- WDP_LOGD("Succeeded to start scan");
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to send prov disc to peer[" MACSTR "]", MAC2STR(peer_addr));
__WDP_LOG_FUNC_EXIT__;
- return 0;
-}
-#endif
-
-#if defined(TIZEN_FEATURE_ASP)
-static void __ws_add_seek_params(GVariantBuilder *builder)
-{
- GVariantBuilder *outter = NULL;
- GVariantBuilder *inner = NULL;
- wfd_oem_asp_service_s *data = NULL;
- int len = 0;
- int i = 0;
-
- if(seek_list == NULL || g_list_length(seek_list) == 0) {
- WDP_LOGD("seek list is NULL");
- return;
- }
- WDP_LOGD("seek list length [%d]", g_list_length(seek_list));
-
- outter = g_variant_builder_new(G_VARIANT_TYPE("aay"));
-
-GLIST_ITER_START(seek_list, data)
- if (data && data->service_type) {
- len = strlen(data->service_type) + 1;
- WDP_LOGD("data [%s] len [%d]", data->service_type, len);
- inner = g_variant_builder_new(G_VARIANT_TYPE("ay"));
- for(i = 0; i < len; i++)
- g_variant_builder_add(inner, "y", data->service_type[i]);
- g_variant_builder_add(outter, "ay", inner);
- g_variant_builder_unref(inner);
- }
-GLIST_ITER_END()
- g_variant_builder_add (builder, "{sv}", "Seek", g_variant_new ("aay", outter));
- g_variant_builder_unref(outter);
-
- return;
+ return res;
}
-#endif /* TIZEN_FEATURE_ASP */
-
-int ws_start_scan(wfd_oem_scan_param_s *param)
+int ws_connect(unsigned char *peer_addr, wfd_oem_conn_param_s *param)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
GVariantBuilder *builder = NULL;
GVariant *value = NULL;
dbus_method_param_s params;
+ static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
int res = 0;
- if (!param) {
+ if (!peer_addr || !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_mode == WFD_OEM_SCAN_MODE_ACTIVE) {
+ dbus_set_method_param(¶ms, "Connect", g_pd->iface_path, g_dbus);
- dbus_set_method_param(¶ms, "Find", g_pd->iface_path, g_dbus);
+ g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
+ COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
+ WDP_LOGD("get peer path [%s]", peer_path);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
+ if (param->conn_flags & WFD_OEM_CONN_TYPE_PERSISTENT)
+ g_variant_builder_add(builder, "{sv}", "persistent", g_variant_new_boolean(TRUE));
- if (param->scan_time)
- g_variant_builder_add (builder, "{sv}", "Timeout",
- g_variant_new_int32(param->scan_time));
- 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 */
+ if (param->conn_flags & WFD_OEM_CONN_TYPE_JOIN)
+ g_variant_builder_add(builder, "{sv}", "join", g_variant_new_boolean(TRUE));
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
- } else {
+ if (param->conn_flags & WFD_OEM_CONN_TYPE_AUTH)
+ g_variant_builder_add(builder, "{sv}", "autorize_only", g_variant_new_boolean(TRUE));
- dbus_set_method_param(¶ms, "Listen", g_pd->iface_path, g_dbus);
- value = g_variant_new ("(i)", param->scan_time);
- }
+ if (param->wps_pin[0] != '\0')
+ g_variant_builder_add(builder, "{sv}", "pin", g_variant_new_string(param->wps_pin));
+
+ g_variant_builder_add(builder, "{sv}", "wps_method",
+ g_variant_new_string(__ws_wps_to_txt(param->wps_mode)));
+
+ 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)
WDP_LOGE("Failed to send command to wpa_supplicant");
else
- WDP_LOGD("Succeeded to start scan");
+ WDP_LOGD("Succeeded to send connection command to peer[" MACSTR "]", MAC2STR(peer_addr));
__WDP_LOG_FUNC_EXIT__;
return res;
}
-int ws_restart_scan(int freq)
+int ws_disconnect(unsigned char *peer_addr, int is_iface_addr)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
- GVariantBuilder *builder = NULL;
GVariant *value = NULL;
dbus_method_param_s params;
+ GVariantBuilder *builder = NULL;
int 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));
- dbus_set_method_param(¶ms, "Find", g_pd->iface_path, g_dbus);
+ dbus_set_method_param(¶ms, "RemoveClient", g_pd->iface_path, g_dbus);
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
- g_variant_builder_add (builder, "{sv}", "Timeout", g_variant_new_int32(2));
- g_variant_builder_add (builder, "{sv}", "DiscoveryType",
- g_variant_new_string("social"));
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
+ if (is_iface_addr) {
+ char peer_mac_str[WS_MACSTR_LEN] = {'\0', };
+
+ g_snprintf(peer_mac_str, WS_MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
+ WDP_LOGI("peer addr [%s]", peer_mac_str);
+ g_variant_builder_add(builder, "{sv}", "iface",
+ g_variant_new_string(peer_mac_str));
+ } else {
+ char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0', };
+
+ g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
+ COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
+ g_variant_builder_add(builder, "{sv}", "peer",
+ g_variant_new_object_path(peer_path));
+ }
+
+ 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)
WDP_LOGE("Failed to send command to wpa_supplicant");
else
- WDP_LOGD("Succeeded to start scan");
+ WDP_LOGD("Succeeded to send disconnection command to peer[" MACSECSTR "]",
+ MAC2SECSTR(peer_addr));
__WDP_LOG_FUNC_EXIT__;
return res;
}
-int ws_stop_scan()
+int ws_reject_connection(unsigned char *peer_addr)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
+ GVariant *value = NULL;
dbus_method_param_s params;
+ static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
int 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));
- dbus_set_method_param(¶ms, "StopFind", g_pd->iface_path, g_dbus);
- params.params = NULL;
+ dbus_set_method_param(¶ms, "RejectPeer", g_pd->iface_path, g_dbus);
+
+ g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
+ COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
+ WDP_LOGE("get peer path [%s]", peer_path);
+
+ value = g_variant_new("(o)", peer_path);
+
+ params.params = value;
+ DEBUG_G_VARIANT("Params : ", params.params);
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (res < 0)
- WDP_LOGE("Failed to send command to wpa_supplicant");
+ WDP_LOGE("Failed to send command to wpa_supplicant");
else
- WDP_LOGD("Succeeded to stop scan");
+ WDP_LOGD("Succeeded to reject peer[" MACSTR "]", MAC2STR(peer_addr));
+ _ws_flush();
__WDP_LOG_FUNC_EXIT__;
return res;
}
-int ws_get_visibility(int *visibility)
+int ws_cancel_connection(unsigned char *peer_addr)
{
__WDP_LOG_FUNC_ENTER__;
+ _ws_cancel();
+
__WDP_LOG_FUNC_EXIT__;
return 0;
}
-int ws_set_visibility(int visibility)
+int ws_get_connected_peers(GList **peers, int *peer_count)
+{
+ __WDP_LOG_FUNC_ENTER__;
+
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
+
+int ws_get_pin(char *pin)
+{
+ __WDP_LOG_FUNC_ENTER__;
+
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
+
+int ws_set_pin(char *pin)
+{
+ __WDP_LOG_FUNC_ENTER__;
+
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
+
+static void __ws_get_pin(GVariant *value, void *user_data)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ const char *pin = NULL;
+
+ g_variant_get(value, "(&s)", &pin);
+ g_strlcpy((char *)user_data, pin, OEM_PINSTR_LEN + 1);
+
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+}
+
+int ws_generate_pin(char **pin)
{
__WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *g_dbus = NULL;
+ dbus_method_param_s params;
+ char n_pin[9] = {0,};
+ int res = 0;
+
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ return -1;
+ }
+
+ g_dbus = g_pd->g_dbus;
+ if (!g_dbus) {
+ WDP_LOGE("DBus connection is NULL");
+ return -1;
+ }
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
+
+ dbus_set_method_param(¶ms, "GeneratePin", g_pd->iface_path, g_dbus);
+ params.params = NULL;
+
+ res = dbus_method_call(¶ms, SUPPLICANT_WPS, __ws_get_pin, (void *)n_pin);
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to generate_pin [ %s ]", n_pin);
+ *pin = strndup(n_pin, OEM_PINSTR_LEN);
__WDP_LOG_FUNC_EXIT__;
return 0;
}
-int ws_get_scan_result(GList **peers, int *peer_count)
+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;
}
-int ws_get_peer_info(unsigned char *peer_addr, wfd_oem_device_s **peer)
+int _ws_get_persistent_net_id(int *persistent_network_id, const unsigned char *go_dev_mac)
{
__WDP_LOG_FUNC_ENTER__;
- GDBusConnection *g_dbus = NULL;
- wfd_oem_device_s *ws_dev = NULL;
- static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
+ int persistent_group_count = 0;
+ int counter = 0;
int res = 0;
- if (!peer_addr || !peer) {
- WDP_LOGE("Invalid parameter");
- return -1;
- }
+ wfd_oem_persistent_group_s *plist = NULL;
- if (!g_pd) {
- WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ res = ws_get_persistent_groups(&plist, &persistent_group_count);
+ if (res < 0) {
+ WDP_LOGE("failed to get persistent groups");
+ __WDP_LOG_FUNC_EXIT__;
return -1;
}
- g_dbus = g_pd->g_dbus;
- if (!g_dbus) {
- WDP_LOGE("DBus connection is NULL");
- return -1;
+ if (persistent_group_count > WS_MAX_PERSISTENT_COUNT) {
+ WDP_LOGE("persistent group count greater than max Persistent count");
+ persistent_group_count = WS_MAX_PERSISTENT_COUNT;
}
- 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));
- __WDP_LOG_FUNC_EXIT__;
- return -1;
+ WDP_LOGD("Persistent Group Count=%d", persistent_group_count);
+
+ for (counter = 0; counter < persistent_group_count ; counter++) {
+ if (!memcmp(go_dev_mac, plist[counter].go_mac_address, WS_MACADDR_LEN)) {
+ *persistent_network_id = plist[counter].network_id;
+ break;
+ } else {
+ WDP_LOGD("Invite: Persistent GO[" MACSTR "], GO Addr[" MACSTR "]",
+ MAC2STR(plist[counter].go_mac_address), MAC2STR(go_dev_mac));
+ }
}
- g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
- COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
+ g_free(plist);
+ plist = NULL;
+ WDP_LOGD("persistent network ID : [%d]", *persistent_network_id);
- WDP_LOGD("get peer path [%s]", peer_path);
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
- res = dbus_property_get_all(peer_path, g_dbus, SUPPLICANT_P2P_PEER,
- __ws_get_peer_property, ws_dev);
+static void __store_group_iface_path(GVariant* value, void* user_data)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ ws_dbus_plugin_data_s * pd_data;
+ const char *path = NULL;
- if (res < 0) {
- WDP_LOGE("Failed to send command to wpa_supplicant");
- g_free(ws_dev);
- __WDP_LOG_FUNC_EXIT__;
- return -1;
- } else {
- WDP_LOGD("succeeded to get peer info");
- *peer = ws_dev;
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ return;
}
- __WDP_LOG_FUNC_EXIT__;
- return 0;
+
+ pd_data = (ws_dbus_plugin_data_s *) g_pd;
+
+ g_variant_get(value, "(&o)", &path);
+ g_strlcpy(pd_data->group_iface_path, path, DBUS_OBJECT_PATH_MAX);
+
+ WDP_LOGD("group object path [%s]", pd_data->group_iface_path);
+ /* subscribe interface p2p signal */
}
-int ws_prov_disc_req(unsigned char *peer_addr, wfd_oem_wps_mode_e wps_mode, int join)
+int ws_create_group(wfd_oem_group_param_s *param)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
+ GVariantBuilder *builder = NULL;
GVariant *value = NULL;
dbus_method_param_s params;
- static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
+ char persistent_group_obj_path[OBJECT_PATH_MAX] = {0,};
int res = 0;
- if (!peer_addr) {
+ if (!param) {
WDP_LOGE("Invalid parameter");
__WDP_LOG_FUNC_EXIT__;
return -1;
}
memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- dbus_set_method_param(¶ms, "ProvisionDiscoveryRequest", g_pd->iface_path, g_dbus);
+ dbus_set_method_param(¶ms, "GroupAdd", g_pd->iface_path, g_dbus);
- g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
- COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
- WDP_LOGD("get peer path [%s]", peer_path);
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+
+ if (param->persistent > 0) {
+ unsigned char mac_address[WS_MACADDR_LEN] = {0x00, };
+ int persistent_group_id = -1;
+
+ res = _ws_get_local_dev_mac(mac_address);
+ if (res < 0) {
+ WDP_LOGE("failed to get local mac address");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ res = _ws_get_persistent_net_id(&persistent_group_id, mac_address);
+ if (res < 0) {
+ WDP_LOGE("failed to get persistent group ID");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ WDP_LOGD("persistent network ID : [%d]", persistent_group_id);
+
+ g_variant_builder_add(builder, "{sv}", "persistent",
+ g_variant_new_boolean(TRUE));
+ if (persistent_group_id > -1) {
+ g_snprintf(persistent_group_obj_path, OBJECT_PATH_MAX,
+ "%s/" SUPPLICANT_PERSISTENT_GROUPS_PART "/%d",
+ g_pd->iface_path, persistent_group_id);
+ g_variant_builder_add(builder, "{sv}", "persistent_group_object",
+ g_variant_new_object_path(persistent_group_obj_path));
+ }
+
+ } else {
+ g_variant_builder_add(builder, "{sv}", "persistent",
+ g_variant_new_boolean(FALSE));
+ }
+
+ if (param->passphrase && strlen(param->passphrase) > 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));
- value = g_variant_new ("(os)", peer_path, __ws_wps_to_txt(wps_mode));
+ 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);
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE,
+ __store_group_iface_path, g_pd);
if (res < 0)
WDP_LOGE("Failed to send command to wpa_supplicant");
else
- WDP_LOGD("Succeeded to send prov disc to peer[" MACSTR "]", MAC2STR(peer_addr));
+ WDP_LOGD("Succeeded to add group");
__WDP_LOG_FUNC_EXIT__;
return res;
}
-int ws_connect(unsigned char *peer_addr, wfd_oem_conn_param_s *param)
+int ws_destroy_group(const char *ifname)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
- GVariantBuilder *builder = NULL;
- GVariant *value = NULL;
dbus_method_param_s params;
- static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
int res = 0;
- if (!peer_addr || !param) {
+ if (!ifname) {
WDP_LOGE("Invalid parameter");
- __WDP_LOG_FUNC_EXIT__;
return -1;
}
__WDP_LOG_FUNC_EXIT__;
return -1;
}
- memset(¶ms, 0x0, sizeof(dbus_method_param_s));
-
- dbus_set_method_param(¶ms, "Connect", g_pd->iface_path, g_dbus);
-
- g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
- COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
- WDP_LOGD("get peer path [%s]", peer_path);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
- g_variant_builder_add (builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
- if (param->conn_flags & WFD_OEM_CONN_TYPE_PERSISTENT)
- g_variant_builder_add (builder, "{sv}", "persistent", g_variant_new_boolean(TRUE));
-
- if (param->conn_flags & WFD_OEM_CONN_TYPE_JOIN)
- g_variant_builder_add (builder, "{sv}", "join", g_variant_new_boolean(TRUE));
-
- if (param->conn_flags& WFD_OEM_CONN_TYPE_AUTH)
- g_variant_builder_add (builder, "{sv}", "autorize_only", g_variant_new_boolean(TRUE));
-
- if (param->wps_pin[0] != '\0')
- g_variant_builder_add (builder, "{sv}", "pin", g_variant_new_string(param->wps_pin));
-
- g_variant_builder_add (builder, "{sv}", "wps_method",
- g_variant_new_string(__ws_wps_to_txt(param->wps_mode)));
+ if (g_pd->group_iface_path[0] == 0) {
+ WDP_LOGE("group iface path is NULL");
+ return -1;
+ }
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- params.params = value;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ dbus_set_method_param(¶ms, "Disconnect", g_pd->group_iface_path, g_dbus);
+ params.params = NULL;
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
- if (res < 0)
+ if (res < 0) {
WDP_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to send connection command to peer[" MACSTR "]", MAC2STR(peer_addr));
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ } else {
+ _ws_flush();
+ WDP_LOGD("Succeeded to remove group");
+ }
__WDP_LOG_FUNC_EXIT__;
- return res;
+ return 0;
}
-int ws_disconnect(unsigned char *peer_addr)
+int ws_invite(unsigned char *peer_addr, wfd_oem_invite_param_s *param)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
+ GVariantBuilder *builder = NULL;
GVariant *value = NULL;
dbus_method_param_s params;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
int res = 0;
- if (!peer_addr) {
+ if (!peer_addr || !param) {
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;
}
memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- dbus_set_method_param(¶ms, "RemoveClient", g_pd->iface_path ,g_dbus);
+ dbus_set_method_param(¶ms, "Invite", g_pd->group_iface_path, g_dbus);
g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
WDP_LOGE("get peer path [%s]", peer_path);
- value = g_variant_new ("(oi)", peer_path, 0);
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
+ 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)
WDP_LOGE("Failed to send command to wpa_supplicant");
else
- WDP_LOGD("Succeeded to stop scan");
+ WDP_LOGD("Succeeded to invite peer[" MACSTR "]", MAC2STR(peer_addr));
__WDP_LOG_FUNC_EXIT__;
- return res;
+ return 0;
}
-int ws_reject_connection(unsigned char *peer_addr)
+/* Only group owner can use this command */
+int ws_wps_start(unsigned char *peer_addr, int wps_mode, const char *pin)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
+ GVariantBuilder *builder = NULL;
GVariant *value = NULL;
+ GVariant *dev_addr = NULL;
dbus_method_param_s params;
- static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
+ int i = 0;
int 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__;
__WDP_LOG_FUNC_EXIT__;
return -1;
}
- memset(¶ms, 0x0, sizeof(dbus_method_param_s));
-
- dbus_set_method_param(¶ms, "RejectPeer", g_pd->iface_path ,g_dbus);
-
- g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
- COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
- WDP_LOGE("get peer path [%s]", peer_path);
-
- 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 */
-
- res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
- if (res < 0)
- WDP_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to reject peer[" MACSTR "]", MAC2STR(peer_addr));
- _ws_flush();
- __WDP_LOG_FUNC_EXIT__;
- return res;
-}
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
-int ws_cancel_connection(unsigned char *peer_addr)
-{
- __WDP_LOG_FUNC_ENTER__;
+ dbus_set_method_param(¶ms, "Start", g_pd->group_iface_path, g_dbus);
- _ws_cancel();
+ if (peer_addr != NULL) {
+ builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < WS_MACADDR_LEN; i++)
+ g_variant_builder_add(builder, "y", peer_addr[i]);
- __WDP_LOG_FUNC_EXIT__;
- return 0;
-}
+ dev_addr = g_variant_new("ay", builder);
+ g_variant_builder_unref(builder);
+ }
-int ws_get_connected_peers(GList **peers, int *peer_count)
-{
- __WDP_LOG_FUNC_ENTER__;
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "Role", g_variant_new_string("enrollee"));
+ if (peer_addr != NULL)
+ g_variant_builder_add(builder, "{sv}", "P2PDeviceAddress", dev_addr);
- __WDP_LOG_FUNC_EXIT__;
- return 0;
-}
+ if (pin != NULL && pin[0] != '\0') {
+ g_variant_builder_add(builder, "{sv}", "Type", g_variant_new_string("pin"));
+ g_variant_builder_add(builder, "{sv}", "Pin", g_variant_new_string(pin));
+ } else {
+ g_variant_builder_add(builder, "{sv}", "Type", g_variant_new_string("pbc"));
+ }
-int ws_get_pin(char *pin)
-{
- __WDP_LOG_FUNC_ENTER__;
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
- __WDP_LOG_FUNC_EXIT__;
- return 0;
-}
+ params.params = value;
+ DEBUG_G_VARIANT("Params : ", params.params);
-int ws_set_pin(char *pin)
-{
- __WDP_LOG_FUNC_ENTER__;
+ res = dbus_method_call(¶ms, SUPPLICANT_WPS, NULL, NULL);
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to run wps");
__WDP_LOG_FUNC_EXIT__;
return 0;
}
-static void __ws_get_pin(GVariant *value, void *user_data)
+int ws_enrollee_start(unsigned char *peer_addr, int wps_mode, const char *pin)
{
__WDP_LOG_FUNC_ENTER__;
- const char *pin = NULL;
- g_variant_get(value, "(&s)", &pin);
- g_strlcpy((char *)user_data, pin, OEM_PINSTR_LEN + 1);
+ WDP_LOGD("Succeeded to start WPS");
__WDP_LOG_FUNC_EXIT__;
- return;
+ return 0;
}
-int ws_generate_pin(char **pin)
+int ws_wps_cancel(void)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
dbus_method_param_s params;
- char n_pin[9] = {0,};
int res = 0;
- if (!g_pd) {
- WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
- 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, "GeneratePin", g_pd->iface_path ,g_dbus);
+ dbus_set_method_param(¶ms, "Cancel", g_pd->group_iface_path, g_dbus);
params.params = NULL;
- res = dbus_method_call(¶ms, SUPPLICANT_WPS, __ws_get_pin, (void *)n_pin);
+ res = dbus_method_call(¶ms, SUPPLICANT_WPS, NULL, NULL);
if (res < 0)
WDP_LOGE("Failed to send command to wpa_supplicant");
else
- WDP_LOGD("Succeeded to generate_pin [ %s ]", n_pin);
+ WDP_LOGD("Succeeded to cancel WPS");
- *pin = strndup(n_pin, OEM_PINSTR_LEN);
__WDP_LOG_FUNC_EXIT__;
return 0;
}
-int ws_get_supported_wps_mode()
+int ws_get_dev_name(char *dev_name)
{
__WDP_LOG_FUNC_ENTER__;
return 0;
}
-int _ws_get_persistent_net_id(int *persistent_network_id, const unsigned char *go_dev_mac)
+int ws_set_dev_name(char *dev_name)
{
__WDP_LOG_FUNC_ENTER__;
- int persistent_group_count = 0;
- int counter = 0;
+ GDBusConnection *g_dbus = NULL;
+
+ GVariant *value = NULL;
+ GVariant *param = NULL;
+ GVariantBuilder *builder = NULL;
+ dbus_method_param_s params;
int res = 0;
- wfd_oem_persistent_group_s *plist = NULL;
+ if (!dev_name) {
+ WDP_LOGE("Invalid parameter");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
- res = ws_get_persistent_groups(&plist, &persistent_group_count);
- if (res < 0) {
- WDP_LOGE("failed to get persistent groups");
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
__WDP_LOG_FUNC_EXIT__;
return -1;
}
- if (persistent_group_count > WS_MAX_PERSISTENT_COUNT) {
- WDP_LOGE("persistent group count greater than max Persistent count");
- persistent_group_count = WS_MAX_PERSISTENT_COUNT;
+ 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("Persistent Group Count=%d", persistent_group_count);
+ dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
+ g_dbus);
- for (counter = 0; counter < persistent_group_count ; counter++) {
- if(!memcmp(go_dev_mac, plist[counter].go_mac_address, WS_MACADDR_LEN)) {
- *persistent_network_id = plist[counter].network_id;
- break;
- } else {
- WDP_LOGD("Invite: Persistent GO[" MACSTR "], GO Addr[" MACSTR "]",
- MAC2STR(plist[counter].go_mac_address), MAC2STR(go_dev_mac));
- }
- }
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "DeviceName",
+ g_variant_new_string(dev_name));
+ g_variant_builder_add(builder, "{sv}", "SsidPostfix",
+ g_variant_new_string(dev_name));
+ value = g_variant_new("a{sv}", builder);
+ g_variant_builder_unref(builder);
- g_free(plist);
- plist = NULL;
- WDP_LOGD("persistent network ID : [%d]", *persistent_network_id);
+ param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE,
+ "P2PDeviceConfig", value);
+
+ params.params = param;
+ DEBUG_G_VARIANT("Params : ", params.params);
+
+ res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to set device name");
__WDP_LOG_FUNC_EXIT__;
- return 0;
+ return res;
}
-static void __store_group_iface_path(GVariant *value, void *user_data) {
+int ws_get_dev_mac(char *dev_mac)
+{
__WDP_LOG_FUNC_ENTER__;
- ws_dbus_plugin_data_s * pd_data;
- const char *path = NULL;
- if (!g_pd) {
- WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
- return;
- }
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
- pd_data = (ws_dbus_plugin_data_s *) g_pd;
+int ws_get_dev_type(int *pri_dev_type, int *sec_dev_type)
+{
+ __WDP_LOG_FUNC_ENTER__;
- g_variant_get(value, "(&o)", &path);
- g_strlcpy(pd_data->group_iface_path, path, DBUS_OBJECT_PATH_MAX);
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
- WDP_LOGD("group object path [%s]", pd_data->group_iface_path);
- /* subscribe interface p2p signal */
+int ws_set_dev_type(int pri_dev_type, int sec_dev_type)
+{
+ __WDP_LOG_FUNC_ENTER__;
+
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
}
-int ws_create_group(wfd_oem_group_param_s *param)
+int ws_get_go_intent(int *go_intent)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
- GVariantBuilder *builder = NULL;
- GVariant *value = NULL;
- dbus_method_param_s params;
- char persistent_group_obj_path[OBJECT_PATH_MAX] = {0,};
- int res = 0;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+ GError *error = NULL;
+ GVariantIter *iter = NULL;
- if (!param) {
+
+ if (!go_intent) {
WDP_LOGE("Invalid parameter");
- __WDP_LOG_FUNC_EXIT__;
return -1;
}
__WDP_LOG_FUNC_EXIT__;
return -1;
}
- memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- dbus_set_method_param(¶ms, "GroupAdd", g_pd->iface_path, g_dbus);
+ param = g_variant_new("(ss)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig");
+ DEBUG_G_VARIANT("Params : ", param);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
+ reply = g_dbus_connection_call_sync(
+ g_dbus,
+ SUPPLICANT_SERVICE, /* bus name */
+ g_pd->iface_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 */
- if (param->persistent > 0) {
- unsigned char mac_address[WS_MACADDR_LEN] = {0x00, };
- int persistent_group_id = -1;
+ if (error != NULL) {
+ WDP_LOGE("Error! Failed to get interface State: [%s]",
+ error->message);
+ g_error_free(error);
+ if (reply)
+ g_variant_unref(reply);
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
- res = _ws_get_local_dev_mac(mac_address);
- if (res < 0) {
- WDP_LOGE("failed to get local mac address");
- __WDP_LOG_FUNC_EXIT__;
- return -1;
- }
+ if (reply != NULL) {
+ g_variant_get(reply, "(a{sv})", &iter);
- res = _ws_get_persistent_net_id(&persistent_group_id, mac_address);
- if(res < 0) {
- WDP_LOGE("failed to get persistent group ID");
- __WDP_LOG_FUNC_EXIT__;
- return -1;
- }
+ if (iter != NULL) {
+ gchar *key = NULL;
+ GVariant *value = NULL;
- WDP_LOGD("persistent network ID : [%d]", persistent_group_id);
+ while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
+ CHECK_KEY_VALUE(key, value);
- g_variant_builder_add(builder, "{sv}", "persistent",
- g_variant_new_boolean(TRUE));
- if(persistent_group_id > -1) {
- g_snprintf(persistent_group_obj_path, OBJECT_PATH_MAX,
- "%s/" SUPPLICANT_PERSISTENT_GROUPS_PART "/%d",
- g_pd->iface_path, persistent_group_id);
- g_variant_builder_add(builder, "{sv}", "persistent_group_object",
- g_variant_new_object_path(persistent_group_obj_path));
+ if (g_strcmp0(key, "GOIntent") == 0)
+ g_variant_get(value, "u", go_intent);
+ }
+ g_variant_iter_free(iter);
}
-
- } else {
- g_variant_builder_add(builder, "{sv}", "persistent",
- g_variant_new_boolean(FALSE));
+ g_variant_unref(reply);
}
-
- if (param->passphrase && strlen(param->passphrase) > 0)
- g_variant_builder_add(builder, "{sv}", "passphrase",
- g_variant_new_string(param->passphrase));
-
- if (param->freq)
- g_variant_builder_add(builder, "{sv}", "frequency",
- g_variant_new_int32(param->freq));
-
- 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 */
-
- res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE,
- __store_group_iface_path, g_pd);
- if (res < 0)
- WDP_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to add group");
-
__WDP_LOG_FUNC_EXIT__;
- return res;
+ return 0;
}
-int ws_destroy_group(const char *ifname)
+int ws_set_go_intent(int go_intent)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
+
+ GVariant *value = NULL;
+ GVariant *param = NULL;
+ GVariantBuilder *builder = NULL;
dbus_method_param_s params;
int res = 0;
- if (!ifname) {
- 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;
}
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- if (g_pd->group_iface_path[0] == 0) {
- WDP_LOGE("group iface path is NULL");
- return -1;
- }
+ dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
+ g_dbus);
- memset(¶ms, 0x0, sizeof(dbus_method_param_s));
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "GOIntent",
+ g_variant_new_uint32(go_intent));
+ value = g_variant_new("a{sv}", builder);
+ g_variant_builder_unref(builder);
- dbus_set_method_param(¶ms, "Disconnect", g_pd->group_iface_path, g_dbus);
- params.params = NULL;
+ param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig", value);
- 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;
- } else {
- _ws_flush();
- WDP_LOGD("Succeeded to remove group");
- }
+ params.params = param;
+ DEBUG_G_VARIANT("Params : ", params.params);
+ res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGE("Succeeded to set go intent");
__WDP_LOG_FUNC_EXIT__;
- return 0;
+ return res;
}
-int ws_invite(unsigned char *peer_addr, wfd_oem_invite_param_s *param)
+int ws_set_country(char *ccode)
{
__WDP_LOG_FUNC_ENTER__;
+ __WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
- GVariantBuilder *builder = NULL;
+
GVariant *value = NULL;
+ GVariant *param = NULL;
+
dbus_method_param_s params;
- static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
int res = 0;
- if (!peer_addr || !param) {
- 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;
}
memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- dbus_set_method_param(¶ms, "Invite", g_pd->group_iface_path, g_dbus);
+ dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
+ g_dbus);
- g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
- COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
- WDP_LOGE("get peer path [%s]", peer_path);
+ value = g_variant_new_string(ccode);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
- g_variant_builder_add (builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
+ param = g_variant_new("(ssv)", SUPPLICANT_IFACE, "Country", value);
- params.params = value;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ params.params = param;
+ DEBUG_G_VARIANT("Params : ", params.params);
- res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
+ res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
if (res < 0)
WDP_LOGE("Failed to send command to wpa_supplicant");
else
- WDP_LOGD("Succeeded to invite peer[" MACSTR "]", MAC2STR(peer_addr));
+ WDP_LOGD("Succeeded to set country(%s)", ccode);
__WDP_LOG_FUNC_EXIT__;
- return 0;
+ return res;
}
-// Only group owner can use this command
-int ws_wps_start(unsigned char *peer_addr, int wps_mode, const char *pin)
+void __parsing_networks(const char* key, GVariant* value, void* user_data)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ if (!user_data) {
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
+ ws_network_info_s *network = (ws_network_info_s *)user_data;
+
+ CHECK_KEY_VALUE(key, value);
+
+ if (g_strcmp0(key, "ssid") == 0) {
+ const char *ssid = NULL;
+ g_variant_get(value, "&s", &ssid);
+ WDP_LOGD("ssid [%s]", ssid);
+ g_strlcpy(network->ssid, ssid + 1, WS_SSID_LEN + 1);
+ network->ssid[strlen(ssid) - 2] = '\0';
+
+ } else if (g_strcmp0(key, "bssid") == 0) {
+ unsigned char *bssid = NULL;
+ g_variant_get(value, "&s", &bssid);
+ WDP_LOGD("bssid [%s]", bssid);
+ __ws_txt_to_mac(bssid, network->bssid);
+
+ } else if (g_strcmp0(key, "proto") == 0) {
+ const char *proto = NULL;
+ g_variant_get(value, "&s", &proto);
+ WDP_LOGD("proto [%s]", proto);
+
+ if (g_strrstr(proto, WFD_OEM_STR_PROTO_WPA) != NULL)
+ network->proto |= WFD_OEM_PROTO_WPA;
+ if (g_strrstr(proto, WFD_OEM_STR_PROTO_RSN) != NULL)
+ network->proto |= WFD_OEM_PROTO_RSN;
+
+ } else if (g_strcmp0(key, "key_mgmt") == 0) {
+ const char *key_mgmt = NULL;
+ g_variant_get(value, "&s", &key_mgmt);
+ WDP_LOGD("key_mgmt [%s]", key_mgmt);
+
+ if (g_strrstr(key_mgmt, WFD_OEM_STR_KEY_MGMT_IEEE8021X) != NULL)
+ network->key_mgmt |= WFD_OEM_KEY_MGMT_IEEE8021X;
+ if (g_strrstr(key_mgmt, WFD_OEM_STR_KEY_MGMT_PSK) != NULL)
+ network->key_mgmt |= WFD_OEM_KEY_MGMT_PSK;
+ if (g_strrstr(key_mgmt, WFD_OEM_STR_KEY_MGMT_NONE) != NULL)
+ network->key_mgmt |= WFD_OEM_KEY_MGMT_NONE;
+
+ } else if (g_strcmp0(key, "pairwise") == 0) {
+ const char *pairwise = NULL;
+ g_variant_get(value, "&s", &pairwise);
+ WDP_LOGD("pairwise [%s]", pairwise);
+
+ if (g_strrstr(pairwise, WFD_OEM_STR_CIPHER_NONE) != NULL)
+ network->pairwise |= WFD_OEM_CIPHER_NONE;
+ if (g_strrstr(pairwise, WFD_OEM_STR_CIPHER_TKIP) != NULL)
+ network->pairwise |= WFD_OEM_CIPHER_TKIP;
+ if (g_strrstr(pairwise, WFD_OEM_STR_CIPHER_CCMP) != NULL)
+ network->pairwise |= WFD_OEM_CIPHER_CCMP;
+
+ } else if (g_strcmp0(key, "group") == 0) {
+ const char *group = NULL;
+ g_variant_get(value, "&s", &group);
+ WDP_LOGD("group [%s]", group);
+
+ if (g_strrstr(group, WFD_OEM_STR_CIPHER_NONE) != NULL)
+ network->group |= WFD_OEM_CIPHER_NONE;
+ if (g_strrstr(group, WFD_OEM_STR_CIPHER_WEP40) != NULL)
+ network->group |= WFD_OEM_CIPHER_WEP40;
+ if (g_strrstr(group, WFD_OEM_STR_CIPHER_WEP104) != NULL)
+ network->group |= WFD_OEM_CIPHER_WEP104;
+ if (g_strrstr(group, WFD_OEM_STR_CIPHER_TKIP) != NULL)
+ network->group |= WFD_OEM_CIPHER_TKIP;
+ if (g_strrstr(group, WFD_OEM_STR_CIPHER_CCMP) != NULL)
+ network->group |= WFD_OEM_CIPHER_CCMP;
+
+ } else if (g_strcmp0(key, "auth_alg") == 0) {
+ const char *auth_alg = NULL;
+ g_variant_get(value, "&s", &auth_alg);
+ WDP_LOGD("auth_alg [%s]", auth_alg);
+
+ if (g_strrstr(auth_alg, WFD_OEM_STR_AUTH_ALG_OPEN) != NULL)
+ network->auth_alg |= WFD_OEM_AUTH_ALG_OPEN;
+
+ } else if (g_strcmp0(key, "mode") == 0) {
+ const char *mode = NULL;
+ g_variant_get(value, "&s", &mode);
+ WDP_LOGD("mode [%s]", mode);
+
+ if (g_strrstr(mode, WFD_OEM_STR_MODE_GC) != NULL)
+ network->mode |= WFD_OEM_PERSISTENT_MODE_GC;
+ if (g_strrstr(mode, WFD_OEM_STR_MODE_GO) != NULL)
+ network->mode |= WFD_OEM_PERSISTENT_MODE_GO;
+
+ } else if (g_strcmp0(key, "p2p_client_list") == 0) {
+ const char *p2p_client_list = NULL;
+ char *ptr = NULL;
+ int list_len = 0;
+ int num = 0;
+
+ g_variant_get(value, "&s", &p2p_client_list);
+ WDP_LOGD("p2p_client_list [%s]", p2p_client_list);
+ ptr = (char *)p2p_client_list;
+ list_len = strlen(p2p_client_list);
+ WDP_LOGD("list_len [%d]", list_len);
+ while (ptr && list_len >= (OEM_MACSTR_LEN - 1)) {
+ __ws_txt_to_mac((unsigned char *)ptr, (network->p2p_client_list[num]));
+ ptr += OEM_MACSTR_LEN;
+ list_len -= OEM_MACSTR_LEN;
+ if (ptr && ptr[0] == ' ') {
+ ptr += 1;
+ list_len -= 1;
+ }
+ num++;
+ if (num >= OEM_MAX_PEER_NUM)
+ break;
+ }
+ network->p2p_client_num = num;
+ WDP_LOGD("p2p_client_num [%d]", network->p2p_client_num);
+ }
+ return;
+}
+
+void __ws_extract_p2pdevice_details(const char *key, GVariant *value, void *user_data)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ CHECK_KEY_VALUE(key, value);
+
+ if (g_strcmp0(key, "PersistentGroups") == 0) {
+ GVariantIter *iter = NULL;
+ const char *path = NULL;
+ int num = 0;
+
+ ws_network_info_s *networks = NULL;
+ networks = (ws_network_info_s *)user_data;
+ if (!networks) {
+ WDP_LOGE("network is NULL");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
+ g_variant_get(value, "ao", &iter);
+ while (g_variant_iter_loop(iter, "&o", &path)) {
+ char *loc = NULL;
+
+ if (num >= WS_MAX_PERSISTENT_COUNT)
+ break;
+
+ WDP_LOGD("Retrive persistent path [%s]", path);
+ g_strlcpy(networks[num].persistent_path, path, DBUS_OBJECT_PATH_MAX);
+
+ loc = strrchr(networks[num].persistent_path, '/');
+ 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,
+ SUPPLICANT_P2P_PERSISTENTGROUP, __parsing_networks, &networks[num]);
+ num++;
+ }
+
+ networks[0].total = num;
+ WDP_LOGI("total number [%d]", num);
+ g_variant_iter_free(iter);
+ }
+ __WDP_LOG_FUNC_EXIT__;
+}
+
+
+int ws_get_persistent_groups(wfd_oem_persistent_group_s **groups, int *group_count)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
- GVariantBuilder *builder = NULL;
- GVariant *value = NULL;
- GVariant *dev_addr = NULL;
- dbus_method_param_s params;
- int i = 0;
- int res = 0;
+
+ ws_network_info_s networks[WS_MAX_PERSISTENT_COUNT];
+ wfd_oem_persistent_group_s *wfd_persistent_groups = NULL;
+ int i, cnt = 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, "Start", g_pd->group_iface_path, g_dbus);
+ 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[0]);
- if (peer_addr != NULL) {
- builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
- for(i = 0; i < WS_MACADDR_LEN; i++)
- g_variant_builder_add(builder, "y", peer_addr[i]);
+ cnt = networks[0].total;
- dev_addr = g_variant_new ("ay", builder);
- g_variant_builder_unref (builder);
+ 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;
}
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
- g_variant_builder_add (builder, "{sv}", "Role", g_variant_new_string("enrollee"));
- if (peer_addr != NULL)
- g_variant_builder_add (builder, "{sv}", "P2PDeviceAddress", dev_addr);
-
- if (pin != NULL && pin[0] != '\0') {
- g_variant_builder_add (builder, "{sv}", "Type", g_variant_new_string("pin"));
- g_variant_builder_add (builder, "{sv}", "Pin", g_variant_new_string(pin));
- } else {
- g_variant_builder_add (builder, "{sv}", "Type", g_variant_new_string("pbc"));
+ if (cnt == 0) {
+ WDP_LOGE("Persistent group count zero");
+ *group_count = 0;
+ *groups = NULL;
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
}
- 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 */
+ wfd_persistent_groups = (wfd_oem_persistent_group_s *) g_try_malloc0(cnt * sizeof(wfd_oem_persistent_group_s));
+ if (wfd_persistent_groups == NULL) {
+ WDP_LOGE("Failed to allocate memory for wfd_persistent_groups ");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
- res = dbus_method_call(¶ms, SUPPLICANT_WPS, NULL, NULL);
- if (res < 0)
- WDP_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to run wps");
+ for (i = 0; i < cnt; i++) {
+ int j = 0;
- __WDP_LOG_FUNC_EXIT__;
- return 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]));
-int ws_enrollee_start(unsigned char *peer_addr, int wps_mode, const char *pin)
-{
- __WDP_LOG_FUNC_ENTER__;
+ wfd_persistent_groups[i].network_id = networks[i].network_id;
+ g_strlcpy(wfd_persistent_groups[i].ssid, networks[i].ssid, WS_SSID_LEN + 1);
+ memcpy(wfd_persistent_groups[i].go_mac_address, networks[i].bssid, WS_MACADDR_LEN);
+ wfd_persistent_groups[i].p2p_client_num = networks[i].p2p_client_num;
+ if (wfd_persistent_groups[i].p2p_client_num > 0)
+ memcpy(wfd_persistent_groups[i].p2p_client_list, networks[i].p2p_client_list,
+ OEM_MACADDR_LEN * OEM_MAX_PEER_NUM * sizeof(char));
+ }
- WDP_LOGD("Succeeded to start WPS");
+ *group_count = cnt;
+ *groups = wfd_persistent_groups;
__WDP_LOG_FUNC_EXIT__;
return 0;
}
-int ws_wps_cancel()
+int ws_remove_persistent_group(char *ssid, unsigned char *bssid)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
+
dbus_method_param_s params;
+ ws_network_info_s networks[WS_MAX_PERSISTENT_COUNT];
+ int i, cnt = 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(¶ms, 0x0, sizeof(dbus_method_param_s));
+ 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, "Cancel", g_pd->group_iface_path, g_dbus);
- params.params = NULL;
+ cnt = networks[0].total;
- res = dbus_method_call(¶ms, SUPPLICANT_WPS, NULL, NULL);
- if (res < 0)
- WDP_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to cancel WPS");
+ 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;
+ }
- __WDP_LOG_FUNC_EXIT__;
- return 0;
-}
+ for (i = 0; i < cnt; i++) {
+ int j = 0;
-int ws_get_dev_name(char *dev_name)
-{
- __WDP_LOG_FUNC_ENTER__;
+ WDP_LOGD("----persistent group [%d]----", i);
+ WDP_LOGD("network_id [%d]", networks[i].network_id);
+ WDP_LOGD("network ssid [%s]", networks[i].ssid);
+ WDP_LOGD("network bssid ["MACSTR"]", MAC2STR(networks[i].bssid));
+ WDP_LOGD("network p2p_client_num [%d]", networks[i].p2p_client_num);
+ for (j = 0; j < networks[i].p2p_client_num; j++)
+ WDP_LOGD("network p2p_client_list ["MACSTR"]",
+ MAC2STR(networks[i].p2p_client_list[j]));
+
+ WDP_LOGD("ssid [%s]", ssid);
+ WDP_LOGD("bssid ["MACSTR"]", MAC2STR(bssid));
+
+ if (!g_strcmp0(ssid, networks[i].ssid) &&
+ !memcmp(bssid, networks[i].bssid, WS_MACADDR_LEN)) {
+ WDP_LOGD("Persistent group owner found [%d: %s]",
+ networks[i].network_id, ssid);
+
+ 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)", networks[i].persistent_path);
+ DEBUG_G_VARIANT("Params : ", params.params);
+
+ 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;
+ }
+
+ WDP_LOGD("Succeeded to remove persistent group");;
+ break;
+ }
+ }
+
+ if (i == cnt) {
+ WDP_LOGE("Persistent group not found [%s]", ssid);
+ return -1;
+ }
__WDP_LOG_FUNC_EXIT__;
return 0;
}
-int ws_set_dev_name(char *dev_name)
+int ws_set_persistent_reconnect(unsigned char *bssid, int reconnect)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
dbus_method_param_s params;
int res = 0;
- if (!dev_name) {
- 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;
}
memset(¶ms, 0x0, sizeof(dbus_method_param_s));
dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
- g_dbus);
+ g_dbus);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
- g_variant_builder_add (builder, "{sv}", "DeviceName",
- g_variant_new_string(dev_name));
- g_variant_builder_add (builder, "{sv}", "SsidPostfix",
- g_variant_new_string(dev_name));
- value = g_variant_new ("a{sv}", builder);
- g_variant_builder_unref (builder);
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "PersistentReconnect",
+ g_variant_new_boolean(reconnect));
+ value = g_variant_new("a{sv}", builder);
+ g_variant_builder_unref(builder);
- param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE,
- "P2PDeviceConfig", value);
+ 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)
WDP_LOGE("Failed to send command to wpa_supplicant");
else
- WDP_LOGD("Succeeded to set device name");
+ WDP_LOGD("Succeeded to set persistent reconnect");
__WDP_LOG_FUNC_EXIT__;
return res;
}
-int ws_get_dev_mac(char *dev_mac)
+static int __ws_compress_query(char *compressed, char *query, int qtype)
{
- __WDP_LOG_FUNC_ENTER__;
+ char *token = NULL;
+ char *temp = NULL;
+ int token_num = 0;
+ int token_len = 0;
+ int length = 0;
- __WDP_LOG_FUNC_EXIT__;
- return 0;
-}
+ token = strtok_r(query, ".", &temp);
+ while (token) {
+ if (!strcmp(token, "local")) {
+ WDP_LOGD("Query conversion done");
+ break;
-int ws_get_dev_type(int *pri_dev_type, int *sec_dev_type)
-{
- __WDP_LOG_FUNC_ENTER__;
+ } else if (!strncmp(token, "_tcp", 4)) {
+ memcpy(&compressed[length], WS_TCP_PTR_HEX, 2);
+ length += 2;
- __WDP_LOG_FUNC_EXIT__;
- return 0;
+ } else if (!strncmp(token, "_udp", 4)) {
+ memcpy(&compressed[length], WS_UDP_PTR_HEX, 2);
+ length += 2;
+
+ } else {
+ WDP_LOGD("Token: [%s]", token);
+ token_len = strlen(token);
+ compressed[length] = token_len;
+ length++;
+
+ memcpy(&compressed[length], token, token_len);
+ length += token_len;
+ }
+ token_num++;
+ token = strtok_r(NULL, ".", &temp);
+ }
+ if (qtype == WS_QTYPE_PTR || token_num == 2)
+ memcpy(&compressed[length], WS_PTR_TYPE_HEX, 3);
+ else if (qtype == WS_QTYPE_TXT || token_num == 3)
+ memcpy(&compressed[length], WS_TXT_TYPE_HEX, 3);
+
+ length += 3;
+ WDP_LOGD("converted query length [%d] token num [%d]", length, token_num);
+
+ return length;
}
-int ws_set_dev_type(int pri_dev_type, int sec_dev_type)
+static int __ws_compress_rdata(char *compressed, char *rdata, int qtype)
{
- __WDP_LOG_FUNC_ENTER__;
+ char *token = NULL;
+ char *temp = NULL;
+ int token_len = 0;
+ int length = 0;
- __WDP_LOG_FUNC_EXIT__;
- return 0;
+ if (qtype == WS_QTYPE_PTR) {
+
+ token = strtok_r(rdata, ".", &temp);
+ if (token) {
+ WDP_LOGD("Token: %s", token);
+ token_len = strlen(token);
+ compressed[length] = token_len;
+ length++;
+
+ memcpy(&compressed[length], token, token_len);
+ length += token_len;
+ }
+
+ compressed[length] = 0xc0;
+ compressed[length+1] = 0x27;
+ length += 2;
+
+ } else if (qtype == WS_QTYPE_TXT) {
+
+ token = strtok_r(rdata, ",", &temp);
+
+ while (token) {
+ WDP_LOGD("Token: [%s]", token);
+
+ token_len = strlen(token);
+ compressed[length] = token_len;
+ length++;
+
+ memcpy(&compressed[length], token, token_len);
+ length += token_len;
+
+ token = strtok_r(NULL, ",", &temp);
+ }
+ } else {
+ WDP_LOGD("RDATA is NULL");
+ }
+ return length;
}
-int ws_get_go_intent(int *go_intent)
+int _convert_bonjour_to_args(char *query, char *rdata, GVariantBuilder *builder)
{
- __WDP_LOG_FUNC_ENTER__;
- GDBusConnection *g_dbus = NULL;
- GVariant *param = NULL;
- GVariant *reply = NULL;
- GError *error = NULL;
- GVariantIter *iter = NULL;
-
+ GVariantBuilder *args = NULL;
+ char compressed[256] = {0, };
+ char *temp = NULL;
+ int length = 0;
+ int qtype = 0;
+ int i = 0;
- if (!go_intent) {
+ if (!query || !builder) {
WDP_LOGE("Invalid parameter");
return -1;
}
+ if (!rdata || !strlen(rdata)) {
+ WDP_LOGD("RDATA is NULL\n");
+ } else {
+ temp = strstr(rdata, query);
- if (!g_pd) {
- WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
- return -1;
+ if (temp != NULL && temp - rdata > 0)
+ qtype = WS_QTYPE_PTR;
+ else
+ qtype = WS_QTYPE_TXT;
+ temp = NULL;
}
- g_dbus = g_pd->g_dbus;
- if (!g_dbus) {
- WDP_LOGE("DBus connection is NULL");
- return -1;
- }
+ g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("bonjour"));
- param = g_variant_new("(ss)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig");
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(param);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ /* compress query */
+ length = __ws_compress_query(compressed, query, qtype);
- reply = g_dbus_connection_call_sync (
- g_dbus,
- SUPPLICANT_SERVICE, /* bus name */
- g_pd->iface_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 */
+ args = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < length; i++)
+ g_variant_builder_add(args, "y", compressed[i]);
+ g_variant_builder_add(builder, "{sv}", "query", g_variant_new("ay", args));
+ g_variant_builder_unref(args);
- if(error != NULL) {
- WDP_LOGE("Error! Failed to get interface State: [%s]",
- error->message);
- g_error_free(error);
- if(reply)
- g_variant_unref(reply);
- __WDP_LOG_FUNC_EXIT__;
- return -1;
+ memset(compressed, 0x0, 256);
+ length = 0;
+ args = NULL;
+
+ if (qtype != 0) {
+ length = __ws_compress_rdata(compressed, rdata, qtype);
+
+ args = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < length; i++)
+ g_variant_builder_add(args, "y", compressed[i]);
+ g_variant_builder_add(builder, "{sv}", "response", g_variant_new("ay", args));
+ g_variant_builder_unref(args);
+ }
+
+ return 0;
+}
+
+int _check_service_query_exists(wfd_oem_service_s *service)
+{
+ int count = 0;
+ wfd_oem_service_s *data = NULL;
+
+ for (count = 0; count < g_list_length(service_list); count++) {
+ data = (wfd_oem_service_s*) g_list_nth_data(service_list, count);
+ if (strncmp(service->query_id, data->query_id, OEM_QUERY_ID_LEN) == 0) {
+ WDP_LOGD("Query already exists");
+ return 1;
+ }
}
+ return 0;
+}
- if (reply != NULL) {
- g_variant_get(reply, "(a{sv})", &iter);
+static wfd_oem_service_s* _remove_service_query(char * s_type, char *mac_str, char *query_id)
+{
+ if (NULL == s_type || NULL == mac_str || NULL == query_id)
+ return NULL;
- if (iter != NULL) {
- gchar *key = NULL;
- GVariant *value = NULL;
+ int count = 0;
+ wfd_oem_service_s *data = 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);
- }
- g_variant_iter_free(iter);
+ for (count = 0; count < g_list_length(service_list); count++) {
+ 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) {
+ g_strlcpy(query_id, data->query_id, OEM_QUERY_ID_LEN + 1);
+ break;
}
- g_variant_unref(reply);
}
- __WDP_LOG_FUNC_EXIT__;
- return 0;
+ if (strlen(query_id) <= 0) {
+ WDP_LOGD("!! Query ID not found !!");
+ return NULL;
+ }
+
+ WDP_LOGD("query id :[%s]", query_id);
+
+ return data;
}
-int ws_set_go_intent(int go_intent)
+void __add_service_query(GVariant *value, void *user_data)
{
__WDP_LOG_FUNC_ENTER__;
- GDBusConnection *g_dbus = NULL;
+ wfd_oem_service_s *service = NULL;
- GVariant *value = NULL;
- GVariant *param = NULL;
- GVariantBuilder *builder = NULL;
- dbus_method_param_s params;
+ long long unsigned ref = 0;
int res = 0;
- if (!g_pd) {
- WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
- return -1;
- }
-
- g_dbus = g_pd->g_dbus;
- if (!g_dbus) {
- WDP_LOGE("DBus connection is NULL");
- return -1;
- }
- memset(¶ms, 0x0, sizeof(dbus_method_param_s));
+ if (!user_data)
+ return;
- dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
- g_dbus);
+ g_variant_get(value, "(t)", &ref);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
- g_variant_builder_add (builder, "{sv}", "GOIntent",
- g_variant_new_uint32(go_intent));
- value = g_variant_new ("a{sv}", builder);
- g_variant_builder_unref (builder);
+ service = (wfd_oem_service_s*) g_try_malloc0(sizeof(wfd_oem_service_s));
+ if (!service) {
+ WDP_LOGE("Failed to allocate memory for service");
+ return;
+ }
- param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig", value);
+ memcpy(service, user_data, sizeof(wfd_oem_service_s));
- params.params = param;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ g_snprintf(service->query_id, OEM_QUERY_ID_LEN + 1, "%llx", ref);
- res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
- if (res < 0)
- WDP_LOGE("Failed to send command to wpa_supplicant");
+ res = _check_service_query_exists(service);
+ if (res)
+ g_free(service);
else
- WDP_LOGE("Succeeded to set go intent");
+ service_list = g_list_append(service_list, service);
+
__WDP_LOG_FUNC_EXIT__;
- return res;
+ return;
+
}
-int ws_set_country(char *ccode)
+/* for now, supplicant dbus interface only provides upnp service fully */
+int ws_start_service_discovery(unsigned char *mac_addr, int service_type)
{
__WDP_LOG_FUNC_ENTER__;
- __WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
-
+ GVariantBuilder *builder = NULL;
GVariant *value = NULL;
- GVariant *param = NULL;
-
+ wfd_oem_service_s data = {0,};
dbus_method_param_s params;
+ static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
+ int i = 0;
int res = 0;
+ if (!mac_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));
- dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
- g_dbus);
-
- value = g_variant_new_string(ccode);
-
- 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 */
-
- res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
- if (res < 0)
- WDP_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to set country(%s)", ccode);
+ dbus_set_method_param(¶ms, "ServiceDiscoveryRequest", g_pd->iface_path, g_dbus);
- __WDP_LOG_FUNC_EXIT__;
- return res;
-}
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
-void __parsing_networks (const char *key, GVariant *value, void *user_data)
-{
- __WDP_LOG_FUNC_ENTER__;
- if(!user_data) {
- __WDP_LOG_FUNC_EXIT__;
- return;
+ 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(builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
}
- 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);
- WDP_LOGD("ssid [%s]", ssid);
- g_strlcpy(network->ssid, ssid + 1, WS_SSID_LEN + 1);
- network->ssid[strlen(ssid) - 2] = '\0';
+ if (service_type == WFD_OEM_SERVICE_TYPE_ALL) {
- } else if (g_strcmp0(key, "bssid") == 0) {
- unsigned char *bssid = NULL;
- g_variant_get(value, "&s", &bssid);
- WDP_LOGD("bssid [%s]", bssid);
- __ws_txt_to_mac(bssid, network->bssid);
+ char *service_all = "\x02\x00\x00\x01";
+ GVariantBuilder *query = NULL;
- } else if (g_strcmp0(key, "proto") == 0) {
- const char *proto = NULL;
- g_variant_get(value, "&s", &proto);
- WDP_LOGD("proto [%s]", proto);
+ query = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < SERVICE_QUERY_LEN; i++)
+ 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);
- if (g_strrstr(proto, WFD_OEM_STR_PROTO_WPA) != NULL)
- network->proto |= WFD_OEM_PROTO_WPA;
- if (g_strrstr(proto, WFD_OEM_STR_PROTO_RSN) != NULL)
- network->proto |= WFD_OEM_PROTO_RSN;
+ } else if (service_type == WFD_OEM_SERVICE_TYPE_UPNP) {
- } else if (g_strcmp0(key, "key_mgmt") == 0) {
- const char *key_mgmt = NULL;
- g_variant_get(value, "&s", &key_mgmt);
- WDP_LOGD("key_mgmt [%s]", key_mgmt);
+ g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("upnp"));
+ 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);
- if (g_strrstr(key_mgmt, WFD_OEM_STR_KEY_MGMT_IEEE8021X) != NULL)
- network->key_mgmt |= WFD_OEM_KEY_MGMT_IEEE8021X;
- if (g_strrstr(key_mgmt, WFD_OEM_STR_KEY_MGMT_PSK) != NULL)
- network->key_mgmt |= WFD_OEM_KEY_MGMT_PSK;
- if (g_strrstr(key_mgmt, WFD_OEM_STR_KEY_MGMT_NONE) != NULL)
- network->key_mgmt |= WFD_OEM_KEY_MGMT_NONE;
+ } else if (service_type == WFD_OEM_SERVICE_TYPE_BONJOUR) {
- } else if (g_strcmp0(key, "pairwise") == 0) {
- const char *pairwise = NULL;
- g_variant_get(value, "&s", &pairwise);
- WDP_LOGD("pairwise [%s]", pairwise);
+ char *service_bonjour = "\x02\x00\x01\x01";
+ GVariantBuilder *query = NULL;
- if (g_strrstr(pairwise, WFD_OEM_STR_CIPHER_NONE) != NULL)
- network->pairwise |= WFD_OEM_CIPHER_NONE;
- if (g_strrstr(pairwise, WFD_OEM_STR_CIPHER_TKIP) != NULL)
- network->pairwise |= WFD_OEM_CIPHER_TKIP;
- if (g_strrstr(pairwise, WFD_OEM_STR_CIPHER_CCMP) != NULL)
- network->pairwise |= WFD_OEM_CIPHER_CCMP;
+ 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}", "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);
+ }
- } else if (g_strcmp0(key, "group") == 0) {
- const char *group = NULL;
- g_variant_get(value, "&s", &group);
- WDP_LOGD("group [%s]", group);
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
- if (g_strrstr(group, WFD_OEM_STR_CIPHER_NONE) != NULL)
- network->group |= WFD_OEM_CIPHER_NONE;
- if (g_strrstr(group, WFD_OEM_STR_CIPHER_WEP40) != NULL)
- network->group |= WFD_OEM_CIPHER_WEP40;
- if (g_strrstr(group, WFD_OEM_STR_CIPHER_WEP104) != NULL)
- network->group |= WFD_OEM_CIPHER_WEP104;
- if (g_strrstr(group, WFD_OEM_STR_CIPHER_TKIP) != NULL)
- network->group |= WFD_OEM_CIPHER_TKIP;
- if (g_strrstr(group, WFD_OEM_STR_CIPHER_CCMP) != NULL)
- network->group |= WFD_OEM_CIPHER_CCMP;
+ params.params = value;
+ DEBUG_G_VARIANT("Params : ", params.params);
- } else if (g_strcmp0(key, "auth_alg") == 0) {
- const char *auth_alg = NULL;
- g_variant_get(value, "&s", &auth_alg);
- WDP_LOGD("auth_alg [%s]", auth_alg);
+ 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));
- if (g_strrstr(auth_alg, WFD_OEM_STR_AUTH_ALG_OPEN) != NULL)
- network->auth_alg |= WFD_OEM_AUTH_ALG_OPEN;
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, __add_service_query, &data);
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to start service discovery");
- } else if (g_strcmp0(key, "mode") == 0) {
- const char *mode = NULL;
- g_variant_get(value, "&s", &mode);
- WDP_LOGD("mode [%s]", mode);
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
+}
- if (g_strrstr(mode, WFD_OEM_STR_MODE_GC) != NULL)
- network->mode |= WFD_OEM_PERSISTENT_MODE_GC;
- if (g_strrstr(mode, WFD_OEM_STR_MODE_GO) != NULL)
- network->mode |= WFD_OEM_PERSISTENT_MODE_GO;
+int ws_cancel_service_discovery(unsigned char *mac_addr, int service_type)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *g_dbus = NULL;
+ dbus_method_param_s params;
+ wfd_oem_service_s *data = NULL;
+ 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;
- } else if (g_strcmp0(key, "p2p_client_list") == 0) {
- const char *p2p_client_list = NULL;
- char *ptr = NULL;
- int list_len = 0;
- int num = 0;
+ int res = 0;
- g_variant_get(value, "&s", &p2p_client_list);
- WDP_LOGD("p2p_client_list [%s]", p2p_client_list);
- ptr = (char *)p2p_client_list;
- list_len = strlen(p2p_client_list);
- WDP_LOGD("list_len [%d]", list_len);
- while (ptr && list_len >= (OEM_MACSTR_LEN - 1)) {
- __ws_txt_to_mac((unsigned char *)ptr, (network->p2p_client_list[num]));
- ptr += OEM_MACSTR_LEN;
- list_len -= OEM_MACSTR_LEN;
- if (ptr && ptr[0] == ' ') {
- ptr += 1;
- list_len -= 1;
- }
- num++;
- if (num >= OEM_MAX_PEER_NUM)
- break;
- }
- network->p2p_client_num = num;
- WDP_LOGD("p2p_client_num [%d]", network->p2p_client_num);
+ if (!mac_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;
}
- return;
-}
-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;
- int num = 0;
+ g_dbus = g_pd->g_dbus;
+ if (!g_dbus) {
+ WDP_LOGE("DBus connection is NULL");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
- ws_network_info_s *networks = NULL;
- networks = (ws_network_info_s *)user_data;
- if(!networks) {
- WDP_LOGE("network is NULL");
- __WDP_LOG_FUNC_EXIT__;
- return;
- }
+ 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));
+ }
- g_variant_get(value, "ao", &iter);
- while(g_variant_iter_loop(iter, "&o", &path)) {
- char *loc = NULL;
+ switch (service_type) {
+ case WFD_OEM_SERVICE_TYPE_ALL:
+ g_strlcpy(s_type, SERV_DISC_REQ_ALL, OEM_SERVICE_TYPE_LEN + 1);
+ break;
+ case WFD_OEM_SERVICE_TYPE_BONJOUR:
+ g_strlcpy(s_type, SERV_DISC_REQ_BONJOUR, OEM_SERVICE_TYPE_LEN + 1);
+ break;
+ case WFD_OEM_SERVICE_TYPE_UPNP:
+ g_strlcpy(s_type, SERV_DISC_REQ_UPNP, OEM_SERVICE_TYPE_LEN + 1);
+ break;
+ default:
+ WDP_LOGE("Invalid Service type");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
- if(num >= WS_MAX_PERSISTENT_COUNT)
- break;
+ WDP_LOGD("Cancel service discovery service_type [%d]", service_type);
+ WDP_LOGD("Cancel service discovery s_type [%s]", s_type);
- WDP_LOGD("Retrive persistent path [%s]", path);
- g_strlcpy(networks[num].persistent_path, path, DBUS_OBJECT_PATH_MAX);
+ data = _remove_service_query(s_type, mac_str, query_id);
+ if (NULL == data) {
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- loc = strrchr(networks[num].persistent_path, '/');
- networks[num].network_id = strtoul(loc+1, NULL, 10);
+ dbus_set_method_param(¶ms, "ServiceDiscoveryCancelRequest", g_pd->iface_path, g_dbus);
+ id = (long long unsigned)strtoul(query_id, NULL, 16);
+ params.params = g_variant_new("(t)", id);
- WDP_LOGD("Retrive persistent path [%s]", networks[num].persistent_path);
- dbus_property_get_all(networks[num].persistent_path, g_pd->g_dbus,
- SUPPLICANT_P2P_PERSISTENTGROUP, __parsing_networks, &networks[num]);
- num++;
- }
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to cancel service discovery");
+
+ service_list = g_list_remove(service_list, data);
+ free(data);
- networks[0].total = num;
- WDP_LOGI("total number [%d]", num);
- g_variant_iter_free(iter);
- }
__WDP_LOG_FUNC_EXIT__;
+ return res;
}
-
-int ws_get_persistent_groups(wfd_oem_persistent_group_s **groups, int *group_count)
+int ws_serv_add(wfd_oem_new_service_s *service)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
-
- ws_network_info_s networks[WS_MAX_PERSISTENT_COUNT];
- wfd_oem_persistent_group_s *wfd_persistent_groups = NULL;
- int i, cnt = 0;
+ GVariantBuilder *builder = NULL;
+ GVariant *value = 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;
}
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- 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[0]);
+ dbus_set_method_param(¶ms, "AddService", g_pd->iface_path, g_dbus);
- cnt = networks[0].total;
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
- 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;
+ if (service->protocol == WFD_OEM_SERVICE_TYPE_BONJOUR) {
+
+ WDP_LOGD("Service type: WFD_OEM_SERVICE_TYPE_BONJOUR");
+ WDP_LOGD("Query: %s", service->data.bonjour.query);
+ WDP_LOGD("RData: %s", service->data.bonjour.rdata);
+
+ res = _convert_bonjour_to_args(service->data.bonjour.query,
+ service->data.bonjour.rdata, builder);
+ if (res < 0) {
+ WDP_LOGE("Failed to convert Key string");
+ g_variant_builder_unref(builder);
+ return -1;
+ }
+
+ } 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_int32(10));
+ g_variant_builder_add(builder, "{sv}", "service", g_variant_new_string(service->data.upnp.service));
}
- if(cnt == 0) {
- WDP_LOGE("Persistent group count zero");
- *group_count = 0;
- *groups = NULL;
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
+
+ params.params = value;
+ DEBUG_G_VARIANT("Params : ", params.params);
+
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to add service");
+
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
+}
+
+int ws_serv_del(wfd_oem_new_service_s *service)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *g_dbus = NULL;
+ GVariantBuilder *builder = NULL;
+ GVariant *value = 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 0;
+ return -1;
}
- wfd_persistent_groups = (wfd_oem_persistent_group_s *) g_try_malloc0(cnt * sizeof(wfd_oem_persistent_group_s));
- if (wfd_persistent_groups == NULL) {
- WDP_LOGE("Failed to allocate memory for wfd_persistent_groups ");
+ 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));
- for (i = 0; i < cnt; i++) {
- int j = 0;
+ dbus_set_method_param(¶ms, "DeleteService", g_pd->iface_path, g_dbus);
- 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]));
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
- wfd_persistent_groups[i].network_id = networks[i].network_id;
- g_strlcpy(wfd_persistent_groups[i].ssid, networks[i].ssid, WS_SSID_LEN + 1);
- memcpy(wfd_persistent_groups[i].go_mac_address, networks[i].bssid, WS_MACADDR_LEN);
- wfd_persistent_groups[i].p2p_client_num = networks[i].p2p_client_num;
- if (wfd_persistent_groups[i].p2p_client_num > 0)
- memcpy(wfd_persistent_groups[i].p2p_client_list, networks[i].p2p_client_list,
- OEM_MACADDR_LEN * OEM_MAX_PEER_NUM * sizeof(char));
+ if (service->protocol == WFD_OEM_SERVICE_TYPE_BONJOUR) {
+
+ WDP_LOGD("Service type: WFD_OEM_SERVICE_TYPE_BONJOUR");
+ WDP_LOGD("Query: %s", service->data.bonjour.query);
+
+ res = _convert_bonjour_to_args(service->data.bonjour.query,
+ NULL, builder);
+ if (res < 0) {
+ WDP_LOGE("Failed to convert Key string");
+ g_variant_builder_unref(builder);
+ return -1;
+ }
+
+ } 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_int32(10));
+ g_variant_builder_add(builder, "{sv}", "service", g_variant_new_string(service->data.upnp.service));
}
- *group_count = cnt;
- *groups = wfd_persistent_groups;
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
+
+ params.params = value;
+ DEBUG_G_VARIANT("Params : ", params.params);
+
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to del service");
__WDP_LOG_FUNC_EXIT__;
return 0;
}
-int ws_remove_persistent_group(char *ssid, unsigned char *bssid)
+int _ws_disable_display()
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
-
+ GVariantBuilder *builder = NULL;
+ GVariant *value = NULL;
+ GVariant *param = NULL;
dbus_method_param_s params;
- ws_network_info_s networks[WS_MAX_PERSISTENT_COUNT];
- int i, cnt = 0;
int res = 0;
if (!g_pd) {
__WDP_LOG_FUNC_EXIT__;
return -1;
}
- dbus_property_get_all(g_pd->iface_path, g_dbus, SUPPLICANT_P2PDEVICE,
- __ws_extract_p2pdevice_details, networks);
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- cnt = networks[0].total;
+ dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, SUPPLICANT_PATH,
+ g_dbus);
- 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;
- }
+ builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ value = g_variant_new("ay", builder);
+ g_variant_builder_unref(builder);
- for (i = 0; i < cnt; i++) {
- int j = 0;
+ param = g_variant_new("(ssv)", SUPPLICANT_INTERFACE, "WFDIEs", value);
- WDP_LOGD("----persistent group [%d]----", i);
- WDP_LOGD("network_id [%d]", networks[i].network_id);
- WDP_LOGD("network ssid [%s]", networks[i].ssid);
- WDP_LOGD("network bssid ["MACSTR"]", MAC2STR(networks[i].bssid));
- WDP_LOGD("network p2p_client_num [%d]", networks[i].p2p_client_num);
- for(j = 0; j < networks[i].p2p_client_num; j++)
- WDP_LOGD("network p2p_client_list ["MACSTR"]",
- MAC2STR(networks[i].p2p_client_list[j]));
+ params.params = param;
+ DEBUG_G_VARIANT("Params : ", params.params);
- WDP_LOGD("ssid [%s]", ssid);
- WDP_LOGD("bssid ["MACSTR"]", MAC2STR(bssid));
+ res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to disable Wi-Fi display");
- if (!g_strcmp0(ssid, networks[i].ssid) &&
- !memcmp(bssid, networks[i].bssid, WS_MACADDR_LEN)) {
- WDP_LOGD("Persistent group owner found [%d: %s]",
- networks[i].network_id, ssid);
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
+}
- 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)", networks[i].persistent_path);
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+int ws_miracast_init(int enable)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ wfd_oem_display_s wifi_display;
+ int res = 0;
- 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;
- }
+ memset(&wifi_display, 0x0, sizeof(wfd_oem_display_s));
- WDP_LOGD("Succeeded to remove persistent group");;
- break;
- }
- }
+ wifi_display.availability = enable;
+ wifi_display.hdcp_support = 1;
+ wifi_display.port = 0x07E6;
+ wifi_display.max_tput = 0x0028;
- if (i == cnt) {
- WDP_LOGE("Persistent group not found [%s]", ssid);
+ res = ws_set_display(&wifi_display);
+ if (res < 0) {
+ WDP_LOGE("Failed to set miracast parameter(device info)");
+ __WDP_LOG_FUNC_EXIT__;
return -1;
}
-
+
+ if (!enable) {
+ res = _ws_disable_display();
+ if (res < 0)
+ WDP_LOGE("Failed to disable wifi display");
+ else
+ WDP_LOGD("Succeeded to disable wifi display");
+ }
__WDP_LOG_FUNC_EXIT__;
- return 0;
+ return res;
}
-int ws_set_persistent_reconnect(unsigned char *bssid, int reconnect)
+int ws_set_display(wfd_oem_display_s *wifi_display)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
GVariant *param = NULL;
GVariantBuilder *builder = NULL;
dbus_method_param_s params;
+ int i = 0;
int res = 0;
- if (!g_pd) {
- WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ unsigned char ies[WFD_SUBELEM_LEN_DEV_INFO + 3] = {0,};
+
+ if (!wifi_display) {
+ WDP_LOGE("Invalid parameter");
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);
+ dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, SUPPLICANT_PATH,
+ g_dbus);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
- g_variant_builder_add (builder, "{sv}", "PersistentReconnect",
- g_variant_new_boolean(reconnect));
- value = g_variant_new ("a{sv}", builder);
- g_variant_builder_unref (builder);
+ ies[2] = WFD_SUBELEM_LEN_DEV_INFO;
+ ies[3] = wifi_display->hdcp_support;
+ ies[4] = (wifi_display->type) | (wifi_display->availability<<4);
+ ies[5] = wifi_display->port>>8;
+ ies[6] = wifi_display->port&0xff;
+ ies[7] = wifi_display->max_tput>>8;
+ ies[8] = wifi_display->max_tput&0xff;
- param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig", value);
+ builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < WFD_SUBELEM_LEN_DEV_INFO + 3; i++)
+ g_variant_builder_add(builder, "y", ies[i]);
+ value = g_variant_new("ay", builder);
+ g_variant_builder_unref(builder);
+
+ 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_LOGE("Failed to send command to wpa_supplicant");
else
- WDP_LOGD("Succeeded to set persistent reconnect");
+ WDP_LOGD("Succeeded to set Wi-Fi Display");
__WDP_LOG_FUNC_EXIT__;
return res;
}
-#ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
-static int __ws_compress_query(char *compressed, char *query, int qtype)
-{
- char *token = NULL;
- char *temp = NULL;
- int token_num = 0;
- int token_len = 0;
- int length = 0;
-
- token = strtok_r(query, ".", &temp);
- while (token) {
- if (!strcmp(token, "local")) {
- WDP_LOGD("Query conversion done");
- break;
-
- } else if (!strncmp(token, "_tcp", 4)) {
- memcpy(&compressed[length], WS_TCP_PTR_HEX, 2);
- length+=2;
-
- } else if (!strncmp(token, "_udp", 4)) {
- memcpy(&compressed[length], WS_UDP_PTR_HEX, 2);
- length+=2;
-
- } else {
- WDP_LOGD("Token: [%s]", token);
- token_len = strlen(token);
- compressed[length] = token_len;
- length++;
-
- memcpy(&compressed[length], token, token_len);
- length+=token_len;
- }
- token_num++;
- token = strtok_r(NULL, ".", &temp);
- }
- if(qtype == WS_QTYPE_PTR || token_num == 2) {
- memcpy(&compressed[length], WS_PTR_TYPE_HEX, 3);
- } else if (qtype == WS_QTYPE_TXT || token_num == 3) {
- memcpy(&compressed[length], WS_TXT_TYPE_HEX, 3);
- }
- length+=3;
- WDP_LOGD("converted query length [%d] token num [%d]", length, token_num);
-
- return length;
-}
-
-static int __ws_compress_rdata(char *compressed, char *rdata, int qtype)
+int ws_refresh(void)
{
- char *token = NULL;
- char *temp = NULL;
- int token_len = 0;
- int length = 0;
-
- if (qtype == WS_QTYPE_PTR) {
-
- token = strtok_r(rdata, ".", &temp);
- if (token) {
- WDP_LOGD("Token: %s", token);
- token_len = strlen(token);
- compressed[length] = token_len;
- length++;
-
- memcpy(&compressed[length], token, token_len);
- length+=token_len;
- }
-
- compressed[length] = 0xc0;
- compressed[length+1] = 0x27;
- length+=2;
-
- } else if (qtype == WS_QTYPE_TXT) {
-
- token = strtok_r(rdata, ",", &temp);
-
- while (token) {
- WDP_LOGD("Token: [%s]", token);
-
- token_len = strlen(token);
- compressed[length] = token_len;
- length++;
+ __WDP_LOG_FUNC_ENTER__;
- memcpy(&compressed[length], token, token_len);
- length+=token_len;
+ _ws_cancel();
+ _ws_flush();
- token = strtok_r(NULL, ",", &temp);
- }
- } else {
- WDP_LOGD("RDATA is NULL");
- }
- return length;
+ __WDP_LOG_FUNC_EXIT__;
+ return 0;
}
-int _convert_bonjour_to_args(char *query, char *rdata, GVariantBuilder *builder)
+int ws_save_config(void)
{
- GVariantBuilder *args = NULL;
- char compressed[256] = {0, };
- char *temp = NULL;
- int length = 0;
- int qtype = 0;
- int i = 0;
+ __WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *g_dbus = NULL;
+ dbus_method_param_s params;
+ int res = 0;
- if (!query || !builder) {
- 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;
}
- if (!rdata || !strlen(rdata)) {
- WDP_LOGD("RDATA is NULL\n");
- } else {
- temp = strstr(rdata, query);
-
- if(temp != NULL && temp - rdata > 0)
- qtype = WS_QTYPE_PTR;
- else
- qtype = WS_QTYPE_TXT;
- temp = NULL;
- }
-
- g_variant_builder_add (builder, "{sv}", "service_type", g_variant_new_string("bonjour"));
-
- /* compress query */
- length = __ws_compress_query(compressed, query, qtype);
-
- args = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
- for (i = 0; i < length; i++)
- g_variant_builder_add(args, "y", compressed[i]);
- g_variant_builder_add(builder, "{sv}", "query", g_variant_new ("ay", args));
- g_variant_builder_unref (args);
-
- memset(compressed, 0x0, 256);
- length = 0;
- args = NULL;
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- if(qtype != 0) {
- length = __ws_compress_rdata(compressed, rdata, qtype);
+ dbus_set_method_param(¶ms, "SaveConfig", g_pd->iface_path, g_dbus);
+ params.params = NULL;
- args = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
- for (i = 0; i < length; i++)
- g_variant_builder_add(args, "y", compressed[i]);
- g_variant_builder_add(builder, "{sv}", "response", g_variant_new ("ay", args));
- g_variant_builder_unref (args);
- }
+ res = dbus_method_call(¶ms, SUPPLICANT_IFACE, NULL, NULL);
+ if (res < 0)
+ WDP_LOGE("Failed to save config to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to save config");
- return 0;
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
}
-int _check_service_query_exists(wfd_oem_service_s *service)
+int ws_set_operating_channel(int channel)
{
- int count = 0;
- wfd_oem_service_s *data = NULL;
+ __WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *g_dbus = NULL;
+ GVariant *value = NULL;
+ GVariant *param = NULL;
+ GVariantBuilder *builder = NULL;
+ dbus_method_param_s params;
+ int res = 0;
- for (count = 0; count < g_list_length(service_list); count ++) {
- data = (wfd_oem_service_s*) g_list_nth_data(service_list, count);
- if (strncmp(service->query_id, data->query_id, OEM_QUERY_ID_LEN) == 0) {
- WDP_LOGD("Query already exists");
- return 1;
- }
+ g_dbus = g_pd->g_dbus;
+ if (!g_dbus) {
+ WDP_LOGE("DBus connection is NULL");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
}
- return 0;
-}
-static wfd_oem_service_s* _remove_service_query(char * s_type, char *mac_str, char *query_id)
-{
- if (NULL == s_type || NULL == mac_str || NULL == query_id)
- return NULL;
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- int count = 0;
- wfd_oem_service_s *data = NULL;
+ dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path, g_dbus);
- for (count = 0; count < g_list_length(service_list); count ++) {
- 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);
- break;
- }
- }
- if (strlen(query_id) <= 0) {
- WDP_LOGD("!! Query ID not found !!");
- return NULL;
- }
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "OperChannel", g_variant_new_uint32(channel));
+ value = g_variant_new("a{sv}", builder);
+ g_variant_builder_unref(builder);
- WDP_LOGD("query id :[0x%s]",query_id);
+ param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig", value);
+ params.params = param;
- return data;
+ res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to set Operating Channel");
+
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
}
-void __add_service_query(GVariant *value, void *mac_addr)
+int ws_remove_all_network(void)
{
__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, };
-
+ GDBusConnection *g_dbus = NULL;
+ dbus_method_param_s params;
int res = 0;
- g_variant_get(value, "(t)", &ref);
-
- service = (wfd_oem_service_s*) g_try_malloc0(sizeof(wfd_oem_service_s));
- if (!service) {
- WDP_LOGE("Failed to allocate memory for service");
- 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));
+ 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_strlcpy(service->dev_addr, mac_str, OEM_MACSTR_LEN);
- g_snprintf(service->query_id, OEM_QUERY_ID_LEN + 1, "0x%llx", ref);
+ dbus_set_method_param(¶ms, "RemoveAllNetworks", g_pd->iface_path, g_dbus);
+ params.params = NULL;
- res = _check_service_query_exists(service);
- if(res) {
- free(service);
- } else {
- service_list = g_list_append(service_list, service);
- }
+ res = dbus_method_call(¶ms, SUPPLICANT_IFACE, NULL, NULL);
+ if (res < 0)
+ WDP_LOGE("Failed to send [RemoveAllNetworks] command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to remove all networks from supplicant");
+ WDP_LOGD("Succeeded to remove all network");
__WDP_LOG_FUNC_EXIT__;
- return;
-
+ return res;
}
-/* for now, supplicant dbus interface only provides upnp service fully */
-int ws_start_service_discovery(unsigned char *mac_addr, int service_type)
+int ws_get_wpa_status(int *wpa_status)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
- GVariantBuilder *builder = NULL;
- GVariant *value = NULL;
- dbus_method_param_s params;
- static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- int i = 0;
- int res = 0;
+ GVariant *param = NULL;
+ GVariant *reply = NULL;
+ GError *error = NULL;
- if (!mac_addr ) {
+ if (!wpa_status) {
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;
- }
+ *wpa_status = WFD_OEM_WPA_STATE_MAX;
g_dbus = g_pd->g_dbus;
if (!g_dbus) {
__WDP_LOG_FUNC_EXIT__;
return -1;
}
- memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- dbus_set_method_param(¶ms, "ServiceDiscoveryRequest", g_pd->iface_path, g_dbus);
+ param = g_variant_new("(s)", SUPPLICANT_IFACE);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
+ reply = g_dbus_connection_call_sync(
+ g_pd->g_dbus,
+ SUPPLICANT_SERVICE, /* bus name */
+ g_pd->iface_path, /* object path */
+ DBUS_PROPERTIES_INTERFACE, /* interface name */
+ DBUS_PROPERTIES_METHOD_GETALL, /* method name */
+ param, /* GVariant *params */
+ NULL, /* reply_type */
+ G_DBUS_CALL_FLAGS_NONE, /* flags */
+ SUPPLICANT_TIMEOUT , /* timeout */
+ NULL, /* cancellable */
+ &error); /* error */
- if(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 (builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
+ if (error != NULL) {
+ WDP_LOGE("Error! Failed to get properties: [%s]",
+ error->message);
+ g_error_free(error);
+ if (reply)
+ g_variant_unref(reply);
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
}
- if (service_type == WFD_OEM_SERVICE_TYPE_ALL) {
-
- char *service_all = "\x02\x00\x00\x01";
- GVariantBuilder *query = NULL;
-
- query = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
- for (i = 0; i < SERVICE_QUERY_LEN; i++)
- 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);
-
- } else if (service_type == WFD_OEM_SERVICE_TYPE_UPNP) {
+ gchar *reply_str = NULL;
+ if (reply)
+ reply_str = g_variant_print(reply, TRUE);
+ WDP_LOGE("reply [%s]", reply_str ? reply_str : "NULL");
+ g_free(reply_str);
- 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));
+ if (reply != NULL) {
+ GVariantIter *iter = NULL;
+ g_variant_get(reply, "(a{sv})", &iter);
- } else if (service_type == WFD_OEM_SERVICE_TYPE_BONJOUR) {
+ if (iter != NULL) {
+ gchar *key = NULL;
+ GVariant *value = NULL;
- char *service_bonjour = "\x02\x00\x01\x01";
- GVariantBuilder *query = NULL;
+ while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
+ if (g_strcmp0(key, "State") == 0) {
+ const gchar *state = NULL;
+ g_variant_get(value, "&s", &state);
+ WDP_LOGI("state : [%s]", state);
- 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_unref (query);
+ if (g_strcmp0(state, "disconnected") == 0)
+ *wpa_status = WFD_OEM_WPA_STATE_DISCONNECTED;
+ else if (g_strcmp0(state, "inactive") == 0)
+ *wpa_status = WFD_OEM_WPA_STATE_INACTIVE;
+ else if (g_strcmp0(state, "scanning") == 0)
+ *wpa_status = WFD_OEM_WPA_STATE_SCANNING;
+ else if (g_strcmp0(state, "authenticating") == 0)
+ *wpa_status = WFD_OEM_WPA_STATE_AUTHENTICATING;
+ else if (g_strcmp0(state, "associating") == 0)
+ *wpa_status = WFD_OEM_WPA_STATE_ASSOCIATING;
+ else if (g_strcmp0(state, "associated") == 0)
+ *wpa_status = WFD_OEM_WPA_STATE_ASSOCIATED;
+ else if (g_strcmp0(state, "4way_handshake") == 0)
+ *wpa_status = WFD_OEM_WPA_STATE_4WAY_HANDSHAKE;
+ else if (g_strcmp0(state, "group_handshake") == 0)
+ *wpa_status = WFD_OEM_WPA_STATE_GROUP_HANDSHAKE;
+ else if (g_strcmp0(state, "completed") == 0)
+ *wpa_status = WFD_OEM_WPA_STATE_COMPLETED;
+ else
+ *wpa_status = WFD_OEM_WPA_STATE_MAX;
+ }
+ }
+ g_variant_iter_free(iter);
+ }
+ g_variant_unref(reply);
+ } else {
+ WDP_LOGD("No properties");
}
- 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 */
-
- res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, __add_service_query, mac_addr);
- if (res < 0)
- WDP_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to start service discovery");
+ WDP_LOGI("wpa_status : [%d]", *wpa_status);
__WDP_LOG_FUNC_EXIT__;
- return res;
+ return 0;
}
-int ws_cancel_service_discovery(unsigned char *mac_addr, int service_type)
+int ws_advertise_service(wfd_oem_asp_service_s *service, int replace)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
+ GVariantBuilder *builder = NULL;
+ GVariant *value = NULL;
dbus_method_param_s params;
- wfd_oem_service_s *data = NULL;
- char query_id[OEM_QUERY_ID_LEN + 1] = {0, };
- char s_type[OEM_SERVICE_TYPE_LEN + 1] ={0, };
- char mac_str[18] = {0, };
-
+ unsigned int config_method = 0x1108;
+ int auto_accept = 0;
+ gboolean rep;
int res = 0;
- if (!mac_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;
}
- 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) {
- snprintf(mac_str, WS_MACSTR_LEN , "%s", SERV_BROADCAST_ADDRESS);
- } else {
- snprintf(mac_str, WS_MACSTR_LEN, MACSTR, MAC2STR(mac_addr));
+ if (service->config_method == 2) {
+ config_method = WS_CONFIG_METHOD_KEYPAD |
+ WS_CONFIG_METHOD_DISPLAY;
+ } else if (service->config_method == 3) {
+ config_method = WS_CONFIG_METHOD_DISPLAY;
+ } else if (service->config_method == 4) {
+ config_method = WS_CONFIG_METHOD_KEYPAD;
}
- switch(service_type) {
- case WFD_OEM_SERVICE_TYPE_ALL:
- strncpy(s_type, SERV_DISC_REQ_ALL, OEM_SERVICE_TYPE_LEN);
- break;
- case WFD_OEM_SERVICE_TYPE_BONJOUR:
- strncpy(s_type, SERV_DISC_REQ_BONJOUR, OEM_SERVICE_TYPE_LEN);
- break;
- case WFD_OEM_SERVICE_TYPE_UPNP:
- strncpy(s_type, SERV_DISC_REQ_UPNP, OEM_SERVICE_TYPE_LEN);
- break;
- default:
- WDP_LOGE("Invalid Service type");
- __WDP_LOG_FUNC_EXIT__;
- return -1;
+ if (service->auto_accept) {
+ if (service->role == 0)
+ auto_accept = 1;
+ else
+ auto_accept = 2;
+ } else {
+ auto_accept = 0;
}
- WDP_LOGD("Cancel service discovery service_type [%d]", service_type);
- WDP_LOGD("Cancel service discovery s_type [%s]", s_type);
+ rep = (replace == 1);
- data = _remove_service_query(s_type, mac_str, query_id);
- if (NULL == data) {
- __WDP_LOG_FUNC_EXIT__;
- return -1;
- }
memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- dbus_set_method_param(¶ms, "ServiceDiscoveryCancelRequest", g_pd->iface_path, g_dbus);
+ dbus_set_method_param(¶ms, "AddService", g_pd->iface_path, g_dbus);
+
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+
+ g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("asp"));
+ g_variant_builder_add(builder, "{sv}", "auto_accept", g_variant_new_int32(auto_accept));
+ g_variant_builder_add(builder, "{sv}", "adv_id", g_variant_new_uint32(service->adv_id));
+ g_variant_builder_add(builder, "{sv}", "svc_state", g_variant_new_uint32(service->status));
+ 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));
+ if (service->service_info != NULL)
+ 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);
+ DEBUG_G_VARIANT("Params : ", value);
- params.params = g_variant_new ("(t)", strtoul(query_id, NULL, 16));
+ params.params = value;
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (res < 0)
WDP_LOGE("Failed to send command to wpa_supplicant");
else
- WDP_LOGD("Succeeded to cancel service discovery");
-
- service_list = g_list_remove(service_list, data);
- free(data);
+ WDP_LOGD("Succeeded to add service");
__WDP_LOG_FUNC_EXIT__;
- return res;
+ return 0;
}
-int ws_serv_add(wfd_oem_new_service_s *service)
+int ws_cancel_advertise_service(wfd_oem_asp_service_s *service)
{
__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");
- return -1;
- }
-
g_dbus = g_pd->g_dbus;
if (!g_dbus) {
WDP_LOGE("DBus connection is NULL");
}
memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- dbus_set_method_param(¶ms, "AddService", g_pd->iface_path, g_dbus);
-
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
-
- if (service->protocol == WFD_OEM_SERVICE_TYPE_BONJOUR) {
-
- WDP_LOGD("Service type: WFD_OEM_SERVICE_TYPE_BONJOUR");
- WDP_LOGD("Query: %s", service->data.bonjour.query);
- WDP_LOGD("RData: %s", service->data.bonjour.rdata);
-
- res = _convert_bonjour_to_args(service->data.bonjour.query,
- service->data.bonjour.rdata, builder);
- if (res < 0) {
- WDP_LOGE("Failed to convert Key string");
- g_variant_builder_unref (builder);
- return -1;
- }
+ dbus_set_method_param(¶ms, "DeleteService", g_pd->iface_path, g_dbus);
- } 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}", "service", g_variant_new_string(service->data.upnp.service));
- }
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
+ g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("asp"));
+ g_variant_builder_add(builder, "{sv}", "adv_id", g_variant_new_uint32(service->adv_id));
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
+ DEBUG_G_VARIANT("Params : ", value);
params.params = value;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (res < 0)
WDP_LOGE("Failed to send command to wpa_supplicant");
else
- WDP_LOGD("Succeeded to add service");
+ WDP_LOGD("Succeeded to del service");
__WDP_LOG_FUNC_EXIT__;
return 0;
}
-int ws_serv_del(wfd_oem_new_service_s *service)
+static void __ws_add_seek(wfd_oem_asp_service_s *service)
{
__WDP_LOG_FUNC_ENTER__;
- GDBusConnection *g_dbus = NULL;
- GVariantBuilder *builder = NULL;
- GVariant *value = NULL;
- dbus_method_param_s params;
- int res = 0;
-
- if (!g_pd) {
- WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
- return -1;
+ wfd_oem_asp_service_s *seek = NULL;
+ if (!service) {
+ WDP_LOGE("invalid parameters");
+ return;
}
- g_dbus = g_pd->g_dbus;
- if (!g_dbus) {
- WDP_LOGE("DBus connection is NULL");
- return -1;
+ seek = g_try_malloc0(sizeof(wfd_oem_asp_service_s));
+ if (!seek) {
+ WDP_LOGE("Failed to allocate memory for service");
+ return;
}
- memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- dbus_set_method_param(¶ms, "DeleteService", g_pd->iface_path, g_dbus);
+ service->search_id = (intptr_t)seek;
+ memcpy(seek, service, sizeof(wfd_oem_asp_service_s));
+ if (service->service_type)
+ seek->service_type = strdup(service->service_type);
+ seek_list = g_list_prepend(seek_list, seek);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+}
- if (service->protocol == WFD_OEM_SERVICE_TYPE_BONJOUR) {
+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;
+ GList *list = NULL;
- WDP_LOGD("Service type: WFD_OEM_SERVICE_TYPE_BONJOUR");
- WDP_LOGD("Query: %s", service->data.bonjour.query);
+ for (list = seek_list; list != NULL; list = list->next) {
+ seek = list->data;
+ if (seek && (seek->asp_search_id == asp_search_id)) {
+ WDP_LOGD("List found");
+ break;
+ } else {
+ seek = NULL;
+ }
+ }
+ __WDP_LOG_FUNC_EXIT__;
+ return seek;
+}
- res = _convert_bonjour_to_args(service->data.bonjour.query,
- NULL, builder);
- if (res < 0) {
- WDP_LOGE("Failed to convert Key string");
- g_variant_builder_unref (builder);
- return -1;
+static void __ws_remove_seek(wfd_oem_asp_service_s *service)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ wfd_oem_asp_service_s *seek = NULL;
+ GList *list = NULL;
+
+ for (list = seek_list; list != NULL; list = list->next) {
+
+ seek = list->data;
+ 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_free(seek->service_info);
+ g_free(seek);
}
+ }
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+}
+
+static void __get_asp_search_id(GVariant *value, void *args)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ wfd_oem_asp_service_s *service = NULL;
+ wfd_oem_asp_service_s *seek = NULL;
+ long long unsigned search_id = 0;
- } else if (service->protocol == WFD_OEM_SERVICE_TYPE_UPNP) {
- g_variant_builder_add (builder, "{sv}", "service_type", g_variant_new_string("upnp"));
- g_variant_builder_add (builder, "{sv}", "version", g_variant_new_uint16(TRUE));
- g_variant_builder_add (builder, "{sv}", "service", g_variant_new_string(service->data.upnp.service));
- }
+ g_variant_get(value, "(t)", &search_id);
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
+ service = (wfd_oem_asp_service_s *)args;
+ if (!service) {
+ WDP_LOGE("invalid parameters");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
- params.params = value;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ seek = g_try_malloc0(sizeof(wfd_oem_asp_service_s));
+ if (!seek) {
+ WDP_LOGE("Failed to allocate memory for service");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
- res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
- if (res < 0)
- WDP_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to del service");
+ service->search_id = search_id;
+ memcpy(seek, service, sizeof(wfd_oem_asp_service_s));
+ if (service->service_type)
+ seek->service_type = strdup(service->service_type);
+ if (service->service_info)
+ seek->service_info = strdup(service->service_info);
+ seek_list = g_list_append(seek_list, seek);
__WDP_LOG_FUNC_EXIT__;
- return 0;
+ return;
}
-#endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
-#ifdef TIZEN_FEATURE_WIFI_DISPLAY
-
-int _ws_disable_display()
+int ws_seek_service(wfd_oem_asp_service_s *service)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
- GVariantBuilder *builder = NULL;
- GVariant *value = NULL;
- GVariant *param = NULL;
- dbus_method_param_s params;
+ GList *list = NULL;
+ wfd_oem_asp_service_s *seek = NULL;
int res = 0;
- if (!g_pd) {
- WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
- 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));
+ list = g_list_last(seek_list);
+ if (list == NULL) {
+ service->tran_id = 1;
- dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, SUPPLICANT_PATH,
- g_dbus);
+ } else {
+ seek = list->data;
+ if (seek)
+ service->tran_id = seek->tran_id + 1;
+ else
+ service->tran_id = 1;
+ }
- builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
- value = g_variant_new ("ay", builder);
- g_variant_builder_unref (builder);
+ if (service->service_info) {
+ GVariantBuilder *builder = NULL;
+ GVariant *value = NULL;
+ dbus_method_param_s params;
- param = g_variant_new("(ssv)", SUPPLICANT_INTERFACE, "WFDIEs", value);
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
+ dbus_set_method_param(¶ms, "ServiceDiscoveryRequest",
+ g_pd->iface_path, g_dbus);
- params.params = param;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
- DEBUG_PARAMS(params.params);
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
- res = dbus_method_call(¶ms, DBUS_PROPERTIES_INTERFACE, NULL, NULL);
- if (res < 0)
- WDP_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to disable Wi-Fi display");
+ g_variant_builder_add(builder, "{sv}", "service_type",
+ g_variant_new_string("asp"));
+ g_variant_builder_add(builder, "{sv}", "transaction_id",
+ g_variant_new_byte(service->tran_id));
+ if (service->service_type != NULL)
+ g_variant_builder_add(builder, "{sv}", "svc_str",
+ g_variant_new_string(service->service_type));
- __WDP_LOG_FUNC_EXIT__;
- return res;
-}
+ if (service->service_info != NULL)
+ g_variant_builder_add(builder, "{sv}", "svc_info",
+ g_variant_new_string(service->service_info));
-int ws_miracast_init(int enable)
-{
- __WDP_LOG_FUNC_ENTER__;
- wfd_oem_display_s wifi_display;
- int res = 0;
+ if (service->instance_name != NULL)
+ g_variant_builder_add(builder, "{sv}", "svc_instance",
+ g_variant_new_string(service->instance_name));
- memset(&wifi_display, 0x0, sizeof(wfd_oem_display_s));
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
- wifi_display.availability = enable;
- wifi_display.hdcp_support = 1;
- wifi_display.port = 0x07E6;
- wifi_display.max_tput = 0x0028;
+ DEBUG_G_VARIANT("Params : ", value);
- res = ws_set_display(&wifi_display);
- if (res < 0) {
- WDP_LOGE("Failed to set miracast parameter(device info)");
- __WDP_LOG_FUNC_EXIT__;
- return -1;
- }
+ params.params = value;
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE,
+ __get_asp_search_id, service);
- if(!enable) {
- res = _ws_disable_display();
- if (res < 0)
- WDP_LOGE("Failed to disable wifi display");
- else
- WDP_LOGD("Succeeded to disable wifi display");
+ } else {
+ __ws_add_seek(service);
}
+
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to seek service");
+
__WDP_LOG_FUNC_EXIT__;
return res;
}
-int ws_set_display(wfd_oem_display_s *wifi_display)
+int ws_cancel_seek_service(wfd_oem_asp_service_s *service)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
-
- GVariant *value = NULL;
- GVariant *param = NULL;
- GVariantBuilder *builder = NULL;
+ wfd_oem_asp_service_s *seek = NULL;
dbus_method_param_s params;
- int i = 0;
int res = 0;
- unsigned char ies[WFD_SUBELEM_LEN_DEV_INFO + 3] = {0,};
-
- if (!wifi_display) {
- WDP_LOGE("Invalid parameter");
- 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, SUPPLICANT_PATH,
- g_dbus);
+ seek = __ws_get_seek(service->asp_search_id);
+ if (!seek) {
+ WDP_LOGE("seek data is NULL");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
- ies[2] = WFD_SUBELEM_LEN_DEV_INFO;
- ies[3] = wifi_display->hdcp_support;
- ies[4] = (wifi_display->type) | (wifi_display->availability<<4);
- ies[5] = wifi_display->port>>8;
- ies[6] = wifi_display->port&0xff;
- ies[7] = wifi_display->max_tput>>8;
- ies[8] = wifi_display->max_tput&0xff;
+ if (seek->service_info) {
- builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
- for(i = 0; i < WFD_SUBELEM_LEN_DEV_INFO + 3; i++)
- g_variant_builder_add(builder, "y", ies[i]);
- value = g_variant_new ("ay", builder);
- g_variant_builder_unref (builder);
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
+ dbus_set_method_param(¶ms, "ServiceDiscoveryCancelRequest",
+ g_pd->iface_path, g_dbus);
- param = g_variant_new("(ssv)", SUPPLICANT_INTERFACE, "WFDIEs", value);
+ params.params = g_variant_new("(t)", service->search_id);
- 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_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to set Wi-Fi Display");
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
+ if (res < 0)
+ WDP_LOGE("Failed to send command to wpa_supplicant");
+ else
+ WDP_LOGD("Succeeded to cancel seek service");
+ }
+ if (res == 0)
+ __ws_remove_seek(seek);
__WDP_LOG_FUNC_EXIT__;
return res;
}
-#endif /* TIZEN_FEATURE_WIFI_DISPLAY */
-
-int ws_refresh()
-{
- __WDP_LOG_FUNC_ENTER__;
-
- _ws_cancel();
- _ws_flush();
-
- __WDP_LOG_FUNC_EXIT__;
- return 0;
-}
-int ws_save_config(void)
+int ws_asp_prov_disc_req(wfd_oem_asp_prov_s *asp_params)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
+ GVariantBuilder *builder = NULL;
+ GVariantBuilder *mac_builder = NULL;
+ GVariant *value = NULL;
dbus_method_param_s params;
+ static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
+ int config_method = 0x1000;
int res = 0;
+ int i = 0;
+ if (!asp_params) {
+ WDP_LOGE("Invalid parameter");
+ __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 (asp_params->network_config == WFD_OEM_ASP_WPS_TYPE_PIN_DISPLAY)
+ config_method = 0x8;
+ else if (asp_params->network_config == WFD_OEM_ASP_WPS_TYPE_PIN_KEYPAD)
+ config_method = 0x100;
+
memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- dbus_set_method_param(¶ms, "SaveConfig", g_pd->iface_path, g_dbus);
- params.params = NULL;
+ dbus_set_method_param(¶ms, "ASPProvisionDiscoveryRequest", g_pd->iface_path, g_dbus);
- res = dbus_method_call(¶ms, SUPPLICANT_IFACE, NULL, NULL);
+ 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}"));
+ g_variant_builder_add(builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
+
+ g_variant_builder_add(builder, "{sv}", "adv_id", g_variant_new_uint32(asp_params->adv_id));
+ g_variant_builder_add(builder, "{sv}", "session_id", g_variant_new_uint32(asp_params->session_id));
+ g_variant_builder_add(builder, "{sv}", "role", g_variant_new_byte(asp_params->network_role));
+ g_variant_builder_add(builder, "{sv}", "method", g_variant_new_int32(config_method));
+ if (asp_params->status > 0)
+ g_variant_builder_add(builder, "{sv}", "status", g_variant_new_int32(asp_params->status));
+ if (asp_params->session_information)
+ g_variant_builder_add(builder, "{sv}", "info", g_variant_new_string(asp_params->session_information));
+
+ mac_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < OEM_MACADDR_LEN; i++)
+ g_variant_builder_add(mac_builder, "y", asp_params->service_mac[i]);
+ g_variant_builder_add(builder, "{sv}", "adv_mac",
+ g_variant_new("ay", mac_builder));
+ g_variant_builder_unref(mac_builder);
+
+ mac_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < OEM_MACADDR_LEN; i++)
+ g_variant_builder_add(mac_builder, "y", asp_params->session_mac[i]);
+ g_variant_builder_add(builder, "{sv}", "session_mac",
+ g_variant_new("ay", mac_builder));
+ g_variant_builder_unref(mac_builder);
+
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
+ DEBUG_G_VARIANT("Params : ", value);
+
+ params.params = value;
+
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (res < 0)
- WDP_LOGE("Failed to save config to wpa_supplicant");
+ WDP_LOGE("Failed to send command to wpa_supplicant");
else
- WDP_LOGD("Succeeded to save config");
+ WDP_LOGD("Succeeded to send connection command to peer[" MACSTR "]", MAC2STR(asp_params->service_mac));
__WDP_LOG_FUNC_EXIT__;
return res;
}
-int ws_set_operating_channel(int channel)
+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_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);
+ 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}"));
- g_variant_builder_add (builder, "{sv}", "OperChannel", g_variant_new_uint32(channel));
- value = g_variant_new ("a{sv}", builder);
- g_variant_builder_unref (builder);
+ 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)
+ if (res < 0) {
WDP_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to set Operating Channel");
-
+ } else {
+ WDP_LOGI("Succeeded to set eapol IP");
+ }
__WDP_LOG_FUNC_EXIT__;
return res;
}
-int ws_remove_all_network(void)
+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_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);
- dbus_set_method_param(¶ms, "RemoveAllNetworks", g_pd->iface_path, g_dbus);
- params.params = NULL;
+ 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 [RemoveAllNetworks] command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to remove all networks from supplicant");
+ 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 all network");
+ WDP_LOGD("Succeeded to add vsie: Frame ID [%d], VSIE [%s]", frame_id,
+ vsie);
+
+ g_free(bytearray);
__WDP_LOG_FUNC_EXIT__;
- return res;
+ return 0;
}
-int ws_get_wpa_status(int *wpa_status)
+int ws_get_vsie(wfd_oem_vsie_frames_e frame_id, char **vsie)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
GVariant *reply = NULL;
GError *error = NULL;
- if (!wpa_status) {
+ if (frame_id >= WFD_OEM_VSIE_FRAME_MAX ||
+ vsie == NULL) {
WDP_LOGE("Invalid parameter");
__WDP_LOG_FUNC_EXIT__;
return -1;
}
- *wpa_status = WFD_OEM_WPA_STATE_MAX;
+ 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) {
return -1;
}
- param = g_variant_new("(s)", SUPPLICANT_IFACE);
+ param = g_variant_new("(i)", frame_id);
- reply = g_dbus_connection_call_sync (
+ reply = g_dbus_connection_call_sync(
g_pd->g_dbus,
SUPPLICANT_SERVICE, /* bus name */
g_pd->iface_path, /* object path */
- DBUS_PROPERTIES_INTERFACE, /* interface name */
- DBUS_PROPERTIES_METHOD_GETALL, /* method name */
+ SUPPLICANT_IFACE, /* interface name */
+ "VendorElemGet", /* method name */
param, /* GVariant *params */
NULL, /* reply_type */
G_DBUS_CALL_FLAGS_NONE, /* flags */
- SUPPLICANT_TIMEOUT , /* timeout */
+ SUPPLICANT_TIMEOUT, /* timeout */
NULL, /* cancellable */
&error); /* error */
- if(error != NULL) {
- WDP_LOGE("Error! Failed to get properties: [%s]",
- error->message);
+ if (error != NULL) {
+ WDP_LOGE("Error! Failed to get vsie: [%s]", error->message);
g_error_free(error);
if (reply)
g_variant_unref(reply);
return -1;
}
- gchar *reply_str = NULL;
- if (reply)
- reply_str = g_variant_print(reply, TRUE);
- WDP_LOGE("reply [%s]", reply_str ? reply_str : "NULL");
- g_free(reply_str);
-
- if(reply != NULL) {
- GVariantIter *iter = NULL;
- g_variant_get(reply, "(a{sv})", &iter);
+ if (reply != NULL) {
+ DEBUG_G_VARIANT("Reply : ", reply);
- if (iter != NULL) {
- gchar *key = NULL;
- GVariant *value = NULL;
+ GVariantIter *iter = NULL;
+ unsigned char *vsie_bytes = NULL;
+ int vsie_len = 0;
- while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
- if(g_strcmp0(key, "State") == 0) {
- const gchar *state = NULL;
- g_variant_get(value, "&s", &state);
- WDP_LOGI("state : [%s]", state);
+ g_variant_get(reply, "(ay)", &iter);
+ if (iter == NULL) {
+ WDP_LOGD("vsie is not present");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
- if (g_strcmp0(state, "disconnected") == 0)
- *wpa_status = WFD_OEM_WPA_STATE_DISCONNECTED;
- else if (g_strcmp0(state, "inactive") == 0)
- *wpa_status = WFD_OEM_WPA_STATE_INACTIVE;
- else if (g_strcmp0(state, "scanning") == 0)
- *wpa_status = WFD_OEM_WPA_STATE_SCANNING;
- else if (g_strcmp0(state, "authenticating") == 0)
- *wpa_status = WFD_OEM_WPA_STATE_AUTHENTICATING;
- else if (g_strcmp0(state, "associating") == 0)
- *wpa_status = WFD_OEM_WPA_STATE_ASSOCIATING;
- else if (g_strcmp0(state, "associated") == 0)
- *wpa_status = WFD_OEM_WPA_STATE_ASSOCIATED;
- else if (g_strcmp0(state, "4way_handshake") == 0)
- *wpa_status = WFD_OEM_WPA_STATE_4WAY_HANDSHAKE;
- else if (g_strcmp0(state, "group_handshake") == 0)
- *wpa_status = WFD_OEM_WPA_STATE_GROUP_HANDSHAKE;
- else if (g_strcmp0(state, "completed") == 0)
- *wpa_status = WFD_OEM_WPA_STATE_COMPLETED;
- else
- *wpa_status = WFD_OEM_WPA_STATE_MAX;
- }
- }
- g_variant_iter_free(iter);
+ 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;
}
- g_variant_unref(reply);
- } else {
- WDP_LOGD("No properties");
- }
- WDP_LOGI("wpa_status : [%d]", *wpa_status);
+ __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;
}
-#if defined(TIZEN_FEATURE_ASP)
-int ws_advertise_service(wfd_oem_asp_service_s *service, int replace)
+int ws_remove_vsie(wfd_oem_vsie_frames_e frame_id, const char *vsie)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
- GVariantBuilder *builder = NULL;
+ GVariantBuilder *bytearray_builder = NULL;
GVariant *value = NULL;
dbus_method_param_s params;
- unsigned int config_method = 0x1108;
- int auto_accept = 0;
- gboolean rep;
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;
}
- if (service->config_method == 2) {
- config_method = WS_CONFIG_METHOD_KEYPAD |
- WS_CONFIG_METHOD_DISPLAY;
- } else if (service->config_method == 3) {
- config_method = WS_CONFIG_METHOD_DISPLAY;
- } else if (service->config_method == 4) {
- config_method = WS_CONFIG_METHOD_KEYPAD;
+ vsie_len = strlen(vsie);
+ if (vsie_len == 0) {
+ WDP_LOGE("vsie length is zero");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
}
- if(service->auto_accept) {
- if(service->role == 0)
- auto_accept = 1;
- else
- auto_accept = 2;
- } else {
- auto_accept = 0;
+ 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;
}
- rep = (replace == 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);
- dbus_set_method_param(¶ms, "AddService", 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]);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
-
- g_variant_builder_add (builder, "{sv}", "service_type", g_variant_new_string("asp"));
- g_variant_builder_add (builder, "{sv}", "auto_accept", g_variant_new_int32(auto_accept));
- g_variant_builder_add (builder, "{sv}", "adv_id", g_variant_new_uint32(service->adv_id));
- g_variant_builder_add (builder, "{sv}", "svc_state", g_variant_new_uint32(service->status));
- 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));
- if(service->service_info != NULL)
- g_variant_builder_add (builder, "{sv}", "svc_info", g_variant_new_string(service->service_info));
-
- 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 */
+ value = g_variant_new("(iay)", frame_id, bytearray_builder);
+ g_variant_builder_unref(bytearray_builder);
params.params = value;
- res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
- if (res < 0)
+ res = dbus_method_call(¶ms, SUPPLICANT_IFACE, NULL, NULL);
+ if (res < 0) {
WDP_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to add service");
+ 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_cancel_advertise_service(wfd_oem_asp_service_s *service)
+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;
- GVariantBuilder *builder = NULL;
- GVariant *value = 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, "DeleteService", g_pd->iface_path, g_dbus);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
-
- g_variant_builder_add (builder, "{sv}", "service_type", g_variant_new_string("asp"));
- g_variant_builder_add (builder, "{sv}", "adv_id", g_variant_new_uint32(service->adv_id));
-
- 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 */
- params.params = value;
+ 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)
+ if (res < 0) {
WDP_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to del service");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+ ws_save_config();
+ WDP_LOGD("Succeeded to remove persistent group");;
__WDP_LOG_FUNC_EXIT__;
return 0;
}
-static void __remove_seek_service(long long unsigned search_id)
+int ws_remove_persistent_device(unsigned char *mac_addr)
{
- wfd_oem_asp_service_s *data = NULL;
- int count = 1;
+ __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;
- GLIST_ITER_START(seek_list, data)
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
- if (data) {
- if(data->search_id == search_id) {
- WDP_LOGD("List remove");
- seek_list = g_list_remove(seek_list, data);
- g_free(data->service_type);
- g_free(data);
- } else {
- data->tran_id = count;
- count++;
- }
+ 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);
- GLIST_ITER_END()
- return;
-}
+ cnt = networks[0].total;
-static void __get_asp_search_id(GVariant *value, void *args)
-{
- __WDP_LOG_FUNC_ENTER__;
- wfd_oem_asp_service_s *service = NULL;
- wfd_oem_asp_service_s *tmp = NULL;
- long long unsigned search_id = 0;
+ 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;
+ }
- g_variant_get(value, "(t)", &search_id);
+ for (i = 0 ; i < cnt ; i++) {
+ int j = 0;
+ need_delete = 0;
- service = (wfd_oem_asp_service_s *)args;
- if (!service) {
- WDP_LOGE("invalid parameters");
- return;
- }
+ 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]));
+ }
- tmp = g_try_malloc0(sizeof(wfd_oem_asp_service_s));
- if (!tmp) {
- WDP_LOGE("Failed to allocate memory for service");
- return;
- }
+ WDP_LOGD("mac_addr ["MACSTR"]", MAC2STR(mac_addr));
- service->search_id = search_id;
- memcpy(tmp, service, sizeof(wfd_oem_asp_service_s));
- if(service->service_type)
- tmp->service_type = strdup(service->service_type);
- seek_list = g_list_prepend(seek_list, tmp);
+ 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;
+ }
- __WDP_LOG_FUNC_EXIT__;
- return;
+ 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_seek_service(wfd_oem_asp_service_s *service)
+int ws_remove_all_persistent_device(void)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
- GVariantBuilder *builder = NULL;
- GVariant *value = 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));
- service->tran_id = g_list_length(seek_list) + 1;
- dbus_set_method_param(¶ms, "ServiceDiscoveryRequest", g_pd->iface_path, g_dbus);
+ 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");
+ }
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
+ ws_save_config();
+ WDP_LOGD("Succeeded to remove all network");
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
+}
- g_variant_builder_add (builder, "{sv}", "service_type", g_variant_new_string("asp"));
- g_variant_builder_add (builder, "{sv}", "transaction_id", g_variant_new_byte(service->tran_id));
- if(service->service_type != NULL)
- g_variant_builder_add (builder, "{sv}", "svc_str", g_variant_new_string(service->service_type));
+static void __ws_get_supported_channels_reply(GVariant *reply, void *user_data)
+{
+ __WDP_LOG_FUNC_ENTER__;
- if(service->service_info != NULL)
- g_variant_builder_add (builder, "{sv}", "svc_info", g_variant_new_string(service->service_info));
+ GVariantIter *iter = NULL;
+ wfd_oem_supported_channels_s *data = (wfd_oem_supported_channels_s *)user_data;
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
+ if (reply) {
+ int channel = 0;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
- WDP_LOGD("params [%s]", g_variant_print(value, TRUE));
-#endif /* TIZEN_DEBUG_DBUS_VALUE */
+ g_variant_get(reply, "(ai)", &iter);
- params.params = value;
+ while (g_variant_iter_loop(iter, "i", &channel))
+ data->channels[data->count++] = channel;
- res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, __get_asp_search_id, service);
- if (res < 0)
- WDP_LOGE("Failed to send command to wpa_supplicant");
- else
- WDP_LOGD("Succeeded to seek service");
+ g_variant_iter_free (iter);
+ } else {
+ WDP_LOGE("Reply is NULL");
+ }
__WDP_LOG_FUNC_EXIT__;
- return res;
}
-int ws_cancel_seek_service(wfd_oem_asp_service_s *service)
+int ws_get_supported_channels(wfd_oem_supported_channels_s *data)
{
__WDP_LOG_FUNC_ENTER__;
- GDBusConnection *g_dbus = NULL;
- dbus_method_param_s params;
-
int res = 0;
+ dbus_method_param_s params;
- g_dbus = g_pd->g_dbus;
- if (!g_dbus) {
- WDP_LOGE("DBus connection is NULL");
+ 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, "ServiceDiscoveryCancelRequest", g_pd->iface_path, g_dbus);
-
- 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 */
+ dbus_set_method_param(¶ms, "GetSupportedChannels", g_pd->iface_path, g_pd->g_dbus);
+ params.params = NULL;
- res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE,
+ __ws_get_supported_channels_reply, data);
if (res < 0) {
- WDP_LOGE("Failed to send command to wpa_supplicant");
+ WDP_LOGE("Failed to GetSupportedChannels");
} else {
- WDP_LOGD("Succeeded to cancel seek service");
- __remove_seek_service(service->search_id);
+ WDP_LOGD("Succeeded to GetSupportedChannels");
}
__WDP_LOG_FUNC_EXIT__;
return res;
}
-#endif /* TIZEN_FEATURE_ASP */
projects / platform / core / connectivity / wifi-direct-manager.git / blobdiff