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 * This function is copyright 2001 Simon Tatham.
360 * Permission is hereby granted, free of charge, to any person
361 * obtaining a copy of this software and associated documentation
362 * files (the "Software"), to deal in the Software without
363 * restriction, including without limitation the rights to use,
364 * copy, modify, merge, publish, distribute, sublicense, and/or
365 * sell copies of the Software, and to permit persons to whom the
366 * Software is furnished to do so, subject to the following
369 * The above copyright notice and this permission notice shall be
370 * included in all copies or substantial portions of the Software.
372 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
373 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
374 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
375 * NONINFRINGEMENT. IN NO EVENT SHALL SIMON TATHAM BE LIABLE FOR
376 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
377 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
378 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
381 static DHCPCD_WI_SCAN *
382 dhcpcd_wi_scan_sort(DHCPCD_WI_SCAN *list)
384 DHCPCD_WI_SCAN *p, *q, *e, *tail;
385 size_t insize, nmerges, psize, qsize, i;
387 /* Silly special case: if `list' was passed in as NULL, return
388 * NULL immediately. */
397 nmerges = 0; /* count number of merges we do in this pass */
400 nmerges++; /* there exists a merge to be done */
401 /* step `insize' places along from p */
404 for (i = 0; i < insize; i++) {
411 /* if q hasn't fallen off end,
412 * we have two lists to merge */
415 /* now we have two lists; merge them */
416 while (psize > 0 || (qsize > 0 && q)) {
417 /* decide whether next element of merge comes
420 /* p is empty; e must come from q. */
421 e = q; q = q->next; qsize--;
422 } else if (qsize == 0 || !q) {
423 /* q is empty; e must come from p. */
424 e = p; p = p->next; psize--;
425 } else if (strcasecmp(p->ssid,q->ssid) <= 0) {
426 /* First element of p is lower
427 * (or same); e must come from p. */
428 e = p; p = p->next; psize--;
430 /* First element of q is lower;
431 * e must come from q. */
432 e = q; q = q->next; qsize--;
435 /* add the next element to the merged list */
443 /* now p has stepped `insize' places along,
449 /* If we have done only one merge, we're finished. */
450 if (nmerges <= 1) /* allow for nmerges==0, the empty list */
453 /* Otherwise repeat, merging lists twice the size */
459 dhcpcd_wi_scans(DHCPCD_IF *i)
462 DHCPCD_WI_SCAN *wis, *w;
464 DHCPCD_WI_HIST *h, *hl;
466 wpa = dhcpcd_wpa_find(i->con, i->ifname);
469 wis = dhcpcd_wpa_scans_read(wpa);
471 /* Sort the resultant list alphabetically */
472 wis = dhcpcd_wi_scan_sort(wis);
474 for (w = wis; w; w = w->next) {
477 w->quality.average = w->quality.value;
478 w->noise.average = w->noise.value;
479 w->level.average = w->level.value;
480 w->strength.average = w->strength.value;
482 for (h = wpa->con->wi_history; h; h = h->next) {
483 if (strcmp(h->ifname, i->ifname) == 0 &&
484 strcmp(h->bssid, wis->bssid) == 0)
486 w->quality.average += h->quality;
487 w->noise.average += h->noise;
488 w->level.average += h->level;
489 w->strength.average += h->strength;
490 if (++nh == DHCPCD_WI_HIST_MAX) {
500 w->quality.average /= nh;
501 w->noise.average /= nh;
502 w->level.average /= nh;
503 w->strength.average /= nh;
505 h = malloc(sizeof(*h));
507 strlcpy(h->ifname, i->ifname, sizeof(h->ifname));
508 strlcpy(h->bssid, w->bssid, sizeof(h->bssid));
509 h->quality = w->quality.value;
510 h->noise = w->noise.value;
511 h->level = w->level.value;
512 h->strength = w->strength.value;
513 h->next = wpa->con->wi_history;
514 wpa->con->wi_history = h;
522 dhcpcd_wpa_reassociate(DHCPCD_WPA *wpa)
525 return dhcpcd_wpa_command(wpa, "REASSOCIATE");
529 dhcpcd_wpa_disconnect(DHCPCD_WPA *wpa)
532 return dhcpcd_wpa_command(wpa, "DISCONNECT");
536 dhcpcd_wpa_config_write(DHCPCD_WPA *wpa)
539 return dhcpcd_wpa_command(wpa, "SAVE_CONFIG");
543 dhcpcd_wpa_network(DHCPCD_WPA *wpa, const char *cmd, int id)
547 len = strlen(cmd) + 32;
548 if (!dhcpcd_realloc(wpa->con, len))
550 snprintf(wpa->con->buf, wpa->con->buflen, "%s %d", cmd, id);
551 return dhcpcd_wpa_command(wpa, wpa->con->buf);
555 dhcpcd_wpa_network_disable(DHCPCD_WPA *wpa, int id)
558 return dhcpcd_wpa_network(wpa, "DISABLE_NETWORK", id);
562 dhcpcd_wpa_network_enable(DHCPCD_WPA *wpa, int id)
565 return dhcpcd_wpa_network(wpa, "ENABLE_NETWORK", id);
569 dhcpcd_wpa_network_remove(DHCPCD_WPA *wpa, int id)
572 return dhcpcd_wpa_network(wpa, "REMOVE_NETWORK", id);
576 dhcpcd_wpa_network_get(DHCPCD_WPA *wpa, int id, const char *param)
580 if (!dhcpcd_realloc(wpa->con, 2048))
582 snprintf(wpa->con->buf, wpa->con->buflen, "GET_NETWORK %d %s",
584 bytes = wpa_cmd(wpa->command_fd, wpa->con->buf,
585 wpa->con->buf, wpa->con->buflen);
586 if (bytes == 0 || bytes == -1)
588 if (strcmp(wpa->con->buf, "FAIL\n") == 0) {
592 return wpa->con->buf;
596 dhcpcd_wpa_network_set(DHCPCD_WPA *wpa, int id,
597 const char *param, const char *value)
601 len = strlen("SET_NETWORK") + 32 + strlen(param) + strlen(value) + 3;
602 if (!dhcpcd_realloc(wpa->con, len))
604 snprintf(wpa->con->buf, wpa->con->buflen, "SET_NETWORK %d %s %s",
606 return dhcpcd_wpa_command(wpa, wpa->con->buf);
610 dhcpcd_wpa_network_find(DHCPCD_WPA *wpa, const char *fssid)
612 ssize_t bytes, dl, tl;
614 char *s, *t, *ssid, *bssid, *flags;
615 char dssid[IF_SSIDSIZE], tssid[IF_SSIDSIZE];
618 dhcpcd_realloc(wpa->con, 2048);
619 bytes = wpa_cmd(wpa->command_fd, "LIST_NETWORKS",
620 wpa->con->buf, wpa->con->buflen);
621 if (bytes == 0 || bytes == -1)
626 s = strchr(wpa->con->buf, '\n');
629 while ((t = strsep(&s, "\b"))) {
632 ssid = strchr(t, '\t');
636 bssid = strchr(ssid, '\t');
640 flags = strchr(bssid, '\t');
644 l = strtol(t, NULL, 0);
645 if (l < 0 || l > INT_MAX) {
650 /* Decode the wpa_supplicant SSID into raw chars and
651 * then encode into our octal escaped string to
653 dl = dhcpcd_wpa_decode_ssid(dssid, sizeof(dssid), ssid);
656 tl = dhcpcd_encode_string_escape(tssid,
657 sizeof(tssid), dssid, (size_t)dl);
660 if ((size_t)tl == fl && memcmp(tssid, fssid, (size_t)tl) == 0)
668 dhcpcd_wpa_network_new(DHCPCD_WPA *wpa)
673 dhcpcd_realloc(wpa->con, 32);
674 bytes = wpa_cmd(wpa->command_fd, "ADD_NETWORK",
675 wpa->con->buf, sizeof(wpa->con->buf));
676 if (bytes == 0 || bytes == -1)
678 l = strtol(wpa->con->buf, NULL, 0);
679 if (l < 0 || l > INT_MAX) {
686 static const char hexchrs[] = "0123456789abcdef";
688 dhcpcd_wpa_network_find_new(DHCPCD_WPA *wpa, const char *ssid)
691 char dssid[IF_SSIDSIZE], essid[IF_SSIDSIZE], *ep;
695 id = dhcpcd_wpa_network_find(wpa, ssid);
699 dl = dhcpcd_decode_string_escape(dssid, sizeof(dssid), ssid);
703 for (i = 0; i < dl; i++) {
704 if (!isascii((int)dssid[i]) && !isprint((int)dssid[i]))
710 /* Non standard characters found! Encode as hex string */
714 c = (unsigned char)*dp++;
715 *ep++ = hexchrs[(c & 0xf0) >> 4];
716 *ep++ = hexchrs[(c & 0x0f)];
722 while (*++dp != '\0');
727 id = dhcpcd_wpa_network_new(wpa);
729 dhcpcd_wpa_network_set(wpa, id, "ssid", essid);
734 dhcpcd_wpa_close(DHCPCD_WPA *wpa)
739 if (wpa->command_fd == -1 || !wpa->open)
743 dhcpcd_attach_detach(wpa, false);
744 shutdown(wpa->command_fd, SHUT_RDWR);
745 shutdown(wpa->listen_fd, SHUT_RDWR);
747 if (wpa->con->wpa_status_cb)
748 wpa->con->wpa_status_cb(wpa, "down",
749 wpa->con->wpa_status_context);
751 close(wpa->command_fd);
752 wpa->command_fd = -1;
753 close(wpa->listen_fd);
755 unlink(wpa->command_path);
756 free(wpa->command_path);
757 wpa->command_path = NULL;
758 unlink(wpa->listen_path);
759 free(wpa->listen_path);
760 wpa->listen_path = NULL;
764 dhcpcd_wpa_find(DHCPCD_CONNECTION *con, const char *ifname)
768 for (wpa = con->wpa; wpa; wpa = wpa->next) {
769 if (strcmp(wpa->ifname, ifname) == 0)
777 dhcpcd_wpa_new(DHCPCD_CONNECTION *con, const char *ifname)
781 wpa = dhcpcd_wpa_find(con, ifname);
785 wpa = malloc(sizeof(*wpa));
790 strlcpy(wpa->ifname, ifname, sizeof(wpa->ifname));
791 wpa->command_fd = wpa->listen_fd = -1;
792 wpa->command_path = wpa->listen_path = NULL;
793 wpa->next = con->wpa;
799 dhcpcd_wpa_connection(DHCPCD_WPA *wpa)
807 dhcpcd_wpa_if(DHCPCD_WPA *wpa)
810 return dhcpcd_get_if(wpa->con, wpa->ifname, "link");
814 dhcpcd_wpa_open(DHCPCD_WPA *wpa)
816 int cmd_fd, list_fd = -1;
817 char *cmd_path = NULL, *list_path = NULL;
819 if (wpa->listen_fd != -1) {
824 return wpa->listen_fd;
827 cmd_fd = wpa_open(wpa->ifname, &cmd_path);
831 list_fd = wpa_open(wpa->ifname, &list_path);
836 wpa->attached = false;
837 wpa->command_fd = cmd_fd;
838 wpa->command_path = cmd_path;
839 wpa->listen_fd = list_fd;
840 wpa->listen_path = list_path;
841 if (!dhcpcd_attach_detach(wpa, true)) {
842 dhcpcd_wpa_close(wpa);
846 if (wpa->con->wi_scanresults_cb)
847 wpa->con->wi_scanresults_cb(wpa,
848 wpa->con->wi_scanresults_context);
850 return wpa->listen_fd;
866 dhcpcd_wpa_get_fd(DHCPCD_WPA *wpa)
870 return wpa->open ? wpa->listen_fd : -1;
874 dhcpcd_wpa_set_scan_callback(DHCPCD_CONNECTION *con,
875 void (*cb)(DHCPCD_WPA *, void *), void *context)
879 con->wi_scanresults_cb = cb;
880 con->wi_scanresults_context = context;
884 void dhcpcd_wpa_set_status_callback(DHCPCD_CONNECTION * con,
885 void (*cb)(DHCPCD_WPA *, const char *, void *), void *context)
889 con->wpa_status_cb = cb;
890 con->wpa_status_context = context;
894 dhcpcd_wpa_dispatch(DHCPCD_WPA *wpa)
896 char buffer[256], *p;
900 bytes = (size_t)read(wpa->listen_fd, buffer, sizeof(buffer));
901 if ((ssize_t)bytes == -1 || bytes == 0) {
902 dhcpcd_wpa_close(wpa);
906 buffer[bytes] = '\0';
907 bytes = strlen(buffer);
908 if (buffer[bytes - 1] == ' ')
909 buffer[--bytes] = '\0';
910 for (p = buffer + 1; *p != '\0'; p++)
915 if (strcmp(p, "CTRL-EVENT-SCAN-RESULTS") == 0 &&
916 wpa->con->wi_scanresults_cb)
917 wpa->con->wi_scanresults_cb(wpa,
918 wpa->con->wi_scanresults_context);
923 dhcpcd_wpa_if_event(DHCPCD_IF *i)
928 if (strcmp(i->type, "link") == 0) {
929 if (strcmp(i->reason, "STOPPED") == 0 ||
930 strcmp(i->reason, "DEPARTED") == 0)
932 wpa = dhcpcd_wpa_find(i->con, i->ifname);
934 dhcpcd_wpa_close(wpa);
935 } else if (i->wireless && i->con->wpa_started) {
936 wpa = dhcpcd_wpa_new(i->con, i->ifname);
937 if (wpa && wpa->listen_fd == -1)
938 dhcpcd_wpa_open(wpa);
944 dhcpcd_wpa_start(DHCPCD_CONNECTION *con)
949 con->wpa_started = true;
951 for (i = con->interfaces; i; i = i->next)
952 dhcpcd_wpa_if_event(i);
956 dhcpcd_wpa_configure_psk(DHCPCD_WPA *wpa, DHCPCD_WI_SCAN *s, const char *psk)
958 const char *mgmt, *var;
967 id = dhcpcd_wpa_network_find_new(wpa, s->ssid);
969 return DHCPCD_WPA_ERR;
971 if (strcmp(s->flags, "[WEP]") == 0) {
979 if (!dhcpcd_wpa_network_set(wpa, id, "key_mgmt", mgmt))
980 return DHCPCD_WPA_ERR_SET;
983 psk_len = strlen(psk);
986 npsk = malloc(psk_len + 3);
988 return DHCPCD_WPA_ERR;
991 memcpy(npsk + 1, psk, psk_len);
992 npsk[psk_len + 1] = '"';
993 npsk[psk_len + 2] = '\0';
994 r = dhcpcd_wpa_network_set(wpa, id, var, npsk);
997 return DHCPCD_WPA_ERR_SET_PSK;
999 if (!dhcpcd_wpa_network_enable(wpa, id))
1000 return DHCPCD_WPA_ERR_ENABLE;
1001 if (!dhcpcd_wpa_reassociate(wpa))
1002 return DHCPCD_WPA_ERR_ASSOC;
1003 if (!dhcpcd_wpa_config_write(wpa))
1004 return DHCPCD_WPA_ERR_WRITE;
1005 return DHCPCD_WPA_SUCCESS;