usr/src/cmd/cmd-inet/usr.lib/wpad/wpa_supplicant.c

   1 /*
   2  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
   3  * Use is subject to license terms.
   4  */
   5
   6 /*
   7  * Copyright (c) 2003-2004, Jouni Malinen <jkmaline@cc.hut.fi>
   8  * Sun elects to license this software under the BSD license.
   9  * See README for more details.
  10  */
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <stdarg.h>
  15 #include <unistd.h>
  16 #include <string.h>
  17 #include <syslog.h>
  18 #include <sys/stat.h>
  19 #include <errno.h>
  20 #include <signal.h>
  21 #include <fcntl.h>
  22 #include <door.h>
  23 #include <libscf.h>
  24 #include <libdladm.h>
  25 #include <libdllink.h>
  26 #include <sys/ethernet.h>
  27
  28 #include "wpa_impl.h"
  29 #include "wpa_enc.h"
  30 #include "driver.h"
  31 #include "eloop.h"
  32 #include "l2_packet.h"
  33
  34 extern struct wpa_driver_ops wpa_driver_wifi_ops;
  35 int wpa_debug_level = MSG_ERROR;
  36
  37 /*
  38  * wpa_printf - conditional printf
  39  * @level: priority level (MSG_*) of the message
  40  * @fmt: printf format string, followed by optional arguments
  41  *
  42  * This function is used to print conditional debugging and error messages. The
  43  * output may be directed to stdout, stderr, and/or syslog based on
  44  * configuration.
  45  */
  46 void
  47 wpa_printf(int level, char *fmt, ...)
  48 {
  49         va_list ap;
  50         char buffer[MAX_LOGBUF];
  51
  52         if (level < wpa_debug_level)
  53                 return;
  54
  55         va_start(ap, fmt);
  56
  57         /* LINTED E_SEC_PRINTF_VAR_FMT */
  58         (void) vsnprintf(buffer, sizeof (buffer), fmt, ap);
  59
  60         va_end(ap);
  61
  62         syslog(LOG_NOTICE | LOG_DAEMON, "%s", buffer);
  63 }
  64
  65 /*
  66  * wpa_hexdump - conditional hex dump
  67  * @level: priority level (MSG_*) of the message
  68  * @title: title of for the message
  69  * @buf: data buffer to be dumped
  70  * @len: length of the @buf
  71  *
  72  * This function is used to print conditional debugging and error messages. The
  73  * output may be directed to stdout, stderr, and/or syslog based on
  74  * configuration. The contents of @buf is printed out has hex dump.
  75  */
  76 void
  77 wpa_hexdump(int level, const char *title, const uint8_t *buf, size_t len)
  78 {
  79         size_t i;
  80         char buffer[MAX_LOGBUF], tmp[4];
  81         int n;
  82
  83         if (level < wpa_debug_level)
  84                 return;
  85
  86         (void) snprintf(buffer, sizeof (buffer), "%s - hexdump(len=%d):",
  87             title, len);
  88         n = strlen(buffer);
  89
  90         for (i = 0; i < len; i++) {
  91                 (void) sprintf(tmp, " %02x", buf[i]);
  92
  93                 n += strlen(tmp);
  94                 if (n >= MAX_LOGBUF) break;
  95
  96                 (void) strlcat(buffer, tmp, sizeof (buffer));
  97         }
  98
  99         syslog(LOG_NOTICE | LOG_DAEMON, "%s", buffer);
 100 }
 101
 102 static const char *
 103 wpa_ssid_txt(char *ssid, size_t ssid_len)
 104 {
 105         static char ssid_txt[MAX_ESSID_LENGTH + 1];
 106         char *pos;
 107
 108         if (ssid_len > MAX_ESSID_LENGTH)
 109                 ssid_len = MAX_ESSID_LENGTH;
 110         (void) memcpy(ssid_txt, ssid, ssid_len);
 111         ssid_txt[ssid_len] = '\0';
 112         for (pos = ssid_txt; *pos != '\0'; pos ++) {
 113                 if ((uint8_t)*pos < 32 || (uint8_t)*pos >= 127)
 114                         *pos = '_';
 115         }
 116         return (ssid_txt);
 117 }
 118
 119 /* ARGSUSED */
 120 void
 121 wpa_supplicant_scan(void *eloop_ctx, void *timeout_ctx)
 122 {
 123         struct wpa_supplicant *wpa_s = eloop_ctx;
 124         struct wpa_ssid *ssid;
 125
 126         if (wpa_s->conf == NULL)
 127                 return;
 128
 129         if (wpa_s->wpa_state == WPA_DISCONNECTED)
 130                 wpa_s->wpa_state = WPA_SCANNING;
 131
 132         ssid = wpa_s->conf->ssid;
 133         wpa_printf(MSG_DEBUG, "Starting AP scan (%s SSID)",
 134             ssid ? "specific": "broadcast");
 135
 136         if (ssid) {
 137                 wpa_printf(MSG_DEBUG, "Scan SSID: %s", ssid->ssid);
 138         }
 139
 140         if (wpa_s->driver->scan(wpa_s->handle, wpa_s->linkid)) {
 141                 wpa_printf(MSG_WARNING, "Failed to initiate AP scan.");
 142         }
 143 }
 144
 145 void
 146 wpa_supplicant_req_scan(struct wpa_supplicant *wpa_s, int sec, int usec)
 147 {
 148         wpa_printf(MSG_DEBUG, "Setting scan request: %d sec %d usec",
 149             sec, usec);
 150         (void) eloop_cancel_timeout(wpa_supplicant_scan, wpa_s, NULL);
 151         (void) eloop_register_timeout(sec, usec, wpa_supplicant_scan,
 152             wpa_s, NULL);
 153 }
 154
 155 void
 156 wpa_supplicant_cancel_scan(struct wpa_supplicant *wpa_s)
 157 {
 158         wpa_printf(MSG_DEBUG, "Cancelling scan request");
 159         eloop_cancel_timeout(wpa_supplicant_scan, wpa_s, NULL);
 160 }
 161
 162 /* ARGSUSED */
 163 static void
 164 wpa_supplicant_timeout(void *eloop_ctx, void *timeout_ctx)
 165 {
 166         struct wpa_supplicant *wpa_s = eloop_ctx;
 167
 168         wpa_printf(MSG_INFO, "Authentication with " MACSTR " timed out.",
 169             MAC2STR(wpa_s->bssid));
 170
 171         wpa_s->reassociate = 1;
 172         wpa_supplicant_req_scan(wpa_s, 0, 0);
 173 }
 174
 175 void
 176 wpa_supplicant_req_auth_timeout(struct wpa_supplicant *wpa_s,
 177                                 int sec, int usec)
 178 {
 179         wpa_printf(MSG_DEBUG, "Setting authentication timeout: %d sec "
 180             "%d usec", sec, usec);
 181         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
 182         (void) eloop_register_timeout(sec, usec, wpa_supplicant_timeout,
 183             wpa_s, NULL);
 184 }
 185
 186 void
 187 wpa_supplicant_cancel_auth_timeout(struct wpa_supplicant *wpa_s)
 188 {
 189         wpa_printf(MSG_DEBUG, "Cancelling authentication timeout");
 190         eloop_cancel_timeout(wpa_supplicant_timeout, wpa_s, NULL);
 191 }
 192
 193 static void
 194 wpa_supplicant_cleanup(struct wpa_supplicant *wpa_s)
 195 {
 196         l2_packet_deinit(wpa_s->l2);
 197         wpa_s->l2 = NULL;
 198
 199         if (wpa_s->conf != NULL) {
 200                 wpa_config_free(wpa_s->conf);
 201                 wpa_s->conf = NULL;
 202         }
 203
 204         dladm_close(wpa_s->handle);
 205         free(wpa_s->ap_wpa_ie);
 206         pmksa_candidate_free(wpa_s);
 207         pmksa_cache_free(wpa_s);
 208 }
 209
 210 static void
 211 wpa_clear_keys(struct wpa_supplicant *wpa_s, uint8_t *addr)
 212 {
 213         wpa_s->driver->set_key(wpa_s->handle, wpa_s->linkid, WPA_ALG_NONE,
 214             (uint8_t *)"\xff\xff\xff\xff\xff\xff", 0, 0, NULL, 0, NULL, 0);
 215         wpa_s->driver->set_key(wpa_s->handle, wpa_s->linkid, WPA_ALG_NONE,
 216             (uint8_t *)"\xff\xff\xff\xff\xff\xff", 1, 0, NULL, 0, NULL, 0);
 217         wpa_s->driver->set_key(wpa_s->handle, wpa_s->linkid, WPA_ALG_NONE,
 218             (uint8_t *)"\xff\xff\xff\xff\xff\xff", 2, 0, NULL, 0, NULL, 0);
 219         wpa_s->driver->set_key(wpa_s->handle, wpa_s->linkid, WPA_ALG_NONE,
 220             (uint8_t *)"\xff\xff\xff\xff\xff\xff", 3, 0, NULL, 0, NULL, 0);
 221         if (addr) {
 222                 wpa_s->driver->set_key(wpa_s->handle, wpa_s->linkid,
 223                     WPA_ALG_NONE, addr, 0, 0, NULL, 0, NULL, 0);
 224         }
 225 }
 226
 227 static void
 228 wpa_supplicant_mark_disassoc(struct wpa_supplicant *wpa_s)
 229 {
 230         wpa_s->wpa_state = WPA_DISCONNECTED;
 231         (void) memset(wpa_s->bssid, 0, IEEE80211_ADDR_LEN);
 232 }
 233
 234 static int
 235 wpa_supplicant_set_suites(struct wpa_supplicant *wpa_s,
 236     dladm_wlan_ess_t *bss, struct wpa_ssid *ssid,
 237     uint8_t *wpa_ie, int *wpa_ie_len)
 238 {
 239         struct wpa_ie_data ie;
 240         int sel, proto;
 241         uint8_t *ap_ie;
 242         size_t ap_ie_len;
 243
 244         /* RSN or WPA */
 245         if (bss->we_wpa_ie_len && bss->we_wpa_ie[0] == RSN_INFO_ELEM &&
 246             (ssid->proto & WPA_PROTO_RSN)) {
 247                 wpa_printf(MSG_DEBUG, "RSN: using IEEE 802.11i/D9.0");
 248                 proto = WPA_PROTO_RSN;
 249         } else {
 250                 wpa_printf(MSG_DEBUG, "WPA: using IEEE 802.11i/D3.0");
 251                 proto = WPA_PROTO_WPA;
 252         }
 253
 254         ap_ie = bss->we_wpa_ie;
 255         ap_ie_len = bss->we_wpa_ie_len;
 256
 257         if (wpa_parse_wpa_ie(wpa_s, ap_ie, ap_ie_len, &ie)) {
 258                 wpa_printf(MSG_WARNING, "WPA: Failed to parse WPA IE for "
 259                     "the selected BSS.");
 260                 return (-1);
 261         }
 262
 263         wpa_s->proto = proto;
 264         free(wpa_s->ap_wpa_ie);
 265         wpa_s->ap_wpa_ie = malloc(ap_ie_len);
 266         (void) memcpy(wpa_s->ap_wpa_ie, ap_ie, ap_ie_len);
 267         wpa_s->ap_wpa_ie_len = ap_ie_len;
 268
 269         sel = ie.group_cipher & ssid->group_cipher;
 270         if (sel & WPA_CIPHER_CCMP) {
 271                 wpa_s->group_cipher = WPA_CIPHER_CCMP;
 272         } else if (sel & WPA_CIPHER_TKIP) {
 273                 wpa_s->group_cipher = WPA_CIPHER_TKIP;
 274         } else if (sel & WPA_CIPHER_WEP104) {
 275                 wpa_s->group_cipher = WPA_CIPHER_WEP104;
 276         } else if (sel & WPA_CIPHER_WEP40) {
 277                 wpa_s->group_cipher = WPA_CIPHER_WEP40;
 278         } else {
 279                 wpa_printf(MSG_WARNING, "WPA: Failed to select group cipher.");
 280                 return (-1);
 281         }
 282
 283         sel = ie.pairwise_cipher & ssid->pairwise_cipher;
 284         if (sel & WPA_CIPHER_CCMP) {
 285                 wpa_s->pairwise_cipher = WPA_CIPHER_CCMP;
 286         } else if (sel & WPA_CIPHER_TKIP) {
 287                 wpa_s->pairwise_cipher = WPA_CIPHER_TKIP;
 288         } else if (sel & WPA_CIPHER_NONE) {
 289                 wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
 290         } else {
 291                 wpa_printf(MSG_WARNING, "WPA: Failed to select pairwise "
 292                     "cipher.");
 293                 return (-1);
 294         }
 295
 296         sel = ie.key_mgmt & ssid->key_mgmt;
 297         if (sel & WPA_KEY_MGMT_IEEE8021X) {
 298                 wpa_s->key_mgmt = WPA_KEY_MGMT_IEEE8021X;
 299         } else if (sel & WPA_KEY_MGMT_PSK) {
 300                 wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
 301         } else {
 302                 wpa_printf(MSG_WARNING, "WPA: Failed to select authenticated "
 303                     "key management type.");
 304                 return (-1);
 305         }
 306
 307         *wpa_ie_len = wpa_gen_wpa_ie(wpa_s, wpa_ie);
 308         if (*wpa_ie_len < 0) {
 309                 wpa_printf(MSG_WARNING, "WPA: Failed to generate WPA IE.");
 310                 return (-1);
 311         }
 312         wpa_hexdump(MSG_DEBUG, "WPA: Own WPA IE", wpa_ie, *wpa_ie_len);
 313
 314         if (ssid->key_mgmt & WPA_KEY_MGMT_PSK)
 315                 (void) memcpy(wpa_s->pmk, ssid->psk, PMK_LEN);
 316         else if (wpa_s->cur_pmksa)
 317                 (void) memcpy(wpa_s->pmk, wpa_s->cur_pmksa->pmk, PMK_LEN);
 318         else {
 319                 (void) memset(wpa_s->pmk, 0, PMK_LEN);
 320         }
 321
 322         return (0);
 323 }
 324
 325 static void wpa_supplicant_associate(struct wpa_supplicant *wpa_s,
 326     dladm_wlan_ess_t *bss, struct wpa_ssid *ssid)
 327 {
 328         uint8_t wpa_ie[IEEE80211_MAX_OPT_IE];
 329         int wpa_ie_len;
 330
 331         wpa_s->reassociate = 0;
 332         wpa_printf(MSG_DEBUG, "Trying to associate with " MACSTR
 333             " (SSID='%s' freq=%d MHz)", MAC2STR(bss->we_bssid.wb_bytes),
 334             wpa_ssid_txt((char *)ssid->ssid, ssid->ssid_len), bss->we_freq);
 335         wpa_supplicant_cancel_scan(wpa_s);
 336
 337         if (bss->we_wpa_ie_len &&
 338             (ssid->key_mgmt & (WPA_KEY_MGMT_IEEE8021X | WPA_KEY_MGMT_PSK))) {
 339                 wpa_s->cur_pmksa = pmksa_cache_get(wpa_s,
 340                     bss->we_bssid.wb_bytes, NULL);
 341                 if (wpa_s->cur_pmksa) {
 342                         wpa_hexdump(MSG_DEBUG, "RSN: PMKID",
 343                             wpa_s->cur_pmksa->pmkid, PMKID_LEN);
 344                 }
 345                 if (wpa_supplicant_set_suites(wpa_s, bss, ssid,
 346                     wpa_ie, &wpa_ie_len)) {
 347                         wpa_printf(MSG_WARNING, "WPA: Failed to set WPA key "
 348                             "management and encryption suites");
 349                         return;
 350                 }
 351         } else {
 352                 wpa_ie_len = 0;
 353         }
 354
 355         wpa_clear_keys(wpa_s, bss->we_bssid.wb_bytes);
 356         wpa_s->wpa_state = WPA_ASSOCIATING;
 357         wpa_s->driver->associate(wpa_s->handle, wpa_s->linkid,
 358             (const char *)bss->we_bssid.wb_bytes, wpa_ie, wpa_ie_len);
 359
 360         /* Timeout for IEEE 802.11 authentication and association */
 361         wpa_supplicant_req_auth_timeout(wpa_s, 15, 0);
 362 }
 363
 364 void
 365 wpa_supplicant_disassociate(struct wpa_supplicant *wpa_s, int reason_code)
 366 {
 367         uint8_t *addr = NULL;
 368         wpa_s->wpa_state = WPA_DISCONNECTED;
 369         if (memcmp(wpa_s->bssid, "\x00\x00\x00\x00\x00\x00",
 370             IEEE80211_ADDR_LEN) != 0) {
 371                 wpa_s->driver->disassociate(wpa_s->handle, wpa_s->linkid,
 372                     reason_code);
 373                 addr = wpa_s->bssid;
 374         }
 375         wpa_clear_keys(wpa_s, addr);
 376 }
 377
 378 static dladm_wlan_ess_t *
 379 wpa_supplicant_select_bss(struct wpa_supplicant *wpa_s, struct wpa_ssid *group,
 380     dladm_wlan_ess_t *results, int num, struct wpa_ssid **selected_ssid)
 381 {
 382         struct wpa_ssid *ssid;
 383         dladm_wlan_ess_t *bss, *selected = NULL;
 384         int i;
 385
 386         struct wpa_ie_data ie;
 387
 388         wpa_printf(MSG_DEBUG, "Selecting BSS from scan results (%d)", num);
 389
 390         bss = NULL;
 391         ssid = NULL;
 392
 393         /* try to find matched AP */
 394         for (i = 0; i < num && !selected; i++) {
 395                 bss = &results[i];
 396                 wpa_printf(MSG_DEBUG, "%d: " MACSTR " ssid='%s' "
 397                     "wpa_ie_len=%d",
 398                     i, MAC2STR(bss->we_bssid.wb_bytes),
 399                     wpa_ssid_txt(bss->we_ssid.we_bytes, bss->we_ssid_len),
 400                     bss->we_wpa_ie_len);
 401                 if (bss->we_wpa_ie_len == 0) {
 402                         wpa_printf(MSG_DEBUG, "   skip - no WPA/RSN IE");
 403                 }
 404
 405                 ssid = group;
 406                 if (bss->we_ssid_len != ssid->ssid_len ||
 407                     memcmp(bss->we_ssid.we_bytes, ssid->ssid,
 408                     bss->we_ssid_len) != 0) {
 409                         wpa_printf(MSG_DEBUG, "   skip - SSID mismatch");
 410                         continue;
 411                 }
 412                 if (!((ssid->proto & (WPA_PROTO_RSN | WPA_PROTO_WPA)) &&
 413                     wpa_parse_wpa_ie(wpa_s, bss->we_wpa_ie,
 414                     bss->we_wpa_ie_len, &ie) == 0)) {
 415                         wpa_printf(MSG_DEBUG, "   skip - "
 416                             "could not parse WPA/RSN IE");
 417                         continue;
 418                 }
 419                 if (!(ie.proto & ssid->proto)) {
 420                         wpa_printf(MSG_DEBUG, "   skip - proto mismatch");
 421                         continue;
 422                 }
 423                 if (!(ie.pairwise_cipher & ssid->pairwise_cipher)) {
 424                         wpa_printf(MSG_DEBUG, "   skip - PTK cipher mismatch");
 425                         continue;
 426                 }
 427                 if (!(ie.group_cipher & ssid->group_cipher)) {
 428                         wpa_printf(MSG_DEBUG, "   skip - GTK cipher mismatch");
 429                         continue;
 430                 }
 431                 if (!(ie.key_mgmt & ssid->key_mgmt)) {
 432                         wpa_printf(MSG_DEBUG, "   skip - key mgmt mismatch");
 433                         continue;
 434                 }
 435
 436                 selected = bss;
 437                 *selected_ssid = ssid;
 438                 wpa_printf(MSG_DEBUG, "   selected");
 439         }
 440
 441         return (selected);
 442 }
 443
 444
 445 static void
 446 wpa_supplicant_scan_results(struct wpa_supplicant *wpa_s)
 447 {
 448         dladm_wlan_ess_t results[MAX_SCANRESULTS];
 449         int num;
 450         dladm_wlan_ess_t *selected = NULL;
 451         struct wpa_ssid *ssid;
 452
 453         (void) memset(results, 0, sizeof (dladm_wlan_ess_t) * MAX_SCANRESULTS);
 454         num = wpa_s->driver->get_scan_results(wpa_s->handle, wpa_s->linkid,
 455             results, MAX_SCANRESULTS);
 456         wpa_printf(MSG_DEBUG, "Scan results: %d", num);
 457         if (num < 0)
 458                 return;
 459         if (num > MAX_SCANRESULTS) {
 460                 wpa_printf(MSG_INFO, "Not enough room for all APs (%d < %d)",
 461                     num, MAX_SCANRESULTS);
 462                 num = MAX_SCANRESULTS;
 463         }
 464
 465         selected = wpa_supplicant_select_bss(wpa_s,
 466             wpa_s->conf->ssid, results, num, &ssid);
 467
 468         if (selected) {
 469                 if (wpa_s->reassociate ||
 470                     memcmp(selected->we_bssid.wb_bytes, wpa_s->bssid,
 471                     IEEE80211_ADDR_LEN) != 0) {
 472                         wpa_supplicant_associate(wpa_s, selected, ssid);
 473                 } else {
 474                         wpa_printf(MSG_DEBUG, "Already associated with the "
 475                             "selected AP.");
 476                 }
 477         } else {
 478                 wpa_printf(MSG_DEBUG, "No suitable AP found.");
 479                 wpa_supplicant_req_scan(wpa_s, 5, 0);   /* wait 5 seconds */
 480         }
 481 }
 482
 483 /*
 484  * wpa_event_handler - report a driver event for wpa_supplicant
 485  * @wpa_s: pointer to wpa_supplicant data; this is the @ctx variable registered
 486  *      with wpa_driver_events_init()
 487  * @event: event type (defined above)
 488  *
 489  * Driver wrapper code should call this function whenever an event is received
 490  * from the driver.
 491  */
 492 void
 493 wpa_event_handler(void *cookie, wpa_event_type event)
 494 {
 495         struct wpa_supplicant *wpa_s = cookie;
 496
 497         switch (event) {
 498         case EVENT_ASSOC:
 499                 wpa_printf(MSG_DEBUG, "\nAssociation event\n");
 500                 /* async event */
 501                 if (wpa_s->wpa_state < WPA_ASSOCIATED) {
 502                         wpa_s->wpa_state = WPA_ASSOCIATED;
 503                         if (wpa_s->key_mgmt == WPA_KEY_MGMT_NONE) {
 504                                 wpa_supplicant_cancel_auth_timeout(wpa_s);
 505                         } else {
 506                                 /* Timeout for receiving first EAPOL packet */
 507                                 wpa_supplicant_req_auth_timeout(wpa_s, 10, 0);
 508                         }
 509                 }
 510                 break;
 511         case EVENT_DISASSOC:
 512                 if (wpa_s->wpa_state >= WPA_ASSOCIATED)
 513                         wpa_supplicant_req_scan(wpa_s, 0, 100000);
 514                 wpa_supplicant_mark_disassoc(wpa_s);
 515                 wpa_printf(MSG_DEBUG, "Disconnect event - remove keys");
 516                 if (wpa_s->key_mgmt != WPA_KEY_MGMT_NONE)
 517                         wpa_clear_keys(wpa_s, wpa_s->bssid);
 518                 break;
 519         case EVENT_SCAN_RESULTS:
 520                 wpa_supplicant_scan_results(wpa_s);
 521                 /* reset vars */
 522                 (void) memset(wpa_s->rx_replay_counter, 0,
 523                     WPA_REPLAY_COUNTER_LEN);
 524                 wpa_s->rx_replay_counter_set = 0;
 525                 wpa_s->renew_snonce = 1;
 526                 wpa_s->eapol_received = 0;
 527                 break;
 528         default:
 529                 wpa_printf(MSG_INFO, "Unknown event %d", event);
 530                 break;
 531         }
 532 }
 533
 534 /* ARGSUSED */
 535 static void
 536 wpa_supplicant_terminate(int sig, void *eloop_ctx, void *signal_ctx)
 537 {
 538         wpa_printf(MSG_INFO, "Signal %d received - terminating", sig);
 539         eloop_terminate();
 540 }
 541
 542 static int
 543 wpa_supplicant_driver_init(const char *link, struct wpa_supplicant *wpa_s)
 544 {
 545         wpa_s->l2 = l2_packet_init(link, ETHERTYPE_EAPOL,
 546             wpa_supplicant_rx_eapol, wpa_s);
 547         if (wpa_s->l2 == NULL)
 548                 return (-1);
 549
 550         if (l2_packet_get_own_addr(wpa_s->l2, wpa_s->own_addr)) {
 551                 (void) fprintf(stderr, "Failed to get own L2 address\n");
 552                 return (-1);
 553         }
 554
 555         if (wpa_s->driver->set_wpa(wpa_s->handle, wpa_s->linkid, 1) < 0) {
 556                 wpa_printf(MSG_ERROR, "Failed to enable WPA in the driver.");
 557                 return (-1);
 558         }
 559
 560         wpa_clear_keys(wpa_s, NULL);
 561         wpa_supplicant_req_scan(wpa_s, 0, 100000);
 562
 563         return (0);
 564 }
 565
 566 static int door_id = -1;
 567
 568 /* ARGSUSED */
 569 static void
 570 event_handler(void *cookie, char *argp, size_t asize,
 571     door_desc_t *dp, uint_t n_desc)
 572 {
 573         wpa_event_type event;
 574
 575         /* LINTED E_BAD_PTR_CAST_ALIGN */
 576         event = ((wl_events_t *)argp)->event;
 577         wpa_event_handler(cookie, event);
 578
 579         (void) door_return(NULL, 0, NULL, 0);
 580 }
 581
 582 /*
 583  * Create the driver to wpad door
 584  */
 585 int
 586 wpa_supplicant_door_setup(void *cookie, char *doorname)
 587 {
 588         struct stat stbuf;
 589         int error = 0;
 590
 591         wpa_printf(MSG_DEBUG, "wpa_supplicant_door_setup(%s)", doorname);
 592         /*
 593          * Create the door
 594          */
 595         door_id = door_create(event_handler, cookie,
 596             DOOR_UNREF | DOOR_REFUSE_DESC | DOOR_NO_CANCEL);
 597
 598         if (door_id < 0) {
 599                 error = -1;
 600                 goto out;
 601         }
 602
 603         if (stat(doorname, &stbuf) < 0) {
 604                 int newfd;
 605                 if ((newfd = creat(doorname, 0666)) < 0) {
 606                         (void) door_revoke(door_id);
 607                         door_id = -1;
 608                         error = -1;
 609
 610                         goto out;
 611                 }
 612                 (void) close(newfd);
 613         }
 614
 615         if (fattach(door_id, doorname) < 0) {
 616                 if ((errno != EBUSY) || (fdetach(doorname) < 0) ||
 617                     (fattach(door_id, doorname) < 0)) {
 618                         (void) door_revoke(door_id);
 619                         door_id = -1;
 620                         error = -1;
 621
 622                         goto out;
 623                 }
 624         }
 625
 626 out:
 627         return (error);
 628 }
 629
 630 void
 631 wpa_supplicant_door_destroy(char *doorname)
 632 {
 633         wpa_printf(MSG_DEBUG, "wpa_supplicant_door_destroy(%s)\n", doorname);
 634
 635         if (door_id == -1)
 636                 return;
 637
 638         if (door_revoke(door_id) == -1) {
 639                 wpa_printf(MSG_ERROR, "failed to door_revoke(%d) %s, exiting.",
 640                     door_id, strerror(errno));
 641         }
 642
 643         if (fdetach(doorname) == -1) {
 644                 wpa_printf(MSG_ERROR, "failed to fdetach %s: %s, exiting.",
 645                     doorname, strerror(errno));
 646         }
 647
 648         (void) close(door_id);
 649 }
 650
 651 static int
 652 wpa_config_parse_ssid(struct wpa_ssid *ssid, int line, const char *value)
 653 {
 654         free(ssid->ssid);
 655
 656         ssid->ssid = (uint8_t *)strdup(value);
 657         ssid->ssid_len = strlen(value);
 658
 659         if (ssid->ssid == NULL) {
 660                 wpa_printf(MSG_ERROR, "Invalid SSID '%s'.", line, value);
 661                 return (-1);
 662         }
 663         if (ssid->ssid_len > MAX_ESSID_LENGTH) {
 664                 free(ssid->ssid);
 665                 wpa_printf(MSG_ERROR, "Too long SSID '%s'.", line, value);
 666                 return (-1);
 667         }
 668         wpa_printf(MSG_MSGDUMP, "SSID: %s", ssid->ssid);
 669         return (0);
 670 }
 671
 672 static struct wpa_ssid *
 673 wpa_config_read_network(struct wpa_supplicant *wpa_s)
 674 {
 675         struct wpa_ssid *ssid;
 676         char buf[MAX_ESSID_LENGTH + 1];
 677         dladm_secobj_class_t cl;
 678         uint8_t psk[MAX_PSK_LENGTH + 1];
 679         uint_t key_len;
 680
 681         wpa_printf(MSG_MSGDUMP, "Start of a new network configration");
 682
 683         ssid = (struct wpa_ssid *)malloc(sizeof (*ssid));
 684         if (ssid == NULL)
 685                 return (NULL);
 686         (void) memset(ssid, 0, sizeof (*ssid));
 687
 688         /*
 689          * Set default supported values
 690          */
 691         ssid->proto = WPA_PROTO_WPA | WPA_PROTO_RSN;
 692         ssid->pairwise_cipher = WPA_CIPHER_CCMP | WPA_CIPHER_TKIP;
 693         ssid->group_cipher = WPA_CIPHER_CCMP | WPA_CIPHER_TKIP |
 694             WPA_CIPHER_WEP104 | WPA_CIPHER_WEP40;
 695         ssid->key_mgmt = WPA_KEY_MGMT_PSK; /* | WPA_KEY_MGMT_IEEE8021X; */
 696
 697         (void) memset(buf, 0, MAX_ESSID_LENGTH + 1);
 698         wpa_s->driver->get_ssid(wpa_s->handle, wpa_s->linkid, (char *)buf);
 699
 700         (void) wpa_config_parse_ssid(ssid, 0, buf);
 701
 702         key_len = sizeof (psk);
 703         (void) dladm_get_secobj(wpa_s->handle, (const char *)wpa_s->kname, &cl,
 704             psk, &key_len, DLADM_OPT_ACTIVE);
 705         psk[key_len] = '\0';
 706         ssid->passphrase = strdup((const char *)psk);
 707
 708         if (ssid->passphrase) {
 709                 pbkdf2_sha1(ssid->passphrase, (char *)ssid->ssid,
 710                     ssid->ssid_len, 4096, ssid->psk, PMK_LEN);
 711                 wpa_hexdump(MSG_MSGDUMP, "PSK (from passphrase)",
 712                     ssid->psk, PMK_LEN);
 713                 ssid->psk_set = 1;
 714         }
 715
 716         if ((ssid->key_mgmt & WPA_KEY_MGMT_PSK) && !ssid->psk_set) {
 717                 wpa_printf(MSG_ERROR, "WPA-PSK accepted for key "
 718                     "management, but no PSK configured.");
 719                 free(ssid);
 720                 ssid = NULL;
 721         }
 722
 723         return (ssid);
 724 }
 725
 726 struct wpa_config *
 727 wpa_config_read(void *arg)
 728 {
 729         struct wpa_ssid *ssid;
 730         struct wpa_config *config;
 731         struct wpa_supplicant *wpa_s = arg;
 732
 733         config = malloc(sizeof (*config));
 734         if (config == NULL)
 735                 return (NULL);
 736         (void) memset(config, 0, sizeof (*config));
 737         config->eapol_version = 1;      /* fixed value */
 738
 739         wpa_printf(MSG_DEBUG, "Reading configuration parameters from driver\n");
 740
 741         ssid = wpa_config_read_network(wpa_s);
 742         if (ssid == NULL) {
 743                 wpa_config_free(config);
 744                 config = NULL;
 745         } else {
 746                 config->ssid = ssid;
 747         }
 748
 749         return (config);
 750 }
 751
 752 void
 753 wpa_config_free(struct wpa_config *config)
 754 {
 755         struct wpa_ssid *ssid = config->ssid;
 756
 757         if (ssid != NULL) {
 758                 free(ssid->ssid);
 759                 free(ssid->passphrase);
 760                 free(ssid);
 761         }
 762         free(config);
 763 }
 764
 765 /*
 766  * make sure wpad is running under SMF context.
 767  */
 768 static boolean_t
 769 is_smf_context(void)
 770 {
 771         char *fmri;
 772
 773         return (((fmri = getenv("SMF_FMRI")) != NULL) &&
 774             (strstr(fmri, SERVICE_NAME) != NULL));
 775 }
 776
 777 int
 778 main(int argc, char *argv[])
 779 {
 780         struct wpa_supplicant wpa_s;
 781         char *link = NULL;
 782         char *key = NULL;
 783         dlpi_handle_t dh = NULL;
 784         datalink_id_t linkid;
 785         dladm_phys_attr_t dpa;
 786         int c;
 787         int exitcode;
 788         char door_file[MAXPATHLEN];
 789         dladm_handle_t handle;
 790
 791         if (!is_smf_context()) {
 792                 (void) fprintf(stderr,
 793                     "wpad is an smf(5) managed service and cannot be run from "
 794                     "the command line; please use dladm(1M).\n");
 795                 return (SMF_EXIT_ERR_NOSMF);
 796         }
 797
 798         for (;;) {
 799                 c = getopt(argc, argv, "i:k:");
 800                 if (c < 0)
 801                         break;
 802                 switch (c) {
 803                 case 'i':
 804                         link = optarg;
 805                         break;
 806                 case 'k':
 807                         key = optarg;
 808                         break;
 809                 default:
 810                         return (SMF_EXIT_ERR_CONFIG);
 811                 }
 812         }
 813
 814         /*
 815          * key name is required to retrieve PSK value through libwdladm APIs.
 816          * key is saved by dladm command by keyname
 817          * see dladm.
 818          */
 819         if ((link == NULL) || (key == NULL)) {
 820                 wpa_printf(MSG_ERROR, "\nLink & key is required.");
 821                 return (-1);
 822         }
 823
 824         if ((strlen(key) >= sizeof (wpa_s.kname)))  {
 825                 wpa_printf(MSG_ERROR, "Too long key name '%s'.", key);
 826                 return (-1);
 827         }
 828
 829         if (daemon(0, 0))
 830                 return (-1);
 831
 832         /*
 833          * Hold this link open to prevent a link renaming operation.
 834          */
 835         if (dlpi_open(link, &dh, 0) != DLPI_SUCCESS) {
 836                 wpa_printf(MSG_ERROR, "Failed to open link '%s'.", link);
 837                 return (-1);
 838         }
 839
 840         /* This handle is stored in wpa_s when that struct is filled. */
 841         if (dladm_open(&handle) != DLADM_STATUS_OK) {
 842                 wpa_printf(MSG_ERROR, "Failed to open dladm handle");
 843                 dlpi_close(dh);
 844                 return (-1);
 845         }
 846
 847         if (dladm_name2info(handle, link, &linkid, NULL, NULL, NULL) !=
 848             DLADM_STATUS_OK) {
 849                 wpa_printf(MSG_ERROR, "Invalid link name '%s'.", link);
 850                 dladm_close(handle);
 851                 dlpi_close(dh);
 852                 return (-1);
 853         }
 854
 855         /*
 856          * Get the device name of the link, which will be used as the door
 857          * file name used to communicate with the driver. Note that different
 858          * links use different doors.
 859          */
 860         if (dladm_phys_info(handle, linkid, &dpa, DLADM_OPT_ACTIVE) !=
 861             DLADM_STATUS_OK) {
 862                 wpa_printf(MSG_ERROR,
 863                     "Failed to get device name of link '%s'.", link);
 864                 dladm_close(handle);
 865                 dlpi_close(dh);
 866                 return (-1);
 867         }
 868         (void) snprintf(door_file, MAXPATHLEN, "%s_%s", WPA_DOOR, dpa.dp_dev);
 869
 870         (void) memset(&wpa_s, 0, sizeof (wpa_s));
 871         wpa_s.driver = &wpa_driver_wifi_ops;
 872         wpa_s.handle = handle;
 873         wpa_s.linkid = linkid;
 874         (void) strlcpy(wpa_s.kname, key, sizeof (wpa_s.kname));
 875         eloop_init(&wpa_s);
 876
 877         /*
 878          * Setup default WPA/WPA2 configuration
 879          * get ESSID and PSK value
 880          */
 881         wpa_s.conf = wpa_config_read(&wpa_s);
 882         if (wpa_s.conf == NULL || wpa_s.conf->ssid == NULL) {
 883                 wpa_printf(MSG_ERROR, "\nNo networks (SSID) configured.\n");
 884                 exitcode = -1;
 885                 goto cleanup;
 886         }
 887
 888         exitcode = 0;
 889
 890         /*
 891          * Setup door file to communicate with driver
 892          */
 893         if (wpa_supplicant_door_setup(&wpa_s, door_file) != 0) {
 894                 wpa_printf(MSG_ERROR, "Failed to setup door(%s)", door_file);
 895                 exitcode = -1;
 896                 goto cleanup;
 897         }
 898
 899         wpa_s.renew_snonce = 1;
 900         if (wpa_supplicant_driver_init(link, &wpa_s) < 0) {
 901                 exitcode = -1;
 902                 goto cleanup;
 903         }
 904
 905         /*
 906          * This link is hold again in wpa_supplicant_driver_init(), so that
 907          * we release the first reference.
 908          */
 909         dlpi_close(dh);
 910         dh = NULL;
 911
 912         wpa_printf(MSG_DEBUG, "=> eloop_run");
 913
 914         (void) eloop_register_signal(SIGINT, wpa_supplicant_terminate, NULL);
 915         (void) eloop_register_signal(SIGTERM, wpa_supplicant_terminate, NULL);
 916         (void) eloop_register_signal(SIGKILL, wpa_supplicant_terminate, NULL);
 917
 918         eloop_run();
 919
 920         wpa_printf(MSG_DEBUG, "<= eloop_run()");
 921         wpa_supplicant_disassociate(&wpa_s, REASON_DEAUTH_LEAVING);
 922
 923         if (wpa_s.driver->set_wpa(wpa_s.handle, wpa_s.linkid, 0) < 0) {
 924                 wpa_printf(MSG_ERROR, "Failed to disable WPA in the driver.\n");
 925         }
 926
 927 cleanup:
 928         wpa_supplicant_door_destroy(door_file);
 929         /* The libdladm handle is closed in the following method */
 930         wpa_supplicant_cleanup(&wpa_s);
 931         eloop_destroy();
 932
 933         if (dh != NULL)
 934                 dlpi_close(dh);
 935
 936         return (exitcode);
 937 }