#include <gio/gio.h>
#include <tzplatform_config.h>
+#include <hal-wifi.h>
#include "wifi-direct-oem.h"
#include "wfd-plugin-log.h"
return 0;
}
+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;
return 0;
}
+static void _ws_manage_group_iface_signal(const gchar *group_iface_obj_path,
+ gboolean is_created);
+
static void _ws_process_interface_removed(GDBusConnection *connection,
const gchar *sender, const gchar *object_path, const gchar *interface,
const gchar *signal, GVariant *parameters, gpointer user_data)
GVariantIter *iter;
gboolean iter_res = TRUE;
- static unsigned char peer_dev[WS_MACSTR_LEN] = {'\0',};
const char *path = NULL;
- char *loc = NULL;
int i = 0;
g_variant_get(parameter, "(&oay)", &path, &iter);
g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
WDP_LOGD("Retrive Added path [%s]", peer_path);
- loc = strrchr(peer_path, '/');
- if (loc != NULL)
- __ws_mac_compact_to_normal(loc + 1, peer_dev);
- __ws_txt_to_mac(peer_dev, dev_addr);
- WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(dev_addr));
+ __extract_addr_from_path(peer_path, dev_addr);
+
for (i = 0; iter_res && i < OEM_IPADDR_LEN; i++)
iter_res = g_variant_iter_loop(iter, "y", &ip_addr[i]);
g_variant_iter_free(iter);
return;
}
+static gboolean __is_valid_plugin(void)
+{
+ gboolean is_valid = (g_pd && g_pd->callback);
+
+ if (!is_valid)
+ WDP_LOGD("Ignoring event");
+
+ return is_valid;
+}
+
+static wfd_oem_dev_data_s *__create_dev_data(void)
+{
+ wfd_oem_dev_data_s *dev_data =
+ (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
+ if (!dev_data) {
+ char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
+ strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
+ WDP_LOGF("Failed to allocate memory for event. [%s]",
+ error_buf);
+ }
+
+ return dev_data;
+}
+
+static void __set_event_data(int event_id, int edata_type, void *data, wfd_oem_event_s *event)
+{
+ if (!event)
+ return;
+
+ memset(event, 0x0, sizeof(wfd_oem_event_s));
+
+ event->edata = data;
+ event->edata_type = edata_type;
+ event->event_id = event_id;
+
+ return;
+}
+
+static void __destroy_dev_data(wfd_oem_dev_data_s *dev_data)
+{
+ if (!dev_data)
+ return;
+
+ if (dev_data->vsie)
+ g_free(dev_data->vsie);
+ g_free(dev_data);
+}
+
static void _ws_process_peer_joined(GDBusConnection *connection,
const gchar *sender, const gchar *object_path, const gchar *interface,
const gchar *signal, GVariant *parameters, gpointer user_data)
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
+ if (!__is_valid_plugin())
return;
- }
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- error_buf);
+ dev_data = __create_dev_data();
+ if (!dev_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_STA_CONNECTED;
+ __set_event_data(WFD_OEM_EVENT_STA_CONNECTED,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
__ws_parse_peer_joined(peer_path, event.dev_addr, event.ip_addr_peer, parameters);
is_peer_joined_notified = 1;
- g_free(edata);
+ __destroy_dev_data(dev_data);
+
__WDP_LOG_FUNC_EXIT__;
}
g_strlcpy(interface_path, i_path, DBUS_OBJECT_PATH_MAX);
WDP_LOGD("Retrive Added path [%s]", interface_path);
g_strlcpy(g_pd->group_iface_path, interface_path, DBUS_OBJECT_PATH_MAX);
+
dbus_property_get_all(interface_path, g_pd->g_dbus,
SUPPLICANT_IFACE, __ws_interface_property, event);
+ _ws_manage_group_iface_signal(interface_path, TRUE);
+
} else if (g_strcmp0(key, "role") == 0) {
const char *role = NULL;
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
- char *loc = NULL;
GVariantIter *iter = NULL;
const char *path = NULL;
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
+ if (!__is_valid_plugin())
return;
- }
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- error_buf);
+ dev_data = __create_dev_data();
+ if (!dev_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_PEER_FOUND;
+ __set_event_data(WFD_OEM_EVENT_PEER_FOUND,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
g_variant_get(parameters, "(&oa{sv})", &path, &iter);
g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
WDP_LOGD("Retrive Added path [%s]", peer_path);
- loc = strrchr(peer_path, '/');
- if (loc != NULL)
- __ws_mac_compact_to_normal(loc + 1, peer_dev);
- __ws_txt_to_mac(peer_dev, event.dev_addr);
- WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
+ __extract_addr_from_path(peer_path, event.dev_addr);
if (iter != NULL) {
gchar *key = NULL;
while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
CHECK_KEY_VALUE(key, value);
- __ws_peer_property(key, value, (void *) event.edata);
+ __ws_peer_property(key, value, (void *)event.edata);
}
g_variant_iter_free(iter);
}
- if (edata->has_asp_services)
+ if (dev_data->has_asp_services)
ws_get_advertise_service(peer_path, (GList **)&(event.asp_services));
- if (edata->has_asp2_services)
+ if (dev_data->has_asp2_services)
ws_get_advertise_asp_service(peer_path, (GList **)&(event.asp2_services));
if (g_pd->callback->peer_found_cb)
g_free(service);
}
}
- g_free(event.edata);
+
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
const char *path = NULL;
const char *pin = NULL;
- char *loc = NULL;
-
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
+ if (!__is_valid_plugin())
return;
- }
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- error_buf);
+ dev_data = __create_dev_data();
+ if (!dev_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
+ __set_event_data(WFD_OEM_EVENT_PROV_DISC_REQ,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
event.wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
g_variant_get(parameters, "(&o&s)", &path, &pin);
g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
WDP_LOGD("Retrive Added path [%s]", peer_path);
- loc = strrchr(peer_path, '/');
- if (loc != NULL)
- __ws_mac_compact_to_normal(loc + 1, peer_dev);
- __ws_txt_to_mac(peer_dev, event.dev_addr);
- WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
+ __extract_addr_from_path(peer_path, event.dev_addr);
g_strlcpy(event.wps_pin, pin, WS_PINSTR_LEN + 1);
WDP_LOGD("Retrive pin [%s]", event.wps_pin);
if (g_pd->callback->prov_disc_req_cb)
g_pd->callback->prov_disc_req_cb(&event);
- g_free(event.edata);
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
const char *path = NULL;
const char *pin = NULL;
- char *loc = NULL;
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
+ if (!__is_valid_plugin())
return;
- }
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- error_buf);
+ dev_data = __create_dev_data();
+ if (!dev_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
+ __set_event_data(WFD_OEM_EVENT_PROV_DISC_RESP,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
event.wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
g_variant_get(parameters, "(&o&s)", &path, &pin);
g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
WDP_LOGD("Retrive Added path [%s]", peer_path);
- loc = strrchr(peer_path, '/');
- if (loc != NULL)
- __ws_mac_compact_to_normal(loc + 1, peer_dev);
- __ws_txt_to_mac(peer_dev, event.dev_addr);
- WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
+ __extract_addr_from_path(peer_path, event.dev_addr);
g_strlcpy(event.wps_pin, pin, WS_PINSTR_LEN + 1);
WDP_LOGD("Retrive pin [%s]", event.wps_pin);
if (g_pd->callback->prov_disc_resp_cb)
g_pd->callback->prov_disc_resp_cb(&event);
- g_free(event.edata);
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
-
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
+ if (!__is_valid_plugin())
return;
- }
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- error_buf);
+ dev_data = __create_dev_data();
+ if (!dev_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
+ __set_event_data(WFD_OEM_EVENT_PROV_DISC_REQ,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
event.wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
__ws_path_to_addr(peer_path, event.dev_addr, parameters);
if (g_pd->callback->prov_disc_req_cb)
g_pd->callback->prov_disc_req_cb(&event);
- g_free(event.edata);
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
+ if (!__is_valid_plugin())
return;
- }
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- error_buf);
+ dev_data = __create_dev_data();
+ if (!dev_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
+ __set_event_data(WFD_OEM_EVENT_PROV_DISC_RESP,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
+
event.wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
__ws_path_to_addr(peer_path, event.dev_addr, parameters);
if (g_pd->callback->prov_disc_resp_cb)
g_pd->callback->prov_disc_resp_cb(&event);
- g_free(event.edata);
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
+ if (!__is_valid_plugin())
return;
- }
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- error_buf);
+ dev_data = __create_dev_data();
+ if (!dev_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
-
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_PROV_DISC_REQ;
+ __set_event_data(WFD_OEM_EVENT_PROV_DISC_REQ,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
event.wps_mode = WFD_OEM_WPS_MODE_PBC;
__ws_path_to_addr(peer_path, event.dev_addr, parameters);
if (g_pd->callback->prov_disc_req_cb)
g_pd->callback->prov_disc_req_cb(&event);
- g_free(event.edata);
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
+ if (!__is_valid_plugin())
return;
- }
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- error_buf);
+ dev_data = __create_dev_data();
+ if (!dev_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
-
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_PROV_DISC_RESP;
+ __set_event_data(WFD_OEM_EVENT_PROV_DISC_RESP,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
event.wps_mode = WFD_OEM_WPS_MODE_PBC;
__ws_path_to_addr(peer_path, event.dev_addr, parameters);
if (g_pd->callback->prov_disc_resp_cb)
g_pd->callback->prov_disc_resp_cb(&event);
- g_free(event.edata);
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
__WDP_LOG_FUNC_EXIT__;
}
+static void __set_wps_mode_for_event(int dev_passwd_id, wfd_oem_event_s *event)
+{
+ if (!event)
+ return;
+
+ WDP_LOGD("Retrive dev_passwd_id [%d]", dev_passwd_id);
+
+ if (dev_passwd_id == WS_DEV_PASSWD_ID_PUSH_BUTTON)
+ event->wps_mode = WFD_OEM_WPS_MODE_PBC;
+ else if (dev_passwd_id == WS_DEV_PASSWD_ID_REGISTRAR_SPECIFIED)
+ event->wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
+ else if (dev_passwd_id == WS_DEV_PASSWD_ID_USER_SPECIFIED)
+ event->wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
+ else
+ event->wps_mode = WFD_OEM_WPS_MODE_NONE;
+}
+
static void _ws_process_go_neg_request(GDBusConnection *connection,
const gchar *sender, const gchar *object_path, const gchar *interface,
const gchar *signal, GVariant *parameters, gpointer user_data)
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s event;
- wfd_oem_dev_data_s *edata = NULL;
+ wfd_oem_dev_data_s *dev_data = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
- static unsigned char peer_dev[OEM_MACSTR_LEN] = {'\0',};
const char *path = NULL;
- char * loc = NULL;
int dev_passwd_id = 0;
int device_go_intent = 0;
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
- if (!g_pd || !g_pd->callback) {
- WDP_LOGD("Ignoring event");
- __WDP_LOG_FUNC_EXIT__;
+ if (!__is_valid_plugin())
return;
- }
- edata = (wfd_oem_dev_data_s *) g_try_malloc0(sizeof(wfd_oem_dev_data_s));
- if (!edata) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory for event. [%s]",
- error_buf);
+ dev_data = __create_dev_data();
+ if (!dev_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
- memset(&event, 0x0, sizeof(wfd_oem_event_s));
-
- event.edata = (void*) edata;
- event.edata_type = WFD_OEM_EDATA_TYPE_DEVICE;
- event.event_id = WFD_OEM_EVENT_GO_NEG_REQ;
+ __set_event_data(WFD_OEM_EVENT_GO_NEG_REQ,
+ WFD_OEM_EDATA_TYPE_DEVICE,
+ (void *)dev_data,
+ &event);
g_variant_get(parameters, "(&oqy)", &path, &dev_passwd_id, &device_go_intent);
g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
WDP_LOGD("Retrive peer path [%s]", peer_path);
- WDP_LOGD("Retrive dev_passwd_id [%d]", dev_passwd_id);
+ __set_wps_mode_for_event(dev_passwd_id, &event);
WDP_LOGD("Retrive device_go_intent [%d]", device_go_intent);
+ dev_data->device_go_intent = device_go_intent;
- if (dev_passwd_id == WS_DEV_PASSWD_ID_PUSH_BUTTON)
- event.wps_mode = WFD_OEM_WPS_MODE_PBC;
- else if (dev_passwd_id == WS_DEV_PASSWD_ID_REGISTRAR_SPECIFIED)
- event.wps_mode = WFD_OEM_WPS_MODE_DISPLAY;
- else if (dev_passwd_id == WS_DEV_PASSWD_ID_USER_SPECIFIED)
- event.wps_mode = WFD_OEM_WPS_MODE_KEYPAD;
- else
- event.wps_mode = WFD_OEM_WPS_MODE_NONE;
- edata->device_go_intent = device_go_intent;
-
- loc = strrchr(peer_path, '/');
- if (loc != NULL)
- __ws_mac_compact_to_normal(loc + 1, peer_dev);
- __ws_txt_to_mac(peer_dev, event.dev_addr);
- WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
+ __extract_addr_from_path(peer_path, event.dev_addr);
dbus_property_get_all(peer_path, g_pd->g_dbus, SUPPLICANT_P2P_PEER,
__ws_peer_property, event.edata);
if (g_pd->callback->go_neg_req_cb)
g_pd->callback->go_neg_req_cb(&event);
- g_free(event.edata);
+ __destroy_dev_data(dev_data);
__WDP_LOG_FUNC_EXIT__;
}
g_dbus_connection_signal_unsubscribe(g_pd->g_dbus, ws_group_signal_map[i].sub_id);
ws_group_signal_map[i].sub_id = 0;
}
+
+ _ws_manage_group_iface_signal(interface, FALSE);
memset(g_pd->group_iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
_ws_flush();
}
};
+static struct {
+ int sub_id;
+ const char *interface;
+ const char *member;
+ void (*function) (GDBusConnection *connection,
+ const gchar *sender, const gchar *object_path, const gchar *interface,
+ const gchar *signal, GVariant *parameters, gpointer user_data);
+} ws_group_interface_signal_map[] = {
+ {
+ 0,
+ SUPPLICANT_IFACE,
+ "StaAuthorized",
+ _ws_process_sta_authorized
+ },
+ {
+ 0,
+ SUPPLICANT_IFACE,
+ "StaDeauthorized",
+ _ws_process_sta_deauthorized
+ },
+ {
+ 0,
+ NULL,
+ NULL,
+ NULL
+ }
+};
+
static void __register_p2pdevice_signal(GVariant *value, void *user_data)
{
__WDP_LOG_FUNC_ENTER__;
return 0;
}
+static void _ws_manage_group_iface_signal(const gchar *group_iface_obj_path,
+ gboolean is_created)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ GDBusConnection *connection;
+
+ if (!g_pd) {
+ WDP_LOGD("Ignore");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
+ if (!g_strcmp0(g_pd->iface_path, group_iface_obj_path)) {
+ WDP_LOGD("group iface is p2p iface, ignore");
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+ }
+
+ connection = g_pd->g_dbus;
+ int i;
+ if (is_created) {
+ /* subscribe Interface iface signal */
+ for (i = 0; ws_group_interface_signal_map[i].member != NULL; i++) {
+ ws_group_interface_signal_map[i].sub_id =
+ g_dbus_connection_signal_subscribe(connection,
+ SUPPLICANT_SERVICE, /* bus name */
+ ws_group_interface_signal_map[i].interface, /* interface */
+ ws_group_interface_signal_map[i].member, /* member */
+ group_iface_obj_path, /* object path */
+ NULL, /* arg0 */
+ G_DBUS_SIGNAL_FLAGS_NONE,
+ ws_group_interface_signal_map[i].function,
+ NULL, NULL);
+ WDP_LOGD("Subscribed Interface iface signal [%s]", ws_group_interface_signal_map[i].member);
+ }
+
+ } else {
+ for (i = 0; ws_group_interface_signal_map[i].member != NULL; i++) {
+ g_dbus_connection_signal_unsubscribe(connection, ws_group_interface_signal_map[i].sub_id);
+ ws_group_interface_signal_map[i].sub_id = 0;
+ }
+ }
+ __WDP_LOG_FUNC_EXIT__;
+ return;
+}
+
int wfd_plugin_load(wfd_oem_ops_s **ops)
{
__WDP_LOG_FUNC_ENTER__;
return FALSE;
}
-static int __ws_p2p_firmware_start(void)
+static int __ws_p2p_firmware_start(const char *interface_name)
{
- gboolean rv = FALSE;
- const char *path = "/usr/bin/wlan.sh";
- char *const args[] = { "/usr/bin/wlan.sh", "p2p", NULL };
- char *const envs[] = { NULL };
+ GError *error = NULL;
+ GDBusConnection *conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
+ if (conn == NULL) {
+ WDP_LOGE("Failed to get system bus");
+ return -1;
+ }
- rv = _ws_util_execute_file(path, args, envs);
- if (rv != TRUE)
- return -1;
+ error = NULL;
+ GVariant *params = g_variant_new("(sb)", interface_name, FALSE);
+ GVariant *reply = g_dbus_connection_call_sync(
+ conn,
+ NETCONFIG_SERVICE, /* bus name */
+ NETCONFIG_WIFI_PATH, /* object path */
+ NETCONFIG_WIFI_INTERFACE, /* interface name */
+ "LoadDriver", /* method name */
+ params, /* GVariant *params */
+ NULL, /* reply_type */
+ G_DBUS_CALL_FLAGS_NONE, /* flags */
+ SUPPLICANT_TIMEOUT , /* timeout */
+ NULL, /* cancellable */
+ &error); /* error */
+
+ if (error != NULL) {
+ WDP_LOGE("Error! Failed to call method: [%s]", error->message);
+ g_error_free(error);
+ __WDP_LOG_FUNC_EXIT__;
+ }
+
+ if (reply)
+ g_variant_unref(reply);
+ g_object_unref(conn);
- WDP_LOGI("Successfully loaded p2p device driver");
return 0;
}
-static int __ws_p2p_firmware_stop(void)
+static int __ws_p2p_firmware_stop(const char *interface_name)
{
- gboolean rv = FALSE;
- const char *path = "/usr/bin/wlan.sh";
- char *const args[] = { "/usr/bin/wlan.sh", "stop", NULL };
- char *const envs[] = { NULL };
- rv = _ws_util_execute_file(path, args, envs);
- if (rv < 0)
+ int rv = 0;
+
+ rv = hal_wifi_get_backend();
+ if (rv < 0) {
+ WDP_LOGD("hal_wifi_get_backend() failed, ret: %d", rv);
+ return -1;
+ }
+
+ rv = hal_wifi_stop(interface_name);
+ if (rv < 0) {
+ WDP_LOGD("hal_wifi_stop() failed, ret: %d", rv);
return -1;
+ }
WDP_LOGI("Successfully removed p2p device driver");
return 0;
while (retry_count < WS_CONN_RETRY_COUNT) {
/* load wlan driver */
if (concurrent == 0)
- res = __ws_p2p_firmware_start();
+ res = __ws_p2p_firmware_start(config->ifname);
if (res < 0) {
WDP_LOGE("Failed to load driver [ret=%d]", res);
return -1;
if (res < 0) {
res = __ws_p2p_supplicant_stop();
WDP_LOGI("[/usr/sbin/p2p_supp.sh stop] returns %d", res);
- res = __ws_p2p_firmware_stop();
+ res = __ws_p2p_firmware_stop(config->ifname);
WDP_LOGI("P2P firmware stopped with error %d", res);
__WDP_LOG_FUNC_EXIT__;
return -1;
if (concurrent == 0) {
res = __ws_p2p_supplicant_stop();
WDP_LOGI("[/usr/sbin/p2p_supp.sh stop] returns %d", res);
- res = __ws_p2p_firmware_stop();
+ res = __ws_p2p_firmware_stop(config->ifname);
WDP_LOGI("P2P firmware stopped with error %d", res);
}
g_pd->activated = FALSE;
__WDP_LOG_FUNC_EXIT__;
return 0;
}
+static wfd_oem_device_s *__create_oem_device(void)
+{
+ wfd_oem_device_s *device =
+ (wfd_oem_device_s *) g_try_malloc0(sizeof(wfd_oem_device_s));
+ if (!device) {
+ char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
+ strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
+ WDP_LOGF("Failed to allocate memory for event. [%s]",
+ error_buf);
+ }
+
+ return device;
+}
int ws_get_peer_info(unsigned char *peer_addr, wfd_oem_device_s **peer)
{
__WDP_LOG_FUNC_ENTER__;
GDBusConnection *g_dbus = NULL;
- wfd_oem_device_s *ws_dev = NULL;
+ wfd_oem_device_s *device = NULL;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
int res = 0;
return -1;
}
- ws_dev = (wfd_oem_device_s *) g_try_malloc0(sizeof(wfd_oem_device_s));
- if (!ws_dev) {
- char error_buf[MAX_SIZE_ERROR_BUFFER] = {0, };
- strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
- WDP_LOGF("Failed to allocate memory device. [%s]",
- error_buf);
+ device = __create_oem_device();
+ if (!device) {
__WDP_LOG_FUNC_EXIT__;
return -1;
}
WDP_LOGD("get peer path [%s]", peer_path);
res = dbus_property_get_all(peer_path, g_dbus, SUPPLICANT_P2P_PEER,
- __ws_get_peer_property, ws_dev);
+ __ws_get_peer_property, device);
if (res < 0) {
WDP_LOGE("Failed to send command to wpa_supplicant");
- g_free(ws_dev);
+ if (device->vsie)
+ g_free(device->vsie);
+ g_free(device);
__WDP_LOG_FUNC_EXIT__;
return -1;
} else {
WDP_LOGD("succeeded to get peer info");
- *peer = ws_dev;
+ *peer = device;
}
+
+ //Memory ownership of dev_data is transferred to method handler
+ //which uses this function.
+
__WDP_LOG_FUNC_EXIT__;
return 0;
}
return NULL;
}
- WDP_LOGD("query id :[0x%s]", query_id);
+ WDP_LOGD("query id :[%s]", query_id);
return data;
}
-void __add_service_query(GVariant *value, void *mac_addr)
+void __add_service_query(GVariant *value, void *user_data)
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_service_s *service = NULL;
long long unsigned ref = 0;
- unsigned char *mac_address = (unsigned char *)mac_addr;
- char mac_str[18] = {0, };
-
int res = 0;
+ if (!user_data)
+ return;
+
g_variant_get(value, "(t)", &ref);
service = (wfd_oem_service_s*) g_try_malloc0(sizeof(wfd_oem_service_s));
return;
}
- if (mac_address[0] == 0 && mac_address[1] == 0 && mac_address[2] == 0 &&
- mac_address[3] == 0 && mac_address[4] == 0 && mac_address[5] == 0) {
- g_snprintf(mac_str, WS_MACSTR_LEN , "%s", SERV_BROADCAST_ADDRESS);
- } else {
- g_snprintf(mac_str, WS_MACSTR_LEN, MACSTR, MAC2STR(mac_address));
- }
+ memcpy(service, user_data, sizeof(wfd_oem_service_s));
- g_strlcpy(service->dev_addr, mac_str, OEM_MACSTR_LEN);
- g_snprintf(service->query_id, OEM_QUERY_ID_LEN + 1, "0x%llx", ref);
+ g_snprintf(service->query_id, OEM_QUERY_ID_LEN + 1, "%llx", ref);
res = _check_service_query_exists(service);
if (res)
GDBusConnection *g_dbus = NULL;
GVariantBuilder *builder = NULL;
GVariant *value = NULL;
+ wfd_oem_service_s data = {0,};
dbus_method_param_s params;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
int i = 0;
builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
- if (mac_addr) {
+ if (mac_addr && !ISZEROMACADDR(mac_addr)) {
g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
COMPACT_MACSTR, g_pd->iface_path, MAC2STR(mac_addr));
WDP_LOGD("get peer path [%s]", peer_path);
g_variant_builder_add(query, "y", service_all[i]);
g_variant_builder_add(builder, "{sv}", "query", g_variant_new("ay", query));
g_variant_builder_unref(query);
+ g_strlcpy(data.service_type, SERV_DISC_REQ_ALL, OEM_SERVICE_TYPE_LEN + 1);
- } else if (service_type == WFD_OEM_SERVICE_TYPE_UPNP) {
+ } else if (service_type == WFD_OEM_SERVICE_TYPE_UPNP) {
g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("upnp"));
- g_variant_builder_add(builder, "{sv}", "version", g_variant_new_uint16(TRUE));
+ g_variant_builder_add(builder, "{sv}", "version", g_variant_new_int32(10));
+ g_variant_builder_add(builder, "{sv}", "service", g_variant_new_string("ssdp:all"));
+ g_strlcpy(data.service_type, SERV_DISC_REQ_UPNP, OEM_SERVICE_TYPE_LEN + 1);
} else if (service_type == WFD_OEM_SERVICE_TYPE_BONJOUR) {
query = g_variant_builder_new(G_VARIANT_TYPE("ay"));
for (i = 0; i < SERVICE_QUERY_LEN; i++)
g_variant_builder_add(query, "y", service_bonjour[i]);
- g_variant_builder_add(builder, "{sv}", "query", g_variant_new("ay", query));
+ g_variant_builder_add(builder, "{sv}", "tlv", g_variant_new("ay", query));
g_variant_builder_unref(query);
+ g_strlcpy(data.service_type, SERV_DISC_REQ_BONJOUR, OEM_SERVICE_TYPE_LEN + 1);
}
value = g_variant_new("(a{sv})", builder);
params.params = value;
DEBUG_G_VARIANT("Params : ", params.params);
- res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, __add_service_query, mac_addr);
+ if (ISZEROMACADDR(mac_addr))
+ snprintf(data.dev_addr, WS_MACSTR_LEN , "%s", SERV_BROADCAST_ADDRESS);
+ else
+ snprintf(data.dev_addr, WS_MACSTR_LEN, MACSTR, MAC2STR(mac_addr));
+
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, __add_service_query, &data);
if (res < 0)
WDP_LOGE("Failed to send command to wpa_supplicant");
else
char query_id[OEM_QUERY_ID_LEN + 1] = {0, };
char s_type[OEM_SERVICE_TYPE_LEN + 1] = {0, };
char mac_str[18] = {0, };
+ long long unsigned id;
int res = 0;
return -1;
}
- if (mac_addr[0] == 0 && mac_addr[1] == 0 && mac_addr[2] == 0 &&
- mac_addr[3] == 0 && mac_addr[4] == 0 && mac_addr[5] == 0) {
+ if (ISZEROMACADDR(mac_addr)) {
snprintf(mac_str, WS_MACSTR_LEN , "%s", SERV_BROADCAST_ADDRESS);
} else {
snprintf(mac_str, WS_MACSTR_LEN, MACSTR, MAC2STR(mac_addr));
memset(¶ms, 0x0, sizeof(dbus_method_param_s));
dbus_set_method_param(¶ms, "ServiceDiscoveryCancelRequest", g_pd->iface_path, g_dbus);
-
- params.params = g_variant_new("(t)", strtoul(query_id, NULL, 16));
+ id = (long long unsigned)strtoul(query_id, NULL, 16);
+ params.params = g_variant_new("(t)", id);
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (res < 0)
} else if (service->protocol == WFD_OEM_SERVICE_TYPE_UPNP) {
g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("upnp"));
- g_variant_builder_add(builder, "{sv}", "version", g_variant_new_uint16(TRUE));
+ g_variant_builder_add(builder, "{sv}", "version", g_variant_new_int32(10));
g_variant_builder_add(builder, "{sv}", "service", g_variant_new_string(service->data.upnp.service));
}
} else if (service->protocol == WFD_OEM_SERVICE_TYPE_UPNP) {
g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("upnp"));
- g_variant_builder_add(builder, "{sv}", "version", g_variant_new_uint16(TRUE));
+ g_variant_builder_add(builder, "{sv}", "version", g_variant_new_int32(10));
g_variant_builder_add(builder, "{sv}", "service", g_variant_new_string(service->data.upnp.service));
}
projects / platform / core / connectivity / wifi-direct-manager.git / blobdiff