hyper_simple_server/
accepter.rs

1
2
3use crate::prelude::*;
4
5
6
7
8#[ cfg (feature = "hss-accepter") ]
9pub enum Accepter {
10	TcpListener (Arc<tokio::TcpListener>),
11	#[ cfg (feature = "hss-tls-rust") ]
12	RustTlsTcpListener (Arc<tokio_rustls::TlsAcceptor>, Arc<tokio::TcpListener>),
13	#[ cfg (feature = "hss-tls-native") ]
14	NativeTlsTcpListener (Arc<tokio_natls::TlsAcceptor>, Arc<tokio::TcpListener>),
15}
16
17
18
19
20#[ cfg (feature = "hss-accepter") ]
21impl Accepter {
22	
23	pub fn poll (self : Pin<&mut Self>, _context : &mut Context<'_>) -> Poll<Option<ServerResult<Connection>>> {
24		
25		let _self = Pin::into_inner (self);
26		
27		let _listener = _self.listener ();
28		let (_socket, _address) = match futures::ready! (_listener.poll_accept (_context)) {
29			Ok ((_socket, _address)) =>
30				(_socket, _address),
31			Err (_error) =>
32				return Poll::Ready (Some (Err (_error))),
33		};
34		
35		match _self {
36			
37			Accepter::TcpListener (_) => {
38				let _connection = Connection::TcpStream (_socket, _address);
39				Poll::Ready (Some (Ok (_connection)))
40			}
41			
42			#[ cfg (feature = "hss-tls-rust") ]
43			Accepter::RustTlsTcpListener (_tls, _) => {
44				let _accepter = _tls.accept (_socket);
45				let _connection = Connection::RustTlsTcpStreamPending (_accepter, _address);
46				Poll::Ready (Some (Ok (_connection)))
47			}
48			
49			#[ cfg (feature = "hss-tls-native") ]
50			Accepter::NativeTlsTcpListener (_tls, _) => {
51				let _tls = _tls.clone ();
52				#[ allow (unsafe_code) ]
53				let _tls_static = unsafe { mem::transmute::<&tokio_natls::TlsAcceptor, &'static tokio_natls::TlsAcceptor> (_tls.deref ()) };
54				let _accepter = _tls_static.accept (_socket);
55				let _accepter = Box::pin (_accepter);
56				let _connection = Connection::NativeTlsTcpStreamPending (_tls, _accepter, _address);
57				Poll::Ready (Some (Ok (_connection)))
58			}
59		}
60	}
61}
62
63
64
65
66#[ cfg (feature = "hss-accepter") ]
67impl Accepter {
68	
69	pub fn new (_endpoint : &Endpoint) -> ServerResult<Self> {
70		
71		let _listener = new_listener (&_endpoint.address) ?;
72		let _listener = Arc::new (_listener);
73		
74		match &_endpoint.security {
75			
76			EndpointSecurity::Insecure =>
77				Ok (Accepter::TcpListener (_listener)),
78			
79			#[ cfg (feature = "hss-tls-rust") ]
80			EndpointSecurity::RustTls (_certificate) => {
81				let _accepter = new_rustls_accepter (_certificate, &_endpoint.protocol) ?;
82				Ok (Accepter::RustTlsTcpListener (Arc::new (_accepter), _listener))
83			}
84			
85			#[ cfg (feature = "hss-tls-native") ]
86			EndpointSecurity::NativeTls (_certificate) => {
87				let _accepter = new_native_accepter (_certificate, &_endpoint.protocol) ?;
88				Ok (Accepter::NativeTlsTcpListener (Arc::new (_accepter), _listener))
89			}
90		}
91	}
92	
93	pub(crate) fn listener (&self) -> &tokio::TcpListener {
94		match self {
95			Accepter::TcpListener (_listener) =>
96				_listener,
97			#[ cfg (feature = "hss-tls-rust") ]
98			Accepter::RustTlsTcpListener (_, _listener) =>
99				_listener,
100			#[ cfg (feature = "hss-tls-native") ]
101			Accepter::NativeTlsTcpListener (_, _listener) =>
102				_listener,
103		}
104	}
105}
106
107
108
109
110#[ cfg (feature = "hss-accepter") ]
111#[ cfg (feature = "hyper--server") ]
112impl hyper::Accept for Accepter {
113	
114	type Conn = Connection;
115	type Error = ServerError;
116	
117	fn poll_accept (self : Pin<&mut Self>, _context : &mut Context<'_>) -> Poll<Option<Result<Self::Conn, Self::Error>>> {
118		self.poll (_context)
119	}
120}
121
122
123
124
125#[ cfg (feature = "hss-accepter") ]
126fn new_listener (_address : &EndpointAddress) -> ServerResult<tokio::TcpListener> {
127	
128	#[ allow (unsafe_code) ]
129	let _listener = match _address {
130		EndpointAddress::Socket (_address) =>
131			net::TcpListener::bind (_address) ?,
132		#[ cfg (unix) ]
133		EndpointAddress::Descriptor (_descriptor) =>
134			unsafe {
135				os::unix::io::FromRawFd::from_raw_fd (*_descriptor as i32)
136			},
137	};
138	
139	_listener.set_nonblocking (true) ?;
140	
141	let _listener = tokio::TcpListener::from_std (_listener) ?;
142	
143	Ok (_listener)
144}
145
146
147
148
149#[ cfg (feature = "hss-accepter") ]
150#[ cfg (feature = "hss-tls-rust") ]
151fn new_rustls_accepter (_certificate : &RustTlsCertificate, _protocol : &EndpointProtocol) -> ServerResult<tokio_rustls::TlsAcceptor> {
152	
153	let _resolver = {
154		struct Resolver (RustTlsCertificate);
155		impl rustls::ResolvesServerCert for Resolver {
156			fn resolve (&self, _ : rustls::ClientHello<'_>) -> Option<rustls::sign::CertifiedKey> {
157				Some (self.0.certified.clone ())
158			}
159		}
160		Resolver (_certificate.clone ())
161	};
162	
163	let _configuration = {
164		let mut _builder = rustls::ServerConfig::new (rustls::NoClientAuth::new ());
165		_builder.cert_resolver = Arc::new (_resolver);
166		if _protocol.supports_http1 () {
167			_builder.alpn_protocols.push ("http/1.1".into ());
168		}
169		if _protocol.supports_http2 () {
170			_builder.alpn_protocols.push ("h2".into ());
171		}
172		Arc::new (_builder)
173	};
174	
175	let _accepter = tokio_rustls::TlsAcceptor::from (_configuration);
176	
177	Ok (_accepter)
178}
179
180
181
182
183#[ cfg (feature = "hss-accepter") ]
184#[ cfg (feature = "hss-tls-native") ]
185fn new_native_accepter (_certificate : &NativeTlsCertificate, _protocol : &EndpointProtocol) -> ServerResult<tokio_natls::TlsAcceptor> {
186	
187	let _configuration = {
188		let mut _builder = natls::TlsAcceptor::builder (_certificate.identity.clone ());
189		_builder.min_protocol_version (Some (natls::Protocol::Tlsv12));
190		_builder.build () .or_wrap (0xaf2c7136) ?
191	};
192	
193	let _accepter = tokio_natls::TlsAcceptor::from (_configuration);
194	
195	Ok (_accepter)
196}
197
hyper_simple_server/accepter.rs

hyper_simple_server/
accepter.rs
