2021-04-27 10:28:11 +02:00
|
|
|
package dorkboxTest.network
|
|
|
|
|
|
|
|
import dorkbox.netUtil.IPv4
|
|
|
|
import dorkbox.netUtil.IPv6
|
|
|
|
import dorkbox.network.Client
|
|
|
|
import dorkbox.network.Server
|
|
|
|
import dorkbox.network.connection.Connection
|
|
|
|
import dorkbox.network.exceptions.ClientException
|
|
|
|
import dorkbox.network.ipFilter.IpSubnetFilterRule
|
|
|
|
import kotlinx.atomicfu.atomic
|
|
|
|
import org.junit.Assert
|
|
|
|
import org.junit.Test
|
|
|
|
|
|
|
|
class ConnectionFilterTest : BaseTest() {
|
|
|
|
@Test
|
|
|
|
fun autoAcceptAll() {
|
|
|
|
val serverConnectSuccess = atomic(false)
|
|
|
|
val clientConnectSuccess = atomic(false)
|
|
|
|
|
|
|
|
run {
|
|
|
|
val configuration = serverConfig()
|
|
|
|
|
|
|
|
val server: Server<Connection> = Server(configuration)
|
|
|
|
addEndPoint(server)
|
|
|
|
server.bind()
|
|
|
|
|
2021-04-30 22:39:36 +02:00
|
|
|
server.onConnect {
|
2021-04-27 10:28:11 +02:00
|
|
|
serverConnectSuccess.value = true
|
2021-04-30 22:39:36 +02:00
|
|
|
close()
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
run {
|
|
|
|
val config = clientConfig()
|
|
|
|
|
|
|
|
val client: Client<Connection> = Client(config)
|
|
|
|
addEndPoint(client)
|
|
|
|
|
|
|
|
client.onConnect {
|
|
|
|
clientConnectSuccess.value = true
|
|
|
|
}
|
|
|
|
|
|
|
|
client.onDisconnect {
|
|
|
|
stopEndPoints()
|
|
|
|
}
|
|
|
|
|
2021-04-29 11:26:19 +02:00
|
|
|
try {
|
2022-03-15 12:44:52 +01:00
|
|
|
client.connect(LOCALHOST)
|
2021-04-29 11:26:19 +02:00
|
|
|
} catch (e: Exception) {
|
|
|
|
stopEndPoints()
|
|
|
|
throw e
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
waitForThreads()
|
|
|
|
|
|
|
|
Assert.assertTrue(serverConnectSuccess.value)
|
|
|
|
Assert.assertTrue(clientConnectSuccess.value)
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
|
|
fun acceptWildcardServer() {
|
|
|
|
val serverConnectSuccess = atomic(false)
|
|
|
|
val clientConnectSuccess = atomic(false)
|
|
|
|
|
|
|
|
run {
|
|
|
|
val configuration = serverConfig()
|
|
|
|
|
|
|
|
val server: Server<Connection> = Server(configuration)
|
|
|
|
addEndPoint(server)
|
|
|
|
server.bind()
|
|
|
|
server.filter(IpSubnetFilterRule(IPv4.WILDCARD, 0))
|
|
|
|
server.filter(IpSubnetFilterRule(IPv6.WILDCARD, 0))
|
|
|
|
|
2021-04-30 22:39:36 +02:00
|
|
|
server.onConnect {
|
2021-04-27 10:28:11 +02:00
|
|
|
serverConnectSuccess.value = true
|
2021-04-30 22:39:36 +02:00
|
|
|
close()
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
run {
|
|
|
|
val config = clientConfig()
|
|
|
|
|
|
|
|
val client: Client<Connection> = Client(config)
|
|
|
|
addEndPoint(client)
|
|
|
|
|
|
|
|
client.onConnect {
|
|
|
|
clientConnectSuccess.value = true
|
|
|
|
}
|
|
|
|
|
|
|
|
client.onDisconnect {
|
|
|
|
stopEndPoints()
|
|
|
|
}
|
|
|
|
|
2021-04-29 11:26:19 +02:00
|
|
|
try {
|
2022-03-15 12:44:52 +01:00
|
|
|
client.connect(LOCALHOST)
|
2021-04-29 11:26:19 +02:00
|
|
|
} catch (e: Exception) {
|
|
|
|
stopEndPoints()
|
|
|
|
throw e
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
waitForThreads()
|
|
|
|
|
|
|
|
Assert.assertTrue(serverConnectSuccess.value)
|
|
|
|
Assert.assertTrue(clientConnectSuccess.value)
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
|
|
fun acceptZeroCidrServer() {
|
|
|
|
val serverConnectSuccess = atomic(false)
|
|
|
|
val clientConnectSuccess = atomic(false)
|
|
|
|
|
|
|
|
run {
|
|
|
|
val configuration = serverConfig()
|
|
|
|
|
|
|
|
val server: Server<Connection> = Server(configuration)
|
|
|
|
addEndPoint(server)
|
|
|
|
server.bind()
|
|
|
|
server.filter(IpSubnetFilterRule("1.1.1.1", 0))
|
|
|
|
server.filter(IpSubnetFilterRule("::1.1.1.1", 0)) // compressed ipv6
|
|
|
|
|
2021-04-30 22:39:36 +02:00
|
|
|
server.onConnect {
|
2021-04-27 10:28:11 +02:00
|
|
|
serverConnectSuccess.value = true
|
2021-04-30 22:39:36 +02:00
|
|
|
close()
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
run {
|
|
|
|
val config = clientConfig()
|
|
|
|
|
|
|
|
val client: Client<Connection> = Client(config)
|
|
|
|
addEndPoint(client)
|
|
|
|
|
|
|
|
client.onConnect {
|
|
|
|
clientConnectSuccess.value = true
|
|
|
|
}
|
|
|
|
|
|
|
|
client.onDisconnect {
|
|
|
|
stopEndPoints()
|
|
|
|
}
|
|
|
|
|
2021-04-29 11:26:19 +02:00
|
|
|
try {
|
2022-03-15 12:44:52 +01:00
|
|
|
client.connect(LOCALHOST)
|
2021-04-29 11:26:19 +02:00
|
|
|
} catch (e: Exception) {
|
|
|
|
stopEndPoints()
|
|
|
|
throw e
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
waitForThreads()
|
|
|
|
|
|
|
|
Assert.assertTrue(serverConnectSuccess.value)
|
|
|
|
Assert.assertTrue(clientConnectSuccess.value)
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
|
|
fun acceptWildcardClient() {
|
|
|
|
val serverConnectSuccess = atomic(false)
|
|
|
|
val clientConnectSuccess = atomic(false)
|
|
|
|
|
|
|
|
run {
|
|
|
|
val configuration = serverConfig()
|
|
|
|
|
|
|
|
val server: Server<Connection> = Server(configuration)
|
|
|
|
addEndPoint(server)
|
|
|
|
server.bind()
|
|
|
|
|
2021-04-30 22:39:36 +02:00
|
|
|
server.onConnect {
|
2021-04-27 10:28:11 +02:00
|
|
|
serverConnectSuccess.value = true
|
2022-04-04 23:22:18 +02:00
|
|
|
println("Closing server connection")
|
2021-04-30 22:39:36 +02:00
|
|
|
close()
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
run {
|
|
|
|
val config = clientConfig()
|
|
|
|
|
|
|
|
val client: Client<Connection> = Client(config)
|
|
|
|
addEndPoint(client)
|
|
|
|
client.filter(IpSubnetFilterRule(IPv4.WILDCARD, 0))
|
|
|
|
client.filter(IpSubnetFilterRule(IPv6.WILDCARD, 0))
|
|
|
|
|
|
|
|
client.onConnect {
|
|
|
|
clientConnectSuccess.value = true
|
|
|
|
}
|
|
|
|
|
|
|
|
client.onDisconnect {
|
2021-04-30 18:22:38 +02:00
|
|
|
println("**************************** CLOSE")
|
2021-04-27 10:28:11 +02:00
|
|
|
stopEndPoints()
|
|
|
|
}
|
|
|
|
|
2021-04-29 11:26:19 +02:00
|
|
|
try {
|
2022-03-15 12:44:52 +01:00
|
|
|
client.connect(LOCALHOST)
|
2021-04-29 11:26:19 +02:00
|
|
|
} catch (e: Exception) {
|
|
|
|
stopEndPoints()
|
|
|
|
throw e
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
waitForThreads()
|
|
|
|
|
|
|
|
Assert.assertTrue(serverConnectSuccess.value)
|
|
|
|
Assert.assertTrue(clientConnectSuccess.value)
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
@Test(expected = ClientException::class)
|
|
|
|
fun rejectServer() {
|
|
|
|
run {
|
|
|
|
val configuration = serverConfig()
|
|
|
|
|
|
|
|
val server: Server<Connection> = Server(configuration)
|
|
|
|
addEndPoint(server)
|
|
|
|
server.bind()
|
|
|
|
server.filter(IpSubnetFilterRule("1.1.1.1", 32)) // this address will NEVER actually connect. we just use it for testing
|
|
|
|
|
2021-04-30 22:39:36 +02:00
|
|
|
server.onConnect {
|
|
|
|
close()
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
run {
|
|
|
|
val config = clientConfig()
|
|
|
|
|
|
|
|
val client: Client<Connection> = Client(config)
|
|
|
|
addEndPoint(client)
|
|
|
|
|
|
|
|
client.onDisconnect {
|
|
|
|
stopEndPoints()
|
|
|
|
}
|
|
|
|
|
2021-04-29 11:26:19 +02:00
|
|
|
try {
|
2022-03-15 12:44:52 +01:00
|
|
|
client.connect(LOCALHOST)
|
2021-04-29 11:26:19 +02:00
|
|
|
} catch (e: Exception) {
|
2021-04-30 18:22:38 +02:00
|
|
|
e.printStackTrace()
|
2021-04-29 11:26:19 +02:00
|
|
|
stopEndPoints()
|
|
|
|
throw e
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-29 11:37:13 +02:00
|
|
|
waitForThreads()
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
|
2021-04-30 18:22:38 +02:00
|
|
|
@Test
|
|
|
|
fun rejectServerIpc() {
|
2022-03-15 12:47:19 +01:00
|
|
|
// we do not want to limit loopback addresses! Even with filtering, IPC is always allowed to connect
|
|
|
|
|
2021-04-30 18:22:38 +02:00
|
|
|
val serverConnectSuccess = atomic(false)
|
|
|
|
val clientConnectSuccess = atomic(false)
|
|
|
|
|
|
|
|
run {
|
|
|
|
val configuration = serverConfig() {
|
|
|
|
enableIpc = true
|
|
|
|
}
|
|
|
|
|
|
|
|
val server: Server<Connection> = Server(configuration)
|
|
|
|
addEndPoint(server)
|
|
|
|
server.bind()
|
|
|
|
server.filter(IpSubnetFilterRule("1.1.1.1", 32)) // this address will NEVER actually connect. we just use it for testing
|
|
|
|
|
2021-04-30 22:39:36 +02:00
|
|
|
server.onConnect {
|
2021-04-30 18:22:38 +02:00
|
|
|
serverConnectSuccess.lazySet(true)
|
2021-04-30 22:39:36 +02:00
|
|
|
close()
|
2021-04-30 18:22:38 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
run {
|
|
|
|
val config = clientConfig() {
|
|
|
|
enableIpc = true
|
|
|
|
}
|
|
|
|
|
|
|
|
val client: Client<Connection> = Client(config)
|
|
|
|
addEndPoint(client)
|
|
|
|
|
|
|
|
client.onConnect {
|
|
|
|
clientConnectSuccess.value = true
|
|
|
|
}
|
|
|
|
|
|
|
|
client.onDisconnect {
|
|
|
|
stopEndPoints()
|
|
|
|
}
|
|
|
|
|
|
|
|
try {
|
2022-03-15 12:44:52 +01:00
|
|
|
client.connect(LOCALHOST)
|
2021-04-30 18:22:38 +02:00
|
|
|
} catch (e: Exception) {
|
|
|
|
e.printStackTrace()
|
|
|
|
stopEndPoints()
|
2022-03-15 10:31:36 +01:00
|
|
|
// this is expected.
|
2021-04-30 18:22:38 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
waitForThreads()
|
|
|
|
|
2022-03-15 12:47:19 +01:00
|
|
|
Assert.assertTrue(serverConnectSuccess.value)
|
|
|
|
Assert.assertTrue(clientConnectSuccess.value)
|
2021-04-30 18:22:38 +02:00
|
|
|
}
|
|
|
|
|
2021-04-27 10:28:11 +02:00
|
|
|
@Test(expected = ClientException::class)
|
|
|
|
fun rejectClient() {
|
|
|
|
run {
|
|
|
|
val configuration = serverConfig()
|
|
|
|
|
|
|
|
val server: Server<Connection> = Server(configuration)
|
|
|
|
addEndPoint(server)
|
|
|
|
server.bind()
|
|
|
|
|
2021-04-30 22:39:36 +02:00
|
|
|
server.onConnect {
|
|
|
|
close()
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
run {
|
|
|
|
val config = clientConfig()
|
|
|
|
|
|
|
|
val client: Client<Connection> = Client(config)
|
|
|
|
addEndPoint(client)
|
|
|
|
client.filter(IpSubnetFilterRule("1.1.1.1", 32)) // this address will NEVER actually connect. we just use it for testing
|
|
|
|
|
|
|
|
client.onDisconnect {
|
|
|
|
stopEndPoints()
|
|
|
|
}
|
|
|
|
|
2021-04-29 11:26:19 +02:00
|
|
|
try {
|
2022-03-15 12:44:52 +01:00
|
|
|
client.connect(LOCALHOST)
|
2021-04-29 11:26:19 +02:00
|
|
|
} catch (e: Exception) {
|
|
|
|
stopEndPoints()
|
|
|
|
throw e
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
waitForThreads()
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
|
|
fun acceptAllCustomServer() {
|
|
|
|
val serverConnectSuccess = atomic(false)
|
|
|
|
val clientConnectSuccess = atomic(false)
|
|
|
|
|
|
|
|
run {
|
|
|
|
val configuration = serverConfig()
|
|
|
|
|
|
|
|
val server: Server<Connection> = Server(configuration)
|
|
|
|
addEndPoint(server)
|
|
|
|
server.bind()
|
|
|
|
server.filter {
|
|
|
|
true
|
|
|
|
}
|
|
|
|
|
2021-04-30 22:39:36 +02:00
|
|
|
server.onConnect {
|
2021-04-27 10:28:11 +02:00
|
|
|
serverConnectSuccess.value = true
|
2021-04-30 22:39:36 +02:00
|
|
|
close()
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
run {
|
|
|
|
val config = clientConfig()
|
|
|
|
|
|
|
|
val client: Client<Connection> = Client(config)
|
|
|
|
addEndPoint(client)
|
|
|
|
|
|
|
|
client.onConnect {
|
|
|
|
clientConnectSuccess.value = true
|
|
|
|
}
|
|
|
|
|
|
|
|
client.onDisconnect {
|
|
|
|
stopEndPoints()
|
|
|
|
}
|
|
|
|
|
2021-04-29 11:26:19 +02:00
|
|
|
try {
|
2022-03-15 12:44:52 +01:00
|
|
|
client.connect(LOCALHOST)
|
2021-04-29 11:26:19 +02:00
|
|
|
} catch (e: Exception) {
|
|
|
|
stopEndPoints()
|
|
|
|
throw e
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
waitForThreads()
|
|
|
|
|
|
|
|
Assert.assertTrue(serverConnectSuccess.value)
|
|
|
|
Assert.assertTrue(clientConnectSuccess.value)
|
|
|
|
}
|
|
|
|
|
|
|
|
@Test
|
|
|
|
fun acceptAllCustomClient() {
|
|
|
|
val serverConnectSuccess = atomic(false)
|
|
|
|
val clientConnectSuccess = atomic(false)
|
|
|
|
|
|
|
|
run {
|
|
|
|
val configuration = serverConfig()
|
|
|
|
|
|
|
|
val server: Server<Connection> = Server(configuration)
|
|
|
|
addEndPoint(server)
|
|
|
|
server.bind()
|
|
|
|
|
2021-04-30 22:39:36 +02:00
|
|
|
server.onConnect {
|
2021-04-27 10:28:11 +02:00
|
|
|
serverConnectSuccess.value = true
|
2021-07-26 20:40:43 +02:00
|
|
|
logger.error { "closing" }
|
2021-04-30 22:39:36 +02:00
|
|
|
close()
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
run {
|
|
|
|
val config = clientConfig()
|
|
|
|
|
|
|
|
val client: Client<Connection> = Client(config)
|
|
|
|
addEndPoint(client)
|
|
|
|
client.filter {
|
|
|
|
true
|
|
|
|
}
|
|
|
|
|
|
|
|
client.onConnect {
|
|
|
|
clientConnectSuccess.value = true
|
|
|
|
}
|
|
|
|
|
|
|
|
client.onDisconnect {
|
2021-07-26 20:40:43 +02:00
|
|
|
logger.error { "on close" }
|
2021-04-27 10:28:11 +02:00
|
|
|
stopEndPoints()
|
|
|
|
}
|
|
|
|
|
2021-04-29 11:26:19 +02:00
|
|
|
try {
|
2022-03-15 12:44:52 +01:00
|
|
|
client.connect(LOCALHOST)
|
2021-04-29 11:26:19 +02:00
|
|
|
} catch (e: Exception) {
|
|
|
|
stopEndPoints()
|
|
|
|
throw e
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
waitForThreads()
|
|
|
|
|
|
|
|
Assert.assertTrue(serverConnectSuccess.value)
|
|
|
|
Assert.assertTrue(clientConnectSuccess.value)
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
@Test(expected = ClientException::class)
|
|
|
|
fun rejectCustomServer() {
|
|
|
|
run {
|
|
|
|
val configuration = serverConfig()
|
|
|
|
|
|
|
|
val server: Server<Connection> = Server(configuration)
|
|
|
|
addEndPoint(server)
|
|
|
|
server.bind()
|
|
|
|
server.filter {
|
|
|
|
false
|
|
|
|
}
|
|
|
|
|
2021-04-30 22:39:36 +02:00
|
|
|
server.onConnect {
|
|
|
|
close()
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
run {
|
|
|
|
val config = clientConfig()
|
|
|
|
|
|
|
|
val client: Client<Connection> = Client(config)
|
|
|
|
addEndPoint(client)
|
|
|
|
|
2021-04-30 22:39:36 +02:00
|
|
|
client.onDisconnect {
|
2021-04-27 10:28:11 +02:00
|
|
|
stopEndPoints()
|
|
|
|
}
|
|
|
|
|
2021-04-29 11:26:19 +02:00
|
|
|
try {
|
2022-03-15 12:44:52 +01:00
|
|
|
client.connect(LOCALHOST)
|
2021-04-29 11:26:19 +02:00
|
|
|
} catch (e: Exception) {
|
|
|
|
stopEndPoints()
|
|
|
|
throw e
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-27 13:57:47 +02:00
|
|
|
waitForThreads()
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Test(expected = ClientException::class)
|
|
|
|
fun rejectCustomClient() {
|
|
|
|
run {
|
|
|
|
val configuration = serverConfig()
|
|
|
|
|
|
|
|
val server: Server<Connection> = Server(configuration)
|
|
|
|
addEndPoint(server)
|
|
|
|
server.bind()
|
|
|
|
|
2021-04-30 22:39:36 +02:00
|
|
|
server.onConnect {
|
|
|
|
close()
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
run {
|
|
|
|
val config = clientConfig()
|
|
|
|
|
|
|
|
val client: Client<Connection> = Client(config)
|
|
|
|
addEndPoint(client)
|
|
|
|
client.filter {
|
|
|
|
false
|
|
|
|
}
|
|
|
|
|
2021-04-30 22:39:36 +02:00
|
|
|
client.onDisconnect {
|
2021-04-27 10:28:11 +02:00
|
|
|
stopEndPoints()
|
|
|
|
}
|
|
|
|
|
2021-04-29 11:26:19 +02:00
|
|
|
try {
|
2022-03-15 12:44:52 +01:00
|
|
|
client.connect(LOCALHOST)
|
2021-04-29 11:26:19 +02:00
|
|
|
} catch (e: Exception) {
|
|
|
|
stopEndPoints()
|
|
|
|
throw e
|
2021-04-27 10:28:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
waitForThreads()
|
|
|
|
}
|
|
|
|
}
|