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