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 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
// Copyright 2015-2021 Benjamin Fry <benjaminfry@me.com>
//
// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// http://opensource.org/licenses/MIT>, at your option. This file may not be
// copied, modified, or distributed except according to those terms.
//! Request Handler for incoming requests
use std::net::SocketAddr;
use crate::{
authority::MessageRequest,
proto::op::{Header, LowerQuery, ResponseCode},
server::{Protocol, ResponseHandler},
};
/// An incoming request to the DNS catalog
#[derive(Debug)]
pub struct Request {
/// Message with the associated query or update data
message: MessageRequest,
/// Source address of the Client
src: SocketAddr,
/// Protocol of the request
protocol: Protocol,
}
impl Request {
/// Build a new requests with the inbound message, source address, and protocol.
///
/// This will return an error on bad verification.
pub fn new(message: MessageRequest, src: SocketAddr, protocol: Protocol) -> Self {
Self {
message,
src,
protocol,
}
}
/// Return just the header and request information from the Request Message
pub fn request_info(&self) -> RequestInfo<'_> {
RequestInfo {
src: self.src,
protocol: self.protocol,
header: self.message.header(),
query: self.message.query(),
}
}
/// The IP address from which the request originated.
pub fn src(&self) -> SocketAddr {
self.src
}
/// The protocol that was used for the request
pub fn protocol(&self) -> Protocol {
self.protocol
}
}
impl std::ops::Deref for Request {
type Target = MessageRequest;
fn deref(&self) -> &Self::Target {
&self.message
}
}
// TODO: add ProtocolInfo that would have TLS details or other additional things...
/// A narrow view of the Request, specifically a verified single query for the request
#[non_exhaustive]
#[derive(Clone)]
pub struct RequestInfo<'a> {
/// The source address from which the request came
pub src: SocketAddr,
/// The protocol used for the request
pub protocol: Protocol,
/// The header from the original request
pub header: &'a Header,
/// The query from the request
pub query: &'a LowerQuery,
}
impl<'a> RequestInfo<'a> {
/// Construct a new RequestInfo
///
/// # Arguments
///
/// * `src` - The source address from which the request came
/// * `protocol` - The protocol used for the request
/// * `header` - The header from the original request
/// * `query` - The query from the request, LowerQuery is intended to reduce complexity for lookups in authorities
pub fn new(
src: SocketAddr,
protocol: Protocol,
header: &'a Header,
query: &'a LowerQuery,
) -> Self {
Self {
src,
protocol,
header,
query,
}
}
}
/// Information about the response sent for a request
#[derive(Clone, Copy)]
#[repr(transparent)]
pub struct ResponseInfo(Header);
impl ResponseInfo {
pub(crate) fn serve_failed() -> Self {
let mut header = Header::new();
header.set_response_code(ResponseCode::ServFail);
header.into()
}
}
impl From<Header> for ResponseInfo {
fn from(header: Header) -> Self {
Self(header)
}
}
impl std::ops::Deref for ResponseInfo {
type Target = Header;
fn deref(&self) -> &Self::Target {
&self.0
}
}
/// Trait for handling incoming requests, and providing a message response.
#[async_trait::async_trait]
pub trait RequestHandler: Send + Sync + Unpin + 'static {
/// Determines what needs to happen given the type of request, i.e. Query or Update.
///
/// # Arguments
///
/// * `request` - the requested action to perform.
/// * `response_handle` - handle to which a return message should be sent
async fn handle_request<R: ResponseHandler>(
&self,
request: &Request,
response_handle: R,
) -> ResponseInfo;
}
#[cfg(test)]
mod tests {
use crate::proto::op::{Header, Query};
use crate::server::Protocol;
use super::RequestInfo;
#[test]
fn request_info_clone() {
let query: Query = Query::new();
let header = Header::new();
let lower_query = query.into();
let origin = RequestInfo::new(
"127.0.0.1:3000".parse().unwrap(),
Protocol::Udp,
&header,
&lower_query,
);
let cloned = origin.clone();
assert_eq!(origin.header, cloned.header);
}
}