routing 0.4.0

A secured storage DHT
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

// Copyright 2015 MaidSafe.net limited.
//
// This SAFE Network Software is licensed to you under (1) the MaidSafe.net Commercial License,
// version 1.0 or later, or (2) The General Public License (GPL), version 3, depending on which
// licence you accepted on initial access to the Software (the "Licences").
//
// By contributing code to the SAFE Network Software, or to this project generally, you agree to be
// bound by the terms of the MaidSafe Contributor Agreement, version 1.0.  This, along with the
// Licenses can be found in the root directory of this project at LICENSE, COPYING and CONTRIBUTOR.
//
// Unless required by applicable law or agreed to in writing, the SAFE Network Software distributed
// under the GPL Licence is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.
//
// Please review the Licences for the specific language governing permissions and limitations
// relating to use of the SAFE Network Software.

/// Return a random u8.
pub fn generate_random_u8() -> u8 {
    use rand::Rng;

    let mut rng = ::rand::thread_rng();
    rng.gen::<u8>()
}

fn generate_random_nametype() -> ::NameType {
    ::NameType(::types::vector_as_u8_64_array(::types::generate_random_vec_u8(64)))
}

fn generate_random_authority(name: ::NameType, key: &::sodiumoxide::crypto::sign::PublicKey)
        -> ::authority::Authority {
    use rand::distributions::IndependentSample;

    let mut rng = ::rand::thread_rng();
    let range = ::rand::distributions::Range::new(0, 5);
    let index = range.ind_sample(&mut rng);

    match index {
        0 => return ::authority::Authority::ClientManager(name),
        1 => return ::authority::Authority::NaeManager(name),
        2 => return ::authority::Authority::NodeManager(name),
        3 => return ::authority::Authority::ManagedNode(name),
        4 => return ::authority::Authority::Client(name, key.clone()),
        _ => panic!("Unexpected index.")
    }
}

fn generate_random_data(public_sign_key: &::sodiumoxide::crypto::sign::PublicKey,
                        secret_sign_key: &::sodiumoxide::crypto::sign::SecretKey)
        -> ::data::Data {
    use rand::distributions::IndependentSample;

    let mut rng = ::rand::thread_rng();
    let range = ::rand::distributions::Range::new(0, 3);
    let index = range.ind_sample(&mut rng);

    match index {
        0 => {
            let structured_data =
                match ::structured_data::StructuredData::new(0, generate_random_nametype(), 0,
                        vec![], vec![public_sign_key.clone()], vec![], Some(&secret_sign_key)) {
                    Ok(structured_data) => structured_data,
                    Err(error) => panic!("StructuredData error: {:?}", error),
            };
            return ::data::Data::StructuredData(structured_data)
        },
        1 => {
            let type_tag = ::immutable_data::ImmutableDataType::Normal;
            let immutable_data = ::immutable_data::ImmutableData::new(
                    type_tag, ::types::generate_random_vec_u8(1025));
            return ::data::Data::ImmutableData(immutable_data)
        },
        2 => {
            let plain_data = ::plain_data::PlainData::new(
                generate_random_nametype(), ::types::generate_random_vec_u8(1025));
            return ::data::Data::PlainData(plain_data)
        },
        _ => panic!("Unexpected index.")
    }
}

/// Semi-random routing message.
// TODO Brian: Randomize Content and rename to random_routing_message.
pub fn arbitrary_routing_message(public_key: &::sodiumoxide::crypto::sign::PublicKey,
                          secret_key: &::sodiumoxide::crypto::sign::SecretKey)
        -> ::messages::RoutingMessage {
    let from_authority = generate_random_authority(generate_random_nametype(), public_key);
    let to_authority = generate_random_authority(generate_random_nametype(), public_key);
    let data = generate_random_data(public_key, secret_key);
    let content = ::messages::Content::ExternalRequest(::messages::ExternalRequest::Put(data));

    ::messages::RoutingMessage {
        from_authority: from_authority,
        to_authority: to_authority,
        content: content,
    }
}

#[cfg(test)]
pub mod test {

    // TODO: Use IPv6 and non-TCP
    pub fn random_socket_addr() -> ::std::net::SocketAddr {
        ::std::net::SocketAddr::V4(::std::net::SocketAddrV4::new(
            ::std::net::Ipv4Addr::new(::rand::random::<u8>(),
                                      ::rand::random::<u8>(),
                                      ::rand::random::<u8>(),
                                      ::rand::random::<u8>()),
            ::rand::random::<u16>()))
    }

    pub fn random_endpoint() -> ::crust::Endpoint {
        // TODO: Udt
        ::crust::Endpoint::Tcp(random_socket_addr())
    }

    pub fn random_connection() -> ::crust::Connection {
        let local = random_socket_addr();
        let remote = random_socket_addr();
        // TODO: Udt
        ::crust::Connection::new(::crust::Protocol::Tcp, local, remote)
    }

    pub fn random_endpoints() -> Vec<::crust::Endpoint> {
        use rand::distributions::IndependentSample;
        let range = ::rand::distributions::Range::new(1, 10);
        let mut rng = ::rand::thread_rng();
        let count = range.ind_sample(&mut rng);
        let mut endpoints = vec![];
        for _ in 0..count {
            endpoints.push(random_endpoint());
        }
        endpoints
    }

    impl super::super::random_trait::Random for ::messages::ConnectRequest {
            fn generate_random() -> ::messages::ConnectRequest {
                ::messages::ConnectRequest {
                    local_endpoints: random_endpoints(),
                    external_endpoints: random_endpoints(),
                    requester_fob: super::super::random_trait::Random::generate_random(),
                }
            }
    }

    impl super::super::random_trait::Random for ::messages::ConnectResponse {
            fn generate_random() -> ::messages::ConnectResponse {
                ::messages::ConnectResponse {
                    local_endpoints: random_endpoints(),
                    external_endpoints: random_endpoints(),
                    receiver_fob: super::super::random_trait::Random::generate_random(),
                }
            }
    }
}