tiny_http_fork 0.12.7

Low level HTTP server library FORK
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

# tiny-http-fork

<img src="https://cdn.4neko.org/http-server.webp" width="300"/>

<br/>


<a href = "https://codeberg.org/4neko/tiny-http-fork/actions"><img src="https://codeberg.org/4neko/tiny-http-fork/badges/workflows/linux-os.yml/badge.svg" /></a>
<a href = "https://codeberg.org/4neko/tiny-http-fork/actions"><img src="https://codeberg.org/4neko/tiny-http-fork/badges/workflows/freebsd-os.yml/badge.svg" /></a>
<a href = "https://codeberg.org/4neko/tiny-http-fork/actions"><img src="https://codeberg.org/4neko/tiny-http-fork/badges/workflows/openbsd-os.yml/badge.svg" /></a>
<a href = "https://codeberg.org/4neko/tiny-http-fork/actions"><img src="https://codeberg.org/4neko/tiny-http-fork/badges/workflows/netbsd-os.yml/badge.svg" /></a>
<a href = "https://codeberg.org/4neko/tiny-http-fork/actions"><img src="https://codeberg.org/4neko/tiny-http-fork/badges/workflows/linux-os-arm.yml/badge.svg" /></a>

This is fork of original [tiny-http](https://github.com/tiny-http/tiny-http).

A new development repo: [codeberg](https://codeberg.org/4neko/tiny-http-fork)

Because original authors does not respond on CVE and this crate is the only which is lightweight and actually working, I (hopefully) temporarily decided to fork the crate and keep development and support there.

The LICENSES which were initially were preserved and published under the same licenses.

## Version
V 0.12.7-crate

## Changelog

Since the crate was forked the following was implemented:
- fix [CVE-2026-66753](https://github.com/tiny-http/tiny-http/issues/288)
- fix [CVE-2026-66752](https://github.com/tiny-http/tiny-http/issues/287)
- merged [ECONNABORTED triggers a server shutdown](https://github.com/tiny-http/tiny-http/issues/283)
- merged [Handle ECONNABORTED errors from accept()](https://github.com/tiny-http/tiny-http/pull/284)
- merged [fix: Make sure that the connection is indeed closed at the end of request](https://github.com/tiny-http/tiny-http/pull/282) but later rejected because it is breaking tests and this is a wrong way
- updated crate versions
- updated SSL/TLS subsystem
- code cleanup (partly)

## -- INFO/POLICY --

<details>
  <summary>AI (LLM) policy</summary>

- AI (LLM) generated sloppy code is prohibited. AI (LLM) generates slop "a priori" (anyway).
- It is strongly discouraged from using the AI based tools to write or enhance the code. AI slope would 100% violate the license by introducing the 3rd party licensed code. This code will never be accepted.
- It is ok to use the AI (LLM) for consultation purposes i.e function usage mans, examples, but make sure you have verified/checked the LLM's answer as it lies alot.

</details>  

## ---- original readme ----

[**Documentation**](https://docs.rs/tiny_http_fork)

Tiny but strong HTTP server in Rust.
Its main objectives are to be 100% compliant with the HTTP standard and to provide an easy way to create an HTTP server.

What does **tiny-http** handle?
 - Accepting and managing connections to the clients
 - Parsing requests
 - Requests pipelining
 - HTTPS (using either OpenSSL, Rustls or native-tls)
 - Transfer-Encoding and Content-Encoding
 - Turning user input (eg. POST input) into a contiguous UTF-8 string (**not implemented yet**)
 - Ranges (**not implemented yet**)
 - `Connection: upgrade` (used by websockets)

Tiny-http handles everything that is related to client connections and data transfers and encoding.

Everything else (parsing the values of the headers, multipart data, routing, etags, cache-control, HTML templates, etc.) must be handled by your code.
If you want to create a website in Rust, I strongly recommend using a framework instead of this library.

### Installation

Add this to the `Cargo.toml` file of your project:

```toml
[dependencies]
tiny_http_fork = "0.11"
```

### Usage

```rust
use tiny_http_fork::{Server, Response};

let server = Server::http("0.0.0.0:8000").unwrap();

for request in server.incoming_requests() {
    println!("received request! method: {:?}, url: {:?}, headers: {:?}",
        request.method(),
        request.url(),
        request.headers()
    );

    let response = Response::from_string("hello world");
    request.respond(response);
}
```

### Speed

Tiny-http was designed with speed in mind:
 - Each client connection will be dispatched to a thread pool. Each thread will handle one client.
 If there is no thread available when a client connects, a new one is created. Threads that are idle
 for a long time (currently 5 seconds) will automatically die.
 - If multiple requests from the same client are being pipelined (ie. multiple requests
 are sent without waiting for the answer), tiny-http will read them all at once and they will
 all be available via `server.recv()`. Tiny-http will automatically rearrange the responses
 so that they are sent in the right order.
 - One exception to the previous statement exists when a request has a large body (currently > 1kB),
 in which case the request handler will read the body directly from the stream and tiny-http
 will wait for it to be read before processing the next request. Tiny-http will never wait for
 a request to be answered to read the next one.
 - When a client connection has sent its last request (by sending `Connection: close` header),
 the thread will immediately stop reading from this client and can be reclaimed, even when the
 request has not yet been answered. The reading part of the socket will also be immediately closed.
 - Decoding the client's request is done lazily. If you don't read the request's body, it will not
 be decoded.

### Examples

Examples of tiny-http in use:

* [heroku-tiny-http-hello-world](https://github.com/frewsxcv/heroku-tiny-http-hello-world) - A simple web application demonstrating how to deploy tiny-http to Heroku
* [crate-deps](https://github.com/frewsxcv/crate-deps) - A web service that generates images of dependency graphs for crates hosted on crates.io
* [rouille](https://crates.io/crates/rouille) - Web framework built on tiny-http

### License

This project is licensed under either of

 * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
   http://www.apache.org/licenses/LICENSE-2.0)
 * MIT license ([LICENSE-MIT](LICENSE-MIT) or
   http://opensource.org/licenses/MIT)

at your option.

#### Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in tiny-http by you, as defined in the Apache-2.0 license, shall be
dual licensed as above, without any additional terms or conditions.

<!-- Links and Badges -->
[crate_img]: https://img.shields.io/crates/v/tiny_http_fork.svg?logo=rust "Crate Page"
[crate]: https://crates.io/crates/tiny_http_fork "Crate Link"
[docs]: https://docs.rs/tiny_http_fork "Documentation"
[docs_img]: https://docs.rs/tiny_http_fork/badge.svg "Documentation"
[license_img]: https://img.shields.io/crates/l/tiny_http_fork.svg "License"
[ci_badge]: https://github.com/tiny-http/tiny-http/actions/workflows/ci.yaml/badge.svg "CI Status"
[ci_link]: https://github.com/tiny-http/tiny-http/actions/workflows/ci.yaml "Workflow Link"