void wpas_notify_suspend(struct wpa_global *global) { struct wpa_supplicant *wpa_s; os_get_time(&global->suspend_time); wpa_printf(MSG_DEBUG, "System suspend notification"); for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) wpa_drv_suspend(wpa_s); }
int eloop_register_timeout(unsigned int secs, unsigned int usecs, eloop_timeout_handler handler, void *eloop_data, void *user_data) { struct eloop_timeout *timeout, *tmp, *prev; os_time_t now_sec; timeout = os_malloc(sizeof(*timeout)); if (timeout == NULL) return -1; os_get_time(&timeout->time); now_sec = timeout->time.sec; timeout->time.sec += secs; if (timeout->time.sec < now_sec) { /* * Integer overflow - assume long enough timeout to be assumed * to be infinite, i.e., the timeout would never happen. */ wpa_printf(MSG_DEBUG, "ELOOP: Too long timeout (secs=%u) to " "ever happen - ignore it", secs); os_free(timeout); return 0; } timeout->time.usec += usecs; while (timeout->time.usec >= 1000000) { timeout->time.sec++; timeout->time.usec -= 1000000; } timeout->eloop_data = eloop_data; timeout->user_data = user_data; timeout->handler = handler; timeout->next = NULL; if (eloop.timeout == NULL) { eloop.timeout = timeout; return 0; } prev = NULL; tmp = eloop.timeout; while (tmp != NULL) { if (os_time_before(&timeout->time, &tmp->time)) break; prev = tmp; tmp = tmp->next; } if (prev == NULL) { timeout->next = eloop.timeout; eloop.timeout = timeout; } else { timeout->next = prev->next; prev->next = timeout; } return 0; }
int os_get_reltime(struct os_reltime *t) { /* consider using performance counters or so instead */ struct os_time now; int res = os_get_time(&now); t->sec = now.sec; t->usec = now.usec; return res; }
/** * Start measuring the elapsed time. * This means simply setting the given timeval struct to the current time. * * @param timer The timeval struct used to determine the passed time later on. * @param msg The message to be printed when starting the timer. */ void pwifi_start_timer(struct os_time *const timer, const char *const msg) { if (!timer) { return; } if (msg) { wpa_printf(MSG_DEBUG, "%s", msg); } os_get_time(timer); }
/** * hostapd_acl_expire - ACL cache expiration callback * @eloop_ctx: struct hostapd_data * * @timeout_ctx: Not used */ static void hostapd_acl_expire(void *eloop_ctx, void *timeout_ctx) { struct hostapd_data *hapd = eloop_ctx; struct os_time now; os_get_time(&now); hostapd_acl_expire_cache(hapd, now.sec); hostapd_acl_expire_queries(hapd, now.sec); eloop_register_timeout(10, 0, hostapd_acl_expire, hapd, NULL); }
int wpa_supplicant_may_scan(struct wpa_supplicant *wpa_s) { struct os_time time; if (wpa_s->conf->scan_cache > 0) { os_get_time(&time); time.sec -= wpa_s->conf->scan_cache; if (os_time_before(&time, &wpa_s->last_scan_results)) return 0; } return 1; }
static void radius_client_list_add(struct radius_client_data *radius, struct radius_msg *msg, RadiusType msg_type, u8 *shared_secret, size_t shared_secret_len, const u8 *addr) { struct radius_msg_list *entry, *prev; if (eloop_terminated()) { /* No point in adding entries to retransmit queue since event * loop has already been terminated. */ radius_msg_free(msg); os_free(msg); return; } entry = os_zalloc(sizeof(*entry)); if (entry == NULL) { printf("Failed to add RADIUS packet into retransmit list\n"); radius_msg_free(msg); os_free(msg); return; } if (addr) os_memcpy(entry->addr, addr, ETH_ALEN); entry->msg = msg; entry->msg_type = msg_type; entry->shared_secret = shared_secret; entry->shared_secret_len = shared_secret_len; os_get_time(&entry->last_attempt); entry->first_try = entry->last_attempt.sec; entry->next_try = entry->first_try + RADIUS_CLIENT_FIRST_WAIT; entry->attempts = 1; entry->next_wait = RADIUS_CLIENT_FIRST_WAIT * 2; entry->next = radius->msgs; radius->msgs = entry; radius_client_update_timeout(radius); if (radius->num_msgs >= RADIUS_CLIENT_MAX_ENTRIES) { printf("Removing the oldest un-ACKed RADIUS packet due to " "retransmit list limits.\n"); prev = NULL; while (entry->next) { prev = entry; entry = entry->next; } if (prev) { prev->next = NULL; radius_client_msg_free(entry); } } else radius->num_msgs++; }
void Gui::exec() { os_mutex_unlock(gui_mutex); fps = 60.0; double last_time = os_get_time(); while (_running) { os_mutex_lock(gui_mutex); genesis_flush_events(_genesis_context); glfwPollEvents(); events.trigger(EventFlushEvents); os_mutex_unlock(gui_mutex); _utility_window->draw(); double this_time = os_get_time(); double delta = this_time - last_time; last_time = this_time; double this_fps = 1.0 / delta; fps = fps * 0.90 + this_fps * 0.10; } os_mutex_lock(gui_mutex); }
static void ap_list_timer(void *eloop_ctx, void *timeout_ctx) { struct hostapd_iface *iface = eloop_ctx; struct os_time now; struct ap_info *ap; int set_beacon = 0; eloop_register_timeout(10, 0, ap_list_timer, iface, NULL); if (!iface->ap_list) return; os_get_time(&now); while (iface->ap_list) { ap = iface->ap_list->prev; if (ap->last_beacon + iface->conf->ap_table_expiration_time >= now.sec) break; ap_free_ap(iface, ap); } if (iface->olbc || iface->olbc_ht) { int olbc = 0; int olbc_ht = 0; ap = iface->ap_list; while (ap && (olbc == 0 || olbc_ht == 0)) { if (ap_list_beacon_olbc(iface, ap)) olbc = 1; if (!ap->ht_support) olbc_ht = 1; ap = ap->next; } if (!olbc && iface->olbc) { wpa_printf(MSG_DEBUG, "OLBC not detected anymore"); iface->olbc = 0; set_beacon++; } #ifdef CONFIG_IEEE80211N if (!olbc_ht && iface->olbc_ht) { wpa_printf(MSG_DEBUG, "OLBC HT not detected anymore"); iface->olbc_ht = 0; hostapd_ht_operation_update(iface); set_beacon++; } #endif /* CONFIG_IEEE80211N */ } if (set_beacon) ieee802_11_update_beacons(iface); }
struct radius_server_data * radius_server_init(struct radius_server_conf *conf) { struct radius_server_data *data; #ifndef CONFIG_IPV6 if (conf->ipv6) { fprintf(stderr, "RADIUS server compiled without IPv6 " "support.\n"); return NULL; } #endif /* CONFIG_IPV6 */ data = wpa_zalloc(sizeof(*data)); if (data == NULL) return NULL; os_get_time(&data->start_time); data->hostapd_conf = conf->hostapd_conf; data->eap_sim_db_priv = conf->eap_sim_db_priv; data->ssl_ctx = conf->ssl_ctx; data->ipv6 = conf->ipv6; data->clients = radius_server_read_clients(conf->client_file, conf->ipv6); if (data->clients == NULL) { printf("No RADIUS clients configured.\n"); radius_server_deinit(data); return NULL; } #ifdef CONFIG_IPV6 if (conf->ipv6) data->auth_sock = radius_server_open_socket6(conf->auth_port); else #endif /* CONFIG_IPV6 */ data->auth_sock = radius_server_open_socket(conf->auth_port); if (data->auth_sock < 0) { printf("Failed to open UDP socket for RADIUS authentication " "server\n"); radius_server_deinit(data); return NULL; } if (eloop_register_read_sock(data->auth_sock, radius_server_receive_auth, data, NULL)) { radius_server_deinit(data); return NULL; } return data; }
int hostapd_update_time_adv(struct hostapd_data *hapd) { const int elen = 2 + 1 + 10 + 5 + 1; struct os_time t; struct os_tm tm; u8 *pos; if (hapd->conf->time_advertisement != 2) return 0; if (os_get_time(&t) < 0 || os_gmtime(t.sec, &tm) < 0) return -1; if (!hapd->time_adv) { hapd->time_adv = wpabuf_alloc(elen); if (hapd->time_adv == NULL) return -1; pos = wpabuf_put(hapd->time_adv, elen); } else pos = wpabuf_mhead_u8(hapd->time_adv); *pos++ = WLAN_EID_TIME_ADVERTISEMENT; *pos++ = 1 + 10 + 5 + 1; *pos++ = 2; /* UTC time at which the TSF timer is 0 */ /* Time Value at TSF 0 */ /* FIX: need to calculate this based on the current TSF value */ WPA_PUT_LE16(pos, tm.year); /* Year */ pos += 2; *pos++ = tm.month; /* Month */ *pos++ = tm.day; /* Day of month */ *pos++ = tm.hour; /* Hours */ *pos++ = tm.min; /* Minutes */ *pos++ = tm.sec; /* Seconds */ WPA_PUT_LE16(pos, 0); /* Milliseconds (not used) */ pos += 2; *pos++ = 0; /* Reserved */ /* Time Error */ /* TODO: fill in an estimate on the error */ *pos++ = 0; *pos++ = 0; *pos++ = 0; *pos++ = 0; *pos++ = 0; *pos++ = hapd->time_update_counter++; return 0; }
static void pmksa_cache_expire(void *eloop_ctx, void *timeout_ctx) { struct rsn_pmksa_cache *pmksa = eloop_ctx; struct os_time now; os_get_time(&now); while (pmksa->pmksa && pmksa->pmksa->expiration <= now.sec) { wpa_printf(MSG_DEBUG, "RSN: expired PMKSA cache entry for " MACSTR, MAC2STR(pmksa->pmksa->spa)); pmksa_cache_free_entry(pmksa, pmksa->pmksa); } pmksa_cache_set_expiration(pmksa); }
static void pmksa_cache_set_expiration(struct rsn_pmksa_cache *pmksa) { int sec; struct os_time now; eloop_cancel_timeout(pmksa_cache_expire, pmksa, NULL); if (pmksa->pmksa == NULL) return; os_get_time(&now); sec = pmksa->pmksa->expiration - now.sec; if (sec < 0) sec = 0; eloop_register_timeout(sec + 1, 0, pmksa_cache_expire, pmksa, NULL); }
static int radius_client_retransmit(struct radius_client_data *radius, struct radius_msg_list *entry, os_time_t now) { struct hostapd_radius_servers *conf = radius->conf; int s; struct wpabuf *buf; if (entry->msg_type == RADIUS_ACCT || entry->msg_type == RADIUS_ACCT_INTERIM) { s = radius->acct_sock; if (entry->attempts == 0) conf->acct_server->requests++; else { conf->acct_server->timeouts++; conf->acct_server->retransmissions++; } } else { s = radius->auth_sock; if (entry->attempts == 0) conf->auth_server->requests++; else { conf->auth_server->timeouts++; conf->auth_server->retransmissions++; } } /* retransmit; remove entry if too many attempts */ entry->attempts++; hostapd_logger(radius->ctx, entry->addr, HOSTAPD_MODULE_RADIUS, HOSTAPD_LEVEL_DEBUG, "Resending RADIUS message (id=%d)", radius_msg_get_hdr(entry->msg)->identifier); os_get_time(&entry->last_attempt); buf = radius_msg_get_buf(entry->msg); if (send(s, wpabuf_head(buf), wpabuf_len(buf), 0) < 0) radius_client_handle_send_error(radius, s, entry->msg_type); entry->next_try = now + entry->next_wait; entry->next_wait *= 2; if (entry->next_wait > RADIUS_CLIENT_MAX_WAIT) entry->next_wait = RADIUS_CLIENT_MAX_WAIT; if (entry->attempts >= RADIUS_CLIENT_MAX_RETRIES) { printf("Removing un-ACKed RADIUS message due to too many " "failed retransmit attempts\n"); return 1; } return 0; }
int eloop_register_timeout(unsigned int secs, unsigned int usecs, eloop_timeout_handler handler, void *eloop_data, void *user_data) { struct eloop_timeout *timeout, *tmp; os_time_t now_sec; timeout = os_zalloc(sizeof(*timeout)); if (timeout == NULL) return -1; if (os_get_time(&timeout->time) < 0) { os_free(timeout); return -1; } now_sec = timeout->time.sec; timeout->time.sec += secs; if (timeout->time.sec < now_sec) { /* * Integer overflow - assume long enough timeout to be assumed * to be infinite, i.e., the timeout would never happen. */ wpa_printf(MSG_DEBUG, "ELOOP: Too long timeout (secs=%u) to " "ever happen - ignore it", secs); os_free(timeout); return 0; } timeout->time.usec += usecs; while (timeout->time.usec >= 1000000) { timeout->time.sec++; timeout->time.usec -= 1000000; } timeout->eloop_data = eloop_data; timeout->user_data = user_data; timeout->handler = handler; wpa_trace_add_ref(timeout, eloop, eloop_data); wpa_trace_add_ref(timeout, user, user_data); wpa_trace_record(timeout); /* Maintain timeouts in order of increasing time */ dl_list_for_each(tmp, &eloop.timeout, struct eloop_timeout, list) { if (os_time_before(&timeout->time, &tmp->time)) { dl_list_add(tmp->list.prev, &timeout->list); return 0; } } dl_list_add_tail(&eloop.timeout, &timeout->list); return 0; }
/** * wps_generate_pin - Generate a random PIN * Returns: Eight digit PIN (i.e., including the checksum digit) */ unsigned int wps_generate_pin(void) { unsigned int val; /* Generate seven random digits for the PIN */ if (random_get_bytes((unsigned char *) &val, sizeof(val)) < 0) { struct os_time now; os_get_time(&now); val = os_random() ^ now.sec ^ now.usec; } val %= 10000000; /* Append checksum digit */ return val * 10 + wps_pin_checksum(val); }
int eloop_register_timeout(unsigned int secs, unsigned int usecs, eloop_timeout_handler handler, void *eloop_data, void *user_data) { struct eloop_timeout *timeout, *tmp, *prev; timeout = os_malloc(sizeof(*timeout)); if (timeout == NULL) return -1; if (os_get_time(&timeout->time) < 0) { os_free(timeout); return -1; } timeout->time.sec += secs; timeout->time.usec += usecs; while (timeout->time.usec >= 1000000) { timeout->time.sec++; timeout->time.usec -= 1000000; } timeout->eloop_data = eloop_data; timeout->user_data = user_data; timeout->handler = handler; timeout->next = NULL; if (eloop.timeout == NULL) { eloop.timeout = timeout; return 0; } prev = NULL; tmp = eloop.timeout; while (tmp != NULL) { if (os_time_before(&timeout->time, &tmp->time)) break; prev = tmp; tmp = tmp->next; } if (prev == NULL) { timeout->next = eloop.timeout; eloop.timeout = timeout; } else { timeout->next = prev->next; prev->next = timeout; } return 0; }
void wpa_debug_print_timestamp(void) { struct os_time tv; if (!wpa_debug_timestamp) return; os_get_time(&tv); #ifdef CONFIG_DEBUG_FILE if (out_file) { fprintf(out_file, "%ld.%06u: ", (long) tv.sec, (unsigned int) tv.usec); } else #endif /* CONFIG_DEBUG_FILE */ printf("%ld.%06u: ", (long) tv.sec, (unsigned int) tv.usec); }
/** * pmksa_cache_auth_add - Add a PMKSA cache entry * @pmksa: Pointer to PMKSA cache data from pmksa_cache_auth_init() * @pmk: The new pairwise master key * @pmk_len: PMK length in bytes, usually PMK_LEN (32) * @aa: Authenticator address * @spa: Supplicant address * @session_timeout: Session timeout * @eapol: Pointer to EAPOL state machine data * @akmp: WPA_KEY_MGMT_* used in key derivation * Returns: Pointer to the added PMKSA cache entry or %NULL on error * * This function create a PMKSA entry for a new PMK and adds it to the PMKSA * cache. If an old entry is already in the cache for the same Supplicant, * this entry will be replaced with the new entry. PMKID will be calculated * based on the PMK. */ struct rsn_pmksa_cache_entry * pmksa_cache_auth_add(struct rsn_pmksa_cache *pmksa, const u8 *pmk, size_t pmk_len, const u8 *aa, const u8 *spa, int session_timeout, struct eapol_state_machine *eapol, int akmp) { struct rsn_pmksa_cache_entry *entry, *pos; struct os_time now; if (pmk_len > PMK_LEN) return NULL; entry = os_zalloc(sizeof(*entry)); if (entry == NULL) return NULL; os_memcpy(entry->pmk, pmk, pmk_len); entry->pmk_len = pmk_len; rsn_pmkid(pmk, pmk_len, aa, spa, entry->pmkid, wpa_key_mgmt_sha256(akmp)); os_get_time(&now); entry->expiration = now.sec; if (session_timeout > 0) entry->expiration += session_timeout; else entry->expiration += dot11RSNAConfigPMKLifetime; entry->akmp = akmp; os_memcpy(entry->spa, spa, ETH_ALEN); pmksa_cache_from_eapol_data(entry, eapol); /* Replace an old entry for the same STA (if found) with the new entry */ pos = pmksa_cache_auth_get(pmksa, spa, NULL); if (pos) pmksa_cache_free_entry(pmksa, pos); if (pmksa->pmksa_count >= pmksa_cache_max_entries && pmksa->pmksa) { /* Remove the oldest entry to make room for the new entry */ wpa_printf(MSG_DEBUG, "RSN: removed the oldest PMKSA cache " "entry (for " MACSTR ") to make room for new one", MAC2STR(pmksa->pmksa->spa)); pmksa_cache_free_entry(pmksa, pmksa->pmksa); } pmksa_cache_link_entry(pmksa, entry); return entry; }
/** * accounting_init: Initialize accounting * @hapd: hostapd BSS data * Returns: 0 on success, -1 on failure */ int accounting_init(struct hostapd_data *hapd) { struct os_time now; /* Acct-Session-Id should be unique over reboots. If reliable clock is * not available, this could be replaced with reboot counter, etc. */ os_get_time(&now); hapd->acct_session_id_hi = now.sec; if (radius_client_register(hapd->radius, RADIUS_ACCT, accounting_receive, hapd)) return -1; accounting_report_state(hapd, 1); return 0; }
static int sme_check_sa_query_timeout(struct wpa_supplicant *wpa_s) { u32 tu; struct os_time now, passed; os_get_time(&now); os_time_sub(&now, &wpa_s->sme.sa_query_start, &passed); tu = (passed.sec * 1000000 + passed.usec) / 1024; if (sa_query_max_timeout < tu) { wpa_dbg(wpa_s, MSG_DEBUG, "SME: SA Query timed out"); sme_stop_sa_query(wpa_s); wpa_supplicant_deauthenticate( wpa_s, WLAN_REASON_PREV_AUTH_NOT_VALID); return 1; } return 0; }
static void pmksa_cache_expire(void *eloop_ctx, void *timeout_ctx) { struct rsn_pmksa_cache *pmksa = eloop_ctx; struct os_time now; os_get_time(&now); while (pmksa->pmksa && pmksa->pmksa->expiration <= now.sec) { struct rsn_pmksa_cache_entry *entry = pmksa->pmksa; pmksa->pmksa = entry->next; wpa_printf(MSG_DEBUG, "RSN: expired PMKSA cache entry for " MACSTR, MAC2STR(entry->aa)); wpa_sm_remove_pmkid(pmksa->sm, entry->aa, entry->pmkid); pmksa_cache_free_entry(pmksa, entry, 0); } pmksa_cache_set_expiration(pmksa); }
/* Create Request Authenticator. The value should be unique over the lifetime * of the shared secret between authenticator and authentication server. * Use one-way MD5 hash calculated from current timestamp and some data given * by the caller. */ void radius_msg_make_authenticator(struct radius_msg *msg, const u8 *data, size_t len) { struct os_time tv; long int l; const u8 *addr[3]; size_t elen[3]; os_get_time(&tv); l = os_random(); addr[0] = (u8 *) &tv; elen[0] = sizeof(tv); addr[1] = data; elen[1] = len; addr[2] = (u8 *) &l; elen[2] = sizeof(l); md5_vector(3, addr, elen, msg->hdr->authenticator); }
void hostapd_trigger_20mhz(struct hostapd_iface *iface) { if (!iface->conf->dynamic_ht40) return; if (!iface->force_20mhz) { iface->force_20mhz = 1; hostapd_set_force_20mhz(iface); } if (!iface->last_20mhz_trigger.sec) { eloop_cancel_timeout(hostapd_restore_40mhz, iface, NULL); eloop_register_timeout(iface->conf->dynamic_ht40, 0, hostapd_restore_40mhz, iface, NULL); } os_get_time(&iface->last_20mhz_trigger); }
int circle_register_timeout(unsigned int secs, unsigned int usecs, circle_timeout_handler handler, void *circle_data, void *user_data) { struct circle_timeout *timeout, *tmp, *prev; timeout = os_malloc(sizeof(*timeout)); if (timeout == NULL) return -1; os_get_time(&timeout->time); timeout->time.sec += secs; timeout->time.usec += usecs; while (timeout->time.usec >= 1000000) { timeout->time.sec++; timeout->time.usec -= 1000000; } timeout->circle_data = circle_data; timeout->user_data = user_data; timeout->handler = handler; timeout->next = NULL; if (circle.timeout == NULL) { circle.timeout = timeout; return 0; } prev = NULL; tmp = circle.timeout; while (tmp != NULL) { if (os_time_before(&timeout->time, &tmp->time)) break; prev = tmp; tmp = tmp->next; } if (prev == NULL) { timeout->next = circle.timeout; circle.timeout = timeout; } else { timeout->next = prev->next; prev->next = timeout; } return 0; }
static int hostapd_acl_cache_get(struct hostapd_data *hapd, const u8 *addr, u32 *session_timeout, u32 *acct_interim_interval, int *vlan_id, struct hostapd_sta_wpa_psk_short **psk, char **identity, char **radius_cui) { struct hostapd_cached_radius_acl *entry; struct os_time now; os_get_time(&now); for (entry = hapd->acl_cache; entry; entry = entry->next) { if (os_memcmp(entry->addr, addr, ETH_ALEN) != 0) continue; if (now.sec - entry->timestamp > RADIUS_ACL_TIMEOUT) return -1; /* entry has expired */ if (entry->accepted == HOSTAPD_ACL_ACCEPT_TIMEOUT) if (session_timeout) *session_timeout = entry->session_timeout; if (acct_interim_interval) *acct_interim_interval = entry->acct_interim_interval; if (vlan_id) *vlan_id = entry->vlan_id; copy_psk_list(psk, entry->psk); if (identity) { if (entry->identity) *identity = os_strdup(entry->identity); else *identity = NULL; } if (radius_cui) { if (entry->radius_cui) *radius_cui = os_strdup(entry->radius_cui); else *radius_cui = NULL; } return entry->accepted; } return -1; }
/** * wpa_supplicant_trigger_scan - Request driver to start a scan * @wpa_s: Pointer to wpa_supplicant data * @params: Scan parameters * Returns: 0 on success, -1 on failure */ int wpa_supplicant_trigger_scan(struct wpa_supplicant *wpa_s, struct wpa_driver_scan_params *params) { int ret; wpa_supplicant_notify_scanning(wpa_s, 1); ret = wpa_drv_scan(wpa_s, params); if (ret) { wpa_supplicant_notify_scanning(wpa_s, 0); wpas_notify_scan_done(wpa_s, 0); } else { os_get_time(&wpa_s->scan_trigger_time); wpa_s->scan_runs++; wpa_s->normal_scans++; } return ret; }
static void blacklist_timeout(void *eloop_ctx, void *timeout_ctx) { struct wpa_supplicant *wpa_s = eloop_ctx; struct wpa_blacklist *e, *prev = NULL, *next = NULL; struct wpa_blacklist *earliest = NULL; struct os_time now; unsigned long next_time; wpa_printf(MSG_DEBUG, "Starting blacklist timeout eloop"); os_get_time(&now); e = wpa_s->blacklist; while (e) { if (now.sec >= e->last_add.sec + BLACKLIST_TIMEOUT) { if (prev == NULL) { wpa_s->blacklist = e->next; } else { prev->next = e->next; } wpa_printf(MSG_DEBUG, "Removed BSSID " MACSTR " from " "blacklist due to timeout", MAC2STR(e->bssid)); next = e->next; os_free(e); e = next; continue; } if (!earliest || os_time_before(&e->last_add, &earliest->last_add)) earliest = e; prev = e; e = e->next; } if (earliest) { next_time = earliest->last_add.sec + BLACKLIST_TIMEOUT - now.sec; eloop_register_timeout(next_time, 0, blacklist_timeout, wpa_s, NULL); } }
int hostapd_neighbor_set(struct hostapd_data *hapd, const u8 *bssid, const struct wpa_ssid_value *ssid, const struct wpabuf *nr, const struct wpabuf *lci, const struct wpabuf *civic, int stationary) { struct hostapd_neighbor_entry *entry; entry = hostapd_neighbor_get(hapd, bssid, ssid); if (!entry) entry = hostapd_neighbor_add(hapd); if (!entry) return -1; hostapd_neighbor_clear_entry(entry); os_memcpy(entry->bssid, bssid, ETH_ALEN); os_memcpy(&entry->ssid, ssid, sizeof(entry->ssid)); entry->nr = wpabuf_dup(nr); if (!entry->nr) goto fail; if (lci && wpabuf_len(lci)) { entry->lci = wpabuf_dup(lci); if (!entry->lci || os_get_time(&entry->lci_date)) goto fail; } if (civic && wpabuf_len(civic)) { entry->civic = wpabuf_dup(civic); if (!entry->civic) goto fail; } entry->stationary = stationary; return 0; fail: hostapd_neighbor_remove(hapd, bssid, ssid); return -1; }
/** * wpa_supplicant_get_scan_results - Get scan results * @wpa_s: Pointer to wpa_supplicant data * @info: Information about what was scanned or %NULL if not available * @new_scan: Whether a new scan was performed * Returns: Scan results, %NULL on failure * * This function request the current scan results from the driver and updates * the local BSS list wpa_s->bss. The caller is responsible for freeing the * results with wpa_scan_results_free(). */ struct wpa_scan_results * wpa_supplicant_get_scan_results(struct wpa_supplicant *wpa_s, struct scan_info *info, int new_scan) { struct wpa_scan_results *scan_res; size_t i; int (*compar)(const void *, const void *) = wpa_scan_result_compar; scan_res = wpa_drv_get_scan_results2(wpa_s); if (scan_res == NULL) { wpa_dbg(wpa_s, MSG_DEBUG, "Failed to get scan results"); return NULL; } if (scan_res->fetch_time.sec == 0) { /* * Make sure we have a valid timestamp if the driver wrapper * does not set this. */ os_get_time(&scan_res->fetch_time); } filter_scan_res(wpa_s, scan_res); #ifdef CONFIG_WPS if (wpas_wps_in_progress(wpa_s)) { wpa_dbg(wpa_s, MSG_DEBUG, "WPS: Order scan results with WPS " "provisioning rules"); compar = wpa_scan_result_wps_compar; } #endif /* CONFIG_WPS */ qsort(scan_res->res, scan_res->num, sizeof(struct wpa_scan_res *), compar); dump_scan_res(scan_res); wpa_bss_update_start(wpa_s); for (i = 0; i < scan_res->num; i++) wpa_bss_update_scan_res(wpa_s, scan_res->res[i], &scan_res->fetch_time); wpa_bss_update_end(wpa_s, info, new_scan); return scan_res; }