[thirdparty/hostap.git] / src / wps / http_server.c

/*
 * http_server - HTTP server
 * Copyright (c) 2009, Jouni Malinen <j@w1.fi>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Alternatively, this software may be distributed under the terms of BSD
 * license.
 *
 * See README and COPYING for more details.
 */

#include "includes.h"
#include <fcntl.h>

#include "common.h"
#include "eloop.h"
#include "httpread.h"
#include "http_server.h"

#define HTTP_SERVER_TIMEOUT 30
#define HTTP_SERVER_MAX_REQ_LEN 8000
#define HTTP_SERVER_MAX_CONNECTIONS 10

struct http_request {
	struct http_request *next;
	struct http_server *srv;
	int fd;
	struct sockaddr_in cli;
	struct httpread *hread;
};

struct http_server {
	void (*cb)(void *ctx, struct http_request *req);
	void *cb_ctx;

	int fd;
	int port;

	struct http_request *requests;
	unsigned int request_count;
};


static void http_request_cb(struct httpread *handle, void *cookie,
			    enum httpread_event en)
{
	struct http_request *req = cookie;
	struct http_server *srv = req->srv;

	if (en == HTTPREAD_EVENT_FILE_READY) {
		wpa_printf(MSG_DEBUG, "HTTP: Request from %s:%d received",
			   inet_ntoa(req->cli.sin_addr),
			   ntohs(req->cli.sin_port));
		srv->cb(srv->cb_ctx, req);
		return;
	}
	wpa_printf(MSG_DEBUG, "HTTP: Request from %s:%d could not be received "
		   "completely", inet_ntoa(req->cli.sin_addr),
		   ntohs(req->cli.sin_port));
	http_request_deinit(req);
}


static struct http_request * http_request_init(struct http_server *srv, int fd,
					       struct sockaddr_in *cli)
{
	struct http_request *req;

	if (srv->request_count >= HTTP_SERVER_MAX_CONNECTIONS) {
		wpa_printf(MSG_DEBUG, "HTTP: Too many concurrent requests");
		return NULL;
	}

	req = os_zalloc(sizeof(*req));
	if (req == NULL)
		return NULL;

	req->srv = srv;
	req->fd = fd;
	req->cli = *cli;

	req->hread = httpread_create(req->fd, http_request_cb, req,
				     HTTP_SERVER_MAX_REQ_LEN,
				     HTTP_SERVER_TIMEOUT);
	if (req->hread == NULL) {
		http_request_deinit(req);
		return NULL;
	}

	return req;
}


void http_request_deinit(struct http_request *req)
{
	struct http_request *r, *p;
	struct http_server *srv;

	if (req == NULL)
		return;

	srv = req->srv;
	p = NULL;
	r = srv->requests;
	while (r) {
		if (r == req) {
			if (p)
				p->next = r->next;
			else
				srv->requests = r->next;
			srv->request_count--;
			break;
		}
		p = r;
		r = r->next;
	}

	httpread_destroy(req->hread);
	close(req->fd);
	os_free(req);
}


static void http_request_free_all(struct http_request *req)
{
	struct http_request *prev;
	while (req) {
		prev = req;
		req = req->next;
		http_request_deinit(prev);
	}
}


void http_request_send(struct http_request *req, struct wpabuf *resp)
{
	int res;

	wpa_printf(MSG_DEBUG, "HTTP: Send %lu byte response to %s:%d",
		   (unsigned long) wpabuf_len(resp),
		   inet_ntoa(req->cli.sin_addr),
		   ntohs(req->cli.sin_port));

	res = send(req->fd, wpabuf_head(resp), wpabuf_len(resp), 0);
	if (res < 0) {
		wpa_printf(MSG_DEBUG, "HTTP: Send failed: %s",
			   strerror(errno));
	} else if ((size_t) res < wpabuf_len(resp)) {
		wpa_printf(MSG_DEBUG, "HTTP: Sent only %d of %lu bytes",
			   res, (unsigned long) wpabuf_len(resp));
		/* TODO: add eloop handler for sending rest of the data */
	}

	wpabuf_free(resp);
}


void http_request_send_and_deinit(struct http_request *req,
				  struct wpabuf *resp)
{
	http_request_send(req, resp);
	http_request_deinit(req);
}


enum httpread_hdr_type http_request_get_type(struct http_request *req)
{
	return httpread_hdr_type_get(req->hread);
}


char * http_request_get_uri(struct http_request *req)
{
	return httpread_uri_get(req->hread);
}


char * http_request_get_hdr(struct http_request *req)
{
	return httpread_hdr_get(req->hread);
}


char * http_request_get_data(struct http_request *req)
{
	return httpread_data_get(req->hread);
}


char * http_request_get_hdr_line(struct http_request *req, const char *tag)
{
	return httpread_hdr_line_get(req->hread, tag);
}


struct sockaddr_in * http_request_get_cli_addr(struct http_request *req)
{
	return &req->cli;
}


static void http_server_cb(int sd, void *eloop_ctx, void *sock_ctx)
{
	struct sockaddr_in addr;
	socklen_t addr_len = sizeof(addr);
	struct http_server *srv = eloop_ctx;
	int conn;
	struct http_request *req;

	conn = accept(srv->fd, (struct sockaddr *) &addr, &addr_len);
	if (conn < 0) {
		wpa_printf(MSG_DEBUG, "HTTP: Failed to accept new connection: "
			   "%s", strerror(errno));
		return;
	}
	wpa_printf(MSG_DEBUG, "HTTP: Connection from %s:%d",
		   inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));

	req = http_request_init(srv, conn, &addr);
	if (req == NULL) {
		close(conn);
		return;
	}

	req->next = srv->requests;
	srv->requests = req;
	srv->request_count++;
}


struct http_server * http_server_init(struct in_addr *addr, int port,
				      void (*cb)(void *ctx,
						 struct http_request *req),
				      void *cb_ctx)
{
	struct sockaddr_in sin;
	struct http_server *srv;

	srv = os_zalloc(sizeof(*srv));
	if (srv == NULL)
		return NULL;
	srv->cb = cb;
	srv->cb_ctx = cb_ctx;

	srv->fd = socket(AF_INET, SOCK_STREAM, 0);
	if (srv->fd < 0)
		goto fail;
	if (fcntl(srv->fd, F_SETFL, O_NONBLOCK) < 0)
		goto fail;
	if (port < 0)
		srv->port = 49152;
	else
		srv->port = port;

	os_memset(&sin, 0, sizeof(sin));
	sin.sin_family = AF_INET;
	sin.sin_addr.s_addr = addr->s_addr;

	for (;;) {
		sin.sin_port = htons(srv->port);
		if (bind(srv->fd, (struct sockaddr *) &sin, sizeof(sin)) == 0)
			break;
		if (errno == EADDRINUSE) {
			/* search for unused port */
			if (++srv->port == 65535 || port >= 0)
				goto fail;
			continue;
		}
		wpa_printf(MSG_DEBUG, "HTTP: Failed to bind server port %d: "
			   "%s", srv->port, strerror(errno));
		goto fail;
	}
	if (listen(srv->fd, 10 /* max backlog */) < 0)
		goto fail;
	if (fcntl(srv->fd, F_SETFL, O_NONBLOCK) < 0)
		goto fail;
	if (eloop_register_sock(srv->fd, EVENT_TYPE_READ, http_server_cb,
				srv, NULL))
		goto fail;

	wpa_printf(MSG_DEBUG, "HTTP: Started server on %s:%d",
		   inet_ntoa(*addr), srv->port);

	return srv;

fail:
	http_server_deinit(srv);
	return NULL;
}


void http_server_deinit(struct http_server *srv)
{
	if (srv == NULL)
		return;
	if (srv->fd >= 0) {
		eloop_unregister_sock(srv->fd, EVENT_TYPE_READ);
		close(srv->fd);
	}
	http_request_free_all(srv->requests);

	os_free(srv);
}


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