?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Expand PMF_FN_* macros.
[netbsd-mini2440.git] / dist / wpa / wpa_supplicant / wpa_priv.c
blob4a8d363ad5c517091dd002d84a1e6542d8cb10fe
1 /*
2 * WPA Supplicant / privileged helper program
3 * Copyright (c) 2007, Jouni Malinen <j@w1.fi>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 *
9 * Alternatively, this software may be distributed under the terms of BSD
10 * license.
11 *
12 * See README and COPYING for more details.
13 */
14
15 #include "includes.h"
16 #ifdef __linux__
17 #include <fcntl.h>
18 #endif /* __linux__ */
19 #include <sys/un.h>
20 #include <sys/stat.h>
21
22 #include "common.h"
23 #include "eloop.h"
24 #include "version.h"
25 #include "drivers/driver.h"
26 #include "l2_packet/l2_packet.h"
27 #include "privsep_commands.h"
28 #include "ieee802_11_defs.h"
29
30 #ifndef ETH_P_EAPOL
31 #define ETH_P_EAPOL 0x888e
32 #endif
33
34 #ifndef ETH_P_RSN_PREAUTH
35 #define ETH_P_RSN_PREAUTH 0x88c7
36 #endif
37
38
39 struct wpa_priv_interface {
40 struct wpa_priv_interface *next;
41 char *driver_name;
42 char *ifname;
43 char *sock_name;
44 int fd;
45
46 struct wpa_driver_ops *driver;
47 void *drv_priv;
48 struct sockaddr_un drv_addr;
49 int wpas_registered;
50
51 /* TODO: add support for multiple l2 connections */
52 struct l2_packet_data *l2;
53 struct sockaddr_un l2_addr;
54 };
55
56
57 static void wpa_priv_cmd_register(struct wpa_priv_interface *iface,
58 struct sockaddr_un *from)
59 {
60 if (iface->drv_priv) {
61 wpa_printf(MSG_DEBUG, "Cleaning up forgotten driver instance");
62 if (iface->driver->set_wpa)
63 iface->driver->set_wpa(iface->drv_priv, 0);
64 if (iface->driver->deinit)
65 iface->driver->deinit(iface->drv_priv);
66 iface->drv_priv = NULL;
67 iface->wpas_registered = 0;
68 }
69
70 if (iface->l2) {
71 wpa_printf(MSG_DEBUG, "Cleaning up forgotten l2_packet "
72 "instance");
73 l2_packet_deinit(iface->l2);
74 iface->l2 = NULL;
75 }
76
77 if (iface->driver->init == NULL)
78 return;
79
80 iface->drv_priv = iface->driver->init(iface, iface->ifname);
81 if (iface->drv_priv == NULL) {
82 wpa_printf(MSG_DEBUG, "Failed to initialize driver wrapper");
83 return;
84 }
85
86 wpa_printf(MSG_DEBUG, "Driver wrapper '%s' initialized for interface "
87 "'%s'", iface->driver_name, iface->ifname);
88
89 os_memcpy(&iface->drv_addr, from, sizeof(iface->drv_addr));
90 iface->wpas_registered = 1;
91
92 if (iface->driver->set_param &&
93 iface->driver->set_param(iface->drv_priv, NULL) < 0) {
94 wpa_printf(MSG_ERROR, "Driver interface rejected param");
95 }
96
97 if (iface->driver->set_wpa)
98 iface->driver->set_wpa(iface->drv_priv, 1);
99 }
100
101
102 static void wpa_priv_cmd_unregister(struct wpa_priv_interface *iface,
103 struct sockaddr_un *from)
104 {
105 if (iface->drv_priv) {
106 if (iface->driver->set_wpa)
107 iface->driver->set_wpa(iface->drv_priv, 0);
108 if (iface->driver->deinit)
109 iface->driver->deinit(iface->drv_priv);
110 iface->drv_priv = NULL;
111 iface->wpas_registered = 0;
112 }
113 }
114
115
116 static void wpa_priv_cmd_set_wpa(struct wpa_priv_interface *iface,
117 char *buf, size_t len)
118 {
119 if (iface->drv_priv == NULL || len != sizeof(int))
120 return;
121
122 if (iface->driver->set_wpa)
123 iface->driver->set_wpa(iface->drv_priv, *((int *) buf));
124 }
125
126
127 static void wpa_priv_cmd_scan(struct wpa_priv_interface *iface,
128 char *buf, size_t len)
129 {
130 if (iface->drv_priv == NULL)
131 return;
132
133 if (iface->driver->scan)
134 iface->driver->scan(iface->drv_priv, len ? (u8 *) buf : NULL,
135 len);
136 }
137
138
139 static void wpa_priv_get_scan_results2(struct wpa_priv_interface *iface,
140 struct sockaddr_un *from)
141 {
142 struct wpa_scan_results *res;
143 u8 *buf = NULL, *pos, *end;
144 int val;
145 size_t i;
146
147 res = iface->driver->get_scan_results2(iface->drv_priv);
148 if (res == NULL)
149 goto fail;
150
151 buf = os_malloc(60000);
152 if (buf == NULL)
153 goto fail;
154 pos = buf;
155 end = buf + 60000;
156 val = res->num;
157 os_memcpy(pos, &val, sizeof(int));
158 pos += sizeof(int);
159
160 for (i = 0; i < res->num; i++) {
161 struct wpa_scan_res *r = res->res[i];
162 val = sizeof(*r) + r->ie_len;
163 if (end - pos < (int) sizeof(int) + val)
164 break;
165 os_memcpy(pos, &val, sizeof(int));
166 pos += sizeof(int);
167 os_memcpy(pos, r, val);
168 pos += val;
169 }
170
171 sendto(iface->fd, buf, pos - buf, 0, (struct sockaddr *) from,
172 sizeof(*from));
173
174 os_free(buf);
175 os_free(res);
176 return;
177
178 fail:
179 os_free(buf);
180 os_free(res);
181 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
182 }
183
184
185 static void wpa_priv_send_old_scan_results(struct wpa_priv_interface *iface,
186 struct sockaddr_un *from)
187 {
188 #define SCAN_AP_LIMIT 128
189 int i, res, val;
190 struct wpa_scan_result *results = NULL;
191 u8 *buf = NULL, *pos, *end;
192 struct wpa_scan_res nres;
193
194 results = os_malloc(SCAN_AP_LIMIT * sizeof(*results));
195 if (results == NULL)
196 goto fail;
197
198 res = iface->driver->get_scan_results(iface->drv_priv, results,
199 SCAN_AP_LIMIT);
200 if (res < 0 || res > SCAN_AP_LIMIT)
201 goto fail;
202
203 buf = os_malloc(60000);
204 if (buf == NULL)
205 goto fail;
206 pos = buf;
207 end = buf + 60000;
208 os_memcpy(pos, &res, sizeof(int));
209 pos += sizeof(int);
210
211 os_memset(&nres, 0, sizeof(nres));
212 for (i = 0; i < res; i++) {
213 struct wpa_scan_result *r = &results[i];
214 size_t ie_len;
215
216 ie_len = 2 + r->ssid_len + r->rsn_ie_len + r->wpa_ie_len;
217 if (r->maxrate)
218 ie_len += 3;
219 if (r->mdie_present)
220 ie_len += 5;
221
222 val = sizeof(nres) + ie_len;
223 if (end - pos < (int) sizeof(int) + val)
224 break;
225 os_memcpy(pos, &val, sizeof(int));
226 pos += sizeof(int);
227
228 os_memcpy(nres.bssid, r->bssid, ETH_ALEN);
229 nres.freq = r->freq;
230 nres.caps = r->caps;
231 nres.qual = r->qual;
232 nres.noise = r->noise;
233 nres.level = r->level;
234 nres.tsf = r->tsf;
235 nres.ie_len = ie_len;
236
237 os_memcpy(pos, &nres, sizeof(nres));
238 pos += sizeof(nres);
239
240 /* SSID IE */
241 *pos++ = WLAN_EID_SSID;
242 *pos++ = r->ssid_len;
243 os_memcpy(pos, r->ssid, r->ssid_len);
244 pos += r->ssid_len;
245
246 if (r->maxrate) {
247 /* Fake Supported Rate IE to include max rate */
248 *pos++ = WLAN_EID_SUPP_RATES;
249 *pos++ = 1;
250 *pos++ = r->maxrate;
251 }
252
253 if (r->rsn_ie_len) {
254 os_memcpy(pos, r->rsn_ie, r->rsn_ie_len);
255 pos += r->rsn_ie_len;
256 }
257
258 if (r->mdie_present) {
259 os_memcpy(pos, r->mdie, 5);
260 pos += 5;
261 }
262
263 if (r->wpa_ie_len) {
264 os_memcpy(pos, r->wpa_ie, r->wpa_ie_len);
265 pos += r->wpa_ie_len;
266 }
267 }
268
269 sendto(iface->fd, buf, pos - buf, 0, (struct sockaddr *) from,
270 sizeof(*from));
271
272 os_free(buf);
273 os_free(results);
274 return;
275
276 fail:
277 os_free(buf);
278 os_free(results);
279 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
280 }
281
282
283 static void wpa_priv_cmd_get_scan_results(struct wpa_priv_interface *iface,
284 struct sockaddr_un *from)
285 {
286 if (iface->drv_priv == NULL)
287 return;
288
289 if (iface->driver->get_scan_results2)
290 wpa_priv_get_scan_results2(iface, from);
291 else if (iface->driver->get_scan_results)
292 wpa_priv_send_old_scan_results(iface, from);
293 else
294 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from,
295 sizeof(*from));
296 }
297
298
299 static void wpa_priv_cmd_associate(struct wpa_priv_interface *iface,
300 void *buf, size_t len)
301 {
302 struct wpa_driver_associate_params params;
303 struct privsep_cmd_associate *assoc;
304 u8 *bssid;
305 int res;
306
307 if (iface->drv_priv == NULL || iface->driver->associate == NULL)
308 return;
309
310 if (len < sizeof(*assoc)) {
311 wpa_printf(MSG_DEBUG, "Invalid association request");
312 return;
313 }
314
315 assoc = buf;
316 if (sizeof(*assoc) + assoc->wpa_ie_len > len) {
317 wpa_printf(MSG_DEBUG, "Association request overflow");
318 return;
319 }
320
321 os_memset(&params, 0, sizeof(params));
322 bssid = assoc->bssid;
323 if (bssid[0] | bssid[1] | bssid[2] | bssid[3] | bssid[4] | bssid[5])
324 params.bssid = bssid;
325 params.ssid = assoc->ssid;
326 if (assoc->ssid_len > 32)
327 return;
328 params.ssid_len = assoc->ssid_len;
329 params.freq = assoc->freq;
330 if (assoc->wpa_ie_len) {
331 params.wpa_ie = (u8 *) (assoc + 1);
332 params.wpa_ie_len = assoc->wpa_ie_len;
333 }
334 params.pairwise_suite = assoc->pairwise_suite;
335 params.group_suite = assoc->group_suite;
336 params.key_mgmt_suite = assoc->key_mgmt_suite;
337 params.auth_alg = assoc->auth_alg;
338 params.mode = assoc->mode;
339
340 res = iface->driver->associate(iface->drv_priv, &params);
341 wpa_printf(MSG_DEBUG, "drv->associate: res=%d", res);
342 }
343
344
345 static void wpa_priv_cmd_get_bssid(struct wpa_priv_interface *iface,
346 struct sockaddr_un *from)
347 {
348 u8 bssid[ETH_ALEN];
349
350 if (iface->drv_priv == NULL)
351 goto fail;
352
353 if (iface->driver->get_bssid == NULL ||
354 iface->driver->get_bssid(iface->drv_priv, bssid) < 0)
355 goto fail;
356
357 sendto(iface->fd, bssid, ETH_ALEN, 0, (struct sockaddr *) from,
358 sizeof(*from));
359 return;
360
361 fail:
362 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
363 }
364
365
366 static void wpa_priv_cmd_get_ssid(struct wpa_priv_interface *iface,
367 struct sockaddr_un *from)
368 {
369 u8 ssid[sizeof(int) + 32];
370 int res;
371
372 if (iface->drv_priv == NULL)
373 goto fail;
374
375 if (iface->driver->get_ssid == NULL)
376 goto fail;
377
378 res = iface->driver->get_ssid(iface->drv_priv, &ssid[sizeof(int)]);
379 if (res < 0 || res > 32)
380 goto fail;
381 os_memcpy(ssid, &res, sizeof(int));
382
383 sendto(iface->fd, ssid, sizeof(ssid), 0, (struct sockaddr *) from,
384 sizeof(*from));
385 return;
386
387 fail:
388 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
389 }
390
391
392 static void wpa_priv_cmd_set_key(struct wpa_priv_interface *iface,
393 void *buf, size_t len)
394 {
395 struct privsep_cmd_set_key *params;
396 int res;
397
398 if (iface->drv_priv == NULL || iface->driver->set_key == NULL)
399 return;
400
401 if (len != sizeof(*params)) {
402 wpa_printf(MSG_DEBUG, "Invalid set_key request");
403 return;
404 }
405
406 params = buf;
407
408 res = iface->driver->set_key(iface->drv_priv, params->alg,
409 params->addr, params->key_idx,
410 params->set_tx,
411 params->seq_len ? params->seq : NULL,
412 params->seq_len,
413 params->key_len ? params->key : NULL,
414 params->key_len);
415 wpa_printf(MSG_DEBUG, "drv->set_key: res=%d", res);
416 }
417
418
419 static void wpa_priv_cmd_get_capa(struct wpa_priv_interface *iface,
420 struct sockaddr_un *from)
421 {
422 struct wpa_driver_capa capa;
423
424 if (iface->drv_priv == NULL)
425 goto fail;
426
427 if (iface->driver->get_capa == NULL ||
428 iface->driver->get_capa(iface->drv_priv, &capa) < 0)
429 goto fail;
430
431 sendto(iface->fd, &capa, sizeof(capa), 0, (struct sockaddr *) from,
432 sizeof(*from));
433 return;
434
435 fail:
436 sendto(iface->fd, "", 0, 0, (struct sockaddr *) from, sizeof(*from));
437 }
438
439
440 static void wpa_priv_l2_rx(void *ctx, const u8 *src_addr, const u8 *buf,
441 size_t len)
442 {
443 struct wpa_priv_interface *iface = ctx;
444 struct msghdr msg;
445 struct iovec io[2];
446
447 io[0].iov_base = (u8 *) src_addr;
448 io[0].iov_len = ETH_ALEN;
449 io[1].iov_base = (u8 *) buf;
450 io[1].iov_len = len;
451
452 os_memset(&msg, 0, sizeof(msg));
453 msg.msg_iov = io;
454 msg.msg_iovlen = 2;
455 msg.msg_name = &iface->l2_addr;
456 msg.msg_namelen = sizeof(iface->l2_addr);
457
458 if (sendmsg(iface->fd, &msg, 0) < 0) {
459 perror("sendmsg(l2 rx)");
460 }
461 }
462
463
464 static void wpa_priv_cmd_l2_register(struct wpa_priv_interface *iface,
465 struct sockaddr_un *from,
466 void *buf, size_t len)
467 {
468 int *reg_cmd = buf;
469 u8 own_addr[ETH_ALEN];
470 int res;
471 u16 proto;
472
473 if (len != 2 * sizeof(int)) {
474 wpa_printf(MSG_DEBUG, "Invalid l2_register length %lu",
475 (unsigned long) len);
476 return;
477 }
478
479 proto = reg_cmd[0];
480 if (proto != ETH_P_EAPOL && proto != ETH_P_RSN_PREAUTH) {
481 wpa_printf(MSG_DEBUG, "Refused l2_packet connection for "
482 "ethertype 0x%x", proto);
483 return;
484 }
485
486 if (iface->l2) {
487 wpa_printf(MSG_DEBUG, "Cleaning up forgotten l2_packet "
488 "instance");
489 l2_packet_deinit(iface->l2);
490 iface->l2 = NULL;
491 }
492
493 os_memcpy(&iface->l2_addr, from, sizeof(iface->l2_addr));
494
495 iface->l2 = l2_packet_init(iface->ifname, NULL, proto,
496 wpa_priv_l2_rx, iface, reg_cmd[1]);
497 if (iface->l2 == NULL) {
498 wpa_printf(MSG_DEBUG, "Failed to initialize l2_packet "
499 "instance for protocol %d", proto);
500 return;
501 }
502
503 if (l2_packet_get_own_addr(iface->l2, own_addr) < 0) {
504 wpa_printf(MSG_DEBUG, "Failed to get own address from "
505 "l2_packet");
506 l2_packet_deinit(iface->l2);
507 iface->l2 = NULL;
508 return;
509 }
510
511 res = sendto(iface->fd, own_addr, ETH_ALEN, 0,
512 (struct sockaddr *) from, sizeof(*from));
513 wpa_printf(MSG_DEBUG, "L2 registration: res=%d", res);
514 }
515
516
517 static void wpa_priv_cmd_l2_unregister(struct wpa_priv_interface *iface,
518 struct sockaddr_un *from)
519 {
520 if (iface->l2) {
521 l2_packet_deinit(iface->l2);
522 iface->l2 = NULL;
523 }
524 }
525
526
527 static void wpa_priv_cmd_l2_notify_auth_start(struct wpa_priv_interface *iface,
528 struct sockaddr_un *from)
529 {
530 if (iface->l2)
531 l2_packet_notify_auth_start(iface->l2);
532 }
533
534
535 static void wpa_priv_cmd_l2_send(struct wpa_priv_interface *iface,
536 struct sockaddr_un *from,
537 void *buf, size_t len)
538 {
539 u8 *dst_addr;
540 u16 proto;
541 int res;
542
543 if (iface->l2 == NULL)
544 return;
545
546 if (len < ETH_ALEN + 2) {
547 wpa_printf(MSG_DEBUG, "Too short L2 send packet (len=%lu)",
548 (unsigned long) len);
549 return;
550 }
551
552 dst_addr = buf;
553 os_memcpy(&proto, buf + ETH_ALEN, 2);
554
555 if (proto != ETH_P_EAPOL && proto != ETH_P_RSN_PREAUTH) {
556 wpa_printf(MSG_DEBUG, "Refused l2_packet send for ethertype "
557 "0x%x", proto);
558 return;
559 }
560
561 res = l2_packet_send(iface->l2, dst_addr, proto, buf + ETH_ALEN + 2,
562 len - ETH_ALEN - 2);
563 wpa_printf(MSG_DEBUG, "L2 send: res=%d", res);
564 }
565
566
567 static void wpa_priv_receive(int sock, void *eloop_ctx, void *sock_ctx)
568 {
569 struct wpa_priv_interface *iface = eloop_ctx;
570 char buf[2000];
571 void *cmd_buf;
572 size_t cmd_len;
573 int res, cmd;
574 struct sockaddr_un from;
575 socklen_t fromlen = sizeof(from);
576
577 res = recvfrom(sock, buf, sizeof(buf), 0, (struct sockaddr *) &from,
578 &fromlen);
579 if (res < 0) {
580 perror("recvfrom");
581 return;
582 }
583
584 if (res < (int) sizeof(int)) {
585 wpa_printf(MSG_DEBUG, "Too short command (len=%d)", res);
586 return;
587 }
588
589 os_memcpy(&cmd, buf, sizeof(int));
590 wpa_printf(MSG_DEBUG, "Command %d for interface %s",
591 cmd, iface->ifname);
592 cmd_buf = &buf[sizeof(int)];
593 cmd_len = res - sizeof(int);
594
595 switch (cmd) {
596 case PRIVSEP_CMD_REGISTER:
597 wpa_priv_cmd_register(iface, &from);
598 break;
599 case PRIVSEP_CMD_UNREGISTER:
600 wpa_priv_cmd_unregister(iface, &from);
601 break;
602 case PRIVSEP_CMD_SET_WPA:
603 wpa_priv_cmd_set_wpa(iface, cmd_buf, cmd_len);
604 break;
605 case PRIVSEP_CMD_SCAN:
606 wpa_priv_cmd_scan(iface, cmd_buf, cmd_len);
607 break;
608 case PRIVSEP_CMD_GET_SCAN_RESULTS:
609 wpa_priv_cmd_get_scan_results(iface, &from);
610 break;
611 case PRIVSEP_CMD_ASSOCIATE:
612 wpa_priv_cmd_associate(iface, cmd_buf, cmd_len);
613 break;
614 case PRIVSEP_CMD_GET_BSSID:
615 wpa_priv_cmd_get_bssid(iface, &from);
616 break;
617 case PRIVSEP_CMD_GET_SSID:
618 wpa_priv_cmd_get_ssid(iface, &from);
619 break;
620 case PRIVSEP_CMD_SET_KEY:
621 wpa_priv_cmd_set_key(iface, cmd_buf, cmd_len);
622 break;
623 case PRIVSEP_CMD_GET_CAPA:
624 wpa_priv_cmd_get_capa(iface, &from);
625 break;
626 case PRIVSEP_CMD_L2_REGISTER:
627 wpa_priv_cmd_l2_register(iface, &from, cmd_buf, cmd_len);
628 break;
629 case PRIVSEP_CMD_L2_UNREGISTER:
630 wpa_priv_cmd_l2_unregister(iface, &from);
631 break;
632 case PRIVSEP_CMD_L2_NOTIFY_AUTH_START:
633 wpa_priv_cmd_l2_notify_auth_start(iface, &from);
634 break;
635 case PRIVSEP_CMD_L2_SEND:
636 wpa_priv_cmd_l2_send(iface, &from, cmd_buf, cmd_len);
637 break;
638 }
639 }
640
641
642 static void wpa_priv_interface_deinit(struct wpa_priv_interface *iface)
643 {
644 if (iface->drv_priv && iface->driver->deinit)
645 iface->driver->deinit(iface->drv_priv);
646
647 if (iface->fd >= 0) {
648 eloop_unregister_read_sock(iface->fd);
649 close(iface->fd);
650 unlink(iface->sock_name);
651 }
652
653 if (iface->l2)
654 l2_packet_deinit(iface->l2);
655
656 os_free(iface->ifname);
657 os_free(iface->driver_name);
658 os_free(iface->sock_name);
659 os_free(iface);
660 }
661
662
663 extern struct wpa_driver_ops *wpa_supplicant_drivers[];
664
665 static struct wpa_priv_interface *
666 wpa_priv_interface_init(const char *dir, const char *params)
667 {
668 struct wpa_priv_interface *iface;
669 char *pos;
670 size_t len;
671 struct sockaddr_un addr;
672 int i;
673
674 pos = os_strchr(params, ':');
675 if (pos == NULL)
676 return NULL;
677
678 iface = os_zalloc(sizeof(*iface));
679 if (iface == NULL)
680 return NULL;
681 iface->fd = -1;
682
683 len = pos - params;
684 iface->driver_name = os_malloc(len + 1);
685 if (iface->driver_name == NULL) {
686 wpa_priv_interface_deinit(iface);
687 return NULL;
688 }
689 os_memcpy(iface->driver_name, params, len);
690 iface->driver_name[len] = '\0';
691
692 for (i = 0; wpa_supplicant_drivers[i]; i++) {
693 if (os_strcmp(iface->driver_name,
694 wpa_supplicant_drivers[i]->name) == 0) {
695 iface->driver = wpa_supplicant_drivers[i];
696 break;
697 }
698 }
699 if (iface->driver == NULL) {
700 wpa_printf(MSG_ERROR, "Unsupported driver '%s'",
701 iface->driver_name);
702 wpa_priv_interface_deinit(iface);
703 return NULL;
704 }
705
706 pos++;
707 iface->ifname = os_strdup(pos);
708 if (iface->ifname == NULL) {
709 wpa_priv_interface_deinit(iface);
710 return NULL;
711 }
712
713 len = os_strlen(dir) + 1 + os_strlen(iface->ifname);
714 iface->sock_name = os_malloc(len + 1);
715 if (iface->sock_name == NULL) {
716 wpa_priv_interface_deinit(iface);
717 return NULL;
718 }
719
720 os_snprintf(iface->sock_name, len + 1, "%s/%s", dir, iface->ifname);
721 if (os_strlen(iface->sock_name) >= sizeof(addr.sun_path)) {
722 wpa_priv_interface_deinit(iface);
723 return NULL;
724 }
725
726 iface->fd = socket(PF_UNIX, SOCK_DGRAM, 0);
727 if (iface->fd < 0) {
728 perror("socket(PF_UNIX)");
729 wpa_priv_interface_deinit(iface);
730 return NULL;
731 }
732
733 os_memset(&addr, 0, sizeof(addr));
734 addr.sun_family = AF_UNIX;
735 os_strlcpy(addr.sun_path, iface->sock_name, sizeof(addr.sun_path));
736
737 if (bind(iface->fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
738 wpa_printf(MSG_DEBUG, "bind(PF_UNIX) failed: %s",
739 strerror(errno));
740 if (connect(iface->fd, (struct sockaddr *) &addr,
741 sizeof(addr)) < 0) {
742 wpa_printf(MSG_DEBUG, "Socket exists, but does not "
743 "allow connections - assuming it was "
744 "leftover from forced program termination");
745 if (unlink(iface->sock_name) < 0) {
746 perror("unlink[ctrl_iface]");
747 wpa_printf(MSG_ERROR, "Could not unlink "
748 "existing ctrl_iface socket '%s'",
749 iface->sock_name);
750 goto fail;
751 }
752 if (bind(iface->fd, (struct sockaddr *) &addr,
753 sizeof(addr)) < 0) {
754 perror("bind(PF_UNIX)");
755 goto fail;
756 }
757 wpa_printf(MSG_DEBUG, "Successfully replaced leftover "
758 "socket '%s'", iface->sock_name);
759 } else {
760 wpa_printf(MSG_INFO, "Socket exists and seems to be "
761 "in use - cannot override it");
762 wpa_printf(MSG_INFO, "Delete '%s' manually if it is "
763 "not used anymore", iface->sock_name);
764 goto fail;
765 }
766 }
767
768 if (chmod(iface->sock_name, S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
769 perror("chmod");
770 goto fail;
771 }
772
773 eloop_register_read_sock(iface->fd, wpa_priv_receive, iface, NULL);
774
775 return iface;
776
777 fail:
778 wpa_priv_interface_deinit(iface);
779 return NULL;
780 }
781
782
783 static int wpa_priv_send_event(struct wpa_priv_interface *iface, int event,
784 const void *data, size_t data_len)
785 {
786 struct msghdr msg;
787 struct iovec io[2];
788
789 io[0].iov_base = &event;
790 io[0].iov_len = sizeof(event);
791 io[1].iov_base = (u8 *) data;
792 io[1].iov_len = data_len;
793
794 os_memset(&msg, 0, sizeof(msg));
795 msg.msg_iov = io;
796 msg.msg_iovlen = data ? 2 : 1;
797 msg.msg_name = &iface->drv_addr;
798 msg.msg_namelen = sizeof(iface->drv_addr);
799
800 if (sendmsg(iface->fd, &msg, 0) < 0) {
801 perror("sendmsg(wpas_socket)");
802 return -1;
803 }
804
805 return 0;
806 }
807
808
809 static void wpa_priv_send_assoc(struct wpa_priv_interface *iface, int event,
810 union wpa_event_data *data)
811 {
812 size_t buflen = 3 * sizeof(int);
813 u8 *buf, *pos;
814 int len;
815
816 if (data) {
817 buflen += data->assoc_info.req_ies_len +
818 data->assoc_info.resp_ies_len +
819 data->assoc_info.beacon_ies_len;
820 }
821
822 buf = os_malloc(buflen);
823 if (buf == NULL)
824 return;
825
826 pos = buf;
827
828 if (data && data->assoc_info.req_ies) {
829 len = data->assoc_info.req_ies_len;
830 os_memcpy(pos, &len, sizeof(int));
831 pos += sizeof(int);
832 os_memcpy(pos, data->assoc_info.req_ies, len);
833 pos += len;
834 } else {
835 len = 0;
836 os_memcpy(pos, &len, sizeof(int));
837 pos += sizeof(int);
838 }
839
840 if (data && data->assoc_info.resp_ies) {
841 len = data->assoc_info.resp_ies_len;
842 os_memcpy(pos, &len, sizeof(int));
843 pos += sizeof(int);
844 os_memcpy(pos, data->assoc_info.resp_ies, len);
845 pos += len;
846 } else {
847 len = 0;
848 os_memcpy(pos, &len, sizeof(int));
849 pos += sizeof(int);
850 }
851
852 if (data && data->assoc_info.beacon_ies) {
853 len = data->assoc_info.beacon_ies_len;
854 os_memcpy(pos, &len, sizeof(int));
855 pos += sizeof(int);
856 os_memcpy(pos, data->assoc_info.beacon_ies, len);
857 pos += len;
858 } else {
859 len = 0;
860 os_memcpy(pos, &len, sizeof(int));
861 pos += sizeof(int);
862 }
863
864 wpa_priv_send_event(iface, event, buf, buflen);
865
866 os_free(buf);
867 }
868
869
870 static void wpa_priv_send_interface_status(struct wpa_priv_interface *iface,
871 union wpa_event_data *data)
872 {
873 int ievent;
874 size_t len, maxlen;
875 u8 *buf;
876 char *ifname;
877
878 if (data == NULL)
879 return;
880
881 ievent = data->interface_status.ievent;
882 maxlen = sizeof(data->interface_status.ifname);
883 ifname = data->interface_status.ifname;
884 for (len = 0; len < maxlen && ifname[len]; len++)
885 ;
886
887 buf = os_malloc(sizeof(int) + len);
888 if (buf == NULL)
889 return;
890
891 os_memcpy(buf, &ievent, sizeof(int));
892 os_memcpy(buf + sizeof(int), ifname, len);
893
894 wpa_priv_send_event(iface, PRIVSEP_EVENT_INTERFACE_STATUS,
895 buf, sizeof(int) + len);
896
897 os_free(buf);
898
899 }
900
901
902 static void wpa_priv_send_ft_response(struct wpa_priv_interface *iface,
903 union wpa_event_data *data)
904 {
905 size_t len;
906 u8 *buf, *pos;
907
908 if (data == NULL || data->ft_ies.ies == NULL)
909 return;
910
911 len = sizeof(int) + ETH_ALEN + data->ft_ies.ies_len;
912 buf = os_malloc(len);
913 if (buf == NULL)
914 return;
915
916 pos = buf;
917 os_memcpy(pos, &data->ft_ies.ft_action, sizeof(int));
918 pos += sizeof(int);
919 os_memcpy(pos, data->ft_ies.target_ap, ETH_ALEN);
920 pos += ETH_ALEN;
921 os_memcpy(pos, data->ft_ies.ies, data->ft_ies.ies_len);
922
923 wpa_priv_send_event(iface, PRIVSEP_EVENT_FT_RESPONSE, buf, len);
924
925 os_free(buf);
926
927 }
928
929
930 void wpa_supplicant_event(void *ctx, wpa_event_type event,
931 union wpa_event_data *data)
932 {
933 struct wpa_priv_interface *iface = ctx;
934
935 wpa_printf(MSG_DEBUG, "%s - event=%d", __func__, event);
936
937 if (!iface->wpas_registered) {
938 wpa_printf(MSG_DEBUG, "Driver event received, but "
939 "wpa_supplicant not registered");
940 return;
941 }
942
943 switch (event) {
944 case EVENT_ASSOC:
945 wpa_priv_send_assoc(iface, PRIVSEP_EVENT_ASSOC, data);
946 break;
947 case EVENT_DISASSOC:
948 wpa_priv_send_event(iface, PRIVSEP_EVENT_DISASSOC, NULL, 0);
949 break;
950 case EVENT_ASSOCINFO:
951 if (data == NULL)
952 return;
953 wpa_priv_send_assoc(iface, PRIVSEP_EVENT_ASSOCINFO, data);
954 break;
955 case EVENT_MICHAEL_MIC_FAILURE:
956 if (data == NULL)
957 return;
958 wpa_priv_send_event(iface, PRIVSEP_EVENT_MICHAEL_MIC_FAILURE,
959 &data->michael_mic_failure.unicast,
960 sizeof(int));
961 break;
962 case EVENT_SCAN_RESULTS:
963 wpa_priv_send_event(iface, PRIVSEP_EVENT_SCAN_RESULTS, NULL,
964 0);
965 break;
966 case EVENT_INTERFACE_STATUS:
967 wpa_priv_send_interface_status(iface, data);
968 break;
969 case EVENT_PMKID_CANDIDATE:
970 if (data == NULL)
971 return;
972 wpa_priv_send_event(iface, PRIVSEP_EVENT_PMKID_CANDIDATE,
973 &data->pmkid_candidate,
974 sizeof(struct pmkid_candidate));
975 break;
976 case EVENT_STKSTART:
977 if (data == NULL)
978 return;
979 wpa_priv_send_event(iface, PRIVSEP_EVENT_STKSTART,
980 &data->stkstart.peer, ETH_ALEN);
981 break;
982 case EVENT_FT_RESPONSE:
983 wpa_priv_send_ft_response(iface, data);
984 break;
985 default:
986 wpa_printf(MSG_DEBUG, "Unsupported driver event %d - TODO",
987 event);
988 break;
989 }
990 }
991
992
993 void wpa_supplicant_rx_eapol(void *ctx, const u8 *src_addr,
994 const u8 *buf, size_t len)
995 {
996 struct wpa_priv_interface *iface = ctx;
997 struct msghdr msg;
998 struct iovec io[3];
999 int event = PRIVSEP_EVENT_RX_EAPOL;
1000
1001 wpa_printf(MSG_DEBUG, "RX EAPOL from driver");
1002 io[0].iov_base = &event;
1003 io[0].iov_len = sizeof(event);
1004 io[1].iov_base = (u8 *) src_addr;
1005 io[1].iov_len = ETH_ALEN;
1006 io[2].iov_base = (u8 *) buf;
1007 io[2].iov_len = len;
1008
1009 os_memset(&msg, 0, sizeof(msg));
1010 msg.msg_iov = io;
1011 msg.msg_iovlen = 3;
1012 msg.msg_name = &iface->drv_addr;
1013 msg.msg_namelen = sizeof(iface->drv_addr);
1014
1015 if (sendmsg(iface->fd, &msg, 0) < 0)
1016 perror("sendmsg(wpas_socket)");
1017 }
1018
1019 static void wpa_priv_terminate(int sig, void *eloop_ctx, void *signal_ctx)
1020 {
1021 wpa_printf(MSG_DEBUG, "wpa_priv termination requested");
1022 eloop_terminate();
1023 }
1024
1025
1026 static void wpa_priv_fd_workaround(void)
1027 {
1028 #ifdef __linux__
1029 int s, i;
1030 /* When started from pcmcia-cs scripts, wpa_supplicant might start with
1031 * fd 0, 1, and 2 closed. This will cause some issues because many
1032 * places in wpa_supplicant are still printing out to stdout. As a
1033 * workaround, make sure that fd's 0, 1, and 2 are not used for other
1034 * sockets. */
1035 for (i = 0; i < 3; i++) {
1036 s = open("/dev/null", O_RDWR);
1037 if (s > 2) {
1038 close(s);
1039 break;
1040 }
1041 }
1042 #endif /* __linux__ */
1043 }
1044
1045
1046 static void usage(void)
1047 {
1048 printf("wpa_priv v" VERSION_STR "\n"
1049 "Copyright (c) 2007, Jouni Malinen <j@w1.fi> and contributors\n"
1050 "\n"
1051 "usage:\n"
1052 " wpa_priv [-Bdd] [-P<pid file>] <driver:ifname> "
1053 "[driver:ifname ...]\n");
1054 }
1055
1056
1057 extern int wpa_debug_level;
1058
1059 int main(int argc, char *argv[])
1060 {
1061 int c, i;
1062 int ret = -1;
1063 char *pid_file = NULL;
1064 int daemonize = 0;
1065 char *ctrl_dir = "/var/run/wpa_priv";
1066 struct wpa_priv_interface *interfaces = NULL, *iface;
1067
1068 if (os_program_init())
1069 return -1;
1070
1071 wpa_priv_fd_workaround();
1072
1073 for (;;) {
1074 c = getopt(argc, argv, "Bc:dP:");
1075 if (c < 0)
1076 break;
1077 switch (c) {
1078 case 'B':
1079 daemonize++;
1080 break;
1081 case 'c':
1082 ctrl_dir = optarg;
1083 break;
1084 case 'd':
1085 wpa_debug_level--;
1086 break;
1087 case 'P':
1088 pid_file = os_rel2abs_path(optarg);
1089 break;
1090 default:
1091 usage();
1092 goto out;
1093 }
1094 }
1095
1096 if (optind >= argc) {
1097 usage();
1098 goto out;
1099 }
1100
1101 wpa_printf(MSG_DEBUG, "wpa_priv control directory: '%s'", ctrl_dir);
1102
1103 if (eloop_init(NULL)) {
1104 wpa_printf(MSG_ERROR, "Failed to initialize event loop");
1105 goto out;
1106 }
1107
1108 for (i = optind; i < argc; i++) {
1109 wpa_printf(MSG_DEBUG, "Adding driver:interface %s", argv[i]);
1110 iface = wpa_priv_interface_init(ctrl_dir, argv[i]);
1111 if (iface == NULL)
1112 goto out;
1113 iface->next = interfaces;
1114 interfaces = iface;
1115 }
1116
1117 if (daemonize && os_daemonize(pid_file))
1118 goto out;
1119
1120 eloop_register_signal_terminate(wpa_priv_terminate, NULL);
1121 eloop_run();
1122
1123 ret = 0;
1124
1125 out:
1126 iface = interfaces;
1127 while (iface) {
1128 struct wpa_priv_interface *prev = iface;
1129 iface = iface->next;
1130 wpa_priv_interface_deinit(prev);
1131 }
1132
1133 eloop_destroy();
1134
1135 os_daemonize_terminate(pid_file);
1136 os_free(pid_file);
1137 os_program_deinit();
1138
1139 return ret;
1140 }
NetBSD on the FriendlyARM MINI2440