lighttpd
/
lighttpd1.4
2
0
Fork 0
Code Issues Releases Wiki Activity
lighttpd1.4/src/response.h

71 lines
2.3 KiB
C
Raw Normal View History

moved everything below trunk/ and added branches/ and tags/ git-svn-id: svn://svn.lighttpd.net/lighttpd/trunk@30 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-02-20 14:27:00 +00:00
#ifndef _RESPONSE_H_
#define _RESPONSE_H_
consistent inclusion of config.h at top of files (fixes #2073) From: Glenn Strauss <gstrauss@gluelogic.com> git-svn-id: svn://svn.lighttpd.net/lighttpd/branches/lighttpd-1.4.x@3113 152afb58-edef-0310-8abb-c4023f1b3aa9
2016-03-19 15:14:35 +00:00
#include "first.h"
moved everything below trunk/ and added branches/ and tags/ git-svn-id: svn://svn.lighttpd.net/lighttpd/trunk@30 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-02-20 14:27:00 +00:00
[core] consistent inclusion of sys-time.h
2021-04-28 17:18:37 +00:00
#include "sys-time.h"
[core] some header cleanup provide standard types in first.h instead of base.h provide lighttpd types in base_decls.h instead of settings.h reduce headers exposed by headers for core data structures do not expose <pcre.h> or <stdlib.h> in headers move stat_cache_entry to stat_cache.h reduce use of "server.h" and "base.h" in headers
2018-03-25 07:45:05 +00:00
#include "base_decls.h"
#include "buffer.h"
#include "array.h"
moved everything below trunk/ and added branches/ and tags/ git-svn-id: svn://svn.lighttpd.net/lighttpd/trunk@30 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-02-20 14:27:00 +00:00
[multiple] static file optimization; reuse cache reuse cache lookup in common case of serving a static file rather than repeating the stat_cache_entry lookup (which is more work than memcmp() to re-check stat_cache_entry match)
2021-05-04 02:18:20 +00:00
struct stat_cache_entry;/* declaration */
[mod_ajp13,mod_fastcgi] check resp w/ content len limit response body from mod_ajp13 and mod_fastcgi to Content-Length, if Content-Length is provided in response headers; discard excess
2021-10-21 13:45:06 +00:00
struct chunkqueue; /* declaration */
[multiple] static file optimization; reuse cache reuse cache lookup in common case of serving a static file rather than repeating the stat_cache_entry lookup (which is more work than memcmp() to re-check stat_cache_entry match)
2021-05-04 02:18:20 +00:00
[multiple] split con, request (very large change) NB: r->tmp_buf == srv->tmp_buf (pointer is copied for quicker access) NB: request read and write chunkqueues currently point to connection chunkqueues; per-request and per-connection chunkqueues are not distinct from one another con->read_queue == r->read_queue con->write_queue == r->write_queue NB: in the future, a separate connection config may be needed for connection-level module hooks. Similarly, might need to have per-request chunkqueues separate from per-connection chunkqueues. Should probably also have a request_reset() which is distinct from connection_reset().
2020-01-13 02:51:12 +00:00
int http_response_parse(server *srv, request_st *r);
moved everything below trunk/ and added branches/ and tags/ git-svn-id: svn://svn.lighttpd.net/lighttpd/trunk@30 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-02-20 14:27:00 +00:00
[core] consolidate dynamic handler response parse - consolidate dynamic handler HTTP response parsing code - reduce string copies for CGI, FastCGI, SCGI, proxy response headers - let read() signal EOF or EAGAIN instead of ioctl FIONREAD 0-data-ready
2017-03-18 04:10:48 +00:00
enum {
[mod_ajp13] AJPv13 Tomcat connector for lighttpd (experimental) AJPv13 protocol reference: https://tomcat.apache.org/connectors-doc/ajp/ajpv13a.html
2021-01-24 05:02:58 +00:00
BACKEND_PROXY = 0
,BACKEND_CGI
,BACKEND_FASTCGI
,BACKEND_SCGI
,BACKEND_AJP13
[core] consolidate dynamic handler response parse - consolidate dynamic handler HTTP response parsing code - reduce string copies for CGI, FastCGI, SCGI, proxy response headers - let read() signal EOF or EAGAIN instead of ioctl FIONREAD 0-data-ready
2017-03-18 04:10:48 +00:00
};
typedef struct http_response_opts_t {
[multiple] internal control for backend read bytes separate internal control for backend max_per_read When not streaming, large reads will be flushed to temp files on disk. When streaming, use a smaller buffer to help reduce memory usage. When not streaming, attempt to read and empty kernel socket bufs. (e.g. MAX_READ_LIMIT 256k) When writing to sockets (or pipes) attempt to fill kernel socket bufs. (e.g. MAX_WRITE_LIMIT 256k)
2021-09-17 15:49:55 +00:00
uint32_t max_per_read;
[core] collect ioctl FIONREAD code include <sys/ioctl.h> in files which use ioctl() instead of exposing header in local header "sys-socket.h"
2017-03-28 05:57:16 +00:00
int fdfmt;
[core] consolidate dynamic handler response parse - consolidate dynamic handler HTTP response parsing code - reduce string copies for CGI, FastCGI, SCGI, proxy response headers - let read() signal EOF or EAGAIN instead of ioctl FIONREAD 0-data-ready
2017-03-18 04:10:48 +00:00
int backend;
[core] disable streaming response with authorizer (fixes #3106) disable streaming response while processing "authorizer" mode until "authorizer" response 200 OK from the backend is complete (thx jefftharris) x-ref: "FastCGI authorizer hang with server.stream-response-body" https://redmine.lighttpd.net/boards/2/topics/9969 "FastCGI authorizer hang with server.stream-response-body" https://redmine.lighttpd.net/issues/3106
2021-09-25 19:10:35 +00:00
int authorizer; /* bool *//*(maybe overloaded w/ response streaming flags)*/
[core] improve handling of suboptimal backend wr more efficiently handle reading of suboptimal backend write behavior check to accumulate small reads in mem before flushing to temp file
2021-07-24 16:09:32 +00:00
uint8_t simple_accum; /* bool */
uint8_t local_redir; /* 0,1,2 */
uint8_t xsendfile_allow; /* bool */
[core] add xsendfile* check if xdocroot is NULL
2019-11-07 05:15:17 +00:00
const array *xsendfile_docroot;
[mod_fastcgi] consolidate backend read code Use same funcs as other dynamic handlers to recv data from backend. Add hook for fastcgi to process FastCGI packets (and other future dynamic handlers may hook this in order to handle custom data framing)
2017-05-06 03:57:55 +00:00
void *pdata;
[multiple] split con, request (very large change) NB: r->tmp_buf == srv->tmp_buf (pointer is copied for quicker access) NB: request read and write chunkqueues currently point to connection chunkqueues; per-request and per-connection chunkqueues are not distinct from one another con->read_queue == r->read_queue con->write_queue == r->write_queue NB: in the future, a separate connection config may be needed for connection-level module hooks. Similarly, might need to have per-request chunkqueues separate from per-connection chunkqueues. Should probably also have a request_reset() which is distinct from connection_reset().
2020-01-13 02:51:12 +00:00
handler_t(*parse)(request_st *, struct http_response_opts_t *, buffer *, size_t);
handler_t(*headers)(request_st *, struct http_response_opts_t *);
[core] consolidate dynamic handler response parse - consolidate dynamic handler HTTP response parsing code - reduce string copies for CGI, FastCGI, SCGI, proxy response headers - let read() signal EOF or EAGAIN instead of ioctl FIONREAD 0-data-ready
2017-03-18 04:10:48 +00:00
} http_response_opts;
[core] relay 1xx from backend over HTTP/2 relay 1xx from backend over HTTP/2, e.g. 103 Early Hints (if client is connected using HTTP/2) enabled by default unless disabled in lighttpd.conf with: server.feature-flags += ( "server.h2-discard-backend-1xx" = "enable" ) Warning: backends which send 103 Early Hints should check User-Agent before doing so since naive clients might not handle unexpected 1xx. Some clients may take the 1xx response as the final response, expecting only one response. Some clients might not properly handle 100 Continue if the client did not send Expect: 100-continue with the request. https://tools.ietf.org/html/rfc8297#section-3 Security Considerations x-ref: An HTTP Status Code for Indicating Hints (103 Early Hints) https://tools.ietf.org/html/rfc8297
2020-09-17 23:29:59 +00:00
typedef int (*http_response_send_1xx_cb)(request_st *r, connection *con);
__attribute_cold__
void http_response_send_1xx_cb_set (http_response_send_1xx_cb fn, int vers);
int http_response_send_1xx (request_st *r);
[multiple] split con, request (very large change) NB: r->tmp_buf == srv->tmp_buf (pointer is copied for quicker access) NB: request read and write chunkqueues currently point to connection chunkqueues; per-request and per-connection chunkqueues are not distinct from one another con->read_queue == r->read_queue con->write_queue == r->write_queue NB: in the future, a separate connection config may be needed for connection-level module hooks. Similarly, might need to have per-request chunkqueues separate from per-connection chunkqueues. Should probably also have a request_reset() which is distinct from connection_reset().
2020-01-13 02:51:12 +00:00
handler_t http_response_parse_headers(request_st *r, http_response_opts *opts, buffer *hdrs);
handler_t http_response_read(request_st *r, http_response_opts *opts, buffer *b, fdnode *fdn);
[core] http_response_comeback() group HANDLER_COMEBACK logic in http_response_comeback() and call it from places that reset state in order to (sometimes partially) reprocess a request. This includes error handler (server.error-handler), r->handler_module when cgi.local-redir, and looping in http_response_prepare() when modules make changes to the request and return HANDLER_COMEBACK (e.g. mod_rewrite, mod_magnet, mod_cml) Also, set r->conditional_is_valid closer to where elements are set (and become valid for use in condition checks), and parse target in http_request_parse() instead of http_response_prepare()
2020-01-21 02:05:56 +00:00
[multiple] isolate more con code in connections.c move code from connections-glue.c back into connections.c move code from connections-glue.c to http-header-glue.c rename connection_response_reset() to http_response_reset() rename connection_handle_read_post_error() to http_response_reqbody_read_error()
2020-08-11 05:10:57 +00:00
__attribute_cold__
handler_t http_response_reqbody_read_error(request_st *r, int http_status);
[core] http_response_buffer_append_authority() make public func for benefit of external, third-party mod_authn_tkt
2020-11-10 11:10:27 +00:00
int http_response_buffer_append_authority(request_st *r, buffer *o);
[multiple] split con, request (very large change) NB: r->tmp_buf == srv->tmp_buf (pointer is copied for quicker access) NB: request read and write chunkqueues currently point to connection chunkqueues; per-request and per-connection chunkqueues are not distinct from one another con->read_queue == r->read_queue con->write_queue == r->write_queue NB: in the future, a separate connection config may be needed for connection-level module hooks. Similarly, might need to have per-request chunkqueues separate from per-connection chunkqueues. Should probably also have a request_reset() which is distinct from connection_reset().
2020-01-13 02:51:12 +00:00
int http_response_redirect_to_directory(request_st *r, int status);
[multiple] Y2038 32-bit signed time_t mitigations Most OS platforms have already provided solutions to Y2038 32-bit signed time_t 5 - 10 years ago (or more!) Notable exceptions are Linux i686 and FreeBSD i386. Since 32-bit systems tend to be embedded systems, and since many distros take years to pick up new software, this commit aims to provide Y2038 mitigations for lighttpd running on 32-bit systems with Y2038-unsafe 32-bit signed time_t * Y2038: lighttpd 1.4.60 and later report Y2038 safety $ lighttpd -V + Y2038 support # Y2038-SAFE $ lighttpd -V - Y2038 support (unsafe 32-bit signed time_t) # Y2038-UNSAFE * Y2038: general platform info * Y2038-SAFE: lighttpd 64-bit builds on platforms using 64-bit time_t - all major 64-bit platforms (known to this author) use 64-bit time_t * Y2038-SAFE: lighttpd 32-bit builds on platforms using 64-bit time_t - Linux x32 ABI (different from i686) - FreeBSD all 32-bit and 64-bit architectures *except* 32-bit i386 - NetBSD 6.0 (released Oct 2012) all 32-bit and 64-bit architectures - OpenBSD 5.5 (released May 2014) all 32-bit and 64-bit architectures - Microsoft Windows XP and Visual Studio 2005 (? unsure ?) Another reference suggests Visual Studio 2015 defaults to 64-bit time_t - MacOS 10.15 Catalina (released 2019) drops support for 32-bit apps * Y2038-SAFE: lighttpd 32-bit builds on platforms using 32-bit unsigned time_t - e.g. OpenVMS (unknown if lighttpd builds on this platform) * Y2038-UNSAFE: lighttpd 32-bit builds on platforms using 32-bit signed time_t - Linux 32-bit (including i686) - glibc 32-bit library support not yet available for 64-bit time_t - https://sourceware.org/glibc/wiki/Y2038ProofnessDesign - Linux kernel 5.6 on 32-bit platforms does support 64-bit time_t https://itsubuntu.com/linux-kernel-5-6-to-fix-the-year-2038-issue-unix-y2k/ - https://www.gnu.org/software/libc/manual/html_node/64_002dbit-time-symbol-handling.html "Note: at this point, 64-bit time support in dual-time configurations is work-in-progress, so for these configurations, the public API only makes the 32-bit time support available. In a later change, the public API will allow user code to choose the time size for a given compilation unit." - compiling with -D_TIME_BITS=64 currently has no effect - glibc recent (Jul 2021) mailing list discussion - https://public-inbox.org/bug-gnulib/878s2ozq70.fsf@oldenburg.str.redhat.com/T/ - FreeBSD i386 - DragonFlyBSD 32-bit * Y2038 mitigations attempted on Y2038-UNSAFE platforms (32-bit signed time_t) * lighttpd prefers system monotonic clock instead of realtime clock in places where realtime clock is not required * lighttpd treats negative time_t values as after 19 Jan 2038 03:14:07 GMT * (lighttpd presumes that lighttpd will not encounter dates before 1970 during normal operation.) * lighttpd casts struct stat st.st_mtime (and st.st_*time) through uint64_t to convert negative timestamps for comparisions with 64-bit timestamps (treating negative timestamp values as after 19 Jan 2038 03:14:07 GMT) * lighttpd provides unix_time64_t (int64_t) and * lighttpd provides struct unix_timespec64 (unix_timespec64_t) (struct timespec equivalent using unix_time64_t tv_sec member) * lighttpd provides gmtime64_r() and localtime64_r() wrappers for platforms 32-bit platforms using 32-bit time_t and lighttpd temporarily shifts the year in order to use gmtime_r() and localtime_r() (or gmtime() and localtime()) from standard libraries, before readjusting year and passing struct tm to formatting functions such as strftime() * lighttpd provides TIME64_CAST() macro to cast signed 32-bit time_t to unsigned 32-bit and then to unix_time64_t * Note: while lighttpd tries handle times past 19 Jan 2038 03:14:07 GMT on 32-bit platforms using 32-bit signed time_t, underlying libraries and underlying filesystems might not behave properly after 32-bit signed time_t overflows (19 Jan 2038 03:14:08 GMT). If a given 32-bit OS does not work properly using negative time_t values, then lighttpd likely will not work properly on that system. * Other references and blogs - https://en.wikipedia.org/wiki/Year_2038_problem - https://en.wikipedia.org/wiki/Time_formatting_and_storage_bugs - http://www.lieberbiber.de/2017/03/14/a-look-at-the-year-20362038-problems-and-time-proofness-in-various-systems/
2021-07-12 18:46:49 +00:00
const buffer * http_response_set_last_modified(request_st *r, unix_time64_t lmtime);
int http_response_handle_cachable(request_st *r, const buffer *lmod, unix_time64_t lmtime);
[multiple] split con, request (very large change) NB: r->tmp_buf == srv->tmp_buf (pointer is copied for quicker access) NB: request read and write chunkqueues currently point to connection chunkqueues; per-request and per-connection chunkqueues are not distinct from one another con->read_queue == r->read_queue con->write_queue == r->write_queue NB: in the future, a separate connection config may be needed for connection-level module hooks. Similarly, might need to have per-request chunkqueues separate from per-connection chunkqueues. Should probably also have a request_reset() which is distinct from connection_reset().
2020-01-13 02:51:12 +00:00
void http_response_body_clear(request_st *r, int preserve_length);
[multiple] isolate more con code in connections.c move code from connections-glue.c back into connections.c move code from connections-glue.c to http-header-glue.c rename connection_response_reset() to http_response_reset() rename connection_handle_read_post_error() to http_response_reqbody_read_error()
2020-08-11 05:10:57 +00:00
void http_response_reset(request_st *r);
[multiple] static file optimization; reuse cache reuse cache lookup in common case of serving a static file rather than repeating the stat_cache_entry lookup (which is more work than memcmp() to re-check stat_cache_entry match)
2021-05-04 02:18:20 +00:00
void http_response_send_file (request_st *r, buffer *path, struct stat_cache_entry *sce);
[multiple] split con, request (very large change) NB: r->tmp_buf == srv->tmp_buf (pointer is copied for quicker access) NB: request read and write chunkqueues currently point to connection chunkqueues; per-request and per-connection chunkqueues are not distinct from one another con->read_queue == r->read_queue con->write_queue == r->write_queue NB: in the future, a separate connection config may be needed for connection-level module hooks. Similarly, might need to have per-request chunkqueues separate from per-connection chunkqueues. Should probably also have a request_reset() which is distinct from connection_reset().
2020-01-13 02:51:12 +00:00
void http_response_backend_done (request_st *r);
void http_response_backend_error (request_st *r);
void http_response_upgrade_read_body_unknown(request_st *r);
[mod_ajp13,mod_fastcgi] check resp w/ content len limit response body from mod_ajp13 and mod_fastcgi to Content-Length, if Content-Length is provided in response headers; discard excess
2021-10-21 13:45:06 +00:00
int http_response_transfer_cqlen(request_st *r, struct chunkqueue *cq, size_t len);
[core] h2_send_headers() specialized for resp hdrs specialized version of http_response_write_header(); send headers directly to HPACK encoder, rather than double-buffering in chunkqueue
2020-08-25 10:34:47 +00:00
__attribute_cold__
int http_response_omit_header(request_st *r, const data_string *ds);
[core] isolate more resp code in response.c http_response_handler() and response generation flow control logic
2020-08-13 02:38:59 +00:00
void http_response_write_header(request_st *r);
handler_t http_response_handler(request_st *r);
moved everything below trunk/ and added branches/ and tags/ git-svn-id: svn://svn.lighttpd.net/lighttpd/trunk@30 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-02-20 14:27:00 +00:00
[core] static buffers for mtime_cache
2019-12-10 04:57:53 +00:00
__attribute_cold__
void strftime_cache_reset(void);
moved everything below trunk/ and added branches/ and tags/ git-svn-id: svn://svn.lighttpd.net/lighttpd/trunk@30 152afb58-edef-0310-8abb-c4023f1b3aa9
2005-02-20 14:27:00 +00:00
#endif