www.project-moonshot.org Git - mech_eap.orig/blob - src/wps/http_client.c

   1 /*
   2  * http_client - HTTP client
   3  * Copyright (c) 2009, 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 #include <fcntl.h>
  17
  18 #include "common.h"
  19 #include "eloop.h"
  20 #include "httpread.h"
  21 #include "http_client.h"
  22
  23
  24 #define HTTP_CLIENT_TIMEOUT_SEC 30
  25
  26
  27 struct http_client {
  28         struct sockaddr_in dst;
  29         int sd;
  30         struct wpabuf *req;
  31         size_t req_pos;
  32         size_t max_response;
  33
  34         void (*cb)(void *ctx, struct http_client *c,
  35                    enum http_client_event event);
  36         void *cb_ctx;
  37         struct httpread *hread;
  38         struct wpabuf body;
  39 };
  40
  41
  42 static void http_client_timeout(void *eloop_data, void *user_ctx)
  43 {
  44         struct http_client *c = eloop_data;
  45         wpa_printf(MSG_DEBUG, "HTTP: Timeout (c=%p)", c);
  46         c->cb(c->cb_ctx, c, HTTP_CLIENT_TIMEOUT);
  47 }
  48
  49
  50 static void http_client_got_response(struct httpread *handle, void *cookie,
  51                                      enum httpread_event e)
  52 {
  53         struct http_client *c = cookie;
  54
  55         wpa_printf(MSG_DEBUG, "HTTP: httpread callback: handle=%p cookie=%p "
  56                    "e=%d", handle, cookie, e);
  57
  58         eloop_cancel_timeout(http_client_timeout, c, NULL);
  59         switch (e) {
  60         case HTTPREAD_EVENT_FILE_READY:
  61                 if (httpread_hdr_type_get(c->hread) == HTTPREAD_HDR_TYPE_REPLY)
  62                 {
  63                         int reply_code = httpread_reply_code_get(c->hread);
  64                         if (reply_code == 200 /* OK */) {
  65                                 wpa_printf(MSG_DEBUG, "HTTP: Response OK from "
  66                                            "%s:%d",
  67                                            inet_ntoa(c->dst.sin_addr),
  68                                            ntohs(c->dst.sin_port));
  69                                 c->cb(c->cb_ctx, c, HTTP_CLIENT_OK);
  70                         } else {
  71                                 wpa_printf(MSG_DEBUG, "HTTP: Error %d from "
  72                                            "%s:%d", reply_code,
  73                                            inet_ntoa(c->dst.sin_addr),
  74                                            ntohs(c->dst.sin_port));
  75                                 c->cb(c->cb_ctx, c, HTTP_CLIENT_INVALID_REPLY);
  76                         }
  77                 } else
  78                         c->cb(c->cb_ctx, c, HTTP_CLIENT_INVALID_REPLY);
  79                 break;
  80         case HTTPREAD_EVENT_TIMEOUT:
  81                 c->cb(c->cb_ctx, c, HTTP_CLIENT_TIMEOUT);
  82                 break;
  83         case HTTPREAD_EVENT_ERROR:
  84                 c->cb(c->cb_ctx, c, HTTP_CLIENT_FAILED);
  85                 break;
  86         }
  87 }
  88
  89
  90 static void http_client_tx_ready(int sock, void *eloop_ctx, void *sock_ctx)
  91 {
  92         struct http_client *c = eloop_ctx;
  93         int res;
  94
  95         wpa_printf(MSG_DEBUG, "HTTP: Send client request to %s:%d (%lu of %lu "
  96                    "bytes remaining)",
  97                    inet_ntoa(c->dst.sin_addr), ntohs(c->dst.sin_port),
  98                    (unsigned long) wpabuf_len(c->req),
  99                    (unsigned long) wpabuf_len(c->req) - c->req_pos);
 100
 101         res = send(c->sd, wpabuf_head(c->req) + c->req_pos,
 102                    wpabuf_len(c->req) - c->req_pos, 0);
 103         if (res < 0) {
 104                 wpa_printf(MSG_DEBUG, "HTTP: Failed to send buffer: %s",
 105                            strerror(errno));
 106                 eloop_unregister_sock(c->sd, EVENT_TYPE_WRITE);
 107                 c->cb(c->cb_ctx, c, HTTP_CLIENT_FAILED);
 108                 return;
 109         }
 110
 111         if ((size_t) res < wpabuf_len(c->req) - c->req_pos) {
 112                 wpa_printf(MSG_DEBUG, "HTTP: Sent %d of %lu bytes; %lu bytes "
 113                            "remaining",
 114                            res, (unsigned long) wpabuf_len(c->req),
 115                            (unsigned long) wpabuf_len(c->req) - c->req_pos -
 116                            res);
 117                 c->req_pos += res;
 118                 return;
 119         }
 120
 121         wpa_printf(MSG_DEBUG, "HTTP: Full client request sent to %s:%d",
 122                    inet_ntoa(c->dst.sin_addr), ntohs(c->dst.sin_port));
 123         eloop_unregister_sock(c->sd, EVENT_TYPE_WRITE);
 124         wpabuf_free(c->req);
 125         c->req = NULL;
 126
 127         c->hread = httpread_create(c->sd, http_client_got_response, c,
 128                                    c->max_response, HTTP_CLIENT_TIMEOUT_SEC);
 129         if (c->hread == NULL) {
 130                 c->cb(c->cb_ctx, c, HTTP_CLIENT_FAILED);
 131                 return;
 132         }
 133 }
 134
 135
 136 struct http_client * http_client_addr(struct sockaddr_in *dst,
 137                                       struct wpabuf *req, size_t max_response,
 138                                       void (*cb)(void *ctx,
 139                                                  struct http_client *c,
 140                                                  enum http_client_event event),
 141                                       void *cb_ctx)
 142 {
 143         struct http_client *c;
 144
 145         c = os_zalloc(sizeof(*c));
 146         if (c == NULL)
 147                 return NULL;
 148         c->sd = -1;
 149         c->dst = *dst;
 150         c->max_response = max_response;
 151         c->cb = cb;
 152         c->cb_ctx = cb_ctx;
 153
 154         c->sd = socket(AF_INET, SOCK_STREAM, 0);
 155         if (c->sd < 0) {
 156                 http_client_free(c);
 157                 return NULL;
 158         }
 159
 160         if (fcntl(c->sd, F_SETFL, O_NONBLOCK) != 0) {
 161                 wpa_printf(MSG_DEBUG, "HTTP: fnctl(O_NONBLOCK) failed: %s",
 162                            strerror(errno));
 163                 http_client_free(c);
 164                 return NULL;
 165         }
 166
 167         if (connect(c->sd, (struct sockaddr *) dst, sizeof(*dst))) {
 168                 if (errno != EINPROGRESS) {
 169                         wpa_printf(MSG_DEBUG, "HTTP: Failed to connect: %s",
 170                                    strerror(errno));
 171                         http_client_free(c);
 172                         return NULL;
 173                 }
 174
 175                 /*
 176                  * Continue connecting in the background; eloop will call us
 177                  * once the connection is ready (or failed).
 178                  */
 179         }
 180
 181         if (eloop_register_sock(c->sd, EVENT_TYPE_WRITE, http_client_tx_ready,
 182                                 c, NULL)) {
 183                 http_client_free(c);
 184                 return NULL;
 185         }
 186
 187         if (eloop_register_timeout(HTTP_CLIENT_TIMEOUT_SEC, 0,
 188                                    http_client_timeout, c, NULL)) {
 189                 http_client_free(c);
 190                 return NULL;
 191         }
 192
 193         c->req = req;
 194
 195         return c;
 196 }
 197
 198
 199 char * http_client_url_parse(const char *url, struct sockaddr_in *dst,
 200                              char **ret_path)
 201 {
 202         char *u, *addr, *port, *path;
 203
 204         u = os_strdup(url);
 205         if (u == NULL)
 206                 return NULL;
 207
 208         os_memset(dst, 0, sizeof(*dst));
 209         dst->sin_family = AF_INET;
 210         addr = u + 7;
 211         path = os_strchr(addr, '/');
 212         port = os_strchr(addr, ':');
 213         if (path == NULL) {
 214                 path = "/";
 215         } else {
 216                 *path = '\0'; /* temporary nul termination for address */
 217                 if (port > path)
 218                         port = NULL;
 219         }
 220         if (port)
 221                 *port++ = '\0';
 222
 223         if (inet_aton(addr, &dst->sin_addr) == 0) {
 224                 /* TODO: name lookup */
 225                 wpa_printf(MSG_DEBUG, "HTTP: Unsupported address in URL '%s' "
 226                            "(addr='%s' port='%s')",
 227                            url, addr, port);
 228                 os_free(u);
 229                 return NULL;
 230         }
 231
 232         if (port)
 233                 dst->sin_port = htons(atoi(port));
 234         else
 235                 dst->sin_port = htons(80);
 236
 237         if (*path == '\0') {
 238                 /* remove temporary nul termination for address */
 239                 *path = '/';
 240         }
 241
 242         *ret_path = path;
 243
 244         return u;
 245 }
 246
 247
 248 struct http_client * http_client_url(const char *url,
 249                                      struct wpabuf *req, size_t max_response,
 250                                      void (*cb)(void *ctx,
 251                                                 struct http_client *c,
 252                                                 enum http_client_event event),
 253                                      void *cb_ctx)
 254 {
 255         struct sockaddr_in dst;
 256         struct http_client *c;
 257         char *u, *path;
 258         struct wpabuf *req_buf = NULL;
 259
 260         if (os_strncmp(url, "http://", 7) != 0)
 261                 return NULL;
 262         u = http_client_url_parse(url, &dst, &path);
 263         if (u == NULL)
 264                 return NULL;
 265
 266         if (req == NULL) {
 267                 req_buf = wpabuf_alloc(os_strlen(url) + 1000);
 268                 if (req_buf == NULL) {
 269                         os_free(u);
 270                         return NULL;
 271                 }
 272                 req = req_buf;
 273                 wpabuf_printf(req,
 274                               "GET %s HTTP/1.1\r\n"
 275                               "Cache-Control: no-cache\r\n"
 276                               "Pragma: no-cache\r\n"
 277                               "Accept: text/xml, application/xml\r\n"
 278                               "User-Agent: wpa_supplicant\r\n"
 279                               "Host: %s:%d\r\n"
 280                               "\r\n",
 281                               path, inet_ntoa(dst.sin_addr),
 282                               ntohs(dst.sin_port));
 283         }
 284         os_free(u);
 285
 286         c = http_client_addr(&dst, req, max_response, cb, cb_ctx);
 287         if (c == NULL) {
 288                 wpabuf_free(req_buf);
 289                 return NULL;
 290         }
 291
 292         return c;
 293 }
 294
 295
 296 void http_client_free(struct http_client *c)
 297 {
 298         if (c == NULL)
 299                 return;
 300         httpread_destroy(c->hread);
 301         wpabuf_free(c->req);
 302         if (c->sd >= 0) {
 303                 eloop_unregister_sock(c->sd, EVENT_TYPE_WRITE);
 304                 close(c->sd);
 305         }
 306         eloop_cancel_timeout(http_client_timeout, c, NULL);
 307         os_free(c);
 308 }
 309
 310
 311 struct wpabuf * http_client_get_body(struct http_client *c)
 312 {
 313         if (c->hread == NULL)
 314                 return NULL;
 315         wpabuf_set(&c->body, httpread_data_get(c->hread),
 316                    httpread_length_get(c->hread));
 317         return &c->body;
 318 }
 319
 320
 321 char * http_client_get_hdr_line(struct http_client *c, const char *tag)
 322 {
 323         if (c->hread == NULL)
 324                 return NULL;
 325         return httpread_hdr_line_get(c->hread, tag);
 326 }
 327
 328
 329 char * http_link_update(char *url, const char *base)
 330 {
 331         char *n;
 332         size_t len;
 333         const char *pos;
 334
 335         /* RFC 2396, Chapter 5.2 */
 336         /* TODO: consider adding all cases described in RFC 2396 */
 337
 338         if (url == NULL)
 339                 return NULL;
 340
 341         if (os_strncmp(url, "http://", 7) == 0)
 342                 return url; /* absolute link */
 343
 344         if (os_strncmp(base, "http://", 7) != 0)
 345                 return url; /* unable to handle base URL */
 346
 347         len = os_strlen(url) + 1 + os_strlen(base) + 1;
 348         n = os_malloc(len);
 349         if (n == NULL)
 350                 return url; /* failed */
 351
 352         if (url[0] == '/') {
 353                 pos = os_strchr(base + 7, '/');
 354                 if (pos == NULL) {
 355                         os_snprintf(n, len, "%s%s", base, url);
 356                 } else {
 357                         os_memcpy(n, base, pos - base);
 358                         os_memcpy(n + (pos - base), url, os_strlen(url) + 1);
 359                 }
 360         } else {
 361                 pos = os_strrchr(base + 7, '/');
 362                 if (pos == NULL) {
 363                         os_snprintf(n, len, "%s/%s", base, url);
 364                 } else {
 365                         os_memcpy(n, base, pos - base + 1);
 366                         os_memcpy(n + (pos - base) + 1, url, os_strlen(url) +
 367                                   1);
 368                 }
 369         }
 370
 371         os_free(url);
 372
 373         return n;
 374 }