Merge remote-tracking branch 'upstream/master' into linux

Author: markjfisher

source/SmartPortOverSlip.cpp

@@ -99,10 +99,10 @@ void SmartPortOverSlip::handle_smartport_call()
 	WORD rts_location = static_cast<WORD>(mem[regs.sp + 1]) + static_cast<WORD>(mem[regs.sp + 2] << 8);
 	const BYTE command = mem[rts_location + 1];
 	const WORD cmd_list_loc = mem[rts_location + 2] + (mem[rts_location + 3] << 8);
-	// BYTE paramCount = mem[cmdListLoc]; // parameter count not used
+	const BYTE param_count = mem[cmd_list_loc];
 	const BYTE unit_number = mem[cmd_list_loc + 1];
 	const WORD sp_payload_loc = static_cast<WORD>(mem[cmd_list_loc + 2]) + static_cast<WORD>(mem[cmd_list_loc + 3] << 8);
-	const WORD params_loc = cmd_list_loc + 4;
+	const WORD params_loc = cmd_list_loc + 2; // we are ONLY skipping the count and destination bytes (used to skip the payload bytes, but that's only certain commands)
 
 	// LogFileOutput("SmartPortOverSlip processing SP command: 0x%02x, unit: "
 	//	"0x%02x, cmdList: 0x%04x, spPayLoad: 0x%04x, p1: 0x%02x\n",
@@ -119,8 +119,8 @@ void SmartPortOverSlip::handle_smartport_call()
 	memdirty[dirty_page_end] = 0xFF;
 
 
-	// Deal with unit 0, status 0 call to return device count, doesn't need connection details.
-	if (unit_number == 0 && mem[params_loc] == 0)
+	// Deal with status call (command == 0) with params unit == 0, status_code == 0 to return device count, doesn't need connection details.
+	if (command == 0 && unit_number == 0 && mem[params_loc + 2] == 0)
 	{
 		device_count(sp_payload_loc);
 		return;
@@ -142,19 +142,22 @@ void SmartPortOverSlip::handle_smartport_call()
 	switch (command)
 	{
 	case CMD_STATUS:
-		status_sp(device_id, connection, sp_payload_loc, mem[params_loc]);
+		status_sp(device_id, connection, sp_payload_loc, param_count, params_loc); // we are including the payload params and count part now too
 		break;
 	case CMD_READ_BLOCK:
-		read_block(device_id, connection, sp_payload_loc, params_loc);
+		// TODO: fix the fact params_loc has changed from +4 to +2
+		read_block(device_id, connection, sp_payload_loc, params_loc + 2);
 		break;
 	case CMD_WRITE_BLOCK:
-		write_block(device_id, connection, sp_payload_loc, params_loc);
+		// TODO: fix the fact params_loc has changed from +4 to +2
+		write_block(device_id, connection, sp_payload_loc, params_loc + 2);
 		break;
 	case CMD_FORMAT:
 		format(device_id, connection);
 		break;
 	case CMD_CONTROL:
-		control(device_id, connection, sp_payload_loc, mem[params_loc]);
+		// TODO: fix the fact params_loc has changed from +4 to +2
+		control(device_id, connection, sp_payload_loc, param_count, params_loc);
 		break;
 	case CMD_INIT:
 		init(device_id, connection);
@@ -166,10 +169,12 @@ void SmartPortOverSlip::handle_smartport_call()
 		close(device_id, connection);
 		break;
 	case CMD_READ:
-		read(device_id, connection, sp_payload_loc, params_loc);
+		// TODO: fix the fact params_loc has changed from +4 to +2
+		read(device_id, connection, sp_payload_loc, params_loc + 2);
 		break;
 	case CMD_WRITE:
-		write(device_id, connection, sp_payload_loc, params_loc);
+		// TODO: fix the fact params_loc has changed from +4 to +2
+		write(device_id, connection, sp_payload_loc, params_loc + 2);
 		break;
 	case CMD_RESET:
 		reset(device_id, connection);
@@ -480,9 +485,11 @@ void SmartPortOverSlip::write(const BYTE unit_number, Connection *connection, co
 	handle_simple_response<WriteResponse>(std::move(response));
 }
 
-void SmartPortOverSlip::status_sp(const BYTE unit_number, Connection *connection, const WORD sp_payload_loc, const BYTE status_code)
+void SmartPortOverSlip::status_sp(const BYTE unit_number, Connection *connection, const WORD sp_payload_loc, const BYTE params_count, const WORD params_loc)
 {
-	auto response = status(unit_number, connection, status_code);
+	const BYTE status_code = mem[params_loc + 2];
+	const BYTE network_unit = params_count > 3 ? mem[params_loc + 3] : 0;
+	auto response = status(unit_number, connection, status_code, network_unit);
 	handle_response<StatusResponse>(std::move(response), [sp_payload_loc](const StatusResponse *sr) {
 		const auto response_size = sr->get_data().size();
 		memcpy(mem + sp_payload_loc, sr->get_data().data(), response_size);
@@ -499,16 +506,16 @@ void SmartPortOverSlip::status_sp(const BYTE unit_number, Connection *connection
 	});
 }
 
-std::unique_ptr<Response> SmartPortOverSlip::status(const BYTE unit_number, Connection *connection, const BYTE status_code)
+std::unique_ptr<Response> SmartPortOverSlip::status(const BYTE unit_number, Connection *connection, const BYTE status_code, const BYTE network_unit)
 {
 	// see https://www.1000bit.it/support/manuali/apple/technotes/smpt/tn.smpt.2.html
-	const StatusRequest request(Requestor::next_request_number(), unit_number, status_code);
+	const StatusRequest request(Requestor::next_request_number(), unit_number, status_code, network_unit);
 	return Requestor::send_request(request, connection);
 }
 
 std::unique_ptr<StatusResponse> SmartPortOverSlip::status_pd(const BYTE unit_number, Connection *connection, const BYTE status_code)
 {
-	auto response = status(unit_number, connection, status_code);
+	auto response = status(unit_number, connection, status_code, 0);
 
 	// Cast the Response to a StatusResponse. We need to release ownership. As ChatGPT explains:
 	/*
@@ -519,13 +526,15 @@ std::unique_ptr<StatusResponse> SmartPortOverSlip::status_pd(const BYTE unit_num
 	return std::unique_ptr<StatusResponse>(static_cast<StatusResponse *>(response.release()));
 }
 
-void SmartPortOverSlip::control(const BYTE unit_number, Connection *connection, const WORD sp_payload_loc, const BYTE control_code)
+void SmartPortOverSlip::control(const BYTE unit_number, Connection *connection, const WORD sp_payload_loc, const BYTE params_count, const WORD params_loc)
 {
+	const BYTE control_code = mem[params_loc + 2]; // skip the payload location bytes
+	const BYTE network_unit = params_count > 3 ? mem[params_loc + 3] : 0;
 	const auto length = mem[sp_payload_loc] + (mem[sp_payload_loc + 1] << 8) + 2;
 	uint8_t *start_ptr = &mem[sp_payload_loc];
 	std::vector<uint8_t> payload(start_ptr, start_ptr + length);
 
-	const ControlRequest request(Requestor::next_request_number(), unit_number, control_code, payload);
+	const ControlRequest request(Requestor::next_request_number(), unit_number, control_code, network_unit, payload);
 	auto response = Requestor::send_request(request, connection);
 	handle_simple_response<ControlResponse>(std::move(response));
 }

source/SmartPortOverSlip.h

@@ -32,7 +32,7 @@ class SmartPortOverSlip : public Card
 	static void device_count(WORD sp_payload_loc);
 	void handle_smartport_call();
 	void handle_prodos_call();
-	void control(BYTE unit_number, Connection *connection, WORD sp_payload_loc, BYTE control_code);
+	void control(BYTE unit_number, Connection *connection, WORD sp_payload_loc, const BYTE params_count, const WORD params_loc);
 	void init(BYTE unit_number, Connection *connection);
 	void open(BYTE unit_number, Connection *connection);
 	void close(BYTE unit_number, Connection *connection);
@@ -43,9 +43,9 @@ class SmartPortOverSlip : public Card
 	void read(BYTE unit_number, Connection *connection, WORD sp_payload_loc, WORD params_loc);
 	void write(BYTE unit_number, Connection *connection, WORD sp_payload_loc, WORD params_loc);
 
-	std::unique_ptr<Response> status(BYTE unit_number, Connection *connection, BYTE status_code);
+	std::unique_ptr<Response> status(BYTE unit_number, Connection *connection, const BYTE status_code, const BYTE network_unit);
 	std::unique_ptr<StatusResponse> status_pd(const BYTE unit_number, Connection *connection, const BYTE status_code);
-	void status_sp(const BYTE unit_number, Connection *connection, const WORD sp_payload_loc, const BYTE status_code);
+	void status_sp(const BYTE unit_number, Connection *connection, const WORD sp_payload_loc, const BYTE params_count, const WORD params_loc);
 
 	void handle_prodos_status(uint8_t drive_num, std::pair<int, int> disk_devices);
 	void handle_prodos_read(uint8_t drive_num, std::pair<int, int> disk_devices);

source/devrelay/commands/Control.cpp

@@ -3,8 +3,8 @@
 #include <iostream>
 #include "Control.h"
 
-ControlRequest::ControlRequest(const uint8_t request_sequence_number, const uint8_t device_id, const uint8_t control_code, std::vector<uint8_t> &data)
-	: Request(request_sequence_number, CMD_CONTROL, device_id), control_code_(control_code), data_(std::move(data))
+ControlRequest::ControlRequest(const uint8_t request_sequence_number, const uint8_t device_id, const uint8_t control_code, const uint8_t network_unit, std::vector<uint8_t> &data)
+	: Request(request_sequence_number, CMD_CONTROL, device_id), control_code_(control_code), network_unit_(network_unit), data_(std::move(data))
 {
 }
 
@@ -15,6 +15,7 @@ std::vector<uint8_t> ControlRequest::serialize() const
 	request_data.push_back(this->get_command_number());
 	request_data.push_back(this->get_device_id());
 	request_data.push_back(this->get_control_code());
+	request_data.push_back(this->get_network_unit());
 	request_data.insert(request_data.end(), get_data().begin(), get_data().end());
 	return request_data;
 }
@@ -36,6 +37,7 @@ void ControlRequest::create_command(uint8_t* cmd_data) const
 	init_command(cmd_data);
 	// The control byte is at params[2], or cmd_data[4], it is then followed by the payload, see serialize above.
 	cmd_data[4] = control_code_;
+	cmd_data[5] = network_unit_;
 }
 
 void ControlRequest::copy_payload(uint8_t* data) const {

source/devrelay/commands/Control.h

@@ -9,19 +9,21 @@
 class ControlRequest : public Request
 {
 public:
-	ControlRequest(const uint8_t request_sequence_number, const uint8_t device_id, const uint8_t control_code, std::vector<uint8_t> &data);
+	ControlRequest(const uint8_t request_sequence_number, const uint8_t device_id, const uint8_t control_code, const uint8_t network_unit, std::vector<uint8_t> &data);
 	std::vector<uint8_t> serialize() const override;
 	std::unique_ptr<Response> deserialize(const std::vector<uint8_t> &data) const override;
 
 	const std::vector<uint8_t> &get_data() const { return data_; }
 	uint8_t get_control_code() const { return control_code_; }
+	uint8_t get_network_unit() const { return network_unit_; }
 	void create_command(uint8_t* output_data) const override;
 	void copy_payload(uint8_t* data) const override;
 	size_t payload_size() const override;
 	std::unique_ptr<Response> create_response(uint8_t source, uint8_t status, const uint8_t* data, uint16_t num) const override;
 
 private:
 	uint8_t control_code_;
+	uint8_t network_unit_;
 	std::vector<uint8_t> data_;
 };
 

source/devrelay/commands/Status.cpp

@@ -5,7 +5,7 @@
 
 #include "Status.h"
 
-StatusRequest::StatusRequest(const uint8_t request_sequence_number, const uint8_t device_id, const uint8_t status_code) : Request(request_sequence_number, CMD_STATUS, device_id), status_code_(status_code)
+StatusRequest::StatusRequest(const uint8_t request_sequence_number, const uint8_t device_id, const uint8_t status_code, const uint8_t network_unit) : Request(request_sequence_number, CMD_STATUS, device_id), status_code_(status_code), network_unit_(network_unit)
 {
 }
 
@@ -16,6 +16,7 @@ std::vector<uint8_t> StatusRequest::serialize() const
 	request_data.push_back(this->get_command_number());
 	request_data.push_back(this->get_device_id());
 	request_data.push_back(this->get_status_code());
+	request_data.push_back(this->get_network_unit());
 
 	return request_data;
 }
@@ -45,6 +46,7 @@ void StatusRequest::create_command(uint8_t* cmd_data) const
 {
 	init_command(cmd_data);
 	cmd_data[4] = status_code_;
+	cmd_data[5] = network_unit_;
 }
 
 std::unique_ptr<Response> StatusRequest::create_response(uint8_t source, uint8_t status, const uint8_t* data, uint16_t num) const

source/devrelay/commands/Status.h

@@ -9,11 +9,12 @@
 class StatusRequest : public Request
 {
 public:
-	StatusRequest(uint8_t request_sequence_number, uint8_t device_id, uint8_t status_code);
+	StatusRequest(uint8_t request_sequence_number, uint8_t device_id, uint8_t status_code, uint8_t network_unit);
 	virtual std::vector<uint8_t> serialize() const override;
 	std::unique_ptr<Response> deserialize(const std::vector<uint8_t> &data) const override;
 
 	uint8_t get_status_code() const { return status_code_; }
+	uint8_t get_network_unit() const { return network_unit_; }
 
 	void create_command(uint8_t* output_data) const override;
 	void copy_payload(uint8_t* data) const override {}
@@ -22,6 +23,7 @@ class StatusRequest : public Request
 
 private:
 	uint8_t status_code_;
+	uint8_t network_unit_;
 };
 
 

source/devrelay/service/Listener.cpp

@@ -294,7 +294,7 @@ std::pair<int, int> Listener::first_two_disk_devices(std::function<bool(const st
 		const uint8_t unit_number = id_and_connection.first;
 
 		// DIB request to get information block. We need the device id the target understands here, not the unit_number from the ids maintained by host
-		const StatusRequest request(Requestor::next_request_number(), id_and_connection.first, 3);
+		const StatusRequest request(Requestor::next_request_number(), id_and_connection.first, 3, 0); // no network unit here
 
 		std::unique_ptr<Response> response = Requestor::send_request(request, id_and_connection.second);
 

source/devrelay/types/Request.cpp

@@ -35,14 +35,16 @@ std::unique_ptr<Request> Request::from_packet(const std::vector<uint8_t>& packet
   switch(command) {
 
   case CMD_STATUS: {
-    request = std::make_unique<StatusRequest>(packet[0], packet[2], packet[3]);
+    uint8_t network_unit = packet.size() > 4 ? packet[4] : 0;
+    request = std::make_unique<StatusRequest>(packet[0], packet[2], packet[3], network_unit);
     break;
   }
 
   case CMD_CONTROL: {
-    // +6 = 3 for "header", 1 for control code, 2 for length bytes we need to skip
-    std::vector<uint8_t> payload(packet.begin() + 6, packet.end());
-    request = std::make_unique<ControlRequest>(packet[0], packet[2], packet[3], payload);
+    uint8_t network_unit = packet.size() > 4 ? packet[4] : 0;
+    // +7 = 3 for "header", 1 for control code, 1 for network unit, 2 for length bytes we need to skip
+    std::vector<uint8_t> payload(packet.begin() + 7, packet.end());
+    request = std::make_unique<ControlRequest>(packet[0], packet[2], packet[3], network_unit, payload);
     break;
   }