Merge branch 'develop' into feature/integrated_websocket

src/clients/mix.rs

@@ -1,8 +1,8 @@
-use crate::clients::directory::Client;
-use sphinx::route::Node as MixNode;
+use sphinx::route::{Node as MixNode, NodeAddressBytes};
 use sphinx::SphinxPacket;
-use tokio::prelude::*;
 use std::net::SocketAddr;
+use std::net::{Ipv4Addr, SocketAddrV4};
+use tokio::prelude::*;
 
 pub struct MixClient {}
 
@@ -15,11 +15,16 @@ impl MixClient {
     pub async fn send(
         &self,
         packet: SphinxPacket,
-        mix_addr: SocketAddr,
+        mix_addr: NodeAddressBytes,
     ) -> Result<(), Box<dyn std::error::Error>> {
         let bytes = packet.to_bytes();
 
-        let mut stream = tokio::net::TcpStream::connect(mix_addr).await?;
+        let b = mix_addr;
+        let host = Ipv4Addr::new(b[0], b[1], b[2], b[3]);
+        let port: u16 = u16::from_be_bytes([b[4], b[5]]);
+        let socket_address = SocketAddrV4::new(host, port);
+
+        let mut stream = tokio::net::TcpStream::connect(socket_address).await?;
         stream.write_all(&bytes[..]).await?;
         Ok(())
     }

src/clients/provider.rs

@@ -1,15 +1,12 @@
+use sfw_provider_requests::requests::{ProviderRequest, PullRequest};
+use sfw_provider_requests::responses::{ProviderResponse, PullResponse};
 use sphinx::route::Node as MixNode;
-use sphinx::SphinxPacket;
-use tokio::prelude::*;
-use sfw_provider_requests::*;
 use std::net::Shutdown;
-use std::time::Duration;
-use sfw_provider_requests::requests::{PullRequest, ProviderRequest};
-use sfw_provider_requests::responses::{PullResponse, ProviderResponse};
+use tokio::prelude::*;
+use tokio::time::Duration;
 
 pub struct ProviderClient {}
 
-
 impl ProviderClient {
     pub fn new() -> Self {
         ProviderClient {}
@@ -17,7 +14,7 @@ impl ProviderClient {
 
     pub async fn retrieve_messages(
         &self,
-//        provider: &MixNode,
+        // provider: &MixNode,
     ) -> Result<(), Box<dyn std::error::Error>> {
         let address = [42; 32];
         let pull_request = PullRequest::new(address);
@@ -25,7 +22,7 @@ impl ProviderClient {
 
         let mut socket = tokio::net::TcpStream::connect("127.0.0.1:9000").await?;
         println!("keep alive: {:?}", socket.keepalive());
-        socket.set_keepalive(Some(tokio::time::Duration::from_secs(2)));
+        socket.set_keepalive(Some(Duration::from_secs(2))).unwrap();
         socket.write_all(&bytes[..]).await?;
         if let Err(e) = socket.shutdown(Shutdown::Write) {
             eprintln!("failed to close write part of the socket; err = {:?}", e)

src/commands/run.rs

@@ -11,6 +11,7 @@ use clap::ArgMatches;
 use curve25519_dalek::montgomery::MontgomeryPoint;
 use sphinx::route::Destination;
 use sphinx::route::Node as SphinxNode;
+use std::net::{Ipv4Addr, SocketAddrV4};
 use std::time::Duration;
 use tokio::runtime::Runtime;
 use tokio::time::{interval_at, Instant};
@@ -67,6 +68,47 @@ pub fn execute(matches: &ArgMatches) {
     //            }
     //        }
     //    })
+    //    // Create the runtime, probably later move it to Client struct itself?
+    //    let mut rt = Runtime::new().unwrap();
+    //
+    //    // Spawn the root task
+    //    rt.block_on(async {
+    //        let start = Instant::now() + Duration::from_nanos(1000);
+    //        let mut interval = interval_at(start, Duration::from_millis(1000));
+    //        let mut i: usize = 0;
+    //        loop {
+    //            interval.tick().await;
+    //            let message = format!("Hello, Sphinx {}", i).as_bytes().to_vec();
+    //
+    //            let route_len = 2;
+    //
+    //            // data needed to generate a new Sphinx packet
+    //            let route = route_from(&topology, route_len);
+    //            let destination = get_destination();
+    //            let delays = sphinx::header::delays::generate(route_len);
+    //
+    //            // build the packet
+    //            let packet =
+    //                sphinx::SphinxPacket::new(message, &route[..], &destination, &delays).unwrap();
+    //
+    //            // send to mixnet
+    //            let mix_client = MixClient::new();
+    //            mix_client
+    //                .send(packet, route.first().unwrap())
+    //                .await
+    //                .unwrap();
+    //            println!("packet sent:  {:?}", i);
+    //            i += 1;
+    //
+    //            // retrieve messages every now and then
+    //            if i % 3 == 0 {
+    //                interval.tick().await;
+    //                println!("going to retrieve messages!");
+    //                let provider_client = ProviderClient::new();
+    //                provider_client.retrieve_messages().await.unwrap();
+    //            }
+    //        }
+    //    })
 }
 
 fn get_topology(is_local: bool) -> Topology {
@@ -90,22 +132,30 @@ fn route_from(topology: &Topology, route_len: usize) -> Vec<SphinxNode> {
     let mut route = vec![];
     let nodes = topology.mix_nodes.iter();
     for mix in nodes.take(route_len) {
-        let address_bytes = bytes::zero_pad_to_32(mix.host.as_bytes().to_vec());
+        let address_bytes = socket_bytes_from_string(mix.host.clone());
         let decoded_key_bytes = base64::decode_config(&mix.pub_key, base64::URL_SAFE).unwrap();
         let key_bytes = bytes::zero_pad_to_32(decoded_key_bytes);
         let key = MontgomeryPoint(key_bytes);
-        let mut sphinx_node = SphinxNode {
+        let sphinx_node = SphinxNode {
             address: address_bytes,
             pub_key: key,
         };
-
-        // temporary to make it work locally:
-        sphinx_node.pub_key = Default::default();
         route.push(sphinx_node);
     }
     route
 }
 
+fn socket_bytes_from_string(address: String) -> [u8; 32] {
+    let socket: SocketAddrV4 = address.parse().unwrap();
+    let host_bytes = socket.ip().octets();
+    let port_bytes = socket.port().to_be_bytes();
+    let mut address_bytes = [0u8; 32];
+    address_bytes.copy_from_slice(&host_bytes);
+    address_bytes[4] = port_bytes[0];
+    address_bytes[5] = port_bytes[1];
+    address_bytes
+}
+
 // TODO: where do we retrieve this guy from?
 fn get_destination() -> Destination {
     Destination {

src/identity/mixnet.rs

@@ -17,11 +17,9 @@ impl KeyPair {
         let mut bytes = [0; 32];
         bytes.copy_from_slice(&private_bytes[..]);
         let private = Scalar::from_canonical_bytes(bytes).unwrap();
-
         let mut bytes = [0; 32];
         bytes.copy_from_slice(&public_bytes[..]);
         let public = MontgomeryPoint(bytes);
-
         KeyPair { private, public }
     }
 

src/lib.rs

@@ -1 +1,3 @@
 pub mod clients;
+pub mod identity;
+pub mod persistence;