hyprshell 4.10.2

A modern GTK4-based window switcher and application launcher for Hyprland
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

use anyhow::{Context, bail};
use async_channel::{Receiver, Sender};
use core_lib::transfer;
use core_lib::transfer::ExternalTransferType;
use core_lib::util::get_daemon_socket_path_buff;
use std::fs::remove_file;
use std::io::{BufRead, BufReader, Write};
use std::os::unix::net;
use std::os::unix::net::UnixStream;
use std::thread;
use tracing::{debug, debug_span, info, instrument, trace, warn};

pub fn socket_handler(event_sender: Sender<ExternalTransferType>) {
    let _span = debug_span!("socket_handler").entered();
    let path = &get_daemon_socket_path_buff();
    let listener = {
        // remove old PATH
        if path.exists() {
            remove_file(path).expect("Unable to remove old socket file");
        }
        net::UnixListener::bind(path)
            .unwrap_or_else(|_| panic!("Failed to bind to socket {}", path.display()))
    };
    debug!("Starting socket on {}", path.display());

    loop {
        let path = listener.accept();
        match path {
            Ok((conn, _)) => {
                handle_client(conn, &event_sender)
                    .context("Failed to handle client")
                    .unwrap_or_else(|e| {
                        warn!("Failed to handle connection: {e:?}");
                    });
            }
            Err(e) => {
                warn!("Failed to accept connection: {e:?}");
            }
        }
    }
}

#[instrument(level = "debug", skip(stream, event_sender))]
fn handle_client(
    mut stream: UnixStream,
    event_sender: &Sender<ExternalTransferType>,
) -> anyhow::Result<()> {
    let mut buffer = vec![];
    let mut reader = BufReader::new(&mut stream);
    reader
        .read_until(b'\0', &mut buffer)
        .context("Can't read data from socket")?;
    if buffer.is_empty() {
        return Ok(());
    }
    let transfer = match transfer::receive_from_buffer(buffer) {
        Ok(transfer) => transfer,
        Err(err) => {
            let _ = stream
                .write_all(b"ERR")
                .and_then(|()| stream.write_all(b"\0"));
            bail!("Invalid transfer received.\n{err:?}");
        }
    };
    event_sender
        .send_blocking(transfer)
        .context("Failed to send transfer")?;
    let _ = stream
        .write_all(b"OK")
        .and_then(|()| stream.write_all(b"\0"));
    Ok(())
}