Migrate to Kotlin 1.8.20

TheEvilRoot · TheEvilRoot · commit ac7fa8a92d7e · 2023-04-04T10:55:34.000+03:00
Update Dockerfile to optimize subsequent runs
Remove jcenter() from repositories since it is deprecated
Update dependencies
Fix some linter complains
Add dependabot config file
Add publish action to github actions
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
@@ -0,0 +1,9 @@
+version: 2
+updates:
+  - package-ecosystem: "gradle"
+    directory: "/"
+    target-branch: "master"
+    labels:
+      - "dependency"
+    schedule:
+      interval: "daily"
diff --git a/.github/workflows/publish-gpr.yml b/.github/workflows/publish-gpr.yml
@@ -0,0 +1,30 @@
+name: Publish to Github Packages
+
+permissions:
+  packages: write
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up JDK 11
+        uses: actions/setup-java@v3
+        with:
+          java-version: '11'
+          distribution: 'temurin'
+      - name: Validate Gradle wrapper
+        uses: gradle/wrapper-validation-action@e6e38bacfdf1a337459f332974bb2327a31aaf4b
+      - name: publishGprPublicationToGitHubPackagesRepository
+        uses: gradle/gradle-build-action@67421db6bd0bf253fb4bd25b31ebb98943c375e1
+        env:
+          USERNAME: ${{ secrets.USERNAME }}
+          TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          arguments: publishGprPublicationToGitHubPackagesRepository
diff --git a/Dockerfile b/Dockerfile
@@ -1,7 +1,17 @@
-FROM ubuntu:18.04
+FROM ubuntu:latest
 
-RUN apt-get update && apt-get install -y openjdk-8-jdk python3 python3-pip 
+RUN apt-get update && apt-get install -y openjdk-8-jdk python3 python3-pip
 RUN python3 -m pip install pproxy
 
-COPY . /tmp
-WORKDIR /tmp
+WORKDIR /tests
+COPY gradle/ /tests/gradle
+COPY gradlew /tests/
+
+RUN touch settings.gradle.kts && ./gradlew :wrapper
+
+COPY settings.gradle.kts build.gradle.kts gradle.properties /tests/
+
+RUN ./gradlew --refresh-dependencies
+
+COPY test_proxy.sh run_tests.sh server.py /tests/
+COPY src /tests/src
diff --git a/README.md b/README.md
@@ -17,7 +17,7 @@ is called with either success or failure method.
 But using callback based socket is inconvenient after all. It's commonly causes lots of lambdas, interfaces and 
 indentation levels. 
 
-Here's out library comes in. Using a `suspendCoroutine` and `Continuation` mechanism in kotlin coroutines
+Here's our library comes in. Using a `suspendCoroutine` and `Continuation` mechanism in kotlin coroutines
 we're wrapped a callback based functions into coroutine-blocking function. 
 
 It's just blocking a current coroutine on connect/read/write call and resume it on callback functions -- success or failure.
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -3,20 +3,19 @@ import org.jetbrains.kotlin.konan.properties.Properties
 
 plugins {
     `maven-publish`
-    kotlin("jvm") version "1.5.21"
+    kotlin("jvm") version "1.8.20"
 }
 
 group = "me.theevilroot"
-version = "1.1"
+version = "1.2"
 
 repositories {
     mavenCentral()
-    jcenter()
 }
 
 dependencies {
-    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.1")
-    testImplementation("junit:junit:4.13")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4")
+    testImplementation("junit:junit:4.13.2")
 }
 
 val sourcesJar by tasks.registering(Jar::class) {
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.8-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.6.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/src/main/kotlin/com/theevilroot/asyncsocket/CoroutineSocket.kt b/src/main/kotlin/com/theevilroot/asyncsocket/CoroutineSocket.kt
@@ -21,7 +21,7 @@ open class CoroutineSocket(
         get() = socket.isOpen
 
     open suspend fun connect(isa: InetSocketAddress) {
-        suspendCoroutine<Void> {
+        suspendCoroutine {
             socket.connect(isa, it, ContinuationHandler<Void>())
         }
         isConnected = true
@@ -30,8 +30,13 @@ open class CoroutineSocket(
     open suspend fun read(buffer: ByteBuffer): Int {
         return suspendCoroutine {
             if (readTimeout != null) {
-                socket.read(buffer, readTimeout.first,
-                    readTimeout.second, it, ContinuationHandler<Int>())
+                socket.read(
+                    buffer,
+                    readTimeout.first,
+                    readTimeout.second,
+                    it,
+                    ContinuationHandler<Int>(),
+                )
             } else {
                 socket.read(buffer, it, ContinuationHandler<Int>())
             }
diff --git a/src/main/kotlin/com/theevilroot/asyncsocket/Socks4CoroutineSocket.kt b/src/main/kotlin/com/theevilroot/asyncsocket/Socks4CoroutineSocket.kt
@@ -10,31 +10,38 @@ class Socks4CoroutineSocket(
     val socksIsa: InetSocketAddress,
     channel: AsynchronousSocketChannel,
     val userId: String,
-    readTimeout: Pair<Long, TimeUnit>? = null
+    readTimeout: Pair<Long, TimeUnit>? = null,
 ) : CoroutineSocket(channel, readTimeout) {
 
     lateinit var remoteIsa: InetSocketAddress
 
     private suspend fun socksConnect(isa: InetSocketAddress): InetSocketAddress {
-        val message = byteArrayOf(0x04, 0x01,
+        val message = byteArrayOf(
+            0x04,
+            0x01,
             (isa.port shr 8).toByte(),
             (isa.port and 0xff).toByte(),
             *isa.address.address,
             *userId.toByteArray(),
-            0x00.toByte())
+            0x00.toByte(),
+        )
         ByteBuffer.wrap(message).let {
             val count = super.write(it)
-            if (count < message.size)
+            if (count < message.size) {
                 throw SocksException("failed to write connect message. $count < ${message.size}")
+            }
         }
         val response = ByteBuffer.allocate(8).also {
             val count = super.read(it)
-            if (count < 8)
+            if (count < 8) {
                 throw SocksException("failed to read connect response. $count < 8")
+            }
+        }
+        if (response[1] != 90.toByte()) {
+            throw SocksException(
+                "failed to connect to remote server through proxy. socks error: ${String.format("%02x", response[1])}",
+            )
         }
-        if (response[1] != 90.toByte())
-            throw SocksException("failed to connect to remote server through proxy. " +
-                    "socks error: ${String.format("%02x", response[1])}")
 
         val addr = ByteArray(4)
         val bPort = ByteArray(2)
@@ -59,18 +66,20 @@ class Socks4CoroutineSocket(
     }
 
     override suspend fun read(buffer: ByteBuffer): Int {
-        if (!this::remoteIsa.isInitialized)
+        if (!this::remoteIsa.isInitialized) {
             throw IllegalStateException("remote address is not initialized. please, connect first")
+        }
         return super.read(buffer).also {
             if (it < 0) close()
         }
     }
 
     override suspend fun write(buffer: ByteBuffer): Int {
-        if (!this::remoteIsa.isInitialized)
+        if (!this::remoteIsa.isInitialized) {
             throw IllegalStateException("remote address is not initialized. please, connect first")
+        }
         return super.write(buffer).also {
             if (it < 0) close()
         }
     }
-}
+}
diff --git a/src/main/kotlin/com/theevilroot/asyncsocket/SocksCoroutineSocket.kt b/src/main/kotlin/com/theevilroot/asyncsocket/SocksCoroutineSocket.kt
@@ -11,23 +11,25 @@ class SocksCoroutineSocket(
     val socksIsa: InetSocketAddress,
     channel: AsynchronousSocketChannel,
     val credentials: Pair<String, String>? = null,
-    readTimeout: Pair<Long, TimeUnit>? = null
+    readTimeout: Pair<Long, TimeUnit>? = null,
 ) : CoroutineSocket(channel, readTimeout) {
 
     enum class Method { NO_AUTH, USER_PASS }
 
     enum class AddressType(val id: Byte) {
         IPv4(0x01.toByte()),
         DOMAIN(0x03.toByte()),
-        IPv6(0x04.toByte());
+        IPv6(0x04.toByte()),
+        ;
 
         private suspend fun sizeOfAddress(read: suspend (ByteBuffer) -> Int): Int = when (this) {
             IPv4 -> 0x04
             IPv6 -> 0x10
             DOMAIN -> ByteBuffer.allocate(1).let {
                 val count = read(it)
-                if (count < 1)
+                if (count < 1) {
                     throw SocksException("failed to read domain name length for address. $count < 1")
+                }
                 it[0].toUByte().toInt()
             }
         }
@@ -36,8 +38,9 @@ class SocksCoroutineSocket(
             sizeOfAddress(read).let {
                 val buffer = ByteBuffer.allocate(it + 2)
                 val count = read(buffer)
-                if (count < it + 2)
+                if (count < it + 2) {
                     throw SocksException("failed to read address. $count < ${it + 2}")
+                }
                 buffer
             }
     }
@@ -51,16 +54,19 @@ class SocksCoroutineSocket(
         val message = byteArrayOf(0x05, methods.size.toByte(), *methods)
         ByteBuffer.wrap(message).let {
             val count = super.write(it)
-            if (count < message.size)
+            if (count < message.size) {
                 throw SocksException("failed to write methods message. $count < ${message.size}")
+            }
         }
 
         val method = ByteBuffer.allocate(2).let {
             val count = super.read(it)
-            if (count < 2)
+            if (count < 2) {
                 throw SocksException("failed to read methods response. $count < 2")
-            if (it[0] != 0x05.toByte())
+            }
+            if (it[0] != 0x05.toByte()) {
                 throw SocksException("methods response: versions mismatch: ${it[0]}")
+            }
             it[1]
         }
         return when (method) {
@@ -71,23 +77,32 @@ class SocksCoroutineSocket(
     }
 
     private suspend fun socksConnect(isa: InetSocketAddress): InetSocketAddress {
-        if (!this::method.isInitialized)
+        if (!this::method.isInitialized) {
             throw IllegalStateException("socks auth method is not initialized. maybe you forget to call init()?")
-        val message = byteArrayOf(0x05, 0x01, 0x00, 0x01,
+        }
+        val message = byteArrayOf(
+            0x05,
+            0x01,
+            0x00,
+            0x01,
             *isa.address.address,
             (isa.port shr 8).toByte(),
-            (isa.port and 0xff).toByte())
+            (isa.port and 0xff).toByte(),
+        )
         ByteBuffer.wrap(message).let {
             val count = super.write(it)
-            if (count < message.size)
+            if (count < message.size) {
                 throw SocksException("failed to write connect message. $count < ${message.size}")
+            }
         }
         val header = ByteBuffer.allocate(4).also {
             val count = super.read(it)
-            if (count < 4)
+            if (count < 4) {
                 throw SocksException("failed to read header of connect response. $count < 4")
-            if (it[1] != 0x00.toByte())
+            }
+            if (it[1] != 0x00.toByte()) {
                 throw ConnectException("failed to connect to ${isa.address.canonicalHostName}:${isa.port}. socks server respond ${it[1]} code")
+            }
         }
         val addrType = AddressType.values().firstOrNull { it.id == header[3] }
             ?: throw SocksException("unknown address type ${header[3]}")
@@ -102,26 +117,36 @@ class SocksCoroutineSocket(
     }
 
     private suspend fun socksUserPassNegotiations() {
-        if (credentials == null)
+        if (credentials == null) {
             throw SocksException("server want to use user/pass authentication, but no credentials provided")
+        }
         val (username, password) = credentials
-        if (username.length > 255 || password.length > 255)
+        if (username.length > 255 || password.length > 255) {
             throw SocksException("credentials is invalid. max length of username and password is 255")
-        val message = byteArrayOf(0x01, username.length.toByte(), *username.toByteArray(),
-            password.length.toByte(), *password.toByteArray())
+        }
+        val message = byteArrayOf(
+            0x01,
+            username.length.toByte(),
+            *username.toByteArray(),
+            password.length.toByte(),
+            *password.toByteArray(),
+        )
         ByteBuffer.wrap(message).also {
             val count = super.write(it)
-            if (count < message.size)
+            if (count < message.size) {
                 throw SocksException("failed to write user/pass message. $count < ${message.size}")
+            }
         }
         val response = ByteBuffer.allocate(2).let {
             val count = super.read(it)
-            if (count < 2)
+            if (count < 2) {
                 throw SocksException("failed to read user/pass response. $count < 2")
+            }
             it[1]
         }
-        if (response != 0x00.toByte())
+        if (response != 0x00.toByte()) {
             throw SocksException("authentication failure. server respond $response != 0x00")
+        }
     }
 
     lateinit var method: Method
@@ -163,18 +188,20 @@ class SocksCoroutineSocket(
     }
 
     override suspend fun read(buffer: ByteBuffer): Int {
-        if (!this::remoteIsa.isInitialized)
+        if (!this::remoteIsa.isInitialized) {
             throw IllegalStateException("remote address is not initialized. please, connect first")
+        }
         return super.read(buffer).also {
             if (it < 0) close()
         }
     }
 
     override suspend fun write(buffer: ByteBuffer): Int {
-        if (!this::remoteIsa.isInitialized)
+        if (!this::remoteIsa.isInitialized) {
             throw IllegalStateException("remote address is not initialized. please, connect first")
+        }
         return super.write(buffer).also {
             if (it < 0) close()
         }
     }
-}
+}
diff --git a/src/test/kotlin/com/theevilroot/asyncsocket/Socks4Test.kt b/src/test/kotlin/com/theevilroot/asyncsocket/Socks4Test.kt
@@ -21,7 +21,7 @@ class Socks4Test {
     fun testSocks4Connect(): Unit = runBlocking {
         val socket = Socks4CoroutineSocket(InetSocketAddress("127.0.0.1", 1082), channel, "user")
         socket.init()
-        socket.connect(InetSocketAddress("52.48.142.75", 80))
+        socket.connect(InetSocketAddress("api.ipify.org", 80))
 
         Assert.assertTrue(socket.isOpened)
         Assert.assertTrue(socket.isConnected)
@@ -31,7 +31,8 @@ class Socks4Test {
 
         // read some data, we don't need much
         val response = ByteBuffer.allocate(32)
-        Assert.assertTrue(socket.read(response) > 0)
+        val count = socket.read(response)
+        Assert.assertTrue("count was $count", count > 0)
 
         val http = ByteArray(4)
         response.position(0)
diff --git a/src/test/kotlin/com/theevilroot/asyncsocket/SocksTest.kt b/src/test/kotlin/com/theevilroot/asyncsocket/SocksTest.kt
