1 /*
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>
5  *
6  * This software may be distributed under the terms of the BSD license.
7  * See README for more details.
8  */
9 
10 #include "includes.h"
11 
12 #include "common.h"
13 #include "../config.h"
14 #include "../wpa_supplicant_i.h"
15 #include "../wps_supplicant.h"
16 #include "../driver_i.h"
17 #include "../ap.h"
18 #include "dbus_new_helpers.h"
19 #include "dbus_new.h"
20 #include "dbus_new_handlers.h"
21 #include "dbus_dict_helpers.h"
22 
23 
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       */
27 	u8 *bssid;
28 	char *pin;
29 	u8 *p2p_dev_addr;
30 };
31 
32 
wpas_dbus_handler_wps_role(DBusMessage * message,DBusMessageIter * entry_iter,struct wps_start_params * params,DBusMessage ** reply)33 static int wpas_dbus_handler_wps_role(DBusMessage *message,
34 				      DBusMessageIter *entry_iter,
35 				      struct wps_start_params *params,
36 				      DBusMessage **reply)
37 {
38 	DBusMessageIter variant_iter;
39 	char *val;
40 
41 	dbus_message_iter_recurse(entry_iter, &variant_iter);
42 	if (dbus_message_iter_get_arg_type(&variant_iter) !=
43 	    DBUS_TYPE_STRING) {
44 		wpa_printf(MSG_DEBUG,
45 			   "dbus: WPS.Start - Wrong Role type, string required");
46 		*reply = wpas_dbus_error_invalid_args(message,
47 						      "Role must be a string");
48 		return -1;
49 	}
50 	dbus_message_iter_get_basic(&variant_iter, &val);
51 	if (os_strcmp(val, "enrollee") == 0)
52 		params->role = 1;
53 	else if (os_strcmp(val, "registrar") == 0)
54 		params->role = 2;
55 	else {
56 		wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Unknown role %s", val);
57 		*reply = wpas_dbus_error_invalid_args(message, val);
58 		return -1;
59 	}
60 	return 0;
61 }
62 
63 
wpas_dbus_handler_wps_type(DBusMessage * message,DBusMessageIter * entry_iter,struct wps_start_params * params,DBusMessage ** reply)64 static int wpas_dbus_handler_wps_type(DBusMessage *message,
65 				      DBusMessageIter *entry_iter,
66 				      struct wps_start_params *params,
67 				      DBusMessage **reply)
68 {
69 	DBusMessageIter variant_iter;
70 	char *val;
71 
72 	dbus_message_iter_recurse(entry_iter, &variant_iter);
73 	if (dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING) {
74 		wpa_printf(MSG_DEBUG,
75 			   "dbus: WPS.Start - Wrong Type type, string required");
76 		*reply = wpas_dbus_error_invalid_args(message,
77 						      "Type must be a string");
78 		return -1;
79 	}
80 	dbus_message_iter_get_basic(&variant_iter, &val);
81 	if (os_strcmp(val, "pin") == 0)
82 		params->type = 1;
83 	else if (os_strcmp(val, "pbc") == 0)
84 		params->type = 2;
85 	else {
86 		wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Unknown type %s",
87 			   val);
88 		*reply = wpas_dbus_error_invalid_args(message, val);
89 		return -1;
90 	}
91 	return 0;
92 }
93 
94 
wpas_dbus_handler_wps_bssid(DBusMessage * message,DBusMessageIter * entry_iter,struct wps_start_params * params,DBusMessage ** reply)95 static int wpas_dbus_handler_wps_bssid(DBusMessage *message,
96 				       DBusMessageIter *entry_iter,
97 				       struct wps_start_params *params,
98 				       DBusMessage **reply)
99 {
100 	DBusMessageIter variant_iter, array_iter;
101 	int len;
102 
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) !=
106 	    DBUS_TYPE_BYTE) {
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");
111 		return -1;
112 	}
113 	dbus_message_iter_recurse(&variant_iter, &array_iter);
114 	dbus_message_iter_get_fixed_array(&array_iter, &params->bssid, &len);
115 	if (len != ETH_ALEN) {
116 		wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Wrong Bssid length %d",
117 			   len);
118 		*reply = wpas_dbus_error_invalid_args(message,
119 						      "Bssid is wrong length");
120 		return -1;
121 	}
122 	return 0;
123 }
124 
125 
wpas_dbus_handler_wps_pin(DBusMessage * message,DBusMessageIter * entry_iter,struct wps_start_params * params,DBusMessage ** reply)126 static int wpas_dbus_handler_wps_pin(DBusMessage *message,
127 				     DBusMessageIter *entry_iter,
128 				     struct wps_start_params *params,
129 				     DBusMessage **reply)
130 {
131 	DBusMessageIter variant_iter;
132 
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");
139 		return -1;
140 	}
141 	dbus_message_iter_get_basic(&variant_iter, &params->pin);
142 	return 0;
143 }
144 
145 
146 #ifdef CONFIG_P2P
wpas_dbus_handler_wps_p2p_dev_addr(DBusMessage * message,DBusMessageIter * entry_iter,struct wps_start_params * params,DBusMessage ** reply)147 static int wpas_dbus_handler_wps_p2p_dev_addr(DBusMessage *message,
148 					      DBusMessageIter *entry_iter,
149 					      struct wps_start_params *params,
150 					      DBusMessage **reply)
151 {
152 	DBusMessageIter variant_iter, array_iter;
153 	int len;
154 
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) !=
158 	    DBUS_TYPE_BYTE) {
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");
163 		return -1;
164 	}
165 	dbus_message_iter_recurse(&variant_iter, &array_iter);
166 	dbus_message_iter_get_fixed_array(&array_iter, &params->p2p_dev_addr,
167 					  &len);
168 	if (len != ETH_ALEN) {
169 		wpa_printf(MSG_DEBUG,
170 			   "dbus: WPS.Start - Wrong P2PDeviceAddress length %d",
171 			   len);
172 		*reply = wpas_dbus_error_invalid_args(
173 			message, "P2PDeviceAddress has wrong length");
174 		return -1;
175 	}
176 	return 0;
177 }
178 #endif /* CONFIG_P2P */
179 
180 
wpas_dbus_handler_wps_start_entry(DBusMessage * message,char * key,DBusMessageIter * entry_iter,struct wps_start_params * params,DBusMessage ** reply)181 static int wpas_dbus_handler_wps_start_entry(DBusMessage *message, char *key,
182 					     DBusMessageIter *entry_iter,
183 					     struct wps_start_params *params,
184 					     DBusMessage **reply)
185 {
186 	if (os_strcmp(key, "Role") == 0)
187 		return wpas_dbus_handler_wps_role(message, entry_iter,
188 						  params, reply);
189 	else if (os_strcmp(key, "Type") == 0)
190 		return wpas_dbus_handler_wps_type(message, entry_iter,
191 						  params, reply);
192 	else if (os_strcmp(key, "Bssid") == 0)
193 		return wpas_dbus_handler_wps_bssid(message, entry_iter,
194 						   params, reply);
195 	else if (os_strcmp(key, "Pin") == 0)
196 		return wpas_dbus_handler_wps_pin(message, entry_iter,
197 						 params, reply);
198 #ifdef CONFIG_P2P
199 	else if (os_strcmp(key, "P2PDeviceAddress") == 0)
200 		return wpas_dbus_handler_wps_p2p_dev_addr(message, entry_iter,
201 							  params, reply);
202 #endif /* CONFIG_P2P */
203 
204 	wpa_printf(MSG_DEBUG, "dbus: WPS.Start - unknown key %s", key);
205 	*reply = wpas_dbus_error_invalid_args(message, key);
206 	return -1;
207 }
208 
209 
210 /**
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
215  *
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).
220  */
wpas_dbus_handler_wps_start(DBusMessage * message,struct wpa_supplicant * wpa_s)221 DBusMessage * wpas_dbus_handler_wps_start(DBusMessage *message,
222 					  struct wpa_supplicant *wpa_s)
223 {
224 	DBusMessage *reply = NULL;
225 	DBusMessageIter iter, dict_iter, entry_iter;
226 	struct wps_start_params params;
227 	char *key;
228 	char npin[9] = { '\0' };
229 	int ret;
230 
231 	os_memset(&params, 0, sizeof(params));
232 	dbus_message_iter_init(message, &iter);
233 
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);
238 
239 		dbus_message_iter_get_basic(&entry_iter, &key);
240 		dbus_message_iter_next(&entry_iter);
241 
242 		if (wpas_dbus_handler_wps_start_entry(message, key,
243 						      &entry_iter,
244 						      &params, &reply))
245 			return reply;
246 
247 		dbus_message_iter_next(&dict_iter);
248 	}
249 
250 #ifdef CONFIG_AP
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.");
257 		}
258 		ret = wpa_supplicant_ap_wps_pin(wpa_s,
259 						params.bssid,
260 						params.pin,
261 						npin, sizeof(npin), 0);
262 	} else if (wpa_s->ap_iface) {
263 		ret = wpa_supplicant_ap_wps_pbc(wpa_s,
264 						params.bssid,
265 						params.p2p_dev_addr);
266 	} else
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.");
278 		}
279 		ret = wpas_wps_start_reg(wpa_s, params.bssid, params.pin,
280 					 NULL);
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,
287 					 params.pin, 0,
288 					 DEV_PW_DEFAULT);
289 		if (ret > 0) {
290 			ret = os_snprintf(npin, sizeof(npin), "%08d", ret);
291 			if (os_snprintf_error(sizeof(npin), ret))
292 				return wpas_dbus_error_unknown_error(
293 					message, "invalid PIN");
294 		}
295 	} else {
296 		ret = wpas_wps_start_pbc(wpa_s, params.bssid, 0, 0);
297 	}
298 
299 	if (ret < 0) {
300 		wpa_printf(MSG_DEBUG,
301 			   "dbus: WPS.Start wpas_wps_failed in role %s and key %s",
302 			   (params.role == 1 ? "enrollee" : "registrar"),
303 			   (params.type == 0 ? "" :
304 			    (params.type == 1 ? "pin" : "pbc")));
305 		return wpas_dbus_error_unknown_error(message,
306 						     "WPS start failed");
307 	}
308 
309 	reply = dbus_message_new_method_return(message);
310 	if (!reply)
311 		return wpas_dbus_error_no_memory(message);
312 
313 	dbus_message_iter_init_append(reply, &iter);
314 	if (!wpa_dbus_dict_open_write(&iter, &dict_iter) ||
315 	    (os_strlen(npin) > 0 &&
316 	     !wpa_dbus_dict_append_string(&dict_iter, "Pin", npin)) ||
317 	    !wpa_dbus_dict_close_write(&iter, &dict_iter)) {
318 		dbus_message_unref(reply);
319 		return wpas_dbus_error_no_memory(message);
320 	}
321 
322 	return reply;
323 }
324 
325 
326 /**
327  * wpas_dbus_handler_wps_cancel - Cancel ongoing WPS configuration
328  * @message: Pointer to incoming dbus message
329  * @wpa_s: %wpa_supplicant data structure
330  * Returns: NULL on success or DBus error on failure
331  *
332  * Handler for "Cancel" method call. Returns NULL if WPS cancel successful
333  * or DBus error on WPS cancel failure
334  */
wpas_dbus_handler_wps_cancel(DBusMessage * message,struct wpa_supplicant * wpa_s)335 DBusMessage * wpas_dbus_handler_wps_cancel(DBusMessage *message,
336 					   struct wpa_supplicant *wpa_s)
337 {
338 	if (wpas_wps_cancel(wpa_s))
339 		return wpas_dbus_error_unknown_error(message,
340 						     "WPS cancel failed");
341 
342 	return NULL;
343 }
344 
345 
346 /**
347  * wpas_dbus_getter_process_credentials - Check if credentials are processed
348  * @message: Pointer to incoming dbus message
349  * @wpa_s: %wpa_supplicant data structure
350  * Returns: TRUE on success, FALSE on failure
351  *
352  * Getter for "ProcessCredentials" property. Returns returned boolean will be
353  * true if wps_cred_processing configuration field is not equal to 1 or false
354  * if otherwise.
355  */
wpas_dbus_getter_process_credentials(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)356 dbus_bool_t wpas_dbus_getter_process_credentials(
357 	const struct wpa_dbus_property_desc *property_desc,
358 	DBusMessageIter *iter, DBusError *error, void *user_data)
359 {
360 	struct wpa_supplicant *wpa_s = user_data;
361 	dbus_bool_t process = wpa_s->conf->wps_cred_processing != 1;
362 
363 	return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
364 						&process, error);
365 }
366 
367 
368 /**
369  * wpas_dbus_setter_process_credentials - Set credentials_processed conf param
370  * @iter: Pointer to incoming dbus message iter
371  * @error: Location to store error on failure
372  * @user_data: Function specific data
373  * Returns: TRUE on success, FALSE on failure
374  *
375  * Setter for "ProcessCredentials" property. Sets credentials_processed on 2
376  * if boolean argument is true or on 1 if otherwise.
377  */
wpas_dbus_setter_process_credentials(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)378 dbus_bool_t wpas_dbus_setter_process_credentials(
379 	const struct wpa_dbus_property_desc *property_desc,
380 	DBusMessageIter *iter, DBusError *error, void *user_data)
381 {
382 	struct wpa_supplicant *wpa_s = user_data;
383 	dbus_bool_t process_credentials, old_pc;
384 
385 	if (!wpa_s->dbus_new_path)
386 		return FALSE;
387 	if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN,
388 					      &process_credentials))
389 		return FALSE;
390 
391 	old_pc = wpa_s->conf->wps_cred_processing != 1;
392 	wpa_s->conf->wps_cred_processing = (process_credentials ? 2 : 1);
393 
394 	if ((wpa_s->conf->wps_cred_processing != 1) != old_pc)
395 		wpa_dbus_mark_property_changed(wpa_s->global->dbus,
396 					       wpa_s->dbus_new_path,
397 					       WPAS_DBUS_NEW_IFACE_WPS,
398 					       "ProcessCredentials");
399 
400 	return TRUE;
401 }
402 
403 
404 /**
405  * wpas_dbus_getter_config_methods - Get current WPS configuration methods
406  * @iter: Pointer to incoming dbus message iter
407  * @error: Location to store error on failure
408  * @user_data: Function specific data
409  * Returns: TRUE on success, FALSE on failure
410  *
411  * Getter for "ConfigMethods" property. Returned boolean will be true if
412  * providing the relevant string worked, or false otherwise.
413  */
wpas_dbus_getter_config_methods(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)414 dbus_bool_t wpas_dbus_getter_config_methods(
415 	const struct wpa_dbus_property_desc *property_desc,
416 	DBusMessageIter *iter, DBusError *error, void *user_data)
417 {
418 	struct wpa_supplicant *wpa_s = user_data;
419 
420 	return wpas_dbus_string_property_getter(iter,
421 						wpa_s->conf->config_methods,
422 						error);
423 }
424 
425 
426 /**
427  * wpas_dbus_setter_config_methods - Set WPS configuration methods
428  * @iter: Pointer to incoming dbus message iter
429  * @error: Location to store error on failure
430  * @user_data: Function specific data
431  * Returns: TRUE on success, FALSE on failure
432  *
433  * Setter for "ConfigMethods" property. Sets the methods string, apply such
434  * change and returns true on success. Returns false otherwise.
435  */
wpas_dbus_setter_config_methods(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)436 dbus_bool_t wpas_dbus_setter_config_methods(
437 	const struct wpa_dbus_property_desc *property_desc,
438 	DBusMessageIter *iter, DBusError *error, void *user_data)
439 {
440 	struct wpa_supplicant *wpa_s = user_data;
441 	char *methods, *new_methods;
442 
443 	if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
444 					      &methods))
445 		return FALSE;
446 
447 	new_methods = os_strdup(methods);
448 	if (!new_methods)
449 		return FALSE;
450 
451 	os_free(wpa_s->conf->config_methods);
452 	wpa_s->conf->config_methods = new_methods;
453 
454 	wpa_s->conf->changed_parameters |= CFG_CHANGED_CONFIG_METHODS;
455 	wpa_supplicant_update_config(wpa_s);
456 
457 	return TRUE;
458 }
459 
460 
461 /**
462  * wpas_dbus_getter_wps_device_name - Get current WPS device name
463  * @iter: Pointer to incoming dbus message iter
464  * @error: Location to store error on failure
465  * @user_data: Function specific data
466  * Returns: TRUE on success, FALSE on failure
467  *
468  * Getter for "DeviceName" property.
469  */
wpas_dbus_getter_wps_device_name(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)470 dbus_bool_t wpas_dbus_getter_wps_device_name(
471 	const struct wpa_dbus_property_desc *property_desc,
472 	DBusMessageIter *iter, DBusError *error, void *user_data)
473 {
474 	struct wpa_supplicant *wpa_s = user_data;
475 
476 	return wpas_dbus_string_property_getter(iter, wpa_s->conf->device_name,
477 						error);
478 }
479 
480 
481 /**
482  * wpas_dbus_setter_wps_device_name - Set current WPS device name
483  * @iter: Pointer to incoming dbus message iter
484  * @error: Location to store error on failure
485  * @user_data: Function specific data
486  * Returns: TRUE on success, FALSE on failure
487  *
488  * Setter for "DeviceName" property.
489  */
wpas_dbus_setter_wps_device_name(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)490 dbus_bool_t wpas_dbus_setter_wps_device_name(
491 	const struct wpa_dbus_property_desc *property_desc,
492 	DBusMessageIter *iter, DBusError *error, void *user_data)
493 {
494 	struct wpa_supplicant *wpa_s = user_data;
495 	char *methods, *devname;
496 
497 	if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
498 					      &methods))
499 		return FALSE;
500 
501 	if (os_strlen(methods) > WPS_DEV_NAME_MAX_LEN)
502 		return FALSE;
503 
504 	devname = os_strdup(methods);
505 	if (!devname)
506 		return FALSE;
507 
508 	os_free(wpa_s->conf->device_name);
509 	wpa_s->conf->device_name = devname;
510 	wpa_s->conf->changed_parameters |= CFG_CHANGED_DEVICE_NAME;
511 	wpa_supplicant_update_config(wpa_s);
512 
513 	return TRUE;
514 }
515 
516 
517 /**
518  * wpas_dbus_getter_wps_manufacturer - Get current manufacturer name
519  * @iter: Pointer to incoming dbus message iter
520  * @error: Location to store error on failure
521  * @user_data: Function specific data
522  * Returns: TRUE on success, FALSE on failure
523  *
524  * Getter for "Manufacturer" property.
525  */
wpas_dbus_getter_wps_manufacturer(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)526 dbus_bool_t wpas_dbus_getter_wps_manufacturer(
527 	const struct wpa_dbus_property_desc *property_desc,
528 	DBusMessageIter *iter, DBusError *error, void *user_data)
529 {
530 	struct wpa_supplicant *wpa_s = user_data;
531 
532 	return wpas_dbus_string_property_getter(iter, wpa_s->conf->manufacturer,
533 						error);
534 }
535 
536 
537 /**
538  * wpas_dbus_setter_wps_manufacturer - Set current manufacturer name
539  * @iter: Pointer to incoming dbus message iter
540  * @error: Location to store error on failure
541  * @user_data: Function specific data
542  * Returns: TRUE on success, FALSE on failure
543  *
544  * Setter for "Manufacturer" property.
545  */
wpas_dbus_setter_wps_manufacturer(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)546 dbus_bool_t wpas_dbus_setter_wps_manufacturer(
547 	const struct wpa_dbus_property_desc *property_desc,
548 	DBusMessageIter *iter, DBusError *error, void *user_data)
549 {
550 	struct wpa_supplicant *wpa_s = user_data;
551 	char *methods, *manufacturer;
552 
553 	if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
554 					      &methods))
555 		return FALSE;
556 
557 	if (os_strlen(methods) > WPS_MANUFACTURER_MAX_LEN)
558 		return FALSE;
559 
560 	manufacturer = os_strdup(methods);
561 	if (!manufacturer)
562 		return FALSE;
563 
564 	os_free(wpa_s->conf->manufacturer);
565 	wpa_s->conf->manufacturer = manufacturer;
566 	wpa_s->conf->changed_parameters |= CFG_CHANGED_WPS_STRING;
567 	wpa_supplicant_update_config(wpa_s);
568 
569 	return TRUE;
570 }
571 
572 
573 /**
574  * wpas_dbus_getter_wps_device_model_name - Get current device model name
575  * @iter: Pointer to incoming dbus message iter
576  * @error: Location to store error on failure
577  * @user_data: Function specific data
578  * Returns: TRUE on success, FALSE on failure
579  *
580  * Getter for "ModelName" property.
581  */
wpas_dbus_getter_wps_device_model_name(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)582 dbus_bool_t wpas_dbus_getter_wps_device_model_name(
583 	const struct wpa_dbus_property_desc *property_desc,
584 	DBusMessageIter *iter, DBusError *error, void *user_data)
585 {
586 	struct wpa_supplicant *wpa_s = user_data;
587 
588 	return wpas_dbus_string_property_getter(iter, wpa_s->conf->model_name,
589 						error);
590 }
591 
592 
593 /**
594  * wpas_dbus_setter_wps_device_model_name - Set current device model name
595  * @iter: Pointer to incoming dbus message iter
596  * @error: Location to store error on failure
597  * @user_data: Function specific data
598  * Returns: TRUE on success, FALSE on failure
599  *
600  * Setter for "ModelName" property.
601  */
wpas_dbus_setter_wps_device_model_name(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)602 dbus_bool_t wpas_dbus_setter_wps_device_model_name(
603 	const struct wpa_dbus_property_desc *property_desc,
604 	DBusMessageIter *iter, DBusError *error, void *user_data)
605 {
606 	struct wpa_supplicant *wpa_s = user_data;
607 	char *methods, *model_name;
608 
609 	if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
610 					      &methods))
611 		return FALSE;
612 
613 	if (os_strlen(methods) > WPS_MODEL_NAME_MAX_LEN)
614 		return FALSE;
615 
616 	model_name = os_strdup(methods);
617 	if (!model_name)
618 		return FALSE;
619 	os_free(wpa_s->conf->model_name);
620 	wpa_s->conf->model_name = model_name;
621 	wpa_s->conf->changed_parameters |= CFG_CHANGED_WPS_STRING;
622 	wpa_supplicant_update_config(wpa_s);
623 
624 	return TRUE;
625 }
626 
627 
628 /**
629  * wpas_dbus_getter_wps_device_model_number - Get current device model number
630  * @iter: Pointer to incoming dbus message iter
631  * @error: Location to store error on failure
632  * @user_data: Function specific data
633  * Returns: TRUE on success, FALSE on failure
634  *
635  * Getter for "ModelNumber" property.
636  */
wpas_dbus_getter_wps_device_model_number(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)637 dbus_bool_t wpas_dbus_getter_wps_device_model_number(
638 	const struct wpa_dbus_property_desc *property_desc,
639 	DBusMessageIter *iter, DBusError *error, void *user_data)
640 {
641 	struct wpa_supplicant *wpa_s = user_data;
642 
643 	return wpas_dbus_string_property_getter(iter, wpa_s->conf->model_number,
644 						error);
645 }
646 
647 
648 /**
649  * wpas_dbus_setter_wps_device_model_number - Set current device model number
650  * @iter: Pointer to incoming dbus message iter
651  * @error: Location to store error on failure
652  * @user_data: Function specific data
653  * Returns: TRUE on success, FALSE on failure
654  *
655  * Setter for "ModelNumber" property.
656  */
wpas_dbus_setter_wps_device_model_number(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)657 dbus_bool_t wpas_dbus_setter_wps_device_model_number(
658 	const struct wpa_dbus_property_desc *property_desc,
659 	DBusMessageIter *iter, DBusError *error, void *user_data)
660 {
661 	struct wpa_supplicant *wpa_s = user_data;
662 	char *methods, *model_number;
663 
664 	if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
665 					      &methods))
666 		return FALSE;
667 
668 	if (os_strlen(methods) > WPS_MODEL_NUMBER_MAX_LEN)
669 		return FALSE;
670 
671 	model_number = os_strdup(methods);
672 	if (!model_number)
673 		return FALSE;
674 
675 	os_free(wpa_s->conf->model_number);
676 	wpa_s->conf->model_number = model_number;
677 	wpa_s->conf->changed_parameters |= CFG_CHANGED_WPS_STRING;
678 	wpa_supplicant_update_config(wpa_s);
679 
680 	return TRUE;
681 }
682 
683 
684 /**
685  * wpas_dbus_getter_wps_device_serial_number - Get current device serial number
686  * @iter: Pointer to incoming dbus message iter
687  * @error: Location to store error on failure
688  * @user_data: Function specific data
689  * Returns: TRUE on success, FALSE on failure
690  *
691  * Getter for "SerialNumber" property.
692  */
wpas_dbus_getter_wps_device_serial_number(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)693 dbus_bool_t wpas_dbus_getter_wps_device_serial_number(
694 	const struct wpa_dbus_property_desc *property_desc,
695 	DBusMessageIter *iter, DBusError *error, void *user_data)
696 {
697 	struct wpa_supplicant *wpa_s = user_data;
698 
699 	return wpas_dbus_string_property_getter(iter,
700 						wpa_s->conf->serial_number,
701 						error);
702 }
703 
704 
705 /**
706  * wpas_dbus_setter_wps_device_serial_number - Set current device serial number
707  * @iter: Pointer to incoming dbus message iter
708  * @error: Location to store error on failure
709  * @user_data: Function specific data
710  * Returns: TRUE on success, FALSE on failure
711  *
712  * Setter for "SerialNumber" property.
713  */
wpas_dbus_setter_wps_device_serial_number(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)714 dbus_bool_t wpas_dbus_setter_wps_device_serial_number(
715 	const struct wpa_dbus_property_desc *property_desc,
716 	DBusMessageIter *iter, DBusError *error, void *user_data)
717 {
718 	struct wpa_supplicant *wpa_s = user_data;
719 	char *methods, *serial_number;
720 
721 	if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
722 					      &methods))
723 		return FALSE;
724 
725 	if (os_strlen(methods) > WPS_SERIAL_NUMBER_MAX_LEN)
726 		return FALSE;
727 
728 	serial_number = os_strdup(methods);
729 	if (!serial_number)
730 		return FALSE;
731 	os_free(wpa_s->conf->serial_number);
732 	wpa_s->conf->serial_number = serial_number;
733 	wpa_s->conf->changed_parameters |= CFG_CHANGED_WPS_STRING;
734 	wpa_supplicant_update_config(wpa_s);
735 
736 	return TRUE;
737 }
738 
739 
740 /**
741  * wpas_dbus_getter_wps_device_device_type - Get current device type
742  * @iter: Pointer to incoming dbus message iter
743  * @error: Location to store error on failure
744  * @user_data: Function specific data
745  * Returns: TRUE on success, FALSE on failure
746  *
747  * Getter for "DeviceType" property.
748  */
wpas_dbus_getter_wps_device_device_type(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)749 dbus_bool_t wpas_dbus_getter_wps_device_device_type(
750 	const struct wpa_dbus_property_desc *property_desc,
751 	DBusMessageIter *iter, DBusError *error, void *user_data)
752 {
753 	struct wpa_supplicant *wpa_s = user_data;
754 
755 	if (!wpas_dbus_simple_array_property_getter(iter, DBUS_TYPE_BYTE,
756 						    (char *)
757 						    wpa_s->conf->device_type,
758 						    WPS_DEV_TYPE_LEN, error)) {
759 		dbus_set_error(error, DBUS_ERROR_FAILED,
760 			       "%s: error constructing reply", __func__);
761 		return FALSE;
762 	}
763 
764 	return TRUE;
765 }
766 
767 
768 /**
769  * wpas_dbus_setter_wps_device_device_type - Set current device type
770  * @iter: Pointer to incoming dbus message iter
771  * @error: Location to store error on failure
772  * @user_data: Function specific data
773  * Returns: TRUE on success, FALSE on failure
774  *
775  * Setter for "DeviceType" property.
776  */
wpas_dbus_setter_wps_device_device_type(const struct wpa_dbus_property_desc * property_desc,DBusMessageIter * iter,DBusError * error,void * user_data)777 dbus_bool_t wpas_dbus_setter_wps_device_device_type(
778 	const struct wpa_dbus_property_desc *property_desc,
779 	DBusMessageIter *iter, DBusError *error, void *user_data)
780 {
781 	struct wpa_supplicant *wpa_s = user_data;
782 	u8 *dev_type;
783 	int dev_len;
784 	DBusMessageIter variant, array_iter;
785 
786 	if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_VARIANT)
787 		return FALSE;
788 
789 	dbus_message_iter_recurse(iter, &variant);
790 	if (dbus_message_iter_get_arg_type(&variant) != DBUS_TYPE_ARRAY)
791 		return FALSE;
792 
793 	dbus_message_iter_recurse(&variant, &array_iter);
794 	dbus_message_iter_get_fixed_array(&array_iter, &dev_type, &dev_len);
795 
796 	if (dev_len != WPS_DEV_TYPE_LEN)
797 		return FALSE;
798 
799 	os_memcpy(wpa_s->conf->device_type, dev_type, WPS_DEV_TYPE_LEN);
800 	wpa_s->conf->changed_parameters |= CFG_CHANGED_DEVICE_TYPE;
801 	wpa_supplicant_update_config(wpa_s);
802 
803 	return TRUE;
804 }
805