git.maemo.org Git - wpasupplicant/blob - src/common/wpa_ctrl.c

   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
  23 #include "wpa_ctrl.h"
  24 #include "common.h"
  25
  26
  27 #if defined(CONFIG_CTRL_IFACE_UNIX) || defined(CONFIG_CTRL_IFACE_UDP)
  28 #define CTRL_IFACE_SOCKET
  29 #endif /* CONFIG_CTRL_IFACE_UNIX || CONFIG_CTRL_IFACE_UDP */
  30
  31
  32 /**
  33  * struct wpa_ctrl - Internal structure for control interface library
  34  *
  35  * This structure is used by the wpa_supplicant/hostapd control interface
  36  * library to store internal data. Programs using the library should not touch
  37  * this data directly. They can only use the pointer to the data structure as
  38  * an identifier for the control interface connection and use this as one of
  39  * the arguments for most of the control interface library functions.
  40  */
  41 struct wpa_ctrl {
  42 #ifdef CONFIG_CTRL_IFACE_UDP
  43         int s;
  44         struct sockaddr_in local;
  45         struct sockaddr_in dest;
  46         char *cookie;
  47 #endif /* CONFIG_CTRL_IFACE_UDP */
  48 #ifdef CONFIG_CTRL_IFACE_UNIX
  49         int s;
  50         struct sockaddr_un local;
  51         struct sockaddr_un dest;
  52 #endif /* CONFIG_CTRL_IFACE_UNIX */
  53 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
  54         HANDLE pipe;
  55 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
  56 };
  57
  58
  59 #ifdef CONFIG_CTRL_IFACE_UNIX
  60
  61 struct wpa_ctrl * wpa_ctrl_open(const char *ctrl_path)
  62 {
  63         struct wpa_ctrl *ctrl;
  64         static int counter = 0;
  65         int ret;
  66         size_t res;
  67
  68         ctrl = os_malloc(sizeof(*ctrl));
  69         if (ctrl == NULL)
  70                 return NULL;
  71         os_memset(ctrl, 0, sizeof(*ctrl));
  72
  73         ctrl->s = socket(PF_UNIX, SOCK_DGRAM, 0);
  74         if (ctrl->s < 0) {
  75                 os_free(ctrl);
  76                 return NULL;
  77         }
  78
  79         ctrl->local.sun_family = AF_UNIX;
  80         ret = os_snprintf(ctrl->local.sun_path, sizeof(ctrl->local.sun_path),
  81                           "/tmp/wpa_ctrl_%d-%d", getpid(), counter++);
  82         if (ret < 0 || (size_t) ret >= sizeof(ctrl->local.sun_path)) {
  83                 close(ctrl->s);
  84                 os_free(ctrl);
  85                 return NULL;
  86         }
  87         if (bind(ctrl->s, (struct sockaddr *) &ctrl->local,
  88                     sizeof(ctrl->local)) < 0) {
  89                 close(ctrl->s);
  90                 os_free(ctrl);
  91                 return NULL;
  92         }
  93
  94         ctrl->dest.sun_family = AF_UNIX;
  95         res = os_strlcpy(ctrl->dest.sun_path, ctrl_path,
  96                          sizeof(ctrl->dest.sun_path));
  97         if (res >= sizeof(ctrl->dest.sun_path)) {
  98                 close(ctrl->s);
  99                 os_free(ctrl);
 100                 return NULL;
 101         }
 102         if (connect(ctrl->s, (struct sockaddr *) &ctrl->dest,
 103                     sizeof(ctrl->dest)) < 0) {
 104                 close(ctrl->s);
 105                 unlink(ctrl->local.sun_path);
 106                 os_free(ctrl);
 107                 return NULL;
 108         }
 109
 110         return ctrl;
 111 }
 112
 113
 114 void wpa_ctrl_close(struct wpa_ctrl *ctrl)
 115 {
 116         unlink(ctrl->local.sun_path);
 117         close(ctrl->s);
 118         os_free(ctrl);
 119 }
 120
 121 #endif /* CONFIG_CTRL_IFACE_UNIX */
 122
 123
 124 #ifdef CONFIG_CTRL_IFACE_UDP
 125
 126 struct wpa_ctrl * wpa_ctrl_open(const char *ctrl_path)
 127 {
 128         struct wpa_ctrl *ctrl;
 129         char buf[128];
 130         size_t len;
 131
 132         ctrl = os_malloc(sizeof(*ctrl));
 133         if (ctrl == NULL)
 134                 return NULL;
 135         os_memset(ctrl, 0, sizeof(*ctrl));
 136
 137         ctrl->s = socket(PF_INET, SOCK_DGRAM, 0);
 138         if (ctrl->s < 0) {
 139                 perror("socket");
 140                 os_free(ctrl);
 141                 return NULL;
 142         }
 143
 144         ctrl->local.sin_family = AF_INET;
 145         ctrl->local.sin_addr.s_addr = htonl((127 << 24) | 1);
 146         if (bind(ctrl->s, (struct sockaddr *) &ctrl->local,
 147                  sizeof(ctrl->local)) < 0) {
 148                 close(ctrl->s);
 149                 os_free(ctrl);
 150                 return NULL;
 151         }
 152
 153         ctrl->dest.sin_family = AF_INET;
 154         ctrl->dest.sin_addr.s_addr = htonl((127 << 24) | 1);
 155         ctrl->dest.sin_port = htons(WPA_CTRL_IFACE_PORT);
 156         if (connect(ctrl->s, (struct sockaddr *) &ctrl->dest,
 157                     sizeof(ctrl->dest)) < 0) {
 158                 perror("connect");
 159                 close(ctrl->s);
 160                 os_free(ctrl);
 161                 return NULL;
 162         }
 163
 164         len = sizeof(buf) - 1;
 165         if (wpa_ctrl_request(ctrl, "GET_COOKIE", 10, buf, &len, NULL) == 0) {
 166                 buf[len] = '\0';
 167                 ctrl->cookie = os_strdup(buf);
 168         }
 169
 170         return ctrl;
 171 }
 172
 173
 174 void wpa_ctrl_close(struct wpa_ctrl *ctrl)
 175 {
 176         close(ctrl->s);
 177         os_free(ctrl->cookie);
 178         os_free(ctrl);
 179 }
 180
 181 #endif /* CONFIG_CTRL_IFACE_UDP */
 182
 183
 184 #ifdef CTRL_IFACE_SOCKET
 185 int wpa_ctrl_request(struct wpa_ctrl *ctrl, const char *cmd, size_t cmd_len,
 186                      char *reply, size_t *reply_len,
 187                      void (*msg_cb)(char *msg, size_t len))
 188 {
 189         struct timeval tv;
 190         int res;
 191         fd_set rfds;
 192         const char *_cmd;
 193         char *cmd_buf = NULL;
 194         size_t _cmd_len;
 195
 196 #ifdef CONFIG_CTRL_IFACE_UDP
 197         if (ctrl->cookie) {
 198                 char *pos;
 199                 _cmd_len = os_strlen(ctrl->cookie) + 1 + cmd_len;
 200                 cmd_buf = os_malloc(_cmd_len);
 201                 if (cmd_buf == NULL)
 202                         return -1;
 203                 _cmd = cmd_buf;
 204                 pos = cmd_buf;
 205                 os_strlcpy(pos, ctrl->cookie, _cmd_len);
 206                 pos += os_strlen(ctrl->cookie);
 207                 *pos++ = ' ';
 208                 os_memcpy(pos, cmd, cmd_len);
 209         } else
 210 #endif /* CONFIG_CTRL_IFACE_UDP */
 211         {
 212                 _cmd = cmd;
 213                 _cmd_len = cmd_len;
 214         }
 215
 216         if (send(ctrl->s, _cmd, _cmd_len, 0) < 0) {
 217                 os_free(cmd_buf);
 218                 return -1;
 219         }
 220         os_free(cmd_buf);
 221
 222         for (;;) {
 223                 tv.tv_sec = 2;
 224                 tv.tv_usec = 0;
 225                 FD_ZERO(&rfds);
 226                 FD_SET(ctrl->s, &rfds);
 227                 res = select(ctrl->s + 1, &rfds, NULL, NULL, &tv);
 228                 if (FD_ISSET(ctrl->s, &rfds)) {
 229                         res = recv(ctrl->s, reply, *reply_len, 0);
 230                         if (res < 0)
 231                                 return res;
 232                         if (res > 0 && reply[0] == '<') {
 233                                 /* This is an unsolicited message from
 234                                  * wpa_supplicant, not the reply to the
 235                                  * request. Use msg_cb to report this to the
 236                                  * caller. */
 237                                 if (msg_cb) {
 238                                         /* Make sure the message is nul
 239                                          * terminated. */
 240                                         if ((size_t) res == *reply_len)
 241                                                 res = (*reply_len) - 1;
 242                                         reply[res] = '\0';
 243                                         msg_cb(reply, res);
 244                                 }
 245                                 continue;
 246                         }
 247                         *reply_len = res;
 248                         break;
 249                 } else {
 250                         return -2;
 251                 }
 252         }
 253         return 0;
 254 }
 255 #endif /* CTRL_IFACE_SOCKET */
 256
 257
 258 static int wpa_ctrl_attach_helper(struct wpa_ctrl *ctrl, int attach)
 259 {
 260         char buf[10];
 261         int ret;
 262         size_t len = 10;
 263
 264         ret = wpa_ctrl_request(ctrl, attach ? "ATTACH" : "DETACH", 6,
 265                                buf, &len, NULL);
 266         if (ret < 0)
 267                 return ret;
 268         if (len == 3 && os_memcmp(buf, "OK\n", 3) == 0)
 269                 return 0;
 270         return -1;
 271 }
 272
 273
 274 int wpa_ctrl_attach(struct wpa_ctrl *ctrl)
 275 {
 276         return wpa_ctrl_attach_helper(ctrl, 1);
 277 }
 278
 279
 280 int wpa_ctrl_detach(struct wpa_ctrl *ctrl)
 281 {
 282         return wpa_ctrl_attach_helper(ctrl, 0);
 283 }
 284
 285
 286 #ifdef CTRL_IFACE_SOCKET
 287
 288 int wpa_ctrl_recv(struct wpa_ctrl *ctrl, char *reply, size_t *reply_len)
 289 {
 290         int res;
 291
 292         res = recv(ctrl->s, reply, *reply_len, 0);
 293         if (res < 0)
 294                 return res;
 295         *reply_len = res;
 296         return 0;
 297 }
 298
 299
 300 int wpa_ctrl_pending(struct wpa_ctrl *ctrl)
 301 {
 302         struct timeval tv;
 303         fd_set rfds;
 304         tv.tv_sec = 0;
 305         tv.tv_usec = 0;
 306         FD_ZERO(&rfds);
 307         FD_SET(ctrl->s, &rfds);
 308         select(ctrl->s + 1, &rfds, NULL, NULL, &tv);
 309         return FD_ISSET(ctrl->s, &rfds);
 310 }
 311
 312
 313 int wpa_ctrl_get_fd(struct wpa_ctrl *ctrl)
 314 {
 315         return ctrl->s;
 316 }
 317
 318 #endif /* CTRL_IFACE_SOCKET */
 319
 320
 321 #ifdef CONFIG_CTRL_IFACE_NAMED_PIPE
 322
 323 #ifndef WPA_SUPPLICANT_NAMED_PIPE
 324 #define WPA_SUPPLICANT_NAMED_PIPE "WpaSupplicant"
 325 #endif
 326 #define NAMED_PIPE_PREFIX TEXT("\\\\.\\pipe\\") TEXT(WPA_SUPPLICANT_NAMED_PIPE)
 327
 328 struct wpa_ctrl * wpa_ctrl_open(const char *ctrl_path)
 329 {
 330         struct wpa_ctrl *ctrl;
 331         DWORD mode;
 332         TCHAR name[256];
 333         int i, ret;
 334
 335         ctrl = os_malloc(sizeof(*ctrl));
 336         if (ctrl == NULL)
 337                 return NULL;
 338         os_memset(ctrl, 0, sizeof(*ctrl));
 339
 340 #ifdef UNICODE
 341         if (ctrl_path == NULL)
 342                 ret = _snwprintf(name, 256, NAMED_PIPE_PREFIX);
 343         else
 344                 ret = _snwprintf(name, 256, NAMED_PIPE_PREFIX TEXT("-%S"),
 345                                  ctrl_path);
 346 #else /* UNICODE */
 347         if (ctrl_path == NULL)
 348                 ret = os_snprintf(name, 256, NAMED_PIPE_PREFIX);
 349         else
 350                 ret = os_snprintf(name, 256, NAMED_PIPE_PREFIX "-%s",
 351                                   ctrl_path);
 352 #endif /* UNICODE */
 353         if (ret < 0 || ret >= 256) {
 354                 os_free(ctrl);
 355                 return NULL;
 356         }
 357
 358         for (i = 0; i < 10; i++) {
 359                 ctrl->pipe = CreateFile(name, GENERIC_READ | GENERIC_WRITE, 0,
 360                                         NULL, OPEN_EXISTING, 0, NULL);
 361                 /*
 362                  * Current named pipe server side in wpa_supplicant is
 363                  * re-opening the pipe for new clients only after the previous
 364                  * one is taken into use. This leaves a small window for race
 365                  * conditions when two connections are being opened at almost
 366                  * the same time. Retry if that was the case.
 367                  */
 368                 if (ctrl->pipe != INVALID_HANDLE_VALUE ||
 369                     GetLastError() != ERROR_PIPE_BUSY)
 370                         break;
 371                 WaitNamedPipe(name, 1000);
 372         }
 373         if (ctrl->pipe == INVALID_HANDLE_VALUE) {
 374                 os_free(ctrl);
 375                 return NULL;
 376         }
 377
 378         mode = PIPE_READMODE_MESSAGE;
 379         if (!SetNamedPipeHandleState(ctrl->pipe, &mode, NULL, NULL)) {
 380                 CloseHandle(ctrl->pipe);
 381                 os_free(ctrl);
 382                 return NULL;
 383         }
 384
 385         return ctrl;
 386 }
 387
 388
 389 void wpa_ctrl_close(struct wpa_ctrl *ctrl)
 390 {
 391         CloseHandle(ctrl->pipe);
 392         os_free(ctrl);
 393 }
 394
 395
 396 int wpa_ctrl_request(struct wpa_ctrl *ctrl, const char *cmd, size_t cmd_len,
 397                      char *reply, size_t *reply_len,
 398                      void (*msg_cb)(char *msg, size_t len))
 399 {
 400         DWORD written;
 401         DWORD readlen = *reply_len;
 402
 403         if (!WriteFile(ctrl->pipe, cmd, cmd_len, &written, NULL))
 404                 return -1;
 405
 406         if (!ReadFile(ctrl->pipe, reply, *reply_len, &readlen, NULL))
 407                 return -1;
 408         *reply_len = readlen;
 409
 410         return 0;
 411 }
 412
 413
 414 int wpa_ctrl_recv(struct wpa_ctrl *ctrl, char *reply, size_t *reply_len)
 415 {
 416         DWORD len = *reply_len;
 417         if (!ReadFile(ctrl->pipe, reply, *reply_len, &len, NULL))
 418                 return -1;
 419         *reply_len = len;
 420         return 0;
 421 }
 422
 423
 424 int wpa_ctrl_pending(struct wpa_ctrl *ctrl)
 425 {
 426         DWORD left;
 427
 428         if (!PeekNamedPipe(ctrl->pipe, NULL, 0, NULL, &left, NULL))
 429                 return -1;
 430         return left ? 1 : 0;
 431 }
 432
 433
 434 int wpa_ctrl_get_fd(struct wpa_ctrl *ctrl)
 435 {
 436         return -1;
 437 }
 438
 439 #endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */
 440
 441 #endif /* CONFIG_CTRL_IFACE */