Add SPoverSLIP to linux

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.13)
 
-project(applewin HOMEPAGE_URL "https://github.com/audetto/AppleWin")
+project(applewin HOMEPAGE_URL "https://github.com/FujiNetWIFI/AppleWin")
 
 option(BUILD_APPLEN   "build ncurses frontend")
 option(BUILD_QAPPLE   "build Qt5 frontend")

source/.clang-format

@@ -0,0 +1,5 @@
+BasedOnStyle: LLVM
+ColumnLimit: 160
+BreakBeforeBraces: Allman
+AllowShortBlocksOnASingleLine: true
+AlwaysBreakAfterReturnType: None

source/CMakeLists.txt

@@ -94,6 +94,7 @@ set(SOURCE_FILES
   Utilities.cpp
   FrameBase.cpp
   CmdLine.cpp
+  SmartPortOverSlip.cpp
 
   Configuration/PropertySheetHelper.cpp
   Configuration/Config.cpp
@@ -119,6 +120,36 @@ set(SOURCE_FILES
   linux/duplicates/SNESMAX.cpp
   linux/duplicates/Keyboard.cpp
 
+  SPoverSLIP/CloseRequest.cpp
+  SPoverSLIP/CloseResponse.cpp
+  SPoverSLIP/Connection.cpp
+  SPoverSLIP/ControlRequest.cpp
+  SPoverSLIP/ControlResponse.cpp
+  SPoverSLIP/FormatRequest.cpp
+  SPoverSLIP/FormatResponse.cpp
+  SPoverSLIP/InitRequest.cpp
+  SPoverSLIP/InitResponse.cpp
+  SPoverSLIP/Listener.cpp
+  SPoverSLIP/OpenRequest.cpp
+  SPoverSLIP/OpenResponse.cpp
+  SPoverSLIP/ReadBlockRequest.cpp
+  SPoverSLIP/ReadBlockResponse.cpp
+  SPoverSLIP/ReadRequest.cpp
+  SPoverSLIP/ReadResponse.cpp
+  SPoverSLIP/Request.cpp
+  SPoverSLIP/Requestor.cpp
+  SPoverSLIP/ResetRequest.cpp
+  SPoverSLIP/ResetResponse.cpp
+  SPoverSLIP/Response.cpp
+  SPoverSLIP/SLIP.cpp
+  SPoverSLIP/StatusRequest.cpp
+  SPoverSLIP/StatusResponse.cpp
+  SPoverSLIP/TCPConnection.cpp
+  SPoverSLIP/WriteBlockRequest.cpp
+  SPoverSLIP/WriteBlockResponse.cpp
+  SPoverSLIP/WriteRequest.cpp
+  SPoverSLIP/WriteResponse.cpp
+
   Z80VICE/z80.cpp
   Z80VICE/z80mem.cpp
   Z80VICE/daa.cpp
@@ -178,6 +209,7 @@ set(HEADER_FILES
   FrameBase.h
   FourPlay.h
   SNESMAX.h
+  SmartPortOverSlip.h
 
   Common.h
   DiskDefs.h
@@ -215,6 +247,39 @@ set(HEADER_FILES
   linux/network/slirp2.h
   linux/network/portfwds.h
 
+  SPoverSLIP/CloseRequest.h
+  SPoverSLIP/CloseResponse.h
+  SPoverSLIP/Connection.h
+  SPoverSLIP/ControlRequest.h
+  SPoverSLIP/ControlResponse.h
+  SPoverSLIP/FormatRequest.h
+  SPoverSLIP/FormatResponse.h
+  SPoverSLIP/InitRequest.h
+  SPoverSLIP/InitResponse.h
+  SPoverSLIP/Listener.h
+  SPoverSLIP/OpenRequest.h
+  SPoverSLIP/OpenResponse.h
+  SPoverSLIP/Packet.h
+  SPoverSLIP/ReadBlockRequest.h
+  SPoverSLIP/ReadBlockResponse.h
+  SPoverSLIP/ReadRequest.h
+  SPoverSLIP/ReadResponse.h
+  SPoverSLIP/Request.h
+  SPoverSLIP/Requestor.h
+  SPoverSLIP/ResetRequest.h
+  SPoverSLIP/ResetResponse.h
+  SPoverSLIP/Response.h
+  SPoverSLIP/SLIP.h
+  SPoverSLIP/SmartPortCodes.h
+  SPoverSLIP/SPoSLIP.h
+  SPoverSLIP/StatusRequest.h
+  SPoverSLIP/StatusResponse.h
+  SPoverSLIP/TCPConnection.h
+  SPoverSLIP/WriteBlockRequest.h
+  SPoverSLIP/WriteBlockResponse.h
+  SPoverSLIP/WriteRequest.h
+  SPoverSLIP/WriteResponse.h
+
   Z80VICE/z80.h
   Z80VICE/z80mem.h
   Z80VICE/z80regs.h

source/CardManager.cpp

@@ -27,6 +27,7 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
  */
 
+#include "Log.h"
 #include "StdAfx.h"
 
 #include "CardManager.h"
@@ -117,6 +118,7 @@ void CardManager::InsertInternal(UINT slot, SS_CARDTYPE type)
 		m_slot[slot] = new Uthernet2(slot);
 		break;
 	case CT_SmartPortOverSlip:
+    LogOutput("Inserting SP over SLIP in slot %d\n", slot);
 		m_slot[slot] = new SmartPortOverSlip(slot);
 		break;
 	case CT_LanguageCard:

source/SPoverSLIP/CloseRequest.cpp

@@ -1,29 +1,26 @@
-#include "stdafx.h"
 #include "CloseRequest.h"
 
 #include "CloseResponse.h"
 #include "SmartPortCodes.h"
 
-
-CloseRequest::CloseRequest(const uint8_t request_sequence_number, const uint8_t sp_unit)
-	: Request(request_sequence_number, SP_CLOSE, sp_unit) {}
+CloseRequest::CloseRequest(const uint8_t request_sequence_number, const uint8_t sp_unit) : Request(request_sequence_number, SP_CLOSE, sp_unit) {}
 
 std::vector<uint8_t> CloseRequest::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_sp_unit());
-	return request_data;
+  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_sp_unit());
+  return request_data;
 }
 
-std::unique_ptr<Response> CloseRequest::deserialize(const std::vector<uint8_t>& data) const
+std::unique_ptr<Response> CloseRequest::deserialize(const std::vector<uint8_t> &data) const
 {
-	if (data.size() < 2)
-	{
-		throw std::runtime_error("Not enough data to deserialize CloseResponse");
-	}
+  if (data.size() < 2)
+  {
+    throw std::runtime_error("Not enough data to deserialize CloseResponse");
+  }
 
-	auto response = std::make_unique<CloseResponse>(data[0], data[1]);
-	return response;
+  auto response = std::make_unique<CloseResponse>(data[0], data[1]);
+  return response;
 }

source/SPoverSLIP/CloseRequest.h

@@ -1,15 +1,15 @@
 #pragma once
 
-#include <vector>
 #include <cstdint>
+#include <vector>
 
 #include "Request.h"
 #include "Response.h"
 
 class CloseRequest : public Request
 {
 public:
-	CloseRequest(uint8_t request_sequence_number, uint8_t sp_unit);
-	std::vector<uint8_t> serialize() const override;
-	std::unique_ptr<Response> deserialize(const std::vector<uint8_t>& data) const override;
+  CloseRequest(uint8_t request_sequence_number, uint8_t sp_unit);
+  std::vector<uint8_t> serialize() const override;
+  std::unique_ptr<Response> deserialize(const std::vector<uint8_t> &data) const override;
 };

source/SPoverSLIP/CloseResponse.cpp

@@ -1,12 +1,11 @@
-#include "stdafx.h"
 #include "CloseResponse.h"
 
 CloseResponse::CloseResponse(const uint8_t request_sequence_number, const uint8_t status) : Response(request_sequence_number, status) {}
 
 std::vector<uint8_t> CloseResponse::serialize() const
 {
-	std::vector<uint8_t> data;
-	data.push_back(this->get_request_sequence_number());
-	data.push_back(this->get_status());
-	return data;
+  std::vector<uint8_t> data;
+  data.push_back(this->get_request_sequence_number());
+  data.push_back(this->get_status());
+  return data;
 }

source/SPoverSLIP/CloseResponse.h

@@ -4,6 +4,6 @@
 class CloseResponse : public Response
 {
 public:
-	explicit CloseResponse(uint8_t request_sequence_number, uint8_t status);
-	std::vector<uint8_t> serialize() const override;
+  explicit CloseResponse(uint8_t request_sequence_number, uint8_t status);
+  std::vector<uint8_t> serialize() const override;
 };

source/SPoverSLIP/Connection.cpp

@@ -1,39 +1,39 @@
-#include "StdAfx.h"
-
-#include <vector>
+#include "Connection.h"
+#include <condition_variable>
 #include <cstdint>
 #include <mutex>
-#include <condition_variable>
-#include "Connection.h"
+#include <stdexcept>
+#include <vector>
 
 std::vector<uint8_t> Connection::wait_for_response(uint8_t request_id, std::chrono::seconds timeout)
 {
-	std::unique_lock<std::mutex> lock(responses_mutex_);
-	// mutex is unlocked as it goes into a wait, so then the inserting thread can add to map, and this can then pick it up when notified, or timeout.
-	if (!response_cv_.wait_for(lock, timeout, [this, request_id]() { return responses_.count(request_id) > 0; }))
-	{
-		throw std::runtime_error("Timeout waiting for response");
-	}
-	std::vector<uint8_t> response_data = responses_[request_id];
-	responses_.erase(request_id);
-	return response_data;
+  std::unique_lock<std::mutex> lock(responses_mutex_);
+  // mutex is unlocked as it goes into a wait, so then the inserting thread can
+  // add to map, and this can then pick it up when notified, or timeout.
+  if (!response_cv_.wait_for(lock, timeout, [this, request_id]() { return responses_.count(request_id) > 0; }))
+  {
+    throw std::runtime_error("Timeout waiting for response");
+  }
+  std::vector<uint8_t> response_data = responses_[request_id];
+  responses_.erase(request_id);
+  return response_data;
 }
 
 std::vector<uint8_t> Connection::wait_for_request()
 {
-	std::unique_lock<std::mutex> lock(responses_mutex_);
-	response_cv_.wait(lock, [this]() { return !responses_.empty(); });
-	const auto it = responses_.begin();
-	std::vector<uint8_t> request_data = it->second;
-	responses_.erase(it);
+  std::unique_lock<std::mutex> lock(responses_mutex_);
+  response_cv_.wait(lock, [this]() { return !responses_.empty(); });
+  const auto it = responses_.begin();
+  std::vector<uint8_t> request_data = it->second;
+  responses_.erase(it);
 
-	return request_data;
+  return request_data;
 }
 
 void Connection::join()
 {
-	if (reading_thread_.joinable())
-	{
-		reading_thread_.join();
-	}
+  if (reading_thread_.joinable())
+  {
+    reading_thread_.join();
+  }
 }

source/SPoverSLIP/Connection.h

@@ -1,36 +1,37 @@
 #pragma once
 
-#include <vector>
 #include <atomic>
-#include <map>
+#include <chrono>
+#include <condition_variable>
 #include <cstdint>
+#include <map>
 #include <mutex>
-#include <condition_variable>
-#include <chrono>
+#include <thread>
+#include <vector>
 
 class Connection
 {
 public:
-	virtual ~Connection() = default;
-	virtual void send_data(const std::vector<uint8_t>& data) = 0;
+  virtual ~Connection() = default;
+  virtual void send_data(const std::vector<uint8_t> &data) = 0;
 
-	virtual void create_read_channel() = 0;
+  virtual void create_read_channel() = 0;
 
-	bool is_connected() const { return is_connected_; }
-	void set_is_connected(const bool is_connected) { is_connected_ = is_connected; }
+  bool is_connected() const { return is_connected_; }
+  void set_is_connected(const bool is_connected) { is_connected_ = is_connected; }
 
-	std::vector<uint8_t> wait_for_response(uint8_t request_id, std::chrono::seconds timeout);
-	std::vector<uint8_t> wait_for_request();
+  std::vector<uint8_t> wait_for_response(uint8_t request_id, std::chrono::seconds timeout);
+  std::vector<uint8_t> wait_for_request();
 
-	void join();
+  void join();
 
 private:
-	std::atomic<bool> is_connected_{false};
+  std::atomic<bool> is_connected_{false};
 
 protected:
-	std::map<uint8_t, std::vector<uint8_t>> responses_;
-	std::thread reading_thread_;
+  std::map<uint8_t, std::vector<uint8_t>> responses_;
+  std::thread reading_thread_;
 
-	std::mutex responses_mutex_;
-	std::condition_variable response_cv_;
+  std::mutex responses_mutex_;
+  std::condition_variable response_cv_;
 };

source/SPoverSLIP/ControlRequest.cpp

@@ -1,31 +1,31 @@
-#include "stdafx.h"
 #include "ControlRequest.h"
 
 #include "ControlResponse.h"
 #include "SmartPortCodes.h"
 
-
-ControlRequest::ControlRequest(const uint8_t request_sequence_number, const uint8_t sp_unit, const uint8_t control_code, std::vector<uint8_t>& data)
-	: Request(request_sequence_number, SP_CONTROL, sp_unit), control_code_(control_code), data_(std::move(data)) {}
+ControlRequest::ControlRequest(const uint8_t request_sequence_number, const uint8_t sp_unit, const uint8_t control_code, std::vector<uint8_t> &data)
+    : Request(request_sequence_number, SP_CONTROL, sp_unit), control_code_(control_code), data_(std::move(data))
+{
+}
 
 std::vector<uint8_t> ControlRequest::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_sp_unit());
-	request_data.push_back(this->get_control_code());
-	request_data.insert(request_data.end(), get_data().begin(), get_data().end());
-	return request_data;
+  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_sp_unit());
+  request_data.push_back(this->get_control_code());
+  request_data.insert(request_data.end(), get_data().begin(), get_data().end());
+  return request_data;
 }
 
-std::unique_ptr<Response> ControlRequest::deserialize(const std::vector<uint8_t>& data) const
+std::unique_ptr<Response> ControlRequest::deserialize(const std::vector<uint8_t> &data) const
 {
-	if (data.size() < 2)
-	{
-		throw std::runtime_error("Not enough data to deserialize ControlResponse");
-	}
+  if (data.size() < 2)
+  {
+    throw std::runtime_error("Not enough data to deserialize ControlResponse");
+  }
 
-	auto response = std::make_unique<ControlResponse>(data[0], data[1]);
-	return response;
+  auto response = std::make_unique<ControlResponse>(data[0], data[1]);
+  return response;
 }