Kernel/iwd
3
0
Fork 0
mirror of https://git.kernel.org/pub/scm/network/wireless/iwd.git synced 2024-11-22 06:29:23 +01:00
Code Releases Activity

p2p: Consistently use the conn_ prefix for variables

Browse Source 
Prefix all the struct p2p_device members that are part of the connection
state with the "conn_" string for consistency.  If we needed to support
multiple client connections, these members are the ones that would
probably land in a separate structure, without that prefix.
This commit is contained in:
Andrew Zaborowski 2020-09-09 01:49:23 +02:00 committed by Denis Kenzior
parent d511b4b782
commit 0d2d34c353
1 changed files with 48 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
src/p2p.c
View File

@ -100,14 +100,14 @@ struct p2p_device {
uint8_t conn_psk[32];
int conn_retry_count;
struct l_timeout *config_timeout;
unsigned long go_config_delay;
struct l_timeout *go_neg_req_timeout;
uint8_t go_dialog_token;
unsigned int go_scan_retry;
uint32_t go_oper_freq;
struct l_timeout *conn_peer_config_timeout;
unsigned long conn_config_delay;
struct l_timeout *conn_go_neg_req_timeout;
uint8_t conn_go_dialog_token;
unsigned int conn_go_scan_retry;
uint32_t conn_go_oper_freq;
struct p2p_group_id_attr go_group_id;
uint8_t go_interface_addr[6];
uint8_t conn_peer_interface_addr[6];
bool enabled : 1;
bool have_roc_cookie : 1;
@ -425,8 +425,8 @@ static void p2p_connection_reset(struct p2p_device *dev)
l_dbus_property_changed(dbus_get_bus(), p2p_device_get_path(dev),
IWD_P2P_INTERFACE, "AvailableConnections");
l_timeout_remove(dev->config_timeout);
l_timeout_remove(dev->go_neg_req_timeout);
l_timeout_remove(dev->conn_peer_config_timeout);
l_timeout_remove(dev->conn_go_neg_req_timeout);
l_timeout_remove(dev->conn_dhcp_timeout);
if (dev->conn_netconfig) {
@ -911,8 +911,8 @@ static void p2p_peer_provision_done(int err, struct wsc_credentials_info *creds,
dev->conn_enrollee = NULL;
l_timeout_remove(dev->config_timeout);
l_timeout_remove(dev->go_neg_req_timeout);
l_timeout_remove(dev->conn_peer_config_timeout);
l_timeout_remove(dev->conn_go_neg_req_timeout);
if (err < 0) {
if (err == -ECANCELED && peer->wsc.pending_cancel) {
@ -1159,8 +1159,9 @@ static bool p2p_provision_scan_notify(int err, struct l_queue *bss_list,
if (dev->go_group_id.ssid[bss->ssid_len] != '\0')
continue;
if (!util_mem_is_zero(dev->go_interface_addr, 6) &&
memcmp(bss->addr, dev->go_interface_addr, 6))
if (!util_mem_is_zero(dev->conn_peer_interface_addr, 6) &&
memcmp(bss->addr, dev->conn_peer_interface_addr,
6))
l_debug("SSID matched but BSSID didn't match the GO's "
"intended interface addr, proceeding anyway");
@ -1280,9 +1281,9 @@ static bool p2p_provision_scan_notify(int err, struct l_queue *bss_list,
}
/* Retry a few times if the WSC AP not found or not ready */
dev->go_scan_retry++;
dev->conn_go_scan_retry++;
if (dev->go_scan_retry > 15) {
if (dev->conn_go_scan_retry > 15) {
p2p_connect_failed(dev);
return false;
}
@ -1320,9 +1321,9 @@ static void p2p_provision_scan_start(struct p2p_device *dev)
* ourselves any work anyway as the Channel List is going to
* contain all of the 2.4 and 5G channels.
*/
if (dev->go_scan_retry < 12) {
if (dev->conn_go_scan_retry < 12) {
params.freqs = scan_freq_set_new();
scan_freq_set_add(params.freqs, dev->go_oper_freq);
scan_freq_set_add(params.freqs, dev->conn_go_oper_freq);
}
dev->scan_id = scan_active_full(dev->wdev_id, &params, NULL,
@ -1337,13 +1338,14 @@ static void p2p_start_client_provision(struct p2p_device *dev)
{
char bssid_str[18];
memcpy(bssid_str, util_address_to_string(dev->go_interface_addr), 18);
l_debug("freq=%u ssid=%s group_addr=%s bssid=%s", dev->go_oper_freq,
dev->go_group_id.ssid,
memcpy(bssid_str, util_address_to_string(dev->conn_peer_interface_addr),
18);
l_debug("freq=%u ssid=%s group_addr=%s bssid=%s",
dev->conn_go_oper_freq, dev->go_group_id.ssid,
util_address_to_string(dev->go_group_id.device_addr),
bssid_str);
dev->go_scan_retry = 0;
dev->conn_go_scan_retry = 0;
p2p_provision_scan_start(dev);
}
@ -1351,14 +1353,14 @@ static void p2p_config_timeout_destroy(void *user_data)
{
struct p2p_device *dev = user_data;
dev->config_timeout = NULL;
dev->conn_peer_config_timeout = NULL;
}
static void p2p_config_timeout(struct l_timeout *timeout, void *user_data)
{
struct p2p_device *dev = user_data;
l_timeout_remove(dev->config_timeout);
l_timeout_remove(dev->conn_peer_config_timeout);
/* Ready to start WSC */
p2p_start_client_provision(dev);
@ -1643,7 +1645,7 @@ static bool p2p_go_negotiation_confirm_cb(const struct mmpdu_header *mpdu,
return true;
}
if (info.dialog_token != dev->go_dialog_token) {
if (info.dialog_token != dev->conn_go_dialog_token) {
l_error("GO Negotiation Response dialog token doesn't match");
p2p_connect_failed(dev);
return true;
@ -1676,7 +1678,7 @@ static bool p2p_go_negotiation_confirm_cb(const struct mmpdu_header *mpdu,
return true;
}
dev->go_oper_freq = frequency;
dev->conn_go_oper_freq = frequency;
memcpy(&dev->go_group_id, &info.group_id,
sizeof(struct p2p_group_id_attr));
@ -1685,7 +1687,8 @@ static bool p2p_go_negotiation_confirm_cb(const struct mmpdu_header *mpdu,
* of time indicated by the peer in the GO Negotiation Response's
* Configuration Timeout attribute and start the provisioning phase.
*/
dev->config_timeout = l_timeout_create_ms(dev->go_config_delay,
dev->conn_peer_config_timeout = l_timeout_create_ms(
dev->conn_config_delay,
p2p_config_timeout, dev,
p2p_config_timeout_destroy);
return true;
@ -1737,7 +1740,7 @@ static void p2p_device_go_negotiation_req_cb(const struct mmpdu_header *mpdu,
if (body_len < 8)
return;
if (!dev->go_neg_req_timeout || peer != dev->conn_peer) {
if (!dev->conn_go_neg_req_timeout || peer != dev->conn_peer) {
status = P2P_STATUS_FAIL_INFO_NOT_AVAIL;
goto respond;
}
@ -1803,12 +1806,13 @@ static void p2p_device_go_negotiation_req_cb(const struct mmpdu_header *mpdu,
goto p2p_free;
}
l_timeout_remove(dev->go_neg_req_timeout);
l_timeout_remove(dev->conn_go_neg_req_timeout);
p2p_device_discovery_stop(dev);
dev->go_dialog_token = req_info.dialog_token;
dev->go_config_delay = req_info.config_timeout.go_config_timeout * 10;
memcpy(dev->go_interface_addr, req_info.intended_interface_addr, 6);
dev->conn_go_dialog_token = req_info.dialog_token;
dev->conn_config_delay = req_info.config_timeout.go_config_timeout * 10;
memcpy(dev->conn_peer_interface_addr, req_info.intended_interface_addr,
6);
p2p_free:
tie_breaker = !req_info.go_tie_breaker;
@ -1816,7 +1820,7 @@ p2p_free:
respond:
/* Build and send the GO Negotiation Response */
resp_info.dialog_token = dev->go_dialog_token;
resp_info.dialog_token = dev->conn_go_dialog_token;
resp_info.status = status;
resp_info.capability.device_caps = dev->capability.device_caps;
resp_info.capability.group_caps = 0; /* Reserved */
@ -1885,7 +1889,8 @@ static void p2p_go_negotiation_confirm_done(int error, void *user_data)
* time indicated by the peer in the GO Negotiation Response's
* Configuration Timeout attribute and start the provisioning phase.
*/
dev->config_timeout = l_timeout_create_ms(dev->go_config_delay,
dev->conn_peer_config_timeout = l_timeout_create_ms(
dev->conn_config_delay,
p2p_config_timeout, dev,
p2p_config_timeout_destroy);
}
@ -1894,7 +1899,7 @@ static void p2p_go_neg_req_timeout_destroy(void *user_data)
{
struct p2p_device *dev = user_data;
dev->go_neg_req_timeout = NULL;
dev->conn_go_neg_req_timeout = NULL;
}
static void p2p_go_neg_req_timeout(struct l_timeout *timeout, void *user_data)
@ -1952,7 +1957,7 @@ static bool p2p_go_negotiation_resp_cb(const struct mmpdu_header *mpdu,
l_error("P2P_STATUS_FAIL_INFO_NOT_AVAIL: Will wait for "
"a new GO Negotiation Request before declaring "
"failure");
dev->go_neg_req_timeout = l_timeout_create(120,
dev->conn_go_neg_req_timeout = l_timeout_create(120,
p2p_go_neg_req_timeout, dev,
p2p_go_neg_req_timeout_destroy);
p2p_device_discovery_start(dev);
@ -2016,11 +2021,13 @@ static bool p2p_go_negotiation_resp_cb(const struct mmpdu_header *mpdu,
return true;
}
dev->go_config_delay = resp_info.config_timeout.go_config_timeout * 10;
dev->go_oper_freq = frequency;
dev->conn_config_delay =
resp_info.config_timeout.go_config_timeout * 10;
dev->conn_go_oper_freq = frequency;
memcpy(&dev->go_group_id, &resp_info.group_id,
sizeof(struct p2p_group_id_attr));
memcpy(dev->go_interface_addr, resp_info.intended_interface_addr, 6);
memcpy(dev->conn_peer_interface_addr,
resp_info.intended_interface_addr, 6);
/* Build and send the GO Negotiation Confirmation */
confirm_info.dialog_token = resp_info.dialog_token;
@ -2207,8 +2214,8 @@ static bool p2p_provision_disc_resp_cb(const struct mmpdu_header *mpdu,
* We might want to make sure that Group Formation is false but the
* Capability attribute is also optional.
*/
dev->go_oper_freq = dev->conn_peer->bss->frequency;
memset(dev->go_interface_addr, 0, 6);
dev->conn_go_oper_freq = dev->conn_peer->bss->frequency;
memset(dev->conn_peer_interface_addr, 0, 6);
memcpy(dev->go_group_id.device_addr, dev->conn_peer->device_addr, 6);
l_strlcpy(dev->go_group_id.ssid,
(const char *) dev->conn_peer->bss->ssid,
@ -3264,7 +3271,7 @@ static void p2p_device_probe_cb(const struct mmpdu_header *mpdu,
return;
from_conn_peer =
dev->go_neg_req_timeout && dev->conn_peer &&
dev->conn_go_neg_req_timeout && dev->conn_peer &&
!memcmp(mpdu->address_2, dev->conn_peer->bss->addr, 6);
wsc_payload = ie_tlv_extract_wsc_payload(body, body_len, &wsc_len);