#include <gio/gio.h>
#include <tzplatform_config.h>
+#include <hal-wifi.h>
#include "wifi-direct-oem.h"
#include "wfd-plugin-log.h"
.remove_persistent_device = ws_remove_persistent_device,
.remove_all_persistent_device = ws_remove_all_persistent_device,
+ .get_supported_channels = ws_get_supported_channels,
+
.extra_data = NULL
};
if (serv_tmp->status != 0) {
WDP_LOGE("Service status is not success");
- free(serv_tmp);
+ g_free(serv_tmp);
return -1;
}
temp[i+1] = (char) __ws_hex_to_num(ptr, 2);
ptr += 2;
}
- strncat(query, temp, size + 1);
+ g_strlcat(query, temp, sizeof(query));
g_free(temp);
temp = NULL;
}
ptr += 6;
if (dns_type == 12) {
if (!strncmp(compr, "c011", 4))
- strncat(query, ".local.", 7);
+ g_strlcat(query, ".local.", sizeof(query));
else if (!strncmp(compr, "c00c", 4))
- strncat(query, "._tcp.local.", 12);
+ g_strlcat(query, "._tcp.local.", sizeof(query));
else if (!strncmp(compr, "c01c", 4))
- strncat(query, "._udp.local.", 12);
+ g_strlcat(query, "._udp.local.", sizeof(query));
}
}
}
temp[i+1] = (char) __ws_hex_to_num(ptr, 2);
ptr += 2;
}
- strncat(rdata, temp, size + 1);
+ g_strlcat(rdata, temp, sizeof(rdata));
g_free(temp);
temp = NULL;
}
return 0;
}
+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;
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__;
}
GDBusConnection *g_dbus = NULL;
GVariant *param = NULL;
GVariant *reply = NULL;
- GVariant *temp = NULL;
+ GVariant *temp1 = NULL;
+ GVariant *temp2 = NULL;
GError *error = NULL;
GVariantIter *iter = NULL;
wfd_oem_advertise_service_s *service;
* So, you need to remove tuple out side of variant and
* variant out side of byte array
* */
- temp = g_variant_get_child_value(reply, 0);
- temp = g_variant_get_child_value(temp, 0);
- g_variant_get(temp, "ay", &iter);
+ temp1 = g_variant_get_child_value(reply, 0);
+ temp2 = g_variant_get_child_value(temp1, 0);
+ g_variant_get(temp2, "ay", &iter);
if (iter == NULL) {
g_variant_unref(reply);
WDP_LOGE("Failed to get iterator");
return -1;
}
+ g_variant_unref(temp2);
+ g_variant_unref(temp1);
while (1) {
/* 4byte advertisement ID, 2 byte config method, 1byte length */
GDBusConnection *g_dbus = NULL;
GVariant *param = NULL;
GVariant *reply = NULL;
- GVariant *temp = NULL;
+ GVariant *temp1 = NULL;
+ GVariant *temp2 = NULL;
GError *error = NULL;
GVariantIter *iter = NULL;
wfd_oem_advertise_service_s *service;
* So, you need to remove tuple out side of variant and
* variant out side of byte array
* */
- temp = g_variant_get_child_value(reply, 0);
- temp = g_variant_get_child_value(temp, 0);
- g_variant_get(temp, "ay", &iter);
+ temp1 = g_variant_get_child_value(reply, 0);
+ temp2 = g_variant_get_child_value(temp1, 0);
+ g_variant_get(temp2, "ay", &iter);
if (iter == NULL) {
g_variant_unref(reply);
WDP_LOGE("Failed to get iterator");
return -1;
}
+ g_variant_unref(temp2);
+ g_variant_unref(temp1);
while (1) {
/* 4byte advertisement ID, 2 byte config method, 1byte length */
{
__WDP_LOG_FUNC_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__;
}
WDP_LOGD("Succeeded to CreateInterface");
__WDP_LOG_FUNC_EXIT__;
- return 0;
+ return res;
}
static int _ws_get_interface(const char *iface_name, handle_reply function, void *user_data)
}
memset(&ifr, 0, sizeof(ifr));
- strncpy(ifr.ifr_name, if_name, sizeof(ifr.ifr_name));
- ifr.ifr_name[IFNAMSIZ-1] = '\0';
+ g_strlcpy(ifr.ifr_name, if_name, IFNAMSIZ);
if (ioctl(fd, SIOCGIFFLAGS, &ifr) < 0) {
close(fd);
return 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 };
+ int rv = 0;
- rv = _ws_util_execute_file(path, args, envs);
- if (rv != TRUE)
+ rv = hal_wifi_get_backend();
+ if (rv < 0) {
+ WDP_LOGD("hal_wifi_get_backend() failed, ret: %d", rv);
return -1;
+ }
+
+ rv = hal_wifi_p2p_start(interface_name);
+ if (rv < 0) {
+ WDP_LOGD("hal_wifi_p2p_start() failed, ret: %d", rv);
+ return -1;
+ }
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;
}
__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);
data = (wfd_oem_service_s*) g_list_nth_data(service_list, count);
if (data && !strncmp(data->service_type, s_type, SERVICE_TYPE_LEN) &&
memcmp(data->dev_addr, mac_str, OEM_MACSTR_LEN - 1) == 0) {
- strncpy(query_id, data->query_id, OEM_QUERY_ID_LEN);
+ g_strlcpy(query_id, data->query_id, OEM_QUERY_ID_LEN + 1);
break;
}
}
return NULL;
}
- WDP_LOGD("query id :[0x%s]", query_id);
+ WDP_LOGD("query id :[%s]", query_id);
return data;
}
-void __add_service_query(GVariant *value, void *mac_addr)
+void __add_service_query(GVariant *value, void *user_data)
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_service_s *service = NULL;
long long unsigned ref = 0;
- unsigned char *mac_address = (unsigned char *)mac_addr;
- char mac_str[18] = {0, };
-
int res = 0;
+ if (!user_data)
+ return;
+
g_variant_get(value, "(t)", &ref);
service = (wfd_oem_service_s*) g_try_malloc0(sizeof(wfd_oem_service_s));
return;
}
- if (mac_address[0] == 0 && mac_address[1] == 0 && mac_address[2] == 0 &&
- mac_address[3] == 0 && mac_address[4] == 0 && mac_address[5] == 0) {
- g_snprintf(mac_str, WS_MACSTR_LEN , "%s", SERV_BROADCAST_ADDRESS);
- } else {
- g_snprintf(mac_str, WS_MACSTR_LEN, MACSTR, MAC2STR(mac_address));
- }
+ memcpy(service, user_data, sizeof(wfd_oem_service_s));
- g_strlcpy(service->dev_addr, mac_str, OEM_MACSTR_LEN);
- g_snprintf(service->query_id, OEM_QUERY_ID_LEN + 1, "0x%llx", ref);
+ g_snprintf(service->query_id, OEM_QUERY_ID_LEN + 1, "%llx", ref);
res = _check_service_query_exists(service);
if (res)
- free(service);
+ g_free(service);
else
service_list = g_list_append(service_list, service);
GDBusConnection *g_dbus = NULL;
GVariantBuilder *builder = NULL;
GVariant *value = NULL;
+ wfd_oem_service_s data = {0,};
dbus_method_param_s params;
static char peer_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
int i = 0;
builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
- if (mac_addr) {
+ if (mac_addr && !ISZEROMACADDR(mac_addr)) {
g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
COMPACT_MACSTR, g_pd->iface_path, MAC2STR(mac_addr));
WDP_LOGD("get peer path [%s]", peer_path);
g_variant_builder_add(query, "y", service_all[i]);
g_variant_builder_add(builder, "{sv}", "query", g_variant_new("ay", query));
g_variant_builder_unref(query);
+ g_strlcpy(data.service_type, SERV_DISC_REQ_ALL, OEM_SERVICE_TYPE_LEN + 1);
- } else if (service_type == WFD_OEM_SERVICE_TYPE_UPNP) {
+ } else if (service_type == WFD_OEM_SERVICE_TYPE_UPNP) {
g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("upnp"));
- g_variant_builder_add(builder, "{sv}", "version", g_variant_new_uint16(TRUE));
+ g_variant_builder_add(builder, "{sv}", "version", g_variant_new_int32(10));
+ g_variant_builder_add(builder, "{sv}", "service", g_variant_new_string("ssdp:all"));
+ g_strlcpy(data.service_type, SERV_DISC_REQ_UPNP, OEM_SERVICE_TYPE_LEN + 1);
} else if (service_type == WFD_OEM_SERVICE_TYPE_BONJOUR) {
query = g_variant_builder_new(G_VARIANT_TYPE("ay"));
for (i = 0; i < SERVICE_QUERY_LEN; i++)
g_variant_builder_add(query, "y", service_bonjour[i]);
- g_variant_builder_add(builder, "{sv}", "query", g_variant_new("ay", query));
+ g_variant_builder_add(builder, "{sv}", "tlv", g_variant_new("ay", query));
g_variant_builder_unref(query);
+ g_strlcpy(data.service_type, SERV_DISC_REQ_BONJOUR, OEM_SERVICE_TYPE_LEN + 1);
}
value = g_variant_new("(a{sv})", builder);
params.params = value;
DEBUG_G_VARIANT("Params : ", params.params);
- res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, __add_service_query, mac_addr);
+ if (ISZEROMACADDR(mac_addr))
+ snprintf(data.dev_addr, WS_MACSTR_LEN , "%s", SERV_BROADCAST_ADDRESS);
+ else
+ snprintf(data.dev_addr, WS_MACSTR_LEN, MACSTR, MAC2STR(mac_addr));
+
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, __add_service_query, &data);
if (res < 0)
WDP_LOGE("Failed to send command to wpa_supplicant");
else
char query_id[OEM_QUERY_ID_LEN + 1] = {0, };
char s_type[OEM_SERVICE_TYPE_LEN + 1] = {0, };
char mac_str[18] = {0, };
+ long long unsigned id;
int res = 0;
return -1;
}
- if (mac_addr[0] == 0 && mac_addr[1] == 0 && mac_addr[2] == 0 &&
- mac_addr[3] == 0 && mac_addr[4] == 0 && mac_addr[5] == 0) {
+ if (ISZEROMACADDR(mac_addr)) {
snprintf(mac_str, WS_MACSTR_LEN , "%s", SERV_BROADCAST_ADDRESS);
} else {
snprintf(mac_str, WS_MACSTR_LEN, MACSTR, MAC2STR(mac_addr));
switch (service_type) {
case WFD_OEM_SERVICE_TYPE_ALL:
- strncpy(s_type, SERV_DISC_REQ_ALL, OEM_SERVICE_TYPE_LEN);
+ g_strlcpy(s_type, SERV_DISC_REQ_ALL, OEM_SERVICE_TYPE_LEN + 1);
break;
case WFD_OEM_SERVICE_TYPE_BONJOUR:
- strncpy(s_type, SERV_DISC_REQ_BONJOUR, OEM_SERVICE_TYPE_LEN);
+ g_strlcpy(s_type, SERV_DISC_REQ_BONJOUR, OEM_SERVICE_TYPE_LEN + 1);
break;
case WFD_OEM_SERVICE_TYPE_UPNP:
- strncpy(s_type, SERV_DISC_REQ_UPNP, OEM_SERVICE_TYPE_LEN);
+ g_strlcpy(s_type, SERV_DISC_REQ_UPNP, OEM_SERVICE_TYPE_LEN + 1);
break;
default:
WDP_LOGE("Invalid Service type");
memset(¶ms, 0x0, sizeof(dbus_method_param_s));
dbus_set_method_param(¶ms, "ServiceDiscoveryCancelRequest", g_pd->iface_path, g_dbus);
-
- params.params = g_variant_new("(t)", strtoul(query_id, NULL, 16));
+ id = (long long unsigned)strtoul(query_id, NULL, 16);
+ params.params = g_variant_new("(t)", id);
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (res < 0)
} else if (service->protocol == WFD_OEM_SERVICE_TYPE_UPNP) {
g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("upnp"));
- g_variant_builder_add(builder, "{sv}", "version", g_variant_new_uint16(TRUE));
+ g_variant_builder_add(builder, "{sv}", "version", g_variant_new_int32(10));
g_variant_builder_add(builder, "{sv}", "service", g_variant_new_string(service->data.upnp.service));
}
} else if (service->protocol == WFD_OEM_SERVICE_TYPE_UPNP) {
g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("upnp"));
- g_variant_builder_add(builder, "{sv}", "version", g_variant_new_uint16(TRUE));
+ g_variant_builder_add(builder, "{sv}", "version", g_variant_new_int32(10));
g_variant_builder_add(builder, "{sv}", "service", g_variant_new_string(service->data.upnp.service));
}
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_builder_add(builder, "{sv}", "IpAddrGo",
g_variant_new("ay", type_builder));
g_variant_builder_unref(type_builder);
}
if (new_wps_mode & WFD_OEM_WPS_MODE_KEYPAD) {
- strncat(config_value, "keypad ", 7);
+ g_strlcat(config_value, "keypad ", sizeof(config_value));
length += 7;
}
if (new_wps_mode & WFD_OEM_WPS_MODE_PBC) {
- strncat(config_value, "virtual_push_button ", 20);
+ g_strlcat(config_value, "virtual_push_button ", sizeof(config_value));
length += 20;
}
if (new_wps_mode & WFD_OEM_WPS_MODE_DISPLAY) {
- strncat(config_value, "physical_display ", 17);
+ g_strlcat(config_value, "physical_display ", sizeof(config_value));
length += 17;
}
config_value[length-1] = 0;
__WDP_LOG_FUNC_EXIT__;
return res;
}
+
+static void __ws_get_supported_channels_reply(GVariant *reply, void *user_data)
+{
+ __WDP_LOG_FUNC_ENTER__;
+
+ GVariantIter *iter = NULL;
+ wfd_oem_supported_channels_s *data = (wfd_oem_supported_channels_s *)user_data;
+
+ if (reply) {
+ int channel = 0;
+
+ g_variant_get(reply, "(ai)", &iter);
+
+ while (g_variant_iter_loop(iter, "i", &channel))
+ data->channels[data->count++] = channel;
+
+ g_variant_iter_free (iter);
+
+ } else {
+ WDP_LOGE("Reply is NULL");
+ }
+ __WDP_LOG_FUNC_EXIT__;
+}
+
+int ws_get_supported_channels(wfd_oem_supported_channels_s *data)
+{
+ __WDP_LOG_FUNC_ENTER__;
+ int res = 0;
+ dbus_method_param_s params;
+
+ if (!g_pd) {
+ WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
+ }
+
+ memset(¶ms, 0x0, sizeof(dbus_method_param_s));
+ memset(data, 0x0, sizeof(wfd_oem_supported_channels_s));
+
+ dbus_set_method_param(¶ms, "GetSupportedChannels", g_pd->iface_path, g_pd->g_dbus);
+ params.params = NULL;
+
+ res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE,
+ __ws_get_supported_channels_reply, data);
+ if (res < 0) {
+ WDP_LOGE("Failed to GetSupportedChannels");
+ } else {
+ WDP_LOGD("Succeeded to GetSupportedChannels");
+ }
+
+ __WDP_LOG_FUNC_EXIT__;
+ return res;
+}
projects / platform / core / connectivity / wifi-direct-manager.git / blobdiff