static int hostapd_cli_cmd_bss_tm_req(struct wpa_ctrl *ctrl, int argc, char *argv[]) { char buf[2000], *tmp; int res, i, total; if (argc < 1) { printf("Invalid 'bss_tm_req' command - at least one argument (STA addr) is needed\n"); return -1; } res = os_snprintf(buf, sizeof(buf), "BSS_TM_REQ %s", argv[0]); if (os_snprintf_error(sizeof(buf), res)) return -1; total = res; for (i = 1; i < argc; i++) { tmp = &buf[total]; res = os_snprintf(tmp, sizeof(buf) - total, " %s", argv[i]); if (os_snprintf_error(sizeof(buf) - total, res)) return -1; total += res; } return wpa_ctrl_command(ctrl, buf); }
/** * pmksa_cache_auth_list - Dump text list of entries in PMKSA cache * @pmksa: Pointer to PMKSA cache data from pmksa_cache_auth_init() * @buf: Buffer for the list * @len: Length of the buffer * Returns: Number of bytes written to buffer * * This function is used to generate a text format representation of the * current PMKSA cache contents for the ctrl_iface PMKSA command. */ int pmksa_cache_auth_list(struct rsn_pmksa_cache *pmksa, char *buf, size_t len) { int i, ret; char *pos = buf; struct rsn_pmksa_cache_entry *entry; struct os_reltime now; os_get_reltime(&now); ret = os_snprintf(pos, buf + len - pos, "Index / SPA / PMKID / expiration (in seconds) / opportunistic\n"); if (os_snprintf_error(buf + len - pos, ret)) return pos - buf; pos += ret; i = 0; entry = pmksa->pmksa; while (entry) { ret = os_snprintf(pos, buf + len - pos, "%d " MACSTR " ", i, MAC2STR(entry->spa)); if (os_snprintf_error(buf + len - pos, ret)) return pos - buf; pos += ret; pos += wpa_snprintf_hex(pos, buf + len - pos, entry->pmkid, PMKID_LEN); ret = os_snprintf(pos, buf + len - pos, " %d %d\n", (int) (entry->expiration - now.sec), entry->opportunistic); if (os_snprintf_error(buf + len - pos, ret)) return pos - buf; pos += ret; entry = entry->next; } return pos - buf; }
int wpa_supplicant_ap_wps_pin(struct wpa_supplicant *wpa_s, const u8 *bssid, const char *pin, char *buf, size_t buflen, int timeout) { int ret, ret_len = 0; if (!wpa_s->ap_iface) return -1; if (pin == NULL) { unsigned int rpin; if (wps_generate_pin(&rpin) < 0) return -1; ret_len = os_snprintf(buf, buflen, "%08d", rpin); if (os_snprintf_error(buflen, ret_len)) return -1; pin = buf; } else if (buf) { ret_len = os_snprintf(buf, buflen, "%s", pin); if (os_snprintf_error(buflen, ret_len)) return -1; } ret = hostapd_wps_add_pin(wpa_s->ap_iface->bss[0], bssid, "any", pin, timeout); if (ret) return -1; return ret_len; }
static int write_cmd(char *buf, size_t buflen, const char *cmd, int argc, char *argv[]) { int i, res; char *pos, *end; pos = buf; end = buf + buflen; res = os_snprintf(pos, end - pos, "%s", cmd); if (os_snprintf_error(end - pos, res)) goto fail; pos += res; for (i = 0; i < argc; i++) { res = os_snprintf(pos, end - pos, " %s", argv[i]); if (os_snprintf_error(end - pos, res)) goto fail; pos += res; } buf[buflen - 1] = '\0'; return 0; fail: printf("Too long command\n"); return -1; }
void p2p_channels_dump(struct p2p_data *p2p, const char *title, const struct p2p_channels *chan) { char buf[500], *pos, *end; size_t i, j; int ret; pos = buf; end = pos + sizeof(buf); for (i = 0; i < chan->reg_classes; i++) { const struct p2p_reg_class *c; c = &chan->reg_class[i]; ret = os_snprintf(pos, end - pos, " %u:", c->reg_class); if (os_snprintf_error(end - pos, ret)) break; pos += ret; for (j = 0; j < c->channels; j++) { ret = os_snprintf(pos, end - pos, "%s%u", j == 0 ? "" : ",", c->channel[j]); if (os_snprintf_error(end - pos, ret)) break; pos += ret; } } *pos = '\0'; p2p_dbg(p2p, "%s:%s", title, buf); }
/** * eap_sim_db_resynchronize - Resynchronize AKA AUTN * @data: Private data pointer from eap_sim_db_init() * @username: Permanent username * @auts: AUTS value from the peer * @_rand: RAND value used in the rejected message * Returns: 0 on success, -1 on failure * * This function is called when the peer reports synchronization failure in the * AUTN value by sending AUTS. The AUTS and RAND values should be sent to * HLR/AuC to allow it to resynchronize with the peer. After this, * eap_sim_db_get_aka_auth() will be called again to to fetch updated * RAND/AUTN values for the next challenge. */ int eap_sim_db_resynchronize(struct eap_sim_db_data *data, const char *username, const u8 *auts, const u8 *_rand) { const char *imsi; size_t imsi_len; if (username == NULL || (username[0] != EAP_AKA_PERMANENT_PREFIX && username[0] != EAP_AKA_PRIME_PERMANENT_PREFIX) || username[1] == '\0' || os_strlen(username) > 20) { wpa_printf(MSG_DEBUG, "EAP-SIM DB: unexpected username '%s'", username); return -1; } imsi = username + 1; wpa_printf(MSG_DEBUG, "EAP-SIM DB: Get AKA auth for IMSI '%s'", imsi); if (data->sock >= 0) { char msg[100]; int len, ret; imsi_len = os_strlen(imsi); len = os_snprintf(msg, sizeof(msg), "AKA-AUTS "); if (os_snprintf_error(sizeof(msg), len) || len + imsi_len >= sizeof(msg)) return -1; os_memcpy(msg + len, imsi, imsi_len); len += imsi_len; ret = os_snprintf(msg + len, sizeof(msg) - len, " "); if (os_snprintf_error(sizeof(msg) - len, ret)) return -1; len += ret; len += wpa_snprintf_hex(msg + len, sizeof(msg) - len, auts, EAP_AKA_AUTS_LEN); ret = os_snprintf(msg + len, sizeof(msg) - len, " "); if (os_snprintf_error(sizeof(msg) - len, ret)) return -1; len += ret; len += wpa_snprintf_hex(msg + len, sizeof(msg) - len, _rand, EAP_AKA_RAND_LEN); wpa_printf(MSG_DEBUG, "EAP-SIM DB: reporting AKA AUTS for " "IMSI '%s'", imsi); if (eap_sim_db_send(data, msg, len) < 0) return -1; } return 0; }
int mbo_ap_get_info(struct sta_info *sta, char *buf, size_t buflen) { char *pos = buf, *end = buf + buflen; int ret; struct mbo_non_pref_chan_info *info; u8 i; unsigned int count = 0; if (!sta->cell_capa) return 0; ret = os_snprintf(pos, end - pos, "mbo_cell_capa=%u\n", sta->cell_capa); if (os_snprintf_error(end - pos, ret)) return pos - buf; pos += ret; for (info = sta->non_pref_chan; info; info = info->next) { char *pos2 = pos; ret = os_snprintf(pos2, end - pos2, "non_pref_chan[%u]=%u:%u:%u:%u:", count, info->op_class, info->pref, info->reason_code, info->reason_detail); count++; if (os_snprintf_error(end - pos2, ret)) break; pos2 += ret; for (i = 0; i < info->num_channels; i++) { ret = os_snprintf(pos2, end - pos2, "%u%s", info->channels[i], i + 1 < info->num_channels ? "," : ""); if (os_snprintf_error(end - pos2, ret)) { pos2 = NULL; break; } pos2 += ret; } if (!pos2) break; ret = os_snprintf(pos2, end - pos2, "\n"); if (os_snprintf_error(end - pos2, ret)) break; pos2 += ret; pos = pos2; } return pos - buf; }
static int hostapd_cli_cmd_fst(struct wpa_ctrl *ctrl, int argc, char *argv[]) { char cmd[256]; int res; int i; int total; if (argc <= 0) { printf("FST command: parameters are required.\n"); return -1; } total = os_snprintf(cmd, sizeof(cmd), "FST-MANAGER"); for (i = 0; i < argc; i++) { res = os_snprintf(cmd + total, sizeof(cmd) - total, " %s", argv[i]); if (os_snprintf_error(sizeof(cmd) - total, res)) { printf("Too long fst command.\n"); return -1; } total += res; } return wpa_ctrl_command(ctrl, cmd); }
int ap_sta_flags_txt(u32 flags, char *buf, size_t buflen) { int res; buf[0] = '\0'; res = os_snprintf(buf, buflen, "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s", (flags & WLAN_STA_AUTH ? "[AUTH]" : ""), (flags & WLAN_STA_ASSOC ? "[ASSOC]" : ""), (flags & WLAN_STA_AUTHORIZED ? "[AUTHORIZED]" : ""), (flags & WLAN_STA_PENDING_POLL ? "[PENDING_POLL" : ""), (flags & WLAN_STA_SHORT_PREAMBLE ? "[SHORT_PREAMBLE]" : ""), (flags & WLAN_STA_PREAUTH ? "[PREAUTH]" : ""), (flags & WLAN_STA_WMM ? "[WMM]" : ""), (flags & WLAN_STA_MFP ? "[MFP]" : ""), (flags & WLAN_STA_WPS ? "[WPS]" : ""), (flags & WLAN_STA_MAYBE_WPS ? "[MAYBE_WPS]" : ""), (flags & WLAN_STA_WDS ? "[WDS]" : ""), (flags & WLAN_STA_NONERP ? "[NonERP]" : ""), (flags & WLAN_STA_WPS2 ? "[WPS2]" : ""), (flags & WLAN_STA_GAS ? "[GAS]" : ""), (flags & WLAN_STA_VHT ? "[VHT]" : ""), (flags & WLAN_STA_VENDOR_VHT ? "[VENDOR_VHT]" : ""), (flags & WLAN_STA_WNM_SLEEP_MODE ? "[WNM_SLEEP_MODE]" : "")); if (os_snprintf_error(buflen, res)) res = -1; return res; }
int ap_ctrl_iface_wpa_get_status(struct wpa_supplicant *wpa_s, char *buf, size_t buflen, int verbose) { char *pos = buf, *end = buf + buflen; int ret; struct hostapd_bss_config *conf; if (wpa_s->ap_iface == NULL) return -1; conf = wpa_s->ap_iface->bss[0]->conf; if (conf->wpa == 0) return 0; ret = os_snprintf(pos, end - pos, "pairwise_cipher=%s\n" "group_cipher=%s\n" "key_mgmt=%s\n", wpa_cipher_txt(conf->rsn_pairwise), wpa_cipher_txt(conf->wpa_group), wpa_key_mgmt_txt(conf->wpa_key_mgmt, conf->wpa)); if (os_snprintf_error(end - pos, ret)) return pos - buf; pos += ret; return pos - buf; }
static int is_signature_correct(DBusMessage *message, const struct wpa_dbus_method_desc *method_dsc) { /* According to DBus documentation max length of signature is 255 */ #define MAX_SIG_LEN 256 char registered_sig[MAX_SIG_LEN], *pos; const char *sig = dbus_message_get_signature(message); int ret; const struct wpa_dbus_argument *arg; pos = registered_sig; *pos = '\0'; for (arg = method_dsc->args; arg && arg->name; arg++) { if (arg->dir == ARG_IN) { size_t blen = registered_sig + MAX_SIG_LEN - pos; ret = os_snprintf(pos, blen, "%s", arg->type); if (os_snprintf_error(blen, ret)) return 0; pos += ret; } } return !os_strncmp(registered_sig, sig, MAX_SIG_LEN); }
void wpas_send_ctrl_req(struct wpa_supplicant *wpa_s, struct wpa_ssid *ssid, const char *field_name, const char *txt) { char *buf; size_t buflen; int len; buflen = 100 + os_strlen(txt) + ssid->ssid_len; buf = os_malloc(buflen); if (buf == NULL) return; len = os_snprintf(buf, buflen, "%s-%d:%s needed for SSID ", field_name, ssid->id, txt); if (os_snprintf_error(buflen, len)) { os_free(buf); return; } if (ssid->ssid && buflen > len + ssid->ssid_len) { os_memcpy(buf + len, ssid->ssid, ssid->ssid_len); len += ssid->ssid_len; buf[len] = '\0'; } buf[buflen - 1] = '\0'; wpa_msg(wpa_s, MSG_INFO, WPA_CTRL_REQ "%s", buf); os_free(buf); }
/** * pmksa_cache_auth_list_mesh - Dump text list of entries in PMKSA cache * @pmksa: Pointer to PMKSA cache data from pmksa_cache_auth_init() * @addr: MAC address of the peer (NULL means any) * @buf: Buffer for the list * @len: Length of the buffer * Returns: Number of bytes written to buffer * * This function is used to generate a text format representation of the * current PMKSA cache contents for the ctrl_iface PMKSA_GET command to store * in external storage. */ int pmksa_cache_auth_list_mesh(struct rsn_pmksa_cache *pmksa, const u8 *addr, char *buf, size_t len) { int ret; char *pos, *end; struct rsn_pmksa_cache_entry *entry; struct os_reltime now; pos = buf; end = buf + len; os_get_reltime(&now); /* * Entry format: * <BSSID> <PMKID> <PMK> <expiration in seconds> */ for (entry = pmksa->pmksa; entry; entry = entry->next) { if (addr && os_memcmp(entry->spa, addr, ETH_ALEN) != 0) continue; ret = os_snprintf(pos, end - pos, MACSTR " ", MAC2STR(entry->spa)); if (os_snprintf_error(end - pos, ret)) return 0; pos += ret; pos += wpa_snprintf_hex(pos, end - pos, entry->pmkid, PMKID_LEN); ret = os_snprintf(pos, end - pos, " "); if (os_snprintf_error(end - pos, ret)) return 0; pos += ret; pos += wpa_snprintf_hex(pos, end - pos, entry->pmk, entry->pmk_len); ret = os_snprintf(pos, end - pos, " %d\n", (int) (entry->expiration - now.sec)); if (os_snprintf_error(end - pos, ret)) return 0; pos += ret; } return pos - buf; }
struct wpa_ctrl * wpa_ctrl_open(const char *ctrl_path) { struct wpa_ctrl *ctrl; DWORD mode; TCHAR name[256]; int i, ret; ctrl = os_malloc(sizeof(*ctrl)); if (ctrl == NULL) return NULL; os_memset(ctrl, 0, sizeof(*ctrl)); #ifdef UNICODE if (ctrl_path == NULL) ret = _snwprintf(name, 256, NAMED_PIPE_PREFIX); else ret = _snwprintf(name, 256, NAMED_PIPE_PREFIX TEXT("-%S"), ctrl_path); #else /* UNICODE */ if (ctrl_path == NULL) ret = os_snprintf(name, 256, NAMED_PIPE_PREFIX); else ret = os_snprintf(name, 256, NAMED_PIPE_PREFIX "-%s", ctrl_path); #endif /* UNICODE */ if (os_snprintf_error(256, ret)) { os_free(ctrl); return NULL; } for (i = 0; i < 10; i++) { ctrl->pipe = CreateFile(name, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL); /* * Current named pipe server side in wpa_supplicant is * re-opening the pipe for new clients only after the previous * one is taken into use. This leaves a small window for race * conditions when two connections are being opened at almost * the same time. Retry if that was the case. */ if (ctrl->pipe != INVALID_HANDLE_VALUE || GetLastError() != ERROR_PIPE_BUSY) break; WaitNamedPipe(name, 1000); } if (ctrl->pipe == INVALID_HANDLE_VALUE) { os_free(ctrl); return NULL; } mode = PIPE_READMODE_MESSAGE; if (!SetNamedPipeHandleState(ctrl->pipe, &mode, NULL, NULL)) { CloseHandle(ctrl->pipe); os_free(ctrl); return NULL; } return ctrl; }
static int wpas_mesh_get_ifname(struct wpa_supplicant *wpa_s, char *ifname, size_t len) { char *ifname_ptr = wpa_s->ifname; int res; res = os_snprintf(ifname, len, "mesh-%s-%d", ifname_ptr, wpa_s->mesh_if_idx); if (os_snprintf_error(len, res) || (os_strlen(ifname) >= IFNAMSIZ && os_strlen(wpa_s->ifname) < IFNAMSIZ)) { /* Try to avoid going over the IFNAMSIZ length limit */ res = os_snprintf(ifname, len, "mesh-%d", wpa_s->mesh_if_idx); if (os_snprintf_error(len, res)) return -1; } wpa_s->mesh_if_idx++; return 0; }
static size_t hostapd_write_ht_mcs_bitmask(char *buf, size_t buflen, size_t curr_len, const u8 *mcs_set) { int ret; size_t len = curr_len; ret = os_snprintf(buf + len, buflen - len, "ht_mcs_bitmask="); if (os_snprintf_error(buflen - len, ret)) return len; len += ret; /* 77 first bits (+ 3 reserved bits) */ len += wpa_snprintf_hex(buf + len, buflen - len, mcs_set, 10); ret = os_snprintf(buf + len, buflen - len, "\n"); if (os_snprintf_error(buflen - len, ret)) return curr_len; len += ret; return len; }
char * wps_dev_type_bin2str(const u8 dev_type[WPS_DEV_TYPE_LEN], char *buf, size_t buf_len) { int ret; ret = os_snprintf(buf, buf_len, "%u-%08X-%u", WPA_GET_BE16(dev_type), WPA_GET_BE32(&dev_type[2]), WPA_GET_BE16(&dev_type[6])); if (os_snprintf_error(buf_len, ret)) return NULL; return buf; }
static char * wpa_supplicant_ctrl_iface_path(struct wpa_supplicant *wpa_s) { char *buf; size_t len; char *pbuf, *dir = NULL; int res; if (wpa_s->conf->ctrl_interface == NULL) return NULL; pbuf = os_strdup(wpa_s->conf->ctrl_interface); if (pbuf == NULL) return NULL; if (os_strncmp(pbuf, "DIR=", 4) == 0) { char *gid_str; dir = pbuf + 4; gid_str = os_strstr(dir, " GROUP="); if (gid_str) *gid_str = '\0'; } else dir = pbuf; len = os_strlen(dir) + os_strlen(wpa_s->ifname) + 2; buf = os_malloc(len); if (buf == NULL) { os_free(pbuf); return NULL; } res = os_snprintf(buf, len, "%s/%s", dir, wpa_s->ifname); if (os_snprintf_error(len, res)) { os_free(pbuf); os_free(buf); return NULL; } #ifdef __CYGWIN__ { /* Windows/WinPcap uses interface names that are not suitable * as a file name - convert invalid chars to underscores */ char *pos = buf; while (*pos) { if (*pos == '\\') *pos = '_'; pos++; } } #endif /* __CYGWIN__ */ os_free(pbuf); return buf; }
static void write_wep_key(FILE *f, int idx, struct wpa_ssid *ssid) { char field[20], *value; int res; res = os_snprintf(field, sizeof(field), "wep_key%d", idx); if (os_snprintf_error(sizeof(field), res)) return; value = wpa_config_get(ssid, field); if (value) { fprintf(f, "\t%s=%s\n", field, value); os_free(value); } }
static int hostapd_cli_cmd_chan_switch(struct wpa_ctrl *ctrl, int argc, char *argv[]) { char cmd[256]; int res; int i; char *tmp; int total; if (argc < 2) { printf("Invalid chan_switch command: needs at least two " "arguments (count and freq)\n" "usage: <cs_count> <freq> [sec_channel_offset=] " "[center_freq1=] [center_freq2=] [bandwidth=] " "[blocktx] [ht|vht]\n"); return -1; } res = os_snprintf(cmd, sizeof(cmd), "CHAN_SWITCH %s %s", argv[0], argv[1]); if (os_snprintf_error(sizeof(cmd), res)) { printf("Too long CHAN_SWITCH command.\n"); return -1; } total = res; for (i = 2; i < argc; i++) { tmp = cmd + total; res = os_snprintf(tmp, sizeof(cmd) - total, " %s", argv[i]); if (os_snprintf_error(sizeof(cmd) - total, res)) { printf("Too long CHAN_SWITCH command.\n"); return -1; } total += res; } return wpa_ctrl_command(ctrl, cmd); }
static void mbo_ap_parse_non_pref_chan(struct sta_info *sta, const u8 *buf, size_t len) { struct mbo_non_pref_chan_info *info, *tmp; char channels[200], *pos, *end; size_t num_chan, i; int ret; if (len <= 4) return; /* Not enough room for any channels */ num_chan = len - 4; info = os_zalloc(sizeof(*info) + num_chan); if (!info) return; info->op_class = buf[0]; info->pref = buf[len - 3]; info->reason_code = buf[len - 2]; info->reason_detail = buf[len - 1]; info->num_channels = num_chan; buf++; os_memcpy(info->channels, buf, num_chan); if (!sta->non_pref_chan) { sta->non_pref_chan = info; } else { tmp = sta->non_pref_chan; while (tmp->next) tmp = tmp->next; tmp->next = info; } pos = channels; end = pos + sizeof(channels); *pos = '\0'; for (i = 0; i < num_chan; i++) { ret = os_snprintf(pos, end - pos, "%s%u", i == 0 ? "" : " ", buf[i]); if (os_snprintf_error(end - pos, ret)) { *pos = '\0'; break; } pos += ret; } wpa_printf(MSG_DEBUG, "MBO: STA " MACSTR " non-preferred channel list (op class %u, pref %u, reason code %u, reason detail %u, channels %s)", MAC2STR(sta->addr), info->op_class, info->pref, info->reason_code, info->reason_detail, channels); }
struct hostapd_vlan * vlan_add_dynamic(struct hostapd_data *hapd, struct hostapd_vlan *vlan, int vlan_id, struct vlan_description *vlan_desc) { struct hostapd_vlan *n; char ifname[IFNAMSIZ + 1], *pos; int ret; if (vlan == NULL || vlan->vlan_id != VLAN_ID_WILDCARD) return NULL; wpa_printf(MSG_DEBUG, "VLAN: %s(vlan_id=%d ifname=%s)", __func__, vlan_id, vlan->ifname); os_strlcpy(ifname, vlan->ifname, sizeof(ifname)); pos = os_strchr(ifname, '#'); if (pos == NULL) return NULL; *pos++ = '\0'; n = os_zalloc(sizeof(*n)); if (n == NULL) return NULL; n->vlan_id = vlan_id; if (vlan_desc) n->vlan_desc = *vlan_desc; n->dynamic_vlan = 1; ret = os_snprintf(n->ifname, sizeof(n->ifname), "%s%d%s", ifname, vlan_id, pos); if (os_snprintf_error(sizeof(n->ifname), ret)) { os_free(n); return NULL; } os_strlcpy(n->bridge, vlan->bridge, sizeof(n->bridge)); n->next = hapd->conf->vlan; hapd->conf->vlan = n; /* hapd->conf->vlan needs this new VLAN here for WPA setup */ if (vlan_if_add(hapd, n, 0)) { hapd->conf->vlan = n->next; os_free(n); n = NULL; } return n; }
static void wpa_supplicant_eap_param_needed(void *ctx, enum wpa_ctrl_req_type field, const char *default_txt) { struct wpa_supplicant *wpa_s = ctx; struct wpa_ssid *ssid = wpa_s->current_ssid; const char *field_name, *txt = NULL; char *buf; size_t buflen; int len; if (ssid == NULL) return; wpas_notify_network_request(wpa_s, ssid, field, default_txt); field_name = wpa_supplicant_ctrl_req_to_string(field, default_txt, &txt); if (field_name == NULL) { wpa_printf(MSG_WARNING, "Unhandled EAP param %d needed", field); return; } wpas_notify_eap_status(wpa_s, "eap parameter needed", field_name); buflen = 100 + os_strlen(txt) + ssid->ssid_len; buf = os_malloc(buflen); if (buf == NULL) return; len = os_snprintf(buf, buflen, WPA_CTRL_REQ "%s-%d:%s needed for SSID ", field_name, ssid->id, txt); if (os_snprintf_error(buflen, len)) { os_free(buf); return; } if (ssid->ssid && buflen > len + ssid->ssid_len) { os_memcpy(buf + len, ssid->ssid, ssid->ssid_len); len += ssid->ssid_len; buf[len] = '\0'; } buf[buflen - 1] = '\0'; wpa_msg(wpa_s, MSG_INFO, "%s", buf); os_free(buf); }
static int eap_fast_get_status(struct eap_sm *sm, void *priv, char *buf, size_t buflen, int verbose) { struct eap_fast_data *data = priv; int len, ret; len = eap_peer_tls_status(sm, &data->ssl, buf, buflen, verbose); if (data->phase2_method) { ret = os_snprintf(buf + len, buflen - len, "EAP-FAST Phase2 method=%s\n", data->phase2_method->name); if (os_snprintf_error(buflen - len, ret)) return len; len += ret; } return len; }
static void bgscan_learn_timeout(void *eloop_ctx, void *timeout_ctx) { struct bgscan_learn_data *data = eloop_ctx; struct wpa_supplicant *wpa_s = data->wpa_s; struct wpa_driver_scan_params params; int *freqs = NULL; size_t count, i; char msg[100], *pos; os_memset(¶ms, 0, sizeof(params)); params.num_ssids = 1; params.ssids[0].ssid = data->ssid->ssid; params.ssids[0].ssid_len = data->ssid->ssid_len; if (data->ssid->scan_freq) params.freqs = data->ssid->scan_freq; else { freqs = bgscan_learn_get_freqs(data, &count); wpa_printf(MSG_DEBUG, "bgscan learn: BSSes in this ESS have " "been seen on %u channels", (unsigned int) count); freqs = bgscan_learn_get_probe_freq(data, freqs, count); msg[0] = '\0'; pos = msg; for (i = 0; freqs && freqs[i]; i++) { int ret; ret = os_snprintf(pos, msg + sizeof(msg) - pos, " %d", freqs[i]); if (os_snprintf_error(msg + sizeof(msg) - pos, ret)) break; pos += ret; } pos[0] = '\0'; wpa_printf(MSG_DEBUG, "bgscan learn: Scanning frequencies:%s", msg); params.freqs = freqs; } wpa_printf(MSG_DEBUG, "bgscan learn: Request a background scan"); if (wpa_supplicant_trigger_scan(wpa_s, ¶ms)) { wpa_printf(MSG_DEBUG, "bgscan learn: Failed to trigger scan"); eloop_register_timeout(data->scan_interval, 0, bgscan_learn_timeout, data, NULL); } else os_get_reltime(&data->last_bgscan); os_free(freqs); }
static int hostapd_cli_cmd_send_qos_map_conf(struct wpa_ctrl *ctrl, int argc, char *argv[]) { char buf[50]; int res; if (argc != 1) { printf("Invalid 'send_qos_map_conf' command - " "one argument (STA addr) is needed\n"); return -1; } res = os_snprintf(buf, sizeof(buf), "SEND_QOS_MAP_CONF %s", argv[0]); if (os_snprintf_error(sizeof(buf), res)) return -1; return wpa_ctrl_command(ctrl, buf); }
static int hostapd_get_sta_conn_time(struct sta_info *sta, char *buf, size_t buflen) { struct os_reltime age; int ret; if (!sta->connected_time.sec) return 0; os_reltime_age(&sta->connected_time, &age); ret = os_snprintf(buf, buflen, "connected_time=%u\n", (unsigned int) age.sec); if (os_snprintf_error(buflen, ret)) return 0; return ret; }
static int hostapd_cli_cmd_log_level(struct wpa_ctrl *ctrl, int argc, char *argv[]) { char cmd[256]; int res; res = os_snprintf(cmd, sizeof(cmd), "LOG_LEVEL%s%s%s%s", argc >= 1 ? " " : "", argc >= 1 ? argv[0] : "", argc == 2 ? " " : "", argc == 2 ? argv[1] : ""); if (os_snprintf_error(sizeof(cmd), res)) { printf("Too long option\n"); return -1; } return wpa_ctrl_command(ctrl, cmd); }
static int hostapd_cli_cmd_hs20_wnm_notif(struct wpa_ctrl *ctrl, int argc, char *argv[]) { char buf[300]; int res; if (argc < 2) { printf("Invalid 'hs20_wnm_notif' command - two arguments (STA " "addr and URL) are needed\n"); return -1; } res = os_snprintf(buf, sizeof(buf), "HS20_WNM_NOTIF %s %s", argv[0], argv[1]); if (os_snprintf_error(sizeof(buf), res)) return -1; return wpa_ctrl_command(ctrl, buf); }
static int hostapd_cli_cmd_set_qos_map_set(struct wpa_ctrl *ctrl, int argc, char *argv[]) { char buf[200]; int res; if (argc != 1) { printf("Invalid 'set_qos_map_set' command - " "one argument (comma delimited QoS map set) " "is needed\n"); return -1; } res = os_snprintf(buf, sizeof(buf), "SET_QOS_MAP_SET %s", argv[0]); if (os_snprintf_error(sizeof(buf), res)) return -1; return wpa_ctrl_command(ctrl, buf); }