/**
* 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);
}
