colin/mslicer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add little endian serde functions

Browse Source
This commit is contained in:
Connor Slade
2024-09-02 22:08:45 -04:00
parent b9c6958ee1
commit a55f2eb130
15 changed files with 224 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
common/src/serde/deserializer.rs
View File

@@ -1,3 +1,5 @@
use std::mem;
use super::SizedString;
pub struct Deserializer<'a> {
@@ -18,6 +20,18 @@ impl<'a> Deserializer<'a> {
self.offset
}
pub fn advance_by(&mut self, amount: usize) {
self.offset += amount;
}
pub fn advance<T>(&mut self) {
self.advance_by(mem::size_of::<T>());
}
pub fn jump_to(&mut self, pos: usize) {
self.offset = pos;
}
pub fn read_bool(&mut self) -> bool {
self.read_u8() != 0
}
@@ -28,13 +42,19 @@ impl<'a> Deserializer<'a> {
value
}
pub fn read_u16(&mut self) -> u16 {
pub fn read_u16_be(&mut self) -> u16 {
let value = u16::from_be_bytes([self.buffer[self.offset], self.buffer[self.offset + 1]]);
self.offset += 2;
value
}
pub fn read_u32(&mut self) -> u32 {
pub fn read_u16_le(&mut self) -> u16 {
let value = u16::from_le_bytes([self.buffer[self.offset], self.buffer[self.offset + 1]]);
self.offset += 2;
value
}
pub fn read_u32_be(&mut self) -> u32 {
let value = u32::from_be_bytes([
self.buffer[self.offset],
self.buffer[self.offset + 1],
@@ -45,7 +65,18 @@ impl<'a> Deserializer<'a> {
value
}
pub fn read_u64(&mut self) -> u64 {
pub fn read_u32_le(&mut self) -> u32 {
let value = u32::from_le_bytes([
self.buffer[self.offset],
self.buffer[self.offset + 1],
self.buffer[self.offset + 2],
self.buffer[self.offset + 3],
]);
self.offset += 4;
value
}
pub fn read_u64_be(&mut self) -> u64 {
let value = u64::from_be_bytes([
self.buffer[self.offset],
self.buffer[self.offset + 1],
@@ -60,7 +91,22 @@ impl<'a> Deserializer<'a> {
value
}
pub fn read_f32(&mut self) -> f32 {
pub fn read_u64_le(&mut self) -> u64 {
let value = u64::from_le_bytes([
self.buffer[self.offset],
self.buffer[self.offset + 1],
self.buffer[self.offset + 2],
self.buffer[self.offset + 3],
self.buffer[self.offset + 4],
self.buffer[self.offset + 5],
self.buffer[self.offset + 6],
self.buffer[self.offset + 7],
]);
self.offset += 8;
value
}
pub fn read_f32_be(&mut self) -> f32 {
let value = f32::from_be_bytes([
self.buffer[self.offset],
self.buffer[self.offset + 1],
@@ -71,6 +117,17 @@ impl<'a> Deserializer<'a> {
value
}
pub fn read_f32_le(&mut self) -> f32 {
let value = f32::from_le_bytes([
self.buffer[self.offset],
self.buffer[self.offset + 1],
self.buffer[self.offset + 2],
self.buffer[self.offset + 3],
]);
self.offset += 4;
value
}
pub fn read_bytes(&mut self, length: usize) -> &'a [u8] {
let value = &self.buffer[self.offset..self.offset + length];
self.offset += length;

24
common/src/serde/serializer.rs
View File

@@ -3,10 +3,10 @@ use super::SizedString;
pub trait Serializer {
fn write_bool(&mut self, data: bool);
fn write_u8(&mut self, data: u8);
fn write_u16(&mut self, data: u16);
fn write_u32(&mut self, data: u32);
fn write_u64(&mut self, data: u64);
fn write_f32(&mut self, data: f32);
fn write_u16_be(&mut self, data: u16);
fn write_u32_be(&mut self, data: u32);
fn write_u64_be(&mut self, data: u64);
fn write_f32_be(&mut self, data: f32);
fn write_bytes(&mut self, data: &[u8]);
fn write_sized_string<const SIZE: usize>(&mut self, data: &SizedString<SIZE>);
}
@@ -46,22 +46,22 @@ impl Serializer for SizedSerializer<'_> {
self.offset += 1;
}
fn write_u16(&mut self, data: u16) {
fn write_u16_be(&mut self, data: u16) {
self.buffer[self.offset..self.offset + 2].copy_from_slice(&data.to_be_bytes());
self.offset += 2;
}
fn write_u32(&mut self, data: u32) {
fn write_u32_be(&mut self, data: u32) {
self.buffer[self.offset..self.offset + 4].copy_from_slice(&data.to_be_bytes());
self.offset += 4;
}
fn write_u64(&mut self, data: u64) {
fn write_u64_be(&mut self, data: u64) {
self.buffer[self.offset..self.offset + 8].copy_from_slice(&data.to_be_bytes());
self.offset += 8;
}
fn write_f32(&mut self, data: f32) {
fn write_f32_be(&mut self, data: f32) {
self.buffer[self.offset..self.offset + 4].copy_from_slice(&data.to_be_bytes());
self.offset += 4;
}
@@ -87,19 +87,19 @@ impl Serializer for DynamicSerializer {
self.buffer.push(data);
}
fn write_u16(&mut self, data: u16) {
fn write_u16_be(&mut self, data: u16) {
self.buffer.extend_from_slice(&data.to_be_bytes());
}
fn write_u32(&mut self, data: u32) {
fn write_u32_be(&mut self, data: u32) {
self.buffer.extend_from_slice(&data.to_be_bytes());
}
fn write_u64(&mut self, data: u64) {
fn write_u64_be(&mut self, data: u64) {
self.buffer.extend_from_slice(&data.to_be_bytes());
}
fn write_f32(&mut self, data: f32) {
fn write_f32_be(&mut self, data: f32) {
self.buffer.extend_from_slice(&data.to_be_bytes());
}

4
goo_format/src/default.rs
View File

@@ -1,8 +1,8 @@
use common::serde::SizedString;
use crate::{header_info::ExposureDelayMode, HeaderInfo, LayerContent, PreviewImage};
use crate::{header::ExposureDelayMode, Header, LayerContent, PreviewImage};
impl Default for HeaderInfo {
impl Default for Header {
fn default() -> Self {
Self {
version: SizedString::new(b"V3.0"),

10
goo_format/src/file.rs
View File

@@ -6,15 +6,15 @@ use common::{
serde::{Deserializer, Serializer, SizedString},
};
use crate::{HeaderInfo, LayerContent, ENDING_STRING};
use crate::{Header, LayerContent, ENDING_STRING};
pub struct File {
pub header: HeaderInfo,
pub header: Header,
pub layers: Vec<LayerContent>,
}
impl File {
pub fn new(header: HeaderInfo, layers: Vec<LayerContent>) -> Self {
pub fn new(header: Header, layers: Vec<LayerContent>) -> Self {
Self { header, layers }
}
@@ -37,7 +37,7 @@ impl File {
+ slice_config.first_layers as f32 * bottom_layer_time;
Self::new(
HeaderInfo {
Header {
x_resolution: slice_config.platform_resolution.x as u16,
y_resolution: slice_config.platform_resolution.y as u16,
x_size: slice_config.platform_size.x,
@@ -87,7 +87,7 @@ impl File {
pub fn deserialize(buf: &[u8]) -> Result<Self> {
let mut des = Deserializer::new(buf);
let header = HeaderInfo::deserialize(&mut des)?;
let header = Header::deserialize(&mut des)?;
let mut layers = Vec::with_capacity(header.layer_count as usize);
for _ in 0..header.layer_count {

184
goo_format/src/header_info.rs → goo_format/src/header.rs
View File

@@ -7,7 +7,7 @@ use common::serde::{Deserializer, Serializer, SizedString};
use crate::{PreviewImage, DELIMITER, MAGIC_TAG};
/// The header section of a `.goo` file.
pub struct HeaderInfo {
pub struct Header {
/// Format version, should be "V3.0".
pub version: SizedString<4>,
/// Name of software that generated the file.
@@ -142,12 +142,12 @@ pub enum ExposureDelayMode {
StaticTime,
}
impl HeaderInfo {
impl Header {
pub const SIZE: usize = 0x2FB95;
}
// this is fine
impl HeaderInfo {
impl Header {
pub fn serialize<T: Serializer>(&self, ser: &mut T) {
ser.write_sized_string(&self.version);
ser.write_bytes(MAGIC_TAG);
@@ -157,60 +157,60 @@ impl HeaderInfo {
ser.write_sized_string(&self.printer_name);
ser.write_sized_string(&self.printer_type);
ser.write_sized_string(&self.profile_name);
ser.write_u16(self.anti_aliasing_level);
ser.write_u16(self.grey_level);
ser.write_u16(self.blur_level);
ser.write_u16_be(self.anti_aliasing_level);
ser.write_u16_be(self.grey_level);
ser.write_u16_be(self.blur_level);
self.small_preview.serializes(ser);
ser.write_bytes(DELIMITER);
self.big_preview.serializes(ser);
ser.write_bytes(DELIMITER);
ser.write_u32(self.layer_count);
ser.write_u16(self.x_resolution);
ser.write_u16(self.y_resolution);
ser.write_u32_be(self.layer_count);
ser.write_u16_be(self.x_resolution);
ser.write_u16_be(self.y_resolution);
ser.write_bool(self.x_mirror);
ser.write_bool(self.y_mirror);
ser.write_f32(self.x_size);
ser.write_f32(self.y_size);
ser.write_f32(self.z_size);
ser.write_f32(self.layer_thickness);
ser.write_f32(self.exposure_time);
ser.write_f32_be(self.x_size);
ser.write_f32_be(self.y_size);
ser.write_f32_be(self.z_size);
ser.write_f32_be(self.layer_thickness);
ser.write_f32_be(self.exposure_time);
ser.write_u8(self.exposure_delay_mode as u8);
ser.write_f32(self.turn_off_time);
ser.write_f32(self.bottom_before_lift_time);
ser.write_f32(self.bottom_after_lift_time);
ser.write_f32(self.bottom_after_retract_time);
ser.write_f32(self.before_lift_time);
ser.write_f32(self.after_lift_time);
ser.write_f32(self.after_retract_time);
ser.write_f32(self.bottom_exposure_time);
ser.write_u32(self.bottom_layers);
ser.write_f32(self.bottom_lift_distance);
ser.write_f32(self.bottom_lift_speed);
ser.write_f32(self.lift_distance);
ser.write_f32(self.lift_speed);
ser.write_f32(self.bottom_retract_distance);
ser.write_f32(self.bottom_retract_speed);
ser.write_f32(self.retract_distance);
ser.write_f32(self.retract_speed);
ser.write_f32(self.bottom_second_lift_distance);
ser.write_f32(self.bottom_second_lift_speed);
ser.write_f32(self.second_lift_distance);
ser.write_f32(self.second_lift_speed);
ser.write_f32(self.bottom_second_retract_distance);
ser.write_f32(self.bottom_second_retract_speed);
ser.write_f32(self.second_retract_distance);
ser.write_f32(self.second_retract_speed);
ser.write_u16(self.bottom_light_pwm as u16);
ser.write_u16(self.light_pwm as u16);
ser.write_f32_be(self.turn_off_time);
ser.write_f32_be(self.bottom_before_lift_time);
ser.write_f32_be(self.bottom_after_lift_time);
ser.write_f32_be(self.bottom_after_retract_time);
ser.write_f32_be(self.before_lift_time);
ser.write_f32_be(self.after_lift_time);
ser.write_f32_be(self.after_retract_time);
ser.write_f32_be(self.bottom_exposure_time);
ser.write_u32_be(self.bottom_layers);
ser.write_f32_be(self.bottom_lift_distance);
ser.write_f32_be(self.bottom_lift_speed);
ser.write_f32_be(self.lift_distance);
ser.write_f32_be(self.lift_speed);
ser.write_f32_be(self.bottom_retract_distance);
ser.write_f32_be(self.bottom_retract_speed);
ser.write_f32_be(self.retract_distance);
ser.write_f32_be(self.retract_speed);
ser.write_f32_be(self.bottom_second_lift_distance);
ser.write_f32_be(self.bottom_second_lift_speed);
ser.write_f32_be(self.second_lift_distance);
ser.write_f32_be(self.second_lift_speed);
ser.write_f32_be(self.bottom_second_retract_distance);
ser.write_f32_be(self.bottom_second_retract_speed);
ser.write_f32_be(self.second_retract_distance);
ser.write_f32_be(self.second_retract_speed);
ser.write_u16_be(self.bottom_light_pwm as u16);
ser.write_u16_be(self.light_pwm as u16);
ser.write_bool(self.per_layer_settings);
ser.write_u32(self.printing_time);
ser.write_f32(self.total_volume);
ser.write_f32(self.total_weight);
ser.write_f32(self.total_price);
ser.write_u32_be(self.printing_time);
ser.write_f32_be(self.total_volume);
ser.write_f32_be(self.total_weight);
ser.write_f32_be(self.total_price);
ser.write_sized_string(&self.price_unit);
ser.write_u32(Self::SIZE as u32);
ser.write_u32_be(Self::SIZE as u32);
ser.write_bool(self.grey_scale_level);
ser.write_u16(self.transition_layers);
ser.write_u16_be(self.transition_layers);
}
pub fn deserialize(des: &mut Deserializer) -> Result<Self> {
@@ -222,60 +222,60 @@ impl HeaderInfo {
let printer_name = des.read_sized_string();
let printer_type = des.read_sized_string();
let profile_name = des.read_sized_string();
let anti_aliasing_level = des.read_u16();
let grey_level = des.read_u16();
let blur_level = des.read_u16();
let anti_aliasing_level = des.read_u16_be();
let grey_level = des.read_u16_be();
let blur_level = des.read_u16_be();
let small_preview = PreviewImage::deserializes(des);
ensure!(des.read_bytes(2) == [0xd, 0xa]);
let big_preview = PreviewImage::deserializes(des);
ensure!(des.read_bytes(2) == [0xd, 0xa]);
let layer_count = des.read_u32();
let x_resolution = des.read_u16();
let y_resolution = des.read_u16();
let layer_count = des.read_u32_be();
let x_resolution = des.read_u16_be();
let y_resolution = des.read_u16_be();
let x_mirror = des.read_bool();
let y_mirror = des.read_bool();
let x_size = des.read_f32();
let y_size = des.read_f32();
let z_size = des.read_f32();
let layer_thickness = des.read_f32();
let exposure_time = des.read_f32();
let x_size = des.read_f32_be();
let y_size = des.read_f32_be();
let z_size = des.read_f32_be();
let layer_thickness = des.read_f32_be();
let exposure_time = des.read_f32_be();
let exposure_delay_mode = ExposureDelayMode::from_bool(des.read_bool());
let turn_off_time = des.read_f32();
let bottom_before_lift_time = des.read_f32();
let bottom_after_lift_time = des.read_f32();
let bottom_after_retract_time = des.read_f32();
let before_lift_time = des.read_f32();
let after_lift_time = des.read_f32();
let after_retract_time = des.read_f32();
let bottom_exposure_time = des.read_f32();
let bottom_layers = des.read_u32();
let bottom_lift_distance = des.read_f32();
let bottom_lift_speed = des.read_f32();
let lift_distance = des.read_f32();
let lift_speed = des.read_f32();
let bottom_retract_distance = des.read_f32();
let bottom_retract_speed = des.read_f32();
let retract_distance = des.read_f32();
let retract_speed = des.read_f32();
let bottom_second_lift_distance = des.read_f32();
let bottom_second_lift_speed = des.read_f32();
let second_lift_distance = des.read_f32();
let second_lift_speed = des.read_f32();
let bottom_second_retract_distance = des.read_f32();
let bottom_second_retract_speed = des.read_f32();
let second_retract_distance = des.read_f32();
let second_retract_speed = des.read_f32();
let bottom_light_pwm = des.read_u16().min(255) as u8;
let light_pwm = des.read_u16().min(255) as u8;
let turn_off_time = des.read_f32_be();
let bottom_before_lift_time = des.read_f32_be();
let bottom_after_lift_time = des.read_f32_be();
let bottom_after_retract_time = des.read_f32_be();
let before_lift_time = des.read_f32_be();
let after_lift_time = des.read_f32_be();
let after_retract_time = des.read_f32_be();
let bottom_exposure_time = des.read_f32_be();
let bottom_layers = des.read_u32_be();
let bottom_lift_distance = des.read_f32_be();
let bottom_lift_speed = des.read_f32_be();
let lift_distance = des.read_f32_be();
let lift_speed = des.read_f32_be();
let bottom_retract_distance = des.read_f32_be();
let bottom_retract_speed = des.read_f32_be();
let retract_distance = des.read_f32_be();
let retract_speed = des.read_f32_be();
let bottom_second_lift_distance = des.read_f32_be();
let bottom_second_lift_speed = des.read_f32_be();
let second_lift_distance = des.read_f32_be();
let second_lift_speed = des.read_f32_be();
let bottom_second_retract_distance = des.read_f32_be();
let bottom_second_retract_speed = des.read_f32_be();
let second_retract_distance = des.read_f32_be();
let second_retract_speed = des.read_f32_be();
let bottom_light_pwm = des.read_u16_be().min(255) as u8;
let light_pwm = des.read_u16_be().min(255) as u8;
let advance_mode = des.read_bool();
let printing_time = des.read_u32();
let total_volume = des.read_f32();
let total_weight = des.read_f32();
let total_price = des.read_f32();
let printing_time = des.read_u32_be();
let total_volume = des.read_f32_be();
let total_weight = des.read_f32_be();
let total_price = des.read_f32_be();
let price_unit = des.read_sized_string();
ensure!(des.read_u32() == Self::SIZE as u32);
ensure!(des.read_u32_be() == Self::SIZE as u32);
let grey_scale_level = des.read_bool();
let transition_layers = des.read_u16();
let transition_layers = des.read_u16_be();
Ok(Self {
version,
@@ -349,7 +349,7 @@ impl ExposureDelayMode {
}
}
impl Debug for HeaderInfo {
impl Debug for Header {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("HeaderInfo")
.field("version", &self.version)

72
goo_format/src/layer_content.rs
View File

@@ -48,25 +48,25 @@ pub struct LayerContent {
impl LayerContent {
pub fn serialize<T: Serializer>(&self, ser: &mut T) {
ser.write_u16(self.pause as u16);
ser.write_f32(self.pause_position_z);
ser.write_f32(self.layer_position_z);
ser.write_f32(self.layer_exposure_time);
ser.write_f32(self.layer_off_time);
ser.write_f32(self.before_lift_time);
ser.write_f32(self.after_lift_time);
ser.write_f32(self.after_retract_time);
ser.write_f32(self.lift_distance);
ser.write_f32(self.lift_speed);
ser.write_f32(self.second_lift_distance);
ser.write_f32(self.second_lift_speed);
ser.write_f32(self.retract_distance);
ser.write_f32(self.retract_speed);
ser.write_f32(self.second_retract_distance);
ser.write_f32(self.second_retract_speed);
ser.write_u16(self.light_pwm as u16);
ser.write_u16_be(self.pause as u16);
ser.write_f32_be(self.pause_position_z);
ser.write_f32_be(self.layer_position_z);
ser.write_f32_be(self.layer_exposure_time);
ser.write_f32_be(self.layer_off_time);
ser.write_f32_be(self.before_lift_time);
ser.write_f32_be(self.after_lift_time);
ser.write_f32_be(self.after_retract_time);
ser.write_f32_be(self.lift_distance);
ser.write_f32_be(self.lift_speed);
ser.write_f32_be(self.second_lift_distance);
ser.write_f32_be(self.second_lift_speed);
ser.write_f32_be(self.retract_distance);
ser.write_f32_be(self.retract_speed);
ser.write_f32_be(self.second_retract_distance);
ser.write_f32_be(self.second_retract_speed);
ser.write_u16_be(self.light_pwm as u16);
ser.write_bytes(DELIMITER);
ser.write_u32(self.data.len() as u32 + 2);
ser.write_u32_be(self.data.len() as u32 + 2);
ser.write_bytes(&[0x55]);
ser.write_bytes(&self.data);
ser.write_u8(calculate_checksum(&self.data));
@@ -74,25 +74,25 @@ impl LayerContent {
}
pub fn deserialize(des: &mut Deserializer) -> Result<Self> {
let pause_flag = des.read_u16();
let pause_position_z = des.read_f32();
let layer_position_z = des.read_f32();
let layer_exposure_time = des.read_f32();
let layer_off_time = des.read_f32();
let before_lift_time = des.read_f32();
let after_lift_time = des.read_f32();
let after_retract_time = des.read_f32();
let lift_distance = des.read_f32();
let lift_speed = des.read_f32();
let second_lift_distance = des.read_f32();
let second_lift_speed = des.read_f32();
let retract_distance = des.read_f32();
let retract_speed = des.read_f32();
let second_retract_distance = des.read_f32();
let second_retract_speed = des.read_f32();
let light_pwm = des.read_u16().min(255) as u8;
let pause_flag = des.read_u16_be();
let pause_position_z = des.read_f32_be();
let layer_position_z = des.read_f32_be();
let layer_exposure_time = des.read_f32_be();
let layer_off_time = des.read_f32_be();
let before_lift_time = des.read_f32_be();
let after_lift_time = des.read_f32_be();
let after_retract_time = des.read_f32_be();
let lift_distance = des.read_f32_be();
let lift_speed = des.read_f32_be();
let second_lift_distance = des.read_f32_be();
let second_lift_speed = des.read_f32_be();
let retract_distance = des.read_f32_be();
let retract_speed = des.read_f32_be();
let second_retract_distance = des.read_f32_be();
let second_retract_speed = des.read_f32_be();
let light_pwm = des.read_u16_be().min(255) as u8;
ensure!(des.read_bytes(2) == DELIMITER);
let data_len = des.read_u32() as usize - 2;
let data_len = des.read_u32_be() as usize - 2;
ensure!(des.read_u8() == 0x55);
let data = des.read_bytes(data_len);
let checksum = des.read_u8();

4
goo_format/src/lib.rs
View File

@@ -3,13 +3,13 @@
mod default;
mod encoded_layer;
mod file;
mod header_info;
mod header;
mod layer_content;
mod preview_image;
pub use encoded_layer::{LayerDecoder, LayerEncoder};
pub use file::File;
pub use header_info::HeaderInfo;
pub use header::Header;
pub use layer_content::LayerContent;
pub use preview_image::PreviewImage;

4
goo_format/src/preview_image.rs
View File

@@ -48,7 +48,7 @@ impl<const WIDTH: usize, const HEIGHT: usize> PreviewImage<WIDTH, HEIGHT> {
pub fn serializes<T: Serializer>(&self, serializer: &mut T) {
for pixel in self.data.iter() {
serializer.write_u16(*pixel);
serializer.write_u16_be(*pixel);
}
}
@@ -56,7 +56,7 @@ impl<const WIDTH: usize, const HEIGHT: usize> PreviewImage<WIDTH, HEIGHT> {
let mut out = Self::empty();
for pixel in out.data.iter_mut() {
*pixel = deserializer.read_u16();
*pixel = deserializer.read_u16_be();
}
out

4
mslicer/src/app/mod.rs
View File

@@ -20,7 +20,9 @@ use tracing::{info, warn};
use crate::{
plugins::{
anti_alias, elephant_foot_fixer::{self}, PluginManager
anti_alias,
elephant_foot_fixer::{self},
PluginManager,
},
render::{camera::Camera, rendered_mesh::RenderedMesh},
ui::{

4
remote_send/src/mqtt/misc.rs
View File

@@ -15,7 +15,7 @@ pub trait MqttSerializer {
impl<'a> MqttDeserialize<'a> for Deserializer<'a> {
fn read_string(&mut self) -> Cow<'a, str> {
let len = self.read_u16();
let len = self.read_u16_be();
let buf = self.read_bytes(len as usize);
String::from_utf8_lossy(buf)
}
@@ -28,7 +28,7 @@ where
fn write_string(&mut self, data: &str) {
assert!(data.len() <= u16::MAX as usize);
let len = data.len() as u16;
self.write_u16(len);
self.write_u16_be(len);
self.write_bytes(data.as_bytes());
}
}

2
remote_send/src/mqtt/packets/connect.rs
View File

@@ -43,7 +43,7 @@ impl ConnectPacket {
let protocol_name = des.read_string().into_owned();
let protocol_level = des.read_u8();
let connect_flags = ConnectFlags::from_bits(des.read_u8()).unwrap();
let keep_alive = des.read_u16();
let keep_alive = des.read_u16_be();
let client_id = des.read_string().into_owned();
let will_topic = connect_flags

4
remote_send/src/mqtt/packets/publish.rs
View File

@@ -36,7 +36,7 @@ impl PublishPacket {
let topic = des.read_string().into_owned();
let packet_id = (flags.contains(PublishFlags::QOS1) || flags.contains(PublishFlags::QOS2))
.then(|| des.read_u16());
.then(|| des.read_u16_be());
let data = des
.read_bytes(packet.remaining_length as usize - des.pos())
.to_vec();
@@ -53,7 +53,7 @@ impl PublishPacket {
let mut ser = DynamicSerializer::new();
ser.write_string(&self.topic);
if self.flags.contains(PublishFlags::QOS1) || self.flags.contains(PublishFlags::QOS2) {
ser.write_u16(self.packet_id.unwrap());
ser.write_u16_be(self.packet_id.unwrap());
}
ser.write_bytes(&self.data);

4
remote_send/src/mqtt/packets/publish_ack.rs
View File

@@ -13,7 +13,7 @@ impl PublishAckPacket {
pub fn to_packet(&self) -> Packet {
let mut ser = DynamicSerializer::new();
ser.write_u16(self.packet_id);
ser.write_u16_be(self.packet_id);
let data = ser.into_inner();
Packet {
@@ -28,7 +28,7 @@ impl PublishAckPacket {
assert_eq!(packet.packet_type, Self::PACKET_TYPE);
let mut des = Deserializer::new(&packet.remaining_bytes);
let packet_id = des.read_u16();
let packet_id = des.read_u16_be();
Ok(Self { packet_id })
}

2
remote_send/src/mqtt/packets/subscribe.rs
View File

@@ -17,7 +17,7 @@ impl SubscribePacket {
pub fn from_packet(packet: &Packet) -> Result<Self> {
let mut des = Deserializer::new(&packet.remaining_bytes);
let packet_id = des.read_u16();
let packet_id = des.read_u16_be();
let mut filters = Vec::new();
while !des.is_empty() {
let topic = des.read_string().into_owned();

2
remote_send/src/mqtt/packets/subscribe_ack.rs
View File

@@ -20,7 +20,7 @@ impl SubscribeAckPacket {
pub fn to_packet(&self) -> Packet {
let mut ser = DynamicSerializer::new();
ser.write_u16(self.packet_id);
ser.write_u16_be(self.packet_id);
for return_code in &self.return_codes {
match return_code {
SubscribeReturnCode::Failure => ser.write_u8(0x80),