Lines Matching +full:config +full:- +full:complete +full:- +full:timeout +full:- +full:us
3 * Copyright (c) 2019-2020, The Linux Foundation
4 * Copyright (c) 2021-2022, Qualcomm Innovation Center, Inc.
104 if (conn->sock >= 0) {
106 conn->sock);
107 eloop_unregister_sock(conn->sock, EVENT_TYPE_READ);
108 eloop_unregister_sock(conn->sock, EVENT_TYPE_WRITE);
109 close(conn->sock);
119 wpabuf_free(conn->msg);
120 wpabuf_free(conn->msg_out);
121 dpp_auth_deinit(conn->auth);
122 dpp_pkex_free(conn->pkex);
123 os_free(conn->name);
124 os_free(conn->mud_url);
125 os_free(conn->extra_conf_req_name);
126 os_free(conn->extra_conf_req_value);
133 dl_list_del(&conn->list);
139 struct dpp_relay_config *config)
145 return -1;
149 return -1;
150 dl_list_init(&ctrl->conn);
151 ctrl->global = dpp;
152 os_memcpy(&ctrl->ipaddr, config->ipaddr, sizeof(*config->ipaddr));
153 os_memcpy(ctrl->pkhash, config->pkhash, SHA256_MAC_LEN);
154 ctrl->msg_ctx = config->msg_ctx;
155 ctrl->cb_ctx = config->cb_ctx;
156 ctrl->tx = config->tx;
157 ctrl->gas_resp_tx = config->gas_resp_tx;
159 hostapd_ip_txt(&ctrl->ipaddr, txt, sizeof(txt)));
160 dl_list_add(&dpp->controllers, &ctrl->list);
173 dl_list_for_each(ctrl, &dpp->controllers, struct dpp_relay_controller,
175 if (os_memcmp(pkhash, ctrl->pkhash, SHA256_MAC_LEN) == 0)
191 dl_list_for_each(ctrl, &dpp->controllers, struct dpp_relay_controller,
193 if (cb_ctx == ctrl->cb_ctx)
210 dl_list_for_each(ctrl, &dpp->controllers, struct dpp_relay_controller,
212 if (ctrl->ipaddr.af == AF_INET &&
213 addr->sin_addr.s_addr == ctrl->ipaddr.u.v4.s_addr)
217 if (dpp->tmp_controller &&
218 dpp->tmp_controller->ipaddr.af == AF_INET &&
219 addr->sin_addr.s_addr == dpp->tmp_controller->ipaddr.u.v4.s_addr)
220 return dpp->tmp_controller;
228 struct dpp_authentication *auth = conn->auth;
230 if (auth->waiting_csr) {
232 conn->on_tcp_tx_complete_gas_done = 0;
237 if (auth->waiting_new_key) {
239 conn->on_tcp_tx_complete_gas_done = 0;
244 if (auth->peer_version >= 2 &&
245 auth->conf_resp_status == DPP_STATUS_OK) {
247 auth->waiting_conf_result = 1;
251 wpa_msg(conn->msg_ctx, MSG_INFO, DPP_EVENT_CONF_SENT "conf_status=%d",
252 auth->conf_resp_status);
261 if (!conn->msg_out) {
262 eloop_unregister_sock(conn->sock, EVENT_TYPE_WRITE);
263 conn->write_eloop = 0;
264 return -1;
266 res = send(conn->sock,
267 wpabuf_head_u8(conn->msg_out) + conn->msg_out_pos,
268 wpabuf_len(conn->msg_out) - conn->msg_out_pos, 0);
273 return -1;
276 conn->msg_out_pos += res;
277 if (wpabuf_len(conn->msg_out) > conn->msg_out_pos) {
280 (unsigned int) conn->msg_out_pos,
281 (unsigned int) wpabuf_len(conn->msg_out));
282 if (!conn->write_eloop &&
283 eloop_register_sock(conn->sock, EVENT_TYPE_WRITE,
285 conn->write_eloop = 1;
290 wpabuf_free(conn->msg_out);
291 conn->msg_out = NULL;
292 conn->msg_out_pos = 0;
293 eloop_unregister_sock(conn->sock, EVENT_TYPE_WRITE);
294 conn->write_eloop = 0;
295 if (!conn->read_eloop &&
296 eloop_register_sock(conn->sock, EVENT_TYPE_READ,
298 conn->read_eloop = 1;
299 if (conn->on_tcp_tx_complete_remove) {
300 if (conn->auth && conn->auth->connect_on_tx_status &&
301 conn->tcp_msg_sent &&
302 conn->tcp_msg_sent(conn->cb_ctx, conn->auth))
305 } else if (conn->auth && (conn->ctrl || conn->auth->configurator) &&
306 conn->on_tcp_tx_complete_gas_done) {
308 } else if (conn->on_tcp_tx_complete_auth_ok) {
309 conn->on_tcp_tx_complete_auth_ok = 0;
320 wpabuf_free(conn->msg_out);
321 conn->msg_out_pos = 0;
322 conn->msg_out = wpabuf_alloc(4 + wpabuf_len(msg) - 1);
323 if (!conn->msg_out)
324 return -1;
325 wpabuf_put_be32(conn->msg_out, wpabuf_len(msg) - 1);
326 wpabuf_put_data(conn->msg_out, wpabuf_head_u8(msg) + 1,
327 wpabuf_len(msg) - 1);
330 if (!conn->write_eloop) {
331 if (eloop_register_sock(conn->sock, EVENT_TYPE_WRITE,
334 return -1;
335 conn->write_eloop = 1;
345 struct dpp_authentication *auth = conn->auth;
349 dpp_name = conn->name ? conn->name : "Test";
350 buf = dpp_build_conf_req_helper(auth, dpp_name, conn->netrole,
351 conn->mud_url, NULL,
352 conn->extra_conf_req_name,
353 conn->extra_conf_req_value);
368 struct dpp_authentication *auth = conn->auth;
378 "DPP: TESTING - stop at Authentication Confirm");
379 if (auth->configurator) {
381 auth->auth_success = 0;
387 if (!auth->configurator)
410 switch (ipaddr->af) {
414 dst->sin_family = AF_INET;
415 dst->sin_addr.s_addr = ipaddr->u.v4.s_addr;
416 dst->sin_port = htons(port);
423 dst6->sin6_family = AF_INET6;
424 os_memcpy(&dst6->sin6_addr, &ipaddr->u.v6,
426 dst6->sin6_port = htons(port);
431 return -1;
443 "DPP: Timeout while waiting for relayed connection to complete");
457 if (dl_list_len(&ctrl->conn) >= 15) {
459 "DPP: Too many ongoing Relay connections to the Controller - cannot start a new one");
464 &ctrl->ipaddr, DPP_TCP_PORT) < 0)
471 conn->global = ctrl->global;
472 conn->relay = ctrl;
473 conn->msg_ctx = ctrl->msg_ctx;
474 conn->cb_ctx = ctrl->global->cb_ctx;
475 os_memcpy(conn->mac_addr, src, ETH_ALEN);
476 conn->freq = freq;
478 conn->sock = socket(AF_INET, SOCK_STREAM, 0);
479 if (conn->sock < 0)
482 conn->sock, hostapd_ip_txt(&ctrl->ipaddr, txt, sizeof(txt)));
484 if (fcntl(conn->sock, F_SETFL, O_NONBLOCK) != 0) {
490 if (connect(conn->sock, (struct sockaddr *) &addr, addrlen) < 0) {
498 * Continue connecting in the background; eloop will call us
503 if (eloop_register_sock(conn->sock, EVENT_TYPE_WRITE,
506 conn->write_eloop = 1;
511 dl_list_add(&ctrl->conn, &conn->list);
538 u8 type = hdr[DPP_HDR_LEN - 1];
542 wpabuf_free(conn->msg_out);
543 conn->msg_out_pos = 0;
544 conn->msg_out = dpp_tcp_encaps(hdr, buf, len);
545 if (!conn->msg_out) {
547 return -1;
553 conn->on_tcp_tx_complete_remove = 1;
565 dl_list_for_each(conn, &ctrl->conn, struct dpp_connection, list) {
566 if (ether_addr_equal(src, conn->mac_addr))
570 conn->freq == 0 &&
571 is_broadcast_ether_addr(conn->mac_addr)) {
574 os_memcpy(conn->mac_addr, src, ETH_ALEN);
575 conn->freq = freq;
591 u8 type = hdr[DPP_HDR_LEN - 1];
600 dl_list_for_each(ctrl, &dpp->controllers,
607 if (dpp->tmp_controller) {
608 conn = dpp_relay_match_ctrl(dpp->tmp_controller, src,
624 return -1;
628 return -1;
634 (!conn->auth || conn->auth->waiting_auth_resp)) {
645 return -1;
647 conn->msg_out = dpp_tcp_encaps(hdr, buf, len);
648 if (!conn->msg_out) {
650 return -1;
663 dl_list_for_each(conn, &ctrl->conn, struct dpp_connection, list) {
664 if (ether_addr_equal(src, conn->mac_addr))
682 dl_list_for_each(ctrl, &dpp->controllers,
689 if (!conn && dpp->tmp_controller)
690 conn = dpp_relay_find_conn(dpp->tmp_controller, src);
693 return -1;
697 return -1;
703 wpabuf_free(conn->msg_out);
704 conn->msg_out_pos = 0;
705 conn->msg_out = msg;
713 return dpp && dl_list_len(&dpp->controllers) > 0;
724 dl_list_for_each_safe(conn, tmp, &ctrl->conn, struct dpp_connection,
728 if (ctrl->sock >= 0) {
729 close(ctrl->sock);
730 eloop_unregister_sock(ctrl->sock, EVENT_TYPE_READ);
732 os_free(ctrl->configurator_params);
733 os_free(ctrl->pkex_code);
734 os_free(ctrl->pkex_identifier);
746 if (!conn->ctrl)
756 return -1;
766 return -1;
773 dpp_bootstrap_find_pair(conn->ctrl->global, i_bootstrap, r_bootstrap,
777 "No matching own bootstrapping key found - ignore message");
778 return -1;
781 if (conn->auth) {
783 "Already in DPP authentication exchange - ignore new one");
787 conn->auth = dpp_auth_req_rx(conn->ctrl->global, conn->msg_ctx,
788 conn->ctrl->allowed_roles,
789 conn->ctrl->qr_mutual,
790 peer_bi, own_bi, -1, hdr, buf, len);
791 if (!conn->auth) {
793 return -1;
796 if (dpp_set_configurator(conn->auth,
797 conn->ctrl->configurator_params) < 0)
798 return -1;
800 return dpp_tcp_send_msg(conn, conn->auth->resp_msg);
807 struct dpp_authentication *auth = conn->auth;
812 return -1;
818 if (auth->auth_resp_status == DPP_STATUS_RESPONSE_PENDING) {
824 return -1;
827 conn->on_tcp_tx_complete_auth_ok = 1;
837 struct dpp_authentication *auth = conn->auth;
843 "DPP: No DPP Authentication in progress - drop");
844 return -1;
849 return -1;
862 if (!conn->auth->waiting_conf_result)
866 "DPP: Timeout while waiting for Connection Status Result");
867 wpa_msg(conn->msg_ctx, MSG_INFO,
868 DPP_EVENT_CONN_STATUS_RESULT "timeout");
877 struct dpp_authentication *auth = conn->auth;
879 void *msg_ctx = conn->msg_ctx;
881 if (!conn->ctrl && (!auth || !auth->configurator))
886 if (!auth || !auth->waiting_conf_result) {
888 "DPP: No DPP Configuration waiting for result - drop");
889 return -1;
893 if (status == DPP_STATUS_OK && auth->send_conn_status) {
896 auth->conf_resp_status);
898 auth->waiting_conn_status_result = 1;
909 "conf_resp_status=%d", auth->conf_resp_status);
912 return -1; /* to remove the completed connection */
920 struct dpp_authentication *auth = conn->auth;
926 if (!conn->ctrl)
931 if (!auth || !auth->waiting_conn_status_result) {
933 "DPP: No DPP Configuration waiting for connection status result - drop");
934 return -1;
939 wpa_msg(conn->msg_ctx, MSG_INFO, DPP_EVENT_CONN_STATUS_RESULT
944 return -1; /* to remove the completed connection */
956 struct dpp_global *dpp = conn->ctrl->global;
963 wpa_msg(conn->msg_ctx, MSG_INFO, DPP_EVENT_FAIL
965 return -1;
973 return -1;
976 if (conn->auth) {
982 auth = dpp_auth_init(dpp, conn->msg_ctx, peer_bi, NULL,
983 DPP_CAPAB_CONFIGURATOR, -1, NULL, 0);
985 return -1;
986 if (dpp_set_configurator(auth, conn->ctrl->configurator_params) < 0) {
988 return -1;
991 conn->auth = auth;
992 return dpp_tcp_send_msg(conn, conn->auth->req_msg);
1003 struct dpp_global *dpp = conn->ctrl->global;
1007 if (conn->auth) {
1010 return -1;
1018 wpa_msg(conn->msg_ctx, MSG_INFO, DPP_EVENT_FAIL
1019 "Missing or invalid required Configurator C-sign key Hash attribute");
1020 return -1;
1022 wpa_hexdump(MSG_MSGDUMP, "DPP: Configurator C-sign key Hash (kid)",
1028 return -1;
1034 wpa_msg(conn->msg_ctx, MSG_INFO, DPP_EVENT_FAIL
1036 return -1;
1044 auth = dpp_reconfig_init(dpp, conn->msg_ctx, conf, 0, group,
1047 return -1;
1048 if (dpp_set_configurator(auth, conn->ctrl->configurator_params) < 0) {
1050 return -1;
1053 conn->auth = auth;
1054 return dpp_tcp_send_msg(conn, auth->reconfig_req_msg);
1062 struct dpp_authentication *auth = conn->auth;
1068 if (!auth || !auth->reconfig || !auth->configurator) {
1070 "DPP: No DPP Reconfig Authentication in progress - drop");
1071 return -1;
1076 return -1;
1088 struct dpp_controller *ctrl = conn->ctrl;
1098 if (!ctrl->pkex_code || !ctrl->pkex_bi) {
1100 "DPP: No PKEX code configured - ignore request");
1104 if (conn->pkex || conn->auth) {
1106 "DPP: Already in PKEX/Authentication session - ignore new PKEX request");
1110 conn->pkex = dpp_pkex_rx_exchange_req(conn->msg_ctx, ctrl->pkex_bi,
1112 ctrl->pkex_identifier,
1113 ctrl->pkex_code,
1114 os_strlen(ctrl->pkex_code),
1116 if (!conn->pkex) {
1119 return -1;
1122 return dpp_tcp_send_msg(conn, conn->pkex->exchange_resp);
1130 struct dpp_pkex *pkex = conn->pkex;
1136 if (!pkex || !pkex->initiator || pkex->exchange_done) {
1144 return -1;
1147 wpa_printf(MSG_DEBUG, "DPP: Send PKEX Commit-Reveal Request");
1158 struct dpp_pkex *pkex = conn->pkex;
1163 wpa_printf(MSG_DEBUG, "DPP: PKEX Commit-Reveal Request");
1165 if (!pkex || pkex->initiator || !pkex->exchange_done) {
1173 return -1;
1176 wpa_printf(MSG_DEBUG, "DPP: Send PKEX Commit-Reveal Response");
1181 bi = dpp_pkex_finish(conn->global, pkex, NULL, 0);
1183 return -1;
1184 conn->pkex = NULL;
1194 struct dpp_pkex *pkex = conn->pkex;
1198 wpa_printf(MSG_DEBUG, "DPP: PKEX Commit-Reveal Response");
1200 if (!pkex || !pkex->initiator || !pkex->exchange_done) {
1211 bi = dpp_pkex_finish(conn->global, pkex, NULL, 0);
1213 return -1;
1214 conn->pkex = NULL;
1216 if (!conn->pkex_done)
1217 return -1;
1218 return conn->pkex_done(conn->cb_ctx, conn, bi);
1232 if (end - pos < DPP_HDR_LEN ||
1236 return -1;
1242 return -1;
1249 pos, end - pos);
1250 if (dpp_check_attrs(pos, end - pos) < 0)
1251 return -1;
1253 if (conn->relay) {
1254 wpa_printf(MSG_DEBUG, "DPP: Relay - send over WLAN");
1255 conn->relay->tx(conn->relay->cb_ctx, conn->mac_addr,
1256 conn->freq, msg, len);
1262 return dpp_controller_rx_auth_req(conn, msg, pos, end - pos);
1264 return dpp_controller_rx_auth_resp(conn, msg, pos, end - pos);
1266 return dpp_controller_rx_auth_conf(conn, msg, pos, end - pos);
1268 return dpp_controller_rx_conf_result(conn, msg, pos, end - pos);
1271 end - pos);
1274 end - pos);
1277 end - pos);
1280 end - pos);
1283 "DPP: Ignore PKEXv1 Exchange Request - not supported over TCP");
1284 return -1;
1287 end - pos);
1290 end - pos);
1293 end - pos);
1296 end - pos);
1301 return -1;
1316 return -1;
1321 wpabuf_put_u8(buf, conn->gas_dialog_token);
1330 /* Send Config Response over TCP */
1332 wpabuf_free(conn->msg_out);
1333 conn->msg_out_pos = 0;
1334 conn->msg_out = buf;
1347 return -1;
1356 return -1;
1362 wpabuf_put_u8(buf, conn->gas_dialog_token);
1372 /* Send Config Response over TCP; GAS fragmentation is taken care of by
1375 wpabuf_free(conn->msg_out);
1376 conn->msg_out_pos = 0;
1377 conn->msg_out = buf;
1378 conn->on_tcp_tx_complete_gas_done = 1;
1391 struct dpp_authentication *auth = conn->auth;
1394 return -1;
1399 if (!auth || (!conn->ctrl && !auth->configurator) ||
1400 (!auth->auth_success && !auth->reconfig_success)) {
1402 return -1;
1405 wpa_msg(conn->msg_ctx, MSG_INFO, DPP_EVENT_CONF_REQ_RX);
1410 conn->gas_dialog_token = *pos++;
1414 slen > end - pos || slen < 2)
1415 return -1;
1418 pos++; /* skip QueryRespLenLimit and PAME-BI */
1423 return -1;
1427 if (end - pos < 2)
1428 return -1;
1431 if (slen > end - pos)
1432 return -1;
1435 if (!resp && auth->waiting_cert) {
1437 conn->gas_comeback_in_progress = 1;
1442 if (!resp && auth->waiting_config && auth->peer_bi) {
1445 int i, res, *opclass = auth->e_band_support;
1449 if (auth->e_name) {
1450 size_t e_len = os_strlen(auth->e_name);
1455 (const u8 *) auth->e_name, e_len);
1463 res = os_snprintf(b_pos, b_end - b_pos, "%s%d",
1465 if (os_snprintf_error(b_end - b_pos, res)) {
1471 if (auth->e_mud_url) {
1472 size_t e_len = os_strlen(auth->e_mud_url);
1474 if (!has_ctrl_char((const u8 *) auth->e_mud_url, e_len))
1475 mud_url = auth->e_mud_url;
1477 wpa_msg(conn->msg_ctx, MSG_INFO, DPP_EVENT_CONF_NEEDED
1479 auth->peer_bi->id, dpp_netrole_str(auth->e_netrole),
1483 conn->gas_comeback_in_progress = 1;
1496 struct dpp_authentication *auth = conn->auth;
1500 return -1;
1505 if (!auth || (!conn->ctrl && !auth->configurator) ||
1506 (!auth->auth_success && !auth->reconfig_success) ||
1507 !conn->gas_comeback_in_progress) {
1509 return -1;
1513 if (dialog_token != conn->gas_dialog_token) {
1515 dialog_token, conn->gas_dialog_token);
1516 return -1;
1519 if (!auth->conf_resp_tcp) {
1527 resp = auth->conf_resp_tcp;
1528 auth->conf_resp_tcp = NULL;
1536 struct dpp_authentication *auth = conn->auth;
1538 if (!auth || !auth->csrattrs)
1542 wpabuf_free(auth->csr);
1544 auth->csr = dpp_build_csr(auth, conn->name ? conn->name : "Test");
1545 if (!auth->csr) {
1558 struct dpp_authentication *auth = conn->auth;
1560 if (!auth || !auth->waiting_new_key)
1563 wpa_printf(MSG_DEBUG, "DPP: Build config request with a new key");
1571 struct dpp_authentication *auth = conn->auth;
1582 res = -1;
1584 if (res == -2) {
1590 if (res == -3) {
1599 return -1;
1602 if (conn->process_conf_obj)
1603 res = conn->process_conf_obj(conn->cb_ctx, auth);
1607 if (auth->peer_version < 2 || auth->conf_resp_status != DPP_STATUS_OK)
1608 return -1;
1614 return -1;
1616 conn->on_tcp_tx_complete_remove = 1;
1629 struct dpp_authentication *auth = conn->auth;
1641 wpabuf_put_u8(msg, conn->gas_dialog_token);
1644 wpabuf_free(conn->msg_out);
1645 conn->msg_out_pos = 0;
1646 conn->msg_out = msg;
1660 return -1;
1672 return -1;
1683 slen > end - pos || slen < 2)
1684 return -1;
1687 pos++; /* skip QueryRespLenLimit and PAME-BI */
1692 return -1;
1696 if (end - pos < 2)
1697 return -1;
1700 if (slen > end - pos)
1701 return -1;
1706 conn->gas_dialog_token = dialog_token;
1708 usecs = comeback_delay * 1024 - secs * 1000000;
1719 return -1;
1722 if (!conn->relay &&
1723 (!conn->ctrl || (conn->ctrl->allowed_roles & DPP_CAPAB_ENROLLEE)))
1726 if (!conn->relay) {
1729 return -1;
1731 wpa_printf(MSG_DEBUG, "DPP: Relay - send over WLAN");
1732 conn->relay->gas_resp_tx(conn->relay->cb_ctx, conn->mac_addr,
1748 if (conn->msg_len_octets < 4) {
1751 res = recv(sd, &conn->msg_len[conn->msg_len_octets],
1752 4 - conn->msg_len_octets, 0);
1767 res, (int) (4 - conn->msg_len_octets));
1768 conn->msg_len_octets += res;
1770 if (conn->msg_len_octets < 4) {
1773 (int) (4 - conn->msg_len_octets));
1777 msglen = WPA_GET_BE32(conn->msg_len);
1785 wpabuf_free(conn->msg);
1786 conn->msg = wpabuf_alloc(msglen);
1789 if (!conn->msg) {
1797 (unsigned int) wpabuf_tailroom(conn->msg));
1799 res = recv(sd, wpabuf_put(conn->msg, 0), wpabuf_tailroom(conn->msg), 0);
1811 wpabuf_put(conn->msg, res);
1813 if (wpabuf_tailroom(conn->msg) > 0) {
1816 (unsigned int) wpabuf_tailroom(conn->msg));
1820 conn->msg_len_octets = 0;
1821 wpa_hexdump_buf(MSG_DEBUG, "DPP: Received TCP message", conn->msg);
1822 if (wpabuf_len(conn->msg) < 1) {
1827 pos = wpabuf_head(conn->msg);
1831 wpabuf_len(conn->msg) - 1) < 0)
1836 wpabuf_len(conn->msg) - 1) < 0)
1842 wpabuf_len(conn->msg) - 1,
1848 conn, pos + 1, wpabuf_len(conn->msg) - 1) < 0)
1869 fd = accept(ctrl->sock, (struct sockaddr *) &addr, &addr_len);
1883 conn->global = ctrl->global;
1884 conn->ctrl = ctrl;
1885 conn->msg_ctx = ctrl->msg_ctx;
1886 conn->cb_ctx = ctrl->cb_ctx;
1887 conn->process_conf_obj = ctrl->process_conf_obj;
1888 conn->tcp_msg_sent = ctrl->tcp_msg_sent;
1889 conn->sock = fd;
1890 conn->netrole = ctrl->netrole;
1892 if (fcntl(conn->sock, F_SETFL, O_NONBLOCK) != 0) {
1898 if (eloop_register_sock(conn->sock, EVENT_TYPE_READ,
1901 conn->read_eloop = 1;
1903 /* TODO: eloop timeout to expire connections that do not complete in
1905 dl_list_add(&ctrl->conn, &conn->list);
1931 return -1;
1937 return -1;
1940 conn->msg_ctx = msg_ctx;
1941 conn->cb_ctx = cb_ctx;
1942 conn->pkex_done = pkex_done;
1943 conn->global = dpp;
1944 conn->pkex = pkex;
1945 conn->sock = socket(AF_INET, SOCK_STREAM, 0);
1946 if (conn->sock < 0)
1949 if (fcntl(conn->sock, F_SETFL, O_NONBLOCK) != 0) {
1955 if (connect(conn->sock, (struct sockaddr *) &saddr, addrlen) < 0) {
1963 * Continue connecting in the background; eloop will call us
1968 if (eloop_register_sock(conn->sock, EVENT_TYPE_WRITE,
1971 conn->write_eloop = 1;
1973 hdr = wpabuf_head(pkex->exchange_req);
1974 end = hdr + wpabuf_len(pkex->exchange_req);
1977 conn->msg_out = dpp_tcp_encaps(hdr, pos, end - pos);
1978 if (!conn->msg_out)
1982 /* TODO: eloop timeout to clear a connection if it does not complete
1984 dl_list_add(&dpp->tcp_init, &conn->list);
1988 return -1;
1997 hdr = wpabuf_head(auth->req_msg);
1998 end = hdr + wpabuf_len(auth->req_msg);
2001 conn->msg_out = dpp_tcp_encaps(hdr, pos, end - pos);
2002 if (!conn->msg_out)
2003 return -1;
2030 return -1;
2036 return -1;
2039 conn->msg_ctx = msg_ctx;
2040 conn->cb_ctx = cb_ctx;
2041 conn->process_conf_obj = process_conf_obj;
2042 conn->tcp_msg_sent = tcp_msg_sent;
2043 conn->name = os_strdup(name ? name : "Test");
2045 conn->mud_url = os_strdup(mud_url);
2047 conn->extra_conf_req_name = os_strdup(extra_conf_req_name);
2049 conn->extra_conf_req_value = os_strdup(extra_conf_req_value);
2050 conn->netrole = netrole;
2051 conn->global = dpp;
2052 conn->auth = auth;
2053 conn->sock = socket(AF_INET, SOCK_STREAM, 0);
2054 if (conn->sock < 0)
2057 if (fcntl(conn->sock, F_SETFL, O_NONBLOCK) != 0) {
2063 if (connect(conn->sock, (struct sockaddr *) &saddr, addrlen) < 0) {
2071 * Continue connecting in the background; eloop will call us
2076 if (eloop_register_sock(conn->sock, EVENT_TYPE_WRITE,
2079 conn->write_eloop = 1;
2084 /* TODO: eloop timeout to clear a connection if it does not complete
2086 dl_list_add(&dpp->tcp_init, &conn->list);
2090 return -1;
2108 conn->process_conf_obj = process_conf_obj;
2109 conn->tcp_msg_sent = tcp_msg_sent;
2110 os_free(conn->name);
2111 conn->name = os_strdup(name ? name : "Test");
2112 os_free(conn->mud_url);
2113 conn->mud_url = mud_url ? os_strdup(mud_url) : NULL;
2114 os_free(conn->extra_conf_req_name);
2115 conn->extra_conf_req_name = extra_conf_req_name ?
2117 conn->extra_conf_req_value = extra_conf_req_value ?
2119 conn->netrole = netrole;
2120 conn->auth = auth;
2123 return -1;
2125 dpp_conn_tx_ready(conn->sock, conn, NULL);
2131 struct dpp_controller_config *config)
2138 if (!dpp || dpp->controller)
2139 return -1;
2143 return -1;
2144 ctrl->global = dpp;
2145 if (config->configurator_params)
2146 ctrl->configurator_params =
2147 os_strdup(config->configurator_params);
2148 dl_list_init(&ctrl->conn);
2149 ctrl->allowed_roles = config->allowed_roles;
2150 ctrl->qr_mutual = config->qr_mutual;
2151 ctrl->netrole = config->netrole;
2152 ctrl->msg_ctx = config->msg_ctx;
2153 ctrl->cb_ctx = config->cb_ctx;
2154 ctrl->process_conf_obj = config->process_conf_obj;
2155 ctrl->tcp_msg_sent = config->tcp_msg_sent;
2157 ctrl->sock = socket(AF_INET, SOCK_STREAM, 0);
2158 if (ctrl->sock < 0)
2161 if (setsockopt(ctrl->sock, SOL_SOCKET, SO_REUSEADDR,
2169 if (fcntl(ctrl->sock, F_SETFL, O_NONBLOCK) < 0) {
2179 port = config->tcp_port ? config->tcp_port : DPP_TCP_PORT;
2181 if (bind(ctrl->sock, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
2187 if (listen(ctrl->sock, 10 /* max backlog */) < 0 ||
2188 fcntl(ctrl->sock, F_SETFL, O_NONBLOCK) < 0 ||
2189 eloop_register_sock(ctrl->sock, EVENT_TYPE_READ,
2193 dpp->controller = ctrl;
2198 return -1;
2206 if (!dpp || !dpp->controller)
2207 return -1;
2213 return -1;
2214 os_free(dpp->controller->configurator_params);
2215 dpp->controller->configurator_params = val;
2217 os_free(dpp->controller->configurator_params);
2218 dpp->controller->configurator_params = NULL;
2228 dpp_controller_free(dpp->controller);
2229 dpp->controller = NULL;
2236 if (dpp && dpp->controller && dpp->controller->cb_ctx == cb_ctx)
2245 ((auth->peer_bi && auth->peer_bi->id == id) ||
2246 (auth->tmp_peer_bi && auth->tmp_peer_bi->id == id));
2255 dl_list_for_each(conn, &dpp->tcp_init, struct dpp_connection, list) {
2256 if (dpp_tcp_peer_id_match(conn->auth, id))
2257 return conn->auth;
2267 struct dpp_controller *ctrl = dpp->controller;
2273 dl_list_for_each(conn, &ctrl->conn, struct dpp_connection, list) {
2274 if (dpp_tcp_peer_id_match(conn->auth, id))
2275 return conn->auth;
2285 struct dpp_controller *ctrl = dpp->controller;
2291 dl_list_for_each(conn, &ctrl->conn, struct dpp_connection, list) {
2292 struct dpp_authentication *auth = conn->auth;
2294 if (!auth->response_pending ||
2299 dpp_tcp_send_msg(conn, conn->auth->resp_msg);
2308 struct dpp_controller *ctrl = dpp->controller;
2313 ctrl->pkex_bi = bi;
2314 os_free(ctrl->pkex_code);
2315 ctrl->pkex_code = code ? os_strdup(code) : NULL;
2316 os_free(ctrl->pkex_identifier);
2317 ctrl->pkex_identifier = identifier ? os_strdup(identifier) : NULL;
2328 dl_list_for_each(conn, &dpp->tcp_init, struct dpp_connection, list) {
2329 if (!conn->pkex || !conn->pkex->enc_key)
2340 if (attr_key_len == wpabuf_len(conn->pkex->enc_key) &&
2341 os_memcmp(attr_key, wpabuf_head(conn->pkex->enc_key),
2354 dl_list_for_each_safe(conn, tmp, &dpp->tcp_init, struct dpp_connection,
2366 hostapd_ip_txt(&ctrl->ipaddr, txt, sizeof(txt)));
2368 dl_list_for_each_safe(conn, tmp, &ctrl->conn, struct dpp_connection,
2382 dl_list_for_each_safe(ctrl, tmp, &dpp->controllers,
2384 dl_list_del(&ctrl->list);
2388 if (dpp->tmp_controller) {
2389 dpp_relay_controller_free(dpp->tmp_controller);
2390 dpp->tmp_controller = NULL;
2403 dl_list_for_each(ctrl, &dpp->controllers, struct dpp_relay_controller,
2405 if (hostapd_ip_equal(&ctrl->ipaddr, addr)) {
2406 dl_list_del(&ctrl->list);
2412 if (dpp->tmp_controller &&
2413 hostapd_ip_equal(&dpp->tmp_controller->ipaddr, addr)) {
2414 dpp_relay_controller_free(dpp->tmp_controller);
2415 dpp->tmp_controller = NULL;
2431 fd = accept(dpp->relay_sock, (struct sockaddr *) &addr, &addr_len);
2442 if (!ctrl && dpp->tmp_controller &&
2443 dl_list_len(&dpp->tmp_controller->conn)) {
2448 hostapd_ip_txt(&dpp->tmp_controller->ipaddr,
2450 dpp_relay_controller_free(dpp->tmp_controller);
2451 dpp->tmp_controller = NULL;
2453 if (!ctrl && !dpp->tmp_controller) {
2458 dl_list_init(&ctrl->conn);
2459 ctrl->global = dpp;
2460 ctrl->ipaddr.af = AF_INET;
2461 ctrl->ipaddr.u.v4.s_addr = addr.sin_addr.s_addr;
2462 ctrl->msg_ctx = dpp->relay_msg_ctx;
2463 ctrl->cb_ctx = dpp->relay_cb_ctx;
2464 ctrl->tx = dpp->relay_tx;
2465 ctrl->gas_resp_tx = dpp->relay_gas_resp_tx;
2466 dpp->tmp_controller = ctrl;
2474 if (dl_list_len(&ctrl->conn) >= 15) {
2476 "DPP: Too many ongoing Relay connections to the Controller - cannot start a new one");
2484 conn->global = ctrl->global;
2485 conn->relay = ctrl;
2486 conn->msg_ctx = ctrl->msg_ctx;
2487 conn->cb_ctx = ctrl->global->cb_ctx;
2488 os_memset(conn->mac_addr, 0xff, ETH_ALEN);
2489 conn->sock = fd;
2491 if (fcntl(conn->sock, F_SETFL, O_NONBLOCK) != 0) {
2497 if (eloop_register_sock(conn->sock, EVENT_TYPE_READ,
2500 conn->read_eloop = 1;
2502 /* TODO: eloop timeout to expire connections that do not complete in
2504 dl_list_add(&ctrl->conn, &conn->list);
2514 struct dpp_relay_config *config)
2520 if (dpp->relay_sock >= 0) {
2521 wpa_printf(MSG_INFO, "DPP: %s(%d) - relay port already opened",
2523 return -1;
2531 return -1;
2545 return -1;
2558 return -1;
2565 return -1;
2568 dpp->relay_sock = s;
2569 dpp->relay_msg_ctx = config->msg_ctx;
2570 dpp->relay_cb_ctx = config->cb_ctx;
2571 dpp->relay_tx = config->tx;
2572 dpp->relay_gas_resp_tx = config->gas_resp_tx;
2580 if (!dpp || dpp->relay_sock < 0)
2582 eloop_unregister_sock(dpp->relay_sock, EVENT_TYPE_READ);
2583 close(dpp->relay_sock);
2584 dpp->relay_sock = -1;
2595 dl_list_for_each(conn, &dpp->tcp_init, struct dpp_connection, list) {
2596 if (conn->auth && conn->auth->conn_status_requested)
2610 struct dpp_authentication *auth = conn->auth;
2615 auth->conn_status_requested = 0;
2634 dl_list_for_each(c, &dpp->tcp_init, struct dpp_connection, list) {
2638 conn->on_tcp_tx_complete_remove = 1;
2652 dl_list_for_each(conn, &dpp->tcp_init, struct dpp_connection, list) {
2653 if (conn->auth && conn->auth->conn_status_requested) {