work blyattt

src/main/kotlin/Server.kt

@@ -1,12 +1,17 @@
 package su.sonoma
 
 import kotlinx.coroutines.*
+import java.io.BufferedInputStream
+import java.io.BufferedOutputStream
 import java.net.ServerSocket
 import java.net.Socket
 import java.io.DataInputStream
 
-fun startServer(address: String, port: Int) = runBlocking {
-    val tun = TunDevice(address)
+fun startServer(address: String, port: Int, tun: String, outIntefrace: String) = runBlocking {
+    val tun = TunDevice(address, "awake0")
+    tun.addRoute()
+    tun.enableIpForwarding()
+    tun.enableMasquerade(outIntefrace)
 
     val server = ServerSocket(port)
     println("Server started on $port")
@@ -21,55 +26,80 @@ fun startServer(address: String, port: Int) = runBlocking {
             try {
                 handle(client, tun)
             } catch (e: Exception) {
-                println("${client.inetAddress} Client disconnected: ${e.message}")
+                e.printStackTrace()
+            }
+        }
+
+        launch(Dispatchers.IO) {
+            try {
+                forward(client, tun)
+            } catch (e: Exception) {
+                e.printStackTrace()
             }
         }
     }
 }
 
-suspend fun handle(socket: Socket, tun: TunDevice) {
-    val input = withContext(Dispatchers.IO) {
-        socket.getInputStream()
-    }
-    val output = withContext(Dispatchers.IO) {
-        socket.getOutputStream()
-    }
+fun handle(socket: Socket, tun: TunDevice) {
 
-    val buffer = ByteArray(32768)
+    val input = BufferedInputStream(socket.getInputStream())
 
-    withContext(Dispatchers.IO) {
-        while (true) {
+    val buffer = ByteArray(1500)
 
-            val hi = input.read()
+    while (true) {
 
-            val lo = input.read()
+        val hi = input.read()
+        val lo = input.read()
 
-            val len = (hi shl 8) or lo
-
-            DataInputStream(input).readFully(buffer, 0, len)
-
-            val packet = buffer.copyOf(len)
-
-            val response = forwardPacket(packet)
-
-            //output.write(response.size shr 8)
-            //output.write(response.size)
-            //output.write(response)
-            tun.output.write(packet, 0, len)
+        if (hi == -1 || lo == -1) {
+            println("${socket.inetAddress} Client disconnected")
+            break
         }
+
+        val len = (hi shl 8) or lo
+
+        //println("Message length: $len")
+
+        if (len <= 0 || len > buffer.size) {
+            println("Invalid packet size: $len")
+            break
+        }
+
+        var offset = 0
+        while (offset < len) {
+            val r = input.read(buffer, offset, len - offset)
+
+            //println("Read $r from client")
+
+            if (r == -1) {
+                println("${socket.inetAddress} Client closed stream")
+                return
+            }
+            offset += r
+        }
+
+        runCatching {
+            tun.output.write(buffer, 0, len)
+            tun.output.flush()
+        }
+        //println("Write in tun")
     }
 }
-fun forwardPacket(packet: ByteArray): ByteArray {
-    val host = "localhost"
-    val port = 1080
 
-    val socket = Socket(host, port)
+fun forward(socket: Socket, tun: TunDevice) {
 
-    socket.getOutputStream().write(packet)
+    val readBuffer = ByteArray(1500)
+    val output = BufferedOutputStream(socket.getOutputStream())
 
-    val response = socket.getInputStream().readBytes()
+    while (true) {
+        val responseLen = tun.input.read(readBuffer)
+        if (responseLen > 0) {
 
-    socket.close()
+            output.write((responseLen shr 8) and 0xFF)
+            output.write(responseLen and 0xFF)
 
-    return response
+            output.write(readBuffer, 0, responseLen)
+            output.flush()
+        }
+    }
 }