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; }