http_server.c revision 051af73b8f8014eff33330aead0f36944b3403e6 
1/*
2 * http_server - HTTP server
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_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
21struct 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
29struct 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
41static 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
61static 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
91void 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
121static 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
132void 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
155void 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
163enum httpread_hdr_type http_request_get_type(struct http_request *req)
164{
165	return httpread_hdr_type_get(req->hread);
166}
167
168
169char * http_request_get_uri(struct http_request *req)
170{
171	return httpread_uri_get(req->hread);
172}
173
174
175char * http_request_get_hdr(struct http_request *req)
176{
177	return httpread_hdr_get(req->hread);
178}
179
180
181char * http_request_get_data(struct http_request *req)
182{
183	return httpread_data_get(req->hread);
184}
185
186
187char * 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
193struct sockaddr_in * http_request_get_cli_addr(struct http_request *req)
194{
195	return &req->cli;
196}
197
198
199static 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
228struct 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	int on = 1;
236
237	srv = os_zalloc(sizeof(*srv));
238	if (srv == NULL)
239		return NULL;
240	srv->cb = cb;
241	srv->cb_ctx = cb_ctx;
242
243	srv->fd = socket(AF_INET, SOCK_STREAM, 0);
244	if (srv->fd < 0)
245		goto fail;
246
247	setsockopt(srv->fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
248
249	if (fcntl(srv->fd, F_SETFL, O_NONBLOCK) < 0)
250		goto fail;
251	if (port < 0)
252		srv->port = 49152;
253	else
254		srv->port = port;
255
256	os_memset(&sin, 0, sizeof(sin));
257	sin.sin_family = AF_INET;
258	sin.sin_addr.s_addr = addr->s_addr;
259
260	for (;;) {
261		sin.sin_port = htons(srv->port);
262		if (bind(srv->fd, (struct sockaddr *) &sin, sizeof(sin)) == 0)
263			break;
264		if (errno == EADDRINUSE) {
265			/* search for unused port */
266			if (++srv->port == 65535 || port >= 0)
267				goto fail;
268			continue;
269		}
270		wpa_printf(MSG_DEBUG, "HTTP: Failed to bind server port %d: "
271			   "%s", srv->port, strerror(errno));
272		goto fail;
273	}
274	if (listen(srv->fd, 10 /* max backlog */) < 0)
275		goto fail;
276	if (fcntl(srv->fd, F_SETFL, O_NONBLOCK) < 0)
277		goto fail;
278	if (eloop_register_sock(srv->fd, EVENT_TYPE_READ, http_server_cb,
279				srv, NULL))
280		goto fail;
281
282	wpa_printf(MSG_DEBUG, "HTTP: Started server on %s:%d",
283		   inet_ntoa(*addr), srv->port);
284
285	return srv;
286
287fail:
288	http_server_deinit(srv);
289	return NULL;
290}
291
292
293void http_server_deinit(struct http_server *srv)
294{
295	if (srv == NULL)
296		return;
297	if (srv->fd >= 0) {
298		eloop_unregister_sock(srv->fd, EVENT_TYPE_READ);
299		close(srv->fd);
300	}
301	http_request_free_all(srv->requests);
302
303	os_free(srv);
304}
305
306
307int http_server_get_port(struct http_server *srv)
308{
309	return srv->port;
310}
311