libeap/src/p2p/p2p_parse.c

   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 }