luke-else/subnet_calculator
1
0
Fork 0
Code Issues 3 Pull Requests Projects Releases Wiki Activity

Used cargo fmt

Browse Source
This commit is contained in:
Luke Else 2023-08-05 13:24:09 +01:00
parent aeae3af5e6
commit 53837d7b33
2 changed files with 220 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/ip.rs
View File

@ -1,5 +1,5 @@
use std::str::FromStr;
use super::NetworkingErr;
use std::str::FromStr;
#[derive(Debug, PartialEq, Eq)]
pub struct InvalidIPErr;
@ -19,7 +19,7 @@ pub struct InvalidIPErr;
#[derive(Debug, PartialEq, Eq, Clone)]
pub enum IpAddr {
V4(u8, u8, u8, u8),
V6(String)
V6(String),
}
impl IpAddr {
@ -39,10 +39,8 @@ impl IpAddr {
/// ```
pub fn to_arr(&self) -> Result<[u8; 4], NetworkingErr> {
match self {
IpAddr::V4(o1, o2, o3, o4) => {
Ok([*o1, *o2, *o3, *o4])
}
_ => Err(NetworkingErr::InvalidIPErr)
IpAddr::V4(o1, o2, o3, o4) => Ok([*o1, *o2, *o3, *o4]),
_ => Err(NetworkingErr::InvalidIPErr),
}
}
@ -110,7 +108,7 @@ impl ToString for IpAddr {
fn to_string(&self) -> String {
match self {
IpAddr::V4(oct1, oct2, oct3, oct4) => format!("{}.{}.{}.{}", oct1, oct2, oct3, oct4),
IpAddr::V6(addr) => format!("{}", addr)
IpAddr::V6(addr) => format!("{}", addr),
}
}
}
@ -135,18 +133,18 @@ impl FromStr for IpAddr {
let split_ip = s.split('.');
if split_ip.clone().count() != 4 {
//Invalid IP address entered
return Err(super::NetworkingErr::InvalidIPErr)
return Err(super::NetworkingErr::InvalidIPErr);
}
let mut ip: [u8; 4] = Default::default();
//Go through each octet and ensure it can be parsed;
for (i, oct) in split_ip.into_iter().enumerate() {
if i > ip.len() {
//Ip string is out of the range of the 4 octets in an IPv4 Address
return Err(NetworkingErr::InvalidIPErr)
return Err(NetworkingErr::InvalidIPErr);
}
match oct.parse::<u8>() {
Ok(parsed_oct) => ip[i] = parsed_oct,
Err(_) => return Err(NetworkingErr::InvalidIPErr)
Err(_) => return Err(NetworkingErr::InvalidIPErr),
}
}
Ok(IpAddr::from_arr(&ip)?)
@ -216,7 +214,10 @@ mod tests {
fn arr_to_ipaddr() {
use super::*;
let ip_addr: [u8; 4] = [127, 0, 0, 1];
assert_eq!(IpAddr::from_arr(&ip_addr).unwrap(), IpAddr::V4(127, 0, 0, 1));
assert_eq!(
IpAddr::from_arr(&ip_addr).unwrap(),
IpAddr::V4(127, 0, 0, 1)
);
}
#[test]
@ -240,8 +241,7 @@ mod tests {
#[test]
/// Tests the conversion of an u32 IPv4 Address to
/// an IpAddr
fn u32_to_ipaddr()
{
fn u32_to_ipaddr() {
use super::*;
let ip = u32::from(IpAddr::V4(0, 0, 0, 0));
assert_eq!(IpAddr::V4(0, 0, 0, 0), IpAddr::from(ip));

205
src/lib.rs
View File

@ -9,7 +9,7 @@ pub enum NetworkingErr {
InvalidCIDRErr,
InvalidSubnetMask,
InvalidNetwork,
InvalidIPErr
InvalidIPErr,
}
/// enum to allow the identification of the class of the network
@ -17,7 +17,7 @@ pub enum NetworkingErr {
enum NetworkClass {
A = 8,
B = 16,
C = 24
C = 24,
}
#[allow(unused)]
@ -36,7 +36,6 @@ pub struct Subnet {
}
impl Network {
#[allow(unused)]
/// Function that constucts a network struct.
///
@ -69,7 +68,7 @@ impl Network {
// If the CIDR < class network enum associated value, then there is an invalid subnet.
if cidr < network_class as u8 {
return Err(NetworkingErr::InvalidCIDRErr)
return Err(NetworkingErr::InvalidCIDRErr);
}
// Determine the starting network
@ -77,7 +76,7 @@ impl Network {
let most_sig_octet: u8 = match network_class {
NetworkClass::A => 1,
NetworkClass::B => 2,
NetworkClass::C => 3
NetworkClass::C => 3,
};
for i in most_sig_octet..4 {
@ -104,19 +103,27 @@ impl Network {
let mut broadcast_addr = (base_addr + addr_increment) - 1;
//Create the subnets
let mut subnet = Subnet::new(&IpAddr::from(base_addr), &IpAddr::from(broadcast_addr), num_hosts, cidr)?;
let mut subnet = Subnet::new(
&IpAddr::from(base_addr),
&IpAddr::from(broadcast_addr),
num_hosts,
cidr,
)?;
// Determine the networking gaps
//If there is only 1 network, returning the base network will be sufficient
if num_networks > 1 {
for _ in 0..num_networks-1 {
for _ in 0..num_networks - 1 {
//Increment address and append to list
base_addr += addr_increment;
// We can start adding the full subnet range now instead of 1 less
broadcast_addr += addr_increment;
subnet.networks.push(Network::new(&IpAddr::from(base_addr), &IpAddr::from(broadcast_addr), num_hosts));
subnet.networks.push(Network::new(
&IpAddr::from(base_addr),
&IpAddr::from(broadcast_addr),
num_hosts,
));
}
}
@ -134,15 +141,15 @@ impl Network {
fn get_network_class(network_address: &IpAddr) -> Result<NetworkClass, NetworkingErr> {
let network_address = network_address.to_arr()?;
if network_address[0] > 224 {
return Err(NetworkingErr::InvalidIPErr)
}else if network_address[0] >= 192 {
return Ok(NetworkClass::C)
}else if network_address[0] >= 128 {
return Ok(NetworkClass::B)
}else if network_address[0] >= 1 {
return Err(NetworkingErr::InvalidIPErr);
} else if network_address[0] >= 192 {
return Ok(NetworkClass::C);
} else if network_address[0] >= 128 {
return Ok(NetworkClass::B);
} else if network_address[0] >= 1 {
return Ok(NetworkClass::A);
}
return Err(NetworkingErr::InvalidIPErr)
return Err(NetworkingErr::InvalidIPErr);
}
#[allow(unused)]
@ -156,7 +163,7 @@ impl Network {
/// ```
fn gen_subnet_mask(mut cidr: u8) -> Result<IpAddr, NetworkingErr> {
if cidr > 32 {
return Err(NetworkingErr::InvalidCIDRErr)
return Err(NetworkingErr::InvalidCIDRErr);
}
let mut oct: [u8; 4] = [0; 4];
@ -165,10 +172,10 @@ impl Network {
*octet = if usize::from(cidr) >= 8 {
cidr -= 8;
u8::MAX
}else{
} else {
// Count the number of remaining 1s and convert to binary
let mut count: u8 = 0;
for i in ((8-cidr)..8).rev() {
for i in ((8 - cidr)..8).rev() {
count += u8::pow(2, u32::from(i));
}
cidr = 0;
@ -196,7 +203,7 @@ impl Network {
///
/// assert_eq!(result, (IpAddr::V4(192, 168, 0, 1), 24));
/// ```
pub fn ip_and_cidr_from_string(ip_and_cidr: &String) -> Result<(IpAddr, u8), ip::InvalidIPErr>{
pub fn ip_and_cidr_from_string(ip_and_cidr: &String) -> Result<(IpAddr, u8), ip::InvalidIPErr> {
let mut cidr: u8 = Default::default();
let mut ip: String = Default::default();
@ -205,13 +212,18 @@ pub fn ip_and_cidr_from_string(ip_and_cidr: &String) -> Result<(IpAddr, u8), ip:
if split_ip_cidr.clone().count() > 2 {
return Err(ip::InvalidIPErr);
}
ip = split_ip_cidr.clone().into_iter().next().unwrap_or("0.0.0.0").to_owned();
ip = split_ip_cidr
.clone()
.into_iter()
.next()
.unwrap_or("0.0.0.0")
.to_owned();
cidr = match split_ip_cidr.into_iter().last() {
None => return Err(ip::InvalidIPErr),
Some(cidr) => match cidr.trim().parse::<u8>() {
Err(_) => return Err(ip::InvalidIPErr),
Ok(cidr) => cidr
}
Ok(cidr) => cidr,
},
};
}
@ -220,19 +232,22 @@ pub fn ip_and_cidr_from_string(ip_and_cidr: &String) -> Result<(IpAddr, u8), ip:
Ok(ip) => ip,
};
return Ok((ip_address, cidr))
return Ok((ip_address, cidr));
}
impl Subnet {
/// Function to return a new subbet struct
///
fn new(base_address: &IpAddr, broadcast_addr: &IpAddr, num_hosts: u32, cidr: u8) -> Result<Subnet, NetworkingErr> {
Ok(
Subnet {
fn new(
base_address: &IpAddr,
broadcast_addr: &IpAddr,
num_hosts: u32,
cidr: u8,
) -> Result<Subnet, NetworkingErr> {
Ok(Subnet {
networks: vec![Network::new(base_address, broadcast_addr, num_hosts)],
subnet_mask: Network::gen_subnet_mask(cidr)?,
}
)
})
}
}
@ -245,7 +260,7 @@ mod tests {
let ip_string = String::from("127.0.0.1/8");
let result = match ip_and_cidr_from_string(&ip_string) {
Err(_) => panic!(),
Ok(ip_and_cidr) => ip_and_cidr
Ok(ip_and_cidr) => ip_and_cidr,
};
assert_eq!(result.0, IpAddr::V4(127, 0, 0, 1));
assert_eq!(result.1, 8);
@ -255,61 +270,137 @@ mod tests {
fn cidr_to_ip_test() {
use super::*;
assert_eq!(Network::gen_subnet_mask(22).unwrap(), IpAddr::V4(255, 255, 252, 0));
assert_eq!(Network::gen_subnet_mask(24).unwrap(), IpAddr::V4(255, 255, 255, 0));
assert_eq!(
Network::gen_subnet_mask(22).unwrap(),
IpAddr::V4(255, 255, 252, 0)
);
assert_eq!(
Network::gen_subnet_mask(24).unwrap(),
IpAddr::V4(255, 255, 255, 0)
);
assert_eq!(Network::gen_subnet_mask(0).unwrap(), IpAddr::V4(0, 0, 0, 0));
assert_eq!(Network::gen_subnet_mask(4).unwrap(), IpAddr::V4(240, 0, 0, 0));
assert_eq!(Network::gen_subnet_mask(35).unwrap_err(), NetworkingErr::InvalidCIDRErr);
assert_eq!(
Network::gen_subnet_mask(4).unwrap(),
IpAddr::V4(240, 0, 0, 0)
);
assert_eq!(
Network::gen_subnet_mask(35).unwrap_err(),
NetworkingErr::InvalidCIDRErr
);
}
#[test]
fn network_class_test() {
use super::*;
assert_eq!(Network::get_network_class(&IpAddr::V4(127, 0, 0, 1)).unwrap(), NetworkClass::A);
assert_eq!(Network::get_network_class(&IpAddr::V4(172, 6, 8, 10)).unwrap(), NetworkClass::B);
assert_eq!(Network::get_network_class(&IpAddr::V4(192, 168, 0, 1)).unwrap(), NetworkClass::C);
assert_eq!(Network::get_network_class(&IpAddr::V4(10, 6, 8, 10)).unwrap(), NetworkClass::A);
assert_eq!(Network::get_network_class(&IpAddr::V4(225, 255, 255, 255)).unwrap_err(), NetworkingErr::InvalidIPErr);
assert_eq!(Network::get_network_class(&IpAddr::V4(225, 0, 0, 0)).unwrap_err(), NetworkingErr::InvalidIPErr);
assert_eq!(Network::get_network_class(&IpAddr::V4(0, 0, 0, 0)).unwrap_err(), NetworkingErr::InvalidIPErr);
assert_eq!(Network::get_network_class(&IpAddr::V4(0, 0, 0, 1)).unwrap_err(), NetworkingErr::InvalidIPErr);
assert_eq!(
Network::get_network_class(&IpAddr::V4(127, 0, 0, 1)).unwrap(),
NetworkClass::A
);
assert_eq!(
Network::get_network_class(&IpAddr::V4(172, 6, 8, 10)).unwrap(),
NetworkClass::B
);
assert_eq!(
Network::get_network_class(&IpAddr::V4(192, 168, 0, 1)).unwrap(),
NetworkClass::C
);
assert_eq!(
Network::get_network_class(&IpAddr::V4(10, 6, 8, 10)).unwrap(),
NetworkClass::A
);
assert_eq!(
Network::get_network_class(&IpAddr::V4(225, 255, 255, 255)).unwrap_err(),
NetworkingErr::InvalidIPErr
);
assert_eq!(
Network::get_network_class(&IpAddr::V4(225, 0, 0, 0)).unwrap_err(),
NetworkingErr::InvalidIPErr
);
assert_eq!(
Network::get_network_class(&IpAddr::V4(0, 0, 0, 0)).unwrap_err(),
NetworkingErr::InvalidIPErr
);
assert_eq!(
Network::get_network_class(&IpAddr::V4(0, 0, 0, 1)).unwrap_err(),
NetworkingErr::InvalidIPErr
);
}
#[test]
fn subnet_creation_test() {
use super::*;
assert_eq!(Network::create_subnet(&IpAddr::V4(192, 168, 0, 1), 23).unwrap_err(), NetworkingErr::InvalidCIDRErr);
assert_eq!(
Network::create_subnet(&IpAddr::V4(192, 168, 0, 1), 23).unwrap_err(),
NetworkingErr::InvalidCIDRErr
);
let networks = Network::create_subnet(&IpAddr::V4(127, 0, 0, 1), 10).unwrap();
assert_eq!(networks.networks.len(), 4);
let networks = Network::create_subnet(&IpAddr::V4(192, 168, 200, 1), 31).unwrap().networks;
let networks = Network::create_subnet(&IpAddr::V4(192, 168, 200, 1), 31)
.unwrap()
.networks;
assert_eq!(networks.len(), 128);
assert_eq!(networks.last().unwrap().network_address, IpAddr::V4(192, 168, 200, 254));
assert_eq!(networks.last().unwrap().broadcast_addr, IpAddr::V4(192, 168, 200, 255));
assert_eq!(
networks.last().unwrap().network_address,
IpAddr::V4(192, 168, 200, 254)
);
assert_eq!(
networks.last().unwrap().broadcast_addr,
IpAddr::V4(192, 168, 200, 255)
);
assert_eq!(networks.last().unwrap().num_hosts, 2);
let networks = Network::create_subnet(&IpAddr::V4(127, 0, 0, 0), 8).unwrap().networks;
let networks = Network::create_subnet(&IpAddr::V4(127, 0, 0, 0), 8)
.unwrap()
.networks;
assert_eq!(networks.len(), 1);
assert_eq!(networks.last().unwrap().network_address, IpAddr::V4(127, 0, 0, 0));
assert_eq!(networks.last().unwrap().broadcast_addr, IpAddr::V4(127, 255, 255, 255));
assert_eq!(
networks.last().unwrap().network_address,
IpAddr::V4(127, 0, 0, 0)
);
assert_eq!(
networks.last().unwrap().broadcast_addr,
IpAddr::V4(127, 255, 255, 255)
);
assert_eq!(networks.last().unwrap().num_hosts, 16_777_216);
let networks = Network::create_subnet(&IpAddr::V4(127, 0, 0, 0), 9).unwrap().networks;
let networks = Network::create_subnet(&IpAddr::V4(127, 0, 0, 0), 9)
.unwrap()
.networks;
assert_eq!(networks.len(), 2);
assert_eq!(networks.first().unwrap().network_address, IpAddr::V4(127, 0, 0, 0));
assert_eq!(networks.first().unwrap().broadcast_addr, IpAddr::V4(127, 127, 255, 255));
assert_eq!(
networks.first().unwrap().network_address,
IpAddr::V4(127, 0, 0, 0)
);
assert_eq!(
networks.first().unwrap().broadcast_addr,
IpAddr::V4(127, 127, 255, 255)
);
let networks = Network::create_subnet(&IpAddr::V4(168, 20, 0, 0), 17).unwrap().networks;
let networks = Network::create_subnet(&IpAddr::V4(168, 20, 0, 0), 17)
.unwrap()
.networks;
assert_eq!(networks.len(), 2);
assert_eq!(networks.last().unwrap().network_address, IpAddr::V4(168, 20, 128, 0));
assert_eq!(networks.last().unwrap().broadcast_addr, IpAddr::V4(168, 20, 255, 255));
assert_eq!(
networks.last().unwrap().network_address,
IpAddr::V4(168, 20, 128, 0)
);
assert_eq!(
networks.last().unwrap().broadcast_addr,
IpAddr::V4(168, 20, 255, 255)
);
assert_eq!(networks.last().unwrap().num_hosts, 32_768);
let networks = Network::create_subnet(&IpAddr::V4(127, 0, 0, 0), 17).unwrap().networks;
let networks = Network::create_subnet(&IpAddr::V4(127, 0, 0, 0), 17)
.unwrap()
.networks;
assert_eq!(networks.len(), 512);
assert_eq!(networks.last().unwrap().network_address, IpAddr::V4(127, 255, 128, 0));
assert_eq!(
networks.last().unwrap().network_address,
IpAddr::V4(127, 255, 128, 0)
);
}
}