c18f0bbbb3
This is a part of preliminary work for sending a v6 NAT-T
keepalive packet in a v6 only network. This commit
release the constraint on constructing a v6 NAT-T keepalive
packet.
Bug: 196453719
Test: Manually connect to v6 only network and check if the
keepalive packets are sent with subsequent commit
Test: atest FrameworksNetTests with the updated test
Change-Id: I9dc96e840265c5dee6b9e3ef2b3901a0aeb4ff9e
129 lines
5.1 KiB
Kotlin
129 lines
5.1 KiB
Kotlin
/*
|
|
* Copyright (C) 2020 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package android.net
|
|
|
|
import android.net.InvalidPacketException.ERROR_INVALID_IP_ADDRESS
|
|
import android.net.InvalidPacketException.ERROR_INVALID_PORT
|
|
import android.net.NattSocketKeepalive.NATT_PORT
|
|
import android.os.Build
|
|
import androidx.test.filters.SmallTest
|
|
import androidx.test.runner.AndroidJUnit4
|
|
import com.android.testutils.DevSdkIgnoreRule
|
|
import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo
|
|
import com.android.testutils.assertEqualBothWays
|
|
import com.android.testutils.assertParcelingIsLossless
|
|
import com.android.testutils.parcelingRoundTrip
|
|
import java.net.InetAddress
|
|
import kotlin.test.assertFailsWith
|
|
import org.junit.Assert.assertEquals
|
|
import org.junit.Assert.assertNotEquals
|
|
import org.junit.Rule
|
|
import org.junit.Test
|
|
import org.junit.runner.RunWith
|
|
|
|
@RunWith(AndroidJUnit4::class)
|
|
@SmallTest
|
|
class NattKeepalivePacketDataTest {
|
|
@Rule @JvmField
|
|
val ignoreRule: DevSdkIgnoreRule = DevSdkIgnoreRule()
|
|
|
|
private val TEST_PORT = 4243
|
|
private val TEST_PORT2 = 4244
|
|
private val TEST_SRC_ADDRV4 = "198.168.0.2".address()
|
|
private val TEST_DST_ADDRV4 = "198.168.0.1".address()
|
|
private val TEST_ADDRV6 = "2001:db8::1".address()
|
|
private val TEST_ADDRV4MAPPEDV6 = "::ffff:1.2.3.4".address()
|
|
private val TEST_ADDRV4 = "1.2.3.4".address()
|
|
|
|
private fun String.address() = InetAddresses.parseNumericAddress(this)
|
|
private fun nattKeepalivePacket(
|
|
srcAddress: InetAddress? = TEST_SRC_ADDRV4,
|
|
srcPort: Int = TEST_PORT,
|
|
dstAddress: InetAddress? = TEST_DST_ADDRV4,
|
|
dstPort: Int = NATT_PORT
|
|
) = NattKeepalivePacketData.nattKeepalivePacket(srcAddress, srcPort, dstAddress, dstPort)
|
|
|
|
@Test @IgnoreUpTo(Build.VERSION_CODES.Q)
|
|
fun testConstructor() {
|
|
assertFailsWith<InvalidPacketException>(
|
|
"Dst port is not NATT port should cause exception") {
|
|
nattKeepalivePacket(dstPort = TEST_PORT)
|
|
}.let {
|
|
assertEquals(it.error, ERROR_INVALID_PORT)
|
|
}
|
|
|
|
assertFailsWith<InvalidPacketException>("A v6 srcAddress should cause exception") {
|
|
nattKeepalivePacket(srcAddress = TEST_ADDRV6)
|
|
}.let {
|
|
assertEquals(it.error, ERROR_INVALID_IP_ADDRESS)
|
|
}
|
|
|
|
assertFailsWith<InvalidPacketException>("A v6 dstAddress should cause exception") {
|
|
nattKeepalivePacket(dstAddress = TEST_ADDRV6)
|
|
}.let {
|
|
assertEquals(it.error, ERROR_INVALID_IP_ADDRESS)
|
|
}
|
|
|
|
assertFailsWith<IllegalArgumentException>("Invalid data should cause exception") {
|
|
parcelingRoundTrip(
|
|
NattKeepalivePacketData(TEST_SRC_ADDRV4, TEST_PORT, TEST_DST_ADDRV4, TEST_PORT,
|
|
byteArrayOf(12, 31, 22, 44)))
|
|
}
|
|
}
|
|
|
|
@Test @IgnoreUpTo(Build.VERSION_CODES.R)
|
|
fun testConstructor_afterR() {
|
|
// v4 mapped v6 will be translated to a v4 address.
|
|
assertFailsWith<InvalidPacketException> {
|
|
nattKeepalivePacket(srcAddress = TEST_ADDRV6, dstAddress = TEST_ADDRV4MAPPEDV6)
|
|
}
|
|
assertFailsWith<InvalidPacketException> {
|
|
nattKeepalivePacket(srcAddress = TEST_ADDRV4MAPPEDV6, dstAddress = TEST_ADDRV6)
|
|
}
|
|
|
|
// Both src and dst address will be v4 after translation, so it won't cause exception.
|
|
val packet1 = nattKeepalivePacket(
|
|
dstAddress = TEST_ADDRV4MAPPEDV6, srcAddress = TEST_ADDRV4MAPPEDV6)
|
|
assertEquals(TEST_ADDRV4, packet1.srcAddress)
|
|
assertEquals(TEST_ADDRV4, packet1.dstAddress)
|
|
|
|
// Packet with v6 src and v6 dst address is valid.
|
|
val packet2 = nattKeepalivePacket(srcAddress = TEST_ADDRV6, dstAddress = TEST_ADDRV6)
|
|
assertEquals(TEST_ADDRV6, packet2.srcAddress)
|
|
assertEquals(TEST_ADDRV6, packet2.dstAddress)
|
|
}
|
|
|
|
@Test @IgnoreUpTo(Build.VERSION_CODES.Q)
|
|
fun testParcel() {
|
|
assertParcelingIsLossless(nattKeepalivePacket())
|
|
}
|
|
|
|
@Test @IgnoreUpTo(Build.VERSION_CODES.Q)
|
|
fun testEquals() {
|
|
assertEqualBothWays(nattKeepalivePacket(), nattKeepalivePacket())
|
|
assertNotEquals(nattKeepalivePacket(dstAddress = TEST_SRC_ADDRV4), nattKeepalivePacket())
|
|
assertNotEquals(nattKeepalivePacket(srcAddress = TEST_DST_ADDRV4), nattKeepalivePacket())
|
|
// Test src port only because dst port have to be NATT_PORT
|
|
assertNotEquals(nattKeepalivePacket(srcPort = TEST_PORT2), nattKeepalivePacket())
|
|
}
|
|
|
|
@Test @IgnoreUpTo(Build.VERSION_CODES.Q)
|
|
fun testHashCode() {
|
|
assertEquals(nattKeepalivePacket().hashCode(), nattKeepalivePacket().hashCode())
|
|
}
|
|
}
|