hostapd/src/common/dpp_tcp.c

1776 lines
44 KiB
C
Raw Normal View History

/*
* DPP over TCP
* Copyright (c) 2019-2020, The Linux Foundation
*
* This software may be distributed under the terms of the BSD license.
* See README for more details.
*/
#include "utils/includes.h"
#include <fcntl.h>
#include "utils/common.h"
#include "utils/ip_addr.h"
#include "utils/eloop.h"
#include "common/ieee802_11_common.h"
#include "common/wpa_ctrl.h"
#include "dpp.h"
#include "dpp_i.h"
#ifdef CONFIG_DPP2
struct dpp_connection {
struct dl_list list;
struct dpp_controller *ctrl;
struct dpp_relay_controller *relay;
struct dpp_global *global;
struct dpp_authentication *auth;
void *msg_ctx;
int sock;
u8 mac_addr[ETH_ALEN];
unsigned int freq;
u8 msg_len[4];
size_t msg_len_octets;
struct wpabuf *msg;
struct wpabuf *msg_out;
size_t msg_out_pos;
unsigned int read_eloop:1;
unsigned int write_eloop:1;
unsigned int on_tcp_tx_complete_gas_done:1;
unsigned int on_tcp_tx_complete_remove:1;
unsigned int on_tcp_tx_complete_auth_ok:1;
unsigned int gas_comeback_in_progress:1;
u8 gas_dialog_token;
char *name;
enum dpp_netrole netrole;
};
/* Remote Controller */
struct dpp_relay_controller {
struct dl_list list;
struct dpp_global *global;
u8 pkhash[SHA256_MAC_LEN];
struct hostapd_ip_addr ipaddr;
void *cb_ctx;
void (*tx)(void *ctx, const u8 *addr, unsigned int freq, const u8 *msg,
size_t len);
void (*gas_resp_tx)(void *ctx, const u8 *addr, u8 dialog_token,
int prot, struct wpabuf *buf);
struct dl_list conn; /* struct dpp_connection */
};
/* Local Controller */
struct dpp_controller {
struct dpp_global *global;
u8 allowed_roles;
int qr_mutual;
int sock;
struct dl_list conn; /* struct dpp_connection */
char *configurator_params;
};
static void dpp_controller_rx(int sd, void *eloop_ctx, void *sock_ctx);
static void dpp_conn_tx_ready(int sock, void *eloop_ctx, void *sock_ctx);
static void dpp_controller_auth_success(struct dpp_connection *conn,
int initiator);
static void dpp_tcp_build_csr(void *eloop_ctx, void *timeout_ctx);
static void dpp_tcp_gas_query_comeback(void *eloop_ctx, void *timeout_ctx);
static void dpp_connection_free(struct dpp_connection *conn)
{
if (conn->sock >= 0) {
wpa_printf(MSG_DEBUG, "DPP: Close Controller socket %d",
conn->sock);
eloop_unregister_sock(conn->sock, EVENT_TYPE_READ);
eloop_unregister_sock(conn->sock, EVENT_TYPE_WRITE);
close(conn->sock);
}
eloop_cancel_timeout(dpp_controller_conn_status_result_wait_timeout,
conn, NULL);
eloop_cancel_timeout(dpp_tcp_build_csr, conn, NULL);
eloop_cancel_timeout(dpp_tcp_gas_query_comeback, conn, NULL);
wpabuf_free(conn->msg);
wpabuf_free(conn->msg_out);
dpp_auth_deinit(conn->auth);
os_free(conn->name);
os_free(conn);
}
static void dpp_connection_remove(struct dpp_connection *conn)
{
dl_list_del(&conn->list);
dpp_connection_free(conn);
}
int dpp_relay_add_controller(struct dpp_global *dpp,
struct dpp_relay_config *config)
{
struct dpp_relay_controller *ctrl;
if (!dpp)
return -1;
ctrl = os_zalloc(sizeof(*ctrl));
if (!ctrl)
return -1;
dl_list_init(&ctrl->conn);
ctrl->global = dpp;
os_memcpy(&ctrl->ipaddr, config->ipaddr, sizeof(*config->ipaddr));
os_memcpy(ctrl->pkhash, config->pkhash, SHA256_MAC_LEN);
ctrl->cb_ctx = config->cb_ctx;
ctrl->tx = config->tx;
ctrl->gas_resp_tx = config->gas_resp_tx;
dl_list_add(&dpp->controllers, &ctrl->list);
return 0;
}
static struct dpp_relay_controller *
dpp_relay_controller_get(struct dpp_global *dpp, const u8 *pkhash)
{
struct dpp_relay_controller *ctrl;
if (!dpp)
return NULL;
dl_list_for_each(ctrl, &dpp->controllers, struct dpp_relay_controller,
list) {
if (os_memcmp(pkhash, ctrl->pkhash, SHA256_MAC_LEN) == 0)
return ctrl;
}
return NULL;
}
static void dpp_controller_gas_done(struct dpp_connection *conn)
{
struct dpp_authentication *auth = conn->auth;
if (auth->waiting_csr) {
wpa_printf(MSG_DEBUG, "DPP: Waiting for CSR");
conn->on_tcp_tx_complete_gas_done = 0;
return;
}
if (auth->peer_version >= 2 &&
auth->conf_resp_status == DPP_STATUS_OK) {
wpa_printf(MSG_DEBUG, "DPP: Wait for Configuration Result");
auth->waiting_conf_result = 1;
return;
}
wpa_msg(conn->msg_ctx, MSG_INFO, DPP_EVENT_CONF_SENT);
dpp_connection_remove(conn);
}
static int dpp_tcp_send(struct dpp_connection *conn)
{
int res;
if (!conn->msg_out) {
eloop_unregister_sock(conn->sock, EVENT_TYPE_WRITE);
conn->write_eloop = 0;
return -1;
}
res = send(conn->sock,
wpabuf_head_u8(conn->msg_out) + conn->msg_out_pos,
wpabuf_len(conn->msg_out) - conn->msg_out_pos, 0);
if (res < 0) {
wpa_printf(MSG_DEBUG, "DPP: Failed to send buffer: %s",
strerror(errno));
dpp_connection_remove(conn);
return -1;
}
conn->msg_out_pos += res;
if (wpabuf_len(conn->msg_out) > conn->msg_out_pos) {
wpa_printf(MSG_DEBUG,
"DPP: %u/%u bytes of message sent to Controller",
(unsigned int) conn->msg_out_pos,
(unsigned int) wpabuf_len(conn->msg_out));
if (!conn->write_eloop &&
eloop_register_sock(conn->sock, EVENT_TYPE_WRITE,
dpp_conn_tx_ready, conn, NULL) == 0)
conn->write_eloop = 1;
return 1;
}
wpa_printf(MSG_DEBUG, "DPP: Full message sent over TCP");
wpabuf_free(conn->msg_out);
conn->msg_out = NULL;
conn->msg_out_pos = 0;
eloop_unregister_sock(conn->sock, EVENT_TYPE_WRITE);
conn->write_eloop = 0;
if (!conn->read_eloop &&
eloop_register_sock(conn->sock, EVENT_TYPE_READ,
dpp_controller_rx, conn, NULL) == 0)
conn->read_eloop = 1;
if (conn->on_tcp_tx_complete_remove) {
dpp_connection_remove(conn);
} else if (conn->auth && (conn->ctrl || conn->auth->configurator) &&
conn->on_tcp_tx_complete_gas_done) {
dpp_controller_gas_done(conn);
} else if (conn->on_tcp_tx_complete_auth_ok) {
conn->on_tcp_tx_complete_auth_ok = 0;
dpp_controller_auth_success(conn, 1);
}
return 0;
}
static int dpp_tcp_send_msg(struct dpp_connection *conn,
const struct wpabuf *msg)
{
wpabuf_free(conn->msg_out);
conn->msg_out_pos = 0;
conn->msg_out = wpabuf_alloc(4 + wpabuf_len(msg) - 1);
if (!conn->msg_out)
return -1;
wpabuf_put_be32(conn->msg_out, wpabuf_len(msg) - 1);
wpabuf_put_data(conn->msg_out, wpabuf_head_u8(msg) + 1,
wpabuf_len(msg) - 1);
if (dpp_tcp_send(conn) == 1) {
if (!conn->write_eloop) {
if (eloop_register_sock(conn->sock, EVENT_TYPE_WRITE,
dpp_conn_tx_ready,
conn, NULL) < 0)
return -1;
conn->write_eloop = 1;
}
}
return 0;
}
static void dpp_controller_start_gas_client(struct dpp_connection *conn)
{
struct dpp_authentication *auth = conn->auth;
struct wpabuf *buf;
const char *dpp_name;
dpp_name = conn->name ? conn->name : "Test";
buf = dpp_build_conf_req_helper(auth, dpp_name, conn->netrole, NULL,
NULL);
if (!buf) {
wpa_printf(MSG_DEBUG,
"DPP: No configuration request data available");
return;
}
dpp_tcp_send_msg(conn, buf);
wpabuf_free(buf);
}
static void dpp_controller_auth_success(struct dpp_connection *conn,
int initiator)
{
struct dpp_authentication *auth = conn->auth;
if (!auth)
return;
wpa_printf(MSG_DEBUG, "DPP: Authentication succeeded");
wpa_msg(conn->msg_ctx, MSG_INFO,
DPP_EVENT_AUTH_SUCCESS "init=%d", initiator);
#ifdef CONFIG_TESTING_OPTIONS
if (dpp_test == DPP_TEST_STOP_AT_AUTH_CONF) {
wpa_printf(MSG_INFO,
"DPP: TESTING - stop at Authentication Confirm");
if (auth->configurator) {
/* Prevent GAS response */
auth->auth_success = 0;
}
return;
}
#endif /* CONFIG_TESTING_OPTIONS */
if (!auth->configurator)
dpp_controller_start_gas_client(conn);
}
static void dpp_conn_tx_ready(int sock, void *eloop_ctx, void *sock_ctx)
{
struct dpp_connection *conn = eloop_ctx;
wpa_printf(MSG_DEBUG, "DPP: TCP socket %d ready for TX", sock);
dpp_tcp_send(conn);
}
static int dpp_ipaddr_to_sockaddr(struct sockaddr *addr, socklen_t *addrlen,
const struct hostapd_ip_addr *ipaddr,
int port)
{
struct sockaddr_in *dst;
#ifdef CONFIG_IPV6
struct sockaddr_in6 *dst6;
#endif /* CONFIG_IPV6 */
switch (ipaddr->af) {
case AF_INET:
dst = (struct sockaddr_in *) addr;
os_memset(dst, 0, sizeof(*dst));
dst->sin_family = AF_INET;
dst->sin_addr.s_addr = ipaddr->u.v4.s_addr;
dst->sin_port = htons(port);
*addrlen = sizeof(*dst);
break;
#ifdef CONFIG_IPV6
case AF_INET6:
dst6 = (struct sockaddr_in6 *) addr;
os_memset(dst6, 0, sizeof(*dst6));
dst6->sin6_family = AF_INET6;
os_memcpy(&dst6->sin6_addr, &ipaddr->u.v6,
sizeof(struct in6_addr));
dst6->sin6_port = htons(port);
*addrlen = sizeof(*dst6);
break;
#endif /* CONFIG_IPV6 */
default:
return -1;
}
return 0;
}
static struct dpp_connection *
dpp_relay_new_conn(struct dpp_relay_controller *ctrl, const u8 *src,
unsigned int freq)
{
struct dpp_connection *conn;
struct sockaddr_storage addr;
socklen_t addrlen;
char txt[100];
if (dl_list_len(&ctrl->conn) >= 15) {
wpa_printf(MSG_DEBUG,
"DPP: Too many ongoing Relay connections to the Controller - cannot start a new one");
return NULL;
}
if (dpp_ipaddr_to_sockaddr((struct sockaddr *) &addr, &addrlen,
&ctrl->ipaddr, DPP_TCP_PORT) < 0)
return NULL;
conn = os_zalloc(sizeof(*conn));
if (!conn)
return NULL;
conn->global = ctrl->global;
conn->relay = ctrl;
conn->msg_ctx = ctrl->global->msg_ctx;
os_memcpy(conn->mac_addr, src, ETH_ALEN);
conn->freq = freq;
conn->sock = socket(AF_INET, SOCK_STREAM, 0);
if (conn->sock < 0)
goto fail;
wpa_printf(MSG_DEBUG, "DPP: TCP relay socket %d connection to %s",
conn->sock, hostapd_ip_txt(&ctrl->ipaddr, txt, sizeof(txt)));
if (fcntl(conn->sock, F_SETFL, O_NONBLOCK) != 0) {
wpa_printf(MSG_DEBUG, "DPP: fnctl(O_NONBLOCK) failed: %s",
strerror(errno));
goto fail;
}
if (connect(conn->sock, (struct sockaddr *) &addr, addrlen) < 0) {
if (errno != EINPROGRESS) {
wpa_printf(MSG_DEBUG, "DPP: Failed to connect: %s",
strerror(errno));
goto fail;
}
/*
* Continue connecting in the background; eloop will call us
* once the connection is ready (or failed).
*/
}
if (eloop_register_sock(conn->sock, EVENT_TYPE_WRITE,
dpp_conn_tx_ready, conn, NULL) < 0)
goto fail;
conn->write_eloop = 1;
/* TODO: eloop timeout to clear a connection if it does not complete
* properly */
dl_list_add(&ctrl->conn, &conn->list);
return conn;
fail:
dpp_connection_free(conn);
return NULL;
}
static struct wpabuf * dpp_tcp_encaps(const u8 *hdr, const u8 *buf, size_t len)
{
struct wpabuf *msg;
msg = wpabuf_alloc(4 + 1 + DPP_HDR_LEN + len);
if (!msg)
return NULL;
wpabuf_put_be32(msg, 1 + DPP_HDR_LEN + len);
wpabuf_put_u8(msg, WLAN_PA_VENDOR_SPECIFIC);
wpabuf_put_data(msg, hdr, DPP_HDR_LEN);
wpabuf_put_data(msg, buf, len);
wpa_hexdump_buf(MSG_MSGDUMP, "DPP: Outgoing TCP message", msg);
return msg;
}
static int dpp_relay_tx(struct dpp_connection *conn, const u8 *hdr,
const u8 *buf, size_t len)
{
u8 type = hdr[DPP_HDR_LEN - 1];
wpa_printf(MSG_DEBUG,
"DPP: Continue already established Relay/Controller connection for this session");
wpabuf_free(conn->msg_out);
conn->msg_out_pos = 0;
conn->msg_out = dpp_tcp_encaps(hdr, buf, len);
if (!conn->msg_out) {
dpp_connection_remove(conn);
return -1;
}
/* TODO: for proto ver 1, need to do remove connection based on GAS Resp
* TX status */
if (type == DPP_PA_CONFIGURATION_RESULT)
conn->on_tcp_tx_complete_remove = 1;
dpp_tcp_send(conn);
return 0;
}
int dpp_relay_rx_action(struct dpp_global *dpp, const u8 *src, const u8 *hdr,
const u8 *buf, size_t len, unsigned int freq,
const u8 *i_bootstrap, const u8 *r_bootstrap)
{
struct dpp_relay_controller *ctrl;
struct dpp_connection *conn;
u8 type = hdr[DPP_HDR_LEN - 1];
/* Check if there is an already started session for this peer and if so,
* continue that session (send this over TCP) and return 0.
*/
if (type != DPP_PA_PEER_DISCOVERY_REQ &&
type != DPP_PA_PEER_DISCOVERY_RESP &&
type != DPP_PA_PRESENCE_ANNOUNCEMENT &&
type != DPP_PA_RECONFIG_ANNOUNCEMENT) {
dl_list_for_each(ctrl, &dpp->controllers,
struct dpp_relay_controller, list) {
dl_list_for_each(conn, &ctrl->conn,
struct dpp_connection, list) {
if (os_memcmp(src, conn->mac_addr,
ETH_ALEN) == 0)
return dpp_relay_tx(conn, hdr, buf, len);
}
}
}
if (type == DPP_PA_PRESENCE_ANNOUNCEMENT ||
type == DPP_PA_RECONFIG_ANNOUNCEMENT) {
/* TODO: Could send this to all configured Controllers. For now,
* only the first Controller is supported. */
ctrl = dl_list_first(&dpp->controllers,
struct dpp_relay_controller, list);
} else {
if (!r_bootstrap)
return -1;
ctrl = dpp_relay_controller_get(dpp, r_bootstrap);
}
if (!ctrl)
return -1;
wpa_printf(MSG_DEBUG,
"DPP: Authentication Request for a configured Controller");
conn = dpp_relay_new_conn(ctrl, src, freq);
if (!conn)
return -1;
conn->msg_out = dpp_tcp_encaps(hdr, buf, len);
if (!conn->msg_out) {
dpp_connection_remove(conn);
return -1;
}
/* Message will be sent in dpp_conn_tx_ready() */
return 0;
}
int dpp_relay_rx_gas_req(struct dpp_global *dpp, const u8 *src, const u8 *data,
size_t data_len)
{
struct dpp_relay_controller *ctrl;
struct dpp_connection *conn, *found = NULL;
struct wpabuf *msg;
/* Check if there is a successfully completed authentication for this
* and if so, continue that session (send this over TCP) and return 0.
*/
dl_list_for_each(ctrl, &dpp->controllers,
struct dpp_relay_controller, list) {
if (found)
break;
dl_list_for_each(conn, &ctrl->conn,
struct dpp_connection, list) {
if (os_memcmp(src, conn->mac_addr,
ETH_ALEN) == 0) {
found = conn;
break;
}
}
}
if (!found)
return -1;
msg = wpabuf_alloc(4 + 1 + data_len);
if (!msg)
return -1;
wpabuf_put_be32(msg, 1 + data_len);
wpabuf_put_u8(msg, WLAN_PA_GAS_INITIAL_REQ);
wpabuf_put_data(msg, data, data_len);
wpa_hexdump_buf(MSG_MSGDUMP, "DPP: Outgoing TCP message", msg);
wpabuf_free(conn->msg_out);
conn->msg_out_pos = 0;
conn->msg_out = msg;
dpp_tcp_send(conn);
return 0;
}
static void dpp_controller_free(struct dpp_controller *ctrl)
{
struct dpp_connection *conn, *tmp;
if (!ctrl)
return;
dl_list_for_each_safe(conn, tmp, &ctrl->conn, struct dpp_connection,
list)
dpp_connection_remove(conn);
if (ctrl->sock >= 0) {
close(ctrl->sock);
eloop_unregister_sock(ctrl->sock, EVENT_TYPE_READ);
}
os_free(ctrl->configurator_params);
os_free(ctrl);
}
static int dpp_controller_rx_auth_req(struct dpp_connection *conn,
const u8 *hdr, const u8 *buf, size_t len)
{
const u8 *r_bootstrap, *i_bootstrap;
u16 r_bootstrap_len, i_bootstrap_len;
struct dpp_bootstrap_info *own_bi = NULL, *peer_bi = NULL;
if (!conn->ctrl)
return 0;
wpa_printf(MSG_DEBUG, "DPP: Authentication Request");
r_bootstrap = dpp_get_attr(buf, len, DPP_ATTR_R_BOOTSTRAP_KEY_HASH,
&r_bootstrap_len);
if (!r_bootstrap || r_bootstrap_len != SHA256_MAC_LEN) {
wpa_printf(MSG_INFO,
"Missing or invalid required Responder Bootstrapping Key Hash attribute");
return -1;
}
wpa_hexdump(MSG_MSGDUMP, "DPP: Responder Bootstrapping Key Hash",
r_bootstrap, r_bootstrap_len);
i_bootstrap = dpp_get_attr(buf, len, DPP_ATTR_I_BOOTSTRAP_KEY_HASH,
&i_bootstrap_len);
if (!i_bootstrap || i_bootstrap_len != SHA256_MAC_LEN) {
wpa_printf(MSG_INFO,
"Missing or invalid required Initiator Bootstrapping Key Hash attribute");
return -1;
}
wpa_hexdump(MSG_MSGDUMP, "DPP: Initiator Bootstrapping Key Hash",
i_bootstrap, i_bootstrap_len);
/* Try to find own and peer bootstrapping key matches based on the
* received hash values */
dpp_bootstrap_find_pair(conn->ctrl->global, i_bootstrap, r_bootstrap,
&own_bi, &peer_bi);
if (!own_bi) {
wpa_printf(MSG_INFO,
"No matching own bootstrapping key found - ignore message");
return -1;
}
if (conn->auth) {
wpa_printf(MSG_INFO,
"Already in DPP authentication exchange - ignore new one");
return 0;
}
conn->auth = dpp_auth_req_rx(conn->ctrl->global, conn->msg_ctx,
conn->ctrl->allowed_roles,
conn->ctrl->qr_mutual,
peer_bi, own_bi, -1, hdr, buf, len);
if (!conn->auth) {
wpa_printf(MSG_DEBUG, "DPP: No response generated");
return -1;
}
if (dpp_set_configurator(conn->auth,
conn->ctrl->configurator_params) < 0) {
dpp_connection_remove(conn);
return -1;
}
return dpp_tcp_send_msg(conn, conn->auth->resp_msg);
}
static int dpp_controller_rx_auth_resp(struct dpp_connection *conn,
const u8 *hdr, const u8 *buf, size_t len)
{
struct dpp_authentication *auth = conn->auth;
struct wpabuf *msg;
int res;
if (!auth)
return -1;
wpa_printf(MSG_DEBUG, "DPP: Authentication Response");
msg = dpp_auth_resp_rx(auth, hdr, buf, len);
if (!msg) {
if (auth->auth_resp_status == DPP_STATUS_RESPONSE_PENDING) {
wpa_printf(MSG_DEBUG,
"DPP: Start wait for full response");
return 0;
}
wpa_printf(MSG_DEBUG, "DPP: No confirm generated");
dpp_connection_remove(conn);
return -1;
}
conn->on_tcp_tx_complete_auth_ok = 1;
res = dpp_tcp_send_msg(conn, msg);
wpabuf_free(msg);
return res;
}
static int dpp_controller_rx_auth_conf(struct dpp_connection *conn,
const u8 *hdr, const u8 *buf, size_t len)
{
struct dpp_authentication *auth = conn->auth;
wpa_printf(MSG_DEBUG, "DPP: Authentication Confirmation");
if (!auth) {
wpa_printf(MSG_DEBUG,
"DPP: No DPP Authentication in progress - drop");
return -1;
}
if (dpp_auth_conf_rx(auth, hdr, buf, len) < 0) {
wpa_printf(MSG_DEBUG, "DPP: Authentication failed");
return -1;
}
dpp_controller_auth_success(conn, 0);
return 0;
}
void dpp_controller_conn_status_result_wait_timeout(void *eloop_ctx,
void *timeout_ctx)
{
struct dpp_connection *conn = eloop_ctx;
if (!conn->auth->waiting_conf_result)
return;
wpa_printf(MSG_DEBUG,
"DPP: Timeout while waiting for Connection Status Result");
wpa_msg(conn->msg_ctx, MSG_INFO,
DPP_EVENT_CONN_STATUS_RESULT "timeout");
dpp_connection_remove(conn);
}
static int dpp_controller_rx_conf_result(struct dpp_connection *conn,
const u8 *hdr, const u8 *buf,
size_t len)
{
struct dpp_authentication *auth = conn->auth;
enum dpp_status_error status;
void *msg_ctx = conn->msg_ctx;
if (!conn->ctrl && (!auth || !auth->configurator))
return 0;
wpa_printf(MSG_DEBUG, "DPP: Configuration Result");
if (!auth || !auth->waiting_conf_result) {
wpa_printf(MSG_DEBUG,
"DPP: No DPP Configuration waiting for result - drop");
return -1;
}
status = dpp_conf_result_rx(auth, hdr, buf, len);
if (status == DPP_STATUS_OK && auth->send_conn_status) {
wpa_msg(msg_ctx, MSG_INFO,
DPP_EVENT_CONF_SENT "wait_conn_status=1");
wpa_printf(MSG_DEBUG, "DPP: Wait for Connection Status Result");
eloop_cancel_timeout(
dpp_controller_conn_status_result_wait_timeout,
conn, NULL);
eloop_register_timeout(
16, 0, dpp_controller_conn_status_result_wait_timeout,
conn, NULL);
return 0;
}
if (status == DPP_STATUS_OK)
wpa_msg(msg_ctx, MSG_INFO, DPP_EVENT_CONF_SENT);
else
wpa_msg(msg_ctx, MSG_INFO, DPP_EVENT_CONF_FAILED);
return -1; /* to remove the completed connection */
}
static int dpp_controller_rx_conn_status_result(struct dpp_connection *conn,
const u8 *hdr, const u8 *buf,
size_t len)
{
struct dpp_authentication *auth = conn->auth;
enum dpp_status_error status;
u8 ssid[SSID_MAX_LEN];
size_t ssid_len = 0;
char *channel_list = NULL;
if (!conn->ctrl)
return 0;
wpa_printf(MSG_DEBUG, "DPP: Connection Status Result");
if (!auth || !auth->waiting_conn_status_result) {
wpa_printf(MSG_DEBUG,
"DPP: No DPP Configuration waiting for connection status result - drop");
return -1;
}
status = dpp_conn_status_result_rx(auth, hdr, buf, len,
ssid, &ssid_len, &channel_list);
wpa_msg(conn->msg_ctx, MSG_INFO, DPP_EVENT_CONN_STATUS_RESULT
"result=%d ssid=%s channel_list=%s",
status, wpa_ssid_txt(ssid, ssid_len),
channel_list ? channel_list : "N/A");
os_free(channel_list);
return -1; /* to remove the completed connection */
}
static int dpp_controller_rx_presence_announcement(struct dpp_connection *conn,
const u8 *hdr, const u8 *buf,
size_t len)
{
const u8 *r_bootstrap;
u16 r_bootstrap_len;
struct dpp_bootstrap_info *peer_bi;
struct dpp_authentication *auth;
struct dpp_global *dpp = conn->ctrl->global;
if (conn->auth) {
wpa_printf(MSG_DEBUG,
"DPP: Ignore Presence Announcement during ongoing Authentication");
return -1;
}
wpa_printf(MSG_DEBUG, "DPP: Presence Announcement");
r_bootstrap = dpp_get_attr(buf, len, DPP_ATTR_R_BOOTSTRAP_KEY_HASH,
&r_bootstrap_len);
if (!r_bootstrap || r_bootstrap_len != SHA256_MAC_LEN) {
wpa_msg(conn->msg_ctx, MSG_INFO, DPP_EVENT_FAIL
"Missing or invalid required Responder Bootstrapping Key Hash attribute");
return -1;
}
wpa_hexdump(MSG_MSGDUMP, "DPP: Responder Bootstrapping Key Hash",
r_bootstrap, r_bootstrap_len);
peer_bi = dpp_bootstrap_find_chirp(dpp, r_bootstrap);
if (!peer_bi) {
wpa_printf(MSG_DEBUG,
"DPP: No matching bootstrapping information found");
return -1;
}
auth = dpp_auth_init(dpp, conn->msg_ctx, peer_bi, NULL,
DPP_CAPAB_CONFIGURATOR, -1, NULL, 0);
if (!auth)
return -1;
if (dpp_set_configurator(auth, conn->ctrl->configurator_params) < 0) {
dpp_auth_deinit(auth);
dpp_connection_remove(conn);
return -1;
}
conn->auth = auth;
return dpp_tcp_send_msg(conn, conn->auth->req_msg);
}
static int dpp_controller_rx_reconfig_announcement(struct dpp_connection *conn,
const u8 *hdr, const u8 *buf,
size_t len)
{
const u8 *csign_hash, *fcgroup, *a_nonce, *e_id;
u16 csign_hash_len, fcgroup_len, a_nonce_len, e_id_len;
struct dpp_configurator *conf;
struct dpp_global *dpp = conn->ctrl->global;
struct dpp_authentication *auth;
u16 group;
if (conn->auth) {
wpa_printf(MSG_DEBUG,
"DPP: Ignore Reconfig Announcement during ongoing Authentication");
return -1;
}
wpa_printf(MSG_DEBUG, "DPP: Reconfig Announcement");
csign_hash = dpp_get_attr(buf, len, DPP_ATTR_C_SIGN_KEY_HASH,
&csign_hash_len);
if (!csign_hash || csign_hash_len != SHA256_MAC_LEN) {
wpa_msg(conn->msg_ctx, MSG_INFO, DPP_EVENT_FAIL
"Missing or invalid required Configurator C-sign key Hash attribute");
return -1;
}
wpa_hexdump(MSG_MSGDUMP, "DPP: Configurator C-sign key Hash (kid)",
csign_hash, csign_hash_len);
conf = dpp_configurator_find_kid(dpp, csign_hash);
if (!conf) {
wpa_printf(MSG_DEBUG,
"DPP: No matching Configurator information found");
return -1;
}
fcgroup = dpp_get_attr(buf, len, DPP_ATTR_FINITE_CYCLIC_GROUP,
&fcgroup_len);
if (!fcgroup || fcgroup_len != 2) {
wpa_msg(conn->msg_ctx, MSG_INFO, DPP_EVENT_FAIL
"Missing or invalid required Finite Cyclic Group attribute");
return -1;
}
group = WPA_GET_LE16(fcgroup);
wpa_printf(MSG_DEBUG, "DPP: Enrollee finite cyclic group: %u", group);
a_nonce = dpp_get_attr(buf, len, DPP_ATTR_A_NONCE, &a_nonce_len);
e_id = dpp_get_attr(buf, len, DPP_ATTR_E_PRIME_ID, &e_id_len);
auth = dpp_reconfig_init(dpp, conn->msg_ctx, conf, 0, group,
a_nonce, a_nonce_len, e_id, e_id_len);
if (!auth)
return -1;
if (dpp_set_configurator(auth, conn->ctrl->configurator_params) < 0) {
dpp_auth_deinit(auth);
return -1;
}
conn->auth = auth;
return dpp_tcp_send_msg(conn, auth->reconfig_req_msg);
}
static int dpp_controller_rx_reconfig_auth_resp(struct dpp_connection *conn,
const u8 *hdr, const u8 *buf,
size_t len)
{
struct dpp_authentication *auth = conn->auth;
struct wpabuf *conf;
int res;
wpa_printf(MSG_DEBUG, "DPP: Reconfig Authentication Response");
if (!auth || !auth->reconfig || !auth->configurator) {
wpa_printf(MSG_DEBUG,
"DPP: No DPP Reconfig Authentication in progress - drop");
return -1;
}
conf = dpp_reconfig_auth_resp_rx(auth, hdr, buf, len);
if (!conf)
return -1;
res = dpp_tcp_send_msg(conn, conf);
wpabuf_free(conf);
return res;
}
static int dpp_controller_rx_action(struct dpp_connection *conn, const u8 *msg,
size_t len)
{
const u8 *pos, *end;
u8 type;
wpa_printf(MSG_DEBUG, "DPP: Received DPP Action frame over TCP");
pos = msg;
end = msg + len;
if (end - pos < DPP_HDR_LEN ||
WPA_GET_BE24(pos) != OUI_WFA ||
pos[3] != DPP_OUI_TYPE) {
wpa_printf(MSG_DEBUG, "DPP: Unrecognized header");
return -1;
}
if (pos[4] != 1) {
wpa_printf(MSG_DEBUG, "DPP: Unsupported Crypto Suite %u",
pos[4]);
return -1;
}
type = pos[5];
wpa_printf(MSG_DEBUG, "DPP: Received message type %u", type);
pos += DPP_HDR_LEN;
wpa_hexdump(MSG_MSGDUMP, "DPP: Received message attributes",
pos, end - pos);
if (dpp_check_attrs(pos, end - pos) < 0)
return -1;
if (conn->relay) {
wpa_printf(MSG_DEBUG, "DPP: Relay - send over WLAN");
conn->relay->tx(conn->relay->cb_ctx, conn->mac_addr,
conn->freq, msg, len);
return 0;
}
switch (type) {
case DPP_PA_AUTHENTICATION_REQ:
return dpp_controller_rx_auth_req(conn, msg, pos, end - pos);
case DPP_PA_AUTHENTICATION_RESP:
return dpp_controller_rx_auth_resp(conn, msg, pos, end - pos);
case DPP_PA_AUTHENTICATION_CONF:
return dpp_controller_rx_auth_conf(conn, msg, pos, end - pos);
case DPP_PA_CONFIGURATION_RESULT:
return dpp_controller_rx_conf_result(conn, msg, pos, end - pos);
case DPP_PA_CONNECTION_STATUS_RESULT:
return dpp_controller_rx_conn_status_result(conn, msg, pos,
end - pos);
case DPP_PA_PRESENCE_ANNOUNCEMENT:
return dpp_controller_rx_presence_announcement(conn, msg, pos,
end - pos);
case DPP_PA_RECONFIG_ANNOUNCEMENT:
return dpp_controller_rx_reconfig_announcement(conn, msg, pos,
end - pos);
case DPP_PA_RECONFIG_AUTH_RESP:
return dpp_controller_rx_reconfig_auth_resp(conn, msg, pos,
end - pos);
default:
/* TODO: missing messages types */
wpa_printf(MSG_DEBUG,
"DPP: Unsupported frame subtype %d", type);
return -1;
}
}
static int dpp_tcp_send_comeback_delay(struct dpp_connection *conn, u8 action)
{
struct wpabuf *buf;
size_t len = 18;
if (action == WLAN_PA_GAS_COMEBACK_RESP)
len++;
buf = wpabuf_alloc(4 + len);
if (!buf)
return -1;
wpabuf_put_be32(buf, len);
wpabuf_put_u8(buf, action);
wpabuf_put_u8(buf, conn->gas_dialog_token);
wpabuf_put_le16(buf, WLAN_STATUS_SUCCESS);
if (action == WLAN_PA_GAS_COMEBACK_RESP)
wpabuf_put_u8(buf, 0);
wpabuf_put_le16(buf, 500); /* GAS Comeback Delay */
dpp_write_adv_proto(buf);
wpabuf_put_le16(buf, 0); /* Query Response Length */
/* Send Config Response over TCP */
wpa_hexdump_buf(MSG_MSGDUMP, "DPP: Outgoing TCP message", buf);
wpabuf_free(conn->msg_out);
conn->msg_out_pos = 0;
conn->msg_out = buf;
dpp_tcp_send(conn);
return 0;
}
static int dpp_tcp_send_gas_resp(struct dpp_connection *conn, u8 action,
struct wpabuf *resp)
{
struct wpabuf *buf;
size_t len;
if (!resp)
return -1;
len = 18 + wpabuf_len(resp);
if (action == WLAN_PA_GAS_COMEBACK_RESP)
len++;
buf = wpabuf_alloc(4 + len);
if (!buf) {
wpabuf_free(resp);
return -1;
}
wpabuf_put_be32(buf, len);
wpabuf_put_u8(buf, action);
wpabuf_put_u8(buf, conn->gas_dialog_token);
wpabuf_put_le16(buf, WLAN_STATUS_SUCCESS);
if (action == WLAN_PA_GAS_COMEBACK_RESP)
wpabuf_put_u8(buf, 0);
wpabuf_put_le16(buf, 0); /* GAS Comeback Delay */
dpp_write_adv_proto(buf);
dpp_write_gas_query(buf, resp);
wpabuf_free(resp);
/* Send Config Response over TCP; GAS fragmentation is taken care of by
* the Relay */
wpa_hexdump_buf(MSG_MSGDUMP, "DPP: Outgoing TCP message", buf);
wpabuf_free(conn->msg_out);
conn->msg_out_pos = 0;
conn->msg_out = buf;
conn->on_tcp_tx_complete_gas_done = 1;
dpp_tcp_send(conn);
return 0;
}
static int dpp_controller_rx_gas_req(struct dpp_connection *conn, const u8 *msg,
size_t len)
{
const u8 *pos, *end, *next;
const u8 *adv_proto;
u16 slen;
struct wpabuf *resp;
struct dpp_authentication *auth = conn->auth;
if (len < 1 + 2)
return -1;
wpa_printf(MSG_DEBUG,
"DPP: Received DPP Configuration Request over TCP");
if (!auth || (!conn->ctrl && !auth->configurator) ||
(!auth->auth_success && !auth->reconfig_success)) {
wpa_printf(MSG_DEBUG, "DPP: No matching exchange in progress");
return -1;
}
pos = msg;
end = msg + len;
conn->gas_dialog_token = *pos++;
adv_proto = pos++;
slen = *pos++;
if (*adv_proto != WLAN_EID_ADV_PROTO ||
slen > end - pos || slen < 2)
return -1;
next = pos + slen;
pos++; /* skip QueryRespLenLimit and PAME-BI */
if (slen != 8 || *pos != WLAN_EID_VENDOR_SPECIFIC ||
pos[1] != 5 || WPA_GET_BE24(&pos[2]) != OUI_WFA ||
pos[5] != DPP_OUI_TYPE || pos[6] != 0x01)
return -1;
pos = next;
/* Query Request */
if (end - pos < 2)
return -1;
slen = WPA_GET_LE16(pos);
pos += 2;
if (slen > end - pos)
return -1;
resp = dpp_conf_req_rx(auth, pos, slen);
if (!resp && auth->waiting_cert) {
wpa_printf(MSG_DEBUG, "DPP: Certificate not yet ready");
conn->gas_comeback_in_progress = 1;
return dpp_tcp_send_comeback_delay(conn,
WLAN_PA_GAS_INITIAL_RESP);
}
return dpp_tcp_send_gas_resp(conn, WLAN_PA_GAS_INITIAL_RESP, resp);
}
static int dpp_controller_rx_gas_comeback_req(struct dpp_connection *conn,
const u8 *msg, size_t len)
{
u8 dialog_token;
struct dpp_authentication *auth = conn->auth;
struct wpabuf *resp;
if (len < 1)
return -1;
wpa_printf(MSG_DEBUG,
"DPP: Received DPP Configuration Request over TCP (comeback)");
if (!auth || (!conn->ctrl && !auth->configurator) ||
(!auth->auth_success && !auth->reconfig_success) ||
!conn->gas_comeback_in_progress) {
wpa_printf(MSG_DEBUG, "DPP: No matching exchange in progress");
return -1;
}
dialog_token = msg[0];
if (dialog_token != conn->gas_dialog_token) {
wpa_printf(MSG_DEBUG, "DPP: Dialog token mismatch (%u != %u)",
dialog_token, conn->gas_dialog_token);
return -1;
}
if (!auth->conf_resp_tcp) {
wpa_printf(MSG_DEBUG, "DPP: Certificate not yet ready");
return dpp_tcp_send_comeback_delay(conn,
WLAN_PA_GAS_COMEBACK_RESP);
}
wpa_printf(MSG_DEBUG,
"DPP: Configuration response is ready to be sent out");
resp = auth->conf_resp_tcp;
auth->conf_resp_tcp = NULL;
return dpp_tcp_send_gas_resp(conn, WLAN_PA_GAS_COMEBACK_RESP, resp);
}
static void dpp_tcp_build_csr(void *eloop_ctx, void *timeout_ctx)
{
struct dpp_connection *conn = eloop_ctx;
struct dpp_authentication *auth = conn->auth;
if (!auth || !auth->csrattrs)
return;
wpa_printf(MSG_DEBUG, "DPP: Build CSR");
wpabuf_free(auth->csr);
/* TODO: Additional information needed for CSR based on csrAttrs */
auth->csr = dpp_build_csr(auth, conn->name ? conn->name : "Test");
if (!auth->csr) {
dpp_connection_remove(conn);
return;
}
dpp_controller_start_gas_client(conn);
}
static int dpp_tcp_rx_gas_resp(struct dpp_connection *conn, struct wpabuf *resp)
{
struct dpp_authentication *auth = conn->auth;
int res;
struct wpabuf *msg;
enum dpp_status_error status;
wpa_printf(MSG_DEBUG,
"DPP: Configuration Response for local stack from TCP");
if (auth)
res = dpp_conf_resp_rx(auth, resp);
else
res = -1;
wpabuf_free(resp);
if (res == -2) {
wpa_printf(MSG_DEBUG, "DPP: CSR needed");
eloop_register_timeout(0, 0, dpp_tcp_build_csr, conn, NULL);
return 0;
}
if (res < 0) {
wpa_printf(MSG_DEBUG, "DPP: Configuration attempt failed");
return -1;
}
if (conn->global->process_conf_obj)
res = conn->global->process_conf_obj(conn->global->cb_ctx,
auth);
else
res = 0;
if (auth->peer_version < 2 || auth->conf_resp_status != DPP_STATUS_OK)
return -1;
wpa_printf(MSG_DEBUG, "DPP: Send DPP Configuration Result");
status = res < 0 ? DPP_STATUS_CONFIG_REJECTED : DPP_STATUS_OK;
msg = dpp_build_conf_result(auth, status);
if (!msg)
return -1;
conn->on_tcp_tx_complete_remove = 1;
res = dpp_tcp_send_msg(conn, msg);
wpabuf_free(msg);
/* This exchange will be terminated in the TX status handler */
return res;
}
static void dpp_tcp_gas_query_comeback(void *eloop_ctx, void *timeout_ctx)
{
struct dpp_connection *conn = eloop_ctx;
struct dpp_authentication *auth = conn->auth;
struct wpabuf *msg;
if (!auth)
return;
wpa_printf(MSG_DEBUG, "DPP: Send GAS Comeback Request");
msg = wpabuf_alloc(4 + 2);
if (!msg)
return;
wpabuf_put_be32(msg, 2);
wpabuf_put_u8(msg, WLAN_PA_GAS_COMEBACK_REQ);
wpabuf_put_u8(msg, conn->gas_dialog_token);
wpa_hexdump_buf(MSG_MSGDUMP, "DPP: Outgoing TCP message", msg);
wpabuf_free(conn->msg_out);
conn->msg_out_pos = 0;
conn->msg_out = msg;
dpp_tcp_send(conn);
}
static int dpp_rx_gas_resp(struct dpp_connection *conn, const u8 *msg,
size_t len, bool comeback)
{
struct wpabuf *buf;
u8 dialog_token;
const u8 *pos, *end, *next, *adv_proto;
u16 status, slen, comeback_delay;
if (len < 5 + 2 + (comeback ? 1 : 0))
return -1;
wpa_printf(MSG_DEBUG,
"DPP: Received DPP Configuration Response over TCP");
pos = msg;
end = msg + len;
dialog_token = *pos++;
status = WPA_GET_LE16(pos);
if (status != WLAN_STATUS_SUCCESS) {
wpa_printf(MSG_DEBUG, "DPP: Unexpected Status Code %u", status);
return -1;
}
pos += 2;
if (comeback)
pos++; /* ignore Fragment ID */
comeback_delay = WPA_GET_LE16(pos);
pos += 2;
adv_proto = pos++;
slen = *pos++;
if (*adv_proto != WLAN_EID_ADV_PROTO ||
slen > end - pos || slen < 2)
return -1;
next = pos + slen;
pos++; /* skip QueryRespLenLimit and PAME-BI */
if (slen != 8 || *pos != WLAN_EID_VENDOR_SPECIFIC ||
pos[1] != 5 || WPA_GET_BE24(&pos[2]) != OUI_WFA ||
pos[5] != DPP_OUI_TYPE || pos[6] != 0x01)
return -1;
pos = next;
/* Query Response */
if (end - pos < 2)
return -1;
slen = WPA_GET_LE16(pos);
pos += 2;
if (slen > end - pos)
return -1;
if (comeback_delay) {
unsigned int secs, usecs;
conn->gas_dialog_token = dialog_token;
secs = (comeback_delay * 1024) / 1000000;
usecs = comeback_delay * 1024 - secs * 1000000;
wpa_printf(MSG_DEBUG, "DPP: Comeback delay: %u",
comeback_delay);
eloop_cancel_timeout(dpp_tcp_gas_query_comeback, conn, NULL);
eloop_register_timeout(secs, usecs, dpp_tcp_gas_query_comeback,
conn, NULL);
return 0;
}
buf = wpabuf_alloc(slen);
if (!buf)
return -1;
wpabuf_put_data(buf, pos, slen);
if (!conn->relay &&
(!conn->ctrl || (conn->ctrl->allowed_roles & DPP_CAPAB_ENROLLEE)))
return dpp_tcp_rx_gas_resp(conn, buf);
if (!conn->relay) {
wpa_printf(MSG_DEBUG, "DPP: No matching exchange in progress");
wpabuf_free(buf);
return -1;
}
wpa_printf(MSG_DEBUG, "DPP: Relay - send over WLAN");
conn->relay->gas_resp_tx(conn->relay->cb_ctx, conn->mac_addr,
dialog_token, 0, buf);
return 0;
}
static void dpp_controller_rx(int sd, void *eloop_ctx, void *sock_ctx)
{
struct dpp_connection *conn = eloop_ctx;
int res;
const u8 *pos;
wpa_printf(MSG_DEBUG, "DPP: TCP data available for reading (sock %d)",
sd);
if (conn->msg_len_octets < 4) {
u32 msglen;
res = recv(sd, &conn->msg_len[conn->msg_len_octets],
4 - conn->msg_len_octets, 0);
if (res < 0) {
wpa_printf(MSG_DEBUG, "DPP: recv failed: %s",
strerror(errno));
dpp_connection_remove(conn);
return;
}
if (res == 0) {
wpa_printf(MSG_DEBUG,
"DPP: No more data available over TCP");
dpp_connection_remove(conn);
return;
}
wpa_printf(MSG_DEBUG,
"DPP: Received %d/%d octet(s) of message length field",
res, (int) (4 - conn->msg_len_octets));
conn->msg_len_octets += res;
if (conn->msg_len_octets < 4) {
wpa_printf(MSG_DEBUG,
"DPP: Need %d more octets of message length field",
(int) (4 - conn->msg_len_octets));
return;
}
msglen = WPA_GET_BE32(conn->msg_len);
wpa_printf(MSG_DEBUG, "DPP: Message length: %u", msglen);
if (msglen > 65535) {
wpa_printf(MSG_INFO, "DPP: Unexpectedly long message");
dpp_connection_remove(conn);
return;
}
wpabuf_free(conn->msg);
conn->msg = wpabuf_alloc(msglen);
}
if (!conn->msg) {
wpa_printf(MSG_DEBUG,
"DPP: No buffer available for receiving the message");
dpp_connection_remove(conn);
return;
}
wpa_printf(MSG_DEBUG, "DPP: Need %u more octets of message payload",
(unsigned int) wpabuf_tailroom(conn->msg));
res = recv(sd, wpabuf_put(conn->msg, 0), wpabuf_tailroom(conn->msg), 0);
if (res < 0) {
wpa_printf(MSG_DEBUG, "DPP: recv failed: %s", strerror(errno));
dpp_connection_remove(conn);
return;
}
if (res == 0) {
wpa_printf(MSG_DEBUG, "DPP: No more data available over TCP");
dpp_connection_remove(conn);
return;
}
wpa_printf(MSG_DEBUG, "DPP: Received %d octets", res);
wpabuf_put(conn->msg, res);
if (wpabuf_tailroom(conn->msg) > 0) {
wpa_printf(MSG_DEBUG,
"DPP: Need %u more octets of message payload",
(unsigned int) wpabuf_tailroom(conn->msg));
return;
}
conn->msg_len_octets = 0;
wpa_hexdump_buf(MSG_DEBUG, "DPP: Received TCP message", conn->msg);
if (wpabuf_len(conn->msg) < 1) {
dpp_connection_remove(conn);
return;
}
pos = wpabuf_head(conn->msg);
switch (*pos) {
case WLAN_PA_VENDOR_SPECIFIC:
if (dpp_controller_rx_action(conn, pos + 1,
wpabuf_len(conn->msg) - 1) < 0)
dpp_connection_remove(conn);
break;
case WLAN_PA_GAS_INITIAL_REQ:
if (dpp_controller_rx_gas_req(conn, pos + 1,
wpabuf_len(conn->msg) - 1) < 0)
dpp_connection_remove(conn);
break;
case WLAN_PA_GAS_INITIAL_RESP:
case WLAN_PA_GAS_COMEBACK_RESP:
if (dpp_rx_gas_resp(conn, pos + 1,
wpabuf_len(conn->msg) - 1,
*pos == WLAN_PA_GAS_COMEBACK_RESP) < 0)
dpp_connection_remove(conn);
break;
case WLAN_PA_GAS_COMEBACK_REQ:
if (dpp_controller_rx_gas_comeback_req(
conn, pos + 1, wpabuf_len(conn->msg) - 1) < 0)
dpp_connection_remove(conn);
break;
default:
wpa_printf(MSG_DEBUG, "DPP: Ignore unsupported message type %u",
*pos);
break;
}
}
static void dpp_controller_tcp_cb(int sd, void *eloop_ctx, void *sock_ctx)
{
struct dpp_controller *ctrl = eloop_ctx;
struct sockaddr_in addr;
socklen_t addr_len = sizeof(addr);
int fd;
struct dpp_connection *conn;
wpa_printf(MSG_DEBUG, "DPP: New TCP connection");
fd = accept(ctrl->sock, (struct sockaddr *) &addr, &addr_len);
if (fd < 0) {
wpa_printf(MSG_DEBUG,
"DPP: Failed to accept new connection: %s",
strerror(errno));
return;
}
wpa_printf(MSG_DEBUG, "DPP: Connection from %s:%d",
inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
conn = os_zalloc(sizeof(*conn));
if (!conn)
goto fail;
conn->global = ctrl->global;
conn->ctrl = ctrl;
conn->msg_ctx = ctrl->global->msg_ctx;
conn->sock = fd;
if (fcntl(conn->sock, F_SETFL, O_NONBLOCK) != 0) {
wpa_printf(MSG_DEBUG, "DPP: fnctl(O_NONBLOCK) failed: %s",
strerror(errno));
goto fail;
}
if (eloop_register_sock(conn->sock, EVENT_TYPE_READ,
dpp_controller_rx, conn, NULL) < 0)
goto fail;
conn->read_eloop = 1;
/* TODO: eloop timeout to expire connections that do not complete in
* reasonable time */
dl_list_add(&ctrl->conn, &conn->list);
return;
fail:
close(fd);
os_free(conn);
}
int dpp_tcp_init(struct dpp_global *dpp, struct dpp_authentication *auth,
const struct hostapd_ip_addr *addr, int port, const char *name,
enum dpp_netrole netrole, void *msg_ctx)
{
struct dpp_connection *conn;
struct sockaddr_storage saddr;
socklen_t addrlen;
const u8 *hdr, *pos, *end;
char txt[100];
wpa_printf(MSG_DEBUG, "DPP: Initialize TCP connection to %s port %d",
hostapd_ip_txt(addr, txt, sizeof(txt)), port);
if (dpp_ipaddr_to_sockaddr((struct sockaddr *) &saddr, &addrlen,
addr, port) < 0) {
dpp_auth_deinit(auth);
return -1;
}
conn = os_zalloc(sizeof(*conn));
if (!conn) {
dpp_auth_deinit(auth);
return -1;
}
conn->msg_ctx = msg_ctx;
conn->name = os_strdup(name ? name : "Test");
conn->netrole = netrole;
conn->global = dpp;
conn->auth = auth;
conn->sock = socket(AF_INET, SOCK_STREAM, 0);
if (conn->sock < 0)
goto fail;
if (fcntl(conn->sock, F_SETFL, O_NONBLOCK) != 0) {
wpa_printf(MSG_DEBUG, "DPP: fnctl(O_NONBLOCK) failed: %s",
strerror(errno));
goto fail;
}
if (connect(conn->sock, (struct sockaddr *) &saddr, addrlen) < 0) {
if (errno != EINPROGRESS) {
wpa_printf(MSG_DEBUG, "DPP: Failed to connect: %s",
strerror(errno));
goto fail;
}
/*
* Continue connecting in the background; eloop will call us
* once the connection is ready (or failed).
*/
}
if (eloop_register_sock(conn->sock, EVENT_TYPE_WRITE,
dpp_conn_tx_ready, conn, NULL) < 0)
goto fail;
conn->write_eloop = 1;
hdr = wpabuf_head(auth->req_msg);
end = hdr + wpabuf_len(auth->req_msg);
hdr += 2; /* skip Category and Actiom */
pos = hdr + DPP_HDR_LEN;
conn->msg_out = dpp_tcp_encaps(hdr, pos, end - pos);
if (!conn->msg_out)
goto fail;
/* Message will be sent in dpp_conn_tx_ready() */
/* TODO: eloop timeout to clear a connection if it does not complete
* properly */
dl_list_add(&dpp->tcp_init, &conn->list);
return 0;
fail:
dpp_connection_free(conn);
return -1;
}
int dpp_controller_start(struct dpp_global *dpp,
struct dpp_controller_config *config)
{
struct dpp_controller *ctrl;
int on = 1;
struct sockaddr_in sin;
int port;
if (!dpp || dpp->controller)
return -1;
ctrl = os_zalloc(sizeof(*ctrl));
if (!ctrl)
return -1;
ctrl->global = dpp;
if (config->configurator_params)
ctrl->configurator_params =
os_strdup(config->configurator_params);
dl_list_init(&ctrl->conn);
ctrl->allowed_roles = config->allowed_roles;
ctrl->qr_mutual = config->qr_mutual;
ctrl->sock = socket(AF_INET, SOCK_STREAM, 0);
if (ctrl->sock < 0)
goto fail;
if (setsockopt(ctrl->sock, SOL_SOCKET, SO_REUSEADDR,
&on, sizeof(on)) < 0) {
wpa_printf(MSG_DEBUG,
"DPP: setsockopt(SO_REUSEADDR) failed: %s",
strerror(errno));
/* try to continue anyway */
}
if (fcntl(ctrl->sock, F_SETFL, O_NONBLOCK) < 0) {
wpa_printf(MSG_INFO, "DPP: fnctl(O_NONBLOCK) failed: %s",
strerror(errno));
goto fail;
}
/* TODO: IPv6 */
os_memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = INADDR_ANY;
port = config->tcp_port ? config->tcp_port : DPP_TCP_PORT;
sin.sin_port = htons(port);
if (bind(ctrl->sock, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
wpa_printf(MSG_INFO,
"DPP: Failed to bind Controller TCP port: %s",
strerror(errno));
goto fail;
}
if (listen(ctrl->sock, 10 /* max backlog */) < 0 ||
fcntl(ctrl->sock, F_SETFL, O_NONBLOCK) < 0 ||
eloop_register_sock(ctrl->sock, EVENT_TYPE_READ,
dpp_controller_tcp_cb, ctrl, NULL))
goto fail;
dpp->controller = ctrl;
wpa_printf(MSG_DEBUG, "DPP: Controller started on TCP port %d", port);
return 0;
fail:
dpp_controller_free(ctrl);
return -1;
}
void dpp_controller_stop(struct dpp_global *dpp)
{
if (dpp) {
dpp_controller_free(dpp->controller);
dpp->controller = NULL;
}
}
static bool dpp_tcp_peer_id_match(struct dpp_authentication *auth,
unsigned int id)
{
return auth &&
((auth->peer_bi && auth->peer_bi->id == id) ||
(auth->tmp_peer_bi && auth->tmp_peer_bi->id == id));
}
static struct dpp_authentication * dpp_tcp_get_auth(struct dpp_global *dpp,
unsigned int id)
{
struct dpp_connection *conn;
dl_list_for_each(conn, &dpp->tcp_init, struct dpp_connection, list) {
if (dpp_tcp_peer_id_match(conn->auth, id))
return conn->auth;
}
return NULL;
}
struct dpp_authentication * dpp_controller_get_auth(struct dpp_global *dpp,
unsigned int id)
{
struct dpp_controller *ctrl = dpp->controller;
struct dpp_connection *conn;
if (!ctrl)
return dpp_tcp_get_auth(dpp, id);
dl_list_for_each(conn, &ctrl->conn, struct dpp_connection, list) {
if (dpp_tcp_peer_id_match(conn->auth, id))
return conn->auth;
}
return dpp_tcp_get_auth(dpp, id);
}
void dpp_controller_new_qr_code(struct dpp_global *dpp,
struct dpp_bootstrap_info *bi)
{
struct dpp_controller *ctrl = dpp->controller;
struct dpp_connection *conn;
if (!ctrl)
return;
dl_list_for_each(conn, &ctrl->conn, struct dpp_connection, list) {
struct dpp_authentication *auth = conn->auth;
if (!auth->response_pending ||
dpp_notify_new_qr_code(auth, bi) != 1)
continue;
wpa_printf(MSG_DEBUG,
"DPP: Sending out pending authentication response");
dpp_tcp_send_msg(conn, conn->auth->resp_msg);
}
}
void dpp_tcp_init_flush(struct dpp_global *dpp)
{
struct dpp_connection *conn, *tmp;
dl_list_for_each_safe(conn, tmp, &dpp->tcp_init, struct dpp_connection,
list)
dpp_connection_remove(conn);
}
static void dpp_relay_controller_free(struct dpp_relay_controller *ctrl)
{
struct dpp_connection *conn, *tmp;
dl_list_for_each_safe(conn, tmp, &ctrl->conn, struct dpp_connection,
list)
dpp_connection_remove(conn);
os_free(ctrl);
}
void dpp_relay_flush_controllers(struct dpp_global *dpp)
{
struct dpp_relay_controller *ctrl, *tmp;
if (!dpp)
return;
dl_list_for_each_safe(ctrl, tmp, &dpp->controllers,
struct dpp_relay_controller, list) {
dl_list_del(&ctrl->list);
dpp_relay_controller_free(ctrl);
}
}
#endif /* CONFIG_DPP2 */