#include "wps_er.h"
+static void wps_er_deinit_finish(void *eloop_data, void *user_ctx);
static void wps_er_ap_timeout(void *eloop_data, void *user_ctx);
static void wps_er_sta_timeout(void *eloop_data, void *user_ctx);
static void wps_er_ap_process(struct wps_er_ap *ap, struct wpabuf *msg);
static struct wps_er_sta * wps_er_sta_get(struct wps_er_ap *ap, const u8 *addr)
{
- struct wps_er_sta *sta = ap->sta;
- while (sta) {
+ struct wps_er_sta *sta;
+ dl_list_for_each(sta, &ap->sta, struct wps_er_sta, list) {
if (os_memcmp(sta->addr, addr, ETH_ALEN) == 0)
return sta;
- sta = sta->next;
}
return NULL;
}
os_free(sta->dev_name);
http_client_free(sta->http);
eloop_cancel_timeout(wps_er_sta_timeout, sta, NULL);
+ os_free(sta->cred);
os_free(sta);
}
-static void wps_er_sta_unlink(struct wps_er_sta *sta)
-{
- struct wps_er_sta *prev, *tmp;
- struct wps_er_ap *ap = sta->ap;
- tmp = ap->sta;
- prev = NULL;
- while (tmp) {
- if (tmp == sta) {
- if (prev)
- prev->next = sta->next;
- else
- ap->sta = sta->next;
- return;
- }
- prev = tmp;
- tmp = tmp->next;
- }
-}
-
-
static void wps_er_sta_remove_all(struct wps_er_ap *ap)
{
struct wps_er_sta *prev, *sta;
-
- sta = ap->sta;
- ap->sta = NULL;
-
- while (sta) {
- prev = sta;
- sta = sta->next;
- wps_er_sta_free(prev);
- }
+ dl_list_for_each_safe(sta, prev, &ap->sta, struct wps_er_sta, list)
+ wps_er_sta_free(sta);
}
struct in_addr *addr, const u8 *uuid)
{
struct wps_er_ap *ap;
- for (ap = er->ap; ap; ap = ap->next) {
+ dl_list_for_each(ap, &er->ap, struct wps_er_ap, list) {
if ((addr == NULL || ap->addr.s_addr == addr->s_addr) &&
(uuid == NULL ||
os_memcmp(uuid, ap->uuid, WPS_UUID_LEN) == 0))
- break;
+ return ap;
}
- return ap;
+ return NULL;
}
static struct wps_er_ap * wps_er_ap_get_id(struct wps_er *er, unsigned int id)
{
struct wps_er_ap *ap;
- for (ap = er->ap; ap; ap = ap->next) {
+ dl_list_for_each(ap, &er->ap, struct wps_er_ap, list) {
if (ap->id == id)
- break;
+ return ap;
}
- return ap;
+ return NULL;
}
}
-static void wps_er_ap_free(struct wps_er *er, struct wps_er_ap *ap)
+static void wps_er_ap_free(struct wps_er_ap *ap)
{
- /* TODO: if ap->subscribed, unsubscribe from events if the AP is still
- * alive */
- 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_ap_event(er->wps, ap, WPS_EV_ER_AP_REMOVE);
- os_free(ap->location);
http_client_free(ap->http);
- if (ap->wps)
- wps_deinit(ap->wps);
+ ap->http = NULL;
+ os_free(ap->location);
os_free(ap->friendly_name);
os_free(ap->manufacturer);
os_free(ap->manufacturer_url);
os_free(ap->ap_settings);
- wps_er_sta_remove_all(ap);
-
os_free(ap);
}
-static void wps_er_ap_unlink(struct wps_er *er, struct wps_er_ap *ap)
+static void wps_er_ap_unsubscribed(struct wps_er *er, struct wps_er_ap *ap)
{
- struct wps_er_ap *prev, *tmp;
- tmp = er->ap;
- prev = NULL;
- while (tmp) {
- if (tmp == ap) {
- if (prev)
- prev->next = ap->next;
- else
- er->ap = ap->next;
- return;
- }
- prev = tmp;
- tmp = tmp->next;
+ wpa_printf(MSG_DEBUG, "WPS ER: Unsubscribed from AP %s (%s)",
+ inet_ntoa(ap->addr), ap->location);
+ dl_list_del(&ap->list);
+ wps_er_ap_free(ap);
+
+ if (er->deinitializing && dl_list_empty(&er->ap_unsubscribing)) {
+ eloop_cancel_timeout(wps_er_deinit_finish, er, NULL);
+ wps_er_deinit_finish(er, NULL);
}
}
+static void wps_er_http_unsubscribe_cb(void *ctx, struct http_client *c,
+ enum http_client_event event)
+{
+ struct wps_er_ap *ap = ctx;
+
+ switch (event) {
+ case HTTP_CLIENT_OK:
+ wpa_printf(MSG_DEBUG, "WPS ER: Unsubscribed from events");
+ ap->subscribed = 0;
+ break;
+ case HTTP_CLIENT_FAILED:
+ case HTTP_CLIENT_INVALID_REPLY:
+ case HTTP_CLIENT_TIMEOUT:
+ wpa_printf(MSG_DEBUG, "WPS ER: Failed to unsubscribe from "
+ "events");
+ break;
+ }
+ http_client_free(ap->http);
+ ap->http = NULL;
+
+ /*
+ * Need to get rid of the AP entry regardless of whether we managed to
+ * unsubscribe cleanly or not.
+ */
+ wps_er_ap_unsubscribed(ap->er, ap);
+}
+
+
+static void wps_er_ap_unsubscribe(struct wps_er *er, struct wps_er_ap *ap)
+{
+ struct wpabuf *req;
+ struct sockaddr_in dst;
+ char *url, *path;
+ char sid[100];
+
+ if (ap->event_sub_url == NULL) {
+ wpa_printf(MSG_DEBUG, "WPS ER: No eventSubURL - cannot "
+ "subscribe");
+ goto fail;
+ }
+ if (ap->http) {
+ wpa_printf(MSG_DEBUG, "WPS ER: Pending HTTP request - cannot "
+ "send subscribe request");
+ goto fail;
+ }
+
+ url = http_client_url_parse(ap->event_sub_url, &dst, &path);
+ if (url == NULL) {
+ wpa_printf(MSG_DEBUG, "WPS ER: Failed to parse eventSubURL");
+ goto fail;
+ }
+
+ req = wpabuf_alloc(os_strlen(ap->event_sub_url) + 1000);
+ if (req == NULL) {
+ os_free(url);
+ goto fail;
+ }
+ uuid_bin2str(ap->sid, sid, sizeof(sid));
+ wpabuf_printf(req,
+ "UNSUBSCRIBE %s HTTP/1.1\r\n"
+ "HOST: %s:%d\r\n"
+ "SID: uuid:%s\r\n"
+ "\r\n",
+ path, inet_ntoa(dst.sin_addr), ntohs(dst.sin_port), sid);
+ os_free(url);
+ wpa_hexdump_ascii(MSG_MSGDUMP, "WPS ER: Unsubscription request",
+ wpabuf_head(req), wpabuf_len(req));
+
+ ap->http = http_client_addr(&dst, req, 1000,
+ wps_er_http_unsubscribe_cb, ap);
+ if (ap->http == NULL) {
+ wpabuf_free(req);
+ goto fail;
+ }
+ return;
+
+fail:
+ /*
+ * Need to get rid of the AP entry even when we fail to unsubscribe
+ * cleanly.
+ */
+ wps_er_ap_unsubscribed(ap->er, ap);
+}
+
+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 wps_er_ap_timeout(void *eloop_data, void *user_ctx)
{
struct wps_er *er = eloop_data;
struct wps_er_ap *ap = user_ctx;
wpa_printf(MSG_DEBUG, "WPS ER: AP advertisement timed out");
- wps_er_ap_unlink(er, ap);
- wps_er_ap_free(er, ap);
+ wps_er_ap_remove_entry(er, ap);
+}
+
+
+static int wps_er_get_sid(struct wps_er_ap *ap, char *sid)
+{
+ char *pos;
+ char txt[100];
+
+ if (!sid) {
+ wpa_printf(MSG_DEBUG, "WPS ER: No SID received from %s (%s)",
+ inet_ntoa(ap->addr), ap->location);
+ return -1;
+ }
+
+ pos = os_strstr(sid, "uuid:");
+ if (!pos) {
+ wpa_printf(MSG_DEBUG, "WPS ER: Invalid SID received from "
+ "%s (%s): '%s'", inet_ntoa(ap->addr), ap->location,
+ sid);
+ return -1;
+ }
+
+ pos += 5;
+ if (uuid_str2bin(pos, ap->sid) < 0) {
+ wpa_printf(MSG_DEBUG, "WPS ER: Invalid SID received from "
+ "%s (%s): '%s'", inet_ntoa(ap->addr), ap->location,
+ sid);
+ return -1;
+ }
+
+ uuid_bin2str(ap->sid, txt, sizeof(txt));
+ wpa_printf(MSG_DEBUG, "WPS ER: SID for subscription with %s (%s): %s",
+ inet_ntoa(ap->addr), ap->location, txt);
+
+ return 0;
}
switch (event) {
case HTTP_CLIENT_OK:
wpa_printf(MSG_DEBUG, "WPS ER: Subscribed to events");
+ ap->subscribed = 1;
+ wps_er_get_sid(ap, http_client_get_hdr_line(c, "SID"));
wps_er_ap_event(ap->er->wps, ap, WPS_EV_ER_AP_ADD);
break;
case HTTP_CLIENT_FAILED:
pos = os_strstr(ap->udn, "uuid:");
if (pos) {
pos += 5;
- uuid_str2bin(pos, ap->uuid);
+ if (uuid_str2bin(pos, ap->uuid) < 0)
+ wpa_printf(MSG_DEBUG, "WPS ER: Invalid UUID in UDN");
}
ap->upc = xml_get_first_item(data, "UPC");
ap = os_zalloc(sizeof(*ap));
if (ap == NULL)
return;
+ dl_list_init(&ap->sta);
ap->er = er;
ap->id = ++er->next_ap_id;
ap->location = os_strdup(location);
os_free(ap);
return;
}
- ap->next = er->ap;
- er->ap = ap;
+ dl_list_add(&er->ap, &ap->list);
ap->addr.s_addr = addr->s_addr;
os_memcpy(ap->uuid, uuid, WPS_UUID_LEN);
void wps_er_ap_remove(struct wps_er *er, struct in_addr *addr)
{
- struct wps_er_ap *prev = NULL, *ap = er->ap;
-
- while (ap) {
+ struct wps_er_ap *ap;
+ dl_list_for_each(ap, &er->ap, struct wps_er_ap, list) {
if (ap->addr.s_addr == addr->s_addr) {
- if (prev)
- prev->next = ap->next;
- else
- er->ap = ap->next;
- wps_er_ap_free(er, ap);
+ wps_er_ap_remove_entry(er, ap);
return;
}
- prev = ap;
- ap = ap->next;
}
}
static void wps_er_ap_remove_all(struct wps_er *er)
{
struct wps_er_ap *prev, *ap;
-
- ap = er->ap;
- er->ap = NULL;
-
- while (ap) {
- prev = ap;
- ap = ap->next;
- wps_er_ap_free(er, prev);
- }
+ dl_list_for_each_safe(ap, prev, &er->ap, struct wps_er_ap, list)
+ wps_er_ap_remove_entry(er, ap);
}
{
struct wps_er_sta *sta = eloop_data;
wpa_printf(MSG_DEBUG, "WPS ER: STA entry timed out");
- wps_er_sta_unlink(sta);
+ dl_list_del(&sta->list);
wps_er_sta_free(sta);
}
return NULL;
os_memcpy(sta->addr, addr, ETH_ALEN);
sta->ap = ap;
- sta->next = ap->sta;
- ap->sta = sta;
+ dl_list_add(&ap->sta, &sta->list);
new_sta = 1;
}
}
wps_er_add_sta_data(ap, addr, &attr, 1);
+ wps_registrar_probe_req_rx(ap->er->wps->registrar, addr, msg, 0);
}
return;
sta->wps->er = 1;
sta->wps->use_cred = sta->ap->ap_settings;
+ if (sta->ap->ap_settings) {
+ os_free(sta->cred);
+ sta->cred = os_malloc(sizeof(*sta->cred));
+ if (sta->cred) {
+ os_memcpy(sta->cred, sta->ap->ap_settings,
+ sizeof(*sta->cred));
+ sta->cred->cred_attr = NULL;
+ os_memcpy(sta->cred->mac_addr, sta->addr, ETH_ALEN);
+ sta->wps->use_cred = sta->cred;
+ }
+ }
wps_er_sta_process(sta, msg, WSC_MSG);
}
struct wps_er *
-wps_er_init(struct wps_context *wps, const char *ifname)
+wps_er_init(struct wps_context *wps, const char *ifname, const char *filter)
{
struct wps_er *er;
struct in_addr addr;
er = os_zalloc(sizeof(*er));
if (er == NULL)
return NULL;
+ dl_list_init(&er->ap);
+ dl_list_init(&er->ap_unsubscribing);
er->multicast_sd = -1;
er->ssdp_sd = -1;
os_strlcpy(er->ifname, ifname, sizeof(er->ifname));
er->wps = wps;
- os_get_random((unsigned char *) &er->event_id, sizeof(er->event_id));
+ if (os_get_random((unsigned char *) &er->event_id,
+ sizeof(er->event_id)) < 0) {
+ wps_er_deinit(er, NULL, NULL);
+ return NULL;
+ }
+ /* Limit event_id to < 32 bits to avoid issues with atoi() */
+ er->event_id &= 0x0fffffff;
- if (get_netif_info(ifname,
- &er->ip_addr, &er->ip_addr_text,
- er->mac_addr, &er->mac_addr_text)) {
+ if (filter) {
+ if (inet_aton(filter, &er->filter_addr) == 0) {
+ wpa_printf(MSG_INFO, "WPS UPnP: Invalid filter "
+ "address %s", filter);
+ wps_er_deinit(er, NULL, NULL);
+ return NULL;
+ }
+ wpa_printf(MSG_DEBUG, "WPS UPnP: Only accepting connections "
+ "with %s", filter);
+ }
+ if (get_netif_info(ifname, &er->ip_addr, &er->ip_addr_text,
+ er->mac_addr)) {
wpa_printf(MSG_INFO, "WPS UPnP: Could not get IP/MAC address "
"for %s. Does it have IP address?", ifname);
- wps_er_deinit(er);
+ wps_er_deinit(er, NULL, NULL);
return NULL;
}
if (wps_er_ssdp_init(er) < 0) {
- wps_er_deinit(er);
+ wpa_printf(MSG_INFO, "WPS UPnP: SSDP initialization failed");
+ wps_er_deinit(er, NULL, NULL);
return NULL;
}
addr.s_addr = er->ip_addr;
er->http_srv = http_server_init(&addr, -1, wps_er_http_req, er);
if (er->http_srv == NULL) {
- wps_er_deinit(er);
+ wpa_printf(MSG_INFO, "WPS UPnP: HTTP initialization failed");
+ wps_er_deinit(er, NULL, NULL);
return NULL;
}
er->http_port = http_server_get_port(er->http_srv);
- wpa_printf(MSG_DEBUG, "WPS ER: Start (ifname=%s ip_addr=%s "
- "mac_addr=%s)",
- er->ifname, er->ip_addr_text, er->mac_addr_text);
+ wpa_printf(MSG_DEBUG, "WPS ER: Start (ifname=%s ip_addr=%s)",
+ er->ifname, er->ip_addr_text);
return er;
}
struct wps_er_ap *ap;
struct wps_er_sta *sta;
- for (ap = er->ap; ap; ap = ap->next) {
+ dl_list_for_each(ap, &er->ap, struct wps_er_ap, list) {
wps_er_ap_event(er->wps, ap, WPS_EV_ER_AP_ADD);
- for (sta = ap->sta; sta; sta = sta->next)
+ dl_list_for_each(sta, &ap->sta, struct wps_er_sta, list)
wps_er_sta_event(er->wps, sta, WPS_EV_ER_ENROLLEE_ADD);
}
}
-void wps_er_deinit(struct wps_er *er)
+static void wps_er_deinit_finish(void *eloop_data, void *user_ctx)
+{
+ struct wps_er *er = eloop_data;
+ void (*deinit_done_cb)(void *ctx);
+ void *deinit_done_ctx;
+
+ wpa_printf(MSG_DEBUG, "WPS ER: Finishing deinit");
+
+ deinit_done_cb = er->deinit_done_cb;
+ deinit_done_ctx = er->deinit_done_ctx;
+ os_free(er->ip_addr_text);
+ os_free(er);
+
+ if (deinit_done_cb)
+ deinit_done_cb(deinit_done_ctx);
+}
+
+
+void wps_er_deinit(struct wps_er *er, void (*cb)(void *ctx), void *ctx)
{
if (er == NULL)
return;
http_server_deinit(er->http_srv);
wps_er_ap_remove_all(er);
wps_er_ssdp_deinit(er);
- os_free(er->ip_addr_text);
- os_free(er->mac_addr_text);
- os_free(er);
+ eloop_register_timeout(dl_list_empty(&er->ap_unsubscribing) ? 0 : 5, 0,
+ wps_er_deinit_finish, er, NULL);
+ wpa_printf(MSG_DEBUG, "WPS ER: Finish deinit from timeout");
+ er->deinitializing = 1;
+ er->deinit_done_cb = cb;
+ er->deinit_done_ctx = ctx;
}
return;
}
+ if (ap->wps) {
+ wpa_printf(MSG_DEBUG, "WPS ER: Pending WPS operation for AP - "
+ "skip SetSelectedRegistrar");
+ return;
+ }
+
url = http_client_url_parse(ap->control_url, &dst, &path);
if (url == NULL) {
wpa_printf(MSG_DEBUG, "WPS ER: Failed to parse controlURL");
}
+static int wps_er_build_uuid_r(struct wpabuf *msg, const u8 *uuid_r)
+{
+#ifdef CONFIG_WPS2
+ wpabuf_put_be16(msg, ATTR_UUID_R);
+ wpabuf_put_be16(msg, WPS_UUID_LEN);
+ wpabuf_put_data(msg, uuid_r, WPS_UUID_LEN);
+#endif /* CONFIG_WPS2 */
+ return 0;
+}
+
+
void wps_er_set_sel_reg(struct wps_er *er, int sel_reg, u16 dev_passwd_id,
u16 sel_reg_config_methods)
{
struct wpabuf *msg;
struct wps_er_ap *ap;
+ struct wps_registrar *reg = er->wps->registrar;
+ const u8 *auth_macs;
+ size_t count;
+
+ if (er->skip_set_sel_reg) {
+ wpa_printf(MSG_DEBUG, "WPS ER: Skip SetSelectedRegistrar");
+ return;
+ }
msg = wpabuf_alloc(500);
if (msg == NULL)
return;
+ auth_macs = wps_authorized_macs(reg, &count);
+
if (wps_build_version(msg) ||
wps_er_build_selected_registrar(msg, sel_reg) ||
wps_er_build_dev_password_id(msg, dev_passwd_id) ||
- wps_er_build_sel_reg_config_methods(msg, sel_reg_config_methods)) {
+ wps_er_build_sel_reg_config_methods(msg, sel_reg_config_methods) ||
+ wps_build_wfa_ext(msg, 0, auth_macs, count) ||
+ wps_er_build_uuid_r(msg, er->wps->uuid)) {
wpabuf_free(msg);
return;
}
- for (ap = er->ap; ap; ap = ap->next)
+ dl_list_for_each(ap, &er->ap, struct wps_er_ap, list)
wps_er_send_set_sel_reg(ap, msg);
wpabuf_free(msg);
if (er == NULL || er->wps == NULL)
return -1;
+ if (wps_registrar_pbc_overlap(er->wps->registrar, NULL, NULL)) {
+ wpa_printf(MSG_DEBUG, "WPS ER: PBC overlap - do not start PBC "
+ "mode");
+ return -1;
+ }
+
/*
* TODO: Should enable PBC mode only in a single AP based on which AP
* the Enrollee (uuid) is using. Now, we may end up enabling multiple
static void wps_er_ap_settings_cb(void *ctx, const struct wps_credential *cred)
{
struct wps_er_ap *ap = ctx;
+ union wps_event_data data;
+
wpa_printf(MSG_DEBUG, "WPS ER: AP Settings received");
os_free(ap->ap_settings);
ap->ap_settings = os_malloc(sizeof(*cred));
ap->ap_settings->cred_attr = NULL;
}
- /* TODO: send info through ctrl_iface */
+ os_memset(&data, 0, sizeof(data));
+ data.ap_settings.uuid = ap->uuid;
+ data.ap_settings.cred = cred;
+ ap->er->wps->event_cb(ap->er->wps->cb_ctx, WPS_EV_ER_AP_SETTINGS,
+ &data);
}
static void wps_er_ap_process(struct wps_er_ap *ap, struct wpabuf *msg)
{
enum wps_process_res res;
+ struct wps_parse_attr attr;
+ enum wsc_op_code op_code;
- res = wps_process_msg(ap->wps, WSC_MSG, msg);
+ op_code = WSC_MSG;
+ if (wps_parse_msg(msg, &attr) == 0 && attr.msg_type) {
+ switch (*attr.msg_type) {
+ case WPS_WSC_ACK:
+ op_code = WSC_ACK;
+ break;
+ case WPS_WSC_NACK:
+ op_code = WSC_NACK;
+ break;
+ case WPS_WSC_DONE:
+ op_code = WSC_Done;
+ break;
+ }
+ }
+
+ res = wps_process_msg(ap->wps, op_code, msg);
if (res == WPS_CONTINUE) {
- enum wsc_op_code op_code;
struct wpabuf *next = wps_get_msg(ap->wps, &op_code);
if (next) {
wps_er_ap_put_message(ap, next);
wps_deinit(ap->wps);
ap->wps = NULL;
}
+ } else if (res == WPS_DONE) {
+ wpa_printf(MSG_DEBUG, "WPS ER: Protocol run done");
+ wps_deinit(ap->wps);
+ ap->wps = NULL;
} else {
wpa_printf(MSG_DEBUG, "WPS ER: Failed to process message from "
"AP (res=%d)", res);
if (wps_er_send_get_device_info(ap, wps_er_ap_learn_m1) < 0)
return -1;
- /* TODO: add PIN without SetSelectedRegistrar trigger to all APs */
- wps_registrar_add_pin(er->wps->registrar, uuid, pin, pin_len, 0);
+ er->skip_set_sel_reg = 1;
+ wps_registrar_add_pin(er->wps->registrar, NULL, uuid, pin, pin_len, 0);
+ er->skip_set_sel_reg = 0;
+
+ return 0;
+}
+
+
+static void wps_er_ap_config_m1(struct wps_er_ap *ap, struct wpabuf *m1)
+{
+ struct wps_config cfg;
+
+ if (ap->wps) {
+ wpa_printf(MSG_DEBUG, "WPS ER: Protocol run already in "
+ "progress with this AP");
+ return;
+ }
+
+ os_memset(&cfg, 0, sizeof(cfg));
+ cfg.wps = ap->er->wps;
+ cfg.registrar = 1;
+ cfg.new_ap_settings = ap->ap_settings;
+ ap->wps = wps_init(&cfg);
+ if (ap->wps == NULL)
+ return;
+ ap->wps->ap_settings_cb = NULL;
+ ap->wps->ap_settings_cb_ctx = NULL;
+
+ wps_er_ap_process(ap, m1);
+}
+
+
+int wps_er_config(struct wps_er *er, const u8 *uuid, const u8 *pin,
+ size_t pin_len, const struct wps_credential *cred)
+{
+ struct wps_er_ap *ap;
+
+ if (er == NULL)
+ return -1;
+
+ ap = wps_er_ap_get(er, NULL, uuid);
+ if (ap == NULL) {
+ wpa_printf(MSG_DEBUG, "WPS ER: AP not found for config "
+ "request");
+ return -1;
+ }
+ if (ap->wps) {
+ wpa_printf(MSG_DEBUG, "WPS ER: Pending operation ongoing "
+ "with the AP - cannot start config");
+ return -1;
+ }
+
+ os_free(ap->ap_settings);
+ ap->ap_settings = os_malloc(sizeof(*cred));
+ if (ap->ap_settings == NULL)
+ return -1;
+ os_memcpy(ap->ap_settings, cred, sizeof(*cred));
+ ap->ap_settings->cred_attr = NULL;
+
+ if (wps_er_send_get_device_info(ap, wps_er_ap_config_m1) < 0)
+ return -1;
+
+ er->skip_set_sel_reg = 1;
+ wps_registrar_add_pin(er->wps->registrar, NULL, uuid, pin, pin_len, 0);
+ er->skip_set_sel_reg = 0;
return 0;
}
projects / libeap.git / blobdiff