1use std::io;
2use std::sync::Arc;
3use std::sync::atomic::{AtomicBool, Ordering};
4use std::time::Duration;
5use std::pin::{pin, Pin};
6
7use yansi::Paint;
8use bytes::Bytes;
9use tokio::sync::{mpsc, oneshot};
10use tokio::time::{sleep, sleep_until, Instant};
11use tokio_stream::wrappers::ReceiverStream;
12use futures::stream::StreamExt;
13use futures::future::{FutureExt, Future, BoxFuture};
14use http_body_util::{Either, Empty, StreamBody};
15use hyper_util::rt::TokioIo;
16
17#[cfg(feature = "http2")]
18use hyper_util::rt::{TokioExecutor, TokioTimer};
19#[cfg(feature = "http2")]
20use hyper_util::server::conn::auto::Builder;
21#[cfg(not(feature = "http2"))]
22use crate::http::hyper::server::conn::http1::Builder;
23
24use crate::{route, Rocket, Orbit, Request, Response, Data, Config};
25use crate::form::Form;
26use crate::outcome::Outcome;
27use crate::error::{Error, ErrorKind};
28use crate::ext::{AsyncReadExt, CancellableListener, LingeringIo};
29use crate::request::ConnectionMeta;
30use crate::data::IoHandler;
31
32use crate::http::{hyper, uncased, Method, Status, Header};
33use crate::http::hyper::body::Frame;
34use crate::http::private::{TcpListener, Listener, Connection, Incoming};
35
36pub(crate) struct RequestToken;
38
39type HttpBody = Either<
40 Empty<Bytes>,
41 StreamBody<ReceiverStream<io::Result<Frame<Bytes>>>>,
42>;
43
44async fn handle<Fut, T, F>(name: Option<&str>, run: F) -> Option<T>
45 where F: FnOnce() -> Fut, Fut: Future<Output = T>,
46{
47 use std::panic::AssertUnwindSafe;
48
49 macro_rules! panic_info {
50 ($name:expr, $e:expr) => {{
51 match $name {
52 Some(name) => error_!("Handler {} panicked.", name.primary()),
53 None => error_!("A handler panicked.")
54 };
55
56 info_!("This is an application bug.");
57 info_!("A panic in Rust must be treated as an exceptional event.");
58 info_!("Panicking is not a suitable error handling mechanism.");
59 info_!("Unwinding, the result of a panic, is an expensive operation.");
60 info_!("Panics will degrade application performance.");
61 info_!("Instead of panicking, return `Option` and/or `Result`.");
62 info_!("Values of either type can be returned directly from handlers.");
63 warn_!("A panic is treated as an internal server error.");
64 $e
65 }}
66 }
67
68 let run = AssertUnwindSafe(run);
69 let fut = std::panic::catch_unwind(move || run())
70 .map_err(|e| panic_info!(name, e))
71 .ok()?;
72
73 AssertUnwindSafe(fut)
74 .catch_unwind()
75 .await
76 .map_err(|e| panic_info!(name, e))
77 .ok()
78}
79
80async fn hyper_service_fn(
85 rocket: Arc<Rocket<Orbit>>,
86 conn: ConnectionMeta,
87 upgraded: Arc<AtomicBool>,
88 mut hyp_req: hyper::Request<hyper::Body>,
89) -> Result<hyper::Response<HttpBody>, io::Error> {
90 let (tx, rx) = oneshot::channel();
94 let version = hyp_req.version();
95
96 #[cfg(not(broken_fmt))]
97 debug!("received request: {:#?}", hyp_req);
98
99 tokio::spawn(async move {
100 let pending_upgrade = hyper::upgrade::on(&mut hyp_req);
102
103 let (h_parts, mut h_body) = hyp_req.into_parts();
105 match Request::from_hyp(&rocket, &h_parts, Some(conn)) {
106 Ok(mut req) => {
107 let mut data = Data::from(&mut h_body);
109 let token = rocket.preprocess_request(&mut req, &mut data).await;
110 let mut response = rocket.dispatch(token, &req, data).await;
111 let upgrade = response.take_upgrade(req.headers().get("upgrade"));
112 if let Ok(Some((proto, handler))) = upgrade {
113 rocket.handle_upgrade(
114 response, proto, handler, pending_upgrade, upgraded, tx, version
115 ).await;
116 } else {
117 if upgrade.is_err() {
118 warn_!("Request wants upgrade but no I/O handler matched.");
119 info_!("Request is not being upgraded.");
120 }
121
122 rocket.send_response(response, tx, version).await;
123 }
124 },
125 Err(e) => {
126 warn!("Bad incoming HTTP request.");
127 e.errors.iter().for_each(|e| warn_!("Error: {}.", e));
128 warn_!("Dispatching salvaged request to catcher: {}.", e.request);
129
130 let response = rocket.handle_error(Status::BadRequest, &e.request).await;
131 rocket.send_response(response, tx, version).await;
132 }
133 }
134 });
135
136 rx.await.map_err(|e| io::Error::new(io::ErrorKind::BrokenPipe, e))
138}
139
140impl Rocket<Orbit> {
141 #[inline]
143 async fn send_response(
144 &self,
145 response: Response<'_>,
146 tx: oneshot::Sender<hyper::Response<HttpBody>>,
147 version: hyper::Version,
148 ) {
149 let remote_hungup = |e: &io::Error| match e.kind() {
150 | io::ErrorKind::BrokenPipe
151 | io::ErrorKind::ConnectionReset
152 | io::ErrorKind::ConnectionAborted => true,
153 _ => false,
154 };
155
156 match self._send_response(response, tx, version).await {
157 Ok(()) => info_!("{}", "Response succeeded.".green()),
158 Err(e) if remote_hungup(&e) => warn_!("Remote left: {}.", e),
159 Err(e) => warn_!("Failed to write response: {}.", e),
160 }
161 }
162
163 #[inline]
165 async fn _send_response(
166 &self,
167 mut response: Response<'_>,
168 tx: oneshot::Sender<hyper::Response<HttpBody>>,
169 version: hyper::Version,
170 ) -> io::Result<()> {
171 if response.headers().contains("Transfer-Encoding") {
172 response.remove_header("Content-Length");
173 } else if let Some(size) = response.body_mut().size().await {
174 response.set_raw_header("Content-Length", size.to_string());
175 }
176
177 let mut hyp_res = hyper::Response::builder();
178
179 hyp_res = hyp_res.status(response.status().code);
180 for header in response.headers().iter() {
181 let name = header.name.as_str();
182 let value = header.value.as_bytes();
183 hyp_res = hyp_res.header(name, value);
184 }
185
186 let send_headers = |body| {
187 let hyp_response = hyp_res.body(body)
188 .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
189
190 #[cfg(not(broken_fmt))]
191 debug!("sending response: {:#?}", hyp_response);
192
193 tx.send(hyp_response).map_err(|_| {
194 let msg = "client disconnect before response started";
195 io::Error::new(io::ErrorKind::BrokenPipe, msg)
196 })
197 };
198
199 if version == hyper::Version::HTTP_2 && response.body().is_empty() {
202 return send_headers(Either::Left(Empty::new()));
203 }
204
205 let (sender, receiver) = mpsc::channel(1);
208 let hyp_body = StreamBody::new(ReceiverStream::new(receiver));
209 send_headers(Either::Right(hyp_body))?;
210
211 let body = response.body_mut();
212 let max_chunk_size = body.max_chunk_size();
213 let mut stream = body.into_bytes_stream(max_chunk_size);
214 while let Some(next) = tokio::select! {
215 biased;
216 next = stream.next() => next,
217 _ = sender.closed() => return Err(io::Error::new(
218 io::ErrorKind::BrokenPipe, "client disconnect during response body"
219 )),
220 } {
221 let bytes = match next {
222 Ok(bytes) => bytes,
223 Err(e) => {
224 let _ = sender.send(Err(io::Error::new(e.kind(), e.to_string()))).await;
227 return Err(e);
228 }
229 };
230
231 sender.send(Ok(Frame::data(bytes))).await
232 .map_err(|e| io::Error::new(io::ErrorKind::BrokenPipe, e))?;
233 }
234
235 Ok(())
236 }
237
238 async fn handle_upgrade<'r>(
239 &self,
240 mut response: Response<'r>,
241 proto: uncased::Uncased<'r>,
242 io_handler: Pin<Box<dyn IoHandler + 'r>>,
243 pending_upgrade: hyper::upgrade::OnUpgrade,
244 upgraded: Arc<AtomicBool>,
245 tx: oneshot::Sender<hyper::Response<HttpBody>>,
246 version: hyper::Version,
247 ) {
248 info_!("Upgrading connection to {}.", Paint::white(&proto).bold());
249 response.set_status(Status::SwitchingProtocols);
250 response.set_raw_header("Connection", "Upgrade");
251 response.set_raw_header("Upgrade", proto.clone().into_cow());
252 self.send_response(response, tx, version).await;
253
254 match pending_upgrade.await {
255 Ok(io_stream) => {
256 info_!("Upgrade successful.");
257
258 upgraded.store(true, Ordering::Release);
261 if let Err(e) = io_handler.io(io_stream.into()).await {
262 if e.kind() == io::ErrorKind::BrokenPipe {
263 warn!("Upgraded {} I/O handler was closed.", proto);
264 } else {
265 error!("Upgraded {} I/O handler failed: {}", proto, e);
266 }
267 }
268 },
269 Err(e) => {
270 warn!("Response indicated upgrade, but upgrade failed.");
271 warn_!("Upgrade error: {}", e);
272 }
273 }
274 }
275
276 pub(crate) async fn preprocess_request(
283 &self,
284 req: &mut Request<'_>,
285 data: &mut Data<'_>
286 ) -> RequestToken {
287 let (min_len, max_len) = ("_method=get".len(), "_method=delete".len());
290 let peek_buffer = data.peek(max_len).await;
291 let is_form = req.content_type().map_or(false, |ct| ct.is_form());
292
293 if is_form && req.method() == Method::Post && peek_buffer.len() >= min_len {
294 let method = std::str::from_utf8(peek_buffer).ok()
295 .and_then(|raw_form| Form::values(raw_form).next())
296 .filter(|field| field.name == "_method")
297 .and_then(|field| field.value.parse().ok());
298
299 if let Some(method) = method {
300 req._set_method(method);
301 }
302 }
303
304 self.fairings.handle_request(req, data).await;
306
307 RequestToken
308 }
309
310 #[inline]
311 pub(crate) async fn dispatch<'s, 'r: 's>(
312 &'s self,
313 _token: RequestToken,
314 request: &'r Request<'s>,
315 data: Data<'r>
316 ) -> Response<'r> {
317 info!("{}:", request);
318
319 let was_head_request = request.method() == Method::Head;
321
322 let mut response = self.route_and_process(request, data).await;
324
325 if let Some(ident) = request.rocket().config.ident.as_str() {
328 if !response.headers().contains("Server") {
329 response.set_header(Header::new("Server", ident));
330 }
331 }
332
333 self.fairings.handle_response(request, &mut response).await;
335
336 if response.status() == Status::NoContent {
337 response.remove_header("Content-Length");
339 response.remove_header("Transfer-Encoding");
340 *response.body_mut() = crate::response::Body::unsized_none();
341 } else if was_head_request || response.status() == Status::NotModified {
342 response.strip_body();
344 }
345
346 response
347 }
348
349 async fn route_and_process<'s, 'r: 's>(
350 &'s self,
351 request: &'r Request<'s>,
352 data: Data<'r>
353 ) -> Response<'r> {
354 let mut response = match self.route(request, data).await {
355 Outcome::Success(response) => response,
356 Outcome::Forward((data, _)) if request.method() == Method::Head => {
357 info_!("Autohandling {} request.", "HEAD".primary().bold());
358
359 request._set_method(Method::Get);
361 match self.route(request, data).await {
362 Outcome::Success(response) => response,
363 Outcome::Error(status) => self.handle_error(status, request).await,
364 Outcome::Forward((_, status)) => self.handle_error(status, request).await,
365 }
366 }
367 Outcome::Forward((_, status)) => self.handle_error(status, request).await,
368 Outcome::Error(status) => self.handle_error(status, request).await,
369 };
370
371 let delta_jar = request.cookies().take_delta_jar();
374 for cookie in delta_jar.delta() {
375 response.adjoin_header(cookie);
376 }
377
378 response
379 }
380
381 #[inline]
387 async fn route<'s, 'r: 's>(
388 &'s self,
389 request: &'r Request<'s>,
390 mut data: Data<'r>,
391 ) -> route::Outcome<'r> {
392 let mut status = Status::NotFound;
395 for route in self.router.route(request) {
396 info_!("Matched: {}", route);
398 request.set_route(route);
399
400 let name = route.name.as_deref();
401 let outcome = handle(name, || route.handler.handle(request, data)).await
402 .unwrap_or(Outcome::Error(Status::InternalServerError));
403
404 info_!("{}", outcome.log_display());
408 match outcome {
409 o@Outcome::Success(_) | o@Outcome::Error(_) => return o,
410 Outcome::Forward(forwarded) => (data, status) = forwarded,
411 }
412 }
413
414 error_!("No matching routes for {}.", request);
415 Outcome::Forward((data, status))
416 }
417
418 async fn invoke_catcher<'s, 'r: 's>(
429 &'s self,
430 status: Status,
431 req: &'r Request<'s>
432 ) -> Result<Response<'r>, Option<Status>> {
433 req.cookies().reset_delta();
437
438 if let Some(catcher) = self.router.catch(status, req) {
439 warn_!("Responding with registered {} catcher.", catcher);
440 let name = catcher.name.as_deref();
441 handle(name, || catcher.handler.handle(status, req)).await
442 .map(|result| result.map_err(Some))
443 .unwrap_or_else(|| Err(None))
444 } else {
445 let code = status.code.blue().bold();
446 warn_!("No {} catcher registered. Using Rocket default.", code);
447 Ok(crate::catcher::default_handler(status, req))
448 }
449 }
450
451 pub(crate) async fn handle_error<'s, 'r: 's>(
456 &'s self,
457 mut status: Status,
458 req: &'r Request<'s>
459 ) -> Response<'r> {
460 if let Ok(r) = self.invoke_catcher(status, req).await {
462 return r;
463 }
464
465 if status != Status::InternalServerError {
467 error_!("Catcher failed. Attempting 500 error catcher.");
468 status = Status::InternalServerError;
469 if let Ok(r) = self.invoke_catcher(status, req).await {
470 return r;
471 }
472 }
473
474 error_!("{} catcher failed. Using Rocket default 500.", status.code);
476 crate::catcher::default_handler(Status::InternalServerError, req)
477 }
478
479 pub(crate) async fn default_tcp_http_server<C>(mut self, ready: C) -> Result<Self, Error>
480 where C: for<'a> Fn(&'a Self) -> BoxFuture<'a, ()>
481 {
482 use std::net::ToSocketAddrs;
483
484 let addr = format!("{}:{}", self.config.address, self.config.port);
486 let mut addr = addr.to_socket_addrs()
487 .map(|mut addrs| addrs.next().expect(">= 1 socket addr"))
488 .map_err(|e| Error::new(ErrorKind::Io(e)))?;
489
490 #[cfg(feature = "tls")]
491 if self.config.tls_enabled() {
492 if let Some(ref config) = self.config.tls {
493 use crate::http::tls::TlsListener;
494
495 let conf = config.to_native_config().map_err(ErrorKind::Io)?;
496 let l = TlsListener::bind(addr, conf).await.map_err(ErrorKind::Bind)?;
497 addr = l.local_addr().unwrap_or(addr);
498 self.config.address = addr.ip();
499 self.config.port = addr.port();
500 ready(&mut self).await;
501 return self.http_server(l).await;
502 }
503 }
504
505 let l = TcpListener::bind(addr).await.map_err(ErrorKind::Bind)?;
506 addr = l.local_addr().unwrap_or(addr);
507 self.config.address = addr.ip();
508 self.config.port = addr.port();
509 ready(&mut self).await;
510 self.http_server(l).await
511 }
512
513 pub(crate) async fn http_server<L>(self, listener: L) -> Result<Self, Error>
515 where L: Listener + Send, <L as Listener>::Connection: Send + Unpin + 'static
516 {
517 if self.config.profile == Config::DEBUG_PROFILE {
519 tokio::task::spawn_blocking(|| {
520 let this = std::thread::current();
521 if !this.name().map_or(false, |s| s.starts_with("rocket-worker")) {
522 warn!("Rocket is executing inside of a custom runtime.");
523 info_!("Rocket's runtime is enabled via `#[rocket::main]` or `#[launch]`.");
524 info_!("Forced shutdown is disabled. Runtime settings may be suboptimal.");
525 }
526 });
527 }
528
529 let shutdown = self.shutdown();
534 let sig_stream = self.config.shutdown.signal_stream();
535 let grace = self.config.shutdown.grace as u64;
536 let mercy = self.config.shutdown.mercy as u64;
537
538 if let Some(mut stream) = sig_stream {
540 let shutdown = shutdown.clone();
541 tokio::spawn(async move {
542 while let Some(sig) = stream.next().await {
543 if shutdown.0.tripped() {
544 warn!("Received {}. Shutdown already in progress.", sig);
545 } else {
546 warn!("Received {}. Requesting shutdown.", sig);
547 }
548
549 shutdown.0.trip();
550 }
551 });
552 }
553
554 let rocket = Arc::new(self);
555 let listener = CancellableListener::new(shutdown.clone(), listener, grace, mercy);
556 let server = rocket.clone().serve(listener);
557
558 tokio::pin!(server);
590 tokio::select! {
591 biased;
592
593 _ = shutdown => {
594 info!("Shutdown requested. Waiting for pending I/O...");
598 let shutdown_timer = sleep(Duration::from_secs(grace + mercy + 1));
599 rocket.fairings.handle_shutdown(&*rocket).await;
600
601 tokio::pin!(shutdown_timer);
602 tokio::select! {
603 biased;
604
605 result = &mut server => {
606 if let Err(e) = result {
607 warn!("Server failed while shutting down: {}", e);
608 return Err(Error::shutdown(rocket.clone(), e));
609 }
610
611 let deadline = shutdown_timer.deadline();
612 while Arc::strong_count(&rocket) != 1 && Instant::now() < deadline {
613 let next = Instant::now() + Duration::from_millis(10);
614 sleep_until(next.min(deadline)).await;
615 }
616
617 match Arc::try_unwrap(rocket) {
618 Ok(rocket) => {
619 info!("Graceful shutdown completed successfully.");
620 Ok(rocket)
621 }
622 Err(rocket) => {
623 warn!("Shutdown failed: outstanding background I/O.");
624 Err(Error::shutdown(rocket, None))
625 }
626 }
627 }
628 _ = &mut shutdown_timer => {
629 warn!("Shutdown failed: server executing after timeouts.");
630 return Err(Error::shutdown(rocket.clone(), None));
631 },
632 }
633 }
634 result = &mut server => {
635 match result {
636 Ok(()) => {
637 info!("Server shutdown nominally.");
638 Ok(Arc::try_unwrap(rocket).map_err(|r| Error::shutdown(r, None))?)
639 }
640 Err(e) => {
641 info!("Server failed prior to shutdown: {}:", e);
642 Err(Error::shutdown(rocket.clone(), e))
643 }
644 }
645 }
646 }
647 }
648
649 async fn serve<L>(self: Arc<Self>, listener: L) -> io::Result<()>
650 where L: Listener + Send,
651 L::Connection: Send + Unpin + 'static
652 {
653 #[cfg(feature = "http2")]
654 let mut builder = Builder::new(TokioExecutor::new());
655 #[cfg(not(feature = "http2"))]
656 let mut builder = Builder::new();
657
658 #[cfg(feature = "http2")]
659 let mut http1 = builder.http1();
660 #[cfg(not(feature = "http2"))]
661 let http1 = &mut builder;
662
663 let keep_alive = self.config.keep_alive;
664 http1.keep_alive(keep_alive != 0)
665 .preserve_header_case(true)
666 .header_read_timeout(None);
667
668 #[cfg(feature = "http2")]
669 builder.http2()
670 .max_concurrent_streams(None)
671 .max_header_list_size(16 << 20)
672 .timer(TokioTimer::new())
673 .keep_alive_timeout(Duration::from_secs(20))
674 .keep_alive_interval(match keep_alive {
675 0 => None,
676 n => Some(Duration::from_secs(n as u64)),
677 });
678
679 let server = Arc::new(builder);
680 let linger = Duration::from_secs(self.config.linger as u64);
681 let incoming = Incoming::new(listener).nodelay(true).take_until(self.shutdown());
682 let mut incoming = pin!(incoming);
683
684 while let Some(conn) = incoming.next().await.transpose()? {
685 let (rocket, server) = (self.clone(), server.clone());
686 let shutdown = rocket.shutdown();
687 tokio::spawn(async move {
688 let connection = ConnectionMeta {
689 remote: conn.peer_address(),
690 client_certificates: conn.peer_certificates(),
691 };
692 let upgraded = Arc::new(AtomicBool::new(false));
693 let service = hyper::service::service_fn({
694 let upgraded = upgraded.clone();
695 move |req| {
696 hyper_service_fn(rocket.clone(), connection.clone(), upgraded.clone(), req)
697 }
698 });
699
700 let io = TokioIo::new(LingeringIo::new(conn, linger, upgraded));
701 #[cfg(feature = "http2")]
702 let mut server = pin!(server.serve_connection_with_upgrades(io, service));
703 #[cfg(not(feature = "http2"))]
704 let mut server = pin!(server.serve_connection(io, service).with_upgrades());
705
706 let result = tokio::select! {
707 biased;
708 _ = shutdown => {
709 server.as_mut().graceful_shutdown();
710 server.await
711 },
712 result = &mut server => result,
713 };
714
715 if let Err(e) = result {
716 let e: Box<dyn std::error::Error + Send + Sync> = e.into();
717 warn!("Connection failed: {}", e);
718 let mut source = e.source();
719 while let Some(e) = source {
720 warn_!("Error: {}", e);
721 source = e.source();
722 }
723 }
724 });
725 }
726
727 Ok(())
728 }
729}