2 * WPA Supplicant / dbus-based control interface
3 * Copyright (c) 2006, Dan Williams <dcbw@redhat.com> and Red Hat, Inc.
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
10 #include <dbus/dbus.h>
14 #include "dbus_dict_helpers.h"
18 * Start a dict in a dbus message. Should be paired with a call to
19 * wpa_dbus_dict_close_write().
21 * @param iter A valid dbus message iterator
22 * @param iter_dict (out) A dict iterator to pass to further dict functions
23 * @return TRUE on success, FALSE on failure
26 dbus_bool_t wpa_dbus_dict_open_write(DBusMessageIter *iter,
27 DBusMessageIter *iter_dict)
31 if (!iter || !iter_dict)
34 result = dbus_message_iter_open_container(
37 DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
38 DBUS_TYPE_STRING_AS_STRING
39 DBUS_TYPE_VARIANT_AS_STRING
40 DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
47 * End a dict element in a dbus message. Should be paired with
48 * a call to wpa_dbus_dict_open_write().
50 * @param iter valid dbus message iterator, same as passed to
51 * wpa_dbus_dict_open_write()
52 * @param iter_dict a dbus dict iterator returned from
53 * wpa_dbus_dict_open_write()
54 * @return TRUE on success, FALSE on failure
57 dbus_bool_t wpa_dbus_dict_close_write(DBusMessageIter *iter,
58 DBusMessageIter *iter_dict)
60 if (!iter || !iter_dict)
63 return dbus_message_iter_close_container(iter, iter_dict);
67 const char * wpa_dbus_type_as_string(const int type)
71 return DBUS_TYPE_BYTE_AS_STRING;
72 case DBUS_TYPE_BOOLEAN:
73 return DBUS_TYPE_BOOLEAN_AS_STRING;
75 return DBUS_TYPE_INT16_AS_STRING;
76 case DBUS_TYPE_UINT16:
77 return DBUS_TYPE_UINT16_AS_STRING;
79 return DBUS_TYPE_INT32_AS_STRING;
80 case DBUS_TYPE_UINT32:
81 return DBUS_TYPE_UINT32_AS_STRING;
83 return DBUS_TYPE_INT64_AS_STRING;
84 case DBUS_TYPE_UINT64:
85 return DBUS_TYPE_UINT64_AS_STRING;
86 case DBUS_TYPE_DOUBLE:
87 return DBUS_TYPE_DOUBLE_AS_STRING;
88 case DBUS_TYPE_STRING:
89 return DBUS_TYPE_STRING_AS_STRING;
90 case DBUS_TYPE_OBJECT_PATH:
91 return DBUS_TYPE_OBJECT_PATH_AS_STRING;
93 return DBUS_TYPE_ARRAY_AS_STRING;
100 static dbus_bool_t _wpa_dbus_add_dict_entry_start(
101 DBusMessageIter *iter_dict, DBusMessageIter *iter_dict_entry,
102 const char *key, const int value_type)
104 if (!dbus_message_iter_open_container(iter_dict,
105 DBUS_TYPE_DICT_ENTRY, NULL,
109 if (!dbus_message_iter_append_basic(iter_dict_entry, DBUS_TYPE_STRING,
117 static dbus_bool_t _wpa_dbus_add_dict_entry_end(
118 DBusMessageIter *iter_dict, DBusMessageIter *iter_dict_entry,
119 DBusMessageIter *iter_dict_val)
121 if (!dbus_message_iter_close_container(iter_dict_entry, iter_dict_val))
123 if (!dbus_message_iter_close_container(iter_dict, iter_dict_entry))
130 static dbus_bool_t _wpa_dbus_add_dict_entry_basic(DBusMessageIter *iter_dict,
132 const int value_type,
135 DBusMessageIter iter_dict_entry, iter_dict_val;
136 const char *type_as_string = NULL;
141 type_as_string = wpa_dbus_type_as_string(value_type);
145 if (!_wpa_dbus_add_dict_entry_start(iter_dict, &iter_dict_entry,
149 if (!dbus_message_iter_open_container(&iter_dict_entry,
151 type_as_string, &iter_dict_val))
154 if (!dbus_message_iter_append_basic(&iter_dict_val, value_type, value))
157 if (!_wpa_dbus_add_dict_entry_end(iter_dict, &iter_dict_entry,
165 static dbus_bool_t _wpa_dbus_add_dict_entry_byte_array(
166 DBusMessageIter *iter_dict, const char *key,
167 const char *value, const dbus_uint32_t value_len)
169 DBusMessageIter iter_dict_entry, iter_dict_val, iter_array;
172 if (!_wpa_dbus_add_dict_entry_start(iter_dict, &iter_dict_entry,
173 key, DBUS_TYPE_ARRAY))
176 if (!dbus_message_iter_open_container(&iter_dict_entry,
178 DBUS_TYPE_ARRAY_AS_STRING
179 DBUS_TYPE_BYTE_AS_STRING,
183 if (!dbus_message_iter_open_container(&iter_dict_val, DBUS_TYPE_ARRAY,
184 DBUS_TYPE_BYTE_AS_STRING,
188 for (i = 0; i < value_len; i++) {
189 if (!dbus_message_iter_append_basic(&iter_array,
195 if (!dbus_message_iter_close_container(&iter_dict_val, &iter_array))
198 if (!_wpa_dbus_add_dict_entry_end(iter_dict, &iter_dict_entry,
207 * Add a string entry to the dict.
209 * @param iter_dict A valid DBusMessageIter returned from
210 * wpa_dbus_dict_open_write()
211 * @param key The key of the dict item
212 * @param value The string value
213 * @return TRUE on success, FALSE on failure
216 dbus_bool_t wpa_dbus_dict_append_string(DBusMessageIter *iter_dict,
217 const char *key, const char *value)
221 return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_STRING,
227 * Add a byte entry to the dict.
229 * @param iter_dict A valid DBusMessageIter returned from
230 * wpa_dbus_dict_open_write()
231 * @param key The key of the dict item
232 * @param value The byte value
233 * @return TRUE on success, FALSE on failure
236 dbus_bool_t wpa_dbus_dict_append_byte(DBusMessageIter *iter_dict,
237 const char *key, const char value)
239 return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_BYTE,
245 * Add a boolean entry to the dict.
247 * @param iter_dict A valid DBusMessageIter returned from
248 * wpa_dbus_dict_open_write()
249 * @param key The key of the dict item
250 * @param value The boolean value
251 * @return TRUE on success, FALSE on failure
254 dbus_bool_t wpa_dbus_dict_append_bool(DBusMessageIter *iter_dict,
255 const char *key, const dbus_bool_t value)
257 return _wpa_dbus_add_dict_entry_basic(iter_dict, key,
258 DBUS_TYPE_BOOLEAN, &value);
263 * Add a 16-bit signed integer entry to the dict.
265 * @param iter_dict A valid DBusMessageIter returned from
266 * wpa_dbus_dict_open_write()
267 * @param key The key of the dict item
268 * @param value The 16-bit signed integer value
269 * @return TRUE on success, FALSE on failure
272 dbus_bool_t wpa_dbus_dict_append_int16(DBusMessageIter *iter_dict,
274 const dbus_int16_t value)
276 return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_INT16,
282 * Add a 16-bit unsigned integer entry to the dict.
284 * @param iter_dict A valid DBusMessageIter returned from
285 * wpa_dbus_dict_open_write()
286 * @param key The key of the dict item
287 * @param value The 16-bit unsigned integer value
288 * @return TRUE on success, FALSE on failure
291 dbus_bool_t wpa_dbus_dict_append_uint16(DBusMessageIter *iter_dict,
293 const dbus_uint16_t value)
295 return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_UINT16,
301 * Add a 32-bit signed integer to the dict.
303 * @param iter_dict A valid DBusMessageIter returned from
304 * wpa_dbus_dict_open_write()
305 * @param key The key of the dict item
306 * @param value The 32-bit signed integer value
307 * @return TRUE on success, FALSE on failure
310 dbus_bool_t wpa_dbus_dict_append_int32(DBusMessageIter *iter_dict,
312 const dbus_int32_t value)
314 return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_INT32,
320 * Add a 32-bit unsigned integer entry to the dict.
322 * @param iter_dict A valid DBusMessageIter returned from
323 * wpa_dbus_dict_open_write()
324 * @param key The key of the dict item
325 * @param value The 32-bit unsigned integer value
326 * @return TRUE on success, FALSE on failure
329 dbus_bool_t wpa_dbus_dict_append_uint32(DBusMessageIter *iter_dict,
331 const dbus_uint32_t value)
333 return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_UINT32,
339 * Add a 64-bit integer entry to the dict.
341 * @param iter_dict A valid DBusMessageIter returned from
342 * wpa_dbus_dict_open_write()
343 * @param key The key of the dict item
344 * @param value The 64-bit integer value
345 * @return TRUE on success, FALSE on failure
348 dbus_bool_t wpa_dbus_dict_append_int64(DBusMessageIter *iter_dict,
350 const dbus_int64_t value)
352 return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_INT64,
358 * Add a 64-bit unsigned integer entry to the dict.
360 * @param iter_dict A valid DBusMessageIter returned from
361 * wpa_dbus_dict_open_write()
362 * @param key The key of the dict item
363 * @param value The 64-bit unsigned integer value
364 * @return TRUE on success, FALSE on failure
367 dbus_bool_t wpa_dbus_dict_append_uint64(DBusMessageIter *iter_dict,
369 const dbus_uint64_t value)
371 return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_UINT64,
377 * Add a double-precision floating point entry to the dict.
379 * @param iter_dict A valid DBusMessageIter returned from
380 * wpa_dbus_dict_open_write()
381 * @param key The key of the dict item
382 * @param value The double-precision floating point value
383 * @return TRUE on success, FALSE on failure
386 dbus_bool_t wpa_dbus_dict_append_double(DBusMessageIter *iter_dict,
387 const char *key, const double value)
389 return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_DOUBLE,
395 * Add a DBus object path entry to the dict.
397 * @param iter_dict A valid DBusMessageIter returned from
398 * wpa_dbus_dict_open_write()
399 * @param key The key of the dict item
400 * @param value The DBus object path value
401 * @return TRUE on success, FALSE on failure
404 dbus_bool_t wpa_dbus_dict_append_object_path(DBusMessageIter *iter_dict,
410 return _wpa_dbus_add_dict_entry_basic(iter_dict, key,
411 DBUS_TYPE_OBJECT_PATH, &value);
416 * Add a byte array entry to the dict.
418 * @param iter_dict A valid DBusMessageIter returned from
419 * wpa_dbus_dict_open_write()
420 * @param key The key of the dict item
421 * @param value The byte array
422 * @param value_len The length of the byte array, in bytes
423 * @return TRUE on success, FALSE on failure
426 dbus_bool_t wpa_dbus_dict_append_byte_array(DBusMessageIter *iter_dict,
429 const dbus_uint32_t value_len)
433 if (!value && (value_len != 0))
435 return _wpa_dbus_add_dict_entry_byte_array(iter_dict, key, value,
441 * Begin an array entry in the dict
443 * @param iter_dict A valid DBusMessageIter returned from
444 * wpa_dbus_dict_open_write()
445 * @param key The key of the dict item
446 * @param type The type of the contained data
447 * @param iter_dict_entry A private DBusMessageIter provided by the caller to
448 * be passed to wpa_dbus_dict_end_string_array()
449 * @param iter_dict_val A private DBusMessageIter provided by the caller to
450 * be passed to wpa_dbus_dict_end_string_array()
451 * @param iter_array On return, the DBusMessageIter to be passed to
452 * wpa_dbus_dict_string_array_add_element()
453 * @return TRUE on success, FALSE on failure
456 dbus_bool_t wpa_dbus_dict_begin_array(DBusMessageIter *iter_dict,
457 const char *key, const char *type,
458 DBusMessageIter *iter_dict_entry,
459 DBusMessageIter *iter_dict_val,
460 DBusMessageIter *iter_array)
465 err = os_snprintf(array_type, sizeof(array_type),
466 DBUS_TYPE_ARRAY_AS_STRING "%s",
468 if (err < 0 || err > (int) sizeof(array_type))
471 if (!iter_dict || !iter_dict_entry || !iter_dict_val || !iter_array)
474 if (!_wpa_dbus_add_dict_entry_start(iter_dict, iter_dict_entry,
475 key, DBUS_TYPE_ARRAY))
478 if (!dbus_message_iter_open_container(iter_dict_entry,
484 if (!dbus_message_iter_open_container(iter_dict_val, DBUS_TYPE_ARRAY,
492 dbus_bool_t wpa_dbus_dict_begin_string_array(DBusMessageIter *iter_dict,
494 DBusMessageIter *iter_dict_entry,
495 DBusMessageIter *iter_dict_val,
496 DBusMessageIter *iter_array)
498 return wpa_dbus_dict_begin_array(
500 DBUS_TYPE_STRING_AS_STRING,
501 iter_dict_entry, iter_dict_val, iter_array);
506 * Add a single string element to a string array dict entry
508 * @param iter_array A valid DBusMessageIter returned from
509 * wpa_dbus_dict_begin_string_array()'s
510 * iter_array parameter
511 * @param elem The string element to be added to the dict entry's string array
512 * @return TRUE on success, FALSE on failure
515 dbus_bool_t wpa_dbus_dict_string_array_add_element(DBusMessageIter *iter_array,
518 if (!iter_array || !elem)
521 return dbus_message_iter_append_basic(iter_array, DBUS_TYPE_STRING,
527 * Add a single byte array element to a string array dict entry
529 * @param iter_array A valid DBusMessageIter returned from
530 * wpa_dbus_dict_begin_array()'s iter_array
531 * parameter -- note that wpa_dbus_dict_begin_array()
532 * must have been called with "ay" as the type
533 * @param value The data to be added to the dict entry's array
534 * @param value_len The length of the data
535 * @return TRUE on success, FALSE on failure
538 dbus_bool_t wpa_dbus_dict_bin_array_add_element(DBusMessageIter *iter_array,
542 DBusMessageIter iter_bytes;
545 if (!iter_array || !value)
548 if (!dbus_message_iter_open_container(iter_array, DBUS_TYPE_ARRAY,
549 DBUS_TYPE_BYTE_AS_STRING,
553 for (i = 0; i < value_len; i++) {
554 if (!dbus_message_iter_append_basic(&iter_bytes,
560 if (!dbus_message_iter_close_container(iter_array, &iter_bytes))
568 * End an array dict entry
570 * @param iter_dict A valid DBusMessageIter returned from
571 * wpa_dbus_dict_open_write()
572 * @param iter_dict_entry A private DBusMessageIter returned from
573 * wpa_dbus_dict_begin_string_array() or
574 * wpa_dbus_dict_begin_array()
575 * @param iter_dict_val A private DBusMessageIter returned from
576 * wpa_dbus_dict_begin_string_array() or
577 * wpa_dbus_dict_begin_array()
578 * @param iter_array A DBusMessageIter returned from
579 * wpa_dbus_dict_begin_string_array() or
580 * wpa_dbus_dict_begin_array()
581 * @return TRUE on success, FALSE on failure
584 dbus_bool_t wpa_dbus_dict_end_array(DBusMessageIter *iter_dict,
585 DBusMessageIter *iter_dict_entry,
586 DBusMessageIter *iter_dict_val,
587 DBusMessageIter *iter_array)
589 if (!iter_dict || !iter_dict_entry || !iter_dict_val || !iter_array)
592 if (!dbus_message_iter_close_container(iter_dict_val, iter_array))
595 if (!_wpa_dbus_add_dict_entry_end(iter_dict, iter_dict_entry,
604 * Convenience function to add an entire string array to the dict.
606 * @param iter_dict A valid DBusMessageIter returned from
607 * wpa_dbus_dict_open_write()
608 * @param key The key of the dict item
609 * @param items The array of strings
610 * @param num_items The number of strings in the array
611 * @return TRUE on success, FALSE on failure
614 dbus_bool_t wpa_dbus_dict_append_string_array(DBusMessageIter *iter_dict,
617 const dbus_uint32_t num_items)
619 DBusMessageIter iter_dict_entry, iter_dict_val, iter_array;
624 if (!items && (num_items != 0))
627 if (!wpa_dbus_dict_begin_string_array(iter_dict, key,
628 &iter_dict_entry, &iter_dict_val,
632 for (i = 0; i < num_items; i++) {
633 if (!wpa_dbus_dict_string_array_add_element(&iter_array,
638 if (!wpa_dbus_dict_end_string_array(iter_dict, &iter_dict_entry,
639 &iter_dict_val, &iter_array))
647 * Convenience function to add an wpabuf binary array to the dict.
649 * @param iter_dict A valid DBusMessageIter returned from
650 * wpa_dbus_dict_open_write()
651 * @param key The key of the dict item
652 * @param items The array of wpabuf structures
653 * @param num_items The number of strings in the array
654 * @return TRUE on success, FALSE on failure
657 dbus_bool_t wpa_dbus_dict_append_wpabuf_array(DBusMessageIter *iter_dict,
659 const struct wpabuf **items,
660 const dbus_uint32_t num_items)
662 DBusMessageIter iter_dict_entry, iter_dict_val, iter_array;
667 if (!items && (num_items != 0))
670 if (!wpa_dbus_dict_begin_array(iter_dict, key,
671 DBUS_TYPE_ARRAY_AS_STRING
672 DBUS_TYPE_BYTE_AS_STRING,
673 &iter_dict_entry, &iter_dict_val,
677 for (i = 0; i < num_items; i++) {
678 if (!wpa_dbus_dict_bin_array_add_element(&iter_array,
679 wpabuf_head(items[i]),
680 wpabuf_len(items[i])))
684 if (!wpa_dbus_dict_end_array(iter_dict, &iter_dict_entry,
685 &iter_dict_val, &iter_array))
692 /*****************************************************/
693 /* Stuff for reading dicts */
694 /*****************************************************/
697 * Start reading from a dbus dict.
699 * @param iter A valid DBusMessageIter pointing to the start of the dict
700 * @param iter_dict (out) A DBusMessageIter to be passed to
701 * wpa_dbus_dict_read_next_entry()
702 * @error on failure a descriptive error
703 * @return TRUE on success, FALSE on failure
706 dbus_bool_t wpa_dbus_dict_open_read(DBusMessageIter *iter,
707 DBusMessageIter *iter_dict,
710 if (!iter || !iter_dict) {
711 dbus_set_error_const(error, DBUS_ERROR_FAILED,
712 "[internal] missing message iterators");
716 if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY ||
717 dbus_message_iter_get_element_type(iter) != DBUS_TYPE_DICT_ENTRY) {
718 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
719 "unexpected message argument types");
723 dbus_message_iter_recurse(iter, iter_dict);
728 #define BYTE_ARRAY_CHUNK_SIZE 34
729 #define BYTE_ARRAY_ITEM_SIZE (sizeof(char))
731 static dbus_bool_t _wpa_dbus_dict_entry_get_byte_array(
732 DBusMessageIter *iter, struct wpa_dbus_dict_entry *entry)
734 dbus_uint32_t count = 0;
735 dbus_bool_t success = FALSE;
736 char *buffer, *nbuffer;
738 entry->bytearray_value = NULL;
739 entry->array_type = DBUS_TYPE_BYTE;
741 buffer = os_calloc(BYTE_ARRAY_CHUNK_SIZE, BYTE_ARRAY_ITEM_SIZE);
745 entry->bytearray_value = buffer;
746 entry->array_len = 0;
747 while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_BYTE) {
750 if ((count % BYTE_ARRAY_CHUNK_SIZE) == 0 && count != 0) {
751 nbuffer = os_realloc_array(
752 buffer, count + BYTE_ARRAY_CHUNK_SIZE,
753 BYTE_ARRAY_ITEM_SIZE);
754 if (nbuffer == NULL) {
756 wpa_printf(MSG_ERROR, "dbus: _wpa_dbus_dict_"
757 "entry_get_byte_array out of "
758 "memory trying to retrieve the "
764 entry->bytearray_value = buffer;
766 dbus_message_iter_get_basic(iter, &byte);
767 entry->bytearray_value[count] = byte;
768 entry->array_len = ++count;
769 dbus_message_iter_next(iter);
772 /* Zero-length arrays are valid. */
773 if (entry->array_len == 0) {
774 os_free(entry->bytearray_value);
775 entry->bytearray_value = NULL;
785 #define STR_ARRAY_CHUNK_SIZE 8
786 #define STR_ARRAY_ITEM_SIZE (sizeof(char *))
788 static dbus_bool_t _wpa_dbus_dict_entry_get_string_array(
789 DBusMessageIter *iter, int array_type,
790 struct wpa_dbus_dict_entry *entry)
792 dbus_uint32_t count = 0;
793 dbus_bool_t success = FALSE;
794 char **buffer, **nbuffer;
796 entry->strarray_value = NULL;
797 entry->array_type = DBUS_TYPE_STRING;
799 buffer = os_calloc(STR_ARRAY_CHUNK_SIZE, STR_ARRAY_ITEM_SIZE);
803 entry->strarray_value = buffer;
804 entry->array_len = 0;
805 while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRING) {
809 if ((count % STR_ARRAY_CHUNK_SIZE) == 0 && count != 0) {
810 nbuffer = os_realloc_array(
811 buffer, count + STR_ARRAY_CHUNK_SIZE,
812 STR_ARRAY_ITEM_SIZE);
813 if (nbuffer == NULL) {
815 wpa_printf(MSG_ERROR, "dbus: _wpa_dbus_dict_"
816 "entry_get_string_array out of "
817 "memory trying to retrieve the "
823 entry->strarray_value = buffer;
825 dbus_message_iter_get_basic(iter, &value);
826 str = os_strdup(value);
828 wpa_printf(MSG_ERROR, "dbus: _wpa_dbus_dict_entry_get_"
829 "string_array out of memory trying to "
830 "duplicate the string array");
833 entry->strarray_value[count] = str;
834 entry->array_len = ++count;
835 dbus_message_iter_next(iter);
838 /* Zero-length arrays are valid. */
839 if (entry->array_len == 0) {
840 os_free(entry->strarray_value);
841 entry->strarray_value = NULL;
851 #define BIN_ARRAY_CHUNK_SIZE 10
852 #define BIN_ARRAY_ITEM_SIZE (sizeof(struct wpabuf *))
854 static dbus_bool_t _wpa_dbus_dict_entry_get_binarray(
855 DBusMessageIter *iter, struct wpa_dbus_dict_entry *entry)
857 struct wpa_dbus_dict_entry tmpentry;
861 if (dbus_message_iter_get_element_type(iter) != DBUS_TYPE_BYTE)
864 entry->array_type = WPAS_DBUS_TYPE_BINARRAY;
865 entry->array_len = 0;
866 entry->binarray_value = NULL;
868 while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_ARRAY) {
869 DBusMessageIter iter_array;
871 if (entry->array_len == buflen) {
872 struct wpabuf **newbuf;
874 buflen += BIN_ARRAY_CHUNK_SIZE;
876 newbuf = os_realloc_array(entry->binarray_value,
877 buflen, BIN_ARRAY_ITEM_SIZE);
880 entry->binarray_value = newbuf;
883 dbus_message_iter_recurse(iter, &iter_array);
884 if (_wpa_dbus_dict_entry_get_byte_array(&iter_array, &tmpentry)
888 entry->binarray_value[entry->array_len] =
889 wpabuf_alloc_ext_data((u8 *) tmpentry.bytearray_value,
891 if (entry->binarray_value[entry->array_len] == NULL) {
892 wpa_dbus_dict_entry_clear(&tmpentry);
896 dbus_message_iter_next(iter);
902 for (i = 0; i < (int) entry->array_len; i++)
903 wpabuf_free(entry->binarray_value[i]);
904 os_free(entry->binarray_value);
905 entry->array_len = 0;
906 entry->binarray_value = NULL;
911 static dbus_bool_t _wpa_dbus_dict_entry_get_array(
912 DBusMessageIter *iter_dict_val, struct wpa_dbus_dict_entry *entry)
914 int array_type = dbus_message_iter_get_element_type(iter_dict_val);
915 dbus_bool_t success = FALSE;
916 DBusMessageIter iter_array;
921 dbus_message_iter_recurse(iter_dict_val, &iter_array);
923 switch (array_type) {
925 success = _wpa_dbus_dict_entry_get_byte_array(&iter_array,
928 case DBUS_TYPE_STRING:
929 success = _wpa_dbus_dict_entry_get_string_array(&iter_array,
933 case DBUS_TYPE_ARRAY:
934 success = _wpa_dbus_dict_entry_get_binarray(&iter_array, entry);
943 static dbus_bool_t _wpa_dbus_dict_fill_value_from_variant(
944 struct wpa_dbus_dict_entry *entry, DBusMessageIter *iter)
948 switch (entry->type) {
949 case DBUS_TYPE_OBJECT_PATH:
950 case DBUS_TYPE_STRING:
951 dbus_message_iter_get_basic(iter, &v);
952 entry->str_value = os_strdup(v);
953 if (entry->str_value == NULL)
956 case DBUS_TYPE_BOOLEAN:
957 dbus_message_iter_get_basic(iter, &entry->bool_value);
960 dbus_message_iter_get_basic(iter, &entry->byte_value);
962 case DBUS_TYPE_INT16:
963 dbus_message_iter_get_basic(iter, &entry->int16_value);
965 case DBUS_TYPE_UINT16:
966 dbus_message_iter_get_basic(iter, &entry->uint16_value);
968 case DBUS_TYPE_INT32:
969 dbus_message_iter_get_basic(iter, &entry->int32_value);
971 case DBUS_TYPE_UINT32:
972 dbus_message_iter_get_basic(iter, &entry->uint32_value);
974 case DBUS_TYPE_INT64:
975 dbus_message_iter_get_basic(iter, &entry->int64_value);
977 case DBUS_TYPE_UINT64:
978 dbus_message_iter_get_basic(iter, &entry->uint64_value);
980 case DBUS_TYPE_DOUBLE:
981 dbus_message_iter_get_basic(iter, &entry->double_value);
983 case DBUS_TYPE_ARRAY:
984 return _wpa_dbus_dict_entry_get_array(iter, entry);
994 * Read the current key/value entry from the dict. Entries are dynamically
995 * allocated when needed and must be freed after use with the
996 * wpa_dbus_dict_entry_clear() function.
998 * The returned entry object will be filled with the type and value of the next
999 * entry in the dict, or the type will be DBUS_TYPE_INVALID if an error
1002 * @param iter_dict A valid DBusMessageIter returned from
1003 * wpa_dbus_dict_open_read()
1004 * @param entry A valid dict entry object into which the dict key and value
1006 * @return TRUE on success, FALSE on failure
1009 dbus_bool_t wpa_dbus_dict_get_entry(DBusMessageIter *iter_dict,
1010 struct wpa_dbus_dict_entry * entry)
1012 DBusMessageIter iter_dict_entry, iter_dict_val;
1016 if (!iter_dict || !entry)
1019 if (dbus_message_iter_get_arg_type(iter_dict) != DBUS_TYPE_DICT_ENTRY)
1022 dbus_message_iter_recurse(iter_dict, &iter_dict_entry);
1023 dbus_message_iter_get_basic(&iter_dict_entry, &key);
1026 if (!dbus_message_iter_next(&iter_dict_entry))
1028 type = dbus_message_iter_get_arg_type(&iter_dict_entry);
1029 if (type != DBUS_TYPE_VARIANT)
1032 dbus_message_iter_recurse(&iter_dict_entry, &iter_dict_val);
1033 entry->type = dbus_message_iter_get_arg_type(&iter_dict_val);
1034 if (!_wpa_dbus_dict_fill_value_from_variant(entry, &iter_dict_val))
1037 dbus_message_iter_next(iter_dict);
1042 wpa_dbus_dict_entry_clear(entry);
1043 entry->type = DBUS_TYPE_INVALID;
1044 entry->array_type = DBUS_TYPE_INVALID;
1052 * Return whether or not there are additional dictionary entries.
1054 * @param iter_dict A valid DBusMessageIter returned from
1055 * wpa_dbus_dict_open_read()
1056 * @return TRUE if more dict entries exists, FALSE if no more dict entries
1059 dbus_bool_t wpa_dbus_dict_has_dict_entry(DBusMessageIter *iter_dict)
1063 return dbus_message_iter_get_arg_type(iter_dict) ==
1064 DBUS_TYPE_DICT_ENTRY;
1069 * Free any memory used by the entry object.
1071 * @param entry The entry object
1073 void wpa_dbus_dict_entry_clear(struct wpa_dbus_dict_entry *entry)
1079 switch (entry->type) {
1080 case DBUS_TYPE_OBJECT_PATH:
1081 case DBUS_TYPE_STRING:
1082 os_free(entry->str_value);
1084 case DBUS_TYPE_ARRAY:
1085 switch (entry->array_type) {
1086 case DBUS_TYPE_BYTE:
1087 os_free(entry->bytearray_value);
1089 case DBUS_TYPE_STRING:
1090 for (i = 0; i < entry->array_len; i++)
1091 os_free(entry->strarray_value[i]);
1092 os_free(entry->strarray_value);
1094 case WPAS_DBUS_TYPE_BINARRAY:
1095 for (i = 0; i < entry->array_len; i++)
1096 wpabuf_free(entry->binarray_value[i]);
1097 os_free(entry->binarray_value);
1103 os_memset(entry, 0, sizeof(struct wpa_dbus_dict_entry));