}
-DBusMessage *wpas_dbus_handler_p2p_find(DBusMessage * message,
- struct wpa_supplicant * wpa_s)
+DBusMessage * wpas_dbus_handler_p2p_find(DBusMessage *message,
+ struct wpa_supplicant *wpa_s)
{
struct wpa_dbus_dict_entry entry;
DBusMessage *reply = NULL;
return reply;
}
-DBusMessage *wpas_dbus_handler_p2p_stop_find(DBusMessage * message,
- struct wpa_supplicant * wpa_s)
+
+DBusMessage * wpas_dbus_handler_p2p_stop_find(DBusMessage *message,
+ struct wpa_supplicant *wpa_s)
{
wpas_p2p_stop_find(wpa_s);
return NULL;
}
-DBusMessage *wpas_dbus_handler_p2p_rejectpeer(DBusMessage * message,
- struct wpa_supplicant * wpa_s)
+
+DBusMessage * wpas_dbus_handler_p2p_rejectpeer(DBusMessage *message,
+ struct wpa_supplicant *wpa_s)
{
DBusMessageIter iter;
char *peer_object_path = NULL;
return NULL;
}
-DBusMessage *wpas_dbus_handler_p2p_listen(DBusMessage * message,
- struct wpa_supplicant * wpa_s)
+
+DBusMessage * wpas_dbus_handler_p2p_listen(DBusMessage *message,
+ struct wpa_supplicant *wpa_s)
{
dbus_int32_t timeout = 0;
return NULL;
}
-DBusMessage *wpas_dbus_handler_p2p_extendedlisten(DBusMessage * message,
- struct wpa_supplicant * wpa_s)
+
+DBusMessage * wpas_dbus_handler_p2p_extendedlisten(
+ DBusMessage *message, struct wpa_supplicant *wpa_s)
{
unsigned int period = 0, interval = 0;
struct wpa_dbus_dict_entry entry;
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
- if (!strcmp(entry.key, "period") &&
+ if (!os_strcmp(entry.key, "period") &&
(entry.type == DBUS_TYPE_INT32))
period = entry.uint32_value;
- else if (!strcmp(entry.key, "interval") &&
+ else if (!os_strcmp(entry.key, "interval") &&
(entry.type == DBUS_TYPE_INT32))
interval = entry.uint32_value;
else
}
if (wpas_p2p_ext_listen(wpa_s, period, interval))
- return wpas_dbus_error_unknown_error(message,
- "failed to initiate a p2p_ext_listen.");
+ return wpas_dbus_error_unknown_error(
+ message, "failed to initiate a p2p_ext_listen.");
return NULL;
return wpas_dbus_error_invalid_args(message, entry.key);
}
-DBusMessage *wpas_dbus_handler_p2p_presence_request(DBusMessage * message,
- struct wpa_supplicant *
- wpa_s)
+
+DBusMessage * wpas_dbus_handler_p2p_presence_request(
+ DBusMessage *message, struct wpa_supplicant *wpa_s)
{
unsigned int dur1 = 0, int1 = 0, dur2 = 0, int2 = 0;
struct wpa_dbus_dict_entry entry;
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
- if (!strcmp(entry.key, "duration1") &&
+ if (!os_strcmp(entry.key, "duration1") &&
(entry.type == DBUS_TYPE_INT32))
dur1 = entry.uint32_value;
- else if (!strcmp(entry.key, "interval1") &&
+ else if (!os_strcmp(entry.key, "interval1") &&
entry.type == DBUS_TYPE_INT32)
int1 = entry.uint32_value;
- else if (!strcmp(entry.key, "duration2") &&
+ else if (!os_strcmp(entry.key, "duration2") &&
entry.type == DBUS_TYPE_INT32)
dur2 = entry.uint32_value;
- else if (!strcmp(entry.key, "interval2") &&
+ else if (!os_strcmp(entry.key, "interval2") &&
entry.type == DBUS_TYPE_INT32)
int2 = entry.uint32_value;
else
return wpas_dbus_error_invalid_args(message, entry.key);
}
-DBusMessage *wpas_dbus_handler_p2p_group_add(DBusMessage * message,
- struct wpa_supplicant * wpa_s)
+
+DBusMessage * wpas_dbus_handler_p2p_group_add(DBusMessage *message,
+ struct wpa_supplicant *wpa_s)
{
DBusMessageIter iter_dict;
DBusMessage *reply = NULL;
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto inv_args;
- if (!strcmp(entry.key, "persistent") &&
+ if (!os_strcmp(entry.key, "persistent") &&
(entry.type == DBUS_TYPE_BOOLEAN)) {
persistent_group = (entry.bool_value == TRUE) ? 1 : 0;
- } else if (!strcmp(entry.key, "frequency") &&
+ } else if (!os_strcmp(entry.key, "frequency") &&
(entry.type == DBUS_TYPE_INT32)) {
freq = entry.int32_value;
if (freq <= 0)
goto inv_args_clear;
- } else if (!strcmp(entry.key, "persistent_group_object") &&
+ } else if (!os_strcmp(entry.key, "persistent_group_object") &&
entry.type == DBUS_TYPE_OBJECT_PATH)
pg_object_path = os_strdup(entry.str_value);
else
goto inv_args;
if (wpas_p2p_group_add_persistent(wpa_s, ssid, 0, freq)) {
- reply = wpas_dbus_error_unknown_error(message,
- "Failed to reinvoke a persistent group");
+ reply = wpas_dbus_error_unknown_error(
+ message,
+ "Failed to reinvoke a persistent group");
goto out;
}
} else if (wpas_p2p_group_add(wpa_s, persistent_group, freq))
goto out;
}
-DBusMessage *wpas_dbus_handler_p2p_disconnect(DBusMessage *message,
- struct wpa_supplicant *wpa_s)
+
+DBusMessage * wpas_dbus_handler_p2p_disconnect(DBusMessage *message,
+ struct wpa_supplicant *wpa_s)
{
if (wpas_p2p_disconnect(wpa_s))
return wpas_dbus_error_unknown_error(message,
return NULL;
}
-DBusMessage *wpas_dbus_handler_p2p_flush(DBusMessage * message,
- struct wpa_supplicant * wpa_s)
+
+DBusMessage * wpas_dbus_handler_p2p_flush(DBusMessage *message,
+ struct wpa_supplicant *wpa_s)
{
os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
wpa_s->force_long_sd = 0;
return NULL;
}
-DBusMessage *wpas_dbus_handler_p2p_connect(DBusMessage * message,
- struct wpa_supplicant * wpa_s)
+
+DBusMessage * wpas_dbus_handler_p2p_connect(DBusMessage *message,
+ struct wpa_supplicant *wpa_s)
{
DBusMessageIter iter_dict;
DBusMessage *reply = NULL;
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto inv_args;
- if (!strcmp(entry.key, "peer") &&
+ if (!os_strcmp(entry.key, "peer") &&
(entry.type == DBUS_TYPE_OBJECT_PATH)) {
peer_object_path = os_strdup(entry.str_value);
- } else if (!strcmp(entry.key, "persistent") &&
+ } else if (!os_strcmp(entry.key, "persistent") &&
(entry.type == DBUS_TYPE_BOOLEAN)) {
persistent_group = (entry.bool_value == TRUE) ? 1 : 0;
- } else if (!strcmp(entry.key, "join") &&
+ } else if (!os_strcmp(entry.key, "join") &&
(entry.type == DBUS_TYPE_BOOLEAN)) {
join = (entry.bool_value == TRUE) ? 1 : 0;
- } else if (!strcmp(entry.key, "authorize_only") &&
+ } else if (!os_strcmp(entry.key, "authorize_only") &&
(entry.type == DBUS_TYPE_BOOLEAN)) {
authorize_only = (entry.bool_value == TRUE) ? 1 : 0;
- } else if (!strcmp(entry.key, "frequency") &&
+ } else if (!os_strcmp(entry.key, "frequency") &&
(entry.type == DBUS_TYPE_INT32)) {
freq = entry.int32_value;
if (freq <= 0)
goto inv_args_clear;
- } else if (!strcmp(entry.key, "go_intent") &&
+ } else if (!os_strcmp(entry.key, "go_intent") &&
(entry.type == DBUS_TYPE_INT32)) {
go_intent = entry.int32_value;
if ((go_intent < 0) || (go_intent > 15))
goto inv_args_clear;
- } else if (!strcmp(entry.key, "wps_method") &&
+ } else if (!os_strcmp(entry.key, "wps_method") &&
(entry.type == DBUS_TYPE_STRING)) {
- if (!strcmp(entry.str_value, "pbc"))
+ if (!os_strcmp(entry.str_value, "pbc"))
wps_method = WPS_PBC;
- else if (!strcmp(entry.str_value, "pin"))
+ else if (!os_strcmp(entry.str_value, "pin"))
wps_method = WPS_PIN_DISPLAY;
- else if (!strcmp(entry.str_value, "label"))
+ else if (!os_strcmp(entry.str_value, "label"))
wps_method = WPS_PIN_LABEL;
- else if (!strcmp(entry.str_value, "display"))
+ else if (!os_strcmp(entry.str_value, "display"))
wps_method = WPS_PIN_DISPLAY;
- else if (!strcmp(entry.str_value, "keypad"))
+ else if (!os_strcmp(entry.str_value, "keypad"))
wps_method = WPS_PIN_KEYPAD;
else
goto inv_args_clear;
- } else if (!strcmp(entry.key, "pin") &&
+ } else if (!os_strcmp(entry.key, "pin") &&
(entry.type == DBUS_TYPE_STRING)) {
pin = os_strdup(entry.str_value);
} else
goto out;
}
-DBusMessage *wpas_dbus_handler_p2p_invite(DBusMessage * message,
- struct wpa_supplicant *wpa_s)
+
+DBusMessage * wpas_dbus_handler_p2p_invite(DBusMessage *message,
+ struct wpa_supplicant *wpa_s)
{
DBusMessageIter iter_dict;
DBusMessage *reply = NULL;
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto err;
- if (!strcmp(entry.key, "peer") &&
+ if (!os_strcmp(entry.key, "peer") &&
(entry.type == DBUS_TYPE_OBJECT_PATH)) {
peer_object_path = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
- } else if (!strcmp(entry.key, "persistent_group_object") &&
+ } else if (!os_strcmp(entry.key, "persistent_group_object") &&
(entry.type == DBUS_TYPE_OBJECT_PATH)) {
pg_object_path = os_strdup(entry.str_value);
persistent = 1;
if (persistent) {
/*
* A group ID is defined meaning we want to re-invoke a
- * persisatnt group
+ * persistant group
*/
iface = wpas_dbus_new_decompose_object_path(pg_object_path, 1,
&net_id_str, NULL);
if (iface == NULL ||
os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
- reply =
- wpas_dbus_error_invalid_args(message,
- pg_object_path);
+ reply = wpas_dbus_error_invalid_args(message,
+ pg_object_path);
goto out;
}
group_id = strtoul(net_id_str, NULL, 10);
if (errno == EINVAL) {
reply = wpas_dbus_error_invalid_args(
- message, pg_object_path);
+ message, pg_object_path);
goto out;
}
if (wpas_p2p_invite(wpa_s, peer_addr, ssid, NULL) < 0) {
reply = wpas_dbus_error_unknown_error(
- message,
- "Failed to reinvoke a persistent group");
+ message,
+ "Failed to reinvoke a persistent group");
goto out;
}
} else {
* No group ID means propose to a peer to join my active group
*/
if (wpas_p2p_invite_group(wpa_s, wpa_s->ifname,
- peer_addr, NULL)) {
+ peer_addr, NULL)) {
reply = wpas_dbus_error_unknown_error(
- message,
- "Failed to join to an active group");
+ message, "Failed to join to an active group");
goto out;
}
}
goto out;
}
-DBusMessage *wpas_dbus_handler_p2p_prov_disc_req(DBusMessage * message,
- struct wpa_supplicant *wpa_s)
+
+DBusMessage * wpas_dbus_handler_p2p_prov_disc_req(DBusMessage *message,
+ struct wpa_supplicant *wpa_s)
{
DBusMessageIter iter;
char *peer_object_path = NULL;
return NULL;
}
+
/*
* P2P Device property accessor methods.
*/
-DBusMessage *wpas_dbus_getter_p2p_device_properties(DBusMessage * message,
- struct wpa_supplicant *
- wpa_s)
+DBusMessage * wpas_dbus_getter_p2p_device_properties(
+ DBusMessage *message, struct wpa_supplicant *wpa_s)
{
DBusMessage *reply = NULL;
DBusMessageIter iter, variant_iter, dict_iter;
return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY, NULL);
}
-DBusMessage *wpas_dbus_setter_p2p_device_properties(DBusMessage * message,
- struct wpa_supplicant *
- wpa_s)
+
+DBusMessage * wpas_dbus_setter_p2p_device_properties(
+ DBusMessage *message, struct wpa_supplicant *wpa_s)
{
DBusMessage *reply = NULL;
DBusMessageIter iter, variant_iter;
wpa_s->conf->device_name = devname;
wpa_s->conf->changed_parameters |=
- CFG_CHANGED_DEVICE_NAME;
+ CFG_CHANGED_DEVICE_NAME;
} else if (os_strcmp(entry.key, "PrimaryDeviceType") == 0) {
if (entry.type != DBUS_TYPE_ARRAY ||
entry.array_type != DBUS_TYPE_BYTE ||
goto error;
for (i = 0; i < entry.array_len; i++)
- if (wpabuf_len(entry.binarray_value[i]) != WPS_DEV_TYPE_LEN)
+ if (wpabuf_len(entry.binarray_value[i]) !=
+ WPS_DEV_TYPE_LEN)
goto err_no_mem_clear;
for (i = 0; i < entry.array_len; i++)
os_memcpy(wpa_s->conf->sec_device_type[i],
goto error_clear;
wpa_s->conf->changed_parameters |=
- CFG_CHANGED_VENDOR_EXTENSION;
+ CFG_CHANGED_VENDOR_EXTENSION;
for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
wpabuf_free(wpa_s->conf->wps_vendor_ext[i]);
(entry.type == DBUS_TYPE_UINT32) &&
(entry.uint32_value <= 15))
wpa_s->conf->p2p_go_intent = entry.uint32_value;
-
else if ((os_strcmp(entry.key, "PersistantReconnect") == 0) &&
(entry.type == DBUS_TYPE_BOOLEAN))
wpa_s->conf->persistent_reconnect = entry.bool_value;
-
else if ((os_strcmp(entry.key, "ListenRegClass") == 0) &&
(entry.type == DBUS_TYPE_UINT32)) {
wpa_s->conf->p2p_listen_reg_class = entry.uint32_value;
(entry.type == DBUS_TYPE_BOOLEAN)) {
wpa_s->conf->p2p_intra_bss = entry.bool_value;
wpa_s->conf->changed_parameters |=
- CFG_CHANGED_P2P_INTRA_BSS;
+ CFG_CHANGED_P2P_INTRA_BSS;
} else if ((os_strcmp(entry.key, "GroupIdle") == 0) &&
(entry.type == DBUS_TYPE_UINT32))
wpa_s->conf->p2p_group_idle = entry.uint32_value;
return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY, NULL);
}
-DBusMessage *wpas_dbus_getter_p2p_peers(DBusMessage * message,
- struct wpa_supplicant * wpa_s)
+
+DBusMessage * wpas_dbus_getter_p2p_peers(DBusMessage *message,
+ struct wpa_supplicant *wpa_s)
{
DBusMessage *reply = NULL;
struct p2p_data *p2p = wpa_s->global->p2p;
return reply;
}
+
enum wpas_p2p_role {
WPAS_P2P_ROLE_DEVICE,
WPAS_P2P_ROLE_GO,
}
}
-DBusMessage *wpas_dbus_getter_p2p_role(DBusMessage * message,
- struct wpa_supplicant * wpa_s)
+
+DBusMessage * wpas_dbus_getter_p2p_role(DBusMessage *message,
+ struct wpa_supplicant *wpa_s)
{
char *str;
&str);
}
-DBusMessage *wpas_dbus_getter_p2p_group(DBusMessage * message,
- struct wpa_supplicant * wpa_s)
+
+DBusMessage * wpas_dbus_getter_p2p_group(DBusMessage *message,
+ struct wpa_supplicant *wpa_s)
{
if (wpa_s->dbus_groupobj_path == NULL)
return NULL;
&wpa_s->dbus_groupobj_path);
}
-DBusMessage *wpas_dbus_getter_p2p_peergo(DBusMessage * message,
- struct wpa_supplicant * wpa_s)
+
+DBusMessage * wpas_dbus_getter_p2p_peergo(DBusMessage *message,
+ struct wpa_supplicant *wpa_s)
{
char go_peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
DBUS_TYPE_OBJECT_PATH, &path);
}
+
/*
* Peer object properties accessor methods
*/
-DBusMessage *wpas_dbus_getter_p2p_peer_properties(DBusMessage * message,
- struct peer_handler_args *
- peer_args)
+DBusMessage * wpas_dbus_getter_p2p_peer_properties(
+ DBusMessage *message, struct peer_handler_args *peer_args)
{
DBusMessage *reply = NULL;
DBusMessageIter iter, variant_iter, dict_iter;
const struct p2p_peer_info *info = NULL;
char devtype[WPS_DEV_TYPE_BUFSIZE];
+ const struct wpabuf *vendor_extension[P2P_MAX_WPS_VENDOR_EXT];
+ int i, num;
/* get the peer info */
info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
info->config_methods))
goto err_no_mem;
if (!wpa_dbus_dict_append_int32(&dict_iter, "level",
- info->level))
+ info->level))
goto err_no_mem;
if (!wpa_dbus_dict_append_byte(&dict_iter, "devicecapability",
info->dev_capab))
u8 *sec_dev_type_list = NULL;
char secdevtype[WPS_DEV_TYPE_BUFSIZE];
int num_sec_dev_types = 0;
- int i;
sec_dev_type_list = os_zalloc(info->wps_sec_dev_type_list_len);
if (!sec_dev_types[i] ||
wps_dev_type_bin2str(
- &sec_dev_type_list[i *
- WPS_DEV_TYPE_LEN],
- sec_dev_types[i],
- sizeof(secdevtype)) == NULL) {
+ &sec_dev_type_list[i * WPS_DEV_TYPE_LEN],
+ sec_dev_types[i],
+ sizeof(secdevtype)) == NULL) {
while (--i >= 0)
os_free(sec_dev_types[i]);
os_free(sec_dev_type_list);
}
}
- {
- /* Add WPS vendor extensions attribute */
- const struct wpabuf *vendor_extension[P2P_MAX_WPS_VENDOR_EXT];
- int i, num = 0;
-
- for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
- if (info->wps_vendor_ext[i] == NULL)
- continue;
- vendor_extension[num] = info->wps_vendor_ext[i];
- num++;
- }
-
- if (!wpa_dbus_dict_append_wpabuf_array(
- &dict_iter, "VendorExtension",
- vendor_extension, num))
- goto err_no_mem;
+ /* Add WPS vendor extensions attribute */
+ for (i = 0, num = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
+ if (info->wps_vendor_ext[i] == NULL)
+ continue;
+ vendor_extension[num] = info->wps_vendor_ext[i];
+ num++;
}
+ if (!wpa_dbus_dict_append_wpabuf_array(&dict_iter, "VendorExtension",
+ vendor_extension, num))
+ goto err_no_mem;
+
if (!wpa_dbus_dict_close_write(&variant_iter, &dict_iter) ||
!dbus_message_iter_close_container(&iter, &variant_iter))
goto err_no_mem;
return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY, NULL);
}
-DBusMessage *wpas_dbus_getter_p2p_peer_ies(DBusMessage * message,
- struct peer_handler_args * peer_args)
+
+DBusMessage * wpas_dbus_getter_p2p_peer_ies(
+ DBusMessage *message, struct peer_handler_args *peer_args)
{
return NULL;
}
* Group object properties accessor methods
*/
-DBusMessage *wpas_dbus_getter_p2p_group_members(DBusMessage * message,
- struct wpa_supplicant * wpa_s)
+DBusMessage * wpas_dbus_getter_p2p_group_members(DBusMessage *message,
+ struct wpa_supplicant *wpa_s)
{
DBusMessage *reply = NULL;
struct wpa_ssid *ssid;
}
-DBusMessage *wpas_dbus_getter_p2p_group_properties(
- DBusMessage *message,
- struct wpa_supplicant *wpa_s)
+DBusMessage * wpas_dbus_getter_p2p_group_properties(
+ DBusMessage *message, struct wpa_supplicant *wpa_s)
{
DBusMessage *reply = NULL;
DBusMessageIter iter, variant_iter, dict_iter;
return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY, NULL);
}
-DBusMessage *wpas_dbus_setter_p2p_group_properties(
- DBusMessage *message,
- struct wpa_supplicant *wpa_s)
+
+DBusMessage * wpas_dbus_setter_p2p_group_properties(
+ DBusMessage *message, struct wpa_supplicant *wpa_s)
{
DBusMessage *reply = NULL;
DBusMessageIter iter, variant_iter;
- struct wpa_dbus_dict_entry entry = {.type = DBUS_TYPE_STRING };
+ struct wpa_dbus_dict_entry entry = { .type = DBUS_TYPE_STRING };
DBusMessageIter iter_dict;
unsigned int i;
-
struct hostapd_data *hapd = wpa_s->ap_iface->bss[0];
if (!hapd)
return reply;
}
-DBusMessage *wpas_dbus_handler_p2p_add_service(DBusMessage * message,
- struct wpa_supplicant * wpa_s)
+
+DBusMessage * wpas_dbus_handler_p2p_add_service(DBusMessage *message,
+ struct wpa_supplicant *wpa_s)
{
DBusMessageIter iter_dict;
DBusMessage *reply = NULL;
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
- if (!strcmp(entry.key, "service_type") &&
+ if (!os_strcmp(entry.key, "service_type") &&
(entry.type == DBUS_TYPE_STRING)) {
- if (!strcmp(entry.str_value, "upnp"))
+ if (!os_strcmp(entry.str_value, "upnp"))
upnp = 1;
- else if (!strcmp(entry.str_value, "bonjour"))
+ else if (!os_strcmp(entry.str_value, "bonjour"))
bonjour = 1;
else
goto error_clear;
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
- if (!strcmp(entry.key, "version") &&
+ if (!os_strcmp(entry.key, "version") &&
entry.type == DBUS_TYPE_INT32)
version = entry.uint32_value;
- else if (!strcmp(entry.key, "service") &&
+ else if (!os_strcmp(entry.key, "service") &&
entry.type == DBUS_TYPE_STRING)
service = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
- if (!strcmp(entry.key, "query")) {
+ if (!os_strcmp(entry.key, "query")) {
if ((entry.type != DBUS_TYPE_ARRAY) ||
(entry.array_type != DBUS_TYPE_BYTE))
goto error_clear;
- query = wpabuf_alloc_copy(entry.bytearray_value,
- entry.array_len);
- } else if (!strcmp(entry.key, "response")) {
+ query = wpabuf_alloc_copy(
+ entry.bytearray_value,
+ entry.array_len);
+ } else if (!os_strcmp(entry.key, "response")) {
if ((entry.type != DBUS_TYPE_ARRAY) ||
(entry.array_type != DBUS_TYPE_BYTE))
goto error_clear;
return wpas_dbus_error_invalid_args(message, NULL);
}
-DBusMessage *wpas_dbus_handler_p2p_delete_service(DBusMessage * message,
- struct wpa_supplicant * wpa_s)
+
+DBusMessage * wpas_dbus_handler_p2p_delete_service(
+ DBusMessage *message, struct wpa_supplicant *wpa_s)
{
DBusMessageIter iter_dict;
DBusMessage *reply = NULL;
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
- if (!strcmp(entry.key, "service_type") &&
+ if (!os_strcmp(entry.key, "service_type") &&
(entry.type == DBUS_TYPE_STRING)) {
- if (!strcmp(entry.str_value, "upnp"))
+ if (!os_strcmp(entry.str_value, "upnp"))
upnp = 1;
- else if (!strcmp(entry.str_value, "bonjour"))
+ else if (!os_strcmp(entry.str_value, "bonjour"))
bonjour = 1;
else
goto error_clear;
while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
- if (!strcmp(entry.key, "version") &&
+ if (!os_strcmp(entry.key, "version") &&
entry.type == DBUS_TYPE_INT32)
version = entry.uint32_value;
- else if (!strcmp(entry.key, "service") &&
+ else if (!os_strcmp(entry.key, "service") &&
entry.type == DBUS_TYPE_STRING)
service = os_strdup(entry.str_value);
else
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
- if (!strcmp(entry.key, "query")) {
+ if (!os_strcmp(entry.key, "query")) {
if ((entry.type != DBUS_TYPE_ARRAY) ||
(entry.array_type != DBUS_TYPE_BYTE))
goto error_clear;
- query = wpabuf_alloc_copy(entry.bytearray_value,
- entry.array_len);
+ query = wpabuf_alloc_copy(
+ entry.bytearray_value,
+ entry.array_len);
} else
goto error_clear;
return wpas_dbus_error_invalid_args(message, NULL);
}
-DBusMessage *wpas_dbus_handler_p2p_flush_service(DBusMessage * message,
- struct wpa_supplicant * wpa_s)
+
+DBusMessage * wpas_dbus_handler_p2p_flush_service(DBusMessage *message,
+ struct wpa_supplicant *wpa_s)
{
wpas_p2p_service_flush(wpa_s);
return NULL;
}
-DBusMessage *wpas_dbus_handler_p2p_service_sd_req(DBusMessage * message,
- struct wpa_supplicant * wpa_s)
+
+DBusMessage * wpas_dbus_handler_p2p_service_sd_req(
+ DBusMessage *message, struct wpa_supplicant *wpa_s)
{
DBusMessageIter iter_dict;
DBusMessage *reply = NULL;
while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
- if (!strcmp(entry.key, "peer_object") &&
+ if (!os_strcmp(entry.key, "peer_object") &&
entry.type == DBUS_TYPE_OBJECT_PATH) {
peer_object_path = os_strdup(entry.str_value);
- } else if (!strcmp(entry.key, "service_type") &&
+ } else if (!os_strcmp(entry.key, "service_type") &&
entry.type == DBUS_TYPE_STRING) {
- if (!strcmp(entry.str_value, "upnp"))
+ if (!os_strcmp(entry.str_value, "upnp"))
upnp = 1;
else
goto error_clear;
- } else if (!strcmp(entry.key, "version") &&
+ } else if (!os_strcmp(entry.key, "version") &&
entry.type == DBUS_TYPE_INT32) {
version = entry.uint32_value;
- } else if (!strcmp(entry.key, "service") &&
+ } else if (!os_strcmp(entry.key, "service") &&
entry.type == DBUS_TYPE_STRING) {
service = os_strdup(entry.str_value);
- } else if (!strcmp(entry.key, "tlv")) {
+ } else if (!os_strcmp(entry.key, "tlv")) {
if (entry.type != DBUS_TYPE_ARRAY ||
entry.array_type != DBUS_TYPE_BYTE)
goto error_clear;
if (version <= 0 || service == NULL)
goto error;
- ref = (unsigned long)wpas_p2p_sd_request_upnp(wpa_s, addr,
- version, service);
+ ref = (unsigned long) wpas_p2p_sd_request_upnp(wpa_s, addr,
+ version,
+ service);
} else {
if (tlv == NULL)
goto error;
dbus_message_append_args(reply, DBUS_TYPE_UINT64,
&ref, DBUS_TYPE_INVALID);
} else {
- reply = wpas_dbus_error_unknown_error(message,
- "Unable to send SD request");
+ reply = wpas_dbus_error_unknown_error(
+ message, "Unable to send SD request");
}
out:
os_free(service);
goto out;
}
-DBusMessage *wpas_dbus_handler_p2p_service_sd_res(
+
+DBusMessage * wpas_dbus_handler_p2p_service_sd_res(
DBusMessage *message, struct wpa_supplicant *wpa_s)
{
DBusMessageIter iter_dict;
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
- if (!strcmp(entry.key, "peer_object") &&
+ if (!os_strcmp(entry.key, "peer_object") &&
entry.type == DBUS_TYPE_OBJECT_PATH) {
peer_object_path = os_strdup(entry.str_value);
- } else if (!strcmp(entry.key, "frequency") &&
+ } else if (!os_strcmp(entry.key, "frequency") &&
entry.type == DBUS_TYPE_INT32) {
freq = entry.uint32_value;
- } else if (!strcmp(entry.key, "dialog_token") &&
+ } else if (!os_strcmp(entry.key, "dialog_token") &&
entry.type == DBUS_TYPE_UINT32) {
dlg_tok = entry.uint32_value;
- } else if (!strcmp(entry.key, "tlvs")) {
+ } else if (!os_strcmp(entry.key, "tlvs")) {
if (entry.type != DBUS_TYPE_ARRAY ||
entry.array_type != DBUS_TYPE_BYTE)
goto error_clear;
goto out;
}
-DBusMessage *wpas_dbus_handler_p2p_service_sd_cancel_req(DBusMessage * message, struct wpa_supplicant
- *wpa_s)
+
+DBusMessage * wpas_dbus_handler_p2p_service_sd_cancel_req(
+ DBusMessage *message, struct wpa_supplicant *wpa_s)
{
DBusMessageIter iter;
u64 req = 0;
if (req == 0)
goto error;
- if (!wpas_p2p_sd_cancel_request(wpa_s, (void *)(unsigned long)req))
+ if (!wpas_p2p_sd_cancel_request(wpa_s, (void *)(unsigned long) req))
goto error;
return NULL;
return wpas_dbus_error_invalid_args(message, NULL);
}
-DBusMessage *wpas_dbus_handler_p2p_service_update(DBusMessage * message,
- struct wpa_supplicant * wpa_s)
+
+DBusMessage * wpas_dbus_handler_p2p_service_update(
+ DBusMessage *message, struct wpa_supplicant *wpa_s)
{
wpas_p2p_sd_service_update(wpa_s);
return NULL;
}
-DBusMessage *wpas_dbus_handler_p2p_serv_disc_external(DBusMessage * message,
- struct wpa_supplicant *
- wpa_s)
+
+DBusMessage * wpas_dbus_handler_p2p_serv_disc_external(
+ DBusMessage *message, struct wpa_supplicant *wpa_s)
{
DBusMessageIter iter;
int ext = 0;
projects / thirdparty / hostap.git / commitdiff
