wifi/wifi.c

   1 /*
   2  * Copyright 2008, The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdlib.h>
  18 #include <fcntl.h>
  19 #include <errno.h>
  20 #include <string.h>
  21
  22 #include "hardware_legacy/wifi.h"
  23 #include "libwpa_client/wpa_ctrl.h"
  24
  25 #define LOG_TAG "WifiHW"
  26 #include "cutils/log.h"
  27 #include "cutils/memory.h"
  28 #include "cutils/misc.h"
  29 #include "cutils/properties.h"
  30 #include "private/android_filesystem_config.h"
  31 #ifdef HAVE_LIBC_SYSTEM_PROPERTIES
  32 #define _REALLY_INCLUDE_SYS__SYSTEM_PROPERTIES_H_
  33 #include <sys/_system_properties.h>
  34 #endif
  35
  36 static struct wpa_ctrl *ctrl_conn;
  37 static struct wpa_ctrl *monitor_conn;
  38
  39 extern int do_dhcp();
  40 extern int ifc_init();
  41 extern void ifc_close();
  42 extern char *dhcp_lasterror();
  43 extern void get_dhcp_info();
  44 extern int init_module(void *, unsigned long, const char *);
  45 extern int delete_module(const char *, unsigned int);
  46
  47 static char iface[PROPERTY_VALUE_MAX];
  48 // TODO: use new ANDROID_SOCKET mechanism, once support for multiple
  49 // sockets is in
  50
  51 #ifndef WIFI_DRIVER_MODULE_PATH
  52 #define WIFI_DRIVER_MODULE_PATH         "/system/lib/modules/wlan.ko"
  53 #endif
  54 #ifndef WIFI_DRIVER_MODULE_NAME
  55 #define WIFI_DRIVER_MODULE_NAME         "wlan"
  56 #endif
  57 #ifndef WIFI_DRIVER_MODULE_ARG
  58 #define WIFI_DRIVER_MODULE_ARG          ""
  59 #endif
  60 #ifndef WIFI_FIRMWARE_LOADER
  61 #define WIFI_FIRMWARE_LOADER            ""
  62 #endif
  63 #define WIFI_TEST_INTERFACE             "sta"
  64
  65 static const char IFACE_DIR[]           = "/data/system/wpa_supplicant";
  66 static const char DRIVER_MODULE_NAME[]  = WIFI_DRIVER_MODULE_NAME;
  67 static const char DRIVER_MODULE_TAG[]   = WIFI_DRIVER_MODULE_NAME " ";
  68 static const char DRIVER_MODULE_PATH[]  = WIFI_DRIVER_MODULE_PATH;
  69 static const char DRIVER_MODULE_ARG[]   = WIFI_DRIVER_MODULE_ARG;
  70 static const char FIRMWARE_LOADER[]     = WIFI_FIRMWARE_LOADER;
  71 static const char DRIVER_PROP_NAME[]    = "wlan.driver.status";
  72 static const char SUPPLICANT_NAME[]     = "wpa_supplicant";
  73 static const char SUPP_PROP_NAME[]      = "init.svc.wpa_supplicant";
  74 static const char SUPP_CONFIG_TEMPLATE[]= "/system/etc/wifi/wpa_supplicant.conf";
  75 static const char SUPP_CONFIG_FILE[]    = "/data/misc/wifi/wpa_supplicant.conf";
  76 static const char MODULE_FILE[]         = "/proc/modules";
  77
  78 static int insmod(const char *filename, const char *args)
  79 {
  80     void *module;
  81     unsigned int size;
  82     int ret;
  83
  84     module = load_file(filename, &size);
  85     if (!module)
  86         return -1;
  87
  88     ret = init_module(module, size, args);
  89
  90     free(module);
  91
  92     return ret;
  93 }
  94
  95 static int rmmod(const char *modname)
  96 {
  97     int ret = -1;
  98     int maxtry = 10;
  99
 100     while (maxtry-- > 0) {
 101         ret = delete_module(modname, O_NONBLOCK | O_EXCL);
 102         if (ret < 0 && errno == EAGAIN)
 103             usleep(500000);
 104         else
 105             break;
 106     }
 107
 108     if (ret != 0)
 109         LOGD("Unable to unload driver module \"%s\": %s\n",
 110              modname, strerror(errno));
 111     return ret;
 112 }
 113
 114 int do_dhcp_request(int *ipaddr, int *gateway, int *mask,
 115                     int *dns1, int *dns2, int *server, int *lease) {
 116     /* For test driver, always report success */
 117     if (strcmp(iface, WIFI_TEST_INTERFACE) == 0)
 118         return 0;
 119
 120     if (ifc_init() < 0)
 121         return -1;
 122
 123     if (do_dhcp(iface) < 0) {
 124         ifc_close();
 125         return -1;
 126     }
 127     ifc_close();
 128     get_dhcp_info(ipaddr, gateway, mask, dns1, dns2, server, lease);
 129     return 0;
 130 }
 131
 132 const char *get_dhcp_error_string() {
 133     return dhcp_lasterror();
 134 }
 135
 136 static int check_driver_loaded() {
 137     char driver_status[PROPERTY_VALUE_MAX];
 138     FILE *proc;
 139     char line[sizeof(DRIVER_MODULE_TAG)+10];
 140
 141     if (!property_get(DRIVER_PROP_NAME, driver_status, NULL)
 142             || strcmp(driver_status, "ok") != 0) {
 143         return 0;  /* driver not loaded */
 144     }
 145     /*
 146      * If the property says the driver is loaded, check to
 147      * make sure that the property setting isn't just left
 148      * over from a previous manual shutdown or a runtime
 149      * crash.
 150      */
 151     if ((proc = fopen(MODULE_FILE, "r")) == NULL) {
 152         LOGW("Could not open %s: %s", MODULE_FILE, strerror(errno));
 153         property_set(DRIVER_PROP_NAME, "unloaded");
 154         return 0;
 155     }
 156     while ((fgets(line, sizeof(line), proc)) != NULL) {
 157         if (strncmp(line, DRIVER_MODULE_TAG, strlen(DRIVER_MODULE_TAG)) == 0) {
 158             fclose(proc);
 159             return 1;
 160         }
 161     }
 162     fclose(proc);
 163     property_set(DRIVER_PROP_NAME, "unloaded");
 164     return 0;
 165 }
 166
 167 int wifi_load_driver()
 168 {
 169     char driver_status[PROPERTY_VALUE_MAX];
 170     int count = 100; /* wait at most 20 seconds for completion */
 171
 172     if (check_driver_loaded()) {
 173         return 0;
 174     }
 175
 176     if (insmod(DRIVER_MODULE_PATH, DRIVER_MODULE_ARG) < 0)
 177         return -1;
 178
 179     if (strcmp(FIRMWARE_LOADER,"") == 0) {
 180         usleep(500000);
 181         property_set(DRIVER_PROP_NAME, "ok");
 182     }
 183     else {
 184         property_set("ctl.start", FIRMWARE_LOADER);
 185     }
 186     sched_yield();
 187     while (count-- > 0) {
 188         if (property_get(DRIVER_PROP_NAME, driver_status, NULL)) {
 189             if (strcmp(driver_status, "ok") == 0)
 190                 return 0;
 191             else if (strcmp(DRIVER_PROP_NAME, "failed") == 0)
 192                 return -1;
 193         }
 194         usleep(200000);
 195     }
 196     property_set(DRIVER_PROP_NAME, "timeout");
 197     return -1;
 198 }
 199
 200 int wifi_unload_driver()
 201 {
 202     int count = 20; /* wait at most 10 seconds for completion */
 203
 204     if (rmmod(DRIVER_MODULE_NAME) == 0) {
 205         while (count-- > 0) {
 206             if (!check_driver_loaded())
 207                 break;
 208             usleep(500000);
 209         }
 210         if (count) {
 211             return 0;
 212         }
 213         return -1;
 214     } else
 215         return -1;
 216 }
 217
 218 int ensure_config_file_exists()
 219 {
 220     char buf[2048];
 221     int srcfd, destfd;
 222     int nread;
 223
 224     if (access(SUPP_CONFIG_FILE, R_OK|W_OK) == 0) {
 225         return 0;
 226     } else if (errno != ENOENT) {
 227         LOGE("Cannot access \"%s\": %s", SUPP_CONFIG_FILE, strerror(errno));
 228         return -1;
 229     }
 230
 231     srcfd = open(SUPP_CONFIG_TEMPLATE, O_RDONLY);
 232     if (srcfd < 0) {
 233         LOGE("Cannot open \"%s\": %s", SUPP_CONFIG_TEMPLATE, strerror(errno));
 234         return -1;
 235     }
 236
 237     destfd = open(SUPP_CONFIG_FILE, O_CREAT|O_WRONLY, 0660);
 238     if (destfd < 0) {
 239         close(srcfd);
 240         LOGE("Cannot create \"%s\": %s", SUPP_CONFIG_FILE, strerror(errno));
 241         return -1;
 242     }
 243
 244     while ((nread = read(srcfd, buf, sizeof(buf))) != 0) {
 245         if (nread < 0) {
 246             LOGE("Error reading \"%s\": %s", SUPP_CONFIG_TEMPLATE, strerror(errno));
 247             close(srcfd);
 248             close(destfd);
 249             unlink(SUPP_CONFIG_FILE);
 250             return -1;
 251         }
 252         write(destfd, buf, nread);
 253     }
 254
 255     close(destfd);
 256     close(srcfd);
 257
 258     if (chown(SUPP_CONFIG_FILE, AID_SYSTEM, AID_WIFI) < 0) {
 259         LOGE("Error changing group ownership of %s to %d: %s",
 260              SUPP_CONFIG_FILE, AID_WIFI, strerror(errno));
 261         unlink(SUPP_CONFIG_FILE);
 262         return -1;
 263     }
 264     return 0;
 265 }
 266
 267 int wifi_start_supplicant()
 268 {
 269     char supp_status[PROPERTY_VALUE_MAX] = {'\0'};
 270     int count = 200; /* wait at most 20 seconds for completion */
 271 #ifdef HAVE_LIBC_SYSTEM_PROPERTIES
 272     const prop_info *pi;
 273     unsigned serial = 0;
 274 #endif
 275
 276     /* Check whether already running */
 277     if (property_get(SUPP_PROP_NAME, supp_status, NULL)
 278             && strcmp(supp_status, "running") == 0) {
 279         return 0;
 280     }
 281
 282     /* Before starting the daemon, make sure its config file exists */
 283     if (ensure_config_file_exists() < 0) {
 284         LOGE("Wi-Fi will not be enabled");
 285         return -1;
 286     }
 287
 288     /* Clear out any stale socket files that might be left over. */
 289     wpa_ctrl_cleanup();
 290
 291 #ifdef HAVE_LIBC_SYSTEM_PROPERTIES
 292     /*
 293      * Get a reference to the status property, so we can distinguish
 294      * the case where it goes stopped => running => stopped (i.e.,
 295      * it start up, but fails right away) from the case in which
 296      * it starts in the stopped state and never manages to start
 297      * running at all.
 298      */
 299     pi = __system_property_find(SUPP_PROP_NAME);
 300     if (pi != NULL) {
 301         serial = pi->serial;
 302     }
 303 #endif
 304     property_set("ctl.start", SUPPLICANT_NAME);
 305     sched_yield();
 306
 307     while (count-- > 0) {
 308  #ifdef HAVE_LIBC_SYSTEM_PROPERTIES
 309         if (pi == NULL) {
 310             pi = __system_property_find(SUPP_PROP_NAME);
 311         }
 312         if (pi != NULL) {
 313             __system_property_read(pi, NULL, supp_status);
 314             if (strcmp(supp_status, "running") == 0) {
 315                 return 0;
 316             } else if (pi->serial != serial &&
 317                     strcmp(supp_status, "stopped") == 0) {
 318                 return -1;
 319             }
 320         }
 321 #else
 322         if (property_get(SUPP_PROP_NAME, supp_status, NULL)) {
 323             if (strcmp(supp_status, "running") == 0)
 324                 return 0;
 325         }
 326 #endif
 327         usleep(100000);
 328     }
 329     return -1;
 330 }
 331
 332 int wifi_stop_supplicant()
 333 {
 334     char supp_status[PROPERTY_VALUE_MAX] = {'\0'};
 335     int count = 50; /* wait at most 5 seconds for completion */
 336
 337     /* Check whether supplicant already stopped */
 338     if (property_get(SUPP_PROP_NAME, supp_status, NULL)
 339         && strcmp(supp_status, "stopped") == 0) {
 340         return 0;
 341     }
 342
 343     property_set("ctl.stop", SUPPLICANT_NAME);
 344     sched_yield();
 345
 346     while (count-- > 0) {
 347         if (property_get(SUPP_PROP_NAME, supp_status, NULL)) {
 348             if (strcmp(supp_status, "stopped") == 0)
 349                 return 0;
 350         }
 351         usleep(100000);
 352     }
 353     return -1;
 354 }
 355
 356 int wifi_connect_to_supplicant()
 357 {
 358     char ifname[256];
 359     char supp_status[PROPERTY_VALUE_MAX] = {'\0'};
 360
 361     /* Make sure supplicant is running */
 362     if (!property_get(SUPP_PROP_NAME, supp_status, NULL)
 363             || strcmp(supp_status, "running") != 0) {
 364         LOGE("Supplicant not running, cannot connect");
 365         return -1;
 366     }
 367
 368     property_get("wifi.interface", iface, WIFI_TEST_INTERFACE);
 369
 370     if (access(IFACE_DIR, F_OK) == 0) {
 371         snprintf(ifname, sizeof(ifname), "%s/%s", IFACE_DIR, iface);
 372     } else {
 373         strlcpy(ifname, iface, sizeof(ifname));
 374     }
 375
 376     ctrl_conn = wpa_ctrl_open(ifname);
 377     if (ctrl_conn == NULL) {
 378         LOGE("Unable to open connection to supplicant on \"%s\": %s",
 379              ifname, strerror(errno));
 380         return -1;
 381     }
 382     monitor_conn = wpa_ctrl_open(ifname);
 383     if (monitor_conn == NULL) {
 384         wpa_ctrl_close(ctrl_conn);
 385         ctrl_conn = NULL;
 386         return -1;
 387     }
 388     if (wpa_ctrl_attach(monitor_conn) != 0) {
 389         wpa_ctrl_close(monitor_conn);
 390         wpa_ctrl_close(ctrl_conn);
 391         ctrl_conn = monitor_conn = NULL;
 392         return -1;
 393     }
 394     return 0;
 395 }
 396
 397 int wifi_send_command(struct wpa_ctrl *ctrl, const char *cmd, char *reply, size_t *reply_len)
 398 {
 399     int ret;
 400
 401     if (ctrl_conn == NULL) {
 402         LOGV("Not connected to wpa_supplicant - \"%s\" command dropped.\n", cmd);
 403         return -1;
 404     }
 405     ret = wpa_ctrl_request(ctrl, cmd, strlen(cmd), reply, reply_len, NULL);
 406     if (ret == -2) {
 407         LOGD("'%s' command timed out.\n", cmd);
 408         return -2;
 409     } else if (ret < 0 || strncmp(reply, "FAIL", 4) == 0) {
 410         return -1;
 411     }
 412     if (strncmp(cmd, "PING", 4) == 0) {
 413         reply[*reply_len] = '\0';
 414     }
 415     return 0;
 416 }
 417
 418 int wifi_wait_for_event(char *buf, size_t buflen)
 419 {
 420     size_t nread = buflen - 1;
 421     int fd;
 422     fd_set rfds;
 423     int result;
 424     struct timeval tval;
 425     struct timeval *tptr;
 426
 427     if (monitor_conn == NULL)
 428         return 0;
 429
 430     result = wpa_ctrl_recv(monitor_conn, buf, &nread);
 431     if (result < 0) {
 432         LOGD("wpa_ctrl_recv failed: %s\n", strerror(errno));
 433         return -1;
 434     }
 435     buf[nread] = '\0';
 436     /* LOGD("wait_for_event: result=%d nread=%d string=\"%s\"\n", result, nread, buf); */
 437     /* Check for EOF on the socket */
 438     if (result == 0 && nread == 0) {
 439         /* Fabricate an event to pass up */
 440         LOGD("Received EOF on supplicant socket\n");
 441         strncpy(buf, WPA_EVENT_TERMINATING " - signal 0 received", buflen-1);
 442         buf[buflen-1] = '\0';
 443         return strlen(buf);
 444     }
 445     /*
 446      * Events strings are in the format
 447      *
 448      *     <N>CTRL-EVENT-XXX
 449      *
 450      * where N is the message level in numerical form (0=VERBOSE, 1=DEBUG,
 451      * etc.) and XXX is the event name. The level information is not useful
 452      * to us, so strip it off.
 453      */
 454     if (buf[0] == '<') {
 455         char *match = strchr(buf, '>');
 456         if (match != NULL) {
 457             nread -= (match+1-buf);
 458             memmove(buf, match+1, nread+1);
 459         }
 460     }
 461     return nread;
 462 }
 463
 464 void wifi_close_supplicant_connection()
 465 {
 466     if (ctrl_conn != NULL) {
 467         wpa_ctrl_close(ctrl_conn);
 468         ctrl_conn = NULL;
 469     }
 470     if (monitor_conn != NULL) {
 471         wpa_ctrl_close(monitor_conn);
 472         monitor_conn = NULL;
 473     }
 474 }
 475
 476 int wifi_command(const char *command, char *reply, size_t *reply_len)
 477 {
 478     return wifi_send_command(ctrl_conn, command, reply, reply_len);
 479 }