Kernel
/
iwd
mirror of https://git.kernel.org/pub/scm/network/wireless/iwd.git
3
0
Fork 0
Code Releases Activity
iwd/unit/test-p2p.c

1179 lines
39 KiB
C
Raw Blame History

/*
*
* Wireless daemon for Linux
*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#include <errno.h>
#include <ell/ell.h>
#include "src/p2putil.h"
#include "src/ie.h"
static const uint8_t p2p_attrs1[] = {
0x02, 0x02, 0x00, 0x25, 0x00, 0x0d, 0x1d, 0x00, 0x00, 0x28, 0xf8, 0xed,
0x26, 0x57, 0x11, 0x08, 0x00, 0x01, 0x00, 0x50, 0xf2, 0x04, 0x00, 0x01,
0x00, 0x10, 0x11, 0x00, 0x08, 0x74, 0x65, 0x73, 0x74, 0x64, 0x65, 0x76,
0x31, 0x0f, 0x15, 0x00, 0x2a, 0xfe, 0xcd, 0x01, 0xbe, 0xa0, 0x44, 0x49,
0x52, 0x45, 0x43, 0x54, 0x2d, 0x5a, 0x75, 0x2d, 0x41, 0x6e, 0x64, 0x72,
0x65,
};
static void p2p_test_iter_sanity_check(const void *data)
{
struct p2p_attr_iter iter;
p2p_attr_iter_init(&iter, p2p_attrs1, sizeof(p2p_attrs1));
assert(p2p_attr_iter_next(&iter));
assert(p2p_attr_iter_get_type(&iter) == P2P_ATTR_P2P_CAPABILITY);
assert(p2p_attr_iter_get_length(&iter) == 2);
assert(p2p_attr_iter_next(&iter));
assert(p2p_attr_iter_get_type(&iter) == P2P_ATTR_P2P_DEVICE_INFO);
assert(p2p_attr_iter_get_length(&iter) == 29);
assert(p2p_attr_iter_next(&iter));
assert(p2p_attr_iter_get_type(&iter) == P2P_ATTR_P2P_GROUP_ID);
assert(p2p_attr_iter_get_length(&iter) == 21);
assert(!p2p_attr_iter_next(&iter));
}
typedef bool (*test_queue_cmp_func)(const void *data1, const void *data2);
static bool test_queue_cmp(struct l_queue *q1, struct l_queue *q2,
test_queue_cmp_func func)
{
const struct l_queue_entry *entry1 = l_queue_get_entries(q1);
const struct l_queue_entry *entry2 = l_queue_get_entries(q2);
while (entry1 && entry2) {
if (!func(entry1->data, entry2->data))
return false;
entry1 = entry1->next;
entry2 = entry2->next;
}
return !entry1 && !entry2;
}
static bool p2p_noa_desc_cmp(const void *data1, const void *data2)
{
const struct p2p_notice_of_absence_desc *desc1 = data1;
const struct p2p_notice_of_absence_desc *desc2 = data2;
if (desc1->count_type != desc2->count_type)
return false;
if (desc1->duration != desc2->duration)
return false;
if (desc1->interval != desc2->interval)
return false;
if (desc1->start_time != desc2->start_time)
return false;
return true;
}
/*
* The attributes in a P2P IE are not explicitly required to be ordered
* in the same way they're listed in each frame's format specification in
* Wi-Fi P2P Technical Specification v1.7 and in fact some consumer devices
* switch some attributes' order in their probe responses. This compares
* the contents of two sets of P2P IEs ignoring attribute order and payload
* segmentation into individual P2P IEs.
* TODO: Might also want to validate the WSC IEs written by the p2putil.c
* builder functions.
*/
static bool p2p_payload_cmd(const uint8_t *ies1, size_t ies1_len,
const uint8_t *ies2, size_t ies2_len)
{
uint8_t *payload1, *payload2;
ssize_t payload1_len, payload2_len;
struct p2p_attr_iter iter1, iter2;
const uint8_t *attr1_start[P2P_ATTR_PERSISTENT_GROUP_INFO + 1];
int i;
bool r = false;
if (!ies1 || !ies2)
return false;
payload1 = ie_tlv_extract_p2p_payload(ies1, ies1_len, &payload1_len);
payload2 = ie_tlv_extract_p2p_payload(ies2, ies2_len, &payload2_len);
if (payload1_len < 0 || payload2_len < 0)
return false;
p2p_attr_iter_init(&iter1, payload1, payload1_len);
p2p_attr_iter_init(&iter2, payload2, payload2_len);
memset(attr1_start, 0, sizeof(attr1_start));
while (p2p_attr_iter_next(&iter1)) {
enum p2p_attr type = p2p_attr_iter_get_type(&iter1);
const uint8_t *start = p2p_attr_iter_get_data(&iter1) - 3;
if (type >= L_ARRAY_SIZE(attr1_start))
goto done; /* Unknown attribute */
if (attr1_start[type])
goto done; /* Duplicate attribute type in @ies1 */
attr1_start[type] = start;
}
while (p2p_attr_iter_next(&iter2)) {
enum p2p_attr type = p2p_attr_iter_get_type(&iter2);
const uint8_t *start = p2p_attr_iter_get_data(&iter2) - 3;
size_t len;
if ((int) type >= (int) L_ARRAY_SIZE(attr1_start))
goto done; /* Unknown attribute */
if (!attr1_start[type])
goto done; /* Not in @ies1 or dupe in @ies2 */
len = p2p_attr_iter_get_length(&iter2) + 3;
/*
* It's safe to memcmp len bytes because the length is also
* encoded in the first 3 bytes of both buffers.
*/
if (memcmp(start, attr1_start[type], len))
goto done; /* Contents or lengths differ */
attr1_start[type] = NULL;
}
for (i = 0; i < (int) L_ARRAY_SIZE(attr1_start); i++)
if (attr1_start[i])
goto done; /* @ies1 attribute was not in @ies2 */
r = true;
done:
l_free(payload1);
l_free(payload2);
return r;
}
static const uint8_t p2p_beacon_ies_1[] = {
0xdd, 0x12, 0x50, 0x6f, 0x9a, 0x09, 0x02, 0x02, 0x00, 0x05, 0xab, 0x03,
0x06, 0x00, 0x2a, 0xfe, 0xcd, 0x01, 0xbe, 0xa0, 0xdd, 0x4e, 0x00, 0x50,
0xf2, 0x04, 0x10, 0x4a, 0x00, 0x01, 0x10, 0x10, 0x44, 0x00, 0x01, 0x02,
0x10, 0x41, 0x00, 0x01, 0x01, 0x10, 0x12, 0x00, 0x02, 0x00, 0x04, 0x10,
0x53, 0x00, 0x02, 0x43, 0x88, 0x10, 0x49, 0x00, 0x0e, 0x00, 0x37, 0x2a,
0x00, 0x01, 0x20, 0x01, 0x06, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x10,
0x11, 0x00, 0x0d, 0x4c, 0x45, 0x58, 0x36, 0x32, 0x36, 0x2d, 0x50, 0x64,
0x61, 0x4e, 0x65, 0x74, 0x10, 0x54, 0x00, 0x08, 0x00, 0x08, 0x00, 0x50,
0xf2, 0x04, 0x00, 0x02, 0xdd, 0x16, 0x50, 0x6f, 0x9a, 0x09, 0x0c, 0x0f,
0x00, 0xe1, 0x00, 0x01, 0xb0, 0xb3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x7c, 0x45, 0x8f, 0x0c,
};
struct p2p_beacon_data {
const uint8_t *ies;
size_t ies_len;
ssize_t payload_len;
struct p2p_beacon data;
const struct p2p_notice_of_absence_desc *noa_descs;
};
static const struct p2p_beacon_data p2p_beacon_data_1 = {
.ies = p2p_beacon_ies_1,
.ies_len = L_ARRAY_SIZE(p2p_beacon_ies_1),
.payload_len = 32,
.data = {
.capability = {
.device_caps = P2P_DEVICE_CAP_SVC_DISCOVERY |
P2P_DEVICE_CAP_CONCURRENT_OP,
.group_caps = P2P_GROUP_CAP_GO |
P2P_GROUP_CAP_PERSISTENT_GROUP |
P2P_GROUP_CAP_INTRA_BSS_DISTRIBUTION |
P2P_GROUP_CAP_PERSISTENT_RECONNECT |
P2P_GROUP_CAP_IP_ALLOCATION,
},
.device_addr = { 0x2a, 0xfe, 0xcd, 0x01, 0xbe, 0xa0 },
.notice_of_absence = {
.index = 225,
.opp_ps = false,
.ct_window = 0,
},
},
.noa_descs = (const struct p2p_notice_of_absence_desc []) {
[0] = {
.count_type = 1,
.duration = 46000,
.interval = 0,
.start_time = 210716028,
},
[1] = {}
},
};
static void p2p_test_parse_beacon(const void *data)
{
const struct p2p_beacon_data *test = data;
struct p2p_beacon attrs1, attrs2;
const struct p2p_notice_of_absence_desc *desc = test->noa_descs;
uint8_t *payload;
ssize_t payload_len;
payload = ie_tlv_extract_p2p_payload(test->ies, test->ies_len,
&payload_len);
l_free(payload);
assert(payload_len == test->payload_len);
memcpy(&attrs2, &test->data, sizeof(attrs2));
if (desc)
attrs2.notice_of_absence.descriptors = l_queue_new();
while (desc && desc->start_time) {
l_queue_push_tail(attrs2.notice_of_absence.descriptors,
l_memdup(desc, sizeof(*desc)));
desc++;
}
assert(p2p_parse_beacon(test->ies, test->ies_len, &attrs1) == 0);
assert(attrs1.capability.device_caps == attrs2.capability.device_caps);
assert(attrs1.capability.group_caps == attrs2.capability.group_caps);
assert(!memcmp(attrs1.device_addr, attrs2.device_addr, 6));
assert(attrs1.notice_of_absence.index ==
attrs2.notice_of_absence.index);
assert(attrs1.notice_of_absence.opp_ps ==
attrs2.notice_of_absence.opp_ps);
assert(attrs1.notice_of_absence.ct_window ==
attrs2.notice_of_absence.ct_window);
assert(test_queue_cmp(attrs1.notice_of_absence.descriptors,
attrs2.notice_of_absence.descriptors,
p2p_noa_desc_cmp));
p2p_clear_beacon(&attrs1);
p2p_clear_beacon(&attrs2);
}
static void p2p_test_build_beacon(const void *data)
{
const struct p2p_beacon_data *test = data;
struct p2p_beacon attrs2;
const struct p2p_notice_of_absence_desc *desc = test->noa_descs;
uint8_t *ies;
size_t ies_len;
memcpy(&attrs2, &test->data, sizeof(attrs2));
if (desc)
attrs2.notice_of_absence.descriptors = l_queue_new();
while (desc && desc->start_time) {
l_queue_push_tail(attrs2.notice_of_absence.descriptors,
l_memdup(desc, sizeof(*desc)));
desc++;
}
ies = p2p_build_beacon(&attrs2, &ies_len);
p2p_clear_beacon(&attrs2);
assert(p2p_payload_cmd(ies, ies_len, test->ies, test->ies_len));
l_free(ies);
}
static const uint8_t p2p_probe_req_ies_1[] = {
0xdd, 0x73, 0x00, 0x50, 0xf2, 0x04, 0x10, 0x4a, 0x00, 0x01, 0x10, 0x10,
0x3a, 0x00, 0x01, 0x01, 0x10, 0x08, 0x00, 0x02, 0x31, 0x48, 0x10, 0x47,
0x00, 0x10, 0x9a, 0xdd, 0x77, 0x82, 0xcb, 0xa6, 0x5e, 0x2d, 0xac, 0xd9,
0xc0, 0x54, 0x34, 0xd0, 0xd7, 0x29, 0x10, 0x54, 0x00, 0x08, 0x00, 0x01,
0x00, 0x50, 0xf2, 0x04, 0x00, 0x01, 0x10, 0x3c, 0x00, 0x01, 0x03, 0x10,
0x02, 0x00, 0x02, 0x00, 0x00, 0x10, 0x09, 0x00, 0x02, 0x00, 0x00, 0x10,
0x12, 0x00, 0x02, 0x00, 0x00, 0x10, 0x21, 0x00, 0x01, 0x20, 0x10, 0x23,
0x00, 0x01, 0x20, 0x10, 0x24, 0x00, 0x01, 0x20, 0x10, 0x11, 0x00, 0x08,
0x74, 0x65, 0x73, 0x74, 0x64, 0x65, 0x76, 0x31, 0x10, 0x49, 0x00, 0x09,
0x00, 0x37, 0x2a, 0x00, 0x01, 0x20, 0x03, 0x01, 0x01, 0xdd, 0x11, 0x50,
0x6f, 0x9a, 0x09, 0x02, 0x02, 0x00, 0x25, 0x00, 0x06, 0x05, 0x00, 0x58,
0x58, 0x04, 0x51, 0x01,
};
struct p2p_probe_req_data {
const uint8_t *ies;
size_t ies_len;
ssize_t payload_len;
struct p2p_probe_req data;
};
static const struct p2p_probe_req_data p2p_probe_req_data_1 = {
.ies = p2p_probe_req_ies_1,
.ies_len = L_ARRAY_SIZE(p2p_probe_req_ies_1),
.payload_len = 13,
.data = {
.capability = {
.device_caps = P2P_DEVICE_CAP_SVC_DISCOVERY |
P2P_DEVICE_CAP_CONCURRENT_OP |
P2P_DEVICE_CAP_INVITATION_PROCEDURE,
.group_caps = 0,
},
.listen_channel = {
.country = "XX\x04",
.oper_class = 81,
.channel_num = 1,
},
},
};
static void p2p_test_parse_probe_req(const void *data)
{
const struct p2p_probe_req_data *test = data;
uint8_t *payload;
ssize_t payload_len;
struct p2p_probe_req attrs;
payload = ie_tlv_extract_p2p_payload(test->ies, test->ies_len,
&payload_len);
l_free(payload);
assert(payload_len == test->payload_len);
assert(p2p_parse_probe_req(test->ies, test->ies_len, &attrs) == 0);
assert(attrs.capability.device_caps ==
test->data.capability.device_caps);
assert(attrs.capability.group_caps == test->data.capability.group_caps);
assert(!memcmp(attrs.device_addr, test->data.device_addr, 6));
assert(!memcmp(attrs.listen_channel.country,
test->data.listen_channel.country, 3));
assert(attrs.listen_channel.oper_class ==
test->data.listen_channel.oper_class);
assert(attrs.listen_channel.channel_num ==
test->data.listen_channel.channel_num);
assert(attrs.listen_availability.avail_period_ms ==
test->data.listen_availability.avail_period_ms);
assert(attrs.listen_availability.avail_interval_ms ==
test->data.listen_availability.avail_interval_ms);
assert(!memcmp(attrs.device_info.device_addr,
test->data.device_info.device_addr, 6));
assert(attrs.device_info.wsc_config_methods ==
test->data.device_info.wsc_config_methods);
assert(attrs.device_info.primary_device_type.category ==
test->data.device_info.primary_device_type.category);
assert(!memcmp(attrs.device_info.primary_device_type.oui,
test->data.device_info.primary_device_type.oui, 3));
assert(attrs.device_info.primary_device_type.oui_type ==
test->data.device_info.primary_device_type.oui_type);
assert(attrs.device_info.primary_device_type.subcategory ==
test->data.device_info.primary_device_type.subcategory);
assert(l_queue_length(attrs.device_info.secondary_device_types) ==
l_queue_length(test->data.device_info.secondary_device_types));
assert(!strcmp(attrs.device_info.device_name,
test->data.device_info.device_name));
assert(!memcmp(attrs.operating_channel.country,
test->data.operating_channel.country, 3));
assert(attrs.operating_channel.oper_class ==
test->data.operating_channel.oper_class);
assert(attrs.operating_channel.channel_num ==
test->data.operating_channel.channel_num);
assert(l_queue_length(attrs.service_hashes) ==
l_queue_length(test->data.service_hashes));
p2p_clear_probe_req(&attrs);
}
static void p2p_test_build_probe_req(const void *data)
{
const struct p2p_probe_req_data *test = data;
uint8_t *ies;
size_t ies_len;
ies = p2p_build_probe_req(&test->data, &ies_len);
assert(p2p_payload_cmd(ies, ies_len, test->ies, test->ies_len));
l_free(ies);
}
/* Notice of Absence and Device Info in the wrong order */
static const uint8_t p2p_probe_resp_ies_1[] = {
0xdd, 0xa2, 0x00, 0x50, 0xf2, 0x04, 0x10, 0x4a, 0x00, 0x01, 0x10, 0x10,
0x44, 0x00, 0x01, 0x02, 0x10, 0x41, 0x00, 0x01, 0x01, 0x10, 0x12, 0x00,
0x02, 0x00, 0x04, 0x10, 0x53, 0x00, 0x02, 0x43, 0x88, 0x10, 0x3b, 0x00,
0x01, 0x03, 0x10, 0x47, 0x00, 0x10, 0xb1, 0x7d, 0x6f, 0xc9, 0x4f, 0xd1,
0x5a, 0x6f, 0xb6, 0x50, 0x53, 0x11, 0x0b, 0x2a, 0xb5, 0x25, 0x10, 0x21,
0x00, 0x0d, 0x4d, 0x65, 0x64, 0x69, 0x61, 0x54, 0x65, 0x6b, 0x20, 0x49,
0x6e, 0x63, 0x2e, 0x10, 0x23, 0x00, 0x12, 0x4d, 0x54, 0x4b, 0x20, 0x57,
0x69, 0x72, 0x65, 0x6c, 0x65, 0x73, 0x73, 0x20, 0x4d, 0x6f, 0x64, 0x65,
0x6c, 0x10, 0x24, 0x00, 0x03, 0x31, 0x2e, 0x30, 0x10, 0x42, 0x00, 0x03,
0x32, 0x2e, 0x30, 0x10, 0x54, 0x00, 0x08, 0x00, 0x08, 0x00, 0x50, 0xf2,
0x04, 0x00, 0x02, 0x10, 0x11, 0x00, 0x0d, 0x4c, 0x45, 0x58, 0x36, 0x32,
0x36, 0x2d, 0x50, 0x64, 0x61, 0x4e, 0x65, 0x74, 0x10, 0x08, 0x00, 0x02,
0x41, 0x08, 0x10, 0x49, 0x00, 0x0e, 0x00, 0x37, 0x2a, 0x00, 0x01, 0x20,
0x01, 0x06, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xdd, 0x27, 0x50, 0x6f,
0x9a, 0x09, 0x02, 0x02, 0x00, 0x05, 0xab, 0x0d, 0x1b, 0x00, 0x2a, 0xfe,
0xcd, 0x01, 0xbe, 0xa0, 0x01, 0x88, 0x00, 0x08, 0x00, 0x50, 0xf2, 0x04,
0x00, 0x02, 0x00, 0x10, 0x11, 0x00, 0x06, 0x4d, 0x6f, 0x62, 0x69, 0x6c,
0x65, 0xdd, 0x16, 0x50, 0x6f, 0x9a, 0x09, 0x0c, 0x0f, 0x00, 0xe1, 0x00,
0x01, 0xb0, 0xb3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x45, 0x8f,
0x0c,
};
struct p2p_probe_resp_data {
const uint8_t *ies;
size_t ies_len;
ssize_t payload_len;
struct p2p_probe_resp data;
const struct p2p_notice_of_absence_desc *noa_descs;
};
static const struct p2p_probe_resp_data p2p_probe_resp_data_1 = {
.ies = p2p_probe_resp_ies_1,
.ies_len = L_ARRAY_SIZE(p2p_probe_resp_ies_1),
.payload_len = 53,
.data = {
.capability = {
.device_caps = P2P_DEVICE_CAP_SVC_DISCOVERY |
P2P_DEVICE_CAP_CONCURRENT_OP,
.group_caps = P2P_GROUP_CAP_GO |
P2P_GROUP_CAP_PERSISTENT_GROUP |
P2P_GROUP_CAP_INTRA_BSS_DISTRIBUTION |
P2P_GROUP_CAP_PERSISTENT_RECONNECT |
P2P_GROUP_CAP_IP_ALLOCATION,
},
.notice_of_absence = {
.index = 225,
.opp_ps = false,
.ct_window = 0,
},
.device_info = {
.device_addr = { 0x2a, 0xfe, 0xcd, 0x01, 0xbe, 0xa0 },
.wsc_config_methods = WSC_CONFIGURATION_METHOD_DISPLAY |
WSC_CONFIGURATION_METHOD_PUSH_BUTTON |
WSC_CONFIGURATION_METHOD_KEYPAD,
.primary_device_type = {
.category = 8,
.oui = { 0x00, 0x50, 0xf2 },
.oui_type = 0x04,
.subcategory = 2,
},
.device_name = "Mobile",
},
},
.noa_descs = (const struct p2p_notice_of_absence_desc []) {
[0] = {
.count_type = 1,
.duration = 46000,
.interval = 0,
.start_time = 210716028,
},
[1] = {}
},
};
static const uint8_t p2p_probe_resp_ies_2[] = {
0xdd, 0x3e, 0x50, 0x6f, 0x9a, 0x09, 0x02, 0x02, 0x00, 0x05, 0x01, 0x0d,
0x32, 0x00, 0xa2, 0x8c, 0xfd, 0xb9, 0x05, 0xef, 0x5a, 0x88, 0x00, 0x03,
0x00, 0x50, 0xf2, 0x04, 0x00, 0x01, 0x00, 0x10, 0x11, 0x00, 0x1d, 0x44,
0x49, 0x52, 0x45, 0x43, 0x54, 0x2d, 0x45, 0x46, 0x2d, 0x48, 0x50, 0x20,
0x45, 0x4e, 0x56, 0x59, 0x20, 0x34, 0x35, 0x32, 0x30, 0x20, 0x73, 0x65,
0x72, 0x69, 0x65, 0x73, 0xdd, 0xc1, 0x00, 0x50, 0xf2, 0x04, 0x10, 0x4a,
0x00, 0x01, 0x10, 0x10, 0x44, 0x00, 0x01, 0x02, 0x10, 0x57, 0x00, 0x01,
0x01, 0x10, 0x41, 0x00, 0x01, 0x00, 0x10, 0x3b, 0x00, 0x01, 0x03, 0x10,
0x47, 0x00, 0x10, 0x1c, 0x85, 0x2a, 0x4d, 0xb8, 0x00, 0x1f, 0x08, 0xab,
0xcd, 0xa0, 0x8c, 0xfd, 0xb9, 0x05, 0xef, 0x10, 0x21, 0x00, 0x02, 0x48,
0x50, 0x10, 0x23, 0x00, 0x11, 0x45, 0x4e, 0x56, 0x59, 0x20, 0x34, 0x35,
0x32, 0x30, 0x20, 0x73, 0x65, 0x72, 0x69, 0x65, 0x73, 0x00, 0x10, 0x24,
0x00, 0x05, 0x34, 0x35, 0x32, 0x37, 0x00, 0x10, 0x42, 0x00, 0x10, 0x54,
0x48, 0x36, 0x35, 0x4f, 0x33, 0x48, 0x31, 0x58, 0x59, 0x30, 0x36, 0x36,
0x30, 0x00, 0x00, 0x10, 0x54, 0x00, 0x08, 0x00, 0x03, 0x00, 0x50, 0xf2,
0x04, 0x00, 0x05, 0x10, 0x11, 0x00, 0x1d, 0x44, 0x49, 0x52, 0x45, 0x43,
0x54, 0x2d, 0x45, 0x46, 0x2d, 0x48, 0x50, 0x20, 0x45, 0x4e, 0x56, 0x59,
0x20, 0x34, 0x35, 0x32, 0x30, 0x20, 0x73, 0x65, 0x72, 0x69, 0x65, 0x73,
0x10, 0x08, 0x00, 0x02, 0x00, 0x00, 0x10, 0x49, 0x00, 0x06, 0x00, 0x37,
0x2a, 0x00, 0x01, 0x20, 0x10, 0x49, 0x00, 0x17, 0x00, 0x01, 0x37, 0x10,
0x06, 0x00, 0x10, 0x1c, 0x85, 0x2a, 0x4d, 0xb8, 0x00, 0x1f, 0x08, 0xab,
0xcd, 0xa0, 0x8c, 0xfd, 0xb9, 0x05, 0xef,
};
static const struct p2p_probe_resp_data p2p_probe_resp_data_2 = {
.ies = p2p_probe_resp_ies_2,
.ies_len = L_ARRAY_SIZE(p2p_probe_resp_ies_2),
.payload_len = 58,
.data = {
.capability = {
.device_caps = P2P_DEVICE_CAP_SVC_DISCOVERY |
P2P_DEVICE_CAP_CONCURRENT_OP,
.group_caps = P2P_GROUP_CAP_GO,
},
.device_info = {
.device_addr = { 0xa2, 0x8c, 0xfd, 0xb9, 0x05, 0xef },
.wsc_config_methods =
WSC_CONFIGURATION_METHOD_VIRTUAL_PUSH_BUTTON |
0x0800 | WSC_CONFIGURATION_METHOD_P2P |
WSC_CONFIGURATION_METHOD_PHYSICAL_DISPLAY_PIN,
.primary_device_type = {
.category = 3,
.oui = { 0x00, 0x50, 0xf2 },
.oui_type = 0x04,
.subcategory = 1,
},
.device_name = "DIRECT-EF-HP ENVY 4520 series",
},
},
};
static void p2p_test_parse_probe_resp(const void *data)
{
const struct p2p_probe_resp_data *test = data;
struct p2p_probe_resp attrs1, attrs2;
const struct p2p_notice_of_absence_desc *desc = test->noa_descs;
uint8_t *payload;
ssize_t payload_len;
payload = ie_tlv_extract_p2p_payload(test->ies, test->ies_len,
&payload_len);
l_free(payload);
assert(payload_len == test->payload_len);
assert(p2p_parse_probe_resp(test->ies, test->ies_len, &attrs1) == 0);
memcpy(&attrs2, &test->data, sizeof(attrs2));
if (desc)
attrs2.notice_of_absence.descriptors = l_queue_new();
while (desc && desc->start_time) {
l_queue_push_tail(attrs2.notice_of_absence.descriptors,
l_memdup(desc, sizeof(*desc)));
desc++;
}
assert(attrs1.capability.device_caps == attrs2.capability.device_caps);
assert(attrs1.capability.group_caps == attrs2.capability.group_caps);
assert(attrs1.listen_availability.avail_period_ms ==
attrs2.listen_availability.avail_period_ms);
assert(attrs1.listen_availability.avail_interval_ms ==
attrs2.listen_availability.avail_interval_ms);
assert(attrs1.notice_of_absence.index ==
attrs2.notice_of_absence.index);
assert(attrs1.notice_of_absence.opp_ps ==
attrs2.notice_of_absence.opp_ps);
assert(attrs1.notice_of_absence.ct_window ==
attrs2.notice_of_absence.ct_window);
assert(test_queue_cmp(attrs1.notice_of_absence.descriptors,
attrs2.notice_of_absence.descriptors,
p2p_noa_desc_cmp));
assert(!memcmp(attrs1.device_info.device_addr,
attrs2.device_info.device_addr, 6));
assert(attrs1.device_info.wsc_config_methods ==
attrs2.device_info.wsc_config_methods);
assert(attrs1.device_info.primary_device_type.category ==
attrs2.device_info.primary_device_type.category);
assert(!memcmp(attrs1.device_info.primary_device_type.oui,
attrs2.device_info.primary_device_type.oui, 3));
assert(attrs1.device_info.primary_device_type.oui_type ==
attrs2.device_info.primary_device_type.oui_type);
assert(attrs1.device_info.primary_device_type.subcategory ==
attrs2.device_info.primary_device_type.subcategory);
assert(l_queue_length(attrs1.device_info.secondary_device_types) ==
l_queue_length(attrs2.device_info.secondary_device_types));
assert(!strcmp(attrs1.device_info.device_name,
attrs2.device_info.device_name));
assert(l_queue_length(attrs1.group_clients) ==
l_queue_length(attrs2.group_clients));
assert(l_queue_length(attrs1.advertised_svcs) ==
l_queue_length(attrs2.advertised_svcs));
p2p_clear_probe_resp(&attrs1);
p2p_clear_probe_resp(&attrs2);
}
static void p2p_test_build_probe_resp(const void *data)
{
const struct p2p_probe_resp_data *test = data;
struct p2p_probe_resp attrs2;
const struct p2p_notice_of_absence_desc *desc = test->noa_descs;
uint8_t *ies;
size_t ies_len;
memcpy(&attrs2, &test->data, sizeof(attrs2));
if (desc)
attrs2.notice_of_absence.descriptors = l_queue_new();
while (desc && desc->start_time) {
l_queue_push_tail(attrs2.notice_of_absence.descriptors,
l_memdup(desc, sizeof(*desc)));
desc++;
}
ies = p2p_build_probe_resp(&attrs2, &ies_len);
p2p_clear_probe_resp(&attrs2);
assert(p2p_payload_cmd(ies, ies_len, test->ies, test->ies_len));
l_free(ies);
}
static const uint8_t p2p_association_req_ies_1[] = {
0xdd, 0x18, 0x00, 0x50, 0xf2, 0x04, 0x10, 0x4a, 0x00, 0x01, 0x10, 0x10,
0x3a, 0x00, 0x01, 0x01, 0x10, 0x49, 0x00, 0x06, 0x00, 0x37, 0x2a, 0x00,
0x01, 0x20, 0xdd, 0x29, 0x50, 0x6f, 0x9a, 0x09, 0x02, 0x02, 0x00, 0x27,
0x00, 0x0d, 0x1d, 0x00, 0x00, 0x28, 0xf8, 0xed, 0x26, 0x57, 0x11, 0x08,
0x00, 0x01, 0x00, 0x50, 0xf2, 0x04, 0x00, 0x01, 0x00, 0x10, 0x11, 0x00,
0x08, 0x74, 0x65, 0x73, 0x74, 0x64, 0x65, 0x76, 0x31,
};
struct p2p_association_req_data {
const uint8_t *ies;
size_t ies_len;
ssize_t payload_len;
struct p2p_association_req data;
};
static const struct p2p_association_req_data p2p_association_req_data_1 = {
.ies = p2p_association_req_ies_1,
.ies_len = L_ARRAY_SIZE(p2p_association_req_ies_1),
.payload_len = 37,
.data = {
.capability = {
.device_caps = P2P_DEVICE_CAP_SVC_DISCOVERY |
P2P_DEVICE_CAP_CLIENT_DISCOVERABILITY |
P2P_DEVICE_CAP_CONCURRENT_OP |
P2P_DEVICE_CAP_INVITATION_PROCEDURE,
.group_caps = 0,
},
.device_info = {
.device_addr = { 0x00, 0x28, 0xf8, 0xed, 0x26, 0x57 },
.wsc_config_methods = WSC_CONFIGURATION_METHOD_DISPLAY |
WSC_CONFIGURATION_METHOD_KEYPAD |
WSC_CONFIGURATION_METHOD_P2P,
.primary_device_type = {
.category = 1,
.oui = { 0x00, 0x50, 0xf2 },
.oui_type = 0x04,
.subcategory = 1,
},
.device_name = "testdev1",
},
},
};
static void p2p_test_parse_association_req(const void *data)
{
const struct p2p_association_req_data *test = data;
struct p2p_association_req attrs1, attrs2;
uint8_t *payload;
ssize_t payload_len;
payload = ie_tlv_extract_p2p_payload(test->ies, test->ies_len,
&payload_len);
l_free(payload);
assert(payload_len == test->payload_len);
assert(p2p_parse_association_req(test->ies, test->ies_len, &attrs1) ==
0);
memcpy(&attrs2, &test->data, sizeof(attrs2));
assert(attrs1.capability.device_caps == attrs2.capability.device_caps);
assert(attrs1.capability.group_caps == attrs2.capability.group_caps);
assert(attrs1.listen_availability.avail_period_ms ==
attrs2.listen_availability.avail_period_ms);
assert(attrs1.listen_availability.avail_interval_ms ==
attrs2.listen_availability.avail_interval_ms);
assert(!memcmp(attrs1.device_info.device_addr,
attrs2.device_info.device_addr, 6));
assert(attrs1.device_info.wsc_config_methods ==
attrs2.device_info.wsc_config_methods);
assert(attrs1.device_info.primary_device_type.category ==
attrs2.device_info.primary_device_type.category);
assert(!memcmp(attrs1.device_info.primary_device_type.oui,
attrs2.device_info.primary_device_type.oui, 3));
assert(attrs1.device_info.primary_device_type.oui_type ==
attrs2.device_info.primary_device_type.oui_type);
assert(attrs1.device_info.primary_device_type.subcategory ==
attrs2.device_info.primary_device_type.subcategory);
assert(l_queue_length(attrs1.device_info.secondary_device_types) ==
l_queue_length(attrs2.device_info.secondary_device_types));
assert(!strcmp(attrs1.device_info.device_name,
attrs2.device_info.device_name));
assert(!memcmp(attrs1.interface.device_addr,
attrs2.interface.device_addr, 6));
assert(l_queue_length(attrs1.interface.interface_addrs) ==
l_queue_length(attrs2.interface.interface_addrs));
p2p_clear_association_req(&attrs1);
p2p_clear_association_req(&attrs2);
}
static void p2p_test_build_association_req(const void *data)
{
const struct p2p_association_req_data *test = data;
uint8_t *ies;
size_t ies_len;
ies = p2p_build_association_req(&test->data, &ies_len);
assert(p2p_payload_cmd(ies, ies_len, test->ies, test->ies_len));
l_free(ies);
}
/* Obligatory P2P IE empty here */
static const uint8_t p2p_association_resp_ies_1[] = {
0x01, 0x08, 0x8c, 0x12, 0x98, 0x24, 0xb0, 0x48, 0x60, 0x6c, 0x2d, 0x1a,
0x73, 0x11, 0x03, 0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x3d, 0x16, 0x64, 0x05, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xdd, 0x04, 0x50, 0x6f, 0x9a, 0x09, 0x7f, 0x08, 0x01, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xbf, 0x0c, 0x30, 0x71, 0x90, 0x03,
0xfe, 0xff, 0x00, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xc0, 0x05, 0x00, 0x00,
0x00, 0xfe, 0xff, 0xdd, 0x18, 0x00, 0x50, 0xf2, 0x02, 0x01, 0x01, 0x80,
0x01, 0x03, 0xa4, 0x00, 0x00, 0x27, 0xa4, 0x00, 0x00, 0x42, 0x43, 0x5e,
0x00, 0x62, 0x32, 0x2f, 0x00, 0xdd, 0x07, 0x00, 0x0c, 0xe7, 0x08, 0x00,
0x00, 0x00,
};
struct p2p_association_resp_data {
const uint8_t *ies;
size_t ies_len;
ssize_t payload_len;
struct p2p_association_resp data;
};
static const struct p2p_association_resp_data p2p_association_resp_data_1 = {
.ies = p2p_association_resp_ies_1,
.ies_len = L_ARRAY_SIZE(p2p_association_resp_ies_1),
.payload_len = 0,
.data = {},
};
static void p2p_test_parse_association_resp(const void *data)
{
const struct p2p_association_resp_data *test = data;
struct p2p_association_resp attrs1, attrs2;
uint8_t *payload;
ssize_t payload_len;
payload = ie_tlv_extract_p2p_payload(test->ies, test->ies_len,
&payload_len);
l_free(payload);
assert(payload_len == test->payload_len);
assert(p2p_parse_association_resp(test->ies, test->ies_len, &attrs1) ==
0);
memcpy(&attrs2, &test->data, sizeof(attrs2));
assert(attrs1.status == attrs2.status);
assert(attrs1.listen_availability.avail_period_ms ==
attrs2.listen_availability.avail_period_ms);
assert(attrs1.listen_availability.avail_interval_ms ==
attrs2.listen_availability.avail_interval_ms);
p2p_clear_association_resp(&attrs1);
p2p_clear_association_resp(&attrs2);
}
static void p2p_test_build_association_resp(const void *data)
{
const struct p2p_association_resp_data *test = data;
uint8_t *ies;
size_t ies_len;
ies = p2p_build_association_resp(&test->data, &ies_len);
assert(p2p_payload_cmd(ies, ies_len, test->ies, test->ies_len));
l_free(ies);
}
static const uint8_t p2p_provision_disc_req_1[] = {
0x04, 0x09, 0x50, 0x6f, 0x9a, 0x09, 0x07, 0x01, 0xdd, 0x41, 0x50, 0x6f,
0x9a, 0x09, 0x02, 0x02, 0x00, 0x25, 0x00, 0x0d, 0x1d, 0x00, 0x00, 0x28,
0xf8, 0xed, 0x26, 0x57, 0x11, 0x08, 0x00, 0x01, 0x00, 0x50, 0xf2, 0x04,
0x00, 0x01, 0x00, 0x10, 0x11, 0x00, 0x08, 0x74, 0x65, 0x73, 0x74, 0x64,
0x65, 0x76, 0x31, 0x0f, 0x15, 0x00, 0x2a, 0xfe, 0xcd, 0x01, 0xbe, 0xa0,
0x44, 0x49, 0x52, 0x45, 0x43, 0x54, 0x2d, 0x5a, 0x75, 0x2d, 0x54, 0x65,
0x73, 0x74, 0x31, 0xdd, 0x0a, 0x00, 0x50, 0xf2, 0x04, 0x10, 0x08, 0x00,
0x02, 0x00, 0x80,
};
struct p2p_provision_disc_req_data {
const uint8_t *frame;
size_t frame_len;
ssize_t payload_len;
struct p2p_provision_discovery_req data;
};
static const struct p2p_provision_disc_req_data p2p_provision_disc_req_data_1 =
{
.frame = p2p_provision_disc_req_1,
.frame_len = L_ARRAY_SIZE(p2p_provision_disc_req_1),
.payload_len = 61,
.data = {
.dialog_token = 1,
.capability = {
.device_caps = P2P_DEVICE_CAP_SVC_DISCOVERY |
P2P_DEVICE_CAP_CONCURRENT_OP |
P2P_DEVICE_CAP_INVITATION_PROCEDURE,
.group_caps = 0,
},
.device_info = {
.device_addr = { 0x00, 0x28, 0xf8, 0xed, 0x26, 0x57 },
.wsc_config_methods = WSC_CONFIGURATION_METHOD_DISPLAY |
WSC_CONFIGURATION_METHOD_KEYPAD |
WSC_CONFIGURATION_METHOD_P2P,
.primary_device_type = {
.category = 1,
.oui = { 0x00, 0x50, 0xf2 },
.oui_type = 0x04,
.subcategory = 1,
},
.device_name = "testdev1",
},
.group_id = {
.device_addr = { 0x2a, 0xfe, 0xcd, 0x01, 0xbe, 0xa0 },
.ssid = "DIRECT-Zu-Test1",
},
.status = -1,
.wsc_config_method = WSC_CONFIGURATION_METHOD_PUSH_BUTTON,
},
};
static void p2p_test_parse_provision_disc_req(const void *data)
{
const struct p2p_provision_disc_req_data *test = data;
struct p2p_provision_discovery_req attrs1, attrs2;
uint8_t *payload;
ssize_t payload_len;
payload = ie_tlv_extract_p2p_payload(test->frame + 8,
test->frame_len - 8,
&payload_len);
l_free(payload);
assert(payload_len == test->payload_len);
assert(p2p_parse_provision_disc_req(test->frame + 7,
test->frame_len - 7,
&attrs1) == 0);
memcpy(&attrs2, &test->data, sizeof(attrs2));
assert(attrs1.dialog_token == attrs2.dialog_token);
assert(attrs1.capability.device_caps == attrs2.capability.device_caps);
assert(attrs1.capability.group_caps == attrs2.capability.group_caps);
assert(!memcmp(attrs1.device_info.device_addr,
attrs2.device_info.device_addr, 6));
assert(attrs1.device_info.wsc_config_methods ==
attrs2.device_info.wsc_config_methods);
assert(attrs1.device_info.primary_device_type.category ==
attrs2.device_info.primary_device_type.category);
assert(!memcmp(attrs1.device_info.primary_device_type.oui,
attrs2.device_info.primary_device_type.oui, 3));
assert(attrs1.device_info.primary_device_type.oui_type ==
attrs2.device_info.primary_device_type.oui_type);
assert(attrs1.device_info.primary_device_type.subcategory ==
attrs2.device_info.primary_device_type.subcategory);
assert(l_queue_length(attrs1.device_info.secondary_device_types) ==
l_queue_length(attrs2.device_info.secondary_device_types));
assert(!strcmp(attrs1.device_info.device_name,
attrs2.device_info.device_name));
assert(!memcmp(attrs1.group_id.device_addr,
attrs2.group_id.device_addr, 6));
assert(!strcmp(attrs1.group_id.ssid, attrs2.group_id.ssid));
assert(!memcmp(attrs1.intended_interface_addr,
attrs2.intended_interface_addr, 6));
assert(attrs1.status == attrs2.status);
assert(!memcmp(attrs1.operating_channel.country,
attrs2.operating_channel.country, 3));
assert(attrs1.operating_channel.oper_class ==
attrs2.operating_channel.oper_class);
assert(attrs1.operating_channel.channel_num ==
attrs2.operating_channel.channel_num);
assert(!memcmp(attrs1.channel_list.country,
attrs2.channel_list.country, 3));
assert(l_queue_length(attrs1.channel_list.channel_entries) ==
l_queue_length(attrs2.channel_list.channel_entries));
assert(attrs1.session_info.data_len == attrs2.session_info.data_len);
assert(!attrs1.session_info.data_len ||
!memcmp(attrs1.session_info.data, attrs2.session_info.data,
attrs1.session_info.data_len));
assert(attrs1.connection_capability == attrs2.connection_capability);
assert(attrs1.advertisement_id.advertisement_id ==
attrs2.advertisement_id.advertisement_id);
assert(!memcmp(attrs1.advertisement_id.service_mac_addr,
attrs2.advertisement_id.service_mac_addr, 6));
assert(attrs1.config_timeout.go_config_timeout ==
attrs2.config_timeout.go_config_timeout);
assert(attrs1.config_timeout.client_config_timeout ==
attrs2.config_timeout.client_config_timeout);
assert(!memcmp(attrs1.listen_channel.country,
attrs2.listen_channel.country, 3));
assert(attrs1.listen_channel.oper_class ==
attrs2.listen_channel.oper_class);
assert(attrs1.listen_channel.channel_num ==
attrs2.listen_channel.channel_num);
assert(attrs1.session_id.session_id == attrs2.session_id.session_id);
assert(!memcmp(attrs1.session_id.session_mac_addr,
attrs2.session_id.session_mac_addr, 6));
assert(attrs1.transport_protocol == attrs2.transport_protocol);
assert(!memcmp(attrs1.persistent_group_info.device_addr,
attrs2.persistent_group_info.device_addr, 6));
assert(!strcmp(attrs1.persistent_group_info.ssid,
attrs2.persistent_group_info.ssid));
assert(attrs1.wsc_config_method == attrs2.wsc_config_method);
p2p_clear_provision_disc_req(&attrs1);
p2p_clear_provision_disc_req(&attrs2);
}
static void p2p_test_build_provision_disc_req(const void *data)
{
const struct p2p_provision_disc_req_data *test = data;
uint8_t *frame;
size_t frame_len;
frame = p2p_build_provision_disc_req(&test->data, &frame_len);
assert(!memcmp(frame, test->frame, 8));
assert(p2p_payload_cmd(frame + 8, frame_len - 8,
test->frame + 8, test->frame_len - 8));
l_free(frame);
}
/* The optional P2P IE not present here */
static const uint8_t p2p_provision_disc_resp_1[] = {
0x04, 0x09, 0x50, 0x6f, 0x9a, 0x09, 0x08, 0x01, 0xdd, 0x0a, 0x00, 0x50,
0xf2, 0x04, 0x10, 0x08, 0x00, 0x02, 0x00, 0x80, 0xdd, 0x0d, 0x50, 0x6f,
0x9a, 0x0a, 0x00, 0x00, 0x06, 0x00, 0x11, 0x00, 0x00, 0x00, 0x32,
};
struct p2p_provision_disc_resp_data {
const uint8_t *frame;
size_t frame_len;
ssize_t payload_len;
struct p2p_provision_discovery_resp data;
};
static const struct p2p_provision_disc_resp_data
p2p_provision_disc_resp_data_1 = {
.frame = p2p_provision_disc_resp_1,
.frame_len = L_ARRAY_SIZE(p2p_provision_disc_resp_1),
.payload_len = -ENOENT,
.data = {
.dialog_token = 1,
.status = -1,
.wsc_config_method = WSC_CONFIGURATION_METHOD_PUSH_BUTTON,
},
};
static void p2p_test_parse_provision_disc_resp(const void *data)
{
const struct p2p_provision_disc_resp_data *test = data;
struct p2p_provision_discovery_resp attrs1, attrs2;
uint8_t *payload;
ssize_t payload_len;
payload = ie_tlv_extract_p2p_payload(test->frame + 8,
test->frame_len - 8,
&payload_len);
if (payload_len >= 0)
l_free(payload);
assert(payload_len == test->payload_len);
assert(p2p_parse_provision_disc_resp(test->frame + 7,
test->frame_len - 7,
&attrs1) == 0);
memcpy(&attrs2, &test->data, sizeof(attrs2));
assert(attrs1.dialog_token == attrs2.dialog_token);
assert(attrs1.status == attrs2.status);
assert(attrs1.capability.device_caps == attrs2.capability.device_caps);
assert(attrs1.capability.group_caps == attrs2.capability.group_caps);
assert(!memcmp(attrs1.device_info.device_addr,
attrs2.device_info.device_addr, 6));
assert(attrs1.device_info.wsc_config_methods ==
attrs2.device_info.wsc_config_methods);
assert(attrs1.device_info.primary_device_type.category ==
attrs2.device_info.primary_device_type.category);
assert(!memcmp(attrs1.device_info.primary_device_type.oui,
attrs2.device_info.primary_device_type.oui, 3));
assert(attrs1.device_info.primary_device_type.oui_type ==
attrs2.device_info.primary_device_type.oui_type);
assert(attrs1.device_info.primary_device_type.subcategory ==
attrs2.device_info.primary_device_type.subcategory);
assert(l_queue_length(attrs1.device_info.secondary_device_types) ==
l_queue_length(attrs2.device_info.secondary_device_types));
assert(!strcmp(attrs1.device_info.device_name,
attrs2.device_info.device_name));
assert(!memcmp(attrs1.group_id.device_addr,
attrs2.group_id.device_addr, 6));
assert(!strcmp(attrs1.group_id.ssid, attrs2.group_id.ssid));
assert(!memcmp(attrs1.intended_interface_addr,
attrs2.intended_interface_addr, 6));
assert(!memcmp(attrs1.operating_channel.country,
attrs2.operating_channel.country, 3));
assert(attrs1.operating_channel.oper_class ==
attrs2.operating_channel.oper_class);
assert(attrs1.operating_channel.channel_num ==
attrs2.operating_channel.channel_num);
assert(!memcmp(attrs1.channel_list.country,
attrs2.channel_list.country, 3));
assert(l_queue_length(attrs1.channel_list.channel_entries) ==
l_queue_length(attrs2.channel_list.channel_entries));
assert(attrs1.connection_capability == attrs2.connection_capability);
assert(attrs1.advertisement_id.advertisement_id ==
attrs2.advertisement_id.advertisement_id);
assert(!memcmp(attrs1.advertisement_id.service_mac_addr,
attrs2.advertisement_id.service_mac_addr, 6));
assert(attrs1.config_timeout.go_config_timeout ==
attrs2.config_timeout.go_config_timeout);
assert(attrs1.config_timeout.client_config_timeout ==
attrs2.config_timeout.client_config_timeout);
assert(attrs1.session_id.session_id == attrs2.session_id.session_id);
assert(!memcmp(attrs1.session_id.session_mac_addr,
attrs2.session_id.session_mac_addr, 6));
assert(attrs1.transport_protocol == attrs2.transport_protocol);
assert(!memcmp(attrs1.persistent_group_info.device_addr,
attrs2.persistent_group_info.device_addr, 6));
assert(!strcmp(attrs1.persistent_group_info.ssid,
attrs2.persistent_group_info.ssid));
assert(attrs1.session_info.data_len == attrs2.session_info.data_len);
assert(!attrs1.session_info.data_len ||
!memcmp(attrs1.session_info.data, attrs2.session_info.data,
attrs1.session_info.data_len));
assert(attrs1.wsc_config_method == attrs2.wsc_config_method);
p2p_clear_provision_disc_resp(&attrs1);
p2p_clear_provision_disc_resp(&attrs2);
}
int main(int argc, char *argv[])
{
l_test_init(&argc, &argv);
l_test_add("/p2p/iter/sanity-check", p2p_test_iter_sanity_check, NULL);
l_test_add("/p2p/parse/Beacon IEs 1", p2p_test_parse_beacon,
&p2p_beacon_data_1);
l_test_add("/p2p/build/Beacon IEs 1", p2p_test_build_beacon,
&p2p_beacon_data_1);
l_test_add("/p2p/parse/Probe Request IEs 1", p2p_test_parse_probe_req,
&p2p_probe_req_data_1);
l_test_add("/p2p/build/Probe Request IEs 1", p2p_test_build_probe_req,
&p2p_probe_req_data_1);
l_test_add("/p2p/parse/Probe Response IEs 1", p2p_test_parse_probe_resp,
&p2p_probe_resp_data_1);
l_test_add("/p2p/parse/Probe Response IEs 2", p2p_test_parse_probe_resp,
&p2p_probe_resp_data_2);
l_test_add("/p2p/build/Probe Response IEs 1", p2p_test_build_probe_resp,
&p2p_probe_resp_data_1);
l_test_add("/p2p/build/Probe Response IEs 2", p2p_test_build_probe_resp,
&p2p_probe_resp_data_2);
l_test_add("/p2p/parse/Association Request IEs 1",
p2p_test_parse_association_req,
&p2p_association_req_data_1);
l_test_add("/p2p/build/Association Request IEs 1",
p2p_test_build_association_req,
&p2p_association_req_data_1);
l_test_add("/p2p/parse/Association Response IEs 1",
p2p_test_parse_association_resp,
&p2p_association_resp_data_1);
l_test_add("/p2p/build/Association Response IEs 1",
p2p_test_build_association_resp,
&p2p_association_resp_data_1);
l_test_add("/p2p/parse/Provision Discovery Request 1",
p2p_test_parse_provision_disc_req,
&p2p_provision_disc_req_data_1);
l_test_add("/p2p/build/Provision Discovery Request 1",
p2p_test_build_provision_disc_req,
&p2p_provision_disc_req_data_1);
l_test_add("/p2p/parse/Provision Discovery Response 1",
p2p_test_parse_provision_disc_resp,
&p2p_provision_disc_resp_data_1);
return l_test_run();
}
View Git Blame Copy Permalink