5e2e1146667aa00a6fb3c16992e55d7a65ca2440
[dragonfly.git] / usr.sbin / 802_11 / ndis_events / ndis_events.c
1 /*-
2  * Copyright (c) 2005
3  *      Bill Paul <wpaul@windriver.com>.  All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
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.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *      This product includes software developed by Bill Paul.
16  * 4. Neither the name of the author nor the names of any co-contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL Bill Paul OR THE VOICES IN HIS HEAD
24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
30  * THE POSSIBILITY OF SUCH DAMAGE.
31  *
32  * $FreeBSD: src/usr.sbin/wpa/ndis_events/ndis_events.c,v 1.8 2011/06/24 07:05:20 kevlo Exp $
33  */
34
35 /*
36  * This program simulates the behavior of the ndis_events utility
37  * supplied with wpa_supplicant for Windows. The original utility
38  * is designed to translate Windows WMI events. We don't have WMI,
39  * but we need to supply certain event info to wpa_supplicant in
40  * order to make WPA2 work correctly, so we fake up the interface.
41  */
42
43 #include <sys/types.h>
44 #include <sys/param.h>
45 #include <sys/socket.h>
46 #include <sys/ioctl.h>
47 #include <sys/errno.h>
48 #include <sys/sysctl.h>
49 #include <net/if.h>
50 #include <net/if_dl.h>
51 #include <net/if_var.h>
52
53 #include <netinet/in.h>
54 #include <arpa/inet.h>
55 #include <netdb.h>
56 #include <net/route.h>
57
58 #include <stdio.h>
59 #include <string.h>
60 #include <stdlib.h>
61 #include <unistd.h>
62 #include <err.h>
63 #include <syslog.h>
64 #include <stdarg.h>
65
66 static int verbose = 0;
67 static int debug = 0;
68 static int all_events = 0;
69
70 #define PROGNAME "ndis_events"
71
72 #define WPA_SUPPLICANT_PORT     9876
73 #define NDIS_INDICATION_LEN     2048
74
75 #define EVENT_CONNECT           0
76 #define EVENT_DISCONNECT        1
77 #define EVENT_MEDIA_SPECIFIC    2
78
79 #define NDIS_STATUS_MEDIA_CONNECT               0x4001000B
80 #define NDIS_STATUS_MEDIA_DISCONNECT            0x4001000C
81 #define NDIS_STATUS_MEDIA_SPECIFIC_INDICATION   0x40010012
82
83 struct ndis_evt {
84         uint32_t                ne_sts;
85         uint32_t                ne_len;
86 #ifdef notdef
87         char                    ne_buf[1];
88 #endif
89 };
90
91 static int find_ifname(int, char *);
92 static int announce_event(char *, int, struct sockaddr_in *);
93 static void usage(void);
94
95 static void
96 dbgmsg(const char *fmt, ...)
97 {
98         va_list                 ap;
99
100         va_start(ap, fmt);
101         if (debug)
102                 vwarnx(fmt, ap);
103         else
104                 vsyslog(LOG_ERR, fmt, ap);
105         va_end(ap);
106
107         return;
108 }
109
110 static int
111 find_ifname(int idx, char *name)
112 {
113         int                     mib[6];
114         size_t                  needed;
115         struct if_msghdr        *ifm;
116         struct sockaddr_dl      *sdl;
117         char                    *buf, *lim, *next;
118
119         needed = 0;
120         mib[0] = CTL_NET;
121         mib[1] = PF_ROUTE;
122         mib[2] = 0;             /* protocol */
123         mib[3] = 0;             /* wildcard address family */
124         mib[4] = NET_RT_IFLIST;
125         mib[5] = 0;             /* no flags */
126
127         if (sysctl (mib, 6, NULL, &needed, NULL, 0) < 0)
128                 return(EIO);
129
130         buf = malloc (needed);
131         if (buf == NULL)
132                 return(ENOMEM);
133
134         if (sysctl (mib, 6, buf, &needed, NULL, 0) < 0) {
135                 free(buf);
136                 return(EIO);
137         }
138
139         lim = buf + needed;
140
141         next = buf;
142         while (next < lim) {
143                 ifm = (struct if_msghdr *)next;
144                 if (ifm->ifm_type == RTM_IFINFO) {
145                         sdl = (struct sockaddr_dl *)(ifm + 1);
146                         if (ifm->ifm_index == idx) {
147                                 strncpy(name, sdl->sdl_data, sdl->sdl_nlen);
148                                 name[sdl->sdl_nlen] = '\0';
149                                 free (buf);
150                                 return (0);
151                         }
152                 }
153                 next += ifm->ifm_msglen;
154         }
155
156         free (buf);
157
158         return(ENOENT);
159 }
160
161 static int
162 announce_event(char *ifname, int sock, struct sockaddr_in *dst)
163 {
164         int                     s;
165         char                    indication[NDIS_INDICATION_LEN];
166         struct ifreq            ifr;
167         struct ndis_evt         *e;
168         char                    buf[512], *pos, *end;
169         int                     len, type, _type;
170
171         s = socket(PF_INET, SOCK_DGRAM, 0);
172
173         if (s < 0) {
174                 dbgmsg("socket creation failed");
175                 return(EINVAL);
176         }
177
178         bzero((char *)&ifr, sizeof(ifr));
179         e = (struct ndis_evt *)indication;
180         e->ne_len = NDIS_INDICATION_LEN - sizeof(struct ndis_evt);
181
182         strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
183         ifr.ifr_data = indication;
184
185         if (ioctl(s, SIOCGPRIVATE_0, &ifr) < 0) {
186                 close(s);
187                 if (verbose) {
188                         if (errno == ENOENT)
189                                 dbgmsg("drained all events from %s",
190                                     ifname);
191                         else
192                                 dbgmsg("failed to read event info from %s: %d",
193                                     ifname, errno);
194                 }
195                 return(ENOENT);
196         }
197
198         if (e->ne_sts == NDIS_STATUS_MEDIA_CONNECT) {
199                 type = EVENT_CONNECT;
200                 if (verbose)
201                         dbgmsg("Received a connect event for %s", ifname);
202                 if (!all_events) {
203                         close(s);
204                         return(0);
205                 }
206         } else if (e->ne_sts == NDIS_STATUS_MEDIA_DISCONNECT) {
207                 type = EVENT_DISCONNECT;
208                 if (verbose)
209                         dbgmsg("Received a disconnect event for %s", ifname);
210                 if (!all_events) {
211                         close(s);
212                         return(0);
213                 }
214         } else if (e->ne_sts == NDIS_STATUS_MEDIA_SPECIFIC_INDICATION) {
215                 type = EVENT_MEDIA_SPECIFIC;
216                 if (verbose)
217                         dbgmsg("Received a media-specific event for %s",
218                             ifname);
219         } else {
220                 dbgmsg("unknown event %u\n", e->ne_sts);
221                 return(EINVAL);
222         }
223
224         end = buf + sizeof(buf);
225         _type = (int) type;
226         memcpy(buf, &_type, sizeof(_type));
227         pos = buf + sizeof(_type);
228
229         len = snprintf(pos + 1, end - pos - 1, "%s", ifname);
230         if (len < 0) {
231                 close(s);
232                 return(ENOSPC);
233         }
234         if (len > 255)
235                 len = 255;
236         *pos = (unsigned char) len;
237         pos += 1 + len;
238         if (e->ne_len) {
239                 if (e->ne_len > 255 || 1 + e->ne_len > (u_int)(end - pos)) {
240                         dbgmsg("Not enough room for send_event data (%d)\n",
241                             e->ne_len);
242                         close(s);
243                         return(ENOSPC);
244                 }
245                 *pos++ = (unsigned char) e->ne_len;
246                 memcpy(pos, (indication) + sizeof(struct ndis_evt), e->ne_len);
247                 pos += e->ne_len;
248         }
249
250         len = sendto(sock, buf, pos - buf, 0, (struct sockaddr *) dst,
251             sizeof(struct sockaddr_in));
252
253         close(s);
254         return(0);
255 }
256
257 static void
258 usage(void)
259 {
260         fprintf(stderr, "Usage: ndis_events [-a] [-d] [-v]\n");
261         exit(1);
262 }
263
264 int
265 main(int argc, char *argv[])
266 {
267         int                     s, r, n;
268         struct sockaddr_in      sin;
269         char                    msg[NDIS_INDICATION_LEN];
270         struct rt_msghdr        *rtm;
271         struct if_msghdr        *ifm;
272         char                    ifname[IFNAMSIZ];
273         int                     ch;
274
275         while ((ch = getopt(argc, argv, "dva")) != -1) {
276                 switch(ch) {
277                 case 'd':
278                         debug++;
279                         break;
280                 case 'v':
281                         verbose++;
282                         break;
283                 case 'a':
284                         all_events++;
285                         break;
286                 default:
287                         usage();
288                         break;
289                 }
290         }
291
292         if (!debug && daemon(0, 0))
293                 err(1, "failed to daemonize ourselves");
294
295         if (!debug)
296                 openlog(PROGNAME, LOG_PID | LOG_CONS, LOG_DAEMON);
297
298         bzero((char *)&sin, sizeof(sin));
299
300         /* Create a datagram  socket. */
301
302         s = socket(PF_INET, SOCK_DGRAM, 0);
303         if (s < 0) {
304                 dbgmsg("socket creation failed");
305                 exit(1);
306         }
307
308         sin.sin_family = AF_INET;
309         sin.sin_addr.s_addr = inet_addr("127.0.0.1");
310         sin.sin_port = htons(WPA_SUPPLICANT_PORT);
311
312         /* Create a routing socket. */
313
314         r = socket (PF_ROUTE, SOCK_RAW, 0);
315         if (r < 0) {
316                 dbgmsg("routing socket creation failed");
317                 exit(1);
318         }
319
320         /* Now sit and spin, waiting for events. */
321
322         if (verbose)
323                 dbgmsg("Listening for events");
324
325         while (1) {
326                 n = read(r, msg, NDIS_INDICATION_LEN);
327                 if (n < 0) {
328                         dbgmsg("read failed");
329                         exit(1);
330                 }
331                 rtm = (struct rt_msghdr *)msg;
332                 if (rtm->rtm_type != RTM_IFINFO)
333                         continue;
334                 ifm = (struct if_msghdr *)msg;
335                 if (find_ifname(ifm->ifm_index, ifname))
336                         continue;
337                 if (strstr(ifname, "ndis")) {
338                         while(announce_event(ifname, s, &sin) == 0)
339                                 ;
340                 } else {
341                         if (verbose)
342                                 dbgmsg("Skipping ifinfo message from %s",
343                                     ifname);
344                 }
345         }
346
347         /* NOTREACHED */
348         exit(0);
349 }