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
22static 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
45static 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
68static 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
91static 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
114int 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
124static 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
146int 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
159int 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
169int 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
179static 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
200static 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
221static 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
242static 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
263static 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
284static 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
305int 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
323int 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
337int 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
351void 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
370void 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