package http

Source

Body :: string

Body_Callback :: proc(user_data: rawptr, body: string, err: bufio.Scanner_Error)

Body_Error :: bufio.Scanner_Error

Connection :: struct {
	server:         ^Server,
	socket:         net.TCP_Socket,
	state:          Connection_State,
	scanner:        Scanner,
	temp_allocator: mem_virtual.Arena,
	loop:           Loop,
}

Connection_State :: enum int {
	Pending,    // Pending a client to attach.
	New,        // Got client, waiting to service first request.
	Active,     // Servicing request.
	Idle,       // Waiting for next request.
	Will_Close, // Closing after the current response is sent.
	Closing,    // Going to close, cleaning up.
	Closed,     // Fully closed.
}

Cookie :: struct {
	name:         string,
	value:        string,
	domain:       runtime.Maybe($T=string),
	expires_gmt:  runtime.Maybe($T=Time),
	max_age_secs: runtime.Maybe($T=int),
	path:         runtime.Maybe($T=string),
	http_only:    bool,
	partitioned:  bool,
	secure:       bool,
	same_site:    Cookie_Same_Site,
}

Cookie_Same_Site :: enum int {
	Unspecified, 
	None, 
	Strict, 
	Lax, 
}

Handle_Proc :: proc(req: ^Request, res: ^Response)

Handler :: struct {
	user_data: rawptr,
	next:      runtime.Maybe($T=^Handler),
	handle:    Handler_Proc,
}

Handler_Proc :: proc(handler: ^Handler, req: ^Request, res: ^Response)

Headers :: struct {
	_kv:      map[string]string,
	readonly: bool,
}

Method :: enum int {
	Get, 
	Post, 
	Delete, 
	Patch, 
	Put, 
	Head, 
	Connect, 
	Options, 
	Trace, 
}

Mime_Type :: enum int {
	Plain, 
	Css, 
	Csv, 
	Gif, 
	Html, 
	Ico, 
	Jpeg, 
	Js, 
	Json, 
	Png, 
	Svg, 
	Url_Encoded, 
	Xml, 
	Zip, 
	Wasm, 
}

Query_Entry :: struct {
	key:   string,
	value: string,
}

Rate_Limit_Data :: struct {
	opts:       ^Rate_Limit_Opts,
	next_sweep: time.Time,
	hits:       map[net.Address]int,
	mu:         sync.Mutex,
}

Rate_Limit_On_Limit :: struct {
	user_data: rawptr,
	on_limit:  proc(req: ^Request, res: ^Response, user_data: rawptr),
}

Rate_Limit_Opts :: struct {
	window:   time.Duration,
	max:      int,
	// Optional handler to call when a request is being rate-limited, allows you to customize the response.
	on_limit: runtime.Maybe($T=Rate_Limit_On_Limit),
}

Request :: struct {
	// If in a handler, this is always there and never None.
	// TODO: we should not expose this as a maybe to package users.
	line:       runtime.Maybe($T=Requestline),
	// Is true if the request is actually a HEAD request,
	// line.method will be .Get if Server_Opts.redirect_head_to_get is set.
	is_head:    bool,
	headers:    Headers,
	url:        URL,
	client:     net.Endpoint,
	// Route params/captures.
	url_params: []string,
	// Internal usage only.
	_scanner:   ^Scanner,
	_body_ok:   runtime.Maybe($T=bool),
}

Requestline :: struct {
	method:  Method,
	target:  union {
		string, 
		URL, 
	},
	version: Version,
}

Requestline_Error :: enum int {
	None, 
	Method_Not_Implemented, 
	Not_Enough_Fields, 
	Invalid_Version_Format, 
}

Response :: struct {
	// Add your headers and cookies here directly.
	headers:          Headers,
	cookies:          [dynamic]Cookie,
	// If the response has been sent.
	sent:             bool,
	// NOTE: use `http.response_status` if the response body might have been set already.
	status:           Status,
	// Only for internal usage.
	_conn:            ^Connection,
	// TODO/PERF: with some internal refactoring, we should be able to write directly to the
	// connection (maybe a small buffer in this struct).
	_buf:             bytes.Buffer,
	_heading_written: bool,
}

Response_Writer :: struct {
	r:     ^Response,
	// The writer you can write to.
	w:     io.Stream,
	// A dynamic wrapper over the `buffer` given in `response_writer_init`, doesn't allocate.
	buf:   [dynamic]u8,
	// If destroy or close has been called.
	ended: bool,
}

Route :: struct {
	handler: Handler,
	pattern: string,
}

Router :: struct {
	allocator: runtime.Allocator,
	routes:    map[Method][dynamic]Route,
	all:       [dynamic]Route,
}

Server :: struct {
	opts:           Server_Opts,
	tcp_sock:       net.TCP_Socket,
	conn_allocator: runtime.Allocator,
	handler:        Handler,
	main_thread:    int,
	threads:        []^thread.Thread,
	// Once the server starts closing/shutdown this is set to true, all threads will check it
	// and start their thread local shutdown procedure.
	// 
	// NOTE: This is only ever set from false to true, and checked repeatedly,
	// so it doesn't have to be atomic, this is purely to keep the thread sanitizer happy.
	closing:        Atomic($T=bool),
	// Threads will decrement the wait group when they have fully closed/shutdown.
	// The main thread waits on this to clean up global data and return.
	threads_closed: sync.Wait_Group,
	// Updated every second with an updated date, this speeds up the server considerably
	// because it would otherwise need to call time.now() and format the date on each response.
	date:           Server_Date,
}

Server_Opts :: struct {
	// Whether the server should accept every request that sends a "Expect: 100-continue" header automatically.
	// Defaults to true.
	auto_expect_continue: bool,
	// When this is true, any HEAD request is automatically redirected to the handler as a GET request.
	// Then, when the response is sent, the body is removed from the response.
	// Defaults to true.
	redirect_head_to_get: bool,
	// Limit the maximum number of bytes to read for the request line (first line of request containing the URI).
	// The HTTP spec does not specify any limits but in practice it is safer.
	// RFC 7230 3.1.1 says:
	// Various ad hoc limitations on request-line length are found in
	// practice.  It is RECOMMENDED that all HTTP senders and recipients
	// support, at a minimum, request-line lengths of 8000 octets.
	// defaults to 8000.
	limit_request_line:   int,
	// Limit the length of the headers.
	// The HTTP spec does not specify any limits but in practice it is safer.
	// defaults to 8000.
	limit_headers:        int,
	// The thread count to use, defaults to your core count - 1.
	thread_count:         int,
}

Server_State :: enum int {
	Uninitialized, 
	Idle, 
	Listening, 
	Serving, 
	Running, 
	Closing, 
	Cleaning, 
	Closed, 
}

Server_Thread :: struct {
	conns: map[net.TCP_Socket]^Connection,
	state: Server_State,
	io:    nbio._IO,
}

Status :: enum int {
	Continue                        = 100, 
	Switching_Protocols             = 101, 
	Processing                      = 102, 
	Early_Hints                     = 103, 
	OK                              = 200, 
	Created                         = 201, 
	Accepted                        = 202, 
	Non_Authoritative_Information   = 203, 
	No_Content                      = 204, 
	Reset_Content                   = 205, 
	Partial_Content                 = 206, 
	Multi_Status                    = 207, 
	Already_Reported                = 208, 
	IM_Used                         = 226, 
	Multiple_Choices                = 300, 
	Moved_Permanently               = 301, 
	Found                           = 302, 
	See_Other                       = 303, 
	Not_Modified                    = 304, 
	Use_Proxy                       = 305, // Deprecated.
	Unused                          = 306, // Deprecated.
	Temporary_Redirect              = 307, 
	Permanent_Redirect              = 308, 
	Bad_Request                     = 400, 
	Unauthorized                    = 401, 
	Payment_Required                = 402, 
	Forbidden                       = 403, 
	Not_Found                       = 404, 
	Method_Not_Allowed              = 405, 
	Not_Acceptable                  = 406, 
	Proxy_Authentication_Required   = 407, 
	Request_Timeout                 = 408, 
	Conflict                        = 409, 
	Gone                            = 410, 
	Length_Required                 = 411, 
	Precondition_Failed             = 412, 
	Payload_Too_Large               = 413, 
	URI_Too_Long                    = 414, 
	Unsupported_Media_Type          = 415, 
	Range_Not_Satisfiable           = 416, 
	Expectation_Failed              = 417, 
	Im_A_Teapot                     = 418, 
	Misdirected_Request             = 421, 
	Unprocessable_Content           = 422, 
	Locked                          = 423, 
	Failed_Dependency               = 424, 
	Too_Early                       = 425, 
	Upgrade_Required                = 426, 
	Precondition_Required           = 428, 
	Too_Many_Requests               = 429, 
	Request_Header_Fields_Too_Large = 431, 
	Unavailable_For_Legal_Reasons   = 451, 
	Internal_Server_Error           = 500, 
	Not_Implemented                 = 501, 
	Bad_Gateway                     = 502, 
	Service_Unavailable             = 503, 
	Gateway_Timeout                 = 504, 
	HTTP_Version_Not_Supported      = 505, 
	Variant_Also_Negotiates         = 506, 
	Insufficient_Storage            = 507, 
	Loop_Detected                   = 508, 
	Not_Extended                    = 510, 
	Network_Authentication_Required = 511, 
}

URL :: struct {
	raw:    string,
	// All other fields are views/slices into this string.
	scheme: string,
	host:   string,
	path:   string,
	query:  string,
}

Version :: struct {
	major: u8,
	minor: u8,
}

Default_Endpoint: net.Endpoint = …

Default_Server_Opts: Server_Opts = …

@(thread_local)
td: Server_Thread

body :: proc(req: ^Request, max_length: int = -1, user_data: rawptr, cb: Body_Callback) {…}

body_error_status :: proc(e: bufio.Scanner_Error) -> Status {…}

body_set_bytes :: proc(r: ^Response, byts: []u8, loc := #caller_location) {…}

body_set_str :: proc(r: ^Response, str: string, loc := #caller_location) {…}

body_url_encoded :: proc(plain: string, allocator := context.temp_allocator) -> (res: map[string]string, ok: bool) {…}

cookie_date_parse :: proc(value: string) -> (t: time.Time, ok: bool) {…}

cookie_parse :: proc(value: string, allocator := context.allocator) -> (cookie: Cookie, ok: bool) {…}

cookie_string :: proc(c: Cookie, allocator := context.allocator) -> string {…}

cookie_write :: proc(w: io.Stream, c: Cookie) -> io.Error {…}

date_parse :: proc(value: string) -> (t: time.Time, ok: bool) {…}

date_string :: proc(t: time.Time, allocator := context.allocator) -> string {…}

date_write :: proc(w: io.Stream, t: time.Time) -> io.Error {…}

handler :: proc(handle: Handle_Proc) -> Handler {…}

header_allowed_trailer :: proc(key: string) -> bool {…}

header_parse :: proc(headers: ^Headers, line: string, allocator := context.temp_allocator) -> (key: string, ok: bool) {…}

headers_count :: proc(h: Headers) -> int {…}

headers_delete :: proc(h: ^Headers, k: string) -> (deleted_key: string, deleted_value: string) {…}

headers_delete_unsafe :: proc(h: ^Headers, k: string) {…}

headers_get :: proc(h: Headers, k: string) -> (string, bool) #optional_ok {…}

headers_get_unsafe :: proc(h: Headers, k: string) -> (string, bool) #optional_ok {…}

headers_has :: proc(h: Headers, k: string) -> bool {…}

headers_has_unsafe :: proc(h: Headers, k: string) -> bool {…}

headers_init :: proc(h: ^Headers, allocator := context.temp_allocator) {…}

headers_set :: proc(h: ^Headers, k: string, v: string, loc := #caller_location) -> string {…}

headers_set_close :: proc(h: ^Headers) {…}

headers_set_content_type_mime :: proc(h: ^Headers, ct: Mime_Type) {…}

headers_set_content_type_string :: proc(h: ^Headers, ct: string) {…}

headers_set_unsafe :: proc(h: ^Headers, k: string, v: string, loc := #caller_location) {…}

headers_validate :: proc(headers: ^Headers) -> bool {…}

headers_validate_for_server :: proc(headers: ^Headers) -> bool {…}

listen :: proc(s: ^Server, endpoint: net.Endpoint = Default_Endpoint, opts: Server_Opts = Default_Server_Opts) -> (err: net.Network_Error) {…}

listen_and_serve :: proc(s: ^Server, h: Handler, endpoint: net.Endpoint = Default_Endpoint, opts: Server_Opts = Default_Server_Opts) -> (err: net.Network_Error) {…}

method_parse :: proc(m: string) -> (method: Method, ok: bool) {…}

method_string :: proc(m: Method) -> string {…}

middleware_proc :: proc(next: runtime.Maybe($T=^Handler), handle: Handler_Proc) -> Handler {…}

mime_from_extension :: proc(s: string) -> Mime_Type {…}

mime_to_content_type :: proc(m: Mime_Type) -> string {…}

query_get :: proc(url: URL, key: string) -> (val: string, ok: bool) #optional_ok {…}

query_get_bool :: proc(url: URL, key: string) -> (result, set: bool) #optional_ok {…}

query_get_int :: proc(url: URL, key: string, base: int = 0) -> (result: int, ok: bool, set: bool) {…}

query_get_percent_decoded :: proc(url: URL, key: string, allocator := context.temp_allocator) -> (val: string, ok: bool) {…}

query_get_uint :: proc(url: URL, key: string, base: int = 0) -> (result: uint, ok: bool, set: bool) {…}

query_iter :: proc(query: ^string) -> (entry: Query_Entry, ok: bool) {…}

rate_limit :: proc(data: ^Rate_Limit_Data, next: ^Handler, opts: ^Rate_Limit_Opts, allocator := context.allocator) -> Handler {…}

rate_limit_destroy :: proc(data: ^Rate_Limit_Data) {…}

rate_limit_message :: proc(message: ^string) -> Rate_Limit_On_Limit {…}

request_cookie_get :: proc(r: ^Request, key: string) -> (value: string, ok: bool) {…}

request_cookies :: proc(r: ^Request, allocator := context.temp_allocator) -> (res: map[string]string) {…}

request_cookies_iter :: proc(cookies: ^string) -> (key: string, value: string, ok: bool) {…}

request_init :: proc(r: ^Request, allocator := context.temp_allocator) {…}

request_path :: proc(target: URL, allocator := context.allocator) -> (rq_path: string) {…}

request_path_write :: proc(w: io.Stream, target: URL) -> io.Error {…}

requestline_parse :: proc(s: string, allocator := context.temp_allocator) -> (line: Requestline, err: Requestline_Error) {…}

requestline_write :: proc(w: io.Stream, rline: Requestline) -> io.Error {…}

respond_dir :: proc(r: ^Response, base, target, request: string, loc := #caller_location) {…}

respond_file :: proc(r: ^Response, path: string, content_type: runtime.Maybe($T=Mime_Type) = nil, loc := #caller_location) {…}

respond_file_content :: proc(r: ^Response, path: string, content: []u8, status: Status = .OK, loc := #caller_location) {…}

respond_html :: proc(r: ^Response, html: string, status: Status = .OK, loc := #caller_location) {…}

respond_json :: proc(r: ^Response, v: any, status: Status = .OK, opt: encoding_json.Marshal_Options = {}, loc := #caller_location) -> (err: encoding_json.Marshal_Error) {…}

respond_plain :: proc(r: ^Response, text: string, status: Status = .OK, loc := #caller_location) {…}

respond_with_none :: proc(r: ^Response, loc := #caller_location) {…}

respond_with_status :: proc(r: ^Response, status: Status, loc := #caller_location) {…}

response_init :: proc(r: ^Response, allocator := context.allocator) {…}

response_status :: proc(r: ^Response, status: Status) {…}

response_writer_init :: proc(rw: ^Response_Writer, r: ^Response, buffer: []u8) -> io.Stream {…}

route_all :: proc(router: ^Router, pattern: string, handler: Handler) {…}

route_connect :: proc(router: ^Router, pattern: string, handler: Handler) {…}

route_delete :: proc(router: ^Router, pattern: string, handler: Handler) {…}

route_get :: proc(router: ^Router, pattern: string, handler: Handler) {…}

route_head :: proc(router: ^Router, pattern: string, handler: Handler) {…}

route_options :: proc(router: ^Router, pattern: string, handler: Handler) {…}

route_patch :: proc(router: ^Router, pattern: string, handler: Handler) {…}

route_post :: proc(router: ^Router, pattern: string, handler: Handler) {…}

route_put :: proc(router: ^Router, pattern: string, handler: Handler) {…}

route_trace :: proc(router: ^Router, pattern: string, handler: Handler) {…}

router_destroy :: proc(router: ^Router) {…}

router_handler :: proc(router: ^Router) -> Handler {…}

router_init :: proc(router: ^Router, allocator := context.allocator) {…}

serve :: proc(s: ^Server, h: Handler) -> (err: net.Network_Error) {…}

server_shutdown :: proc(s: ^Server) {…}

server_shutdown_on_interrupt :: proc(s: ^Server) {…}

status_from_string :: proc(s: string) -> (Status, bool) {…}

status_is_client_error :: proc(s: Status) -> bool {…}

status_is_informational :: proc(s: Status) -> bool {…}

status_is_redirect :: proc(s: Status) -> bool {…}

status_is_server_error :: proc(s: Status) -> bool {…}

status_is_success :: proc(s: Status) -> bool {…}

status_string :: proc(s: Status) -> string {…}

status_valid :: proc(s: Status) -> bool {…}

test_dynamic_unwritten :: proc(t: ^testing.T) {…}

url_parse :: proc(raw: string) -> (url: URL) {…}

version_parse :: proc(s: string) -> (version: Version, ok: bool) {…}

version_string :: proc(v: Version, allocator := context.allocator) -> string {…}

version_write :: proc(w: io.Stream, v: Version) -> io.Error {…}

body_set :: proc{
	body_set_str,
	body_set_bytes,
}

headers_set_content_type :: proc{
	headers_set_content_type_mime,
	headers_set_content_type_string,
}

respond :: proc{
	respond_with_none,
	respond_with_status,
}