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