Line data Source code
1 : /*
2 : * Wi-Fi Protected Setup - device attributes
3 : * Copyright (c) 2008, Jouni Malinen <j@w1.fi>
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 :
11 : #include "common.h"
12 : #include "wps_i.h"
13 : #include "wps_dev_attr.h"
14 :
15 :
16 7135 : int wps_build_manufacturer(struct wps_device_data *dev, struct wpabuf *msg)
17 : {
18 : size_t len;
19 7135 : wpa_printf(MSG_DEBUG, "WPS: * Manufacturer");
20 7135 : wpabuf_put_be16(msg, ATTR_MANUFACTURER);
21 7135 : len = dev->manufacturer ? os_strlen(dev->manufacturer) : 0;
22 : #ifndef CONFIG_WPS_STRICT
23 7135 : if (len == 0) {
24 : /*
25 : * Some deployed WPS implementations fail to parse zero-length
26 : * attributes. As a workaround, send a space character if the
27 : * device attribute string is empty.
28 : */
29 6932 : wpabuf_put_be16(msg, 1);
30 6932 : wpabuf_put_u8(msg, ' ');
31 6932 : return 0;
32 : }
33 : #endif /* CONFIG_WPS_STRICT */
34 203 : wpabuf_put_be16(msg, len);
35 203 : wpabuf_put_data(msg, dev->manufacturer, len);
36 203 : return 0;
37 : }
38 :
39 :
40 7135 : int wps_build_model_name(struct wps_device_data *dev, struct wpabuf *msg)
41 : {
42 : size_t len;
43 7135 : wpa_printf(MSG_DEBUG, "WPS: * Model Name");
44 7135 : wpabuf_put_be16(msg, ATTR_MODEL_NAME);
45 7135 : len = dev->model_name ? os_strlen(dev->model_name) : 0;
46 : #ifndef CONFIG_WPS_STRICT
47 7135 : if (len == 0) {
48 : /*
49 : * Some deployed WPS implementations fail to parse zero-length
50 : * attributes. As a workaround, send a space character if the
51 : * device attribute string is empty.
52 : */
53 6932 : wpabuf_put_be16(msg, 1);
54 6932 : wpabuf_put_u8(msg, ' ');
55 6932 : return 0;
56 : }
57 : #endif /* CONFIG_WPS_STRICT */
58 203 : wpabuf_put_be16(msg, len);
59 203 : wpabuf_put_data(msg, dev->model_name, len);
60 203 : return 0;
61 : }
62 :
63 :
64 7135 : int wps_build_model_number(struct wps_device_data *dev, struct wpabuf *msg)
65 : {
66 : size_t len;
67 7135 : wpa_printf(MSG_DEBUG, "WPS: * Model Number");
68 7135 : wpabuf_put_be16(msg, ATTR_MODEL_NUMBER);
69 7135 : len = dev->model_number ? os_strlen(dev->model_number) : 0;
70 : #ifndef CONFIG_WPS_STRICT
71 7135 : if (len == 0) {
72 : /*
73 : * Some deployed WPS implementations fail to parse zero-length
74 : * attributes. As a workaround, send a space character if the
75 : * device attribute string is empty.
76 : */
77 6932 : wpabuf_put_be16(msg, 1);
78 6932 : wpabuf_put_u8(msg, ' ');
79 6932 : return 0;
80 : }
81 : #endif /* CONFIG_WPS_STRICT */
82 203 : wpabuf_put_be16(msg, len);
83 203 : wpabuf_put_data(msg, dev->model_number, len);
84 203 : return 0;
85 : }
86 :
87 :
88 2465 : int wps_build_serial_number(struct wps_device_data *dev, struct wpabuf *msg)
89 : {
90 : size_t len;
91 2465 : wpa_printf(MSG_DEBUG, "WPS: * Serial Number");
92 2465 : wpabuf_put_be16(msg, ATTR_SERIAL_NUMBER);
93 2465 : len = dev->serial_number ? os_strlen(dev->serial_number) : 0;
94 : #ifndef CONFIG_WPS_STRICT
95 2465 : if (len == 0) {
96 : /*
97 : * Some deployed WPS implementations fail to parse zero-length
98 : * attributes. As a workaround, send a space character if the
99 : * device attribute string is empty.
100 : */
101 2262 : wpabuf_put_be16(msg, 1);
102 2262 : wpabuf_put_u8(msg, ' ');
103 2262 : return 0;
104 : }
105 : #endif /* CONFIG_WPS_STRICT */
106 203 : wpabuf_put_be16(msg, len);
107 203 : wpabuf_put_data(msg, dev->serial_number, len);
108 203 : return 0;
109 : }
110 :
111 :
112 7966 : int wps_build_primary_dev_type(struct wps_device_data *dev, struct wpabuf *msg)
113 : {
114 7966 : wpa_printf(MSG_DEBUG, "WPS: * Primary Device Type");
115 7966 : wpabuf_put_be16(msg, ATTR_PRIMARY_DEV_TYPE);
116 7966 : wpabuf_put_be16(msg, WPS_DEV_TYPE_LEN);
117 7966 : wpabuf_put_data(msg, dev->pri_dev_type, WPS_DEV_TYPE_LEN);
118 7966 : return 0;
119 : }
120 :
121 :
122 4670 : int wps_build_secondary_dev_type(struct wps_device_data *dev,
123 : struct wpabuf *msg)
124 : {
125 4670 : if (!dev->num_sec_dev_types)
126 4538 : return 0;
127 :
128 132 : wpa_printf(MSG_DEBUG, "WPS: * Secondary Device Type");
129 132 : wpabuf_put_be16(msg, ATTR_SECONDARY_DEV_TYPE_LIST);
130 132 : wpabuf_put_be16(msg, WPS_DEV_TYPE_LEN * dev->num_sec_dev_types);
131 132 : wpabuf_put_data(msg, dev->sec_dev_type,
132 132 : WPS_DEV_TYPE_LEN * dev->num_sec_dev_types);
133 :
134 132 : return 0;
135 : }
136 :
137 :
138 4670 : int wps_build_req_dev_type(struct wps_device_data *dev, struct wpabuf *msg,
139 : unsigned int num_req_dev_types,
140 : const u8 *req_dev_types)
141 : {
142 : unsigned int i;
143 :
144 4679 : for (i = 0; i < num_req_dev_types; i++) {
145 9 : wpa_hexdump(MSG_DEBUG, "WPS: * Requested Device Type",
146 9 : req_dev_types + i * WPS_DEV_TYPE_LEN,
147 : WPS_DEV_TYPE_LEN);
148 9 : wpabuf_put_be16(msg, ATTR_REQUESTED_DEV_TYPE);
149 9 : wpabuf_put_be16(msg, WPS_DEV_TYPE_LEN);
150 9 : wpabuf_put_data(msg, req_dev_types + i * WPS_DEV_TYPE_LEN,
151 : WPS_DEV_TYPE_LEN);
152 : }
153 :
154 4670 : return 0;
155 : }
156 :
157 :
158 7966 : int wps_build_dev_name(struct wps_device_data *dev, struct wpabuf *msg)
159 : {
160 : size_t len;
161 7966 : wpa_printf(MSG_DEBUG, "WPS: * Device Name");
162 7966 : wpabuf_put_be16(msg, ATTR_DEV_NAME);
163 7966 : len = dev->device_name ? os_strlen(dev->device_name) : 0;
164 : #ifndef CONFIG_WPS_STRICT
165 7966 : if (len == 0) {
166 : /*
167 : * Some deployed WPS implementations fail to parse zero-length
168 : * attributes. As a workaround, send a space character if the
169 : * device attribute string is empty.
170 : */
171 1227 : wpabuf_put_be16(msg, 1);
172 1227 : wpabuf_put_u8(msg, ' ');
173 1227 : return 0;
174 : }
175 : #endif /* CONFIG_WPS_STRICT */
176 6739 : wpabuf_put_be16(msg, len);
177 6739 : wpabuf_put_data(msg, dev->device_name, len);
178 6739 : return 0;
179 : }
180 :
181 :
182 2428 : int wps_build_device_attrs(struct wps_device_data *dev, struct wpabuf *msg)
183 : {
184 4856 : if (wps_build_manufacturer(dev, msg) ||
185 4856 : wps_build_model_name(dev, msg) ||
186 4856 : wps_build_model_number(dev, msg) ||
187 4856 : wps_build_serial_number(dev, msg) ||
188 4856 : wps_build_primary_dev_type(dev, msg) ||
189 2428 : wps_build_dev_name(dev, msg))
190 0 : return -1;
191 2428 : return 0;
192 : }
193 :
194 :
195 889 : int wps_build_os_version(struct wps_device_data *dev, struct wpabuf *msg)
196 : {
197 889 : wpa_printf(MSG_DEBUG, "WPS: * OS Version");
198 889 : wpabuf_put_be16(msg, ATTR_OS_VERSION);
199 889 : wpabuf_put_be16(msg, 4);
200 889 : wpabuf_put_be32(msg, 0x80000000 | dev->os_version);
201 889 : return 0;
202 : }
203 :
204 :
205 459 : int wps_build_vendor_ext_m1(struct wps_device_data *dev, struct wpabuf *msg)
206 : {
207 459 : if (dev->vendor_ext_m1 != NULL) {
208 8 : wpa_hexdump(MSG_DEBUG, "WPS: * Vendor Extension M1",
209 4 : wpabuf_head_u8(dev->vendor_ext_m1),
210 4 : wpabuf_len(dev->vendor_ext_m1));
211 4 : wpabuf_put_be16(msg, ATTR_VENDOR_EXT);
212 4 : wpabuf_put_be16(msg, wpabuf_len(dev->vendor_ext_m1));
213 4 : wpabuf_put_buf(msg, dev->vendor_ext_m1);
214 : }
215 459 : return 0;
216 : }
217 :
218 :
219 5642 : int wps_build_rf_bands(struct wps_device_data *dev, struct wpabuf *msg,
220 : u8 rf_band)
221 : {
222 5642 : return wps_build_rf_bands_attr(msg, rf_band ? rf_band : dev->rf_bands);
223 : }
224 :
225 :
226 3078 : int wps_build_vendor_ext(struct wps_device_data *dev, struct wpabuf *msg)
227 : {
228 : int i;
229 :
230 33858 : for (i = 0; i < MAX_WPS_VENDOR_EXTENSIONS; i++) {
231 30780 : if (dev->vendor_ext[i] == NULL)
232 30774 : continue;
233 12 : wpa_hexdump(MSG_DEBUG, "WPS: * Vendor Extension",
234 6 : wpabuf_head_u8(dev->vendor_ext[i]),
235 6 : wpabuf_len(dev->vendor_ext[i]));
236 6 : wpabuf_put_be16(msg, ATTR_VENDOR_EXT);
237 6 : wpabuf_put_be16(msg, wpabuf_len(dev->vendor_ext[i]));
238 6 : wpabuf_put_buf(msg, dev->vendor_ext[i]);
239 : }
240 :
241 3078 : return 0;
242 : }
243 :
244 :
245 826 : static int wps_process_manufacturer(struct wps_device_data *dev, const u8 *str,
246 : size_t str_len)
247 : {
248 826 : if (str == NULL) {
249 1 : wpa_printf(MSG_DEBUG, "WPS: No Manufacturer received");
250 1 : return -1;
251 : }
252 :
253 825 : wpa_hexdump_ascii(MSG_DEBUG, "WPS: Manufacturer", str, str_len);
254 :
255 825 : os_free(dev->manufacturer);
256 825 : dev->manufacturer = dup_binstr(str, str_len);
257 825 : if (dev->manufacturer == NULL)
258 1 : return -1;
259 :
260 824 : return 0;
261 : }
262 :
263 :
264 824 : static int wps_process_model_name(struct wps_device_data *dev, const u8 *str,
265 : size_t str_len)
266 : {
267 824 : if (str == NULL) {
268 1 : wpa_printf(MSG_DEBUG, "WPS: No Model Name received");
269 1 : return -1;
270 : }
271 :
272 823 : wpa_hexdump_ascii(MSG_DEBUG, "WPS: Model Name", str, str_len);
273 :
274 823 : os_free(dev->model_name);
275 823 : dev->model_name = dup_binstr(str, str_len);
276 823 : if (dev->model_name == NULL)
277 1 : return -1;
278 :
279 822 : return 0;
280 : }
281 :
282 :
283 822 : static int wps_process_model_number(struct wps_device_data *dev, const u8 *str,
284 : size_t str_len)
285 : {
286 822 : if (str == NULL) {
287 1 : wpa_printf(MSG_DEBUG, "WPS: No Model Number received");
288 1 : return -1;
289 : }
290 :
291 821 : wpa_hexdump_ascii(MSG_DEBUG, "WPS: Model Number", str, str_len);
292 :
293 821 : os_free(dev->model_number);
294 821 : dev->model_number = dup_binstr(str, str_len);
295 821 : if (dev->model_number == NULL)
296 1 : return -1;
297 :
298 820 : return 0;
299 : }
300 :
301 :
302 820 : static int wps_process_serial_number(struct wps_device_data *dev,
303 : const u8 *str, size_t str_len)
304 : {
305 820 : if (str == NULL) {
306 1 : wpa_printf(MSG_DEBUG, "WPS: No Serial Number received");
307 1 : return -1;
308 : }
309 :
310 819 : wpa_hexdump_ascii(MSG_DEBUG, "WPS: Serial Number", str, str_len);
311 :
312 819 : os_free(dev->serial_number);
313 819 : dev->serial_number = dup_binstr(str, str_len);
314 819 : if (dev->serial_number == NULL)
315 1 : return -1;
316 :
317 818 : return 0;
318 : }
319 :
320 :
321 817 : static int wps_process_dev_name(struct wps_device_data *dev, const u8 *str,
322 : size_t str_len)
323 : {
324 817 : if (str == NULL) {
325 1 : wpa_printf(MSG_DEBUG, "WPS: No Device Name received");
326 1 : return -1;
327 : }
328 :
329 816 : wpa_hexdump_ascii(MSG_DEBUG, "WPS: Device Name", str, str_len);
330 :
331 816 : os_free(dev->device_name);
332 816 : dev->device_name = dup_binstr(str, str_len);
333 816 : if (dev->device_name == NULL)
334 1 : return -1;
335 :
336 815 : return 0;
337 : }
338 :
339 :
340 818 : static int wps_process_primary_dev_type(struct wps_device_data *dev,
341 : const u8 *dev_type)
342 : {
343 : #ifndef CONFIG_NO_STDOUT_DEBUG
344 : char devtype[WPS_DEV_TYPE_BUFSIZE];
345 : #endif /* CONFIG_NO_STDOUT_DEBUG */
346 :
347 818 : if (dev_type == NULL) {
348 1 : wpa_printf(MSG_DEBUG, "WPS: No Primary Device Type received");
349 1 : return -1;
350 : }
351 :
352 817 : os_memcpy(dev->pri_dev_type, dev_type, WPS_DEV_TYPE_LEN);
353 817 : wpa_printf(MSG_DEBUG, "WPS: Primary Device Type: %s",
354 817 : wps_dev_type_bin2str(dev->pri_dev_type, devtype,
355 : sizeof(devtype)));
356 :
357 817 : return 0;
358 : }
359 :
360 :
361 826 : int wps_process_device_attrs(struct wps_device_data *dev,
362 : struct wps_parse_attr *attr)
363 : {
364 826 : if (wps_process_manufacturer(dev, attr->manufacturer,
365 1650 : attr->manufacturer_len) ||
366 824 : wps_process_model_name(dev, attr->model_name,
367 1646 : attr->model_name_len) ||
368 822 : wps_process_model_number(dev, attr->model_number,
369 1642 : attr->model_number_len) ||
370 820 : wps_process_serial_number(dev, attr->serial_number,
371 1638 : attr->serial_number_len) ||
372 1635 : wps_process_primary_dev_type(dev, attr->primary_dev_type) ||
373 817 : wps_process_dev_name(dev, attr->dev_name, attr->dev_name_len))
374 11 : return -1;
375 815 : return 0;
376 : }
377 :
378 :
379 432 : int wps_process_os_version(struct wps_device_data *dev, const u8 *ver)
380 : {
381 432 : if (ver == NULL) {
382 1 : wpa_printf(MSG_DEBUG, "WPS: No OS Version received");
383 1 : return -1;
384 : }
385 :
386 431 : dev->os_version = WPA_GET_BE32(ver);
387 431 : wpa_printf(MSG_DEBUG, "WPS: OS Version %08x", dev->os_version);
388 :
389 431 : return 0;
390 : }
391 :
392 :
393 436 : int wps_process_rf_bands(struct wps_device_data *dev, const u8 *bands)
394 : {
395 436 : if (bands == NULL) {
396 1 : wpa_printf(MSG_DEBUG, "WPS: No RF Bands received");
397 1 : return -1;
398 : }
399 :
400 435 : dev->rf_bands = *bands;
401 435 : wpa_printf(MSG_DEBUG, "WPS: Enrollee RF Bands 0x%x", dev->rf_bands);
402 :
403 435 : return 0;
404 : }
405 :
406 :
407 1868 : void wps_device_data_free(struct wps_device_data *dev)
408 : {
409 1868 : os_free(dev->device_name);
410 1868 : dev->device_name = NULL;
411 1868 : os_free(dev->manufacturer);
412 1868 : dev->manufacturer = NULL;
413 1868 : os_free(dev->model_name);
414 1868 : dev->model_name = NULL;
415 1868 : os_free(dev->model_number);
416 1868 : dev->model_number = NULL;
417 1868 : os_free(dev->serial_number);
418 1868 : dev->serial_number = NULL;
419 1868 : }
|
