jeltz/hostap
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

P2P: Coding style cleanup for D-Bus handlers

Browse source
This commit is contained in:
Jouni Malinen 2011-07-15 14:18:29 +03:00
parent faa9f2cf95
commit f94a85ee33
1 changed files with 184 additions and 168 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

352
wpa_supplicant/dbus/dbus_new_handlers_p2p.c
View file

@ -70,8 +70,8 @@ static DBusMessage * wpas_dbus_error_persistent_group_unknown(
} }
DBusMessage *wpas_dbus_handler_p2p_find(DBusMessage * message, DBusMessage * wpas_dbus_handler_p2p_find(DBusMessage *message,
struct wpa_supplicant * wpa_s) struct wpa_supplicant *wpa_s)
{ {
struct wpa_dbus_dict_entry entry; struct wpa_dbus_dict_entry entry;
DBusMessage *reply = NULL; DBusMessage *reply = NULL;
@ -135,15 +135,17 @@ error:
return reply; 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); wpas_p2p_stop_find(wpa_s);
return NULL; 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; DBusMessageIter iter;
char *peer_object_path = NULL; char *peer_object_path = NULL;
@ -162,8 +164,9 @@ DBusMessage *wpas_dbus_handler_p2p_rejectpeer(DBusMessage * message,
return 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; dbus_int32_t timeout = 0;
@ -179,8 +182,9 @@ DBusMessage *wpas_dbus_handler_p2p_listen(DBusMessage * message,
return NULL; 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; unsigned int period = 0, interval = 0;
struct wpa_dbus_dict_entry entry; struct wpa_dbus_dict_entry entry;
@ -196,10 +200,10 @@ DBusMessage *wpas_dbus_handler_p2p_extendedlisten(DBusMessage * message,
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error; goto error;
if (!strcmp(entry.key, "period") && if (!os_strcmp(entry.key, "period") &&
(entry.type == DBUS_TYPE_INT32)) (entry.type == DBUS_TYPE_INT32))
period = entry.uint32_value; period = entry.uint32_value;
else if (!strcmp(entry.key, "interval") && else if (!os_strcmp(entry.key, "interval") &&
(entry.type == DBUS_TYPE_INT32)) (entry.type == DBUS_TYPE_INT32))
interval = entry.uint32_value; interval = entry.uint32_value;
else else
@ -208,8 +212,8 @@ DBusMessage *wpas_dbus_handler_p2p_extendedlisten(DBusMessage * message,
} }
if (wpas_p2p_ext_listen(wpa_s, period, interval)) if (wpas_p2p_ext_listen(wpa_s, period, interval))
return wpas_dbus_error_unknown_error(message, return wpas_dbus_error_unknown_error(
"failed to initiate a p2p_ext_listen."); message, "failed to initiate a p2p_ext_listen.");
return NULL; return NULL;
@ -219,9 +223,9 @@ error:
return wpas_dbus_error_invalid_args(message, entry.key); return wpas_dbus_error_invalid_args(message, entry.key);
} }
DBusMessage *wpas_dbus_handler_p2p_presence_request(DBusMessage * message,
struct wpa_supplicant * DBusMessage * wpas_dbus_handler_p2p_presence_request(
wpa_s) DBusMessage *message, struct wpa_supplicant *wpa_s)
{ {
unsigned int dur1 = 0, int1 = 0, dur2 = 0, int2 = 0; unsigned int dur1 = 0, int1 = 0, dur2 = 0, int2 = 0;
struct wpa_dbus_dict_entry entry; struct wpa_dbus_dict_entry entry;
@ -237,16 +241,16 @@ DBusMessage *wpas_dbus_handler_p2p_presence_request(DBusMessage * message,
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error; goto error;
if (!strcmp(entry.key, "duration1") && if (!os_strcmp(entry.key, "duration1") &&
(entry.type == DBUS_TYPE_INT32)) (entry.type == DBUS_TYPE_INT32))
dur1 = entry.uint32_value; dur1 = entry.uint32_value;
else if (!strcmp(entry.key, "interval1") && else if (!os_strcmp(entry.key, "interval1") &&
entry.type == DBUS_TYPE_INT32) entry.type == DBUS_TYPE_INT32)
int1 = entry.uint32_value; int1 = entry.uint32_value;
else if (!strcmp(entry.key, "duration2") && else if (!os_strcmp(entry.key, "duration2") &&
entry.type == DBUS_TYPE_INT32) entry.type == DBUS_TYPE_INT32)
dur2 = entry.uint32_value; dur2 = entry.uint32_value;
else if (!strcmp(entry.key, "interval2") && else if (!os_strcmp(entry.key, "interval2") &&
entry.type == DBUS_TYPE_INT32) entry.type == DBUS_TYPE_INT32)
int2 = entry.uint32_value; int2 = entry.uint32_value;
else else
@ -266,8 +270,9 @@ error:
return wpas_dbus_error_invalid_args(message, entry.key); 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; DBusMessageIter iter_dict;
DBusMessage *reply = NULL; DBusMessage *reply = NULL;
@ -290,15 +295,15 @@ DBusMessage *wpas_dbus_handler_p2p_group_add(DBusMessage * message,
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto inv_args; goto inv_args;
if (!strcmp(entry.key, "persistent") && if (!os_strcmp(entry.key, "persistent") &&
(entry.type == DBUS_TYPE_BOOLEAN)) { (entry.type == DBUS_TYPE_BOOLEAN)) {
persistent_group = (entry.bool_value == TRUE) ? 1 : 0; 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)) { (entry.type == DBUS_TYPE_INT32)) {
freq = entry.int32_value; freq = entry.int32_value;
if (freq <= 0) if (freq <= 0)
goto inv_args_clear; 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) entry.type == DBUS_TYPE_OBJECT_PATH)
pg_object_path = os_strdup(entry.str_value); pg_object_path = os_strdup(entry.str_value);
else else
@ -336,8 +341,9 @@ DBusMessage *wpas_dbus_handler_p2p_group_add(DBusMessage * message,
goto inv_args; goto inv_args;
if (wpas_p2p_group_add_persistent(wpa_s, ssid, 0, freq)) { if (wpas_p2p_group_add_persistent(wpa_s, ssid, 0, freq)) {
reply = wpas_dbus_error_unknown_error(message, reply = wpas_dbus_error_unknown_error(
"Failed to reinvoke a persistent group"); message,
"Failed to reinvoke a persistent group");
goto out; goto out;
} }
} else if (wpas_p2p_group_add(wpa_s, persistent_group, freq)) } else if (wpas_p2p_group_add(wpa_s, persistent_group, freq))
@ -355,8 +361,9 @@ inv_args:
goto out; 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)) if (wpas_p2p_disconnect(wpa_s))
return wpas_dbus_error_unknown_error(message, return wpas_dbus_error_unknown_error(message,
@ -365,8 +372,9 @@ DBusMessage *wpas_dbus_handler_p2p_disconnect(DBusMessage *message,
return NULL; 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); os_memset(wpa_s->p2p_auth_invite, 0, ETH_ALEN);
wpa_s->force_long_sd = 0; wpa_s->force_long_sd = 0;
@ -375,8 +383,9 @@ DBusMessage *wpas_dbus_handler_p2p_flush(DBusMessage * message,
return NULL; 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; DBusMessageIter iter_dict;
DBusMessage *reply = NULL; DBusMessage *reply = NULL;
@ -404,43 +413,43 @@ DBusMessage *wpas_dbus_handler_p2p_connect(DBusMessage * message,
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto inv_args; goto inv_args;
if (!strcmp(entry.key, "peer") && if (!os_strcmp(entry.key, "peer") &&
(entry.type == DBUS_TYPE_OBJECT_PATH)) { (entry.type == DBUS_TYPE_OBJECT_PATH)) {
peer_object_path = os_strdup(entry.str_value); 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)) { (entry.type == DBUS_TYPE_BOOLEAN)) {
persistent_group = (entry.bool_value == TRUE) ? 1 : 0; 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)) { (entry.type == DBUS_TYPE_BOOLEAN)) {
join = (entry.bool_value == TRUE) ? 1 : 0; 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)) { (entry.type == DBUS_TYPE_BOOLEAN)) {
authorize_only = (entry.bool_value == TRUE) ? 1 : 0; 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)) { (entry.type == DBUS_TYPE_INT32)) {
freq = entry.int32_value; freq = entry.int32_value;
if (freq <= 0) if (freq <= 0)
goto inv_args_clear; goto inv_args_clear;
} else if (!strcmp(entry.key, "go_intent") && } else if (!os_strcmp(entry.key, "go_intent") &&
(entry.type == DBUS_TYPE_INT32)) { (entry.type == DBUS_TYPE_INT32)) {
go_intent = entry.int32_value; go_intent = entry.int32_value;
if ((go_intent < 0) || (go_intent > 15)) if ((go_intent < 0) || (go_intent > 15))
goto inv_args_clear; goto inv_args_clear;
} else if (!strcmp(entry.key, "wps_method") && } else if (!os_strcmp(entry.key, "wps_method") &&
(entry.type == DBUS_TYPE_STRING)) { (entry.type == DBUS_TYPE_STRING)) {
if (!strcmp(entry.str_value, "pbc")) if (!os_strcmp(entry.str_value, "pbc"))
wps_method = WPS_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; 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; 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; 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; wps_method = WPS_PIN_KEYPAD;
else else
goto inv_args_clear; goto inv_args_clear;
} else if (!strcmp(entry.key, "pin") && } else if (!os_strcmp(entry.key, "pin") &&
(entry.type == DBUS_TYPE_STRING)) { (entry.type == DBUS_TYPE_STRING)) {
pin = os_strdup(entry.str_value); pin = os_strdup(entry.str_value);
} else } else
@ -511,8 +520,9 @@ inv_args:
goto out; 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; DBusMessageIter iter_dict;
DBusMessage *reply = NULL; DBusMessage *reply = NULL;
@ -536,11 +546,11 @@ DBusMessage *wpas_dbus_handler_p2p_invite(DBusMessage * message,
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto err; goto err;
if (!strcmp(entry.key, "peer") && if (!os_strcmp(entry.key, "peer") &&
(entry.type == DBUS_TYPE_OBJECT_PATH)) { (entry.type == DBUS_TYPE_OBJECT_PATH)) {
peer_object_path = os_strdup(entry.str_value); peer_object_path = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry); 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)) { (entry.type == DBUS_TYPE_OBJECT_PATH)) {
pg_object_path = os_strdup(entry.str_value); pg_object_path = os_strdup(entry.str_value);
persistent = 1; persistent = 1;
@ -561,23 +571,22 @@ DBusMessage *wpas_dbus_handler_p2p_invite(DBusMessage * message,
if (persistent) { if (persistent) {
/* /*
* A group ID is defined meaning we want to re-invoke a * 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, iface = wpas_dbus_new_decompose_object_path(pg_object_path, 1,
&net_id_str, NULL); &net_id_str, NULL);
if (iface == NULL || if (iface == NULL ||
os_strcmp(iface, wpa_s->dbus_new_path) != 0) { os_strcmp(iface, wpa_s->dbus_new_path) != 0) {
reply = reply = wpas_dbus_error_invalid_args(message,
wpas_dbus_error_invalid_args(message, pg_object_path);
pg_object_path);
goto out; goto out;
} }
group_id = strtoul(net_id_str, NULL, 10); group_id = strtoul(net_id_str, NULL, 10);
if (errno == EINVAL) { if (errno == EINVAL) {
reply = wpas_dbus_error_invalid_args( reply = wpas_dbus_error_invalid_args(
message, pg_object_path); message, pg_object_path);
goto out; goto out;
} }
@ -588,8 +597,8 @@ DBusMessage *wpas_dbus_handler_p2p_invite(DBusMessage * message,
if (wpas_p2p_invite(wpa_s, peer_addr, ssid, NULL) < 0) { if (wpas_p2p_invite(wpa_s, peer_addr, ssid, NULL) < 0) {
reply = wpas_dbus_error_unknown_error( reply = wpas_dbus_error_unknown_error(
message, message,
"Failed to reinvoke a persistent group"); "Failed to reinvoke a persistent group");
goto out; goto out;
} }
} else { } else {
@ -597,10 +606,9 @@ DBusMessage *wpas_dbus_handler_p2p_invite(DBusMessage * message,
* No group ID means propose to a peer to join my active group * No group ID means propose to a peer to join my active group
*/ */
if (wpas_p2p_invite_group(wpa_s, wpa_s->ifname, if (wpas_p2p_invite_group(wpa_s, wpa_s->ifname,
peer_addr, NULL)) { peer_addr, NULL)) {
reply = wpas_dbus_error_unknown_error( reply = wpas_dbus_error_unknown_error(
message, message, "Failed to join to an active group");
"Failed to join to an active group");
goto out; goto out;
} }
} }
@ -615,8 +623,9 @@ err:
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; DBusMessageIter iter;
char *peer_object_path = NULL; char *peer_object_path = NULL;
@ -650,13 +659,13 @@ DBusMessage *wpas_dbus_handler_p2p_prov_disc_req(DBusMessage * message,
return NULL; return NULL;
} }
/* /*
* P2P Device property accessor methods. * P2P Device property accessor methods.
*/ */
DBusMessage *wpas_dbus_getter_p2p_device_properties(DBusMessage * message, DBusMessage * wpas_dbus_getter_p2p_device_properties(
struct wpa_supplicant * DBusMessage *message, struct wpa_supplicant *wpa_s)
wpa_s)
{ {
DBusMessage *reply = NULL; DBusMessage *reply = NULL;
DBusMessageIter iter, variant_iter, dict_iter; DBusMessageIter iter, variant_iter, dict_iter;
@ -794,9 +803,9 @@ err_no_mem:
return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY, NULL); return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY, NULL);
} }
DBusMessage *wpas_dbus_setter_p2p_device_properties(DBusMessage * message,
struct wpa_supplicant * DBusMessage * wpas_dbus_setter_p2p_device_properties(
wpa_s) DBusMessage *message, struct wpa_supplicant *wpa_s)
{ {
DBusMessage *reply = NULL; DBusMessage *reply = NULL;
DBusMessageIter iter, variant_iter; DBusMessageIter iter, variant_iter;
@ -832,7 +841,7 @@ DBusMessage *wpas_dbus_setter_p2p_device_properties(DBusMessage * message,
wpa_s->conf->device_name = devname; wpa_s->conf->device_name = devname;
wpa_s->conf->changed_parameters |= wpa_s->conf->changed_parameters |=
CFG_CHANGED_DEVICE_NAME; CFG_CHANGED_DEVICE_NAME;
} else if (os_strcmp(entry.key, "PrimaryDeviceType") == 0) { } else if (os_strcmp(entry.key, "PrimaryDeviceType") == 0) {
if (entry.type != DBUS_TYPE_ARRAY || if (entry.type != DBUS_TYPE_ARRAY ||
entry.array_type != DBUS_TYPE_BYTE || entry.array_type != DBUS_TYPE_BYTE ||
@ -851,7 +860,8 @@ DBusMessage *wpas_dbus_setter_p2p_device_properties(DBusMessage * message,
goto error; goto error;
for (i = 0; i < entry.array_len; i++) 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; goto err_no_mem_clear;
for (i = 0; i < entry.array_len; i++) for (i = 0; i < entry.array_len; i++)
os_memcpy(wpa_s->conf->sec_device_type[i], os_memcpy(wpa_s->conf->sec_device_type[i],
@ -867,7 +877,7 @@ DBusMessage *wpas_dbus_setter_p2p_device_properties(DBusMessage * message,
goto error_clear; goto error_clear;
wpa_s->conf->changed_parameters |= wpa_s->conf->changed_parameters |=
CFG_CHANGED_VENDOR_EXTENSION; CFG_CHANGED_VENDOR_EXTENSION;
for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) { for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
wpabuf_free(wpa_s->conf->wps_vendor_ext[i]); wpabuf_free(wpa_s->conf->wps_vendor_ext[i]);
@ -882,11 +892,9 @@ DBusMessage *wpas_dbus_setter_p2p_device_properties(DBusMessage * message,
(entry.type == DBUS_TYPE_UINT32) && (entry.type == DBUS_TYPE_UINT32) &&
(entry.uint32_value <= 15)) (entry.uint32_value <= 15))
wpa_s->conf->p2p_go_intent = entry.uint32_value; wpa_s->conf->p2p_go_intent = entry.uint32_value;
else if ((os_strcmp(entry.key, "PersistantReconnect") == 0) && else if ((os_strcmp(entry.key, "PersistantReconnect") == 0) &&
(entry.type == DBUS_TYPE_BOOLEAN)) (entry.type == DBUS_TYPE_BOOLEAN))
wpa_s->conf->persistent_reconnect = entry.bool_value; wpa_s->conf->persistent_reconnect = entry.bool_value;
else if ((os_strcmp(entry.key, "ListenRegClass") == 0) && else if ((os_strcmp(entry.key, "ListenRegClass") == 0) &&
(entry.type == DBUS_TYPE_UINT32)) { (entry.type == DBUS_TYPE_UINT32)) {
wpa_s->conf->p2p_listen_reg_class = entry.uint32_value; wpa_s->conf->p2p_listen_reg_class = entry.uint32_value;
@ -926,7 +934,7 @@ DBusMessage *wpas_dbus_setter_p2p_device_properties(DBusMessage * message,
(entry.type == DBUS_TYPE_BOOLEAN)) { (entry.type == DBUS_TYPE_BOOLEAN)) {
wpa_s->conf->p2p_intra_bss = entry.bool_value; wpa_s->conf->p2p_intra_bss = entry.bool_value;
wpa_s->conf->changed_parameters |= wpa_s->conf->changed_parameters |=
CFG_CHANGED_P2P_INTRA_BSS; CFG_CHANGED_P2P_INTRA_BSS;
} else if ((os_strcmp(entry.key, "GroupIdle") == 0) && } else if ((os_strcmp(entry.key, "GroupIdle") == 0) &&
(entry.type == DBUS_TYPE_UINT32)) (entry.type == DBUS_TYPE_UINT32))
wpa_s->conf->p2p_group_idle = entry.uint32_value; wpa_s->conf->p2p_group_idle = entry.uint32_value;
@ -958,8 +966,9 @@ DBusMessage *wpas_dbus_setter_p2p_device_properties(DBusMessage * message,
return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY, NULL); 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; DBusMessage *reply = NULL;
struct p2p_data *p2p = wpa_s->global->p2p; struct p2p_data *p2p = wpa_s->global->p2p;
@ -1036,6 +1045,7 @@ error:
return reply; return reply;
} }
enum wpas_p2p_role { enum wpas_p2p_role {
WPAS_P2P_ROLE_DEVICE, WPAS_P2P_ROLE_DEVICE,
WPAS_P2P_ROLE_GO, WPAS_P2P_ROLE_GO,
@ -1064,8 +1074,9 @@ static enum wpas_p2p_role wpas_get_p2p_role(struct wpa_supplicant *wpa_s)
} }
} }
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; char *str;
@ -1084,8 +1095,9 @@ DBusMessage *wpas_dbus_getter_p2p_role(DBusMessage * message,
&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) if (wpa_s->dbus_groupobj_path == NULL)
return NULL; return NULL;
@ -1095,8 +1107,9 @@ DBusMessage *wpas_dbus_getter_p2p_group(DBusMessage * message,
&wpa_s->dbus_groupobj_path); &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; char go_peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
@ -1111,18 +1124,20 @@ DBusMessage *wpas_dbus_getter_p2p_peergo(DBusMessage * message,
DBUS_TYPE_OBJECT_PATH, &path); DBUS_TYPE_OBJECT_PATH, &path);
} }
/* /*
* Peer object properties accessor methods * Peer object properties accessor methods
*/ */
DBusMessage *wpas_dbus_getter_p2p_peer_properties(DBusMessage * message, DBusMessage * wpas_dbus_getter_p2p_peer_properties(
struct peer_handler_args * DBusMessage *message, struct peer_handler_args *peer_args)
peer_args)
{ {
DBusMessage *reply = NULL; DBusMessage *reply = NULL;
DBusMessageIter iter, variant_iter, dict_iter; DBusMessageIter iter, variant_iter, dict_iter;
const struct p2p_peer_info *info = NULL; const struct p2p_peer_info *info = NULL;
char devtype[WPS_DEV_TYPE_BUFSIZE]; char devtype[WPS_DEV_TYPE_BUFSIZE];
const struct wpabuf *vendor_extension[P2P_MAX_WPS_VENDOR_EXT];
int i, num;
/* get the peer info */ /* get the peer info */
info = p2p_get_peer_found(peer_args->wpa_s->global->p2p, info = p2p_get_peer_found(peer_args->wpa_s->global->p2p,
@ -1156,7 +1171,7 @@ DBusMessage *wpas_dbus_getter_p2p_peer_properties(DBusMessage * message,
info->config_methods)) info->config_methods))
goto err_no_mem; goto err_no_mem;
if (!wpa_dbus_dict_append_int32(&dict_iter, "level", if (!wpa_dbus_dict_append_int32(&dict_iter, "level",
info->level)) info->level))
goto err_no_mem; goto err_no_mem;
if (!wpa_dbus_dict_append_byte(&dict_iter, "devicecapability", if (!wpa_dbus_dict_append_byte(&dict_iter, "devicecapability",
info->dev_capab)) info->dev_capab))
@ -1170,7 +1185,6 @@ DBusMessage *wpas_dbus_getter_p2p_peer_properties(DBusMessage * message,
u8 *sec_dev_type_list = NULL; u8 *sec_dev_type_list = NULL;
char secdevtype[WPS_DEV_TYPE_BUFSIZE]; char secdevtype[WPS_DEV_TYPE_BUFSIZE];
int num_sec_dev_types = 0; int num_sec_dev_types = 0;
int i;
sec_dev_type_list = os_zalloc(info->wps_sec_dev_type_list_len); sec_dev_type_list = os_zalloc(info->wps_sec_dev_type_list_len);
@ -1188,10 +1202,9 @@ DBusMessage *wpas_dbus_getter_p2p_peer_properties(DBusMessage * message,
if (!sec_dev_types[i] || if (!sec_dev_types[i] ||
wps_dev_type_bin2str( wps_dev_type_bin2str(
&sec_dev_type_list[i * &sec_dev_type_list[i * WPS_DEV_TYPE_LEN],
WPS_DEV_TYPE_LEN], sec_dev_types[i],
sec_dev_types[i], sizeof(secdevtype)) == NULL) {
sizeof(secdevtype)) == NULL) {
while (--i >= 0) while (--i >= 0)
os_free(sec_dev_types[i]); os_free(sec_dev_types[i]);
os_free(sec_dev_type_list); os_free(sec_dev_type_list);
@ -1218,24 +1231,18 @@ DBusMessage *wpas_dbus_getter_p2p_peer_properties(DBusMessage * message,
} }
} }
{ /* Add WPS vendor extensions attribute */
/* Add WPS vendor extensions attribute */ for (i = 0, num = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
const struct wpabuf *vendor_extension[P2P_MAX_WPS_VENDOR_EXT]; if (info->wps_vendor_ext[i] == NULL)
int i, num = 0; continue;
vendor_extension[num] = info->wps_vendor_ext[i];
for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) { num++;
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_append_wpabuf_array(&dict_iter, "VendorExtension",
vendor_extension, num))
goto err_no_mem;
if (!wpa_dbus_dict_close_write(&variant_iter, &dict_iter) || if (!wpa_dbus_dict_close_write(&variant_iter, &dict_iter) ||
!dbus_message_iter_close_container(&iter, &variant_iter)) !dbus_message_iter_close_container(&iter, &variant_iter))
goto err_no_mem; goto err_no_mem;
@ -1246,8 +1253,9 @@ err_no_mem:
return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY, NULL); 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; return NULL;
} }
@ -1564,8 +1572,8 @@ DBusMessage * wpas_dbus_handler_remove_all_persistent_groups(
* Group object properties accessor methods * Group object properties accessor methods
*/ */
DBusMessage *wpas_dbus_getter_p2p_group_members(DBusMessage * message, DBusMessage * wpas_dbus_getter_p2p_group_members(DBusMessage *message,
struct wpa_supplicant * wpa_s) struct wpa_supplicant *wpa_s)
{ {
DBusMessage *reply = NULL; DBusMessage *reply = NULL;
struct wpa_ssid *ssid; struct wpa_ssid *ssid;
@ -1624,9 +1632,8 @@ out_of_memory:
} }
DBusMessage *wpas_dbus_getter_p2p_group_properties( DBusMessage * wpas_dbus_getter_p2p_group_properties(
DBusMessage *message, DBusMessage *message, struct wpa_supplicant *wpa_s)
struct wpa_supplicant *wpa_s)
{ {
DBusMessage *reply = NULL; DBusMessage *reply = NULL;
DBusMessageIter iter, variant_iter, dict_iter; DBusMessageIter iter, variant_iter, dict_iter;
@ -1679,16 +1686,15 @@ err_no_mem:
return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY, NULL); return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY, NULL);
} }
DBusMessage *wpas_dbus_setter_p2p_group_properties(
DBusMessage *message, DBusMessage * wpas_dbus_setter_p2p_group_properties(
struct wpa_supplicant *wpa_s) DBusMessage *message, struct wpa_supplicant *wpa_s)
{ {
DBusMessage *reply = NULL; DBusMessage *reply = NULL;
DBusMessageIter iter, variant_iter; 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; DBusMessageIter iter_dict;
unsigned int i; unsigned int i;
struct hostapd_data *hapd = wpa_s->ap_iface->bss[0]; struct hostapd_data *hapd = wpa_s->ap_iface->bss[0];
if (!hapd) if (!hapd)
@ -1741,8 +1747,9 @@ error:
return reply; 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; DBusMessageIter iter_dict;
DBusMessage *reply = NULL; DBusMessage *reply = NULL;
@ -1764,11 +1771,11 @@ DBusMessage *wpas_dbus_handler_p2p_add_service(DBusMessage * message,
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error; goto error;
if (!strcmp(entry.key, "service_type") && if (!os_strcmp(entry.key, "service_type") &&
(entry.type == DBUS_TYPE_STRING)) { (entry.type == DBUS_TYPE_STRING)) {
if (!strcmp(entry.str_value, "upnp")) if (!os_strcmp(entry.str_value, "upnp"))
upnp = 1; upnp = 1;
else if (!strcmp(entry.str_value, "bonjour")) else if (!os_strcmp(entry.str_value, "bonjour"))
bonjour = 1; bonjour = 1;
else else
goto error_clear; goto error_clear;
@ -1781,10 +1788,10 @@ DBusMessage *wpas_dbus_handler_p2p_add_service(DBusMessage * message,
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error; goto error;
if (!strcmp(entry.key, "version") && if (!os_strcmp(entry.key, "version") &&
entry.type == DBUS_TYPE_INT32) entry.type == DBUS_TYPE_INT32)
version = entry.uint32_value; version = entry.uint32_value;
else if (!strcmp(entry.key, "service") && else if (!os_strcmp(entry.key, "service") &&
entry.type == DBUS_TYPE_STRING) entry.type == DBUS_TYPE_STRING)
service = os_strdup(entry.str_value); service = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry); wpa_dbus_dict_entry_clear(&entry);
@ -1801,13 +1808,14 @@ DBusMessage *wpas_dbus_handler_p2p_add_service(DBusMessage * message,
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error; goto error;
if (!strcmp(entry.key, "query")) { if (!os_strcmp(entry.key, "query")) {
if ((entry.type != DBUS_TYPE_ARRAY) || if ((entry.type != DBUS_TYPE_ARRAY) ||
(entry.array_type != DBUS_TYPE_BYTE)) (entry.array_type != DBUS_TYPE_BYTE))
goto error_clear; goto error_clear;
query = wpabuf_alloc_copy(entry.bytearray_value, query = wpabuf_alloc_copy(
entry.array_len); entry.bytearray_value,
} else if (!strcmp(entry.key, "response")) { entry.array_len);
} else if (!os_strcmp(entry.key, "response")) {
if ((entry.type != DBUS_TYPE_ARRAY) || if ((entry.type != DBUS_TYPE_ARRAY) ||
(entry.array_type != DBUS_TYPE_BYTE)) (entry.array_type != DBUS_TYPE_BYTE))
goto error_clear; goto error_clear;
@ -1836,8 +1844,9 @@ error:
return wpas_dbus_error_invalid_args(message, NULL); 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; DBusMessageIter iter_dict;
DBusMessage *reply = NULL; DBusMessage *reply = NULL;
@ -1859,11 +1868,11 @@ DBusMessage *wpas_dbus_handler_p2p_delete_service(DBusMessage * message,
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error; goto error;
if (!strcmp(entry.key, "service_type") && if (!os_strcmp(entry.key, "service_type") &&
(entry.type == DBUS_TYPE_STRING)) { (entry.type == DBUS_TYPE_STRING)) {
if (!strcmp(entry.str_value, "upnp")) if (!os_strcmp(entry.str_value, "upnp"))
upnp = 1; upnp = 1;
else if (!strcmp(entry.str_value, "bonjour")) else if (!os_strcmp(entry.str_value, "bonjour"))
bonjour = 1; bonjour = 1;
else else
goto error_clear; goto error_clear;
@ -1874,10 +1883,10 @@ DBusMessage *wpas_dbus_handler_p2p_delete_service(DBusMessage * message,
while (wpa_dbus_dict_has_dict_entry(&iter_dict)) { while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error; goto error;
if (!strcmp(entry.key, "version") && if (!os_strcmp(entry.key, "version") &&
entry.type == DBUS_TYPE_INT32) entry.type == DBUS_TYPE_INT32)
version = entry.uint32_value; version = entry.uint32_value;
else if (!strcmp(entry.key, "service") && else if (!os_strcmp(entry.key, "service") &&
entry.type == DBUS_TYPE_STRING) entry.type == DBUS_TYPE_STRING)
service = os_strdup(entry.str_value); service = os_strdup(entry.str_value);
else else
@ -1898,12 +1907,13 @@ DBusMessage *wpas_dbus_handler_p2p_delete_service(DBusMessage * message,
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error; goto error;
if (!strcmp(entry.key, "query")) { if (!os_strcmp(entry.key, "query")) {
if ((entry.type != DBUS_TYPE_ARRAY) || if ((entry.type != DBUS_TYPE_ARRAY) ||
(entry.array_type != DBUS_TYPE_BYTE)) (entry.array_type != DBUS_TYPE_BYTE))
goto error_clear; goto error_clear;
query = wpabuf_alloc_copy(entry.bytearray_value, query = wpabuf_alloc_copy(
entry.array_len); entry.bytearray_value,
entry.array_len);
} else } else
goto error_clear; goto error_clear;
@ -1927,15 +1937,17 @@ error:
return wpas_dbus_error_invalid_args(message, NULL); 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); wpas_p2p_service_flush(wpa_s);
return NULL; 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; DBusMessageIter iter_dict;
DBusMessage *reply = NULL; DBusMessage *reply = NULL;
@ -1957,22 +1969,22 @@ DBusMessage *wpas_dbus_handler_p2p_service_sd_req(DBusMessage * message,
while (wpa_dbus_dict_has_dict_entry(&iter_dict)) { while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error; goto error;
if (!strcmp(entry.key, "peer_object") && if (!os_strcmp(entry.key, "peer_object") &&
entry.type == DBUS_TYPE_OBJECT_PATH) { entry.type == DBUS_TYPE_OBJECT_PATH) {
peer_object_path = os_strdup(entry.str_value); 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) { entry.type == DBUS_TYPE_STRING) {
if (!strcmp(entry.str_value, "upnp")) if (!os_strcmp(entry.str_value, "upnp"))
upnp = 1; upnp = 1;
else else
goto error_clear; goto error_clear;
} else if (!strcmp(entry.key, "version") && } else if (!os_strcmp(entry.key, "version") &&
entry.type == DBUS_TYPE_INT32) { entry.type == DBUS_TYPE_INT32) {
version = entry.uint32_value; version = entry.uint32_value;
} else if (!strcmp(entry.key, "service") && } else if (!os_strcmp(entry.key, "service") &&
entry.type == DBUS_TYPE_STRING) { entry.type == DBUS_TYPE_STRING) {
service = os_strdup(entry.str_value); 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 || if (entry.type != DBUS_TYPE_ARRAY ||
entry.array_type != DBUS_TYPE_BYTE) entry.array_type != DBUS_TYPE_BYTE)
goto error_clear; goto error_clear;
@ -1993,8 +2005,9 @@ DBusMessage *wpas_dbus_handler_p2p_service_sd_req(DBusMessage * message,
if (version <= 0 || service == NULL) if (version <= 0 || service == NULL)
goto error; goto error;
ref = (unsigned long)wpas_p2p_sd_request_upnp(wpa_s, addr, ref = (unsigned long) wpas_p2p_sd_request_upnp(wpa_s, addr,
version, service); version,
service);
} else { } else {
if (tlv == NULL) if (tlv == NULL)
goto error; goto error;
@ -2007,8 +2020,8 @@ DBusMessage *wpas_dbus_handler_p2p_service_sd_req(DBusMessage * message,
dbus_message_append_args(reply, DBUS_TYPE_UINT64, dbus_message_append_args(reply, DBUS_TYPE_UINT64,
&ref, DBUS_TYPE_INVALID); &ref, DBUS_TYPE_INVALID);
} else { } else {
reply = wpas_dbus_error_unknown_error(message, reply = wpas_dbus_error_unknown_error(
"Unable to send SD request"); message, "Unable to send SD request");
} }
out: out:
os_free(service); os_free(service);
@ -2023,7 +2036,8 @@ error:
goto out; 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) DBusMessage *message, struct wpa_supplicant *wpa_s)
{ {
DBusMessageIter iter_dict; DBusMessageIter iter_dict;
@ -2045,16 +2059,16 @@ DBusMessage *wpas_dbus_handler_p2p_service_sd_res(
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry)) if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error; goto error;
if (!strcmp(entry.key, "peer_object") && if (!os_strcmp(entry.key, "peer_object") &&
entry.type == DBUS_TYPE_OBJECT_PATH) { entry.type == DBUS_TYPE_OBJECT_PATH) {
peer_object_path = os_strdup(entry.str_value); 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) { entry.type == DBUS_TYPE_INT32) {
freq = entry.uint32_value; freq = entry.uint32_value;
} else if (!strcmp(entry.key, "dialog_token") && } else if (!os_strcmp(entry.key, "dialog_token") &&
entry.type == DBUS_TYPE_UINT32) { entry.type == DBUS_TYPE_UINT32) {
dlg_tok = entry.uint32_value; dlg_tok = entry.uint32_value;
} else if (!strcmp(entry.key, "tlvs")) { } else if (!os_strcmp(entry.key, "tlvs")) {
if (entry.type != DBUS_TYPE_ARRAY || if (entry.type != DBUS_TYPE_ARRAY ||
entry.array_type != DBUS_TYPE_BYTE) entry.array_type != DBUS_TYPE_BYTE)
goto error_clear; goto error_clear;
@ -2085,8 +2099,9 @@ error:
goto out; 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; DBusMessageIter iter;
u64 req = 0; u64 req = 0;
@ -2097,7 +2112,7 @@ DBusMessage *wpas_dbus_handler_p2p_service_sd_cancel_req(DBusMessage * message,
if (req == 0) if (req == 0)
goto error; 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; goto error;
return NULL; return NULL;
@ -2105,16 +2120,17 @@ error:
return wpas_dbus_error_invalid_args(message, 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); wpas_p2p_sd_service_update(wpa_s);
return NULL; return NULL;
} }
DBusMessage *wpas_dbus_handler_p2p_serv_disc_external(DBusMessage * message,
struct wpa_supplicant * DBusMessage * wpas_dbus_handler_p2p_serv_disc_external(
wpa_s) DBusMessage *message, struct wpa_supplicant *wpa_s)
{ {
DBusMessageIter iter; DBusMessageIter iter;
int ext = 0; int ext = 0;