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