wpa_priv: Add authentication command and event

[mech_eap.git] / wpa_supplicant / wpa_priv.c

diff --git a/wpa_supplicant/wpa_priv.c b/wpa_supplicant/wpa_priv.c
index 0d4aeeb..850ec40 100644 (file)
--- a/wpa_supplicant/wpa_priv.c
+++ b/wpa_supplicant/wpa_priv.c
@@ -31,6 +31,7 @@ struct wpa_priv_interface {
 
        const struct wpa_driver_ops *driver;
        void *drv_priv;
+       void *drv_global_priv;
        struct sockaddr_un drv_addr;
        int wpas_registered;
 
@@ -48,6 +49,10 @@ static void wpa_priv_cmd_register(struct wpa_priv_interface *iface,
                if (iface->driver->deinit)
                        iface->driver->deinit(iface->drv_priv);
                iface->drv_priv = NULL;
+               if (iface->drv_global_priv) {
+                       iface->driver->global_deinit(iface->drv_global_priv);
+                       iface->drv_global_priv = NULL;
+               }
                iface->wpas_registered = 0;
        }
 
@@ -58,10 +63,24 @@ static void wpa_priv_cmd_register(struct wpa_priv_interface *iface,
                iface->l2 = NULL;
        }
 
-       if (iface->driver->init == NULL)
+       if (iface->driver->init2) {
+               if (iface->driver->global_init) {
+                       iface->drv_global_priv = iface->driver->global_init();
+                       if (!iface->drv_global_priv) {
+                               wpa_printf(MSG_INFO,
+                                          "Failed to initialize driver global context");
+                               return;
+                       }
+               } else {
+                       iface->drv_global_priv = NULL;
+               }
+               iface->drv_priv = iface->driver->init2(iface, iface->ifname,
+                                                      iface->drv_global_priv);
+       } else if (iface->driver->init) {
+               iface->drv_priv = iface->driver->init(iface, iface->ifname);
+       } else {
                return;
-
-       iface->drv_priv = iface->driver->init(iface, iface->ifname);
+       }
        if (iface->drv_priv == NULL) {
                wpa_printf(MSG_DEBUG, "Failed to initialize driver wrapper");
                return;
@@ -87,6 +106,10 @@ static void wpa_priv_cmd_unregister(struct wpa_priv_interface *iface,
                if (iface->driver->deinit)
                        iface->driver->deinit(iface->drv_priv);
                iface->drv_priv = NULL;
+               if (iface->drv_global_priv) {
+                       iface->driver->global_deinit(iface->drv_global_priv);
+                       iface->drv_global_priv = NULL;
+               }
                iface->wpas_registered = 0;
        }
 }
@@ -172,6 +195,58 @@ static void wpa_priv_cmd_get_scan_results(struct wpa_priv_interface *iface,
 }
 
 
+static void wpa_priv_cmd_authenticate(struct wpa_priv_interface *iface,
+                                     void *buf, size_t len)
+{
+       struct wpa_driver_auth_params params;
+       struct privsep_cmd_authenticate *auth;
+       int res, i;
+
+       if (iface->drv_priv == NULL || iface->driver->authenticate == NULL)
+               return;
+
+       if (len < sizeof(*auth)) {
+               wpa_printf(MSG_DEBUG, "Invalid authentication request");
+               return;
+       }
+
+       auth = buf;
+       if (sizeof(*auth) + auth->ie_len + auth->sae_data_len > len) {
+               wpa_printf(MSG_DEBUG, "Authentication request overflow");
+               return;
+       }
+
+       os_memset(&params, 0, sizeof(params));
+       params.freq = auth->freq;
+       params.bssid = auth->bssid;
+       params.ssid = auth->ssid;
+       if (auth->ssid_len > SSID_MAX_LEN)
+               return;
+       params.ssid_len = auth->ssid_len;
+       params.auth_alg = auth->auth_alg;
+       for (i = 0; i < 4; i++) {
+               if (auth->wep_key_len[i]) {
+                       params.wep_key[i] = auth->wep_key[i];
+                       params.wep_key_len[i] = auth->wep_key_len[i];
+               }
+       }
+       params.wep_tx_keyidx = auth->wep_tx_keyidx;
+       params.local_state_change = auth->local_state_change;
+       params.p2p = auth->p2p;
+       if (auth->ie_len) {
+               params.ie = (u8 *) (auth + 1);
+               params.ie_len = auth->ie_len;
+       }
+       if (auth->sae_data_len) {
+               params.sae_data = ((u8 *) (auth + 1)) + auth->ie_len;
+               params.sae_data_len = auth->sae_data_len;
+       }
+
+       res = iface->driver->authenticate(iface->drv_priv, &params);
+       wpa_printf(MSG_DEBUG, "drv->authenticate: res=%d", res);
+}
+
+
 static void wpa_priv_cmd_associate(struct wpa_priv_interface *iface,
                                   void *buf, size_t len)
 {
@@ -307,6 +382,10 @@ static void wpa_priv_cmd_get_capa(struct wpa_priv_interface *iface,
            iface->driver->get_capa(iface->drv_priv, &capa) < 0)
                goto fail;
 
+       /* For now, no support for passing extended_capa pointers */
+       capa.extended_capa = NULL;
+       capa.extended_capa_mask = NULL;
+       capa.extended_capa_len = 0;
        sendto(iface->fd, &capa, sizeof(capa), 0, (struct sockaddr *) from,
               sizeof(*from));
        return;
@@ -356,7 +435,8 @@ static void wpa_priv_cmd_l2_register(struct wpa_priv_interface *iface,
        }
 
        proto = reg_cmd[0];
-       if (proto != ETH_P_EAPOL && proto != ETH_P_RSN_PREAUTH) {
+       if (proto != ETH_P_EAPOL && proto != ETH_P_RSN_PREAUTH &&
+           proto != ETH_P_80211_ENCAP) {
                wpa_printf(MSG_DEBUG, "Refused l2_packet connection for "
                           "ethertype 0x%x", proto);
                return;
@@ -529,6 +609,9 @@ static void wpa_priv_receive(int sock, void *eloop_ctx, void *sock_ctx)
                pos[cmd_len] = '\0';
                wpa_priv_cmd_set_country(iface, pos);
                break;
+       case PRIVSEP_CMD_AUTHENTICATE:
+               wpa_priv_cmd_authenticate(iface, cmd_buf, cmd_len);
+               break;
        }
 }
 
@@ -698,6 +781,36 @@ static int wpa_priv_send_event(struct wpa_priv_interface *iface, int event,
 }
 
 
+static void wpa_priv_send_auth(struct wpa_priv_interface *iface,
+                              union wpa_event_data *data)
+{
+       size_t buflen = sizeof(struct privsep_event_auth) + data->auth.ies_len;
+       struct privsep_event_auth *auth;
+       u8 *buf, *pos;
+
+       buf = os_malloc(buflen);
+       if (buf == NULL)
+               return;
+
+       auth = (struct privsep_event_auth *) buf;
+       pos = (u8 *) (auth + 1);
+
+       os_memcpy(auth->peer, data->auth.peer, ETH_ALEN);
+       os_memcpy(auth->bssid, data->auth.bssid, ETH_ALEN);
+       auth->auth_type = data->auth.auth_type;
+       auth->auth_transaction = data->auth.auth_transaction;
+       auth->status_code = data->auth.status_code;
+       if (data->auth.ies) {
+               os_memcpy(pos, data->auth.ies, data->auth.ies_len);
+               auth->ies_len = data->auth.ies_len;
+       }
+
+       wpa_priv_send_event(iface, PRIVSEP_EVENT_AUTH, buf, buflen);
+
+       os_free(buf);
+}
+
+
 static void wpa_priv_send_assoc(struct wpa_priv_interface *iface, int event,
                                union wpa_event_data *data)
 {
@@ -851,6 +964,10 @@ void wpa_supplicant_event(void *ctx, enum wpa_event_type event,
                                    &data->michael_mic_failure.unicast,
                                    sizeof(int));
                break;
+       case EVENT_SCAN_STARTED:
+               wpa_priv_send_event(iface, PRIVSEP_EVENT_SCAN_STARTED, NULL,
+                                   0);
+               break;
        case EVENT_SCAN_RESULTS:
                wpa_priv_send_event(iface, PRIVSEP_EVENT_SCAN_RESULTS, NULL,
                                    0);
@@ -874,9 +991,12 @@ void wpa_supplicant_event(void *ctx, enum wpa_event_type event,
        case EVENT_FT_RESPONSE:
                wpa_priv_send_ft_response(iface, data);
                break;
+       case EVENT_AUTH:
+               wpa_priv_send_auth(iface, data);
+               break;
        default:
-               wpa_printf(MSG_DEBUG, "Unsupported driver event %d - TODO",
-                          event);
+               wpa_printf(MSG_DEBUG, "Unsupported driver event %d (%s) - TODO",
+                          event, event_to_string(event));
                break;
        }
 }