+++ /dev/null
-/*
- * WPA Supplicant / dbus-based control interface
- * Copyright (c) 2006, Dan Williams <dcbw@redhat.com> and Red Hat, Inc.
- *
- * This software may be distributed under the terms of the BSD license.
- * See README for more details.
- */
-
-#include "includes.h"
-#include <dbus/dbus.h>
-
-#include "common.h"
-#include "wpabuf.h"
-#include "dbus_dict_helpers.h"
-
-
-/**
- * Start a dict in a dbus message. Should be paired with a call to
- * wpa_dbus_dict_close_write().
- *
- * @param iter A valid dbus message iterator
- * @param iter_dict (out) A dict iterator to pass to further dict functions
- * @return TRUE on success, FALSE on failure
- *
- */
-dbus_bool_t wpa_dbus_dict_open_write(DBusMessageIter *iter,
- DBusMessageIter *iter_dict)
-{
- dbus_bool_t result;
-
- if (!iter || !iter_dict)
- return FALSE;
-
- result = dbus_message_iter_open_container(
- iter,
- DBUS_TYPE_ARRAY,
- DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
- DBUS_TYPE_STRING_AS_STRING
- DBUS_TYPE_VARIANT_AS_STRING
- DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
- iter_dict);
- return result;
-}
-
-
-/**
- * End a dict element in a dbus message. Should be paired with
- * a call to wpa_dbus_dict_open_write().
- *
- * @param iter valid dbus message iterator, same as passed to
- * wpa_dbus_dict_open_write()
- * @param iter_dict a dbus dict iterator returned from
- * wpa_dbus_dict_open_write()
- * @return TRUE on success, FALSE on failure
- *
- */
-dbus_bool_t wpa_dbus_dict_close_write(DBusMessageIter *iter,
- DBusMessageIter *iter_dict)
-{
- if (!iter || !iter_dict)
- return FALSE;
-
- return dbus_message_iter_close_container(iter, iter_dict);
-}
-
-
-const char * wpa_dbus_type_as_string(const int type)
-{
- switch (type) {
- case DBUS_TYPE_BYTE:
- return DBUS_TYPE_BYTE_AS_STRING;
- case DBUS_TYPE_BOOLEAN:
- return DBUS_TYPE_BOOLEAN_AS_STRING;
- case DBUS_TYPE_INT16:
- return DBUS_TYPE_INT16_AS_STRING;
- case DBUS_TYPE_UINT16:
- return DBUS_TYPE_UINT16_AS_STRING;
- case DBUS_TYPE_INT32:
- return DBUS_TYPE_INT32_AS_STRING;
- case DBUS_TYPE_UINT32:
- return DBUS_TYPE_UINT32_AS_STRING;
- case DBUS_TYPE_INT64:
- return DBUS_TYPE_INT64_AS_STRING;
- case DBUS_TYPE_UINT64:
- return DBUS_TYPE_UINT64_AS_STRING;
- case DBUS_TYPE_DOUBLE:
- return DBUS_TYPE_DOUBLE_AS_STRING;
- case DBUS_TYPE_STRING:
- return DBUS_TYPE_STRING_AS_STRING;
- case DBUS_TYPE_OBJECT_PATH:
- return DBUS_TYPE_OBJECT_PATH_AS_STRING;
- case DBUS_TYPE_ARRAY:
- return DBUS_TYPE_ARRAY_AS_STRING;
- default:
- return NULL;
- }
-}
-
-
-static dbus_bool_t _wpa_dbus_add_dict_entry_start(
- DBusMessageIter *iter_dict, DBusMessageIter *iter_dict_entry,
- const char *key, const int value_type)
-{
- if (!dbus_message_iter_open_container(iter_dict,
- DBUS_TYPE_DICT_ENTRY, NULL,
- iter_dict_entry))
- return FALSE;
-
- return dbus_message_iter_append_basic(iter_dict_entry, DBUS_TYPE_STRING,
- &key);
-}
-
-
-static dbus_bool_t _wpa_dbus_add_dict_entry_end(
- DBusMessageIter *iter_dict, DBusMessageIter *iter_dict_entry,
- DBusMessageIter *iter_dict_val)
-{
- if (!dbus_message_iter_close_container(iter_dict_entry, iter_dict_val))
- return FALSE;
-
- return dbus_message_iter_close_container(iter_dict, iter_dict_entry);
-}
-
-
-static dbus_bool_t _wpa_dbus_add_dict_entry_basic(DBusMessageIter *iter_dict,
- const char *key,
- const int value_type,
- const void *value)
-{
- DBusMessageIter iter_dict_entry, iter_dict_val;
- const char *type_as_string = NULL;
-
- if (key == NULL)
- return FALSE;
-
- type_as_string = wpa_dbus_type_as_string(value_type);
- if (!type_as_string)
- return FALSE;
-
- if (!_wpa_dbus_add_dict_entry_start(iter_dict, &iter_dict_entry,
- key, value_type) ||
- !dbus_message_iter_open_container(&iter_dict_entry,
- DBUS_TYPE_VARIANT,
- type_as_string, &iter_dict_val) ||
- !dbus_message_iter_append_basic(&iter_dict_val, value_type, value))
- return FALSE;
-
- return _wpa_dbus_add_dict_entry_end(iter_dict, &iter_dict_entry,
- &iter_dict_val);
-}
-
-
-static dbus_bool_t _wpa_dbus_add_dict_entry_byte_array(
- DBusMessageIter *iter_dict, const char *key,
- const char *value, const dbus_uint32_t value_len)
-{
- DBusMessageIter iter_dict_entry, iter_dict_val, iter_array;
- dbus_uint32_t i;
-
- if (!_wpa_dbus_add_dict_entry_start(iter_dict, &iter_dict_entry,
- key, DBUS_TYPE_ARRAY) ||
- !dbus_message_iter_open_container(&iter_dict_entry,
- DBUS_TYPE_VARIANT,
- DBUS_TYPE_ARRAY_AS_STRING
- DBUS_TYPE_BYTE_AS_STRING,
- &iter_dict_val) ||
- !dbus_message_iter_open_container(&iter_dict_val, DBUS_TYPE_ARRAY,
- DBUS_TYPE_BYTE_AS_STRING,
- &iter_array))
- return FALSE;
-
- for (i = 0; i < value_len; i++) {
- if (!dbus_message_iter_append_basic(&iter_array,
- DBUS_TYPE_BYTE,
- &(value[i])))
- return FALSE;
- }
-
- if (!dbus_message_iter_close_container(&iter_dict_val, &iter_array))
- return FALSE;
-
- return _wpa_dbus_add_dict_entry_end(iter_dict, &iter_dict_entry,
- &iter_dict_val);
-}
-
-
-/**
- * Add a string entry to the dict.
- *
- * @param iter_dict A valid DBusMessageIter returned from
- * wpa_dbus_dict_open_write()
- * @param key The key of the dict item
- * @param value The string value
- * @return TRUE on success, FALSE on failure
- *
- */
-dbus_bool_t wpa_dbus_dict_append_string(DBusMessageIter *iter_dict,
- const char *key, const char *value)
-{
- if (!value)
- return FALSE;
- return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_STRING,
- &value);
-}
-
-
-/**
- * Add a boolean entry to the dict.
- *
- * @param iter_dict A valid DBusMessageIter returned from
- * wpa_dbus_dict_open_write()
- * @param key The key of the dict item
- * @param value The boolean value
- * @return TRUE on success, FALSE on failure
- *
- */
-dbus_bool_t wpa_dbus_dict_append_bool(DBusMessageIter *iter_dict,
- const char *key, const dbus_bool_t value)
-{
- return _wpa_dbus_add_dict_entry_basic(iter_dict, key,
- DBUS_TYPE_BOOLEAN, &value);
-}
-
-
-/**
- * Add a 16-bit signed integer entry to the dict.
- *
- * @param iter_dict A valid DBusMessageIter returned from
- * wpa_dbus_dict_open_write()
- * @param key The key of the dict item
- * @param value The 16-bit signed integer value
- * @return TRUE on success, FALSE on failure
- *
- */
-dbus_bool_t wpa_dbus_dict_append_int16(DBusMessageIter *iter_dict,
- const char *key,
- const dbus_int16_t value)
-{
- return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_INT16,
- &value);
-}
-
-
-/**
- * Add a 16-bit unsigned integer entry to the dict.
- *
- * @param iter_dict A valid DBusMessageIter returned from
- * wpa_dbus_dict_open_write()
- * @param key The key of the dict item
- * @param value The 16-bit unsigned integer value
- * @return TRUE on success, FALSE on failure
- *
- */
-dbus_bool_t wpa_dbus_dict_append_uint16(DBusMessageIter *iter_dict,
- const char *key,
- const dbus_uint16_t value)
-{
- return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_UINT16,
- &value);
-}
-
-
-/**
- * Add a 32-bit signed integer to the dict.
- *
- * @param iter_dict A valid DBusMessageIter returned from
- * wpa_dbus_dict_open_write()
- * @param key The key of the dict item
- * @param value The 32-bit signed integer value
- * @return TRUE on success, FALSE on failure
- *
- */
-dbus_bool_t wpa_dbus_dict_append_int32(DBusMessageIter *iter_dict,
- const char *key,
- const dbus_int32_t value)
-{
- return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_INT32,
- &value);
-}
-
-
-/**
- * Add a 32-bit unsigned integer entry to the dict.
- *
- * @param iter_dict A valid DBusMessageIter returned from
- * wpa_dbus_dict_open_write()
- * @param key The key of the dict item
- * @param value The 32-bit unsigned integer value
- * @return TRUE on success, FALSE on failure
- *
- */
-dbus_bool_t wpa_dbus_dict_append_uint32(DBusMessageIter *iter_dict,
- const char *key,
- const dbus_uint32_t value)
-{
- return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_UINT32,
- &value);
-}
-
-
-/**
- * Add a DBus object path entry to the dict.
- *
- * @param iter_dict A valid DBusMessageIter returned from
- * wpa_dbus_dict_open_write()
- * @param key The key of the dict item
- * @param value The DBus object path value
- * @return TRUE on success, FALSE on failure
- *
- */
-dbus_bool_t wpa_dbus_dict_append_object_path(DBusMessageIter *iter_dict,
- const char *key,
- const char *value)
-{
- if (!value)
- return FALSE;
- return _wpa_dbus_add_dict_entry_basic(iter_dict, key,
- DBUS_TYPE_OBJECT_PATH, &value);
-}
-
-
-/**
- * Add a byte array entry to the dict.
- *
- * @param iter_dict A valid DBusMessageIter returned from
- * wpa_dbus_dict_open_write()
- * @param key The key of the dict item
- * @param value The byte array
- * @param value_len The length of the byte array, in bytes
- * @return TRUE on success, FALSE on failure
- *
- */
-dbus_bool_t wpa_dbus_dict_append_byte_array(DBusMessageIter *iter_dict,
- const char *key,
- const char *value,
- const dbus_uint32_t value_len)
-{
- if (!key || (!value && value_len != 0))
- return FALSE;
- return _wpa_dbus_add_dict_entry_byte_array(iter_dict, key, value,
- value_len);
-}
-
-
-/**
- * Begin an array entry in the dict
- *
- * @param iter_dict A valid DBusMessageIter returned from
- * wpa_dbus_dict_open_write()
- * @param key The key of the dict item
- * @param type The type of the contained data
- * @param iter_dict_entry A private DBusMessageIter provided by the caller to
- * be passed to wpa_dbus_dict_end_string_array()
- * @param iter_dict_val A private DBusMessageIter provided by the caller to
- * be passed to wpa_dbus_dict_end_string_array()
- * @param iter_array On return, the DBusMessageIter to be passed to
- * wpa_dbus_dict_string_array_add_element()
- * @return TRUE on success, FALSE on failure
- *
- */
-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)
-{
- char array_type[10];
- int err;
-
- err = os_snprintf(array_type, sizeof(array_type),
- DBUS_TYPE_ARRAY_AS_STRING "%s",
- type);
- if (os_snprintf_error(sizeof(array_type), err))
- return FALSE;
-
- if (!iter_dict || !iter_dict_entry || !iter_dict_val || !iter_array ||
- !_wpa_dbus_add_dict_entry_start(iter_dict, iter_dict_entry,
- key, DBUS_TYPE_ARRAY) ||
- !dbus_message_iter_open_container(iter_dict_entry,
- DBUS_TYPE_VARIANT,
- array_type,
- iter_dict_val))
- return FALSE;
-
- return dbus_message_iter_open_container(iter_dict_val, DBUS_TYPE_ARRAY,
- type, 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)
-{
- return wpa_dbus_dict_begin_array(
- iter_dict, key,
- DBUS_TYPE_STRING_AS_STRING,
- iter_dict_entry, iter_dict_val, iter_array);
-}
-
-
-/**
- * Add a single string element to a string array dict entry
- *
- * @param iter_array A valid DBusMessageIter returned from
- * wpa_dbus_dict_begin_string_array()'s
- * iter_array parameter
- * @param elem The string element to be added to the dict entry's string array
- * @return TRUE on success, FALSE on failure
- *
- */
-dbus_bool_t wpa_dbus_dict_string_array_add_element(DBusMessageIter *iter_array,
- const char *elem)
-{
- if (!iter_array || !elem)
- return FALSE;
-
- return dbus_message_iter_append_basic(iter_array, DBUS_TYPE_STRING,
- &elem);
-}
-
-
-/**
- * Add a single byte array element to a string array dict entry
- *
- * @param iter_array A valid DBusMessageIter returned from
- * wpa_dbus_dict_begin_array()'s iter_array
- * parameter -- note that wpa_dbus_dict_begin_array()
- * must have been called with "ay" as the type
- * @param value The data to be added to the dict entry's array
- * @param value_len The length of the data
- * @return TRUE on success, FALSE on failure
- *
- */
-dbus_bool_t wpa_dbus_dict_bin_array_add_element(DBusMessageIter *iter_array,
- const u8 *value,
- size_t value_len)
-{
- DBusMessageIter iter_bytes;
- size_t i;
-
- if (!iter_array || !value ||
- !dbus_message_iter_open_container(iter_array, DBUS_TYPE_ARRAY,
- DBUS_TYPE_BYTE_AS_STRING,
- &iter_bytes))
- return FALSE;
-
- for (i = 0; i < value_len; i++) {
- if (!dbus_message_iter_append_basic(&iter_bytes,
- DBUS_TYPE_BYTE,
- &(value[i])))
- return FALSE;
- }
-
- return dbus_message_iter_close_container(iter_array, &iter_bytes);
-}
-
-
-/**
- * End an array dict entry
- *
- * @param iter_dict A valid DBusMessageIter returned from
- * wpa_dbus_dict_open_write()
- * @param iter_dict_entry A private DBusMessageIter returned from
- * wpa_dbus_dict_begin_string_array() or
- * wpa_dbus_dict_begin_array()
- * @param iter_dict_val A private DBusMessageIter returned from
- * wpa_dbus_dict_begin_string_array() or
- * wpa_dbus_dict_begin_array()
- * @param iter_array A DBusMessageIter returned from
- * wpa_dbus_dict_begin_string_array() or
- * wpa_dbus_dict_begin_array()
- * @return TRUE on success, FALSE on failure
- *
- */
-dbus_bool_t wpa_dbus_dict_end_array(DBusMessageIter *iter_dict,
- DBusMessageIter *iter_dict_entry,
- DBusMessageIter *iter_dict_val,
- DBusMessageIter *iter_array)
-{
- if (!iter_dict || !iter_dict_entry || !iter_dict_val || !iter_array ||
- !dbus_message_iter_close_container(iter_dict_val, iter_array))
- return FALSE;
-
- return _wpa_dbus_add_dict_entry_end(iter_dict, iter_dict_entry,
- iter_dict_val);
-}
-
-
-/**
- * Convenience function to add an entire string array to the dict.
- *
- * @param iter_dict A valid DBusMessageIter returned from
- * wpa_dbus_dict_open_write()
- * @param key The key of the dict item
- * @param items The array of strings
- * @param num_items The number of strings in the array
- * @return TRUE on success, FALSE on failure
- *
- */
-dbus_bool_t wpa_dbus_dict_append_string_array(DBusMessageIter *iter_dict,
- const char *key,
- const char **items,
- const dbus_uint32_t num_items)
-{
- DBusMessageIter iter_dict_entry, iter_dict_val, iter_array;
- dbus_uint32_t i;
-
- if (!key || (!items && num_items != 0) ||
- !wpa_dbus_dict_begin_string_array(iter_dict, key,
- &iter_dict_entry, &iter_dict_val,
- &iter_array))
- return FALSE;
-
- for (i = 0; i < num_items; i++) {
- if (!wpa_dbus_dict_string_array_add_element(&iter_array,
- items[i]))
- return FALSE;
- }
-
- return wpa_dbus_dict_end_string_array(iter_dict, &iter_dict_entry,
- &iter_dict_val, &iter_array);
-}
-
-
-/**
- * Convenience function to add an wpabuf binary array to the dict.
- *
- * @param iter_dict A valid DBusMessageIter returned from
- * wpa_dbus_dict_open_write()
- * @param key The key of the dict item
- * @param items The array of wpabuf structures
- * @param num_items The number of strings in the array
- * @return TRUE on success, FALSE on failure
- *
- */
-dbus_bool_t wpa_dbus_dict_append_wpabuf_array(DBusMessageIter *iter_dict,
- const char *key,
- const struct wpabuf **items,
- const dbus_uint32_t num_items)
-{
- DBusMessageIter iter_dict_entry, iter_dict_val, iter_array;
- dbus_uint32_t i;
-
- if (!key ||
- (!items && num_items != 0) ||
- !wpa_dbus_dict_begin_array(iter_dict, key,
- DBUS_TYPE_ARRAY_AS_STRING
- DBUS_TYPE_BYTE_AS_STRING,
- &iter_dict_entry, &iter_dict_val,
- &iter_array))
- return FALSE;
-
- for (i = 0; i < num_items; i++) {
- if (!wpa_dbus_dict_bin_array_add_element(&iter_array,
- wpabuf_head(items[i]),
- wpabuf_len(items[i])))
- return FALSE;
- }
-
- return wpa_dbus_dict_end_array(iter_dict, &iter_dict_entry,
- &iter_dict_val, &iter_array);
-}
-
-
-/*****************************************************/
-/* Stuff for reading dicts */
-/*****************************************************/
-
-/**
- * Start reading from a dbus dict.
- *
- * @param iter A valid DBusMessageIter pointing to the start of the dict
- * @param iter_dict (out) A DBusMessageIter to be passed to
- * wpa_dbus_dict_read_next_entry()
- * @error on failure a descriptive error
- * @return TRUE on success, FALSE on failure
- *
- */
-dbus_bool_t wpa_dbus_dict_open_read(DBusMessageIter *iter,
- DBusMessageIter *iter_dict,
- DBusError *error)
-{
- int type;
-
- 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");
- return FALSE;
- }
-
- type = dbus_message_iter_get_arg_type(iter);
- if (type != DBUS_TYPE_ARRAY ||
- dbus_message_iter_get_element_type(iter) != DBUS_TYPE_DICT_ENTRY) {
- wpa_printf(MSG_DEBUG,
- "%s: unexpected message argument types (arg=%c element=%c)",
- __func__, type,
- type != DBUS_TYPE_ARRAY ? '?' :
- dbus_message_iter_get_element_type(iter));
- dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
- "unexpected message argument types");
- return FALSE;
- }
-
- dbus_message_iter_recurse(iter, iter_dict);
- return TRUE;
-}
-
-
-#define BYTE_ARRAY_CHUNK_SIZE 34
-#define BYTE_ARRAY_ITEM_SIZE (sizeof(char))
-
-static dbus_bool_t _wpa_dbus_dict_entry_get_byte_array(
- DBusMessageIter *iter, struct wpa_dbus_dict_entry *entry)
-{
- dbus_uint32_t count = 0;
- dbus_bool_t success = FALSE;
- char *buffer, *nbuffer;
-
- entry->bytearray_value = NULL;
- entry->array_type = DBUS_TYPE_BYTE;
-
- buffer = os_calloc(BYTE_ARRAY_CHUNK_SIZE, BYTE_ARRAY_ITEM_SIZE);
- if (!buffer)
- return FALSE;
-
- entry->array_len = 0;
- while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_BYTE) {
- char byte;
-
- if ((count % BYTE_ARRAY_CHUNK_SIZE) == 0 && count != 0) {
- nbuffer = os_realloc_array(
- buffer, count + BYTE_ARRAY_CHUNK_SIZE,
- BYTE_ARRAY_ITEM_SIZE);
- if (nbuffer == NULL) {
- os_free(buffer);
- wpa_printf(MSG_ERROR,
- "dbus: %s out of memory trying to retrieve the string array",
- __func__);
- goto done;
- }
- buffer = nbuffer;
- }
-
- dbus_message_iter_get_basic(iter, &byte);
- buffer[count] = byte;
- entry->array_len = ++count;
- dbus_message_iter_next(iter);
- }
- entry->bytearray_value = buffer;
- wpa_hexdump_key(MSG_MSGDUMP, "dbus: byte array contents",
- entry->bytearray_value, entry->array_len);
-
- /* Zero-length arrays are valid. */
- if (entry->array_len == 0) {
- os_free(entry->bytearray_value);
- entry->bytearray_value = NULL;
- }
-
- success = TRUE;
-
-done:
- return success;
-}
-
-
-#define STR_ARRAY_CHUNK_SIZE 8
-#define STR_ARRAY_ITEM_SIZE (sizeof(char *))
-
-static dbus_bool_t _wpa_dbus_dict_entry_get_string_array(
- DBusMessageIter *iter, int array_type,
- struct wpa_dbus_dict_entry *entry)
-{
- dbus_uint32_t count = 0;
- char **buffer, **nbuffer;
-
- entry->strarray_value = NULL;
- entry->array_len = 0;
- entry->array_type = DBUS_TYPE_STRING;
-
- buffer = os_calloc(STR_ARRAY_CHUNK_SIZE, STR_ARRAY_ITEM_SIZE);
- if (buffer == NULL)
- return FALSE;
-
- while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRING) {
- const char *value;
- char *str;
-
- if ((count % STR_ARRAY_CHUNK_SIZE) == 0 && count != 0) {
- nbuffer = os_realloc_array(
- buffer, count + STR_ARRAY_CHUNK_SIZE,
- STR_ARRAY_ITEM_SIZE);
- if (nbuffer == NULL) {
- wpa_printf(MSG_ERROR,
- "dbus: %s out of memory trying to retrieve the string array",
- __func__);
- goto fail;
- }
- buffer = nbuffer;
- }
-
- dbus_message_iter_get_basic(iter, &value);
- wpa_printf(MSG_MSGDUMP, "%s: string_array value: %s",
- __func__, wpa_debug_show_keys ? value : "[omitted]");
- str = os_strdup(value);
- if (str == NULL) {
- wpa_printf(MSG_ERROR,
- "dbus: %s out of memory trying to duplicate the string array",
- __func__);
- goto fail;
- }
- buffer[count++] = str;
- dbus_message_iter_next(iter);
- }
- entry->strarray_value = buffer;
- entry->array_len = count;
- wpa_printf(MSG_MSGDUMP, "%s: string_array length %u",
- __func__, entry->array_len);
-
- /* Zero-length arrays are valid. */
- if (entry->array_len == 0) {
- os_free(entry->strarray_value);
- entry->strarray_value = NULL;
- }
-
- return TRUE;
-
-fail:
- while (count > 0) {
- count--;
- os_free(buffer[count]);
- }
- os_free(buffer);
- return FALSE;
-}
-
-
-#define BIN_ARRAY_CHUNK_SIZE 10
-#define BIN_ARRAY_ITEM_SIZE (sizeof(struct wpabuf *))
-
-static dbus_bool_t _wpa_dbus_dict_entry_get_binarray(
- DBusMessageIter *iter, struct wpa_dbus_dict_entry *entry)
-{
- struct wpa_dbus_dict_entry tmpentry;
- size_t buflen = 0;
- int i, type;
-
- entry->array_type = WPAS_DBUS_TYPE_BINARRAY;
- entry->array_len = 0;
- entry->binarray_value = NULL;
-
- type = dbus_message_iter_get_arg_type(iter);
- wpa_printf(MSG_MSGDUMP, "%s: parsing binarray type %c", __func__, type);
- if (type == DBUS_TYPE_INVALID) {
- /* Likely an empty array of arrays */
- return TRUE;
- }
- if (type != DBUS_TYPE_ARRAY) {
- wpa_printf(MSG_DEBUG, "%s: not an array type: %c",
- __func__, type);
- return FALSE;
- }
-
- type = dbus_message_iter_get_element_type(iter);
- if (type != DBUS_TYPE_BYTE) {
- wpa_printf(MSG_DEBUG, "%s: unexpected element type %c",
- __func__, type);
- return FALSE;
- }
-
- while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_ARRAY) {
- DBusMessageIter iter_array;
-
- if (entry->array_len == buflen) {
- struct wpabuf **newbuf;
-
- buflen += BIN_ARRAY_CHUNK_SIZE;
-
- newbuf = os_realloc_array(entry->binarray_value,
- buflen, BIN_ARRAY_ITEM_SIZE);
- if (!newbuf)
- goto cleanup;
- entry->binarray_value = newbuf;
- }
-
- dbus_message_iter_recurse(iter, &iter_array);
- os_memset(&tmpentry, 0, sizeof(tmpentry));
- tmpentry.type = DBUS_TYPE_ARRAY;
- if (_wpa_dbus_dict_entry_get_byte_array(&iter_array, &tmpentry)
- == FALSE)
- goto cleanup;
-
- entry->binarray_value[entry->array_len] =
- wpabuf_alloc_ext_data((u8 *) tmpentry.bytearray_value,
- tmpentry.array_len);
- if (entry->binarray_value[entry->array_len] == NULL) {
- wpa_dbus_dict_entry_clear(&tmpentry);
- goto cleanup;
- }
- entry->array_len++;
- dbus_message_iter_next(iter);
- }
- wpa_printf(MSG_MSGDUMP, "%s: binarray length %u",
- __func__, entry->array_len);
-
- return TRUE;
-
- cleanup:
- for (i = 0; i < (int) entry->array_len; i++)
- wpabuf_free(entry->binarray_value[i]);
- os_free(entry->binarray_value);
- entry->array_len = 0;
- entry->binarray_value = NULL;
- return FALSE;
-}
-
-
-static dbus_bool_t _wpa_dbus_dict_entry_get_array(
- DBusMessageIter *iter_dict_val, struct wpa_dbus_dict_entry *entry)
-{
- int array_type = dbus_message_iter_get_element_type(iter_dict_val);
- dbus_bool_t success = FALSE;
- DBusMessageIter iter_array;
-
- wpa_printf(MSG_MSGDUMP, "%s: array_type %c", __func__, array_type);
-
- dbus_message_iter_recurse(iter_dict_val, &iter_array);
-
- switch (array_type) {
- case DBUS_TYPE_BYTE:
- success = _wpa_dbus_dict_entry_get_byte_array(&iter_array,
- entry);
- break;
- case DBUS_TYPE_STRING:
- success = _wpa_dbus_dict_entry_get_string_array(&iter_array,
- array_type,
- entry);
- break;
- case DBUS_TYPE_ARRAY:
- success = _wpa_dbus_dict_entry_get_binarray(&iter_array, entry);
- break;
- default:
- wpa_printf(MSG_MSGDUMP, "%s: unsupported array type %c",
- __func__, array_type);
- break;
- }
-
- return success;
-}
-
-
-static dbus_bool_t _wpa_dbus_dict_fill_value_from_variant(
- struct wpa_dbus_dict_entry *entry, DBusMessageIter *iter)
-{
- const char *v;
-
- switch (entry->type) {
- case DBUS_TYPE_OBJECT_PATH:
- dbus_message_iter_get_basic(iter, &v);
- wpa_printf(MSG_MSGDUMP, "%s: object path value: %s",
- __func__, v);
- entry->str_value = os_strdup(v);
- if (entry->str_value == NULL)
- return FALSE;
- break;
- case DBUS_TYPE_STRING:
- dbus_message_iter_get_basic(iter, &v);
- wpa_printf(MSG_MSGDUMP, "%s: string value: %s",
- __func__, wpa_debug_show_keys ? v : "[omitted]");
- entry->str_value = os_strdup(v);
- if (entry->str_value == NULL)
- return FALSE;
- break;
- case DBUS_TYPE_BOOLEAN:
- dbus_message_iter_get_basic(iter, &entry->bool_value);
- wpa_printf(MSG_MSGDUMP, "%s: boolean value: %d",
- __func__, entry->bool_value);
- break;
- case DBUS_TYPE_BYTE:
- dbus_message_iter_get_basic(iter, &entry->byte_value);
- wpa_printf(MSG_MSGDUMP, "%s: byte value: %d",
- __func__, entry->byte_value);
- break;
- case DBUS_TYPE_INT16:
- dbus_message_iter_get_basic(iter, &entry->int16_value);
- wpa_printf(MSG_MSGDUMP, "%s: int16 value: %d",
- __func__, entry->int16_value);
- break;
- case DBUS_TYPE_UINT16:
- dbus_message_iter_get_basic(iter, &entry->uint16_value);
- wpa_printf(MSG_MSGDUMP, "%s: uint16 value: %d",
- __func__, entry->uint16_value);
- break;
- case DBUS_TYPE_INT32:
- dbus_message_iter_get_basic(iter, &entry->int32_value);
- wpa_printf(MSG_MSGDUMP, "%s: int32 value: %d",
- __func__, entry->int32_value);
- break;
- case DBUS_TYPE_UINT32:
- dbus_message_iter_get_basic(iter, &entry->uint32_value);
- wpa_printf(MSG_MSGDUMP, "%s: uint32 value: %d",
- __func__, entry->uint32_value);
- break;
- case DBUS_TYPE_INT64:
- dbus_message_iter_get_basic(iter, &entry->int64_value);
- wpa_printf(MSG_MSGDUMP, "%s: int64 value: %lld",
- __func__, (long long int) entry->int64_value);
- break;
- case DBUS_TYPE_UINT64:
- dbus_message_iter_get_basic(iter, &entry->uint64_value);
- wpa_printf(MSG_MSGDUMP, "%s: uint64 value: %llu",
- __func__,
- (unsigned long long int) entry->uint64_value);
- break;
- case DBUS_TYPE_DOUBLE:
- dbus_message_iter_get_basic(iter, &entry->double_value);
- wpa_printf(MSG_MSGDUMP, "%s: double value: %f",
- __func__, entry->double_value);
- break;
- case DBUS_TYPE_ARRAY:
- return _wpa_dbus_dict_entry_get_array(iter, entry);
- default:
- wpa_printf(MSG_MSGDUMP, "%s: unsupported type %c",
- __func__, entry->type);
- return FALSE;
- }
-
- return TRUE;
-}
-
-
-/**
- * Read the current key/value entry from the dict. Entries are dynamically
- * allocated when needed and must be freed after use with the
- * wpa_dbus_dict_entry_clear() function.
- *
- * The returned entry object will be filled with the type and value of the next
- * entry in the dict, or the type will be DBUS_TYPE_INVALID if an error
- * occurred.
- *
- * @param iter_dict A valid DBusMessageIter returned from
- * wpa_dbus_dict_open_read()
- * @param entry A valid dict entry object into which the dict key and value
- * will be placed
- * @return TRUE on success, FALSE on failure
- *
- */
-dbus_bool_t wpa_dbus_dict_get_entry(DBusMessageIter *iter_dict,
- struct wpa_dbus_dict_entry * entry)
-{
- DBusMessageIter iter_dict_entry, iter_dict_val;
- int type;
- const char *key;
-
- if (!iter_dict || !entry ||
- dbus_message_iter_get_arg_type(iter_dict) != DBUS_TYPE_DICT_ENTRY) {
- wpa_printf(MSG_DEBUG, "%s: not a dict entry", __func__);
- goto error;
- }
-
- dbus_message_iter_recurse(iter_dict, &iter_dict_entry);
- dbus_message_iter_get_basic(&iter_dict_entry, &key);
- wpa_printf(MSG_MSGDUMP, "%s: dict entry key: %s", __func__, key);
- entry->key = key;
-
- if (!dbus_message_iter_next(&iter_dict_entry)) {
- wpa_printf(MSG_DEBUG, "%s: no variant in dict entry", __func__);
- goto error;
- }
- type = dbus_message_iter_get_arg_type(&iter_dict_entry);
- if (type != DBUS_TYPE_VARIANT) {
- wpa_printf(MSG_DEBUG,
- "%s: unexpected dict entry variant type: %c",
- __func__, type);
- goto error;
- }
-
- dbus_message_iter_recurse(&iter_dict_entry, &iter_dict_val);
- entry->type = dbus_message_iter_get_arg_type(&iter_dict_val);
- wpa_printf(MSG_MSGDUMP, "%s: dict entry variant content type: %c",
- __func__, entry->type);
- entry->array_type = DBUS_TYPE_INVALID;
- if (!_wpa_dbus_dict_fill_value_from_variant(entry, &iter_dict_val)) {
- wpa_printf(MSG_DEBUG,
- "%s: failed to fetch dict values from variant",
- __func__);
- goto error;
- }
-
- dbus_message_iter_next(iter_dict);
- return TRUE;
-
-error:
- if (entry) {
- wpa_dbus_dict_entry_clear(entry);
- entry->type = DBUS_TYPE_INVALID;
- entry->array_type = DBUS_TYPE_INVALID;
- }
-
- return FALSE;
-}
-
-
-/**
- * Return whether or not there are additional dictionary entries.
- *
- * @param iter_dict A valid DBusMessageIter returned from
- * wpa_dbus_dict_open_read()
- * @return TRUE if more dict entries exists, FALSE if no more dict entries
- * exist
- */
-dbus_bool_t wpa_dbus_dict_has_dict_entry(DBusMessageIter *iter_dict)
-{
- if (!iter_dict)
- return FALSE;
- return dbus_message_iter_get_arg_type(iter_dict) ==
- DBUS_TYPE_DICT_ENTRY;
-}
-
-
-/**
- * Free any memory used by the entry object.
- *
- * @param entry The entry object
- */
-void wpa_dbus_dict_entry_clear(struct wpa_dbus_dict_entry *entry)
-{
- unsigned int i;
-
- if (!entry)
- return;
- switch (entry->type) {
- case DBUS_TYPE_OBJECT_PATH:
- case DBUS_TYPE_STRING:
- os_free(entry->str_value);
- break;
- case DBUS_TYPE_ARRAY:
- switch (entry->array_type) {
- case DBUS_TYPE_BYTE:
- os_free(entry->bytearray_value);
- break;
- case DBUS_TYPE_STRING:
- if (!entry->strarray_value)
- break;
- for (i = 0; i < entry->array_len; i++)
- os_free(entry->strarray_value[i]);
- os_free(entry->strarray_value);
- break;
- case WPAS_DBUS_TYPE_BINARRAY:
- for (i = 0; i < entry->array_len; i++)
- wpabuf_free(entry->binarray_value[i]);
- os_free(entry->binarray_value);
- break;
- }
- break;
- }
-
- os_memset(entry, 0, sizeof(struct wpa_dbus_dict_entry));
-}
projects / mech_eap.git / blobdiff