DGNum/hostapd
6
0
Fork 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions

D-Bus: Coding style cleanup

Browse source 
Signed-off-by: Jouni Malinen <j@w1.fi>
This commit is contained in:
Jouni Malinen 2014-12-31 23:21:10 +02:00
parent e3c4f0b5d5
commit 38279bdb35
17 changed files with 636 additions and 630 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
wpa_supplicant/dbus/dbus_common.c
View file

@ -165,6 +165,7 @@ static void process_timeout(void *eloop_ctx, void *sock_ctx)
static dbus_bool_t add_timeout(DBusTimeout *timeout, void *data)
{
struct wpas_dbus_priv *priv = data;
if (!dbus_timeout_get_enabled(timeout))
return TRUE;
@ -180,6 +181,7 @@ static dbus_bool_t add_timeout(DBusTimeout *timeout, void *data)
static void remove_timeout(DBusTimeout *timeout, void *data)
{
struct wpas_dbus_priv *priv = data;
eloop_cancel_timeout(process_timeout, priv, timeout);
dbus_timeout_set_data(timeout, NULL, NULL);
}
@ -244,8 +246,7 @@ static int integrate_with_eloop(struct wpas_dbus_priv *priv)
remove_timeout,
timeout_toggled, priv,
NULL)) {
wpa_printf(MSG_ERROR, "dbus: Failed to set callback "
"functions");
wpa_printf(MSG_ERROR, "dbus: Failed to set callback functions");
return -1;
}
@ -259,12 +260,12 @@ static int integrate_with_eloop(struct wpas_dbus_priv *priv)
static DBusHandlerResult disconnect_filter(DBusConnection *conn,
DBusMessage *message, void *data)
DBusMessage *message, void *data)
{
struct wpas_dbus_priv *priv = data;
if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL,
"Disconnected")) {
"Disconnected")) {
wpa_printf(MSG_DEBUG, "dbus: bus disconnected, terminating");
dbus_connection_set_exit_on_disconnect(conn, FALSE);
wpa_supplicant_terminate_proc(priv->global);
@ -284,10 +285,11 @@ static int wpas_dbus_init_common(struct wpas_dbus_priv *priv)
priv->con = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
if (priv->con) {
dbus_connection_add_filter(priv->con, disconnect_filter, priv,
NULL);
NULL);
} else {
wpa_printf(MSG_ERROR, "dbus: Could not acquire the system "
"bus: %s - %s", error.name, error.message);
wpa_printf(MSG_ERROR,
"dbus: Could not acquire the system bus: %s - %s",
error.name, error.message);
ret = -1;
}
dbus_error_free(&error);
@ -309,7 +311,7 @@ static int wpas_dbus_init_common_finish(struct wpas_dbus_priv *priv)
* FIXME: is there a better solution to this problem?
*/
eloop_register_timeout(0, 50, dispatch_initial_dbus_messages,
priv->con, NULL);
priv->con, NULL);
return 0;
}

30
wpa_supplicant/dbus/dbus_dict_helpers.c
View file

@ -66,7 +66,7 @@ dbus_bool_t wpa_dbus_dict_close_write(DBusMessageIter *iter,
const char * wpa_dbus_type_as_string(const int type)
{
switch(type) {
switch (type) {
case DBUS_TYPE_BYTE:
return DBUS_TYPE_BYTE_AS_STRING;
case DBUS_TYPE_BOOLEAN:
@ -661,7 +661,7 @@ dbus_bool_t wpa_dbus_dict_open_read(DBusMessageIter *iter,
wpa_printf(MSG_MSGDUMP, "%s: start reading a dict entry", __func__);
if (!iter || !iter_dict) {
dbus_set_error_const(error, DBUS_ERROR_FAILED,
"[internal] missing message iterators");
"[internal] missing message iterators");
return FALSE;
}
@ -674,7 +674,7 @@ dbus_bool_t wpa_dbus_dict_open_read(DBusMessageIter *iter,
type != DBUS_TYPE_ARRAY ? '?' :
dbus_message_iter_get_element_type(iter));
dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
"unexpected message argument types");
"unexpected message argument types");
return FALSE;
}
@ -711,10 +711,9 @@ static dbus_bool_t _wpa_dbus_dict_entry_get_byte_array(
BYTE_ARRAY_ITEM_SIZE);
if (nbuffer == NULL) {
os_free(buffer);
wpa_printf(MSG_ERROR, "dbus: _wpa_dbus_dict_"
"entry_get_byte_array out of "
"memory trying to retrieve the "
"string array");
wpa_printf(MSG_ERROR,
"dbus: %s out of memory trying to retrieve the string array",
__func__);
goto done;
}
buffer = nbuffer;
@ -772,10 +771,9 @@ static dbus_bool_t _wpa_dbus_dict_entry_get_string_array(
STR_ARRAY_ITEM_SIZE);
if (nbuffer == NULL) {
os_free(buffer);
wpa_printf(MSG_ERROR, "dbus: _wpa_dbus_dict_"
"entry_get_string_array out of "
"memory trying to retrieve the "
"string array");
wpa_printf(MSG_ERROR,
"dbus: %s out of memory trying to retrieve the string array",
__func__);
goto done;
}
buffer = nbuffer;
@ -787,9 +785,9 @@ static dbus_bool_t _wpa_dbus_dict_entry_get_string_array(
__func__, wpa_debug_show_keys ? value : "[omitted]");
str = os_strdup(value);
if (str == NULL) {
wpa_printf(MSG_ERROR, "dbus: _wpa_dbus_dict_entry_get_"
"string_array out of memory trying to "
"duplicate the string array");
wpa_printf(MSG_ERROR,
"dbus: %s out of memory trying to duplicate the string array",
__func__);
goto done;
}
entry->strarray_value[count] = str;
@ -864,7 +862,7 @@ static dbus_bool_t _wpa_dbus_dict_entry_get_binarray(
os_memset(&tmpentry, 0, sizeof(tmpentry));
tmpentry.type = DBUS_TYPE_ARRAY;
if (_wpa_dbus_dict_entry_get_byte_array(&iter_array, &tmpentry)
== FALSE)
== FALSE)
goto cleanup;
entry->binarray_value[entry->array_len] =
@ -903,7 +901,7 @@ static dbus_bool_t _wpa_dbus_dict_entry_get_array(
dbus_message_iter_recurse(iter_dict_val, &iter_array);
switch (array_type) {
switch (array_type) {
case DBUS_TYPE_BYTE:
success = _wpa_dbus_dict_entry_get_byte_array(&iter_array,
entry);

24
wpa_supplicant/dbus/dbus_dict_helpers.h
View file

@ -72,28 +72,28 @@ dbus_bool_t wpa_dbus_dict_append_byte_array(DBusMessageIter *iter_dict,
/* Manual construction and addition of array elements */
dbus_bool_t wpa_dbus_dict_begin_array(DBusMessageIter *iter_dict,
const char *key, const char *type,
DBusMessageIter *iter_dict_entry,
DBusMessageIter *iter_dict_val,
DBusMessageIter *iter_array);
const char *key, const char *type,
DBusMessageIter *iter_dict_entry,
DBusMessageIter *iter_dict_val,
DBusMessageIter *iter_array);
dbus_bool_t wpa_dbus_dict_begin_string_array(DBusMessageIter *iter_dict,
const char *key,
DBusMessageIter *iter_dict_entry,
DBusMessageIter *iter_dict_val,
DBusMessageIter *iter_array);
const char *key,
DBusMessageIter *iter_dict_entry,
DBusMessageIter *iter_dict_val,
DBusMessageIter *iter_array);
dbus_bool_t wpa_dbus_dict_string_array_add_element(DBusMessageIter *iter_array,
const char *elem);
const char *elem);
dbus_bool_t wpa_dbus_dict_bin_array_add_element(DBusMessageIter *iter_array,
const u8 *value,
size_t value_len);
dbus_bool_t wpa_dbus_dict_end_array(DBusMessageIter *iter_dict,
DBusMessageIter *iter_dict_entry,
DBusMessageIter *iter_dict_val,
DBusMessageIter *iter_array);
DBusMessageIter *iter_dict_entry,
DBusMessageIter *iter_dict_val,
DBusMessageIter *iter_array);
static inline dbus_bool_t
wpa_dbus_dict_end_string_array(DBusMessageIter *iter_dict,

134
wpa_supplicant/dbus/dbus_new.c
View file

@ -75,8 +75,7 @@ static DBusHandlerResult noc_filter(DBusConnection *conn,
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
for (wpa_s = priv->global->ifaces; wpa_s; wpa_s = wpa_s->next)
{
for (wpa_s = priv->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
if (wpa_s->preq_notify_peer != NULL &&
os_strcmp(name, wpa_s->preq_notify_peer) == 0 &&
(new_owner == NULL || os_strlen(new_owner) == 0)) {
@ -511,6 +510,7 @@ void wpas_dbus_signal_network_enabled_changed(struct wpa_supplicant *wpa_s,
{
char path[WPAS_DBUS_OBJECT_PATH_MAX];
os_snprintf(path, WPAS_DBUS_OBJECT_PATH_MAX,
"%s/" WPAS_DBUS_NEW_NETWORKS_PART "/%d",
wpa_s->dbus_new_path, ssid->id);
@ -1537,6 +1537,7 @@ void wpas_dbus_signal_p2p_sd_request(struct wpa_supplicant *wpa_s,
DBusMessageIter iter, dict_iter;
struct wpas_dbus_priv *iface;
char peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
iface = wpa_s->global->dbus;
/* Do nothing if the control interface is not turned on */
@ -1602,6 +1603,7 @@ void wpas_dbus_signal_p2p_sd_response(struct wpa_supplicant *wpa_s,
DBusMessageIter iter, dict_iter;
struct wpas_dbus_priv *iface;
char peer_obj_path[WPAS_DBUS_OBJECT_PATH_MAX], *path;
iface = wpa_s->global->dbus;
/* Do nothing if the control interface is not turned on */
@ -1970,7 +1972,7 @@ static void wpas_dbus_register(struct wpa_dbus_object_desc *obj_desc,
static const struct wpa_dbus_method_desc wpas_dbus_global_methods[] = {
{ "CreateInterface", WPAS_DBUS_NEW_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_create_interface,
(WPADBusMethodHandler) wpas_dbus_handler_create_interface,
{
{ "args", "a{sv}", ARG_IN },
{ "path", "o", ARG_OUT },
@ -1978,14 +1980,14 @@ static const struct wpa_dbus_method_desc wpas_dbus_global_methods[] = {
}
},
{ "RemoveInterface", WPAS_DBUS_NEW_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_remove_interface,
(WPADBusMethodHandler) wpas_dbus_handler_remove_interface,
{
{ "path", "o", ARG_IN },
END_ARGS
}
},
{ "GetInterface", WPAS_DBUS_NEW_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_get_interface,
(WPADBusMethodHandler) wpas_dbus_handler_get_interface,
{
{ "ifname", "s", ARG_IN },
{ "path", "o", ARG_OUT },
@ -2077,8 +2079,8 @@ int wpas_dbus_ctrl_iface_init(struct wpas_dbus_priv *priv)
obj_desc = os_zalloc(sizeof(struct wpa_dbus_object_desc));
if (!obj_desc) {
wpa_printf(MSG_ERROR, "Not enough memory "
"to create object description");
wpa_printf(MSG_ERROR,
"Not enough memory to create object description");
return -1;
}
@ -2192,16 +2194,16 @@ int wpas_dbus_register_network(struct wpa_supplicant *wpa_s,
net_obj_path);
obj_desc = os_zalloc(sizeof(struct wpa_dbus_object_desc));
if (!obj_desc) {
wpa_printf(MSG_ERROR, "Not enough memory "
"to create object description");
wpa_printf(MSG_ERROR,
"Not enough memory to create object description");
goto err;
}
/* allocate memory for handlers arguments */
arg = os_zalloc(sizeof(struct network_handler_args));
if (!arg) {
wpa_printf(MSG_ERROR, "Not enough memory "
"to create arguments for method");
wpa_printf(MSG_ERROR,
"Not enough memory to create arguments for method");
goto err;
}
@ -2407,15 +2409,15 @@ int wpas_dbus_register_bss(struct wpa_supplicant *wpa_s,
obj_desc = os_zalloc(sizeof(struct wpa_dbus_object_desc));
if (!obj_desc) {
wpa_printf(MSG_ERROR, "Not enough memory "
"to create object description");
wpa_printf(MSG_ERROR,
"Not enough memory to create object description");
goto err;
}
arg = os_zalloc(sizeof(struct bss_handler_args));
if (!arg) {
wpa_printf(MSG_ERROR, "Not enough memory "
"to create arguments for handler");
wpa_printf(MSG_ERROR,
"Not enough memory to create arguments for handler");
goto err;
}
arg->wpa_s = wpa_s;
@ -2448,27 +2450,27 @@ err:
static const struct wpa_dbus_method_desc wpas_dbus_interface_methods[] = {
{ "Scan", WPAS_DBUS_NEW_IFACE_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_scan,
(WPADBusMethodHandler) wpas_dbus_handler_scan,
{
{ "args", "a{sv}", ARG_IN },
END_ARGS
}
},
{ "SignalPoll", WPAS_DBUS_NEW_IFACE_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_signal_poll,
(WPADBusMethodHandler) wpas_dbus_handler_signal_poll,
{
{ "args", "a{sv}", ARG_OUT },
END_ARGS
}
},
{ "Disconnect", WPAS_DBUS_NEW_IFACE_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_disconnect,
(WPADBusMethodHandler) wpas_dbus_handler_disconnect,
{
END_ARGS
}
},
{ "AddNetwork", WPAS_DBUS_NEW_IFACE_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_add_network,
(WPADBusMethodHandler) wpas_dbus_handler_add_network,
{
{ "args", "a{sv}", ARG_IN },
{ "path", "o", ARG_OUT },
@ -2476,39 +2478,39 @@ static const struct wpa_dbus_method_desc wpas_dbus_interface_methods[] = {
}
},
{ "Reassociate", WPAS_DBUS_NEW_IFACE_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_reassociate,
(WPADBusMethodHandler) wpas_dbus_handler_reassociate,
{
END_ARGS
}
},
{ "Reattach", WPAS_DBUS_NEW_IFACE_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_reattach,
(WPADBusMethodHandler) wpas_dbus_handler_reattach,
{
END_ARGS
}
},
{ "RemoveNetwork", WPAS_DBUS_NEW_IFACE_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_remove_network,
(WPADBusMethodHandler) wpas_dbus_handler_remove_network,
{
{ "path", "o", ARG_IN },
END_ARGS
}
},
{ "RemoveAllNetworks", WPAS_DBUS_NEW_IFACE_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_remove_all_networks,
(WPADBusMethodHandler) wpas_dbus_handler_remove_all_networks,
{
END_ARGS
}
},
{ "SelectNetwork", WPAS_DBUS_NEW_IFACE_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_select_network,
(WPADBusMethodHandler) wpas_dbus_handler_select_network,
{
{ "path", "o", ARG_IN },
END_ARGS
}
},
{ "NetworkReply", WPAS_DBUS_NEW_IFACE_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_network_reply,
(WPADBusMethodHandler) wpas_dbus_handler_network_reply,
{
{ "path", "o", ARG_IN },
{ "field", "s", ARG_IN },
@ -2518,7 +2520,7 @@ static const struct wpa_dbus_method_desc wpas_dbus_interface_methods[] = {
},
#ifndef CONFIG_NO_CONFIG_BLOBS
{ "AddBlob", WPAS_DBUS_NEW_IFACE_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_add_blob,
(WPADBusMethodHandler) wpas_dbus_handler_add_blob,
{
{ "name", "s", ARG_IN },
{ "data", "ay", ARG_IN },
@ -2526,7 +2528,7 @@ static const struct wpa_dbus_method_desc wpas_dbus_interface_methods[] = {
}
},
{ "GetBlob", WPAS_DBUS_NEW_IFACE_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_get_blob,
(WPADBusMethodHandler) wpas_dbus_handler_get_blob,
{
{ "name", "s", ARG_IN },
{ "data", "ay", ARG_OUT },
@ -2534,7 +2536,7 @@ static const struct wpa_dbus_method_desc wpas_dbus_interface_methods[] = {
}
},
{ "RemoveBlob", WPAS_DBUS_NEW_IFACE_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_remove_blob,
(WPADBusMethodHandler) wpas_dbus_handler_remove_blob,
{
{ "name", "s", ARG_IN },
END_ARGS
@ -2543,7 +2545,7 @@ static const struct wpa_dbus_method_desc wpas_dbus_interface_methods[] = {
#endif /* CONFIG_NO_CONFIG_BLOBS */
{ "SetPKCS11EngineAndModulePath", WPAS_DBUS_NEW_IFACE_INTERFACE,
(WPADBusMethodHandler)
&wpas_dbus_handler_set_pkcs11_engine_and_module_path,
wpas_dbus_handler_set_pkcs11_engine_and_module_path,
{
{ "pkcs11_engine_path", "s", ARG_IN },
{ "pkcs11_module_path", "s", ARG_IN },
@ -2552,7 +2554,7 @@ static const struct wpa_dbus_method_desc wpas_dbus_interface_methods[] = {
},
#ifdef CONFIG_WPS
{ "Start", WPAS_DBUS_NEW_IFACE_WPS,
(WPADBusMethodHandler) &wpas_dbus_handler_wps_start,
(WPADBusMethodHandler) wpas_dbus_handler_wps_start,
{
{ "args", "a{sv}", ARG_IN },
{ "output", "a{sv}", ARG_OUT },
@ -2562,41 +2564,41 @@ static const struct wpa_dbus_method_desc wpas_dbus_interface_methods[] = {
#endif /* CONFIG_WPS */
#ifdef CONFIG_P2P
{ "Find", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_find,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_find,
{
{ "args", "a{sv}", ARG_IN },
END_ARGS
}
},
{ "StopFind", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_stop_find,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_stop_find,
{
END_ARGS
}
},
{ "Listen", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_listen,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_listen,
{
{ "timeout", "i", ARG_IN },
END_ARGS
}
},
{ "ExtendedListen", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_extendedlisten,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_extendedlisten,
{
{ "args", "a{sv}", ARG_IN },
END_ARGS
}
},
{ "PresenceRequest", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_presence_request,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_presence_request,
{
{ "args", "a{sv}", ARG_IN },
END_ARGS
}
},
{ "ProvisionDiscoveryRequest", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_prov_disc_req,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_prov_disc_req,
{
{ "peer", "o", ARG_IN },
{ "config_method", "s", ARG_IN },
@ -2604,7 +2606,7 @@ static const struct wpa_dbus_method_desc wpas_dbus_interface_methods[] = {
}
},
{ "Connect", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_connect,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_connect,
{
{ "args", "a{sv}", ARG_IN },
{ "generated_pin", "s", ARG_OUT },
@ -2612,60 +2614,60 @@ static const struct wpa_dbus_method_desc wpas_dbus_interface_methods[] = {
}
},
{ "GroupAdd", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_group_add,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_group_add,
{
{ "args", "a{sv}", ARG_IN },
END_ARGS
}
},
{ "Invite", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_invite,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_invite,
{
{ "args", "a{sv}", ARG_IN },
END_ARGS
}
},
{ "Disconnect", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_disconnect,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_disconnect,
{
END_ARGS
}
},
{ "RejectPeer", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_rejectpeer,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_rejectpeer,
{
{ "peer", "o", ARG_IN },
END_ARGS
}
},
{ "Flush", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_flush,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_flush,
{
END_ARGS
}
},
{ "AddService", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_add_service,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_add_service,
{
{ "args", "a{sv}", ARG_IN },
END_ARGS
}
},
{ "DeleteService", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_delete_service,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_delete_service,
{
{ "args", "a{sv}", ARG_IN },
END_ARGS
}
},
{ "FlushService", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_flush_service,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_flush_service,
{
END_ARGS
}
},
{ "ServiceDiscoveryRequest", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_service_sd_req,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_service_sd_req,
{
{ "args", "a{sv}", ARG_IN },
{ "ref", "t", ARG_OUT },
@ -2673,27 +2675,27 @@ static const struct wpa_dbus_method_desc wpas_dbus_interface_methods[] = {
}
},
{ "ServiceDiscoveryResponse", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_service_sd_res,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_service_sd_res,
{
{ "args", "a{sv}", ARG_IN },
END_ARGS
}
},
{ "ServiceDiscoveryCancelRequest", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_service_sd_cancel_req,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_service_sd_cancel_req,
{
{ "args", "t", ARG_IN },
END_ARGS
}
},
{ "ServiceUpdate", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_service_update,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_service_update,
{
END_ARGS
}
},
{ "ServiceDiscoveryExternal", WPAS_DBUS_NEW_IFACE_P2PDEVICE,
(WPADBusMethodHandler)wpas_dbus_handler_p2p_serv_disc_external,
(WPADBusMethodHandler) wpas_dbus_handler_p2p_serv_disc_external,
{
{ "arg", "i", ARG_IN },
END_ARGS
@ -2723,7 +2725,7 @@ static const struct wpa_dbus_method_desc wpas_dbus_interface_methods[] = {
},
#endif /* CONFIG_P2P */
{ "FlushBSS", WPAS_DBUS_NEW_IFACE_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_flush_bss,
(WPADBusMethodHandler) wpas_dbus_handler_flush_bss,
{
{ "age", "u", ARG_IN },
END_ARGS
@ -2744,20 +2746,20 @@ static const struct wpa_dbus_method_desc wpas_dbus_interface_methods[] = {
},
#endif /* CONFIG_AP */
{ "EAPLogoff", WPAS_DBUS_NEW_IFACE_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_eap_logoff,
(WPADBusMethodHandler) wpas_dbus_handler_eap_logoff,
{
END_ARGS
}
},
{ "EAPLogon", WPAS_DBUS_NEW_IFACE_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_eap_logon,
(WPADBusMethodHandler) wpas_dbus_handler_eap_logon,
{
END_ARGS
}
},
#ifdef CONFIG_AUTOSCAN
{ "AutoScan", WPAS_DBUS_NEW_IFACE_INTERFACE,
(WPADBusMethodHandler) &wpas_dbus_handler_autoscan,
(WPADBusMethodHandler) wpas_dbus_handler_autoscan,
{
{ "arg", "s", ARG_IN },
END_ARGS
@ -3195,8 +3197,8 @@ int wpas_dbus_register_interface(struct wpa_supplicant *wpa_s)
obj_desc = os_zalloc(sizeof(struct wpa_dbus_object_desc));
if (!obj_desc) {
wpa_printf(MSG_ERROR, "Not enough memory "
"to create object description");
wpa_printf(MSG_ERROR,
"Not enough memory to create object description");
goto err;
}
@ -3432,16 +3434,16 @@ int wpas_dbus_register_peer(struct wpa_supplicant *wpa_s, const u8 *dev_addr)
peer_obj_path);
obj_desc = os_zalloc(sizeof(struct wpa_dbus_object_desc));
if (!obj_desc) {
wpa_printf(MSG_ERROR, "Not enough memory "
"to create object description");
wpa_printf(MSG_ERROR,
"Not enough memory to create object description");
goto err;
}
/* allocate memory for handlers arguments */
arg = os_zalloc(sizeof(struct peer_handler_args));
if (!arg) {
wpa_printf(MSG_ERROR, "Not enough memory "
"to create arguments for method");
wpa_printf(MSG_ERROR,
"Not enough memory to create arguments for method");
goto err;
}
@ -3616,8 +3618,8 @@ void wpas_dbus_register_p2p_group(struct wpa_supplicant *wpa_s,
group_obj_path);
obj_desc = os_zalloc(sizeof(struct wpa_dbus_object_desc));
if (!obj_desc) {
wpa_printf(MSG_ERROR, "Not enough memory "
"to create object description");
wpa_printf(MSG_ERROR,
"Not enough memory to create object description");
goto err;
}
@ -3736,8 +3738,8 @@ int wpas_dbus_register_persistent_group(struct wpa_supplicant *wpa_s,
pgrp_obj_path);
obj_desc = os_zalloc(sizeof(struct wpa_dbus_object_desc));
if (!obj_desc) {
wpa_printf(MSG_ERROR, "dbus: Not enough memory to create "
"object description");
wpa_printf(MSG_ERROR,
"dbus: Not enough memory to create object description");
goto err;
}
@ -3748,8 +3750,8 @@ int wpas_dbus_register_persistent_group(struct wpa_supplicant *wpa_s,
/* allocate memory for handlers arguments */
arg = os_zalloc(sizeof(struct network_handler_args));
if (!arg) {
wpa_printf(MSG_ERROR, "dbus: Not enough memory to create "
"arguments for method");
wpa_printf(MSG_ERROR,
"dbus: Not enough memory to create arguments for method");
goto err;
}

301
wpa_supplicant/dbus/dbus_new_handlers.c
View file

@ -29,7 +29,7 @@
#include "dbus_common_i.h"
#include "drivers/driver.h"
static const char *debug_strings[] = {
static const char * const debug_strings[] = {
"excessive", "msgdump", "debug", "info", "warning", "error", NULL
};
@ -53,9 +53,9 @@ DBusMessage * wpas_dbus_error_unknown_error(DBusMessage *message,
* in this case, we should not call it.
*/
if (message == NULL) {
wpa_printf(MSG_INFO, "dbus: wpas_dbus_error_unknown_error "
"called with NULL message (arg=%s)",
arg ? arg : "N/A");
wpa_printf(MSG_INFO,
"dbus: %s called with NULL message (arg=%s)",
__func__, arg ? arg : "N/A");
return NULL;
}
@ -73,9 +73,9 @@ DBusMessage * wpas_dbus_error_unknown_error(DBusMessage *message,
*/
static DBusMessage * wpas_dbus_error_iface_unknown(DBusMessage *message)
{
return dbus_message_new_error(message, WPAS_DBUS_ERROR_IFACE_UNKNOWN,
"wpa_supplicant knows nothing about "
"this interface.");
return dbus_message_new_error(
message, WPAS_DBUS_ERROR_IFACE_UNKNOWN,
"wpa_supplicant knows nothing about this interface.");
}
@ -88,9 +88,9 @@ static DBusMessage * wpas_dbus_error_iface_unknown(DBusMessage *message)
*/
static DBusMessage * wpas_dbus_error_network_unknown(DBusMessage *message)
{
return dbus_message_new_error(message, WPAS_DBUS_ERROR_NETWORK_UNKNOWN,
"There is no such a network in this "
"interface.");
return dbus_message_new_error(
message, WPAS_DBUS_ERROR_NETWORK_UNKNOWN,
"There is no such a network in this interface.");
}
@ -106,9 +106,9 @@ DBusMessage * wpas_dbus_error_invalid_args(DBusMessage *message,
{
DBusMessage *reply;
reply = dbus_message_new_error(message, WPAS_DBUS_ERROR_INVALID_ARGS,
"Did not receive correct message "
"arguments.");
reply = dbus_message_new_error(
message, WPAS_DBUS_ERROR_INVALID_ARGS,
"Did not receive correct message arguments.");
if (arg != NULL)
dbus_message_append_args(reply, DBUS_TYPE_STRING, &arg,
DBUS_TYPE_INVALID);
@ -134,7 +134,7 @@ static DBusMessage * wpas_dbus_error_scan_error(DBusMessage *message,
}
static const char *dont_quote[] = {
static const char * const dont_quote[] = {
"key_mgmt", "proto", "pairwise", "auth_alg", "group", "eap",
"opensc_engine_path", "pkcs11_engine_path", "pkcs11_module_path",
"bssid", "scan_freq", "freq_list", NULL
@ -143,6 +143,7 @@ static const char *dont_quote[] = {
static dbus_bool_t should_quote_opt(const char *key)
{
int i = 0;
while (dont_quote[i] != NULL) {
if (os_strcmp(key, dont_quote[i]) == 0)
return FALSE;
@ -302,13 +303,13 @@ dbus_bool_t wpas_dbus_simple_property_getter(DBusMessageIter *iter,
if (!dbus_type_is_basic(type)) {
dbus_set_error(error, DBUS_ERROR_FAILED,
"%s: given type is not basic", __func__);
"%s: given type is not basic", __func__);
return FALSE;
}
if (!dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
wpa_dbus_type_as_string(type),
&variant_iter) ||
wpa_dbus_type_as_string(type),
&variant_iter) ||
!dbus_message_iter_append_basic(&variant_iter, type, val) ||
!dbus_message_iter_close_container(iter, &variant_iter)) {
dbus_set_error(error, DBUS_ERROR_FAILED,
@ -379,7 +380,7 @@ dbus_bool_t wpas_dbus_simple_array_property_getter(DBusMessageIter *iter,
if (!dbus_type_is_basic(type)) {
dbus_set_error(error, DBUS_ERROR_FAILED,
"%s: given type is not basic", __func__);
"%s: given type is not basic", __func__);
return FALSE;
}
@ -395,7 +396,7 @@ dbus_bool_t wpas_dbus_simple_array_property_getter(DBusMessageIter *iter,
return FALSE;
}
switch(type) {
switch (type) {
case DBUS_TYPE_BYTE:
case DBUS_TYPE_BOOLEAN:
element_size = 1;
@ -421,7 +422,7 @@ dbus_bool_t wpas_dbus_simple_array_property_getter(DBusMessageIter *iter,
break;
default:
dbus_set_error(error, DBUS_ERROR_FAILED,
"%s: unknown element type %d", __func__, type);
"%s: unknown element type %d", __func__, type);
return FALSE;
}
@ -438,7 +439,7 @@ dbus_bool_t wpas_dbus_simple_array_property_getter(DBusMessageIter *iter,
if (!dbus_message_iter_close_container(&variant_iter, &array_iter) ||
!dbus_message_iter_close_container(iter, &variant_iter)) {
dbus_set_error(error, DBUS_ERROR_FAILED,
"%s: failed to construct message 3", __func__);
"%s: failed to construct message 3", __func__);
return FALSE;
}
@ -537,29 +538,29 @@ DBusMessage * wpas_dbus_handler_create_interface(DBusMessage *message,
while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
if (!os_strcmp(entry.key, "Driver") &&
(entry.type == DBUS_TYPE_STRING)) {
if (os_strcmp(entry.key, "Driver") == 0 &&
entry.type == DBUS_TYPE_STRING) {
os_free(driver);
driver = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
if (driver == NULL)
goto error;
} else if (!os_strcmp(entry.key, "Ifname") &&
(entry.type == DBUS_TYPE_STRING)) {
} else if (os_strcmp(entry.key, "Ifname") == 0 &&
entry.type == DBUS_TYPE_STRING) {
os_free(ifname);
ifname = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
if (ifname == NULL)
goto error;
} else if (!os_strcmp(entry.key, "ConfigFile") &&
(entry.type == DBUS_TYPE_STRING)) {
} else if (os_strcmp(entry.key, "ConfigFile") == 0 &&
entry.type == DBUS_TYPE_STRING) {
os_free(confname);
confname = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
if (confname == NULL)
goto error;
} else if (!os_strcmp(entry.key, "BridgeIfname") &&
(entry.type == DBUS_TYPE_STRING)) {
} else if (os_strcmp(entry.key, "BridgeIfname") == 0 &&
entry.type == DBUS_TYPE_STRING) {
os_free(bridge_ifname);
bridge_ifname = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
@ -579,28 +580,30 @@ DBusMessage * wpas_dbus_handler_create_interface(DBusMessage *message,
* an error if we already control it.
*/
if (wpa_supplicant_get_iface(global, ifname) != NULL) {
reply = dbus_message_new_error(message,
WPAS_DBUS_ERROR_IFACE_EXISTS,
"wpa_supplicant already "
"controls this interface.");
reply = dbus_message_new_error(
message, WPAS_DBUS_ERROR_IFACE_EXISTS,
"wpa_supplicant already controls this interface.");
} else {
struct wpa_supplicant *wpa_s;
struct wpa_interface iface;
os_memset(&iface, 0, sizeof(iface));
iface.driver = driver;
iface.ifname = ifname;
iface.confname = confname;
iface.bridge_ifname = bridge_ifname;
/* Otherwise, have wpa_supplicant attach to it. */
if ((wpa_s = wpa_supplicant_add_iface(global, &iface))) {
wpa_s = wpa_supplicant_add_iface(global, &iface);
if (wpa_s) {
const char *path = wpa_s->dbus_new_path;
reply = dbus_message_new_method_return(message);
dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH,
&path, DBUS_TYPE_INVALID);
&path, DBUS_TYPE_INVALID);
} else {
reply = wpas_dbus_error_unknown_error(
message, "wpa_supplicant couldn't grab this "
"interface.");
message,
"wpa_supplicant couldn't grab this interface.");
}
}
@ -643,8 +646,8 @@ DBusMessage * wpas_dbus_handler_remove_interface(DBusMessage *message,
reply = wpas_dbus_error_iface_unknown(message);
else if (wpa_supplicant_remove_iface(global, wpa_s, 0)) {
reply = wpas_dbus_error_unknown_error(
message, "wpa_supplicant couldn't remove this "
"interface.");
message,
"wpa_supplicant couldn't remove this interface.");
}
return reply;
@ -727,8 +730,8 @@ dbus_bool_t wpas_dbus_getter_debug_level(DBusMessageIter *iter,
* Getter for "DebugTimestamp" property.
*/
dbus_bool_t wpas_dbus_getter_debug_timestamp(DBusMessageIter *iter,
DBusError *error,
void *user_data)
DBusError *error,
void *user_data)
{
return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
&wpa_debug_timestamp, error);
@ -783,8 +786,8 @@ dbus_bool_t wpas_dbus_setter_debug_level(DBusMessageIter *iter,
if (val < 0 ||
wpa_supplicant_set_debug_params(global, val, wpa_debug_timestamp,
wpa_debug_show_keys)) {
dbus_set_error_const(error, DBUS_ERROR_FAILED, "wrong debug "
"level value");
dbus_set_error_const(error, DBUS_ERROR_FAILED,
"wrong debug level value");
return FALSE;
}
@ -934,8 +937,8 @@ dbus_bool_t wpas_dbus_getter_eap_methods(DBusMessageIter *iter,
* and P2P that are determined at compile time.
*/
dbus_bool_t wpas_dbus_getter_global_capabilities(DBusMessageIter *iter,
DBusError *error,
void *user_data)
DBusError *error,
void *user_data)
{
const char *capabilities[5] = { NULL, NULL, NULL, NULL, NULL };
size_t num_items = 0;
@ -964,8 +967,8 @@ static int wpas_dbus_get_scan_type(DBusMessage *message, DBusMessageIter *var,
char **type, DBusMessage **reply)
{
if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_STRING) {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
"Type must be a string");
wpa_printf(MSG_DEBUG, "%s[dbus]: Type must be a string",
__func__);
*reply = wpas_dbus_error_invalid_args(
message, "Wrong Type value type. String required");
return -1;
@ -987,36 +990,36 @@ static int wpas_dbus_get_scan_ssids(DBusMessage *message, DBusMessageIter *var,
int len;
if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_ARRAY) {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: ssids "
"must be an array of arrays of bytes");
wpa_printf(MSG_DEBUG,
"%s[dbus]: ssids must be an array of arrays of bytes",
__func__);
*reply = wpas_dbus_error_invalid_args(
message, "Wrong SSIDs value type. Array of arrays of "
"bytes required");
message,
"Wrong SSIDs value type. Array of arrays of bytes required");
return -1;
}
dbus_message_iter_recurse(var, &array_iter);
if (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY ||
dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_BYTE)
{
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: ssids "
"must be an array of arrays of bytes");
dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_BYTE) {
wpa_printf(MSG_DEBUG,
"%s[dbus]: ssids must be an array of arrays of bytes",
__func__);
*reply = wpas_dbus_error_invalid_args(
message, "Wrong SSIDs value type. Array of arrays of "
"bytes required");
message,
"Wrong SSIDs value type. Array of arrays of bytes required");
return -1;
}
while (dbus_message_iter_get_arg_type(&array_iter) == DBUS_TYPE_ARRAY)
{
while (dbus_message_iter_get_arg_type(&array_iter) == DBUS_TYPE_ARRAY) {
if (ssids_num >= WPAS_MAX_SCAN_SSIDS) {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
"Too many ssids specified on scan dbus "
"call");
wpa_printf(MSG_DEBUG,
"%s[dbus]: Too many ssids specified on scan dbus call",
__func__);
*reply = wpas_dbus_error_invalid_args(
message, "Too many ssids specified. Specify "
"at most four");
message,
"Too many ssids specified. Specify at most four");
return -1;
}
@ -1026,9 +1029,8 @@ static int wpas_dbus_get_scan_ssids(DBusMessage *message, DBusMessageIter *var,
if (len > MAX_SSID_LEN) {
wpa_printf(MSG_DEBUG,
"wpas_dbus_handler_scan[dbus]: "
"SSID too long (len=%d max_len=%d)",
len, MAX_SSID_LEN);
"%s[dbus]: SSID too long (len=%d max_len=%d)",
__func__, len, MAX_SSID_LEN);
*reply = wpas_dbus_error_invalid_args(
message, "Invalid SSID: too long");
return -1;
@ -1038,9 +1040,8 @@ static int wpas_dbus_get_scan_ssids(DBusMessage *message, DBusMessageIter *var,
ssid = os_malloc(len);
if (ssid == NULL) {
wpa_printf(MSG_DEBUG,
"wpas_dbus_handler_scan[dbus]: "
"out of memory. Cannot allocate "
"memory for SSID");
"%s[dbus]: out of memory. Cannot allocate memory for SSID",
__func__);
*reply = dbus_message_new_error(
message, DBUS_ERROR_NO_MEMORY, NULL);
return -1;
@ -1074,28 +1075,28 @@ static int wpas_dbus_get_scan_ies(DBusMessage *message, DBusMessageIter *var,
int len;
if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_ARRAY) {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: ies must "
"be an array of arrays of bytes");
wpa_printf(MSG_DEBUG,
"%s[dbus]: ies must be an array of arrays of bytes",
__func__);
*reply = wpas_dbus_error_invalid_args(
message, "Wrong IEs value type. Array of arrays of "
"bytes required");
message,
"Wrong IEs value type. Array of arrays of bytes required");
return -1;
}
dbus_message_iter_recurse(var, &array_iter);
if (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_ARRAY ||
dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_BYTE)
{
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: ies must "
"be an array of arrays of bytes");
dbus_message_iter_get_element_type(&array_iter) != DBUS_TYPE_BYTE) {
wpa_printf(MSG_DEBUG,
"%s[dbus]: ies must be an array of arrays of bytes",
__func__);
*reply = wpas_dbus_error_invalid_args(
message, "Wrong IEs value type. Array required");
return -1;
}
while (dbus_message_iter_get_arg_type(&array_iter) == DBUS_TYPE_ARRAY)
{
while (dbus_message_iter_get_arg_type(&array_iter) == DBUS_TYPE_ARRAY) {
dbus_message_iter_recurse(&array_iter, &sub_array_iter);
dbus_message_iter_get_fixed_array(&sub_array_iter, &val, &len);
@ -1106,9 +1107,9 @@ static int wpas_dbus_get_scan_ies(DBusMessage *message, DBusMessageIter *var,
nies = os_realloc(ies, ies_len + len);
if (nies == NULL) {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
"out of memory. Cannot allocate memory for "
"IE");
wpa_printf(MSG_DEBUG,
"%s[dbus]: out of memory. Cannot allocate memory for IE",
__func__);
os_free(ies);
*reply = dbus_message_new_error(
message, DBUS_ERROR_NO_MEMORY, NULL);
@ -1137,11 +1138,12 @@ static int wpas_dbus_get_scan_channels(DBusMessage *message,
int freqs_num = 0;
if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_ARRAY) {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
"Channels must be an array of structs");
wpa_printf(MSG_DEBUG,
"%s[dbus]: Channels must be an array of structs",
__func__);
*reply = wpas_dbus_error_invalid_args(
message, "Wrong Channels value type. Array of structs "
"required");
message,
"Wrong Channels value type. Array of structs required");
return -1;
}
@ -1149,11 +1151,11 @@ static int wpas_dbus_get_scan_channels(DBusMessage *message,
if (dbus_message_iter_get_arg_type(&array_iter) != DBUS_TYPE_STRUCT) {
wpa_printf(MSG_DEBUG,
"wpas_dbus_handler_scan[dbus]: Channels must be an "
"array of structs");
"%s[dbus]: Channels must be an array of structs",
__func__);
*reply = wpas_dbus_error_invalid_args(
message, "Wrong Channels value type. Array of structs "
"required");
message,
"Wrong Channels value type. Array of structs required");
return -1;
}
@ -1165,14 +1167,14 @@ static int wpas_dbus_get_scan_channels(DBusMessage *message,
if (dbus_message_iter_get_arg_type(&sub_array_iter) !=
DBUS_TYPE_UINT32) {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
"Channel must by specified by struct of "
"two UINT32s %c",
wpa_printf(MSG_DEBUG,
"%s[dbus]: Channel must by specified by struct of two UINT32s %c",
__func__,
dbus_message_iter_get_arg_type(
&sub_array_iter));
*reply = wpas_dbus_error_invalid_args(
message, "Wrong Channel struct. Two UINT32s "
"required");
message,
"Wrong Channel struct. Two UINT32s required");
os_free(freqs);
return -1;
}
@ -1181,9 +1183,9 @@ static int wpas_dbus_get_scan_channels(DBusMessage *message,
if (!dbus_message_iter_next(&sub_array_iter) ||
dbus_message_iter_get_arg_type(&sub_array_iter) !=
DBUS_TYPE_UINT32) {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
"Channel must by specified by struct of "
"two UINT32s");
wpa_printf(MSG_DEBUG,
"%s[dbus]: Channel must by specified by struct of two UINT32s",
__func__);
*reply = wpas_dbus_error_invalid_args(
message,
"Wrong Channel struct. Two UINT32s required");
@ -1203,9 +1205,9 @@ static int wpas_dbus_get_scan_channels(DBusMessage *message,
freqs = nfreqs;
}
if (freqs == NULL) {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
"out of memory. can't allocate memory for "
"freqs");
wpa_printf(MSG_DEBUG,
"%s[dbus]: out of memory. can't allocate memory for freqs",
__func__);
*reply = dbus_message_new_error(
message, DBUS_ERROR_NO_MEMORY, NULL);
return -1;
@ -1222,8 +1224,9 @@ static int wpas_dbus_get_scan_channels(DBusMessage *message,
os_free(freqs);
freqs = nfreqs;
if (freqs == NULL) {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
"out of memory. Can't allocate memory for freqs");
wpa_printf(MSG_DEBUG,
"%s[dbus]: out of memory. Can't allocate memory for freqs",
__func__);
*reply = dbus_message_new_error(
message, DBUS_ERROR_NO_MEMORY, NULL);
return -1;
@ -1241,8 +1244,8 @@ static int wpas_dbus_get_scan_allow_roam(DBusMessage *message,
DBusMessage **reply)
{
if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_BOOLEAN) {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
"Type must be a boolean");
wpa_printf(MSG_DEBUG, "%s[dbus]: Type must be a boolean",
__func__);
*reply = wpas_dbus_error_invalid_args(
message, "Wrong Type value type. Boolean required");
return -1;
@ -1279,7 +1282,7 @@ DBusMessage * wpas_dbus_handler_scan(DBusMessage *message,
dbus_message_iter_recurse(&iter, &dict_iter);
while (dbus_message_iter_get_arg_type(&dict_iter) ==
DBUS_TYPE_DICT_ENTRY) {
DBUS_TYPE_DICT_ENTRY) {
dbus_message_iter_recurse(&dict_iter, &entry_iter);
dbus_message_iter_get_basic(&entry_iter, &key);
dbus_message_iter_next(&entry_iter);
@ -1308,8 +1311,8 @@ DBusMessage * wpas_dbus_handler_scan(DBusMessage *message,
&reply) < 0)
goto out;
} else {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
"Unknown argument %s", key);
wpa_printf(MSG_DEBUG, "%s[dbus]: Unknown argument %s",
__func__, key);
reply = wpas_dbus_error_invalid_args(message, key);
goto out;
}
@ -1318,19 +1321,20 @@ DBusMessage * wpas_dbus_handler_scan(DBusMessage *message,
}
if (!type) {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
"Scan type not specified");
wpa_printf(MSG_DEBUG, "%s[dbus]: Scan type not specified",
__func__);
reply = wpas_dbus_error_invalid_args(message, key);
goto out;
}
if (!os_strcmp(type, "passive")) {
if (os_strcmp(type, "passive") == 0) {
if (params.num_ssids || params.extra_ies_len) {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
"SSIDs or IEs specified for passive scan.");
wpa_printf(MSG_DEBUG,
"%s[dbus]: SSIDs or IEs specified for passive scan.",
__func__);
reply = wpas_dbus_error_invalid_args(
message, "You can specify only Channels in "
"passive scan");
message,
"You can specify only Channels in passive scan");
goto out;
} else if (params.freqs && params.freqs[0]) {
if (wpa_supplicant_trigger_scan(wpa_s, &params)) {
@ -1341,7 +1345,7 @@ DBusMessage * wpas_dbus_handler_scan(DBusMessage *message,
wpa_s->scan_req = MANUAL_SCAN_REQ;
wpa_supplicant_req_scan(wpa_s, 0, 0);
}
} else if (!os_strcmp(type, "active")) {
} else if (os_strcmp(type, "active") == 0) {
if (!params.num_ssids) {
/* Add wildcard ssid */
params.num_ssids++;
@ -1354,8 +1358,8 @@ DBusMessage * wpas_dbus_handler_scan(DBusMessage *message,
message, "Scan request rejected");
}
} else {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_scan[dbus]: "
"Unknown scan type: %s", type);
wpa_printf(MSG_DEBUG, "%s[dbus]: Unknown scan type: %s",
__func__, type);
reply = wpas_dbus_error_invalid_args(message,
"Wrong scan type");
goto out;
@ -1486,12 +1490,11 @@ DBusMessage * wpas_dbus_handler_add_network(DBusMessage *message,
ssid = wpa_config_add_network(wpa_s->conf);
if (ssid == NULL) {
wpa_printf(MSG_ERROR, "wpas_dbus_handler_add_network[dbus]: "
"can't add new interface.");
wpa_printf(MSG_ERROR, "%s[dbus]: can't add new interface.",
__func__);
reply = wpas_dbus_error_unknown_error(
message,
"wpa_supplicant could not add "
"a network on this interface.");
"wpa_supplicant could not add a network on this interface.");
goto err;
}
wpas_notify_network_added(wpa_s, ssid);
@ -1500,9 +1503,9 @@ DBusMessage * wpas_dbus_handler_add_network(DBusMessage *message,
dbus_error_init(&error);
if (!set_network_properties(wpa_s, ssid, &iter, &error)) {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_add_network[dbus]:"
"control interface couldn't set network "
"properties");
wpa_printf(MSG_DEBUG,
"%s[dbus]: control interface couldn't set network properties",
__func__);
reply = wpas_dbus_reply_new_from_error(message, &error,
DBUS_ERROR_INVALID_ARGS,
"Failed to add network");
@ -1638,19 +1641,19 @@ DBusMessage * wpas_dbus_handler_remove_network(DBusMessage *message,
wpa_supplicant_deauthenticate(wpa_s,
WLAN_REASON_DEAUTH_LEAVING);
else if (!was_disabled && wpa_s->sched_scanning) {
wpa_printf(MSG_DEBUG, "Stop ongoing sched_scan to remove "
"network from filters");
wpa_printf(MSG_DEBUG,
"Stop ongoing sched_scan to remove network from filters");
wpa_supplicant_cancel_sched_scan(wpa_s);
wpa_supplicant_req_scan(wpa_s, 0, 0);
}
if (wpa_config_remove_network(wpa_s->conf, id) < 0) {
wpa_printf(MSG_ERROR,
"wpas_dbus_handler_remove_network[dbus]: "
"error occurred when removing network %d", id);
"%s[dbus]: error occurred when removing network %d",
__func__, id);
reply = wpas_dbus_error_unknown_error(
message, "error removing the specified network on "
"this interface.");
message,
"error removing the specified network on is interface.");
goto out;
}
@ -1668,9 +1671,8 @@ static void remove_network(void *arg, struct wpa_ssid *ssid)
if (wpa_config_remove_network(wpa_s->conf, ssid->id) < 0) {
wpa_printf(MSG_ERROR,
"wpas_dbus_handler_remove_all_networks[dbus]: "
"error occurred when removing network %d",
ssid->id);
"%s[dbus]: error occurred when removing network %d",
__func__, ssid->id);
return;
}
@ -1772,10 +1774,10 @@ DBusMessage * wpas_dbus_handler_network_reply(DBusMessage *message,
struct wpa_ssid *ssid;
if (!dbus_message_get_args(message, NULL,
DBUS_TYPE_OBJECT_PATH, &op,
DBUS_TYPE_STRING, &field,
DBUS_TYPE_STRING, &value,
DBUS_TYPE_INVALID))
DBUS_TYPE_OBJECT_PATH, &op,
DBUS_TYPE_STRING, &field,
DBUS_TYPE_STRING, &value,
DBUS_TYPE_INVALID))
return wpas_dbus_error_invalid_args(message, NULL);
/* Extract the network ID and ensure the network */
@ -2035,6 +2037,7 @@ DBusMessage * wpas_dbus_handler_autoscan(DBusMessage *message,
if (arg != NULL && os_strlen(arg) > 0) {
char *tmp;
tmp = os_strdup(arg);
if (tmp == NULL) {
reply = dbus_message_new_error(message,
@ -2301,8 +2304,7 @@ DBusMessage * wpas_dbus_handler_set_pkcs11_engine_and_module_path(
pkcs11_module_path))
return dbus_message_new_error(
message, DBUS_ERROR_FAILED,
"Reinit of the EAPOL state machine with the new PKCS "
"#11 engine and module path failed.");
"Reinit of the EAPOL state machine with the new PKCS #11 engine and module path failed.");
wpa_dbus_mark_property_changed(
wpa_s->global->dbus, wpa_s->dbus_new_path,
@ -2344,6 +2346,7 @@ dbus_bool_t wpas_dbus_getter_capabilities(DBusMessageIter *iter,
/***** pairwise cipher */
if (res < 0) {
const char *args[] = {"ccmp", "tkip", "none"};
if (!wpa_dbus_dict_append_string_array(
&iter_dict, "Pairwise", args,
ARRAY_SIZE(args)))
@ -2383,6 +2386,7 @@ dbus_bool_t wpas_dbus_getter_capabilities(DBusMessageIter *iter,
const char *args[] = {
"ccmp", "tkip", "wep104", "wep40"
};
if (!wpa_dbus_dict_append_string_array(
&iter_dict, "Group", args,
ARRAY_SIZE(args)))
@ -2501,6 +2505,7 @@ dbus_bool_t wpas_dbus_getter_capabilities(DBusMessageIter *iter,
/***** WPA protocol */
if (res < 0) {
const char *args[] = { "rsn", "wpa" };
if (!wpa_dbus_dict_append_string_array(
&iter_dict, "Protocol", args,
ARRAY_SIZE(args)))
@ -2528,6 +2533,7 @@ dbus_bool_t wpas_dbus_getter_capabilities(DBusMessageIter *iter,
/***** auth alg */
if (res < 0) {
const char *args[] = { "open", "shared", "leap" };
if (!wpa_dbus_dict_append_string_array(
&iter_dict, "AuthAlg", args,
ARRAY_SIZE(args)))
@ -2652,7 +2658,7 @@ dbus_bool_t wpas_dbus_getter_state(DBusMessageIter *iter, DBusError *error,
* Getter for "scanning" property.
*/
dbus_bool_t wpas_dbus_getter_scanning(DBusMessageIter *iter, DBusError *error,
void *user_data)
void *user_data)
{
struct wpa_supplicant *wpa_s = user_data;
dbus_bool_t scanning = wpa_s->scanning ? TRUE : FALSE;
@ -2774,6 +2780,7 @@ dbus_bool_t wpas_dbus_getter_disconnect_reason(DBusMessageIter *iter,
{
struct wpa_supplicant *wpa_s = user_data;
dbus_int32_t reason = wpa_s->disconnect_reason;
return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_INT32,
&reason, error);
}
@ -3028,8 +3035,8 @@ dbus_bool_t wpas_dbus_getter_driver(DBusMessageIter *iter, DBusError *error,
const char *driver;
if (wpa_s->driver == NULL || wpa_s->driver->name == NULL) {
wpa_printf(MSG_DEBUG, "wpas_dbus_getter_driver[dbus]: "
"wpa_s has no driver set");
wpa_printf(MSG_DEBUG, "%s[dbus]: wpa_s has no driver set",
__func__);
dbus_set_error(error, DBUS_ERROR_FAILED, "%s: no driver set",
__func__);
return FALSE;
@ -3149,6 +3156,7 @@ dbus_bool_t wpas_dbus_getter_bridge_ifname(DBusMessageIter *iter,
{
struct wpa_supplicant *wpa_s = user_data;
const char *bridge_ifname = wpa_s->bridge_ifname;
return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
&bridge_ifname, error);
}
@ -3239,7 +3247,8 @@ dbus_bool_t wpas_dbus_getter_networks(DBusMessageIter *iter, DBusError *error,
continue;
paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
if (paths[i] == NULL) {
dbus_set_error(error, DBUS_ERROR_NO_MEMORY, "no memory");
dbus_set_error(error, DBUS_ERROR_NO_MEMORY,
"no memory");
goto out;
}
@ -3380,7 +3389,7 @@ static struct wpa_bss * get_bss_helper(struct bss_handler_args *args,
if (!res) {
wpa_printf(MSG_ERROR, "%s[dbus]: no bss with id %d found",
func_name, args->id);
func_name, args->id);
dbus_set_error(error, DBUS_ERROR_FAILED,
"%s: BSS %d not found",
func_name, args->id);

4
wpa_supplicant/dbus/dbus_new_handlers.h
View file

@ -55,8 +55,8 @@ dbus_bool_t wpas_dbus_getter_debug_level(DBusMessageIter *iter,
void *user_data);
dbus_bool_t wpas_dbus_getter_debug_timestamp(DBusMessageIter *iter,
DBusError *error,
void *user_data);
DBusError *error,
void *user_data);
dbus_bool_t wpas_dbus_getter_debug_show_keys(DBusMessageIter *iter,
DBusError *error,

277
wpa_supplicant/dbus/dbus_new_handlers_p2p.c
View file

@ -57,12 +57,12 @@ static int parse_peer_object_path(const char *peer_path, u8 addr[ETH_ALEN])
*
* Convenience function to create and return an invalid persistent group error.
*/
static DBusMessage * wpas_dbus_error_persistent_group_unknown(
DBusMessage *message)
static DBusMessage *
wpas_dbus_error_persistent_group_unknown(DBusMessage *message)
{
return dbus_message_new_error(message, WPAS_DBUS_ERROR_NETWORK_UNKNOWN,
"There is no such persistent group in "
"this P2P device.");
return dbus_message_new_error(
message, WPAS_DBUS_ERROR_NETWORK_UNKNOWN,
"There is no such persistent group in this P2P device.");
}
@ -89,12 +89,12 @@ DBusMessage * wpas_dbus_handler_p2p_find(DBusMessage *message,
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
if (!os_strcmp(entry.key, "Timeout") &&
(entry.type == DBUS_TYPE_INT32)) {
if (os_strcmp(entry.key, "Timeout") == 0 &&
entry.type == DBUS_TYPE_INT32) {
timeout = entry.uint32_value;
} else if (os_strcmp(entry.key, "RequestedDeviceTypes") == 0) {
if ((entry.type != DBUS_TYPE_ARRAY) ||
(entry.array_type != WPAS_DBUS_TYPE_BINARRAY))
if (entry.type != DBUS_TYPE_ARRAY ||
entry.array_type != WPAS_DBUS_TYPE_BINARRAY)
goto error_clear;
os_free(req_dev_types);
@ -105,20 +105,20 @@ DBusMessage * wpas_dbus_handler_p2p_find(DBusMessage *message,
for (i = 0; i < entry.array_len; i++) {
if (wpabuf_len(entry.binarray_value[i]) !=
WPS_DEV_TYPE_LEN)
WPS_DEV_TYPE_LEN)
goto error_clear;
os_memcpy(req_dev_types + i * WPS_DEV_TYPE_LEN,
wpabuf_head(entry.binarray_value[i]),
WPS_DEV_TYPE_LEN);
}
num_req_dev_types = entry.array_len;
} else if (!os_strcmp(entry.key, "DiscoveryType") &&
(entry.type == DBUS_TYPE_STRING)) {
if (!os_strcmp(entry.str_value, "start_with_full"))
} else if (os_strcmp(entry.key, "DiscoveryType") == 0 &&
entry.type == DBUS_TYPE_STRING) {
if (os_strcmp(entry.str_value, "start_with_full") == 0)
type = P2P_FIND_START_WITH_FULL;
else if (!os_strcmp(entry.str_value, "social"))
else if (os_strcmp(entry.str_value, "social") == 0)
type = P2P_FIND_ONLY_SOCIAL;
else if (!os_strcmp(entry.str_value, "progressive"))
else if (os_strcmp(entry.str_value, "progressive") == 0)
type = P2P_FIND_PROGRESSIVE;
else
goto error_clear;
@ -220,11 +220,11 @@ DBusMessage * wpas_dbus_handler_p2p_extendedlisten(
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
if (!os_strcmp(entry.key, "period") &&
(entry.type == DBUS_TYPE_INT32))
if (os_strcmp(entry.key, "period") == 0 &&
entry.type == DBUS_TYPE_INT32)
period = entry.uint32_value;
else if (!os_strcmp(entry.key, "interval") &&
(entry.type == DBUS_TYPE_INT32))
else if (os_strcmp(entry.key, "interval") == 0 &&
entry.type == DBUS_TYPE_INT32)
interval = entry.uint32_value;
else
goto error_clear;
@ -265,16 +265,16 @@ DBusMessage * wpas_dbus_handler_p2p_presence_request(
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
if (!os_strcmp(entry.key, "duration1") &&
(entry.type == DBUS_TYPE_INT32))
if (os_strcmp(entry.key, "duration1") == 0 &&
entry.type == DBUS_TYPE_INT32)
dur1 = entry.uint32_value;
else if (!os_strcmp(entry.key, "interval1") &&
else if (os_strcmp(entry.key, "interval1") == 0 &&
entry.type == DBUS_TYPE_INT32)
int1 = entry.uint32_value;
else if (!os_strcmp(entry.key, "duration2") &&
else if (os_strcmp(entry.key, "duration2") == 0 &&
entry.type == DBUS_TYPE_INT32)
dur2 = entry.uint32_value;
else if (!os_strcmp(entry.key, "interval2") &&
else if (os_strcmp(entry.key, "interval2") == 0 &&
entry.type == DBUS_TYPE_INT32)
int2 = entry.uint32_value;
else
@ -322,15 +322,16 @@ DBusMessage * wpas_dbus_handler_p2p_group_add(DBusMessage *message,
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto inv_args;
if (!os_strcmp(entry.key, "persistent") &&
(entry.type == DBUS_TYPE_BOOLEAN)) {
persistent_group = (entry.bool_value == TRUE) ? 1 : 0;
} else if (!os_strcmp(entry.key, "frequency") &&
(entry.type == DBUS_TYPE_INT32)) {
if (os_strcmp(entry.key, "persistent") == 0 &&
entry.type == DBUS_TYPE_BOOLEAN) {
persistent_group = entry.bool_value;
} else if (os_strcmp(entry.key, "frequency") == 0 &&
entry.type == DBUS_TYPE_INT32) {
freq = entry.int32_value;
if (freq <= 0)
goto inv_args_clear;
} else if (!os_strcmp(entry.key, "persistent_group_object") &&
} else if (os_strcmp(entry.key, "persistent_group_object") ==
0 &&
entry.type == DBUS_TYPE_OBJECT_PATH)
pg_object_path = os_strdup(entry.str_value);
else
@ -419,8 +420,7 @@ static dbus_bool_t wpa_dbus_p2p_check_enabled(struct wpa_supplicant *wpa_s,
"P2P is not available for this interface");
}
dbus_set_error_const(error, DBUS_ERROR_FAILED,
"P2P is not available for this "
"interface");
"P2P is not available for this interface");
return FALSE;
}
return TRUE;
@ -478,42 +478,42 @@ DBusMessage * wpas_dbus_handler_p2p_connect(DBusMessage *message,
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto inv_args;
if (!os_strcmp(entry.key, "peer") &&
(entry.type == DBUS_TYPE_OBJECT_PATH)) {
if (os_strcmp(entry.key, "peer") == 0 &&
entry.type == DBUS_TYPE_OBJECT_PATH) {
peer_object_path = os_strdup(entry.str_value);
} else if (!os_strcmp(entry.key, "persistent") &&
(entry.type == DBUS_TYPE_BOOLEAN)) {
persistent_group = (entry.bool_value == TRUE) ? 1 : 0;
} else if (!os_strcmp(entry.key, "join") &&
(entry.type == DBUS_TYPE_BOOLEAN)) {
join = (entry.bool_value == TRUE) ? 1 : 0;
} else if (!os_strcmp(entry.key, "authorize_only") &&
(entry.type == DBUS_TYPE_BOOLEAN)) {
authorize_only = (entry.bool_value == TRUE) ? 1 : 0;
} else if (!os_strcmp(entry.key, "frequency") &&
(entry.type == DBUS_TYPE_INT32)) {
} else if (os_strcmp(entry.key, "persistent") == 0 &&
entry.type == DBUS_TYPE_BOOLEAN) {
persistent_group = entry.bool_value;
} else if (os_strcmp(entry.key, "join") == 0 &&
entry.type == DBUS_TYPE_BOOLEAN) {
join = entry.bool_value;
} else if (os_strcmp(entry.key, "authorize_only") == 0 &&
entry.type == DBUS_TYPE_BOOLEAN) {
authorize_only = entry.bool_value;
} else if (os_strcmp(entry.key, "frequency") == 0 &&
entry.type == DBUS_TYPE_INT32) {
freq = entry.int32_value;
if (freq <= 0)
goto inv_args_clear;
} else if (!os_strcmp(entry.key, "go_intent") &&
(entry.type == DBUS_TYPE_INT32)) {
} else if (os_strcmp(entry.key, "go_intent") == 0 &&
entry.type == DBUS_TYPE_INT32) {
go_intent = entry.int32_value;
if ((go_intent < 0) || (go_intent > 15))
goto inv_args_clear;
} else if (!os_strcmp(entry.key, "wps_method") &&
(entry.type == DBUS_TYPE_STRING)) {
if (!os_strcmp(entry.str_value, "pbc"))
} else if (os_strcmp(entry.key, "wps_method") == 0 &&
entry.type == DBUS_TYPE_STRING) {
if (os_strcmp(entry.str_value, "pbc") == 0)
wps_method = WPS_PBC;
else if (!os_strcmp(entry.str_value, "pin"))
else if (os_strcmp(entry.str_value, "pin") == 0)
wps_method = WPS_PIN_DISPLAY;
else if (!os_strcmp(entry.str_value, "display"))
else if (os_strcmp(entry.str_value, "display") == 0)
wps_method = WPS_PIN_DISPLAY;
else if (!os_strcmp(entry.str_value, "keypad"))
else if (os_strcmp(entry.str_value, "keypad") == 0)
wps_method = WPS_PIN_KEYPAD;
else
goto inv_args_clear;
} else if (!os_strcmp(entry.key, "pin") &&
(entry.type == DBUS_TYPE_STRING)) {
} else if (os_strcmp(entry.key, "pin") == 0 &&
entry.type == DBUS_TYPE_STRING) {
pin = os_strdup(entry.str_value);
} else
goto inv_args_clear;
@ -529,7 +529,7 @@ DBusMessage * wpas_dbus_handler_p2p_connect(DBusMessage *message,
/*
* Validate the wps_method specified and the pin value.
*/
if ((!pin || !pin[0]) && (wps_method == WPS_PIN_KEYPAD))
if ((!pin || !pin[0]) && wps_method == WPS_PIN_KEYPAD)
goto inv_args;
if (wpa_s->p2p_dev)
@ -542,6 +542,7 @@ DBusMessage * wpas_dbus_handler_p2p_connect(DBusMessage *message,
if (new_pin >= 0) {
char npin[9];
char *generated_pin;
os_snprintf(npin, sizeof(npin), "%08d", new_pin);
generated_pin = npin;
reply = dbus_message_new_method_return(message);
@ -550,8 +551,8 @@ DBusMessage * wpas_dbus_handler_p2p_connect(DBusMessage *message,
} else {
switch (new_pin) {
case -2:
err_msg = "connect failed due to channel "
"unavailability.";
err_msg =
"connect failed due to channel unavailability.";
iface = WPAS_DBUS_ERROR_CONNECT_CHANNEL_UNAVAILABLE;
break;
@ -614,12 +615,13 @@ DBusMessage * wpas_dbus_handler_p2p_invite(DBusMessage *message,
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto err;
if (!os_strcmp(entry.key, "peer") &&
(entry.type == DBUS_TYPE_OBJECT_PATH)) {
if (os_strcmp(entry.key, "peer") == 0 &&
entry.type == DBUS_TYPE_OBJECT_PATH) {
peer_object_path = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
} else if (!os_strcmp(entry.key, "persistent_group_object") &&
(entry.type == DBUS_TYPE_OBJECT_PATH)) {
} else if (os_strcmp(entry.key, "persistent_group_object") ==
0 &&
entry.type == DBUS_TYPE_OBJECT_PATH) {
pg_object_path = os_strdup(entry.str_value);
persistent = 1;
wpa_dbus_dict_entry_clear(&entry);
@ -773,8 +775,8 @@ dbus_bool_t wpas_dbus_getter_p2p_device_config(DBusMessageIter *iter,
/* Primary device type */
if (!wpa_dbus_dict_append_byte_array(&dict_iter, "PrimaryDeviceType",
(char *)wpa_s->conf->device_type,
WPS_DEV_TYPE_LEN))
(char *) wpa_s->conf->device_type,
WPS_DEV_TYPE_LEN))
goto err_no_mem;
/* Secondary device types */
@ -921,8 +923,8 @@ dbus_bool_t wpas_dbus_setter_p2p_device_config(DBusMessageIter *iter,
wpa_s->conf->changed_parameters |=
CFG_CHANGED_SEC_DEVICE_TYPE;
} else if (os_strcmp(entry.key, "VendorExtension") == 0) {
if ((entry.type != DBUS_TYPE_ARRAY) ||
(entry.array_type != WPAS_DBUS_TYPE_BINARRAY) ||
if (entry.type != DBUS_TYPE_ARRAY ||
entry.array_type != WPAS_DBUS_TYPE_BINARRAY ||
(entry.array_len > P2P_MAX_WPS_VENDOR_EXT))
goto error;
@ -938,30 +940,30 @@ dbus_bool_t wpas_dbus_setter_p2p_device_config(DBusMessageIter *iter,
} else
wpa_s->conf->wps_vendor_ext[i] = NULL;
}
} else if ((os_strcmp(entry.key, "GOIntent") == 0) &&
(entry.type == DBUS_TYPE_UINT32) &&
} else if (os_strcmp(entry.key, "GOIntent") == 0 &&
entry.type == DBUS_TYPE_UINT32 &&
(entry.uint32_value <= 15))
wpa_s->conf->p2p_go_intent = entry.uint32_value;
else if ((os_strcmp(entry.key, "PersistentReconnect") == 0) &&
(entry.type == DBUS_TYPE_BOOLEAN))
else if (os_strcmp(entry.key, "PersistentReconnect") == 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)) {
else if (os_strcmp(entry.key, "ListenRegClass") == 0 &&
entry.type == DBUS_TYPE_UINT32) {
wpa_s->conf->p2p_listen_reg_class = entry.uint32_value;
wpa_s->conf->changed_parameters |=
CFG_CHANGED_P2P_LISTEN_CHANNEL;
} else if ((os_strcmp(entry.key, "ListenChannel") == 0) &&
(entry.type == DBUS_TYPE_UINT32)) {
} else if (os_strcmp(entry.key, "ListenChannel") == 0 &&
entry.type == DBUS_TYPE_UINT32) {
wpa_s->conf->p2p_listen_channel = entry.uint32_value;
wpa_s->conf->changed_parameters |=
CFG_CHANGED_P2P_LISTEN_CHANNEL;
} else if ((os_strcmp(entry.key, "OperRegClass") == 0) &&
(entry.type == DBUS_TYPE_UINT32)) {
} else if (os_strcmp(entry.key, "OperRegClass") == 0 &&
entry.type == DBUS_TYPE_UINT32) {
wpa_s->conf->p2p_oper_reg_class = entry.uint32_value;
wpa_s->conf->changed_parameters |=
CFG_CHANGED_P2P_OPER_CHANNEL;
} else if ((os_strcmp(entry.key, "OperChannel") == 0) &&
(entry.type == DBUS_TYPE_UINT32)) {
} else if (os_strcmp(entry.key, "OperChannel") == 0 &&
entry.type == DBUS_TYPE_UINT32) {
wpa_s->conf->p2p_oper_channel = entry.uint32_value;
wpa_s->conf->changed_parameters |=
CFG_CHANGED_P2P_OPER_CHANNEL;
@ -980,13 +982,13 @@ dbus_bool_t wpas_dbus_setter_p2p_device_config(DBusMessageIter *iter,
wpa_s->conf->changed_parameters |=
CFG_CHANGED_P2P_SSID_POSTFIX;
} else if ((os_strcmp(entry.key, "IntraBss") == 0) &&
(entry.type == DBUS_TYPE_BOOLEAN)) {
} else if (os_strcmp(entry.key, "IntraBss") == 0 &&
entry.type == DBUS_TYPE_BOOLEAN) {
wpa_s->conf->p2p_intra_bss = entry.bool_value;
wpa_s->conf->changed_parameters |=
CFG_CHANGED_P2P_INTRA_BSS;
} else if ((os_strcmp(entry.key, "GroupIdle") == 0) &&
(entry.type == DBUS_TYPE_UINT32))
} else if (os_strcmp(entry.key, "GroupIdle") == 0 &&
entry.type == DBUS_TYPE_UINT32)
wpa_s->conf->p2p_group_idle = entry.uint32_value;
else if (os_strcmp(entry.key, "disassoc_low_ack") == 0 &&
entry.type == DBUS_TYPE_UINT32)
@ -1266,8 +1268,8 @@ dbus_bool_t wpas_dbus_getter_p2p_peer_primary_device_type(
dbus_bool_t wpas_dbus_getter_p2p_peer_config_method(DBusMessageIter *iter,
DBusError *error,
void *user_data)
DBusError *error,
void *user_data)
{
struct peer_handler_args *peer_args = user_data;
const struct p2p_peer_info *info;
@ -1291,8 +1293,8 @@ dbus_bool_t wpas_dbus_getter_p2p_peer_config_method(DBusMessageIter *iter,
dbus_bool_t wpas_dbus_getter_p2p_peer_level(DBusMessageIter *iter,
DBusError *error,
void *user_data)
DBusError *error,
void *user_data)
{
struct peer_handler_args *peer_args = user_data;
const struct p2p_peer_info *info;
@ -1316,8 +1318,8 @@ dbus_bool_t wpas_dbus_getter_p2p_peer_level(DBusMessageIter *iter,
dbus_bool_t wpas_dbus_getter_p2p_peer_device_capability(DBusMessageIter *iter,
DBusError *error,
void *user_data)
DBusError *error,
void *user_data)
{
struct peer_handler_args *peer_args = user_data;
const struct p2p_peer_info *info;
@ -1747,12 +1749,12 @@ DBusMessage * wpas_dbus_handler_add_persistent_group(
ssid = wpa_config_add_network(wpa_s->conf);
if (ssid == NULL) {
wpa_printf(MSG_ERROR, "dbus: %s: "
"Cannot add new persistent group", __func__);
wpa_printf(MSG_ERROR,
"dbus: %s: Cannot add new persistent group",
__func__);
reply = wpas_dbus_error_unknown_error(
message,
"wpa_supplicant could not add "
"a persistent group on this interface.");
"wpa_supplicant could not add a persistent group on this interface.");
goto err;
}
@ -1765,13 +1767,12 @@ DBusMessage * wpas_dbus_handler_add_persistent_group(
dbus_error_init(&error);
if (!set_network_properties(wpa_s, ssid, &iter, &error)) {
wpa_printf(MSG_DEBUG, "dbus: %s: "
"Control interface could not set persistent group "
"properties", __func__);
reply = wpas_dbus_reply_new_from_error(message, &error,
DBUS_ERROR_INVALID_ARGS,
"Failed to set network "
"properties");
wpa_printf(MSG_DEBUG,
"dbus: %s: Control interface could not set persistent group properties",
__func__);
reply = wpas_dbus_reply_new_from_error(
message, &error, DBUS_ERROR_INVALID_ARGS,
"Failed to set network properties");
dbus_error_free(&error);
goto err;
}
@ -1856,13 +1857,12 @@ DBusMessage * wpas_dbus_handler_remove_persistent_group(
wpas_notify_persistent_group_removed(wpa_s, ssid);
if (wpa_config_remove_network(wpa_s->conf, id) < 0) {
wpa_printf(MSG_ERROR, "dbus: %s: "
"error occurred when removing persistent group %d",
wpa_printf(MSG_ERROR,
"dbus: %s: error occurred when removing persistent group %d",
__func__, id);
reply = wpas_dbus_error_unknown_error(
message,
"error removing the specified persistent group on "
"this interface.");
"error removing the specified persistent group on this interface.");
goto out;
}
@ -1878,8 +1878,8 @@ static void remove_persistent_group(struct wpa_supplicant *wpa_s,
wpas_notify_persistent_group_removed(wpa_s, ssid);
if (wpa_config_remove_network(wpa_s->conf, ssid->id) < 0) {
wpa_printf(MSG_ERROR, "dbus: %s: "
"error occurred when removing persistent group %d",
wpa_printf(MSG_ERROR,
"dbus: %s: error occurred when removing persistent group %d",
__func__, ssid->id);
return;
}
@ -1987,6 +1987,7 @@ dbus_bool_t wpas_dbus_getter_p2p_group_ssid(DBusMessageIter *iter,
DBusError *error, void *user_data)
{
struct wpa_supplicant *wpa_s = user_data;
if (wpa_s->current_ssid == NULL)
return FALSE;
return wpas_dbus_simple_array_property_getter(
@ -2279,31 +2280,31 @@ DBusMessage * wpas_dbus_handler_p2p_add_service(DBusMessage *message,
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
if (!os_strcmp(entry.key, "service_type") &&
(entry.type == DBUS_TYPE_STRING)) {
if (!os_strcmp(entry.str_value, "upnp"))
if (os_strcmp(entry.key, "service_type") == 0 &&
entry.type == DBUS_TYPE_STRING) {
if (os_strcmp(entry.str_value, "upnp") == 0)
upnp = 1;
else if (!os_strcmp(entry.str_value, "bonjour"))
else if (os_strcmp(entry.str_value, "bonjour") == 0)
bonjour = 1;
else
goto error_clear;
} else if (!os_strcmp(entry.key, "version") &&
entry.type == DBUS_TYPE_INT32) {
} else if (os_strcmp(entry.key, "version") == 0 &&
entry.type == DBUS_TYPE_INT32) {
version = entry.uint32_value;
} else if (!os_strcmp(entry.key, "service") &&
(entry.type == DBUS_TYPE_STRING)) {
} else if (os_strcmp(entry.key, "service") == 0 &&
entry.type == DBUS_TYPE_STRING) {
os_free(service);
service = os_strdup(entry.str_value);
} else if (!os_strcmp(entry.key, "query")) {
if ((entry.type != DBUS_TYPE_ARRAY) ||
(entry.array_type != DBUS_TYPE_BYTE))
} else if (os_strcmp(entry.key, "query") == 0) {
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 (!os_strcmp(entry.key, "response")) {
if ((entry.type != DBUS_TYPE_ARRAY) ||
(entry.array_type != DBUS_TYPE_BYTE))
} else if (os_strcmp(entry.key, "response") == 0) {
if (entry.type != DBUS_TYPE_ARRAY ||
entry.array_type != DBUS_TYPE_BYTE)
goto error_clear;
resp = wpabuf_alloc_copy(entry.bytearray_value,
entry.array_len);
@ -2364,11 +2365,11 @@ DBusMessage * wpas_dbus_handler_p2p_delete_service(
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
if (!os_strcmp(entry.key, "service_type") &&
(entry.type == DBUS_TYPE_STRING)) {
if (!os_strcmp(entry.str_value, "upnp"))
if (os_strcmp(entry.key, "service_type") == 0 &&
entry.type == DBUS_TYPE_STRING) {
if (os_strcmp(entry.str_value, "upnp") == 0)
upnp = 1;
else if (!os_strcmp(entry.str_value, "bonjour"))
else if (os_strcmp(entry.str_value, "bonjour") == 0)
bonjour = 1;
else
goto error_clear;
@ -2379,10 +2380,10 @@ DBusMessage * wpas_dbus_handler_p2p_delete_service(
while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
if (!os_strcmp(entry.key, "version") &&
if (os_strcmp(entry.key, "version") == 0 &&
entry.type == DBUS_TYPE_INT32)
version = entry.uint32_value;
else if (!os_strcmp(entry.key, "service") &&
else if (os_strcmp(entry.key, "service") == 0 &&
entry.type == DBUS_TYPE_STRING) {
os_free(service);
service = os_strdup(entry.str_value);
@ -2403,9 +2404,9 @@ DBusMessage * wpas_dbus_handler_p2p_delete_service(
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
if (!os_strcmp(entry.key, "query")) {
if ((entry.type != DBUS_TYPE_ARRAY) ||
(entry.array_type != DBUS_TYPE_BYTE))
if (os_strcmp(entry.key, "query") == 0) {
if (entry.type != DBUS_TYPE_ARRAY ||
entry.array_type != DBUS_TYPE_BYTE)
goto error_clear;
wpabuf_free(query);
query = wpabuf_alloc_copy(
@ -2469,22 +2470,22 @@ DBusMessage * wpas_dbus_handler_p2p_service_sd_req(
while (wpa_dbus_dict_has_dict_entry(&iter_dict)) {
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
if (!os_strcmp(entry.key, "peer_object") &&
if (os_strcmp(entry.key, "peer_object") == 0 &&
entry.type == DBUS_TYPE_OBJECT_PATH) {
peer_object_path = os_strdup(entry.str_value);
} else if (!os_strcmp(entry.key, "service_type") &&
} else if (os_strcmp(entry.key, "service_type") == 0 &&
entry.type == DBUS_TYPE_STRING) {
if (!os_strcmp(entry.str_value, "upnp"))
if (os_strcmp(entry.str_value, "upnp") == 0)
upnp = 1;
else
goto error_clear;
} else if (!os_strcmp(entry.key, "version") &&
} else if (os_strcmp(entry.key, "version") == 0 &&
entry.type == DBUS_TYPE_INT32) {
version = entry.uint32_value;
} else if (!os_strcmp(entry.key, "service") &&
} else if (os_strcmp(entry.key, "service") == 0 &&
entry.type == DBUS_TYPE_STRING) {
service = os_strdup(entry.str_value);
} else if (!os_strcmp(entry.key, "tlv")) {
} else if (os_strcmp(entry.key, "tlv") == 0) {
if (entry.type != DBUS_TYPE_ARRAY ||
entry.array_type != DBUS_TYPE_BYTE)
goto error_clear;
@ -2562,17 +2563,17 @@ DBusMessage * wpas_dbus_handler_p2p_service_sd_res(
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
if (!os_strcmp(entry.key, "peer_object") &&
if (os_strcmp(entry.key, "peer_object") == 0 &&
entry.type == DBUS_TYPE_OBJECT_PATH) {
peer_object_path = os_strdup(entry.str_value);
} else if (!os_strcmp(entry.key, "frequency") &&
} else if (os_strcmp(entry.key, "frequency") == 0 &&
entry.type == DBUS_TYPE_INT32) {
freq = entry.uint32_value;
} else if (!os_strcmp(entry.key, "dialog_token") &&
} else if (os_strcmp(entry.key, "dialog_token") == 0 &&
(entry.type == DBUS_TYPE_UINT32 ||
entry.type == DBUS_TYPE_INT32)) {
dlg_tok = entry.uint32_value;
} else if (!os_strcmp(entry.key, "tlvs")) {
} else if (os_strcmp(entry.key, "tlvs") == 0) {
if (entry.type != DBUS_TYPE_ARRAY ||
entry.array_type != DBUS_TYPE_BYTE)
goto error_clear;

24
wpa_supplicant/dbus/dbus_new_handlers_p2p.h
View file

@ -109,34 +109,34 @@ dbus_bool_t wpas_dbus_getter_p2p_peergo(DBusMessageIter *iter,
*/
dbus_bool_t wpas_dbus_getter_p2p_peer_device_name(DBusMessageIter *iter,
DBusError *error,
void *user_data);
DBusError *error,
void *user_data);
dbus_bool_t wpas_dbus_getter_p2p_peer_primary_device_type(
DBusMessageIter *iter, DBusError *error, void *user_data);
dbus_bool_t wpas_dbus_getter_p2p_peer_config_method(DBusMessageIter *iter,
DBusError *error,
void *user_data);
DBusError *error,
void *user_data);
dbus_bool_t wpas_dbus_getter_p2p_peer_level(DBusMessageIter *iter,
DBusError *error,
void *user_data);
DBusError *error,
void *user_data);
dbus_bool_t wpas_dbus_getter_p2p_peer_device_capability(DBusMessageIter *iter,
DBusError *error,
void *user_data);
DBusError *error,
void *user_data);
dbus_bool_t wpas_dbus_getter_p2p_peer_group_capability(DBusMessageIter *iter,
DBusError *error,
void *user_data);
DBusError *error,
void *user_data);
dbus_bool_t wpas_dbus_getter_p2p_peer_secondary_device_types(
DBusMessageIter *iter, DBusError *error, void *user_data);
dbus_bool_t wpas_dbus_getter_p2p_peer_vendor_extension(DBusMessageIter *iter,
DBusError *error,
void *user_data);
DBusError *error,
void *user_data);
dbus_bool_t wpas_dbus_getter_p2p_peer_ies(DBusMessageIter *iter,
DBusError *error,

53
wpa_supplicant/dbus/dbus_new_handlers_wps.c
View file

@ -41,8 +41,8 @@ static int wpas_dbus_handler_wps_role(DBusMessage *message,
dbus_message_iter_recurse(entry_iter, &variant_iter);
if (dbus_message_iter_get_arg_type(&variant_iter) !=
DBUS_TYPE_STRING) {
wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Wrong Role type, "
"string required");
wpa_printf(MSG_DEBUG,
"dbus: WPS.Start - Wrong Role type, string required");
*reply = wpas_dbus_error_invalid_args(message,
"Role must be a string");
return -1;
@ -70,10 +70,9 @@ static int wpas_dbus_handler_wps_type(DBusMessage *message,
char *val;
dbus_message_iter_recurse(entry_iter, &variant_iter);
if (dbus_message_iter_get_arg_type(&variant_iter) !=
DBUS_TYPE_STRING) {
wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Wrong Type type, "
"string required");
if (dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING) {
wpa_printf(MSG_DEBUG,
"dbus: WPS.Start - Wrong Type type, string required");
*reply = wpas_dbus_error_invalid_args(message,
"Type must be a string");
return -1;
@ -105,8 +104,8 @@ static int wpas_dbus_handler_wps_bssid(DBusMessage *message,
if (dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_ARRAY ||
dbus_message_iter_get_element_type(&variant_iter) !=
DBUS_TYPE_BYTE) {
wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Wrong Bssid type, "
"byte array required");
wpa_printf(MSG_DEBUG,
"dbus: WPS.Start - Wrong Bssid type, byte array required");
*reply = wpas_dbus_error_invalid_args(
message, "Bssid must be a byte array");
return -1;
@ -114,8 +113,8 @@ static int wpas_dbus_handler_wps_bssid(DBusMessage *message,
dbus_message_iter_recurse(&variant_iter, &array_iter);
dbus_message_iter_get_fixed_array(&array_iter, &params->bssid, &len);
if (len != ETH_ALEN) {
wpa_printf(MSG_DEBUG, "dbus: WPS.Stsrt - Wrong Bssid length "
"%d", len);
wpa_printf(MSG_DEBUG, "dbus: WPS.Stsrt - Wrong Bssid length %d",
len);
*reply = wpas_dbus_error_invalid_args(message,
"Bssid is wrong length");
return -1;
@ -132,10 +131,9 @@ static int wpas_dbus_handler_wps_pin(DBusMessage *message,
DBusMessageIter variant_iter;
dbus_message_iter_recurse(entry_iter, &variant_iter);
if (dbus_message_iter_get_arg_type(&variant_iter) !=
DBUS_TYPE_STRING) {
wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Wrong Pin type, "
"string required");
if (dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING) {
wpa_printf(MSG_DEBUG,
"dbus: WPS.Start - Wrong Pin type, string required");
*reply = wpas_dbus_error_invalid_args(message,
"Pin must be a string");
return -1;
@ -158,8 +156,8 @@ static int wpas_dbus_handler_wps_p2p_dev_addr(DBusMessage *message,
if (dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_ARRAY ||
dbus_message_iter_get_element_type(&variant_iter) !=
DBUS_TYPE_BYTE) {
wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Wrong "
"P2PDeviceAddress type, byte array required");
wpa_printf(MSG_DEBUG,
"dbus: WPS.Start - Wrong P2PDeviceAddress type, byte array required");
*reply = wpas_dbus_error_invalid_args(
message, "P2PDeviceAddress must be a byte array");
return -1;
@ -168,11 +166,11 @@ static int wpas_dbus_handler_wps_p2p_dev_addr(DBusMessage *message,
dbus_message_iter_get_fixed_array(&array_iter, &params->p2p_dev_addr,
&len);
if (len != ETH_ALEN) {
wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Wrong "
"P2PDeviceAddress length %d", len);
*reply = wpas_dbus_error_invalid_args(message,
"P2PDeviceAddress "
"has wrong length");
wpa_printf(MSG_DEBUG,
"dbus: WPS.Start - Wrong P2PDeviceAddress length %d",
len);
*reply = wpas_dbus_error_invalid_args(
message, "P2PDeviceAddress has wrong length");
return -1;
}
return 0;
@ -258,8 +256,8 @@ DBusMessage * wpas_dbus_handler_wps_start(DBusMessage *message,
return wpas_dbus_error_invalid_args(message,
"Type not specified");
} else if (params.role == 2 && params.pin == NULL) {
wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Pin required for "
"registrar role");
wpa_printf(MSG_DEBUG,
"dbus: WPS.Start - Pin required for registrar role");
return wpas_dbus_error_invalid_args(
message, "Pin required for registrar role.");
}
@ -295,8 +293,8 @@ DBusMessage * wpas_dbus_handler_wps_start(DBusMessage *message,
}
if (ret < 0) {
wpa_printf(MSG_DEBUG, "dbus: WPS.Start wpas_wps_failed in "
"role %s and key %s",
wpa_printf(MSG_DEBUG,
"dbus: WPS.Start wpas_wps_failed in role %s and key %s",
(params.role == 1 ? "enrollee" : "registrar"),
(params.type == 0 ? "" :
(params.type == 1 ? "pin" : "pbc")));
@ -339,7 +337,8 @@ dbus_bool_t wpas_dbus_getter_process_credentials(DBusMessageIter *iter,
void *user_data)
{
struct wpa_supplicant *wpa_s = user_data;
dbus_bool_t process = (wpa_s->conf->wps_cred_processing != 1);
dbus_bool_t process = wpa_s->conf->wps_cred_processing != 1;
return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
&process, error);
}
@ -366,7 +365,7 @@ dbus_bool_t wpas_dbus_setter_process_credentials(DBusMessageIter *iter,
&process_credentials))
return FALSE;
old_pc = (wpa_s->conf->wps_cred_processing != 1);
old_pc = wpa_s->conf->wps_cred_processing != 1;
wpa_s->conf->wps_cred_processing = (process_credentials ? 2 : 1);
if ((wpa_s->conf->wps_cred_processing != 1) != old_pc)

148
wpa_supplicant/dbus/dbus_new_helpers.c
View file

@ -73,7 +73,7 @@ error:
* with properties names as keys and theirs values as values.
*/
static DBusMessage * get_all_properties(DBusMessage *message, char *interface,
struct wpa_dbus_object_desc *obj_dsc)
struct wpa_dbus_object_desc *obj_dsc)
{
DBusMessage *reply;
DBusMessageIter iter, dict_iter;
@ -91,20 +91,17 @@ static DBusMessage * get_all_properties(DBusMessage *message, char *interface,
wpa_printf(MSG_ERROR, "%s: out of memory creating reply",
__func__);
dbus_message_unref(reply);
reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
"out of memory");
return reply;
return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
"out of memory");
}
dbus_error_init(&error);
if (!fill_dict_with_properties(&dict_iter, obj_dsc->properties,
interface, obj_dsc->user_data, &error))
{
interface, obj_dsc->user_data, &error)) {
dbus_message_unref(reply);
reply = wpas_dbus_reply_new_from_error(message, &error,
DBUS_ERROR_INVALID_ARGS,
"No readable properties"
" in this interface");
reply = wpas_dbus_reply_new_from_error(
message, &error, DBUS_ERROR_INVALID_ARGS,
"No readable properties in this interface");
dbus_error_free(&error);
return reply;
}
@ -135,6 +132,7 @@ static int is_signature_correct(DBusMessage *message,
for (arg = method_dsc->args; arg && arg->name; arg++) {
if (arg->dir == ARG_IN) {
size_t blen = registered_sig + MAX_SIG_LEN - pos;
ret = os_snprintf(pos, blen, "%s", arg->type);
if (os_snprintf_error(blen, ret))
return 0;
@ -298,8 +296,7 @@ static DBusMessage * properties_handler(DBusMessage *message,
!os_strncmp(WPA_DBUS_PROPERTIES_GETALL, method,
WPAS_DBUS_METHOD_SIGNAL_PROP_MAX)) {
/* First argument: interface name (DBUS_TYPE_STRING) */
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
{
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) {
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
NULL);
@ -355,8 +352,7 @@ static DBusMessage * msg_method_handler(DBusMessage *message,
NULL);
}
return method_dsc->method_handler(message,
obj_dsc->user_data);
return method_dsc->method_handler(message, obj_dsc->user_data);
}
@ -405,8 +401,7 @@ static DBusHandlerResult message_handler(DBusConnection *connection,
#else /* CONFIG_CTRL_IFACE_DBUS_INTRO */
reply = dbus_message_new_error(
message, DBUS_ERROR_UNKNOWN_METHOD,
"wpa_supplicant was compiled without "
"introspection support.");
"wpa_supplicant was compiled without introspection support.");
#endif /* CONFIG_CTRL_IFACE_DBUS_INTRO */
} else if (!os_strncmp(WPA_DBUS_PROPERTIES_INTERFACE, msg_interface,
WPAS_DBUS_INTERFACE_MAX)) {
@ -459,6 +454,7 @@ static void free_dbus_object_desc_cb(DBusConnection *connection, void *obj_dsc)
free_dbus_object_desc(obj_dsc);
}
/**
* wpa_dbus_ctrl_iface_init - Initialize dbus control interface
* @application_data: Pointer to application specific data structure
@ -486,30 +482,28 @@ int wpa_dbus_ctrl_iface_init(struct wpas_dbus_priv *iface,
obj_desc->path = os_strdup(dbus_path);
/* Register the message handler for the global dbus interface */
if (!dbus_connection_register_object_path(iface->con,
dbus_path, &wpa_vtable,
obj_desc)) {
wpa_printf(MSG_ERROR, "dbus: Could not set up message "
"handler");
if (!dbus_connection_register_object_path(iface->con, dbus_path,
&wpa_vtable, obj_desc)) {
wpa_printf(MSG_ERROR, "dbus: Could not set up message handler");
return -1;
}
/* Register our service with the message bus */
dbus_error_init(&error);
switch (dbus_bus_request_name(iface->con, dbus_service,
0, &error)) {
switch (dbus_bus_request_name(iface->con, dbus_service, 0, &error)) {
case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
ret = 0;
break;
case DBUS_REQUEST_NAME_REPLY_EXISTS:
case DBUS_REQUEST_NAME_REPLY_IN_QUEUE:
case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
wpa_printf(MSG_ERROR, "dbus: Could not request service name: "
"already registered");
wpa_printf(MSG_ERROR,
"dbus: Could not request service name: already registered");
break;
default:
wpa_printf(MSG_ERROR, "dbus: Could not request service name: "
"%s %s", error.name, error.message);
wpa_printf(MSG_ERROR,
"dbus: Could not request service name: %s %s",
error.name, error.message);
break;
}
dbus_error_free(&error);
@ -533,14 +527,12 @@ int wpa_dbus_ctrl_iface_init(struct wpas_dbus_priv *iface,
*
* Registers a new interface with dbus and assigns it a dbus object path.
*/
int wpa_dbus_register_object_per_iface(
struct wpas_dbus_priv *ctrl_iface,
const char *path, const char *ifname,
struct wpa_dbus_object_desc *obj_desc)
int wpa_dbus_register_object_per_iface(struct wpas_dbus_priv *ctrl_iface,
const char *path, const char *ifname,
struct wpa_dbus_object_desc *obj_desc)
{
DBusConnection *con;
DBusError error;
DBusObjectPathVTable vtable = {
&free_dbus_object_desc_cb, &message_handler,
NULL, NULL, NULL, NULL
@ -558,14 +550,12 @@ int wpa_dbus_register_object_per_iface(
/* Register the message handler for the interface functions */
if (!dbus_connection_try_register_object_path(con, path, &vtable,
obj_desc, &error)) {
if (!os_strcmp(error.name, DBUS_ERROR_OBJECT_PATH_IN_USE)) {
if (os_strcmp(error.name, DBUS_ERROR_OBJECT_PATH_IN_USE) == 0) {
wpa_printf(MSG_DEBUG, "dbus: %s", error.message);
} else {
wpa_printf(MSG_ERROR, "dbus: Could not set up message "
"handler for interface %s object %s",
ifname, path);
wpa_printf(MSG_ERROR, "dbus error: %s", error.name);
wpa_printf(MSG_ERROR, "dbus: %s", error.message);
wpa_printf(MSG_ERROR,
"dbus: Could not set up message handler for interface %s object %s (error: %s message: %s)",
ifname, path, error.name, error.message);
}
dbus_error_free(&error);
return -1;
@ -595,8 +585,9 @@ int wpa_dbus_unregister_object_per_iface(
dbus_connection_get_object_path_data(con, path, (void **) &obj_desc);
if (!obj_desc) {
wpa_printf(MSG_ERROR, "dbus: %s: Could not obtain object's "
"private data: %s", __func__, path);
wpa_printf(MSG_ERROR,
"dbus: %s: Could not obtain object's private data: %s",
__func__, path);
return 0;
}
@ -638,14 +629,14 @@ static dbus_bool_t put_changed_properties(
dbus_error_init(&error);
if (!dsc->getter(&entry_iter, &error, obj_dsc->user_data)) {
if (dbus_error_is_set (&error)) {
wpa_printf(MSG_ERROR, "dbus: %s: Cannot get "
"new value of property %s: (%s) %s",
__func__, dsc->dbus_property,
error.name, error.message);
if (dbus_error_is_set(&error)) {
wpa_printf(MSG_ERROR,
"dbus: %s: Cannot get new value of property %s: (%s) %s",
__func__, dsc->dbus_property,
error.name, error.message);
} else {
wpa_printf(MSG_ERROR, "dbus: %s: Cannot get "
"new value of property %s",
wpa_printf(MSG_ERROR,
"dbus: %s: Cannot get new value of property %s",
__func__, dsc->dbus_property);
}
dbus_error_free(&error);
@ -684,19 +675,14 @@ static void do_send_prop_changed_signal(
/* Invalidated properties array (empty) */
!dbus_message_iter_open_container(&signal_iter, DBUS_TYPE_ARRAY,
"s", &dict_iter) ||
!dbus_message_iter_close_container(&signal_iter, &dict_iter))
goto err;
!dbus_message_iter_close_container(&signal_iter, &dict_iter)) {
wpa_printf(MSG_DEBUG, "dbus: %s: Failed to construct signal",
__func__);
} else {
dbus_connection_send(con, msg, NULL);
}
dbus_connection_send(con, msg, NULL);
out:
dbus_message_unref(msg);
return;
err:
wpa_printf(MSG_DEBUG, "dbus: %s: Failed to construct signal",
__func__);
goto out;
}
@ -716,19 +702,14 @@ static void do_send_deprecated_prop_changed_signal(
if (!dbus_message_iter_open_container(&signal_iter, DBUS_TYPE_ARRAY,
"{sv}", &dict_iter) ||
!put_changed_properties(obj_dsc, interface, &dict_iter, 1) ||
!dbus_message_iter_close_container(&signal_iter, &dict_iter))
goto err;
!dbus_message_iter_close_container(&signal_iter, &dict_iter)) {
wpa_printf(MSG_DEBUG, "dbus: %s: Failed to construct signal",
__func__);
} else {
dbus_connection_send(con, msg, NULL);
}
dbus_connection_send(con, msg, NULL);
out:
dbus_message_unref(msg);
return;
err:
wpa_printf(MSG_DEBUG, "dbus: %s: Failed to construct signal",
__func__);
goto out;
}
@ -760,8 +741,9 @@ static void flush_object_timeout_handler(void *eloop_ctx, void *timeout_ctx)
DBusConnection *con = eloop_ctx;
struct wpa_dbus_object_desc *obj_desc = timeout_ctx;
wpa_printf(MSG_DEBUG, "dbus: %s: Timeout - sending changed properties "
"of object %s", __func__, obj_desc->path);
wpa_printf(MSG_DEBUG,
"dbus: %s: Timeout - sending changed properties of object %s",
__func__, obj_desc->path);
wpa_dbus_flush_object_changed_properties(con, obj_desc->path);
}
@ -872,8 +854,9 @@ void wpa_dbus_mark_property_changed(struct wpas_dbus_priv *iface,
dbus_connection_get_object_path_data(iface->con, path,
(void **) &obj_desc);
if (!obj_desc) {
wpa_printf(MSG_ERROR, "dbus: wpa_dbus_property_changed: "
"could not obtain object's private data: %s", path);
wpa_printf(MSG_ERROR,
"dbus: wpa_dbus_property_changed: could not obtain object's private data: %s",
path);
return;
}
@ -886,8 +869,9 @@ void wpa_dbus_mark_property_changed(struct wpas_dbus_priv *iface,
}
if (!dsc || !dsc->dbus_property) {
wpa_printf(MSG_ERROR, "dbus: wpa_dbus_property_changed: "
"no property %s in object %s", property, path);
wpa_printf(MSG_ERROR,
"dbus: wpa_dbus_property_changed: no property %s in object %s",
property, path);
return;
}
@ -924,8 +908,9 @@ dbus_bool_t wpa_dbus_get_object_properties(struct wpas_dbus_priv *iface,
dbus_connection_get_object_path_data(iface->con, path,
(void **) &obj_desc);
if (!obj_desc) {
wpa_printf(MSG_ERROR, "dbus: %s: could not obtain object's "
"private data: %s", __func__, path);
wpa_printf(MSG_ERROR,
"dbus: %s: could not obtain object's private data: %s",
__func__, path);
return FALSE;
}
@ -939,10 +924,11 @@ dbus_bool_t wpa_dbus_get_object_properties(struct wpas_dbus_priv *iface,
if (!fill_dict_with_properties(&dict_iter, obj_desc->properties,
interface, obj_desc->user_data,
&error)) {
wpa_printf(MSG_ERROR, "dbus: %s: failed to get object"
" properties: (%s) %s", __func__,
dbus_error_is_set(&error) ? error.name : "none",
dbus_error_is_set(&error) ? error.message : "none");
wpa_printf(MSG_ERROR,
"dbus: %s: failed to get object properties: (%s) %s",
__func__,
dbus_error_is_set(&error) ? error.name : "none",
dbus_error_is_set(&error) ? error.message : "none");
dbus_error_free(&error);
return FALSE;
}

12
wpa_supplicant/dbus/dbus_new_helpers.h
View file

@ -12,13 +12,13 @@
#include <dbus/dbus.h>
typedef DBusMessage * (* WPADBusMethodHandler)(DBusMessage *message,
void *user_data);
typedef void (* WPADBusArgumentFreeFunction)(void *handler_arg);
typedef DBusMessage * (*WPADBusMethodHandler)(DBusMessage *message,
void *user_data);
typedef void (*WPADBusArgumentFreeFunction)(void *handler_arg);
typedef dbus_bool_t (* WPADBusPropertyAccessor)(DBusMessageIter *iter,
DBusError *error,
void *user_data);
typedef dbus_bool_t (*WPADBusPropertyAccessor)(DBusMessageIter *iter,
DBusError *error,
void *user_data);
struct wpa_dbus_object_desc {
DBusConnection *connection;

11
wpa_supplicant/dbus/dbus_new_introspect.c
View file

@ -96,6 +96,7 @@ static void extract_interfaces_methods(
{
const struct wpa_dbus_method_desc *dsc;
struct interfaces *iface;
for (dsc = methods; dsc && dsc->dbus_method; dsc++) {
iface = add_interface(list, dsc->dbus_interface);
if (iface)
@ -110,6 +111,7 @@ static void extract_interfaces_signals(
{
const struct wpa_dbus_signal_desc *dsc;
struct interfaces *iface;
for (dsc = signals; dsc && dsc->dbus_signal; dsc++) {
iface = add_interface(list, dsc->dbus_interface);
if (iface)
@ -124,6 +126,7 @@ static void extract_interfaces_properties(
{
const struct wpa_dbus_property_desc *dsc;
struct interfaces *iface;
for (dsc = properties; dsc && dsc->dbus_property; dsc++) {
iface = add_interface(list, dsc->dbus_interface);
if (iface)
@ -154,14 +157,14 @@ static void extract_interfaces(struct dl_list *list,
static void add_interfaces(struct dl_list *list, struct wpabuf *xml)
{
struct interfaces *iface, *n;
dl_list_for_each_safe(iface, n, list, struct interfaces, list) {
if (wpabuf_len(iface->xml) + 20 < wpabuf_tailroom(xml)) {
wpabuf_put_buf(xml, iface->xml);
wpabuf_put_str(xml, "</interface>");
} else {
wpa_printf(MSG_DEBUG, "dbus: Not enough room for "
"add_interfaces inspect data: tailroom %u, "
"add %u",
wpa_printf(MSG_DEBUG,
"dbus: Not enough room for add_interfaces inspect data: tailroom %u, add %u",
(unsigned int) wpabuf_tailroom(xml),
(unsigned int) wpabuf_len(iface->xml));
}
@ -229,6 +232,7 @@ static void add_wpas_interfaces(struct wpabuf *xml,
struct wpa_dbus_object_desc *obj_dsc)
{
struct dl_list ifaces;
dl_list_init(&ifaces);
extract_interfaces(&ifaces, obj_dsc);
add_interfaces(&ifaces, xml);
@ -270,6 +274,7 @@ DBusMessage * wpa_dbus_introspect(DBusMessage *message,
reply = dbus_message_new_method_return(message);
if (reply) {
const char *intro_str = wpabuf_head(xml);
dbus_message_append_args(reply, DBUS_TYPE_STRING, &intro_str,
DBUS_TYPE_INVALID);
}

98
wpa_supplicant/dbus/dbus_old.c
View file

@ -92,9 +92,9 @@ char * wpas_dbus_decompose_object_path(const char *path, char **network,
*/
DBusMessage * wpas_dbus_new_invalid_iface_error(DBusMessage *message)
{
return dbus_message_new_error(message, WPAS_ERROR_INVALID_IFACE,
"wpa_supplicant knows nothing about "
"this interface.");
return dbus_message_new_error(
message, WPAS_ERROR_INVALID_IFACE,
"wpa_supplicant knows nothing about this interface.");
}
@ -221,7 +221,7 @@ static DBusHandlerResult wpas_iface_message_handler(DBusConnection *connection,
dbus_message_get_signature(message));
iface_obj_path = wpas_dbus_decompose_object_path(path, &network,
&bssid);
&bssid);
if (iface_obj_path == NULL) {
reply = wpas_dbus_new_invalid_iface_error(message);
goto out;
@ -231,7 +231,7 @@ static DBusHandlerResult wpas_iface_message_handler(DBusConnection *connection,
* wpa_supplicant structure it's supposed to (which is wpa_s)
*/
if (wpa_supplicant_get_iface_by_dbus_path(wpa_s->global,
iface_obj_path) != wpa_s) {
iface_obj_path) != wpa_s) {
reply = wpas_dbus_new_invalid_iface_error(message);
goto out;
}
@ -239,6 +239,7 @@ static DBusHandlerResult wpas_iface_message_handler(DBusConnection *connection,
if (network && !strcmp(msg_interface, WPAS_DBUS_IFACE_NETWORK)) {
/* A method for one of this interface's configured networks */
int nid = strtoul(network, NULL, 10);
if (errno != EINVAL)
reply = wpas_dispatch_network_method(message, wpa_s,
nid);
@ -279,14 +280,14 @@ static DBusHandlerResult wpas_iface_message_handler(DBusConnection *connection,
reply = wpas_dbus_iface_remove_blobs(message, wpa_s);
#endif /* CONFIG_NO_CONFIG_BLOBS */
#ifdef CONFIG_WPS
else if (!os_strcmp(method, "wpsPbc"))
else if (os_strcmp(method, "wpsPbc") == 0)
reply = wpas_dbus_iface_wps_pbc(message, wpa_s);
else if (!os_strcmp(method, "wpsPin"))
else if (os_strcmp(method, "wpsPin") == 0)
reply = wpas_dbus_iface_wps_pin(message, wpa_s);
else if (!os_strcmp(method, "wpsReg"))
else if (os_strcmp(method, "wpsReg") == 0)
reply = wpas_dbus_iface_wps_reg(message, wpa_s);
#endif /* CONFIG_WPS */
else if (!os_strcmp(method, "flush"))
else if (os_strcmp(method, "flush") == 0)
reply = wpas_dbus_iface_flush(message, wpa_s);
}
@ -389,8 +390,8 @@ void wpa_supplicant_dbus_notify_scan_results(struct wpa_supplicant *wpa_s)
WPAS_DBUS_IFACE_INTERFACE,
"ScanResultsAvailable");
if (_signal == NULL) {
wpa_printf(MSG_ERROR, "dbus: Not enough memory to send scan "
"results signal");
wpa_printf(MSG_ERROR,
"dbus: Not enough memory to send scan results signal");
return;
}
dbus_connection_send(iface->con, _signal, NULL);
@ -434,9 +435,8 @@ void wpa_supplicant_dbus_notify_state_change(struct wpa_supplicant *wpa_s,
"StateChange");
if (_signal == NULL) {
wpa_printf(MSG_ERROR,
"dbus: wpa_supplicant_dbus_notify_state_change: "
"could not create dbus signal; likely out of "
"memory");
"dbus: %s: could not create dbus signal; likely out of memory",
__func__);
return;
}
@ -444,13 +444,12 @@ void wpa_supplicant_dbus_notify_state_change(struct wpa_supplicant *wpa_s,
old_state_str = wpa_supplicant_state_txt(old_state);
if (!dbus_message_append_args(_signal,
DBUS_TYPE_STRING, &new_state_str,
DBUS_TYPE_STRING, &old_state_str,
DBUS_TYPE_INVALID)) {
DBUS_TYPE_STRING, &new_state_str,
DBUS_TYPE_STRING, &old_state_str,
DBUS_TYPE_INVALID)) {
wpa_printf(MSG_ERROR,
"dbus: wpa_supplicant_dbus_notify_state_change: "
"Not enough memory to construct state change "
"signal");
"dbus: %s: Not enough memory to construct state change signal",
__func__);
goto out;
}
@ -482,18 +481,18 @@ void wpa_supplicant_dbus_notify_scanning(struct wpa_supplicant *wpa_s)
WPAS_DBUS_IFACE_INTERFACE,
"Scanning");
if (_signal == NULL) {
wpa_printf(MSG_ERROR, "dbus: Not enough memory to send scan "
"results signal");
wpa_printf(MSG_ERROR,
"dbus: Not enough memory to send scan results signal");
return;
}
if (dbus_message_append_args(_signal,
DBUS_TYPE_BOOLEAN, &scanning,
DBUS_TYPE_INVALID)) {
DBUS_TYPE_BOOLEAN, &scanning,
DBUS_TYPE_INVALID)) {
dbus_connection_send(iface->con, _signal, NULL);
} else {
wpa_printf(MSG_ERROR, "dbus: Not enough memory to construct "
"signal");
wpa_printf(MSG_ERROR,
"dbus: Not enough memory to construct signal");
}
dbus_message_unref(_signal);
}
@ -518,19 +517,18 @@ void wpa_supplicant_dbus_notify_wps_cred(struct wpa_supplicant *wpa_s,
"WpsCred");
if (_signal == NULL) {
wpa_printf(MSG_ERROR,
"dbus: wpa_supplicant_dbus_notify_wps_cred: "
"Could not create dbus signal; likely out of "
"memory");
"dbus: %s: Could not create dbus signal; likely out of memory",
__func__);
return;
}
if (!dbus_message_append_args(_signal,
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
&cred->cred_attr, cred->cred_attr_len,
DBUS_TYPE_INVALID)) {
DBUS_TYPE_INVALID)) {
wpa_printf(MSG_ERROR,
"dbus: wpa_supplicant_dbus_notify_wps_cred: "
"Not enough memory to construct signal");
"dbus: %s: Not enough memory to construct signal",
__func__);
goto out;
}
@ -569,9 +567,8 @@ void wpa_supplicant_dbus_notify_certification(struct wpa_supplicant *wpa_s,
"Certification");
if (_signal == NULL) {
wpa_printf(MSG_ERROR,
"dbus: wpa_supplicant_dbus_notify_certification: "
"Could not create dbus signal; likely out of "
"memory");
"dbus: %s: Could not create dbus signal; likely out of memory",
__func__);
return;
}
@ -580,15 +577,15 @@ void wpa_supplicant_dbus_notify_certification(struct wpa_supplicant *wpa_s,
cert_hex_len = cert ? wpabuf_len(cert) : 0;
if (!dbus_message_append_args(_signal,
DBUS_TYPE_INT32,&depth,
DBUS_TYPE_INT32, &depth,
DBUS_TYPE_STRING, &subject,
DBUS_TYPE_STRING, &hash,
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
DBUS_TYPE_STRING, &hash,
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
&cert_hex, cert_hex_len,
DBUS_TYPE_INVALID)) {
DBUS_TYPE_INVALID)) {
wpa_printf(MSG_ERROR,
"dbus: wpa_supplicant_dbus_notify_certification: "
"Not enough memory to construct signal");
"dbus: %s: Not enough memory to construct signal",
__func__);
goto out;
}
@ -620,8 +617,7 @@ int wpa_supplicant_dbus_ctrl_iface_init(struct wpas_dbus_priv *iface)
if (!dbus_connection_register_object_path(iface->con,
WPAS_DBUS_PATH, &wpas_vtable,
iface)) {
wpa_printf(MSG_ERROR, "dbus: Could not set up message "
"handler");
wpa_printf(MSG_ERROR, "dbus: Could not set up message handler");
return -1;
}
@ -635,12 +631,13 @@ int wpa_supplicant_dbus_ctrl_iface_init(struct wpas_dbus_priv *iface)
case DBUS_REQUEST_NAME_REPLY_EXISTS:
case DBUS_REQUEST_NAME_REPLY_IN_QUEUE:
case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
wpa_printf(MSG_ERROR, "dbus: Could not request service name: "
"already registered");
wpa_printf(MSG_ERROR,
"dbus: Could not request service name: already registered");
break;
default:
wpa_printf(MSG_ERROR, "dbus: Could not request service name: "
"%s %s", error.name, error.message);
wpa_printf(MSG_ERROR,
"dbus: Could not request service name: %s %s",
error.name, error.message);
break;
}
dbus_error_free(&error);
@ -689,8 +686,9 @@ int wpas_dbus_register_iface(struct wpa_supplicant *wpa_s)
/* Register the message handler for the interface functions */
if (!dbus_connection_register_fallback(con, wpa_s->dbus_path, &vtable,
wpa_s)) {
wpa_printf(MSG_ERROR, "dbus: Could not set up message "
"handler for interface %s", wpa_s->ifname);
wpa_printf(MSG_ERROR,
"dbus: Could not set up message handler for interface %s",
wpa_s->ifname);
return -1;
}

9
wpa_supplicant/dbus/dbus_old.h
View file

@ -82,7 +82,7 @@ void wpa_supplicant_dbus_notify_certification(struct wpa_supplicant *wpa_s,
const struct wpabuf *cert);
char * wpas_dbus_decompose_object_path(const char *path, char **network,
char **bssid);
char **bssid);
int wpas_dbus_register_iface(struct wpa_supplicant *wpa_s);
int wpas_dbus_unregister_iface(struct wpa_supplicant *wpa_s);
@ -104,7 +104,12 @@ wpa_supplicant_dbus_notify_scanning(struct wpa_supplicant *wpa_s)
{
}
#define wpa_supplicant_dbus_notify_state_change(w,n,o) do { } while (0)
static inline void
wpa_supplicant_dbus_notify_state_change(struct wpa_supplicant *wpa_s,
enum wpa_states new_state,
enum wpa_states old_state)
{
}
static inline void
wpa_supplicant_dbus_notify_wps_cred(struct wpa_supplicant *wpa_s,

106
wpa_supplicant/dbus/dbus_old_handlers.c
View file

@ -37,9 +37,9 @@ DBusMessage * wpas_dbus_new_invalid_opts_error(DBusMessage *message,
{
DBusMessage *reply;
reply = dbus_message_new_error(message, WPAS_ERROR_INVALID_OPTS,
"Did not receive correct message "
"arguments.");
reply = dbus_message_new_error(
message, WPAS_ERROR_INVALID_OPTS,
"Did not receive correct message arguments.");
if (arg != NULL)
dbus_message_append_args(reply, DBUS_TYPE_STRING, &arg,
DBUS_TYPE_INVALID);
@ -112,28 +112,28 @@ DBusMessage * wpas_dbus_global_add_interface(DBusMessage *message,
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
if (!strcmp(entry.key, "driver") &&
(entry.type == DBUS_TYPE_STRING)) {
entry.type == DBUS_TYPE_STRING) {
os_free(driver);
driver = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
if (driver == NULL)
goto error;
} else if (!strcmp(entry.key, "driver-params") &&
(entry.type == DBUS_TYPE_STRING)) {
entry.type == DBUS_TYPE_STRING) {
os_free(driver_param);
driver_param = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
if (driver_param == NULL)
goto error;
} else if (!strcmp(entry.key, "config-file") &&
(entry.type == DBUS_TYPE_STRING)) {
entry.type == DBUS_TYPE_STRING) {
os_free(confname);
confname = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
if (confname == NULL)
goto error;
} else if (!strcmp(entry.key, "bridge-ifname") &&
(entry.type == DBUS_TYPE_STRING)) {
entry.type == DBUS_TYPE_STRING) {
os_free(bridge_ifname);
bridge_ifname = os_strdup(entry.str_value);
wpa_dbus_dict_entry_clear(&entry);
@ -151,13 +151,13 @@ DBusMessage * wpas_dbus_global_add_interface(DBusMessage *message,
* an error if we already control it.
*/
if (wpa_supplicant_get_iface(global, ifname) != NULL) {
reply = dbus_message_new_error(message,
WPAS_ERROR_EXISTS_ERROR,
"wpa_supplicant already "
"controls this interface.");
reply = dbus_message_new_error(
message, WPAS_ERROR_EXISTS_ERROR,
"wpa_supplicant already controls this interface.");
} else {
struct wpa_supplicant *wpa_s;
struct wpa_interface iface;
os_memset(&iface, 0, sizeof(iface));
iface.ifname = ifname;
iface.driver = driver;
@ -165,17 +165,17 @@ DBusMessage * wpas_dbus_global_add_interface(DBusMessage *message,
iface.confname = confname;
iface.bridge_ifname = bridge_ifname;
/* Otherwise, have wpa_supplicant attach to it. */
if ((wpa_s = wpa_supplicant_add_iface(global, &iface))) {
wpa_s = wpa_supplicant_add_iface(global, &iface);
if (wpa_s) {
const char *path = wpa_s->dbus_path;
reply = dbus_message_new_method_return(message);
dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH,
&path, DBUS_TYPE_INVALID);
&path, DBUS_TYPE_INVALID);
} else {
reply = dbus_message_new_error(message,
WPAS_ERROR_ADD_ERROR,
"wpa_supplicant "
"couldn't grab this "
"interface.");
reply = dbus_message_new_error(
message, WPAS_ERROR_ADD_ERROR,
"wpa_supplicant couldn't grab this interface.");
}
}
@ -226,10 +226,9 @@ DBusMessage * wpas_dbus_global_remove_interface(DBusMessage *message,
if (!wpa_supplicant_remove_iface(global, wpa_s, 0)) {
reply = wpas_dbus_new_success_reply(message);
} else {
reply = dbus_message_new_error(message,
WPAS_ERROR_REMOVE_ERROR,
"wpa_supplicant couldn't "
"remove this interface.");
reply = dbus_message_new_error(
message, WPAS_ERROR_REMOVE_ERROR,
"wpa_supplicant couldn't remove this interface.");
}
out:
@ -256,8 +255,8 @@ DBusMessage * wpas_dbus_global_get_interface(DBusMessage *message,
struct wpa_supplicant *wpa_s;
if (!dbus_message_get_args(message, NULL,
DBUS_TYPE_STRING, &ifname,
DBUS_TYPE_INVALID)) {
DBUS_TYPE_STRING, &ifname,
DBUS_TYPE_INVALID)) {
reply = wpas_dbus_new_invalid_opts_error(message, NULL);
goto out;
}
@ -271,8 +270,8 @@ DBusMessage * wpas_dbus_global_get_interface(DBusMessage *message,
path = wpa_s->dbus_path;
reply = dbus_message_new_method_return(message);
dbus_message_append_args(reply,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
out:
return reply;
@ -298,10 +297,10 @@ DBusMessage * wpas_dbus_global_set_debugparams(DBusMessage *message,
dbus_bool_t debug_show_keys;
if (!dbus_message_get_args(message, NULL,
DBUS_TYPE_INT32, &debug_level,
DBUS_TYPE_BOOLEAN, &debug_timestamp,
DBUS_TYPE_BOOLEAN, &debug_show_keys,
DBUS_TYPE_INVALID)) {
DBUS_TYPE_INT32, &debug_level,
DBUS_TYPE_BOOLEAN, &debug_timestamp,
DBUS_TYPE_BOOLEAN, &debug_show_keys,
DBUS_TYPE_INVALID)) {
return wpas_dbus_new_invalid_opts_error(message, NULL);
}
@ -518,6 +517,7 @@ DBusMessage * wpas_dbus_iface_capabilities(DBusMessage *message,
if (res < 0) {
if (!strict) {
const char *args[] = {"CCMP", "TKIP", "NONE"};
if (!wpa_dbus_dict_append_string_array(
&iter_dict, "pairwise", args,
ARRAY_SIZE(args)))
@ -550,6 +550,7 @@ DBusMessage * wpas_dbus_iface_capabilities(DBusMessage *message,
const char *args[] = {
"CCMP", "TKIP", "WEP104", "WEP40"
};
if (!wpa_dbus_dict_append_string_array(
&iter_dict, "group", args,
ARRAY_SIZE(args)))
@ -624,6 +625,7 @@ DBusMessage * wpas_dbus_iface_capabilities(DBusMessage *message,
if (res < 0) {
if (!strict) {
const char *args[] = { "RSN", "WPA" };
if (!wpa_dbus_dict_append_string_array(
&iter_dict, "proto", args,
ARRAY_SIZE(args)))
@ -653,6 +655,7 @@ DBusMessage * wpas_dbus_iface_capabilities(DBusMessage *message,
if (res < 0) {
if (!strict) {
const char *args[] = { "OPEN", "SHARED", "LEAP" };
if (!wpa_dbus_dict_append_string_array(
&iter_dict, "auth_alg", args,
ARRAY_SIZE(args)))
@ -687,9 +690,9 @@ DBusMessage * wpas_dbus_iface_capabilities(DBusMessage *message,
error:
if (reply)
dbus_message_unref(reply);
return dbus_message_new_error(message, WPAS_ERROR_INTERNAL_ERROR,
"an internal error occurred returning "
"interface capabilities.");
return dbus_message_new_error(
message, WPAS_ERROR_INTERNAL_ERROR,
"an internal error occurred returning interface capabilities.");
}
@ -710,10 +713,9 @@ DBusMessage * wpas_dbus_iface_add_network(DBusMessage *message,
ssid = wpa_config_add_network(wpa_s->conf);
if (ssid == NULL) {
reply = dbus_message_new_error(message,
WPAS_ERROR_ADD_NETWORK_ERROR,
"wpa_supplicant could not add "
"a network on this interface.");
reply = dbus_message_new_error(
message, WPAS_ERROR_ADD_NETWORK_ERROR,
"wpa_supplicant could not add a network on this interface.");
goto out;
}
wpas_notify_network_added(wpa_s, ssid);
@ -753,8 +755,8 @@ DBusMessage * wpas_dbus_iface_remove_network(DBusMessage *message,
struct wpa_ssid *ssid;
if (!dbus_message_get_args(message, NULL,
DBUS_TYPE_OBJECT_PATH, &op,
DBUS_TYPE_INVALID)) {
DBUS_TYPE_OBJECT_PATH, &op,
DBUS_TYPE_INVALID)) {
reply = wpas_dbus_new_invalid_opts_error(message, NULL);
goto out;
}
@ -786,10 +788,9 @@ DBusMessage * wpas_dbus_iface_remove_network(DBusMessage *message,
WLAN_REASON_DEAUTH_LEAVING);
if (wpa_config_remove_network(wpa_s->conf, id) < 0) {
reply = dbus_message_new_error(message,
WPAS_ERROR_REMOVE_NETWORK_ERROR,
"error removing the specified "
"on this interface.");
reply = dbus_message_new_error(
message, WPAS_ERROR_REMOVE_NETWORK_ERROR,
"error removing the specified on this interface.");
goto out;
}
@ -802,7 +803,7 @@ out:
}
static const char *dont_quote[] = {
static const char const *dont_quote[] = {
"key_mgmt", "proto", "pairwise", "auth_alg", "group", "eap",
"opensc_engine_path", "pkcs11_engine_path", "pkcs11_module_path",
"bssid", NULL
@ -812,8 +813,9 @@ static const char *dont_quote[] = {
static dbus_bool_t should_quote_opt(const char *key)
{
int i = 0;
while (dont_quote[i] != NULL) {
if (strcmp(key, dont_quote[i]) == 0)
if (os_strcmp(key, dont_quote[i]) == 0)
return FALSE;
i++;
}
@ -1129,19 +1131,19 @@ DBusMessage * wpas_dbus_iface_set_smartcard_modules(
if (!wpa_dbus_dict_get_entry(&iter_dict, &entry))
goto error;
if (!strcmp(entry.key, "opensc_engine_path") &&
(entry.type == DBUS_TYPE_STRING)) {
entry.type == DBUS_TYPE_STRING) {
os_free(opensc_engine_path);
opensc_engine_path = os_strdup(entry.str_value);
if (opensc_engine_path == NULL)
goto error;
} else if (!strcmp(entry.key, "pkcs11_engine_path") &&
(entry.type == DBUS_TYPE_STRING)) {
entry.type == DBUS_TYPE_STRING) {
os_free(pkcs11_engine_path);
pkcs11_engine_path = os_strdup(entry.str_value);
if (pkcs11_engine_path == NULL)
goto error;
} else if (!strcmp(entry.key, "pkcs11_module_path") &&
(entry.type == DBUS_TYPE_STRING)) {
entry.type == DBUS_TYPE_STRING) {
os_free(pkcs11_module_path);
pkcs11_module_path = os_strdup(entry.str_value);
if (pkcs11_module_path == NULL)
@ -1221,8 +1223,8 @@ DBusMessage * wpas_dbus_iface_get_scanning(DBusMessage *message,
dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &scanning,
DBUS_TYPE_INVALID);
} else {
wpa_printf(MSG_ERROR, "dbus: Not enough memory to return "
"scanning state");
wpa_printf(MSG_ERROR,
"dbus: Not enough memory to return scanning state");
}
return reply;
@ -1334,8 +1336,8 @@ DBusMessage * wpas_dbus_iface_remove_blobs(DBusMessage *message,
dbus_message_iter_init(message, &iter);
if ((dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_ARRAY) ||
(dbus_message_iter_get_element_type (&iter) != DBUS_TYPE_STRING))
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRING)
return wpas_dbus_new_invalid_opts_error(message, NULL);
dbus_message_iter_recurse(&iter, &array);

6
wpa_supplicant/dbus/dbus_old_handlers.h
View file

@ -58,13 +58,13 @@ DBusMessage * wpas_dbus_iface_disable_network(DBusMessage *message,
struct wpa_ssid *ssid);
DBusMessage * wpas_dbus_iface_select_network(DBusMessage *message,
struct wpa_supplicant *wpa_s);
struct wpa_supplicant *wpa_s);
DBusMessage * wpas_dbus_iface_disconnect(DBusMessage *message,
struct wpa_supplicant *wpa_s);
DBusMessage * wpas_dbus_iface_set_ap_scan(DBusMessage *message,
struct wpa_supplicant *wpa_s);
struct wpa_supplicant *wpa_s);
DBusMessage * wpas_dbus_iface_set_smartcard_modules(
DBusMessage *message, struct wpa_supplicant *wpa_s);
@ -76,7 +76,7 @@ DBusMessage * wpas_dbus_iface_get_scanning(DBusMessage *message,
struct wpa_supplicant *wpa_s);
DBusMessage * wpas_dbus_iface_set_blobs(DBusMessage *message,
struct wpa_supplicant *wpa_s);
struct wpa_supplicant *wpa_s);
DBusMessage * wpas_dbus_iface_remove_blobs(DBusMessage *message,
struct wpa_supplicant *wpa_s);

11
wpa_supplicant/dbus/dbus_old_handlers_wps.c
View file

@ -36,7 +36,7 @@ DBusMessage * wpas_dbus_iface_wps_pbc(DBusMessage *message,
DBUS_TYPE_INVALID))
return wpas_dbus_new_invalid_opts_error(message, NULL);
if (!os_strcmp(arg_bssid, "any"))
if (os_strcmp(arg_bssid, "any") == 0)
ret = wpas_wps_start_pbc(wpa_s, NULL, 0);
else if (!hwaddr_aton(arg_bssid, bssid))
ret = wpas_wps_start_pbc(wpa_s, bssid, 0);
@ -46,10 +46,9 @@ DBusMessage * wpas_dbus_iface_wps_pbc(DBusMessage *message,
}
if (ret < 0) {
return dbus_message_new_error(message,
WPAS_ERROR_WPS_PBC_ERROR,
"Could not start PBC "
"negotiation");
return dbus_message_new_error(
message, WPAS_ERROR_WPS_PBC_ERROR,
"Could not start PBC negotiation");
}
return wpas_dbus_new_success_reply(message);
@ -79,7 +78,7 @@ DBusMessage * wpas_dbus_iface_wps_pin(DBusMessage *message,
DBUS_TYPE_STRING, &pin, DBUS_TYPE_INVALID))
return wpas_dbus_new_invalid_opts_error(message, NULL);
if (!os_strcmp(arg_bssid, "any"))
if (os_strcmp(arg_bssid, "any") == 0)
_bssid = NULL;
else if (!hwaddr_aton(arg_bssid, bssid))
_bssid = bssid;