| /* |
| * Copyright (c) 2004-2005 Sergey Lyubka <valenok@gmail.com> |
| * All rights reserved |
| * |
| * "THE BEER-WARE LICENSE" (Revision 42): |
| * Sergey Lyubka wrote this file. As long as you retain this notice you |
| * can do whatever you want with this stuff. If we meet some day, and you think |
| * this stuff is worth it, you can buy me a beer in return. |
| */ |
| |
| #ifndef DEFS_HEADER_DEFINED |
| #define DEFS_HEADER_DEFINED |
| |
| #include "wsman_config.h" |
| |
| #include "std_includes.h" |
| #include "llist.h" |
| #include "io.h" |
| #include "md5.h" |
| #include "u/libu.h" |
| #include "config.h" |
| #include "shttpd.h" |
| |
| #define NELEMS(ar) (sizeof(ar) / sizeof(ar[0])) |
| |
| #ifdef _DEBUG |
| #define DBG(x) do { printf x ; putchar('\n'); fflush(stdout); } while (0) |
| #else |
| #define DBG(x) |
| #endif /* DEBUG */ |
| |
| /* |
| * Darwin prior to 7.0 and Win32 do not have socklen_t |
| */ |
| #ifdef NO_SOCKLEN_T |
| typedef int socklen_t; |
| #endif /* NO_SOCKLEN_T */ |
| |
| /* |
| * For parsing. This guy represents a substring. |
| */ |
| struct vec { |
| const char *ptr; |
| int len; |
| }; |
| |
| #if !defined(FALSE) |
| enum {FALSE, TRUE}; |
| #endif /* !FALSE */ |
| |
| enum {BASIC_AUTH, DIGEST_AUTH}; |
| enum {METHOD_GET, METHOD_POST, METHOD_PUT, METHOD_DELETE, METHOD_HEAD}; |
| enum {HDR_DATE, HDR_INT, HDR_STRING}; /* HTTP header types */ |
| enum {E_FATAL = 1, E_LOG = 2}; /* Flags for elog() function */ |
| typedef unsigned long big_int_t; /* Type for Content-Length */ |
| |
| /* |
| * Unified socket address |
| */ |
| struct usa { |
| socklen_t len; |
| union { |
| struct sockaddr sa; |
| struct sockaddr_in sin; |
| } u; |
| }; |
| |
| /* |
| * This thing is aimed to hold values of any type. |
| * Used to store parsed headers' values. |
| */ |
| union variant { |
| char *v_str; |
| int v_int; |
| big_int_t v_big_int; |
| time_t v_time; |
| void (*v_func)(void); |
| void *v_void; |
| struct vec v_vec; |
| }; |
| |
| /* |
| * This is used only in embedded configuration. This structure holds a |
| * registered URI, associated callback function with callback data. |
| * For non-embedded compilation shttpd_callback_t is not defined, so |
| * we use union variant to keep the compiler silent. |
| */ |
| struct registered_uri { |
| struct llhead link; |
| const char *uri; |
| union variant callback; |
| void *callback_data; |
| }; |
| |
| struct uri_auth { |
| struct llhead link; |
| const char *uri; |
| const char *file_name; |
| int type; |
| size_t uri_len; |
| union variant callback; |
| void *callback_data; |
| }; |
| |
| /* |
| * User may want to handle certain errors. This structure holds the |
| * handlers for corresponding error codes. |
| */ |
| struct error_handler { |
| struct llhead link; |
| int code; |
| union variant callback; |
| void *callback_data; |
| }; |
| |
| struct http_header { |
| int len; /* Header name length */ |
| int type; /* Header type */ |
| size_t offset; /* Value placeholder */ |
| const char *name; /* Header name */ |
| }; |
| |
| /* |
| * This guy holds parsed HTTP headers |
| */ |
| struct headers { |
| union variant cl; /* Content-Length: */ |
| union variant ct; /* Content-Type: */ |
| union variant connection; /* Connection: */ |
| union variant ims; /* If-Modified-Since: */ |
| union variant user; /* Remote user name */ |
| union variant auth; /* Authorization */ |
| union variant useragent; /* User-Agent: */ |
| union variant referer; /* Referer: */ |
| union variant cookie; /* Cookie: */ |
| union variant location; /* Location: */ |
| union variant range; /* Range: */ |
| union variant status; /* Status: */ |
| union variant transenc; /* Transfer-Encoding: */ |
| }; |
| |
| /* Must go after union variant definition */ |
| #include "ssl.h" |
| |
| /* |
| * The communication channel |
| */ |
| union channel { |
| int fd; /* Regular static file */ |
| int sock; /* Connected socket */ |
| struct { |
| int sock; /* XXX important. must be first */ |
| SSL *ssl; /* shttpd_poll() assumes that */ |
| } ssl; /* SSL-ed socket */ |
| struct { |
| DIR *dirp; |
| char *path; |
| } dir; /* Opened directory */ |
| struct { |
| void *state; /* For keeping state */ |
| union variant func; /* User callback function */ |
| void *data; /* User defined parameters */ |
| } emb; /* Embedded, user callback */ |
| }; |
| |
| struct stream; |
| |
| /* |
| * IO class descriptor (file, directory, socket, SSL, CGI, etc) |
| * These classes are defined in io_*.c files. |
| */ |
| struct io_class { |
| const char *name; |
| int (*read)(struct stream *, void *buf, size_t len); |
| int (*write)(struct stream *, const void *buf, size_t len); |
| void (*close)(struct stream *); |
| }; |
| |
| /* |
| * Data exchange stream. It is backed by some communication channel: |
| * opened file, socket, etc. The 'read' and 'write' methods are |
| * determined by a communication channel. |
| */ |
| struct stream { |
| struct conn *conn; |
| union channel chan; /* Descriptor */ |
| struct io io; /* IO buffer */ |
| const struct io_class *io_class; /* IO class */ |
| int headers_len; |
| big_int_t content_len; |
| unsigned int flags; |
| #define FLAG_HEADERS_PARSED 1 |
| #define FLAG_SSL_ACCEPTED 2 |
| #define FLAG_R 4 /* Can read in general */ |
| #define FLAG_W 8 /* Can write in general */ |
| #define FLAG_CLOSED 16 |
| #define FLAG_DONT_CLOSE 32 |
| #define FLAG_ALWAYS_READY 64 /* File, dir, user_func */ |
| #define FLAG_SUSPEND 128 |
| }; |
| |
| struct worker { |
| struct llhead link; |
| int num_conns; /* Num of active connections */ |
| int exit_flag; /* Ditto - exit flag */ |
| int ctl[2]; /* Control socket pair */ |
| struct shttpd_ctx *ctx; /* Context reference */ |
| struct llhead connections; /* List of connections */ |
| }; |
| |
| struct conn { |
| struct llhead link; /* Connections chain */ |
| struct worker *worker; /* Worker this conn belongs to */ |
| struct shttpd_ctx *ctx; /* Context this conn belongs to */ |
| struct usa sa; /* Remote socket address */ |
| time_t birth_time; /* Creation time */ |
| time_t expire_time; /* Expiration time */ |
| |
| int loc_port; /* Local port */ |
| int status; /* Reply status code */ |
| int method; /* Request method */ |
| char *uri; /* Decoded URI */ |
| unsigned long major_version; /* Major HTTP version number */ |
| unsigned long minor_version; /* Minor HTTP version number */ |
| char *request; /* Request line */ |
| char *headers; /* Request headers */ |
| char *query; /* QUERY_STRING part of the URI */ |
| char *path_info; /* PATH_INFO thing */ |
| struct vec mime_type; /* Mime type */ |
| |
| struct headers ch; /* Parsed client headers */ |
| |
| struct stream loc; /* Local stream */ |
| struct stream rem; /* Remote stream */ |
| |
| #if !defined(NO_SSI) |
| void *ssi; /* SSI descriptor */ |
| #endif /* NO_SSI */ |
| }; |
| |
| enum { |
| OPT_ROOT, OPT_INDEX_FILES, OPT_PORTS, OPT_DIR_LIST, |
| OPT_CGI_EXTENSIONS, OPT_CGI_INTERPRETER, OPT_CGI_ENVIRONMENT, |
| OPT_SSI_EXTENSIONS, OPT_AUTH_REALM, OPT_AUTH_GPASSWD, |
| OPT_AUTH_PUT, OPT_ACCESS_LOG, OPT_ERROR_LOG, OPT_MIME_TYPES, |
| OPT_SSL_CERTIFICATE, OPT_ALIASES, OPT_ACL, OPT_INETD, OPT_UID, |
| OPT_CFG_URI, OPT_PROTECT, OPT_SERVICE, OPT_HIDE, OPT_THREADS, |
| NUM_OPTIONS |
| }; |
| |
| /* |
| * SHTTPD context |
| */ |
| struct shttpd_ctx { |
| SSL_CTX *ssl_ctx; /* SSL context */ |
| |
| struct llhead registered_uris;/* User urls */ |
| struct llhead uri_auths; /* User auth files */ |
| struct llhead error_handlers; /* Embedded error handlers */ |
| struct llhead acl; /* Access control list */ |
| struct llhead ssi_funcs; /* SSI callback functions */ |
| struct llhead listeners; /* Listening sockets */ |
| struct llhead workers; /* Worker workers */ |
| |
| FILE *access_log; /* Access log stream */ |
| FILE *error_log; /* Error log stream */ |
| |
| char *options[NUM_OPTIONS]; /* Configurable options */ |
| #if defined(__rtems__) |
| rtems_id mutex; |
| #endif /* _WIN32 */ |
| }; |
| |
| struct listener { |
| struct llhead link; |
| struct shttpd_ctx *ctx; /* Context that socket belongs */ |
| int sock; /* Listening socket */ |
| int is_ssl; /* Should be SSL-ed */ |
| }; |
| |
| /* Types of messages that could be sent over the control socket */ |
| enum {CTL_PASS_SOCKET, CTL_WAKEUP}; |
| |
| /* |
| * In SHTTPD, list of values are represented as comma or space separated |
| * string. For example, list of CGI extensions can be represented as |
| * ".cgi,.php,.pl", or ".cgi .php .pl". The macro that follows allows to |
| * loop through the individual values in that list. |
| * |
| * A "const char *" pointer and size_t variable must be passed to the macro. |
| * Spaces or commas can be used as delimiters (macro DELIM_CHARS). |
| * |
| * In every iteration of the loop, "s" points to the current value, and |
| * "len" specifies its length. The code inside loop must not change |
| * "s" and "len" parameters. |
| */ |
| #define FOR_EACH_WORD_IN_LIST(s,len) \ |
| for (; s != NULL && (len = strcspn(s, DELIM_CHARS)) != 0; \ |
| s += len, s+= strspn(s, DELIM_CHARS)) |
| |
| /* |
| * IPv4 ACL entry. Specifies subnet with deny/allow flag |
| */ |
| struct acl { |
| struct llhead link; |
| uint32_t ip; /* IP, in network byte order */ |
| uint32_t mask; /* Also in network byte order */ |
| int flag; /* Either '+' or '-' */ |
| }; |
| |
| /* |
| * shttpd.c |
| */ |
| extern time_t _shttpd_current_time; /* Current UTC time */ |
| extern int _shttpd_tz_offset; /* Offset from GMT time zone */ |
| extern const struct vec _shttpd_known_http_methods[]; |
| |
| extern void _shttpd_stop_stream(struct stream *stream); |
| extern int _shttpd_url_decode(const char *, int, char *dst, int); |
| extern void _shttpd_send_server_error(struct conn *, int, const char *); |
| extern int _shttpd_get_headers_len(const char *buf, size_t buflen); |
| extern void _shttpd_parse_headers(const char *s, int, struct headers *); |
| extern int _shttpd_is_true(const char *str); |
| extern int _shttpd_socketpair(int pair[2]); |
| extern void _shttpd_get_mime_type(struct shttpd_ctx *, |
| const char *, int, struct vec *); |
| |
| #define IS_TRUE(ctx, opt) _shttpd_is_true((ctx)->options[opt]) |
| |
| /* |
| * config.c |
| */ |
| extern void _shttpd_usage(const char *prog); |
| |
| /* |
| * log.c |
| */ |
| extern void _shttpd_elog(int flags, struct conn *c, const char *fmt, ...); |
| extern void _shttpd_log_access(FILE *fp, const struct conn *c); |
| |
| /* |
| * string.c |
| */ |
| extern void _shttpd_strlcpy(register char *, register const char *, size_t); |
| extern int _shttpd_strncasecmp(register const char *, |
| register const char *, size_t); |
| extern char *_shttpd_strndup(const char *ptr, size_t len); |
| extern char *_shttpd_strdup(const char *str); |
| extern int _shttpd_snprintf(char *buf, size_t len, const char *fmt, ...); |
| extern int _shttpd_match_extension(const char *path, const char *ext_list); |
| |
| /* |
| * compat_*.c |
| */ |
| extern void _shttpd_set_close_on_exec(int fd); |
| extern int _shttpd_set_non_blocking_mode(int fd); |
| extern int _shttpd_stat(const char *, struct stat *stp); |
| extern int _shttpd_open(const char *, int flags, int mode); |
| extern int _shttpd_remove(const char *); |
| extern int _shttpd_rename(const char *, const char *); |
| extern int _shttpd_mkdir(const char *, int); |
| extern char * _shttpd_getcwd(char *, int); |
| extern int _shttpd_spawn_process(struct conn *c, const char *prog, |
| char *envblk, char *envp[], int sock, const char *dir); |
| |
| extern int _shttpd_set_nt_service(struct shttpd_ctx *, const char *); |
| extern int _shttpd_set_systray(struct shttpd_ctx *, const char *); |
| extern void _shttpd_try_to_run_as_nt_service(void); |
| |
| /* |
| * io_*.c |
| */ |
| extern const struct io_class _shttpd_io_file; |
| extern const struct io_class _shttpd_io_socket; |
| extern const struct io_class _shttpd_io_ssl; |
| extern const struct io_class _shttpd_io_cgi; |
| extern const struct io_class _shttpd_io_dir; |
| extern const struct io_class _shttpd_io_embedded; |
| extern const struct io_class _shttpd_io_ssi; |
| |
| extern int _shttpd_put_dir(const char *path); |
| extern void _shttpd_get_dir(struct conn *c); |
| extern void _shttpd_get_file(struct conn *c, struct stat *stp); |
| extern void _shttpd_ssl_handshake(struct stream *stream); |
| extern void _shttpd_setup_embedded_stream(struct conn *, |
| union variant, void *); |
| extern struct registered_uri *_shttpd_is_registered_uri(struct shttpd_ctx *, |
| const char *uri); |
| extern void _shttpd_do_ssi(struct conn *); |
| extern void _shttpd_ssi_func_destructor(struct llhead *lp); |
| |
| /* |
| * auth.c |
| */ |
| extern int _shttpd_check_authorization(struct conn *c, const char *path); |
| extern int _shttpd_is_authorized_for_put(struct conn *c); |
| extern void _shttpd_send_authorization_request(struct conn *c); |
| extern int _shttpd_edit_passwords(const char *fname, const char *domain, |
| const char *user, const char *pass); |
| |
| /* |
| * cgi.c |
| */ |
| extern int _shttpd_run_cgi(struct conn *c, const char *prog); |
| extern void _shttpd_do_cgi(struct conn *c); |
| |
| #define CGI_REPLY "HTTP/1.1 OK\r\n" |
| #define CGI_REPLY_LEN (sizeof(CGI_REPLY) - 1) |
| |
| #endif /* DEFS_HEADER_DEFINED */ |