Encoding

src/packet/auth_packet.rs

@@ -58,13 +58,11 @@ impl<'a, const MAX_PROPERTIES: usize> Packet<'a> for AuthPacket<'a, MAX_PROPERTI
         let property_len_len = VariableByteIntegerEncoder::len(property_len_enc);
         rm_ln = rm_ln + property_len_len as u32;
         rm_ln = rm_ln + 1;
-        let rm_len_enc: [u8; 4] = VariableByteIntegerEncoder::encode(rm_ln).unwrap();
-        let rm_len_len = VariableByteIntegerEncoder::len(rm_len_enc);
 
         buff_writer.write_u8(self.fixed_header);
-        buff_writer.insert_ref(rm_len_len, &rm_len_enc);
+        buff_writer.write_variable_byte_int(rm_ln);
         buff_writer.write_u8(self.auth_reason);
-        buff_writer.insert_ref(property_len_len, &property_len_enc);
+        buff_writer.write_variable_byte_int(self.property_len);
         buff_writer.encode_properties::<MAX_PROPERTIES>(&self.properties);
     }
 

src/packet/connack_packet.rs

@@ -1,7 +1,9 @@
 use heapless::Vec;
+use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder;
 
 use crate::packet::mqtt_packet::Packet;
 use crate::utils::buffer_reader::BuffReader;
+use crate::utils::buffer_writer::BuffWriter;
 
 use super::packet_type::PacketType;
 use super::property::Property;
@@ -32,7 +34,19 @@ impl<'a> ConnackPacket<'a> {
 }
 
 impl<'a> Packet<'a> for ConnackPacket<'a> {
-    fn encode(&mut self, buffer: &mut [u8]) {}
+    fn encode(&mut self, buffer: &mut [u8]) {
+        let mut buff_writer = BuffWriter::new(buffer);
+        buff_writer.write_u8(self.fixed_header);
+        let mut property_len_enc = VariableByteIntegerEncoder::encode(self.property_len).unwrap();
+        let property_len_len = VariableByteIntegerEncoder::len(property_len_enc);
+
+        let rm_len: u32 = 2 + self.property_len + property_len_len as u32;
+        buff_writer.write_variable_byte_int(rm_len);
+        buff_writer.write_u8(self.ack_flags);
+        buff_writer.write_u8(self.connect_reason_code);
+        buff_writer.write_variable_byte_int(self.property_len);
+        buff_writer.encode_properties(&self.properties);
+    }
     fn decode(&mut self, buff_reader: &mut BuffReader<'a>) {
         self.decode_connack_packet(buff_reader);
     }

src/packet/disconnect_packet.rs

@@ -1,7 +1,9 @@
 use heapless::Vec;
+use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder;
 
 use crate::packet::mqtt_packet::Packet;
 use crate::utils::buffer_reader::BuffReader;
+use crate::utils::buffer_writer::BuffWriter;
 
 use super::packet_type::PacketType;
 use super::property::Property;
@@ -31,7 +33,18 @@ impl<'a, const MAX_PROPERTIES: usize> DisconnectPacket<'a, MAX_PROPERTIES> {
 }
 
 impl<'a, const MAX_PROPERTIES: usize> Packet<'a> for DisconnectPacket<'a, MAX_PROPERTIES> {
-    fn encode(&mut self, buffer: &mut [u8]) {}
+    fn encode(&mut self, buffer: &mut [u8]) {
+        let mut buff_writer = BuffWriter::new(buffer);
+        buff_writer.write_u8(self.fixed_header);
+        let mut property_len_enc = VariableByteIntegerEncoder::encode(self.property_len).unwrap();
+        let property_len_len = VariableByteIntegerEncoder::len(property_len_enc);
+
+        let rm_len: u32 = 1 + self.property_len + property_len_len as u32;
+        buff_writer.write_variable_byte_int(rm_len);
+        buff_writer.write_u8(self.disconnect_reason);
+        buff_writer.write_variable_byte_int(self.property_len);
+        buff_writer.encode_properties(&self.properties);
+    }
 
     fn decode(&mut self, buff_reader: &mut BuffReader<'a>) {
         self.decode_auth_packet(buff_reader);

src/packet/mod.rs

@@ -1,10 +1,11 @@
-/*pub mod connack_packet;
+
-pub mod control_packet;*/
+//pub mod control_packet;
 pub mod mqtt_packet;
 pub mod packet_type;
 pub mod property;
 pub mod auth_packet;
-/*pub mod puback_packet;
+pub mod connack_packet;
+pub mod puback_packet;
 pub mod pubcomp_packet;
 pub mod publish_packet;
 pub mod pubrec_packet;
@@ -17,4 +18,4 @@ pub mod disconnect_packet;
 pub mod pingreq_packet;
 pub mod pingresp_packet;
 pub mod suback_packet;
-pub mod unsuback_packet;*/
+pub mod unsuback_packet;

src/packet/pingreq_packet.rs

@@ -1,5 +1,6 @@
 use crate::packet::mqtt_packet::Packet;
 use crate::utils::buffer_reader::BuffReader;
+use crate::utils::buffer_writer::BuffWriter;
 
 use super::packet_type::PacketType;
 use super::property::Property;
@@ -16,7 +17,11 @@ pub struct PingreqPacket {
 impl PingreqPacket {}
 
 impl<'a> Packet<'a> for PingreqPacket {
-    fn encode(&mut self, buffer: &mut [u8]) {}
+    fn encode(&mut self, buffer: &mut [u8]) {
+        let mut buff_writer = BuffWriter::new(buffer);
+        buff_writer.write_u8(self.fixed_header);
+        buff_writer.write_variable_byte_int(0 as u32);
+    }
 
     fn decode(&mut self, buff_reader: &mut BuffReader<'a>) {
         log::error!("PingreqPacket packet does not support decode funtion on client!");

src/packet/pingresp_packet.rs

@@ -1,5 +1,6 @@
 use crate::packet::mqtt_packet::Packet;
 use crate::utils::buffer_reader::BuffReader;
+use crate::utils::buffer_writer::BuffWriter;
 
 use super::packet_type::PacketType;
 use super::property::Property;
@@ -21,7 +22,11 @@ impl<'a> PingrespPacket {
 }
 
 impl<'a> Packet<'a> for PingrespPacket {
-    fn encode(&mut self, buffer: &mut [u8]) {}
+    fn encode(&mut self, buffer: &mut [u8]) {
+        let mut buff_writer = BuffWriter::new(buffer);
+        buff_writer.write_u8(self.fixed_header);
+        buff_writer.write_variable_byte_int(0 as u32);
+    }
 
     fn decode(&mut self, buff_reader: &mut BuffReader<'a>) {
         self.decode_pingresp_packet(buff_reader);

src/packet/puback_packet.rs

@@ -1,7 +1,9 @@
 use heapless::Vec;
+use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder;
 
 use crate::packet::mqtt_packet::Packet;
 use crate::utils::buffer_reader::BuffReader;
+use crate::utils::buffer_writer::BuffWriter;
 
 use super::packet_type::PacketType;
 use super::property::Property;
@@ -36,7 +38,21 @@ impl<'a> PubackPacket<'a> {
 }
 
 impl<'a> Packet<'a> for PubackPacket<'a> {
-    fn encode(&mut self, buffer: &mut [u8]) {}
+    fn encode(&mut self, buffer: &mut [u8]) {
+        let mut buff_writer = BuffWriter::new(buffer);
+
+        let mut rm_ln = self.property_len;
+        let property_len_enc: [u8; 4] = VariableByteIntegerEncoder::encode(self.property_len).unwrap();
+        let property_len_len = VariableByteIntegerEncoder::len(property_len_enc);
+        rm_ln = rm_ln + property_len_len as u32 + 3;
+
+        buff_writer.write_u8(self.fixed_header);
+        buff_writer.write_variable_byte_int(rm_ln);
+        buff_writer.write_u16(self.packet_identifier);
+        buff_writer.write_u8(self.reason_code);
+        buff_writer.write_variable_byte_int(self.property_len);
+        buff_writer.encode_properties::<MAX_PROPERTIES>(&self.properties);
+    }
 
     fn decode(&mut self, buff_reader: &mut BuffReader<'a>) {
         self.decode_puback_packet(buff_reader);

src/packet/pubcomp_packet.rs

@@ -1,7 +1,9 @@
 use heapless::Vec;
+use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder;
 
 use crate::packet::mqtt_packet::Packet;
 use crate::utils::buffer_reader::BuffReader;
+use crate::utils::buffer_writer::BuffWriter;
 
 use super::packet_type::PacketType;
 use super::property::Property;
@@ -37,7 +39,21 @@ impl<'a> PubcompPacket<'a> {
 }
 
 impl<'a> Packet<'a> for PubcompPacket<'a> {
-    fn encode(&mut self, buffer: &mut [u8]) {}
+    fn encode(&mut self, buffer: &mut [u8]) {
+        let mut buff_writer = BuffWriter::new(buffer);
+
+        let mut rm_ln = self.property_len;
+        let property_len_enc: [u8; 4] = VariableByteIntegerEncoder::encode(self.property_len).unwrap();
+        let property_len_len = VariableByteIntegerEncoder::len(property_len_enc);
+        rm_ln = rm_ln + property_len_len as u32 + 3;
+
+        buff_writer.write_u8(self.fixed_header);
+        buff_writer.write_variable_byte_int(rm_ln);
+        buff_writer.write_u16(self.packet_identifier);
+        buff_writer.write_u8(self.reason_code);
+        buff_writer.write_variable_byte_int(self.property_len);
+        buff_writer.encode_properties::<MAX_PROPERTIES>(&self.properties);
+    }
 
     fn decode(&mut self, buff_reader: &mut BuffReader<'a>) {
         self.decode_puback_packet(buff_reader);

src/packet/publish_packet.rs

@@ -1,8 +1,10 @@
 use heapless::Vec;
+use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder;
 
 use crate::packet::mqtt_packet::Packet;
 use crate::utils::buffer_reader::BuffReader;
 use crate::utils::buffer_reader::EncodedString;
+use crate::utils::buffer_writer::BuffWriter;
 
 use super::packet_type::PacketType;
 use super::property::Property;
@@ -40,7 +42,23 @@ impl<'a> PublishPacket<'a> {
 }
 
 impl<'a> Packet<'a> for PublishPacket<'a> {
-    fn encode(&mut self, buffer: &mut [u8]) {}
+    fn encode(&mut self, buffer: &mut [u8]) {
+        let mut buff_writer = BuffWriter::new(buffer);
+
+        let mut rm_ln = self.property_len;
+        let property_len_enc: [u8; 4] = VariableByteIntegerEncoder::encode(self.property_len).unwrap();
+        let property_len_len = VariableByteIntegerEncoder::len(property_len_enc);
+        let mut msg_len = self.message.len() as u32;
+        rm_ln = rm_ln + property_len_len as u32 + 2 + msg_len + self.topic_name.len as u32 + 2;
+
+        buff_writer.write_u8(self.fixed_header);
+        buff_writer.write_variable_byte_int(rm_ln);
+        buff_writer.write_string_ref(& self.topic_name);
+        buff_writer.write_u16(self.packet_identifier);
+        buff_writer.write_variable_byte_int(self.property_len);
+        buff_writer.encode_properties::<MAX_PROPERTIES>(&self.properties);
+        buff_writer.insert_ref(msg_len as usize, self.message)
+    }
 
     fn decode(&mut self, buff_reader: &mut BuffReader<'a>) {
         self.decode_publish_packet(buff_reader);

src/packet/pubrec_packet.rs

@@ -1,7 +1,9 @@
 use heapless::Vec;
+use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder;
 
 use crate::packet::mqtt_packet::Packet;
 use crate::utils::buffer_reader::BuffReader;
+use crate::utils::buffer_writer::BuffWriter;
 
 use super::packet_type::PacketType;
 use super::property::Property;
@@ -37,7 +39,21 @@ impl<'a> PubrecPacket<'a> {
 }
 
 impl<'a> Packet<'a> for PubrecPacket<'a> {
-    fn encode(&mut self, buffer: &mut [u8]) {}
+    fn encode(&mut self, buffer: &mut [u8]) {
+        let mut buff_writer = BuffWriter::new(buffer);
+
+        let mut rm_ln = self.property_len;
+        let property_len_enc: [u8; 4] = VariableByteIntegerEncoder::encode(self.property_len).unwrap();
+        let property_len_len = VariableByteIntegerEncoder::len(property_len_enc);
+        rm_ln = rm_ln + property_len_len as u32 + 3;
+
+        buff_writer.write_u8(self.fixed_header);
+        buff_writer.write_variable_byte_int(rm_ln);
+        buff_writer.write_u16(self.packet_identifier);
+        buff_writer.write_u8(self.reason_code);
+        buff_writer.write_variable_byte_int(self.property_len);
+        buff_writer.encode_properties::<MAX_PROPERTIES>(&self.properties);
+    }
 
     fn decode(&mut self, buff_reader: &mut BuffReader<'a>) {
         self.decode_pubrec_packet(buff_reader);

src/packet/pubrel_packet.rs

@@ -1,7 +1,9 @@
 use heapless::Vec;
+use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder;
 
 use crate::packet::mqtt_packet::Packet;
 use crate::utils::buffer_reader::BuffReader;
+use crate::utils::buffer_writer::BuffWriter;
 
 use super::packet_type::PacketType;
 use super::property::Property;
@@ -37,7 +39,21 @@ impl<'a> PubrelPacket<'a> {
 }
 
 impl<'a> Packet<'a> for PubrelPacket<'a> {
-    fn encode(&mut self, buffer: &mut [u8]) {}
+    fn encode(&mut self, buffer: &mut [u8]) {
+        let mut buff_writer = BuffWriter::new(buffer);
+
+        let mut rm_ln = self.property_len;
+        let property_len_enc: [u8; 4] = VariableByteIntegerEncoder::encode(self.property_len).unwrap();
+        let property_len_len = VariableByteIntegerEncoder::len(property_len_enc);
+        rm_ln = rm_ln + property_len_len as u32 + 3;
+
+        buff_writer.write_u8(self.fixed_header);
+        buff_writer.write_variable_byte_int(rm_ln);
+        buff_writer.write_u16(self.packet_identifier);
+        buff_writer.write_u8(self.reason_code);
+        buff_writer.write_variable_byte_int(self.property_len);
+        buff_writer.encode_properties::<MAX_PROPERTIES>(&self.properties);
+    }
 
     fn decode(&mut self, buff_reader: &mut BuffReader<'a>) {
         self.decode_puback_packet(buff_reader);

src/packet/suback_packet.rs

@@ -1,7 +1,9 @@
 use heapless::Vec;
+use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder;
 
 use crate::packet::mqtt_packet::Packet;
 use crate::utils::buffer_reader::BuffReader;
+use crate::utils::buffer_writer::BuffWriter;
 
 use super::packet_type::PacketType;
 use super::property::Property;
@@ -49,7 +51,9 @@ impl<'a, const MAX_REASONS: usize> SubackPacket<'a, MAX_REASONS> {
 }
 
 impl<'a, const MAX_REASONS: usize> Packet<'a> for SubackPacket<'a, MAX_REASONS> {
-    fn encode(&mut self, buffer: &mut [u8]) {}
+    fn encode(&mut self, buffer: &mut [u8]) {
+        log::error!("SUBACK packet does not support encoding!");
+    }
 
     fn decode(&mut self, buff_reader: &mut BuffReader<'a>) {
         self.decode_suback_packet(buff_reader);

src/packet/subscription_packet.rs

@@ -1,8 +1,10 @@
 use heapless::Vec;
+use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder;
 
 use crate::packet::mqtt_packet::Packet;
 use crate::utils::buffer_reader::BuffReader;
 use crate::utils::buffer_reader::TopicFilter;
+use crate::utils::buffer_writer::BuffWriter;
 
 use super::packet_type::PacketType;
 use super::property::Property;
@@ -23,7 +25,7 @@ pub struct SubscriptionPacket<'a, const MAX_FILTERS: usize> {
     pub properties: Vec<Property<'a>, MAX_PROPERTIES>,
 
     // topic filter len
-    pub topic_filter_let: u16,
+    pub topic_filter_len: u16,
 
     // payload
     pub topic_filters: Vec<TopicFilter<'a>, MAX_FILTERS>,
@@ -36,7 +38,22 @@ impl<'a, const MAX_FILTERS: usize> SubscriptionPacket<'a, MAX_FILTERS> {
 }
 
 impl<'a, const MAX_FILTERS: usize> Packet<'a> for SubscriptionPacket<'a, MAX_FILTERS> {
-    fn encode(&mut self, buffer: &mut [u8]) {}
+    fn encode(&mut self, buffer: &mut [u8]) {
+        let mut buff_writer = BuffWriter::new(buffer);
+
+        let mut rm_ln = self.property_len;
+        let property_len_enc: [u8; 4] = VariableByteIntegerEncoder::encode(self.property_len).unwrap();
+        let property_len_len = VariableByteIntegerEncoder::len(property_len_enc);
+        rm_ln = rm_ln + property_len_len as u32 + 4 + self.topic_filter_len as u32;
+
+        buff_writer.write_u8(self.fixed_header);
+        buff_writer.write_variable_byte_int(rm_ln);
+        buff_writer.write_u16(self.packet_identifier);
+        buff_writer.write_variable_byte_int(self.property_len);
+        buff_writer.encode_properties::<MAX_PROPERTIES>(&self.properties);
+        buff_writer.write_u16(self.topic_filter_len);
+        buff_writer.encode_topic_filters_ref(false, self.topic_filter_len as usize, & self.topic_filters);
+    }
 
     fn decode(&mut self, buff_reader: &mut BuffReader<'a>) {
         log::error!("Subscribe packet does not support decode funtion on client!");

src/packet/unsuback_packet.rs

@@ -49,7 +49,9 @@ impl<'a, const MAX_REASONS: usize> UnsubackPacket<'a, MAX_REASONS> {
 }
 
 impl<'a, const MAX_REASONS: usize> Packet<'a> for UnsubackPacket<'a, MAX_REASONS> {
-    fn encode(&mut self, buffer: &mut [u8]) {}
+    fn encode(&mut self, buffer: &mut [u8]) {
+        log::error!("UNSUBACK packet does not support encoding!");
+    }
 
     fn decode(&mut self, buff_reader: &mut BuffReader<'a>) {
         self.decode_suback_packet(buff_reader);

src/packet/unsubscription_packet.rs

@@ -1,8 +1,10 @@
 use heapless::Vec;
+use crate::encoding::variable_byte_integer::VariableByteIntegerEncoder;
 
 use crate::packet::mqtt_packet::Packet;
 use crate::utils::buffer_reader::BuffReader;
 use crate::utils::buffer_reader::TopicFilter;
+use crate::utils::buffer_writer::BuffWriter;
 
 use super::packet_type::PacketType;
 use super::property::Property;
@@ -23,7 +25,7 @@ pub struct UnsubscriptionPacket<'a, const MAX_FILTERS: usize> {
     pub properties: Vec<Property<'a>, MAX_PROPERTIES>,
 
     // topic filter len
-    pub topic_filter_let: u16,
+    pub topic_filter_len: u16,
 
     // payload
     pub topic_filters: Vec<TopicFilter<'a>, MAX_FILTERS>,
@@ -36,7 +38,22 @@ impl<'a, const MAX_FILTERS: usize> UnsubscriptionPacket<'a, MAX_FILTERS> {
 }
 
 impl<'a, const MAX_FILTERS: usize> Packet<'a> for UnsubscriptionPacket<'a, MAX_FILTERS> {
-    fn encode(&mut self, buffer: &mut [u8]) {}
+    fn encode(&mut self, buffer: &mut [u8]) {
+        let mut buff_writer = BuffWriter::new(buffer);
+
+        let mut rm_ln = self.property_len;
+        let property_len_enc: [u8; 4] = VariableByteIntegerEncoder::encode(self.property_len).unwrap();
+        let property_len_len = VariableByteIntegerEncoder::len(property_len_enc);
+        rm_ln = rm_ln + property_len_len as u32 + 4 + self.topic_filter_len as u32;
+
+        buff_writer.write_u8(self.fixed_header);
+        buff_writer.write_variable_byte_int(rm_ln);
+        buff_writer.write_u16(self.packet_identifier);
+        buff_writer.write_variable_byte_int(self.property_len);
+        buff_writer.encode_properties::<MAX_PROPERTIES>(&self.properties);
+        buff_writer.write_u16(self.topic_filter_len);
+        buff_writer.encode_topic_filters_ref(false, self.topic_filter_len as usize, & self.topic_filters);
+    }
 
     fn decode(&mut self, buff_reader: &mut BuffReader<'a>) {
         log::error!("Unsubscribe packet does not support decode funtion on client!");

src/utils/buffer_reader.rs

@@ -50,7 +50,6 @@ impl StringPair<'_> {
 
 #[derive(Debug)]
 pub struct TopicFilter<'a> {
-    pub len: u16,
     pub filter: EncodedString<'a>,
     pub sub_options: u8,
 }
@@ -58,14 +57,13 @@ pub struct TopicFilter<'a> {
 impl TopicFilter<'_> {
     pub fn new() -> Self {
         Self {
-            len: 0,
             filter: EncodedString::new(),
             sub_options: 0,
         }
     }
 
     pub fn len(&self) -> u16 {
-        return self.len + 2;
+        return self.filter.len + 3;
     }
 }
 

src/utils/buffer_writer.rs

@@ -1,4 +1,4 @@
-use crate::utils::buffer_reader::{BinaryData, EncodedString, StringPair};
+use crate::utils::buffer_reader::{BinaryData, EncodedString, StringPair, TopicFilter};
 use core::str;
 use heapless::Vec;
 use crate::encoding::variable_byte_integer::{VariableByteInteger, VariableByteIntegerEncoder};
@@ -116,4 +116,22 @@ impl<'a> BuffWriter<'a> {
             }
         }
     }
+
+    fn encode_topic_filter_ref(& mut self,  sub: bool, topic_filter: & TopicFilter<'a>) {
+        self.write_string_ref(&topic_filter.filter);
+        if sub {
+            self.write_u8(topic_filter.sub_options)
+        }
+    }
+
+    pub fn encode_topic_filters_ref<const MAX: usize>(& mut self, sub: bool, len: usize, filters: & Vec<TopicFilter<'a>, MAX>) {
+        let mut i = 0;
+        loop {
+            let topic_filter: & TopicFilter<'a> = filters.get(i).unwrap();
+            self.encode_topic_filter_ref(sub, topic_filter);
+            if i == len {
+                break;
+            }
+        }
+    }
 }