Решение на Network Packets от Христина Христова

Обратно към всички решения

Към профила на Христина Христова

Код

use std::fmt;

use std::convert::TryInto;

/// Грешките, които ще очакваме да върнете. По-долу ще е описано кои от тези грешки очакваме да се

/// върнат в каква ситуация.

///

#[derive(Debug)]

pub enum PacketError {

InvalidPacket,

InvalidChecksum,

UnknownProtocolVersion,

CorruptedMessage,

}

/// Нужна е имплементация на Display за грешките, за да може да имплементират `std::error::Error`.

/// Свободни сте да напишете каквито искате съобщения, ще тестваме само типовете, не низовия им

/// вид.

///

/// Ако са във формат на хайку, няма да получите бонус точки, но може да получите чувство на

/// вътрешно удовлетворение.

///

impl fmt::Display for PacketError {

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

match *self {

PacketError::InvalidPacket => write!(f, "InvalidPacket"),

PacketError::InvalidChecksum => write!(f, "InvalidChecksum"),

PacketError:: UnknownProtocolVersion => write!(f, " UnknownProtocolVersion"),

PacketError::CorruptedMessage => write!(f, "CorruptedMessage"),

}

}

}

/// Тази имплементация би трябвало да сработи директно благодарение на горните. При желание, можете

/// да си имплементирате ръчно някои от методите, само внимавайте.

///

impl std::error::Error for PacketError {}

/// Един пакет, съдържащ част от съобщението. Изберете сами какви полета да използвате за

/// съхранение.

///

/// Може да е нужно да добавите lifetimes на дефиницията тук и/или на методите в impl блока.

///

#[derive(PartialEq, Debug)]

pub struct Packet {

protocol: u8,

psize: usize,

payload: Vec<u8>,

checksum: u32,

}

impl Packet {

/// Конструира пакет от дадения slice от байтове. Приема параметър `size`, който е размера на

/// payload-а на новия пакет. Връща двойка от пакет + оставащите байтове. Тоест, ако имате низа

/// "abcd" и викнете метода върху байтовата му репрезентация с параметър `size` равен на 3, ще

/// върнете двойката `(<пакет с payload "abc">, <байтовия низ "d">)`.

///

/// Байтове от низ можете да извадите чрез `.as_bytes()`, можете и да си конструирате байтов

/// литерал като b"abcd".

///

/// Ако подадения `size` е по-голям от дължината на `source`, приемаме, че размера ще е точно

/// дължината на `source` (и остатъка ще е празен slice).

///

/// Ако параметъра `size` е 0, очакваме тази функция да panic-не (приемаме, че това извикване

/// просто е невалидно, програмистка грешка).

///

pub fn from_source(source: &[u8], size: u8) -> (Self, &[u8]) {

assert_ne!(size, 0, "we are testing that size is not 0");

let mut n = size as usize;

let l =source.len();

if l < n {

n=l;

}

let mut vec = Vec::new();

let mut sum: u32 =0;

let mut x=0;

for b in source {

vec.push(*b);

sum=sum+ *b as u32;

x=x+1;

if x==n {break;}

}

Вместо да поддържаш ръчно индекс x, можеш да го получиш с метода enumerate:

for (i, b) in source.iter().enumerate() {
    if i == n { break; }
    vec.push(*b);
    sum += *b as u32;
}

Тук съм изпозвал i вместо x, понеже i е доста по-стандартно име за индекс на итерация.

Иначе, вместо да поддържаш изобщо индекс, можеш и просто да итерираш по &source[0..n]:

for b in &source[0..n] {
    vec.push(*b);
    sum += *b as u32;
}

Андрей коментира преди почти 6 години

(Packet{protocol:1, psize: n ,payload:vec,checksum: sum} ,

&source[n..])

}

/// Връща само slice-а който пакета опакова. Тоест, ако сме конструирали пакета със

/// `Packet::from_source(b"abc", 3)`, очакваме `.payload()` да ни върне `b"abc"`.

///

/// Защо това просто не е публично property? За да не позволяваме мутация, а само конструиране

/// и четене.

///

pub fn payload(&self) -> &[u8] {

&self.payload

}

/// Сериализира пакета, тоест превръща го в байтове, готови за трансфер. Версия, дължина,

/// съобщение (payload), checksum. Вижте по-горе за детайлно обяснение.

///

pub fn serialize(&self) -> Vec<u8> {

let mut vec = Vec::new();

let checksum = self.checksum.to_be_bytes();

vec.push(self.protocol);

vec.push(self.psize as u8);

for b in &self.payload {

vec.push(*b);

}

for b in &checksum {

vec.push(*b);

}

Вместо тези два for цикъла, можеш да използваш метода extend_from_slice:

vec.extend_from_slice(&self.payload);
vec.extend_from_slice(&checksum);

Андрей коментира преди почти 6 години

vec

}

/// Note: if size is less, it'll be the checksum not being valid

/// Имайки slice от байтове, искаме да извадим един пакет от началото и да върнем остатъка,

/// пакетиран в `Result`.

///

/// Байтовете са репрезентация на пакет -- версия, размер, и т.н. както е описано по-горе.

///

///Ако липсват версия, размер, чексума, или размера е твърде малък, за да може да се изпарси

/// валиден пакет от байтовете, връщаме грешка `PacketError::InvalidPacket`.

///

/// Ако версията е различна от 1, връщаме `PacketError::UnknownProtocolVersion`.

///

/// Ако checksum-а, който прочитаме от последните 4 байта на пакета е различен от изчисления

/// checksum на payload-а (сумата от байтовете му), връщаме `PacketError::InvalidChecksum`.

///

/// Забележете, че ако размера е по-голям от истинския размер на payload-а, се очаква

/// `PacketError::InvalidPacket`. Ако размера е по-малък от истинския размер на payload-а,

/// въпросния ще се изпарси, но чексумата ще е грешна, така че ще очакваме

/// `PacketError::InvalidChecksum`. Малко тъпо! Но уви, протоколите имат подобни тъпи ръбове,

/// особено като са написани за един уикенд. Авторите обещават по-добър протокол за версия 2.

///

pub fn deserialize(bytes: &[u8]) -> Result<(Packet, &[u8]), PacketError> {

if bytes.len()<7 {return Err(PacketError::InvalidPacket);}

let protocol=bytes[0];

if protocol!=1 {return Err(PacketError::UnknownProtocolVersion);}

let psize: usize=bytes[1] as usize;

if psize<1 {return Err(PacketError::InvalidPacket);}

if bytes.len()<(psize+6) {return Err(PacketError::InvalidPacket);}

let mut vec = Vec::new();

let mut sum: u32 =0;

let mut x=0;

for b in bytes {

if x>=2

{vec.push(*b);

sum=sum+ *b as u32;}

x=x+1;

if x==(psize+2) {break;}

}

let (int_bytes, rest) = bytes[psize+2..].split_at(std::mem::size_of::<u32>());

let checksum =u32::from_be_bytes(int_bytes.try_into().unwrap());

if checksum!=sum {return Err(PacketError::InvalidChecksum);}

Ok((Packet{protocol:protocol, psize: psize,payload:vec,checksum: sum} ,

rest))

}

}

/// Структура, която ще служи за итериране по пакети. Ще я конструираме от някакво съобщение, и

/// итерацията ще връща всеки следващ пакет, докато съобщението не бъде напълно "изпратено".

/// Изберете каквито полета ви трябват.

///

/// Може да е нужно да добавите lifetimes на дефиницията тук и/или на методите в impl блока.

///

pub struct PacketSerializer <'a> {

message: &'a [u8],

size: u8,

}

impl<'a> Iterator for PacketSerializer<'a> {

type Item = Packet;

fn next(&mut self) -> Option<Self::Item> {

if self.message.len() > 0 {

let (packet, remainder) = Packet::from_source(self.message, self.size);

self.message=remainder;

Some(packet)

} else {

None

}

}

}

/// Този trait ще ни позволи да конвертираме един `String` (а ако искаме, и други неща) от и до

/// комплект от байтове за прехвърляне по мрежата.

///

/// Детайли за методите вижте по-долу в имплементацията на този trait за `String`.

///

pub trait Packetable: Sized {

fn to_packets(&self, packet_size: u8) -> PacketSerializer;

fn to_packet_data(&self, packet_size: u8) -> Vec<u8>;

fn from_packet_data(packet_data: &[u8]) -> Result<Self, PacketError>;

}

impl Packetable for String {

/// Този метод приема размер, който да използваме за размера на payload-а на всеки пакет. Връща

/// итератор върху въпросните пакети. Низа трябва да се използва под формата на байтове.

///

fn to_packets(&self, packet_size: u8) -> PacketSerializer {

PacketSerializer { message: self.as_bytes() , size:packet_size }

}

/// Имайки итератор по пакети, лесно можем да сериализираме всеки индивидуален пакет в поредица

/// от байтове със `.serialize()` и да го натъпчем във вектора.

///

fn to_packet_data(&self, packet_size: u8) -> Vec<u8> {

let packets = self.to_packets(packet_size).collect::<Vec<Packet>>();

let mut vec = Vec::new();

for p in packets

{

vec.append(&mut p.serialize());

}

vec

}

/// Обратното на горния метод е тази асоциирана функция -- имайки slice от байтове които са

/// сериализирана репрезентация на пакети, искаме да десериализираме пакети от този slice, да

/// им извадим payload-ите, и да ги сглобим в оригиналното съобщение.

///

/// Грешките, които могат да се върнат, са същите, които идват от `.deserialize()`.

///

/// Една допълнителна грешка, която може да се случи е при сглобяване на съобщението -- ако е

/// имало липсващ пакет, може съчетанието на байтовете да не генерира правилно UTF8 съобщение.

/// Тогава връщаме `PacketError::CorruptedMessage`.

///

fn from_packet_data(packet_data: &[u8]) -> Result<Self, PacketError>

{

let mut vec :Vec<u8> = Vec::new();

let mut rem=packet_data;

while rem.len()>0

{

let x = Packet::deserialize(rem);

match x

{

Ok((p,rem1)) =>

{

rem=rem1;

let pay=p.payload();

for b in pay

{

vec.push(*b);

}

},

Err(x) => return Err(x),

}

}

let res = String::from_utf8(vec);

match res

{

Ok(s) => return Ok(s),

Err(_) => return Err(PacketError::CorruptedMessage)

};

}

}

Лог от изпълнението

Compiling solution v0.1.0 (/tmp/d20200111-2173579-1fcj513/solution)
    Finished test [unoptimized + debuginfo] target(s) in 3.64s
     Running target/debug/deps/solution-a73e64ec87929bd0

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

     Running target/debug/deps/solution_test-38971695424b36d5

running 15 tests
test solution_test::test_construct_packet_from_unicode ... ok
test solution_test::test_construct_packet_no_remainder ... ok
test solution_test::test_construct_packet_with_remainder ... ok
test solution_test::test_construct_packet_with_remainder_cyrillic ... ok
test solution_test::test_consuming_packets ... ok
test solution_test::test_deserialize_invalid_packet ... ok
test solution_test::test_deserialize_packet ... ok
test solution_test::test_deserialize_unicode_packet ... ok
test solution_test::test_full_roundtrip ... ok
test solution_test::test_full_roundtrip_for_zero_size_string ... ok
test solution_test::test_invalid_packet_combination ... ok
test solution_test::test_iterating_packets ... ok
test solution_test::test_iterating_packets_for_zero_size_string ... ok
test solution_test::test_serialize_packet ... ok
test solution_test::test_zero_size ... ok

test result: ok. 15 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

   Doc-tests solution

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

История (1 версия и 3 коментара)