1 /* 2 * Wi-Fi Protected Setup - device attributes 3 * Copyright (c) 2008, Jouni Malinen <j (at) 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 struct wps_dev_type *d; 117 wpa_printf(MSG_DEBUG, "WPS: * Primary Device Type"); 118 wpabuf_put_be16(msg, ATTR_PRIMARY_DEV_TYPE); 119 wpabuf_put_be16(msg, sizeof(*d)); 120 d = wpabuf_put(msg, sizeof(*d)); 121 WPA_PUT_BE16(d->categ_id, dev->categ); 122 WPA_PUT_BE32(d->oui, dev->oui); 123 WPA_PUT_BE16(d->sub_categ_id, dev->sub_categ); 124 return 0; 125 } 126 127 128 static int wps_build_dev_name(struct wps_device_data *dev, struct wpabuf *msg) 129 { 130 size_t len; 131 wpa_printf(MSG_DEBUG, "WPS: * Device Name"); 132 wpabuf_put_be16(msg, ATTR_DEV_NAME); 133 len = dev->device_name ? os_strlen(dev->device_name) : 0; 134 if (len == 0) { 135 /* 136 * Some deployed WPS implementations fail to parse zero-length 137 * attributes. As a workaround, send a null character if the 138 * device attribute string is empty. 139 */ 140 wpabuf_put_be16(msg, 1); 141 wpabuf_put_u8(msg, '\0'); 142 } else { 143 wpabuf_put_be16(msg, len); 144 wpabuf_put_data(msg, dev->device_name, len); 145 } 146 return 0; 147 } 148 149 150 int wps_build_device_attrs(struct wps_device_data *dev, struct wpabuf *msg) 151 { 152 if (wps_build_manufacturer(dev, msg) || 153 wps_build_model_name(dev, msg) || 154 wps_build_model_number(dev, msg) || 155 wps_build_serial_number(dev, msg) || 156 wps_build_primary_dev_type(dev, msg) || 157 wps_build_dev_name(dev, msg)) 158 return -1; 159 return 0; 160 } 161 162 163 int wps_build_os_version(struct wps_device_data *dev, struct wpabuf *msg) 164 { 165 wpa_printf(MSG_DEBUG, "WPS: * OS Version"); 166 wpabuf_put_be16(msg, ATTR_OS_VERSION); 167 wpabuf_put_be16(msg, 4); 168 wpabuf_put_be32(msg, 0x80000000 | dev->os_version); 169 return 0; 170 } 171 172 173 int wps_build_rf_bands(struct wps_device_data *dev, struct wpabuf *msg) 174 { 175 wpa_printf(MSG_DEBUG, "WPS: * RF Bands (%x)", dev->rf_bands); 176 wpabuf_put_be16(msg, ATTR_RF_BANDS); 177 wpabuf_put_be16(msg, 1); 178 wpabuf_put_u8(msg, dev->rf_bands); 179 return 0; 180 } 181 182 183 static int wps_process_manufacturer(struct wps_device_data *dev, const u8 *str, 184 size_t str_len) 185 { 186 if (str == NULL) { 187 wpa_printf(MSG_DEBUG, "WPS: No Manufacturer received"); 188 return -1; 189 } 190 191 wpa_hexdump_ascii(MSG_DEBUG, "WPS: Manufacturer", str, str_len); 192 193 os_free(dev->manufacturer); 194 dev->manufacturer = os_malloc(str_len + 1); 195 if (dev->manufacturer == NULL) 196 return -1; 197 os_memcpy(dev->manufacturer, str, str_len); 198 dev->manufacturer[str_len] = '\0'; 199 200 return 0; 201 } 202 203 204 static int wps_process_model_name(struct wps_device_data *dev, const u8 *str, 205 size_t str_len) 206 { 207 if (str == NULL) { 208 wpa_printf(MSG_DEBUG, "WPS: No Model Name received"); 209 return -1; 210 } 211 212 wpa_hexdump_ascii(MSG_DEBUG, "WPS: Model Name", str, str_len); 213 214 os_free(dev->model_name); 215 dev->model_name = os_malloc(str_len + 1); 216 if (dev->model_name == NULL) 217 return -1; 218 os_memcpy(dev->model_name, str, str_len); 219 dev->model_name[str_len] = '\0'; 220 221 return 0; 222 } 223 224 225 static int wps_process_model_number(struct wps_device_data *dev, const u8 *str, 226 size_t str_len) 227 { 228 if (str == NULL) { 229 wpa_printf(MSG_DEBUG, "WPS: No Model Number received"); 230 return -1; 231 } 232 233 wpa_hexdump_ascii(MSG_DEBUG, "WPS: Model Number", str, str_len); 234 235 os_free(dev->model_number); 236 dev->model_number = os_malloc(str_len + 1); 237 if (dev->model_number == NULL) 238 return -1; 239 os_memcpy(dev->model_number, str, str_len); 240 dev->model_number[str_len] = '\0'; 241 242 return 0; 243 } 244 245 246 static int wps_process_serial_number(struct wps_device_data *dev, 247 const u8 *str, size_t str_len) 248 { 249 if (str == NULL) { 250 wpa_printf(MSG_DEBUG, "WPS: No Serial Number received"); 251 return -1; 252 } 253 254 wpa_hexdump_ascii(MSG_DEBUG, "WPS: Serial Number", str, str_len); 255 256 os_free(dev->serial_number); 257 dev->serial_number = os_malloc(str_len + 1); 258 if (dev->serial_number == NULL) 259 return -1; 260 os_memcpy(dev->serial_number, str, str_len); 261 dev->serial_number[str_len] = '\0'; 262 263 return 0; 264 } 265 266 267 static int wps_process_dev_name(struct wps_device_data *dev, const u8 *str, 268 size_t str_len) 269 { 270 if (str == NULL) { 271 wpa_printf(MSG_DEBUG, "WPS: No Device Name received"); 272 return -1; 273 } 274 275 wpa_hexdump_ascii(MSG_DEBUG, "WPS: Device Name", str, str_len); 276 277 os_free(dev->device_name); 278 dev->device_name = os_malloc(str_len + 1); 279 if (dev->device_name == NULL) 280 return -1; 281 os_memcpy(dev->device_name, str, str_len); 282 dev->device_name[str_len] = '\0'; 283 284 return 0; 285 } 286 287 288 static int wps_process_primary_dev_type(struct wps_device_data *dev, 289 const u8 *dev_type) 290 { 291 struct wps_dev_type *d; 292 293 if (dev_type == NULL) { 294 wpa_printf(MSG_DEBUG, "WPS: No Primary Device Type received"); 295 return -1; 296 } 297 298 d = (struct wps_dev_type *) dev_type; 299 dev->categ = WPA_GET_BE16(d->categ_id); 300 dev->oui = WPA_GET_BE32(d->oui); 301 dev->sub_categ = WPA_GET_BE16(d->sub_categ_id); 302 303 wpa_printf(MSG_DEBUG, "WPS: Primary Device Type: category %d " 304 "OUI %08x sub-category %d", 305 dev->categ, dev->oui, dev->sub_categ); 306 307 return 0; 308 } 309 310 311 int wps_process_device_attrs(struct wps_device_data *dev, 312 struct wps_parse_attr *attr) 313 { 314 if (wps_process_manufacturer(dev, attr->manufacturer, 315 attr->manufacturer_len) || 316 wps_process_model_name(dev, attr->model_name, 317 attr->model_name_len) || 318 wps_process_model_number(dev, attr->model_number, 319 attr->model_number_len) || 320 wps_process_serial_number(dev, attr->serial_number, 321 attr->serial_number_len) || 322 wps_process_primary_dev_type(dev, attr->primary_dev_type) || 323 wps_process_dev_name(dev, attr->dev_name, attr->dev_name_len)) 324 return -1; 325 return 0; 326 } 327 328 329 int wps_process_os_version(struct wps_device_data *dev, const u8 *ver) 330 { 331 if (ver == NULL) { 332 wpa_printf(MSG_DEBUG, "WPS: No OS Version received"); 333 return -1; 334 } 335 336 dev->os_version = WPA_GET_BE32(ver); 337 wpa_printf(MSG_DEBUG, "WPS: OS Version %08x", dev->os_version); 338 339 return 0; 340 } 341 342 343 int wps_process_rf_bands(struct wps_device_data *dev, const u8 *bands) 344 { 345 if (bands == NULL) { 346 wpa_printf(MSG_DEBUG, "WPS: No RF Bands received"); 347 return -1; 348 } 349 350 dev->rf_bands = *bands; 351 wpa_printf(MSG_DEBUG, "WPS: Enrollee RF Bands 0x%x", dev->rf_bands); 352 353 return 0; 354 } 355 356 357 void wps_device_data_dup(struct wps_device_data *dst, 358 const struct wps_device_data *src) 359 { 360 if (src->device_name) 361 dst->device_name = os_strdup(src->device_name); 362 if (src->manufacturer) 363 dst->manufacturer = os_strdup(src->manufacturer); 364 if (src->model_name) 365 dst->model_name = os_strdup(src->model_name); 366 if (src->model_number) 367 dst->model_number = os_strdup(src->model_number); 368 if (src->serial_number) 369 dst->serial_number = os_strdup(src->serial_number); 370 dst->categ = src->categ; 371 dst->oui = src->oui; 372 dst->sub_categ = src->sub_categ; 373 dst->os_version = src->os_version; 374 dst->rf_bands = src->rf_bands; 375 } 376 377 378 void wps_device_data_free(struct wps_device_data *dev) 379 { 380 os_free(dev->device_name); 381 dev->device_name = NULL; 382 os_free(dev->manufacturer); 383 dev->manufacturer = NULL; 384 os_free(dev->model_name); 385 dev->model_name = NULL; 386 os_free(dev->model_number); 387 dev->model_number = NULL; 388 os_free(dev->serial_number); 389 dev->serial_number = NULL; 390 } 391
