2 * WPA Supplicant / dbus-based control interface (WPS)
3 * Copyright (c) 2006, Dan Williams <dcbw@redhat.com> and Red Hat, Inc.
4 * Copyright (c) 2009, Witold Sowa <witold.sowa@gmail.com>
6 * This software may be distributed under the terms of the BSD license.
7 * See README for more details.
13 #include "../config.h"
14 #include "../wpa_supplicant_i.h"
15 #include "../wps_supplicant.h"
16 #include "../driver_i.h"
18 #include "dbus_new_helpers.h"
20 #include "dbus_new_handlers.h"
21 #include "dbus_dict_helpers.h"
24 struct wps_start_params {
25 int role; /* 0 - not set, 1 - enrollee, 2 - registrar */
26 int type; /* 0 - not set, 1 - pin, 2 - pbc */
33 static int wpas_dbus_handler_wps_role(DBusMessage *message,
34 DBusMessageIter *entry_iter,
35 struct wps_start_params *params,
38 DBusMessageIter variant_iter;
41 dbus_message_iter_recurse(entry_iter, &variant_iter);
42 if (dbus_message_iter_get_arg_type(&variant_iter) !=
45 "dbus: WPS.Start - Wrong Role type, string required");
46 *reply = wpas_dbus_error_invalid_args(message,
47 "Role must be a string");
50 dbus_message_iter_get_basic(&variant_iter, &val);
51 if (os_strcmp(val, "enrollee") == 0)
53 else if (os_strcmp(val, "registrar") == 0)
56 wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Unknown role %s", val);
57 *reply = wpas_dbus_error_invalid_args(message, val);
64 static int wpas_dbus_handler_wps_type(DBusMessage *message,
65 DBusMessageIter *entry_iter,
66 struct wps_start_params *params,
69 DBusMessageIter variant_iter;
72 dbus_message_iter_recurse(entry_iter, &variant_iter);
73 if (dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING) {
75 "dbus: WPS.Start - Wrong Type type, string required");
76 *reply = wpas_dbus_error_invalid_args(message,
77 "Type must be a string");
80 dbus_message_iter_get_basic(&variant_iter, &val);
81 if (os_strcmp(val, "pin") == 0)
83 else if (os_strcmp(val, "pbc") == 0)
86 wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Unknown type %s",
88 *reply = wpas_dbus_error_invalid_args(message, val);
95 static int wpas_dbus_handler_wps_bssid(DBusMessage *message,
96 DBusMessageIter *entry_iter,
97 struct wps_start_params *params,
100 DBusMessageIter variant_iter, array_iter;
103 dbus_message_iter_recurse(entry_iter, &variant_iter);
104 if (dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_ARRAY ||
105 dbus_message_iter_get_element_type(&variant_iter) !=
107 wpa_printf(MSG_DEBUG,
108 "dbus: WPS.Start - Wrong Bssid type, byte array required");
109 *reply = wpas_dbus_error_invalid_args(
110 message, "Bssid must be a byte array");
113 dbus_message_iter_recurse(&variant_iter, &array_iter);
114 dbus_message_iter_get_fixed_array(&array_iter, ¶ms->bssid, &len);
115 if (len != ETH_ALEN) {
116 wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Wrong Bssid length %d",
118 *reply = wpas_dbus_error_invalid_args(message,
119 "Bssid is wrong length");
126 static int wpas_dbus_handler_wps_pin(DBusMessage *message,
127 DBusMessageIter *entry_iter,
128 struct wps_start_params *params,
131 DBusMessageIter variant_iter;
133 dbus_message_iter_recurse(entry_iter, &variant_iter);
134 if (dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING) {
135 wpa_printf(MSG_DEBUG,
136 "dbus: WPS.Start - Wrong Pin type, string required");
137 *reply = wpas_dbus_error_invalid_args(message,
138 "Pin must be a string");
141 dbus_message_iter_get_basic(&variant_iter, ¶ms->pin);
147 static int wpas_dbus_handler_wps_p2p_dev_addr(DBusMessage *message,
148 DBusMessageIter *entry_iter,
149 struct wps_start_params *params,
152 DBusMessageIter variant_iter, array_iter;
155 dbus_message_iter_recurse(entry_iter, &variant_iter);
156 if (dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_ARRAY ||
157 dbus_message_iter_get_element_type(&variant_iter) !=
159 wpa_printf(MSG_DEBUG,
160 "dbus: WPS.Start - Wrong P2PDeviceAddress type, byte array required");
161 *reply = wpas_dbus_error_invalid_args(
162 message, "P2PDeviceAddress must be a byte array");
165 dbus_message_iter_recurse(&variant_iter, &array_iter);
166 dbus_message_iter_get_fixed_array(&array_iter, ¶ms->p2p_dev_addr,
168 if (len != ETH_ALEN) {
169 wpa_printf(MSG_DEBUG,
170 "dbus: WPS.Start - Wrong P2PDeviceAddress length %d",
172 *reply = wpas_dbus_error_invalid_args(
173 message, "P2PDeviceAddress has wrong length");
178 #endif /* CONFIG_P2P */
181 static int wpas_dbus_handler_wps_start_entry(DBusMessage *message, char *key,
182 DBusMessageIter *entry_iter,
183 struct wps_start_params *params,
186 if (os_strcmp(key, "Role") == 0)
187 return wpas_dbus_handler_wps_role(message, entry_iter,
189 else if (os_strcmp(key, "Type") == 0)
190 return wpas_dbus_handler_wps_type(message, entry_iter,
192 else if (os_strcmp(key, "Bssid") == 0)
193 return wpas_dbus_handler_wps_bssid(message, entry_iter,
195 else if (os_strcmp(key, "Pin") == 0)
196 return wpas_dbus_handler_wps_pin(message, entry_iter,
199 else if (os_strcmp(key, "P2PDeviceAddress") == 0)
200 return wpas_dbus_handler_wps_p2p_dev_addr(message, entry_iter,
202 #endif /* CONFIG_P2P */
204 wpa_printf(MSG_DEBUG, "dbus: WPS.Start - unknown key %s", key);
205 *reply = wpas_dbus_error_invalid_args(message, key);
211 * wpas_dbus_handler_wps_start - Start WPS configuration
212 * @message: Pointer to incoming dbus message
213 * @wpa_s: %wpa_supplicant data structure
214 * Returns: DBus message dictionary on success or DBus error on failure
216 * Handler for "Start" method call. DBus dictionary argument contains
217 * information about role (enrollee or registrar), authorization method
218 * (pin or push button) and optionally pin and bssid. Returned message
219 * has a dictionary argument which may contain newly generated pin (optional).
221 DBusMessage * wpas_dbus_handler_wps_start(DBusMessage *message,
222 struct wpa_supplicant *wpa_s)
224 DBusMessage *reply = NULL;
225 DBusMessageIter iter, dict_iter, entry_iter;
226 struct wps_start_params params;
228 char npin[9] = { '\0' };
231 os_memset(¶ms, 0, sizeof(params));
232 dbus_message_iter_init(message, &iter);
234 dbus_message_iter_recurse(&iter, &dict_iter);
235 while (dbus_message_iter_get_arg_type(&dict_iter) ==
236 DBUS_TYPE_DICT_ENTRY) {
237 dbus_message_iter_recurse(&dict_iter, &entry_iter);
239 dbus_message_iter_get_basic(&entry_iter, &key);
240 dbus_message_iter_next(&entry_iter);
242 if (wpas_dbus_handler_wps_start_entry(message, key,
247 dbus_message_iter_next(&dict_iter);
251 if (wpa_s->ap_iface && params.type == 1) {
252 if (params.pin == NULL) {
253 wpa_printf(MSG_DEBUG,
254 "dbus: WPS.Start - Pin required for registrar role");
255 return wpas_dbus_error_invalid_args(
256 message, "Pin required for registrar role.");
258 ret = wpa_supplicant_ap_wps_pin(wpa_s,
261 npin, sizeof(npin), 0);
262 } else if (wpa_s->ap_iface) {
263 ret = wpa_supplicant_ap_wps_pbc(wpa_s,
265 params.p2p_dev_addr);
267 #endif /* CONFIG_AP */
268 if (params.role == 0) {
269 wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Role not specified");
270 return wpas_dbus_error_invalid_args(message,
271 "Role not specified");
272 } else if (params.role == 2) {
273 if (params.pin == NULL) {
274 wpa_printf(MSG_DEBUG,
275 "dbus: WPS.Start - Pin required for registrar role");
276 return wpas_dbus_error_invalid_args(
277 message, "Pin required for registrar role.");
279 ret = wpas_wps_start_reg(wpa_s, params.bssid, params.pin,
281 } else if (params.type == 0) {
282 wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Type not specified");
283 return wpas_dbus_error_invalid_args(message,
284 "Type not specified");
285 } else if (params.type == 1) {
286 ret = wpas_wps_start_pin(wpa_s, params.bssid,
290 os_snprintf(npin, sizeof(npin), "%08d", ret);
292 ret = wpas_wps_start_pbc(wpa_s, params.bssid, 0);
296 wpa_printf(MSG_DEBUG,
297 "dbus: WPS.Start wpas_wps_failed in role %s and key %s",
298 (params.role == 1 ? "enrollee" : "registrar"),
299 (params.type == 0 ? "" :
300 (params.type == 1 ? "pin" : "pbc")));
301 return wpas_dbus_error_unknown_error(message,
305 reply = dbus_message_new_method_return(message);
307 return wpas_dbus_error_no_memory(message);
309 dbus_message_iter_init_append(reply, &iter);
310 if (!wpa_dbus_dict_open_write(&iter, &dict_iter) ||
311 (os_strlen(npin) > 0 &&
312 !wpa_dbus_dict_append_string(&dict_iter, "Pin", npin)) ||
313 !wpa_dbus_dict_close_write(&iter, &dict_iter)) {
314 dbus_message_unref(reply);
315 return wpas_dbus_error_no_memory(message);
323 * wpas_dbus_handler_wps_cancel - Cancel ongoing WPS configuration
324 * @message: Pointer to incoming dbus message
325 * @wpa_s: %wpa_supplicant data structure
326 * Returns: NULL on success or DBus error on failure
328 * Handler for "Cancel" method call. Returns NULL if WPS cancel successful
329 * or DBus error on WPS cancel failure
331 DBusMessage * wpas_dbus_handler_wps_cancel(DBusMessage *message,
332 struct wpa_supplicant *wpa_s)
334 if (wpas_wps_cancel(wpa_s))
335 return wpas_dbus_error_unknown_error(message,
336 "WPS cancel failed");
343 * wpas_dbus_getter_process_credentials - Check if credentials are processed
344 * @message: Pointer to incoming dbus message
345 * @wpa_s: %wpa_supplicant data structure
346 * Returns: TRUE on success, FALSE on failure
348 * Getter for "ProcessCredentials" property. Returns returned boolean will be
349 * true if wps_cred_processing configuration field is not equal to 1 or false
352 dbus_bool_t wpas_dbus_getter_process_credentials(
353 const struct wpa_dbus_property_desc *property_desc,
354 DBusMessageIter *iter, DBusError *error, void *user_data)
356 struct wpa_supplicant *wpa_s = user_data;
357 dbus_bool_t process = wpa_s->conf->wps_cred_processing != 1;
359 return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
365 * wpas_dbus_setter_process_credentials - Set credentials_processed conf param
366 * @iter: Pointer to incoming dbus message iter
367 * @error: Location to store error on failure
368 * @user_data: Function specific data
369 * Returns: TRUE on success, FALSE on failure
371 * Setter for "ProcessCredentials" property. Sets credentials_processed on 2
372 * if boolean argument is true or on 1 if otherwise.
374 dbus_bool_t wpas_dbus_setter_process_credentials(
375 const struct wpa_dbus_property_desc *property_desc,
376 DBusMessageIter *iter, DBusError *error, void *user_data)
378 struct wpa_supplicant *wpa_s = user_data;
379 dbus_bool_t process_credentials, old_pc;
381 if (!wpa_s->dbus_new_path)
383 if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN,
384 &process_credentials))
387 old_pc = wpa_s->conf->wps_cred_processing != 1;
388 wpa_s->conf->wps_cred_processing = (process_credentials ? 2 : 1);
390 if ((wpa_s->conf->wps_cred_processing != 1) != old_pc)
391 wpa_dbus_mark_property_changed(wpa_s->global->dbus,
392 wpa_s->dbus_new_path,
393 WPAS_DBUS_NEW_IFACE_WPS,
394 "ProcessCredentials");
401 * wpas_dbus_getter_config_methods - Get current WPS configuration methods
402 * @iter: Pointer to incoming dbus message iter
403 * @error: Location to store error on failure
404 * @user_data: Function specific data
405 * Returns: TRUE on success, FALSE on failure
407 * Getter for "ConfigMethods" property. Returned boolean will be true if
408 * providing the relevant string worked, or false otherwise.
410 dbus_bool_t wpas_dbus_getter_config_methods(
411 const struct wpa_dbus_property_desc *property_desc,
412 DBusMessageIter *iter, DBusError *error, void *user_data)
414 struct wpa_supplicant *wpa_s = user_data;
416 return wpas_dbus_string_property_getter(iter,
417 wpa_s->conf->config_methods,
423 * wpas_dbus_setter_config_methods - Set WPS configuration methods
424 * @iter: Pointer to incoming dbus message iter
425 * @error: Location to store error on failure
426 * @user_data: Function specific data
427 * Returns: TRUE on success, FALSE on failure
429 * Setter for "ConfigMethods" property. Sets the methods string, apply such
430 * change and returns true on success. Returns false otherwise.
432 dbus_bool_t wpas_dbus_setter_config_methods(
433 const struct wpa_dbus_property_desc *property_desc,
434 DBusMessageIter *iter, DBusError *error, void *user_data)
436 struct wpa_supplicant *wpa_s = user_data;
437 char *methods, *new_methods;
439 if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
443 new_methods = os_strdup(methods);
447 os_free(wpa_s->conf->config_methods);
448 wpa_s->conf->config_methods = new_methods;
450 wpa_s->conf->changed_parameters |= CFG_CHANGED_CONFIG_METHODS;
451 wpa_supplicant_update_config(wpa_s);
458 * wpas_dbus_getter_wps_device_name - Get current WPS device name
459 * @iter: Pointer to incoming dbus message iter
460 * @error: Location to store error on failure
461 * @user_data: Function specific data
462 * Returns: TRUE on success, FALSE on failure
464 * Getter for "DeviceName" property.
466 dbus_bool_t wpas_dbus_getter_wps_device_name(
467 const struct wpa_dbus_property_desc *property_desc,
468 DBusMessageIter *iter, DBusError *error, void *user_data)
470 struct wpa_supplicant *wpa_s = user_data;
472 return wpas_dbus_string_property_getter(iter, wpa_s->conf->device_name,
478 * wpas_dbus_setter_wps_device_name - Set current WPS device name
479 * @iter: Pointer to incoming dbus message iter
480 * @error: Location to store error on failure
481 * @user_data: Function specific data
482 * Returns: TRUE on success, FALSE on failure
484 * Setter for "DeviceName" property.
486 dbus_bool_t wpas_dbus_setter_wps_device_name(
487 const struct wpa_dbus_property_desc *property_desc,
488 DBusMessageIter *iter, DBusError *error, void *user_data)
490 struct wpa_supplicant *wpa_s = user_data;
491 char *methods, *devname;
493 if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
497 if (os_strlen(methods) > WPS_DEV_NAME_MAX_LEN)
500 devname = os_strdup(methods);
504 os_free(wpa_s->conf->device_name);
505 wpa_s->conf->device_name = devname;
506 wpa_s->conf->changed_parameters |= CFG_CHANGED_DEVICE_NAME;
507 wpa_supplicant_update_config(wpa_s);
514 * wpas_dbus_getter_wps_manufacturer - Get current manufacturer name
515 * @iter: Pointer to incoming dbus message iter
516 * @error: Location to store error on failure
517 * @user_data: Function specific data
518 * Returns: TRUE on success, FALSE on failure
520 * Getter for "Manufacturer" property.
522 dbus_bool_t wpas_dbus_getter_wps_manufacturer(
523 const struct wpa_dbus_property_desc *property_desc,
524 DBusMessageIter *iter, DBusError *error, void *user_data)
526 struct wpa_supplicant *wpa_s = user_data;
528 return wpas_dbus_string_property_getter(iter, wpa_s->conf->manufacturer,
534 * wpas_dbus_setter_wps_manufacturer - Set current manufacturer name
535 * @iter: Pointer to incoming dbus message iter
536 * @error: Location to store error on failure
537 * @user_data: Function specific data
538 * Returns: TRUE on success, FALSE on failure
540 * Setter for "Manufacturer" property.
542 dbus_bool_t wpas_dbus_setter_wps_manufacturer(
543 const struct wpa_dbus_property_desc *property_desc,
544 DBusMessageIter *iter, DBusError *error, void *user_data)
546 struct wpa_supplicant *wpa_s = user_data;
547 char *methods, *manufacturer;
549 if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
553 if (os_strlen(methods) > WPS_MANUFACTURER_MAX_LEN)
556 manufacturer = os_strdup(methods);
560 os_free(wpa_s->conf->manufacturer);
561 wpa_s->conf->manufacturer = manufacturer;
562 wpa_s->conf->changed_parameters |= CFG_CHANGED_WPS_STRING;
563 wpa_supplicant_update_config(wpa_s);
570 * wpas_dbus_getter_wps_device_model_name - Get current device model name
571 * @iter: Pointer to incoming dbus message iter
572 * @error: Location to store error on failure
573 * @user_data: Function specific data
574 * Returns: TRUE on success, FALSE on failure
576 * Getter for "ModelName" property.
578 dbus_bool_t wpas_dbus_getter_wps_device_model_name(
579 const struct wpa_dbus_property_desc *property_desc,
580 DBusMessageIter *iter, DBusError *error, void *user_data)
582 struct wpa_supplicant *wpa_s = user_data;
584 return wpas_dbus_string_property_getter(iter, wpa_s->conf->model_name,
590 * wpas_dbus_setter_wps_device_model_name - Set current device model name
591 * @iter: Pointer to incoming dbus message iter
592 * @error: Location to store error on failure
593 * @user_data: Function specific data
594 * Returns: TRUE on success, FALSE on failure
596 * Setter for "ModelName" property.
598 dbus_bool_t wpas_dbus_setter_wps_device_model_name(
599 const struct wpa_dbus_property_desc *property_desc,
600 DBusMessageIter *iter, DBusError *error, void *user_data)
602 struct wpa_supplicant *wpa_s = user_data;
603 char *methods, *model_name;
605 if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
609 if (os_strlen(methods) > WPS_MODEL_NAME_MAX_LEN)
612 model_name = os_strdup(methods);
615 os_free(wpa_s->conf->model_name);
616 wpa_s->conf->model_name = model_name;
617 wpa_s->conf->changed_parameters |= CFG_CHANGED_WPS_STRING;
618 wpa_supplicant_update_config(wpa_s);
625 * wpas_dbus_getter_wps_device_model_number - Get current device model number
626 * @iter: Pointer to incoming dbus message iter
627 * @error: Location to store error on failure
628 * @user_data: Function specific data
629 * Returns: TRUE on success, FALSE on failure
631 * Getter for "ModelNumber" property.
633 dbus_bool_t wpas_dbus_getter_wps_device_model_number(
634 const struct wpa_dbus_property_desc *property_desc,
635 DBusMessageIter *iter, DBusError *error, void *user_data)
637 struct wpa_supplicant *wpa_s = user_data;
639 return wpas_dbus_string_property_getter(iter, wpa_s->conf->model_number,
645 * wpas_dbus_setter_wps_device_model_number - Set current device model number
646 * @iter: Pointer to incoming dbus message iter
647 * @error: Location to store error on failure
648 * @user_data: Function specific data
649 * Returns: TRUE on success, FALSE on failure
651 * Setter for "ModelNumber" property.
653 dbus_bool_t wpas_dbus_setter_wps_device_model_number(
654 const struct wpa_dbus_property_desc *property_desc,
655 DBusMessageIter *iter, DBusError *error, void *user_data)
657 struct wpa_supplicant *wpa_s = user_data;
658 char *methods, *model_number;
660 if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
664 if (os_strlen(methods) > WPS_MODEL_NUMBER_MAX_LEN)
667 model_number = os_strdup(methods);
671 os_free(wpa_s->conf->model_number);
672 wpa_s->conf->model_number = model_number;
673 wpa_s->conf->changed_parameters |= CFG_CHANGED_WPS_STRING;
674 wpa_supplicant_update_config(wpa_s);
681 * wpas_dbus_getter_wps_device_serial_number - Get current device serial number
682 * @iter: Pointer to incoming dbus message iter
683 * @error: Location to store error on failure
684 * @user_data: Function specific data
685 * Returns: TRUE on success, FALSE on failure
687 * Getter for "SerialNumber" property.
689 dbus_bool_t wpas_dbus_getter_wps_device_serial_number(
690 const struct wpa_dbus_property_desc *property_desc,
691 DBusMessageIter *iter, DBusError *error, void *user_data)
693 struct wpa_supplicant *wpa_s = user_data;
695 return wpas_dbus_string_property_getter(iter,
696 wpa_s->conf->serial_number,
702 * wpas_dbus_setter_wps_device_serial_number - Set current device serial number
703 * @iter: Pointer to incoming dbus message iter
704 * @error: Location to store error on failure
705 * @user_data: Function specific data
706 * Returns: TRUE on success, FALSE on failure
708 * Setter for "SerialNumber" property.
710 dbus_bool_t wpas_dbus_setter_wps_device_serial_number(
711 const struct wpa_dbus_property_desc *property_desc,
712 DBusMessageIter *iter, DBusError *error, void *user_data)
714 struct wpa_supplicant *wpa_s = user_data;
715 char *methods, *serial_number;
717 if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
721 if (os_strlen(methods) > WPS_SERIAL_NUMBER_MAX_LEN)
724 serial_number = os_strdup(methods);
727 os_free(wpa_s->conf->serial_number);
728 wpa_s->conf->serial_number = serial_number;
729 wpa_s->conf->changed_parameters |= CFG_CHANGED_WPS_STRING;
730 wpa_supplicant_update_config(wpa_s);
737 * wpas_dbus_getter_wps_device_device_type - Get current device type
738 * @iter: Pointer to incoming dbus message iter
739 * @error: Location to store error on failure
740 * @user_data: Function specific data
741 * Returns: TRUE on success, FALSE on failure
743 * Getter for "DeviceType" property.
745 dbus_bool_t wpas_dbus_getter_wps_device_device_type(
746 const struct wpa_dbus_property_desc *property_desc,
747 DBusMessageIter *iter, DBusError *error, void *user_data)
749 struct wpa_supplicant *wpa_s = user_data;
751 if (!wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
753 wpa_s->conf->device_type,
754 WPS_DEV_TYPE_LEN, error)) {
755 dbus_set_error(error, DBUS_ERROR_FAILED,
756 "%s: error constructing reply", __func__);
765 * wpas_dbus_setter_wps_device_device_type - Set current device type
766 * @iter: Pointer to incoming dbus message iter
767 * @error: Location to store error on failure
768 * @user_data: Function specific data
769 * Returns: TRUE on success, FALSE on failure
771 * Setter for "DeviceType" property.
773 dbus_bool_t wpas_dbus_setter_wps_device_device_type(
774 const struct wpa_dbus_property_desc *property_desc,
775 DBusMessageIter *iter, DBusError *error, void *user_data)
777 struct wpa_supplicant *wpa_s = user_data;
780 DBusMessageIter variant, array_iter;
782 if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_VARIANT)
785 dbus_message_iter_recurse(iter, &variant);
786 if (dbus_message_iter_get_arg_type(&variant) != DBUS_TYPE_ARRAY)
789 dbus_message_iter_recurse(&variant, &array_iter);
790 dbus_message_iter_get_fixed_array(&array_iter, &dev_type, &dev_len);
792 if (dev_len != WPS_DEV_TYPE_LEN)
795 os_memcpy(wpa_s->conf->device_type, dev_type, WPS_DEV_TYPE_LEN);
796 wpa_s->conf->changed_parameters |= CFG_CHANGED_DEVICE_TYPE;
797 wpa_supplicant_update_config(wpa_s);