HF Bot - DON'T SUICIDE WHEN READING THIS PIECE OF BULLSHIT PLZZZZ !

main.rs

#![allow(unused_variables)]
extern crate rstox;

use rstox::core::*;
use std::path::Path;
use std::fs::File;
use std::io::prelude::*;

// Static options.
static BOOTSTRAP_IP: &'static str = "195.154.119.113";
static BOOTSTRAP_PORT: u16 = 33445;
static BOOTSTRAP_KEY: &'static str = "E398A69646B8CEACA9F0B84F553726C1C49270558C57DF5F3C368F05A7D71354";
static HFB_PROFILE: &'static str = "./profiles/hfb.tox";
static TRIGGER_TOKEN: &'static str = "!";

// Static array.
static SUPER_USERS: &'static [&'static str] = &[
    "F7A425D7064A8DC1353E5C07E908C0CCF83947916AE519080D8F9DF8B1DCD243",
    "10EC72CA34FB138A6246B48DA8A616D008400F95D61201EB3DD70502601C6820"
];

#[derive(Clone, PartialEq, Debug)]
struct Peer
{
    last_name: String,
    name: String,
    public_key: PublicKey
}

fn main() {
    let mut m: Tox = init_tox();
    let group_id = make_group_tox(&mut m); // 0
    let mut peers: Vec<Peer> = Vec::new();

    println!("ID: {}", m.get_address());

    save_point_tox(&m);

    loop {
        for ev in m.iter() {
            println!("[DEBUG] {:?}", ev);
            match ev {

                FriendRequest(cid, _) => {
                    drop(m.add_friend_norequest(&cid));
                    save_point_tox(&m);
                },

                FriendMessage(cid, kind, data) => {
                    let fnum: i32 = cid as i32;

                    match &*data
                    {
                        "hf4ever" =>
                        {
                            drop(m.invite_friend(fnum, group_id));
                        },
                        _ => { /* IGNORE ALL */ }
                    }
                },

                GroupInvite(fid, kind, data) =>
                {
                    println!("Je crois que {} m'a pris pour une pute...", fid);
                },

                GroupMessage(gid, pid, message) =>
                {
                    let cmd = message.to_string();
                    let pkey = format!("{}", match m.group_peer_pubkey(gid, pid) {
                        Some(k) => k,
                        None => return,
                    });

                    match &*cmd
                    {
                        "aide" =>
                        {
                            let message = "est développé par SkyzohKey et Ogromny avec le langage Rust";
                            drop(m.group_action_send(gid, &message));
                        },
                        "id" =>
                        {
                            if is_su(pkey)
                            {
                                let pub_key = format!("{}", m.get_address());
                                drop(m.group_message_send(gid, &pub_key));
                            }
                        },
                        "pubkey" =>
                        {
                            drop(m.group_message_send(gid, &pkey));
                        },
                        _ => { /* Ignore. */ }
                    };
                },

                GroupNamelistChange(gid, pid, kind) =>
                {
                    let name = m.group_peername(gid, pid).unwrap();
                    let pkey = format!("{}", match m.group_peer_pubkey(gid, pid) {
                        Some(k) => k,
                        None => return,
                    });

                    let pkey_o: PublicKey = m.group_peer_pubkey(gid, pid).unwrap();

                    match kind
                    {
                        ChatChange::PeerAdd =>
                        {
                            if peers.iter().any(|x| x.public_key != pkey_o)
                            {
                                peers.push(Peer {
                                    name: "".to_string(),
                                    last_name: "".to_string(),
                                    public_key: pkey_o
                                });

                                println!("[PEERS-ADD] {:?}", &peers);
                            }
                        },
                        ChatChange::PeerDel =>
                        {
                            if peers.iter().any(|&x| x.public_key == pkey_o)
                            {
                                let peer = peers.iter_mut().find(|x| x.public_key == pkey_o).unwrap();
                                let msg = format!("{} a quitté le groupe.", peer.name);
                                drop(m.group_message_send(gid, &msg));

                                peers.retain(|&x| x.public_key != pkey_o);
                                println!("[PEERS-DEL] {:?}", &peers);
                            }
                        },
                        ChatChange::PeerName =>
                        {
                            match m.group_peername(gid, pid)
                            {
                                Some(pname) =>
                                {
                                    if peers.iter().any(|&x| x.public_key == pkey_o)
                                    {
                                        let peer = peers.iter_mut().find(|x| x.public_key == pkey_o).unwrap();
                                        *peer = Peer {
                                            last_name: peer.name.to_string(),
                                            name: pname.to_string(),
                                            public_key: pkey_o
                                        };

                                        let msg = format!("Bienvenue {}, si tu as besoin d'aide il te suffit d'écrire \"aide\" :)", peer.name);
                                        drop(m.group_message_send(gid, &msg));
                                    }
                                },
                                None => { /* */ },
                            };
                        }
                    };
                }

                ev =>
                {
                    //println!("[DEBUG] {:?}", ev);
                },
            }
        }
        m.wait();
    }
}

fn init_tox() -> Tox
{
    // load Tox Profile
    let mut xp: Vec<u8> = Vec::new();

    let mut tox = match Tox::new(ToxOptions::new(), match File::open(Path::new(HFB_PROFILE))
    {
        Ok(mut data) =>
        {
            data.read_to_end(&mut xp).ok().expect("[ERROR] Impossible de lire le profil.");
            Some(&xp)
        },
        Err(_) => None
    })
    {
        Ok(t) => t,
        Err(err) => panic!("[ERROR] Tox InitError: {:?}", err)
    };

    let bootstrap_key = match BOOTSTRAP_KEY.parse()
    {
        Ok(b) => b,
        Err(_) => panic!("[ERROR] Erreur lors de la creation de la clef de bootstrap"),
    };

    // config + bootstrap
    tox.set_name("Hack-Free Bot").unwrap();
    tox.set_status_message("Programmé par Skyzohkey et Ogromny").unwrap();
    tox.bootstrap(BOOTSTRAP_IP, BOOTSTRAP_PORT, bootstrap_key).unwrap();

    tox
}

fn save_point_tox(tox: &Tox)
{
    let path = Path::new(HFB_PROFILE);

    let mut file = match File::create(&path)
    {
        Err(e) => panic!("[ERROR] Impossible de créer le fichier \"{}\": {}", HFB_PROFILE, e),
        Ok(file) => file,
    };

    match file.write_all(&tox.save())
    {
        Ok(_) => println!("[DEBUG] Le fichier \"{}\" a été sauvegardé avec succés.", HFB_PROFILE),
        Err(e) => panic!("[ERROR] Impossible de sauvegarder le fichier \"{}\": {}", HFB_PROFILE, e),
    };
}

fn make_group_tox(tox: &mut Tox) -> i32
{
    let nbr = tox.add_groupchat().unwrap();
    drop(tox.group_set_title(nbr, "Hack-Free - Groupe officiel"));

    nbr
}

fn is_su(public_key: String) -> bool
{
    SUPER_USERS.contains(&&*public_key)
}