Skip to content
This repository

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Newer
Older
100644 516 lines (438 sloc) 11.769 kb
845e0124 » The Android Open Source Project
2009-03-03 auto import from //depot/cupcake/@135843
1 /*
2 * wpa_supplicant/hostapd control interface library
3 * Copyright (c) 2004-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
17 #ifdef CONFIG_CTRL_IFACE
18
19 #ifdef CONFIG_CTRL_IFACE_UNIX
20 #include <sys/un.h>
21 #endif /* CONFIG_CTRL_IFACE_UNIX */
22 #ifdef ANDROID
23 #include <dirent.h>
24 #include <linux/limits.h>
25 #include <cutils/sockets.h>
26 #include <cutils/memory.h>
27 #include "private/android_filesystem_config.h"
28 #endif
29
30 #include "wpa_ctrl.h"
31 #include "common.h"
32
33
34 #if defined(CONFIG_CTRL_IFACE_UNIX) || defined(CONFIG_CTRL_IFACE_UDP)
35 #define CTRL_IFACE_SOCKET
36 #ifdef ANDROID
37 static const char *local_socket_dir = "/data/misc/wifi/sockets";
38 static const char *local_socket_prefix = "wpa_ctrl_";
39 #endif /* ANDROID */
40 #endif /* CONFIG_CTRL_IFACE_UNIX || CONFIG_CTRL_IFACE_UDP */
41
42 /**
43 * struct wpa_ctrl - Internal structure for control interface library
44 *
45 * This structure is used by the wpa_supplicant/hostapd control interface
46 * library to store internal data. Programs using the library should not touch
47 * this data directly. They can only use the pointer to the data structure as
48 * an identifier for the control interface connection and use this as one of
49 * the arguments for most of the control interface library functions.
50 */
51 struct wpa_ctrl {
52 #ifdef CONFIG_CTRL_IFACE_UDP
53 int s;
54 struct sockaddr_in local;
55 struct sockaddr_in dest;
56 char *cookie;
57 #endif /* CONFIG_CTRL_IFACE_UDP */
58 #ifdef CONFIG_CTRL_IFACE_UNIX
59 int s;
60 struct sockaddr_un local;
61 struct sockaddr_un dest;
62 #endif /* CONFIG_CTRL_IFACE_UNIX */
63 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
64 HANDLE pipe;
65 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
66 };
67
68
69 #ifdef CONFIG_CTRL_IFACE_UNIX
70
71 struct wpa_ctrl * wpa_ctrl_open(const char *ctrl_path)
72 {
73 struct wpa_ctrl *ctrl;
74 static int counter = 0;
75
76 ctrl = os_malloc(sizeof(*ctrl));
77 if (ctrl == NULL)
78 return NULL;
79 os_memset(ctrl, 0, sizeof(*ctrl));
80
81 ctrl->s = socket(PF_UNIX, SOCK_DGRAM, 0);
82 if (ctrl->s < 0) {
83 os_free(ctrl);
84 return NULL;
85 }
86
87 ctrl->local.sun_family = AF_UNIX;
88 os_snprintf(ctrl->local.sun_path, sizeof(ctrl->local.sun_path),
89 #ifdef ANDROID
90 "%s/%s%d-%d", local_socket_dir, local_socket_prefix,
91 getpid(), counter++);
92 #else /* ANDROID */
93 "/tmp/wpa_ctrl_%d-%d", getpid(), counter++);
94 #endif
95 if (bind(ctrl->s, (struct sockaddr *) &ctrl->local,
96 sizeof(ctrl->local)) < 0) {
97 close(ctrl->s);
98 os_free(ctrl);
99 return NULL;
100 }
101
102 #ifdef ANDROID
103 chmod(ctrl->local.sun_path, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
104 chown(ctrl->local.sun_path, AID_SYSTEM, AID_WIFI);
105 /*
106 * If the ctrl_path isn't an absolute pathname, assume that
107 * it's the name of a socket in the Android reserved namespace.
108 * Otherwise, it's a normal UNIX domain socket appearing in the
109 * filesystem.
110 */
111 if (ctrl_path != NULL && *ctrl_path != '/') {
112 os_snprintf(ctrl->dest.sun_path, sizeof(ctrl->dest.sun_path), "wpa_%s",
113 ctrl_path);
114 if (socket_local_client_connect(ctrl->s,
115 ctrl->dest.sun_path,
116 ANDROID_SOCKET_NAMESPACE_RESERVED,
117 SOCK_DGRAM) < 0) {
118 close(ctrl->s);
119 unlink(ctrl->local.sun_path);
120 os_free(ctrl);
121 return NULL;
122 }
123 return ctrl;
124 }
125 #endif
126 ctrl->dest.sun_family = AF_UNIX;
127 os_snprintf(ctrl->dest.sun_path, sizeof(ctrl->dest.sun_path), "%s",
128 ctrl_path);
129 if (connect(ctrl->s, (struct sockaddr *) &ctrl->dest,
130 sizeof(ctrl->dest)) < 0) {
131 close(ctrl->s);
132 unlink(ctrl->local.sun_path);
133 os_free(ctrl);
134 return NULL;
135 }
136
137 return ctrl;
138 }
139
140
141 void wpa_ctrl_close(struct wpa_ctrl *ctrl)
142 {
be5cce4a » Dmitry Shmidt
2009-11-11 Check if interface is valid in wpa_ctrl_close()
143 if (ctrl == NULL)
144 return;
845e0124 » The Android Open Source Project
2009-03-03 auto import from //depot/cupcake/@135843
145 unlink(ctrl->local.sun_path);
be5cce4a » Dmitry Shmidt
2009-11-11 Check if interface is valid in wpa_ctrl_close()
146 if (ctrl->s >= 0)
147 close(ctrl->s);
845e0124 » The Android Open Source Project
2009-03-03 auto import from //depot/cupcake/@135843
148 os_free(ctrl);
149 }
150
151 #ifdef ANDROID
152 /**
153 * wpa_ctrl_cleanup() - Delete any local UNIX domain socket files that
154 * may be left over from clients that were previously connected to
155 * wpa_supplicant. This keeps these files from being orphaned in the
156 * event of crashes that prevented them from being removed as part
157 * of the normal orderly shutdown.
158 */
c2f31631 » Dmitry Shmidt
2009-05-14 Fix compilation warning
159 void wpa_ctrl_cleanup(void)
845e0124 » The Android Open Source Project
2009-03-03 auto import from //depot/cupcake/@135843
160 {
161 DIR *dir;
162 struct dirent entry;
163 struct dirent *result;
164 size_t dirnamelen;
165 int prefixlen = strlen(local_socket_prefix);
166 size_t maxcopy;
167 char pathname[PATH_MAX];
168 char *namep;
169
170 if ((dir = opendir(local_socket_dir)) == NULL)
171 return;
172
173 dirnamelen = (size_t)snprintf(pathname, sizeof(pathname), "%s/", local_socket_dir);
174 if (dirnamelen >= sizeof(pathname)) {
175 closedir(dir);
176 return;
177 }
178 namep = pathname + dirnamelen;
179 maxcopy = PATH_MAX-dirnamelen;
180 while (readdir_r(dir, &entry, &result) == 0 && result != NULL) {
181 if (strncmp(entry.d_name, local_socket_prefix, prefixlen) == 0) {
182 if (strlcpy(namep, entry.d_name, maxcopy) < maxcopy) {
183 unlink(pathname);
184 }
185 }
186 }
187 closedir(dir);
188 }
189 #endif /* ANDROID */
190
191 #else /* CONFIG_CTRL_IFACE_UNIX */
192 #ifdef ANDROID
d81a4e85 » Dmitry Shmidt
2010-02-01 Remove compilation warning
193 void wpa_ctrl_cleanup(void)
845e0124 » The Android Open Source Project
2009-03-03 auto import from //depot/cupcake/@135843
194 {
195 }
196 #endif /* ANDROID */
197 #endif /* CONFIG_CTRL_IFACE_UNIX */
198
199 #ifdef CONFIG_CTRL_IFACE_UDP
200
201 struct wpa_ctrl * wpa_ctrl_open(const char *ctrl_path)
202 {
203 struct wpa_ctrl *ctrl;
204 char buf[128];
205 size_t len;
206
207 ctrl = os_malloc(sizeof(*ctrl));
208 if (ctrl == NULL)
209 return NULL;
210 os_memset(ctrl, 0, sizeof(*ctrl));
211
212 ctrl->s = socket(PF_INET, SOCK_DGRAM, 0);
213 if (ctrl->s < 0) {
214 perror("socket");
215 os_free(ctrl);
216 return NULL;
217 }
218
219 ctrl->local.sin_family = AF_INET;
220 ctrl->local.sin_addr.s_addr = htonl((127 << 24) | 1);
221 if (bind(ctrl->s, (struct sockaddr *) &ctrl->local,
222 sizeof(ctrl->local)) < 0) {
223 close(ctrl->s);
224 os_free(ctrl);
225 return NULL;
226 }
227
228 ctrl->dest.sin_family = AF_INET;
229 ctrl->dest.sin_addr.s_addr = htonl((127 << 24) | 1);
230 ctrl->dest.sin_port = htons(WPA_CTRL_IFACE_PORT);
231 if (connect(ctrl->s, (struct sockaddr *) &ctrl->dest,
232 sizeof(ctrl->dest)) < 0) {
233 perror("connect");
234 close(ctrl->s);
235 os_free(ctrl);
236 return NULL;
237 }
238
239 len = sizeof(buf) - 1;
240 if (wpa_ctrl_request(ctrl, "GET_COOKIE", 10, buf, &len, NULL) == 0) {
241 buf[len] = '\0';
242 ctrl->cookie = strdup(buf);
243 }
244
245 return ctrl;
246 }
247
248
249 void wpa_ctrl_close(struct wpa_ctrl *ctrl)
250 {
251 close(ctrl->s);
252 os_free(ctrl->cookie);
253 os_free(ctrl);
254 }
255
256 #endif /* CONFIG_CTRL_IFACE_UDP */
257
258
259 #ifdef CTRL_IFACE_SOCKET
260 int wpa_ctrl_request(struct wpa_ctrl *ctrl, const char *cmd, size_t cmd_len,
261 char *reply, size_t *reply_len,
262 void (*msg_cb)(char *msg, size_t len))
263 {
264 struct timeval tv;
265 int res;
266 fd_set rfds;
267 const char *_cmd;
268 char *cmd_buf = NULL;
269 size_t _cmd_len;
270
271 #ifdef CONFIG_CTRL_IFACE_UDP
272 if (ctrl->cookie) {
273 char *pos;
274 _cmd_len = strlen(ctrl->cookie) + 1 + cmd_len;
275 cmd_buf = os_malloc(_cmd_len );
276 if (cmd_buf == NULL)
277 return -1;
278 _cmd = cmd_buf;
279 pos = cmd_buf;
280 strcpy(pos, ctrl->cookie);
281 pos += strlen(ctrl->cookie);
282 *pos++ = ' ';
283 memcpy(pos, cmd, cmd_len);
284 } else
285 #endif /* CONFIG_CTRL_IFACE_UDP */
286 {
287 _cmd = cmd;
288 _cmd_len = cmd_len;
289 }
290
291 if (send(ctrl->s, _cmd, _cmd_len, 0) < 0) {
292 os_free(cmd_buf);
293 return -1;
294 }
295 os_free(cmd_buf);
296
297 for (;;) {
d5a0f104 » Dmitry Shmidt
2009-10-19 Increase timeout for responce to 10 sec (http://b/issue?id=2182998)
298 #ifdef ANDROID
299 tv.tv_sec = 10;
300 #else
845e0124 » The Android Open Source Project
2009-03-03 auto import from //depot/cupcake/@135843
301 tv.tv_sec = 2;
d5a0f104 » Dmitry Shmidt
2009-10-19 Increase timeout for responce to 10 sec (http://b/issue?id=2182998)
302 #endif
845e0124 » The Android Open Source Project
2009-03-03 auto import from //depot/cupcake/@135843
303 tv.tv_usec = 0;
304 FD_ZERO(&rfds);
305 FD_SET(ctrl->s, &rfds);
306 res = select(ctrl->s + 1, &rfds, NULL, NULL, &tv);
307 if (FD_ISSET(ctrl->s, &rfds)) {
308 res = recv(ctrl->s, reply, *reply_len, 0);
309 if (res < 0)
310 return res;
311 if (res > 0 && reply[0] == '<') {
312 /* This is an unsolicited message from
313 * wpa_supplicant, not the reply to the
314 * request. Use msg_cb to report this to the
315 * caller. */
316 if (msg_cb) {
317 /* Make sure the message is nul
318 * terminated. */
319 if ((size_t) res == *reply_len)
320 res = (*reply_len) - 1;
321 reply[res] = '\0';
322 msg_cb(reply, res);
323 }
324 continue;
325 }
326 *reply_len = res;
327 break;
328 } else {
329 return -2;
330 }
331 }
332 return 0;
333 }
334 #endif /* CTRL_IFACE_SOCKET */
335
336
337 static int wpa_ctrl_attach_helper(struct wpa_ctrl *ctrl, int attach)
338 {
339 char buf[10];
340 int ret;
341 size_t len = 10;
342
343 ret = wpa_ctrl_request(ctrl, attach ? "ATTACH" : "DETACH", 6,
344 buf, &len, NULL);
345 if (ret < 0)
346 return ret;
347 if (len == 3 && os_memcmp(buf, "OK\n", 3) == 0)
348 return 0;
349 return -1;
350 }
351
352
353 int wpa_ctrl_attach(struct wpa_ctrl *ctrl)
354 {
355 return wpa_ctrl_attach_helper(ctrl, 1);
356 }
357
358
359 int wpa_ctrl_detach(struct wpa_ctrl *ctrl)
360 {
361 return wpa_ctrl_attach_helper(ctrl, 0);
362 }
363
364
365 #ifdef CTRL_IFACE_SOCKET
366
367 int wpa_ctrl_recv(struct wpa_ctrl *ctrl, char *reply, size_t *reply_len)
368 {
369 int res;
370
371 res = recv(ctrl->s, reply, *reply_len, 0);
372 if (res < 0)
373 return res;
374 *reply_len = res;
375 return 0;
376 }
377
378
379 int wpa_ctrl_pending(struct wpa_ctrl *ctrl)
380 {
381 struct timeval tv;
382 fd_set rfds;
383 tv.tv_sec = 0;
384 tv.tv_usec = 0;
385 FD_ZERO(&rfds);
386 FD_SET(ctrl->s, &rfds);
387 select(ctrl->s + 1, &rfds, NULL, NULL, &tv);
388 return FD_ISSET(ctrl->s, &rfds);
389 }
390
391
392 int wpa_ctrl_get_fd(struct wpa_ctrl *ctrl)
393 {
394 return ctrl->s;
395 }
396
397 #endif /* CTRL_IFACE_SOCKET */
398
399
400 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
401
402 #ifndef WPA_SUPPLICANT_NAMED_PIPE
403 #define WPA_SUPPLICANT_NAMED_PIPE "WpaSupplicant"
404 #endif
405 #define NAMED_PIPE_PREFIX TEXT("\\\\.\\pipe\\") TEXT(WPA_SUPPLICANT_NAMED_PIPE)
406
407 struct wpa_ctrl * wpa_ctrl_open(const char *ctrl_path)
408 {
409 struct wpa_ctrl *ctrl;
410 DWORD mode;
411 TCHAR name[256];
412 int i;
413
414 ctrl = os_malloc(sizeof(*ctrl));
415 if (ctrl == NULL)
416 return NULL;
417 os_memset(ctrl, 0, sizeof(*ctrl));
418
419 #ifdef UNICODE
420 if (ctrl_path == NULL)
421 _snwprintf(name, 256, NAMED_PIPE_PREFIX);
422 else
423 _snwprintf(name, 256, NAMED_PIPE_PREFIX TEXT("-%S"),
424 ctrl_path);
425 #else /* UNICODE */
426 if (ctrl_path == NULL)
427 os_snprintf(name, 256, NAMED_PIPE_PREFIX);
428 else
429 os_snprintf(name, 256, NAMED_PIPE_PREFIX "-%s",
430 ctrl_path);
431 #endif /* UNICODE */
432
433 for (i = 0; i < 10; i++) {
434 ctrl->pipe = CreateFile(name, GENERIC_READ | GENERIC_WRITE, 0,
435 NULL, OPEN_EXISTING, 0, NULL);
436 /*
437 * Current named pipe server side in wpa_supplicant is
438 * re-opening the pipe for new clients only after the previous
439 * one is taken into use. This leaves a small window for race
440 * conditions when two connections are being opened at almost
441 * the same time. Retry if that was the case.
442 */
443 if (ctrl->pipe != INVALID_HANDLE_VALUE ||
444 GetLastError() != ERROR_PIPE_BUSY)
445 break;
446 WaitNamedPipe(name, 1000);
447 }
448 if (ctrl->pipe == INVALID_HANDLE_VALUE) {
449 os_free(ctrl);
450 return NULL;
451 }
452
453 mode = PIPE_READMODE_MESSAGE;
454 if (!SetNamedPipeHandleState(ctrl->pipe, &mode, NULL, NULL)) {
455 CloseHandle(ctrl->pipe);
456 os_free(ctrl);
457 return NULL;
458 }
459
460 return ctrl;
461 }
462
463
464 void wpa_ctrl_close(struct wpa_ctrl *ctrl)
465 {
466 CloseHandle(ctrl->pipe);
467 os_free(ctrl);
468 }
469
470
471 int wpa_ctrl_request(struct wpa_ctrl *ctrl, const char *cmd, size_t cmd_len,
472 char *reply, size_t *reply_len,
473 void (*msg_cb)(char *msg, size_t len))
474 {
475 DWORD written;
476 DWORD readlen = *reply_len;
477
478 if (!WriteFile(ctrl->pipe, cmd, cmd_len, &written, NULL))
479 return -1;
480
481 if (!ReadFile(ctrl->pipe, reply, *reply_len, &readlen, NULL))
482 return -1;
483 *reply_len = readlen;
484
485 return 0;
486 }
487
488
489 int wpa_ctrl_recv(struct wpa_ctrl *ctrl, char *reply, size_t *reply_len)
490 {
491 DWORD len = *reply_len;
492 if (!ReadFile(ctrl->pipe, reply, *reply_len, &len, NULL))
493 return -1;
494 *reply_len = len;
495 return 0;
496 }
497
498
499 int wpa_ctrl_pending(struct wpa_ctrl *ctrl)
500 {
501 DWORD left;
502
503 if (!PeekNamedPipe(ctrl->pipe, NULL, 0, NULL, &left, NULL))
504 return -1;
505 return left ? 1 : 0;
506 }
507
508
509 int wpa_ctrl_get_fd(struct wpa_ctrl *ctrl)
510 {
68f59441 » San Mehat
2009-05-06 wpa_supplicant: impliment wpa_ctrl_get_fd()
511 return ctrl->pipe;
845e0124 » The Android Open Source Project
2009-03-03 auto import from //depot/cupcake/@135843
512 }
513
514 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
515
516 #endif /* CONFIG_CTRL_IFACE */
Something went wrong with that request. Please try again.