why2-chat 2.4.0

/*
This is part of WHY2
Copyright (C) 2022-2026 Václav Šmejkal

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

//MODULES
pub mod consts;

#[cfg(all(feature = "client_base"))]
pub mod client;

#[cfg(feature = "server")]
pub mod server;

use std::time::Duration;

#[cfg(target_os = "linux")]
use std::
{
    mem,
    os::fd::AsRawFd,
};

use tokio::net::
{
    TcpStream,
    tcp::OwnedWriteHalf,
};

use wincode::{ SchemaRead, SchemaWrite };

use crate::
{
    consts::{ self as chat_consts, Streams },
    crypto::RexPacketStream,
    network::
    {
        self,
        EncryptionMode,
        SequencedPacket,
    },
};

//ENUMS
#[derive(SchemaWrite, SchemaRead, Clone)]
pub enum ScreenPacketCode
{
    Video { data: Vec<u8> }, //VIDEO DATA
    Audio { data: Vec<u8> }, //AUDIO DATA
    Feedback { delay: u32, unsent: u32, shed: bool }, //WORST VIEWER'S BACKLOG (MICROSECONDS, BYTES)
}

//STRUCTS
#[derive(SchemaWrite, SchemaRead, Clone)]
pub struct ScreenPacket //SCREEN PACKET
{
    pub code: ScreenPacketCode, //CODE
    pub seq: usize,             //SEQUENTIAL NUMBER
}

//IMPLEMENTATIONS
impl SequencedPacket for ScreenPacket
{
    fn seq(&self) -> usize { self.seq }
    fn set_seq(&mut self, seq: usize) { self.seq = seq; }
}

//FUNCTIONS
//UTILS
#[cfg(target_os = "linux")]
pub fn tcp_backlog(stream: &TcpStream) -> Option<(u64, Duration)> //UNSENT BYTES AND RTT OVER THE PATH'S BEST
{
    //SAFETY: tcp_info IS PLAIN DATA
    let mut info: libc::tcp_info = unsafe { mem::zeroed() };
    let mut length = mem::size_of::<libc::tcp_info>() as libc::socklen_t;

    //SAFETY: LIVE SOCKET, info IS length BYTES
    let status = unsafe
    {
        libc::getsockopt(stream.as_raw_fd(), libc::IPPROTO_TCP, libc::TCP_INFO, (&raw mut info).cast(), &mut length)
    };

    if status != 0 || (length as usize) < mem::size_of::<libc::tcp_info>() { return None; }

    Some((u64::from(info.tcpi_notsent_bytes), Duration::from_micros(u64::from(info.tcpi_rtt.saturating_sub(info.tcpi_min_rtt)))))
}

#[cfg(not(target_os = "linux"))]
pub fn tcp_backlog(_stream: &TcpStream) -> Option<(u64, Duration)>
{
    None
}

pub fn cap_socket_buffers(stream: &TcpStream) //BOUND THE KERNEL QUEUE THIS SOCKET MAY HIDE
{
    //CAP THE AUTOTUNED BUFFERS THAT HIDE BACKLOG
    let socket = socket2::SockRef::from(stream);

    //BEST EFFORT
    socket.set_send_buffer_size(consts::SOCKET_BUFFER).ok();
    socket.set_recv_buffer_size(consts::SOCKET_BUFFER).ok();
}

pub async fn send_frame //SEND frame TO stream
(
    write_stream: &mut OwnedWriteHalf,
    code: ScreenPacketCode,
    rex_stream: &mut RexPacketStream,
    seq: Option<&mut usize>, //LOCAL/GLOBAL SEQ COUNTER
)
{
    network::send_tcp
    (
        write_stream,
        ScreenPacket
        {
            code,
            seq: 0,
        },
        EncryptionMode::Stream(rex_stream),
        seq,
    ).await;
}

pub async fn receive_frame
(
    streams: &mut Streams<'_>,
    rex_stream: &mut RexPacketStream,
    seq: &mut usize //LOCAL/GLOBAL SEQ
) -> Option<ScreenPacketCode>
{
    let read = network::read_tcp
    (
        streams,
        EncryptionMode::Stream(rex_stream),
        #[cfg(feature = "server")] true,
    ).await?;

    //DESERIALIZE AND RETURN
    match wincode::config::deserialize::<ScreenPacket, _>(&read.data, chat_consts::PACKET_CONFIG)
    {
        Ok(packet) =>
        {
            //VERIFY SEQUENCE NUMBER (CLIENT)
            if packet.seq > *seq || *seq == 0 //VALID
            {
                *seq = packet.seq;
            } else { return None; }

            Some(packet.code)
        },

        _ => { None } //TODO: Implement
    }
}