httplz 0.0.0

A sans-io, no-std HTTP implementation
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

use core::fmt::Arguments;

use crate::{Error, ErrorKind, Header, HeaderOther, HeaderSpecial, RequestLine, StatusLine};

pub struct FmtWriteAdapter<T> {
	inner: T,
	err: Written,
}
impl<T> FmtWriteAdapter<T> {
	pub fn new(inner: T) -> Self {
		Self { inner, err: Ok(()) }
	}
}

impl<T> core::fmt::Write for FmtWriteAdapter<T>
where
	T: Write + Sized,
{
	fn write_str(&mut self, s: &str) -> core::fmt::Result {
		self.inner.write(s.as_bytes()).map_err(|e| {
			self.err = Err(e);
			core::fmt::Error
		})
	}
}

pub trait Write {
	fn write(&mut self, buf: &[u8]) -> Written;

	fn write_fmt(&mut self, args: Arguments<'_>) -> Written
	where
		Self: Sized,
	{
		let mut adp = FmtWriteAdapter::new(self);
		let _ = core::fmt::Write::write_fmt(&mut adp, args);

		adp.err
	}
}

impl<T> Write for &mut T
where
	T: Write,
{
	fn write(&mut self, buf: &[u8]) -> Written {
		(**self).write(buf)
	}
}

pub struct WriteCursor<T> {
	at: usize,
	buf: T,
}
impl<T> WriteCursor<T> {
	pub fn new(buf: T) -> Self {
		Self { at: 0, buf }
	}

	pub fn reset(&mut self) {
		self.at = 0;
	}

	pub fn remaining_mut(&mut self) -> &mut [u8]
	where
		T: AsMut<[u8]>,
	{
		&mut self.buf.as_mut()[self.at..]
	}

	pub fn written(&mut self) -> &[u8]
	where
		T: AsRef<[u8]>,
	{
		&self.buf.as_ref()[..self.at]
	}
}

impl<T> Write for WriteCursor<T>
where
	T: AsMut<[u8]>,
{
	fn write(&mut self, buf: &[u8]) -> Written {
		let remaining = self.remaining_mut();
		if buf.len() > remaining.len() {
			return Err(Error::from(ErrorKind::BufNotBigEnough));
		}

		remaining[..buf.len()].copy_from_slice(buf);
		self.at += buf.len();

		Ok(())
	}
}

pub type Written = Result<(), Error>;

pub fn status_line(sl: &StatusLine, mut w: impl Write) -> Written {
	write!(
		w,
		"{} {} {}\r\n",
		sl.version, sl.status_code, sl.status_text
	)
}

pub fn request_line(rl: &RequestLine, mut w: impl Write) -> Written {
	write!(w, "{} {} {}\r\n", rl.method, rl.target, rl.version)
}

pub fn header(h: &Header, mut w: impl Write) -> Written {
	match h {
		Header::Special(h) => match h {
			HeaderSpecial::TransferEncodingChunked => write!(w, "Transfer-Encoding: Chunked"),
			HeaderSpecial::ContentLength(cl) => write!(w, "Content-Length: {}", cl),
		},
		Header::Other(HeaderOther { name, value }) => {
			write!(w, "{name}: ")?;
			w.write(value)
		},
	}?;

	write!(w, "\r\n")
}