Introduce protocol versions.

We're now sending serialized Gameboy state, so it's important that both
emulators have the same protocol (and serialization) version.

Author: trekawek

controller/src/main/java/eu/rekawek/coffeegb/controller/network/Connection.kt

@@ -8,17 +8,19 @@ import eu.rekawek.coffeegb.core.GameboyType
 import eu.rekawek.coffeegb.core.events.Event
 import eu.rekawek.coffeegb.core.events.EventBus
 import eu.rekawek.coffeegb.core.joypad.Button
-import org.slf4j.Logger
-import org.slf4j.LoggerFactory
+import java.io.IOException
 import java.io.InputStream
 import java.io.OutputStream
 import java.nio.ByteBuffer
 import kotlin.concurrent.Volatile
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
 
 class Connection(
     private val inputStream: InputStream,
     private val outputStream: OutputStream,
     mainEventBus: EventBus,
+    private val server: Boolean,
 ) : Runnable, AutoCloseable {
 
   private val eventBus: EventBus = mainEventBus.fork("connection")
@@ -87,6 +89,7 @@ class Connection(
   }
 
   override fun run() {
+    handshake()
     while (!doStop) {
       val command = inputStream.read()
       if (command == -1) {
@@ -190,6 +193,36 @@ class Connection(
     outputStream.close()
   }
 
+  private fun handshake() {
+    val buf = ByteBuffer.allocate(PROTOCOL_NAME.length + 1)
+    if (server) {
+      buf.put(PROTOCOL_NAME.toByteArray())
+      buf.put(PROTOCOL_VERSION)
+      outputStream.write(buf.array())
+      LOG.atInfo().log("Sent protocol name {} and version {}", PROTOCOL_NAME, PROTOCOL_VERSION)
+    } else {
+      inputStream.read(buf.array())
+      val receivedProtocolName = String(buf.array().take(PROTOCOL_NAME.length).toByteArray())
+      if (receivedProtocolName != PROTOCOL_NAME) {
+        throw IOException(
+            "Protocol mismatch: expected $PROTOCOL_NAME, received $receivedProtocolName"
+        )
+      }
+      val receivedProtocolVersion = buf.array()[PROTOCOL_NAME.length]
+      if (receivedProtocolVersion != PROTOCOL_VERSION) {
+        throw IOException(
+            "Protocol mismatch: expected $PROTOCOL_VERSION, received $receivedProtocolVersion"
+        )
+      }
+      LOG.atInfo()
+          .log(
+              "Received protocol name {} and version {}",
+              receivedProtocolName,
+              receivedProtocolVersion,
+          )
+    }
+  }
+
   data class PeerLoadedGameEvent(
       val rom: ByteArray,
       val battery: ByteArray?,
@@ -209,5 +242,7 @@ class Connection(
 
   companion object {
     private val LOG: Logger = LoggerFactory.getLogger(Connection::class.java)
+    private const val PROTOCOL_NAME: String = "CoffeeGB NETPLAY"
+    private const val PROTOCOL_VERSION: Byte = 0x01
   }
 }

controller/src/main/java/eu/rekawek/coffeegb/controller/network/TcpClient.kt

@@ -1,11 +1,11 @@
 package eu.rekawek.coffeegb.controller.network
 
 import eu.rekawek.coffeegb.core.events.EventBus
-import org.slf4j.Logger
-import org.slf4j.LoggerFactory
 import java.io.IOException
 import java.net.Socket
 import java.net.SocketException
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
 
 class TcpClient(
     private val host: String,
@@ -18,9 +18,8 @@ class TcpClient(
       clientSocket = createSocket(host)
       LOG.info("Connected to {}", clientSocket!!.inetAddress)
       eventBus.post(ConnectionController.ClientConnectedToServerEvent())
-      Connection(clientSocket!!.getInputStream(), clientSocket!!.getOutputStream(), eventBus).use {
-        it.run()
-      }
+      Connection(clientSocket!!.getInputStream(), clientSocket!!.getOutputStream(), eventBus, false)
+          .use { it.run() }
       LOG.info("Disconnected from {}", clientSocket!!.inetAddress)
     } catch (e: SocketException) {
       if (e.message == "Socket closed") {

controller/src/main/java/eu/rekawek/coffeegb/controller/network/TcpServer.kt

@@ -1,14 +1,14 @@
 package eu.rekawek.coffeegb.controller.network
 
 import eu.rekawek.coffeegb.core.events.EventBus
-import org.slf4j.Logger
-import org.slf4j.LoggerFactory
 import java.io.IOException
 import java.net.ServerSocket
 import java.net.Socket
 import java.net.SocketException
 import java.net.SocketTimeoutException
 import kotlin.concurrent.Volatile
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
 
 class TcpServer(private val eventBus: EventBus) : Runnable {
   @Volatile private var doStop = false
@@ -28,7 +28,9 @@ class TcpServer(private val eventBus: EventBus) : Runnable {
           LOG.info("Got new connection: {}", socket.inetAddress)
           eventBus.post(ConnectionController.ServerGotConnectionEvent(socket.inetAddress.hostName))
           try {
-            Connection(socket.getInputStream(), socket.getOutputStream(), eventBus).use { it.run() }
+            Connection(socket.getInputStream(), socket.getOutputStream(), eventBus, true).use {
+              it.run()
+            }
           } finally {
             LOG.info("Client disconnected: {}", socket.inetAddress)
             eventBus.post(ConnectionController.ServerLostConnectionEvent())