1 /* 2 * P2P - IE parser 3 * Copyright (c) 2009-2010, Atheros Communications 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 "common/ieee802_11_defs.h" 13 #include "common/ieee802_11_common.h" 14 #include "wps/wps_i.h" 15 #include "p2p_i.h" 16 17 18 static int p2p_parse_attribute(u8 id, const u8 *data, u16 len, 19 struct p2p_message *msg) 20 { 21 const u8 *pos; 22 size_t i, nlen; 23 char devtype[WPS_DEV_TYPE_BUFSIZE]; 24 25 switch (id) { 26 case P2P_ATTR_CAPABILITY: 27 if (len < 2) { 28 wpa_printf(MSG_DEBUG, "P2P: Too short Capability " 29 "attribute (length %d)", len); 30 return -1; 31 } 32 msg->capability = data; 33 wpa_printf(MSG_DEBUG, "P2P: * Device Capability %02x " 34 "Group Capability %02x", 35 data[0], data[1]); 36 break; 37 case P2P_ATTR_DEVICE_ID: 38 if (len < ETH_ALEN) { 39 wpa_printf(MSG_DEBUG, "P2P: Too short Device ID " 40 "attribute (length %d)", len); 41 return -1; 42 } 43 msg->device_id = data; 44 wpa_printf(MSG_DEBUG, "P2P: * Device ID " MACSTR, 45 MAC2STR(msg->device_id)); 46 break; 47 case P2P_ATTR_GROUP_OWNER_INTENT: 48 if (len < 1) { 49 wpa_printf(MSG_DEBUG, "P2P: Too short GO Intent " 50 "attribute (length %d)", len); 51 return -1; 52 } 53 msg->go_intent = data; 54 wpa_printf(MSG_DEBUG, "P2P: * GO Intent: Intent %u " 55 "Tie breaker %u", data[0] >> 1, data[0] & 0x01); 56 break; 57 case P2P_ATTR_STATUS: 58 if (len < 1) { 59 wpa_printf(MSG_DEBUG, "P2P: Too short Status " 60 "attribute (length %d)", len); 61 return -1; 62 } 63 msg->status = data; 64 wpa_printf(MSG_DEBUG, "P2P: * Status: %d", data[0]); 65 break; 66 case P2P_ATTR_LISTEN_CHANNEL: 67 if (len == 0) { 68 wpa_printf(MSG_DEBUG, "P2P: * Listen Channel: Ignore " 69 "null channel"); 70 break; 71 } 72 if (len < 5) { 73 wpa_printf(MSG_DEBUG, "P2P: Too short Listen Channel " 74 "attribute (length %d)", len); 75 return -1; 76 } 77 msg->listen_channel = data; 78 wpa_printf(MSG_DEBUG, "P2P: * Listen Channel: " 79 "Country %c%c(0x%02x) Regulatory " 80 "Class %d Channel Number %d", data[0], data[1], 81 data[2], data[3], data[4]); 82 break; 83 case P2P_ATTR_OPERATING_CHANNEL: 84 if (len == 0) { 85 wpa_printf(MSG_DEBUG, "P2P: * Operating Channel: " 86 "Ignore null channel"); 87 break; 88 } 89 if (len < 5) { 90 wpa_printf(MSG_DEBUG, "P2P: Too short Operating " 91 "Channel attribute (length %d)", len); 92 return -1; 93 } 94 msg->operating_channel = data; 95 wpa_printf(MSG_DEBUG, "P2P: * Operating Channel: " 96 "Country %c%c(0x%02x) Regulatory " 97 "Class %d Channel Number %d", data[0], data[1], 98 data[2], data[3], data[4]); 99 break; 100 case P2P_ATTR_CHANNEL_LIST: 101 if (len < 3) { 102 wpa_printf(MSG_DEBUG, "P2P: Too short Channel List " 103 "attribute (length %d)", len); 104 return -1; 105 } 106 msg->channel_list = data; 107 msg->channel_list_len = len; 108 wpa_printf(MSG_DEBUG, "P2P: * Channel List: Country String " 109 "'%c%c(0x%02x)'", data[0], data[1], data[2]); 110 wpa_hexdump(MSG_MSGDUMP, "P2P: Channel List", 111 msg->channel_list, msg->channel_list_len); 112 break; 113 case P2P_ATTR_GROUP_INFO: 114 msg->group_info = data; 115 msg->group_info_len = len; 116 wpa_printf(MSG_DEBUG, "P2P: * Group Info"); 117 break; 118 case P2P_ATTR_DEVICE_INFO: 119 if (len < ETH_ALEN + 2 + 8 + 1) { 120 wpa_printf(MSG_DEBUG, "P2P: Too short Device Info " 121 "attribute (length %d)", len); 122 return -1; 123 } 124 msg->p2p_device_info = data; 125 msg->p2p_device_info_len = len; 126 pos = data; 127 msg->p2p_device_addr = pos; 128 pos += ETH_ALEN; 129 msg->config_methods = WPA_GET_BE16(pos); 130 pos += 2; 131 msg->pri_dev_type = pos; 132 pos += 8; 133 msg->num_sec_dev_types = *pos++; 134 if (msg->num_sec_dev_types * 8 > data + len - pos) { 135 wpa_printf(MSG_DEBUG, "P2P: Device Info underflow"); 136 return -1; 137 } 138 pos += msg->num_sec_dev_types * 8; 139 if (data + len - pos < 4) { 140 wpa_printf(MSG_DEBUG, "P2P: Invalid Device Name " 141 "length %d", (int) (data + len - pos)); 142 return -1; 143 } 144 if (WPA_GET_BE16(pos) != ATTR_DEV_NAME) { 145 wpa_hexdump(MSG_DEBUG, "P2P: Unexpected Device Name " 146 "header", pos, 4); 147 return -1; 148 } 149 pos += 2; 150 nlen = WPA_GET_BE16(pos); 151 pos += 2; 152 if (data + len - pos < (int) nlen || 153 nlen > WPS_DEV_NAME_MAX_LEN) { 154 wpa_printf(MSG_DEBUG, "P2P: Invalid Device Name " 155 "length %d (buf len %d)", (int) nlen, 156 (int) (data + len - pos)); 157 return -1; 158 } 159 os_memcpy(msg->device_name, pos, nlen); 160 msg->device_name[nlen] = '\0'; 161 for (i = 0; i < nlen; i++) { 162 if (msg->device_name[i] == '\0') 163 break; 164 if (is_ctrl_char(msg->device_name[i])) 165 msg->device_name[i] = '_'; 166 } 167 wpa_printf(MSG_DEBUG, "P2P: * Device Info: addr " MACSTR 168 " primary device type %s device name '%s' " 169 "config methods 0x%x", 170 MAC2STR(msg->p2p_device_addr), 171 wps_dev_type_bin2str(msg->pri_dev_type, devtype, 172 sizeof(devtype)), 173 msg->device_name, msg->config_methods); 174 break; 175 case P2P_ATTR_CONFIGURATION_TIMEOUT: 176 if (len < 2) { 177 wpa_printf(MSG_DEBUG, "P2P: Too short Configuration " 178 "Timeout attribute (length %d)", len); 179 return -1; 180 } 181 msg->config_timeout = data; 182 wpa_printf(MSG_DEBUG, "P2P: * Configuration Timeout"); 183 break; 184 case P2P_ATTR_INTENDED_INTERFACE_ADDR: 185 if (len < ETH_ALEN) { 186 wpa_printf(MSG_DEBUG, "P2P: Too short Intended P2P " 187 "Interface Address attribute (length %d)", 188 len); 189 return -1; 190 } 191 msg->intended_addr = data; 192 wpa_printf(MSG_DEBUG, "P2P: * Intended P2P Interface Address: " 193 MACSTR, MAC2STR(msg->intended_addr)); 194 break; 195 case P2P_ATTR_GROUP_BSSID: 196 if (len < ETH_ALEN) { 197 wpa_printf(MSG_DEBUG, "P2P: Too short P2P Group BSSID " 198 "attribute (length %d)", len); 199 return -1; 200 } 201 msg->group_bssid = data; 202 wpa_printf(MSG_DEBUG, "P2P: * P2P Group BSSID: " MACSTR, 203 MAC2STR(msg->group_bssid)); 204 break; 205 case P2P_ATTR_GROUP_ID: 206 if (len < ETH_ALEN || len > ETH_ALEN + SSID_MAX_LEN) { 207 wpa_printf(MSG_DEBUG, "P2P: Invalid P2P Group ID " 208 "attribute length %d", len); 209 return -1; 210 } 211 msg->group_id = data; 212 msg->group_id_len = len; 213 wpa_printf(MSG_DEBUG, "P2P: * P2P Group ID: Device Address " 214 MACSTR, MAC2STR(msg->group_id)); 215 wpa_hexdump_ascii(MSG_DEBUG, "P2P: * P2P Group ID: SSID", 216 msg->group_id + ETH_ALEN, 217 msg->group_id_len - ETH_ALEN); 218 break; 219 case P2P_ATTR_INVITATION_FLAGS: 220 if (len < 1) { 221 wpa_printf(MSG_DEBUG, "P2P: Too short Invitation " 222 "Flag attribute (length %d)", len); 223 return -1; 224 } 225 msg->invitation_flags = data; 226 wpa_printf(MSG_DEBUG, "P2P: * Invitation Flags: bitmap 0x%x", 227 data[0]); 228 break; 229 case P2P_ATTR_MANAGEABILITY: 230 if (len < 1) { 231 wpa_printf(MSG_DEBUG, "P2P: Too short Manageability " 232 "attribute (length %d)", len); 233 return -1; 234 } 235 msg->manageability = data; 236 wpa_printf(MSG_DEBUG, "P2P: * Manageability: bitmap 0x%x", 237 data[0]); 238 break; 239 case P2P_ATTR_NOTICE_OF_ABSENCE: 240 if (len < 2) { 241 wpa_printf(MSG_DEBUG, "P2P: Too short Notice of " 242 "Absence attribute (length %d)", len); 243 return -1; 244 } 245 msg->noa = data; 246 msg->noa_len = len; 247 wpa_printf(MSG_DEBUG, "P2P: * Notice of Absence"); 248 break; 249 case P2P_ATTR_EXT_LISTEN_TIMING: 250 if (len < 4) { 251 wpa_printf(MSG_DEBUG, "P2P: Too short Extended Listen " 252 "Timing attribute (length %d)", len); 253 return -1; 254 } 255 msg->ext_listen_timing = data; 256 wpa_printf(MSG_DEBUG, "P2P: * Extended Listen Timing " 257 "(period %u msec interval %u msec)", 258 WPA_GET_LE16(msg->ext_listen_timing), 259 WPA_GET_LE16(msg->ext_listen_timing + 2)); 260 break; 261 case P2P_ATTR_MINOR_REASON_CODE: 262 if (len < 1) { 263 wpa_printf(MSG_DEBUG, "P2P: Too short Minor Reason " 264 "Code attribute (length %d)", len); 265 return -1; 266 } 267 msg->minor_reason_code = data; 268 wpa_printf(MSG_DEBUG, "P2P: * Minor Reason Code: %u", 269 *msg->minor_reason_code); 270 break; 271 case P2P_ATTR_OOB_GO_NEG_CHANNEL: 272 if (len < 6) { 273 wpa_printf(MSG_DEBUG, "P2P: Too short OOB GO Neg " 274 "Channel attribute (length %d)", len); 275 return -1; 276 } 277 msg->oob_go_neg_channel = data; 278 wpa_printf(MSG_DEBUG, "P2P: * OOB GO Neg Channel: " 279 "Country %c%c(0x%02x) Operating Class %d " 280 "Channel Number %d Role %d", 281 data[0], data[1], data[2], data[3], data[4], 282 data[5]); 283 break; 284 case P2P_ATTR_SERVICE_HASH: 285 if (len < P2PS_HASH_LEN) { 286 wpa_printf(MSG_DEBUG, 287 "P2P: Too short Service Hash (length %u)", 288 len); 289 return -1; 290 } 291 msg->service_hash_count = len / P2PS_HASH_LEN; 292 msg->service_hash = data; 293 wpa_hexdump(MSG_DEBUG, "P2P: * Service Hash(s)", data, len); 294 break; 295 case P2P_ATTR_SESSION_INFORMATION_DATA: 296 msg->session_info = data; 297 msg->session_info_len = len; 298 wpa_printf(MSG_DEBUG, "P2P: * Service Instance: %u bytes - %p", 299 len, data); 300 break; 301 case P2P_ATTR_CONNECTION_CAPABILITY: 302 if (len < 1) { 303 wpa_printf(MSG_DEBUG, 304 "P2P: Too short Connection Capability (length %u)", 305 len); 306 return -1; 307 } 308 msg->conn_cap = data; 309 wpa_printf(MSG_DEBUG, "P2P: * Connection Capability: 0x%x", 310 *msg->conn_cap); 311 break; 312 case P2P_ATTR_ADVERTISEMENT_ID: 313 if (len < 10) { 314 wpa_printf(MSG_DEBUG, 315 "P2P: Too short Advertisement ID (length %u)", 316 len); 317 return -1; 318 } 319 msg->adv_id = data; 320 msg->adv_mac = &data[sizeof(u32)]; 321 wpa_printf(MSG_DEBUG, "P2P: * Advertisement ID %x", 322 WPA_GET_LE32(data)); 323 break; 324 case P2P_ATTR_ADVERTISED_SERVICE: 325 if (len < 8) { 326 wpa_printf(MSG_DEBUG, 327 "P2P: Too short Service Instance (length %u)", 328 len); 329 return -1; 330 } 331 msg->adv_service_instance = data; 332 msg->adv_service_instance_len = len; 333 if (len <= 255 + 8) { 334 char str[256]; 335 u8 namelen; 336 337 namelen = data[6]; 338 if (namelen > len - 7) 339 break; 340 os_memcpy(str, &data[7], namelen); 341 str[namelen] = '\0'; 342 wpa_printf(MSG_DEBUG, "P2P: * Service Instance: %x-%s", 343 WPA_GET_LE32(data), str); 344 } else { 345 wpa_printf(MSG_DEBUG, "P2P: * Service Instance: %p", 346 data); 347 } 348 break; 349 case P2P_ATTR_SESSION_ID: 350 if (len < sizeof(u32) + ETH_ALEN) { 351 wpa_printf(MSG_DEBUG, 352 "P2P: Too short Session ID Info (length %u)", 353 len); 354 return -1; 355 } 356 msg->session_id = data; 357 msg->session_mac = &data[sizeof(u32)]; 358 wpa_printf(MSG_DEBUG, "P2P: * Session ID: %x " MACSTR, 359 WPA_GET_LE32(data), MAC2STR(msg->session_mac)); 360 break; 361 case P2P_ATTR_FEATURE_CAPABILITY: 362 if (!len) { 363 wpa_printf(MSG_DEBUG, 364 "P2P: Too short Feature Capability (length %u)", 365 len); 366 return -1; 367 } 368 msg->feature_cap = data; 369 msg->feature_cap_len = len; 370 wpa_printf(MSG_DEBUG, "P2P: * Feature Cap (length=%u)", len); 371 break; 372 case P2P_ATTR_PERSISTENT_GROUP: 373 { 374 if (len < ETH_ALEN || len > ETH_ALEN + SSID_MAX_LEN) { 375 wpa_printf(MSG_DEBUG, 376 "P2P: Invalid Persistent Group Info (length %u)", 377 len); 378 return -1; 379 } 380 381 msg->persistent_dev = data; 382 msg->persistent_ssid_len = len - ETH_ALEN; 383 msg->persistent_ssid = &data[ETH_ALEN]; 384 wpa_printf(MSG_DEBUG, "P2P: * Persistent Group: " MACSTR " %s", 385 MAC2STR(msg->persistent_dev), 386 wpa_ssid_txt(msg->persistent_ssid, 387 msg->persistent_ssid_len)); 388 break; 389 } 390 default: 391 wpa_printf(MSG_DEBUG, "P2P: Skipped unknown attribute %d " 392 "(length %d)", id, len); 393 break; 394 } 395 396 return 0; 397 } 398 399 400 /** 401 * p2p_parse_p2p_ie - Parse P2P IE 402 * @buf: Concatenated P2P IE(s) payload 403 * @msg: Buffer for returning parsed attributes 404 * Returns: 0 on success, -1 on failure 405 * 406 * Note: Caller is responsible for clearing the msg data structure before 407 * calling this function. 408 */ 409 int p2p_parse_p2p_ie(const struct wpabuf *buf, struct p2p_message *msg) 410 { 411 const u8 *pos = wpabuf_head_u8(buf); 412 const u8 *end = pos + wpabuf_len(buf); 413 414 wpa_printf(MSG_DEBUG, "P2P: Parsing P2P IE"); 415 416 while (pos < end) { 417 u16 attr_len; 418 u8 id; 419 420 if (end - pos < 3) { 421 wpa_printf(MSG_DEBUG, "P2P: Invalid P2P attribute"); 422 return -1; 423 } 424 id = *pos++; 425 attr_len = WPA_GET_LE16(pos); 426 pos += 2; 427 wpa_printf(MSG_DEBUG, "P2P: Attribute %d length %u", 428 id, attr_len); 429 if (attr_len > end - pos) { 430 wpa_printf(MSG_DEBUG, "P2P: Attribute underflow " 431 "(len=%u left=%d)", 432 attr_len, (int) (end - pos)); 433 wpa_hexdump(MSG_MSGDUMP, "P2P: Data", pos, end - pos); 434 return -1; 435 } 436 if (p2p_parse_attribute(id, pos, attr_len, msg)) 437 return -1; 438 pos += attr_len; 439 } 440 441 return 0; 442 } 443 444 445 static int p2p_parse_wps_ie(const struct wpabuf *buf, struct p2p_message *msg) 446 { 447 struct wps_parse_attr attr; 448 int i; 449 450 wpa_printf(MSG_DEBUG, "P2P: Parsing WPS IE"); 451 if (wps_parse_msg(buf, &attr)) 452 return -1; 453 if (attr.dev_name && attr.dev_name_len < sizeof(msg->device_name) && 454 !msg->device_name[0]) 455 os_memcpy(msg->device_name, attr.dev_name, attr.dev_name_len); 456 if (attr.config_methods) { 457 msg->wps_config_methods = 458 WPA_GET_BE16(attr.config_methods); 459 wpa_printf(MSG_DEBUG, "P2P: Config Methods (WPS): 0x%x", 460 msg->wps_config_methods); 461 } 462 if (attr.dev_password_id) { 463 msg->dev_password_id = WPA_GET_BE16(attr.dev_password_id); 464 wpa_printf(MSG_DEBUG, "P2P: Device Password ID: %d", 465 msg->dev_password_id); 466 msg->dev_password_id_present = 1; 467 } 468 if (attr.primary_dev_type) { 469 char devtype[WPS_DEV_TYPE_BUFSIZE]; 470 msg->wps_pri_dev_type = attr.primary_dev_type; 471 wpa_printf(MSG_DEBUG, "P2P: Primary Device Type (WPS): %s", 472 wps_dev_type_bin2str(msg->wps_pri_dev_type, devtype, 473 sizeof(devtype))); 474 } 475 if (attr.sec_dev_type_list) { 476 msg->wps_sec_dev_type_list = attr.sec_dev_type_list; 477 msg->wps_sec_dev_type_list_len = attr.sec_dev_type_list_len; 478 } 479 480 for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) { 481 msg->wps_vendor_ext[i] = attr.vendor_ext[i]; 482 msg->wps_vendor_ext_len[i] = attr.vendor_ext_len[i]; 483 } 484 485 msg->manufacturer = attr.manufacturer; 486 msg->manufacturer_len = attr.manufacturer_len; 487 msg->model_name = attr.model_name; 488 msg->model_name_len = attr.model_name_len; 489 msg->model_number = attr.model_number; 490 msg->model_number_len = attr.model_number_len; 491 msg->serial_number = attr.serial_number; 492 msg->serial_number_len = attr.serial_number_len; 493 494 msg->oob_dev_password = attr.oob_dev_password; 495 msg->oob_dev_password_len = attr.oob_dev_password_len; 496 497 return 0; 498 } 499 500 501 /** 502 * p2p_parse_ies - Parse P2P message IEs (both WPS and P2P IE) 503 * @data: IEs from the message 504 * @len: Length of data buffer in octets 505 * @msg: Buffer for returning parsed attributes 506 * Returns: 0 on success, -1 on failure 507 * 508 * Note: Caller is responsible for clearing the msg data structure before 509 * calling this function. 510 * 511 * Note: Caller must free temporary memory allocations by calling 512 * p2p_parse_free() when the parsed data is not needed anymore. 513 */ 514 int p2p_parse_ies(const u8 *data, size_t len, struct p2p_message *msg) 515 { 516 struct ieee802_11_elems elems; 517 518 ieee802_11_parse_elems(data, len, &elems, 0); 519 if (elems.ds_params) 520 msg->ds_params = elems.ds_params; 521 if (elems.ssid) 522 msg->ssid = elems.ssid - 2; 523 524 msg->wps_attributes = ieee802_11_vendor_ie_concat(data, len, 525 WPS_DEV_OUI_WFA); 526 if (msg->wps_attributes && 527 p2p_parse_wps_ie(msg->wps_attributes, msg)) { 528 p2p_parse_free(msg); 529 return -1; 530 } 531 532 msg->p2p_attributes = ieee802_11_vendor_ie_concat(data, len, 533 P2P_IE_VENDOR_TYPE); 534 if (msg->p2p_attributes && 535 p2p_parse_p2p_ie(msg->p2p_attributes, msg)) { 536 wpa_printf(MSG_DEBUG, "P2P: Failed to parse P2P IE data"); 537 if (msg->p2p_attributes) 538 wpa_hexdump_buf(MSG_MSGDUMP, "P2P: P2P IE data", 539 msg->p2p_attributes); 540 p2p_parse_free(msg); 541 return -1; 542 } 543 544 #ifdef CONFIG_WIFI_DISPLAY 545 if (elems.wfd) { 546 msg->wfd_subelems = ieee802_11_vendor_ie_concat( 547 data, len, WFD_IE_VENDOR_TYPE); 548 } 549 #endif /* CONFIG_WIFI_DISPLAY */ 550 551 msg->pref_freq_list = elems.pref_freq_list; 552 msg->pref_freq_list_len = elems.pref_freq_list_len; 553 554 return 0; 555 } 556 557 558 /** 559 * p2p_parse - Parse a P2P Action frame contents 560 * @data: Action frame payload after Category and Code fields 561 * @len: Length of data buffer in octets 562 * @msg: Buffer for returning parsed attributes 563 * Returns: 0 on success, -1 on failure 564 * 565 * Note: Caller must free temporary memory allocations by calling 566 * p2p_parse_free() when the parsed data is not needed anymore. 567 */ 568 int p2p_parse(const u8 *data, size_t len, struct p2p_message *msg) 569 { 570 os_memset(msg, 0, sizeof(*msg)); 571 wpa_printf(MSG_DEBUG, "P2P: Parsing the received message"); 572 if (len < 1) { 573 wpa_printf(MSG_DEBUG, "P2P: No Dialog Token in the message"); 574 return -1; 575 } 576 msg->dialog_token = data[0]; 577 wpa_printf(MSG_DEBUG, "P2P: * Dialog Token: %d", msg->dialog_token); 578 579 return p2p_parse_ies(data + 1, len - 1, msg); 580 } 581 582 583 int p2p_parse_ies_separate(const u8 *wsc, size_t wsc_len, const u8 *p2p, 584 size_t p2p_len, struct p2p_message *msg) 585 { 586 os_memset(msg, 0, sizeof(*msg)); 587 588 msg->wps_attributes = wpabuf_alloc_copy(wsc, wsc_len); 589 if (msg->wps_attributes && 590 p2p_parse_wps_ie(msg->wps_attributes, msg)) { 591 p2p_parse_free(msg); 592 return -1; 593 } 594 595 msg->p2p_attributes = wpabuf_alloc_copy(p2p, p2p_len); 596 if (msg->p2p_attributes && 597 p2p_parse_p2p_ie(msg->p2p_attributes, msg)) { 598 wpa_printf(MSG_DEBUG, "P2P: Failed to parse P2P IE data"); 599 if (msg->p2p_attributes) 600 wpa_hexdump_buf(MSG_MSGDUMP, "P2P: P2P IE data", 601 msg->p2p_attributes); 602 p2p_parse_free(msg); 603 return -1; 604 } 605 606 return 0; 607 } 608 609 610 /** 611 * p2p_parse_free - Free temporary data from P2P parsing 612 * @msg: Parsed attributes 613 */ 614 void p2p_parse_free(struct p2p_message *msg) 615 { 616 wpabuf_free(msg->p2p_attributes); 617 msg->p2p_attributes = NULL; 618 wpabuf_free(msg->wps_attributes); 619 msg->wps_attributes = NULL; 620 #ifdef CONFIG_WIFI_DISPLAY 621 wpabuf_free(msg->wfd_subelems); 622 msg->wfd_subelems = NULL; 623 #endif /* CONFIG_WIFI_DISPLAY */ 624 } 625 626 627 int p2p_group_info_parse(const u8 *gi, size_t gi_len, 628 struct p2p_group_info *info) 629 { 630 const u8 *g, *gend; 631 632 os_memset(info, 0, sizeof(*info)); 633 if (gi == NULL) 634 return 0; 635 636 g = gi; 637 gend = gi + gi_len; 638 while (g < gend) { 639 struct p2p_client_info *cli; 640 const u8 *t, *cend; 641 int count; 642 643 cli = &info->client[info->num_clients]; 644 cend = g + 1 + g[0]; 645 if (cend > gend) 646 return -1; /* invalid data */ 647 /* g at start of P2P Client Info Descriptor */ 648 /* t at Device Capability Bitmap */ 649 t = g + 1 + 2 * ETH_ALEN; 650 if (t > cend) 651 return -1; /* invalid data */ 652 cli->p2p_device_addr = g + 1; 653 cli->p2p_interface_addr = g + 1 + ETH_ALEN; 654 cli->dev_capab = t[0]; 655 656 if (t + 1 + 2 + 8 + 1 > cend) 657 return -1; /* invalid data */ 658 659 cli->config_methods = WPA_GET_BE16(&t[1]); 660 cli->pri_dev_type = &t[3]; 661 662 t += 1 + 2 + 8; 663 /* t at Number of Secondary Device Types */ 664 cli->num_sec_dev_types = *t++; 665 if (t + 8 * cli->num_sec_dev_types > cend) 666 return -1; /* invalid data */ 667 cli->sec_dev_types = t; 668 t += 8 * cli->num_sec_dev_types; 669 670 /* t at Device Name in WPS TLV format */ 671 if (t + 2 + 2 > cend) 672 return -1; /* invalid data */ 673 if (WPA_GET_BE16(t) != ATTR_DEV_NAME) 674 return -1; /* invalid Device Name TLV */ 675 t += 2; 676 count = WPA_GET_BE16(t); 677 t += 2; 678 if (count > cend - t) 679 return -1; /* invalid Device Name TLV */ 680 if (count >= WPS_DEV_NAME_MAX_LEN) 681 count = WPS_DEV_NAME_MAX_LEN; 682 cli->dev_name = (const char *) t; 683 cli->dev_name_len = count; 684 685 g = cend; 686 687 info->num_clients++; 688 if (info->num_clients == P2P_MAX_GROUP_ENTRIES) 689 return -1; 690 } 691 692 return 0; 693 } 694 695 696 static int p2p_group_info_text(const u8 *gi, size_t gi_len, char *buf, 697 char *end) 698 { 699 char *pos = buf; 700 int ret; 701 struct p2p_group_info info; 702 unsigned int i; 703 704 if (p2p_group_info_parse(gi, gi_len, &info) < 0) 705 return 0; 706 707 for (i = 0; i < info.num_clients; i++) { 708 struct p2p_client_info *cli; 709 char name[WPS_DEV_NAME_MAX_LEN + 1]; 710 char devtype[WPS_DEV_TYPE_BUFSIZE]; 711 u8 s; 712 int count; 713 714 cli = &info.client[i]; 715 ret = os_snprintf(pos, end - pos, "p2p_group_client: " 716 "dev=" MACSTR " iface=" MACSTR, 717 MAC2STR(cli->p2p_device_addr), 718 MAC2STR(cli->p2p_interface_addr)); 719 if (os_snprintf_error(end - pos, ret)) 720 return pos - buf; 721 pos += ret; 722 723 ret = os_snprintf(pos, end - pos, 724 " dev_capab=0x%x config_methods=0x%x " 725 "dev_type=%s", 726 cli->dev_capab, cli->config_methods, 727 wps_dev_type_bin2str(cli->pri_dev_type, 728 devtype, 729 sizeof(devtype))); 730 if (os_snprintf_error(end - pos, ret)) 731 return pos - buf; 732 pos += ret; 733 734 for (s = 0; s < cli->num_sec_dev_types; s++) { 735 ret = os_snprintf(pos, end - pos, " dev_type=%s", 736 wps_dev_type_bin2str( 737 &cli->sec_dev_types[s * 8], 738 devtype, sizeof(devtype))); 739 if (os_snprintf_error(end - pos, ret)) 740 return pos - buf; 741 pos += ret; 742 } 743 744 os_memcpy(name, cli->dev_name, cli->dev_name_len); 745 name[cli->dev_name_len] = '\0'; 746 count = (int) cli->dev_name_len - 1; 747 while (count >= 0) { 748 if (is_ctrl_char(name[count])) 749 name[count] = '_'; 750 count--; 751 } 752 753 ret = os_snprintf(pos, end - pos, " dev_name='%s'\n", name); 754 if (os_snprintf_error(end - pos, ret)) 755 return pos - buf; 756 pos += ret; 757 } 758 759 return pos - buf; 760 } 761 762 763 /** 764 * p2p_attr_text - Build text format description of P2P IE attributes 765 * @data: P2P IE contents 766 * @buf: Buffer for returning text 767 * @end: Pointer to the end of the buf area 768 * Returns: Number of octets written to the buffer or -1 on faikure 769 * 770 * This function can be used to parse P2P IE contents into text format 771 * field=value lines. 772 */ 773 int p2p_attr_text(struct wpabuf *data, char *buf, char *end) 774 { 775 struct p2p_message msg; 776 char *pos = buf; 777 int ret; 778 779 os_memset(&msg, 0, sizeof(msg)); 780 if (p2p_parse_p2p_ie(data, &msg)) 781 return -1; 782 783 if (msg.capability) { 784 ret = os_snprintf(pos, end - pos, 785 "p2p_dev_capab=0x%x\n" 786 "p2p_group_capab=0x%x\n", 787 msg.capability[0], msg.capability[1]); 788 if (os_snprintf_error(end - pos, ret)) 789 return pos - buf; 790 pos += ret; 791 } 792 793 if (msg.pri_dev_type) { 794 char devtype[WPS_DEV_TYPE_BUFSIZE]; 795 ret = os_snprintf(pos, end - pos, 796 "p2p_primary_device_type=%s\n", 797 wps_dev_type_bin2str(msg.pri_dev_type, 798 devtype, 799 sizeof(devtype))); 800 if (os_snprintf_error(end - pos, ret)) 801 return pos - buf; 802 pos += ret; 803 } 804 805 ret = os_snprintf(pos, end - pos, "p2p_device_name=%s\n", 806 msg.device_name); 807 if (os_snprintf_error(end - pos, ret)) 808 return pos - buf; 809 pos += ret; 810 811 if (msg.p2p_device_addr) { 812 ret = os_snprintf(pos, end - pos, "p2p_device_addr=" MACSTR 813 "\n", 814 MAC2STR(msg.p2p_device_addr)); 815 if (os_snprintf_error(end - pos, ret)) 816 return pos - buf; 817 pos += ret; 818 } 819 820 ret = os_snprintf(pos, end - pos, "p2p_config_methods=0x%x\n", 821 msg.config_methods); 822 if (os_snprintf_error(end - pos, ret)) 823 return pos - buf; 824 pos += ret; 825 826 ret = p2p_group_info_text(msg.group_info, msg.group_info_len, 827 pos, end); 828 if (ret < 0) 829 return pos - buf; 830 pos += ret; 831 832 return pos - buf; 833 } 834 835 836 int p2p_get_cross_connect_disallowed(const struct wpabuf *p2p_ie) 837 { 838 struct p2p_message msg; 839 840 os_memset(&msg, 0, sizeof(msg)); 841 if (p2p_parse_p2p_ie(p2p_ie, &msg)) 842 return 0; 843 844 if (!msg.manageability) 845 return 0; 846 847 return !(msg.manageability[0] & P2P_MAN_CROSS_CONNECTION_PERMITTED); 848 } 849 850 851 u8 p2p_get_group_capab(const struct wpabuf *p2p_ie) 852 { 853 struct p2p_message msg; 854 855 os_memset(&msg, 0, sizeof(msg)); 856 if (p2p_parse_p2p_ie(p2p_ie, &msg)) 857 return 0; 858 859 if (!msg.capability) 860 return 0; 861 862 return msg.capability[1]; 863 } 864 865 866 const u8 * p2p_get_go_dev_addr(const struct wpabuf *p2p_ie) 867 { 868 struct p2p_message msg; 869 870 os_memset(&msg, 0, sizeof(msg)); 871 if (p2p_parse_p2p_ie(p2p_ie, &msg)) 872 return NULL; 873 874 if (msg.p2p_device_addr) 875 return msg.p2p_device_addr; 876 if (msg.device_id) 877 return msg.device_id; 878 879 return NULL; 880 } 881