add basic ipv6 support

master/src/config.rs

@@ -1,18 +1,19 @@
 // SPDX-License-Identifier: GPL-3.0-only
 // SPDX-FileCopyrightText: 2023 Denis Drakhnia <numas13@gmail.com>
 
-use std::fs;
-use std::io;
-use std::net::{IpAddr, Ipv4Addr};
-use std::path::Path;
+use std::{
+    fs, io,
+    net::{IpAddr, Ipv4Addr},
+    path::Path,
+};
 
 use log::LevelFilter;
 use serde::{de::Error as _, Deserialize, Deserializer};
 use thiserror::Error;
-use xash3d_protocol::admin;
-use xash3d_protocol::filter::Version;
+use xash3d_protocol::{admin, filter::Version};
+
+pub const DEFAULT_MASTER_SERVER_IP: IpAddr = IpAddr::V4(Ipv4Addr::UNSPECIFIED);
 
-pub const DEFAULT_MASTER_SERVER_IP: IpAddr = IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0));
 pub const DEFAULT_MASTER_SERVER_PORT: u16 = 27010;
 pub const DEFAULT_CHALLENGE_TIMEOUT: u32 = 10;
 pub const DEFAULT_SERVER_TIMEOUT: u32 = 300;

master/src/main.rs

@@ -9,9 +9,13 @@ mod logger;
 mod master_server;
 mod stats;
 
-use std::process;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Arc;
+use std::{
+    process,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+};
 
 use log::{error, info};
 #[cfg(not(windows))]
@@ -19,7 +23,7 @@ use signal_hook::{consts::signal::*, flag as signal_flag};
 
 use crate::cli::Cli;
 use crate::config::Config;
-use crate::master_server::{Error, MasterServer};
+use crate::master_server::{Error, Master};
 
 fn load_config(cli: &Cli) -> Result<Config, config::Error> {
     let mut cfg = match cli.config_path {
@@ -64,7 +68,7 @@ fn run() -> Result<(), Error> {
         process::exit(1);
     });
 
-    let mut master = MasterServer::new(cfg)?;
+    let mut master = Master::new(cfg)?;
     let sig_flag = Arc::new(AtomicBool::new(false));
     // XXX: Windows does not support SIGUSR1.
     #[cfg(not(windows))]

master/src/master_server.rs

@@ -1,25 +1,87 @@
 // SPDX-License-Identifier: GPL-3.0-only
 // SPDX-FileCopyrightText: 2023 Denis Drakhnia <numas13@gmail.com>
 
-use std::collections::hash_map;
-use std::io;
-use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, ToSocketAddrs, UdpSocket};
-use std::ops::Deref;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::time::{Duration, Instant};
+use std::{
+    cmp::Eq,
+    collections::hash_map,
+    fmt::Display,
+    hash::Hash,
+    io,
+    net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs, UdpSocket},
+    ops::Deref,
+    str::FromStr,
+    sync::atomic::{AtomicBool, Ordering},
+    time::{Duration, Instant},
+};
 
 use ahash::{AHashMap as HashMap, AHashSet as HashSet};
 use blake2b_simd::Params;
 use fastrand::Rng;
 use log::{debug, error, info, trace, warn};
 use thiserror::Error;
-use xash3d_protocol::filter::{Filter, FilterFlags, Version};
-use xash3d_protocol::server::Region;
-use xash3d_protocol::wrappers::Str;
-use xash3d_protocol::{admin, game, master, server, Error as ProtocolError, ServerInfo};
+use xash3d_protocol::{
+    admin,
+    filter::{Filter, FilterFlags, Version},
+    game,
+    master::{self, ServerAddress},
+    server,
+    server::Region,
+    wrappers::Str,
+    Error as ProtocolError, ServerInfo,
+};
+
+use crate::{
+    config::{self, Config},
+    stats::Stats,
+};
 
-use crate::config::{self, Config};
-use crate::stats::Stats;
+pub trait AddrExt: Sized + Eq + Hash + Display + Copy + ToSocketAddrs + ServerAddress {
+    type Ip: Eq + Hash + Display + Copy + FromStr;
+
+    fn extract(addr: SocketAddr) -> Result<Self, SocketAddr>;
+    fn ip(&self) -> &Self::Ip;
+    fn wrap(self) -> SocketAddr;
+}
+
+impl AddrExt for SocketAddrV4 {
+    type Ip = Ipv4Addr;
+
+    fn extract(addr: SocketAddr) -> Result<Self, SocketAddr> {
+        if let SocketAddr::V4(addr) = addr {
+            Ok(addr)
+        } else {
+            Err(addr)
+        }
+    }
+
+    fn ip(&self) -> &Self::Ip {
+        SocketAddrV4::ip(self)
+    }
+
+    fn wrap(self) -> SocketAddr {
+        SocketAddr::V4(self)
+    }
+}
+
+impl AddrExt for SocketAddrV6 {
+    type Ip = Ipv6Addr;
+
+    fn extract(addr: SocketAddr) -> Result<Self, SocketAddr> {
+        if let SocketAddr::V6(addr) = addr {
+            Ok(addr)
+        } else {
+            Err(addr)
+        }
+    }
+
+    fn ip(&self) -> &Self::Ip {
+        SocketAddrV6::ip(self)
+    }
+
+    fn wrap(self) -> SocketAddr {
+        SocketAddr::V6(self)
+    }
+}
 
 /// The maximum size of UDP packets.
 const MAX_PACKET_SIZE: usize = 512;
@@ -70,8 +132,8 @@ impl<T> Entry<T> {
 }
 
 impl Entry<ServerInfo> {
-    fn matches(&self, addr: SocketAddrV4, region: Region, filter: &Filter) -> bool {
-        self.region == region && filter.matches(addr, &self.value)
+    fn matches<Addr: AddrExt>(&self, addr: Addr, region: Region, filter: &Filter) -> bool {
+        self.region == region && filter.matches(addr.wrap(), &self.value)
     }
 }
 
@@ -104,11 +166,11 @@ impl Counter {
     }
 }
 
-pub struct MasterServer {
+pub struct MasterServer<Addr: AddrExt> {
     sock: UdpSocket,
-    challenges: HashMap<SocketAddrV4, Entry<u32>>,
+    challenges: HashMap<Addr, Entry<u32>>,
     challenges_counter: Counter,
-    servers: HashMap<SocketAddrV4, Entry<ServerInfo>>,
+    servers: HashMap<Addr, Entry<ServerInfo>>,
     servers_counter: Counter,
     max_servers_per_ip: u16,
     rng: Rng,
@@ -119,39 +181,38 @@ pub struct MasterServer {
     clver: Version,
     update_title: Box<str>,
     update_map: Box<str>,
-    update_addr: SocketAddrV4,
+    update_addr: SocketAddr,
 
-    admin_challenges: HashMap<Ipv4Addr, Entry<(u32, u32)>>,
+    admin_challenges: HashMap<Addr::Ip, Entry<(u32, u32)>>,
     admin_challenges_counter: Counter,
     admin_list: Box<[config::AdminConfig]>,
     // rate limit if hash is invalid
-    admin_limit: HashMap<Ipv4Addr, Entry<()>>,
+    admin_limit: HashMap<Addr::Ip, Entry<()>>,
     admin_limit_counter: Counter,
     hash: config::HashConfig,
 
-    blocklist: HashSet<Ipv4Addr>,
+    blocklist: HashSet<Addr::Ip>,
 
     stats: Stats,
 
     // temporary data
-    filtered_servers: Vec<SocketAddrV4>,
-    filtered_servers_nat: Vec<SocketAddrV4>,
+    filtered_servers: Vec<Addr>,
+    filtered_servers_nat: Vec<Addr>,
 }
 
-fn resolve_socket_addr<A>(addr: A) -> io::Result<Option<SocketAddrV4>>
+fn resolve_socket_addr<A>(addr: A, is_ipv4: bool) -> io::Result<Option<SocketAddr>>
 where
     A: ToSocketAddrs,
 {
     for i in addr.to_socket_addrs()? {
-        match i {
-            SocketAddr::V4(i) => return Ok(Some(i)),
-            SocketAddr::V6(_) => {}
+        if i.is_ipv4() == is_ipv4 {
+            return Ok(Some(i));
         }
     }
     Ok(None)
 }
 
-fn resolve_update_addr(cfg: &Config, local_addr: SocketAddr) -> SocketAddrV4 {
+fn resolve_update_addr(cfg: &Config, local_addr: SocketAddr) -> SocketAddr {
     if let Some(s) = cfg.client.update_addr.as_deref() {
         let addr = if !s.contains(':') {
             format!("{}:{}", s, local_addr.port())
@@ -159,28 +220,57 @@ fn resolve_update_addr(cfg: &Config, local_addr: SocketAddr) -> SocketAddrV4 {
             s.to_owned()
         };
 
-        match resolve_socket_addr(&addr) {
+        match resolve_socket_addr(&addr, local_addr.is_ipv4()) {
             Ok(Some(x)) => return x,
-            Ok(None) => error!("Update address: failed to resolve IPv4 for \"{}\"", addr),
+            Ok(None) => error!("Update address: failed to resolve IP for \"{}\"", addr),
             Err(e) => error!("Update address: {}", e),
         }
     }
-
-    match local_addr {
-        SocketAddr::V4(x) => x,
-        SocketAddr::V6(_) => todo!(),
+    local_addr
 }
+
+pub enum Master {
+    V4(MasterServer<SocketAddrV4>),
+    V6(MasterServer<SocketAddrV6>),
 }
 
-impl MasterServer {
+impl Master {
     pub fn new(cfg: Config) -> Result<Self, Error> {
-        let addr = SocketAddr::new(cfg.server.ip, cfg.server.port);
+        match SocketAddr::new(cfg.server.ip, cfg.server.port) {
+            SocketAddr::V4(addr) => MasterServer::new(cfg, addr).map(Self::V4),
+            SocketAddr::V6(addr) => MasterServer::new(cfg, addr).map(Self::V6),
+        }
+    }
+
+    pub fn update_config(&mut self, cfg: Config) -> Result<(), Error> {
+        let cfg = match self {
+            Self::V4(inner) => inner.update_config(cfg)?,
+            Self::V6(inner) => inner.update_config(cfg)?,
+        };
+        if let Some(cfg) = cfg {
+            info!("Server IP version changed, full restart");
+            *self = Self::new(cfg)?;
+        }
+        Ok(())
+    }
+
+    pub fn run(&mut self, sig_flag: &AtomicBool) -> Result<(), Error> {
+        match self {
+            Self::V4(inner) => inner.run(sig_flag),
+            Self::V6(inner) => inner.run(sig_flag),
+        }
+    }
+}
+
+impl<Addr: AddrExt> MasterServer<Addr> {
+    pub fn new(cfg: Config, addr: Addr) -> Result<Self, Error> {
         info!("Listen address: {}", addr);
+
         let sock = UdpSocket::bind(addr).map_err(Error::BindSocket)?;
         // make socket interruptable by singals
         sock.set_read_timeout(Some(Duration::from_secs(u32::MAX as u64)))?;
 
-        let update_addr = resolve_update_addr(&cfg, addr);
+        let update_addr = resolve_update_addr(&cfg, addr.wrap());
 
         Ok(Self {
             sock,
@@ -210,10 +300,16 @@ impl MasterServer {
         })
     }
 
-    pub fn update_config(&mut self, cfg: Config) -> Result<(), Error> {
-        let local_addr = self.sock.local_addr()?;
+    fn local_addr(&self) -> io::Result<SocketAddr> {
+        self.sock.local_addr()
+    }
+
+    pub fn update_config(&mut self, cfg: Config) -> Result<Option<Config>, Error> {
+        let local_addr = self.local_addr()?;
         let addr = SocketAddr::new(cfg.server.ip, cfg.server.port);
-        if local_addr != addr {
+        if local_addr.is_ipv4() != addr.is_ipv4() {
+            return Ok(Some(cfg));
+        } else if local_addr != addr {
             info!("Listen address: {}", addr);
             self.sock = UdpSocket::bind(addr).map_err(Error::BindSocket)?;
             // make socket interruptable by singals
@@ -231,7 +327,7 @@ impl MasterServer {
         self.hash = cfg.hash;
         self.stats.update_config(cfg.stat);
 
-        Ok(())
+        Ok(None)
     }
 
     pub fn run(&mut self, sig_flag: &AtomicBool) -> Result<(), Error> {
@@ -246,12 +342,9 @@ impl MasterServer {
                 },
             };
 
-            let from = match from {
-                SocketAddr::V4(a) => a,
-                _ => {
-                    warn!("{}: Received message from IPv6, unimplemented", from);
-                    continue;
-                }
+            let from = match Addr::extract(from) {
+                Ok(from) => from,
+                Err(_) => continue,
             };
 
             let src = &buf[..n];
@@ -271,7 +364,7 @@ impl MasterServer {
         self.stats.clear();
     }
 
-    fn handle_server_packet(&mut self, from: SocketAddrV4, p: server::Packet) -> Result<(), Error> {
+    fn handle_server_packet(&mut self, from: Addr, p: server::Packet) -> Result<(), Error> {
         trace!("{}: recv {:?}", from, p);
 
         match p {
@@ -320,13 +413,20 @@ impl MasterServer {
         Ok(())
     }
 
-    fn handle_game_packet(&mut self, from: SocketAddrV4, p: game::Packet) -> Result<(), Error> {
+    fn handle_game_packet(&mut self, from: Addr, p: game::Packet) -> Result<(), Error> {
         trace!("{}: recv {:?}", from, p);
 
         match p {
             game::Packet::QueryServers(p) => {
                 if p.filter.clver.map_or(false, |v| v < self.clver) {
-                    self.send_server_list(from, p.filter.key, &[self.update_addr])?;
+                    match self.update_addr {
+                        SocketAddr::V4(addr) => {
+                            self.send_server_list(from, p.filter.key, &[addr])?;
+                        }
+                        SocketAddr::V6(addr) => {
+                            self.send_server_list(from, p.filter.key, &[addr])?;
+                        }
+                    }
                 } else {
                     let now = self.now();
 
@@ -376,7 +476,7 @@ impl MasterServer {
         Ok(())
     }
 
-    fn handle_admin_packet(&mut self, from: SocketAddrV4, p: admin::Packet) -> Result<(), Error> {
+    fn handle_admin_packet(&mut self, from: Addr, p: admin::Packet) -> Result<(), Error> {
         trace!("{}: recv {:?}", from, p);
 
         let now = self.now();
@@ -449,7 +549,7 @@ impl MasterServer {
         Ok(())
     }
 
-    fn handle_packet(&mut self, from: SocketAddrV4, src: &[u8]) -> Result<(), Error> {
+    fn handle_packet(&mut self, from: Addr, src: &[u8]) -> Result<(), Error> {
         if self.is_blocked(from.ip()) {
             return Ok(());
         }
@@ -479,7 +579,7 @@ impl MasterServer {
         self.start_time.elapsed().as_secs() as u32
     }
 
-    fn add_challenge(&mut self, addr: SocketAddrV4) -> u32 {
+    fn add_challenge(&mut self, addr: Addr) -> u32 {
         let x = self.rng.u32(..);
         let entry = Entry::new(self.now(), x);
         self.challenges.insert(addr, entry);
@@ -494,7 +594,7 @@ impl MasterServer {
         }
     }
 
-    fn admin_challenge_add(&mut self, addr: SocketAddrV4) -> (u32, u32) {
+    fn admin_challenge_add(&mut self, addr: Addr) -> (u32, u32) {
         let x = self.rng.u32(..);
         let y = self.rng.u32(..);
         let entry = Entry::new(self.now(), (x, y));
@@ -502,7 +602,7 @@ impl MasterServer {
         (x, y)
     }
 
-    fn admin_challenge_remove(&mut self, addr: SocketAddrV4) {
+    fn admin_challenge_remove(&mut self, addr: Addr) {
         self.admin_challenges.remove(addr.ip());
     }
 
@@ -523,11 +623,11 @@ impl MasterServer {
         }
     }
 
-    fn count_servers(&self, addr: &Ipv4Addr) -> u16 {
-        self.servers.keys().filter(|i| i.ip() == addr).count() as u16
+    fn count_servers(&self, ip: &Addr::Ip) -> u16 {
+        self.servers.keys().filter(|i| i.ip() == ip).count() as u16
     }
 
-    fn add_server(&mut self, addr: SocketAddrV4, server: ServerInfo) {
+    fn add_server(&mut self, addr: Addr, server: ServerInfo) {
         let now = self.now();
         match self.servers.entry(addr) {
             hash_map::Entry::Occupied(mut e) => {
@@ -554,34 +654,25 @@ impl MasterServer {
         }
     }
 
-    fn send_server_list<A>(
-        &self,
-        to: A,
-        key: Option<u32>,
-        servers: &[SocketAddrV4],
-    ) -> Result<(), Error>
+    fn send_server_list<A, S>(&self, to: A, key: Option<u32>, servers: &[S]) -> Result<(), Error>
     where
         A: ToSocketAddrs,
+        S: ServerAddress,
     {
-        let mut list = master::QueryServersResponse::new(servers.iter().copied(), key);
-        loop {
         let mut buf = [0; MAX_PACKET_SIZE];
-            let (n, is_end) = list.encode(&mut buf)?;
+        let mut offset = 0;
+        let mut list = master::QueryServersResponse::new(key);
+        while offset < servers.len() {
+            let (n, c) = list.encode(&mut buf, &servers[offset..])?;
+            offset += c;
             self.sock.send_to(&buf[..n], &to)?;
-            if is_end {
-                break;
-            }
         }
         Ok(())
     }
 
-    fn send_client_to_nat_servers(
-        &self,
-        to: SocketAddrV4,
-        servers: &[SocketAddrV4],
-    ) -> Result<(), Error> {
+    fn send_client_to_nat_servers(&self, to: Addr, servers: &[Addr]) -> Result<(), Error> {
         let mut buf = [0; 64];
-        let n = master::ClientAnnounce::new(to).encode(&mut buf)?;
+        let n = master::ClientAnnounce::new(to.wrap()).encode(&mut buf)?;
         let buf = &buf[..n];
         for i in servers {
             self.sock.send_to(buf, i)?;
@@ -590,15 +681,19 @@ impl MasterServer {
     }
 
     #[inline]
-    fn is_blocked(&self, ip: &Ipv4Addr) -> bool {
+    fn is_blocked(&self, ip: &Addr::Ip) -> bool {
         self.blocklist.contains(ip)
     }
 
     fn admin_command(&mut self, cmd: &str) {
         let args: Vec<_> = cmd.split(' ').collect();
 
-        fn helper<F: FnMut(&str, Ipv4Addr)>(args: &[&str], mut op: F) {
-            let iter = args.iter().map(|i| (i, i.parse::<Ipv4Addr>()));
+        fn helper<Addr, F>(args: &[&str], mut op: F)
+        where
+            Addr: AddrExt,
+            F: FnMut(&str, Addr::Ip),
+        {
+            let iter = args.iter().map(|i| (i, i.parse::<Addr::Ip>()));
             for (i, ip) in iter {
                 match ip {
                     Ok(ip) => op(i, ip),
@@ -609,14 +704,14 @@ impl MasterServer {
 
         match args[0] {
             "ban" => {
-                helper(&args[1..], |_, ip| {
+                helper::<Addr, _>(&args[1..], |_, ip| {
                     if self.blocklist.insert(ip) {
                         info!("ban ip: {}", ip);
                     }
                 });
             }
             "unban" => {
-                helper(&args[1..], |_, ip| {
+                helper::<Addr, _>(&args[1..], |_, ip| {
                     if self.blocklist.remove(&ip) {
                         info!("unban ip: {}", ip);
                     }

master/src/stats/stub.rs

@@ -6,7 +6,9 @@ struct Counters;
 pub struct Stats;
 
 impl Stats {
-    pub fn new(_: StatConfig) -> Self { Self }
+    pub fn new(_: StatConfig) -> Self {
+        Self
+    }
     pub fn update_config(&mut self, _: StatConfig) {}
     pub fn clear(&self) {}
     pub fn servers_count(&self, _: usize) {}

protocol/src/filter.rs

@@ -30,7 +30,7 @@
 //! * Is not protected by a password
 
 use std::fmt;
-use std::net::SocketAddrV4;
+use std::net::SocketAddr;
 use std::str::FromStr;
 
 use bitflags::bitflags;
@@ -196,7 +196,8 @@ impl Filter<'_> {
     }
 
     /// Returns `true` if a server matches the filter.
-    pub fn matches(&self, _addr: SocketAddrV4, info: &ServerInfo) -> bool {
+    pub fn matches(&self, _addr: SocketAddr, info: &ServerInfo) -> bool {
+        // TODO: match addr
         !((info.flags & self.flags_mask) != self.flags
             || self.gamedir.map_or(false, |s| *s != &*info.gamedir)
             || self.map.map_or(false, |s| *s != &*info.map)
@@ -308,6 +309,7 @@ mod tests {
     use super::*;
     use crate::cursor::CursorMut;
     use crate::wrappers::Str;
+    use std::net::SocketAddr;
 
     macro_rules! tests {
         ($($name:ident$(($($predefined_f:ident: $predefined_v:expr),+ $(,)?))? {
@@ -450,7 +452,7 @@ mod tests {
     macro_rules! servers {
         ($($addr:expr => $info:expr $(=> $func:expr)?)+) => (
             [$({
-                let addr = $addr.parse::<SocketAddrV4>().unwrap();
+                let addr = $addr.parse::<SocketAddr>().unwrap();
                 let mut buf = [0; 512];
                 let n = CursorMut::new(&mut buf)
                     .put_bytes(ServerAdd::HEADER).unwrap()

protocol/src/game.rs

@@ -4,7 +4,7 @@
 //! Game client packets.
 
 use std::fmt;
-use std::net::SocketAddrV4;
+use std::net::SocketAddr;
 
 use crate::cursor::{Cursor, CursorMut};
 use crate::filter::Filter;
@@ -17,7 +17,7 @@ pub struct QueryServers<T> {
     /// Servers must be from the `region`.
     pub region: Region,
     /// Last received server address __(not used)__.
-    pub last: SocketAddrV4,
+    pub last: SocketAddr,
     /// Select only servers that match the `filter`.
     pub filter: T,
 }
@@ -131,13 +131,13 @@ mod tests {
     use super::*;
     use crate::filter::{FilterFlags, Version};
     use crate::wrappers::Str;
-    use std::net::Ipv4Addr;
+    use std::net::{IpAddr, Ipv4Addr};
 
     #[test]
     fn query_servers() {
         let p = QueryServers {
             region: Region::RestOfTheWorld,
-            last: SocketAddrV4::new(Ipv4Addr::new(0, 0, 0, 0), 0),
+            last: SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0),
             filter: Filter {
                 gamedir: Some(Str(&b"valve"[..])),
                 map: Some(Str(&b"crossfire"[..])),
@@ -157,7 +157,7 @@ mod tests {
     fn query_servers_filter_bug() {
         let p = QueryServers {
             region: Region::RestOfTheWorld,
-            last: SocketAddrV4::new(Ipv4Addr::new(0, 0, 0, 0), 0),
+            last: SocketAddr::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), 0),
             filter: Filter {
                 gamedir: None,
                 protocol: Some(48),

protocol/src/master.rs

@@ -3,7 +3,7 @@
 
 //! Master server packets.
 
-use std::net::{Ipv4Addr, SocketAddrV4};
+use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
 
 use super::cursor::{Cursor, CursorMut};
 use super::Error;
@@ -58,6 +58,54 @@ impl ChallengeResponse {
     }
 }
 
+/// Helper trait for dealing with server addresses.
+pub trait ServerAddress: Sized {
+    /// Size of IP and port in bytes.
+    fn size() -> usize;
+
+    /// Read address from a cursor.
+    fn get(cur: &mut Cursor) -> Result<Self, Error>;
+
+    /// Write address to a cursor.
+    fn put(&self, cur: &mut CursorMut) -> Result<(), Error>;
+}
+
+impl ServerAddress for SocketAddrV4 {
+    fn size() -> usize {
+        6
+    }
+
+    fn get(cur: &mut Cursor) -> Result<Self, Error> {
+        let ip = Ipv4Addr::from(cur.get_array()?);
+        let port = cur.get_u16_be()?;
+        Ok(SocketAddrV4::new(ip, port))
+    }
+
+    fn put(&self, cur: &mut CursorMut) -> Result<(), Error> {
+        cur.put_array(&self.ip().octets())?;
+        cur.put_u16_be(self.port())?;
+        Ok(())
+    }
+}
+
+impl ServerAddress for SocketAddrV6 {
+    fn size() -> usize {
+        18
+    }
+
+    fn get(cur: &mut Cursor) -> Result<Self, Error> {
+        let ip = Ipv6Addr::from(cur.get_array()?);
+        let port = cur.get_u16_be()?;
+        Ok(SocketAddrV6::new(ip, port, 0, 0))
+    }
+
+    fn put(&self, cur: &mut CursorMut) -> Result<(), Error> {
+        cur.put_array(&self.ip().octets())?;
+        cur.put_u16_be(self.port())?;
+        Ok(())
+    }
+}
+
 /// Game server addresses list.
 #[derive(Clone, Debug, PartialEq)]
 pub struct QueryServersResponse<I> {
@@ -76,33 +124,31 @@ impl<'a> QueryServersResponse<&'a [u8]> {
     pub fn decode(src: &'a [u8]) -> Result<Self, Error> {
         let mut cur = Cursor::new(src);
         cur.expect(QueryServersResponse::HEADER)?;
-        if cur.remaining() % 6 != 0 {
-            return Err(Error::InvalidPacket);
-        }
-        let s = cur.get_bytes(cur.remaining())?;
+        let s = cur.end();
 
         // extra header for key sent in QueryServers packet
-        let (s, key) = if s.len() >= 6 && s[0] == 0x7f && s[5] == 8 {
-            (&s[6..], Some(u32::from_le_bytes([s[1], s[2], s[3], s[4]])))
+        let (inner, key) = if s.len() >= 6 && s[0] == 0x7f && s[5] == 8 {
+            let key = u32::from_le_bytes([s[1], s[2], s[3], s[4]]);
+            (&s[6..], Some(key))
         } else {
             (s, None)
         };
 
-        let inner = if s.ends_with(&[0; 6]) {
-            &s[..s.len() - 6]
-        } else {
-            s
-        };
         Ok(Self { inner, key })
     }
 
     /// Iterator over game server addresses.
-    pub fn iter(&self) -> impl 'a + Iterator<Item = SocketAddrV4> {
+    pub fn iter<A>(&self) -> impl 'a + Iterator<Item = A>
+    where
+        A: ServerAddress,
+    {
         let mut cur = Cursor::new(self.inner);
-        (0..self.inner.len() / 6).map(move |_| {
-            let ip = Ipv4Addr::from(cur.get_array().unwrap());
-            let port = cur.get_u16_be().unwrap();
-            SocketAddrV4::new(ip, port)
+        std::iter::from_fn(move || {
+            if cur.remaining() == A::size() && cur.end().ends_with(&[0; 2]) {
+                // skip last address with port 0
+                return None;
+            }
+            A::get(&mut cur).ok()
         })
     }
 
@@ -112,13 +158,10 @@ impl<'a> QueryServersResponse<&'a [u8]> {
     }
 }
 
-impl<I> QueryServersResponse<I>
-where
-    I: Iterator<Item = SocketAddrV4>,
-{
+impl QueryServersResponse<()> {
     /// Creates a new `QueryServersResponse`.
-    pub fn new(iter: I, key: Option<u32>) -> Self {
-        Self { inner: iter, key }
+    pub fn new(key: Option<u32>) -> Self {
+        Self { inner: (), key }
     }
 
     /// Encode packet to `buf`.
@@ -127,7 +170,10 @@ where
     /// multiple times until the end flag equals `true`.
     ///
     /// Returns how many bytes was written in `buf` and the end flag.
-    pub fn encode(&mut self, buf: &mut [u8]) -> Result<(usize, bool), Error> {
+    pub fn encode<A>(&mut self, buf: &mut [u8], list: &[A]) -> Result<(usize, usize), Error>
+    where
+        A: ServerAddress,
+    {
         let mut cur = CursorMut::new(buf);
         cur.put_bytes(QueryServersResponse::HEADER)?;
         if let Some(key) = self.key {
@@ -135,19 +181,20 @@ where
             cur.put_u32_le(key)?;
             cur.put_u8(8)?;
         }
-        let mut is_end = false;
-        while cur.remaining() >= 12 {
-            match self.inner.next() {
-                Some(i) => {
-                    cur.put_array(&i.ip().octets())?.put_u16_be(i.port())?;
-                }
-                None => {
-                    is_end = true;
+        let mut count = 0;
+        let mut iter = list.iter();
+        while cur.remaining() >= A::size() * 2 {
+            if let Some(i) = iter.next() {
+                i.put(&mut cur)?;
+                count += 1;
+            } else {
                 break;
             }
         }
+        for _ in 0..A::size() {
+            cur.put_u8(0)?;
         }
-        Ok((cur.put_array(&[0; 6])?.pos(), is_end))
+        Ok((cur.pos(), count))
     }
 }
 
@@ -155,7 +202,7 @@ where
 #[derive(Clone, Debug, PartialEq)]
 pub struct ClientAnnounce {
     /// Address of the client.
-    pub addr: SocketAddrV4,
+    pub addr: SocketAddr,
 }
 
 impl ClientAnnounce {
@@ -163,7 +210,7 @@ impl ClientAnnounce {
     pub const HEADER: &'static [u8] = b"\xff\xff\xff\xffc ";
 
     /// Creates a new `ClientAnnounce`.
-    pub fn new(addr: SocketAddrV4) -> Self {
+    pub fn new(addr: SocketAddr) -> Self {
         Self { addr }
     }
 
@@ -296,18 +343,39 @@ mod tests {
     }
 
     #[test]
-    fn query_servers_response() {
-        let servers: &[SocketAddrV4] = &[
+    fn query_servers_response_ipv4() {
+        type Addr = SocketAddrV4;
+        let servers: &[Addr] = &[
             "1.2.3.4:27001".parse().unwrap(),
             "1.2.3.4:27002".parse().unwrap(),
             "1.2.3.4:27003".parse().unwrap(),
             "1.2.3.4:27004".parse().unwrap(),
         ];
-        let mut p = QueryServersResponse::new(servers.iter().cloned(), Some(0xdeadbeef));
+        let mut p = QueryServersResponse::new(Some(0xdeadbeef));
+        let mut buf = [0; 512];
+        let (n, c) = p.encode(&mut buf, servers).unwrap();
+        assert_eq!(c, servers.len());
+        assert_eq!(n, 12 + Addr::size() * (servers.len() + 1));
+        let e = QueryServersResponse::decode(&buf[..n]).unwrap();
+        assert_eq!(e.iter::<Addr>().collect::<Vec<_>>(), servers);
+    }
+
+    #[test]
+    fn query_servers_response_ipv6() {
+        type Addr = SocketAddrV6;
+        let servers: &[Addr] = &[
+            "[::1]:27001".parse().unwrap(),
+            "[::2]:27002".parse().unwrap(),
+            "[::3]:27003".parse().unwrap(),
+            "[::4]:27004".parse().unwrap(),
+        ];
+        let mut p = QueryServersResponse::new(Some(0xdeadbeef));
         let mut buf = [0; 512];
-        let (n, _) = p.encode(&mut buf).unwrap();
+        let (n, c) = p.encode(&mut buf, servers).unwrap();
+        assert_eq!(c, servers.len());
+        assert_eq!(n, 12 + Addr::size() * (servers.len() + 1));
         let e = QueryServersResponse::decode(&buf[..n]).unwrap();
-        assert_eq!(e.iter().collect::<Vec<_>>(), servers);
+        assert_eq!(e.iter::<Addr>().collect::<Vec<_>>(), servers);
     }
 
     #[test]

supply-chain/imports.lock

@@ -363,7 +363,7 @@ who = "Nick Fitzgerald <fitzgen@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 696 # Nick Fitzgerald (fitzgen)
 start = "2019-03-16"
-end = "2024-03-10"
+end = "2025-07-30"
 
 [[audits.bytecode-alliance.audits.arrayref]]
 who = "Nick Fitzgerald <fitzgen@gmail.com>"