/** * wpa_bss_anqp_free - Free an ANQP data structure * @anqp: ANQP data structure from wpa_bss_anqp_alloc() or wpa_bss_anqp_clone() */ static void wpa_bss_anqp_free(struct wpa_bss_anqp *anqp) { #ifdef CONFIG_INTERWORKING struct wpa_bss_anqp_elem *elem; #endif /* CONFIG_INTERWORKING */ if (anqp == NULL) return; anqp->users--; if (anqp->users > 0) { /* Another BSS entry holds a pointer to this ANQP info */ return; } #ifdef CONFIG_INTERWORKING wpabuf_free(anqp->capability_list); wpabuf_free(anqp->venue_name); wpabuf_free(anqp->network_auth_type); wpabuf_free(anqp->roaming_consortium); wpabuf_free(anqp->ip_addr_type_availability); wpabuf_free(anqp->nai_realm); wpabuf_free(anqp->anqp_3gpp); wpabuf_free(anqp->domain_name); while ((elem = dl_list_first(&anqp->anqp_elems, struct wpa_bss_anqp_elem, list))) { dl_list_del(&elem->list); wpabuf_free(elem->payload); os_free(elem); } #endif /* CONFIG_INTERWORKING */ #ifdef CONFIG_HS20 wpabuf_free(anqp->hs20_capability_list); wpabuf_free(anqp->hs20_operator_friendly_name); wpabuf_free(anqp->hs20_wan_metrics); wpabuf_free(anqp->hs20_connection_capability); wpabuf_free(anqp->hs20_operating_class); wpabuf_free(anqp->hs20_osu_providers_list); #endif /* CONFIG_HS20 */ os_free(anqp); }
/** * subscription_start - Remember a UPnP control point to send events to. * @sm: WPS UPnP state machine from upnp_wps_device_init() * @callback_urls: Callback URLs * Returns: %NULL on error, or pointer to new subscription structure. */ struct subscription * subscription_start(struct upnp_wps_device_sm *sm, const char *callback_urls) { struct subscription *s; time_t now = time(NULL); time_t expire = now + UPNP_SUBSCRIBE_SEC; /* Get rid of expired subscriptions so we have room */ subscription_list_age(sm, now); /* If too many subscriptions, remove oldest */ if (dl_list_len(&sm->subscriptions) >= MAX_SUBSCRIPTIONS) { s = dl_list_first(&sm->subscriptions, struct subscription, list); wpa_printf(MSG_INFO, "WPS UPnP: Too many subscriptions, " "trashing oldest"); dl_list_del(&s->list); subscription_destroy(s); }
void os_free(void *ptr) { struct os_alloc_trace *a; if (ptr == NULL) return; a = (struct os_alloc_trace *) ptr - 1; if (a->magic != ALLOC_MAGIC) { wpa_printf(MSG_INFO, "FREE[%p]: invalid magic 0x%x%s", a, a->magic, a->magic == FREED_MAGIC ? " (already freed)" : ""); wpa_trace_show("Invalid os_free() call"); abort(); } dl_list_del(&a->list); a->magic = FREED_MAGIC; wpa_trace_check_ref(ptr); free(a); }
static void gas_query_done(struct gas_query *gas, struct gas_query_pending *query, enum gas_query_result result) { wpa_msg(gas->wpa_s, MSG_INFO, GAS_QUERY_DONE "addr=" MACSTR " dialog_token=%u freq=%d status_code=%u result=%s", MAC2STR(query->addr), query->dialog_token, query->freq, query->status_code, gas_result_txt(result)); if (gas->current == query) gas->current = NULL; if (query->offchannel_tx_started) offchannel_send_action_done(gas->wpa_s); eloop_cancel_timeout(gas_query_tx_comeback_timeout, gas, query); eloop_cancel_timeout(gas_query_timeout, gas, query); eloop_cancel_timeout(gas_query_rx_comeback_timeout, gas, query); dl_list_del(&query->list); query->cb(query->ctx, query->addr, query->dialog_token, result, query->adv_proto, query->resp, query->status_code); gas_query_free(query, 0); }
static void wps_er_ap_remove_entry(struct wps_er *er, struct wps_er_ap *ap) { wpa_printf(MSG_DEBUG, "WPS ER: Removing AP entry for %s (%s)", inet_ntoa(ap->addr), ap->location); eloop_cancel_timeout(wps_er_ap_timeout, er, ap); wps_er_sta_remove_all(ap); wps_er_ap_event(er->wps, ap, WPS_EV_ER_AP_REMOVE); http_client_free(ap->http); ap->http = NULL; if (ap->wps) { wps_deinit(ap->wps); ap->wps = NULL; } dl_list_del(&ap->list); if (ap->subscribed) { dl_list_add(&er->ap_unsubscribing, &ap->list); wps_er_ap_unsubscribe(er, ap); } else wps_er_ap_free(ap); }
static void gas_server_handle_tx_status(struct gas_server_response *response, int ack) { if (ack && response->offset < wpabuf_len(response->resp)) { wpa_printf(MSG_DEBUG, "GAS: More fragments remaining - keep pending entry"); return; } if (!ack) wpa_printf(MSG_DEBUG, "GAS: No ACK received - drop pending entry"); else wpa_printf(MSG_DEBUG, "GAS: Last fragment of the response sent out - drop pending entry"); response->handler->status_cb(response->handler->ctx, response->resp, ack); response->resp = NULL; dl_list_del(&response->list); gas_server_free_response(response); }
static void wpas_ctrl_msg_send_pending_global(struct wpa_global *global) { struct ctrl_iface_global_priv *gpriv; struct ctrl_iface_msg *msg; gpriv = global->ctrl_iface; while (gpriv && !dl_list_empty(&gpriv->msg_queue) && !wpas_ctrl_iface_throttle(gpriv->sock)) { msg = dl_list_first(&gpriv->msg_queue, struct ctrl_iface_msg, list); if (!msg) break; dl_list_del(&msg->list); wpa_supplicant_ctrl_iface_send( msg->wpa_s, msg->type != WPA_MSG_PER_INTERFACE ? NULL : msg->wpa_s->ifname, gpriv->sock, &gpriv->ctrl_dst, msg->level, msg->txt, msg->len, NULL, gpriv); os_free(msg); } }
err_t tls_netif_remove_status_event(tls_netif_status_event_fn event_fn) { struct tls_netif_status_event *status_event; bool is_exist = FALSE; u32 cpu_sr; if(dl_list_empty(&netif_status_event.list)) return 0; dl_list_for_each(status_event, &netif_status_event.list, struct tls_netif_status_event, list) { if(status_event->status_callback == event_fn) { is_exist = TRUE; break; } } if(is_exist) { cpu_sr = tls_os_set_critical(); dl_list_del(&status_event->list); tls_os_release_critical(cpu_sr); tls_mem_free(status_event); } return 0; }
static void net_free_socket(struct tls_netconn *conn) { int index; u32 cpu_sr; if(conn == NULL || conn->used == false) return; TLS_DBGPRT_INFO("conn ptr = 0x%x\n", conn); if (NULL != conn->op_completed) sys_sem_free(conn->op_completed); conn->used = false; if(conn->client && conn->list.prev != NULL && conn->list.prev != &conn->list) { TLS_DBGPRT_INFO("del from list.\n"); cpu_sr = tls_os_set_critical(); dl_list_del(&conn->list); tls_os_release_critical(cpu_sr); } index = conn->skt_num - 1;//TLS_MAX_NETCONN_NUM - tls_mem_free(conn); cpu_sr = tls_os_set_critical(); conn = NULL; p_net_conn[index] = NULL; tls_os_release_critical(cpu_sr); }
static void secret_deinit(struct wlantest_radius_secret *r) { dl_list_del(&r->list); os_free(r); }
void sta_deinit(struct wlantest_sta *sta) { dl_list_del(&sta->list); os_free(sta->assocreq_ies); os_free(sta); }
void wpa_supplicant_ctrl_iface_deinit(struct ctrl_iface_priv *priv) { struct wpa_ctrl_dst *dst, *prev; struct ctrl_iface_msg *msg, *prev_msg; struct ctrl_iface_global_priv *gpriv; if (priv->sock > -1) { char *fname; char *buf, *dir = NULL; eloop_unregister_read_sock(priv->sock); if (!dl_list_empty(&priv->ctrl_dst)) { /* * Wait before closing the control socket if * there are any attached monitors in order to allow * them to receive any pending messages. */ wpa_printf(MSG_DEBUG, "CTRL_IFACE wait for attached " "monitors to receive messages"); os_sleep(0, 100000); } close(priv->sock); priv->sock = -1; fname = wpa_supplicant_ctrl_iface_path(priv->wpa_s); if (fname) { unlink(fname); os_free(fname); } if (priv->wpa_s->conf->ctrl_interface == NULL) goto free_dst; buf = os_strdup(priv->wpa_s->conf->ctrl_interface); if (buf == NULL) goto free_dst; if (os_strncmp(buf, "DIR=", 4) == 0) { char *gid_str; dir = buf + 4; gid_str = os_strstr(dir, " GROUP="); if (gid_str) *gid_str = '\0'; } else dir = buf; if (rmdir(dir) < 0) { if (errno == ENOTEMPTY) { wpa_printf(MSG_DEBUG, "Control interface " "directory not empty - leaving it " "behind"); } else { wpa_printf(MSG_ERROR, "rmdir[ctrl_interface=%s]: %s", dir, strerror(errno)); } } os_free(buf); } free_dst: dl_list_for_each_safe(dst, prev, &priv->ctrl_dst, struct wpa_ctrl_dst, list) { dl_list_del(&dst->list); os_free(dst); } dl_list_for_each_safe(msg, prev_msg, &priv->msg_queue, struct ctrl_iface_msg, list) { dl_list_del(&msg->list); os_free(msg); } gpriv = priv->wpa_s->global->ctrl_iface; if (gpriv) { dl_list_for_each_safe(msg, prev_msg, &gpriv->msg_queue, struct ctrl_iface_msg, list) { if (msg->wpa_s == priv->wpa_s) { dl_list_del(&msg->list); os_free(msg); } } } eloop_cancel_timeout(wpas_ctrl_msg_queue_timeout, priv->wpa_s, NULL); os_free(priv); }
static void ptk_deinit(struct wlantest_ptk *ptk) { dl_list_del(&ptk->list); os_free(ptk); }
static void eloop_remove_timeout(struct eloop_timeout *timeout) { dl_list_del(&timeout->list); os_free(timeout); }
/** * @brief WPS worker thread * * @param arg * * @return */ void *wps_pbc_work(void *arg) { struct wbr_context *wctx ; struct wbr_wpa_pbc *pvap ; int pid ; char *cmdargs[] = { "/sbin/wpatalk" , NULL , "configthem" , NULL } ; wbr_printf(MSG_DEBUG,"%s: Starting WPS worker ...\n",__func__); wctx = (struct wbr_context *) arg; /* Wait on condition */ pthread_mutex_lock(&wctx->wps_pbc_mutex) ; pthread_cond_wait(&wctx->wps_pbc_cond ,&wctx->wps_pbc_mutex); pthread_mutex_unlock(&wctx->wps_pbc_mutex) ; while(1) { pvap = NULL ; pthread_mutex_lock(&wctx->wps_pbc_mutex) ; if(dl_list_len( &wctx->wps_pbc_head )) { pvap = dl_list_entry(wctx->wps_pbc_head.next, struct wbr_wpa_pbc, list) ; dl_list_del(&pvap->list) ; pthread_mutex_unlock(&wctx->wps_pbc_mutex) ; cmdargs[1] = pvap->name ; pid = 0 ; pid = fork(); if(pid == 0) { /* Child process. * Execute '/sbin/wpatalk <vap> configthem'. */ wbr_printf(MSG_DEBUG,"%s: Execute wpatalk for %s\n", __func__,pvap->name); execve("/sbin/wpatalk" , cmdargs , NULL) ; } else { int stat ; int sleepcount ; int sleepdur ; /* sleep duration in sec */ /* wait on child process */ sleepdur = 5 ; sleepcount = (130) / sleepdur; while(sleepcount) { sleep(sleepdur); stat = waitpid(pid, &stat, WNOHANG); if ( stat == pid ) break ; sleepcount--; } if(sleepcount == 0) { /* Child did not terminate during wait period. * Send signal to terminate child. */ kill(pid , SIGTERM) ; waitpid(pid, &stat, WUNTRACED); } free(pvap) ; } } // end if(dl_list_len( &wctx->wps_pbc_head )) else {
void cli_txt_list_free(struct cli_txt_entry *e) { dl_list_del(&e->list); os_free(e->txt); os_free(e); }
void radius_deinit(struct wlantest_radius *r) { dl_list_del(&r->list); os_free(r); }
static void passphrase_deinit(struct wlantest_passphrase *p) { dl_list_del(&p->list); os_free(p); }
void tdls_deinit(struct wlantest_tdls *tdls) { dl_list_del(&tdls->list); os_free(tdls); }
void pmk_deinit(struct wlantest_pmk *pmk) { dl_list_del(&pmk->list); os_free(pmk); }
static struct wpa_bss * wpa_bss_update(struct wpa_supplicant *wpa_s, struct wpa_bss *bss, struct wpa_scan_res *res, struct os_reltime *fetch_time) { u32 changes; changes = wpa_bss_compare_res(bss, res); if (changes & WPA_BSS_FREQ_CHANGED_FLAG) wpa_printf(MSG_DEBUG, "BSS: " MACSTR " changed freq %d --> %d", MAC2STR(bss->bssid), bss->freq, res->freq); bss->scan_miss_count = 0; bss->last_update_idx = wpa_s->bss_update_idx; wpa_bss_copy_res(bss, res, fetch_time); /* Move the entry to the end of the list */ dl_list_del(&bss->list); #ifdef CONFIG_P2P if (wpa_bss_get_vendor_ie(bss, P2P_IE_VENDOR_TYPE) && !wpa_scan_get_vendor_ie(res, P2P_IE_VENDOR_TYPE)) { /* * This can happen when non-P2P station interface runs a scan * without P2P IE in the Probe Request frame. P2P GO would reply * to that with a Probe Response that does not include P2P IE. * Do not update the IEs in this BSS entry to avoid such loss of * information that may be needed for P2P operations to * determine group information. */ wpa_dbg(wpa_s, MSG_DEBUG, "BSS: Do not update scan IEs for " MACSTR " since that would remove P2P IE information", MAC2STR(bss->bssid)); } else #endif /* CONFIG_P2P */ if (bss->ie_len + bss->beacon_ie_len >= res->ie_len + res->beacon_ie_len) { os_memcpy(bss + 1, res + 1, res->ie_len + res->beacon_ie_len); bss->ie_len = res->ie_len; bss->beacon_ie_len = res->beacon_ie_len; } else { struct wpa_bss *nbss; struct dl_list *prev = bss->list_id.prev; dl_list_del(&bss->list_id); nbss = os_realloc(bss, sizeof(*bss) + res->ie_len + res->beacon_ie_len); if (nbss) { unsigned int i; for (i = 0; i < wpa_s->last_scan_res_used; i++) { if (wpa_s->last_scan_res[i] == bss) { wpa_s->last_scan_res[i] = nbss; break; } } if (wpa_s->current_bss == bss) wpa_s->current_bss = nbss; wpa_bss_update_pending_connect(wpa_s, bss, nbss); bss = nbss; os_memcpy(bss + 1, res + 1, res->ie_len + res->beacon_ie_len); bss->ie_len = res->ie_len; bss->beacon_ie_len = res->beacon_ie_len; } dl_list_add(prev, &bss->list_id); } if (changes & WPA_BSS_IES_CHANGED_FLAG) wpa_bss_set_hessid(bss); dl_list_add_tail(&wpa_s->bss, &bss->list); notify_bss_changes(wpa_s, changes, bss); return bss; }
static void eloop_remove_timeout(struct eloop_timeout *timeout) { dl_list_del(&timeout->list); wpa_trace_remove_ref(timeout, eloop, timeout->eloop_data); wpa_trace_remove_ref(timeout, user, timeout->user_data); os_free(timeout); }