mimetypes: add json and jsonp (distinct from js)
[project/uhttpd.git] / uhttpd.h
1 /*
2  * uhttpd - Tiny single-threaded httpd
3  *
4  *   Copyright (C) 2010-2013 Jo-Philipp Wich <xm@subsignal.org>
5  *   Copyright (C) 2013 Felix Fietkau <nbd@openwrt.org>
6  *
7  * Permission to use, copy, modify, and/or distribute this software for any
8  * purpose with or without fee is hereby granted, provided that the above
9  * copyright notice and this permission notice appear in all copies.
10  *
11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18  */
19
20 #ifndef __UHTTPD_H
21 #define __UHTTPD_H
22
23 #include <netinet/in.h>
24 #include <limits.h>
25 #include <dirent.h>
26
27 #include <libubox/list.h>
28 #include <libubox/uloop.h>
29 #include <libubox/ustream.h>
30 #include <libubox/blob.h>
31 #include <libubox/utils.h>
32 #ifdef HAVE_UBUS
33 #include <libubus.h>
34 #include <json/json.h>
35 #endif
36 #ifdef HAVE_TLS
37 #include <libubox/ustream-ssl.h>
38 #endif
39
40 #include "utils.h"
41
42 #define UH_LIMIT_CLIENTS        64
43
44 #define __enum_header(_name, _val) HDR_##_name,
45 #define __blobmsg_header(_name, _val) [HDR_##_name] = { .name = #_val, .type = BLOBMSG_TYPE_STRING },
46
47 struct client;
48
49 struct config {
50         const char *docroot;
51         const char *realm;
52         const char *file;
53         const char *error_handler;
54         const char *cgi_prefix;
55         const char *cgi_docroot_path;
56         const char *cgi_path;
57         const char *lua_handler;
58         const char *lua_prefix;
59         const char *ubus_prefix;
60         const char *ubus_socket;
61         int no_symlinks;
62         int no_dirlists;
63         int network_timeout;
64         int rfc1918_filter;
65         int tcp_keepalive;
66         int max_script_requests;
67         int max_connections;
68         int http_keepalive;
69         int script_timeout;
70         int ubus_noauth;
71         int ubus_cors;
72 };
73
74 struct auth_realm {
75         struct list_head list;
76         const char *path;
77         const char *user;
78         const char *pass;
79 };
80
81 enum http_method {
82         UH_HTTP_MSG_GET,
83         UH_HTTP_MSG_POST,
84         UH_HTTP_MSG_HEAD,
85         UH_HTTP_MSG_OPTIONS,
86 };
87
88 enum http_version {
89         UH_HTTP_VER_0_9,
90         UH_HTTP_VER_1_0,
91         UH_HTTP_VER_1_1,
92 };
93
94 enum http_user_agent {
95         UH_UA_UNKNOWN,
96         UH_UA_GECKO,
97         UH_UA_CHROME,
98         UH_UA_SAFARI,
99         UH_UA_MSIE,
100         UH_UA_KONQUEROR,
101         UH_UA_OPERA,
102         UH_UA_MSIE_OLD,
103         UH_UA_MSIE_NEW,
104 };
105
106 struct http_request {
107         enum http_method method;
108         enum http_version version;
109         enum http_user_agent ua;
110         int redirect_status;
111         int content_length;
112         bool expect_cont;
113         bool connection_close;
114         uint8_t transfer_chunked;
115         const struct auth_realm *realm;
116 };
117
118 enum client_state {
119         CLIENT_STATE_INIT,
120         CLIENT_STATE_HEADER,
121         CLIENT_STATE_DATA,
122         CLIENT_STATE_DONE,
123         CLIENT_STATE_CLOSE,
124         CLIENT_STATE_CLEANUP,
125 };
126
127 struct interpreter {
128         struct list_head list;
129         const char *path;
130         const char *ext;
131 };
132
133 struct path_info {
134         const char *root;
135         const char *phys;
136         const char *name;
137         const char *info;
138         const char *query;
139         const char *auth;
140         bool redirected;
141         struct stat stat;
142         const struct interpreter *ip;
143 };
144
145 struct env_var {
146         const char *name;
147         const char *value;
148 };
149
150 struct relay {
151         struct ustream_fd sfd;
152         struct uloop_process proc;
153         struct uloop_timeout timeout;
154         struct client *cl;
155
156         bool process_done;
157         bool error;
158         bool skip_data;
159
160         int ret;
161         int header_ofs;
162
163         void (*header_cb)(struct relay *r, const char *name, const char *value);
164         void (*header_end)(struct relay *r);
165         void (*close)(struct relay *r, int ret);
166 };
167
168 struct dispatch_proc {
169         struct uloop_timeout timeout;
170         struct blob_buf hdr;
171         struct uloop_fd wrfd;
172         struct relay r;
173         int status_code;
174         char *status_msg;
175 };
176
177 struct dispatch_handler {
178         struct list_head list;
179         bool script;
180
181         bool (*check_url)(const char *url);
182         bool (*check_path)(struct path_info *pi, const char *url);
183         void (*handle_request)(struct client *cl, char *url, struct path_info *pi);
184 };
185
186 #ifdef HAVE_UBUS
187 struct dispatch_ubus {
188         struct ubus_request req;
189
190         struct uloop_timeout timeout;
191         struct json_tokener *jstok;
192         struct json_object *jsobj;
193         struct json_object *jsobj_cur;
194         int post_len;
195
196         uint32_t obj;
197         const char *func;
198
199         struct blob_buf buf;
200         bool req_pending;
201         bool array;
202         int array_idx;
203 };
204 #endif
205
206 struct dispatch {
207         int (*data_send)(struct client *cl, const char *data, int len);
208         void (*data_done)(struct client *cl);
209         void (*write_cb)(struct client *cl);
210         void (*close_fds)(struct client *cl);
211         void (*free)(struct client *cl);
212
213         void *req_data;
214         void (*req_free)(struct client *cl);
215
216         bool data_blocked;
217
218         union {
219                 struct {
220                         struct blob_attr **hdr;
221                         int fd;
222                 } file;
223                 struct dispatch_proc proc;
224 #ifdef HAVE_UBUS
225                 struct dispatch_ubus ubus;
226 #endif
227         };
228 };
229
230 struct client {
231         struct list_head list;
232         int refcount;
233         int id;
234
235         struct ustream *us;
236         struct ustream_fd sfd;
237 #ifdef HAVE_TLS
238         struct ustream_ssl ssl;
239 #endif
240         struct uloop_timeout timeout;
241         int requests;
242
243         enum client_state state;
244         bool tls;
245
246         int http_code;
247         struct http_request request;
248         struct uh_addr srv_addr, peer_addr;
249
250         struct blob_buf hdr;
251         struct dispatch dispatch;
252 };
253
254 extern char uh_buf[4096];
255 extern int n_clients;
256 extern struct config conf;
257 extern const char * const http_versions[];
258 extern const char * const http_methods[];
259 extern struct dispatch_handler cgi_dispatch;
260
261 void uh_index_add(const char *filename);
262
263 bool uh_accept_client(int fd, bool tls);
264
265 void uh_unblock_listeners(void);
266 void uh_setup_listeners(void);
267 int uh_socket_bind(const char *host, const char *port, bool tls);
268
269 bool uh_use_chunked(struct client *cl);
270 void uh_chunk_write(struct client *cl, const void *data, int len);
271 void uh_chunk_vprintf(struct client *cl, const char *format, va_list arg);
272
273 void __printf(2, 3)
274 uh_chunk_printf(struct client *cl, const char *format, ...);
275
276 void uh_chunk_eof(struct client *cl);
277 void uh_request_done(struct client *cl);
278
279 void uh_http_header(struct client *cl, int code, const char *summary);
280 void __printf(4, 5)
281 uh_client_error(struct client *cl, int code, const char *summary, const char *fmt, ...);
282
283 void uh_handle_request(struct client *cl);
284 void client_poll_post_data(struct client *cl);
285 void uh_client_read_cb(struct client *cl);
286 void uh_client_notify_state(struct client *cl);
287
288 void uh_auth_add(const char *path, const char *user, const char *pass);
289 bool uh_auth_check(struct client *cl, struct path_info *pi);
290
291 void uh_close_listen_fds(void);
292 void uh_close_fds(void);
293
294 void uh_interpreter_add(const char *ext, const char *path);
295 void uh_dispatch_add(struct dispatch_handler *d);
296
297 void uh_relay_open(struct client *cl, struct relay *r, int fd, int pid);
298 void uh_relay_close(struct relay *r, int ret);
299 void uh_relay_free(struct relay *r);
300 void uh_relay_kill(struct client *cl, struct relay *r);
301
302 struct env_var *uh_get_process_vars(struct client *cl, struct path_info *pi);
303 bool uh_create_process(struct client *cl, struct path_info *pi, char *url,
304                        void (*cb)(struct client *cl, struct path_info *pi, char *url));
305
306 int uh_plugin_init(const char *name);
307 void uh_plugin_post_init(void);
308
309 static inline void uh_client_ref(struct client *cl)
310 {
311         cl->refcount++;
312 }
313
314 static inline void uh_client_unref(struct client *cl)
315 {
316         if (--cl->refcount)
317                 return;
318
319         if (cl->state == CLIENT_STATE_CLEANUP)
320                 ustream_state_change(cl->us);
321 }
322
323 #endif