veloren_query_server/
server.rs

1#[expect(deprecated)] use std::hash::SipHasher;
2use std::{
3    hash::{Hash, Hasher},
4    io::{self, ErrorKind},
5    net::SocketAddr,
6    sync::{Arc, Mutex},
7    time::{Duration, Instant},
8};
9
10use protocol::Parcel;
11use rand::{Rng, thread_rng};
12use tokio::{net::UdpSocket, sync::watch};
13use tracing::{debug, error, trace};
14
15use crate::{
16    proto::{
17        Init, MAX_REQUEST_SIZE, MAX_RESPONSE_SIZE, QueryServerRequest, QueryServerResponse,
18        RawQueryServerRequest, RawQueryServerResponse, ServerInfo, VELOREN_HEADER, VERSION,
19    },
20    ratelimit::{RateLimiter, ReducedIpAddr},
21};
22
23const SECRET_REGEN_INTERNVAL: Duration = Duration::from_secs(300);
24
25pub struct QueryServer {
26    addr: SocketAddr,
27    server_info: watch::Receiver<ServerInfo>,
28    settings: protocol::Settings,
29    ratelimit: RateLimiter,
30}
31
32#[derive(Default, Clone, Copy, Debug)]
33pub struct Metrics {
34    pub received_packets: u32,
35    pub dropped_packets: u32,
36    pub invalid_packets: u32,
37    pub proccessing_errors: u32,
38    pub info_requests: u32,
39    pub init_requests: u32,
40    pub sent_responses: u32,
41    pub failed_responses: u32,
42    pub timed_out_responses: u32,
43    pub ratelimited: u32,
44}
45
46impl QueryServer {
47    pub fn new(addr: SocketAddr, server_info: watch::Receiver<ServerInfo>, ratelimit: u16) -> Self {
48        Self {
49            addr,
50            server_info,
51            ratelimit: RateLimiter::new(ratelimit),
52            settings: Default::default(),
53        }
54    }
55
56    /// This produces TRACE level logs for any packet received on the assigned
57    /// port. To prevent potentially unfettered log spam, disable the TRACE
58    /// level for this crate (when outside of debugging contexts).
59    ///
60    /// NOTE: TRACE and DEBUG levels are disabled by default for this crate when
61    /// using `veloren-common-frontend`.
62    pub async fn run(&mut self, metrics: Arc<Mutex<Metrics>>) -> Result<(), tokio::io::Error> {
63        let mut socket = UdpSocket::bind(self.addr).await?;
64
65        let gen_secret = || {
66            let mut rng = thread_rng();
67            (rng.gen::<u64>(), rng.gen::<u64>())
68        };
69        let mut secrets = gen_secret();
70        let mut last_secret_refresh = Instant::now();
71
72        let mut buf = Box::new([0; MAX_REQUEST_SIZE]);
73        loop {
74            let (len, remote_addr) = match socket.recv_from(&mut *buf).await {
75                Ok(v) => v,
76                Err(e) if e.kind() == ErrorKind::NotConnected => {
77                    error!(
78                        ?e,
79                        "Query server connection was closed, re-binding to socket..."
80                    );
81                    socket = UdpSocket::bind(self.addr).await?;
82                    continue;
83                },
84                err => {
85                    debug!(?err, "Error while receiving from query server socket");
86                    continue;
87                },
88            };
89
90            let mut new_metrics = Metrics {
91                received_packets: 1,
92                ..Default::default()
93            };
94
95            let raw_msg_buf = &buf[..len];
96            let msg_buf = if Self::validate_datagram(raw_msg_buf) {
97                // Require 2 extra bytes for version (currently unused)
98                &raw_msg_buf[2..(raw_msg_buf.len() - VELOREN_HEADER.len())]
99            } else {
100                new_metrics.dropped_packets += 1;
101                continue;
102            };
103
104            self.process_datagram(msg_buf, remote_addr, secrets, &mut new_metrics, &socket)
105                .await;
106
107            // Update metrics at the end of eath packet
108            if let Ok(mut metrics) = metrics.lock() {
109                *metrics += new_metrics;
110            }
111
112            {
113                let now = Instant::now();
114                if now.duration_since(last_secret_refresh) > SECRET_REGEN_INTERNVAL {
115                    last_secret_refresh = now;
116                    secrets = gen_secret();
117                }
118
119                self.ratelimit.maintain(now);
120            }
121        }
122    }
123
124    // Header must be discarded after this validation passes
125    fn validate_datagram(data: &[u8]) -> bool {
126        let len = data.len();
127        // Require 2 extra bytes for version (currently unused)
128        if len < MAX_RESPONSE_SIZE.max(VELOREN_HEADER.len() + 2) {
129            trace!(?len, "Datagram too short");
130            false
131        } else if len > MAX_REQUEST_SIZE {
132            trace!(?len, "Datagram too large");
133            false
134        } else if data[(len - VELOREN_HEADER.len())..] != VELOREN_HEADER {
135            trace!(?len, "Datagram header invalid");
136            false
137        // TODO: Allow lower versions once proper versioning is added.
138        } else if u16::from_ne_bytes(data[..2].try_into().unwrap()) != VERSION {
139            trace!(
140                "Datagram has invalid version {:?}, current {VERSION:?}",
141                &data[..2]
142            );
143            false
144        } else {
145            true
146        }
147    }
148
149    async fn process_datagram(
150        &mut self,
151        datagram: &[u8],
152        remote: SocketAddr,
153        secrets: (u64, u64),
154        metrics: &mut Metrics,
155        socket: &UdpSocket,
156    ) {
157        let Ok(RawQueryServerRequest {
158            p: client_p,
159            request,
160        }) =
161            <RawQueryServerRequest as Parcel>::read(&mut io::Cursor::new(datagram), &self.settings)
162        else {
163            metrics.invalid_packets += 1;
164            return;
165        };
166
167        trace!(?request, "Received packet");
168
169        #[expect(deprecated)]
170        let real_p = {
171            // Use SipHash-2-4 to compute the `p` value from a server specific
172            // secret and the client's address.
173            //
174            // This is used to verify that packets are from an entity that can
175            // receive packets at the given address.
176            //
177            // Only use the first 64 bits from Ipv6 addresses since the latter
178            // 64 bits can change very frequently (as much as for every
179            // request).
180            let mut hasher = SipHasher::new_with_keys(secrets.0, secrets.1);
181            ReducedIpAddr::from(remote.ip()).hash(&mut hasher);
182            hasher.finish()
183        };
184
185        if real_p != client_p {
186            Self::send_response(
187                RawQueryServerResponse::Init(Init {
188                    p: real_p,
189                    max_supported_version: VERSION,
190                }),
191                remote,
192                socket,
193                metrics,
194            )
195            .await;
196
197            return;
198        }
199
200        if !self.ratelimit.can_request(remote.ip().into()) {
201            trace!("Ratelimited request");
202            metrics.ratelimited += 1;
203            return;
204        }
205
206        match request {
207            QueryServerRequest::Init => {
208                metrics.init_requests += 1;
209                Self::send_response(
210                    RawQueryServerResponse::Init(Init {
211                        p: real_p,
212                        max_supported_version: VERSION,
213                    }),
214                    remote,
215                    socket,
216                    metrics,
217                )
218                .await;
219            },
220            QueryServerRequest::ServerInfo => {
221                metrics.info_requests += 1;
222                let server_info = *self.server_info.borrow();
223                Self::send_response(
224                    RawQueryServerResponse::Response(QueryServerResponse::ServerInfo(server_info)),
225                    remote,
226                    socket,
227                    metrics,
228                )
229                .await;
230            },
231        }
232    }
233
234    async fn send_response(
235        response: RawQueryServerResponse,
236        addr: SocketAddr,
237        socket: &UdpSocket,
238        metrics: &mut Metrics,
239    ) {
240        // TODO: Once more versions are added, send the packet in the same version as
241        // the request here.
242        match <RawQueryServerResponse as Parcel>::raw_bytes(&response, &Default::default()) {
243            Ok(data) => {
244                if data.len() > MAX_RESPONSE_SIZE {
245                    error!(
246                        ?MAX_RESPONSE_SIZE,
247                        "Attempted to send a response larger than the maximum allowed size (size: \
248                         {}, response: {response:?})",
249                        data.len()
250                    );
251                    #[cfg(debug_assertions)]
252                    panic!(
253                        "Attempted to send a response larger than the maximum allowed size (size: \
254                         {}, max: {}, response: {response:?})",
255                        data.len(),
256                        MAX_RESPONSE_SIZE
257                    );
258                }
259
260                match socket.send_to(&data, addr).await {
261                    Ok(_) => {
262                        metrics.sent_responses += 1;
263                    },
264                    Err(err) => {
265                        metrics.failed_responses += 1;
266                        debug!(?err, "Failed to send query server response");
267                    },
268                }
269            },
270            Err(error) => {
271                trace!(?error, "Failed to serialize response");
272                #[cfg(debug_assertions)]
273                panic!("Serializing response failed: {error:?} ({response:?})");
274            },
275        }
276    }
277}
278
279impl std::ops::AddAssign for Metrics {
280    fn add_assign(
281        &mut self,
282        Self {
283            received_packets,
284            dropped_packets,
285            invalid_packets,
286            proccessing_errors,
287            info_requests,
288            init_requests,
289            sent_responses,
290            failed_responses,
291            timed_out_responses,
292            ratelimited,
293        }: Self,
294    ) {
295        self.received_packets += received_packets;
296        self.dropped_packets += dropped_packets;
297        self.invalid_packets += invalid_packets;
298        self.proccessing_errors += proccessing_errors;
299        self.info_requests += info_requests;
300        self.init_requests += init_requests;
301        self.sent_responses += sent_responses;
302        self.failed_responses += failed_responses;
303        self.timed_out_responses += timed_out_responses;
304        self.ratelimited += ratelimited;
305    }
306}
307
308impl Metrics {
309    /// Resets all metrics to 0 and returns previous ones
310    ///
311    /// Used by the consumer of the metrics.
312    pub fn reset(&mut self) -> Self { std::mem::take(self) }
313}
veloren_query_server/server.rs

veloren_query_server/
server.rs
