void rsn_preauth_send(struct hostapd_data *hapd, struct sta_info *sta,
u8 *buf, size_t len)
{
struct rsn_preauth_interface *piface;
struct l2_ethhdr *ethhdr;
piface = hapd->preauth_iface;
while (piface) {
if (piface == sta->preauth_iface)
break;
piface = piface->next;
}
if (piface == NULL) {
HOSTAPD_DEBUG(HOSTAPD_DEBUG_MINIMAL, "RSN: Could not find "
"pre-authentication interface for " MACSTR "\n",
MAC2STR(sta->addr));
return;
}
ethhdr = malloc(sizeof(*ethhdr) + len);
if (ethhdr == NULL)
return;
memcpy(ethhdr->h_dest, sta->addr, ETH_ALEN);
memcpy(ethhdr->h_source, hapd->own_addr, ETH_ALEN);
ethhdr->h_proto = htons(ETH_P_PREAUTH);
memcpy(ethhdr + 1, buf, len);
if (l2_packet_send(piface->l2, sta->addr, ETH_P_PREAUTH, (u8 *) ethhdr,
sizeof(*ethhdr) + len) < 0) {
printf("Failed to send preauth packet using l2_packet_send\n");
}
free(ethhdr);
}
static void wpa_priv_cmd_l2_send(struct wpa_priv_interface *iface,
struct sockaddr_un *from,
void *buf, size_t len)
{
u8 *dst_addr;
u16 proto;
int res;
if (iface->l2 == NULL)
return;
if (len < ETH_ALEN + 2) {
wpa_printf(MSG_DEBUG, "Too short L2 send packet (len=%lu)",
(unsigned long) len);
return;
}
dst_addr = buf;
os_memcpy(&proto, buf + ETH_ALEN, 2);
if (proto != ETH_P_EAPOL && proto != ETH_P_RSN_PREAUTH) {
wpa_printf(MSG_DEBUG, "Refused l2_packet send for ethertype "
"0x%x", proto);
return;
}
res = l2_packet_send(iface->l2, dst_addr, proto, buf + ETH_ALEN + 2,
len - ETH_ALEN - 2);
wpa_printf(MSG_DEBUG, "L2 send: res=%d", res);
}
void rsn_preauth_send(struct asd_data *wasd, struct sta_info *sta,
u8 *buf, size_t len)
{
struct rsn_preauth_interface *piface;
struct l2_ethhdr *ethhdr;
piface = wasd->preauth_iface;
while (piface) {
if (piface == sta->preauth_iface)
break;
piface = piface->next;
}
if (piface == NULL) {
asd_printf(ASD_DEFAULT,MSG_DEBUG, "RSN: Could not find pre-authentication "
"interface for " MACSTR, MAC2STR(sta->addr));
return;
}
ethhdr = os_zalloc(sizeof(*ethhdr) + len);
if (ethhdr == NULL)
return;
os_memcpy(ethhdr->h_dest, sta->addr, ETH_ALEN);
os_memcpy(ethhdr->h_source, wasd->own_addr, ETH_ALEN);
ethhdr->h_proto = htons(ETH_P_PREAUTH);
os_memcpy(ethhdr + 1, buf, len);
if (l2_packet_send(piface->l2, sta->addr, ETH_P_PREAUTH, (u8 *) ethhdr,
sizeof(*ethhdr) + len) < 0) {
asd_printf(ASD_DEFAULT,MSG_ERROR, "Failed to send preauth packet using "
"l2_packet_send\n");
}
os_free(ethhdr);
}
static int rtl871x_send_mgmt_frame_ops(void *priv, const void *msg, size_t len,
int flags)
{
struct rtl871x_driver_data *drv = priv;
//struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)msg;
int res=0;
//printf("%s\n", __func__);
//hdr->frame_control |= host_to_le16(BIT(1));/* Request TX callback */
#ifdef CONFIG_MGNT_L2SOCK
//res = send(drv->mgnt_l2_sock, msg, len, flags);
//res = l2_packet_send(drv->mgnt_l2_sock, addr, ETH_P_EAPOL, msg, len);
if(drv->mgnt_l2_sock == NULL)
return res;
res = l2_packet_send(drv->mgnt_l2_sock, NULL, ETH_P_80211_RAW, msg, len);
#else
if(drv->mgnt_sock < 0)
return res;
res = send(drv->mgnt_sock, msg, len, flags);
#endif
//hdr->frame_control &= ~host_to_le16(BIT(1));
rtl871x_send_mgnt(drv, msg, len);
rtl871x_handle_tx_callback(drv->hapd, (u8*)msg, len, 1);
return res;
}
static int hostapd_wpa_auth_send_ether(void *ctx, const u8 *dst, u16 proto,
const u8 *data, size_t data_len)
{
struct hostapd_data *hapd = ctx;
struct l2_ethhdr *buf;
int ret;
#ifdef CONFIG_TESTING_OPTIONS
if (hapd->ext_eapol_frame_io && proto == ETH_P_EAPOL) {
size_t hex_len = 2 * data_len + 1;
char *hex = os_malloc(hex_len);
if (hex == NULL)
return -1;
wpa_snprintf_hex(hex, hex_len, data, data_len);
wpa_msg(hapd->msg_ctx, MSG_INFO, "EAPOL-TX " MACSTR " %s",
MAC2STR(dst), hex);
os_free(hex);
return 0;
}
#endif /* CONFIG_TESTING_OPTIONS */
#ifdef CONFIG_IEEE80211R
if (proto == ETH_P_RRB && hapd->iface->interfaces &&
hapd->iface->interfaces->for_each_interface) {
int res;
struct wpa_auth_ft_iface_iter_data idata;
idata.src_hapd = hapd;
idata.dst = dst;
idata.data = data;
idata.data_len = data_len;
res = hapd->iface->interfaces->for_each_interface(
hapd->iface->interfaces, hostapd_wpa_auth_ft_iter,
&idata);
if (res == 1)
return data_len;
}
#endif /* CONFIG_IEEE80211R */
if (hapd->driver && hapd->driver->send_ether)
return hapd->driver->send_ether(hapd->drv_priv, dst,
hapd->own_addr, proto,
data, data_len);
if (hapd->l2 == NULL)
return -1;
buf = os_malloc(sizeof(*buf) + data_len);
if (buf == NULL)
return -1;
os_memcpy(buf->h_dest, dst, ETH_ALEN);
os_memcpy(buf->h_source, hapd->own_addr, ETH_ALEN);
buf->h_proto = host_to_be16(proto);
os_memcpy(buf + 1, data, data_len);
ret = l2_packet_send(hapd->l2, dst, proto, (u8 *) buf,
sizeof(*buf) + data_len);
os_free(buf);
return ret;
}
/**
* wpa_ether_send - Send Ethernet frame
* @wpa_s: Pointer to wpa_supplicant data
* @dest: Destination MAC address
* @proto: Ethertype in host byte order
* @buf: Frame payload starting from IEEE 802.1X header
* @len: Frame payload length
* Returns: >=0 on success, <0 on failure
*/
static int wpa_ether_send(struct wpa_supplicant *wpa_s, const u8 *dest,
u16 proto, const u8 *buf, size_t len)
{
if (wpa_s->l2) {
return l2_packet_send(wpa_s->l2, dest, proto, buf, len);
}
return wpa_drv_send_eapol(wpa_s, dest, proto, buf, len);
}
/*wrapper definition for wapi interface*/
static int wpa_supplicant_tx_wai(void *ctx, const u8* pbuf, int length)
{
struct wpa_supplicant *wpa_s = (struct wpa_supplicant *)ctx;
int ret;
ret = l2_packet_send(wpa_s->l2_wai, wpa_s->bssid, ETH_P_WAI, (const u8*)pbuf, (unsigned int)length);
return ret;
}
static int
bsd_send_eapol(void *priv, const u8 *addr, const u8 *data, size_t data_len,
int encrypt, const u8 *own_addr, u32 flags)
{
struct bsd_driver_data *drv = priv;
wpa_hexdump(MSG_MSGDUMP, "TX EAPOL", data, data_len);
return l2_packet_send(drv->sock_xmit, addr, ETH_P_EAPOL, data,
data_len);
}
static int hostapd_wpa_auth_send_ether(void *ctx, const u8 *dst, u16 proto,
const u8 *data, size_t data_len)
{
struct hostapd_data *hapd = ctx;
if (hapd->driver && hapd->driver->send_ether)
return hapd->driver->send_ether(hapd->drv_priv, dst,
hapd->own_addr, proto,
data, data_len);
if (hapd->l2 == NULL)
return -1;
return l2_packet_send(hapd->l2, dst, proto, data, data_len);
}
unsigned long
WIFI_TX_packet(const char* pbuf, int length)
{
struct wpa_supplicant *wpa_s = g_wpa_s;
int ret;
ret = l2_packet_send(wpa_s->l2_wapi, wpa_s->bssid, ETH_P_WAI,
(const u8*)pbuf, (unsigned int)length);
if (ret >= 0) {
return 0;
} else {
return (unsigned long)ret;
}
}
static int supp_ether_send(void *ctx, const u8 *dest, u16 proto, const u8 *buf,
size_t len)
{
struct ibss_rsn_peer *peer = ctx;
struct wpa_supplicant *wpa_s = peer->ibss_rsn->wpa_s;
wpa_printf(MSG_DEBUG, "SUPP: %s(dest=" MACSTR " proto=0x%04x "
"len=%lu)",
__func__, MAC2STR(dest), proto, (unsigned long) len);
if (wpa_s->l2)
return l2_packet_send(wpa_s->l2, dest, proto, buf, len);
return wpa_drv_send_eapol(wpa_s, dest, proto, buf, len);
}
static int auth_send_eapol(void *ctx, const u8 *addr, const u8 *data,
size_t data_len, int encrypt)
{
struct ibss_rsn *ibss_rsn = ctx;
struct wpa_supplicant *wpa_s = ibss_rsn->wpa_s;
wpa_printf(MSG_DEBUG, "AUTH: %s(addr=" MACSTR " data_len=%lu "
"encrypt=%d)",
__func__, MAC2STR(addr), (unsigned long) data_len, encrypt);
if (wpa_s->l2)
return l2_packet_send(wpa_s->l2, addr, ETH_P_EAPOL, data,
data_len);
return wpa_drv_send_eapol(wpa_s, addr, ETH_P_EAPOL, data, data_len);
}
static int rtl871x_send_eapol_ops(void *priv, const u8 *addr, const u8 *data, size_t data_len,
int encrypt, const u8 *own_addr, u32 flags)
{
struct rtl871x_driver_data *drv = priv;
unsigned char buf[3000];
unsigned char *bp = buf;
struct l2_ethhdr *eth;
size_t len;
int status;
printf("+rtl871x_send_eapol\n");
/*
* Prepend the Ethernet header. If the caller left us
* space at the front we could just insert it but since
* we don't know we copy to a local buffer. Given the frequency
* and size of frames this probably doesn't matter.
*/
len = data_len + sizeof(struct l2_ethhdr);
if (len > sizeof(buf)) {
bp = malloc(len);
if (bp == NULL) {
printf("EAPOL frame discarded, cannot malloc temp "
"buffer of size %lu!\n", (unsigned long) len);
return -1;
}
}
eth = (struct l2_ethhdr *) bp;
memcpy(eth->h_dest, addr, ETH_ALEN);
memcpy(eth->h_source, own_addr, ETH_ALEN);
eth->h_proto = htons(ETH_P_EAPOL);
memcpy(eth+1, data, data_len);
wpa_hexdump(MSG_MSGDUMP, "TX EAPOL", bp, len);
status = l2_packet_send(drv->l2_sock, addr, ETH_P_EAPOL, bp, len);
if (bp != buf)
free(bp);
return status;
}
static int hostapd_wpa_auth_send_ether(void *ctx, const u8 *dst, u16 proto,
const u8 *data, size_t data_len)
{
struct hostapd_data *hapd = ctx;
struct l2_ethhdr *buf;
int ret;
#ifdef CONFIG_IEEE80211R
if (proto == ETH_P_RRB && hapd->iface->interfaces &&
hapd->iface->interfaces->for_each_interface) {
int res;
struct wpa_auth_ft_iface_iter_data idata;
idata.src_hapd = hapd;
idata.dst = dst;
idata.data = data;
idata.data_len = data_len;
res = hapd->iface->interfaces->for_each_interface(
hapd->iface->interfaces, hostapd_wpa_auth_ft_iter,
&idata);
if (res == 1)
return data_len;
}
#endif /* CONFIG_IEEE80211R */
if (hapd->driver && hapd->driver->send_ether)
return hapd->driver->send_ether(hapd->drv_priv, dst,
hapd->own_addr, proto,
data, data_len);
if (hapd->l2 == NULL)
return -1;
buf = os_malloc(sizeof(*buf) + data_len);
if (buf == NULL)
return -1;
os_memcpy(buf->h_dest, dst, ETH_ALEN);
os_memcpy(buf->h_source, hapd->own_addr, ETH_ALEN);
buf->h_proto = host_to_be16(proto);
os_memcpy(buf + 1, data, data_len);
ret = l2_packet_send(hapd->l2, dst, proto, (u8 *) buf,
sizeof(*buf) + data_len);
os_free(buf);
return ret;
}
static int
bsd_send_eapol(void *priv, u8 *addr, u8 *data, size_t data_len, int encrypt)
{
struct bsd_driver_data *drv = priv;
hostapd *hapd = drv->hapd;
unsigned char buf[3000];
unsigned char *bp = buf;
struct l2_ethhdr *eth;
size_t len;
int status;
/*
* Prepend the Etherent header. If the caller left us
* space at the front we could just insert it but since
* we don't know we copy to a local buffer. Given the frequency
* and size of frames this probably doesn't matter.
*/
len = data_len + sizeof(struct l2_ethhdr);
if (len > sizeof(buf)) {
bp = malloc(len);
if (bp == NULL) {
printf("EAPOL frame discarded, cannot malloc temp "
"buffer of size %u!\n", len);
return -1;
}
}
eth = (struct l2_ethhdr *) bp;
memcpy(eth->h_dest, addr, ETH_ALEN);
memcpy(eth->h_source, drv->hapd->own_addr, ETH_ALEN);
eth->h_proto = htons(ETH_P_EAPOL);
memcpy(eth+1, data, data_len);
if (HOSTAPD_DEBUG_COND(HOSTAPD_DEBUG_MSGDUMPS))
hostapd_hexdump("TX EAPOL", bp, len);
status = l2_packet_send(drv->sock_xmit, bp, len);
if (bp != buf)
free(bp);
return status;
}
static int rtl871x_send_mgmt_frame_ops(void *priv, const void *msg, size_t len,
int flags)
{
struct rtl871x_driver_data *drv = priv;
int res=0;
#ifdef CONFIG_MGNT_L2SOCK
if (drv->mgnt_l2_sock == NULL)
return res;
res = l2_packet_send(drv->mgnt_l2_sock, NULL, ETH_P_80211_RAW, msg, len);
#else
if (drv->mgnt_sock < 0)
return res;
res = send(drv->mgnt_sock, msg, len, flags);
#endif
rtl871x_send_mgnt(drv, msg, len);
rtl871x_handle_tx_callback(drv->hapd, (u8*)msg, len, 1);
return res;
}
/**
* wpa_ether_send - Send Ethernet frame
* @wpa_s: Pointer to wpa_supplicant data
* @dest: Destination MAC address
* @proto: Ethertype in host byte order
* @buf: Frame payload starting from IEEE 802.1X header
* @len: Frame payload length
* Returns: >=0 on success, <0 on failure
*/
static int wpa_ether_send(struct wpa_supplicant *wpa_s, const u8 *dest,
u16 proto, const u8 *buf, size_t len)
{
#ifdef CONFIG_TESTING_OPTIONS
if (wpa_s->ext_eapol_frame_io && proto == ETH_P_EAPOL) {
size_t hex_len = 2 * len + 1;
char *hex = os_malloc(hex_len);
if (hex == NULL)
return -1;
wpa_snprintf_hex(hex, hex_len, buf, len);
wpa_msg(wpa_s, MSG_INFO, "EAPOL-TX " MACSTR " %s",
MAC2STR(dest), hex);
os_free(hex);
return 0;
}
#endif /* CONFIG_TESTING_OPTIONS */
if (wpa_s->l2) {
return l2_packet_send(wpa_s->l2, dest, proto, buf, len);
}
return -1;
}
static int rsn_preauth_eapol_send(void *ctx, int type, const u8 *buf,
size_t len)
{
struct wpa_sm *sm = ctx;
u8 *msg;
size_t msglen;
int res;
/* TODO: could add l2_packet_sendmsg that allows fragments to avoid
* extra copy here */
if (sm->l2_preauth == NULL)
return -1;
msg = wpa_sm_alloc_eapol(sm, type, buf, len, &msglen, NULL);
if (msg == NULL)
return -1;
wpa_hexdump(MSG_MSGDUMP, "TX EAPOL (preauth)", msg, msglen);
res = l2_packet_send(sm->l2_preauth, sm->preauth_bssid,
ETH_P_RSN_PREAUTH, msg, msglen);
os_free(msg);
return res;
}
