if (!dbus_connection_set_watch_functions(priv->con, add_watch,
remove_watch, watch_toggled,
priv, NULL)) {
- perror("dbus_connection_set_watch_functions[dbus]");
- wpa_printf(MSG_ERROR, "Not enough memory to set up dbus.");
+ wpa_printf(MSG_ERROR, "dbus: Not enough memory to set up");
return -1;
}
remove_timeout,
timeout_toggled, priv,
NULL)) {
- perror("dbus_connection_set_timeout_functions[dbus]");
- wpa_printf(MSG_ERROR, "Not enough memory to set up dbus.");
+ wpa_printf(MSG_ERROR, "dbus: Not enough memory to set up");
return -1;
}
if (connection_setup_wakeup_main(priv) < 0) {
- perror("connection_setup_wakeup_main[dbus]");
- wpa_printf(MSG_ERROR, "Could not setup main wakeup function.");
+ wpa_printf(MSG_ERROR, "dbus: Could not setup main wakeup "
+ "function");
return -1;
}
{
dbus_uint32_t count = 0;
dbus_bool_t success = FALSE;
- char *buffer;
+ char *buffer, *nbuffer;;
entry->bytearray_value = NULL;
entry->array_type = DBUS_TYPE_BYTE;
buffer = os_zalloc(BYTE_ARRAY_ITEM_SIZE * BYTE_ARRAY_CHUNK_SIZE);
- if (!buffer) {
- perror("_wpa_dbus_dict_entry_get_byte_array[dbus]: out of "
- "memory");
- goto done;
- }
+ if (!buffer)
+ return FALSE;
entry->bytearray_value = buffer;
entry->array_len = 0;
char byte;
if ((count % BYTE_ARRAY_CHUNK_SIZE) == 0 && count != 0) {
- buffer = os_realloc(buffer, BYTE_ARRAY_ITEM_SIZE *
- (count + BYTE_ARRAY_CHUNK_SIZE));
- if (buffer == NULL) {
- perror("_wpa_dbus_dict_entry_get_byte_array["
- "dbus] out of memory trying to "
- "retrieve the string array");
+ nbuffer = os_realloc(buffer, BYTE_ARRAY_ITEM_SIZE *
+ (count + BYTE_ARRAY_CHUNK_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");
goto done;
}
+ buffer = nbuffer;
}
entry->bytearray_value = buffer;
{
dbus_uint32_t count = 0;
dbus_bool_t success = FALSE;
- char **buffer;
+ char **buffer, **nbuffer;
entry->strarray_value = NULL;
entry->array_type = DBUS_TYPE_STRING;
buffer = os_zalloc(STR_ARRAY_ITEM_SIZE * STR_ARRAY_CHUNK_SIZE);
- if (buffer == NULL) {
- perror("_wpa_dbus_dict_entry_get_string_array[dbus] out of "
- "memory trying to retrieve a string array");
- goto done;
- }
+ if (buffer == NULL)
+ return FALSE;
entry->strarray_value = buffer;
entry->array_len = 0;
char *str;
if ((count % STR_ARRAY_CHUNK_SIZE) == 0 && count != 0) {
- buffer = os_realloc(buffer, STR_ARRAY_ITEM_SIZE *
- (count + STR_ARRAY_CHUNK_SIZE));
- if (buffer == NULL) {
- perror("_wpa_dbus_dict_entry_get_string_array["
- "dbus] out of memory trying to "
- "retrieve the string array");
+ nbuffer = os_realloc(buffer, STR_ARRAY_ITEM_SIZE *
+ (count + STR_ARRAY_CHUNK_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");
goto done;
}
+ buffer = nbuffer;
}
entry->strarray_value = buffer;
dbus_message_iter_get_basic(iter, &value);
str = os_strdup(value);
if (str == NULL) {
- perror("_wpa_dbus_dict_entry_get_string_array[dbus] "
- "out of memory trying to duplicate the string "
- "array");
+ wpa_printf(MSG_ERROR, "dbus: _wpa_dbus_dict_entry_get_"
+ "string_array out of memory trying to "
+ "duplicate the string array");
goto done;
}
entry->strarray_value[count] = str;
*/
dbus_bool_t wpa_dbus_dict_has_dict_entry(DBusMessageIter *iter_dict)
{
- if (!iter_dict) {
- perror("wpa_dbus_dict_has_dict_entry[dbus]: out of memory");
+ if (!iter_dict)
return FALSE;
- }
return dbus_message_iter_get_arg_type(iter_dict) ==
DBUS_TYPE_DICT_ENTRY;
}
_signal = dbus_message_new_signal(wpa_s->dbus_new_path,
WPAS_DBUS_NEW_IFACE_INTERFACE,
"StateChanged");
- if (_signal == NULL) {
- perror("wpas_dbus_signal_state_changed[dbus]: "
- "couldn't create dbus signal; likely out of memory");
- wpa_printf(MSG_ERROR,
- "wpas_dbus_signal_state_changed[dbus]: "
- "couldn't create dbus signal; likely out of "
- "memory.");
+ if (_signal == NULL)
return;
- }
new_state_str = os_strdup(wpa_supplicant_state_txt(new_state));
old_state_str = os_strdup(wpa_supplicant_state_txt(old_state));
- if (new_state_str == NULL || old_state_str == NULL) {
- perror("wpas_dbus_signal_state_changed[dbus]: "
- "couldn't convert state strings");
- wpa_printf(MSG_ERROR,
- "wpas_dbus_signal_state_changed[dbus]: "
- "couldn't convert state strings.");
+ if (new_state_str == NULL || old_state_str == NULL)
goto out;
- }
/* make state string lowercase to fit new DBus API convention */
tmp = new_state_str;
DBUS_TYPE_STRING, &new_state_str,
DBUS_TYPE_STRING, &old_state_str,
DBUS_TYPE_INVALID)) {
- perror("wpas_dbus_signal_state_changed[dbus]: "
- "not enough memory to construct state change signal.");
wpa_printf(MSG_ERROR,
- "wpas_dbus_signal_state_changed[dbus]: "
+ "dbus: wpas_dbus_signal_state_changed: "
"not enough memory to construct state change "
- "signal.");
+ "signal");
goto out;
}
_signal = dbus_message_new_signal(wpa_s->dbus_new_path,
WPAS_DBUS_NEW_IFACE_WPS,
"Credentials");
- if (!_signal) {
- wpa_printf(MSG_ERROR, "wpas_dbus_signal_wps_cred[dbus]: "
- "out of memory when creating a signal");
+ if (!_signal)
return;
- }
dbus_message_iter_init_append(_signal, &iter);
- if (!wpa_dbus_dict_open_write(&iter, &dict_iter)) {
- perror("wpas_dbus_signal_wps_cred[dbus]: out of memory "
- "when opening a dictionary");
+ if (!wpa_dbus_dict_open_write(&iter, &dict_iter))
goto nomem;
- }
if (cred->auth_type & WPS_AUTH_OPEN)
auth_type[at_num++] = "open";
if (!wpa_dbus_dict_append_byte_array(
&dict_iter, "BSSID",
(const char *) wpa_s->current_ssid->bssid,
- ETH_ALEN)) {
- perror("wpas_dbus_signal_wps_cred[dbus]: out of "
- "memory when appending bssid to dictionary");
+ ETH_ALEN))
goto nomem;
- }
}
if (!(wpa_dbus_dict_append_byte_array(&dict_iter, "SSID",
(const char *) cred->key,
cred->key_len) &&
wpa_dbus_dict_append_uint32(&dict_iter, "KeyIndex",
- cred->key_idx))) {
- perror("wpas_dbus_signal_wps_cred[dbus]: out of memory "
- "when appending to dictionary");
+ cred->key_idx)))
goto nomem;
- }
- if (!wpa_dbus_dict_close_write(&iter, &dict_iter)) {
- perror("wpas_dbus_signal_wps_cred[dbus]: out of memory "
- "when closing a dictionary");
+ if (!wpa_dbus_dict_close_write(&iter, &dict_iter))
goto nomem;
- }
dbus_connection_send(iface->con, _signal, NULL);
path = wpa_s->dbus_new_path;
reply = dbus_message_new_method_return(message);
- if (reply == NULL) {
- perror("wpas_dbus_handler_get_interface[dbus]: out of memory "
- "when creating reply");
+ if (reply == NULL)
return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
NULL);
- }
if (!dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID)) {
- perror("wpas_dbus_handler_get_interface[dbus]: out of memory "
- "when appending argument to reply");
dbus_message_unref(reply);
return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
NULL);
path = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
if (path == NULL) {
- perror("wpas_dbus_handler_add_network[dbus]: out of "
- "memory.");
reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
NULL);
goto err;
reply = dbus_message_new_method_return(message);
if (reply == NULL) {
- perror("wpas_dbus_handler_add_network[dbus]: out of memory "
- "when creating reply");
reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
NULL);
goto err;
}
if (!dbus_message_append_args(reply, DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID)) {
- perror("wpas_dbus_handler_add_network[dbus]: out of memory "
- "when appending argument to reply");
dbus_message_unref(reply);
reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
NULL);
blob = os_zalloc(sizeof(*blob));
if (!blob) {
- perror("wpas_dbus_handler_add_blob[dbus] out of memory when "
- "trying to allocate blob struct");
reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
NULL);
goto err;
blob->data = os_malloc(blob_len);
if (!blob->data) {
- perror("wpas_dbus_handler_add_blob[dbus] out of memory when "
- "trying to allocate blob data");
reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
NULL);
goto err;
blob->len = blob_len;
blob->name = os_strdup(blob_name);
if (!blob->name) {
- perror("wpas_dbus_handler_add_blob[dbus] out of memory when "
- "trying to copy blob name");
reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
NULL);
goto err;
reply = dbus_message_new_method_return(message);
if (!reply) {
- perror("wpas_dbus_handler_get_blob[dbus] out of memory when "
- "trying to allocate return message");
reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
NULL);
goto out;
DBUS_TYPE_BYTE_AS_STRING,
&array_iter)) {
dbus_message_unref(reply);
- perror("wpas_dbus_handler_get_blob[dbus] out of memory when "
- "trying to open array");
reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
NULL);
goto out;
if (!dbus_message_iter_append_fixed_array(&array_iter, DBUS_TYPE_BYTE,
&(blob->data), blob->len)) {
dbus_message_unref(reply);
- perror("wpas_dbus_handler_get_blob[dbus] out of memory when "
- "trying to append data to array");
reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
NULL);
goto out;
if (!dbus_message_iter_close_container(&iter, &array_iter)) {
dbus_message_unref(reply);
- perror("wpas_dbus_handler_get_blob[dbus] out of memory when "
- "trying to close array");
reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
NULL);
goto out;
char *bss_obj_path = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
struct wpa_bss *bss = NULL;
- if (bss_obj_path == NULL) {
- perror("wpas_dbus_getter_current_bss[dbus]: out of "
- "memory to allocate result argument.");
+ if (bss_obj_path == NULL)
return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
NULL);
- }
/* TODO: store current BSS or BSS id in wpa_s */
if (!is_zero_ether_addr(wpa_s->bssid))
DBusMessage *reply = NULL;
char *net_obj_path = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
- if (net_obj_path == NULL) {
- perror("wpas_dbus_getter_current_network[dbus]: out of "
- "memory to allocate result argument.");
+ if (net_obj_path == NULL)
return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
NULL);
- }
if (wpa_s->current_ssid)
os_snprintf(net_obj_path, WPAS_DBUS_OBJECT_PATH_MAX,
dl_list_for_each(bss, &wpa_s->bss_id, struct wpa_bss, list_id) {
paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
if (paths[i] == NULL) {
- perror("wpas_dbus_getter_bsss[dbus]: out of "
- "memory.");
reply = dbus_message_new_error(message,
DBUS_ERROR_NO_MEMORY,
NULL);
/* Loop through configured networks and append object path of each */
for (ssid = wpa_s->conf->ssid; ssid; ssid = ssid->next) {
-
paths[i] = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
if (paths[i] == NULL) {
- perror("wpas_dbus_getter_networks[dbus]: out of "
- "memory.");
reply = dbus_message_new_error(message,
DBUS_ERROR_NO_MEMORY,
NULL);
reply = dbus_message_new(DBUS_MESSAGE_TYPE_SIGNAL);
else
reply = dbus_message_new_method_return(message);
- if (!reply) {
- perror("wpas_dbus_getter_blobs[dbus] out of memory when "
- "trying to initialize return message");
- reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
- NULL);
- goto out;
- }
+ if (!reply)
+ return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
+ NULL);
dbus_message_iter_init_append(reply, &iter);
if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
- "a{say}", &variant_iter)) {
- dbus_message_unref(reply);
- perror("wpas_dbus_getter_blobs[dbus] out of memory when "
- "trying to open variant");
- reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
- NULL);
- goto out;
- }
-
- if (!dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
+ "a{say}", &variant_iter) ||
+ !dbus_message_iter_open_container(&variant_iter, DBUS_TYPE_ARRAY,
"{say}", &dict_iter)) {
dbus_message_unref(reply);
- perror("wpas_dbus_getter_blobs[dbus] out of memory when "
- "trying to open dictionary");
- reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
- NULL);
- goto out;
+ return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
+ NULL);
}
blob = wpa_s->conf->blobs;
while (blob) {
if (!dbus_message_iter_open_container(&dict_iter,
DBUS_TYPE_DICT_ENTRY,
- NULL, &entry_iter)) {
- dbus_message_unref(reply);
- perror("wpas_dbus_getter_blobs[dbus] out of memory "
- "when trying to open entry");
- reply = dbus_message_new_error(message,
- DBUS_ERROR_NO_MEMORY,
- NULL);
- goto out;
- }
-
- if (!dbus_message_iter_append_basic(&entry_iter,
+ NULL, &entry_iter) ||
+ !dbus_message_iter_append_basic(&entry_iter,
DBUS_TYPE_STRING,
- &(blob->name))) {
- dbus_message_unref(reply);
- perror("wpas_dbus_getter_blobs[dbus] out of memory "
- "when trying to append blob name");
- reply = dbus_message_new_error(message,
- DBUS_ERROR_NO_MEMORY,
- NULL);
- goto out;
- }
-
- if (!dbus_message_iter_open_container(&entry_iter,
+ &(blob->name)) ||
+ !dbus_message_iter_open_container(&entry_iter,
DBUS_TYPE_ARRAY,
DBUS_TYPE_BYTE_AS_STRING,
- &array_iter)) {
- dbus_message_unref(reply);
- perror("wpas_dbus_getter_blobs[dbus] out of memory "
- "when trying to open array");
- reply = dbus_message_new_error(message,
- DBUS_ERROR_NO_MEMORY,
- NULL);
- goto out;
- }
-
- if (!dbus_message_iter_append_fixed_array(&array_iter,
+ &array_iter) ||
+ !dbus_message_iter_append_fixed_array(&array_iter,
DBUS_TYPE_BYTE,
&(blob->data),
- blob->len)) {
- dbus_message_unref(reply);
- perror("wpas_dbus_getter_blobs[dbus] out of memory "
- "when trying to append blob data");
- reply = dbus_message_new_error(message,
- DBUS_ERROR_NO_MEMORY,
- NULL);
- goto out;
- }
-
- if (!dbus_message_iter_close_container(&entry_iter,
- &array_iter)) {
- dbus_message_unref(reply);
- perror("wpas_dbus_getter_blobs[dbus] out of memory "
- "when trying to close array");
- reply = dbus_message_new_error(message,
- DBUS_ERROR_NO_MEMORY,
- NULL);
- goto out;
- }
-
- if (!dbus_message_iter_close_container(&dict_iter,
+ blob->len) ||
+ !dbus_message_iter_close_container(&entry_iter,
+ &array_iter) ||
+ !dbus_message_iter_close_container(&dict_iter,
&entry_iter)) {
dbus_message_unref(reply);
- perror("wpas_dbus_getter_blobs[dbus] out of memory "
- "when trying to close entry");
- reply = dbus_message_new_error(message,
- DBUS_ERROR_NO_MEMORY,
- NULL);
- goto out;
+ return dbus_message_new_error(message,
+ DBUS_ERROR_NO_MEMORY,
+ NULL);
}
blob = blob->next;
}
- if (!dbus_message_iter_close_container(&variant_iter, &dict_iter)) {
- dbus_message_unref(reply);
- perror("wpas_dbus_getter_blobs[dbus] out of memory when "
- "trying to close dictionary");
- reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
- NULL);
- goto out;
- }
-
- if (!dbus_message_iter_close_container(&iter, &variant_iter)) {
+ if (!dbus_message_iter_close_container(&variant_iter, &dict_iter) ||
+ !dbus_message_iter_close_container(&iter, &variant_iter)) {
dbus_message_unref(reply);
- perror("wpas_dbus_getter_blobs[dbus] out of memory when "
- "trying to close variant");
- reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
- NULL);
- goto out;
+ return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
+ NULL);
}
-out:
return reply;
}
DBusMessageIter iter, variant_iter, dict_iter;
char **iterator;
char **props = wpa_config_get_all(net->ssid, 0);
- if (!props) {
- perror("wpas_dbus_getter_network_properties[dbus] couldn't "
- "read network properties. out of memory.");
+ if (!props)
return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
NULL);
- }
if (message == NULL)
reply = dbus_message_new(DBUS_MESSAGE_TYPE_SIGNAL);
else
reply = dbus_message_new_method_return(message);
if (!reply) {
- perror("wpas_dbus_getter_network_properties[dbus] out of "
- "memory when trying to initialize return message");
reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
NULL);
goto out;
dbus_message_iter_init_append(reply, &iter);
if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
- "a{sv}", &variant_iter)) {
- perror("wpas_dbus_getter_network_properties[dbus] out of "
- "memory when trying to open variant container");
- dbus_message_unref(reply);
- reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
- NULL);
- goto out;
- }
-
- if (!wpa_dbus_dict_open_write(&variant_iter, &dict_iter)) {
- perror("wpas_dbus_getter_network_properties[dbus] out of "
- "memory when trying to open dict");
+ "a{sv}", &variant_iter) ||
+ !wpa_dbus_dict_open_write(&variant_iter, &dict_iter)) {
dbus_message_unref(reply);
reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
NULL);
while (*iterator) {
if (!wpa_dbus_dict_append_string(&dict_iter, *iterator,
*(iterator + 1))) {
- perror("wpas_dbus_getter_network_properties[dbus] out "
- "of memory when trying to add entry");
dbus_message_unref(reply);
reply = dbus_message_new_error(message,
DBUS_ERROR_NO_MEMORY,
}
- if (!wpa_dbus_dict_close_write(&variant_iter, &dict_iter)) {
- perror("wpas_dbus_getter_network_properties[dbus] out of "
- "memory when trying to close dictionary");
- dbus_message_unref(reply);
- reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
- NULL);
- goto out;
- }
-
- if (!dbus_message_iter_close_container(&iter, &variant_iter)) {
- perror("wpas_dbus_getter_network_properties[dbus] out of "
- "memory when trying to close variant container");
+ if (!wpa_dbus_dict_close_write(&variant_iter, &dict_iter) ||
+ !dbus_message_iter_close_container(&iter, &variant_iter)) {
dbus_message_unref(reply);
reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
NULL);
"wpas_dbus_handler_wps_start"
"[dbus]: "
"wrong Role type. string required");
- reply = wpas_dbus_error_invald_args(
+ return wpas_dbus_error_invald_args(
message, "Role must be a string");
- goto out;
}
dbus_message_iter_get_basic(&variant_iter, &val);
if (os_strcmp(val, "enrollee") == 0)
wpa_printf(MSG_DEBUG,
"wpas_dbus_handler_wps_start[dbus]: "
"unknown role %s", val);
- reply = wpas_dbus_error_invald_args(message, val);
- goto out;
+ return wpas_dbus_error_invald_args(message,
+ val);
}
} else if (strcmp(key, "Type") == 0) {
dbus_message_iter_recurse(&entry_iter, &variant_iter);
wpa_printf(MSG_DEBUG,
"wpas_dbus_handler_wps_start[dbus]: "
"wrong Type type. string required");
- reply = wpas_dbus_error_invald_args(
+ return wpas_dbus_error_invald_args(
message, "Type must be a string");
- goto out;
}
dbus_message_iter_get_basic(&variant_iter, &val);
if (os_strcmp(val, "pin") == 0)
wpa_printf(MSG_DEBUG,
"wpas_dbus_handler_wps_start[dbus]: "
"unknown type %s", val);
- reply = wpas_dbus_error_invald_args(message,
- val);
- goto out;
+ return wpas_dbus_error_invald_args(message,
+ val);
}
} else if (strcmp(key, "Bssid") == 0) {
dbus_message_iter_recurse(&entry_iter, &variant_iter);
wpa_printf(MSG_DEBUG,
"wpas_dbus_handler_wps_start[dbus]: "
"wrong Bssid type. byte array required");
- reply = wpas_dbus_error_invald_args(
+ return wpas_dbus_error_invald_args(
message, "Bssid must be a byte array");
- goto out;
}
dbus_message_iter_recurse(&variant_iter, &array_iter);
dbus_message_iter_get_fixed_array(&array_iter, &bssid,
wpa_printf(MSG_DEBUG,
"wpas_dbus_handler_wps_start[dbus]: "
"wrong Bssid length %d", len);
- reply = wpas_dbus_error_invald_args(
+ return wpas_dbus_error_invald_args(
message, "Bssid is wrong length");
- goto out;
}
}
else if (os_strcmp(key, "Pin") == 0) {
wpa_printf(MSG_DEBUG,
"wpas_dbus_handler_wps_start[dbus]: "
"wrong Pin type. string required");
- reply = wpas_dbus_error_invald_args(
+ return wpas_dbus_error_invald_args(
message, "Pin must be a string");
- goto out;
}
dbus_message_iter_get_basic(&variant_iter, &pin);
} else {
wpa_printf(MSG_DEBUG,
"wpas_dbus_handler_wps_start[dbus]: "
"unknown key %s", key);
- reply = wpas_dbus_error_invald_args(message, key);
- goto out;
+ return wpas_dbus_error_invald_args(message, key);
}
dbus_message_iter_next(&dict_iter);
if (role == 0) {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_wps_start[dbus]: "
"Role not specified");
- reply = wpas_dbus_error_invald_args(message,
- "Role not specified");
- goto out;
+ return wpas_dbus_error_invald_args(message,
+ "Role not specified");
}
else if (role == 1 && type == 0) {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_wps_start[dbus]: "
"Type not specified");
- reply = wpas_dbus_error_invald_args(message,
- "Type not specified");
- goto out;
+ return wpas_dbus_error_invald_args(message,
+ "Type not specified");
}
else if (role == 2 && pin == NULL) {
wpa_printf(MSG_DEBUG, "wpas_dbus_handler_wps_start[dbus]: "
"Pin required for registrar role.");
- reply = wpas_dbus_error_invald_args(
+ return wpas_dbus_error_invald_args(
message, "Pin required for registrar role.");
- goto out;
}
if (role == 2)
"wpas_wps_failed in role %s and key %s.",
(role == 1 ? "enrollee" : "registrar"),
(type == 0 ? "" : (type == 1 ? "pin" : "pbc")));
- reply = wpas_dbus_error_unknown_error(message,
- "wps start failed");
- goto out;
+ return wpas_dbus_error_unknown_error(message,
+ "wps start failed");
}
reply = dbus_message_new_method_return(message);
if (!reply) {
- perror("wpas_dbus_handler_wps_start[dbus]: out of memory "
- "when creating reply");
- reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
- NULL);
- goto out;
+ return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
+ NULL);
}
dbus_message_iter_init_append(reply, &iter);
if (!wpa_dbus_dict_open_write(&iter, &dict_iter)) {
- perror("wpas_dbus_handler_wps_start[dbus]: out of memory "
- "when opening dictionary");
dbus_message_unref(reply);
- reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
- NULL);
- goto out;
+ return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
+ NULL);
}
if (os_strlen(npin) > 0) {
if (!wpa_dbus_dict_append_string(&dict_iter, "Pin", npin)) {
- perror("wpas_dbus_handler_wps_start[dbus]: "
- "out of memory when appending pin");
dbus_message_unref(reply);
- reply = dbus_message_new_error(message,
- DBUS_ERROR_NO_MEMORY,
- NULL);
- goto out;
+ return dbus_message_new_error(message,
+ DBUS_ERROR_NO_MEMORY,
+ NULL);
}
}
if (!wpa_dbus_dict_close_write(&iter, &dict_iter)) {
- perror("wpas_dbus_handler_wps_start[dbus]: out of memory "
- "when closing dictionary");
dbus_message_unref(reply);
- reply = dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
- NULL);
- goto out;
+ return dbus_message_new_error(message, DBUS_ERROR_NO_MEMORY,
+ NULL);
}
-out:
return reply;
}
if (!dbus_connection_register_object_path(iface->con,
dbus_path, &wpa_vtable,
obj_desc)) {
- perror("dbus_connection_register_object_path[dbus]");
- wpa_printf(MSG_ERROR, "Could not set up DBus message "
- "handler.");
+ wpa_printf(MSG_ERROR, "dbus: Could not set up message "
+ "handler");
return -1;
}
case DBUS_REQUEST_NAME_REPLY_EXISTS:
case DBUS_REQUEST_NAME_REPLY_IN_QUEUE:
case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
- perror("dbus_bus_request_name[dbus]");
- wpa_printf(MSG_ERROR, "Could not request DBus service name: "
- "already registered.");
+ wpa_printf(MSG_ERROR, "dbus: Could not request service name: "
+ "already registered");
break;
default:
- perror("dbus_bus_request_name[dbus]");
- wpa_printf(MSG_ERROR, "Could not request DBus 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);
/* Register the message handler for the interface functions */
if (!dbus_connection_register_object_path(con, path, &vtable,
obj_desc)) {
- perror("wpa_dbus_register_iface [dbus]");
- wpa_printf(MSG_ERROR, "Could not set up DBus message "
- "handler for interface %s\n"
- "and object %s.", ifname, path);
+ wpa_printf(MSG_ERROR, "dbus: Could not set up message "
+ "handler for interface %s object %s", ifname, path);
return -1;
}
WPAS_DBUS_IFACE_INTERFACE,
"ScanResultsAvailable");
if (_signal == NULL) {
- perror("wpa_supplicant_dbus_notify_scan_results[dbus]: "
- "couldn't create dbus signal; likely out of memory");
- wpa_printf(MSG_ERROR, "dbus control interface: 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);
WPAS_DBUS_IFACE_INTERFACE,
"StateChange");
if (_signal == NULL) {
- perror("wpa_supplicant_dbus_notify_state_change[dbus]: "
- "couldn't create dbus signal; likely out of memory");
wpa_printf(MSG_ERROR,
- "wpa_supplicant_dbus_notify_state_change[dbus]: "
- "couldn't create dbus signal; likely out of "
- "memory.");
+ "dbus: wpa_supplicant_dbus_notify_state_change: "
+ "could not create dbus signal; likely out of "
+ "memory");
return;
}
new_state_str = wpa_supplicant_state_txt(new_state);
old_state_str = wpa_supplicant_state_txt(old_state);
if (new_state_str == NULL || old_state_str == NULL) {
- perror("wpa_supplicant_dbus_notify_state_change[dbus]: "
- "couldn't convert state strings");
wpa_printf(MSG_ERROR,
- "wpa_supplicant_dbus_notify_state_change[dbus]: "
- "couldn't convert state strings.");
+ "dbus: wpa_supplicant_dbus_notify_state_change: "
+ "Could not convert state strings");
goto out;
}
DBUS_TYPE_STRING, &new_state_str,
DBUS_TYPE_STRING, &old_state_str,
DBUS_TYPE_INVALID)) {
- perror("wpa_supplicant_dbus_notify_state_change[dbus]: "
- "not enough memory to construct state change signal.");
wpa_printf(MSG_ERROR,
- "wpa_supplicant_dbus_notify_state_change[dbus]: "
- "not enough memory to construct state change "
- "signal.");
+ "dbus: wpa_supplicant_dbus_notify_state_change: "
+ "Not enough memory to construct state change "
+ "signal");
goto out;
}
WPAS_DBUS_IFACE_INTERFACE,
"Scanning");
if (_signal == NULL) {
- perror("wpa_supplicant_dbus_notify_scanning[dbus]: couldn't "
- "create dbus signal; likely out of memory");
- wpa_printf(MSG_ERROR, "%s[dbus]: dbus control interface: not "
- "enough memory to send scan results signal.",
- __FUNCTION__);
+ wpa_printf(MSG_ERROR, "dbus: Not enough memory to send scan "
+ "results signal");
return;
}
DBUS_TYPE_INVALID)) {
dbus_connection_send(iface->con, _signal, NULL);
} else {
- perror("wpa_supplicant_dbus_notify_scanning[dbus]: not enough "
- "memory to construct signal.");
- wpa_printf(MSG_ERROR, "%s[dbus]: not enough memory to "
- "construct signal.", __FUNCTION__);
+ wpa_printf(MSG_ERROR, "dbus: Not enough memory to construct "
+ "signal");
}
dbus_message_unref(_signal);
}
WPAS_DBUS_IFACE_INTERFACE,
"WpsCred");
if (_signal == NULL) {
- perror("wpa_supplicant_dbus_notify_wps_cred[dbus]: "
- "couldn't create dbus signal; likely out of memory");
wpa_printf(MSG_ERROR,
- "wpa_supplicant_dbus_notify_wps_cred[dbus]: "
- "couldn't create dbus signal; likely out of "
- "memory.");
+ "dbus: wpa_supplicant_dbus_notify_wps_cred: "
+ "Could not create dbus signal; likely out of "
+ "memory");
return;
}
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
&cred->cred_attr, cred->cred_attr_len,
DBUS_TYPE_INVALID)) {
- perror("wpa_supplicant_dbus_notify_wps_cred[dbus]: "
- "not enough memory to construct signal.");
wpa_printf(MSG_ERROR,
- "wpa_supplicant_dbus_notify_wps_cred[dbus]: "
- "not enough memory to construct signal.");
+ "dbus: wpa_supplicant_dbus_notify_wps_cred: "
+ "Not enough memory to construct signal");
goto out;
}
if (!dbus_connection_register_object_path(iface->con,
WPAS_DBUS_PATH, &wpas_vtable,
iface)) {
- perror("dbus_connection_register_object_path[dbus]");
- wpa_printf(MSG_ERROR, "Could not set up DBus message "
- "handler.");
+ wpa_printf(MSG_ERROR, "dbus: Could not set up message "
+ "handler");
return -1;
}
case DBUS_REQUEST_NAME_REPLY_EXISTS:
case DBUS_REQUEST_NAME_REPLY_IN_QUEUE:
case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
- perror("dbus_bus_request_name[dbus]");
- wpa_printf(MSG_ERROR, "Could not request DBus service name: "
- "already registered.");
+ wpa_printf(MSG_ERROR, "dbus: Could not request service name: "
+ "already registered");
break;
default:
- perror("dbus_bus_request_name[dbus]");
- wpa_printf(MSG_ERROR, "Could not request DBus 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);
DBusObjectPathVTable vtable = {
NULL, &wpas_iface_message_handler, NULL, NULL, NULL, NULL
};
- int ret = -1;
/* Do nothing if the control interface is not turned on */
if (ctrl_iface == NULL)
/* Register the message handler for the interface functions */
if (!dbus_connection_register_fallback(con, wpa_s->dbus_path, &vtable,
wpa_s)) {
- perror("wpas_dbus_register_iface [dbus]");
- wpa_printf(MSG_ERROR, "Could not set up DBus message "
- "handler for interface %s.", wpa_s->ifname);
- goto out;
+ wpa_printf(MSG_ERROR, "dbus: Could not set up message "
+ "handler for interface %s", wpa_s->ifname);
+ return -1;
}
- ret = 0;
-out:
- return ret;
+ return 0;
}
/* Ensure we've actually got scan results to return */
if (wpa_s->scan_res == NULL &&
wpa_supplicant_get_scan_results(wpa_s) < 0) {
- reply = dbus_message_new_error(message, WPAS_ERROR_SCAN_ERROR,
- "An error ocurred getting scan "
+ return dbus_message_new_error(message, WPAS_ERROR_SCAN_ERROR,
+ "An error ocurred getting scan "
"results.");
- goto out;
}
/* Create and initialize the return message */
path = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
if (path == NULL) {
- perror("wpas_dbus_iface_scan_results[dbus]: out of "
- "memory.");
- wpa_printf(MSG_ERROR, "dbus control interface: not "
- "enough memory to send scan results "
- "signal.");
+ wpa_printf(MSG_ERROR, "dbus: Not enough memory to "
+ "send scan results signal");
break;
}
/* Construct the object path for this network. Note that ':'
dbus_message_iter_close_container(&iter, &sub_iter);
-out:
return reply;
}
path = os_zalloc(WPAS_DBUS_OBJECT_PATH_MAX);
if (path == NULL) {
- perror("wpas_dbus_iface_scan_results[dbus]: out of "
- "memory.");
- wpa_printf(MSG_ERROR, "dbus control interface: not "
- "enough memory to send scan results "
- "signal.");
+ wpa_printf(MSG_ERROR, "dbus: Not enough memory to send scan "
+ "results signal");
goto out;
}
dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &scanning,
DBUS_TYPE_INVALID);
} else {
- perror("wpas_dbus_iface_get_scanning[dbus]: out of "
- "memory.");
- wpa_printf(MSG_ERROR, "dbus control interface: not enough "
- "memory to return scanning state.");
+ wpa_printf(MSG_ERROR, "dbus: Not enough memory to return "
+ "scanning state");
}
return reply;
projects / mech_eap.git / commitdiff