workbench/network/WirelessManager/wpa_supplicant/ctrl_iface_named_pipe.c

   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"
  23 #include "common/wpa_ctrl.h"
  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
  29 BOOL WINAPI ConvertStringSecurityDescriptorToSecurityDescriptorA(
  30         LPCSTR, DWORD, PSECURITY_DESCRIPTOR *, PULONG);
  31 BOOL WINAPI ConvertStringSecurityDescriptorToSecurityDescriptorW(
  32         LPCWSTR, DWORD, PSECURITY_DESCRIPTOR *, PULONG);
  33 #ifdef UNICODE
  34 #define ConvertStringSecurityDescriptorToSecurityDescriptor \
  35 ConvertStringSecurityDescriptorToSecurityDescriptorW
  36 #else
  37 #define ConvertStringSecurityDescriptorToSecurityDescriptor \
  38 ConvertStringSecurityDescriptorToSecurityDescriptorA
  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
  57 struct 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  */
  66 struct 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
  81 struct 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
  89 static void wpa_supplicant_ctrl_iface_send(struct ctrl_iface_priv *priv,
  90                                            int level, const char *buf,
  91                                            size_t len);
  92
  93 static void ctrl_close_pipe(struct wpa_ctrl_dst *dst);
  94 static void wpa_supplicant_ctrl_iface_receive(void *, void *);
  95 static VOID WINAPI ctrl_iface_read_completed(DWORD err, DWORD bytes,
  96                                              LPOVERLAPPED overlap);
  97
  98 struct wpa_global_dst;
  99 static void global_close_pipe(struct wpa_global_dst *dst);
 100 static void wpa_supplicant_global_iface_receive(void *eloop_data,
 101                                                 void *user_ctx);
 102 static VOID WINAPI global_iface_read_completed(DWORD err, DWORD bytes,
 103                                                LPOVERLAPPED overlap);
 104
 105
 106 static 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
 120 static 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
 138 static 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
 222 fail:
 223         ctrl_close_pipe(dst);
 224         return -1;
 225 }
 226
 227
 228 static 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
 260 static 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
 285 static 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
 352 static 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
 363 static 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
 390 static 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,
 415                     (PSECURITY_DESCRIPTOR *) (void *)
 416                     &priv->attr.lpSecurityDescriptor,
 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
 432 static 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
 442 struct ctrl_iface_priv *
 443 wpa_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
 471 void 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
 481 static 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
 530 void 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
 542 struct ctrl_iface_global_priv;
 543
 544 struct 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
 556 struct ctrl_iface_global_priv {
 557         struct wpa_global *global;
 558         struct wpa_global_dst *ctrl_dst;
 559 };
 560
 561
 562 static 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
 580 static 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
 653 fail:
 654         global_close_pipe(dst);
 655         return -1;
 656 }
 657
 658
 659 static 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
 691 static 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
 719 static 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
 768 static 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
 779 static 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
 810 struct ctrl_iface_global_priv *
 811 wpa_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
 829 void
 830 wpa_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 }