source: trunk/third-party/shttpd/defs.h @ 6349

Last change on this file since 6349 was 6349, checked in by charles, 13 years ago

(third-party) upgrade shttpd from 1.39 to the latest, 1.41

File size: 11.2 KB
Line 
1/*
2 * Copyright (c) 2004-2005 Sergey Lyubka <valenok@gmail.com>
3 * All rights reserved
4 *
5 * "THE BEER-WARE LICENSE" (Revision 42):
6 * Sergey Lyubka wrote this file.  As long as you retain this notice you
7 * can do whatever you want with this stuff. If we meet some day, and you think
8 * this stuff is worth it, you can buy me a beer in return.
9 */
10
11#ifndef DEFS_HEADER_DEFINED
12#define DEFS_HEADER_DEFINED
13
14#include "std_includes.h"
15#include "llist.h"
16#include "io.h"
17#include "md5.h"
18#include "config.h"
19#include "shttpd.h"
20
21#define NELEMS(ar)      (sizeof(ar) / sizeof(ar[0]))
22
23#ifdef _DEBUG
24#define DBG(x)  do { printf x ; putchar('\n'); fflush(stdout); } while (0)
25#else
26#define DBG(x)
27#endif /* DEBUG */
28
29/*
30 * Darwin prior to 7.0 and Win32 do not have socklen_t
31 */
32#ifdef NO_SOCKLEN_T
33typedef int socklen_t;
34#endif /* NO_SOCKLEN_T */
35
36/*
37 * For parsing. This guy represents a substring.
38 */
39struct vec {
40        const char      *ptr;
41        int             len;
42};
43
44#if !defined(FALSE)
45enum {FALSE, TRUE};
46#endif /* !FALSE */
47
48enum {METHOD_GET, METHOD_POST, METHOD_PUT, METHOD_DELETE, METHOD_HEAD};
49enum {HDR_DATE, HDR_INT, HDR_STRING};   /* HTTP header types            */
50enum {E_FATAL = 1, E_LOG = 2};          /* Flags for elog() function    */
51typedef unsigned long big_int_t;        /* Type for Content-Length      */
52       
53/*
54 * Unified socket address
55 */
56struct usa {
57        socklen_t len;
58        union {
59                struct sockaddr sa;
60                struct sockaddr_in sin;
61        } u;
62};
63
64/*
65 * This thing is aimed to hold values of any type.
66 * Used to store parsed headers' values.
67 */
68union variant {
69        char            *v_str;
70        int             v_int;
71        big_int_t       v_big_int;
72        time_t          v_time;
73        void            (*v_func)(void);
74        void            *v_void;
75        struct vec      v_vec;
76};
77
78/*
79 * This is used only in embedded configuration. This structure holds a
80 * registered URI, associated callback function with callback data.
81 * For non-embedded compilation shttpd_callback_t is not defined, so
82 * we use union variant to keep the compiler silent.
83 */
84struct registered_uri {
85        struct llhead   link;
86        const char      *uri;
87        union variant   callback;
88        void            *callback_data;
89};
90
91/*
92 * User may want to handle certain errors. This structure holds the
93 * handlers for corresponding error codes.
94 */
95struct error_handler {
96        struct llhead   link;
97        int             code;
98        union variant   callback;
99        void            *callback_data;
100};
101
102struct http_header {
103        int             len;            /* Header name length           */
104        int             type;           /* Header type                  */
105        size_t          offset;         /* Value placeholder            */
106        const char      *name;          /* Header name                  */
107};
108
109/*
110 * This guy holds parsed HTTP headers
111 */
112struct headers {
113        union variant   cl;             /* Content-Length:              */
114        union variant   ct;             /* Content-Type:                */
115        union variant   connection;     /* Connection:                  */
116        union variant   ims;            /* If-Modified-Since:           */
117        union variant   user;           /* Remote user name             */
118        union variant   auth;           /* Authorization                */
119        union variant   useragent;      /* User-Agent:                  */
120        union variant   referer;        /* Referer:                     */
121        union variant   cookie;         /* Cookie:                      */
122        union variant   location;       /* Location:                    */
123        union variant   range;          /* Range:                       */
124        union variant   status;         /* Status:                      */
125        union variant   transenc;       /* Transfer-Encoding:           */
126};
127
128/* Must go after union variant definition */
129#include "ssl.h"
130
131/*
132 * The communication channel
133 */
134union channel {
135        int             fd;             /* Regular static file          */
136        int             sock;           /* Connected socket             */
137        struct {
138                int             sock;   /* XXX important. must be first */
139                SSL             *ssl;   /* shttpd_poll() assumes that   */
140        } ssl;                          /* SSL-ed socket                */
141        struct {
142                DIR     *dirp;
143                char    *path;
144        } dir;                          /* Opened directory             */
145        struct {
146                void            *state; /* For keeping state            */
147                union variant   func;   /* User callback function       */
148                void            *data;  /* User defined parameters      */
149        } emb;                          /* Embedded, user callback      */
150};
151
152struct stream;
153
154/*
155 * IO class descriptor (file, directory, socket, SSL, CGI, etc)
156 * These classes are defined in io_*.c files.
157 */
158struct io_class {
159        const char *name;
160        int (*read)(struct stream *, void *buf, size_t len);
161        int (*write)(struct stream *, const void *buf, size_t len);
162        void (*close)(struct stream *);
163};
164
165/*
166 * Data exchange stream. It is backed by some communication channel:
167 * opened file, socket, etc. The 'read' and 'write' methods are
168 * determined by a communication channel.
169 */
170struct stream {
171        struct conn             *conn;
172        union channel           chan;           /* Descriptor           */
173        struct io               io;             /* IO buffer            */
174        const struct io_class   *io_class;      /* IO class             */
175        int                     headers_len;
176        big_int_t               content_len;
177        unsigned int            flags;
178#define FLAG_HEADERS_PARSED     1
179#define FLAG_SSL_ACCEPTED       2
180#define FLAG_R                  4               /* Can read in general  */
181#define FLAG_W                  8               /* Can write in general */
182#define FLAG_CLOSED             16
183#define FLAG_DONT_CLOSE         32
184#define FLAG_ALWAYS_READY       64              /* File, dir, user_func */
185#define FLAG_SUSPEND            128
186};
187
188struct worker {
189        struct llhead   link;
190        int             num_conns;      /* Num of active connections    */
191        int             exit_flag;      /* Ditto - exit flag            */
192        int             ctl[2];         /* Control socket pair          */
193        struct shttpd_ctx *ctx;         /* Context reference            */
194        struct llhead   connections;    /* List of connections          */
195};
196
197struct conn {
198        struct llhead   link;           /* Connections chain            */
199        struct worker   *worker;        /* Worker this conn belongs to  */
200        struct shttpd_ctx *ctx;         /* Context this conn belongs to */
201        struct usa      sa;             /* Remote socket address        */
202        time_t          birth_time;     /* Creation time                */
203        time_t          expire_time;    /* Expiration time              */
204
205        int             loc_port;       /* Local port                   */
206        int             status;         /* Reply status code            */
207        int             method;         /* Request method               */
208        char            *uri;           /* Decoded URI                  */
209        unsigned long   major_version;  /* Major HTTP version number    */
210        unsigned long   minor_version;  /* Minor HTTP version number    */
211        char            *request;       /* Request line                 */
212        char            *headers;       /* Request headers              */
213        char            *query;         /* QUERY_STRING part of the URI */
214        char            *path_info;     /* PATH_INFO thing              */
215        struct vec      mime_type;      /* Mime type                    */
216
217        struct headers  ch;             /* Parsed client headers        */
218
219        struct stream   loc;            /* Local stream                 */
220        struct stream   rem;            /* Remote stream                */
221
222#if !defined(NO_SSI)
223        void                    *ssi;   /* SSI descriptor               */
224#endif /* NO_SSI */
225};
226
227enum {
228        OPT_ROOT, OPT_INDEX_FILES, OPT_PORTS, OPT_DIR_LIST,
229        OPT_CGI_EXTENSIONS, OPT_CGI_INTERPRETER, OPT_CGI_ENVIRONMENT,
230        OPT_SSI_EXTENSIONS, OPT_AUTH_REALM, OPT_AUTH_GPASSWD,
231        OPT_AUTH_PUT, OPT_ACCESS_LOG, OPT_ERROR_LOG, OPT_MIME_TYPES,
232        OPT_SSL_CERTIFICATE, OPT_ALIASES, OPT_ACL, OPT_INETD, OPT_UID,
233        OPT_CFG_URI, OPT_PROTECT, OPT_SERVICE, OPT_HIDE, OPT_THREADS,
234        NUM_OPTIONS
235};
236
237/*
238 * SHTTPD context
239 */
240struct shttpd_ctx {
241        SSL_CTX         *ssl_ctx;       /* SSL context                  */
242
243        struct llhead   registered_uris;/* User urls                    */
244        struct llhead   error_handlers; /* Embedded error handlers      */
245        struct llhead   acl;            /* Access control list          */
246        struct llhead   ssi_funcs;      /* SSI callback functions       */
247        struct llhead   listeners;      /* Listening sockets            */
248        struct llhead   workers;        /* Worker workers               */
249
250        FILE            *access_log;    /* Access log stream            */
251        FILE            *error_log;     /* Error log stream             */
252
253        char    *options[NUM_OPTIONS];  /* Configurable options         */
254#if defined(__rtems__)
255        rtems_id         mutex;
256#endif /* _WIN32 */
257};
258
259struct listener {
260        struct llhead           link;
261        struct shttpd_ctx       *ctx;   /* Context that socket belongs  */
262        int                     sock;   /* Listening socket             */
263        int                     is_ssl; /* Should be SSL-ed             */
264};
265
266/* Types of messages that could be sent over the control socket */
267enum {CTL_PASS_SOCKET, CTL_WAKEUP};
268
269/*
270 * In SHTTPD, list of values are represented as comma or space separated
271 * string. For example, list of CGI extensions can be represented as
272 * ".cgi,.php,.pl", or ".cgi .php .pl". The macro that follows allows to
273 * loop through the individual values in that list.
274 *
275 * A "const char *" pointer and size_t variable must be passed to the macro.
276 * Spaces or commas can be used as delimiters (macro DELIM_CHARS).
277 *
278 * In every iteration of the loop, "s" points to the current value, and
279 * "len" specifies its length. The code inside loop must not change
280 * "s" and "len" parameters.
281 */
282#define FOR_EACH_WORD_IN_LIST(s,len)                                    \
283        for (; s != NULL && (len = strcspn(s, DELIM_CHARS)) != 0;       \
284                        s += len, s+= strspn(s, DELIM_CHARS))
285
286/*
287 * IPv4 ACL entry. Specifies subnet with deny/allow flag
288 */
289struct acl {
290        struct llhead   link;
291        uint32_t        ip;             /* IP, in network byte order    */
292        uint32_t        mask;           /* Also in network byte order   */
293        int             flag;           /* Either '+' or '-'            */
294};
295
296/*
297 * shttpd.c
298 */
299extern time_t           current_time;   /* Current UTC time             */
300extern int              tz_offset;      /* Offset from GMT time zone    */
301extern const struct vec known_http_methods[];
302
303extern void     stop_stream(struct stream *stream);
304extern int      url_decode(const char *, int, char *dst, int);
305extern void     send_server_error(struct conn *, int code, const char *reason);
306extern int      get_headers_len(const char *buf, size_t buflen);
307extern void     parse_headers(const char *s, int len, struct headers *parsed);
308extern int      is_true(const char *str);
309extern int      shttpd_socketpair(int pair[2]);
310extern void get_mime_type(struct shttpd_ctx *, const char *, int, struct vec *);
311
312#define IS_TRUE(ctx, opt)       is_true((ctx)->options[opt])
313
314/*
315 * config.c
316 */
317extern void     usage(const char *prog);
318
319/*
320 * log.c
321 */
322extern void     elog(int flags, struct conn *c, const char *fmt, ...);
323extern void     log_access(FILE *fp, const struct conn *c);
324
325/*
326 * string.c
327 */
328extern void     my_strlcpy(register char *, register const char *, size_t);
329extern int      my_strncasecmp(register const char *,
330                register const char *, size_t);
331extern char     *my_strndup(const char *ptr, size_t len);
332extern char     *my_strdup(const char *str);
333extern int      my_snprintf(char *buf, size_t buflen, const char *fmt, ...);
334extern int      match_extension(const char *path, const char *ext_list);
335
336/*
337 * compat_*.c
338 */
339extern void     set_close_on_exec(int fd);
340extern int      set_non_blocking_mode(int fd);
341extern int      my_stat(const char *, struct stat *stp);
342extern int      my_open(const char *, int flags, int mode);
343extern int      my_remove(const char *);
344extern int      my_rename(const char *, const char *);
345extern int      my_mkdir(const char *, int);
346extern char *   my_getcwd(char *, int);
347extern int      spawn_process(struct conn *c, const char *prog,
348                char *envblk, char *envp[], int sock, const char *dir);
349
350extern void     set_nt_service(struct shttpd_ctx *, const char *);
351extern void     set_systray(struct shttpd_ctx *, const char *);
352extern void     try_to_run_as_nt_service(void);
353
354/*
355 * io_*.c
356 */
357extern const struct io_class    io_file;
358extern const struct io_class    io_socket;
359extern const struct io_class    io_ssl;
360extern const struct io_class    io_cgi;
361extern const struct io_class    io_dir;
362extern const struct io_class    io_embedded;
363extern const struct io_class    io_ssi;
364
365extern int      put_dir(const char *path);
366extern void     get_dir(struct conn *c);
367extern void     get_file(struct conn *c, struct stat *stp);
368extern void     ssl_handshake(struct stream *stream);
369extern void     setup_embedded_stream(struct conn *, union variant, void *);
370extern struct registered_uri *is_registered_uri(struct shttpd_ctx *,
371                const char *uri);
372extern void     do_ssi(struct conn *);
373extern void     ssi_func_destructor(struct llhead *lp);
374
375/*
376 * auth.c
377 */
378extern int      check_authorization(struct conn *c, const char *path);
379extern int      is_authorized_for_put(struct conn *c);
380extern void     send_authorization_request(struct conn *c);
381extern int      edit_passwords(const char *fname, const char *domain,
382                const char *user, const char *pass);
383
384/*
385 * cgi.c
386 */
387extern int      run_cgi(struct conn *c, const char *prog);
388extern void     do_cgi(struct conn *c);
389
390#define CGI_REPLY       "HTTP/1.1     OK\r\n"
391#define CGI_REPLY_LEN   (sizeof(CGI_REPLY) - 1)
392
393#endif /* DEFS_HEADER_DEFINED */
Note: See TracBrowser for help on using the repository browser.