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>
25 static LIST_HEAD(clients
);
28 struct config conf
= {};
30 const char * const http_versions
[] = {
31 [UH_HTTP_VER_0_9
] = "HTTP/0.9",
32 [UH_HTTP_VER_1_0
] = "HTTP/1.0",
33 [UH_HTTP_VER_1_1
] = "HTTP/1.1",
36 const char * const http_methods
[] = {
37 [UH_HTTP_MSG_GET
] = "GET",
38 [UH_HTTP_MSG_POST
] = "POST",
39 [UH_HTTP_MSG_HEAD
] = "HEAD",
42 void uh_http_header(struct client
*cl
, int code
, const char *summary
)
44 const char *enc
= "Transfer-Encoding: chunked\r\n";
47 if (!uh_use_chunked(cl
))
50 if (cl
->request
.version
!= UH_HTTP_VER_1_1
)
51 conn
= "Connection: close";
53 conn
= "Connection: keep-alive";
55 ustream_printf(cl
->us
, "%s %03i %s\r\n%s\r\n%s",
56 http_versions
[cl
->request
.version
],
57 code
, summary
, conn
, enc
);
60 static void uh_connection_close(struct client
*cl
)
62 cl
->state
= CLIENT_STATE_CLOSE
;
64 ustream_state_change(cl
->us
);
67 static void uh_dispatch_done(struct client
*cl
)
69 if (cl
->dispatch
.free
)
70 cl
->dispatch
.free(cl
);
73 void uh_request_done(struct client
*cl
)
77 cl
->us
->notify_write
= NULL
;
78 memset(&cl
->dispatch
, 0, sizeof(cl
->dispatch
));
80 if (cl
->request
.version
!= UH_HTTP_VER_1_1
|| !conf
.http_keepalive
) {
81 uh_connection_close(cl
);
85 cl
->state
= CLIENT_STATE_INIT
;
86 uloop_timeout_set(&cl
->timeout
, conf
.http_keepalive
* 1000);
90 uh_client_error(struct client
*cl
, int code
, const char *summary
, const char *fmt
, ...)
94 uh_http_header(cl
, code
, summary
);
95 ustream_printf(cl
->us
, "Content-Type: text/html\r\n\r\n");
97 uh_chunk_printf(cl
, "<h1>%s</h1>", summary
);
101 uh_chunk_vprintf(cl
, fmt
, arg
);
108 static void uh_header_error(struct client
*cl
, int code
, const char *summary
)
110 uh_client_error(cl
, code
, summary
, NULL
);
111 uh_connection_close(cl
);
114 static void client_timeout(struct uloop_timeout
*timeout
)
116 struct client
*cl
= container_of(timeout
, struct client
, timeout
);
118 cl
->state
= CLIENT_STATE_CLOSE
;
119 uh_connection_close(cl
);
122 static int find_idx(const char * const *list
, int max
, const char *str
)
126 for (i
= 0; i
< max
; i
++)
127 if (!strcmp(list
[i
], str
))
133 static int client_parse_request(struct client
*cl
, char *data
)
135 struct http_request
*req
= &cl
->request
;
136 char *type
, *path
, *version
;
138 type
= strtok(data
, " ");
139 path
= strtok(NULL
, " ");
140 version
= strtok(NULL
, " ");
141 if (!type
|| !path
|| !version
)
142 return CLIENT_STATE_DONE
;
145 req
->method
= find_idx(http_methods
, ARRAY_SIZE(http_methods
), type
);
147 return CLIENT_STATE_DONE
;
149 req
->version
= find_idx(http_versions
, ARRAY_SIZE(http_versions
), version
);
150 if (cl
->request
.version
< 0)
151 return CLIENT_STATE_DONE
;
153 return CLIENT_STATE_HEADER
;
156 static bool client_init_cb(struct client
*cl
, char *buf
, int len
)
160 newline
= strstr(buf
, "\r\n");
165 blob_buf_init(&cl
->hdr
, 0);
166 blobmsg_add_string(&cl
->hdr
, "REQUEST", buf
);
167 ustream_consume(cl
->us
, newline
+ 2 - buf
);
168 cl
->state
= client_parse_request(cl
, (char *) blobmsg_data(blob_data(cl
->hdr
.head
)));
169 if (cl
->state
== CLIENT_STATE_DONE
)
170 uh_header_error(cl
, 400, "Bad Request");
175 static void client_header_complete(struct client
*cl
)
177 uh_handle_request(cl
);
180 static void client_parse_header(struct client
*cl
, char *data
)
186 uloop_timeout_cancel(&cl
->timeout
);
187 cl
->state
= CLIENT_STATE_DATA
;
188 client_header_complete(cl
);
192 val
= uh_split_header(data
);
194 cl
->state
= CLIENT_STATE_DONE
;
198 for (name
= data
; *name
; name
++)
200 *name
= tolower(*name
);
202 blobmsg_add_string(&cl
->hdr
, data
, val
);
204 cl
->state
= CLIENT_STATE_HEADER
;
207 static bool client_data_cb(struct client
*cl
, char *buf
, int len
)
212 static bool client_header_cb(struct client
*cl
, char *buf
, int len
)
217 newline
= strstr(buf
, "\r\n");
222 client_parse_header(cl
, buf
);
223 line_len
= newline
+ 2 - buf
;
224 ustream_consume(cl
->us
, line_len
);
225 if (cl
->state
== CLIENT_STATE_DATA
)
226 client_data_cb(cl
, newline
+ 2, len
- line_len
);
231 typedef bool (*read_cb_t
)(struct client
*cl
, char *buf
, int len
);
232 static read_cb_t read_cbs
[] = {
233 [CLIENT_STATE_INIT
] = client_init_cb
,
234 [CLIENT_STATE_HEADER
] = client_header_cb
,
235 [CLIENT_STATE_DATA
] = client_data_cb
,
238 static void client_read_cb(struct client
*cl
)
240 struct ustream
*us
= cl
->us
;
245 str
= ustream_get_read_buf(us
, &len
);
249 if (cl
->state
>= array_size(read_cbs
) || !read_cbs
[cl
->state
])
252 if (!read_cbs
[cl
->state
](cl
, str
, len
)) {
253 if (len
== us
->r
.buffer_len
)
254 uh_header_error(cl
, 413, "Request Entity Too Large");
260 static void client_close(struct client
*cl
)
262 uh_dispatch_done(cl
);
263 uloop_timeout_cancel(&cl
->timeout
);
264 ustream_free(&cl
->sfd
.stream
);
265 close(cl
->sfd
.fd
.fd
);
267 blob_buf_free(&cl
->hdr
);
270 uh_unblock_listeners();
273 static void client_ustream_read_cb(struct ustream
*s
, int bytes
)
275 struct client
*cl
= container_of(s
, struct client
, sfd
);
280 static void client_ustream_write_cb(struct ustream
*s
, int bytes
)
282 struct client
*cl
= container_of(s
, struct client
, sfd
);
284 if (cl
->dispatch
.write_cb
)
285 cl
->dispatch
.write_cb(cl
);
288 static void client_notify_state(struct ustream
*s
)
290 struct client
*cl
= container_of(s
, struct client
, sfd
);
292 if (!s
->write_error
) {
293 if (cl
->state
== CLIENT_STATE_DATA
)
296 if (!s
->eof
|| s
->w
.data_bytes
)
300 return client_close(cl
);
303 static void set_addr(struct uh_addr
*addr
, void *src
)
305 struct sockaddr_in
*sin
= src
;
306 struct sockaddr_in6
*sin6
= src
;
308 addr
->family
= sin
->sin_family
;
309 if (addr
->family
== AF_INET
) {
310 addr
->port
= ntohs(sin
->sin_port
);
311 memcpy(&addr
->in
, &sin
->sin_addr
, sizeof(addr
->in
));
313 addr
->port
= ntohs(sin6
->sin6_port
);
314 memcpy(&addr
->in6
, &sin6
->sin6_addr
, sizeof(addr
->in6
));
318 void uh_accept_client(int fd
)
320 static struct client
*next_client
;
324 static int client_id
= 0;
325 struct sockaddr_in6 addr
;
328 next_client
= calloc(1, sizeof(*next_client
));
333 sfd
= accept(fd
, (struct sockaddr
*) &addr
, &sl
);
337 set_addr(&cl
->peer_addr
, &addr
);
339 getsockname(fd
, (struct sockaddr
*) &addr
, &sl
);
340 set_addr(&cl
->srv_addr
, &addr
);
341 cl
->us
= &cl
->sfd
.stream
;
342 cl
->us
->string_data
= true;
343 cl
->us
->notify_read
= client_ustream_read_cb
;
344 cl
->us
->notify_write
= client_ustream_write_cb
;
345 cl
->us
->notify_state
= client_notify_state
;
346 ustream_fd_init(&cl
->sfd
, sfd
);
348 cl
->timeout
.cb
= client_timeout
;
349 uloop_timeout_set(&cl
->timeout
, conf
.network_timeout
* 1000);
351 list_add_tail(&cl
->list
, &clients
);
355 cl
->id
= client_id
++;
358 void uh_close_fds(void)
363 uh_close_listen_fds();
364 list_for_each_entry(cl
, &clients
, list
) {
365 close(cl
->sfd
.fd
.fd
);
366 if (cl
->dispatch
.close_fds
)
367 cl
->dispatch
.close_fds(cl
);