Line data Source code
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 :
33 21 : 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 21 : dbus_message_iter_recurse(entry_iter, &variant_iter);
42 21 : if (dbus_message_iter_get_arg_type(&variant_iter) !=
43 : DBUS_TYPE_STRING) {
44 1 : wpa_printf(MSG_DEBUG,
45 : "dbus: WPS.Start - Wrong Role type, string required");
46 1 : *reply = wpas_dbus_error_invalid_args(message,
47 : "Role must be a string");
48 1 : return -1;
49 : }
50 20 : dbus_message_iter_get_basic(&variant_iter, &val);
51 20 : if (os_strcmp(val, "enrollee") == 0)
52 13 : params->role = 1;
53 7 : else if (os_strcmp(val, "registrar") == 0)
54 6 : params->role = 2;
55 : else {
56 1 : wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Uknown role %s", val);
57 1 : *reply = wpas_dbus_error_invalid_args(message, val);
58 1 : return -1;
59 : }
60 19 : return 0;
61 : }
62 :
63 :
64 23 : 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 23 : dbus_message_iter_recurse(entry_iter, &variant_iter);
73 23 : if (dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING) {
74 1 : wpa_printf(MSG_DEBUG,
75 : "dbus: WPS.Start - Wrong Type type, string required");
76 1 : *reply = wpas_dbus_error_invalid_args(message,
77 : "Type must be a string");
78 1 : return -1;
79 : }
80 22 : dbus_message_iter_get_basic(&variant_iter, &val);
81 22 : if (os_strcmp(val, "pin") == 0)
82 11 : params->type = 1;
83 11 : else if (os_strcmp(val, "pbc") == 0)
84 10 : params->type = 2;
85 : else {
86 1 : wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Unknown type %s",
87 : val);
88 1 : *reply = wpas_dbus_error_invalid_args(message, val);
89 1 : return -1;
90 : }
91 21 : return 0;
92 : }
93 :
94 :
95 11 : 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 11 : dbus_message_iter_recurse(entry_iter, &variant_iter);
104 21 : if (dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_ARRAY ||
105 10 : dbus_message_iter_get_element_type(&variant_iter) !=
106 : DBUS_TYPE_BYTE) {
107 1 : wpa_printf(MSG_DEBUG,
108 : "dbus: WPS.Start - Wrong Bssid type, byte array required");
109 1 : *reply = wpas_dbus_error_invalid_args(
110 : message, "Bssid must be a byte array");
111 1 : return -1;
112 : }
113 10 : dbus_message_iter_recurse(&variant_iter, &array_iter);
114 10 : dbus_message_iter_get_fixed_array(&array_iter, ¶ms->bssid, &len);
115 10 : if (len != ETH_ALEN) {
116 1 : wpa_printf(MSG_DEBUG, "dbus: WPS.Stsrt - Wrong Bssid length %d",
117 : len);
118 1 : *reply = wpas_dbus_error_invalid_args(message,
119 : "Bssid is wrong length");
120 1 : return -1;
121 : }
122 9 : return 0;
123 : }
124 :
125 :
126 9 : 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 9 : dbus_message_iter_recurse(entry_iter, &variant_iter);
134 9 : if (dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING) {
135 1 : wpa_printf(MSG_DEBUG,
136 : "dbus: WPS.Start - Wrong Pin type, string required");
137 1 : *reply = wpas_dbus_error_invalid_args(message,
138 : "Pin must be a string");
139 1 : return -1;
140 : }
141 8 : dbus_message_iter_get_basic(&variant_iter, ¶ms->pin);
142 8 : return 0;
143 : }
144 :
145 :
146 : #ifdef CONFIG_P2P
147 7 : 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 7 : dbus_message_iter_recurse(entry_iter, &variant_iter);
156 13 : if (dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_ARRAY ||
157 6 : dbus_message_iter_get_element_type(&variant_iter) !=
158 : DBUS_TYPE_BYTE) {
159 1 : wpa_printf(MSG_DEBUG,
160 : "dbus: WPS.Start - Wrong P2PDeviceAddress type, byte array required");
161 1 : *reply = wpas_dbus_error_invalid_args(
162 : message, "P2PDeviceAddress must be a byte array");
163 1 : return -1;
164 : }
165 6 : dbus_message_iter_recurse(&variant_iter, &array_iter);
166 6 : dbus_message_iter_get_fixed_array(&array_iter, ¶ms->p2p_dev_addr,
167 : &len);
168 6 : if (len != ETH_ALEN) {
169 1 : wpa_printf(MSG_DEBUG,
170 : "dbus: WPS.Start - Wrong P2PDeviceAddress length %d",
171 : len);
172 1 : *reply = wpas_dbus_error_invalid_args(
173 : message, "P2PDeviceAddress has wrong length");
174 1 : return -1;
175 : }
176 5 : return 0;
177 : }
178 : #endif /* CONFIG_P2P */
179 :
180 :
181 72 : 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 72 : if (os_strcmp(key, "Role") == 0)
187 21 : return wpas_dbus_handler_wps_role(message, entry_iter,
188 : params, reply);
189 51 : else if (os_strcmp(key, "Type") == 0)
190 23 : return wpas_dbus_handler_wps_type(message, entry_iter,
191 : params, reply);
192 28 : else if (os_strcmp(key, "Bssid") == 0)
193 11 : return wpas_dbus_handler_wps_bssid(message, entry_iter,
194 : params, reply);
195 17 : else if (os_strcmp(key, "Pin") == 0)
196 9 : return wpas_dbus_handler_wps_pin(message, entry_iter,
197 : params, reply);
198 : #ifdef CONFIG_P2P
199 8 : else if (os_strcmp(key, "P2PDeviceAddress") == 0)
200 7 : return wpas_dbus_handler_wps_p2p_dev_addr(message, entry_iter,
201 : params, reply);
202 : #endif /* CONFIG_P2P */
203 :
204 1 : wpa_printf(MSG_DEBUG, "dbus: WPS.Start - unknown key %s", key);
205 1 : *reply = wpas_dbus_error_invalid_args(message, key);
206 1 : 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 : */
221 25 : DBusMessage * wpas_dbus_handler_wps_start(DBusMessage *message,
222 : struct wpa_supplicant *wpa_s)
223 : {
224 25 : DBusMessage *reply = NULL;
225 : DBusMessageIter iter, dict_iter, entry_iter;
226 : struct wps_start_params params;
227 : char *key;
228 25 : char npin[9] = { '\0' };
229 : int ret;
230 :
231 25 : os_memset(¶ms, 0, sizeof(params));
232 25 : dbus_message_iter_init(message, &iter);
233 :
234 25 : dbus_message_iter_recurse(&iter, &dict_iter);
235 112 : while (dbus_message_iter_get_arg_type(&dict_iter) ==
236 : DBUS_TYPE_DICT_ENTRY) {
237 72 : dbus_message_iter_recurse(&dict_iter, &entry_iter);
238 :
239 72 : dbus_message_iter_get_basic(&entry_iter, &key);
240 72 : dbus_message_iter_next(&entry_iter);
241 :
242 72 : if (wpas_dbus_handler_wps_start_entry(message, key,
243 : &entry_iter,
244 : ¶ms, &reply))
245 10 : return reply;
246 :
247 62 : dbus_message_iter_next(&dict_iter);
248 : }
249 :
250 : #ifdef CONFIG_AP
251 15 : if (wpa_s->ap_iface && params.type == 1) {
252 5 : if (params.pin == NULL) {
253 1 : wpa_printf(MSG_DEBUG,
254 : "dbus: WPS.Start - Pin required for registrar role");
255 1 : return wpas_dbus_error_invalid_args(
256 : message, "Pin required for registrar role.");
257 : }
258 4 : ret = wpa_supplicant_ap_wps_pin(wpa_s,
259 4 : params.bssid,
260 4 : params.pin,
261 : npin, sizeof(npin), 0);
262 10 : } else if (wpa_s->ap_iface) {
263 1 : ret = wpa_supplicant_ap_wps_pbc(wpa_s,
264 1 : params.bssid,
265 1 : params.p2p_dev_addr);
266 : } else
267 : #endif /* CONFIG_AP */
268 9 : if (params.role == 0) {
269 1 : wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Role not specified");
270 1 : return wpas_dbus_error_invalid_args(message,
271 : "Role not specified");
272 8 : } else if (params.role == 2) {
273 2 : if (params.pin == NULL) {
274 1 : wpa_printf(MSG_DEBUG,
275 : "dbus: WPS.Start - Pin required for registrar role");
276 1 : return wpas_dbus_error_invalid_args(
277 : message, "Pin required for registrar role.");
278 : }
279 1 : ret = wpas_wps_start_reg(wpa_s, params.bssid, params.pin,
280 : NULL);
281 6 : } else if (params.type == 0) {
282 1 : wpa_printf(MSG_DEBUG, "dbus: WPS.Start - Type not specified");
283 1 : return wpas_dbus_error_invalid_args(message,
284 : "Type not specified");
285 5 : } else if (params.type == 1) {
286 4 : ret = wpas_wps_start_pin(wpa_s, params.bssid,
287 4 : params.pin, 0,
288 : DEV_PW_DEFAULT);
289 4 : if (ret > 0)
290 1 : os_snprintf(npin, sizeof(npin), "%08d", ret);
291 : } else {
292 1 : ret = wpas_wps_start_pbc(wpa_s, params.bssid, 0);
293 : }
294 :
295 11 : if (ret < 0) {
296 3 : wpa_printf(MSG_DEBUG,
297 : "dbus: WPS.Start wpas_wps_failed in role %s and key %s",
298 1 : (params.role == 1 ? "enrollee" : "registrar"),
299 1 : (params.type == 0 ? "" :
300 1 : (params.type == 1 ? "pin" : "pbc")));
301 1 : return wpas_dbus_error_unknown_error(message,
302 : "WPS start failed");
303 : }
304 :
305 10 : reply = dbus_message_new_method_return(message);
306 10 : if (!reply)
307 0 : return wpas_dbus_error_no_memory(message);
308 :
309 10 : dbus_message_iter_init_append(reply, &iter);
310 20 : if (!wpa_dbus_dict_open_write(&iter, &dict_iter) ||
311 15 : (os_strlen(npin) > 0 &&
312 15 : !wpa_dbus_dict_append_string(&dict_iter, "Pin", npin)) ||
313 10 : !wpa_dbus_dict_close_write(&iter, &dict_iter)) {
314 0 : dbus_message_unref(reply);
315 0 : return wpas_dbus_error_no_memory(message);
316 : }
317 :
318 10 : return reply;
319 : }
320 :
321 :
322 : /**
323 : * wpas_dbus_getter_process_credentials - Check if credentials are processed
324 : * @message: Pointer to incoming dbus message
325 : * @wpa_s: %wpa_supplicant data structure
326 : * Returns: TRUE on success, FALSE on failure
327 : *
328 : * Getter for "ProcessCredentials" property. Returns returned boolean will be
329 : * true if wps_cred_processing configuration field is not equal to 1 or false
330 : * if otherwise.
331 : */
332 8 : dbus_bool_t wpas_dbus_getter_process_credentials(DBusMessageIter *iter,
333 : DBusError *error,
334 : void *user_data)
335 : {
336 8 : struct wpa_supplicant *wpa_s = user_data;
337 8 : dbus_bool_t process = wpa_s->conf->wps_cred_processing != 1;
338 :
339 8 : return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_BOOLEAN,
340 : &process, error);
341 : }
342 :
343 :
344 : /**
345 : * wpas_dbus_setter_process_credentials - Set credentials_processed conf param
346 : * @iter: Pointer to incoming dbus message iter
347 : * @error: Location to store error on failure
348 : * @user_data: Function specific data
349 : * Returns: TRUE on success, FALSE on failure
350 : *
351 : * Setter for "ProcessCredentials" property. Sets credentials_processed on 2
352 : * if boolean argument is true or on 1 if otherwise.
353 : */
354 2 : dbus_bool_t wpas_dbus_setter_process_credentials(DBusMessageIter *iter,
355 : DBusError *error,
356 : void *user_data)
357 : {
358 2 : struct wpa_supplicant *wpa_s = user_data;
359 : dbus_bool_t process_credentials, old_pc;
360 :
361 2 : if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_BOOLEAN,
362 : &process_credentials))
363 0 : return FALSE;
364 :
365 2 : old_pc = wpa_s->conf->wps_cred_processing != 1;
366 2 : wpa_s->conf->wps_cred_processing = (process_credentials ? 2 : 1);
367 :
368 2 : if ((wpa_s->conf->wps_cred_processing != 1) != old_pc)
369 1 : wpa_dbus_mark_property_changed(wpa_s->global->dbus,
370 1 : wpa_s->dbus_new_path,
371 : WPAS_DBUS_NEW_IFACE_WPS,
372 : "ProcessCredentials");
373 :
374 2 : return TRUE;
375 : }
376 :
377 :
378 : /**
379 : * wpas_dbus_getter_config_methods - Get current WPS configuration methods
380 : * @iter: Pointer to incoming dbus message iter
381 : * @error: Location to store error on failure
382 : * @user_data: Function specific data
383 : * Returns: TRUE on success, FALSE on failure
384 : *
385 : * Getter for "ConfigMethods" property. Returned boolean will be true if
386 : * providing the relevant string worked, or false otherwise.
387 : */
388 4 : dbus_bool_t wpas_dbus_getter_config_methods(DBusMessageIter *iter,
389 : DBusError *error,
390 : void *user_data)
391 : {
392 4 : struct wpa_supplicant *wpa_s = user_data;
393 4 : char *methods = wpa_s->conf->config_methods;
394 :
395 4 : if (methods == NULL)
396 2 : methods = "";
397 4 : return wpas_dbus_simple_property_getter(iter, DBUS_TYPE_STRING,
398 : &methods, error);
399 : }
400 :
401 :
402 : /**
403 : * wpas_dbus_setter_config_methods - Set WPS configuration methods
404 : * @iter: Pointer to incoming dbus message iter
405 : * @error: Location to store error on failure
406 : * @user_data: Function specific data
407 : * Returns: TRUE on success, FALSE on failure
408 : *
409 : * Setter for "ConfigMethods" property. Sets the methods string, apply such
410 : * change and returns true on success. Returns false otherwise.
411 : */
412 2 : dbus_bool_t wpas_dbus_setter_config_methods(DBusMessageIter *iter,
413 : DBusError *error,
414 : void *user_data)
415 : {
416 2 : struct wpa_supplicant *wpa_s = user_data;
417 : char *methods, *new_methods;
418 :
419 2 : if (!wpas_dbus_simple_property_setter(iter, error, DBUS_TYPE_STRING,
420 : &methods))
421 0 : return FALSE;
422 :
423 2 : new_methods = os_strdup(methods);
424 2 : if (!new_methods)
425 1 : return FALSE;
426 :
427 1 : os_free(wpa_s->conf->config_methods);
428 1 : wpa_s->conf->config_methods = new_methods;
429 :
430 1 : wpa_s->conf->changed_parameters |= CFG_CHANGED_CONFIG_METHODS;
431 1 : wpa_supplicant_update_config(wpa_s);
432 :
433 1 : return TRUE;
434 : }
|
