2 * uhttpd - Tiny single-threaded httpd
4 * Copyright (C) 2010-2012 Jo-Philipp Wich <xm@subsignal.org>
5 * Copyright (C) 2012 Felix Fietkau <nbd@openwrt.org>
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
20 #include <libubox/blobmsg.h>
26 static LIST_HEAD(clients
);
29 struct config conf
= {};
31 const char * const http_versions
[] = {
32 [UH_HTTP_VER_0_9
] = "HTTP/0.9",
33 [UH_HTTP_VER_1_0
] = "HTTP/1.0",
34 [UH_HTTP_VER_1_1
] = "HTTP/1.1",
37 const char * const http_methods
[] = {
38 [UH_HTTP_MSG_GET
] = "GET",
39 [UH_HTTP_MSG_POST
] = "POST",
40 [UH_HTTP_MSG_HEAD
] = "HEAD",
43 void uh_http_header(struct client
*cl
, int code
, const char *summary
)
45 const char *enc
= "Transfer-Encoding: chunked\r\n";
48 if (!uh_use_chunked(cl
))
51 if (cl
->request
.version
!= UH_HTTP_VER_1_1
)
52 conn
= "Connection: close";
54 conn
= "Connection: keep-alive";
56 ustream_printf(cl
->us
, "%s %03i %s\r\n%s\r\n%s",
57 http_versions
[cl
->request
.version
],
58 code
, summary
, conn
, enc
);
61 static void uh_connection_close(struct client
*cl
)
63 cl
->state
= CLIENT_STATE_CLOSE
;
65 ustream_state_change(cl
->us
);
68 static void uh_dispatch_done(struct client
*cl
)
70 if (cl
->dispatch
.free
)
71 cl
->dispatch
.free(cl
);
74 void uh_request_done(struct client
*cl
)
78 cl
->us
->notify_write
= NULL
;
79 memset(&cl
->dispatch
, 0, sizeof(cl
->dispatch
));
81 if (cl
->request
.version
!= UH_HTTP_VER_1_1
|| !conf
.http_keepalive
) {
82 uh_connection_close(cl
);
86 cl
->state
= CLIENT_STATE_INIT
;
87 uloop_timeout_set(&cl
->timeout
, conf
.http_keepalive
* 1000);
91 uh_client_error(struct client
*cl
, int code
, const char *summary
, const char *fmt
, ...)
95 uh_http_header(cl
, code
, summary
);
96 ustream_printf(cl
->us
, "Content-Type: text/html\r\n\r\n");
98 uh_chunk_printf(cl
, "<h1>%s</h1>", summary
);
102 uh_chunk_vprintf(cl
, fmt
, arg
);
109 static void uh_header_error(struct client
*cl
, int code
, const char *summary
)
111 uh_client_error(cl
, code
, summary
, NULL
);
112 uh_connection_close(cl
);
115 static void client_timeout(struct uloop_timeout
*timeout
)
117 struct client
*cl
= container_of(timeout
, struct client
, timeout
);
119 cl
->state
= CLIENT_STATE_CLOSE
;
120 uh_connection_close(cl
);
123 static int find_idx(const char * const *list
, int max
, const char *str
)
127 for (i
= 0; i
< max
; i
++)
128 if (!strcmp(list
[i
], str
))
134 static int client_parse_request(struct client
*cl
, char *data
)
136 struct http_request
*req
= &cl
->request
;
137 char *type
, *path
, *version
;
138 int h_method
, h_version
;
140 type
= strtok(data
, " ");
141 path
= strtok(NULL
, " ");
142 version
= strtok(NULL
, " ");
143 if (!type
|| !path
|| !version
)
144 return CLIENT_STATE_DONE
;
146 blobmsg_add_string(&cl
->hdr
, "URL", path
);
148 memset(&cl
->request
, 0, sizeof(cl
->request
));
149 h_method
= find_idx(http_methods
, ARRAY_SIZE(http_methods
), type
);
150 h_version
= find_idx(http_versions
, ARRAY_SIZE(http_versions
), version
);
151 if (h_method
< 0 || h_version
< 0) {
152 req
->version
= UH_HTTP_VER_1_0
;
153 return CLIENT_STATE_DONE
;
156 req
->method
= h_method
;
157 req
->version
= h_version
;
159 return CLIENT_STATE_HEADER
;
162 static bool client_init_cb(struct client
*cl
, char *buf
, int len
)
166 newline
= strstr(buf
, "\r\n");
171 blob_buf_init(&cl
->hdr
, 0);
172 cl
->state
= client_parse_request(cl
, buf
);
173 ustream_consume(cl
->us
, newline
+ 2 - buf
);
174 if (cl
->state
== CLIENT_STATE_DONE
)
175 uh_header_error(cl
, 400, "Bad Request");
180 static bool rfc1918_filter_check(struct client
*cl
)
182 if (!conf
.rfc1918_filter
)
185 if (!uh_addr_rfc1918(&cl
->peer_addr
) || uh_addr_rfc1918(&cl
->srv_addr
))
188 uh_client_error(cl
, 403, "Forbidden",
189 "Rejected request from RFC1918 IP "
190 "to public server address");
194 static void client_header_complete(struct client
*cl
)
196 if (!rfc1918_filter_check(cl
))
199 if (cl
->request
.expect_cont
)
200 ustream_printf(cl
->us
, "HTTP/1.1 100 Continue\r\n\r\n");
202 uh_handle_request(cl
);
205 static void client_parse_header(struct client
*cl
, char *data
)
207 struct http_request
*r
= &cl
->request
;
213 uloop_timeout_cancel(&cl
->timeout
);
214 cl
->state
= CLIENT_STATE_DATA
;
215 client_header_complete(cl
);
219 val
= uh_split_header(data
);
221 cl
->state
= CLIENT_STATE_DONE
;
225 for (name
= data
; *name
; name
++)
227 *name
= tolower(*name
);
229 if (!strcmp(data
, "expect")) {
230 if (!strcasecmp(val
, "100-continue"))
231 r
->expect_cont
= true;
233 uh_header_error(cl
, 412, "Precondition Failed");
236 } else if (!strcmp(data
, "content-length")) {
237 r
->content_length
= strtoul(val
, &err
, 0);
239 uh_header_error(cl
, 400, "Bad Request");
242 } else if (!strcmp(data
, "transfer-encoding")) {
243 if (!strcmp(val
, "chunked"))
244 r
->transfer_chunked
= true;
248 blobmsg_add_string(&cl
->hdr
, data
, val
);
250 cl
->state
= CLIENT_STATE_HEADER
;
253 void client_poll_post_data(struct client
*cl
)
255 struct dispatch
*d
= &cl
->dispatch
;
256 struct http_request
*r
= &cl
->request
;
260 if (cl
->state
== CLIENT_STATE_DONE
)
268 buf
= ustream_get_read_buf(cl
->us
, &len
);
275 cur_len
= min(r
->content_length
, len
);
281 cur_len
= d
->data_send(cl
, buf
, cur_len
);
283 r
->content_length
-= cur_len
;
284 ustream_consume(cl
->us
, cur_len
);
288 if (!r
->transfer_chunked
)
291 if (r
->transfer_chunked
> 1)
294 sep
= strstr(buf
+ offset
, "\r\n");
300 r
->content_length
= strtoul(buf
+ offset
, &sep
, 16);
301 r
->transfer_chunked
++;
302 ustream_consume(cl
->us
, sep
+ 2 - buf
);
304 /* invalid chunk length */
306 r
->content_length
= 0;
307 r
->transfer_chunked
= 0;
311 /* empty chunk == eof */
312 if (!r
->content_length
) {
313 r
->transfer_chunked
= false;
318 buf
= ustream_get_read_buf(cl
->us
, &len
);
319 if (!r
->content_length
&& !r
->transfer_chunked
&&
320 cl
->state
!= CLIENT_STATE_DONE
) {
321 if (cl
->dispatch
.data_done
)
322 cl
->dispatch
.data_done(cl
);
324 cl
->state
= CLIENT_STATE_DONE
;
328 static bool client_data_cb(struct client
*cl
, char *buf
, int len
)
330 client_poll_post_data(cl
);
334 static bool client_header_cb(struct client
*cl
, char *buf
, int len
)
339 newline
= strstr(buf
, "\r\n");
344 client_parse_header(cl
, buf
);
345 line_len
= newline
+ 2 - buf
;
346 ustream_consume(cl
->us
, line_len
);
347 if (cl
->state
== CLIENT_STATE_DATA
)
348 return client_data_cb(cl
, newline
+ 2, len
- line_len
);
353 typedef bool (*read_cb_t
)(struct client
*cl
, char *buf
, int len
);
354 static read_cb_t read_cbs
[] = {
355 [CLIENT_STATE_INIT
] = client_init_cb
,
356 [CLIENT_STATE_HEADER
] = client_header_cb
,
357 [CLIENT_STATE_DATA
] = client_data_cb
,
360 void uh_client_read_cb(struct client
*cl
)
362 struct ustream
*us
= cl
->us
;
367 str
= ustream_get_read_buf(us
, &len
);
371 if (cl
->state
>= array_size(read_cbs
) || !read_cbs
[cl
->state
])
374 if (!read_cbs
[cl
->state
](cl
, str
, len
)) {
375 if (len
== us
->r
.buffer_len
&&
376 cl
->state
!= CLIENT_STATE_DATA
)
377 uh_header_error(cl
, 413, "Request Entity Too Large");
383 static void client_close(struct client
*cl
)
386 uh_dispatch_done(cl
);
387 uloop_timeout_cancel(&cl
->timeout
);
389 uh_tls_client_detach(cl
);
390 ustream_free(&cl
->sfd
.stream
);
391 close(cl
->sfd
.fd
.fd
);
393 blob_buf_free(&cl
->hdr
);
396 uh_unblock_listeners();
399 void uh_client_notify_state(struct client
*cl
)
401 struct ustream
*s
= cl
->us
;
403 if (!s
->write_error
) {
404 if (cl
->state
== CLIENT_STATE_DATA
)
407 if (!s
->eof
|| s
->w
.data_bytes
)
411 return client_close(cl
);
414 static void client_ustream_read_cb(struct ustream
*s
, int bytes
)
416 struct client
*cl
= container_of(s
, struct client
, sfd
);
418 uh_client_read_cb(cl
);
421 static void client_ustream_write_cb(struct ustream
*s
, int bytes
)
423 struct client
*cl
= container_of(s
, struct client
, sfd
);
425 if (cl
->dispatch
.write_cb
)
426 cl
->dispatch
.write_cb(cl
);
429 static void client_notify_state(struct ustream
*s
)
431 struct client
*cl
= container_of(s
, struct client
, sfd
);
433 uh_client_notify_state(cl
);
436 static void set_addr(struct uh_addr
*addr
, void *src
)
438 struct sockaddr_in
*sin
= src
;
439 struct sockaddr_in6
*sin6
= src
;
441 addr
->family
= sin
->sin_family
;
442 if (addr
->family
== AF_INET
) {
443 addr
->port
= ntohs(sin
->sin_port
);
444 memcpy(&addr
->in
, &sin
->sin_addr
, sizeof(addr
->in
));
446 addr
->port
= ntohs(sin6
->sin6_port
);
447 memcpy(&addr
->in6
, &sin6
->sin6_addr
, sizeof(addr
->in6
));
451 bool uh_accept_client(int fd
, bool tls
)
453 static struct client
*next_client
;
457 static int client_id
= 0;
458 struct sockaddr_in6 addr
;
461 next_client
= calloc(1, sizeof(*next_client
));
466 sfd
= accept(fd
, (struct sockaddr
*) &addr
, &sl
);
470 set_addr(&cl
->peer_addr
, &addr
);
472 getsockname(sfd
, (struct sockaddr
*) &addr
, &sl
);
473 set_addr(&cl
->srv_addr
, &addr
);
475 cl
->us
= &cl
->sfd
.stream
;
477 uh_tls_client_attach(cl
);
479 cl
->us
->notify_read
= client_ustream_read_cb
;
480 cl
->us
->notify_write
= client_ustream_write_cb
;
481 cl
->us
->notify_state
= client_notify_state
;
484 cl
->us
->string_data
= true;
485 ustream_fd_init(&cl
->sfd
, sfd
);
487 cl
->timeout
.cb
= client_timeout
;
488 uloop_timeout_set(&cl
->timeout
, conf
.network_timeout
* 1000);
490 list_add_tail(&cl
->list
, &clients
);
494 cl
->id
= client_id
++;
499 void uh_close_fds(void)
504 uh_close_listen_fds();
505 list_for_each_entry(cl
, &clients
, list
) {
506 close(cl
->sfd
.fd
.fd
);
507 if (cl
->dispatch
.close_fds
)
508 cl
->dispatch
.close_fds(cl
);