From 34190a70b1efa0972ef58b88d356f985c46b89ae Mon Sep 17 00:00:00 2001 From: metamuffin Date: Sat, 21 Sep 2024 15:31:18 +0200 Subject: server: mdns and upnp --- server/src/lib.rs | 2 +- server/src/main.rs | 19 +++++- server/src/network/mdns.rs | 61 +++++++++++++++++++ server/src/network/mod.rs | 20 +++++++ server/src/network/register.rs | 132 +++++++++++++++++++++++++++++++++++++++++ server/src/network/upnp.rs | 72 ++++++++++++++++++++++ server/src/register.rs | 132 ----------------------------------------- 7 files changed, 302 insertions(+), 136 deletions(-) create mode 100644 server/src/network/mdns.rs create mode 100644 server/src/network/mod.rs create mode 100644 server/src/network/register.rs create mode 100644 server/src/network/upnp.rs delete mode 100644 server/src/register.rs (limited to 'server/src') diff --git a/server/src/lib.rs b/server/src/lib.rs index ea514d5b..c0ed8edb 100644 --- a/server/src/lib.rs +++ b/server/src/lib.rs @@ -27,10 +27,10 @@ pub mod commands; pub mod data; pub mod entity; pub mod interaction; -pub mod register; pub mod scoreboard; pub mod server; pub mod state; +pub mod network; use hurrycurry_protocol::{glam::Vec2, Message}; diff --git a/server/src/main.rs b/server/src/main.rs index 4db43c64..d0538126 100644 --- a/server/src/main.rs +++ b/server/src/main.rs @@ -21,7 +21,7 @@ use futures_util::{SinkExt, StreamExt}; use hurrycurry_protocol::{PacketC, PacketS, BINCODE_CONFIG, VERSION}; use hurrycurry_server::{ data::DATA_DIR, - register::Register, + network::{mdns::mdns_loop, register::Register, upnp::upnp_loop}, server::{GameServerExt, Server}, trm, ConnectionID, }; @@ -59,9 +59,12 @@ pub(crate) struct Args { /// Enables submissions to the public server registry #[arg(long)] register: bool, - /// Enables mDNS discoverability + /// Enables the mDNS responder for local network discovery #[arg(long)] - discoverable: bool, + mdns: bool, + // Enables automatic gateway port forwarding using UPnP + #[arg(long)] + upnp: bool, /// Server name #[arg(long, short = 'N', default_value = "A Hurry Curry! Server")] server_name: String, @@ -130,6 +133,16 @@ async fn run(args: Args) -> anyhow::Result<()> { ); tokio::task::spawn(r.register_loop()); } + if args.upnp { + tokio::task::spawn(upnp_loop(args.listen.port())); + } + if args.mdns { + tokio::task::spawn(mdns_loop( + args.server_name.clone(), + args.listen.port(), + state.clone(), + )); + } { let state = state.clone(); diff --git a/server/src/network/mdns.rs b/server/src/network/mdns.rs new file mode 100644 index 00000000..870ae7ec --- /dev/null +++ b/server/src/network/mdns.rs @@ -0,0 +1,61 @@ +use crate::server::Server; +use anyhow::Result; +use get_if_addrs::get_if_addrs; +use hurrycurry_protocol::VERSION; +use log::{info, warn}; +use mdns_sd::{ServiceDaemon, ServiceInfo}; +use rand::random; +use std::{collections::HashMap, sync::Arc, time::Duration}; +use tokio::{sync::RwLock, time::interval}; + +pub async fn mdns_loop(name: String, port: u16, state: Arc>) { + let d = match ServiceDaemon::new() { + Ok(d) => d, + Err(e) => { + warn!("mDNS daemon failed to start: {e}"); + return; + } + }; + let mut interval = interval(Duration::from_secs(60)); + let hostname = format!("hks-{}.local.", random::()); + loop { + interval.tick().await; + if let Err(e) = update_service(&d, &state, &name, &hostname, port).await { + warn!("mDNS service update failed: {e}"); + } + info!("updated mDNS service record"); + } +} + +async fn update_service( + d: &ServiceDaemon, + state: &Arc>, + name: &str, + hostname: &str, + port: u16, +) -> Result<()> { + let addrs = get_if_addrs()? + .into_iter() + .map(|e| e.addr.ip()) + .filter(|a| !a.is_loopback()) + .collect::>(); + + let players = state.read().await.count_chefs(); + + d.register(ServiceInfo::new( + "_hurrycurry._tcp.local.", + name, + hostname, + &*addrs, + port, + HashMap::from_iter([ + ("players".to_string(), players.to_string()), + ("version".to_string(), env!("CARGO_PKG_VERSION").to_string()), + ( + "protocol".to_string(), + format!("{}.{}", VERSION.0, VERSION.1), + ), + ]), + )?)?; + Ok(()) +} diff --git a/server/src/network/mod.rs b/server/src/network/mod.rs new file mode 100644 index 00000000..b7ffc15e --- /dev/null +++ b/server/src/network/mod.rs @@ -0,0 +1,20 @@ +/* + Hurry Curry! - a game about cooking + Copyright 2024 metamuffin + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, version 3 of the License only. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . + +*/ +pub mod register; +pub mod upnp; +pub mod mdns; diff --git a/server/src/network/register.rs b/server/src/network/register.rs new file mode 100644 index 00000000..b26768a2 --- /dev/null +++ b/server/src/network/register.rs @@ -0,0 +1,132 @@ +/* + Hurry Curry! - a game about cooking + Copyright 2024 metamuffin + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, version 3 of the License only. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . + +*/ +use crate::server::Server; +use anyhow::{bail, Result}; +use hurrycurry_protocol::{registry::Submission, VERSION}; +use log::{info, warn}; +use rand::random; +use reqwest::{header::USER_AGENT, Client, Url}; +use std::{ + net::{IpAddr, Ipv4Addr, Ipv6Addr}, + str::FromStr, + sync::Arc, + time::Duration, +}; +use tokio::{sync::RwLock, time::interval}; + +const REGISTRY_URI: &'static str = "https://hurrycurry-registry.metamuffin.org"; + +pub struct Register { + name: String, + port: u16, + register_uri: Option, + state: Arc>, + inet_client: Client, + ip4_client: Client, + ip6_client: Client, + secret: u128, + players: usize, +} + +impl Register { + pub fn new( + name: String, + port: u16, + register_uri: Option, + state: Arc>, + ) -> Self { + Self { + name, + register_uri, + players: 0, + port, + secret: random(), + state, + inet_client: Client::new(), + ip4_client: Client::builder() + .local_address(IpAddr::V4(Ipv4Addr::UNSPECIFIED)) + .build() + .unwrap(), + ip6_client: Client::builder() + .local_address(IpAddr::V6(Ipv6Addr::UNSPECIFIED)) + .build() + .unwrap(), + } + } + pub async fn register_loop(mut self) { + let mut interval = interval(Duration::from_secs(60)); + loop { + interval.tick().await; + self.players = self.state.read().await.count_chefs(); + if let Err(e) = self.register().await { + warn!("register error: {e}") + } + } + } + + pub async fn register(&self) -> Result<()> { + info!("register update"); + if let Some(uri) = &self.register_uri { + self.register_with("uri", &self.inet_client, uri.to_owned()) + .await?; + } else { + let (v4, v6) = tokio::join!( + self.register_with( + "ip4", + &self.ip4_client, + format!("ws://0.0.0.0:{}", self.port), + ), + self.register_with( + "ip6", + &self.ip6_client, + format!("ws://0.0.0.0:{}", self.port), + ) + ); + info!("v4: {v4:?}"); + info!("v6: {v6:?}"); + } + Ok(()) + } + // TODO ip v6 + pub async fn register_with(&self, label: &str, client: &Client, uri: String) -> Result<()> { + let res = client + .post(Url::from_str(&format!("{REGISTRY_URI}/v1/register")).unwrap()) + .header( + USER_AGENT, + format!("hurrycurry-server {}", env!("CARGO_PKG_VERSION")), + ) + .json(&Submission { + last_game: 0, + name: self.name.clone(), + uri, + players: self.players, + secret: self.secret, + version: VERSION, + }) + .send() + .await?; + + let r = res.text().await?; + if r == "ok" { + info!("register ok ({label})"); + Ok(()) + } else { + bail!("{r}"); + } + } +} diff --git a/server/src/network/upnp.rs b/server/src/network/upnp.rs new file mode 100644 index 00000000..a16e9684 --- /dev/null +++ b/server/src/network/upnp.rs @@ -0,0 +1,72 @@ +/* + Hurry Curry! - a game about cooking + Copyright 2024 metamuffin + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero General Public License as published by + the Free Software Foundation, version 3 of the License only. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . + +*/ +use anyhow::{bail, Result}; +use get_if_addrs::get_if_addrs; +use igd::{ + aio::{search_gateway, Gateway}, + PortMappingProtocol, SearchOptions, +}; +use log::{error, info}; +use std::{ + net::{IpAddr, Ipv4Addr, SocketAddrV4}, + time::Duration, +}; +use tokio::time::interval; + +pub async fn upnp_loop(port: u16) { + // TODO multiple gateways + let (gateway, local_addr) = match upnp_setup().await { + Ok(g) => g, + Err(e) => { + error!("UPnP gateway not found: {e}"); + return; + } + }; + let mut interval = interval(Duration::from_secs(120)); + loop { + interval.tick().await; + match gateway + .add_port( + PortMappingProtocol::TCP, + 27032, + SocketAddrV4::new(local_addr, port), + 800, + "Hurry Curry! Game Server", + ) + .await + { + Ok(()) => info!("port mapped successfully"), + Err(e) => error!("upnp failed: {e}"), + } + } +} + +async fn upnp_setup() -> Result<(Gateway, Ipv4Addr)> { + let gateway = search_gateway(SearchOptions::default()).await?; + info!("IGD address is {}", gateway.addr); + for i in get_if_addrs()? { + let a = i.addr.ip(); + if !a.is_loopback() { + if let IpAddr::V4(a) = a { + info!("local v4 address is {a}"); + return Ok((gateway, a)); + } + } + } + bail!("no good local address found") +} diff --git a/server/src/register.rs b/server/src/register.rs deleted file mode 100644 index b26768a2..00000000 --- a/server/src/register.rs +++ /dev/null @@ -1,132 +0,0 @@ -/* - Hurry Curry! - a game about cooking - Copyright 2024 metamuffin - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU Affero General Public License as published by - the Free Software Foundation, version 3 of the License only. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU Affero General Public License for more details. - - You should have received a copy of the GNU Affero General Public License - along with this program. If not, see . - -*/ -use crate::server::Server; -use anyhow::{bail, Result}; -use hurrycurry_protocol::{registry::Submission, VERSION}; -use log::{info, warn}; -use rand::random; -use reqwest::{header::USER_AGENT, Client, Url}; -use std::{ - net::{IpAddr, Ipv4Addr, Ipv6Addr}, - str::FromStr, - sync::Arc, - time::Duration, -}; -use tokio::{sync::RwLock, time::interval}; - -const REGISTRY_URI: &'static str = "https://hurrycurry-registry.metamuffin.org"; - -pub struct Register { - name: String, - port: u16, - register_uri: Option, - state: Arc>, - inet_client: Client, - ip4_client: Client, - ip6_client: Client, - secret: u128, - players: usize, -} - -impl Register { - pub fn new( - name: String, - port: u16, - register_uri: Option, - state: Arc>, - ) -> Self { - Self { - name, - register_uri, - players: 0, - port, - secret: random(), - state, - inet_client: Client::new(), - ip4_client: Client::builder() - .local_address(IpAddr::V4(Ipv4Addr::UNSPECIFIED)) - .build() - .unwrap(), - ip6_client: Client::builder() - .local_address(IpAddr::V6(Ipv6Addr::UNSPECIFIED)) - .build() - .unwrap(), - } - } - pub async fn register_loop(mut self) { - let mut interval = interval(Duration::from_secs(60)); - loop { - interval.tick().await; - self.players = self.state.read().await.count_chefs(); - if let Err(e) = self.register().await { - warn!("register error: {e}") - } - } - } - - pub async fn register(&self) -> Result<()> { - info!("register update"); - if let Some(uri) = &self.register_uri { - self.register_with("uri", &self.inet_client, uri.to_owned()) - .await?; - } else { - let (v4, v6) = tokio::join!( - self.register_with( - "ip4", - &self.ip4_client, - format!("ws://0.0.0.0:{}", self.port), - ), - self.register_with( - "ip6", - &self.ip6_client, - format!("ws://0.0.0.0:{}", self.port), - ) - ); - info!("v4: {v4:?}"); - info!("v6: {v6:?}"); - } - Ok(()) - } - // TODO ip v6 - pub async fn register_with(&self, label: &str, client: &Client, uri: String) -> Result<()> { - let res = client - .post(Url::from_str(&format!("{REGISTRY_URI}/v1/register")).unwrap()) - .header( - USER_AGENT, - format!("hurrycurry-server {}", env!("CARGO_PKG_VERSION")), - ) - .json(&Submission { - last_game: 0, - name: self.name.clone(), - uri, - players: self.players, - secret: self.secret, - version: VERSION, - }) - .send() - .await?; - - let r = res.text().await?; - if r == "ok" { - info!("register ok ({label})"); - Ok(()) - } else { - bail!("{r}"); - } - } -} -- cgit v1.2.3-70-g09d2