Home | History | Annotate | Download | only in wps
      1 /*
      2  * http_server - HTTP server
      3  * Copyright (c) 2009, Jouni Malinen <j (at) 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_server.h"
     16 
     17 #define HTTP_SERVER_TIMEOUT 30
     18 #define HTTP_SERVER_MAX_REQ_LEN 8000
     19 #define HTTP_SERVER_MAX_CONNECTIONS 10
     20 
     21 struct http_request {
     22 	struct http_request *next;
     23 	struct http_server *srv;
     24 	int fd;
     25 	struct sockaddr_in cli;
     26 	struct httpread *hread;
     27 };
     28 
     29 struct http_server {
     30 	void (*cb)(void *ctx, struct http_request *req);
     31 	void *cb_ctx;
     32 
     33 	int fd;
     34 	int port;
     35 
     36 	struct http_request *requests;
     37 	unsigned int request_count;
     38 };
     39 
     40 
     41 static void http_request_cb(struct httpread *handle, void *cookie,
     42 			    enum httpread_event en)
     43 {
     44 	struct http_request *req = cookie;
     45 	struct http_server *srv = req->srv;
     46 
     47 	if (en == HTTPREAD_EVENT_FILE_READY) {
     48 		wpa_printf(MSG_DEBUG, "HTTP: Request from %s:%d received",
     49 			   inet_ntoa(req->cli.sin_addr),
     50 			   ntohs(req->cli.sin_port));
     51 		srv->cb(srv->cb_ctx, req);
     52 		return;
     53 	}
     54 	wpa_printf(MSG_DEBUG, "HTTP: Request from %s:%d could not be received "
     55 		   "completely", inet_ntoa(req->cli.sin_addr),
     56 		   ntohs(req->cli.sin_port));
     57 	http_request_deinit(req);
     58 }
     59 
     60 
     61 static struct http_request * http_request_init(struct http_server *srv, int fd,
     62 					       struct sockaddr_in *cli)
     63 {
     64 	struct http_request *req;
     65 
     66 	if (srv->request_count >= HTTP_SERVER_MAX_CONNECTIONS) {
     67 		wpa_printf(MSG_DEBUG, "HTTP: Too many concurrent requests");
     68 		return NULL;
     69 	}
     70 
     71 	req = os_zalloc(sizeof(*req));
     72 	if (req == NULL)
     73 		return NULL;
     74 
     75 	req->srv = srv;
     76 	req->fd = fd;
     77 	req->cli = *cli;
     78 
     79 	req->hread = httpread_create(req->fd, http_request_cb, req,
     80 				     HTTP_SERVER_MAX_REQ_LEN,
     81 				     HTTP_SERVER_TIMEOUT);
     82 	if (req->hread == NULL) {
     83 		http_request_deinit(req);
     84 		return NULL;
     85 	}
     86 
     87 	return req;
     88 }
     89 
     90 
     91 void http_request_deinit(struct http_request *req)
     92 {
     93 	struct http_request *r, *p;
     94 	struct http_server *srv;
     95 
     96 	if (req == NULL)
     97 		return;
     98 
     99 	srv = req->srv;
    100 	p = NULL;
    101 	r = srv->requests;
    102 	while (r) {
    103 		if (r == req) {
    104 			if (p)
    105 				p->next = r->next;
    106 			else
    107 				srv->requests = r->next;
    108 			srv->request_count--;
    109 			break;
    110 		}
    111 		p = r;
    112 		r = r->next;
    113 	}
    114 
    115 	httpread_destroy(req->hread);
    116 	close(req->fd);
    117 	os_free(req);
    118 }
    119 
    120 
    121 static void http_request_free_all(struct http_request *req)
    122 {
    123 	struct http_request *prev;
    124 	while (req) {
    125 		prev = req;
    126 		req = req->next;
    127 		http_request_deinit(prev);
    128 	}
    129 }
    130 
    131 
    132 void http_request_send(struct http_request *req, struct wpabuf *resp)
    133 {
    134 	int res;
    135 
    136 	wpa_printf(MSG_DEBUG, "HTTP: Send %lu byte response to %s:%d",
    137 		   (unsigned long) wpabuf_len(resp),
    138 		   inet_ntoa(req->cli.sin_addr),
    139 		   ntohs(req->cli.sin_port));
    140 
    141 	res = send(req->fd, wpabuf_head(resp), wpabuf_len(resp), 0);
    142 	if (res < 0) {
    143 		wpa_printf(MSG_DEBUG, "HTTP: Send failed: %s",
    144 			   strerror(errno));
    145 	} else if ((size_t) res < wpabuf_len(resp)) {
    146 		wpa_printf(MSG_DEBUG, "HTTP: Sent only %d of %lu bytes",
    147 			   res, (unsigned long) wpabuf_len(resp));
    148 		/* TODO: add eloop handler for sending rest of the data */
    149 	}
    150 
    151 	wpabuf_free(resp);
    152 }
    153 
    154 
    155 void http_request_send_and_deinit(struct http_request *req,
    156 				  struct wpabuf *resp)
    157 {
    158 	http_request_send(req, resp);
    159 	http_request_deinit(req);
    160 }
    161 
    162 
    163 enum httpread_hdr_type http_request_get_type(struct http_request *req)
    164 {
    165 	return httpread_hdr_type_get(req->hread);
    166 }
    167 
    168 
    169 char * http_request_get_uri(struct http_request *req)
    170 {
    171 	return httpread_uri_get(req->hread);
    172 }
    173 
    174 
    175 char * http_request_get_hdr(struct http_request *req)
    176 {
    177 	return httpread_hdr_get(req->hread);
    178 }
    179 
    180 
    181 char * http_request_get_data(struct http_request *req)
    182 {
    183 	return httpread_data_get(req->hread);
    184 }
    185 
    186 
    187 char * http_request_get_hdr_line(struct http_request *req, const char *tag)
    188 {
    189 	return httpread_hdr_line_get(req->hread, tag);
    190 }
    191 
    192 
    193 struct sockaddr_in * http_request_get_cli_addr(struct http_request *req)
    194 {
    195 	return &req->cli;
    196 }
    197 
    198 
    199 static void http_server_cb(int sd, void *eloop_ctx, void *sock_ctx)
    200 {
    201 	struct sockaddr_in addr;
    202 	socklen_t addr_len = sizeof(addr);
    203 	struct http_server *srv = eloop_ctx;
    204 	int conn;
    205 	struct http_request *req;
    206 
    207 	conn = accept(srv->fd, (struct sockaddr *) &addr, &addr_len);
    208 	if (conn < 0) {
    209 		wpa_printf(MSG_DEBUG, "HTTP: Failed to accept new connection: "
    210 			   "%s", strerror(errno));
    211 		return;
    212 	}
    213 	wpa_printf(MSG_DEBUG, "HTTP: Connection from %s:%d",
    214 		   inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
    215 
    216 	req = http_request_init(srv, conn, &addr);
    217 	if (req == NULL) {
    218 		close(conn);
    219 		return;
    220 	}
    221 
    222 	req->next = srv->requests;
    223 	srv->requests = req;
    224 	srv->request_count++;
    225 }
    226 
    227 
    228 struct http_server * http_server_init(struct in_addr *addr, int port,
    229 				      void (*cb)(void *ctx,
    230 						 struct http_request *req),
    231 				      void *cb_ctx)
    232 {
    233 	struct sockaddr_in sin;
    234 	struct http_server *srv;
    235 
    236 	srv = os_zalloc(sizeof(*srv));
    237 	if (srv == NULL)
    238 		return NULL;
    239 	srv->cb = cb;
    240 	srv->cb_ctx = cb_ctx;
    241 
    242 	srv->fd = socket(AF_INET, SOCK_STREAM, 0);
    243 	if (srv->fd < 0)
    244 		goto fail;
    245 	if (fcntl(srv->fd, F_SETFL, O_NONBLOCK) < 0)
    246 		goto fail;
    247 	if (port < 0)
    248 		srv->port = 49152;
    249 	else
    250 		srv->port = port;
    251 
    252 	os_memset(&sin, 0, sizeof(sin));
    253 	sin.sin_family = AF_INET;
    254 	sin.sin_addr.s_addr = addr->s_addr;
    255 
    256 	for (;;) {
    257 		sin.sin_port = htons(srv->port);
    258 		if (bind(srv->fd, (struct sockaddr *) &sin, sizeof(sin)) == 0)
    259 			break;
    260 		if (errno == EADDRINUSE) {
    261 			/* search for unused port */
    262 			if (++srv->port == 65535 || port >= 0)
    263 				goto fail;
    264 			continue;
    265 		}
    266 		wpa_printf(MSG_DEBUG, "HTTP: Failed to bind server port %d: "
    267 			   "%s", srv->port, strerror(errno));
    268 		goto fail;
    269 	}
    270 	if (listen(srv->fd, 10 /* max backlog */) < 0)
    271 		goto fail;
    272 	if (fcntl(srv->fd, F_SETFL, O_NONBLOCK) < 0)
    273 		goto fail;
    274 	if (eloop_register_sock(srv->fd, EVENT_TYPE_READ, http_server_cb,
    275 				srv, NULL))
    276 		goto fail;
    277 
    278 	wpa_printf(MSG_DEBUG, "HTTP: Started server on %s:%d",
    279 		   inet_ntoa(*addr), srv->port);
    280 
    281 	return srv;
    282 
    283 fail:
    284 	http_server_deinit(srv);
    285 	return NULL;
    286 }
    287 
    288 
    289 void http_server_deinit(struct http_server *srv)
    290 {
    291 	if (srv == NULL)
    292 		return;
    293 	if (srv->fd >= 0) {
    294 		eloop_unregister_sock(srv->fd, EVENT_TYPE_READ);
    295 		close(srv->fd);
    296 	}
    297 	http_request_free_all(srv->requests);
    298 
    299 	os_free(srv);
    300 }
    301 
    302 
    303 int http_server_get_port(struct http_server *srv)
    304 {
    305 	return srv->port;
    306 }
    307