1 /*
2 * WPA Supplicant / dbus-based control interface
3 * Copyright (c) 2006, Dan Williams <dcbw@redhat.com> and Red Hat, Inc.
4 *
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
7 */
8
9 #include "includes.h"
10 #include <dbus/dbus.h>
11
12 #include "common.h"
13 #include "wpabuf.h"
14 #include "dbus_dict_helpers.h"
15
16
17 /**
18 * Start a dict in a dbus message. Should be paired with a call to
19 * wpa_dbus_dict_close_write().
20 *
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
24 *
25 */
wpa_dbus_dict_open_write(DBusMessageIter * iter,DBusMessageIter * iter_dict)26 dbus_bool_t wpa_dbus_dict_open_write(DBusMessageIter *iter,
27 DBusMessageIter *iter_dict)
28 {
29 dbus_bool_t result;
30
31 if (!iter || !iter_dict)
32 return FALSE;
33
34 result = dbus_message_iter_open_container(
35 iter,
36 DBUS_TYPE_ARRAY,
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,
41 iter_dict);
42 return result;
43 }
44
45
46 /**
47 * End a dict element in a dbus message. Should be paired with
48 * a call to wpa_dbus_dict_open_write().
49 *
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
55 *
56 */
wpa_dbus_dict_close_write(DBusMessageIter * iter,DBusMessageIter * iter_dict)57 dbus_bool_t wpa_dbus_dict_close_write(DBusMessageIter *iter,
58 DBusMessageIter *iter_dict)
59 {
60 if (!iter || !iter_dict)
61 return FALSE;
62
63 return dbus_message_iter_close_container(iter, iter_dict);
64 }
65
66
wpa_dbus_type_as_string(const int type)67 const char * wpa_dbus_type_as_string(const int type)
68 {
69 switch (type) {
70 case DBUS_TYPE_BYTE:
71 return DBUS_TYPE_BYTE_AS_STRING;
72 case DBUS_TYPE_BOOLEAN:
73 return DBUS_TYPE_BOOLEAN_AS_STRING;
74 case DBUS_TYPE_INT16:
75 return DBUS_TYPE_INT16_AS_STRING;
76 case DBUS_TYPE_UINT16:
77 return DBUS_TYPE_UINT16_AS_STRING;
78 case DBUS_TYPE_INT32:
79 return DBUS_TYPE_INT32_AS_STRING;
80 case DBUS_TYPE_UINT32:
81 return DBUS_TYPE_UINT32_AS_STRING;
82 case DBUS_TYPE_INT64:
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;
92 case DBUS_TYPE_ARRAY:
93 return DBUS_TYPE_ARRAY_AS_STRING;
94 default:
95 return NULL;
96 }
97 }
98
99
_wpa_dbus_add_dict_entry_start(DBusMessageIter * iter_dict,DBusMessageIter * iter_dict_entry,const char * key,const int value_type)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)
103 {
104 if (!dbus_message_iter_open_container(iter_dict,
105 DBUS_TYPE_DICT_ENTRY, NULL,
106 iter_dict_entry))
107 return FALSE;
108
109 return dbus_message_iter_append_basic(iter_dict_entry, DBUS_TYPE_STRING,
110 &key);
111 }
112
113
_wpa_dbus_add_dict_entry_end(DBusMessageIter * iter_dict,DBusMessageIter * iter_dict_entry,DBusMessageIter * iter_dict_val)114 static dbus_bool_t _wpa_dbus_add_dict_entry_end(
115 DBusMessageIter *iter_dict, DBusMessageIter *iter_dict_entry,
116 DBusMessageIter *iter_dict_val)
117 {
118 if (!dbus_message_iter_close_container(iter_dict_entry, iter_dict_val))
119 return FALSE;
120
121 return dbus_message_iter_close_container(iter_dict, iter_dict_entry);
122 }
123
124
_wpa_dbus_add_dict_entry_basic(DBusMessageIter * iter_dict,const char * key,const int value_type,const void * value)125 static dbus_bool_t _wpa_dbus_add_dict_entry_basic(DBusMessageIter *iter_dict,
126 const char *key,
127 const int value_type,
128 const void *value)
129 {
130 DBusMessageIter iter_dict_entry, iter_dict_val;
131 const char *type_as_string = NULL;
132
133 if (key == NULL)
134 return FALSE;
135
136 type_as_string = wpa_dbus_type_as_string(value_type);
137 if (!type_as_string)
138 return FALSE;
139
140 if (!_wpa_dbus_add_dict_entry_start(iter_dict, &iter_dict_entry,
141 key, value_type) ||
142 !dbus_message_iter_open_container(&iter_dict_entry,
143 DBUS_TYPE_VARIANT,
144 type_as_string, &iter_dict_val) ||
145 !dbus_message_iter_append_basic(&iter_dict_val, value_type, value))
146 return FALSE;
147
148 return _wpa_dbus_add_dict_entry_end(iter_dict, &iter_dict_entry,
149 &iter_dict_val);
150 }
151
152
_wpa_dbus_add_dict_entry_byte_array(DBusMessageIter * iter_dict,const char * key,const char * value,const dbus_uint32_t value_len)153 static dbus_bool_t _wpa_dbus_add_dict_entry_byte_array(
154 DBusMessageIter *iter_dict, const char *key,
155 const char *value, const dbus_uint32_t value_len)
156 {
157 DBusMessageIter iter_dict_entry, iter_dict_val, iter_array;
158 dbus_uint32_t i;
159
160 if (!_wpa_dbus_add_dict_entry_start(iter_dict, &iter_dict_entry,
161 key, DBUS_TYPE_ARRAY) ||
162 !dbus_message_iter_open_container(&iter_dict_entry,
163 DBUS_TYPE_VARIANT,
164 DBUS_TYPE_ARRAY_AS_STRING
165 DBUS_TYPE_BYTE_AS_STRING,
166 &iter_dict_val) ||
167 !dbus_message_iter_open_container(&iter_dict_val, DBUS_TYPE_ARRAY,
168 DBUS_TYPE_BYTE_AS_STRING,
169 &iter_array))
170 return FALSE;
171
172 for (i = 0; i < value_len; i++) {
173 if (!dbus_message_iter_append_basic(&iter_array,
174 DBUS_TYPE_BYTE,
175 &(value[i])))
176 return FALSE;
177 }
178
179 if (!dbus_message_iter_close_container(&iter_dict_val, &iter_array))
180 return FALSE;
181
182 return _wpa_dbus_add_dict_entry_end(iter_dict, &iter_dict_entry,
183 &iter_dict_val);
184 }
185
186
187 /**
188 * Add a string entry to the dict.
189 *
190 * @param iter_dict A valid DBusMessageIter returned from
191 * wpa_dbus_dict_open_write()
192 * @param key The key of the dict item
193 * @param value The string value
194 * @return TRUE on success, FALSE on failure
195 *
196 */
wpa_dbus_dict_append_string(DBusMessageIter * iter_dict,const char * key,const char * value)197 dbus_bool_t wpa_dbus_dict_append_string(DBusMessageIter *iter_dict,
198 const char *key, const char *value)
199 {
200 if (!value)
201 return FALSE;
202 return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_STRING,
203 &value);
204 }
205
206
207 /**
208 * Add a boolean entry to the dict.
209 *
210 * @param iter_dict A valid DBusMessageIter returned from
211 * wpa_dbus_dict_open_write()
212 * @param key The key of the dict item
213 * @param value The boolean value
214 * @return TRUE on success, FALSE on failure
215 *
216 */
wpa_dbus_dict_append_bool(DBusMessageIter * iter_dict,const char * key,const dbus_bool_t value)217 dbus_bool_t wpa_dbus_dict_append_bool(DBusMessageIter *iter_dict,
218 const char *key, const dbus_bool_t value)
219 {
220 return _wpa_dbus_add_dict_entry_basic(iter_dict, key,
221 DBUS_TYPE_BOOLEAN, &value);
222 }
223
224
225 /**
226 * Add a 16-bit signed integer entry to the dict.
227 *
228 * @param iter_dict A valid DBusMessageIter returned from
229 * wpa_dbus_dict_open_write()
230 * @param key The key of the dict item
231 * @param value The 16-bit signed integer value
232 * @return TRUE on success, FALSE on failure
233 *
234 */
wpa_dbus_dict_append_int16(DBusMessageIter * iter_dict,const char * key,const dbus_int16_t value)235 dbus_bool_t wpa_dbus_dict_append_int16(DBusMessageIter *iter_dict,
236 const char *key,
237 const dbus_int16_t value)
238 {
239 return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_INT16,
240 &value);
241 }
242
243
244 /**
245 * Add a 16-bit unsigned integer entry to the dict.
246 *
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 16-bit unsigned integer value
251 * @return TRUE on success, FALSE on failure
252 *
253 */
wpa_dbus_dict_append_uint16(DBusMessageIter * iter_dict,const char * key,const dbus_uint16_t value)254 dbus_bool_t wpa_dbus_dict_append_uint16(DBusMessageIter *iter_dict,
255 const char *key,
256 const dbus_uint16_t value)
257 {
258 return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_UINT16,
259 &value);
260 }
261
262
263 /**
264 * Add a 32-bit signed integer to the dict.
265 *
266 * @param iter_dict A valid DBusMessageIter returned from
267 * wpa_dbus_dict_open_write()
268 * @param key The key of the dict item
269 * @param value The 32-bit signed integer value
270 * @return TRUE on success, FALSE on failure
271 *
272 */
wpa_dbus_dict_append_int32(DBusMessageIter * iter_dict,const char * key,const dbus_int32_t value)273 dbus_bool_t wpa_dbus_dict_append_int32(DBusMessageIter *iter_dict,
274 const char *key,
275 const dbus_int32_t value)
276 {
277 return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_INT32,
278 &value);
279 }
280
281
282 /**
283 * Add a 32-bit unsigned integer entry to the dict.
284 *
285 * @param iter_dict A valid DBusMessageIter returned from
286 * wpa_dbus_dict_open_write()
287 * @param key The key of the dict item
288 * @param value The 32-bit unsigned integer value
289 * @return TRUE on success, FALSE on failure
290 *
291 */
wpa_dbus_dict_append_uint32(DBusMessageIter * iter_dict,const char * key,const dbus_uint32_t value)292 dbus_bool_t wpa_dbus_dict_append_uint32(DBusMessageIter *iter_dict,
293 const char *key,
294 const dbus_uint32_t value)
295 {
296 return _wpa_dbus_add_dict_entry_basic(iter_dict, key, DBUS_TYPE_UINT32,
297 &value);
298 }
299
300
301 /**
302 * Add a DBus object path entry to the dict.
303 *
304 * @param iter_dict A valid DBusMessageIter returned from
305 * wpa_dbus_dict_open_write()
306 * @param key The key of the dict item
307 * @param value The DBus object path value
308 * @return TRUE on success, FALSE on failure
309 *
310 */
wpa_dbus_dict_append_object_path(DBusMessageIter * iter_dict,const char * key,const char * value)311 dbus_bool_t wpa_dbus_dict_append_object_path(DBusMessageIter *iter_dict,
312 const char *key,
313 const char *value)
314 {
315 if (!value)
316 return FALSE;
317 return _wpa_dbus_add_dict_entry_basic(iter_dict, key,
318 DBUS_TYPE_OBJECT_PATH, &value);
319 }
320
321
322 /**
323 * Add a byte array entry to the dict.
324 *
325 * @param iter_dict A valid DBusMessageIter returned from
326 * wpa_dbus_dict_open_write()
327 * @param key The key of the dict item
328 * @param value The byte array
329 * @param value_len The length of the byte array, in bytes
330 * @return TRUE on success, FALSE on failure
331 *
332 */
wpa_dbus_dict_append_byte_array(DBusMessageIter * iter_dict,const char * key,const char * value,const dbus_uint32_t value_len)333 dbus_bool_t wpa_dbus_dict_append_byte_array(DBusMessageIter *iter_dict,
334 const char *key,
335 const char *value,
336 const dbus_uint32_t value_len)
337 {
338 if (!key || (!value && value_len != 0))
339 return FALSE;
340 return _wpa_dbus_add_dict_entry_byte_array(iter_dict, key, value,
341 value_len);
342 }
343
344
345 /**
346 * Begin an array entry in the dict
347 *
348 * @param iter_dict A valid DBusMessageIter returned from
349 * wpa_dbus_dict_open_write()
350 * @param key The key of the dict item
351 * @param type The type of the contained data
352 * @param iter_dict_entry A private DBusMessageIter provided by the caller to
353 * be passed to wpa_dbus_dict_end_string_array()
354 * @param iter_dict_val A private DBusMessageIter provided by the caller to
355 * be passed to wpa_dbus_dict_end_string_array()
356 * @param iter_array On return, the DBusMessageIter to be passed to
357 * wpa_dbus_dict_string_array_add_element()
358 * @return TRUE on success, FALSE on failure
359 *
360 */
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)361 dbus_bool_t wpa_dbus_dict_begin_array(DBusMessageIter *iter_dict,
362 const char *key, const char *type,
363 DBusMessageIter *iter_dict_entry,
364 DBusMessageIter *iter_dict_val,
365 DBusMessageIter *iter_array)
366 {
367 char array_type[10];
368 int err;
369
370 err = os_snprintf(array_type, sizeof(array_type),
371 DBUS_TYPE_ARRAY_AS_STRING "%s",
372 type);
373 if (os_snprintf_error(sizeof(array_type), err))
374 return FALSE;
375
376 if (!iter_dict || !iter_dict_entry || !iter_dict_val || !iter_array ||
377 !_wpa_dbus_add_dict_entry_start(iter_dict, iter_dict_entry,
378 key, DBUS_TYPE_ARRAY) ||
379 !dbus_message_iter_open_container(iter_dict_entry,
380 DBUS_TYPE_VARIANT,
381 array_type,
382 iter_dict_val))
383 return FALSE;
384
385 return dbus_message_iter_open_container(iter_dict_val, DBUS_TYPE_ARRAY,
386 type, iter_array);
387 }
388
389
wpa_dbus_dict_begin_string_array(DBusMessageIter * iter_dict,const char * key,DBusMessageIter * iter_dict_entry,DBusMessageIter * iter_dict_val,DBusMessageIter * iter_array)390 dbus_bool_t wpa_dbus_dict_begin_string_array(DBusMessageIter *iter_dict,
391 const char *key,
392 DBusMessageIter *iter_dict_entry,
393 DBusMessageIter *iter_dict_val,
394 DBusMessageIter *iter_array)
395 {
396 return wpa_dbus_dict_begin_array(
397 iter_dict, key,
398 DBUS_TYPE_STRING_AS_STRING,
399 iter_dict_entry, iter_dict_val, iter_array);
400 }
401
402
403 /**
404 * Add a single string element to a string array dict entry
405 *
406 * @param iter_array A valid DBusMessageIter returned from
407 * wpa_dbus_dict_begin_string_array()'s
408 * iter_array parameter
409 * @param elem The string element to be added to the dict entry's string array
410 * @return TRUE on success, FALSE on failure
411 *
412 */
wpa_dbus_dict_string_array_add_element(DBusMessageIter * iter_array,const char * elem)413 dbus_bool_t wpa_dbus_dict_string_array_add_element(DBusMessageIter *iter_array,
414 const char *elem)
415 {
416 if (!iter_array || !elem)
417 return FALSE;
418
419 return dbus_message_iter_append_basic(iter_array, DBUS_TYPE_STRING,
420 &elem);
421 }
422
423
424 /**
425 * Add a single byte array element to a string array dict entry
426 *
427 * @param iter_array A valid DBusMessageIter returned from
428 * wpa_dbus_dict_begin_array()'s iter_array
429 * parameter -- note that wpa_dbus_dict_begin_array()
430 * must have been called with "ay" as the type
431 * @param value The data to be added to the dict entry's array
432 * @param value_len The length of the data
433 * @return TRUE on success, FALSE on failure
434 *
435 */
wpa_dbus_dict_bin_array_add_element(DBusMessageIter * iter_array,const u8 * value,size_t value_len)436 dbus_bool_t wpa_dbus_dict_bin_array_add_element(DBusMessageIter *iter_array,
437 const u8 *value,
438 size_t value_len)
439 {
440 DBusMessageIter iter_bytes;
441 size_t i;
442
443 if (!iter_array || !value ||
444 !dbus_message_iter_open_container(iter_array, DBUS_TYPE_ARRAY,
445 DBUS_TYPE_BYTE_AS_STRING,
446 &iter_bytes))
447 return FALSE;
448
449 for (i = 0; i < value_len; i++) {
450 if (!dbus_message_iter_append_basic(&iter_bytes,
451 DBUS_TYPE_BYTE,
452 &(value[i])))
453 return FALSE;
454 }
455
456 return dbus_message_iter_close_container(iter_array, &iter_bytes);
457 }
458
459
460 /**
461 * End an array dict entry
462 *
463 * @param iter_dict A valid DBusMessageIter returned from
464 * wpa_dbus_dict_open_write()
465 * @param iter_dict_entry A private DBusMessageIter returned from
466 * wpa_dbus_dict_begin_string_array() or
467 * wpa_dbus_dict_begin_array()
468 * @param iter_dict_val A private DBusMessageIter returned from
469 * wpa_dbus_dict_begin_string_array() or
470 * wpa_dbus_dict_begin_array()
471 * @param iter_array A DBusMessageIter returned from
472 * wpa_dbus_dict_begin_string_array() or
473 * wpa_dbus_dict_begin_array()
474 * @return TRUE on success, FALSE on failure
475 *
476 */
wpa_dbus_dict_end_array(DBusMessageIter * iter_dict,DBusMessageIter * iter_dict_entry,DBusMessageIter * iter_dict_val,DBusMessageIter * iter_array)477 dbus_bool_t wpa_dbus_dict_end_array(DBusMessageIter *iter_dict,
478 DBusMessageIter *iter_dict_entry,
479 DBusMessageIter *iter_dict_val,
480 DBusMessageIter *iter_array)
481 {
482 if (!iter_dict || !iter_dict_entry || !iter_dict_val || !iter_array ||
483 !dbus_message_iter_close_container(iter_dict_val, iter_array))
484 return FALSE;
485
486 return _wpa_dbus_add_dict_entry_end(iter_dict, iter_dict_entry,
487 iter_dict_val);
488 }
489
490
491 /**
492 * Convenience function to add an entire string array to the dict.
493 *
494 * @param iter_dict A valid DBusMessageIter returned from
495 * wpa_dbus_dict_open_write()
496 * @param key The key of the dict item
497 * @param items The array of strings
498 * @param num_items The number of strings in the array
499 * @return TRUE on success, FALSE on failure
500 *
501 */
wpa_dbus_dict_append_string_array(DBusMessageIter * iter_dict,const char * key,const char ** items,const dbus_uint32_t num_items)502 dbus_bool_t wpa_dbus_dict_append_string_array(DBusMessageIter *iter_dict,
503 const char *key,
504 const char **items,
505 const dbus_uint32_t num_items)
506 {
507 DBusMessageIter iter_dict_entry, iter_dict_val, iter_array;
508 dbus_uint32_t i;
509
510 if (!key || (!items && num_items != 0) ||
511 !wpa_dbus_dict_begin_string_array(iter_dict, key,
512 &iter_dict_entry, &iter_dict_val,
513 &iter_array))
514 return FALSE;
515
516 for (i = 0; i < num_items; i++) {
517 if (!wpa_dbus_dict_string_array_add_element(&iter_array,
518 items[i]))
519 return FALSE;
520 }
521
522 return wpa_dbus_dict_end_string_array(iter_dict, &iter_dict_entry,
523 &iter_dict_val, &iter_array);
524 }
525
526
527 /**
528 * Convenience function to add an wpabuf binary array to the dict.
529 *
530 * @param iter_dict A valid DBusMessageIter returned from
531 * wpa_dbus_dict_open_write()
532 * @param key The key of the dict item
533 * @param items The array of wpabuf structures
534 * @param num_items The number of strings in the array
535 * @return TRUE on success, FALSE on failure
536 *
537 */
wpa_dbus_dict_append_wpabuf_array(DBusMessageIter * iter_dict,const char * key,const struct wpabuf ** items,const dbus_uint32_t num_items)538 dbus_bool_t wpa_dbus_dict_append_wpabuf_array(DBusMessageIter *iter_dict,
539 const char *key,
540 const struct wpabuf **items,
541 const dbus_uint32_t num_items)
542 {
543 DBusMessageIter iter_dict_entry, iter_dict_val, iter_array;
544 dbus_uint32_t i;
545
546 if (!key ||
547 (!items && num_items != 0) ||
548 !wpa_dbus_dict_begin_array(iter_dict, key,
549 DBUS_TYPE_ARRAY_AS_STRING
550 DBUS_TYPE_BYTE_AS_STRING,
551 &iter_dict_entry, &iter_dict_val,
552 &iter_array))
553 return FALSE;
554
555 for (i = 0; i < num_items; i++) {
556 if (!wpa_dbus_dict_bin_array_add_element(&iter_array,
557 wpabuf_head(items[i]),
558 wpabuf_len(items[i])))
559 return FALSE;
560 }
561
562 return wpa_dbus_dict_end_array(iter_dict, &iter_dict_entry,
563 &iter_dict_val, &iter_array);
564 }
565
566
567 /*****************************************************/
568 /* Stuff for reading dicts */
569 /*****************************************************/
570
571 /**
572 * Start reading from a dbus dict.
573 *
574 * @param iter A valid DBusMessageIter pointing to the start of the dict
575 * @param iter_dict (out) A DBusMessageIter to be passed to
576 * wpa_dbus_dict_read_next_entry()
577 * @error on failure a descriptive error
578 * @return TRUE on success, FALSE on failure
579 *
580 */
wpa_dbus_dict_open_read(DBusMessageIter * iter,DBusMessageIter * iter_dict,DBusError * error)581 dbus_bool_t wpa_dbus_dict_open_read(DBusMessageIter *iter,
582 DBusMessageIter *iter_dict,
583 DBusError *error)
584 {
585 int type;
586
587 wpa_printf(MSG_MSGDUMP, "%s: start reading a dict entry", __func__);
588 if (!iter || !iter_dict) {
589 dbus_set_error_const(error, DBUS_ERROR_FAILED,
590 "[internal] missing message iterators");
591 return FALSE;
592 }
593
594 type = dbus_message_iter_get_arg_type(iter);
595 if (type != DBUS_TYPE_ARRAY ||
596 dbus_message_iter_get_element_type(iter) != DBUS_TYPE_DICT_ENTRY) {
597 wpa_printf(MSG_DEBUG,
598 "%s: unexpected message argument types (arg=%c element=%c)",
599 __func__, type,
600 type != DBUS_TYPE_ARRAY ? '?' :
601 dbus_message_iter_get_element_type(iter));
602 dbus_set_error_const(error, DBUS_ERROR_INVALID_ARGS,
603 "unexpected message argument types");
604 return FALSE;
605 }
606
607 dbus_message_iter_recurse(iter, iter_dict);
608 return TRUE;
609 }
610
611
612 #define BYTE_ARRAY_CHUNK_SIZE 34
613 #define BYTE_ARRAY_ITEM_SIZE (sizeof(char))
614
_wpa_dbus_dict_entry_get_byte_array(DBusMessageIter * iter,struct wpa_dbus_dict_entry * entry)615 static dbus_bool_t _wpa_dbus_dict_entry_get_byte_array(
616 DBusMessageIter *iter, struct wpa_dbus_dict_entry *entry)
617 {
618 dbus_uint32_t count = 0;
619 dbus_bool_t success = FALSE;
620 char *buffer, *nbuffer;
621
622 entry->bytearray_value = NULL;
623 entry->array_type = DBUS_TYPE_BYTE;
624
625 buffer = os_calloc(BYTE_ARRAY_CHUNK_SIZE, BYTE_ARRAY_ITEM_SIZE);
626 if (!buffer)
627 return FALSE;
628
629 entry->array_len = 0;
630 while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_BYTE) {
631 char byte;
632
633 if ((count % BYTE_ARRAY_CHUNK_SIZE) == 0 && count != 0) {
634 nbuffer = os_realloc_array(
635 buffer, count + BYTE_ARRAY_CHUNK_SIZE,
636 BYTE_ARRAY_ITEM_SIZE);
637 if (nbuffer == NULL) {
638 os_free(buffer);
639 wpa_printf(MSG_ERROR,
640 "dbus: %s out of memory trying to retrieve the string array",
641 __func__);
642 goto done;
643 }
644 buffer = nbuffer;
645 }
646
647 dbus_message_iter_get_basic(iter, &byte);
648 buffer[count] = byte;
649 entry->array_len = ++count;
650 dbus_message_iter_next(iter);
651 }
652 entry->bytearray_value = buffer;
653 wpa_hexdump_key(MSG_MSGDUMP, "dbus: byte array contents",
654 entry->bytearray_value, entry->array_len);
655
656 /* Zero-length arrays are valid. */
657 if (entry->array_len == 0) {
658 os_free(entry->bytearray_value);
659 entry->bytearray_value = NULL;
660 }
661
662 success = TRUE;
663
664 done:
665 return success;
666 }
667
668
669 #define STR_ARRAY_CHUNK_SIZE 8
670 #define STR_ARRAY_ITEM_SIZE (sizeof(char *))
671
_wpa_dbus_dict_entry_get_string_array(DBusMessageIter * iter,int array_type,struct wpa_dbus_dict_entry * entry)672 static dbus_bool_t _wpa_dbus_dict_entry_get_string_array(
673 DBusMessageIter *iter, int array_type,
674 struct wpa_dbus_dict_entry *entry)
675 {
676 dbus_uint32_t count = 0;
677 char **buffer, **nbuffer;
678
679 entry->strarray_value = NULL;
680 entry->array_len = 0;
681 entry->array_type = DBUS_TYPE_STRING;
682
683 buffer = os_calloc(STR_ARRAY_CHUNK_SIZE, STR_ARRAY_ITEM_SIZE);
684 if (buffer == NULL)
685 return FALSE;
686
687 while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRING) {
688 const char *value;
689 char *str;
690
691 if ((count % STR_ARRAY_CHUNK_SIZE) == 0 && count != 0) {
692 nbuffer = os_realloc_array(
693 buffer, count + STR_ARRAY_CHUNK_SIZE,
694 STR_ARRAY_ITEM_SIZE);
695 if (nbuffer == NULL) {
696 wpa_printf(MSG_ERROR,
697 "dbus: %s out of memory trying to retrieve the string array",
698 __func__);
699 goto fail;
700 }
701 buffer = nbuffer;
702 }
703
704 dbus_message_iter_get_basic(iter, &value);
705 wpa_printf(MSG_MSGDUMP, "%s: string_array value: %s",
706 __func__, wpa_debug_show_keys ? value : "[omitted]");
707 str = os_strdup(value);
708 if (str == NULL) {
709 wpa_printf(MSG_ERROR,
710 "dbus: %s out of memory trying to duplicate the string array",
711 __func__);
712 goto fail;
713 }
714 buffer[count++] = str;
715 dbus_message_iter_next(iter);
716 }
717 entry->strarray_value = buffer;
718 entry->array_len = count;
719 wpa_printf(MSG_MSGDUMP, "%s: string_array length %u",
720 __func__, entry->array_len);
721
722 /* Zero-length arrays are valid. */
723 if (entry->array_len == 0) {
724 os_free(entry->strarray_value);
725 entry->strarray_value = NULL;
726 }
727
728 return TRUE;
729
730 fail:
731 while (count > 0) {
732 count--;
733 os_free(buffer[count]);
734 }
735 os_free(buffer);
736 return FALSE;
737 }
738
739
740 #define BIN_ARRAY_CHUNK_SIZE 10
741 #define BIN_ARRAY_ITEM_SIZE (sizeof(struct wpabuf *))
742
_wpa_dbus_dict_entry_get_binarray(DBusMessageIter * iter,struct wpa_dbus_dict_entry * entry)743 static dbus_bool_t _wpa_dbus_dict_entry_get_binarray(
744 DBusMessageIter *iter, struct wpa_dbus_dict_entry *entry)
745 {
746 struct wpa_dbus_dict_entry tmpentry;
747 size_t buflen = 0;
748 int i, type;
749
750 entry->array_type = WPAS_DBUS_TYPE_BINARRAY;
751 entry->array_len = 0;
752 entry->binarray_value = NULL;
753
754 type = dbus_message_iter_get_arg_type(iter);
755 wpa_printf(MSG_MSGDUMP, "%s: parsing binarray type %c", __func__, type);
756 if (type == DBUS_TYPE_INVALID) {
757 /* Likely an empty array of arrays */
758 return TRUE;
759 }
760 if (type != DBUS_TYPE_ARRAY) {
761 wpa_printf(MSG_DEBUG, "%s: not an array type: %c",
762 __func__, type);
763 return FALSE;
764 }
765
766 type = dbus_message_iter_get_element_type(iter);
767 if (type != DBUS_TYPE_BYTE) {
768 wpa_printf(MSG_DEBUG, "%s: unexpected element type %c",
769 __func__, type);
770 return FALSE;
771 }
772
773 while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_ARRAY) {
774 DBusMessageIter iter_array;
775
776 if (entry->array_len == buflen) {
777 struct wpabuf **newbuf;
778
779 buflen += BIN_ARRAY_CHUNK_SIZE;
780
781 newbuf = os_realloc_array(entry->binarray_value,
782 buflen, BIN_ARRAY_ITEM_SIZE);
783 if (!newbuf)
784 goto cleanup;
785 entry->binarray_value = newbuf;
786 }
787
788 dbus_message_iter_recurse(iter, &iter_array);
789 os_memset(&tmpentry, 0, sizeof(tmpentry));
790 tmpentry.type = DBUS_TYPE_ARRAY;
791 if (_wpa_dbus_dict_entry_get_byte_array(&iter_array, &tmpentry)
792 == FALSE)
793 goto cleanup;
794
795 entry->binarray_value[entry->array_len] =
796 wpabuf_alloc_ext_data((u8 *) tmpentry.bytearray_value,
797 tmpentry.array_len);
798 if (entry->binarray_value[entry->array_len] == NULL) {
799 wpa_dbus_dict_entry_clear(&tmpentry);
800 goto cleanup;
801 }
802 entry->array_len++;
803 dbus_message_iter_next(iter);
804 }
805 wpa_printf(MSG_MSGDUMP, "%s: binarray length %u",
806 __func__, entry->array_len);
807
808 return TRUE;
809
810 cleanup:
811 for (i = 0; i < (int) entry->array_len; i++)
812 wpabuf_free(entry->binarray_value[i]);
813 os_free(entry->binarray_value);
814 entry->array_len = 0;
815 entry->binarray_value = NULL;
816 return FALSE;
817 }
818
819
_wpa_dbus_dict_entry_get_array(DBusMessageIter * iter_dict_val,struct wpa_dbus_dict_entry * entry)820 static dbus_bool_t _wpa_dbus_dict_entry_get_array(
821 DBusMessageIter *iter_dict_val, struct wpa_dbus_dict_entry *entry)
822 {
823 int array_type = dbus_message_iter_get_element_type(iter_dict_val);
824 dbus_bool_t success = FALSE;
825 DBusMessageIter iter_array;
826
827 wpa_printf(MSG_MSGDUMP, "%s: array_type %c", __func__, array_type);
828
829 dbus_message_iter_recurse(iter_dict_val, &iter_array);
830
831 switch (array_type) {
832 case DBUS_TYPE_BYTE:
833 success = _wpa_dbus_dict_entry_get_byte_array(&iter_array,
834 entry);
835 break;
836 case DBUS_TYPE_STRING:
837 success = _wpa_dbus_dict_entry_get_string_array(&iter_array,
838 array_type,
839 entry);
840 break;
841 case DBUS_TYPE_ARRAY:
842 success = _wpa_dbus_dict_entry_get_binarray(&iter_array, entry);
843 break;
844 default:
845 wpa_printf(MSG_MSGDUMP, "%s: unsupported array type %c",
846 __func__, array_type);
847 break;
848 }
849
850 return success;
851 }
852
853
_wpa_dbus_dict_fill_value_from_variant(struct wpa_dbus_dict_entry * entry,DBusMessageIter * iter)854 static dbus_bool_t _wpa_dbus_dict_fill_value_from_variant(
855 struct wpa_dbus_dict_entry *entry, DBusMessageIter *iter)
856 {
857 const char *v;
858
859 switch (entry->type) {
860 case DBUS_TYPE_OBJECT_PATH:
861 dbus_message_iter_get_basic(iter, &v);
862 wpa_printf(MSG_MSGDUMP, "%s: object path value: %s",
863 __func__, v);
864 entry->str_value = os_strdup(v);
865 if (entry->str_value == NULL)
866 return FALSE;
867 break;
868 case DBUS_TYPE_STRING:
869 dbus_message_iter_get_basic(iter, &v);
870 wpa_printf(MSG_MSGDUMP, "%s: string value: %s",
871 __func__, wpa_debug_show_keys ? v : "[omitted]");
872 entry->str_value = os_strdup(v);
873 if (entry->str_value == NULL)
874 return FALSE;
875 break;
876 case DBUS_TYPE_BOOLEAN:
877 dbus_message_iter_get_basic(iter, &entry->bool_value);
878 wpa_printf(MSG_MSGDUMP, "%s: boolean value: %d",
879 __func__, entry->bool_value);
880 break;
881 case DBUS_TYPE_BYTE:
882 dbus_message_iter_get_basic(iter, &entry->byte_value);
883 wpa_printf(MSG_MSGDUMP, "%s: byte value: %d",
884 __func__, entry->byte_value);
885 break;
886 case DBUS_TYPE_INT16:
887 dbus_message_iter_get_basic(iter, &entry->int16_value);
888 wpa_printf(MSG_MSGDUMP, "%s: int16 value: %d",
889 __func__, entry->int16_value);
890 break;
891 case DBUS_TYPE_UINT16:
892 dbus_message_iter_get_basic(iter, &entry->uint16_value);
893 wpa_printf(MSG_MSGDUMP, "%s: uint16 value: %d",
894 __func__, entry->uint16_value);
895 break;
896 case DBUS_TYPE_INT32:
897 dbus_message_iter_get_basic(iter, &entry->int32_value);
898 wpa_printf(MSG_MSGDUMP, "%s: int32 value: %d",
899 __func__, entry->int32_value);
900 break;
901 case DBUS_TYPE_UINT32:
902 dbus_message_iter_get_basic(iter, &entry->uint32_value);
903 wpa_printf(MSG_MSGDUMP, "%s: uint32 value: %d",
904 __func__, entry->uint32_value);
905 break;
906 case DBUS_TYPE_INT64:
907 dbus_message_iter_get_basic(iter, &entry->int64_value);
908 wpa_printf(MSG_MSGDUMP, "%s: int64 value: %lld",
909 __func__, (long long int) entry->int64_value);
910 break;
911 case DBUS_TYPE_UINT64:
912 dbus_message_iter_get_basic(iter, &entry->uint64_value);
913 wpa_printf(MSG_MSGDUMP, "%s: uint64 value: %llu",
914 __func__,
915 (unsigned long long int) entry->uint64_value);
916 break;
917 case DBUS_TYPE_DOUBLE:
918 dbus_message_iter_get_basic(iter, &entry->double_value);
919 wpa_printf(MSG_MSGDUMP, "%s: double value: %f",
920 __func__, entry->double_value);
921 break;
922 case DBUS_TYPE_ARRAY:
923 return _wpa_dbus_dict_entry_get_array(iter, entry);
924 default:
925 wpa_printf(MSG_MSGDUMP, "%s: unsupported type %c",
926 __func__, entry->type);
927 return FALSE;
928 }
929
930 return TRUE;
931 }
932
933
934 /**
935 * Read the current key/value entry from the dict. Entries are dynamically
936 * allocated when needed and must be freed after use with the
937 * wpa_dbus_dict_entry_clear() function.
938 *
939 * The returned entry object will be filled with the type and value of the next
940 * entry in the dict, or the type will be DBUS_TYPE_INVALID if an error
941 * occurred.
942 *
943 * @param iter_dict A valid DBusMessageIter returned from
944 * wpa_dbus_dict_open_read()
945 * @param entry A valid dict entry object into which the dict key and value
946 * will be placed
947 * @return TRUE on success, FALSE on failure
948 *
949 */
wpa_dbus_dict_get_entry(DBusMessageIter * iter_dict,struct wpa_dbus_dict_entry * entry)950 dbus_bool_t wpa_dbus_dict_get_entry(DBusMessageIter *iter_dict,
951 struct wpa_dbus_dict_entry * entry)
952 {
953 DBusMessageIter iter_dict_entry, iter_dict_val;
954 int type;
955 const char *key;
956
957 if (!iter_dict || !entry ||
958 dbus_message_iter_get_arg_type(iter_dict) != DBUS_TYPE_DICT_ENTRY) {
959 wpa_printf(MSG_DEBUG, "%s: not a dict entry", __func__);
960 goto error;
961 }
962
963 dbus_message_iter_recurse(iter_dict, &iter_dict_entry);
964 dbus_message_iter_get_basic(&iter_dict_entry, &key);
965 wpa_printf(MSG_MSGDUMP, "%s: dict entry key: %s", __func__, key);
966 entry->key = key;
967
968 if (!dbus_message_iter_next(&iter_dict_entry)) {
969 wpa_printf(MSG_DEBUG, "%s: no variant in dict entry", __func__);
970 goto error;
971 }
972 type = dbus_message_iter_get_arg_type(&iter_dict_entry);
973 if (type != DBUS_TYPE_VARIANT) {
974 wpa_printf(MSG_DEBUG,
975 "%s: unexpected dict entry variant type: %c",
976 __func__, type);
977 goto error;
978 }
979
980 dbus_message_iter_recurse(&iter_dict_entry, &iter_dict_val);
981 entry->type = dbus_message_iter_get_arg_type(&iter_dict_val);
982 wpa_printf(MSG_MSGDUMP, "%s: dict entry variant content type: %c",
983 __func__, entry->type);
984 entry->array_type = DBUS_TYPE_INVALID;
985 if (!_wpa_dbus_dict_fill_value_from_variant(entry, &iter_dict_val)) {
986 wpa_printf(MSG_DEBUG,
987 "%s: failed to fetch dict values from variant",
988 __func__);
989 goto error;
990 }
991
992 dbus_message_iter_next(iter_dict);
993 return TRUE;
994
995 error:
996 if (entry) {
997 wpa_dbus_dict_entry_clear(entry);
998 entry->type = DBUS_TYPE_INVALID;
999 entry->array_type = DBUS_TYPE_INVALID;
1000 }
1001
1002 return FALSE;
1003 }
1004
1005
1006 /**
1007 * Return whether or not there are additional dictionary entries.
1008 *
1009 * @param iter_dict A valid DBusMessageIter returned from
1010 * wpa_dbus_dict_open_read()
1011 * @return TRUE if more dict entries exists, FALSE if no more dict entries
1012 * exist
1013 */
wpa_dbus_dict_has_dict_entry(DBusMessageIter * iter_dict)1014 dbus_bool_t wpa_dbus_dict_has_dict_entry(DBusMessageIter *iter_dict)
1015 {
1016 if (!iter_dict)
1017 return FALSE;
1018 return dbus_message_iter_get_arg_type(iter_dict) ==
1019 DBUS_TYPE_DICT_ENTRY;
1020 }
1021
1022
1023 /**
1024 * Free any memory used by the entry object.
1025 *
1026 * @param entry The entry object
1027 */
wpa_dbus_dict_entry_clear(struct wpa_dbus_dict_entry * entry)1028 void wpa_dbus_dict_entry_clear(struct wpa_dbus_dict_entry *entry)
1029 {
1030 unsigned int i;
1031
1032 if (!entry)
1033 return;
1034 switch (entry->type) {
1035 case DBUS_TYPE_OBJECT_PATH:
1036 case DBUS_TYPE_STRING:
1037 os_free(entry->str_value);
1038 break;
1039 case DBUS_TYPE_ARRAY:
1040 switch (entry->array_type) {
1041 case DBUS_TYPE_BYTE:
1042 os_free(entry->bytearray_value);
1043 break;
1044 case DBUS_TYPE_STRING:
1045 if (!entry->strarray_value)
1046 break;
1047 for (i = 0; i < entry->array_len; i++)
1048 os_free(entry->strarray_value[i]);
1049 os_free(entry->strarray_value);
1050 break;
1051 case WPAS_DBUS_TYPE_BINARRAY:
1052 for (i = 0; i < entry->array_len; i++)
1053 wpabuf_free(entry->binarray_value[i]);
1054 os_free(entry->binarray_value);
1055 break;
1056 }
1057 break;
1058 }
1059
1060 os_memset(entry, 0, sizeof(struct wpa_dbus_dict_entry));
1061 }
1062
