Revert block-size values in devrelay to fixed 512 byte size

markjfisher · markjfisher · commit fb92976da296 · 2024-10-20T13:53:47.000+01:00
diff --git a/lib/devrelay/commands/ReadBlock.cpp b/lib/devrelay/commands/ReadBlock.cpp
@@ -2,28 +2,26 @@
 
 #include "ReadBlock.h"
 
-ReadBlockRequest::ReadBlockRequest(const uint8_t request_sequence_number, const uint8_t device_id, uint16_t block_size) : Request(request_sequence_number, CMD_READ_BLOCK, device_id), block_number_{}, block_size_(block_size) {}
+ReadBlockRequest::ReadBlockRequest(const uint8_t request_sequence_number, const uint8_t device_id) : Request(request_sequence_number, CMD_READ_BLOCK, device_id), block_number_{} {}
 
 std::vector<uint8_t> ReadBlockRequest::serialize() const
 {
 	std::vector<uint8_t> request_data;
 	request_data.push_back(this->get_request_sequence_number());
 	request_data.push_back(this->get_command_number());
 	request_data.push_back(this->get_device_id());
-	request_data.push_back(this->get_block_size() & 0xFF);
-	request_data.push_back((this->get_block_size() >> 8) & 0xFF);
 	request_data.insert(request_data.end(), block_number_.begin(), block_number_.end());
 	return request_data;
 }
 
 std::unique_ptr<Response> ReadBlockRequest::deserialize(const std::vector<uint8_t> &data) const
 {
-	if (data.size() != (block_size_ + 2))
+	if (data.size() != (512 + 2)) // 2 additional bytes are added to the block
 	{
 		throw std::runtime_error("Not enough data to deserialize ReadBlockResponse");
 	}
 
-	auto response = std::make_unique<ReadBlockResponse>(data[0], data[1], block_size_);
+	auto response = std::make_unique<ReadBlockResponse>(data[0], data[1]);
 	if (response->get_status() == 0)
 	{
 		response->set_block_data(data.begin() + 2, data.end());
@@ -33,8 +31,6 @@ std::unique_ptr<Response> ReadBlockRequest::deserialize(const std::vector<uint8_
 
 const std::array<uint8_t, 3> &ReadBlockRequest::get_block_number() const { return block_number_; }
 
-const uint16_t ReadBlockRequest::get_block_size() const { return block_size_; }
-
 void ReadBlockRequest::set_block_number_from_ptr(const uint8_t *ptr, const size_t offset) { std::copy_n(ptr + offset, block_number_.size(), block_number_.begin()); }
 
 void ReadBlockRequest::set_block_number_from_bytes(uint8_t l, uint8_t m, uint8_t h)
@@ -50,7 +46,7 @@ void ReadBlockRequest::create_command(uint8_t *cmd_data) const {
 }
 
 std::unique_ptr<Response> ReadBlockRequest::create_response(uint8_t source, uint8_t status, const uint8_t *data, uint16_t num) const {
-	std::unique_ptr<ReadBlockResponse> response = std::make_unique<ReadBlockResponse>(get_request_sequence_number(), status, num);
+	std::unique_ptr<ReadBlockResponse> response = std::make_unique<ReadBlockResponse>(get_request_sequence_number(), status);
 	// Copy the return data if the status is OK
 	if (status == 0) {
 		std::vector<uint8_t> data_vector(data, data + num);
@@ -60,9 +56,7 @@ std::unique_ptr<Response> ReadBlockRequest::create_response(uint8_t source, uint
 }
 
 
-ReadBlockResponse::ReadBlockResponse(const uint8_t request_sequence_number, const uint8_t status, uint16_t block_size) : Response(request_sequence_number, status), block_size_(block_size) {
-	block_data_.resize(block_size_);
-}
+ReadBlockResponse::ReadBlockResponse(const uint8_t request_sequence_number, const uint8_t status) : Response(request_sequence_number, status), block_data_{} {}
 
 std::vector<uint8_t> ReadBlockResponse::serialize() const
 {
@@ -78,11 +72,8 @@ void ReadBlockResponse::set_block_data(std::vector<uint8_t>::const_iterator begi
 	std::copy(begin, end, block_data_.begin()); // NOLINT(performance-unnecessary-value-param)
 }
 
-const std::vector<uint8_t>& ReadBlockResponse::get_block_data() const {
+const std::array<uint8_t, 512>& ReadBlockResponse::get_block_data() const {
 	return block_data_;
 }
 
-const uint16_t ReadBlockResponse::get_block_size() const { return block_size_; }
-
-
 #endif
diff --git a/lib/devrelay/commands/ReadBlock.h b/lib/devrelay/commands/ReadBlock.h
@@ -11,13 +11,12 @@
 class ReadBlockRequest : public Request
 {
 public:
-	ReadBlockRequest(uint8_t request_sequence_number, uint8_t device_id, uint16_t block_size);
+	ReadBlockRequest(uint8_t request_sequence_number, uint8_t device_id);
 	std::vector<uint8_t> serialize() const override;
 	std::unique_ptr<Response> deserialize(const std::vector<uint8_t> &data) const override;
 	const std::array<uint8_t, 3> &get_block_number() const;
 	void set_block_number_from_ptr(const uint8_t *ptr, size_t offset);
 	void set_block_number_from_bytes(uint8_t l, uint8_t m, uint8_t h);
-	const uint16_t get_block_size() const;
 
 	void create_command(uint8_t *output_data) const override;
 	void copy_payload(uint8_t *data) const override {}
@@ -26,21 +25,18 @@ class ReadBlockRequest : public Request
 
 private:
 	std::array<uint8_t, 3> block_number_;
-	uint16_t block_size_;
 };
 
 
 class ReadBlockResponse : public Response
 {
 public:
-	explicit ReadBlockResponse(uint8_t request_sequence_number, uint8_t status, uint16_t block_size);
+	explicit ReadBlockResponse(uint8_t request_sequence_number, uint8_t status);
 	std::vector<uint8_t> serialize() const override;
 
 	void set_block_data(std::vector<uint8_t>::const_iterator begin, std::vector<uint8_t>::const_iterator end);
-	const std::vector<uint8_t>& get_block_data() const;
-	const uint16_t get_block_size() const;
+	const std::array<uint8_t, 512>& get_block_data() const;
 
 private:
-	std::vector<uint8_t> block_data_;
-	uint16_t block_size_;
+	std::array<uint8_t, 512> block_data_;
 };
diff --git a/lib/devrelay/commands/WriteBlock.cpp b/lib/devrelay/commands/WriteBlock.cpp
@@ -3,16 +3,14 @@
 #include "WriteBlock.h"
 #include <cstdint>
 
-WriteBlockRequest::WriteBlockRequest(const uint8_t request_sequence_number, const uint8_t device_id, const uint16_t block_size) : Request(request_sequence_number, CMD_WRITE_BLOCK, device_id), block_number_{}, block_data_{}, block_size_(block_size) {}
+WriteBlockRequest::WriteBlockRequest(const uint8_t request_sequence_number, const uint8_t device_id) : Request(request_sequence_number, CMD_WRITE_BLOCK, device_id), block_number_{}, block_data_{} {}
 
 std::vector<uint8_t> WriteBlockRequest::serialize() const
 {
 	std::vector<uint8_t> request_data;
 	request_data.push_back(this->get_request_sequence_number());
 	request_data.push_back(this->get_command_number());
 	request_data.push_back(this->get_device_id());
-	request_data.push_back(this->get_block_size() & 0xFF);
-	request_data.push_back((this->get_block_size() >> 8) & 0xFF);
 	request_data.insert(request_data.end(), block_number_.begin(), block_number_.end());
 	request_data.insert(request_data.end(), block_data_.begin(), block_data_.end());
 
@@ -32,9 +30,7 @@ std::unique_ptr<Response> WriteBlockRequest::deserialize(const std::vector<uint8
 
 const std::array<uint8_t, 3> &WriteBlockRequest::get_block_number() const { return block_number_; }
 
-const std::vector<uint8_t> &WriteBlockRequest::get_block_data() const { return block_data_; }
-
-const uint16_t WriteBlockRequest::get_block_size() const { return block_size_; }
+const std::array<uint8_t, 512> &WriteBlockRequest::get_block_data() const { return block_data_; }
 
 void WriteBlockRequest::set_block_number_from_ptr(const uint8_t *ptr, const size_t offset) { std::copy_n(ptr + offset, block_number_.size(), block_number_.begin()); }
 
diff --git a/lib/devrelay/commands/WriteBlock.h b/lib/devrelay/commands/WriteBlock.h
@@ -11,16 +11,15 @@
 class WriteBlockRequest : public Request
 {
 public:
-	WriteBlockRequest(uint8_t request_sequence_number, uint8_t device_id, uint16_t block_size);
+	WriteBlockRequest(uint8_t request_sequence_number, uint8_t device_id);
 	std::vector<uint8_t> serialize() const override;
 	std::unique_ptr<Response> deserialize(const std::vector<uint8_t> &data) const override;
 	const std::array<uint8_t, 3> &get_block_number() const;
 	void set_block_number_from_ptr(const uint8_t *ptr, size_t offset);
 
-	const std::vector<uint8_t> &get_block_data() const;
+	const std::array<uint8_t, 512> &get_block_data() const;
 	void set_block_data_from_ptr(const uint8_t *ptr, size_t offset);
 	void set_block_number_from_bytes(uint8_t l, uint8_t m, uint8_t h);
-	const uint16_t get_block_size() const;
 
 	void create_command(uint8_t *output_data) const override;
 	void copy_payload(uint8_t *data) const override;
@@ -29,8 +28,7 @@ class WriteBlockRequest : public Request
 
 private:
 	std::array<uint8_t, 3> block_number_;
-	std::vector<uint8_t> block_data_;
-	uint16_t block_size_;
+	std::array<uint8_t, 512> block_data_;
 };
 
 class WriteBlockResponse : public Response
diff --git a/lib/devrelay/types/Request.cpp b/lib/devrelay/types/Request.cpp
@@ -49,18 +49,16 @@ std::unique_ptr<Request> Request::from_packet(const std::vector<uint8_t>& packet
   }
 
   case CMD_READ_BLOCK: {
-    auto bs = (packet[4] << 8) | packet[3];
-    auto readBlockRequest = std::make_unique<ReadBlockRequest>(packet[0], packet[2], bs);
-    readBlockRequest->set_block_number_from_ptr(packet.data(), 5);
+    auto readBlockRequest = std::make_unique<ReadBlockRequest>(packet[0], packet[2]);
+    readBlockRequest->set_block_number_from_ptr(packet.data(), 3);
     request = std::move(readBlockRequest);
     break;
   }
 
   case CMD_WRITE_BLOCK: {
-    auto bs = (packet[4] << 8) | packet[3];
-    auto writeBlockRequest = std::make_unique<WriteBlockRequest>(packet[0], packet[2], bs);
-    writeBlockRequest->set_block_number_from_ptr(packet.data(), 5);
-    writeBlockRequest->set_block_data_from_ptr(packet.data(), 8);
+    auto writeBlockRequest = std::make_unique<WriteBlockRequest>(packet[0], packet[2]);
+    writeBlockRequest->set_block_number_from_ptr(packet.data(), 3);
+    writeBlockRequest->set_block_data_from_ptr(packet.data(), 6);
 		request = std::move(writeBlockRequest);
     break;
   }

Original file line number	Diff line number	Diff line change
`@@ -2,28 +2,26 @@`
`2`	`2`
`3`	`3`	`#include "ReadBlock.h"`
`4`	`4`
`5`		`-ReadBlockRequest::ReadBlockRequest(const uint8_t request_sequence_number, const uint8_t device_id, uint16_t block_size) : Request(request_sequence_number, CMD_READ_BLOCK, device_id), block_number_{}, block_size_(block_size) {}`
	`5`	`+ReadBlockRequest::ReadBlockRequest(const uint8_t request_sequence_number, const uint8_t device_id) : Request(request_sequence_number, CMD_READ_BLOCK, device_id), block_number_{} {}`
`6`	`6`
`7`	`7`	`std::vector<uint8_t> ReadBlockRequest::serialize() const`
`8`	`8`	`{`
`9`	`9`	`std::vector<uint8_t> request_data;`
`10`	`10`	`request_data.push_back(this->get_request_sequence_number());`
`11`	`11`	`request_data.push_back(this->get_command_number());`
`12`	`12`	`request_data.push_back(this->get_device_id());`
`13`		`- request_data.push_back(this->get_block_size() & 0xFF);`
`14`		`- request_data.push_back((this->get_block_size() >> 8) & 0xFF);`
`15`	`13`	`request_data.insert(request_data.end(), block_number_.begin(), block_number_.end());`
`16`	`14`	`return request_data;`
`17`	`15`	`}`
`18`	`16`
`19`	`17`	`std::unique_ptr<Response> ReadBlockRequest::deserialize(const std::vector<uint8_t> &data) const`
`20`	`18`	`{`
`21`		`- if (data.size() != (block_size_ + 2))`
	`19`	`+ if (data.size() != (512 + 2)) // 2 additional bytes are added to the block`
`22`	`20`	`{`
`23`	`21`	`throw std::runtime_error("Not enough data to deserialize ReadBlockResponse");`
`24`	`22`	`}`
`25`	`23`
`26`		`- auto response = std::make_unique<ReadBlockResponse>(data[0], data[1], block_size_);`
	`24`	`+ auto response = std::make_unique<ReadBlockResponse>(data[0], data[1]);`
`27`	`25`	`if (response->get_status() == 0)`
`28`	`26`	`{`
`29`	`27`	`response->set_block_data(data.begin() + 2, data.end());`
`@@ -33,8 +31,6 @@ std::unique_ptr<Response> ReadBlockRequest::deserialize(const std::vector<uint8_`
`33`	`31`
`34`	`32`	`const std::array<uint8_t, 3> &ReadBlockRequest::get_block_number() const { return block_number_; }`
`35`	`33`
`36`		`-const uint16_t ReadBlockRequest::get_block_size() const { return block_size_; }`
`37`		`-`
`38`	`34`	`void ReadBlockRequest::set_block_number_from_ptr(const uint8_t *ptr, const size_t offset) { std::copy_n(ptr + offset, block_number_.size(), block_number_.begin()); }`
`39`	`35`
`40`	`36`	`void ReadBlockRequest::set_block_number_from_bytes(uint8_t l, uint8_t m, uint8_t h)`
`@@ -50,7 +46,7 @@ void ReadBlockRequest::create_command(uint8_t *cmd_data) const {`
`50`	`46`	`}`
`51`	`47`
`52`	`48`	`std::unique_ptr<Response> ReadBlockRequest::create_response(uint8_t source, uint8_t status, const uint8_t *data, uint16_t num) const {`
`53`		`- std::unique_ptr<ReadBlockResponse> response = std::make_unique<ReadBlockResponse>(get_request_sequence_number(), status, num);`
	`49`	`+ std::unique_ptr<ReadBlockResponse> response = std::make_unique<ReadBlockResponse>(get_request_sequence_number(), status);`
`54`	`50`	`// Copy the return data if the status is OK`
`55`	`51`	`if (status == 0) {`
`56`	`52`	`std::vector<uint8_t> data_vector(data, data + num);`
`@@ -60,9 +56,7 @@ std::unique_ptr<Response> ReadBlockRequest::create_response(uint8_t source, uint`
`60`	`56`	`}`
`61`	`57`
`62`	`58`
`63`		`-ReadBlockResponse::ReadBlockResponse(const uint8_t request_sequence_number, const uint8_t status, uint16_t block_size) : Response(request_sequence_number, status), block_size_(block_size) {`
`64`		`- block_data_.resize(block_size_);`
`65`		`-}`
	`59`	`+ReadBlockResponse::ReadBlockResponse(const uint8_t request_sequence_number, const uint8_t status) : Response(request_sequence_number, status), block_data_{} {}`
`66`	`60`
`67`	`61`	`std::vector<uint8_t> ReadBlockResponse::serialize() const`
`68`	`62`	`{`
`@@ -78,11 +72,8 @@ void ReadBlockResponse::set_block_data(std::vector<uint8_t>::const_iterator begi`
`78`	`72`	`std::copy(begin, end, block_data_.begin()); // NOLINT(performance-unnecessary-value-param)`
`79`	`73`	`}`
`80`	`74`
`81`		`-const std::vector<uint8_t>& ReadBlockResponse::get_block_data() const {`
	`75`	`+const std::array<uint8_t, 512>& ReadBlockResponse::get_block_data() const {`
`82`	`76`	`return block_data_;`
`83`	`77`	`}`
`84`	`78`
`85`		`-const uint16_t ReadBlockResponse::get_block_size() const { return block_size_; }`
`86`		`-`
`87`		`-`
`88`	`79`	`#endif`