LCOV - code coverage report
Current view: top level - src/p2p - p2p_parse.c (source / functions) Hit Total Coverage
Test: wpa_supplicant/hostapd combined for hwsim test run 1422976643 Lines: 446 503 88.7 %
Date: 2015-02-03 Functions: 13 13 100.0 %

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

Generated by: LCOV version 1.10