why2-chat 2.2.3

/*
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 image;
pub mod handshake;

use std::
{
    sync::{ Arc, Mutex },
    path::PathBuf,
    collections::BTreeMap,
};

use tokio::
{
    task,
    io::AsyncWriteExt,
    sync::
    {
        oneshot,
        mpsc::Sender,
    },
};

use rand::
{
    TryRng,
    rngs::SysRng,
};

use zeroize::Zeroizing;

use semver::Version;

use image::Animation;

use handshake::Handshake;

use crate::
{
    misc,
    cache,
    role::Role,
    crypto,
    options::{ self, LoginState },
    consts::Streams,
    network::
    {
        self,
        file::client as file,
        codes::
        {
            PacketCode,
            MessageColors,
            StoredMessage,
            UserFile,
            OnlineUser,
            OfflineUser,
            UserScreen,
            Device,
            ServerSetting,
            UserProfile,
            BanEntry,
        },
    },
};

#[cfg(feature = "client_voice")]
use crate::network::voice::client::
{
    self as voice_client,
    options as voice_options,
};

#[cfg(feature = "client_screen")]
use crate::network::screen::client::
{
    self as screen,
    options as screen_options,
};

//STRUCTS
pub struct TofuRequest
{
    pub host: String,           //WHAT THE KEY IS PINNED AGAINST
    pub hash: String,           //SHA256 OF THE SERVER'S PUBLIC KEYS
    pub mismatch: bool,         //A KEY IS PINNED FOR host AND DIFFERS
    pub pinned: Option<String>, //THE FINGERPRINT ON RECORD
    pub reply: oneshot::Sender<bool>,
}

pub struct VoiceUser
{
    pub id: usize,             //ID OF USER
    pub username: String,      //USERNAME TO DISPLAY
    pub is_speaking: bool,     //TAKE A WILD GUESS
    pub latency: Option<u128>, //USER'S PING
    pub is_local: bool,        //AM I THE USER?
}

//ENUMS
pub enum ClientEvent
{
    Register,                                                    //REGISTER PROMPT
    Login,                                                       //LOGIN PROMPT
    FirstUser,                                                   //FIRST USER
    Authenticated(Role),                                         //LOGIN SUCCESSFUL, ROLE
    Connected(String),                                           //SUCCESSFUL CONNECTION MESSAGE
    Message(String, String, usize, u64, MessageColors, Option<Option<String>>), //RECEIVED MESSAGE, ITS CHANNEL
    PrivateMessageSent(String, usize, String, MessageColors),    //SENT PM
    PrivateMessageRecv(String, usize, String, MessageColors),    //RECEIVED PM
    TofuError,                                                   //TOFU VERIFICATION REJECTED BY THE USER
    TofuPrompt(TofuRequest),                                     //TOFU DECISION ASKED OF THE USER
    TofuSkip(String),                                            //TOFU VERIFICATION SKIPPED
    ReconnectFailed,                                             //RECONNECTING AFTER PINNING THE KEY FAILED
    HandshakeFailed(String),                                     //THE KEY EXCHANGE DID NOT ADD UP
    VoiceActivity(Vec<VoiceUser>),                               //VOICE OVERLAY
    VoiceRoster(Vec<(usize, String)>),                           //THE CHANNEL'S WHOLE VOICE ROSTER, SELF EXCLUDED
    VoiceJoin(usize, String),                                    //SOMEBODY JOINED VOICE IN OUR CHANNEL
    VoiceLeave(usize),                                           //SOMEBODY LEFT VOICE IN OUR CHANNEL
    Join(String, Option<u8>, usize, Option<Device>),             //CLIENT CONNECTED
    Leave(String, usize),                                        //CLIENT DISCONNECTED
    ServerSay(String),                                           //SERVER MESSAGE
    Role(Role, Option<String>),                                  //A ROLE WAS SET (THE ROLE, AND WHO ON - None IS US)
    History(Vec<StoredMessage>, u64, bool, u64, bool),           //A PAGE OF STORED MESSAGES (START, MORE, KEPT, OLDER)
    ChannelChanged(Option<String>),                              //WE SWITCHED CHANNEL
    ChannelCreated(String),                                      //CHANNEL CREATED
    ChannelDestroyed(String),                                    //CHANNEL ABANDONED
    Typing(String),                                              //SOMEBODY IN OUR CHANNEL IS WRITING
    Muted,                                                       //HAHA
    InvalidUsage,                                                //INVALID COMMAND USAGE
    Deleted(u64),                                                //A MESSAGE WAS DELETED (MESSAGE ID)
    VersionFailed,                                               //FETCHING VERSIONS FAILED
    VersionMismatch(String, String),                             //MISMATCH GIT HASH
    UnsafeVersion(usize, Version, String),                       //OLD VERSION
    Username(bool, u64, u64),                                    //USERNAME PROMPT
    VoiceEnabled,                                                //VOICE CHAT ENABLED
    VoiceDeviceFailed,                                           //REBUILDING THE AUDIO STREAMS FAILED
    VoiceHandshakeFailed,                                        //THE SERVER NEVER ANSWERED THE UDP HANDSHAKE
    VoiceDisabled,                                               //VOICE CHAT DISABLED
    List(Vec<OnlineUser>, Option<Vec<OfflineUser>>),             //LIST OF USERS, CONNECTED AND NOT
    ServerSettings(Vec<ServerSetting>, bool),                    //server.toml AS THE SERVER HOLDS IT
    Profile(String, UserProfile, bool, bool),                    //A PROFILE (WHOSE, IT, OURS, A SAVE ACK)
    Colors,                                                      //A /color LANDED ON THE SERVER
    ServerBans(Vec<BanEntry>, Vec<BanEntry>),                    //server_bans.toml (USERNAMES, ADDRESSES)
    Upload(u64, String, u64),                                    //UPLOADING FILE (UID, NAME, SIZE)
    Image(u64, String, u64),                                     //UPLOADING IMAGE (UID, NAME, SIZE)
    ImageDisplay(String, String, u64, Animation, Option<u8>),    //SOMEBODY'S IMAGE, DECODED AND READY TO DRAW
    ImageData([u8; 32], Option<Animation>),                      //A HISTORY IMAGE THAT WAS ASKED FOR (None = NOT COMING)
    ImagePending(String, String, u64, [u8; 32], Option<u8>),     //SOMEBODY'S IMAGE, ASKED FOR AND ON ITS WAY
    ImageOffer(String, String, u64, [u8; 32], Option<u8>),       //SOMEBODY'S IMAGE, WAITING TO BE ASKED FOR
    ImageParked(String, String, String, u64, [u8; 32], Option<u8>), //SOMEBODY'S IMAGE IN ANOTHER CHANNEL (CHANNEL FIRST)
    ImageRequest([u8; 32]),                                      //A CLICKED CAPTION THE CACHE COULD NOT ANSWER
    AvatarFailed(String),                                        //CUTTING OUR AVATAR FAILED
    ImageFailed(String, String, u64, Option<u8>),                //SOMEBODY'S IMAGE, WHICH WOULD NOT DECODE
    Uploaded(String, String),                                    //USER UPLOADED FILE
    UploadDone(u64, String),                                     //OUR OWN UPLOAD IS ON THE WIRE
    Download(u64, String, u64),                                  //DOWNLOADING FILE (UID, NAME, SIZE)
    Downloaded(u64, String),                                     //DOWNLOADED FILE
    DownloadFailed(u64, String),                                 //DOWNLOADING FAILED
    TransferProgress(u64, u64),                                  //HOW FAR A TRANSFER HAS GOT (UID, BYTES)
    Files(Vec<UserFile>),                                        //FILE LIST
    Screens(Vec<UserScreen>),                                    //SCREENSHARE LIST
    UploadLimit,                                                 //MAX CONCURRENT UPLOADS REACHED
    Screen(bool),                                                //TOGGLED SCREENSHARE
    ScreenFailed(String),                                        //SCREEN CAPTURE FAILED
    Attach(String),                                              //ATTACHED SCREENSHARE
    Deattach(String),                                            //DEATTACHED SCREENSHARE
    Attached(String),                                            //SOMEBODY ATTACHED OUR SCREENSHARE
    Deattached(String),                                          //SOMEBODY DEATTACHED OUR SCREENSHARE
    Screenshare(String),                                         //SOMEBODY STARTED SCREENSHARING
    ScreenshareEnd(String),                                      //SOMEBODY STOPPED SCREENSHARING
    IncompatibleVersion(String, String),                         //INCOMPATIBLE SERVER VERSION
    UsernameRejected,                                            //USERNAME REJECTED BY SERVER
    PasswordRejected(u64),                                       //PASSWORD REJECTED BY SERVER
    SpamWarning,                                                 //SPAM WARNING
    Socks5Voice,                                                 //DISABLED VOICE ON SOCKS5
    DisabledFeature,                                             //DISABLED FEATURE
    Quit(bool),                                                  //SERVER QUIT COMMUNICATION
}

//LISTS
pub static ACTIVE_UPLOADS: Mutex<BTreeMap<[u8; 32], PathBuf>> = Mutex::new(BTreeMap::new()); //ACTIVE UPLOADS
//FUNCTIONS
//PUBLIC
pub async fn listen_server(streams: &mut Streams<'_>, tx: Sender<ClientEvent>) //SERVER -> CLIENT COMMUNICATION
{
    //SET GLOBAL CLIENT ENCRYPTION & MAC KEY
    let mut keys = (Zeroizing::new(vec![]), Zeroizing::new(vec![]));

    //PIN THE KEY AND RUN THE HANDSHAKE AGAIN
    loop
    {
        //SEND HEADER
        let mut header = [0u8; 32];
        SysRng.try_fill_bytes(&mut header).unwrap(); //GENERATE RANDOM HEADER
        options::set_obfuscation_key(&header);
        streams.1.lock().await.write_all(&header).await.unwrap();

        match handshake::key_exchange(streams, &mut keys, &tx, None).await
        {
            Handshake::Ready => break,
            Handshake::Failed => return,

            //THE SERVER WENT AWAY BETWEEN CONNECTIONS
            Handshake::Reconnect => if !handshake::reconnect(streams).await
            {
                tx.send(ClientEvent::ReconnectFailed).await.unwrap();
                return;
            },
        }
    }

    //SERVER INFO VARIABLES
    let mut min_pass: Option<u64> = None;
    let mut max_uname: Option<u64> = None;
    let mut min_uname: Option<u64> = None;

    let mut invalid_username = false; //PRINT "Invalid Username!"
    let mut invalid_password = false;

    let mut disabled_registration = false; //PRINT "Registration disabled!"

    //FIRST Join PACKET CARRIES OUR OWN USERNAME
    #[cfg(feature = "client_voice")]
    let mut first_message = true;

    //CONNECTION PROPERTIES
    let mut id = 0usize; //ID SET BY SERVER
    #[cfg(feature = "client_voice")]
    let mut username: Option<String> = None;

    //LOOP READING
    loop
    {
        //SERVER DIED CHECK
        let mut dropped = false;

        let read = match network::receive(streams, Some(&keys), None).await
        {
            Some(code) => code,
            None =>
            {
                dropped = true; //YUP, SERVER IS 6 FEET UNDER
                PacketCode::Disconnect
            },
        };

        //CHECK FOR MUTED CLIENT
        #[cfg(feature = "client_voice")]
        if let PacketCode::Message { id, .. } = read
        {
            if options::is_muted(Some(id)) { continue; }
        }

        //KEEPALIVE
        if matches!(read, PacketCode::KeepAlive)
        {
            //ECHO
            network::send(&mut *streams.1.lock().await, PacketCode::KeepAlive, options::get_keys().as_ref()).await;
            continue;
        }

        //CODES
        match read
        {
            //REGULAR MESSAGE
            PacketCode::Message { text, username, id, message_id, colors, channel } =>
            {
                tx.send(ClientEvent::Message(text, username, id, message_id, colors, channel)).await.unwrap();
            }

            //THE LOBBY'S STORED MESSAGES
            PacketCode::History { messages, start, more, kept, older } =>
            {
                tx.send(ClientEvent::History(messages, start, more, kept, older)).await.unwrap();

                continue;
            }

            //VERSION CHECK
            PacketCode::Version { version } =>
            {
                let local_version = misc::get_version().to_string();

                //NON MATCHING VERSION (WILL GET DISCONNECTED)
                if version != local_version
                {
                    tx.send(ClientEvent::IncompatibleVersion(local_version.clone(), version)).await.unwrap();
                }

                //RESPOND
                network::send(&mut *streams.1.lock().await,
                    PacketCode::Version { version: local_version }, Some(&keys)).await;

                continue;
            }

            //WELCOME CODE - SERVER INFORMATIONS
            PacketCode::Welcome { min_pass: smin_pass, max_uname: smax_uname,
                min_uname: smin_uname, server_name, server_uname, git_hash } =>
            {
                options::set_server_username(&server_uname);

                min_pass = Some(smin_pass);
                max_uname = Some(smax_uname);
                min_uname = Some(smin_uname);

                //COMPARSE HASHES
                let client_hash = env!("WHY2_GIT_HASH");
                if !client_hash.is_empty() && !git_hash.is_empty() && !client_hash.starts_with(&git_hash) && !git_hash.starts_with(client_hash)
                {
                    //DISPLAY VERSION MISMATCH
                    tx.send(ClientEvent::VersionMismatch(client_hash.to_string(), git_hash.to_string())).await.unwrap();
                }

                tx.send(ClientEvent::Connected(server_name)).await.unwrap();
            },

            //REKEY - CHANGE KEYS
            PacketCode::Rekey =>
            {
                //WAIT FOR SERVER TO INIT KEY EXCHANGE
                let current_keys = keys.clone();

                //A REKEY THAT DOES NOT VERIFY ENDS THE SESSION
                if handshake::key_exchange(streams, &mut keys, &tx, Some(&current_keys)).await != Handshake::Ready { return; }
            }

            //PICK USERNAME
            PacketCode::UsernameRequest =>
            {
                //INVALID UNAME
                if invalid_username
                {
                    tx.send(ClientEvent::UsernameRejected).await.unwrap();
                } else //VALID
                {
                    //SET INVALID USERNAME FOR POSSIBLE NEXT CODE
                    invalid_username = true;
                }

                options::set_login_state(LoginState::Username);
                tx.send(ClientEvent::Username(disabled_registration, min_uname.unwrap(), max_uname.unwrap())).await.unwrap();
            },

            //REGISTER
            PacketCode::RegisterRequest =>
            {
                options::set_asking_password(true);

                //INVALID PASS
                if invalid_password
                {
                    tx.send(ClientEvent::PasswordRejected(min_pass.unwrap())).await.unwrap();
                } else
                {
                    invalid_password = true;
                }

                options::set_login_state(LoginState::Register);
                tx.send(ClientEvent::Register).await.unwrap();
            },

            //LOGIN
            PacketCode::LoginRequest =>
            {
                options::set_asking_password(true);
                options::set_login_state(LoginState::Login);
                tx.send(ClientEvent::Login).await.unwrap();
            },

            //FIRST USER
            PacketCode::FirstUser =>
            {
                tx.send(ClientEvent::FirstUser).await.unwrap();
            },

            //START CHATTING
            PacketCode::Accept { id: sid, role } =>
            {
                tx.send(ClientEvent::Authenticated(role)).await.unwrap();

                //SET SERVER-SIDE ID
                id = sid;

                //ALLOW MESSAGE HISTORY & COMMANDS
                options::set_sending_messages(true);
                options::set_login_state(LoginState::None);
            },

            //JOIN MESSAGE (CLIENT CONNECTED)
            PacketCode::Join { username: user, username_color, id, device } =>
            {
                #[cfg(feature = "client_voice")]
                if first_message
                {
                    first_message = false;
                    username = Some(user.clone());
                }

                tx.send(ClientEvent::Join(user, username_color, id, device)).await.unwrap();
            }

            //LEAVE MESSAGE (CLIENT DISCONNECTED)
            PacketCode::Leave { username, id } =>
            {
                tx.send(ClientEvent::Leave(username, id)).await.unwrap();

                #[cfg(feature = "client_voice")]
                voice_client::remove_consumer(&id);
            },

            //CHANNEL CHANGE
            PacketCode::Channel { channel } =>
            {
                //REMOVE ALL STORED VOICE CLIENTS
                #[cfg(feature = "client_voice")]
                voice_client::remove_all_consumers();

                options::set_channel(channel.clone().unwrap_or_default());

                tx.send(ClientEvent::ChannelChanged(channel)).await.unwrap();
            },

            //CHANNEL CREATED
            PacketCode::ChannelCreated { name } =>
            {
                tx.send(ClientEvent::ChannelCreated(name)).await.unwrap();
            },

            //CHANNEL ABANDONED
            PacketCode::ChannelDestroyed { name } =>
            {
                tx.send(ClientEvent::ChannelDestroyed(name)).await.unwrap();
            },

            //SOMEBODY IS WRITING
            PacketCode::Typing { username } =>
            {
                tx.send(ClientEvent::Typing(username)).await.unwrap();
            },

            //SERVER ALLOWED VOICE
            #[cfg(feature = "client_voice")]
            PacketCode::Voice { token } =>
            {
                if options::socks5_enabled()
                {
                    tx.send(ClientEvent::Socks5Voice).await.unwrap();
                    continue;
                }

                //FOLLOW THE SERVER INSTEAD OF TOGGLING
                voice_options::set_use_voice(token.is_some());

                //TOGGLE VOICE (& PRINT STATUS)
                tx.send(match token
                {
                    Some(token) =>
                    {
                        let username = username.clone();
                        let voice_tx = tx.clone();
                        let stream = streams.1.clone();
                        tokio::spawn(voice_client::listen_server_voice(id, username.unwrap(), voice_tx, stream, token));
                        ClientEvent::VoiceEnabled
                    },

                    None => ClientEvent::VoiceDisabled,
                }).await.unwrap();
            },

            //THE WHOLE VOICE ROSTER
            PacketCode::VoiceClients { clients } =>
            {
                //ADD CLIENTS WE CAN ACTUALLY HEAR
                #[cfg(feature = "client_voice")]
                if voice_options::get_use_voice()
                {
                    for (id, username) in clients.iter()
                    {
                        voice_client::add_consumer(*id, username.clone());
                    }
                }

                tx.send(ClientEvent::VoiceRoster(clients)).await.unwrap();
            }

            //CLIENT JOINED VOICE
            PacketCode::VoiceJoin { username, id: sid, channel } =>
            {
                //OUR OWN JOIN COMES BACK TO US TOO
                if id == sid || channel.unwrap_or_default() != options::get_channel() { continue; }

                #[cfg(feature = "client_voice")]
                if voice_options::get_use_voice()
                {
                    voice_client::add_consumer(sid, username.clone());
                }

                tx.send(ClientEvent::VoiceJoin(sid, username)).await.unwrap();
            },

            //CLIENT LEFT VOICE
            PacketCode::VoiceLeave { id, channel } =>
            {
                //ANOTHER CHANNEL'S VOICE
                if channel.unwrap_or_default() != options::get_channel() { continue; }

                #[cfg(feature = "client_voice")]
                voice_client::remove_consumer(&id);

                tx.send(ClientEvent::VoiceLeave(id)).await.unwrap();
            },

            //SERVER MESSAGE
            PacketCode::ServerSay { message } =>
            {
                tx.send(ClientEvent::ServerSay(message)).await.unwrap();
            }

            //A ROLE WAS SET, ON US OR ON SOMEBODY ELSE
            PacketCode::ServerRole { role, username, .. } =>
            {
                tx.send(ClientEvent::Role(role, username)).await.unwrap();
            },

            //server.toml, ASKED FOR OR JUST STORED
            PacketCode::ServerSettings { settings, save } =>
            {
                tx.send(ClientEvent::ServerSettings(settings, save)).await.unwrap();
            },

            //A PROFILE, ASKED FOR OR JUST STORED
            PacketCode::Profile { username, profile, own, save } =>
            {
                tx.send(ClientEvent::Profile(username, profile, own, save)).await.unwrap();
            },

            //THE BAN LIST, ASKED FOR OR JUST LIFTED
            PacketCode::ServerBans { users, ips } =>
            {
                tx.send(ClientEvent::ServerBans(users, ips)).await.unwrap();
            },

            //THE SERVER STORED A COLOR
            PacketCode::Colors { .. } =>
            {
                tx.send(ClientEvent::Colors).await.unwrap();
            },

            //LIST OF USERS
            PacketCode::List { online, offline } =>
            {
                tx.send(ClientEvent::List(online, offline)).await.unwrap();
            },

            //UPLOAD APPROVAL
            PacketCode::Upload { hash, token, uid } | PacketCode::Image { hash, token, uid, .. } =>
            {
                //SPAWN UPLOAD TASK
                let file_tx = tx.clone(); //CLONE TX
                tokio::spawn(file::upload(token, uid, hash,
                    file_tx, matches!(read, PacketCode::Image { .. })));
                continue;
            },

            //DUPLICATE IMAGE
            PacketCode::ImageDuplicate { hash } =>
            {
                if let Some(path) = ACTIVE_UPLOADS.lock().unwrap().remove(&hash) { misc::drop_avatar_temp(&path); }
                continue;
            },

            //DOWNLOAD
            PacketCode::Download { token } =>
            {
                //SPAWN DOWNLOAD TASK
                let file_tx = tx.clone(); //CLONE TX
                tokio::spawn(file::download(token, file_tx));
                continue;
            },

            //SOMEBODY'S IMAGE
            //ONE OF THOSE, DECODED OFF THE LOOP
            PacketCode::ImageData { hash, data } =>
            {
                let image_tx = tx.clone();

                tokio::spawn(async move
                {
                    let data = Arc::new(data);
                    let (digest, image) = image::digest_and_decode(data.clone()).await;
                    if digest == hash { cache::store(&hash, &data).await; }

                    image_tx.send(ClientEvent::ImageData(hash, image)).await.unwrap();
                });

                continue;
            },

            //EITHER THE PICTURE OR THE OFFER OF IT
            PacketCode::ImageDisplay { username, filename, message_id, hash, data, username_color, channel } =>
            {
                let image_tx = tx.clone();

                //ANOTHER CHANNEL'S PICTURE: CACHE IT, DECODE NOTHING
                let elsewhere = channel.map(Option::unwrap_or_default).filter(|channel| *channel != options::get_channel());

                if elsewhere.is_some() || !image::auto_show_images()
                {
                    tokio::spawn(async move
                    {
                        if let Some(data) = data
                        {
                            let data = Arc::new(data);
                            let digest = task::spawn_blocking
                            ({
                                let data = data.clone();
                                move || crypto::sha256(&data)
                            }).await.expect("Hashing image panicked");

                            cache::store(&digest, &data).await;
                        }

                        image_tx.send(match elsewhere
                        {
                            Some(channel) => ClientEvent::ImageParked(channel, username, filename, message_id, hash, username_color),
                            None => ClientEvent::ImageOffer(username, filename, message_id, hash, username_color),
                        }).await.unwrap();
                    });

                    continue;
                }

                tokio::spawn(async move
                {
                    //ANSWER AN OFFER OUT OF THE CACHE FIRST
                    let (data, fresh) = match data
                    {
                        Some(data) => (Some(Arc::new(data)), true),
                        None => (cache::load(&hash).await.map(Arc::new), false),
                    };

                    let Some(data) = data else
                    {
                        //ASK FROM THE EVENT LOOP, WHICH OWNS THE WRITE HALF
                        image_tx.send(ClientEvent::ImagePending(username, filename, message_id, hash, username_color)).await.unwrap();

                        return;
                    };

                    let image = match fresh
                    {
                        //OFF THE WIRE: FILE IT UNDER WHAT IT HASHES TO
                        true =>
                        {
                            let (digest, image) = image::digest_and_decode(data.clone()).await;

                            cache::store(&digest, &data).await;

                            image
                        },

                        //OUT OF THE CACHE, ALREADY FILED UNDER THIS HASH
                        false => task::spawn_blocking(move || image::decode_image(&data))
                            .await.expect("Decoding image panicked"),
                    };

                    image_tx.send(match image
                    {
                        Some(image) => ClientEvent::ImageDisplay(username, filename, message_id, image, username_color),
                        None => ClientEvent::ImageFailed(username, filename, message_id, username_color),
                    }).await.unwrap();
                });

                continue;
            },

            //UPLOADED ANNOUNCEMENT
            PacketCode::Uploaded { filename, username } =>
            {
                tx.send(ClientEvent::Uploaded(username, filename)).await.unwrap();
            },

            //FILE LIST
            PacketCode::Files { users } =>
            {
                tx.send(ClientEvent::Files(users)).await.unwrap();
            },

            //SCREENSHARE LIST
            PacketCode::Screens { users } =>
            {
                tx.send(ClientEvent::Screens(users)).await.unwrap();
            },

            //MAX PARALLEL UPLOADS
            PacketCode::UploadLimit =>
            {
                tx.send(ClientEvent::UploadLimit).await.unwrap();
            },

            //SCREEN UPLOAD APPROVAL, OR AN UNSOLICITED STOP
            #[cfg(feature = "client_screen")]
            PacketCode::Screen { token } =>
            {
                //FOLLOW THE SERVER INSTEAD OF TOGGLING
                screen_options::set_use_screen(token.is_some());

                //THE MONITOR WAS THIS SHARE'S, NOT THIS SESSION'S
                if token.is_none() { screen_options::set_monitor(None); }

                tx.send(match token
                {
                    Some(token) =>
                    {
                        //SPAWN UPLOAD TASK
                        tokio::spawn(screen::screen(token, tx.clone()));
                        ClientEvent::Screen(true)
                    },

                    None => ClientEvent::Screen(false),
                }).await.unwrap();
            },

            //SCREENSHARE ATTACH
            #[cfg(feature = "client_screen")]
            PacketCode::Attach { username, token } =>
            {
                //ENABLE ATTACH
                screen_options::set_attach_screen(true);

                //SPAWN DOWNLOAD TASK
                let main_stream = streams.1.clone();
                tokio::spawn(screen::attach(token, main_stream));
                tx.send(ClientEvent::Attach(username)).await.unwrap();
            },

            //SCREENSHARE DEATTACH
            #[cfg(feature = "client_screen")]
            PacketCode::Deattach { username } =>
            {
                //DISABLE ATTACH
                screen_options::set_attach_screen(false);

                tx.send(ClientEvent::Deattach(username)).await.unwrap();
            },

            //SOMEBODY STARTED SCREENSHARING
            #[cfg(feature = "client_screen")]
            PacketCode::Screenshare { username } =>
            {
                tx.send(ClientEvent::Screenshare(username)).await.unwrap();
            },

            //SOMEBODY STOPPED SCREENSHARING
            #[cfg(feature = "client_screen")]
            PacketCode::ScreenshareEnd { username } =>
            {
                tx.send(ClientEvent::ScreenshareEnd(username)).await.unwrap();
            },

            //SOMEBODY ATTACHED OUR SCREENSHARE
            #[cfg(feature = "client_screen")]
            PacketCode::Attached { username } =>
            {
                tx.send(ClientEvent::Attached(username)).await.unwrap();
            },

            //SOMEBODY DEATTACHED OUR SCREENSHARE
            #[cfg(feature = "client_screen")]
            PacketCode::Deattached { username } =>
            {
                tx.send(ClientEvent::Deattached(username)).await.unwrap();
            },

            //PRIVATE MESSAGE INCOMING
            PacketCode::PrivateMessage { text, username, id, colors } =>
            {
                tx.send(ClientEvent::PrivateMessageRecv(username, id, text, colors)).await.unwrap();
            },

            //PRIVATE MESSAGE INCOMING
            PacketCode::PrivateMessageBack { text, username, id, colors } =>
            {
                tx.send(ClientEvent::PrivateMessageSent(username, id, text, colors)).await.unwrap();
            },

            //SPAM WARNING
            PacketCode::SpamWarning =>
            {
                tx.send(ClientEvent::SpamWarning).await.unwrap();
            },

            //REGISTRATION DISABLED
            PacketCode::RegisterDisabled =>
            {
                disabled_registration = true;
            },

            //HAHA, YOU'RE MUTED
            PacketCode::Muted =>
            {
                tx.send(ClientEvent::Muted).await.unwrap();
            }

            //A MESSAGE WAS DELETED
            PacketCode::Deleted { message_id } =>
            {
                tx.send(ClientEvent::Deleted(message_id)).await.unwrap();
            },

            //CLIENT MESSED SOME COMMAND UP
            PacketCode::InvalidUsage =>
            {
                tx.send(ClientEvent::InvalidUsage).await.unwrap();
            },

            //CLIENTED REQUESTED DISABLED FEATURE
            PacketCode::InvalidFeature =>
            {
                tx.send(ClientEvent::DisabledFeature).await.unwrap();
            },

            //SERVER DOESN'T LIKE YA ANYMORE - EXIT
            PacketCode::Disconnect =>
            {
                tx.send(ClientEvent::Quit(!dropped)).await.unwrap();
                return;
            },

            _ => continue //EITHER INVALID CODE OR A KEY EXCHANGE CODE
        }
    }
}