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
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use crate::error::AetherError;
use crate::identity::{Id, PublicId};
use crate::{acknowledgement::Acknowledgement, config::Config, packet::Packet};
use crate::{link::Link, packet::PType};
use std::io::ErrorKind;
use std::{
    net::{SocketAddr, UdpSocket},
    time::{Duration, SystemTime},
};

use rand::{thread_rng, Rng};

pub fn handshake(
    private_id: Id,
    socket: UdpSocket,
    address: SocketAddr,
    my_uid: String,
    peer_uid: String,
    config: Config,
) -> Result<Link, AetherError> {
    let seq = thread_rng().gen_range(0..(1 << 16_u32)) as u32;
    let recv_seq: u32;

    let ack: bool;

    if socket
        .set_read_timeout(Some(Duration::from_millis(config.handshake.peer_poll_time)))
        .is_err()
    {
        return Err(AetherError::SetReadTimeout);
    }

    let mut packet = Packet::new(PType::Initiation, seq);
    packet.append_payload(my_uid.into_bytes());

    let sequence_data = packet.compile();

    let now = SystemTime::now();
    // Repeat sending start sequence number and ID
    loop {
        let elapsed = now.elapsed()?;

        if elapsed.as_millis() > config.handshake.handshake_timeout.into() {
            return Err(AetherError::HandshakeError);
        }

        loop {
            match socket.send_to(&sequence_data, address) {
                Ok(_) => break,
                Err(err) => match err.kind() {
                    ErrorKind::PermissionDenied => continue,
                    _ => panic!("Error sending sequence: {}", err),
                },
            }
        }

        let mut buf: [u8; 1024] = [0; 1024];

        if let Ok(size) = socket.recv(&mut buf) {
            if size > 0 {
                let recved = Packet::from(buf[..size].to_vec());
                let uid_recved = match String::from_utf8(recved.payload.clone()) {
                    Ok(string) => string,
                    Err(_) => return Err(AetherError::HandshakeError),
                };

                // Verify the sender has the correct uid
                if uid_recved == peer_uid {
                    recv_seq = recved.sequence;

                    ack = recved.flags.ack && recved.ack.ack_begin == seq;

                    break;
                }
            }
        }
    }

    // If not acknowledged by other peer yet
    if !ack {
        packet.add_ack(Acknowledgement {
            ack_begin: recv_seq,
            ack_end: 0,
            miss_count: 0,
            miss: Vec::new(),
        });

        let ack_data = packet.compile();

        // Repeat sending start sequence number, acknowledgement and ID
        loop {
            let elapsed = now.elapsed()?;

            if elapsed.as_millis() > config.handshake.handshake_timeout.into() {
                return Err(AetherError::HandshakeError);
            }

            loop {
                match socket.send_to(&ack_data, address) {
                    Ok(_) => break,
                    Err(err) => match err.kind() {
                        ErrorKind::PermissionDenied => continue,
                        _ => panic!("Error sending sequence: {}", err),
                    },
                }
            }

            let mut buf: [u8; 1024] = [0; 1024];

            if let Ok(size) = socket.recv(&mut buf) {
                if size > 0 {
                    let recved = Packet::from(buf[..size].to_vec());
                    let uid_recved = match String::from_utf8(recved.payload.clone()) {
                        Ok(string) => string,
                        Err(_) => return Err(AetherError::HandshakeError),
                    };

                    // Verify the sender has the correct uid
                    if uid_recved == peer_uid
                        && recved.sequence == recv_seq
                        && recved.flags.ack
                        && recved.ack.ack_begin == seq
                    {
                        break;
                    }
                }
            }
        }
    }

    let peer_id = PublicId::from_base64(&peer_uid)?;

    // Start the link
    let mut link = Link::new(private_id, socket, address, peer_id, seq, recv_seq, config)?;
    link.start();
    Ok(link)
}