3 * Copyright 2009-2014 Roy Marples <roy@marples.name>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 #include <sys/socket.h>
47 (sizeof(*(su)) - sizeof((su)->sun_path) + strlen((su)->sun_path))
50 #define CLAMP(x, low, high) \
51 (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x)))
54 wpa_open(const char *ifname, char **path)
59 struct sockaddr_un sun;
61 if ((fd = socket(AF_UNIX,
62 SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0)) == -1)
64 memset(&sun, 0, sizeof(sun));
65 sun.sun_family = AF_UNIX;
66 snprintf(sun.sun_path, sizeof(sun.sun_path),
67 "/tmp/libdhcpcd-wpa-%d.%d", getpid(), counter++);
68 *path = strdup(sun.sun_path);
69 len = (socklen_t)SUN_LEN(&sun);
70 if (bind(fd, (struct sockaddr *)&sun, len) == -1) {
77 snprintf(sun.sun_path, sizeof(sun.sun_path),
78 WPA_CTRL_DIR "/%s", ifname);
79 len = (socklen_t)SUN_LEN(&sun);
80 if (connect(fd, (struct sockaddr *)&sun, len) == -1) {
92 wpa_cmd(int fd, const char *cmd, char *buffer, size_t len)
100 bytes = write(fd, cmd, strlen(cmd));
101 if (bytes == -1 || bytes == 0)
103 if (buffer == NULL || len == 0)
106 pfd.events = POLLIN | POLLHUP;
108 retval = poll(&pfd, 1, 2000);
111 if (retval == 0 || !(pfd.revents & (POLLIN | POLLHUP)))
114 bytes = read(fd, buffer, len == 1 ? 1 : len - 1);
116 buffer[bytes] = '\0';
121 dhcpcd_wpa_command(DHCPCD_WPA *wpa, const char *cmd)
126 bytes = wpa_cmd(wpa->command_fd, cmd, buf, sizeof(buf));
127 return (bytes == -1 || bytes == 0 ||
128 strcmp(buf, "OK\n")) ? false : true;
132 dhcpcd_wpa_command_arg(DHCPCD_WPA *wpa, const char *cmd, const char *arg)
136 cmdlen = strlen(cmd);
137 nlen = cmdlen + strlen(arg) + 2;
138 if (!dhcpcd_realloc(wpa->con, nlen))
140 strlcpy(wpa->con->buf, cmd, wpa->con->buflen);
141 wpa->con->buf[cmdlen] = ' ';
142 strlcpy(wpa->con->buf + cmdlen + 1, arg, wpa->con->buflen - 1 - cmdlen);
143 return dhcpcd_wpa_command(wpa, wpa->con->buf);
147 dhcpcd_attach_detach(DHCPCD_WPA *wpa, bool attach)
152 if (wpa->attached == attach)
155 bytes = wpa_cmd(wpa->listen_fd, attach > 0 ? "ATTACH" : "DETACH",
157 if (bytes == -1 || bytes == 0 || strcmp(buf, "OK\n"))
160 wpa->attached = attach;
165 dhcpcd_wpa_scan(DHCPCD_WPA *wpa)
168 return dhcpcd_wpa_command(wpa, "SCAN");
172 dhcpcd_wi_scans_free(DHCPCD_WI_SCAN *wis)
184 dhcpcd_strtoi(int *val, const char *s)
188 l = strtol(s, NULL, 0);
189 if (l >= INT_MIN && l <= INT_MAX)
196 dhcpcd_wpa_hex2num(char c)
199 if (c >= '0' && c <= '9')
201 if (c >= 'a' && c <= 'f')
203 if (c >= 'A' && c <= 'F')
209 dhcpcd_wpa_hex2byte(const char *src)
213 if ((h = dhcpcd_wpa_hex2num(*src++)) == -1 ||
214 (l = dhcpcd_wpa_hex2num(*src)) == -1)
220 dhcpcd_wpa_decode_ssid(char *dst, size_t dlen, const char *src)
244 case '"': *dst++ = esc; break;
245 case 'n': *dst++ = '\n'; break;
246 case 'r': *dst++ = '\r'; break;
247 case 't': *dst++ = '\t'; break;
248 case 'e': *dst++ = '\033'; break;
250 if (src[0] == '\0' || src[1] == '\0') {
254 if ((xb = dhcpcd_wpa_hex2byte(src)) == -1)
259 default: errno = EINVAL; return -1;
261 default: *dst++ = c; break;
272 static DHCPCD_WI_SCAN *
273 dhcpcd_wpa_scans_read(DHCPCD_WPA *wpa)
277 DHCPCD_WI_SCAN *wis, *w, *l;
278 char *s, *p, buf[32];
279 char wssid[sizeof(w->ssid)];
281 if (!dhcpcd_realloc(wpa->con, 2048))
284 for (i = 0; i < 1000; i++) {
285 snprintf(buf, sizeof(buf), "BSS %zu", i);
286 bytes = wpa_cmd(wpa->command_fd, buf,
287 wpa->con->buf, wpa->con->buflen);
288 if (bytes == 0 || bytes == -1 ||
289 strncmp(wpa->con->buf, "FAIL", 4) == 0)
292 w = calloc(1, sizeof(*w));
297 while ((s = strsep(&p, "\n"))) {
300 if (strncmp(s, "bssid=", 6) == 0)
301 strlcpy(w->bssid, s + 6, sizeof(w->bssid));
302 else if (strncmp(s, "freq=", 5) == 0)
303 dhcpcd_strtoi(&w->frequency, s + 5);
304 // else if (strncmp(s, "beacon_int=", 11) == 0)
306 else if (strncmp(s, "qual=", 5) == 0)
307 dhcpcd_strtoi(&w->quality.value, s + 5);
308 else if (strncmp(s, "noise=", 6) == 0)
309 dhcpcd_strtoi(&w->noise.value, s + 6);
310 else if (strncmp(s, "level=", 6) == 0)
311 dhcpcd_strtoi(&w->level.value, s + 6);
312 else if (strncmp(s, "flags=", 6) == 0)
313 strlcpy(w->flags, s + 6, sizeof(w->flags));
314 else if (strncmp(s, "ssid=", 5) == 0) {
315 /* Decode it from \xNN to \NNN
316 * so we're consistent */
317 dl = dhcpcd_wpa_decode_ssid(wssid,
318 sizeof(wssid), s + 5);
321 dl = dhcpcd_encode_string_escape(w->ssid,
322 sizeof(w->ssid), wssid, (size_t)dl);
338 w->strength.value = w->level.value;
339 if (w->strength.value > 110 && w->strength.value < 256)
340 /* Convert WEXT level to dBm */
341 w->strength.value -= 256;
343 if (w->strength.value < 0) {
346 abs(CLAMP(w->strength.value, -100, -40) + 40);
348 100 - ((100 * w->strength.value) / 60);
350 /* Assume quality percentage */
351 w->strength.value = CLAMP(w->strength.value, 0, 100);
358 dhcpcd_wi_scan_compare(DHCPCD_WI_SCAN *a, DHCPCD_WI_SCAN *b)
362 cmp = strcasecmp(a->ssid, b->ssid);
364 /* Return strongest first */
365 cmp = b->strength.value - a->strength.value;
370 * This function is copyright 2001 Simon Tatham.
372 * Permission is hereby granted, free of charge, to any person
373 * obtaining a copy of this software and associated documentation
374 * files (the "Software"), to deal in the Software without
375 * restriction, including without limitation the rights to use,
376 * copy, modify, merge, publish, distribute, sublicense, and/or
377 * sell copies of the Software, and to permit persons to whom the
378 * Software is furnished to do so, subject to the following
381 * The above copyright notice and this permission notice shall be
382 * included in all copies or substantial portions of the Software.
384 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
385 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
386 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
387 * NONINFRINGEMENT. IN NO EVENT SHALL SIMON TATHAM BE LIABLE FOR
388 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
389 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
390 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
393 static DHCPCD_WI_SCAN *
394 dhcpcd_wi_scans_sort(DHCPCD_WI_SCAN *list)
396 DHCPCD_WI_SCAN *p, *q, *e, *tail;
397 size_t insize, nmerges, psize, qsize, i;
399 /* Silly special case: if `list' was passed in as NULL, return
400 * NULL immediately. */
409 nmerges = 0; /* count number of merges we do in this pass */
412 nmerges++; /* there exists a merge to be done */
413 /* step `insize' places along from p */
416 for (i = 0; i < insize; i++) {
423 /* if q hasn't fallen off end,
424 * we have two lists to merge */
427 /* now we have two lists; merge them */
428 while (psize > 0 || (qsize > 0 && q)) {
429 /* decide whether next element of merge comes
432 /* p is empty; e must come from q. */
433 e = q; q = q->next; qsize--;
434 } else if (qsize == 0 || !q) {
435 /* q is empty; e must come from p. */
436 e = p; p = p->next; psize--;
437 } else if (dhcpcd_wi_scan_compare(p, q) <= 0) {
438 /* First element of p is lower
439 * (or same); e must come from p. */
440 e = p; p = p->next; psize--;
442 /* First element of q is lower;
443 * e must come from q. */
444 e = q; q = q->next; qsize--;
447 /* add the next element to the merged list */
455 /* now p has stepped `insize' places along,
461 /* If we have done only one merge, we're finished. */
462 if (nmerges <= 1) /* allow for nmerges==0, the empty list */
465 /* Otherwise repeat, merging lists twice the size */
471 dhcpcd_wi_scans(DHCPCD_IF *i)
474 DHCPCD_WI_SCAN *wis, *w;
476 DHCPCD_WI_HIST *h, *hl;
478 wpa = dhcpcd_wpa_find(i->con, i->ifname);
481 wis = dhcpcd_wpa_scans_read(wpa);
483 /* Sort the resultant list alphabetically and then by strength */
484 wis = dhcpcd_wi_scans_sort(wis);
486 for (w = wis; w; w = w->next) {
489 w->quality.average = w->quality.value;
490 w->noise.average = w->noise.value;
491 w->level.average = w->level.value;
492 w->strength.average = w->strength.value;
494 for (h = wpa->con->wi_history; h; h = h->next) {
495 if (strcmp(h->ifname, i->ifname) == 0 &&
496 strcmp(h->bssid, wis->bssid) == 0)
498 w->quality.average += h->quality;
499 w->noise.average += h->noise;
500 w->level.average += h->level;
501 w->strength.average += h->strength;
502 if (++nh == DHCPCD_WI_HIST_MAX) {
512 w->quality.average /= nh;
513 w->noise.average /= nh;
514 w->level.average /= nh;
515 w->strength.average /= nh;
517 h = malloc(sizeof(*h));
519 strlcpy(h->ifname, i->ifname, sizeof(h->ifname));
520 strlcpy(h->bssid, w->bssid, sizeof(h->bssid));
521 h->quality = w->quality.value;
522 h->noise = w->noise.value;
523 h->level = w->level.value;
524 h->strength = w->strength.value;
525 h->next = wpa->con->wi_history;
526 wpa->con->wi_history = h;
534 dhcpcd_wpa_reassociate(DHCPCD_WPA *wpa)
537 return dhcpcd_wpa_command(wpa, "REASSOCIATE");
541 dhcpcd_wpa_disconnect(DHCPCD_WPA *wpa)
544 return dhcpcd_wpa_command(wpa, "DISCONNECT");
548 dhcpcd_wpa_config_write(DHCPCD_WPA *wpa)
551 return dhcpcd_wpa_command(wpa, "SAVE_CONFIG");
555 dhcpcd_wpa_network(DHCPCD_WPA *wpa, const char *cmd, int id)
559 len = strlen(cmd) + 32;
560 if (!dhcpcd_realloc(wpa->con, len))
562 snprintf(wpa->con->buf, wpa->con->buflen, "%s %d", cmd, id);
563 return dhcpcd_wpa_command(wpa, wpa->con->buf);
567 dhcpcd_wpa_network_disable(DHCPCD_WPA *wpa, int id)
570 return dhcpcd_wpa_network(wpa, "DISABLE_NETWORK", id);
574 dhcpcd_wpa_network_enable(DHCPCD_WPA *wpa, int id)
577 return dhcpcd_wpa_network(wpa, "ENABLE_NETWORK", id);
581 dhcpcd_wpa_network_remove(DHCPCD_WPA *wpa, int id)
584 return dhcpcd_wpa_network(wpa, "REMOVE_NETWORK", id);
588 dhcpcd_wpa_network_get(DHCPCD_WPA *wpa, int id, const char *param)
592 if (!dhcpcd_realloc(wpa->con, 2048))
594 snprintf(wpa->con->buf, wpa->con->buflen, "GET_NETWORK %d %s",
596 bytes = wpa_cmd(wpa->command_fd, wpa->con->buf,
597 wpa->con->buf, wpa->con->buflen);
598 if (bytes == 0 || bytes == -1)
600 if (strcmp(wpa->con->buf, "FAIL\n") == 0) {
604 return wpa->con->buf;
608 dhcpcd_wpa_network_set(DHCPCD_WPA *wpa, int id,
609 const char *param, const char *value)
613 len = strlen("SET_NETWORK") + 32 + strlen(param) + strlen(value) + 3;
614 if (!dhcpcd_realloc(wpa->con, len))
616 snprintf(wpa->con->buf, wpa->con->buflen, "SET_NETWORK %d %s %s",
618 return dhcpcd_wpa_command(wpa, wpa->con->buf);
622 dhcpcd_wpa_network_find(DHCPCD_WPA *wpa, const char *fssid)
624 ssize_t bytes, dl, tl;
626 char *s, *t, *ssid, *bssid, *flags;
627 char dssid[IF_SSIDSIZE], tssid[IF_SSIDSIZE];
630 dhcpcd_realloc(wpa->con, 2048);
631 bytes = wpa_cmd(wpa->command_fd, "LIST_NETWORKS",
632 wpa->con->buf, wpa->con->buflen);
633 if (bytes == 0 || bytes == -1)
638 s = strchr(wpa->con->buf, '\n');
641 while ((t = strsep(&s, "\b"))) {
644 ssid = strchr(t, '\t');
648 bssid = strchr(ssid, '\t');
652 flags = strchr(bssid, '\t');
656 l = strtol(t, NULL, 0);
657 if (l < 0 || l > INT_MAX) {
662 /* Decode the wpa_supplicant SSID into raw chars and
663 * then encode into our octal escaped string to
665 dl = dhcpcd_wpa_decode_ssid(dssid, sizeof(dssid), ssid);
668 tl = dhcpcd_encode_string_escape(tssid,
669 sizeof(tssid), dssid, (size_t)dl);
672 if ((size_t)tl == fl && memcmp(tssid, fssid, (size_t)tl) == 0)
680 dhcpcd_wpa_network_new(DHCPCD_WPA *wpa)
685 dhcpcd_realloc(wpa->con, 32);
686 bytes = wpa_cmd(wpa->command_fd, "ADD_NETWORK",
687 wpa->con->buf, sizeof(wpa->con->buf));
688 if (bytes == 0 || bytes == -1)
690 l = strtol(wpa->con->buf, NULL, 0);
691 if (l < 0 || l > INT_MAX) {
698 static const char hexchrs[] = "0123456789abcdef";
700 dhcpcd_wpa_network_find_new(DHCPCD_WPA *wpa, const char *ssid)
703 char dssid[IF_SSIDSIZE], essid[IF_SSIDSIZE], *ep;
707 id = dhcpcd_wpa_network_find(wpa, ssid);
711 dl = dhcpcd_decode_string_escape(dssid, sizeof(dssid), ssid);
715 for (i = 0; i < dl; i++) {
716 if (!isascii((int)dssid[i]) && !isprint((int)dssid[i]))
722 /* Non standard characters found! Encode as hex string */
726 c = (unsigned char)*dp++;
727 *ep++ = hexchrs[(c & 0xf0) >> 4];
728 *ep++ = hexchrs[(c & 0x0f)];
734 while (*++dp != '\0');
739 id = dhcpcd_wpa_network_new(wpa);
741 dhcpcd_wpa_network_set(wpa, id, "ssid", essid);
746 dhcpcd_wpa_close(DHCPCD_WPA *wpa)
751 if (wpa->command_fd == -1 || !wpa->open)
755 dhcpcd_attach_detach(wpa, false);
756 shutdown(wpa->command_fd, SHUT_RDWR);
757 shutdown(wpa->listen_fd, SHUT_RDWR);
759 if (wpa->con->wpa_status_cb)
760 wpa->con->wpa_status_cb(wpa, "down",
761 wpa->con->wpa_status_context);
763 close(wpa->command_fd);
764 wpa->command_fd = -1;
765 close(wpa->listen_fd);
767 unlink(wpa->command_path);
768 free(wpa->command_path);
769 wpa->command_path = NULL;
770 unlink(wpa->listen_path);
771 free(wpa->listen_path);
772 wpa->listen_path = NULL;
776 dhcpcd_wpa_find(DHCPCD_CONNECTION *con, const char *ifname)
780 for (wpa = con->wpa; wpa; wpa = wpa->next) {
781 if (strcmp(wpa->ifname, ifname) == 0)
789 dhcpcd_wpa_new(DHCPCD_CONNECTION *con, const char *ifname)
793 wpa = dhcpcd_wpa_find(con, ifname);
797 wpa = malloc(sizeof(*wpa));
802 strlcpy(wpa->ifname, ifname, sizeof(wpa->ifname));
803 wpa->command_fd = wpa->listen_fd = -1;
804 wpa->command_path = wpa->listen_path = NULL;
805 wpa->next = con->wpa;
811 dhcpcd_wpa_connection(DHCPCD_WPA *wpa)
819 dhcpcd_wpa_if(DHCPCD_WPA *wpa)
822 return dhcpcd_get_if(wpa->con, wpa->ifname, "link");
826 dhcpcd_wpa_open(DHCPCD_WPA *wpa)
828 int cmd_fd, list_fd = -1;
829 char *cmd_path = NULL, *list_path = NULL;
831 if (wpa->listen_fd != -1) {
836 return wpa->listen_fd;
839 cmd_fd = wpa_open(wpa->ifname, &cmd_path);
843 list_fd = wpa_open(wpa->ifname, &list_path);
848 wpa->attached = false;
849 wpa->command_fd = cmd_fd;
850 wpa->command_path = cmd_path;
851 wpa->listen_fd = list_fd;
852 wpa->listen_path = list_path;
853 if (!dhcpcd_attach_detach(wpa, true)) {
854 dhcpcd_wpa_close(wpa);
858 if (wpa->con->wi_scanresults_cb)
859 wpa->con->wi_scanresults_cb(wpa,
860 wpa->con->wi_scanresults_context);
862 return wpa->listen_fd;
878 dhcpcd_wpa_get_fd(DHCPCD_WPA *wpa)
882 return wpa->open ? wpa->listen_fd : -1;
886 dhcpcd_wpa_set_scan_callback(DHCPCD_CONNECTION *con,
887 void (*cb)(DHCPCD_WPA *, void *), void *context)
891 con->wi_scanresults_cb = cb;
892 con->wi_scanresults_context = context;
896 void dhcpcd_wpa_set_status_callback(DHCPCD_CONNECTION * con,
897 void (*cb)(DHCPCD_WPA *, const char *, void *), void *context)
901 con->wpa_status_cb = cb;
902 con->wpa_status_context = context;
906 dhcpcd_wpa_dispatch(DHCPCD_WPA *wpa)
908 char buffer[256], *p;
912 bytes = (size_t)read(wpa->listen_fd, buffer, sizeof(buffer));
913 if ((ssize_t)bytes == -1 || bytes == 0) {
914 dhcpcd_wpa_close(wpa);
918 buffer[bytes] = '\0';
919 bytes = strlen(buffer);
920 if (buffer[bytes - 1] == ' ')
921 buffer[--bytes] = '\0';
922 for (p = buffer + 1; *p != '\0'; p++)
927 if (strcmp(p, "CTRL-EVENT-SCAN-RESULTS") == 0 &&
928 wpa->con->wi_scanresults_cb)
929 wpa->con->wi_scanresults_cb(wpa,
930 wpa->con->wi_scanresults_context);
935 dhcpcd_wpa_if_event(DHCPCD_IF *i)
940 if (strcmp(i->type, "link") == 0) {
941 if (strcmp(i->reason, "STOPPED") == 0 ||
942 strcmp(i->reason, "DEPARTED") == 0)
944 wpa = dhcpcd_wpa_find(i->con, i->ifname);
946 dhcpcd_wpa_close(wpa);
947 } else if (i->wireless && i->con->wpa_started) {
948 wpa = dhcpcd_wpa_new(i->con, i->ifname);
949 if (wpa && wpa->listen_fd == -1)
950 dhcpcd_wpa_open(wpa);
956 dhcpcd_wpa_start(DHCPCD_CONNECTION *con)
961 con->wpa_started = true;
963 for (i = con->interfaces; i; i = i->next)
964 dhcpcd_wpa_if_event(i);
968 dhcpcd_wpa_configure_psk(DHCPCD_WPA *wpa, DHCPCD_WI_SCAN *s, const char *psk)
970 const char *mgmt, *var;
979 id = dhcpcd_wpa_network_find_new(wpa, s->ssid);
981 return DHCPCD_WPA_ERR;
983 if (strcmp(s->flags, "[WEP]") == 0) {
991 if (!dhcpcd_wpa_network_set(wpa, id, "key_mgmt", mgmt))
992 return DHCPCD_WPA_ERR_SET;
995 psk_len = strlen(psk);
998 npsk = malloc(psk_len + 3);
1000 return DHCPCD_WPA_ERR;
1003 memcpy(npsk + 1, psk, psk_len);
1004 npsk[psk_len + 1] = '"';
1005 npsk[psk_len + 2] = '\0';
1006 r = dhcpcd_wpa_network_set(wpa, id, var, npsk);
1009 return DHCPCD_WPA_ERR_SET_PSK;
1011 if (!dhcpcd_wpa_network_enable(wpa, id))
1012 return DHCPCD_WPA_ERR_ENABLE;
1013 if (!dhcpcd_wpa_reassociate(wpa))
1014 return DHCPCD_WPA_ERR_ASSOC;
1015 if (!dhcpcd_wpa_config_write(wpa))
1016 return DHCPCD_WPA_ERR_WRITE;
1017 return DHCPCD_WPA_SUCCESS;