TheLanc3/lan-mouse
1
0
Fork 0
mirror of https://github.com/feschber/lan-mouse.git synced 2026-03-07 11:59:59 +03:00
Code Issues Packages Projects Releases Wiki Activity

simplify dns

Browse Source
This commit is contained in:
Ferdinand Schober
2024-07-15 08:15:27 +02:00
parent 0ffeaf7e91
commit 06c6b2ec2e
6 changed files with 65 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
resources/client_row.ui
View File

@@ -44,6 +44,7 @@
<child>
<object class="GtkEntry" id="port">
<!-- <property name="title" translatable="yes">port</property> -->
<property name="max-width-chars">5</property>
<property name="input_purpose">GTK_INPUT_PURPOSE_NUMBER</property>
<property name="xalign">0.5</property>
<property name="valign">center</property>

1
resources/window.ui
View File

@@ -124,6 +124,7 @@
<property name="title">port</property>
<child>
<object class="GtkEntry" id="port_entry">
<property name="max-width-chars">5</property>
<signal name="activate" handler="handle_port_edit_apply" swapped="true"/>
<signal name="changed" handler="handle_port_changed" swapped="true"/>
<!-- <signal name="delete-text" handler="handle_port_changed" swapped="true"/> -->

2
src/client.rs
View File

@@ -119,6 +119,8 @@ pub struct ClientState {
pub active_addr: Option<SocketAddr>,
/// tracks whether or not the client is responding to pings
pub alive: bool,
/// ips from dns
pub dns_ips: Vec<IpAddr>,
/// all ip addresses associated with a particular client
/// e.g. Laptops usually have at least an ethernet and a wifi port
/// which have different ip addresses

35
src/dns.rs
View File

@@ -1,8 +1,8 @@
use anyhow::Result;
use std::{collections::HashSet, error::Error, net::IpAddr};
use std::net::IpAddr;
use tokio::sync::mpsc::{channel, Receiver, Sender};
use hickory_resolver::TokioAsyncResolver;
use hickory_resolver::{error::ResolveError, TokioAsyncResolver};
use crate::{client::ClientHandle, server::Server};
@@ -24,7 +24,7 @@ impl DnsResolver {
))
}
async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, Box<dyn Error>> {
async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, ResolveError> {
let response = self.resolver.lookup_ip(host).await?;
for ip in response.iter() {
log::info!("{host}: adding ip {ip}");
@@ -44,21 +44,14 @@ impl DnsResolver {
let handle = self.dns_request.recv().await.expect("channel closed");
/* update resolving status */
let hostname = if let Some((c, s)) = server.client_manager.borrow_mut().get_mut(handle)
{
s.resolving = true;
c.hostname.clone()
} else {
continue;
let hostname = match server.get_hostname(handle) {
Some(hostname) => hostname,
None => continue,
};
let Some(hostname) = hostname else {
continue;
};
/* FIXME race -> need some other event */
server.client_resolved(handle);
log::info!("resolving ({handle}) `{hostname}` ...");
server.set_resolving(handle, true);
let ips = match self.resolve(&hostname).await {
Ok(ips) => ips,
Err(e) => {
@@ -67,16 +60,8 @@ impl DnsResolver {
}
};
/* update ips and resolving state */
if let Some((c, s)) = server.client_manager.borrow_mut().get_mut(handle) {
let mut addrs = HashSet::from_iter(c.fix_ips.iter().cloned());
for ip in ips {
addrs.insert(ip);
}
s.ips = addrs;
s.resolving = false;
}
server.client_resolved(handle);
server.update_dns_ips(handle, ips);
server.set_resolving(handle, false);
}
}
}

34
src/frontend/gtk/window.rs
View File

@@ -207,12 +207,15 @@ impl Window {
}
pub fn request_port_change(&self) {
let port = self.imp().port_entry.get().text().to_string();
if let Ok(port) = port.as_str().parse::<u16>() {
self.request(FrontendRequest::ChangePort(port));
} else {
self.request(FrontendRequest::ChangePort(DEFAULT_PORT));
}
let port = self
.imp()
.port_entry
.get()
.text()
.as_str()
.parse::<u16>()
.unwrap_or(DEFAULT_PORT);
self.request(FrontendRequest::ChangePort(port));
}
pub fn request_capture(&self) {
@@ -224,20 +227,15 @@ impl Window {
}
pub fn request_client_state(&self, client: &ClientObject) {
let handle = client.handle();
let event = FrontendRequest::GetState(handle);
self.request(event);
self.request(FrontendRequest::GetState(client.handle()));
}
pub fn request_client_create(&self) {
let event = FrontendRequest::Create;
self.request(event);
self.request(FrontendRequest::Create);
}
pub fn request_dns(&self, client: &ClientObject) {
let data = client.get_data();
let event = FrontendRequest::ResolveDns(data.handle);
self.request(event);
self.request(FrontendRequest::ResolveDns(client.get_data().handle));
}
pub fn request_client_update(&self, client: &ClientObject) {
@@ -257,15 +255,11 @@ impl Window {
}
pub fn request_client_activate(&self, client: &ClientObject, active: bool) {
let handle = client.handle();
let event = FrontendRequest::Activate(handle, active);
self.request(event);
self.request(FrontendRequest::Activate(client.handle(), active));
}
pub fn request_client_delete(&self, client: &ClientObject) {
let handle = client.handle();
let event = FrontendRequest::Delete(handle);
self.request(event);
self.request(FrontendRequest::Delete(client.handle()));
}
pub fn request(&self, event: FrontendRequest) {

43
src/server.rs
View File

@@ -285,7 +285,7 @@ impl Server {
self.notify_frontend(FrontendEvent::PortChanged(port, msg));
}
pub(crate) fn client_resolved(&self, handle: ClientHandle) {
pub(crate) fn client_updated(&self, handle: ClientHandle) {
let state = self.client_manager.borrow().get(handle).cloned();
if let Some((config, state)) = state {
self.notify_frontend(FrontendEvent::State(handle, config, state));
@@ -296,7 +296,8 @@ impl Server {
self.client_manager
.borrow()
.get_client_states()
.filter_map(|(h, (_, s))| if s.active { Some(h) } else { None })
.filter(|(_, (_, s))| s.active)
.map(|(h, _)| h)
.collect()
}
@@ -443,12 +444,28 @@ impl Server {
}
fn update_fix_ips(&self, handle: ClientHandle, fix_ips: Vec<IpAddr>) {
let mut client_manager = self.client_manager.borrow_mut();
let Some((c, _)) = client_manager.get_mut(handle) else {
return;
if let Some((c, _)) = self.client_manager.borrow_mut().get_mut(handle) {
c.fix_ips = fix_ips;
};
self.update_ips(handle);
}
c.fix_ips = fix_ips;
pub(crate) fn update_dns_ips(&self, handle: ClientHandle, dns_ips: Vec<IpAddr>) {
if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
s.dns_ips = dns_ips;
};
self.update_ips(handle);
}
fn update_ips(&self, handle: ClientHandle) {
if let Some((c, s)) = self.client_manager.borrow_mut().get_mut(handle) {
s.ips = c
.fix_ips
.iter()
.cloned()
.chain(s.dns_ips.iter().cloned())
.collect::<HashSet<_>>();
}
}
fn update_hostname(&self, handle: ClientHandle, hostname: Option<String>) {
@@ -528,6 +545,20 @@ impl Server {
let status = FrontendEvent::CaptureStatus(status);
self.notify_frontend(status);
}
pub(crate) fn set_resolving(&self, handle: ClientHandle, status: bool) {
if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
s.resolving = status;
}
self.client_updated(handle);
}
pub(crate) fn get_hostname(&self, handle: u64) -> Option<String> {
self.client_manager
.borrow_mut()
.get_mut(handle)
.and_then(|(c, _)| c.hostname.clone())
}
}
async fn listen_frontend(