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
18static 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 || nlen > 32) {
153			wpa_printf(MSG_DEBUG, "P2P: Invalid Device Name "
154				   "length %d (buf len %d)", (int) nlen,
155				   (int) (data + len - pos));
156			return -1;
157		}
158		os_memcpy(msg->device_name, pos, nlen);
159		msg->device_name[nlen] = '\0';
160		for (i = 0; i < nlen; i++) {
161			if (msg->device_name[i] == '\0')
162				break;
163			if (msg->device_name[i] > 0 &&
164			    msg->device_name[i] < 32)
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 + 32) {
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	default:
272		wpa_printf(MSG_DEBUG, "P2P: Skipped unknown attribute %d "
273			   "(length %d)", id, len);
274		break;
275	}
276
277	return 0;
278}
279
280
281/**
282 * p2p_parse_p2p_ie - Parse P2P IE
283 * @buf: Concatenated P2P IE(s) payload
284 * @msg: Buffer for returning parsed attributes
285 * Returns: 0 on success, -1 on failure
286 *
287 * Note: Caller is responsible for clearing the msg data structure before
288 * calling this function.
289 */
290int p2p_parse_p2p_ie(const struct wpabuf *buf, struct p2p_message *msg)
291{
292	const u8 *pos = wpabuf_head_u8(buf);
293	const u8 *end = pos + wpabuf_len(buf);
294
295	wpa_printf(MSG_DEBUG, "P2P: Parsing P2P IE");
296
297	while (pos < end) {
298		u16 attr_len;
299		if (pos + 2 >= end) {
300			wpa_printf(MSG_DEBUG, "P2P: Invalid P2P attribute");
301			return -1;
302		}
303		attr_len = WPA_GET_LE16(pos + 1);
304		wpa_printf(MSG_DEBUG, "P2P: Attribute %d length %u",
305			   pos[0], attr_len);
306		if (pos + 3 + attr_len > end) {
307			wpa_printf(MSG_DEBUG, "P2P: Attribute underflow "
308				   "(len=%u left=%d)",
309				   attr_len, (int) (end - pos - 3));
310			wpa_hexdump(MSG_MSGDUMP, "P2P: Data", pos, end - pos);
311			return -1;
312		}
313		if (p2p_parse_attribute(pos[0], pos + 3, attr_len, msg))
314			return -1;
315		pos += 3 + attr_len;
316	}
317
318	return 0;
319}
320
321
322static int p2p_parse_wps_ie(const struct wpabuf *buf, struct p2p_message *msg)
323{
324	struct wps_parse_attr attr;
325	int i;
326
327	wpa_printf(MSG_DEBUG, "P2P: Parsing WPS IE");
328	if (wps_parse_msg(buf, &attr))
329		return -1;
330	if (attr.dev_name && attr.dev_name_len < sizeof(msg->device_name) &&
331	    !msg->device_name[0])
332		os_memcpy(msg->device_name, attr.dev_name, attr.dev_name_len);
333	if (attr.config_methods) {
334		msg->wps_config_methods =
335			WPA_GET_BE16(attr.config_methods);
336		wpa_printf(MSG_DEBUG, "P2P: Config Methods (WPS): 0x%x",
337			   msg->wps_config_methods);
338	}
339	if (attr.dev_password_id) {
340		msg->dev_password_id = WPA_GET_BE16(attr.dev_password_id);
341		wpa_printf(MSG_DEBUG, "P2P: Device Password ID: %d",
342			   msg->dev_password_id);
343	}
344	if (attr.primary_dev_type) {
345		char devtype[WPS_DEV_TYPE_BUFSIZE];
346		msg->wps_pri_dev_type = attr.primary_dev_type;
347		wpa_printf(MSG_DEBUG, "P2P: Primary Device Type (WPS): %s",
348			   wps_dev_type_bin2str(msg->wps_pri_dev_type, devtype,
349						sizeof(devtype)));
350	}
351	if (attr.sec_dev_type_list) {
352		msg->wps_sec_dev_type_list = attr.sec_dev_type_list;
353		msg->wps_sec_dev_type_list_len = attr.sec_dev_type_list_len;
354	}
355
356	for (i = 0; i < P2P_MAX_WPS_VENDOR_EXT; i++) {
357		msg->wps_vendor_ext[i] = attr.vendor_ext[i];
358		msg->wps_vendor_ext_len[i] = attr.vendor_ext_len[i];
359	}
360
361	msg->manufacturer = attr.manufacturer;
362	msg->manufacturer_len = attr.manufacturer_len;
363	msg->model_name = attr.model_name;
364	msg->model_name_len = attr.model_name_len;
365	msg->model_number = attr.model_number;
366	msg->model_number_len = attr.model_number_len;
367	msg->serial_number = attr.serial_number;
368	msg->serial_number_len = attr.serial_number_len;
369
370	return 0;
371}
372
373
374/**
375 * p2p_parse_ies - Parse P2P message IEs (both WPS and P2P IE)
376 * @data: IEs from the message
377 * @len: Length of data buffer in octets
378 * @msg: Buffer for returning parsed attributes
379 * Returns: 0 on success, -1 on failure
380 *
381 * Note: Caller is responsible for clearing the msg data structure before
382 * calling this function.
383 *
384 * Note: Caller must free temporary memory allocations by calling
385 * p2p_parse_free() when the parsed data is not needed anymore.
386 */
387int p2p_parse_ies(const u8 *data, size_t len, struct p2p_message *msg)
388{
389	struct ieee802_11_elems elems;
390
391	ieee802_11_parse_elems(data, len, &elems, 0);
392	if (elems.ds_params && elems.ds_params_len >= 1)
393		msg->ds_params = elems.ds_params;
394	if (elems.ssid)
395		msg->ssid = elems.ssid - 2;
396
397	msg->wps_attributes = ieee802_11_vendor_ie_concat(data, len,
398							  WPS_DEV_OUI_WFA);
399	if (msg->wps_attributes &&
400	    p2p_parse_wps_ie(msg->wps_attributes, msg)) {
401		p2p_parse_free(msg);
402		return -1;
403	}
404
405	msg->p2p_attributes = ieee802_11_vendor_ie_concat(data, len,
406							  P2P_IE_VENDOR_TYPE);
407	if (msg->p2p_attributes &&
408	    p2p_parse_p2p_ie(msg->p2p_attributes, msg)) {
409		wpa_printf(MSG_DEBUG, "P2P: Failed to parse P2P IE data");
410		if (msg->p2p_attributes)
411			wpa_hexdump_buf(MSG_MSGDUMP, "P2P: P2P IE data",
412					msg->p2p_attributes);
413		p2p_parse_free(msg);
414		return -1;
415	}
416
417#ifdef CONFIG_WIFI_DISPLAY
418	if (elems.wfd) {
419		msg->wfd_subelems = ieee802_11_vendor_ie_concat(
420			data, len, WFD_IE_VENDOR_TYPE);
421	}
422#endif /* CONFIG_WIFI_DISPLAY */
423
424	return 0;
425}
426
427
428/**
429 * p2p_parse - Parse a P2P Action frame contents
430 * @data: Action frame payload after Category and Code fields
431 * @len: Length of data buffer in octets
432 * @msg: Buffer for returning parsed attributes
433 * Returns: 0 on success, -1 on failure
434 *
435 * Note: Caller must free temporary memory allocations by calling
436 * p2p_parse_free() when the parsed data is not needed anymore.
437 */
438int p2p_parse(const u8 *data, size_t len, struct p2p_message *msg)
439{
440	os_memset(msg, 0, sizeof(*msg));
441	wpa_printf(MSG_DEBUG, "P2P: Parsing the received message");
442	if (len < 1) {
443		wpa_printf(MSG_DEBUG, "P2P: No Dialog Token in the message");
444		return -1;
445	}
446	msg->dialog_token = data[0];
447	wpa_printf(MSG_DEBUG, "P2P: * Dialog Token: %d", msg->dialog_token);
448
449	return p2p_parse_ies(data + 1, len - 1, msg);
450}
451
452
453/**
454 * p2p_parse_free - Free temporary data from P2P parsing
455 * @msg: Parsed attributes
456 */
457void p2p_parse_free(struct p2p_message *msg)
458{
459	wpabuf_free(msg->p2p_attributes);
460	msg->p2p_attributes = NULL;
461	wpabuf_free(msg->wps_attributes);
462	msg->wps_attributes = NULL;
463#ifdef CONFIG_WIFI_DISPLAY
464	wpabuf_free(msg->wfd_subelems);
465	msg->wfd_subelems = NULL;
466#endif /* CONFIG_WIFI_DISPLAY */
467}
468
469
470int p2p_group_info_parse(const u8 *gi, size_t gi_len,
471			 struct p2p_group_info *info)
472{
473	const u8 *g, *gend;
474
475	os_memset(info, 0, sizeof(*info));
476	if (gi == NULL)
477		return 0;
478
479	g = gi;
480	gend = gi + gi_len;
481	while (g < gend) {
482		struct p2p_client_info *cli;
483		const u8 *t, *cend;
484		int count;
485
486		cli = &info->client[info->num_clients];
487		cend = g + 1 + g[0];
488		if (cend > gend)
489			return -1; /* invalid data */
490		/* g at start of P2P Client Info Descriptor */
491		/* t at Device Capability Bitmap */
492		t = g + 1 + 2 * ETH_ALEN;
493		if (t > cend)
494			return -1; /* invalid data */
495		cli->p2p_device_addr = g + 1;
496		cli->p2p_interface_addr = g + 1 + ETH_ALEN;
497		cli->dev_capab = t[0];
498
499		if (t + 1 + 2 + 8 + 1 > cend)
500			return -1; /* invalid data */
501
502		cli->config_methods = WPA_GET_BE16(&t[1]);
503		cli->pri_dev_type = &t[3];
504
505		t += 1 + 2 + 8;
506		/* t at Number of Secondary Device Types */
507		cli->num_sec_dev_types = *t++;
508		if (t + 8 * cli->num_sec_dev_types > cend)
509			return -1; /* invalid data */
510		cli->sec_dev_types = t;
511		t += 8 * cli->num_sec_dev_types;
512
513		/* t at Device Name in WPS TLV format */
514		if (t + 2 + 2 > cend)
515			return -1; /* invalid data */
516		if (WPA_GET_BE16(t) != ATTR_DEV_NAME)
517			return -1; /* invalid Device Name TLV */
518		t += 2;
519		count = WPA_GET_BE16(t);
520		t += 2;
521		if (count > cend - t)
522			return -1; /* invalid Device Name TLV */
523		if (count >= 32)
524			count = 32;
525		cli->dev_name = (const char *) t;
526		cli->dev_name_len = count;
527
528		g = cend;
529
530		info->num_clients++;
531		if (info->num_clients == P2P_MAX_GROUP_ENTRIES)
532			return -1;
533	}
534
535	return 0;
536}
537
538
539static int p2p_group_info_text(const u8 *gi, size_t gi_len, char *buf,
540			       char *end)
541{
542	char *pos = buf;
543	int ret;
544	struct p2p_group_info info;
545	unsigned int i;
546
547	if (p2p_group_info_parse(gi, gi_len, &info) < 0)
548		return 0;
549
550	for (i = 0; i < info.num_clients; i++) {
551		struct p2p_client_info *cli;
552		char name[33];
553		char devtype[WPS_DEV_TYPE_BUFSIZE];
554		u8 s;
555		int count;
556
557		cli = &info.client[i];
558		ret = os_snprintf(pos, end - pos, "p2p_group_client: "
559				  "dev=" MACSTR " iface=" MACSTR,
560				  MAC2STR(cli->p2p_device_addr),
561				  MAC2STR(cli->p2p_interface_addr));
562		if (ret < 0 || ret >= end - pos)
563			return pos - buf;
564		pos += ret;
565
566		ret = os_snprintf(pos, end - pos,
567				  " dev_capab=0x%x config_methods=0x%x "
568				  "dev_type=%s",
569				  cli->dev_capab, cli->config_methods,
570				  wps_dev_type_bin2str(cli->pri_dev_type,
571						       devtype,
572						       sizeof(devtype)));
573		if (ret < 0 || ret >= end - pos)
574			return pos - buf;
575		pos += ret;
576
577		for (s = 0; s < cli->num_sec_dev_types; s++) {
578			ret = os_snprintf(pos, end - pos, " dev_type=%s",
579					  wps_dev_type_bin2str(
580						  &cli->sec_dev_types[s * 8],
581						  devtype, sizeof(devtype)));
582			if (ret < 0 || ret >= end - pos)
583				return pos - buf;
584			pos += ret;
585		}
586
587		os_memcpy(name, cli->dev_name, cli->dev_name_len);
588		name[cli->dev_name_len] = '\0';
589		count = (int) cli->dev_name_len - 1;
590		while (count >= 0) {
591			if (name[count] > 0 && name[count] < 32)
592				name[count] = '_';
593			count--;
594		}
595
596		ret = os_snprintf(pos, end - pos, " dev_name='%s'\n", name);
597		if (ret < 0 || ret >= end - pos)
598			return pos - buf;
599		pos += ret;
600	}
601
602	return pos - buf;
603}
604
605
606/**
607 * p2p_attr_text - Build text format description of P2P IE attributes
608 * @data: P2P IE contents
609 * @buf: Buffer for returning text
610 * @end: Pointer to the end of the buf area
611 * Returns: Number of octets written to the buffer or -1 on faikure
612 *
613 * This function can be used to parse P2P IE contents into text format
614 * field=value lines.
615 */
616int p2p_attr_text(struct wpabuf *data, char *buf, char *end)
617{
618	struct p2p_message msg;
619	char *pos = buf;
620	int ret;
621
622	os_memset(&msg, 0, sizeof(msg));
623	if (p2p_parse_p2p_ie(data, &msg))
624		return -1;
625
626	if (msg.capability) {
627		ret = os_snprintf(pos, end - pos,
628				  "p2p_dev_capab=0x%x\n"
629				  "p2p_group_capab=0x%x\n",
630				  msg.capability[0], msg.capability[1]);
631		if (ret < 0 || ret >= end - pos)
632			return pos - buf;
633		pos += ret;
634	}
635
636	if (msg.pri_dev_type) {
637		char devtype[WPS_DEV_TYPE_BUFSIZE];
638		ret = os_snprintf(pos, end - pos,
639				  "p2p_primary_device_type=%s\n",
640				  wps_dev_type_bin2str(msg.pri_dev_type,
641						       devtype,
642						       sizeof(devtype)));
643		if (ret < 0 || ret >= end - pos)
644			return pos - buf;
645		pos += ret;
646	}
647
648	ret = os_snprintf(pos, end - pos, "p2p_device_name=%s\n",
649			  msg.device_name);
650	if (ret < 0 || ret >= end - pos)
651		return pos - buf;
652	pos += ret;
653
654	if (msg.p2p_device_addr) {
655		ret = os_snprintf(pos, end - pos, "p2p_device_addr=" MACSTR
656				  "\n",
657				  MAC2STR(msg.p2p_device_addr));
658		if (ret < 0 || ret >= end - pos)
659			return pos - buf;
660		pos += ret;
661	}
662
663	ret = os_snprintf(pos, end - pos, "p2p_config_methods=0x%x\n",
664			  msg.config_methods);
665	if (ret < 0 || ret >= end - pos)
666		return pos - buf;
667	pos += ret;
668
669	ret = p2p_group_info_text(msg.group_info, msg.group_info_len,
670				  pos, end);
671	if (ret < 0)
672		return pos - buf;
673	pos += ret;
674
675	return pos - buf;
676}
677
678
679int p2p_get_cross_connect_disallowed(const struct wpabuf *p2p_ie)
680{
681	struct p2p_message msg;
682
683	os_memset(&msg, 0, sizeof(msg));
684	if (p2p_parse_p2p_ie(p2p_ie, &msg))
685		return 0;
686
687	if (!msg.manageability)
688		return 0;
689
690	return !(msg.manageability[0] & P2P_MAN_CROSS_CONNECTION_PERMITTED);
691}
692
693
694u8 p2p_get_group_capab(const struct wpabuf *p2p_ie)
695{
696	struct p2p_message msg;
697
698	os_memset(&msg, 0, sizeof(msg));
699	if (p2p_parse_p2p_ie(p2p_ie, &msg))
700		return 0;
701
702	if (!msg.capability)
703		return 0;
704
705	return msg.capability[1];
706}
707
708
709const u8 * p2p_get_go_dev_addr(const struct wpabuf *p2p_ie)
710{
711	struct p2p_message msg;
712
713	os_memset(&msg, 0, sizeof(msg));
714	if (p2p_parse_p2p_ie(p2p_ie, &msg))
715		return NULL;
716
717	if (msg.p2p_device_addr)
718		return msg.p2p_device_addr;
719	if (msg.device_id)
720		return msg.device_id;
721
722	return NULL;
723}
724