xref: /freebsd/contrib/wpa/src/wps/wps_dev_attr.c (revision 7750ad47a9a7dbc83f87158464170c8640723293)
1 /*
2  * Wi-Fi Protected Setup - device attributes
3  * Copyright (c) 2008, Jouni Malinen <j@w1.fi>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation.
8  *
9  * Alternatively, this software may be distributed under the terms of BSD
10  * license.
11  *
12  * See README and COPYING for more details.
13  */
14 
15 #include "includes.h"
16 
17 #include "common.h"
18 #include "wps_i.h"
19 #include "wps_dev_attr.h"
20 
21 
22 static int wps_build_manufacturer(struct wps_device_data *dev,
23 				  struct wpabuf *msg)
24 {
25 	size_t len;
26 	wpa_printf(MSG_DEBUG, "WPS:  * Manufacturer");
27 	wpabuf_put_be16(msg, ATTR_MANUFACTURER);
28 	len = dev->manufacturer ? os_strlen(dev->manufacturer) : 0;
29 	if (len == 0) {
30 		/*
31 		 * Some deployed WPS implementations fail to parse zero-length
32 		 * attributes. As a workaround, send a null character if the
33 		 * device attribute string is empty.
34 		 */
35 		wpabuf_put_be16(msg, 1);
36 		wpabuf_put_u8(msg, '\0');
37 	} else {
38 		wpabuf_put_be16(msg, len);
39 		wpabuf_put_data(msg, dev->manufacturer, len);
40 	}
41 	return 0;
42 }
43 
44 
45 static int wps_build_model_name(struct wps_device_data *dev,
46 				struct wpabuf *msg)
47 {
48 	size_t len;
49 	wpa_printf(MSG_DEBUG, "WPS:  * Model Name");
50 	wpabuf_put_be16(msg, ATTR_MODEL_NAME);
51 	len = dev->model_name ? os_strlen(dev->model_name) : 0;
52 	if (len == 0) {
53 		/*
54 		 * Some deployed WPS implementations fail to parse zero-length
55 		 * attributes. As a workaround, send a null character if the
56 		 * device attribute string is empty.
57 		 */
58 		wpabuf_put_be16(msg, 1);
59 		wpabuf_put_u8(msg, '\0');
60 	} else {
61 		wpabuf_put_be16(msg, len);
62 		wpabuf_put_data(msg, dev->model_name, len);
63 	}
64 	return 0;
65 }
66 
67 
68 static int wps_build_model_number(struct wps_device_data *dev,
69 				  struct wpabuf *msg)
70 {
71 	size_t len;
72 	wpa_printf(MSG_DEBUG, "WPS:  * Model Number");
73 	wpabuf_put_be16(msg, ATTR_MODEL_NUMBER);
74 	len = dev->model_number ? os_strlen(dev->model_number) : 0;
75 	if (len == 0) {
76 		/*
77 		 * Some deployed WPS implementations fail to parse zero-length
78 		 * attributes. As a workaround, send a null character if the
79 		 * device attribute string is empty.
80 		 */
81 		wpabuf_put_be16(msg, 1);
82 		wpabuf_put_u8(msg, '\0');
83 	} else {
84 		wpabuf_put_be16(msg, len);
85 		wpabuf_put_data(msg, dev->model_number, len);
86 	}
87 	return 0;
88 }
89 
90 
91 static int wps_build_serial_number(struct wps_device_data *dev,
92 				   struct wpabuf *msg)
93 {
94 	size_t len;
95 	wpa_printf(MSG_DEBUG, "WPS:  * Serial Number");
96 	wpabuf_put_be16(msg, ATTR_SERIAL_NUMBER);
97 	len = dev->serial_number ? os_strlen(dev->serial_number) : 0;
98 	if (len == 0) {
99 		/*
100 		 * Some deployed WPS implementations fail to parse zero-length
101 		 * attributes. As a workaround, send a null character if the
102 		 * device attribute string is empty.
103 		 */
104 		wpabuf_put_be16(msg, 1);
105 		wpabuf_put_u8(msg, '\0');
106 	} else {
107 		wpabuf_put_be16(msg, len);
108 		wpabuf_put_data(msg, dev->serial_number, len);
109 	}
110 	return 0;
111 }
112 
113 
114 int wps_build_primary_dev_type(struct wps_device_data *dev, struct wpabuf *msg)
115 {
116 	wpa_printf(MSG_DEBUG, "WPS:  * Primary Device Type");
117 	wpabuf_put_be16(msg, ATTR_PRIMARY_DEV_TYPE);
118 	wpabuf_put_be16(msg, WPS_DEV_TYPE_LEN);
119 	wpabuf_put_data(msg, dev->pri_dev_type, WPS_DEV_TYPE_LEN);
120 	return 0;
121 }
122 
123 
124 static int wps_build_dev_name(struct wps_device_data *dev, struct wpabuf *msg)
125 {
126 	size_t len;
127 	wpa_printf(MSG_DEBUG, "WPS:  * Device Name");
128 	wpabuf_put_be16(msg, ATTR_DEV_NAME);
129 	len = dev->device_name ? os_strlen(dev->device_name) : 0;
130 	if (len == 0) {
131 		/*
132 		 * Some deployed WPS implementations fail to parse zero-length
133 		 * attributes. As a workaround, send a null character if the
134 		 * device attribute string is empty.
135 		 */
136 		wpabuf_put_be16(msg, 1);
137 		wpabuf_put_u8(msg, '\0');
138 	} else {
139 		wpabuf_put_be16(msg, len);
140 		wpabuf_put_data(msg, dev->device_name, len);
141 	}
142 	return 0;
143 }
144 
145 
146 int wps_build_device_attrs(struct wps_device_data *dev, struct wpabuf *msg)
147 {
148 	if (wps_build_manufacturer(dev, msg) ||
149 	    wps_build_model_name(dev, msg) ||
150 	    wps_build_model_number(dev, msg) ||
151 	    wps_build_serial_number(dev, msg) ||
152 	    wps_build_primary_dev_type(dev, msg) ||
153 	    wps_build_dev_name(dev, msg))
154 		return -1;
155 	return 0;
156 }
157 
158 
159 int wps_build_os_version(struct wps_device_data *dev, struct wpabuf *msg)
160 {
161 	wpa_printf(MSG_DEBUG, "WPS:  * OS Version");
162 	wpabuf_put_be16(msg, ATTR_OS_VERSION);
163 	wpabuf_put_be16(msg, 4);
164 	wpabuf_put_be32(msg, 0x80000000 | dev->os_version);
165 	return 0;
166 }
167 
168 
169 int wps_build_rf_bands(struct wps_device_data *dev, struct wpabuf *msg)
170 {
171 	wpa_printf(MSG_DEBUG, "WPS:  * RF Bands (%x)", dev->rf_bands);
172 	wpabuf_put_be16(msg, ATTR_RF_BANDS);
173 	wpabuf_put_be16(msg, 1);
174 	wpabuf_put_u8(msg, dev->rf_bands);
175 	return 0;
176 }
177 
178 
179 static int wps_process_manufacturer(struct wps_device_data *dev, const u8 *str,
180 				    size_t str_len)
181 {
182 	if (str == NULL) {
183 		wpa_printf(MSG_DEBUG, "WPS: No Manufacturer received");
184 		return -1;
185 	}
186 
187 	wpa_hexdump_ascii(MSG_DEBUG, "WPS: Manufacturer", str, str_len);
188 
189 	os_free(dev->manufacturer);
190 	dev->manufacturer = os_malloc(str_len + 1);
191 	if (dev->manufacturer == NULL)
192 		return -1;
193 	os_memcpy(dev->manufacturer, str, str_len);
194 	dev->manufacturer[str_len] = '\0';
195 
196 	return 0;
197 }
198 
199 
200 static int wps_process_model_name(struct wps_device_data *dev, const u8 *str,
201 				  size_t str_len)
202 {
203 	if (str == NULL) {
204 		wpa_printf(MSG_DEBUG, "WPS: No Model Name received");
205 		return -1;
206 	}
207 
208 	wpa_hexdump_ascii(MSG_DEBUG, "WPS: Model Name", str, str_len);
209 
210 	os_free(dev->model_name);
211 	dev->model_name = os_malloc(str_len + 1);
212 	if (dev->model_name == NULL)
213 		return -1;
214 	os_memcpy(dev->model_name, str, str_len);
215 	dev->model_name[str_len] = '\0';
216 
217 	return 0;
218 }
219 
220 
221 static int wps_process_model_number(struct wps_device_data *dev, const u8 *str,
222 				    size_t str_len)
223 {
224 	if (str == NULL) {
225 		wpa_printf(MSG_DEBUG, "WPS: No Model Number received");
226 		return -1;
227 	}
228 
229 	wpa_hexdump_ascii(MSG_DEBUG, "WPS: Model Number", str, str_len);
230 
231 	os_free(dev->model_number);
232 	dev->model_number = os_malloc(str_len + 1);
233 	if (dev->model_number == NULL)
234 		return -1;
235 	os_memcpy(dev->model_number, str, str_len);
236 	dev->model_number[str_len] = '\0';
237 
238 	return 0;
239 }
240 
241 
242 static int wps_process_serial_number(struct wps_device_data *dev,
243 				     const u8 *str, size_t str_len)
244 {
245 	if (str == NULL) {
246 		wpa_printf(MSG_DEBUG, "WPS: No Serial Number received");
247 		return -1;
248 	}
249 
250 	wpa_hexdump_ascii(MSG_DEBUG, "WPS: Serial Number", str, str_len);
251 
252 	os_free(dev->serial_number);
253 	dev->serial_number = os_malloc(str_len + 1);
254 	if (dev->serial_number == NULL)
255 		return -1;
256 	os_memcpy(dev->serial_number, str, str_len);
257 	dev->serial_number[str_len] = '\0';
258 
259 	return 0;
260 }
261 
262 
263 static int wps_process_dev_name(struct wps_device_data *dev, const u8 *str,
264 				size_t str_len)
265 {
266 	if (str == NULL) {
267 		wpa_printf(MSG_DEBUG, "WPS: No Device Name received");
268 		return -1;
269 	}
270 
271 	wpa_hexdump_ascii(MSG_DEBUG, "WPS: Device Name", str, str_len);
272 
273 	os_free(dev->device_name);
274 	dev->device_name = os_malloc(str_len + 1);
275 	if (dev->device_name == NULL)
276 		return -1;
277 	os_memcpy(dev->device_name, str, str_len);
278 	dev->device_name[str_len] = '\0';
279 
280 	return 0;
281 }
282 
283 
284 static int wps_process_primary_dev_type(struct wps_device_data *dev,
285 					const u8 *dev_type)
286 {
287 #ifndef CONFIG_NO_STDOUT_DEBUG
288 	char devtype[WPS_DEV_TYPE_BUFSIZE];
289 #endif /* CONFIG_NO_STDOUT_DEBUG */
290 
291 	if (dev_type == NULL) {
292 		wpa_printf(MSG_DEBUG, "WPS: No Primary Device Type received");
293 		return -1;
294 	}
295 
296 	os_memcpy(dev->pri_dev_type, dev_type, WPS_DEV_TYPE_LEN);
297 	wpa_printf(MSG_DEBUG, "WPS: Primary Device Type: %s",
298 		   wps_dev_type_bin2str(dev->pri_dev_type, devtype,
299 					sizeof(devtype)));
300 
301 	return 0;
302 }
303 
304 
305 int wps_process_device_attrs(struct wps_device_data *dev,
306 			     struct wps_parse_attr *attr)
307 {
308 	if (wps_process_manufacturer(dev, attr->manufacturer,
309 				     attr->manufacturer_len) ||
310 	    wps_process_model_name(dev, attr->model_name,
311 				   attr->model_name_len) ||
312 	    wps_process_model_number(dev, attr->model_number,
313 				     attr->model_number_len) ||
314 	    wps_process_serial_number(dev, attr->serial_number,
315 				      attr->serial_number_len) ||
316 	    wps_process_primary_dev_type(dev, attr->primary_dev_type) ||
317 	    wps_process_dev_name(dev, attr->dev_name, attr->dev_name_len))
318 		return -1;
319 	return 0;
320 }
321 
322 
323 int wps_process_os_version(struct wps_device_data *dev, const u8 *ver)
324 {
325 	if (ver == NULL) {
326 		wpa_printf(MSG_DEBUG, "WPS: No OS Version received");
327 		return -1;
328 	}
329 
330 	dev->os_version = WPA_GET_BE32(ver);
331 	wpa_printf(MSG_DEBUG, "WPS: OS Version %08x", dev->os_version);
332 
333 	return 0;
334 }
335 
336 
337 int wps_process_rf_bands(struct wps_device_data *dev, const u8 *bands)
338 {
339 	if (bands == NULL) {
340 		wpa_printf(MSG_DEBUG, "WPS: No RF Bands received");
341 		return -1;
342 	}
343 
344 	dev->rf_bands = *bands;
345 	wpa_printf(MSG_DEBUG, "WPS: Enrollee RF Bands 0x%x", dev->rf_bands);
346 
347 	return 0;
348 }
349 
350 
351 void wps_device_data_dup(struct wps_device_data *dst,
352 			 const struct wps_device_data *src)
353 {
354 	if (src->device_name)
355 		dst->device_name = os_strdup(src->device_name);
356 	if (src->manufacturer)
357 		dst->manufacturer = os_strdup(src->manufacturer);
358 	if (src->model_name)
359 		dst->model_name = os_strdup(src->model_name);
360 	if (src->model_number)
361 		dst->model_number = os_strdup(src->model_number);
362 	if (src->serial_number)
363 		dst->serial_number = os_strdup(src->serial_number);
364 	os_memcpy(dst->pri_dev_type, src->pri_dev_type, WPS_DEV_TYPE_LEN);
365 	dst->os_version = src->os_version;
366 	dst->rf_bands = src->rf_bands;
367 }
368 
369 
370 void wps_device_data_free(struct wps_device_data *dev)
371 {
372 	os_free(dev->device_name);
373 	dev->device_name = NULL;
374 	os_free(dev->manufacturer);
375 	dev->manufacturer = NULL;
376 	os_free(dev->model_name);
377 	dev->model_name = NULL;
378 	os_free(dev->model_number);
379 	dev->model_number = NULL;
380 	os_free(dev->serial_number);
381 	dev->serial_number = NULL;
382 }
383