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_DONE
;
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 int client_parse_header(struct client
*cl
, char *data
)
186 uloop_timeout_cancel(&cl
->timeout
);
187 client_header_complete(cl
);
188 return CLIENT_STATE_DATA
;
191 val
= uh_split_header(data
);
193 return CLIENT_STATE_DONE
;
195 for (name
= data
; *name
; name
++)
197 *name
= tolower(*name
);
199 blobmsg_add_string(&cl
->hdr
, data
, val
);
201 return CLIENT_STATE_HEADER
;
204 static bool client_data_cb(struct client
*cl
, char *buf
, int len
)
209 static bool client_header_cb(struct client
*cl
, char *buf
, int len
)
214 newline
= strstr(buf
, "\r\n");
219 cl
->state
= client_parse_header(cl
, buf
);
220 line_len
= newline
+ 2 - buf
;
221 ustream_consume(cl
->us
, line_len
);
222 if (cl
->state
== CLIENT_STATE_DATA
)
223 client_data_cb(cl
, newline
+ 2, len
- line_len
);
228 typedef bool (*read_cb_t
)(struct client
*cl
, char *buf
, int len
);
229 static read_cb_t read_cbs
[] = {
230 [CLIENT_STATE_INIT
] = client_init_cb
,
231 [CLIENT_STATE_HEADER
] = client_header_cb
,
232 [CLIENT_STATE_DATA
] = client_data_cb
,
235 static void client_read_cb(struct client
*cl
)
237 struct ustream
*us
= cl
->us
;
242 str
= ustream_get_read_buf(us
, &len
);
246 if (cl
->state
>= array_size(read_cbs
) || !read_cbs
[cl
->state
])
249 if (!read_cbs
[cl
->state
](cl
, str
, len
)) {
250 if (len
== us
->r
.buffer_len
)
251 uh_header_error(cl
, 413, "Request Entity Too Large");
257 static void client_close(struct client
*cl
)
259 uh_dispatch_done(cl
);
260 uloop_timeout_cancel(&cl
->timeout
);
261 ustream_free(&cl
->sfd
.stream
);
262 close(cl
->sfd
.fd
.fd
);
264 blob_buf_free(&cl
->hdr
);
267 uh_unblock_listeners();
270 static void client_ustream_read_cb(struct ustream
*s
, int bytes
)
272 struct client
*cl
= container_of(s
, struct client
, sfd
);
277 static void client_ustream_write_cb(struct ustream
*s
, int bytes
)
279 struct client
*cl
= container_of(s
, struct client
, sfd
);
281 if (cl
->dispatch
.write_cb
)
282 cl
->dispatch
.write_cb(cl
);
285 static void client_notify_state(struct ustream
*s
)
287 struct client
*cl
= container_of(s
, struct client
, sfd
);
289 if (cl
->state
== CLIENT_STATE_CLOSE
||
290 (s
->eof
&& !s
->w
.data_bytes
) || s
->write_error
)
291 return client_close(cl
);
294 void uh_accept_client(int fd
)
296 static struct client
*next_client
;
300 static int client_id
= 0;
303 next_client
= calloc(1, sizeof(*next_client
));
307 sl
= sizeof(cl
->peeraddr
);
308 sfd
= accept(fd
, (struct sockaddr
*) &cl
->peeraddr
, &sl
);
312 sl
= sizeof(cl
->servaddr
);
313 getsockname(fd
, (struct sockaddr
*) &cl
->servaddr
, &sl
);
314 cl
->us
= &cl
->sfd
.stream
;
315 cl
->us
->string_data
= true;
316 cl
->us
->notify_read
= client_ustream_read_cb
;
317 cl
->us
->notify_write
= client_ustream_write_cb
;
318 cl
->us
->notify_state
= client_notify_state
;
319 ustream_fd_init(&cl
->sfd
, sfd
);
321 cl
->timeout
.cb
= client_timeout
;
322 uloop_timeout_set(&cl
->timeout
, conf
.network_timeout
* 1000);
324 list_add_tail(&cl
->list
, &clients
);
328 cl
->id
= client_id
++;
331 void uh_close_fds(void)
336 uh_close_listen_fds();
337 list_for_each_entry(cl
, &clients
, list
) {
338 close(cl
->sfd
.fd
.fd
);
339 if (cl
->dispatch
.close_fds
)
340 cl
->dispatch
.close_fds(cl
);