]> git.ipfire.org Git - thirdparty/hostap.git/blame - wpa_supplicant/ctrl_iface_named_pipe.c
projects / thirdparty / hostap.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Clear current_bss pointer on disassociation/deauthentication
[thirdparty/hostap.git] / wpa_supplicant / ctrl_iface_named_pipe.c
CommitLineData
6fc6879b
JM		 1/*
2 * WPA Supplicant / Windows Named Pipe -based control interface
3 * Copyright (c) 2004-2006, 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#include "common.h"
18#include "eloop.h"
19#include "config.h"
20#include "eapol_supp/eapol_supp_sm.h"
21#include "wpa_supplicant_i.h"
22#include "ctrl_iface.h"
90973fb2 23#include "common/wpa_ctrl.h"
6fc6879b
JM		 24
25#ifdef __MINGW32_VERSION
26/* mingw-w32api v3.1 does not yet include sddl.h, so define needed parts here
27 */
28#define SDDL_REVISION_1 1
29BOOL WINAPI ConvertStringSecurityDescriptorToSecurityDescriptorA(
30 LPCSTR, DWORD, PSECURITY_DESCRIPTOR *, PULONG);
31BOOL WINAPI ConvertStringSecurityDescriptorToSecurityDescriptorW(
32 LPCWSTR, DWORD, PSECURITY_DESCRIPTOR *, PULONG);
33#ifdef UNICODE
34#define ConvertStringSecurityDescriptorToSecurityDescriptor \
35ConvertStringSecurityDescriptorToSecurityDescriptorW
36#else
37#define ConvertStringSecurityDescriptorToSecurityDescriptor \
38ConvertStringSecurityDescriptorToSecurityDescriptorA
39#endif
40#else /* __MINGW32_VERSION */
41#ifndef _WIN32_WINNT
42#define _WIN32_WINNT 0x0500
43#endif
44#include <sddl.h>
45#endif /* __MINGW32_VERSION */
46
47#ifndef WPA_SUPPLICANT_NAMED_PIPE
48#define WPA_SUPPLICANT_NAMED_PIPE "WpaSupplicant"
49#endif
50#define NAMED_PIPE_PREFIX TEXT("\\\\.\\pipe\\") TEXT(WPA_SUPPLICANT_NAMED_PIPE)
51
52/* Per-interface ctrl_iface */
53
54#define REQUEST_BUFSIZE 256
55#define REPLY_BUFSIZE 4096
56
57struct ctrl_iface_priv;
58
59/**
60 * struct wpa_ctrl_dst - Internal data structure of control interface clients
61 *
62 * This structure is used to store information about registered control
63 * interface monitors into struct wpa_supplicant. This data is private to
64 * ctrl_iface_named_pipe.c and should not be touched directly from other files.
65 */
66struct wpa_ctrl_dst {
67 /* Note: OVERLAPPED must be the first member of struct wpa_ctrl_dst */
68 OVERLAPPED overlap;
69 struct wpa_ctrl_dst *next, *prev;
70 struct ctrl_iface_priv *priv;
71 HANDLE pipe;
72 int attached;
73 int debug_level;
74 int errors;
75 char req_buf[REQUEST_BUFSIZE];
76 char *rsp_buf;
77 int used;
78};
79
80
81struct ctrl_iface_priv {
82 struct wpa_supplicant *wpa_s;
83 struct wpa_ctrl_dst *ctrl_dst;
84 SECURITY_ATTRIBUTES attr;
85 int sec_attr_set;
86};
87
88
89static void wpa_supplicant_ctrl_iface_send(struct ctrl_iface_priv *priv,
90 int level, const char *buf,
91 size_t len);
92
93static void ctrl_close_pipe(struct wpa_ctrl_dst *dst);
94static void wpa_supplicant_ctrl_iface_receive(void *, void *);
95static VOID WINAPI ctrl_iface_read_completed(DWORD err, DWORD bytes,
96 LPOVERLAPPED overlap);
97
98struct wpa_global_dst;
99static void global_close_pipe(struct wpa_global_dst *dst);
100static void wpa_supplicant_global_iface_receive(void *eloop_data,
101 void *user_ctx);
102static VOID WINAPI global_iface_read_completed(DWORD err, DWORD bytes,
103 LPOVERLAPPED overlap);
104
105
106static int ctrl_broken_pipe(HANDLE pipe, int used)
107{
108 DWORD err;
109
110 if (PeekNamedPipe(pipe, NULL, 0, NULL, NULL, NULL))
111 return 0;
112
113 err = GetLastError();
114 if (err == ERROR_BROKEN_PIPE || (err == ERROR_BAD_PIPE && used))
115 return 1;
116 return 0;
117}
118
119
120static void ctrl_flush_broken_pipes(struct ctrl_iface_priv *priv)
121{
122 struct wpa_ctrl_dst *dst, *next;
123
124 dst = priv->ctrl_dst;
125
126 while (dst) {
127 next = dst->next;
128 if (ctrl_broken_pipe(dst->pipe, dst->used)) {
129 wpa_printf(MSG_DEBUG, "CTRL: closing broken pipe %p",
130 dst);
131 ctrl_close_pipe(dst);
132 }
133 dst = next;
134 }
135}
136
137
138static int ctrl_open_pipe(struct ctrl_iface_priv *priv)
139{
140 struct wpa_ctrl_dst *dst;
141 DWORD err;
142 TCHAR name[256];
143
144 dst = os_zalloc(sizeof(*dst));
145 if (dst == NULL)
146 return -1;
147 wpa_printf(MSG_DEBUG, "CTRL: Open pipe %p", dst);
148
149 dst->priv = priv;
150 dst->debug_level = MSG_INFO;
151 dst->pipe = INVALID_HANDLE_VALUE;
152
153 dst->overlap.hEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
154 if (dst->overlap.hEvent == NULL) {
155 wpa_printf(MSG_ERROR, "CTRL: CreateEvent failed: %d",
156 (int) GetLastError());
157 goto fail;
158 }
159
160 eloop_register_event(dst->overlap.hEvent,
161 sizeof(dst->overlap.hEvent),
162 wpa_supplicant_ctrl_iface_receive, dst, NULL);
163
164#ifdef UNICODE
165 _snwprintf(name, 256, NAMED_PIPE_PREFIX TEXT("-%S"),
166 priv->wpa_s->ifname);
167#else /* UNICODE */
168 os_snprintf(name, 256, NAMED_PIPE_PREFIX "-%s",
169 priv->wpa_s->ifname);
170#endif /* UNICODE */
171
172 /* TODO: add support for configuring access list for the pipe */
173 dst->pipe = CreateNamedPipe(name,
174 PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
175 PIPE_TYPE_MESSAGE |
176 PIPE_READMODE_MESSAGE |
177 PIPE_WAIT,
178 15, REPLY_BUFSIZE, REQUEST_BUFSIZE,
179 1000,
180 priv->sec_attr_set ? &priv->attr : NULL);
181 if (dst->pipe == INVALID_HANDLE_VALUE) {
182 wpa_printf(MSG_ERROR, "CTRL: CreateNamedPipe failed: %d",
183 (int) GetLastError());
184 goto fail;
185 }
186
187 if (ConnectNamedPipe(dst->pipe, &dst->overlap)) {
188 wpa_printf(MSG_ERROR, "CTRL: ConnectNamedPipe failed: %d",
189 (int) GetLastError());
190 CloseHandle(dst->pipe);
191 os_free(dst);
192 return -1;
193 }
194
195 err = GetLastError();
196 switch (err) {
197 case ERROR_IO_PENDING:
198 wpa_printf(MSG_DEBUG, "CTRL: ConnectNamedPipe: connection in "
199 "progress");
200 break;
201 case ERROR_PIPE_CONNECTED:
202 wpa_printf(MSG_DEBUG, "CTRL: ConnectNamedPipe: already "
203 "connected");
204 if (SetEvent(dst->overlap.hEvent))
205 break;
206 /* fall through */
207 default:
208 wpa_printf(MSG_DEBUG, "CTRL: ConnectNamedPipe error: %d",
209 (int) err);
210 CloseHandle(dst->pipe);
211 os_free(dst);
212 return -1;
213 }
214
215 dst->next = priv->ctrl_dst;
216 if (dst->next)
217 dst->next->prev = dst;
218 priv->ctrl_dst = dst;
219
220 return 0;
221
222fail:
223 ctrl_close_pipe(dst);
224 return -1;
225}
226
227
228static void ctrl_close_pipe(struct wpa_ctrl_dst *dst)
229{
230 wpa_printf(MSG_DEBUG, "CTRL: close pipe %p", dst);
231
232 if (dst->overlap.hEvent) {
233 eloop_unregister_event(dst->overlap.hEvent,
234 sizeof(dst->overlap.hEvent));
235 CloseHandle(dst->overlap.hEvent);
236 }
237
238 if (dst->pipe != INVALID_HANDLE_VALUE) {
239 /*
240 * Could use FlushFileBuffers() here to guarantee that all data
241 * gets delivered to the client, but that can block, so let's
242 * not do this for now.
243 * FlushFileBuffers(dst->pipe);
244 */
245 CloseHandle(dst->pipe);
246 }
247
248 if (dst->prev)
249 dst->prev->next = dst->next;
250 else
251 dst->priv->ctrl_dst = dst->next;
252 if (dst->next)
253 dst->next->prev = dst->prev;
254
255 os_free(dst->rsp_buf);
256 os_free(dst);
257}
258
259
260static VOID WINAPI ctrl_iface_write_completed(DWORD err, DWORD bytes,
261 LPOVERLAPPED overlap)
262{
263 struct wpa_ctrl_dst *dst = (struct wpa_ctrl_dst *) overlap;
264 wpa_printf(MSG_DEBUG, "CTRL: Overlapped write completed: dst=%p "
265 "err=%d bytes=%d", dst, (int) err, (int) bytes);
266 if (err) {
267 ctrl_close_pipe(dst);
268 return;
269 }
270
271 os_free(dst->rsp_buf);
272 dst->rsp_buf = NULL;
273
274 if (!ReadFileEx(dst->pipe, dst->req_buf, sizeof(dst->req_buf),
275 &dst->overlap, ctrl_iface_read_completed)) {
276 wpa_printf(MSG_DEBUG, "CTRL: ReadFileEx failed: %d",
277 (int) GetLastError());
278 ctrl_close_pipe(dst);
279 return;
280 }
281 wpa_printf(MSG_DEBUG, "CTRL: Overlapped read started for %p", dst);
282}
283
284
285static void wpa_supplicant_ctrl_iface_rx(struct wpa_ctrl_dst *dst, size_t len)
286{
287 struct wpa_supplicant *wpa_s = dst->priv->wpa_s;
288 char *reply = NULL, *send_buf;
289 size_t reply_len = 0, send_len;
290 int new_attached = 0;
291 char *buf = dst->req_buf;
292
293 dst->used = 1;
294 if (len >= REQUEST_BUFSIZE)
295 len = REQUEST_BUFSIZE - 1;
296 buf[len] = '\0';
297
298 if (os_strcmp(buf, "ATTACH") == 0) {
299 dst->attached = 1;
300 wpa_printf(MSG_DEBUG, "CTRL_IFACE monitor attached");
301 new_attached = 1;
302 reply_len = 2;
303 } else if (os_strcmp(buf, "DETACH") == 0) {
304 dst->attached = 0;
305 wpa_printf(MSG_DEBUG, "CTRL_IFACE monitor detached");
306 reply_len = 2;
307 } else if (os_strncmp(buf, "LEVEL ", 6) == 0) {
308 wpa_printf(MSG_DEBUG, "CTRL_IFACE LEVEL %s", buf + 6);
309 dst->debug_level = atoi(buf + 6);
310 reply_len = 2;
311 } else {
312 reply = wpa_supplicant_ctrl_iface_process(wpa_s, buf,
313 &reply_len);
314 }
315
316 if (reply) {
317 send_buf = reply;
318 send_len = reply_len;
319 } else if (reply_len == 2) {
320 send_buf = "OK\n";
321 send_len = 3;
322 } else {
323 send_buf = "FAIL\n";
324 send_len = 5;
325 }
326
327 os_free(dst->rsp_buf);
328 dst->rsp_buf = os_malloc(send_len);
329 if (dst->rsp_buf == NULL) {
330 ctrl_close_pipe(dst);
331 os_free(reply);
332 return;
333 }
334 os_memcpy(dst->rsp_buf, send_buf, send_len);
335 os_free(reply);
336
337 if (!WriteFileEx(dst->pipe, dst->rsp_buf, send_len, &dst->overlap,
338 ctrl_iface_write_completed)) {
339 wpa_printf(MSG_DEBUG, "CTRL: WriteFileEx failed: %d",
340 (int) GetLastError());
341 ctrl_close_pipe(dst);
342 } else {
343 wpa_printf(MSG_DEBUG, "CTRL: Overlapped write started for %p",
344 dst);
345 }
346
347 if (new_attached)
348 eapol_sm_notify_ctrl_attached(wpa_s->eapol);
349}
350
351
352static VOID WINAPI ctrl_iface_read_completed(DWORD err, DWORD bytes,
353 LPOVERLAPPED overlap)
354{
355 struct wpa_ctrl_dst *dst = (struct wpa_ctrl_dst *) overlap;
356 wpa_printf(MSG_DEBUG, "CTRL: Overlapped read completed: dst=%p err=%d "
357 "bytes=%d", dst, (int) err, (int) bytes);
358 if (err == 0 && bytes > 0)
359 wpa_supplicant_ctrl_iface_rx(dst, bytes);
360}
361
362
363static void wpa_supplicant_ctrl_iface_receive(void *eloop_data, void *user_ctx)
364{
365 struct wpa_ctrl_dst *dst = eloop_data;
366 struct ctrl_iface_priv *priv = dst->priv;
367 DWORD bytes;
368
369 wpa_printf(MSG_DEBUG, "CTRL: wpa_supplicant_ctrl_iface_receive");
370 ResetEvent(dst->overlap.hEvent);
371
372 if (!GetOverlappedResult(dst->pipe, &dst->overlap, &bytes, FALSE)) {
373 wpa_printf(MSG_DEBUG, "CTRL: GetOverlappedResult failed: %d",
374 (int) GetLastError());
375 return;
376 }
377 wpa_printf(MSG_DEBUG, "CTRL: GetOverlappedResult: New client "
378 "connected");
379
380 /* Open a new named pipe for the next client. */
381 ctrl_open_pipe(priv);
382
383 /* Use write completion function to start reading a command */
384 ctrl_iface_write_completed(0, 0, &dst->overlap);
385
386 ctrl_flush_broken_pipes(priv);
387}
388
389
390static int ctrl_iface_parse(struct ctrl_iface_priv *priv, const char *params)
391{
392 const char *sddl = NULL;
393 TCHAR *t_sddl;
394
395 if (os_strncmp(params, "SDDL=", 5) == 0)
396 sddl = params + 5;
397 if (!sddl) {
398 sddl = os_strstr(params, " SDDL=");
399 if (sddl)
400 sddl += 6;
401 }
402
403 if (!sddl)
404 return 0;
405
406 wpa_printf(MSG_DEBUG, "CTRL: SDDL='%s'", sddl);
407 os_memset(&priv->attr, 0, sizeof(priv->attr));
408 priv->attr.nLength = sizeof(priv->attr);
409 priv->attr.bInheritHandle = FALSE;
410 t_sddl = wpa_strdup_tchar(sddl);
411 if (t_sddl == NULL)
412 return -1;
413 if (!ConvertStringSecurityDescriptorToSecurityDescriptor(
414 t_sddl, SDDL_REVISION_1,
9e72e1d3
JM		 415 (PSECURITY_DESCRIPTOR *) (void *)
416 &priv->attr.lpSecurityDescriptor,
6fc6879b
JM		 417 NULL)) {
418 os_free(t_sddl);
419 wpa_printf(MSG_ERROR, "CTRL: SDDL='%s' - could not convert to "
420 "security descriptor: %d",
421 sddl, (int) GetLastError());
422 return -1;
423 }
424 os_free(t_sddl);
425
426 priv->sec_attr_set = 1;
427
428 return 0;
429}
430
431
432static void wpa_supplicant_ctrl_iface_msg_cb(void *ctx, int level,
433 const char *txt, size_t len)
434{
435 struct wpa_supplicant *wpa_s = ctx;
436 if (wpa_s == NULL || wpa_s->ctrl_iface == NULL)
437 return;
438 wpa_supplicant_ctrl_iface_send(wpa_s->ctrl_iface, level, txt, len);
439}
440
441
442struct ctrl_iface_priv *
443wpa_supplicant_ctrl_iface_init(struct wpa_supplicant *wpa_s)
444{
445 struct ctrl_iface_priv *priv;
446
447 priv = os_zalloc(sizeof(*priv));
448 if (priv == NULL)
449 return NULL;
450 priv->wpa_s = wpa_s;
451
452 if (wpa_s->conf->ctrl_interface == NULL)
453 return priv;
454
455 if (ctrl_iface_parse(priv, wpa_s->conf->ctrl_interface) < 0) {
456 os_free(priv);
457 return NULL;
458 }
459
460 if (ctrl_open_pipe(priv) < 0) {
461 os_free(priv);
462 return NULL;
463 }
464
465 wpa_msg_register_cb(wpa_supplicant_ctrl_iface_msg_cb);
466
467 return priv;
468}
469
470
471void wpa_supplicant_ctrl_iface_deinit(struct ctrl_iface_priv *priv)
472{
473 while (priv->ctrl_dst)
474 ctrl_close_pipe(priv->ctrl_dst);
475 if (priv->sec_attr_set)
476 LocalFree(priv->attr.lpSecurityDescriptor);
477 os_free(priv);
478}
479
480
481static void wpa_supplicant_ctrl_iface_send(struct ctrl_iface_priv *priv,
482 int level, const char *buf,
483 size_t len)
484{
485 struct wpa_ctrl_dst *dst, *next;
486 char levelstr[10];
487 int idx;
488 char *sbuf;
489 int llen;
490 DWORD written;
491
492 dst = priv->ctrl_dst;
493 if (dst == NULL)
494 return;
495
496 os_snprintf(levelstr, sizeof(levelstr), "<%d>", level);
497
498 llen = os_strlen(levelstr);
499 sbuf = os_malloc(llen + len);
500 if (sbuf == NULL)
501 return;
502
503 os_memcpy(sbuf, levelstr, llen);
504 os_memcpy(sbuf + llen, buf, len);
505
506 idx = 0;
507 while (dst) {
508 next = dst->next;
509 if (dst->attached && level >= dst->debug_level) {
510 wpa_printf(MSG_DEBUG, "CTRL_IFACE monitor send %p",
511 dst);
512 if (!WriteFile(dst->pipe, sbuf, llen + len, &written,
513 NULL)) {
514 wpa_printf(MSG_DEBUG, "CTRL: WriteFile to dst "
515 "%p failed: %d",
516 dst, (int) GetLastError());
517 dst->errors++;
518 if (dst->errors > 10)
519 ctrl_close_pipe(dst);
520 } else
521 dst->errors = 0;
522 }
523 idx++;
524 dst = next;
525 }
526 os_free(sbuf);
527}
528
529
530void wpa_supplicant_ctrl_iface_wait(struct ctrl_iface_priv *priv)
531{
532 wpa_printf(MSG_DEBUG, "CTRL_IFACE - %s - wait for monitor",
533 priv->wpa_s->ifname);
534 if (priv->ctrl_dst == NULL)
535 return;
536 WaitForSingleObject(priv->ctrl_dst->pipe, INFINITE);
537}
538
539
540/* Global ctrl_iface */
541
542struct ctrl_iface_global_priv;
543
544struct wpa_global_dst {
545 /* Note: OVERLAPPED must be the first member of struct wpa_global_dst
546 */
547 OVERLAPPED overlap;
548 struct wpa_global_dst *next, *prev;
549 struct ctrl_iface_global_priv *priv;
550 HANDLE pipe;
551 char req_buf[REQUEST_BUFSIZE];
552 char *rsp_buf;
553 int used;
554};
555
556struct ctrl_iface_global_priv {
557 struct wpa_global *global;
558 struct wpa_global_dst *ctrl_dst;
559};
560
561
562static void global_flush_broken_pipes(struct ctrl_iface_global_priv *priv)
563{
564 struct wpa_global_dst *dst, *next;
565
566 dst = priv->ctrl_dst;
567
568 while (dst) {
569 next = dst->next;
570 if (ctrl_broken_pipe(dst->pipe, dst->used)) {
571 wpa_printf(MSG_DEBUG, "CTRL: closing broken pipe %p",
572 dst);
573 global_close_pipe(dst);
574 }
575 dst = next;
576 }
577}
578
579
580static int global_open_pipe(struct ctrl_iface_global_priv *priv)
581{
582 struct wpa_global_dst *dst;
583 DWORD err;
584
585 dst = os_zalloc(sizeof(*dst));
586 if (dst == NULL)
587 return -1;
588 wpa_printf(MSG_DEBUG, "CTRL: Open pipe %p", dst);
589
590 dst->priv = priv;
591 dst->pipe = INVALID_HANDLE_VALUE;
592
593 dst->overlap.hEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
594 if (dst->overlap.hEvent == NULL) {
595 wpa_printf(MSG_ERROR, "CTRL: CreateEvent failed: %d",
596 (int) GetLastError());
597 goto fail;
598 }
599
600 eloop_register_event(dst->overlap.hEvent,
601 sizeof(dst->overlap.hEvent),
602 wpa_supplicant_global_iface_receive, dst, NULL);
603
604 /* TODO: add support for configuring access list for the pipe */
605 dst->pipe = CreateNamedPipe(NAMED_PIPE_PREFIX,
606 PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
607 PIPE_TYPE_MESSAGE |
608 PIPE_READMODE_MESSAGE |
609 PIPE_WAIT,
610 10, REPLY_BUFSIZE, REQUEST_BUFSIZE,
611 1000, NULL);
612 if (dst->pipe == INVALID_HANDLE_VALUE) {
613 wpa_printf(MSG_ERROR, "CTRL: CreateNamedPipe failed: %d",
614 (int) GetLastError());
615 goto fail;
616 }
617
618 if (ConnectNamedPipe(dst->pipe, &dst->overlap)) {
619 wpa_printf(MSG_ERROR, "CTRL: ConnectNamedPipe failed: %d",
620 (int) GetLastError());
621 CloseHandle(dst->pipe);
622 os_free(dst);
623 return -1;
624 }
625
626 err = GetLastError();
627 switch (err) {
628 case ERROR_IO_PENDING:
629 wpa_printf(MSG_DEBUG, "CTRL: ConnectNamedPipe: connection in "
630 "progress");
631 break;
632 case ERROR_PIPE_CONNECTED:
633 wpa_printf(MSG_DEBUG, "CTRL: ConnectNamedPipe: already "
634 "connected");
635 if (SetEvent(dst->overlap.hEvent))
636 break;
637 /* fall through */
638 default:
639 wpa_printf(MSG_DEBUG, "CTRL: ConnectNamedPipe error: %d",
640 (int) err);
641 CloseHandle(dst->pipe);
642 os_free(dst);
643 return -1;
644 }
645
646 dst->next = priv->ctrl_dst;
647 if (dst->next)
648 dst->next->prev = dst;
649 priv->ctrl_dst = dst;
650
651 return 0;
652
653fail:
654 global_close_pipe(dst);
655 return -1;
656}
657
658
659static void global_close_pipe(struct wpa_global_dst *dst)
660{
661 wpa_printf(MSG_DEBUG, "CTRL: close pipe %p", dst);
662
663 if (dst->overlap.hEvent) {
664 eloop_unregister_event(dst->overlap.hEvent,
665 sizeof(dst->overlap.hEvent));
666 CloseHandle(dst->overlap.hEvent);
667 }
668
669 if (dst->pipe != INVALID_HANDLE_VALUE) {
670 /*
671 * Could use FlushFileBuffers() here to guarantee that all data
672 * gets delivered to the client, but that can block, so let's
673 * not do this for now.
674 * FlushFileBuffers(dst->pipe);
675 */
676 CloseHandle(dst->pipe);
677 }
678
679 if (dst->prev)
680 dst->prev->next = dst->next;
681 else
682 dst->priv->ctrl_dst = dst->next;
683 if (dst->next)
684 dst->next->prev = dst->prev;
685
686 os_free(dst->rsp_buf);
687 os_free(dst);
688}
689
690
691static VOID WINAPI global_iface_write_completed(DWORD err, DWORD bytes,
692 LPOVERLAPPED overlap)
693{
694 struct wpa_global_dst *dst = (struct wpa_global_dst *) overlap;
695 wpa_printf(MSG_DEBUG, "CTRL: Overlapped write completed: dst=%p "
696 "err=%d bytes=%d", dst, (int) err, (int) bytes);
697 if (err) {
698 global_close_pipe(dst);
699 return;
700 }
701
702 os_free(dst->rsp_buf);
703 dst->rsp_buf = NULL;
704
705 if (!ReadFileEx(dst->pipe, dst->req_buf, sizeof(dst->req_buf),
706 &dst->overlap, global_iface_read_completed)) {
707 wpa_printf(MSG_DEBUG, "CTRL: ReadFileEx failed: %d",
708 (int) GetLastError());
709 global_close_pipe(dst);
710 /* FIX: if this was the pipe waiting for new global
711 * connections, at this point there are no open global pipes..
712 * Should try to open a new pipe.. */
713 return;
714 }
715 wpa_printf(MSG_DEBUG, "CTRL: Overlapped read started for %p", dst);
716}
717
718
719static void wpa_supplicant_global_iface_rx(struct wpa_global_dst *dst,
720 size_t len)
721{
722 struct wpa_global *global = dst->priv->global;
723 char *reply = NULL, *send_buf;
724 size_t reply_len = 0, send_len;
725 char *buf = dst->req_buf;
726
727 dst->used = 1;
728 if (len >= REQUEST_BUFSIZE)
729 len = REQUEST_BUFSIZE - 1;
730 buf[len] = '\0';
731
732 reply = wpa_supplicant_global_ctrl_iface_process(global, buf,
733 &reply_len);
734 if (reply) {
735 send_buf = reply;
736 send_len = reply_len;
737 } else if (reply_len) {
738 send_buf = "FAIL\n";
739 send_len = 5;
740 } else {
741 os_free(dst->rsp_buf);
742 dst->rsp_buf = NULL;
743 return;
744 }
745
746 os_free(dst->rsp_buf);
747 dst->rsp_buf = os_malloc(send_len);
748 if (dst->rsp_buf == NULL) {
749 global_close_pipe(dst);
750 os_free(reply);
751 return;
752 }
753 os_memcpy(dst->rsp_buf, send_buf, send_len);
754 os_free(reply);
755
756 if (!WriteFileEx(dst->pipe, dst->rsp_buf, send_len, &dst->overlap,
757 global_iface_write_completed)) {
758 wpa_printf(MSG_DEBUG, "CTRL: WriteFileEx failed: %d",
759 (int) GetLastError());
760 global_close_pipe(dst);
761 } else {
762 wpa_printf(MSG_DEBUG, "CTRL: Overlapped write started for %p",
763 dst);
764 }
765}
766
767
768static VOID WINAPI global_iface_read_completed(DWORD err, DWORD bytes,
769 LPOVERLAPPED overlap)
770{
771 struct wpa_global_dst *dst = (struct wpa_global_dst *) overlap;
772 wpa_printf(MSG_DEBUG, "CTRL: Overlapped read completed: dst=%p err=%d "
773 "bytes=%d", dst, (int) err, (int) bytes);
774 if (err == 0 && bytes > 0)
775 wpa_supplicant_global_iface_rx(dst, bytes);
776}
777
778
779static void wpa_supplicant_global_iface_receive(void *eloop_data,
780 void *user_ctx)
781{
782 struct wpa_global_dst *dst = eloop_data;
783 struct ctrl_iface_global_priv *priv = dst->priv;
784 DWORD bytes;
785
786 wpa_printf(MSG_DEBUG, "CTRL: wpa_supplicant_global_iface_receive");
787 ResetEvent(dst->overlap.hEvent);
788
789 if (!GetOverlappedResult(dst->pipe, &dst->overlap, &bytes, FALSE)) {
790 wpa_printf(MSG_DEBUG, "CTRL: GetOverlappedResult failed: %d",
791 (int) GetLastError());
792 return;
793 }
794 wpa_printf(MSG_DEBUG, "CTRL: GetOverlappedResult: New client "
795 "connected");
796
797 /* Open a new named pipe for the next client. */
798 if (global_open_pipe(priv) < 0) {
799 wpa_printf(MSG_DEBUG, "CTRL: global_open_pipe failed");
800 return;
801 }
802
803 /* Use write completion function to start reading a command */
804 global_iface_write_completed(0, 0, &dst->overlap);
805
806 global_flush_broken_pipes(priv);
807}
808
809
810struct ctrl_iface_global_priv *
811wpa_supplicant_global_ctrl_iface_init(struct wpa_global *global)
812{
813 struct ctrl_iface_global_priv *priv;
814
815 priv = os_zalloc(sizeof(*priv));
816 if (priv == NULL)
817 return NULL;
818 priv->global = global;
819
820 if (global_open_pipe(priv) < 0) {
821 os_free(priv);
822 return NULL;
823 }
824
825 return priv;
826}
827
828
829void
830wpa_supplicant_global_ctrl_iface_deinit(struct ctrl_iface_global_priv *priv)
831{
832 while (priv->ctrl_dst)
833 global_close_pipe(priv->ctrl_dst);
834 os_free(priv);
835}
Unnamed repository; edit this file 'description' to name the repository.