size_t read_hwaddr_aton(uint8_t **data, const char *path) { FILE *fp; char *buf; size_t buf_len, len; ssize_t llen; if ((fp = fopen(path, "r")) == NULL) return 0; buf = NULL; buf_len = len = 0; *data = NULL; while ((llen = getline(&buf, &buf_len, fp)) != -1) { if ((len = hwaddr_aton(NULL, buf)) != 0) { if (buf_len >= len) *data = (uint8_t *)buf; else { if ((*data = malloc(len)) == NULL) len = 0; } if (len != 0) (void)hwaddr_aton(*data, buf); if (buf_len < len) free(buf); break; } } fclose(fp); return len; }
/* Based on the implementation here http://www.thegeekstuff.com/2012/10/packet-sniffing-using-libpcap*/ void* read_virtual_interface(){ //char *virtual_dev; char errbuf[PCAP_ERRBUF_SIZE]; struct bpf_program fp; /* to hold compiled program */ bpf_u_int32 pMask; /* subnet mask */ bpf_u_int32 pNet; /* ip address*/ //pcap_if_t *alldevs, *d; //char dev_buff[64] = {0}; printf("Malloc 1\n"); ep1_mac_addr = (u_char *)malloc(ETHER_ADDR_LEN * sizeof(u_char)); hwaddr_aton(ep1_hwaddr, ep1_mac_addr); printf("Malloc 2\n"); wlan_mac_addr = (u_char *)malloc(ETHER_ADDR_LEN * sizeof(u_char)); hwaddr_aton(wlan_hwaddr, wlan_mac_addr); printf("Malloc 3\n"); gateway_mac_addr = (u_char *)malloc(ETHER_ADDR_LEN *sizeof(u_char)); hwaddr_aton(gateway_hwaddr, gateway_mac_addr); ep1s_mac_addr = (u_char *)malloc(ETHER_ADDR_LEN * sizeof(u_char)); hwaddr_aton(ep1s_hwaddr, ep1s_mac_addr); //virtual_dev = "ep1s"; // fetch the network address and network mask pcap_lookupnet(virtual_dev, &pNet, &pMask, errbuf); // Now, open device for sniffing ep1s_descr = pcap_open_live(virtual_dev, BUFSIZ, 0,-1, errbuf); if(ep1s_descr == NULL) { printf("pcap_open_live() failed due to [%s]\n", errbuf); exit(1); } // Compile the filter expression if(pcap_compile(ep1s_descr, &fp, '\0', 0, pNet) == -1) { printf("\npcap_compile() failed\n"); exit(1); } // Set the filter compiled above if(pcap_setfilter(ep1s_descr, &fp) == -1) { printf("\npcap_setfilter() failed\n"); exit(1); } // For every packet received, call the callback function // For now, maximum limit on number of packets is specified // by user. pcap_loop(ep1s_descr, -1, callback, NULL); pcap_close(ep1s_descr); printf("\nDone with packet sniffing on ep1s!\n"); return 0; }
static int bgscan_learn_load(struct bgscan_learn_data *data) { FILE *f; char buf[128]; struct bgscan_learn_bss *bss; if (data->fname == NULL) { return 0; } f = fopen(data->fname, "r"); if (f == NULL) { return 0; } wpa_printf(MSG_DEBUG, "bgscan learn: Loading data from %s", data->fname); if (fgets(buf, sizeof(buf), f) == NULL || os_strncmp(buf, "wpa_supplicant-bgscan-learn\n", 28) != 0) { wpa_printf(MSG_INFO, "bgscan learn: Invalid data file %s", data->fname); fclose(f); return -1; } while (fgets(buf, sizeof(buf), f)) { if (os_strncmp(buf, "BSS ", 4) == 0) { bss = os_zalloc(sizeof(*bss)); if (!bss) { continue; } if (hwaddr_aton(buf + 4, bss->bssid) < 0) { bss_free(bss); continue; } bss->freq = atoi(buf + 4 + 18); dl_list_add(&data->bss, &bss->list); wpa_printf(MSG_DEBUG, "bgscan learn: Loaded BSS " "entry: " MACSTR " freq=%d", MAC2STR(bss->bssid), bss->freq); } if (os_strncmp(buf, "NEIGHBOR ", 9) == 0) { u8 addr[ETH_ALEN]; if (hwaddr_aton(buf + 9, addr) < 0) { continue; } bss = bgscan_learn_get_bss(data, addr); if (bss == NULL) { continue; } if (hwaddr_aton(buf + 9 + 18, addr) < 0) { continue; } bgscan_learn_add_neighbor(bss, addr); } } fclose(f); return 0; }
static int cmd_get_sta_counter(int s, int argc, char *argv[]) { u8 resp[WLANTEST_CTRL_MAX_RESP_LEN]; u8 buf[100], *end, *pos; int rlen, i; size_t len; if (argc != 3) { printf("get_sta_counter needs at three arguments: " "counter name, BSSID, and STA address\n"); return -1; } pos = buf; end = buf + sizeof(buf); WPA_PUT_BE32(pos, WLANTEST_CTRL_GET_STA_COUNTER); pos += 4; for (i = 0; sta_counters[i].name; i++) { if (os_strcasecmp(sta_counters[i].name, argv[0]) == 0) break; } if (sta_counters[i].name == NULL) { printf("Unknown STA counter '%s'\n", argv[0]); printf("Counters:"); for (i = 0; sta_counters[i].name; i++) printf(" %s", sta_counters[i].name); printf("\n"); return -1; } pos = attr_add_be32(pos, end, WLANTEST_ATTR_STA_COUNTER, sta_counters[i].num); pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN); if (hwaddr_aton(argv[1], pos) < 0) { printf("Invalid BSSID '%s'\n", argv[1]); return -1; } pos += ETH_ALEN; pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN); if (hwaddr_aton(argv[2], pos) < 0) { printf("Invalid STA address '%s'\n", argv[2]); return -1; } pos += ETH_ALEN; rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp)); if (rlen < 0) return -1; pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_COUNTER, &len); if (pos == NULL || len != 4) return -1; printf("%u\n", WPA_GET_BE32(pos)); return 0; }
static void madwifi_wireless_event_wireless_custom(struct madwifi_driver_data *drv, char *custom) { wpa_printf(MSG_DEBUG, "Custom wireless event: '%s'", custom); if (strncmp(custom, "MLME-MICHAELMICFAILURE.indication", 33) == 0) { char *pos; u8 addr[ETH_ALEN]; pos = strstr(custom, "addr="); if (pos == NULL) { wpa_printf(MSG_DEBUG, "MLME-MICHAELMICFAILURE.indication " "without sender address ignored"); return; } pos += 5; if (hwaddr_aton(pos, addr) == 0) { union wpa_event_data data; os_memset(&data, 0, sizeof(data)); data.michael_mic_failure.unicast = 1; data.michael_mic_failure.src = addr; wpa_supplicant_event(drv->hapd, EVENT_MICHAEL_MIC_FAILURE, &data); } else { wpa_printf(MSG_DEBUG, "MLME-MICHAELMICFAILURE.indication " "with invalid MAC address"); } } else if (strncmp(custom, "STA-TRAFFIC-STAT", 16) == 0) { char *key, *value; u32 val; key = custom; while ((key = strchr(key, '\n')) != NULL) { key++; value = strchr(key, '='); if (value == NULL) continue; *value++ = '\0'; val = strtoul(value, NULL, 10); if (strcmp(key, "mac") == 0) hwaddr_aton(value, drv->acct_mac); else if (strcmp(key, "rx_packets") == 0) drv->acct_data.rx_packets = val; else if (strcmp(key, "tx_packets") == 0) drv->acct_data.tx_packets = val; else if (strcmp(key, "rx_bytes") == 0) drv->acct_data.rx_bytes = val; else if (strcmp(key, "tx_bytes") == 0) drv->acct_data.tx_bytes = val; key = value; } } }
static void wext_wireless_event_wireless_custom(struct wext_driver_data *drv, char *custom) { struct hostapd_data *hapd = drv->hapd; wpa_printf(MSG_DEBUG, "Custom wireless event: '%s'\n", custom); if (strncmp(custom, "MLME-MICHAELMICFAILURE.indication", 33) == 0) { char *pos; u8 addr[ETH_ALEN]; pos = strstr(custom, "addr="); if (pos == NULL) { wpa_printf(MSG_DEBUG, "MLME-MICHAELMICFAILURE.indication " "without sender address ignored\n"); return; } pos += 5; if (hwaddr_aton(pos, addr) == 0) { ieee80211_michael_mic_failure(drv->hapd, addr, 1); } else { wpa_printf(MSG_DEBUG, "MLME-MICHAELMICFAILURE.indication " "with invalid MAC address"); } } else if (strncmp(custom, "STA-TRAFFIC-STAT", 16) == 0) { char *key, *value; u32 val; key = custom; while ((key = strchr(key, '\n')) != NULL) { key++; value = strchr(key, '='); if (value == NULL) continue; *value++ = '\0'; val = strtoul(value, NULL, 10); if (strcmp(key, "mac") == 0) hwaddr_aton(value, drv->acct_mac); else if (strcmp(key, "rx_packets") == 0) drv->acct_data.rx_packets = val; else if (strcmp(key, "tx_packets") == 0) drv->acct_data.tx_packets = val; else if (strcmp(key, "rx_bytes") == 0) drv->acct_data.rx_bytes = val; else if (strcmp(key, "tx_bytes") == 0) drv->acct_data.tx_bytes = val; key = value; } } }
static int cmd_clear_tdls_counters(int s, int argc, char *argv[]) { u8 resp[WLANTEST_CTRL_MAX_RESP_LEN]; u8 buf[100], *pos; int rlen; if (argc < 3) { printf("clear_tdls_counters needs three arguments: BSSID, " "STA1 address, STA2 address\n"); return -1; } pos = buf; WPA_PUT_BE32(pos, WLANTEST_CTRL_CLEAR_TDLS_COUNTERS); pos += 4; WPA_PUT_BE32(pos, WLANTEST_ATTR_BSSID); pos += 4; WPA_PUT_BE32(pos, ETH_ALEN); pos += 4; if (hwaddr_aton(argv[0], pos) < 0) { printf("Invalid BSSID '%s'\n", argv[0]); return -1; } pos += ETH_ALEN; WPA_PUT_BE32(pos, WLANTEST_ATTR_STA_ADDR); pos += 4; WPA_PUT_BE32(pos, ETH_ALEN); pos += 4; if (hwaddr_aton(argv[1], pos) < 0) { printf("Invalid STA1 address '%s'\n", argv[1]); return -1; } pos += ETH_ALEN; WPA_PUT_BE32(pos, WLANTEST_ATTR_STA2_ADDR); pos += 4; WPA_PUT_BE32(pos, ETH_ALEN); pos += 4; if (hwaddr_aton(argv[2], pos) < 0) { printf("Invalid STA2 address '%s'\n", argv[2]); return -1; } pos += ETH_ALEN; rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp)); if (rlen < 0) return -1; printf("OK\n"); return 0; }
static int hostapd_ctrl_iface_new_sta(struct hostapd_data *hapd, const char *txtaddr) { u8 addr[ETH_ALEN]; struct sta_info *sta; wpa_printf(MSG_DEBUG, "CTRL_IFACE NEW_STA %s", txtaddr); if (hwaddr_aton(txtaddr, addr)) return -1; sta = ap_get_sta(hapd, addr); if (sta) return 0; wpa_printf(MSG_DEBUG, "Add new STA " MACSTR " based on ctrl_iface " "notification", MAC2STR(addr)); sta = ap_sta_add(hapd, addr); if (sta == NULL) return -1; hostapd_new_assoc_sta(hapd, sta, 0); accounting_sta_get_id(hapd, sta); return 0; }
static void hostapd_wireless_event_wireless_custom(struct hostap_driver_data *drv, char *custom) { wpa_printf(MSG_DEBUG, "Custom wireless event: '%s'", custom); if (strncmp(custom, "MLME-MICHAELMICFAILURE.indication", 33) == 0) { char *pos; u8 addr[ETH_ALEN]; pos = strstr(custom, "addr="); if (pos == NULL) { wpa_printf(MSG_DEBUG, "MLME-MICHAELMICFAILURE.indication " "without sender address ignored"); return; } pos += 5; if (hwaddr_aton(pos, addr) == 0) { union wpa_event_data data; os_memset(&data, 0, sizeof(data)); data.michael_mic_failure.unicast = 1; data.michael_mic_failure.src = addr; wpa_supplicant_event(drv->hapd, EVENT_MICHAEL_MIC_FAILURE, &data); } else { wpa_printf(MSG_DEBUG, "MLME-MICHAELMICFAILURE.indication " "with invalid MAC address"); } } }
/** * wpas_dbus_iface_wps_pbc - Request credentials using WPS PBC method * @message: Pointer to incoming dbus message * @wpa_s: %wpa_supplicant data structure * Returns: A dbus message containing a UINT32 indicating success (1) or * failure (0) * * Handler function for "wpsPbc" method call */ DBusMessage * wpas_dbus_iface_wps_pbc(DBusMessage *message, struct wpa_supplicant *wpa_s) { char *arg_bssid = NULL; u8 bssid[ETH_ALEN]; int ret = 0; if (!dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &arg_bssid, DBUS_TYPE_INVALID)) return wpas_dbus_new_invalid_opts_error(message, NULL); if (!os_strcmp(arg_bssid, "any")) ret = wpas_wps_start_pbc(wpa_s, NULL, 0); else if (!hwaddr_aton(arg_bssid, bssid)) ret = wpas_wps_start_pbc(wpa_s, bssid, 0); else { return wpas_dbus_new_invalid_opts_error(message, "Invalid BSSID"); } if (ret < 0) { return dbus_message_new_error(message, WPAS_ERROR_WPS_PBC_ERROR, "Could not start PBC " "negotiation"); } return wpas_dbus_new_success_reply(message); }
static int wpa_supplicant_ctrl_iface_bssid(struct wpa_supplicant *wpa_s, char *cmd) { char *pos; int id; struct wpa_ssid *ssid; u8 bssid[ETH_ALEN]; /* cmd: "<network id> <BSSID>" */ pos = os_strchr(cmd, ' '); if (pos == NULL) return -1; *pos++ = '\0'; id = atoi(cmd); wpa_printf(MSG_DEBUG, "CTRL_IFACE: id=%d bssid='%s'", id, pos); if (hwaddr_aton(pos, bssid)) { wpa_printf(MSG_DEBUG ,"CTRL_IFACE: invalid BSSID '%s'", pos); return -1; } ssid = wpa_config_get_network(wpa_s->conf, id); if (ssid == NULL) { wpa_printf(MSG_DEBUG, "CTRL_IFACE: Could not find SSID id=%d " "to update", id); return -1; } os_memcpy(ssid->bssid, bssid, ETH_ALEN); ssid->bssid_set = os_memcmp(bssid, "\x00\x00\x00\x00\x00\x00", ETH_ALEN) != 0; return 0; }
static int cmd_clear_bss_counters(int s, int argc, char *argv[]) { u8 resp[WLANTEST_CTRL_MAX_RESP_LEN]; u8 buf[100], *pos; int rlen; if (argc < 1) { printf("clear_bss_counters needs one argument: BSSID\n"); return -1; } pos = buf; WPA_PUT_BE32(pos, WLANTEST_CTRL_CLEAR_BSS_COUNTERS); pos += 4; WPA_PUT_BE32(pos, WLANTEST_ATTR_BSSID); pos += 4; WPA_PUT_BE32(pos, ETH_ALEN); pos += 4; if (hwaddr_aton(argv[0], pos) < 0) { printf("Invalid BSSID '%s'\n", argv[0]); return -1; } pos += ETH_ALEN; rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp)); if (rlen < 0) return -1; printf("OK\n"); return 0; }
static void hostapd_wireless_event_wireless_custom(struct hostap_driver_data *drv, char *custom) { wpa_printf(MSG_DEBUG, "Custom wireless event: '%s'", custom); if (strncmp(custom, "MLME-MICHAELMICFAILURE.indication", 33) == 0) { char *pos; u8 addr[ETH_ALEN]; pos = strstr(custom, "addr="); if (pos == NULL) { wpa_printf(MSG_DEBUG, "MLME-MICHAELMICFAILURE.indication " "without sender address ignored"); return; } pos += 5; if (hwaddr_aton(pos, addr) == 0) { ieee80211_michael_mic_failure(drv->hapd, addr, 1); } else { wpa_printf(MSG_DEBUG, "MLME-MICHAELMICFAILURE.indication " "with invalid MAC address"); } } }
static int hostapd_config_read_maclist(const char *fname, macaddr **acl, int *num) { FILE *f; char buf[128], *pos; int line = 0; u8 addr[ETH_ALEN]; macaddr *newacl; if (!fname) return 0; f = fopen(fname, "r"); if (!f) { printf("MAC list file '%s' not found.\n", fname); return -1; } while (fgets(buf, sizeof(buf), f)) { line++; if (buf[0] == '#') continue; pos = buf; while (*pos != '\0') { if (*pos == '\n') { *pos = '\0'; break; } pos++; } if (buf[0] == '\0') continue; if (hwaddr_aton(buf, addr)) { printf("Invalid MAC address '%s' at line %d in '%s'\n", buf, line, fname); fclose(f); return -1; } newacl = (macaddr *) realloc(*acl, (*num + 1) * ETH_ALEN); if (newacl == NULL) { printf("MAC list reallocation failed\n"); fclose(f); return -1; } *acl = newacl; memcpy((*acl)[*num], addr, ETH_ALEN); (*num)++; } fclose(f); qsort(*acl, *num, sizeof(macaddr), mac_comp); return 0; }
int hostapd_ctrl_iface_disassociate(struct hostapd_data *hapd, const char *txtaddr) { u8 addr[ETH_ALEN]; struct sta_info *sta; const char *pos; u16 reason = WLAN_REASON_PREV_AUTH_NOT_VALID; wpa_dbg(hapd->msg_ctx, MSG_DEBUG, "CTRL_IFACE DISASSOCIATE %s", txtaddr); if (hwaddr_aton(txtaddr, addr)) return -1; pos = os_strstr(txtaddr, " test="); if (pos) { struct ieee80211_mgmt mgmt; int encrypt; if (hapd->driver->send_frame == NULL) return -1; pos += 6; encrypt = atoi(pos); os_memset(&mgmt, 0, sizeof(mgmt)); mgmt.frame_control = IEEE80211_FC(WLAN_FC_TYPE_MGMT, WLAN_FC_STYPE_DISASSOC); os_memcpy(mgmt.da, addr, ETH_ALEN); os_memcpy(mgmt.sa, hapd->own_addr, ETH_ALEN); os_memcpy(mgmt.bssid, hapd->own_addr, ETH_ALEN); mgmt.u.disassoc.reason_code = host_to_le16(WLAN_REASON_PREV_AUTH_NOT_VALID); if (hapd->driver->send_frame(hapd->drv_priv, (u8 *) &mgmt, IEEE80211_HDRLEN + sizeof(mgmt.u.deauth), encrypt) < 0) return -1; return 0; } #ifdef CONFIG_P2P_MANAGER pos = os_strstr(txtaddr, " p2p="); if (pos) { return p2p_manager_disconnect(hapd, WLAN_FC_STYPE_DISASSOC, atoi(pos + 5), addr); } #endif /* CONFIG_P2P_MANAGER */ pos = os_strstr(txtaddr, " reason="); if (pos) reason = atoi(pos + 8); hostapd_drv_sta_disassoc(hapd, addr, reason); sta = ap_get_sta(hapd, addr); if (sta) ap_sta_disassociate(hapd, sta, reason); else if (addr[0] == 0xff) hostapd_free_stas(hapd); return 0; }
size_t get_duid(unsigned char *duid, const struct interface *ifp) { FILE *f; int x = 0; size_t len = 0; char *line; /* If we already have a DUID then use it as it's never supposed * to change once we have one even if the interfaces do */ if ((f = fopen(DUID, "r"))) { while ((line = get_line(f))) { len = hwaddr_aton(NULL, line); if (len && len <= DUID_LEN) { hwaddr_aton(duid, line); break; } len = 0; } fclose(f); if (len) return len; } else { if (errno != ENOENT) { syslog(LOG_ERR, "error reading DUID: %s: %m", DUID); return make_duid(duid, ifp, DUID_LL); } } /* No file? OK, lets make one based on our interface */ if (!(f = fopen(DUID, "w"))) { syslog(LOG_ERR, "error writing DUID: %s: %m", DUID); return make_duid(duid, ifp, DUID_LL); } len = make_duid(duid, ifp, DUID_LLT); x = fprintf(f, "%s\n", hwaddr_ntoa(duid, len)); fclose(f); /* Failed to write the duid? scrub it, we cannot use it */ if (x < 1) { syslog(LOG_ERR, "error writing DUID: %s: %m", DUID); unlink(DUID); return make_duid(duid, ifp, DUID_LL); } return len; }
static enum http_reply_code web_process_put_wlan_response(struct upnp_wps_device_sm *sm, char *data, struct wpabuf **reply, const char **replyname) { struct wpabuf *msg; enum http_reply_code ret; u8 macaddr[ETH_ALEN]; int ev_type; int type; char *val; /* * External UPnP-based Registrar is passing us a message to be proxied * over to a Wi-Fi -based client of ours. */ wpa_printf(MSG_DEBUG, "WPS UPnP: PutWLANResponse"); msg = xml_get_base64_item(data, "NewMessage", &ret); if (msg == NULL) return ret; val = xml_get_first_item(data, "NewWLANEventType"); if (val == NULL) { wpabuf_free(msg); return UPNP_ARG_VALUE_INVALID; } ev_type = atol(val); os_free(val); val = xml_get_first_item(data, "NewWLANEventMAC"); if (val == NULL || hwaddr_aton(val, macaddr)) { wpabuf_free(msg); os_free(val); return UPNP_ARG_VALUE_INVALID; } os_free(val); if (ev_type == UPNP_WPS_WLANEVENT_TYPE_EAP) { struct wps_parse_attr attr; if (wps_parse_msg(msg, &attr) < 0 || attr.msg_type == NULL) type = -1; else type = *attr.msg_type; wpa_printf(MSG_DEBUG, "WPS UPnP: Message Type %d", type); } else type = -1; if (!sm->ctx->rx_req_put_wlan_response || sm->ctx->rx_req_put_wlan_response(sm->priv, ev_type, macaddr, msg, type)) { wpa_printf(MSG_INFO, "WPS UPnP: Fail: sm->ctx->" "rx_req_put_wlan_response"); wpabuf_free(msg); return HTTP_INTERNAL_SERVER_ERROR; } wpabuf_free(msg); *replyname = NULL; *reply = NULL; return HTTP_OK; }
static int cmd_get_rx_tid(int s, int argc, char *argv[]) { u8 resp[WLANTEST_CTRL_MAX_RESP_LEN]; u8 buf[100], *end, *pos; int rlen; size_t len; if (argc != 3) { printf("get_tx_tid needs three arguments: " "BSSID, STA address, and TID\n"); return -1; } pos = buf; end = buf + sizeof(buf); WPA_PUT_BE32(pos, WLANTEST_CTRL_GET_RX_TID); pos += 4; pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN); if (hwaddr_aton(argv[0], pos) < 0) { printf("Invalid BSSID '%s'\n", argv[0]); return -1; } pos += ETH_ALEN; pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN); if (hwaddr_aton(argv[1], pos) < 0) { printf("Invalid STA address '%s'\n", argv[1]); return -1; } pos += ETH_ALEN; pos = attr_add_be32(pos, end, WLANTEST_ATTR_TID, atoi(argv[2])); rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp)); if (rlen < 0) return -1; pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_COUNTER, &len); if (pos == NULL || len != 4) return -1; printf("%u\n", WPA_GET_BE32(pos)); return 0; }
void cli_txt_list_del_addr(struct dl_list *txt_list, const char *txt) { u8 addr[ETH_ALEN]; char buf[18]; if (hwaddr_aton(txt, addr) < 0) return; os_snprintf(buf, sizeof(buf), MACSTR, MAC2STR(addr)); cli_txt_list_del(txt_list, buf); }
static int cmd_info_bss(int s, int argc, char *argv[]) { u8 resp[WLANTEST_CTRL_MAX_RESP_LEN]; u8 buf[100], *end, *pos; int rlen, i; size_t len; char info[100]; if (argc != 2) { printf("bss_info needs at two arguments: " "field name and BSSID\n"); return -1; } pos = buf; end = buf + sizeof(buf); WPA_PUT_BE32(pos, WLANTEST_CTRL_INFO_BSS); pos += 4; for (i = 0; bss_infos[i].name; i++) { if (os_strcasecmp(bss_infos[i].name, argv[0]) == 0) break; } if (bss_infos[i].name == NULL) { printf("Unknown BSS info '%s'\n", argv[0]); printf("Info fields:"); for (i = 0; bss_infos[i].name; i++) printf(" %s", bss_infos[i].name); printf("\n"); return -1; } pos = attr_add_be32(pos, end, WLANTEST_ATTR_BSS_INFO, bss_infos[i].num); pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN); if (hwaddr_aton(argv[1], pos) < 0) { printf("Invalid BSSID '%s'\n", argv[1]); return -1; } pos += ETH_ALEN; rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp)); if (rlen < 0) return -1; pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_INFO, &len); if (pos == NULL) return -1; if (len >= sizeof(info)) len = sizeof(info) - 1; os_memcpy(info, pos, len); info[len] = '\0'; printf("%s\n", info); return 0; }
static int hostapd_ctrl_iface_sta(struct hostapd_data *hapd, const char *txtaddr, char *buf, size_t buflen) { u8 addr[ETH_ALEN]; if (hwaddr_aton(txtaddr, addr)) return snprintf(buf, buflen, "FAIL\n"); return hostapd_ctrl_iface_sta_mib(hapd, ap_get_sta(hapd, addr), buf, buflen); }
static int wpa_config_parse_bssid(struct parse_data *data, int line, const char *value) { if (hwaddr_aton(value, data->ssid->bssid)) { wpa_printf(MSG_ERROR, "Line %d: Invalid BSSID '%s'.", line, value); return -1; } data->ssid->bssid_set = 1; wpa_hexdump(MSG_MSGDUMP, "BSSID", data->ssid->bssid, ETH_ALEN); return 0; }
static int wpa_supplicant_ctrl_iface_blacklist( struct wpa_supplicant *wpa_s, char *cmd, char *buf, size_t buflen) { struct wpa_ssid *ssid; u8 bssid[ETH_ALEN]; struct wpa_blacklist *e; char *pos, *end; int ret; /* cmd: "BLACKLIST [<BSSID>]" */ if (*cmd == '\0') { pos = buf; end = buf + buflen; e = wpa_s->blacklist; while (e) { ret = os_snprintf(pos, end-pos, "%02x:%02x:%02x:%02x:%02x:%02x\n", e->bssid[0], e->bssid[1], e->bssid[2], e->bssid[3], e->bssid[4], e->bssid[5]); if (ret < 0 || ret >= end - pos) return pos - buf; pos += ret; e = e->next; } return pos - buf; } wpa_printf(MSG_DEBUG, "CTRL_IFACE: bssid='%s'", cmd); ++cmd; if (os_strncmp(cmd, "clear", 5) == 0) { wpa_blacklist_clear(wpa_s); return 0; } if (hwaddr_aton(cmd, bssid)) { wpa_printf(MSG_DEBUG ,"CTRL_IFACE: invalid BSSID '%s'", cmd); return -1; } /* * Add the BSSID twice, so its count will be 2, causing it to be * skipped when processing scan results. */ ret = wpa_blacklist_add(wpa_s, bssid); if (ret != 0) return ret; return wpa_blacklist_add(wpa_s, bssid); }
static int hostapd_ctrl_iface_sta_next(struct hostapd_data *hapd, const char *txtaddr, char *buf, size_t buflen) { u8 addr[ETH_ALEN]; struct sta_info *sta; if (hwaddr_aton(txtaddr, addr) || (sta = ap_get_sta(hapd, addr)) == NULL) return snprintf(buf, buflen, "FAIL\n"); return hostapd_ctrl_iface_sta_mib(hapd, sta->next, buf, buflen); }
/** * wpas_dbus_iface_wps_pin - Establish the PIN number of the enrollee * @message: Pointer to incoming dbus message * @wpa_s: %wpa_supplicant data structure * Returns: A dbus message containing a UINT32 indicating success (1) or * failure (0) * * Handler function for "wpsPin" method call */ DBusMessage * wpas_dbus_iface_wps_pin(DBusMessage *message, struct wpa_supplicant *wpa_s) { DBusMessage *reply = NULL; char *arg_bssid; char *pin = NULL; u8 bssid[ETH_ALEN], *_bssid = NULL; int ret = 0; if (!dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &arg_bssid, DBUS_TYPE_STRING, &pin, DBUS_TYPE_INVALID)) return wpas_dbus_new_invalid_opts_error(message, NULL); if (!os_strcmp(arg_bssid, "any")) _bssid = NULL; else if (!hwaddr_aton(arg_bssid, bssid)) _bssid = bssid; else { return wpas_dbus_new_invalid_opts_error(message, "Invalid BSSID"); } if (os_strlen(pin) > 0) ret = wpas_wps_start_pin(wpa_s, _bssid, pin, 0, DEV_PW_DEFAULT); else ret = wpas_wps_start_pin(wpa_s, _bssid, NULL, 0, DEV_PW_DEFAULT); if (ret < 0) { return dbus_message_new_error(message, WPAS_ERROR_WPS_PIN_ERROR, "Could not init PIN"); } reply = dbus_message_new_method_return(message); if (reply == NULL) return NULL; if (ret == 0) { dbus_message_append_args(reply, DBUS_TYPE_STRING, &pin, DBUS_TYPE_INVALID); } else { char npin[9]; os_snprintf(npin, sizeof(npin), "%08d", ret); dbus_message_append_args(reply, DBUS_TYPE_STRING, &npin, DBUS_TYPE_INVALID); } return reply; }
static int wpa_supplicant_ctrl_iface_ft_ds( struct wpa_supplicant *wpa_s, char *addr) { u8 target_ap[ETH_ALEN]; if (hwaddr_aton(addr, target_ap)) { wpa_printf(MSG_DEBUG, "CTRL_IFACE FT_DS: invalid " "address '%s'", target_ap); return -1; } wpa_printf(MSG_DEBUG, "CTRL_IFACE FT_DS " MACSTR, MAC2STR(target_ap)); return wpa_ft_start_over_ds(wpa_s->wpa, target_ap); }
int hostapd_ctrl_iface_sta(struct hostapd_data *hapd, const char *txtaddr, char *buf, size_t buflen) { u8 addr[ETH_ALEN]; int ret; if (hwaddr_aton(txtaddr, addr)) { ret = os_snprintf(buf, buflen, "FAIL\n"); if (ret < 0 || (size_t) ret >= buflen) return 0; return ret; } return hostapd_ctrl_iface_sta_mib(hapd, ap_get_sta(hapd, addr), buf, buflen); }
/* MLME-STKSTART.request(peer) */ static int wpa_supplicant_ctrl_iface_stkstart( struct wpa_supplicant *wpa_s, char *addr) { u8 peer[ETH_ALEN]; if (hwaddr_aton(addr, peer)) { wpa_printf(MSG_DEBUG, "CTRL_IFACE STKSTART: invalid " "address '%s'", peer); return -1; } wpa_printf(MSG_DEBUG, "CTRL_IFACE STKSTART " MACSTR, MAC2STR(peer)); return wpa_sm_stkstart(wpa_s->wpa, peer); }
static int wpa_supplicant_ctrl_iface_wps_pbc(struct wpa_supplicant *wpa_s, char *cmd) { u8 bssid[ETH_ALEN]; if (cmd == NULL || os_strcmp(cmd, "any") == 0) return wpas_wps_start_pbc(wpa_s, NULL); if (hwaddr_aton(cmd, bssid)) { wpa_printf(MSG_DEBUG, "CTRL_IFACE WPS_PBC: invalid BSSID '%s'", cmd); return -1; } return wpas_wps_start_pbc(wpa_s, bssid); }
static int hostapd_ctrl_iface_sa_query(struct hostapd_data *hapd, const char *txtaddr) { u8 addr[ETH_ALEN]; u8 trans_id[WLAN_SA_QUERY_TR_ID_LEN]; wpa_printf(MSG_DEBUG, "CTRL_IFACE SA_QUERY %s", txtaddr); if (hwaddr_aton(txtaddr, addr)) return -1; os_get_random(trans_id, WLAN_SA_QUERY_TR_ID_LEN); ieee802_11_send_sa_query_req(hapd, addr, trans_id); return 0; }