From 485cf616b236a6f0c7cf69e6bae2411036c7506b Mon Sep 17 00:00:00 2001 From: Matheus Date: Thu, 10 Sep 2026 23:43:25 -0300 Subject: [PATCH] ports: wpa-supplicant --- .../wpa-supplicant/jinx-working-patch.patch | 695 ++++++++++++++++++ recipes/wpa-supplicant | 38 + source-recipes/wpa-supplicant | 5 + 3 files changed, 738 insertions(+) create mode 100644 patches/wpa-supplicant/jinx-working-patch.patch create mode 100644 recipes/wpa-supplicant create mode 100644 source-recipes/wpa-supplicant diff --git a/patches/wpa-supplicant/jinx-working-patch.patch b/patches/wpa-supplicant/jinx-working-patch.patch new file mode 100644 index 00000000..dd36953c --- /dev/null +++ b/patches/wpa-supplicant/jinx-working-patch.patch @@ -0,0 +1,695 @@ +diff --git wpa-supplicant-clean/src/common/defs.h wpa-supplicant-workdir/src/common/defs.h +index c88766e7..8f8c7431 100644 +--- wpa-supplicant-clean/src/common/defs.h ++++ wpa-supplicant-workdir/src/common/defs.h +@@ -9,6 +9,9 @@ + #ifndef DEFS_H + #define DEFS_H + ++#include ++#include ++ + #define WPA_CIPHER_NONE BIT(0) + #define WPA_CIPHER_WEP40 BIT(1) + #define WPA_CIPHER_WEP104 BIT(2) +diff --git wpa-supplicant-clean/src/common/wpa_common.h wpa-supplicant-workdir/src/common/wpa_common.h +index 51bd3886..045e17d3 100644 +--- wpa-supplicant-clean/src/common/wpa_common.h ++++ wpa-supplicant-workdir/src/common/wpa_common.h +@@ -9,6 +9,9 @@ + #ifndef WPA_COMMON_H + #define WPA_COMMON_H + ++#include ++#include ++ + #include "common/defs.h" + + /* IEEE 802.11i */ +diff --git wpa-supplicant-clean/src/drivers/driver.h wpa-supplicant-workdir/src/drivers/driver.h +index ea5e28be..0825e661 100644 +--- wpa-supplicant-clean/src/drivers/driver.h ++++ wpa-supplicant-workdir/src/drivers/driver.h +@@ -7932,6 +7932,9 @@ extern const struct wpa_driver_ops wpa_driver_bsd_ops; /* driver_bsd.c */ + /* driver_openbsd.c */ + extern const struct wpa_driver_ops wpa_driver_openbsd_ops; + #endif /* CONFIG_DRIVER_OPENBSD */ ++#ifdef CONFIG_DRIVER_ASTRAL ++extern const struct wpa_driver_ops wpa_driver_astral_ops; /* driver_astral.c */ ++#endif /* CONFIG_DRIVER_ASTRAL */ + #ifdef CONFIG_DRIVER_NDIS + extern struct wpa_driver_ops wpa_driver_ndis_ops; /* driver_ndis.c */ + #endif /* CONFIG_DRIVER_NDIS */ +diff --git wpa-supplicant-workdir/src/drivers/driver_astral.c wpa-supplicant-workdir/src/drivers/driver_astral.c +new file mode 100644 +index 00000000..bd340511 +--- /dev/null ++++ wpa-supplicant-workdir/src/drivers/driver_astral.c +@@ -0,0 +1,604 @@ ++#include "includes.h" ++#include ++#include ++ ++#include "common.h" ++#include "eloop.h" ++#include "common/defs.h" ++#include "common/ieee802_11_defs.h" ++#include "common/wpa_common.h" ++#include "driver.h" ++ ++#define ASTRAL_IOCTL_GET_INFO 0x1337631UL ++#define ASTRAL_IOCTL_WLAN_SCAN 0x8021101UL ++#define ASTRAL_IOCTL_WLAN_SCAN_WAIT 0x8021102UL ++#define ASTRAL_IOCTL_WLAN_GET_BSS_CACHE 0x8021103UL ++#define ASTRAL_IOCTL_WLAN_ASSOCIATE 0x8021104UL ++#define ASTRAL_IOCTL_WLAN_ASSOCIATION_WAIT 0x8021105UL ++#define ASTRAL_IOCTL_WLAN_DISASSOCIATE 0x8021106UL ++#define ASTRAL_IOCTL_WLAN_SET_KEY 0x8021107UL ++#define ASTRAL_IOCTL_WLAN_DEL_KEY 0x8021108UL ++ ++#define ASTRAL_MAX_KEY_SIZE 128 ++#define ASTRAL_MAX_SEQ_SIZE 16 ++#define ASTRAL_MAX_IE_SIZE 1024 ++#define ASTRAL_MAX_APS 1000 ++#define ASTRAL_MAX_RSN_SIZE 255 ++#define ASTRAL_MAX_SCAN_IE_SIZE 512 ++ ++#define ASTRAL_CIPHER_CCMP 0 ++#define ASTRAL_CIPHER_TKIP 1 ++#define ASTRAL_CIPHER_WEP40 2 ++#define ASTRAL_CIPHER_WEP104 3 ++ ++#define ASTRAL_KEY_PAIRWISE (1U << 0) ++#define ASTRAL_KEY_GROUP (1U << 1) ++#define ASTRAL_KEY_RX (1U << 2) ++#define ASTRAL_KEY_TX (1U << 3) ++ ++struct astral_abi_sockaddr { ++ u16 type; ++ char addr[14]; ++}; ++ ++struct astral_net_info { ++ struct astral_abi_sockaddr addr; ++ struct astral_abi_sockaddr broadaddr; ++ struct astral_abi_sockaddr netmask; ++ struct astral_abi_sockaddr hwaddr; ++ short flags; ++ int mtu; ++}; ++ ++struct astral_bss_request { ++ void *buffer; ++ size_t buffer_size; ++ size_t records_returned; ++}; ++ ++struct astral_bss_info { ++ u16 length; ++ u16 rsn_ie_length; ++ u16 variable_offset; ++ u16 interval; ++ u16 capabilities; ++ u8 bssid[ETH_ALEN]; ++ u8 rate_bitmap[16]; ++ u8 channel; ++ u8 ssid_length; ++}; ++ ++struct astral_association_request { ++ u8 bssid[ETH_ALEN]; ++ void *ie; ++ size_t ie_size; ++}; ++ ++struct astral_key_request { ++ u8 cipher; ++ u8 index; ++ u8 peer[ETH_ALEN]; ++ u8 *key; ++ size_t key_len; ++ u8 *rx_seq; ++ size_t rx_seq_len; ++ u32 flags; ++}; ++ ++struct astral_del_key_request { ++ u8 peer[ETH_ALEN]; ++ u8 index; ++ u32 flags; ++}; ++ ++struct astral_driver_data { ++ void *ctx; ++ int fd; ++ u8 own_addr[ETH_ALEN]; ++ ++ u8 bssid[ETH_ALEN]; ++ u8 ssid[SSID_MAX_LEN]; ++ size_t ssid_len; ++ ++ u8 pending_bssid[ETH_ALEN]; ++ u8 pending_ssid[SSID_MAX_LEN]; ++ size_t pending_ssid_len; ++ bool association_pending; ++ bool scan_pending; ++}; ++ ++static int astral_ioctl(struct astral_driver_data *drv, unsigned long request, ++ void *arg) ++{ ++ if (ioctl(drv->fd, request, arg) < 0) { ++ wpa_printf(MSG_DEBUG, "Astral ioctl 0x%lx failed: %s", request, ++ strerror(errno)); ++ return -1; ++ } ++ ++ return 0; ++} ++ ++static int astral_channel_to_freq(u8 channel) ++{ ++ if (channel >= 1 && channel <= 13) ++ return 2407 + 5 * channel; ++ if (channel == 14) ++ return 2484; ++ return 0; ++} ++ ++static void astral_append_ie(u8 **pos, u8 id, const u8 *data, size_t len) ++{ ++ *(*pos)++ = id; ++ *(*pos)++ = (u8) len; ++ if (len) ++ os_memcpy(*pos, data, len); ++ *pos += len; ++} ++ ++static size_t astral_build_scan_ies(const struct astral_bss_info *bss, ++ const u8 *variables, u8 *ies) ++{ ++ u8 rates[sizeof(bss->rate_bitmap) * 8]; ++ size_t rate_count = 0; ++ size_t i; ++ u8 *pos = ies; ++ ++ astral_append_ie(&pos, WLAN_EID_SSID, variables, bss->ssid_length); ++ ++ for (i = 0; i <= 125; ++i) { ++ if (bss->rate_bitmap[i / 8] & BIT(i % 8)) ++ rates[rate_count++] = (u8) i; ++ } ++ if (rate_count) { ++ size_t supported = rate_count > 8 ? 8 : rate_count; ++ astral_append_ie(&pos, WLAN_EID_SUPP_RATES, rates, supported); ++ if (rate_count > supported) ++ astral_append_ie(&pos, WLAN_EID_EXT_SUPP_RATES, ++ rates + supported, rate_count - supported); ++ } ++ ++ if (bss->rsn_ie_length) ++ astral_append_ie(&pos, WLAN_EID_RSN, ++ variables + bss->ssid_length, bss->rsn_ie_length); ++ ++ return pos - ies; ++} ++ ++static void astral_scan_complete(void *eloop_ctx, void *user_ctx) ++{ ++ struct astral_driver_data *drv = eloop_ctx; ++ ++ (void) user_ctx; ++ if (!drv->scan_pending) ++ return; ++ ++ drv->scan_pending = false; ++ if (astral_ioctl(drv, ASTRAL_IOCTL_WLAN_SCAN_WAIT, NULL) < 0) ++ wpa_printf(MSG_DEBUG, "Astral scan did not complete successfully"); ++ ++ /* The result callback reads the cache populated by the completed scan. */ ++ wpa_supplicant_event(drv->ctx, EVENT_SCAN_RESULTS, NULL); ++} ++ ++static void astral_association_complete(void *eloop_ctx, void *user_ctx) ++{ ++ struct astral_driver_data *drv = eloop_ctx; ++ union wpa_event_data event; ++ ++ (void) user_ctx; ++ if (!drv->association_pending) ++ return; ++ ++ drv->association_pending = false; ++ if (astral_ioctl(drv, ASTRAL_IOCTL_WLAN_ASSOCIATION_WAIT, NULL) == 0) { ++ os_memcpy(drv->bssid, drv->pending_bssid, ETH_ALEN); ++ drv->ssid_len = drv->pending_ssid_len; ++ os_memcpy(drv->ssid, drv->pending_ssid, drv->ssid_len); ++ wpa_supplicant_event(drv->ctx, EVENT_ASSOC, NULL); ++ return; ++ } ++ ++ /* The current kernel ABI maps all association failures to EINVAL. */ ++ os_memset(&event, 0, sizeof(event)); ++ event.assoc_reject.bssid = drv->pending_bssid; ++ event.assoc_reject.status_code = WLAN_STATUS_UNSPECIFIED_FAILURE; ++ event.assoc_reject.reason_code = STA_CONNECT_FAIL_REASON_UNSPECIFIED; ++ wpa_supplicant_event(drv->ctx, EVENT_ASSOC_REJECT, &event); ++} ++ ++static void *astral_init(void *ctx, const char *ifname) ++{ ++ struct astral_driver_data *drv; ++ struct astral_net_info info; ++ char path[sizeof("/dev/") + IFNAMSIZ]; ++ int path_len; ++ ++ if (!ifname || os_strlen(ifname) >= IFNAMSIZ || os_strchr(ifname, '/')) ++ return NULL; ++ ++ drv = os_zalloc(sizeof(*drv)); ++ if (!drv) ++ return NULL; ++ drv->ctx = ctx; ++ drv->fd = -1; ++ ++ path_len = os_snprintf(path, sizeof(path), "/dev/%s", ifname); ++ if (path_len < 0 || (size_t) path_len >= sizeof(path)) ++ goto fail; ++ ++ drv->fd = open(path, O_RDWR); ++ if (drv->fd < 0) { ++ wpa_printf(MSG_DEBUG, "Could not open %s: %s", path, ++ strerror(errno)); ++ goto fail; ++ } ++ ++ os_memset(&info, 0, sizeof(info)); ++ if (astral_ioctl(drv, ASTRAL_IOCTL_GET_INFO, &info) < 0) ++ goto fail; ++ os_memcpy(drv->own_addr, info.hwaddr.addr, ETH_ALEN); ++ ++ return drv; ++ ++fail: ++ if (drv->fd >= 0) ++ close(drv->fd); ++ os_free(drv); ++ return NULL; ++} ++ ++static void astral_deinit(void *priv) ++{ ++ struct astral_driver_data *drv = priv; ++ ++ if (!drv) ++ return; ++ ++ eloop_cancel_timeout(astral_scan_complete, drv, NULL); ++ eloop_cancel_timeout(astral_association_complete, drv, NULL); ++ ++ /* Drain kernel operations whose completion callbacks were cancelled. */ ++ if (drv->scan_pending) { ++ (void) astral_ioctl(drv, ASTRAL_IOCTL_WLAN_SCAN_WAIT, NULL); ++ drv->scan_pending = false; ++ } ++ if (drv->association_pending) { ++ (void) astral_ioctl(drv, ASTRAL_IOCTL_WLAN_ASSOCIATION_WAIT, NULL); ++ drv->association_pending = false; ++ } ++ ++ if (drv->fd >= 0) ++ close(drv->fd); ++ os_free(drv); ++} ++ ++static int astral_get_bssid(void *priv, u8 *bssid) ++{ ++ struct astral_driver_data *drv = priv; ++ ++ if (!drv || is_zero_ether_addr(drv->bssid)) ++ return -1; ++ os_memcpy(bssid, drv->bssid, ETH_ALEN); ++ return 0; ++} ++ ++static int astral_get_ssid(void *priv, u8 *ssid) ++{ ++ struct astral_driver_data *drv = priv; ++ ++ if (!drv || is_zero_ether_addr(drv->bssid)) ++ return -1; ++ os_memcpy(ssid, drv->ssid, drv->ssid_len); ++ return drv->ssid_len; ++} ++ ++static int astral_scan(void *priv, struct wpa_driver_scan_params *params) ++{ ++ struct astral_driver_data *drv = priv; ++ ++ (void) params; ++ if (!drv || drv->scan_pending) ++ return -1; ++ if (astral_ioctl(drv, ASTRAL_IOCTL_WLAN_SCAN, NULL) < 0) ++ return -1; ++ ++ drv->scan_pending = true; ++ if (eloop_register_timeout(0, 0, astral_scan_complete, drv, NULL) < 0) { ++ (void) astral_ioctl(drv, ASTRAL_IOCTL_WLAN_SCAN_WAIT, NULL); ++ drv->scan_pending = false; ++ return -1; ++ } ++ return 0; ++} ++ ++static struct wpa_scan_results *astral_get_scan_results(void *priv) ++{ ++ struct astral_driver_data *drv = priv; ++ struct astral_bss_request request; ++ struct wpa_scan_results *results = NULL; ++ u8 *buffer; ++ size_t buffer_size; ++ size_t remaining; ++ size_t offset = 0; ++ size_t i; ++ ++ buffer_size = ASTRAL_MAX_APS * ++ (sizeof(struct astral_bss_info) + SSID_MAX_LEN + ASTRAL_MAX_RSN_SIZE); ++ buffer = os_malloc(buffer_size); ++ if (!buffer) ++ return NULL; ++ ++ os_memset(&request, 0, sizeof(request)); ++ request.buffer = buffer; ++ request.buffer_size = buffer_size; ++ if (astral_ioctl(drv, ASTRAL_IOCTL_WLAN_GET_BSS_CACHE, &request) < 0) ++ goto fail; ++ if (request.records_returned > ASTRAL_MAX_APS) ++ goto fail; ++ ++ results = os_zalloc(sizeof(*results)); ++ if (!results) ++ goto fail; ++ if (request.records_returned) { ++ results->res = os_calloc(request.records_returned, ++ sizeof(*results->res)); ++ if (!results->res) ++ goto fail_results; ++ } ++ ++ remaining = buffer_size; ++ for (i = 0; i < request.records_returned; ++i) { ++ const struct astral_bss_info *bss; ++ const u8 *variables; ++ struct wpa_scan_res *result; ++ u8 ies[ASTRAL_MAX_SCAN_IE_SIZE]; ++ size_t ie_len; ++ ++ if (remaining < sizeof(*bss)) ++ goto fail_results; ++ bss = (const struct astral_bss_info *) (buffer + offset); ++ if (bss->length < sizeof(*bss) || bss->length > remaining || ++ bss->variable_offset < sizeof(*bss) || ++ bss->variable_offset > bss->length || ++ bss->ssid_length > bss->length - bss->variable_offset || ++ bss->rsn_ie_length > bss->length - bss->variable_offset - ++ bss->ssid_length) ++ goto fail_results; ++ ++ variables = (const u8 *) bss + bss->variable_offset; ++ ie_len = astral_build_scan_ies(bss, variables, ies); ++ if (ie_len > ASTRAL_MAX_SCAN_IE_SIZE) ++ goto fail_results; ++ ++ result = os_zalloc(sizeof(*result) + ie_len); ++ if (!result) ++ goto fail_results; ++ result->flags = WPA_SCAN_QUAL_INVALID | ++ WPA_SCAN_NOISE_INVALID | WPA_SCAN_LEVEL_INVALID; ++ os_memcpy(result->bssid, bss->bssid, ETH_ALEN); ++ result->freq = astral_channel_to_freq(bss->channel); ++ result->beacon_int = bss->interval; ++ result->caps = bss->capabilities; ++ result->ie_len = ie_len; ++ os_memcpy(result + 1, ies, ie_len); ++ results->res[results->num++] = result; ++ ++ offset += bss->length; ++ remaining -= bss->length; ++ } ++ ++ os_free(buffer); ++ return results; ++ ++fail_results: ++ wpa_scan_results_free(results); ++fail: ++ os_free(buffer); ++ return NULL; ++} ++ ++static int astral_associate(void *priv, ++ struct wpa_driver_associate_params *params) ++{ ++ struct astral_driver_data *drv = priv; ++ struct astral_association_request request; ++ ++ if (!drv || !params || !params->bssid || drv->association_pending || ++ params->ssid_len > SSID_MAX_LEN || ++ (params->ssid_len && !params->ssid) || ++ params->wpa_ie_len > ASTRAL_MAX_IE_SIZE || ++ (params->wpa_ie_len && !params->wpa_ie)) ++ return -1; ++ ++ os_memset(&request, 0, sizeof(request)); ++ os_memcpy(request.bssid, params->bssid, ETH_ALEN); ++ request.ie = (void *) params->wpa_ie; ++ request.ie_size = params->wpa_ie_len; ++ if (astral_ioctl(drv, ASTRAL_IOCTL_WLAN_ASSOCIATE, &request) < 0) ++ return -1; ++ ++ os_memcpy(drv->pending_bssid, params->bssid, ETH_ALEN); ++ drv->pending_ssid_len = params->ssid_len; ++ if (drv->pending_ssid_len) ++ os_memcpy(drv->pending_ssid, params->ssid, drv->pending_ssid_len); ++ os_memset(drv->bssid, 0, ETH_ALEN); ++ drv->ssid_len = 0; ++ drv->association_pending = true; ++ ++ if (eloop_register_timeout(0, 0, astral_association_complete, drv, NULL) < 0) { ++ (void) astral_ioctl(drv, ASTRAL_IOCTL_WLAN_ASSOCIATION_WAIT, NULL); ++ (void) astral_ioctl(drv, ASTRAL_IOCTL_WLAN_DISASSOCIATE, NULL); ++ drv->association_pending = false; ++ return -1; ++ } ++ return 0; ++} ++ ++static int astral_deauthenticate(void *priv, const u8 *addr, u16 reason_code) ++{ ++ struct astral_driver_data *drv = priv; ++ ++ (void) addr; ++ (void) reason_code; ++ if (!drv) ++ return -1; ++ if (drv->association_pending) { ++ eloop_cancel_timeout(astral_association_complete, drv, NULL); ++ if (astral_ioctl(drv, ASTRAL_IOCTL_WLAN_ASSOCIATION_WAIT, NULL) < 0) { ++ drv->association_pending = false; ++ os_memset(drv->bssid, 0, ETH_ALEN); ++ drv->ssid_len = 0; ++ return 0; ++ } ++ drv->association_pending = false; ++ } ++ if (astral_ioctl(drv, ASTRAL_IOCTL_WLAN_DISASSOCIATE, NULL) < 0) ++ return -1; ++ ++ os_memset(drv->bssid, 0, ETH_ALEN); ++ drv->ssid_len = 0; ++ return 0; ++} ++ ++static int astral_wpa_cipher(enum wpa_alg alg, size_t key_len, u8 *cipher) ++{ ++ switch (alg) { ++ case WPA_ALG_CCMP: ++ *cipher = ASTRAL_CIPHER_CCMP; ++ return 0; ++ case WPA_ALG_TKIP: ++ *cipher = ASTRAL_CIPHER_TKIP; ++ return 0; ++ case WPA_ALG_WEP: ++ if (key_len == 5) ++ *cipher = ASTRAL_CIPHER_WEP40; ++ else if (key_len == 13) ++ *cipher = ASTRAL_CIPHER_WEP104; ++ else ++ return -1; ++ return 0; ++ default: ++ return -1; ++ } ++} ++ ++static u32 astral_key_flags(const struct wpa_driver_set_key_params *params) ++{ ++ u32 flags = 0; ++ ++ if (params->key_flag & KEY_FLAG_PAIRWISE) ++ flags |= ASTRAL_KEY_PAIRWISE; ++ if (params->key_flag & KEY_FLAG_GROUP) ++ flags |= ASTRAL_KEY_GROUP; ++ if (params->key_flag & KEY_FLAG_RX) ++ flags |= ASTRAL_KEY_RX; ++ if (params->key_flag & KEY_FLAG_TX) ++ flags |= ASTRAL_KEY_TX; ++ if (params->set_tx) ++ flags |= ASTRAL_KEY_TX; ++ return flags; ++} ++ ++static int astral_set_key(void *priv, ++ struct wpa_driver_set_key_params *params) ++{ ++ struct astral_driver_data *drv = priv; ++ struct astral_key_request request; ++ struct astral_del_key_request del_request; ++ ++ if (!drv || !params || params->key_idx < 0 || params->key_idx > 255 || ++ (params->key_len && !params->key) || ++ (params->seq_len && !params->seq) || ++ params->key_len > ASTRAL_MAX_KEY_SIZE || ++ params->seq_len > ASTRAL_MAX_SEQ_SIZE || ++ (params->key_flag & (KEY_FLAG_NEXT | KEY_FLAG_PMK))) ++ return -1; ++ ++ if (params->alg == WPA_ALG_NONE) { ++ os_memset(&del_request, 0, sizeof(del_request)); ++ del_request.index = params->key_idx; ++ del_request.flags = astral_key_flags(params); ++ if (del_request.flags & ASTRAL_KEY_GROUP) ++ os_memset(del_request.peer, 0, ETH_ALEN); ++ else if (params->addr) ++ os_memcpy(del_request.peer, params->addr, ETH_ALEN); ++ return astral_ioctl(drv, ASTRAL_IOCTL_WLAN_DEL_KEY, &del_request); ++ } ++ ++ os_memset(&request, 0, sizeof(request)); ++ if (astral_wpa_cipher(params->alg, params->key_len, ++ &request.cipher) < 0) ++ return -1; ++ request.index = params->key_idx; ++ request.key = (u8 *) params->key; ++ request.key_len = params->key_len; ++ request.rx_seq = (u8 *) params->seq; ++ request.rx_seq_len = params->seq_len; ++ request.flags = astral_key_flags(params); ++ if ((request.flags & ASTRAL_KEY_PAIRWISE) && ++ (request.flags & ASTRAL_KEY_GROUP)) ++ return -1; ++ if (!(request.flags & (ASTRAL_KEY_PAIRWISE | ASTRAL_KEY_GROUP))) { ++ if (params->addr && !is_broadcast_ether_addr(params->addr)) ++ request.flags |= ASTRAL_KEY_PAIRWISE; ++ else ++ request.flags |= ASTRAL_KEY_GROUP; ++ } ++ if ((request.flags & ASTRAL_KEY_PAIRWISE) && !params->addr) ++ return -1; ++ if (request.flags & ASTRAL_KEY_GROUP) ++ os_memset(request.peer, 0, ETH_ALEN); ++ else ++ os_memcpy(request.peer, params->addr, ETH_ALEN); ++ ++ return astral_ioctl(drv, ASTRAL_IOCTL_WLAN_SET_KEY, &request); ++} ++ ++static int astral_get_capa(void *priv, struct wpa_driver_capa *capa) ++{ ++ int i; ++ ++ (void) priv; ++ if (!capa) ++ return -1; ++ ++ os_memset(capa, 0, sizeof(*capa)); ++ capa->key_mgmt = WPA_DRIVER_CAPA_KEY_MGMT_WPA | ++ WPA_DRIVER_CAPA_KEY_MGMT_WPA2 | ++ WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK | ++ WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK; ++ capa->enc = WPA_DRIVER_CAPA_ENC_WEP40 | ++ WPA_DRIVER_CAPA_ENC_WEP104 | ++ WPA_DRIVER_CAPA_ENC_TKIP | ++ WPA_DRIVER_CAPA_ENC_CCMP; ++ capa->auth = WPA_DRIVER_AUTH_OPEN; ++ capa->max_scan_ssids = 1; ++ for (i = 0; i < WPA_IF_MAX; ++i) ++ capa->key_mgmt_iftype[i] = capa->key_mgmt; ++ return 0; ++} ++ ++static const u8 *astral_get_mac_addr(void *priv) ++{ ++ struct astral_driver_data *drv = priv; ++ ++ return drv ? drv->own_addr : NULL; ++} ++ ++const struct wpa_driver_ops wpa_driver_astral_ops = { ++ .name = "astral", ++ .desc = "Astral WPA supplicant port", ++ .init = astral_init, ++ .deinit = astral_deinit, ++ .get_bssid = astral_get_bssid, ++ .get_ssid = astral_get_ssid, ++ .scan2 = astral_scan, ++ .get_scan_results2 = astral_get_scan_results, ++ .associate = astral_associate, ++ .deauthenticate = astral_deauthenticate, ++ .set_key = astral_set_key, ++ .get_capa = astral_get_capa, ++ .get_mac_addr = astral_get_mac_addr, ++}; +diff --git wpa-supplicant-clean/src/drivers/drivers.c wpa-supplicant-workdir/src/drivers/drivers.c +index f088b6f2..dd913f63 100644 +--- wpa-supplicant-clean/src/drivers/drivers.c ++++ wpa-supplicant-workdir/src/drivers/drivers.c +@@ -25,6 +25,9 @@ const struct wpa_driver_ops *const wpa_drivers[] = + #ifdef CONFIG_DRIVER_OPENBSD + &wpa_driver_openbsd_ops, + #endif /* CONFIG_DRIVER_OPENBSD */ ++#ifdef CONFIG_DRIVER_ASTRAL ++ &wpa_driver_astral_ops, ++#endif /* CONFIG_DRIVER_ASTRAL */ + #ifdef CONFIG_DRIVER_NDIS + &wpa_driver_ndis_ops, + #endif /* CONFIG_DRIVER_NDIS */ +diff --git wpa-supplicant-clean/src/drivers/drivers.mak wpa-supplicant-workdir/src/drivers/drivers.mak +index 160b5378..1b5f4f8f 100644 +--- wpa-supplicant-clean/src/drivers/drivers.mak ++++ wpa-supplicant-workdir/src/drivers/drivers.mak +@@ -77,6 +77,11 @@ DRV_CFLAGS += -DCONFIG_DRIVER_OPENBSD + DRV_OBJS += ../src/drivers/driver_openbsd.o + endif + ++ifdef CONFIG_DRIVER_ASTRAL ++DRV_CFLAGS += -DCONFIG_DRIVER_ASTRAL ++DRV_OBJS += ../src/drivers/driver_astral.o ++endif ++ + ifdef CONFIG_DRIVER_NONE + DRV_CFLAGS += -DCONFIG_DRIVER_NONE + DRV_OBJS += ../src/drivers/driver_none.o +diff --git wpa-supplicant-clean/src/utils/common.h wpa-supplicant-workdir/src/utils/common.h +index 076f2669..4852dd44 100644 +--- wpa-supplicant-clean/src/utils/common.h ++++ wpa-supplicant-workdir/src/utils/common.h +@@ -11,7 +11,7 @@ + + #include "os.h" + +-#if defined(__linux__) || defined(__GLIBC__) ++#if defined(__linux__) || defined(__GLIBC__) || defined(__astral__) + #include + #include + #endif /* __linux__ */ diff --git a/recipes/wpa-supplicant b/recipes/wpa-supplicant new file mode 100644 index 00000000..eee41428 --- /dev/null +++ b/recipes/wpa-supplicant @@ -0,0 +1,38 @@ +name=wpa-supplicant +revision=1 +from_source=wpa-supplicant +imagedeps="build-essential" +hostdeps="xgcc xbinutils" +deps="base openssl" + +configure() { + cp -rpa ${source_dir}/* . + cat > wpa_supplicant/.config << EOF +CONFIG_NO_LINUX_PACKET_SOCKET_WAR=y +CONFIG_L2_PACKET=linux +CONFIG_ELOOP=eloop +CONFIG_OS=unix +CONFIG_DRIVER_ASTRAL=y + +CONFIG_BACKEND=file + +# TODO use unix datagram sockets when implemented +CONFIG_CTRL_IFACE=udp +EOF + + cat > wpa_supplicant.conf << EOF +ctrl_interface=udp +update_config=1 +ap_scan=1 +EOF +} + +build() { + make V=1 CC=x86_64-astral-gcc AR=x86_64-astral-ar RANLIB=x86_64-astral-ranlib -C wpa_supplicant -j${parallelism} +} + +package() { + install -Dm755 ./wpa_supplicant/wpa_supplicant ${dest_dir}${prefix}/sbin/wpa_supplicant + install -Dm755 ./wpa_supplicant/wpa_cli ${dest_dir}${prefix}/bin/wpa_cli + install -Dm644 wpa_supplicant.conf ${dest_dir}/etc/wpa_supplicant.conf +} diff --git a/source-recipes/wpa-supplicant b/source-recipes/wpa-supplicant new file mode 100644 index 00000000..33f71bc5 --- /dev/null +++ b/source-recipes/wpa-supplicant @@ -0,0 +1,5 @@ +name=wpa-supplicant +version=2.12 +source_method=tarball +tarball_url="https://w1.fi/releases/wpa_supplicant-${version}.tar.gz" +tarball_sha512="5e996323fea2a5f6fefe4f2456481b9e8409adb5bf1d7a72d4489f3db2e3a968d6d9fe5cc0959b820f5b18faa330adb1245da98aad49631009609fbd0f447901"