2021-03-11 03:48:38 +00:00
|
|
|
use std::{
|
|
|
|
fmt,
|
|
|
|
future::Future,
|
|
|
|
marker::PhantomData,
|
|
|
|
net,
|
|
|
|
pin::Pin,
|
|
|
|
rc::Rc,
|
|
|
|
task::{Context, Poll},
|
|
|
|
};
|
2019-03-07 06:56:34 +00:00
|
|
|
|
2019-04-08 21:51:16 +00:00
|
|
|
use actix_codec::{AsyncRead, AsyncWrite, Framed};
|
2019-12-02 11:33:11 +00:00
|
|
|
use actix_rt::net::TcpStream;
|
2021-04-16 19:28:21 +00:00
|
|
|
use actix_service::{
|
|
|
|
fn_service, IntoServiceFactory, Service, ServiceFactory, ServiceFactoryExt as _,
|
|
|
|
};
|
2021-03-30 02:06:16 +00:00
|
|
|
use futures_core::{future::LocalBoxFuture, ready};
|
2021-12-04 19:40:47 +00:00
|
|
|
use pin_project_lite::pin_project;
|
2022-03-10 03:12:29 +00:00
|
|
|
use tracing::error;
|
2019-03-07 06:56:34 +00:00
|
|
|
|
2021-06-17 16:57:58 +00:00
|
|
|
use crate::{
|
2021-12-04 19:40:47 +00:00
|
|
|
body::{BoxBody, MessageBody},
|
2021-06-17 16:57:58 +00:00
|
|
|
builder::HttpServiceBuilder,
|
|
|
|
error::DispatchError,
|
2022-01-31 21:22:23 +00:00
|
|
|
h1, ConnectCallback, OnConnectData, Protocol, Request, Response, ServiceConfig,
|
2021-06-17 16:57:58 +00:00
|
|
|
};
|
2019-03-07 06:56:34 +00:00
|
|
|
|
2020-10-30 02:03:26 +00:00
|
|
|
/// A `ServiceFactory` for HTTP/1.1 or HTTP/2 protocol.
|
2021-01-03 23:47:04 +00:00
|
|
|
pub struct HttpService<T, S, B, X = h1::ExpectHandler, U = h1::UpgradeHandler> {
|
2019-03-07 06:56:34 +00:00
|
|
|
srv: S,
|
|
|
|
cfg: ServiceConfig,
|
2019-04-05 23:46:44 +00:00
|
|
|
expect: X,
|
2019-04-08 21:51:16 +00:00
|
|
|
upgrade: Option<U>,
|
2020-10-30 02:03:26 +00:00
|
|
|
on_connect_ext: Option<Rc<ConnectCallback<T>>>,
|
2021-01-04 00:49:02 +00:00
|
|
|
_phantom: PhantomData<B>,
|
2019-03-07 06:56:34 +00:00
|
|
|
}
|
|
|
|
|
2019-12-02 11:33:11 +00:00
|
|
|
impl<T, S, B> HttpService<T, S, B>
|
2019-03-11 22:09:42 +00:00
|
|
|
where
|
2021-01-03 23:47:04 +00:00
|
|
|
S: ServiceFactory<Request, Config = ()>,
|
2021-12-04 19:40:47 +00:00
|
|
|
S::Error: Into<Response<BoxBody>> + 'static,
|
2019-04-05 23:46:44 +00:00
|
|
|
S::InitError: fmt::Debug,
|
2019-11-19 12:54:19 +00:00
|
|
|
S::Response: Into<Response<B>> + 'static,
|
2021-01-03 23:47:04 +00:00
|
|
|
<S::Service as Service<Request>>::Future: 'static,
|
2019-03-11 22:09:42 +00:00
|
|
|
B: MessageBody + 'static,
|
|
|
|
{
|
2022-01-31 17:30:34 +00:00
|
|
|
/// Constructs builder for `HttpService` instance.
|
2019-03-11 22:09:42 +00:00
|
|
|
pub fn build() -> HttpServiceBuilder<T, S> {
|
2022-01-31 17:30:34 +00:00
|
|
|
HttpServiceBuilder::default()
|
2019-03-11 22:09:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-02 11:33:11 +00:00
|
|
|
impl<T, S, B> HttpService<T, S, B>
|
2019-03-07 06:56:34 +00:00
|
|
|
where
|
2021-01-03 23:47:04 +00:00
|
|
|
S: ServiceFactory<Request, Config = ()>,
|
2021-12-04 19:40:47 +00:00
|
|
|
S::Error: Into<Response<BoxBody>> + 'static,
|
2019-04-05 23:46:44 +00:00
|
|
|
S::InitError: fmt::Debug,
|
2019-11-19 12:54:19 +00:00
|
|
|
S::Response: Into<Response<B>> + 'static,
|
2021-01-03 23:47:04 +00:00
|
|
|
<S::Service as Service<Request>>::Future: 'static,
|
2019-03-07 06:56:34 +00:00
|
|
|
B: MessageBody + 'static,
|
|
|
|
{
|
2022-01-31 17:30:34 +00:00
|
|
|
/// Constructs new `HttpService` instance from service with default config.
|
2021-01-03 23:47:04 +00:00
|
|
|
pub fn new<F: IntoServiceFactory<S, Request>>(service: F) -> Self {
|
2019-03-07 06:56:34 +00:00
|
|
|
HttpService {
|
2022-01-31 17:30:34 +00:00
|
|
|
cfg: ServiceConfig::default(),
|
2019-11-15 09:54:11 +00:00
|
|
|
srv: service.into_factory(),
|
2019-04-05 23:46:44 +00:00
|
|
|
expect: h1::ExpectHandler,
|
2019-04-08 21:51:16 +00:00
|
|
|
upgrade: None,
|
2020-10-30 02:03:26 +00:00
|
|
|
on_connect_ext: None,
|
2021-01-04 00:49:02 +00:00
|
|
|
_phantom: PhantomData,
|
2019-03-07 06:59:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-31 17:30:34 +00:00
|
|
|
/// Constructs new `HttpService` instance from config and service.
|
2021-01-03 23:47:04 +00:00
|
|
|
pub(crate) fn with_config<F: IntoServiceFactory<S, Request>>(
|
2019-03-07 06:59:56 +00:00
|
|
|
cfg: ServiceConfig,
|
|
|
|
service: F,
|
|
|
|
) -> Self {
|
|
|
|
HttpService {
|
|
|
|
cfg,
|
2019-11-15 09:54:11 +00:00
|
|
|
srv: service.into_factory(),
|
2019-04-05 23:46:44 +00:00
|
|
|
expect: h1::ExpectHandler,
|
2019-04-08 21:51:16 +00:00
|
|
|
upgrade: None,
|
2020-10-30 02:03:26 +00:00
|
|
|
on_connect_ext: None,
|
2021-01-04 00:49:02 +00:00
|
|
|
_phantom: PhantomData,
|
2019-03-07 06:56:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-02 11:33:11 +00:00
|
|
|
impl<T, S, B, X, U> HttpService<T, S, B, X, U>
|
2019-04-05 23:46:44 +00:00
|
|
|
where
|
2021-01-03 23:47:04 +00:00
|
|
|
S: ServiceFactory<Request, Config = ()>,
|
2021-12-04 19:40:47 +00:00
|
|
|
S::Error: Into<Response<BoxBody>> + 'static,
|
2019-04-05 23:46:44 +00:00
|
|
|
S::InitError: fmt::Debug,
|
2019-11-19 12:54:19 +00:00
|
|
|
S::Response: Into<Response<B>> + 'static,
|
2021-01-03 23:47:04 +00:00
|
|
|
<S::Service as Service<Request>>::Future: 'static,
|
2019-04-05 23:46:44 +00:00
|
|
|
B: MessageBody,
|
|
|
|
{
|
2022-01-31 17:30:34 +00:00
|
|
|
/// Sets service for `Expect: 100-Continue` handling.
|
2019-04-05 23:46:44 +00:00
|
|
|
///
|
2022-01-31 17:30:34 +00:00
|
|
|
/// An expect service is called with requests that contain an `Expect` header. A successful
|
|
|
|
/// response type is also a request which will be forwarded to the main service.
|
2019-12-02 11:33:11 +00:00
|
|
|
pub fn expect<X1>(self, expect: X1) -> HttpService<T, S, B, X1, U>
|
2019-04-05 23:46:44 +00:00
|
|
|
where
|
2021-01-03 23:47:04 +00:00
|
|
|
X1: ServiceFactory<Request, Config = (), Response = Request>,
|
2021-12-04 19:40:47 +00:00
|
|
|
X1::Error: Into<Response<BoxBody>>,
|
2019-04-08 21:51:16 +00:00
|
|
|
X1::InitError: fmt::Debug,
|
2019-04-05 23:46:44 +00:00
|
|
|
{
|
|
|
|
HttpService {
|
|
|
|
expect,
|
|
|
|
cfg: self.cfg,
|
|
|
|
srv: self.srv,
|
2019-04-08 21:51:16 +00:00
|
|
|
upgrade: self.upgrade,
|
2020-10-30 02:03:26 +00:00
|
|
|
on_connect_ext: self.on_connect_ext,
|
2021-01-04 00:49:02 +00:00
|
|
|
_phantom: PhantomData,
|
2019-04-08 21:51:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-31 17:30:34 +00:00
|
|
|
/// Sets service for custom `Connection: Upgrade` handling.
|
2019-04-08 21:51:16 +00:00
|
|
|
///
|
2022-01-31 17:30:34 +00:00
|
|
|
/// If service is provided then normal requests handling get halted and this service get called
|
|
|
|
/// with original request and framed object.
|
2019-12-02 11:33:11 +00:00
|
|
|
pub fn upgrade<U1>(self, upgrade: Option<U1>) -> HttpService<T, S, B, X, U1>
|
2019-04-08 21:51:16 +00:00
|
|
|
where
|
2021-01-03 23:47:04 +00:00
|
|
|
U1: ServiceFactory<(Request, Framed<T, h1::Codec>), Config = (), Response = ()>,
|
2019-04-08 21:51:16 +00:00
|
|
|
U1::Error: fmt::Display,
|
|
|
|
U1::InitError: fmt::Debug,
|
|
|
|
{
|
|
|
|
HttpService {
|
|
|
|
upgrade,
|
|
|
|
cfg: self.cfg,
|
|
|
|
srv: self.srv,
|
|
|
|
expect: self.expect,
|
2020-10-30 02:03:26 +00:00
|
|
|
on_connect_ext: self.on_connect_ext,
|
2021-01-04 00:49:02 +00:00
|
|
|
_phantom: PhantomData,
|
2019-04-05 23:46:44 +00:00
|
|
|
}
|
|
|
|
}
|
2019-06-28 08:34:26 +00:00
|
|
|
|
2020-10-30 02:03:26 +00:00
|
|
|
/// Set connect callback with mutable access to request data container.
|
|
|
|
pub(crate) fn on_connect_ext(mut self, f: Option<Rc<ConnectCallback<T>>>) -> Self {
|
|
|
|
self.on_connect_ext = f;
|
|
|
|
self
|
|
|
|
}
|
2019-04-05 23:46:44 +00:00
|
|
|
}
|
|
|
|
|
2019-12-02 11:33:11 +00:00
|
|
|
impl<S, B, X, U> HttpService<TcpStream, S, B, X, U>
|
2019-03-07 06:56:34 +00:00
|
|
|
where
|
2021-01-03 23:47:04 +00:00
|
|
|
S: ServiceFactory<Request, Config = ()>,
|
2021-03-30 02:06:16 +00:00
|
|
|
S::Future: 'static,
|
2021-12-04 19:40:47 +00:00
|
|
|
S::Error: Into<Response<BoxBody>> + 'static,
|
2019-04-05 23:46:44 +00:00
|
|
|
S::InitError: fmt::Debug,
|
2019-11-19 12:54:19 +00:00
|
|
|
S::Response: Into<Response<B>> + 'static,
|
2021-01-03 23:47:04 +00:00
|
|
|
<S::Service as Service<Request>>::Future: 'static,
|
2021-04-02 07:26:59 +00:00
|
|
|
|
2019-03-07 06:56:34 +00:00
|
|
|
B: MessageBody + 'static,
|
2021-04-02 07:26:59 +00:00
|
|
|
|
2021-01-03 23:47:04 +00:00
|
|
|
X: ServiceFactory<Request, Config = (), Response = Request>,
|
2021-03-30 02:06:16 +00:00
|
|
|
X::Future: 'static,
|
2021-12-04 19:40:47 +00:00
|
|
|
X::Error: Into<Response<BoxBody>>,
|
2019-04-05 23:46:44 +00:00
|
|
|
X::InitError: fmt::Debug,
|
2021-04-02 07:26:59 +00:00
|
|
|
|
2021-12-08 06:01:11 +00:00
|
|
|
U: ServiceFactory<(Request, Framed<TcpStream, h1::Codec>), Config = (), Response = ()>,
|
2021-03-30 02:06:16 +00:00
|
|
|
U::Future: 'static,
|
2021-12-04 19:40:47 +00:00
|
|
|
U::Error: fmt::Display + Into<Response<BoxBody>>,
|
2019-12-02 11:33:11 +00:00
|
|
|
U::InitError: fmt::Debug,
|
|
|
|
{
|
|
|
|
/// Create simple tcp stream service
|
|
|
|
pub fn tcp(
|
|
|
|
self,
|
|
|
|
) -> impl ServiceFactory<
|
2021-01-03 23:47:04 +00:00
|
|
|
TcpStream,
|
2019-12-02 11:33:11 +00:00
|
|
|
Config = (),
|
|
|
|
Response = (),
|
|
|
|
Error = DispatchError,
|
|
|
|
InitError = (),
|
|
|
|
> {
|
2021-04-16 19:28:21 +00:00
|
|
|
fn_service(|io: TcpStream| async {
|
2019-12-02 11:33:11 +00:00
|
|
|
let peer_addr = io.peer_addr().ok();
|
2021-01-07 00:57:34 +00:00
|
|
|
Ok((io, Protocol::Http1, peer_addr))
|
2019-12-02 11:33:11 +00:00
|
|
|
})
|
|
|
|
.and_then(self)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(feature = "openssl")]
|
|
|
|
mod openssl {
|
2021-11-22 15:37:23 +00:00
|
|
|
use actix_service::ServiceFactoryExt as _;
|
|
|
|
use actix_tls::accept::{
|
2021-11-30 14:12:04 +00:00
|
|
|
openssl::{
|
|
|
|
reexports::{Error as SslError, SslAcceptor},
|
|
|
|
Acceptor, TlsStream,
|
|
|
|
},
|
2021-11-22 15:37:23 +00:00
|
|
|
TlsError,
|
|
|
|
};
|
2019-12-02 11:33:11 +00:00
|
|
|
|
2021-04-02 07:26:59 +00:00
|
|
|
use super::*;
|
|
|
|
|
2021-02-27 19:57:09 +00:00
|
|
|
impl<S, B, X, U> HttpService<TlsStream<TcpStream>, S, B, X, U>
|
2019-12-02 11:33:11 +00:00
|
|
|
where
|
2021-01-03 23:47:04 +00:00
|
|
|
S: ServiceFactory<Request, Config = ()>,
|
2021-03-30 02:06:16 +00:00
|
|
|
S::Future: 'static,
|
2021-12-04 19:40:47 +00:00
|
|
|
S::Error: Into<Response<BoxBody>> + 'static,
|
2019-12-02 11:33:11 +00:00
|
|
|
S::InitError: fmt::Debug,
|
|
|
|
S::Response: Into<Response<B>> + 'static,
|
2021-01-03 23:47:04 +00:00
|
|
|
<S::Service as Service<Request>>::Future: 'static,
|
2021-04-02 07:26:59 +00:00
|
|
|
|
2019-12-02 11:33:11 +00:00
|
|
|
B: MessageBody + 'static,
|
2021-04-02 07:26:59 +00:00
|
|
|
|
2021-01-03 23:47:04 +00:00
|
|
|
X: ServiceFactory<Request, Config = (), Response = Request>,
|
2021-03-30 02:06:16 +00:00
|
|
|
X::Future: 'static,
|
2021-12-04 19:40:47 +00:00
|
|
|
X::Error: Into<Response<BoxBody>>,
|
2019-12-02 11:33:11 +00:00
|
|
|
X::InitError: fmt::Debug,
|
2021-04-02 07:26:59 +00:00
|
|
|
|
2019-12-02 11:33:11 +00:00
|
|
|
U: ServiceFactory<
|
2021-02-27 19:57:09 +00:00
|
|
|
(Request, Framed<TlsStream<TcpStream>, h1::Codec>),
|
2019-12-02 11:33:11 +00:00
|
|
|
Config = (),
|
|
|
|
Response = (),
|
|
|
|
>,
|
2021-03-30 02:06:16 +00:00
|
|
|
U::Future: 'static,
|
2021-12-04 19:40:47 +00:00
|
|
|
U::Error: fmt::Display + Into<Response<BoxBody>>,
|
2019-12-02 11:33:11 +00:00
|
|
|
U::InitError: fmt::Debug,
|
|
|
|
{
|
2021-11-22 15:37:23 +00:00
|
|
|
/// Create OpenSSL based service.
|
2019-12-02 11:33:11 +00:00
|
|
|
pub fn openssl(
|
|
|
|
self,
|
|
|
|
acceptor: SslAcceptor,
|
|
|
|
) -> impl ServiceFactory<
|
2021-01-03 23:47:04 +00:00
|
|
|
TcpStream,
|
2019-12-02 11:33:11 +00:00
|
|
|
Config = (),
|
|
|
|
Response = (),
|
2021-01-03 23:47:04 +00:00
|
|
|
Error = TlsError<SslError, DispatchError>,
|
2019-12-02 11:33:11 +00:00
|
|
|
InitError = (),
|
|
|
|
> {
|
2021-04-16 19:28:21 +00:00
|
|
|
Acceptor::new(acceptor)
|
2021-11-22 15:37:23 +00:00
|
|
|
.map_init_err(|_| {
|
|
|
|
unreachable!("TLS acceptor service factory does not error on init")
|
|
|
|
})
|
|
|
|
.map_err(TlsError::into_service_error)
|
|
|
|
.map(|io: TlsStream<TcpStream>| {
|
2021-04-16 19:28:21 +00:00
|
|
|
let proto = if let Some(protos) = io.ssl().selected_alpn_protocol() {
|
|
|
|
if protos.windows(2).any(|window| window == b"h2") {
|
|
|
|
Protocol::Http2
|
|
|
|
} else {
|
|
|
|
Protocol::Http1
|
|
|
|
}
|
2019-12-02 11:33:11 +00:00
|
|
|
} else {
|
|
|
|
Protocol::Http1
|
2021-04-16 19:28:21 +00:00
|
|
|
};
|
2021-11-22 15:37:23 +00:00
|
|
|
|
2021-04-16 19:28:21 +00:00
|
|
|
let peer_addr = io.get_ref().peer_addr().ok();
|
2021-11-22 15:37:23 +00:00
|
|
|
(io, proto, peer_addr)
|
2021-04-16 19:28:21 +00:00
|
|
|
})
|
|
|
|
.and_then(self.map_err(TlsError::Service))
|
2019-12-02 11:33:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-12-05 17:35:43 +00:00
|
|
|
#[cfg(feature = "rustls")]
|
|
|
|
mod rustls {
|
|
|
|
use std::io;
|
|
|
|
|
2021-11-22 15:37:23 +00:00
|
|
|
use actix_service::ServiceFactoryExt as _;
|
|
|
|
use actix_tls::accept::{
|
2021-11-30 14:12:04 +00:00
|
|
|
rustls::{reexports::ServerConfig, Acceptor, TlsStream},
|
2021-11-22 15:37:23 +00:00
|
|
|
TlsError,
|
|
|
|
};
|
2021-01-03 23:47:04 +00:00
|
|
|
|
|
|
|
use super::*;
|
|
|
|
|
2019-12-05 17:35:43 +00:00
|
|
|
impl<S, B, X, U> HttpService<TlsStream<TcpStream>, S, B, X, U>
|
|
|
|
where
|
2021-01-03 23:47:04 +00:00
|
|
|
S: ServiceFactory<Request, Config = ()>,
|
2021-03-30 02:06:16 +00:00
|
|
|
S::Future: 'static,
|
2021-12-04 19:40:47 +00:00
|
|
|
S::Error: Into<Response<BoxBody>> + 'static,
|
2019-12-05 17:35:43 +00:00
|
|
|
S::InitError: fmt::Debug,
|
|
|
|
S::Response: Into<Response<B>> + 'static,
|
2021-01-03 23:47:04 +00:00
|
|
|
<S::Service as Service<Request>>::Future: 'static,
|
2021-04-02 07:26:59 +00:00
|
|
|
|
2019-12-05 17:35:43 +00:00
|
|
|
B: MessageBody + 'static,
|
2021-04-02 07:26:59 +00:00
|
|
|
|
2021-01-03 23:47:04 +00:00
|
|
|
X: ServiceFactory<Request, Config = (), Response = Request>,
|
2021-03-30 02:06:16 +00:00
|
|
|
X::Future: 'static,
|
2021-12-04 19:40:47 +00:00
|
|
|
X::Error: Into<Response<BoxBody>>,
|
2019-12-05 17:35:43 +00:00
|
|
|
X::InitError: fmt::Debug,
|
2021-04-02 07:26:59 +00:00
|
|
|
|
2019-12-05 17:35:43 +00:00
|
|
|
U: ServiceFactory<
|
2021-01-03 23:47:04 +00:00
|
|
|
(Request, Framed<TlsStream<TcpStream>, h1::Codec>),
|
2019-12-05 17:35:43 +00:00
|
|
|
Config = (),
|
|
|
|
Response = (),
|
|
|
|
>,
|
2021-03-30 02:06:16 +00:00
|
|
|
U::Future: 'static,
|
2021-12-04 19:40:47 +00:00
|
|
|
U::Error: fmt::Display + Into<Response<BoxBody>>,
|
2019-12-05 17:35:43 +00:00
|
|
|
U::InitError: fmt::Debug,
|
|
|
|
{
|
2021-11-22 15:37:23 +00:00
|
|
|
/// Create Rustls based service.
|
2019-12-05 17:35:43 +00:00
|
|
|
pub fn rustls(
|
|
|
|
self,
|
|
|
|
mut config: ServerConfig,
|
|
|
|
) -> impl ServiceFactory<
|
2021-01-03 23:47:04 +00:00
|
|
|
TcpStream,
|
2019-12-05 17:35:43 +00:00
|
|
|
Config = (),
|
|
|
|
Response = (),
|
2020-09-09 08:20:54 +00:00
|
|
|
Error = TlsError<io::Error, DispatchError>,
|
2019-12-05 17:35:43 +00:00
|
|
|
InitError = (),
|
|
|
|
> {
|
2021-06-10 15:25:21 +00:00
|
|
|
let mut protos = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
|
|
|
|
protos.extend_from_slice(&config.alpn_protocols);
|
2021-10-20 01:00:11 +00:00
|
|
|
config.alpn_protocols = protos;
|
2019-12-05 17:35:43 +00:00
|
|
|
|
2021-04-16 19:28:21 +00:00
|
|
|
Acceptor::new(config)
|
2021-11-22 15:37:23 +00:00
|
|
|
.map_init_err(|_| {
|
|
|
|
unreachable!("TLS acceptor service factory does not error on init")
|
|
|
|
})
|
|
|
|
.map_err(TlsError::into_service_error)
|
2021-04-16 19:28:21 +00:00
|
|
|
.and_then(|io: TlsStream<TcpStream>| async {
|
2021-10-20 01:00:11 +00:00
|
|
|
let proto = if let Some(protos) = io.get_ref().1.alpn_protocol() {
|
2021-04-16 19:28:21 +00:00
|
|
|
if protos.windows(2).any(|window| window == b"h2") {
|
|
|
|
Protocol::Http2
|
|
|
|
} else {
|
|
|
|
Protocol::Http1
|
|
|
|
}
|
2019-12-05 17:35:43 +00:00
|
|
|
} else {
|
|
|
|
Protocol::Http1
|
2021-04-16 19:28:21 +00:00
|
|
|
};
|
|
|
|
let peer_addr = io.get_ref().0.peer_addr().ok();
|
|
|
|
Ok((io, proto, peer_addr))
|
|
|
|
})
|
|
|
|
.and_then(self.map_err(TlsError::Service))
|
2019-12-05 17:35:43 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-03 23:47:04 +00:00
|
|
|
impl<T, S, B, X, U> ServiceFactory<(T, Protocol, Option<net::SocketAddr>)>
|
|
|
|
for HttpService<T, S, B, X, U>
|
2019-12-02 11:33:11 +00:00
|
|
|
where
|
2021-03-30 02:06:16 +00:00
|
|
|
T: AsyncRead + AsyncWrite + Unpin + 'static,
|
2021-04-02 07:26:59 +00:00
|
|
|
|
2021-01-03 23:47:04 +00:00
|
|
|
S: ServiceFactory<Request, Config = ()>,
|
2021-03-30 02:06:16 +00:00
|
|
|
S::Future: 'static,
|
2021-12-04 19:40:47 +00:00
|
|
|
S::Error: Into<Response<BoxBody>> + 'static,
|
2019-12-02 11:33:11 +00:00
|
|
|
S::InitError: fmt::Debug,
|
|
|
|
S::Response: Into<Response<B>> + 'static,
|
2021-01-03 23:47:04 +00:00
|
|
|
<S::Service as Service<Request>>::Future: 'static,
|
2021-04-02 07:26:59 +00:00
|
|
|
|
2019-12-02 11:33:11 +00:00
|
|
|
B: MessageBody + 'static,
|
2021-04-02 07:26:59 +00:00
|
|
|
|
2021-01-03 23:47:04 +00:00
|
|
|
X: ServiceFactory<Request, Config = (), Response = Request>,
|
2021-03-30 02:06:16 +00:00
|
|
|
X::Future: 'static,
|
2021-12-04 19:40:47 +00:00
|
|
|
X::Error: Into<Response<BoxBody>>,
|
2019-12-02 11:33:11 +00:00
|
|
|
X::InitError: fmt::Debug,
|
2021-04-02 07:26:59 +00:00
|
|
|
|
2021-01-03 23:47:04 +00:00
|
|
|
U: ServiceFactory<(Request, Framed<T, h1::Codec>), Config = (), Response = ()>,
|
2021-03-30 02:06:16 +00:00
|
|
|
U::Future: 'static,
|
2021-12-04 19:40:47 +00:00
|
|
|
U::Error: fmt::Display + Into<Response<BoxBody>>,
|
2019-04-08 21:51:16 +00:00
|
|
|
U::InitError: fmt::Debug,
|
2019-03-07 06:56:34 +00:00
|
|
|
{
|
|
|
|
type Response = ();
|
|
|
|
type Error = DispatchError;
|
2021-01-03 23:47:04 +00:00
|
|
|
type Config = ();
|
2019-12-02 11:33:11 +00:00
|
|
|
type Service = HttpServiceHandler<T, S::Service, B, X::Service, U::Service>;
|
2021-01-03 23:47:04 +00:00
|
|
|
type InitError = ();
|
2021-03-30 02:06:16 +00:00
|
|
|
type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
|
2019-03-07 06:56:34 +00:00
|
|
|
|
2019-12-02 15:37:13 +00:00
|
|
|
fn new_service(&self, _: ()) -> Self::Future {
|
2021-03-30 02:06:16 +00:00
|
|
|
let service = self.srv.new_service(());
|
|
|
|
let expect = self.expect.new_service(());
|
|
|
|
let upgrade = self.upgrade.as_ref().map(|s| s.new_service(()));
|
|
|
|
let on_connect_ext = self.on_connect_ext.clone();
|
|
|
|
let cfg = self.cfg.clone();
|
|
|
|
|
|
|
|
Box::pin(async move {
|
|
|
|
let expect = expect
|
|
|
|
.await
|
2022-03-10 03:12:29 +00:00
|
|
|
.map_err(|e| error!("Init http expect service error: {:?}", e))?;
|
2021-03-30 02:06:16 +00:00
|
|
|
|
|
|
|
let upgrade = match upgrade {
|
|
|
|
Some(upgrade) => {
|
2021-12-08 06:01:11 +00:00
|
|
|
let upgrade = upgrade
|
|
|
|
.await
|
2022-03-10 03:12:29 +00:00
|
|
|
.map_err(|e| error!("Init http upgrade service error: {:?}", e))?;
|
2021-03-30 02:06:16 +00:00
|
|
|
Some(upgrade)
|
|
|
|
}
|
|
|
|
None => None,
|
|
|
|
};
|
|
|
|
|
|
|
|
let service = service
|
|
|
|
.await
|
2022-03-10 03:12:29 +00:00
|
|
|
.map_err(|e| error!("Init http service error: {:?}", e))?;
|
2021-03-30 02:06:16 +00:00
|
|
|
|
|
|
|
Ok(HttpServiceHandler::new(
|
|
|
|
cfg,
|
|
|
|
service,
|
|
|
|
expect,
|
|
|
|
upgrade,
|
|
|
|
on_connect_ext,
|
|
|
|
))
|
|
|
|
})
|
2019-03-07 06:56:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-30 02:06:16 +00:00
|
|
|
/// `Service` implementation for HTTP/1 and HTTP/2 transport
|
|
|
|
pub struct HttpServiceHandler<T, S, B, X, U>
|
2021-01-03 23:47:04 +00:00
|
|
|
where
|
2021-03-30 02:06:16 +00:00
|
|
|
S: Service<Request>,
|
|
|
|
X: Service<Request>,
|
|
|
|
U: Service<(Request, Framed<T, h1::Codec>)>,
|
2021-01-03 23:47:04 +00:00
|
|
|
{
|
2021-03-30 02:06:16 +00:00
|
|
|
pub(super) flow: Rc<HttpFlow<S, X, U>>,
|
|
|
|
pub(super) cfg: ServiceConfig,
|
|
|
|
pub(super) on_connect_ext: Option<Rc<ConnectCallback<T>>>,
|
2021-01-06 18:43:52 +00:00
|
|
|
_phantom: PhantomData<B>,
|
2019-03-07 06:56:34 +00:00
|
|
|
}
|
|
|
|
|
2021-03-30 02:06:16 +00:00
|
|
|
impl<T, S, B, X, U> HttpServiceHandler<T, S, B, X, U>
|
2019-03-07 06:56:34 +00:00
|
|
|
where
|
2021-03-30 02:06:16 +00:00
|
|
|
S: Service<Request>,
|
2021-12-04 19:40:47 +00:00
|
|
|
S::Error: Into<Response<BoxBody>>,
|
2021-03-30 02:06:16 +00:00
|
|
|
X: Service<Request>,
|
2021-12-04 19:40:47 +00:00
|
|
|
X::Error: Into<Response<BoxBody>>,
|
2021-03-30 02:06:16 +00:00
|
|
|
U: Service<(Request, Framed<T, h1::Codec>)>,
|
2021-12-04 19:40:47 +00:00
|
|
|
U::Error: Into<Response<BoxBody>>,
|
2019-03-07 06:56:34 +00:00
|
|
|
{
|
2021-03-30 02:06:16 +00:00
|
|
|
pub(super) fn new(
|
|
|
|
cfg: ServiceConfig,
|
|
|
|
service: S,
|
|
|
|
expect: X,
|
|
|
|
upgrade: Option<U>,
|
|
|
|
on_connect_ext: Option<Rc<ConnectCallback<T>>>,
|
|
|
|
) -> HttpServiceHandler<T, S, B, X, U> {
|
|
|
|
HttpServiceHandler {
|
|
|
|
cfg,
|
|
|
|
on_connect_ext,
|
|
|
|
flow: HttpFlow::new(service, expect, upgrade),
|
|
|
|
_phantom: PhantomData,
|
2019-04-05 23:46:44 +00:00
|
|
|
}
|
2021-03-30 02:06:16 +00:00
|
|
|
}
|
2019-04-05 23:46:44 +00:00
|
|
|
|
2021-06-17 16:57:58 +00:00
|
|
|
pub(super) fn _poll_ready(
|
|
|
|
&self,
|
|
|
|
cx: &mut Context<'_>,
|
2021-12-04 19:40:47 +00:00
|
|
|
) -> Poll<Result<(), Response<BoxBody>>> {
|
2021-03-30 02:06:16 +00:00
|
|
|
ready!(self.flow.expect.poll_ready(cx).map_err(Into::into))?;
|
2019-04-08 21:51:16 +00:00
|
|
|
|
2021-03-30 02:06:16 +00:00
|
|
|
ready!(self.flow.service.poll_ready(cx).map_err(Into::into))?;
|
2020-10-30 02:03:26 +00:00
|
|
|
|
2021-03-30 02:06:16 +00:00
|
|
|
if let Some(ref upg) = self.flow.upgrade {
|
|
|
|
ready!(upg.poll_ready(cx).map_err(Into::into))?;
|
|
|
|
};
|
2019-03-07 06:56:34 +00:00
|
|
|
|
2021-03-30 02:06:16 +00:00
|
|
|
Poll::Ready(Ok(()))
|
|
|
|
}
|
2019-03-07 06:56:34 +00:00
|
|
|
}
|
|
|
|
|
2021-01-06 18:52:06 +00:00
|
|
|
/// A collection of services that describe an HTTP request flow.
|
2021-01-06 18:43:52 +00:00
|
|
|
pub(super) struct HttpFlow<S, X, U> {
|
|
|
|
pub(super) service: S,
|
|
|
|
pub(super) expect: X,
|
|
|
|
pub(super) upgrade: Option<U>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<S, X, U> HttpFlow<S, X, U> {
|
2021-02-07 01:00:40 +00:00
|
|
|
pub(super) fn new(service: S, expect: X, upgrade: Option<U>) -> Rc<Self> {
|
|
|
|
Rc::new(Self {
|
2021-01-06 18:43:52 +00:00
|
|
|
service,
|
|
|
|
expect,
|
|
|
|
upgrade,
|
2021-02-07 01:00:40 +00:00
|
|
|
})
|
2021-01-06 18:43:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-01-03 23:47:04 +00:00
|
|
|
impl<T, S, B, X, U> Service<(T, Protocol, Option<net::SocketAddr>)>
|
|
|
|
for HttpServiceHandler<T, S, B, X, U>
|
2019-03-07 06:56:34 +00:00
|
|
|
where
|
2019-12-02 11:33:11 +00:00
|
|
|
T: AsyncRead + AsyncWrite + Unpin,
|
2021-05-05 17:36:02 +00:00
|
|
|
|
2021-01-03 23:47:04 +00:00
|
|
|
S: Service<Request>,
|
2021-12-04 19:40:47 +00:00
|
|
|
S::Error: Into<Response<BoxBody>> + 'static,
|
2019-11-19 12:54:19 +00:00
|
|
|
S::Future: 'static,
|
|
|
|
S::Response: Into<Response<B>> + 'static,
|
2021-05-05 17:36:02 +00:00
|
|
|
|
2019-03-07 06:56:34 +00:00
|
|
|
B: MessageBody + 'static,
|
2021-05-05 17:36:02 +00:00
|
|
|
|
2021-01-03 23:47:04 +00:00
|
|
|
X: Service<Request, Response = Request>,
|
2021-12-04 19:40:47 +00:00
|
|
|
X::Error: Into<Response<BoxBody>>,
|
2021-05-05 17:36:02 +00:00
|
|
|
|
2021-01-03 23:47:04 +00:00
|
|
|
U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
|
2021-12-04 19:40:47 +00:00
|
|
|
U::Error: fmt::Display + Into<Response<BoxBody>>,
|
2019-03-07 06:56:34 +00:00
|
|
|
{
|
|
|
|
type Response = ();
|
|
|
|
type Error = DispatchError;
|
2019-04-08 21:51:16 +00:00
|
|
|
type Future = HttpServiceHandlerResponse<T, S, B, X, U>;
|
2019-03-07 06:56:34 +00:00
|
|
|
|
2021-02-07 01:00:40 +00:00
|
|
|
fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
|
2021-12-17 01:29:41 +00:00
|
|
|
self._poll_ready(cx).map_err(|err| {
|
2022-03-10 03:12:29 +00:00
|
|
|
error!("HTTP service readiness error: {:?}", err);
|
2021-12-17 01:29:41 +00:00
|
|
|
DispatchError::Service(err)
|
2021-03-30 02:06:16 +00:00
|
|
|
})
|
2019-03-07 06:56:34 +00:00
|
|
|
}
|
|
|
|
|
2021-01-03 23:47:04 +00:00
|
|
|
fn call(
|
2021-02-07 01:00:40 +00:00
|
|
|
&self,
|
2021-01-03 23:47:04 +00:00
|
|
|
(io, proto, peer_addr): (T, Protocol, Option<net::SocketAddr>),
|
|
|
|
) -> Self::Future {
|
2021-12-07 17:23:34 +00:00
|
|
|
let conn_data = OnConnectData::from_io(&io, self.on_connect_ext.as_deref());
|
2019-06-28 08:34:26 +00:00
|
|
|
|
2019-03-11 22:09:42 +00:00
|
|
|
match proto {
|
2022-01-31 21:22:23 +00:00
|
|
|
#[cfg(feature = "http2")]
|
2019-12-02 11:33:11 +00:00
|
|
|
Protocol::Http2 => HttpServiceHandlerResponse {
|
2021-12-04 19:40:47 +00:00
|
|
|
state: State::H2Handshake {
|
|
|
|
handshake: Some((
|
2022-01-31 21:22:23 +00:00
|
|
|
crate::h2::handshake_with_timeout(io, &self.cfg),
|
2021-12-04 19:40:47 +00:00
|
|
|
self.cfg.clone(),
|
|
|
|
self.flow.clone(),
|
2021-12-07 17:23:34 +00:00
|
|
|
conn_data,
|
2021-12-04 19:40:47 +00:00
|
|
|
peer_addr,
|
|
|
|
)),
|
|
|
|
},
|
2019-03-11 22:09:42 +00:00
|
|
|
},
|
2020-10-30 02:03:26 +00:00
|
|
|
|
2022-01-31 21:22:23 +00:00
|
|
|
#[cfg(not(feature = "http2"))]
|
|
|
|
Protocol::Http2 => {
|
|
|
|
panic!("HTTP/2 support is disabled (enable with the `http2` feature flag)")
|
|
|
|
}
|
|
|
|
|
2019-12-02 11:33:11 +00:00
|
|
|
Protocol::Http1 => HttpServiceHandlerResponse {
|
2021-12-04 19:40:47 +00:00
|
|
|
state: State::H1 {
|
|
|
|
dispatcher: h1::Dispatcher::new(
|
|
|
|
io,
|
|
|
|
self.flow.clone(),
|
2021-12-07 17:23:34 +00:00
|
|
|
self.cfg.clone(),
|
2021-12-04 19:40:47 +00:00
|
|
|
peer_addr,
|
2021-12-07 17:23:34 +00:00
|
|
|
conn_data,
|
2021-12-04 19:40:47 +00:00
|
|
|
),
|
|
|
|
},
|
2019-03-11 22:09:42 +00:00
|
|
|
},
|
2021-01-06 18:58:24 +00:00
|
|
|
|
2021-01-07 00:35:19 +00:00
|
|
|
proto => unimplemented!("Unsupported HTTP version: {:?}.", proto),
|
2019-03-07 06:56:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-31 21:22:23 +00:00
|
|
|
#[cfg(not(feature = "http2"))]
|
|
|
|
pin_project! {
|
|
|
|
#[project = StateProj]
|
|
|
|
enum State<T, S, B, X, U>
|
|
|
|
where
|
|
|
|
T: AsyncRead,
|
|
|
|
T: AsyncWrite,
|
|
|
|
T: Unpin,
|
|
|
|
|
|
|
|
S: Service<Request>,
|
|
|
|
S::Future: 'static,
|
|
|
|
S::Error: Into<Response<BoxBody>>,
|
|
|
|
|
|
|
|
B: MessageBody,
|
|
|
|
|
|
|
|
X: Service<Request, Response = Request>,
|
|
|
|
X::Error: Into<Response<BoxBody>>,
|
|
|
|
|
|
|
|
U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
|
|
|
|
U::Error: fmt::Display,
|
|
|
|
{
|
|
|
|
H1 { #[pin] dispatcher: h1::Dispatcher<T, S, B, X, U> },
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(feature = "http2")]
|
2021-12-04 19:40:47 +00:00
|
|
|
pin_project! {
|
|
|
|
#[project = StateProj]
|
|
|
|
enum State<T, S, B, X, U>
|
|
|
|
where
|
|
|
|
T: AsyncRead,
|
|
|
|
T: AsyncWrite,
|
|
|
|
T: Unpin,
|
2021-05-05 17:36:02 +00:00
|
|
|
|
2021-12-04 19:40:47 +00:00
|
|
|
S: Service<Request>,
|
|
|
|
S::Future: 'static,
|
|
|
|
S::Error: Into<Response<BoxBody>>,
|
2021-05-05 17:36:02 +00:00
|
|
|
|
2021-12-04 19:40:47 +00:00
|
|
|
B: MessageBody,
|
2021-05-05 17:36:02 +00:00
|
|
|
|
2021-12-04 19:40:47 +00:00
|
|
|
X: Service<Request, Response = Request>,
|
|
|
|
X::Error: Into<Response<BoxBody>>,
|
2021-05-05 17:36:02 +00:00
|
|
|
|
2021-12-04 19:40:47 +00:00
|
|
|
U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
|
|
|
|
U::Error: fmt::Display,
|
|
|
|
{
|
|
|
|
H1 { #[pin] dispatcher: h1::Dispatcher<T, S, B, X, U> },
|
2022-01-31 21:22:23 +00:00
|
|
|
|
|
|
|
H2 { #[pin] dispatcher: crate::h2::Dispatcher<T, S, B, X, U> },
|
|
|
|
|
2021-12-04 19:40:47 +00:00
|
|
|
H2Handshake {
|
|
|
|
handshake: Option<(
|
2022-01-31 21:22:23 +00:00
|
|
|
crate::h2::HandshakeWithTimeout<T>,
|
2021-12-04 19:40:47 +00:00
|
|
|
ServiceConfig,
|
|
|
|
Rc<HttpFlow<S, X, U>>,
|
|
|
|
OnConnectData,
|
|
|
|
Option<net::SocketAddr>,
|
|
|
|
)>,
|
|
|
|
},
|
|
|
|
}
|
2019-03-07 06:56:34 +00:00
|
|
|
}
|
|
|
|
|
2021-12-04 19:40:47 +00:00
|
|
|
pin_project! {
|
|
|
|
pub struct HttpServiceHandlerResponse<T, S, B, X, U>
|
|
|
|
where
|
|
|
|
T: AsyncRead,
|
|
|
|
T: AsyncWrite,
|
|
|
|
T: Unpin,
|
2021-05-05 17:36:02 +00:00
|
|
|
|
2021-12-04 19:40:47 +00:00
|
|
|
S: Service<Request>,
|
|
|
|
S::Error: Into<Response<BoxBody>>,
|
|
|
|
S::Error: 'static,
|
|
|
|
S::Future: 'static,
|
|
|
|
S::Response: Into<Response<B>>,
|
|
|
|
S::Response: 'static,
|
2021-05-05 17:36:02 +00:00
|
|
|
|
2021-12-04 19:40:47 +00:00
|
|
|
B: MessageBody,
|
2021-05-05 17:36:02 +00:00
|
|
|
|
2021-12-04 19:40:47 +00:00
|
|
|
X: Service<Request, Response = Request>,
|
|
|
|
X::Error: Into<Response<BoxBody>>,
|
2021-05-05 17:36:02 +00:00
|
|
|
|
2021-12-04 19:40:47 +00:00
|
|
|
U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
|
|
|
|
U::Error: fmt::Display,
|
|
|
|
{
|
|
|
|
#[pin]
|
|
|
|
state: State<T, S, B, X, U>,
|
|
|
|
}
|
2019-03-07 06:56:34 +00:00
|
|
|
}
|
|
|
|
|
2019-04-08 21:51:16 +00:00
|
|
|
impl<T, S, B, X, U> Future for HttpServiceHandlerResponse<T, S, B, X, U>
|
2019-03-07 06:56:34 +00:00
|
|
|
where
|
2019-12-02 11:33:11 +00:00
|
|
|
T: AsyncRead + AsyncWrite + Unpin,
|
2021-05-05 17:36:02 +00:00
|
|
|
|
2021-01-03 23:47:04 +00:00
|
|
|
S: Service<Request>,
|
2021-12-04 19:40:47 +00:00
|
|
|
S::Error: Into<Response<BoxBody>> + 'static,
|
2019-11-19 12:54:19 +00:00
|
|
|
S::Future: 'static,
|
|
|
|
S::Response: Into<Response<B>> + 'static,
|
2021-05-05 17:36:02 +00:00
|
|
|
|
|
|
|
B: MessageBody + 'static,
|
|
|
|
|
2021-01-03 23:47:04 +00:00
|
|
|
X: Service<Request, Response = Request>,
|
2021-12-04 19:40:47 +00:00
|
|
|
X::Error: Into<Response<BoxBody>>,
|
2021-05-05 17:36:02 +00:00
|
|
|
|
2021-01-03 23:47:04 +00:00
|
|
|
U: Service<(Request, Framed<T, h1::Codec>), Response = ()>,
|
2019-04-08 21:51:16 +00:00
|
|
|
U::Error: fmt::Display,
|
2019-03-07 06:56:34 +00:00
|
|
|
{
|
2019-11-15 09:54:11 +00:00
|
|
|
type Output = Result<(), DispatchError>;
|
2019-03-07 06:56:34 +00:00
|
|
|
|
2021-01-07 00:57:34 +00:00
|
|
|
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
|
|
|
match self.as_mut().project().state.project() {
|
2021-12-04 19:40:47 +00:00
|
|
|
StateProj::H1 { dispatcher } => dispatcher.poll(cx),
|
2022-01-31 21:22:23 +00:00
|
|
|
|
|
|
|
#[cfg(feature = "http2")]
|
2021-12-04 19:40:47 +00:00
|
|
|
StateProj::H2 { dispatcher } => dispatcher.poll(cx),
|
2022-01-31 21:22:23 +00:00
|
|
|
|
|
|
|
#[cfg(feature = "http2")]
|
2021-12-04 19:40:47 +00:00
|
|
|
StateProj::H2Handshake { handshake: data } => {
|
2021-01-07 00:57:34 +00:00
|
|
|
match ready!(Pin::new(&mut data.as_mut().unwrap().0).poll(cx)) {
|
2021-12-02 18:16:34 +00:00
|
|
|
Ok((conn, timer)) => {
|
2021-12-08 06:01:11 +00:00
|
|
|
let (_, config, flow, conn_data, peer_addr) = data.take().unwrap();
|
2021-12-04 19:40:47 +00:00
|
|
|
|
|
|
|
self.as_mut().project().state.set(State::H2 {
|
2022-01-31 21:22:23 +00:00
|
|
|
dispatcher: crate::h2::Dispatcher::new(
|
2021-12-07 17:23:34 +00:00
|
|
|
conn, flow, config, peer_addr, conn_data, timer,
|
2021-06-17 16:57:58 +00:00
|
|
|
),
|
2021-12-04 19:40:47 +00:00
|
|
|
});
|
2021-01-07 00:57:34 +00:00
|
|
|
self.poll(cx)
|
2019-03-07 06:56:34 +00:00
|
|
|
}
|
2021-01-07 00:57:34 +00:00
|
|
|
Err(err) => {
|
2022-03-10 03:12:29 +00:00
|
|
|
tracing::trace!("H2 handshake error: {}", err);
|
2021-12-02 18:16:34 +00:00
|
|
|
Poll::Ready(Err(err))
|
2021-01-07 00:57:34 +00:00
|
|
|
}
|
|
|
|
}
|
2019-03-07 06:56:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|