Disconnect hostapd from building in base
[dragonfly.git] / contrib / hostapd / src / drivers / rfkill.c
1 /*
2  * Linux rfkill helper functions for driver wrappers
3  * Copyright (c) 2010, Jouni Malinen <j@w1.fi>
4  *
5  * This software may be distributed under the terms of the BSD license.
6  * See README for more details.
7  */
8
9 #include "includes.h"
10 #include <fcntl.h>
11
12 #include "utils/common.h"
13 #include "utils/eloop.h"
14 #include "rfkill.h"
15
16 #define RFKILL_EVENT_SIZE_V1 8
17
18 struct rfkill_event {
19         u32 idx;
20         u8 type;
21         u8 op;
22         u8 soft;
23         u8 hard;
24 } STRUCT_PACKED;
25
26 enum rfkill_operation {
27         RFKILL_OP_ADD = 0,
28         RFKILL_OP_DEL,
29         RFKILL_OP_CHANGE,
30         RFKILL_OP_CHANGE_ALL,
31 };
32
33 enum rfkill_type {
34         RFKILL_TYPE_ALL = 0,
35         RFKILL_TYPE_WLAN,
36         RFKILL_TYPE_BLUETOOTH,
37         RFKILL_TYPE_UWB,
38         RFKILL_TYPE_WIMAX,
39         RFKILL_TYPE_WWAN,
40         RFKILL_TYPE_GPS,
41         RFKILL_TYPE_FM,
42         NUM_RFKILL_TYPES,
43 };
44
45
46 struct rfkill_data {
47         struct rfkill_config *cfg;
48         int fd;
49         int blocked;
50 };
51
52
53 static void rfkill_receive(int sock, void *eloop_ctx, void *sock_ctx)
54 {
55         struct rfkill_data *rfkill = eloop_ctx;
56         struct rfkill_event event;
57         ssize_t len;
58         int new_blocked;
59
60         len = read(rfkill->fd, &event, sizeof(event));
61         if (len < 0) {
62                 wpa_printf(MSG_ERROR, "rfkill: Event read failed: %s",
63                            strerror(errno));
64                 return;
65         }
66         if (len != RFKILL_EVENT_SIZE_V1) {
67                 wpa_printf(MSG_DEBUG, "rfkill: Unexpected event size "
68                            "%d (expected %d)",
69                            (int) len, RFKILL_EVENT_SIZE_V1);
70                 return;
71         }
72         wpa_printf(MSG_DEBUG, "rfkill: event: idx=%u type=%d "
73                    "op=%u soft=%u hard=%u",
74                    event.idx, event.type, event.op, event.soft,
75                    event.hard);
76         if (event.op != RFKILL_OP_CHANGE || event.type != RFKILL_TYPE_WLAN)
77                 return;
78
79         if (event.hard) {
80                 wpa_printf(MSG_INFO, "rfkill: WLAN hard blocked");
81                 new_blocked = 1;
82         } else if (event.soft) {
83                 wpa_printf(MSG_INFO, "rfkill: WLAN soft blocked");
84                 new_blocked = 1;
85         } else {
86                 wpa_printf(MSG_INFO, "rfkill: WLAN unblocked");
87                 new_blocked = 0;
88         }
89
90         if (new_blocked != rfkill->blocked) {
91                 rfkill->blocked = new_blocked;
92                 if (new_blocked)
93                         rfkill->cfg->blocked_cb(rfkill->cfg->ctx);
94                 else
95                         rfkill->cfg->unblocked_cb(rfkill->cfg->ctx);
96         }
97 }
98
99
100 struct rfkill_data * rfkill_init(struct rfkill_config *cfg)
101 {
102         struct rfkill_data *rfkill;
103         struct rfkill_event event;
104         ssize_t len;
105
106         rfkill = os_zalloc(sizeof(*rfkill));
107         if (rfkill == NULL)
108                 return NULL;
109
110         rfkill->cfg = cfg;
111         rfkill->fd = open("/dev/rfkill", O_RDONLY);
112         if (rfkill->fd < 0) {
113                 wpa_printf(MSG_INFO, "rfkill: Cannot open RFKILL control "
114                            "device");
115                 goto fail;
116         }
117
118         if (fcntl(rfkill->fd, F_SETFL, O_NONBLOCK) < 0) {
119                 wpa_printf(MSG_ERROR, "rfkill: Cannot set non-blocking mode: "
120                            "%s", strerror(errno));
121                 goto fail2;
122         }
123
124         for (;;) {
125                 len = read(rfkill->fd, &event, sizeof(event));
126                 if (len < 0) {
127                         if (errno == EAGAIN)
128                                 break; /* No more entries */
129                         wpa_printf(MSG_ERROR, "rfkill: Event read failed: %s",
130                                    strerror(errno));
131                         break;
132                 }
133                 if (len != RFKILL_EVENT_SIZE_V1) {
134                         wpa_printf(MSG_DEBUG, "rfkill: Unexpected event size "
135                                    "%d (expected %d)",
136                                    (int) len, RFKILL_EVENT_SIZE_V1);
137                         continue;
138                 }
139                 wpa_printf(MSG_DEBUG, "rfkill: initial event: idx=%u type=%d "
140                            "op=%u soft=%u hard=%u",
141                            event.idx, event.type, event.op, event.soft,
142                            event.hard);
143                 if (event.op != RFKILL_OP_ADD ||
144                     event.type != RFKILL_TYPE_WLAN)
145                         continue;
146                 if (event.hard) {
147                         wpa_printf(MSG_INFO, "rfkill: WLAN hard blocked");
148                         rfkill->blocked = 1;
149                 } else if (event.soft) {
150                         wpa_printf(MSG_INFO, "rfkill: WLAN soft blocked");
151                         rfkill->blocked = 1;
152                 }
153         }
154
155         eloop_register_read_sock(rfkill->fd, rfkill_receive, rfkill, NULL);
156
157         return rfkill;
158
159 fail2:
160         close(rfkill->fd);
161 fail:
162         os_free(rfkill);
163         return NULL;
164 }
165
166
167 void rfkill_deinit(struct rfkill_data *rfkill)
168 {
169         if (rfkill == NULL)
170                 return;
171
172         if (rfkill->fd >= 0) {
173                 eloop_unregister_read_sock(rfkill->fd);
174                 close(rfkill->fd);
175         }
176
177         os_free(rfkill->cfg);
178         os_free(rfkill);
179 }
180
181
182 int rfkill_is_blocked(struct rfkill_data *rfkill)
183 {
184         if (rfkill == NULL)
185                 return 0;
186
187         return rfkill->blocked;
188 }