├── test-shared
├── .gitignore
├── src
│ └── main
│ │ ├── AndroidManifest.xml
│ │ └── java
│ │ └── com
│ │ └── ustadmobile
│ │ └── meshrabiya
│ │ ├── test
│ │ ├── FileAssert.kt
│ │ ├── TemporaryFolderExt.kt
│ │ ├── ByteArrayAssert.kt
│ │ ├── VirtualNodeExt.kt
│ │ ├── FileEchoSocketServer.kt
│ │ ├── TestVirtualNode.kt
│ │ ├── EchoDatagramServer.kt
│ │ └── VirtualPacketTestUtil.kt
│ │ └── FileExt.kt
├── proguard-rules.pro
└── build.gradle
├── lib-meshrabiya
├── .gitignore
├── consumer-rules.pro
├── src
│ ├── test
│ │ ├── resources
│ │ │ └── mockito-extensions
│ │ │ │ └── org.mockito.plugins.MockMaker
│ │ └── java
│ │ │ └── com
│ │ │ └── ustadmobile
│ │ │ └── meshrabiya
│ │ │ ├── vnet
│ │ │ ├── VirtualNodeSharedTest.kt
│ │ │ ├── VirtualPacketHeaderTest.kt
│ │ │ ├── wifi
│ │ │ │ ├── HotspotResponseTest.kt
│ │ │ │ └── WifiConnectConfigTest.kt
│ │ │ ├── MeshrabiyaConnectLinkTest.kt
│ │ │ ├── VirtualPacketStreamTest.kt
│ │ │ ├── VirtualNodeTest.kt
│ │ │ ├── VirtualNodeDatagramSocketTest.kt
│ │ │ └── VirtualPacketTest.kt
│ │ │ ├── mmcp
│ │ │ ├── MmcpPongTest.kt
│ │ │ ├── MmcpMessageTest.kt
│ │ │ ├── MmcpHotspotResponseTest.kt
│ │ │ └── MmcpOriginatorMessageTest.kt
│ │ │ ├── ext
│ │ │ ├── IntExtTest.kt
│ │ │ └── ByteArrayExtTest.kt
│ │ │ ├── util
│ │ │ └── UuidMaskUtilTest.kt
│ │ │ └── portforward
│ │ │ └── ForwardingTest.kt
│ ├── main
│ │ ├── java
│ │ │ └── com
│ │ │ │ └── ustadmobile
│ │ │ │ └── meshrabiya
│ │ │ │ ├── vnet
│ │ │ │ ├── Protocol.kt
│ │ │ │ ├── wifi
│ │ │ │ │ ├── WifiConnectException.kt
│ │ │ │ │ ├── LocalHotspotRequest.kt
│ │ │ │ │ ├── WifiDirectException.kt
│ │ │ │ │ ├── DnsSdResponse.kt
│ │ │ │ │ ├── HotspotStatus.kt
│ │ │ │ │ ├── state
│ │ │ │ │ │ ├── WifiDirectState.kt
│ │ │ │ │ │ ├── LocalOnlyHotspotState.kt
│ │ │ │ │ │ ├── WifiStationState.kt
│ │ │ │ │ │ └── MeshrabiyaWifiState.kt
│ │ │ │ │ ├── WifiConnectEvent.kt
│ │ │ │ │ ├── MeshrabiyaWifiManager.kt
│ │ │ │ │ ├── WifiDirectError.kt
│ │ │ │ │ ├── WifiP2pFailure.kt
│ │ │ │ │ ├── WifiP2pActionListenerAdapter.kt
│ │ │ │ │ ├── ConnectBand.kt
│ │ │ │ │ ├── HotspotType.kt
│ │ │ │ │ ├── HotspotPersistenceType.kt
│ │ │ │ │ └── LocalHotspotResponse.kt
│ │ │ │ ├── WifiRole.kt
│ │ │ │ ├── bluetooth
│ │ │ │ │ ├── MeshrabiyaBluetoothState.kt
│ │ │ │ │ └── MeshrabiyaBluetoothManager.kt
│ │ │ │ ├── PongListener.kt
│ │ │ │ ├── socket
│ │ │ │ │ ├── ChainSocketNextHop.kt
│ │ │ │ │ ├── ChainSocketFactory.kt
│ │ │ │ │ ├── ChainSocketInitResponse.kt
│ │ │ │ │ ├── ChainSocketExt.kt
│ │ │ │ │ ├── ChainSocketInitRequest.kt
│ │ │ │ │ ├── ChainSocket.kt
│ │ │ │ │ └── ChainSocketFactoryImpl.kt
│ │ │ │ ├── ISocket.kt
│ │ │ │ ├── NodeConfig.kt
│ │ │ │ ├── datagram
│ │ │ │ │ ├── VirtualDatagramSocketImplFactory.kt
│ │ │ │ │ └── VirtualDatagramSocket2.kt
│ │ │ │ ├── LocalNodeState.kt
│ │ │ │ ├── BluetoothSocketISocketAdapter.kt
│ │ │ │ ├── VirtualNodeReturnPathSocketFactory.kt
│ │ │ │ ├── VirtualRouter.kt
│ │ │ │ ├── quic
│ │ │ │ │ └── CertGenerator.kt
│ │ │ │ ├── VirtualNodeDatagramSocket.kt
│ │ │ │ ├── MeshrabiyaConnectLink.kt
│ │ │ │ └── VirtualPacketHeader.kt
│ │ │ │ ├── util
│ │ │ │ ├── ByteArrayUtil.kt
│ │ │ │ ├── RandomString.kt
│ │ │ │ ├── FindFreePort.kt
│ │ │ │ ├── FileSerializer.kt
│ │ │ │ ├── InetAddressSerializer.kt
│ │ │ │ └── UuidMaskUtil.kt
│ │ │ │ ├── RemoteEndpoint.kt
│ │ │ │ ├── server
│ │ │ │ └── OnUuidAllocatedListener.kt
│ │ │ │ ├── MeshrabiyaConstants.kt
│ │ │ │ ├── ext
│ │ │ │ ├── WifiConfigurationExt.kt
│ │ │ │ ├── ContextExt.kt
│ │ │ │ ├── LinkPropertiesExt.kt
│ │ │ │ ├── Inet6AddressExt.kt
│ │ │ │ ├── WifiP2pConfigExt.kt
│ │ │ │ ├── KeyPairExt.kt
│ │ │ │ ├── X509CertificateExt.kt
│ │ │ │ ├── CompanionDeviceManagerExt.kt
│ │ │ │ ├── ListExt.kt
│ │ │ │ ├── EnumerationExt.kt
│ │ │ │ ├── IntExt.kt
│ │ │ │ ├── WifiManagerExt.kt
│ │ │ │ ├── WifiP2pGroupExt.kt
│ │ │ │ ├── OutputStreamExt.kt
│ │ │ │ ├── SoftApConfigurationExt.kt
│ │ │ │ ├── ByteArrayExt.kt
│ │ │ │ ├── InetAddressExt.kt
│ │ │ │ └── ByteBufferExt.kt
│ │ │ │ ├── portforward
│ │ │ │ ├── ReturnPathSocketFactory.kt
│ │ │ │ └── ForwardBindPoint.kt
│ │ │ │ ├── mmcp
│ │ │ │ ├── MmcpMessageAndPacketHeader.kt
│ │ │ │ ├── MmcpPing.kt
│ │ │ │ ├── MmcpHeader.kt
│ │ │ │ ├── MmcpPong.kt
│ │ │ │ ├── MmcpHotspotResponse.kt
│ │ │ │ ├── MmcpAck.kt
│ │ │ │ └── MmcpHotspotRequest.kt
│ │ │ │ ├── client
│ │ │ │ └── BluetoothHttpResponse.kt
│ │ │ │ ├── UuidUtil.kt
│ │ │ │ └── log
│ │ │ │ ├── LogLine.kt
│ │ │ │ ├── MNetLogger.kt
│ │ │ │ └── MNetLoggerStdout.kt
│ │ └── AndroidManifest.xml
│ └── androidTest
│ │ ├── AndroidManifest.xml
│ │ └── java
│ │ └── com
│ │ └── ustadmobile
│ │ └── httpoverbluetooth
│ │ └── VirtualNodeSharedTest.kt
├── proguard-rules.pro
└── build.gradle
├── test-app
├── .gitignore
├── src
│ ├── main
│ │ ├── res
│ │ │ ├── values
│ │ │ │ ├── strings.xml
│ │ │ │ ├── themes.xml
│ │ │ │ └── colors.xml
│ │ │ ├── mipmap-hdpi
│ │ │ │ ├── ic_launcher.webp
│ │ │ │ └── ic_launcher_round.webp
│ │ │ ├── mipmap-mdpi
│ │ │ │ ├── ic_launcher.webp
│ │ │ │ └── ic_launcher_round.webp
│ │ │ ├── mipmap-xhdpi
│ │ │ │ ├── ic_launcher.webp
│ │ │ │ └── ic_launcher_round.webp
│ │ │ ├── mipmap-xxhdpi
│ │ │ │ ├── ic_launcher.webp
│ │ │ │ └── ic_launcher_round.webp
│ │ │ ├── mipmap-xxxhdpi
│ │ │ │ ├── ic_launcher.webp
│ │ │ │ └── ic_launcher_round.webp
│ │ │ ├── xml
│ │ │ │ └── filepaths.xml
│ │ │ ├── mipmap-anydpi-v26
│ │ │ │ ├── ic_launcher.xml
│ │ │ │ └── ic_launcher_round.xml
│ │ │ └── drawable-v24
│ │ │ │ └── ic_launcher_foreground.xml
│ │ ├── java
│ │ │ └── com
│ │ │ │ └── ustadmobile
│ │ │ │ └── meshrabiya
│ │ │ │ └── testapp
│ │ │ │ ├── viewmodel
│ │ │ │ ├── SnackbarMessage.kt
│ │ │ │ ├── InfoViewModel.kt
│ │ │ │ ├── SendFileViewModel.kt
│ │ │ │ ├── LogListViewModel.kt
│ │ │ │ ├── ReceiveViewModel.kt
│ │ │ │ ├── NeighborNodeListViewModel.kt
│ │ │ │ └── SelectDestNodeViewModel.kt
│ │ │ │ ├── appstate
│ │ │ │ ├── AppUiState.kt
│ │ │ │ └── FabState.kt
│ │ │ │ ├── theme
│ │ │ │ ├── Color.kt
│ │ │ │ ├── Type.kt
│ │ │ │ └── Theme.kt
│ │ │ │ ├── ext
│ │ │ │ ├── ListExt.kt
│ │ │ │ └── ContentResolverExt.kt
│ │ │ │ ├── screens
│ │ │ │ ├── OpenSourceLicensesScreen.kt
│ │ │ │ ├── SendFileScreen.kt
│ │ │ │ ├── SelectDestNodeScreen.kt
│ │ │ │ └── NeighborNodeListScreen.kt
│ │ │ │ ├── ScanQrCodeContract.kt
│ │ │ │ ├── ViewModelFactory.kt
│ │ │ │ ├── server
│ │ │ │ └── InputStreamCounter.kt
│ │ │ │ ├── ContextExt.kt
│ │ │ │ └── MNetLoggerAndroid.kt
│ │ └── AndroidManifest.xml
│ ├── test
│ │ └── java
│ │ │ └── com
│ │ │ └── ustadmobile
│ │ │ └── test_app
│ │ │ └── ExampleUnitTest.kt
│ └── androidTest
│ │ └── java
│ │ └── com
│ │ └── ustadmobile
│ │ └── test_app
│ │ └── ExampleInstrumentedTest.kt
└── proguard-rules.pro
├── .idea
├── .gitignore
├── compiler.xml
├── kotlinc.xml
├── vcs.xml
├── misc.xml
├── gradle.xml
└── inspectionProfiles
│ └── Project_Default.xml
├── doc
├── mesh.png
└── mesh-image-attrib.txt
├── gradle
└── wrapper
│ ├── gradle-wrapper.jar
│ └── gradle-wrapper.properties
├── .gitignore
├── settings.gradle
├── gradle.properties
└── gradlew.bat
/test-shared/.gitignore:
--------------------------------------------------------------------------------
1 | /build
--------------------------------------------------------------------------------
/lib-meshrabiya/.gitignore:
--------------------------------------------------------------------------------
1 | /build
--------------------------------------------------------------------------------
/lib-meshrabiya/consumer-rules.pro:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test-app/.gitignore:
--------------------------------------------------------------------------------
1 | /build
2 | /release
3 |
--------------------------------------------------------------------------------
/.idea/.gitignore:
--------------------------------------------------------------------------------
1 | # Default ignored files
2 | /shelf/
3 | /workspace.xml
4 |
--------------------------------------------------------------------------------
/doc/mesh.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UstadMobile/Meshrabiya/HEAD/doc/mesh.png
--------------------------------------------------------------------------------
/doc/mesh-image-attrib.txt:
--------------------------------------------------------------------------------
1 | https://pixabay.com/no/illustrations/textura-modell-tekstur-design-3557036/
2 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker:
--------------------------------------------------------------------------------
1 | mock-maker-inline
2 |
--------------------------------------------------------------------------------
/test-app/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 |
2 | Meshrabiya
3 |
--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UstadMobile/Meshrabiya/HEAD/gradle/wrapper/gradle-wrapper.jar
--------------------------------------------------------------------------------
/test-app/src/main/res/mipmap-hdpi/ic_launcher.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UstadMobile/Meshrabiya/HEAD/test-app/src/main/res/mipmap-hdpi/ic_launcher.webp
--------------------------------------------------------------------------------
/test-app/src/main/res/mipmap-mdpi/ic_launcher.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UstadMobile/Meshrabiya/HEAD/test-app/src/main/res/mipmap-mdpi/ic_launcher.webp
--------------------------------------------------------------------------------
/test-app/src/main/res/mipmap-xhdpi/ic_launcher.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UstadMobile/Meshrabiya/HEAD/test-app/src/main/res/mipmap-xhdpi/ic_launcher.webp
--------------------------------------------------------------------------------
/test-app/src/main/res/mipmap-xxhdpi/ic_launcher.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UstadMobile/Meshrabiya/HEAD/test-app/src/main/res/mipmap-xxhdpi/ic_launcher.webp
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/Protocol.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet
2 |
3 | enum class Protocol {
4 | UDP, TCP
5 | }
--------------------------------------------------------------------------------
/test-app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UstadMobile/Meshrabiya/HEAD/test-app/src/main/res/mipmap-xxxhdpi/ic_launcher.webp
--------------------------------------------------------------------------------
/test-app/src/main/res/mipmap-hdpi/ic_launcher_round.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UstadMobile/Meshrabiya/HEAD/test-app/src/main/res/mipmap-hdpi/ic_launcher_round.webp
--------------------------------------------------------------------------------
/test-app/src/main/res/mipmap-mdpi/ic_launcher_round.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UstadMobile/Meshrabiya/HEAD/test-app/src/main/res/mipmap-mdpi/ic_launcher_round.webp
--------------------------------------------------------------------------------
/test-app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UstadMobile/Meshrabiya/HEAD/test-app/src/main/res/mipmap-xhdpi/ic_launcher_round.webp
--------------------------------------------------------------------------------
/test-app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UstadMobile/Meshrabiya/HEAD/test-app/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp
--------------------------------------------------------------------------------
/test-app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/UstadMobile/Meshrabiya/HEAD/test-app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp
--------------------------------------------------------------------------------
/test-shared/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
--------------------------------------------------------------------------------
/.idea/compiler.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/.idea/kotlinc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/test/java/com/ustadmobile/meshrabiya/vnet/VirtualNodeSharedTest.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet
2 |
3 | class VirtualNodeSharedTest: VirtualNodeIntegrationTest() {
4 |
5 | }
6 |
--------------------------------------------------------------------------------
/test-app/src/main/java/com/ustadmobile/meshrabiya/testapp/viewmodel/SnackbarMessage.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.testapp.viewmodel
2 |
3 | class SnackbarMessage(
4 | val message: String,
5 | ) {
6 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/wifi/WifiConnectException.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.wifi
2 |
3 | class WifiConnectException(message: String): Exception(message) {
4 | }
--------------------------------------------------------------------------------
/test-app/src/main/res/values/themes.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
--------------------------------------------------------------------------------
/test-app/src/main/res/xml/filepaths.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/util/ByteArrayUtil.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.util
2 |
3 | private val EMPTY_BYTE_ARRAY = ByteArray(0)
4 |
5 | fun emptyByteArray(): ByteArray = EMPTY_BYTE_ARRAY
6 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/RemoteEndpoint.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya
2 |
3 | import java.util.UUID
4 |
5 | data class RemoteEndpoint(
6 | val remoteAddress: String,
7 | val remoteControlUuid: UUID,
8 | )
--------------------------------------------------------------------------------
/test-app/src/main/java/com/ustadmobile/meshrabiya/testapp/appstate/AppUiState.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.testapp.appstate
2 |
3 | data class AppUiState(
4 | val title: String = "",
5 | val fabState: FabState = FabState(),
6 | ) {
7 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/wifi/LocalHotspotRequest.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.wifi
2 |
3 | data class LocalHotspotRequest(
4 | val preferredBand: ConnectBand,
5 | val preferredType: HotspotType,
6 | ) {
7 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/androidTest/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
7 |
8 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/server/OnUuidAllocatedListener.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.server
2 |
3 | import java.util.UUID
4 |
5 | fun interface OnUuidAllocatedListener {
6 |
7 | operator fun invoke(uuid: UUID)
8 |
9 | }
10 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/androidTest/java/com/ustadmobile/httpoverbluetooth/VirtualNodeSharedTest.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.httpoverbluetooth
2 |
3 | import com.ustadmobile.meshrabiya.vnet.VirtualNodeIntegrationTest
4 |
5 | class VirtualNodeSharedTest: VirtualNodeIntegrationTest() {
6 |
7 | }
--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | #Sun Jun 04 13:57:33 GST 2023
2 | distributionBase=GRADLE_USER_HOME
3 | distributionPath=wrapper/dists
4 | distributionUrl=https\://services.gradle.org/distributions/gradle-8.0-bin.zip
5 | zipStoreBase=GRADLE_USER_HOME
6 | zipStorePath=wrapper/dists
7 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/WifiRole.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet
2 |
3 | enum class WifiRole {
4 |
5 | NONE, LOCAL_ONLY_HOTSPOT, WIFI_DIRECT_GROUP_OWNER, CLIENT,
6 |
7 | @Suppress("unused") //Reserved for future use
8 | CLIENT_RELAY,
9 |
10 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/bluetooth/MeshrabiyaBluetoothState.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.bluetooth
2 |
3 | import kotlinx.serialization.Serializable
4 |
5 | @Serializable
6 | data class MeshrabiyaBluetoothState(
7 | val deviceName: String? = null,
8 | ) {
9 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/PongListener.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet
2 |
3 | import com.ustadmobile.meshrabiya.mmcp.MmcpPong
4 |
5 | interface PongListener {
6 |
7 | fun onPongReceived(
8 | fromNode: Int,
9 | pong: MmcpPong,
10 | )
11 |
12 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/wifi/WifiDirectException.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.wifi
2 |
3 | class WifiDirectException(
4 | message: String,
5 | val wifiDirectFailReason: Int
6 | ): Exception(
7 | message + ": " + WifiDirectError(wifiDirectFailReason).toString()
8 | )
9 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/MeshrabiyaConstants.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya
2 |
3 | import java.util.UUID
4 |
5 | object MeshrabiyaConstants {
6 |
7 | const val LOG_TAG = "Meshrabiya"
8 |
9 | const val VERSION = "0.1d11"
10 |
11 | val UUID_BUSY = UUID(0, 0)
12 |
13 |
14 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/wifi/DnsSdResponse.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.wifi
2 |
3 | import android.net.wifi.p2p.WifiP2pDevice
4 |
5 | data class DnsSdResponse(
6 | val instanceName: String,
7 | val registrationType: String,
8 | val device: WifiP2pDevice,
9 | )
10 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.iml
2 | .gradle
3 | /local.properties
4 | /.idea/caches
5 | /.idea/libraries
6 | /.idea/modules.xml
7 | /.idea/workspace.xml
8 | /.idea/navEditor.xml
9 | /.idea/assetWizardSettings.xml
10 | .DS_Store
11 | /build
12 | /captures
13 | .externalNativeBuild
14 | .cxx
15 | local.properties
16 | buildconfig.local.properties
17 |
18 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/socket/ChainSocketNextHop.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.socket
2 |
3 | import android.net.Network
4 | import java.net.InetAddress
5 |
6 | data class ChainSocketNextHop(
7 | val address: InetAddress,
8 | val port: Int,
9 | val isFinalDest: Boolean,
10 | val network: Network?,
11 | ) {
12 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/wifi/HotspotStatus.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.wifi
2 |
3 | enum class HotspotStatus {
4 | STARTED, STARTING, STOPPED,
5 |
6 | @Suppress("unused") //Reserved for future use
7 | STOPPING;
8 |
9 | fun isSettled(): Boolean {
10 | return this == STARTED || this == STOPPED
11 | }
12 | }
13 |
--------------------------------------------------------------------------------
/test-app/src/main/java/com/ustadmobile/meshrabiya/testapp/appstate/FabState.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.testapp.appstate
2 |
3 | import androidx.compose.ui.graphics.vector.ImageVector
4 |
5 | data class FabState(
6 | val visible: Boolean = false,
7 | val label: String? = null,
8 | val icon: ImageVector? = null,
9 | val onClick: () -> Unit = { },
10 | ) {
11 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/ext/WifiConfigurationExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.ext
2 |
3 | import android.net.wifi.WifiConfiguration
4 |
5 | @Suppress("Deprecation") //Must use WiFiconfiguration to support pre SDK30 devices
6 | fun WifiConfiguration.prettyPrint(): String {
7 | return "WifiConfiguratino(ssid=$SSID passphrase=$preSharedKey BSSID=$BSSID)"
8 | }
9 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/portforward/ReturnPathSocketFactory.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.portforward
2 |
3 | import java.net.DatagramSocket
4 | import java.net.InetAddress
5 |
6 | fun interface ReturnPathSocketFactory {
7 |
8 | fun createSocket(
9 | destAddress: InetAddress,
10 | port: Int,
11 | ): DatagramSocket
12 |
13 | }
14 |
--------------------------------------------------------------------------------
/test-app/src/main/java/com/ustadmobile/meshrabiya/testapp/theme/Color.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.testapp.theme
2 |
3 | import androidx.compose.ui.graphics.Color
4 |
5 | val Purple80 = Color(0xFFD0BCFF)
6 | val PurpleGrey80 = Color(0xFFCCC2DC)
7 | val Pink80 = Color(0xFFEFB8C8)
8 |
9 | val Purple40 = Color(0xFF6650a4)
10 | val PurpleGrey40 = Color(0xFF625b71)
11 | val Pink40 = Color(0xFF7D5260)
--------------------------------------------------------------------------------
/test-app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/test-app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/ISocket.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet
2 |
3 | import java.io.InputStream
4 | import java.io.OutputStream
5 |
6 | /**
7 | * Common interface that can represent any socket e.g. Bluetooth, IP, etc.
8 | */
9 | interface ISocket {
10 |
11 | val inStream: InputStream
12 |
13 | val outputStream: OutputStream
14 |
15 | fun close()
16 |
17 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/ext/ContextExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.ext
2 |
3 | import android.content.Context
4 | import androidx.datastore.core.DataStore
5 | import androidx.datastore.preferences.core.Preferences
6 | import androidx.datastore.preferences.preferencesDataStore
7 |
8 | val Context.bssidDataStore: DataStore by preferencesDataStore(name = "bssids")
9 |
10 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/NodeConfig.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet
2 |
3 | data class NodeConfig(
4 | val maxHops: Int,
5 | val originatingMessageInterval: Long = 3000,
6 | val originatingMessageInitialDelay: Long = 1000,
7 | ) {
8 | companion object {
9 | val DEFAULT_CONFIG = NodeConfig(
10 | maxHops = 5,
11 | )
12 | }
13 |
14 | }
--------------------------------------------------------------------------------
/.idea/misc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/test-app/src/main/res/values/colors.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 | #FFBB86FC
4 | #FF6200EE
5 | #FF3700B3
6 | #FF03DAC5
7 | #FF018786
8 | #FF000000
9 | #FFFFFFFF
10 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/wifi/state/WifiDirectState.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.wifi.state
2 |
3 | import com.ustadmobile.meshrabiya.vnet.wifi.WifiConnectConfig
4 | import com.ustadmobile.meshrabiya.vnet.wifi.HotspotStatus
5 |
6 | data class WifiDirectState(
7 | val hotspotStatus: HotspotStatus = HotspotStatus.STOPPED,
8 | val error: Int = 0,
9 | val config: WifiConnectConfig? = null,
10 | ) {
11 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/ext/LinkPropertiesExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.ext
2 |
3 | import android.net.LinkProperties
4 | import android.os.Build
5 |
6 | fun LinkProperties.toPrettyString(): String {
7 | val dhcpServerStr = if(Build.VERSION.SDK_INT >= 30) {
8 | dhcpServerAddress.toString()
9 | }else {
10 | ""
11 | }
12 |
13 | return "LinkProperties: dhcpServer=$dhcpServerStr "
14 | }
15 |
--------------------------------------------------------------------------------
/test-app/src/test/java/com/ustadmobile/test_app/ExampleUnitTest.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.test_app
2 |
3 | import org.junit.Test
4 |
5 | import org.junit.Assert.*
6 |
7 | /**
8 | * Example local unit test, which will execute on the development machine (host).
9 | *
10 | * See [testing documentation](http://d.android.com/tools/testing).
11 | */
12 | class ExampleUnitTest {
13 | @Test
14 | fun addition_isCorrect() {
15 | assertEquals(4, 2 + 2)
16 | }
17 | }
--------------------------------------------------------------------------------
/test-shared/src/main/java/com/ustadmobile/meshrabiya/test/FileAssert.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.test
2 |
3 | import com.ustadmobile.meshrabiya.md5sum
4 | import org.junit.Assert
5 | import java.io.File
6 |
7 | fun assertFileContentsAreEqual(
8 | expected: File,
9 | actual: File,
10 | ) {
11 | Assert.assertEquals(expected.length(), actual.length())
12 | val expectedMd5 = expected.md5sum()
13 | assertByteArrayEquals(expectedMd5, 0, actual.md5sum(), 0, expectedMd5.size)
14 | }
15 |
--------------------------------------------------------------------------------
/test-shared/src/main/java/com/ustadmobile/meshrabiya/test/TemporaryFolderExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.test
2 |
3 | import com.ustadmobile.meshrabiya.writeRandomData
4 | import org.junit.rules.TemporaryFolder
5 | import java.io.File
6 |
7 | fun TemporaryFolder.newFileWithRandomData(size: Int, name: String? = null): File {
8 | val file = if(name != null){
9 | newFile(name)
10 | }else {
11 | newFile()
12 | }
13 |
14 | file.writeRandomData(size)
15 |
16 | return file
17 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/wifi/WifiConnectEvent.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.wifi
2 |
3 | import com.ustadmobile.meshrabiya.vnet.VirtualNodeDatagramSocket
4 | import java.net.InetAddress
5 |
6 | /**
7 | * Event triggered by the MeshrabiyaWifiManager when a new connection
8 | */
9 | data class WifiConnectEvent(
10 | val neighborPort: Int,
11 | val neighborInetAddress: InetAddress,
12 | val socket: VirtualNodeDatagramSocket,
13 | val neighborVirtualAddress: Int,
14 | )
15 |
--------------------------------------------------------------------------------
/test-app/src/main/java/com/ustadmobile/meshrabiya/testapp/ext/ListExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.testapp.ext
2 |
3 | inline fun List.updateItem(
4 | updatePredicate: (T) -> Boolean,
5 | function: (T) -> T,
6 | ): List {
7 | val indexToUpdate = indexOfFirst(updatePredicate)
8 | return if(indexToUpdate == -1) {
9 | this
10 | }else {
11 | toMutableList().also {newList ->
12 | newList[indexToUpdate] = function(this[indexToUpdate])
13 | }.toList()
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/util/RandomString.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.util
2 |
3 | import kotlin.random.Random
4 |
5 | private val CHAR_POOL_DEFAULT = "abcdefghikjmnpqrstuvxwyz23456789"
6 |
7 |
8 | /**
9 | * Generate a random string (e.g. default password, class code, etc.
10 | */
11 | fun randomString(length: Int, charPool: String = CHAR_POOL_DEFAULT): String {
12 | return (1 .. length).map { i -> charPool.get(Random.nextInt(0, charPool.length)) }
13 | .joinToString(separator = "")
14 | }
15 |
16 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/datagram/VirtualDatagramSocketImplFactory.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.datagram
2 |
3 | import com.ustadmobile.meshrabiya.vnet.VirtualNode
4 | import java.net.DatagramSocketImpl
5 | import java.net.DatagramSocketImplFactory
6 |
7 | class VirtualDatagramSocketImplFactory(
8 | private val node: VirtualNode,
9 | ): DatagramSocketImplFactory {
10 |
11 | override fun createDatagramSocketImpl(): DatagramSocketImpl {
12 |
13 | TODO("Not yet implemented")
14 | }
15 |
16 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/mmcp/MmcpMessageAndPacketHeader.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.mmcp
2 |
3 | import com.ustadmobile.meshrabiya.vnet.VirtualPacketHeader
4 |
5 | /**
6 | * Contains the MmcpMessage as received and the packet header (e.g. from/to values etc). The packet
7 | * header is immutable and therefor won't be affected by any other usage of the underlying data
8 | * buffer.
9 | */
10 | data class MmcpMessageAndPacketHeader(
11 | val message: MmcpMessage,
12 | val packetHeader: VirtualPacketHeader,
13 | )
14 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/client/BluetoothHttpResponse.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.client
2 |
3 | import rawhttp.core.RawHttpResponse
4 | import java.io.Closeable
5 |
6 | /**
7 | * BluetoothHttpResponse containing the RawHttpResponse itself. This MUST be closed when used to
8 | * release the underlying socket.
9 | */
10 | class BluetoothHttpResponse(
11 | val response: RawHttpResponse<*>,
12 | internal val onClose: () -> Unit,
13 | ) : Closeable{
14 |
15 | override fun close() {
16 | onClose()
17 | }
18 |
19 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/ext/Inet6AddressExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.ext
2 |
3 | import java.net.Inet6Address
4 | import java.net.InetAddress
5 |
6 | /**
7 | * Get the IPv6 address without any interface scope ( without @interfacename )
8 | */
9 | fun Inet6Address.withoutScope(): Inet6Address {
10 | return Inet6Address.getByAddress(this.address) as Inet6Address
11 | }
12 |
13 | fun InetAddress.requireHostAddress(): String {
14 | return hostAddress ?: throw IllegalStateException("No host address on address $this")
15 | }
16 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/test/java/com/ustadmobile/meshrabiya/mmcp/MmcpPongTest.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.mmcp
2 |
3 | import org.junit.Assert
4 | import org.junit.Test
5 |
6 | class MmcpPongTest {
7 |
8 | @Test
9 | fun givenPongMessage_whenConvertedToFromBytes_thenShouldMatch() {
10 | val pong = MmcpPong(42, 4042)
11 | val bytes = pong.toBytes()
12 | val fromBytes = MmcpPong.fromBytes(bytes)
13 | Assert.assertEquals(pong.messageId, fromBytes.messageId)
14 | Assert.assertEquals(pong.replyToMessageId, fromBytes.replyToMessageId)
15 | }
16 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/ext/WifiP2pConfigExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.ext
2 |
3 | import android.net.wifi.p2p.WifiP2pConfig
4 | import android.os.Build
5 | import com.ustadmobile.meshrabiya.vnet.wifi.ConnectBand
6 |
7 | fun WifiP2pConfig.prettyPrint(): String {
8 | return if(Build.VERSION.SDK_INT >= 30) {
9 | "WifiP2pConfig (networkName=${networkName} networkId=$networkId passphrase=$passphrase " +
10 | "groupOwnerBand=${ConnectBand.fromFlag(groupOwnerBand.toByte())})"
11 | }else {
12 | toString()
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | pluginManagement {
2 | repositories {
3 | google()
4 | mavenCentral()
5 | gradlePluginPortal()
6 | }
7 | }
8 | dependencyResolutionManagement {
9 | repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
10 | repositories {
11 | google()
12 | mavenCentral()
13 | mavenLocal()
14 | maven { url 'https://jitpack.io' }
15 | maven { url "https://devserver3.ustadmobile.com/maven2/" }
16 | }
17 | }
18 | rootProject.name = "Meshrabiya"
19 | include ':lib-meshrabiya'
20 | include ':test-app'
21 | include ':test-shared'
22 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/ext/KeyPairExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.ext
2 |
3 | import org.bouncycastle.util.io.pem.PemObject
4 | import org.bouncycastle.util.io.pem.PemWriter
5 | import java.io.PrintWriter
6 | import java.io.StringWriter
7 | import java.security.PrivateKey
8 |
9 | fun PrivateKey.toPem(): String {
10 |
11 | val stringWriter = StringWriter()
12 | val pemWriter = PemWriter(PrintWriter(stringWriter))
13 | pemWriter.writeObject {
14 | PemObject("PRIVATE KEY", encoded)
15 | }
16 | pemWriter.flush()
17 |
18 | return stringWriter.toString()
19 | }
20 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/bluetooth/MeshrabiyaBluetoothManager.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.bluetooth
2 |
3 | import android.bluetooth.BluetoothAdapter
4 | import android.bluetooth.BluetoothManager
5 | import android.content.Context
6 |
7 | class MeshrabiyaBluetoothManager(
8 | private val appContext: Context,
9 | ) {
10 |
11 | private val bluetoothManager: BluetoothManager = appContext.getSystemService(
12 | BluetoothManager::class.java
13 | )
14 |
15 | private val bluetoothAdapter: BluetoothAdapter? = bluetoothManager.adapter
16 |
17 |
18 |
19 |
20 |
21 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/portforward/ForwardBindPoint.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.portforward
2 |
3 | import com.ustadmobile.meshrabiya.vnet.VirtualNode
4 | import java.net.InetAddress
5 |
6 | /**
7 | * Represents a binding point for a forwarding rule. Forwarding can be bound to a specific address
8 | * (e.g. the loopback address) or it can be bound to a zone - the virtual network zone or the real
9 | * network zone.
10 | */
11 | internal data class ForwardBindPoint(
12 | val listenInterface: InetAddress?,
13 | val listenZone: VirtualNode.Zone?,
14 | val listenPort: Int,
15 | ) {
16 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/LocalNodeState.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet
2 |
3 | import com.ustadmobile.meshrabiya.vnet.bluetooth.MeshrabiyaBluetoothState
4 | import com.ustadmobile.meshrabiya.vnet.wifi.state.MeshrabiyaWifiState
5 |
6 | data class LocalNodeState(
7 | val address: Int = 0,
8 | val wifiState: MeshrabiyaWifiState = MeshrabiyaWifiState(),
9 | val bluetoothState: MeshrabiyaBluetoothState = MeshrabiyaBluetoothState(deviceName = ""),
10 | val connectUri: String? = null,
11 | val originatorMessages: Map = emptyMap(),
12 | ) {
13 | }
14 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/ext/X509CertificateExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.ext
2 |
3 | import org.bouncycastle.util.io.pem.PemObject
4 | import org.bouncycastle.util.io.pem.PemWriter
5 | import java.io.PrintWriter
6 | import java.io.StringWriter
7 | import java.security.cert.X509Certificate
8 |
9 | fun X509Certificate.toPem(): String {
10 | val stringWriter = StringWriter()
11 | val pemWriter = PemWriter(PrintWriter(stringWriter))
12 | pemWriter.writeObject {
13 | PemObject("CERTIFICATE", this.encoded)
14 | }
15 | pemWriter.flush()
16 |
17 |
18 | return stringWriter.toString()
19 | }
--------------------------------------------------------------------------------
/test-app/src/main/java/com/ustadmobile/meshrabiya/testapp/screens/OpenSourceLicensesScreen.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.testapp.screens
2 |
3 | import androidx.compose.foundation.layout.fillMaxSize
4 | import androidx.compose.runtime.Composable
5 | import androidx.compose.ui.Modifier
6 | import com.google.accompanist.web.WebView
7 | import com.google.accompanist.web.rememberWebViewState
8 |
9 | @Composable
10 | fun OpenSourceLicensesScreen(){
11 | val state = rememberWebViewState("file:///android_asset/open_source_licenses.html")
12 |
13 | WebView(
14 | modifier = Modifier.fillMaxSize(),
15 | state = state
16 | )
17 | }
18 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/ext/CompanionDeviceManagerExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.ext
2 |
3 | import android.companion.CompanionDeviceManager
4 | import android.net.MacAddress
5 | import android.os.Build
6 |
7 |
8 | @Suppress("DEPRECATION") //Must use deprecated .assocations to support pre-SDK33
9 | fun CompanionDeviceManager.isAssociatedWithCompat(
10 | bssid: String
11 | ) : Boolean {
12 | return if(Build.VERSION.SDK_INT >= 33) {
13 | val knownAdd = MacAddress.fromString(bssid)
14 | myAssociations.any { it.deviceMacAddress == knownAdd }
15 | }else {
16 | bssid in this.associations
17 | }
18 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/UuidUtil.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya
2 |
3 | import java.nio.ByteBuffer
4 | import java.util.UUID
5 |
6 | fun UUID.toBytes(): ByteArray {
7 | val byteBuffer = ByteBuffer.wrap(ByteArray(16))
8 | byteBuffer.putLong(mostSignificantBits)
9 | byteBuffer.putLong(leastSignificantBits)
10 | return byteBuffer.array()
11 | }
12 |
13 | object UuidUtil {
14 |
15 | fun uuidFromBytes(bytes: ByteArray): UUID {
16 | val byteBuffer = ByteBuffer.wrap(bytes)
17 | val mostSigBits = byteBuffer.long
18 | val leastSigBits = byteBuffer.long
19 | return UUID(mostSigBits, leastSigBits)
20 | }
21 |
22 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/util/FindFreePort.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.util
2 |
3 | import java.net.DatagramSocket
4 | import java.net.ServerSocket
5 | import kotlin.random.Random
6 |
7 |
8 | fun findFreePort(preferred: Int = 0): Int {
9 | var portToTry = if(preferred == 0) Random.nextInt(1025, 65_536) else preferred
10 | while(true){
11 | try {
12 | ServerSocket(portToTry).close()
13 | DatagramSocket(portToTry).close()
14 | return portToTry
15 | }catch(e: Exception) {
16 | //Do nothing - try another port
17 | }
18 | portToTry = Random.nextInt(1025, 65_536)
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/datagram/VirtualDatagramSocket2.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.datagram
2 |
3 | import com.ustadmobile.meshrabiya.log.MNetLogger
4 | import com.ustadmobile.meshrabiya.vnet.VirtualRouter
5 | import java.net.DatagramSocket
6 |
7 | /**
8 | * Thin wrapper required so that we can access the protected constructor specifying the impl class
9 | */
10 | class VirtualDatagramSocket2(
11 | router: VirtualRouter,
12 | localVirtualAddress: Int,
13 | logger: MNetLogger,
14 | ): DatagramSocket(VirtualDatagramSocketImpl(
15 | router = router,
16 | localVirtualAddress = localVirtualAddress,
17 | logger = logger,
18 | ))
19 |
20 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/test/java/com/ustadmobile/meshrabiya/ext/IntExtTest.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.ext
2 |
3 | import org.junit.Assert
4 | import org.junit.Test
5 | import java.net.InetAddress
6 |
7 | class IntExtTest {
8 |
9 | @Test
10 | fun givenAddr_whenConvertedToFromInt_thenShouldMatch() {
11 | val inetAddress = InetAddress.getByName("192.168.49.1")
12 | val addressToInt = inetAddress.address.ip4AddressToInt()
13 | val inetAddressFromInt = InetAddress.getByAddress(addressToInt.addressToByteArray())
14 | Assert.assertEquals(inetAddress, inetAddressFromInt)
15 | Assert.assertEquals("192.168.49.1", addressToInt.addressToDotNotation())
16 | }
17 |
18 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/test/java/com/ustadmobile/meshrabiya/util/UuidMaskUtilTest.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.util
2 |
3 | import org.junit.Assert
4 | import org.junit.Test
5 | import java.util.UUID
6 |
7 | class UuidMaskUtilTest {
8 |
9 | @Test
10 | fun givenUuidMaskAndPort_whenMaskedAndPortExtracted_thenShouldMatch() {
11 | val uuidMask = UUID.randomUUID()
12 | val port = 50000
13 | val uuidForMaskAndPort = uuidForMaskAndPort(uuidMask, port)
14 |
15 | Assert.assertEquals(port, uuidForMaskAndPort.maskedPort())
16 | Assert.assertTrue(uuidForMaskAndPort.matchesMask(uuidMask))
17 | Assert.assertFalse(UUID.randomUUID().matchesMask(uuidMask))
18 | }
19 |
20 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/wifi/MeshrabiyaWifiManager.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.wifi
2 |
3 | import com.ustadmobile.meshrabiya.vnet.wifi.state.MeshrabiyaWifiState
4 | import kotlinx.coroutines.flow.Flow
5 |
6 |
7 | interface MeshrabiyaWifiManager {
8 |
9 | val state: Flow
10 |
11 | val is5GhzSupported: Boolean
12 |
13 | suspend fun requestHotspot(
14 | requestMessageId: Int,
15 | request: LocalHotspotRequest
16 | ): LocalHotspotResponse
17 |
18 | suspend fun deactivateHotspot()
19 |
20 |
21 | suspend fun connectToHotspot(
22 | config: WifiConnectConfig,
23 | timeout: Long = 90_000,
24 | )
25 |
26 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/ext/ListExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.ext
2 |
3 | inline fun List.appendOrReplace(
4 | item: T,
5 | replace: (T) -> Boolean
6 | ): List {
7 | val indexOfItemToReplace = indexOfFirst(replace)
8 | return if(indexOfItemToReplace == -1) {
9 | buildList {
10 | addAll(this@appendOrReplace)
11 | add(item)
12 | }
13 | }else {
14 | toMutableList().also {
15 | it[indexOfItemToReplace] = item
16 | }
17 | }
18 | }
19 |
20 | fun List.trimIfExceeds(numItems: Int): List {
21 | return if(size > numItems)
22 | subList(0, numItems)
23 | else
24 | this
25 | }
26 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/log/LogLine.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.log
2 |
3 | import com.ustadmobile.meshrabiya.log.MNetLogger.Companion.priorityLabel
4 | import java.util.concurrent.atomic.AtomicInteger
5 |
6 | val LOG_LINE_ID_ATOMIC = AtomicInteger(0)
7 |
8 | data class LogLine(
9 | val line: String,
10 | val priority: Int,
11 | val time: Long,
12 | val lineId: Int = LOG_LINE_ID_ATOMIC.getAndIncrement(),
13 | ) {
14 |
15 | fun toString(epochTime: Long): String {
16 | val time = (time - epochTime) / 1000.toFloat()
17 | val rounded = (time * 100).toInt() / 100.toFloat()
18 |
19 | return "${priorityLabel(priority)}: t+${rounded}s : $line"
20 | }
21 |
22 | }
23 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/BluetoothSocketISocketAdapter.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet
2 |
3 | import android.bluetooth.BluetoothSocket
4 | import java.io.InputStream
5 | import java.io.OutputStream
6 |
7 | class BluetoothSocketISocketAdapter(
8 | private val bluetoothSocket: BluetoothSocket
9 | ): ISocket {
10 |
11 | override val inStream: InputStream
12 | get() = bluetoothSocket.inputStream
13 |
14 | override val outputStream: OutputStream
15 | get() = bluetoothSocket.outputStream
16 |
17 | override fun close() {
18 | bluetoothSocket.close()
19 | }
20 |
21 | }
22 |
23 | fun BluetoothSocket.asISocket(): ISocket {
24 | return BluetoothSocketISocketAdapter(this)
25 | }
26 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/log/MNetLogger.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.log
2 |
3 | import android.util.Log
4 |
5 | abstract class MNetLogger {
6 |
7 | abstract operator fun invoke(priority: Int, message: String, exception: Exception? = null)
8 |
9 | abstract operator fun invoke(priority: Int, message: () -> String, exception: Exception? = null)
10 |
11 | companion object {
12 |
13 | fun priorityLabel(priority: Int) = when(priority) {
14 | Log.DEBUG -> "D"
15 | Log.ERROR -> "E"
16 | Log.WARN -> "W"
17 | Log.ASSERT -> "A"
18 | Log.VERBOSE -> "V"
19 | Log.INFO -> "I"
20 | else -> "Err-Priority-unknown"
21 | }
22 |
23 | }
24 |
25 | }
--------------------------------------------------------------------------------
/test-app/src/main/java/com/ustadmobile/meshrabiya/testapp/ScanQrCodeContract.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.testapp
2 |
3 | import android.app.Activity
4 | import android.content.Context
5 | import android.content.Intent
6 | import androidx.activity.result.contract.ActivityResultContract
7 |
8 | class ScanQrCodeContract: ActivityResultContract() {
9 |
10 | override fun createIntent(context: Context, input: Unit): Intent {
11 | return Intent(context, CodeScannerActivity::class.java)
12 | }
13 |
14 | override fun parseResult(resultCode: Int, intent: Intent?): String? {
15 | return if(resultCode == Activity.RESULT_OK) {
16 | intent?.getStringExtra(CodeScannerActivity.KEY_QR_TEXT)
17 | }else {
18 | null
19 | }
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/mmcp/MmcpPing.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.mmcp
2 |
3 | import com.ustadmobile.meshrabiya.util.emptyByteArray
4 |
5 | class MmcpPing(
6 | messageId: Int
7 | ): MmcpMessage(WHAT_PING, messageId) {
8 |
9 | override fun toBytes() = headerAndPayloadToBytes(header, emptyByteArray())
10 |
11 | //There is no need for equals/hashcode here because there is no real payload
12 |
13 |
14 | companion object {
15 |
16 | fun fromBytes(
17 | byteArray: ByteArray,
18 | offset: Int = 0,
19 | len: Int = byteArray.size,
20 | ): MmcpPing {
21 | val (header, _) = mmcpHeaderAndPayloadFromBytes(byteArray, offset, len)
22 | return MmcpPing(header.messageId)
23 | }
24 |
25 | }
26 |
27 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/socket/ChainSocketFactory.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.socket
2 |
3 | import java.net.InetAddress
4 | import java.net.Socket
5 | import javax.net.SocketFactory
6 |
7 | /**
8 | * Chain Socket Factory provides a SocketFactory that can connect to addresses on the virtual network.
9 | * See concept notes in ChainSocketServer.
10 | *
11 | * @param virtualRouter local node virtual router
12 | * @param systemSocketFactory the underlying system socket factory
13 | */
14 | abstract class ChainSocketFactory: SocketFactory() {
15 |
16 | data class ChainSocketResult(
17 | val socket: Socket,
18 | val nextHop: ChainSocketNextHop,
19 | )
20 |
21 | abstract fun createChainSocket(address: InetAddress, port: Int): ChainSocketResult
22 |
23 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/test/java/com/ustadmobile/meshrabiya/ext/ByteArrayExtTest.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.ext
2 |
3 | import org.junit.Assert
4 | import org.junit.Test
5 |
6 | class ByteArrayExtTest {
7 |
8 | @Test
9 | fun givenTwoAddresses_whenCheckPrefixMatches_thenShouldCalculateCorrectly() {
10 | val addr1 = byteArrayOf(169.toByte(), 254.toByte(), 1.toByte(), 1.toByte())
11 | val addr2 = byteArrayOf(169.toByte(), 254.toByte(), 128.toByte(), 64.toByte())
12 |
13 | Assert.assertTrue(addr1.prefixMatches(16, addr2))
14 | Assert.assertTrue(addr1.prefixMatches(8, addr2))
15 | Assert.assertTrue(addr1.prefixMatches(12, addr2))
16 |
17 | Assert.assertFalse(addr1.prefixMatches(24, addr2))
18 | Assert.assertFalse(addr1.prefixMatches(17, addr2))
19 | }
20 |
21 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/ext/EnumerationExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.ext
2 |
3 | import java.util.Enumeration
4 |
5 |
6 | /**
7 | * Same as firstNotNullOfOrNull as per Kotlin Collections extensions
8 | */
9 | inline fun Enumeration.firstNotNullOfOrNull(
10 | transform: (T) -> R?
11 | ): R? {
12 | while(hasMoreElements()) {
13 | val transformed = transform(nextElement())
14 | if(transformed != null)
15 | return transformed
16 | }
17 |
18 | return null
19 | }
20 |
21 | fun Enumeration.firstOrNull(
22 | predicate: (T) -> Boolean
23 | ): T? {
24 | while(hasMoreElements()) {
25 | val element = nextElement()
26 | if(predicate(element))
27 | return element
28 | }
29 |
30 | return null
31 | }
32 |
33 |
--------------------------------------------------------------------------------
/test-app/src/androidTest/java/com/ustadmobile/test_app/ExampleInstrumentedTest.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.test_app
2 |
3 | import androidx.test.platform.app.InstrumentationRegistry
4 | import androidx.test.ext.junit.runners.AndroidJUnit4
5 |
6 | import org.junit.Test
7 | import org.junit.runner.RunWith
8 |
9 | import org.junit.Assert.*
10 |
11 | /**
12 | * Instrumented test, which will execute on an Android device.
13 | *
14 | * See [testing documentation](http://d.android.com/tools/testing).
15 | */
16 | @RunWith(AndroidJUnit4::class)
17 | class ExampleInstrumentedTest {
18 | @Test
19 | fun useAppContext() {
20 | // Context of the app under test.
21 | val appContext = InstrumentationRegistry.getInstrumentation().targetContext
22 | assertEquals("com.ustadmobile.test_app", appContext.packageName)
23 | }
24 | }
--------------------------------------------------------------------------------
/test-shared/proguard-rules.pro:
--------------------------------------------------------------------------------
1 | # Add project specific ProGuard rules here.
2 | # You can control the set of applied configuration files using the
3 | # proguardFiles setting in build.gradle.
4 | #
5 | # For more details, see
6 | # http://developer.android.com/guide/developing/tools/proguard.html
7 |
8 | # If your project uses WebView with JS, uncomment the following
9 | # and specify the fully qualified class name to the JavaScript interface
10 | # class:
11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
12 | # public *;
13 | #}
14 |
15 | # Uncomment this to preserve the line number information for
16 | # debugging stack traces.
17 | #-keepattributes SourceFile,LineNumberTable
18 |
19 | # If you keep the line number information, uncomment this to
20 | # hide the original source file name.
21 | #-renamesourcefileattribute SourceFile
--------------------------------------------------------------------------------
/lib-meshrabiya/proguard-rules.pro:
--------------------------------------------------------------------------------
1 | # Add project specific ProGuard rules here.
2 | # You can control the set of applied configuration files using the
3 | # proguardFiles setting in build.gradle.
4 | #
5 | # For more details, see
6 | # http://developer.android.com/guide/developing/tools/proguard.html
7 |
8 | # If your project uses WebView with JS, uncomment the following
9 | # and specify the fully qualified class name to the JavaScript interface
10 | # class:
11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
12 | # public *;
13 | #}
14 |
15 | # Uncomment this to preserve the line number information for
16 | # debugging stack traces.
17 | #-keepattributes SourceFile,LineNumberTable
18 |
19 | # If you keep the line number information, uncomment this to
20 | # hide the original source file name.
21 | #-renamesourcefileattribute SourceFile
--------------------------------------------------------------------------------
/lib-meshrabiya/src/test/java/com/ustadmobile/meshrabiya/mmcp/MmcpMessageTest.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.mmcp
2 |
3 | import org.junit.Assert
4 | import org.junit.Test
5 | import kotlin.random.Random
6 |
7 | class MmcpMessageTest {
8 |
9 | @Test
10 | fun givenPingMessage_whenConvertedToAndFromVirtualPacket_thenWillMatch() {
11 | val pingMessage = MmcpPing(Random.nextInt())
12 | val pingPacket = pingMessage.toVirtualPacket(
13 | toAddr = 1000,
14 | fromAddr = 1042,
15 | )
16 |
17 | val pingFromPacket = MmcpMessage.fromVirtualPacket(pingPacket) as MmcpPing
18 |
19 | Assert.assertEquals(pingMessage.messageId, pingFromPacket.messageId)
20 | Assert.assertEquals(1000, pingPacket.header.toAddr)
21 | Assert.assertEquals(1042, pingPacket.header.fromAddr)
22 |
23 | }
24 |
25 | }
--------------------------------------------------------------------------------
/test-app/src/main/java/com/ustadmobile/meshrabiya/testapp/ViewModelFactory.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.testapp
2 |
3 | import android.os.Bundle
4 | import androidx.lifecycle.AbstractSavedStateViewModelFactory
5 | import androidx.lifecycle.SavedStateHandle
6 | import androidx.lifecycle.ViewModel
7 | import androidx.savedstate.SavedStateRegistryOwner
8 | import org.kodein.di.DI
9 |
10 | class ViewModelFactory(
11 | private val di: DI,
12 | owner: SavedStateRegistryOwner,
13 | defaultArgs: Bundle?,
14 | private val vmFactory: (DI) -> T,
15 | ): AbstractSavedStateViewModelFactory(owner, defaultArgs) {
16 |
17 | @Suppress("UNCHECKED_CAST")
18 | override fun create(
19 | key: String,
20 | modelClass: Class,
21 | handle: SavedStateHandle
22 | ): T {
23 | return vmFactory(di) as T
24 | }
25 | }
--------------------------------------------------------------------------------
/test-shared/src/main/java/com/ustadmobile/meshrabiya/test/ByteArrayAssert.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.test
2 |
3 | import org.junit.Assert
4 |
5 | fun assertByteArrayEquals(
6 | expected: ByteArray,
7 | expectedOffset: Int,
8 | actual: ByteArray,
9 | actualOffset: Int,
10 | length: Int,
11 | ) {
12 | for(i in 0 until length) {
13 | Assert.assertEquals("ByteArray expected[$i + $expectedOffset] == actual[$i + $actualOffset]",
14 | expected[expectedOffset + i], actual[actualOffset + i])
15 | }
16 | }
17 |
18 | fun ByteArray.contentRangeEqual(
19 | thisOffset: Int,
20 | other: ByteArray,
21 | otherOffset: Int,
22 | length: Int
23 | ) : Boolean {
24 | for(i in 0 until length) {
25 | if(this[i + thisOffset] != other[i + otherOffset])
26 | return false
27 | }
28 |
29 | return true
30 | }
31 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/wifi/WifiDirectError.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.wifi
2 |
3 | import android.net.wifi.p2p.WifiP2pManager
4 |
5 | class WifiDirectError(private val errorCode: Int) {
6 |
7 | override fun toString(): String {
8 | return errorString(errorCode)
9 | }
10 |
11 | companion object {
12 |
13 | /**
14 | * Possible errors as per https://developer.android.com/reference/android/net/wifi/p2p/WifiP2pManager.ActionListener
15 | */
16 | fun errorString(reason: Int) : String {
17 | return when(reason) {
18 | WifiP2pManager.P2P_UNSUPPORTED -> "P2P_UNSUPPORTED"
19 | WifiP2pManager.BUSY -> "BUSY"
20 | WifiP2pManager.ERROR -> "ERROR"
21 | else -> "Unknown reason: $reason"
22 | }
23 | }
24 |
25 | }
26 |
27 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/test/java/com/ustadmobile/meshrabiya/vnet/VirtualPacketHeaderTest.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet
2 |
3 | import org.junit.Assert
4 | import org.junit.Test
5 |
6 | class VirtualPacketHeaderTest {
7 |
8 | @Test
9 | fun givenHeaderObject_whenToBytesThenFromBytesCalled_thenShouldBeEqual() {
10 | val header = VirtualPacketHeader(
11 | toAddr = 1000,
12 | toPort = 8080,
13 | fromAddr = 1002,
14 | fromPort = 8072,
15 | lastHopAddr = 1002,
16 | hopCount = 1,
17 | maxHops = 4,
18 | payloadSize = 1300
19 | )
20 |
21 | val headerInBytes = header.toBytes()
22 |
23 | val headerFromBytes = VirtualPacketHeader.fromBytes(headerInBytes)
24 |
25 | Assert.assertEquals("Header matches when serialized/deserialized", header, headerFromBytes)
26 | }
27 |
28 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/ext/IntExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.ext
2 |
3 | import java.net.InetAddress
4 | import java.nio.ByteBuffer
5 | import java.nio.ByteOrder
6 |
7 |
8 | fun Int.addressToDotNotation() : String {
9 | return "${(this shr 24).and(0xff)}.${(this shr 16).and(0xff)}" +
10 | ".${(this shr 8).and(0xff)}.${this.and(0xff)}"
11 | }
12 |
13 | fun Int.addressToByteArray(): ByteArray {
14 | return ByteBuffer.wrap(ByteArray(4)).order(ByteOrder.BIG_ENDIAN).putInt(this).array()
15 | }
16 |
17 | @OptIn(ExperimentalUnsignedTypes::class)
18 | fun Int.encodeAsHex(): String {
19 | return addressToByteArray().asUByteArray().joinToString(separator = "") {
20 | it.toString(radix = 16).padStart(2, '0')
21 | }
22 | }
23 |
24 | fun Int.asInetAddress(): InetAddress {
25 | return InetAddress.getByAddress(addressToByteArray())
26 | }
27 |
28 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/util/FileSerializer.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.util
2 |
3 | import kotlinx.serialization.KSerializer
4 | import kotlinx.serialization.descriptors.PrimitiveKind
5 | import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
6 | import kotlinx.serialization.descriptors.SerialDescriptor
7 | import kotlinx.serialization.encoding.Decoder
8 | import kotlinx.serialization.encoding.Encoder
9 | import java.io.File
10 |
11 |
12 | object FileSerializer: KSerializer {
13 | override fun deserialize(decoder: Decoder): File {
14 | return File(decoder.decodeString())
15 | }
16 |
17 | override val descriptor: SerialDescriptor
18 | get() = PrimitiveSerialDescriptor("file", PrimitiveKind.STRING)
19 |
20 | override fun serialize(encoder: Encoder, value: File) {
21 | encoder.encodeString(value.absolutePath)
22 | }
23 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/wifi/WifiP2pFailure.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.wifi
2 |
3 | import android.net.wifi.p2p.WifiP2pManager
4 |
5 | enum class WifiP2pFailure(val reason: Int) {
6 |
7 | //Reasons as per
8 | // https://developer.android.com/reference/android/net/wifi/p2p/WifiP2pManager.ActionListener#onFailure(int)
9 |
10 | P2P_UNSUPPORTED(WifiP2pManager.P2P_UNSUPPORTED),
11 | ERROR(WifiP2pManager.ERROR),
12 | BUSY(WifiP2pManager.BUSY),
13 | OTHER(0);
14 |
15 | companion object {
16 |
17 | fun valueOf(reason: Int): WifiP2pFailure {
18 | return values().firstOrNull { it.reason == reason } ?: OTHER
19 | }
20 |
21 | fun reasonToString(reason: Int): String {
22 | return values().firstOrNull { it.reason == reason }?.name
23 | ?: "Unknown: reason=$reason"
24 | }
25 |
26 | }
27 |
28 | }
--------------------------------------------------------------------------------
/.idea/gradle.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
21 |
22 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/socket/ChainSocketInitResponse.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.socket
2 |
3 | import java.nio.ByteBuffer
4 | import java.nio.ByteOrder
5 |
6 | data class ChainSocketInitResponse(
7 | val statusCode: Int,
8 | ) {
9 |
10 | fun toBytes(): ByteArray {
11 | return ByteArray(4).also {
12 | ByteBuffer.wrap(it)
13 | .order(ByteOrder.BIG_ENDIAN)
14 | .putInt(statusCode)
15 | }
16 | }
17 |
18 | companion object {
19 |
20 | const val MESSAGE_SIZE = 4
21 |
22 | fun fromBytes(byteArray: ByteArray, offset: Int): ChainSocketInitResponse{
23 | val byteBuf = ByteBuffer.wrap(byteArray, offset, MESSAGE_SIZE)
24 | .order(ByteOrder.BIG_ENDIAN)
25 | val statusCode = byteBuf.int
26 | return ChainSocketInitResponse(statusCode)
27 | }
28 | }
29 |
30 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/ext/WifiManagerExt.kt:
--------------------------------------------------------------------------------
1 | @file:Suppress("DEPRECATION") //Must use deprecated classes to support pre-SDK29 devices
2 |
3 | package com.ustadmobile.meshrabiya.ext
4 |
5 | import android.annotation.SuppressLint
6 | import android.net.wifi.WifiConfiguration
7 | import android.net.wifi.WifiManager
8 | import android.util.Log
9 | import com.ustadmobile.meshrabiya.log.MNetLogger
10 |
11 |
12 |
13 | @SuppressLint("MissingPermission") //Permissions will be set by the app, not the library
14 | fun WifiManager.addOrLookupNetwork(
15 | config: WifiConfiguration,
16 | logger: MNetLogger,
17 | ): Int {
18 | val existingNetwork = configuredNetworks.firstOrNull {
19 | it.SSID == config.SSID && it.status != WifiConfiguration.Status.DISABLED
20 | }
21 |
22 | logger(Log.DEBUG, "addOrLookupNetwork: existingNetworkId=${existingNetwork?.networkId}", null)
23 | return existingNetwork?.networkId ?: addNetwork(config)
24 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
9 |
10 |
11 |
12 |
14 |
15 |
16 |
17 |
18 |
20 |
22 |
23 |
24 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/ext/WifiP2pGroupExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.ext
2 |
3 | import android.net.wifi.p2p.WifiP2pGroup
4 | import android.os.Build
5 | import com.ustadmobile.meshrabiya.vnet.wifi.ConnectBand
6 |
7 | fun WifiP2pGroup.toPrettyString(): String {
8 | return buildString {
9 | val frequencyStr = if(Build.VERSION.SDK_INT >= 29) " frequency=$frequency " else ""
10 | append("WifiP2pGroup: interface=${`interface`} groupOwner = $isGroupOwner, " +
11 | "networkName=$networkName, passphrase=${passphrase} frequency=$frequencyStr")
12 | }
13 | }
14 |
15 | val WifiP2pGroup.connectBand: ConnectBand
16 | get() {
17 | return when {
18 | Build.VERSION.SDK_INT < 29 -> ConnectBand.BAND_UNKNOWN
19 | frequency in 2400..2500 -> ConnectBand.BAND_2GHZ
20 | frequency in 5150 .. 5900 -> ConnectBand.BAND_5GHZ
21 | else -> ConnectBand.BAND_UNKNOWN
22 | }
23 | }
24 |
25 |
26 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/util/InetAddressSerializer.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.util
2 |
3 | import kotlinx.serialization.KSerializer
4 | import kotlinx.serialization.descriptors.PrimitiveKind
5 | import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
6 | import kotlinx.serialization.descriptors.SerialDescriptor
7 | import kotlinx.serialization.encoding.Decoder
8 | import kotlinx.serialization.encoding.Encoder
9 | import java.net.InetAddress
10 |
11 | object InetAddressSerializer: KSerializer {
12 |
13 | override val descriptor: SerialDescriptor
14 | get() = PrimitiveSerialDescriptor("inetaddr", PrimitiveKind.STRING)
15 |
16 | override fun deserialize(decoder: Decoder): InetAddress {
17 | return InetAddress.getByName(decoder.decodeString())
18 | }
19 |
20 | override fun serialize(encoder: Encoder, value: InetAddress) {
21 | encoder.encodeString(value.hostAddress ?: throw IllegalArgumentException("no host addr"))
22 | }
23 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/ext/OutputStreamExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.ext
2 |
3 | import com.ustadmobile.meshrabiya.vnet.VirtualPacket
4 | import com.ustadmobile.meshrabiya.vnet.socket.ChainSocketInitRequest
5 | import com.ustadmobile.meshrabiya.vnet.socket.ChainSocketInitResponse
6 | import java.io.OutputStream
7 | import java.nio.ByteBuffer
8 |
9 | fun OutputStream.writeAddress(address: Int){
10 | val buffer = ByteBuffer.wrap(ByteArray(4))
11 | buffer.putInt(address)
12 | write(buffer.array())
13 | }
14 |
15 | /**
16 | * Write the given virtual packet to the receiver output stream
17 | */
18 | fun OutputStream.writeVirtualPacket(packet: VirtualPacket) {
19 | write(packet.data, packet.dataOffset, packet.datagramPacketSize)
20 | }
21 |
22 | fun OutputStream.writeChainSocketInitRequest(request: ChainSocketInitRequest) {
23 | write(request.toBytes())
24 | }
25 |
26 | fun OutputStream.writeChainSocketInitResponse(response: ChainSocketInitResponse) {
27 | write(response.toBytes())
28 | }
29 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/ext/SoftApConfigurationExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.ext
2 |
3 | import android.net.wifi.SoftApConfiguration
4 | import android.os.Build
5 | import androidx.annotation.RequiresApi
6 |
7 |
8 | val SoftApConfiguration.ssidCompat: String ?
9 | @RequiresApi(30)
10 | get() {
11 | return if(Build.VERSION.SDK_INT >= 33) {
12 | //As per https://developer.android.com/reference/android/net/wifi/WifiSsid#toString()
13 | // Any WiFi ssid that is in UTF-8 will be as a string with quotes.
14 | // No support for ssid with non UTF-8 SSID.
15 | wifiSsid.toString().removeSurrounding("\"")
16 | }else {
17 | @Suppress("DEPRECATION") //Required to support pre-SDK33
18 | ssid
19 | }
20 | }
21 |
22 | @RequiresApi(30)
23 | fun SoftApConfiguration.prettyPrint() : String{
24 | return "SoftApConfiguration(ssid=$ssidCompat passphrase=$passphrase bssid=$bssid " +
25 | "hidden=$isHiddenSsid securityType=$securityType)"
26 | }
--------------------------------------------------------------------------------
/test-shared/src/main/java/com/ustadmobile/meshrabiya/test/VirtualNodeExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.test
2 |
3 | import com.ustadmobile.meshrabiya.vnet.VirtualNode
4 | import kotlinx.coroutines.flow.filter
5 | import kotlinx.coroutines.flow.first
6 | import kotlinx.coroutines.runBlocking
7 | import kotlinx.coroutines.withTimeout
8 | import java.net.InetAddress
9 |
10 | fun VirtualNode.connectTo(other: VirtualNode, timeout: Long = 5000) {
11 | addNewNeighborConnection(
12 | address = InetAddress.getLoopbackAddress(),
13 | port = other.localDatagramPort,
14 | neighborNodeVirtualAddr = other.addressAsInt,
15 | socket = this.datagramSocket
16 | )
17 |
18 | //wait for connections to be ready
19 | runBlocking {
20 | withTimeout(timeout) {
21 | state.filter { it.originatorMessages.containsKey(other.addressAsInt) }
22 | .first()
23 |
24 | other.state.filter {
25 | it.originatorMessages.containsKey(addressAsInt)
26 | }.first()
27 |
28 | }
29 | }
30 | }
--------------------------------------------------------------------------------
/test-shared/src/main/java/com/ustadmobile/meshrabiya/test/FileEchoSocketServer.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.test
2 |
3 | import java.io.File
4 | import java.io.FileInputStream
5 | import java.net.ServerSocket
6 | import java.util.concurrent.ExecutorService
7 | import java.util.concurrent.Executors
8 |
9 | class FileEchoSocketServer(
10 | private val file: File,
11 | port: Int = 0,
12 | executorService: ExecutorService = Executors.newSingleThreadExecutor(),
13 | ) : Runnable {
14 |
15 | private val serverSocket = ServerSocket(port)
16 |
17 | private val future = executorService.submit(this)
18 |
19 | val localPort: Int
20 | get() = serverSocket.localPort
21 |
22 |
23 | override fun run() {
24 | while(!Thread.interrupted()) {
25 | val client = serverSocket.accept()
26 | FileInputStream(file).use { fileIn ->
27 | fileIn.copyTo(client.getOutputStream())
28 | }
29 | client.close()
30 | }
31 | }
32 |
33 | fun close() {
34 | future.cancel(true)
35 | }
36 |
37 | }
--------------------------------------------------------------------------------
/test-shared/src/main/java/com/ustadmobile/meshrabiya/test/TestVirtualNode.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.test
2 |
3 | import com.ustadmobile.meshrabiya.ext.asInetAddress
4 | import com.ustadmobile.meshrabiya.log.MNetLogger
5 | import com.ustadmobile.meshrabiya.log.MNetLoggerStdout
6 | import com.ustadmobile.meshrabiya.vnet.NodeConfig
7 | import com.ustadmobile.meshrabiya.vnet.VirtualNode
8 | import com.ustadmobile.meshrabiya.vnet.randomApipaAddr
9 | import com.ustadmobile.meshrabiya.vnet.wifi.MeshrabiyaWifiManager
10 | import kotlinx.serialization.json.Json
11 | import org.mockito.kotlin.mock
12 | import java.util.UUID
13 |
14 |
15 | class TestVirtualNode(
16 | localNodeAddress: Int = randomApipaAddr(),
17 | port: Int = 0,
18 | logger: MNetLogger = MNetLoggerStdout(),
19 | override val meshrabiyaWifiManager: MeshrabiyaWifiManager = mock { },
20 | json: Json,
21 | config: NodeConfig = NodeConfig(maxHops = 5),
22 | ) : VirtualNode(
23 | port = port,
24 | logger = logger,
25 | json = json,
26 | config = config,
27 | address = localNodeAddress.asInetAddress(),
28 | )
29 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/mmcp/MmcpHeader.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.mmcp
2 |
3 | import java.nio.ByteBuffer
4 | import java.nio.ByteOrder
5 |
6 |
7 | data class MmcpHeader(
8 | val what: Byte,
9 | val messageId: Int,
10 | ) {
11 |
12 | fun toBytes(
13 | byteArray: ByteArray,
14 | offset: Int
15 | ) {
16 | val headerBuf = ByteBuffer
17 | .wrap(byteArray, offset, MmcpMessage.MMCP_HEADER_LEN)
18 | .order(ByteOrder.BIG_ENDIAN)
19 | headerBuf.put(what)
20 | headerBuf.putInt(messageId)
21 | }
22 |
23 |
24 |
25 | companion object {
26 |
27 | fun fromBytes(
28 | byteArray: ByteArray,
29 | offset: Int
30 | ): MmcpHeader {
31 | val headerBuf = ByteBuffer
32 | .wrap(byteArray, offset, MmcpMessage.MMCP_HEADER_LEN)
33 | .order(ByteOrder.BIG_ENDIAN)
34 | val what = headerBuf.get()
35 | val messageId = headerBuf.int
36 |
37 | return MmcpHeader(what, messageId)
38 | }
39 |
40 | }
41 | }
--------------------------------------------------------------------------------
/test-shared/src/main/java/com/ustadmobile/meshrabiya/test/EchoDatagramServer.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.test
2 |
3 | import java.net.DatagramPacket
4 | import java.net.DatagramSocket
5 | import java.util.concurrent.ExecutorService
6 | import java.util.concurrent.Future
7 |
8 | class EchoDatagramServer(
9 | port: Int,
10 | executor: ExecutorService,
11 | ) : Runnable {
12 |
13 | val datagramSocket = DatagramSocket(port)
14 |
15 | val future: Future<*>
16 |
17 | val listeningPort = datagramSocket.localPort
18 |
19 | init {
20 | future = executor.submit(this)
21 | }
22 |
23 | override fun run() {
24 | val buf = ByteArray(1500)
25 | val packet = DatagramPacket(buf, buf.size)
26 | while(!Thread.interrupted()) {
27 | datagramSocket.receive(packet)
28 |
29 | val replyPacket = DatagramPacket(buf, 0, packet.length, packet.address, packet.port)
30 | datagramSocket.send(replyPacket)
31 | }
32 | }
33 |
34 | fun close() {
35 | future.cancel(true)
36 | datagramSocket.close()
37 | }
38 |
39 | }
--------------------------------------------------------------------------------
/test-app/src/main/java/com/ustadmobile/meshrabiya/testapp/server/InputStreamCounter.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.testapp.server
2 |
3 | import java.io.FilterInputStream
4 | import java.io.InputStream
5 |
6 | class InputStreamCounter(
7 | `in`: InputStream
8 | ): FilterInputStream(`in`){
9 |
10 | @Volatile
11 | var bytesRead: Int = 0
12 | private set
13 |
14 | @Volatile
15 | var closed: Boolean = false
16 | private set
17 |
18 | override fun read(): Int {
19 | return super.read().also {
20 | if(it != -1)
21 | bytesRead++
22 | }
23 | }
24 |
25 | override fun read(b: ByteArray): Int {
26 | return super.read(b).also {
27 | if(it != -1)
28 | bytesRead += it
29 | }
30 | }
31 |
32 | override fun read(b: ByteArray, off: Int, len: Int): Int {
33 | return super.read(b, off, len).also {
34 | if(it != -1)
35 | bytesRead += it
36 | }
37 | }
38 |
39 | override fun close() {
40 | super.close()
41 | closed = true
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/test-shared/src/main/java/com/ustadmobile/meshrabiya/test/VirtualPacketTestUtil.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.test
2 |
3 | import com.ustadmobile.meshrabiya.vnet.VirtualPacket
4 | import com.ustadmobile.meshrabiya.vnet.VirtualPacketHeader
5 | import kotlin.random.Random
6 |
7 | fun newVirtualPacketWithRandomPayload(
8 | toAddr: Int,
9 | toPort: Int,
10 | fromAddr: Int,
11 | fromPort: Int,
12 | lastHopAddr: Int = fromAddr,
13 | payloadSize: Int
14 | ): VirtualPacket {
15 | val buffer = ByteArray(payloadSize + VirtualPacket.VIRTUAL_PACKET_BUF_SIZE)
16 | Random.Default.nextBytes(buffer, VirtualPacketHeader.HEADER_SIZE)
17 | return VirtualPacket.fromHeaderAndPayloadData(
18 | header = VirtualPacketHeader(
19 | toAddr = toAddr,
20 | toPort = toPort,
21 | fromAddr = fromAddr,
22 | fromPort = fromPort,
23 | lastHopAddr = lastHopAddr,
24 | hopCount = 0,
25 | maxHops = 8,
26 | payloadSize = payloadSize
27 | ),
28 | data = buffer,
29 | payloadOffset = VirtualPacketHeader.HEADER_SIZE
30 | )
31 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/wifi/WifiP2pActionListenerAdapter.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.wifi
2 |
3 | import android.net.wifi.p2p.WifiP2pManager
4 | import android.util.Log
5 | import com.ustadmobile.meshrabiya.log.MNetLogger
6 | import kotlinx.coroutines.CompletableDeferred
7 |
8 | class WifiP2pActionListenerAdapter(
9 | val onFailLogMessage: String,
10 | val logger: MNetLogger? = null,
11 | val onSuccessLogMessage: String? = null,
12 | ): WifiP2pManager.ActionListener {
13 |
14 | private val completable = CompletableDeferred()
15 |
16 | override fun onSuccess() {
17 | if(onSuccessLogMessage != null) {
18 | logger?.invoke(Log.DEBUG, onSuccessLogMessage, null)
19 | }
20 | completable.complete(true)
21 | }
22 |
23 | override fun onFailure(reason: Int) {
24 | logger?.invoke(Log.WARN, "WifiP2pActionListener: $onFailLogMessage : " +
25 | "reason=${WifiDirectError.errorString(reason)}")
26 | completable.completeExceptionally(WifiDirectException(onFailLogMessage, reason))
27 | }
28 |
29 | suspend fun await() = completable.await()
30 | }
31 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/socket/ChainSocketExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.socket
2 |
3 | import com.ustadmobile.meshrabiya.ext.readChainInitResponse
4 | import com.ustadmobile.meshrabiya.ext.writeChainSocketInitRequest
5 | import java.io.IOException
6 | import java.net.Socket
7 |
8 | /**
9 | * Where this socket is not connected to the intended final destination, then we need to write the
10 | * ChainInitRequest to the output
11 | */
12 | fun Socket.initializeChainIfNotFinalDest(
13 | chainInitRequest: ChainSocketInitRequest,
14 | nextHop: ChainSocketNextHop,
15 | ) {
16 | if(!nextHop.isFinalDest) {
17 | println("${nextHop.address}:${nextHop.port} is not final destination - write init request and get response")
18 | getOutputStream().writeChainSocketInitRequest(chainInitRequest)
19 | val initResponse = getInputStream().readChainInitResponse()
20 | println("${nextHop.address}:${nextHop.port} got init response")
21 |
22 | if(initResponse.statusCode != 200){
23 | throw IOException("Could not init chain socket: status code = ${initResponse.statusCode}")
24 | }
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/test-app/src/main/java/com/ustadmobile/meshrabiya/testapp/theme/Type.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.testapp.theme
2 |
3 | import androidx.compose.material3.Typography
4 | import androidx.compose.ui.text.TextStyle
5 | import androidx.compose.ui.text.font.FontFamily
6 | import androidx.compose.ui.text.font.FontWeight
7 | import androidx.compose.ui.unit.sp
8 |
9 | // Set of Material typography styles to start with
10 | val Typography = Typography(
11 | bodyLarge = TextStyle(
12 | fontFamily = FontFamily.Default,
13 | fontWeight = FontWeight.Normal,
14 | fontSize = 16.sp,
15 | lineHeight = 24.sp,
16 | letterSpacing = 0.5.sp
17 | )
18 | /* Other default text styles to override
19 | titleLarge = TextStyle(
20 | fontFamily = FontFamily.Default,
21 | fontWeight = FontWeight.Normal,
22 | fontSize = 22.sp,
23 | lineHeight = 28.sp,
24 | letterSpacing = 0.sp
25 | ),
26 | labelSmall = TextStyle(
27 | fontFamily = FontFamily.Default,
28 | fontWeight = FontWeight.Medium,
29 | fontSize = 11.sp,
30 | lineHeight = 16.sp,
31 | letterSpacing = 0.5.sp
32 | )
33 | */
34 | )
--------------------------------------------------------------------------------
/test-shared/src/main/java/com/ustadmobile/meshrabiya/FileExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya
2 |
3 | import java.io.File
4 | import java.io.FileInputStream
5 | import java.security.DigestInputStream
6 | import java.security.MessageDigest
7 | import kotlin.random.Random
8 |
9 |
10 | fun File.writeRandomData(size: Int) {
11 | val buf = ByteArray(8192)
12 | var bytesWritten = 0
13 | outputStream().use { outStream ->
14 | while(bytesWritten < size) {
15 | val len = minOf(buf.size, size - bytesWritten)
16 | Random.nextBytes(buf, 0, len)
17 | outStream.write(buf, 0, len)
18 | bytesWritten += len
19 | }
20 | outStream.flush()
21 | }
22 | }
23 |
24 | fun File.md5sum(): ByteArray {
25 | val messageDigest = MessageDigest.getInstance("MD5")
26 | val inStream = FileInputStream(this)
27 | val digestInputStream = DigestInputStream(inStream, messageDigest)
28 |
29 | val buf = ByteArray(8192)
30 | digestInputStream.use {
31 | while(inStream.read(buf) != -1) {
32 | //do nothing - just read through to get the md5sum
33 | }
34 | }
35 |
36 | return messageDigest.digest()
37 | }
38 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/wifi/state/LocalOnlyHotspotState.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.wifi.state
2 |
3 | import android.net.wifi.WifiManager.LocalOnlyHotspotCallback
4 | import com.ustadmobile.meshrabiya.vnet.wifi.HotspotStatus
5 | import com.ustadmobile.meshrabiya.vnet.wifi.WifiConnectConfig
6 |
7 | data class LocalOnlyHotspotState(
8 | val status: HotspotStatus = HotspotStatus.STOPPED,
9 | val config: WifiConnectConfig? = null,
10 | val error: Int = 0,
11 | ) {
12 |
13 | companion object {
14 |
15 | //As per https://developer.android.com/reference/android/net/wifi/WifiManager.LocalOnlyHotspotCallback#onFailed(int)
16 | fun errorCodeToString(errorCode: Int) : String{
17 | return when(errorCode) {
18 | LocalOnlyHotspotCallback.ERROR_TETHERING_DISALLOWED -> "ERROR_TETHERING_DISALLOWED"
19 | LocalOnlyHotspotCallback.ERROR_NO_CHANNEL -> "ERROR_NO_CHANNEL"
20 | LocalOnlyHotspotCallback.ERROR_INCOMPATIBLE_MODE -> "ERROR_INCOMPATIBLE_MODE"
21 | LocalOnlyHotspotCallback.ERROR_GENERIC -> "ERROR_GENERIC"
22 | else -> "Unknown ERROR: $errorCode"
23 | }
24 | }
25 |
26 | }
27 |
28 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/log/MNetLoggerStdout.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.log
2 |
3 | import android.util.Log
4 | import java.util.concurrent.atomic.AtomicInteger
5 |
6 | class MNetLoggerStdout(
7 | private val minLogLevel: Int = Log.VERBOSE,
8 | ): MNetLogger() {
9 |
10 | private val lineIdAtomic = AtomicInteger()
11 |
12 | private val epochTime = System.currentTimeMillis()
13 |
14 | private fun doLog(priority: Int, message: String, exception: Exception?) {
15 | val line = LogLine(message, priority, System.currentTimeMillis(), lineIdAtomic.incrementAndGet())
16 | println(buildString {
17 | append(line.toString(epochTime))
18 | if(exception != null) {
19 | append(" ")
20 | append(exception.stackTraceToString())
21 | }
22 | })
23 | }
24 |
25 | override fun invoke(priority: Int, message: String, exception: Exception?) {
26 | if(priority >= minLogLevel)
27 | doLog(priority, message, exception)
28 | }
29 |
30 | override fun invoke(priority: Int, message: () -> String, exception: Exception?) {
31 | if(priority >= minLogLevel)
32 | doLog(priority, message(), exception)
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/wifi/state/WifiStationState.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.wifi.state
2 |
3 | import android.net.Network
4 | import com.ustadmobile.meshrabiya.vnet.VirtualNodeDatagramSocket
5 | import com.ustadmobile.meshrabiya.vnet.wifi.WifiConnectConfig
6 |
7 | /**
8 | * The Wifi station state - e.g. the 'client' connection.
9 | *
10 | * @param status the current status of station mode as being used by the Meshrabiya node
11 | * @param network the network object for the currently connected station network (if any)
12 | * @param config the config that we are connected or connecting to for station mode (if any)
13 | * @param stationBoundSocketsPort the port number for station bound sockets - see MeshrabiyaWifiManagerAndroid.stationBoundSockets
14 | */
15 | data class WifiStationState(
16 | val status: Status = Status.INACTIVE,
17 | val network: Network? = null,
18 | val config: WifiConnectConfig? = null,
19 | val stationBoundSocketsPort: Int = -1,
20 | val stationBoundDatagramSocket: VirtualNodeDatagramSocket? = null,
21 | ) {
22 |
23 | enum class Status {
24 | INACTIVE, CONNECTING, AVAILABLE, UNAVAILABLE, LOST;
25 |
26 | companion object {
27 |
28 | val FAIL_STATES = listOf(UNAVAILABLE, LOST)
29 | }
30 | }
31 |
32 |
33 |
34 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/test/java/com/ustadmobile/meshrabiya/vnet/wifi/HotspotResponseTest.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.wifi
2 |
3 | import com.ustadmobile.meshrabiya.ext.requireAsIpv6
4 | import com.ustadmobile.meshrabiya.vnet.randomApipaAddr
5 | import org.junit.Assert
6 | import org.junit.Test
7 | import java.net.Inet6Address
8 | import kotlin.random.Random
9 |
10 | class HotspotResponseTest {
11 |
12 | @Test
13 | fun givenHotspotResponse_whenConvertedToAndFromBytes_thenShouldBeEqual() {
14 | val response = LocalHotspotResponse(
15 | responseToMessageId = Random.nextInt(),
16 | errorCode = 0,
17 | config = WifiConnectConfig(
18 | nodeVirtualAddr = randomApipaAddr(),
19 | ssid = "test",
20 | passphrase = "world",
21 | port = 8042,
22 | hotspotType = HotspotType.LOCALONLY_HOTSPOT,
23 | linkLocalAddr = Inet6Address.getByName("2001:0db8:85a3:0000:0000:8a2e:0370:7334").requireAsIpv6(),
24 | ),
25 | redirectAddr = 0,
26 | )
27 |
28 | val responseArr = ByteArray(response.sizeInBytes + 10)
29 | response.toBytes(responseArr, 10)
30 |
31 | val responseFromBytes = LocalHotspotResponse.fromBytes(responseArr, 10)
32 | Assert.assertEquals(response, responseFromBytes)
33 | }
34 |
35 | }
--------------------------------------------------------------------------------
/test-app/src/main/java/com/ustadmobile/meshrabiya/testapp/ext/ContentResolverExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.testapp.ext
2 |
3 | import android.content.ContentResolver
4 | import android.net.Uri
5 | import android.provider.OpenableColumns
6 | import androidx.core.net.toFile
7 |
8 | data class UriNameAndSize(
9 | val name: String?,
10 | val size: Long,
11 | )
12 |
13 | fun ContentResolver.getUriNameAndSize(uri: Uri): UriNameAndSize {
14 | return if(uri.scheme == "file") {
15 | val uriFile = uri.toFile()
16 | UriNameAndSize(uriFile.name, uriFile.length())
17 | }else {
18 | query(
19 | uri, null, null, null, null
20 | )?.use { cursor ->
21 | var nameIndex = 0
22 | var sizeIndex = 0
23 | if(cursor.moveToFirst() &&
24 | cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME).also { nameIndex = it } >= 1 &&
25 | cursor.getColumnIndex(OpenableColumns.SIZE).also { sizeIndex = it } >= 1
26 | ) {
27 | val size = if(cursor.isNull(sizeIndex)) { null } else {
28 | cursor.getString(sizeIndex)
29 | }
30 | UriNameAndSize(cursor.getString(nameIndex), size?.toLong() ?: -1L)
31 | }else {
32 | null
33 | }
34 | } ?: UriNameAndSize(null, -1)
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/test/java/com/ustadmobile/meshrabiya/vnet/MeshrabiyaConnectLinkTest.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet
2 |
3 | import com.ustadmobile.meshrabiya.ext.requireAsIpv6
4 | import com.ustadmobile.meshrabiya.vnet.wifi.WifiConnectConfig
5 | import com.ustadmobile.meshrabiya.vnet.wifi.HotspotType
6 | import kotlinx.serialization.json.Json
7 | import org.junit.Assert
8 | import org.junit.Test
9 | import java.net.Inet6Address
10 |
11 | class MeshrabiyaConnectLinkTest {
12 |
13 | @Test
14 | fun givenLinkFromComponents_whenParsed_thenShouldMatchOriginal(){
15 | val json = Json { encodeDefaults = true }
16 | val link = MeshrabiyaConnectLink.fromComponents(
17 | nodeAddr = randomApipaAddr(),
18 | port = 8087,
19 | hotspotConfig = WifiConnectConfig(
20 | nodeVirtualAddr = randomApipaAddr(),
21 | ssid = "test",
22 | passphrase = "testpass",
23 | port = 8087,
24 | hotspotType = HotspotType.LOCALONLY_HOTSPOT,
25 | linkLocalAddr = Inet6Address.getByName("2001:0db8:85a3:0000:0000:8a2e:0370:7334").requireAsIpv6(),
26 | ),
27 | bluetoothConfig = null,
28 | json = json,
29 | )
30 |
31 | val parsedLink = MeshrabiyaConnectLink.parseUri(link.uri, json)
32 | Assert.assertEquals(link, parsedLink)
33 |
34 |
35 | }
36 |
37 | }
--------------------------------------------------------------------------------
/gradle.properties:
--------------------------------------------------------------------------------
1 | # Project-wide Gradle settings.
2 | # IDE (e.g. Android Studio) users:
3 | # Gradle settings configured through the IDE *will override*
4 | # any settings specified in this file.
5 | # For more details on how to configure your build environment visit
6 | # http://www.gradle.org/docs/current/userguide/build_environment.html
7 | # Specifies the JVM arguments used for the daemon process.
8 | # The setting is particularly useful for tweaking memory settings.
9 | org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
10 | # When configured, Gradle will run in incubating parallel mode.
11 | # This option should only be used with decoupled projects. More details, visit
12 | # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
13 | # org.gradle.parallel=true
14 | # AndroidX package structure to make it clearer which packages are bundled with the
15 | # Android operating system, and which are packaged with your app's APK
16 | # https://developer.android.com/topic/libraries/support-library/androidx-rn
17 | android.useAndroidX=true
18 | # Kotlin code style for this project: "official" or "obsolete":
19 | kotlin.code.style=official
20 | # Enables namespacing of each library's R class so that its R class includes only the
21 | # resources declared in the library itself and none from the library's dependencies,
22 | # thereby reducing the size of the R class for that library
23 | android.nonTransitiveRClass=true
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/util/UuidMaskUtil.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.util
2 |
3 | import java.util.UUID
4 |
5 |
6 | /**
7 | * Using a UUID mask all clients share the same UUID mask (the first 112 bits of the UUID) and the
8 | * remaining 16 bits are randomly allocated. This allows a preset to be shared without any two clients
9 | * using exactly the same UUID.
10 | *
11 | * This also allows each node to have a single port that can then be used to determine the final UUID
12 | * e.g. if the mask and port are known, we know the UUID that will be used for a particular service.
13 | */
14 | fun uuidForMaskAndPort(mask: UUID, port: Int): UUID{
15 | val newLeastSigBits = mask.leastSignificantBits.shl(16)
16 | .or(port.toLong())
17 | return UUID(mask.mostSignificantBits, newLeastSigBits)
18 | }
19 |
20 | /**
21 | * Return the port portion of this UUID if it was created using uuidForMaskAndPort
22 | */
23 | fun UUID.maskedPort(): Int {
24 | return leastSignificantBits.and(0xffff).toInt()
25 | }
26 |
27 | /**
28 | * Check if given UUID matches a mask (e.g. as used in uuidForMaskAndPort)
29 | */
30 | fun UUID.matchesMask(mask: UUID): Boolean {
31 | if(mask.mostSignificantBits != mostSignificantBits)
32 | return false
33 |
34 | //Cut off the rightmost 16 bits (e.g. where the port is stored)
35 | val uuidLeastSigBitsWithoutPort = leastSignificantBits.shr(16).shl(16)
36 | return mask.leastSignificantBits.shl(16) == uuidLeastSigBitsWithoutPort
37 | }
38 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/VirtualNodeReturnPathSocketFactory.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet
2 |
3 | import com.ustadmobile.meshrabiya.ext.findLocalInetAddressForDestinationAddress
4 | import com.ustadmobile.meshrabiya.ext.prefixMatches
5 | import com.ustadmobile.meshrabiya.portforward.ReturnPathSocketFactory
6 | import java.lang.IllegalArgumentException
7 | import java.net.DatagramSocket
8 | import java.net.InetAddress
9 |
10 | /**
11 | * Implementation of return path socket factory that can create an IDatagramSocket for the real
12 | * network or a virtual datagram socket.
13 | *
14 | * If a destination is on the real network, then the created socket will be bound to the network
15 | * interface where the netmask matches the given destination address.
16 | */
17 | class VirtualNodeReturnPathSocketFactory(
18 | private val node: VirtualNode,
19 | ): ReturnPathSocketFactory {
20 |
21 |
22 | override fun createSocket(destAddress: InetAddress, port: Int): DatagramSocket {
23 | return if(
24 | destAddress.address.prefixMatches(node.networkPrefixLength, node.address.address)
25 | ) {
26 | node.createBoundDatagramSocket(0)
27 | }else{
28 | val bindAddress = findLocalInetAddressForDestinationAddress(destAddress)
29 |
30 | return bindAddress?.let { DatagramSocket(0, it) }
31 | ?: throw IllegalArgumentException("Could not find network interface with subnet " +
32 | "mask for dest address $destAddress")
33 | }
34 | }
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/wifi/ConnectBand.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet.wifi
2 |
3 | import kotlinx.serialization.KSerializer
4 | import kotlinx.serialization.Serializable
5 | import kotlinx.serialization.descriptors.PrimitiveKind
6 | import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
7 | import kotlinx.serialization.descriptors.SerialDescriptor
8 | import kotlinx.serialization.encoding.Decoder
9 | import kotlinx.serialization.encoding.Encoder
10 |
11 | @Serializable(with = ConnectBandSerializer::class)
12 | enum class ConnectBand(val flag: Byte) {
13 | //Ids are as per WifiP2pConfig GROUP_OWNER_BAND_
14 | BAND_2GHZ(1), BAND_5GHZ(2), BAND_UNKNOWN(0),
15 | ;
16 |
17 | override fun toString(): String {
18 | return when(this) {
19 | BAND_2GHZ -> "2Ghz"
20 | BAND_5GHZ -> "5Ghz"
21 | BAND_UNKNOWN -> "Band unknown"
22 | }
23 | }
24 |
25 | companion object {
26 | fun fromFlag(flag: Byte): ConnectBand {
27 | return values().first { it.flag == flag }
28 | }
29 |
30 | }
31 | }
32 |
33 | object ConnectBandSerializer: KSerializer {
34 | override fun deserialize(decoder: Decoder): ConnectBand {
35 | return ConnectBand.fromFlag(decoder.decodeByte())
36 | }
37 |
38 | override val descriptor: SerialDescriptor
39 | get() = PrimitiveSerialDescriptor("connectBand", PrimitiveKind.BYTE)
40 |
41 | override fun serialize(encoder: Encoder, value: ConnectBand) {
42 | encoder.encodeByte(value.flag)
43 | }
44 | }
45 |
46 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/mmcp/MmcpPong.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.mmcp
2 |
3 | import java.nio.ByteBuffer
4 | import java.nio.ByteOrder
5 |
6 | /**
7 | * @param replyToMessageId the message ID of the ping that this is a reply to
8 | */
9 | class MmcpPong(
10 | messageId: Int,
11 | val replyToMessageId: Int,
12 | ): MmcpMessage(WHAT_PONG, messageId) {
13 | override fun toBytes() = headerAndPayloadToBytes(header,
14 | ByteBuffer.wrap(ByteArray(4))
15 | .order(ByteOrder.BIG_ENDIAN)
16 | .putInt(replyToMessageId)
17 | .array())
18 |
19 | override fun equals(other: Any?): Boolean {
20 | if (this === other) return true
21 | if (other !is MmcpPong) return false
22 | if (!super.equals(other)) return false
23 |
24 | if (replyToMessageId != other.replyToMessageId) return false
25 |
26 | return true
27 | }
28 |
29 | override fun hashCode(): Int {
30 | var result = super.hashCode()
31 | result = 31 * result + replyToMessageId
32 | return result
33 | }
34 |
35 |
36 | companion object {
37 |
38 | fun fromBytes(
39 | byteArray: ByteArray,
40 | offset: Int = 0,
41 | len: Int = byteArray.size,
42 | ): MmcpPong {
43 | val (header, payload) = mmcpHeaderAndPayloadFromBytes(byteArray, offset, len)
44 | val replyToMessageId = ByteBuffer.wrap(payload)
45 | .order(ByteOrder.BIG_ENDIAN)
46 | .int
47 |
48 | return MmcpPong(header.messageId, replyToMessageId)
49 | }
50 |
51 | }
52 | }
--------------------------------------------------------------------------------
/test-shared/build.gradle:
--------------------------------------------------------------------------------
1 | plugins {
2 | id 'com.android.library'
3 | id 'org.jetbrains.kotlin.android'
4 | id 'org.jetbrains.kotlin.plugin.serialization'
5 | }
6 |
7 | android {
8 | namespace 'com.ustadmobile.meshrabiya.test'
9 | compileSdk 33
10 |
11 | defaultConfig {
12 | minSdk 26
13 | targetSdk 33
14 |
15 | testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
16 | consumerProguardFiles "consumer-rules.pro"
17 | }
18 |
19 | buildTypes {
20 | release {
21 | minifyEnabled false
22 | proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
23 | }
24 | }
25 |
26 | compileOptions {
27 | coreLibraryDesugaringEnabled true
28 |
29 | sourceCompatibility JavaVersion.VERSION_17
30 | targetCompatibility JavaVersion.VERSION_17
31 | }
32 | kotlinOptions {
33 | jvmTarget = JavaVersion.VERSION_17
34 | }
35 | }
36 |
37 | dependencies {
38 | implementation project(':lib-meshrabiya')
39 | implementation 'androidx.core:core-ktx:1.8.0'
40 | implementation 'junit:junit:4.13.2'
41 | implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$version_coroutines"
42 | implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:$version_kotlinx_serialization"
43 | implementation "org.mockito.kotlin:mockito-kotlin:$version_kotlin_mockito"
44 | implementation "app.cash.turbine:turbine:$version_turbine"
45 | implementation "com.squareup.okhttp3:mockwebserver:$version_mockwebserver"
46 | implementation "com.squareup.okhttp3:okhttp:$version_okhttp"
47 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/mmcp/MmcpHotspotResponse.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.mmcp
2 |
3 | import com.ustadmobile.meshrabiya.vnet.wifi.LocalHotspotResponse
4 |
5 | class MmcpHotspotResponse(
6 | messageId: Int,
7 | val result: LocalHotspotResponse,
8 | ) : MmcpMessage(WHAT_HOTSPOT_RESPONSE, messageId) {
9 |
10 | override fun toBytes(): ByteArray {
11 | return headerAndPayloadToBytes(header, result.toBytes())
12 | }
13 |
14 | override fun equals(other: Any?): Boolean {
15 | if (this === other) return true
16 | if (other !is MmcpHotspotResponse) return false
17 | if (!super.equals(other)) return false
18 |
19 | if (result != other.result) return false
20 |
21 | return true
22 | }
23 |
24 | override fun hashCode(): Int {
25 | var result1 = super.hashCode()
26 | result1 = 31 * result1 + result.hashCode()
27 | return result1
28 | }
29 |
30 |
31 | companion object {
32 |
33 | fun fromBytes(
34 | byteArray: ByteArray,
35 | offset: Int = 0,
36 | len: Int = byteArray.size,
37 | ): MmcpHotspotResponse {
38 | try {
39 | val (header, payload) = mmcpHeaderAndPayloadFromBytes(
40 | byteArray, offset, len
41 | )
42 |
43 | val response = LocalHotspotResponse.fromBytes(payload, 0)
44 | return MmcpHotspotResponse(header.messageId, response)
45 | }catch(e: Exception) {
46 | println("FFS")
47 | e.printStackTrace()
48 | throw e
49 | }
50 | }
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/ext/ByteArrayExt.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.ext
2 |
3 | import java.nio.ByteBuffer
4 | import java.nio.ByteOrder
5 | import kotlin.experimental.and
6 | import kotlin.math.min as mathMin
7 |
8 | fun ByteArray.ip4AddressToInt() : Int{
9 | return ByteBuffer.wrap(this).order(ByteOrder.BIG_ENDIAN).int
10 | }
11 |
12 | /**
13 | * Check if two network addresses match up to the given network prefix length.
14 | *
15 | * @receiver a ByteArray that represents a network address
16 | * @param networkPrefixLength the netmask prefix length to check (in bits). e.g. to check a /16 match then 16, etc.
17 | * @param otherAddress a ByteArray that represents another network address
18 | *
19 | * @return true if the addresses are the same for the first networkPrefixLength bits, false otherwise
20 | */
21 | fun ByteArray.prefixMatches(
22 | networkPrefixLength: Int,
23 | otherAddress: ByteArray
24 | ) : Boolean {
25 | var bitsCompared = 0
26 | var bitsToCompare = 0
27 |
28 | var index = 0
29 | var mask : Byte
30 | while(bitsCompared < networkPrefixLength) {
31 | bitsToCompare = mathMin(8, networkPrefixLength - bitsCompared)
32 |
33 | if(bitsToCompare == 8) {
34 | if(this[index] != otherAddress[index])
35 | return false
36 | }else {
37 | for(b in 0 until bitsToCompare) {
38 | mask = 1.shl(b).toByte()
39 |
40 | if(this[index].and(mask) != otherAddress[index].and(mask))
41 | return false
42 | }
43 | }
44 |
45 | bitsCompared += bitsToCompare
46 | index++
47 | }
48 |
49 | return true
50 | }
51 |
52 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/vnet/VirtualRouter.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet
2 |
3 | import com.ustadmobile.meshrabiya.vnet.datagram.VirtualDatagramSocketImpl
4 | import com.ustadmobile.meshrabiya.vnet.socket.ChainSocketNextHop
5 | import java.net.DatagramPacket
6 | import java.net.InetAddress
7 |
8 | /**
9 | * Represents the netwrok
10 | */
11 | interface VirtualRouter {
12 |
13 | val address: InetAddress
14 |
15 | val networkPrefixLength: Int
16 |
17 | /**
18 | * Route the given incoming packet.
19 | *
20 | * @param packet the packet received
21 | */
22 | fun route(
23 | packet: VirtualPacket,
24 | datagramPacket: DatagramPacket? = null,
25 | virtualNodeDatagramSocket: VirtualNodeDatagramSocket? = null,
26 | )
27 |
28 | /**
29 | * When using chain sockets this function will lookup the next hop for the given virtual
30 | * address.
31 | */
32 | fun lookupNextHopForChainSocket(
33 | address: InetAddress,
34 | port: Int,
35 | ): ChainSocketNextHop
36 |
37 | fun nextMmcpMessageId(): Int
38 |
39 | /**
40 | * The default datagram socket local port (not bound to any network). Used to send/receive
41 | * VirtualPackets over the real network.
42 | */
43 | val localDatagramPort: Int
44 |
45 |
46 | /**
47 | * Allocate a port on the virtual router
48 | */
49 | fun allocateUdpPortOrThrow(
50 | virtualDatagramSocketImpl: VirtualDatagramSocketImpl,
51 | portNum: Int
52 | ): Int
53 |
54 | fun deallocatePort(
55 | protocol: Protocol,
56 | portNum: Int
57 | )
58 |
59 |
60 | companion object {
61 |
62 |
63 |
64 | }
65 |
66 | }
67 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/test/java/com/ustadmobile/meshrabiya/mmcp/MmcpHotspotResponseTest.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.mmcp
2 |
3 | import com.ustadmobile.meshrabiya.ext.requireAsIpv6
4 | import com.ustadmobile.meshrabiya.vnet.randomApipaAddr
5 | import com.ustadmobile.meshrabiya.vnet.wifi.WifiConnectConfig
6 | import com.ustadmobile.meshrabiya.vnet.wifi.HotspotType
7 | import com.ustadmobile.meshrabiya.vnet.wifi.LocalHotspotResponse
8 | import org.junit.Assert
9 | import org.junit.Test
10 | import java.net.Inet6Address
11 | import kotlin.random.Random
12 |
13 | class MmcpHotspotResponseTest {
14 |
15 | @Test
16 | fun givenHotspotResponse_whenConvertedToFromBytes_thenShouldBeEqual() {
17 | val responseMessage = MmcpHotspotResponse(
18 | messageId = 42,
19 | result = LocalHotspotResponse(
20 | responseToMessageId = Random.nextInt(),
21 | errorCode = 0,
22 | config = WifiConnectConfig(
23 | nodeVirtualAddr = randomApipaAddr(),
24 | ssid = "test",
25 | passphrase = "secret",
26 | port = 8042,
27 | hotspotType = HotspotType.LOCALONLY_HOTSPOT,
28 | linkLocalAddr = Inet6Address.getByName("2001:0db8:85a3:0000:0000:8a2e:0370:7334").requireAsIpv6(),
29 | ),
30 | redirectAddr = 0
31 | )
32 | )
33 |
34 | val responseBytes = responseMessage.toBytes()
35 | val responseDeserialized = MmcpHotspotResponse.fromBytes(responseBytes) as MmcpHotspotResponse
36 | Assert.assertEquals(responseMessage.messageId, responseDeserialized.messageId)
37 | Assert.assertEquals(responseMessage.result, responseDeserialized.result)
38 | }
39 |
40 | }
--------------------------------------------------------------------------------
/lib-meshrabiya/src/main/java/com/ustadmobile/meshrabiya/mmcp/MmcpAck.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.mmcp
2 |
3 | import java.nio.ByteBuffer
4 | import java.nio.ByteOrder
5 |
6 | /**
7 | * An MMCP message may request an acknowledgement (ACK) reply - e.g. to be sure that the original
8 | * message was received.
9 | */
10 | class MmcpAck(
11 | messageId: Int,
12 | val ackOfMessageId: Int,
13 | ) : MmcpMessage(
14 | what = WHAT_ACK,
15 | messageId = messageId,
16 | ){
17 |
18 | override fun toBytes() = headerAndPayloadToBytes(header,
19 | ByteBuffer.wrap(ByteArray(MESSAGE_SIZE))
20 | .order(ByteOrder.BIG_ENDIAN)
21 | .putInt(ackOfMessageId)
22 | .array())
23 |
24 | override fun equals(other: Any?): Boolean {
25 | if (this === other) return true
26 | if (other !is MmcpAck) return false
27 | if (!super.equals(other)) return false
28 |
29 | if (ackOfMessageId != other.ackOfMessageId) return false
30 |
31 | return true
32 | }
33 |
34 | override fun hashCode(): Int {
35 | var result = super.hashCode()
36 | result = 31 * result + ackOfMessageId
37 | return result
38 | }
39 |
40 | companion object {
41 |
42 | //Size = size of ackOfMessageId = 4 bytes
43 | const val MESSAGE_SIZE = 4
44 |
45 | fun fromBytes(
46 | byteArray: ByteArray,
47 | offset: Int = 0,
48 | len: Int = byteArray.size,
49 | ): MmcpAck {
50 | val (header, payload) = mmcpHeaderAndPayloadFromBytes(byteArray, offset, len)
51 | val ackOfMessageId = ByteBuffer.wrap(payload).int
52 | return MmcpAck(messageId = header.messageId, ackOfMessageId = ackOfMessageId)
53 | }
54 |
55 | }
56 | }
57 |
--------------------------------------------------------------------------------
/lib-meshrabiya/src/test/java/com/ustadmobile/meshrabiya/vnet/VirtualPacketStreamTest.kt:
--------------------------------------------------------------------------------
1 | package com.ustadmobile.meshrabiya.vnet
2 |
3 | import com.ustadmobile.meshrabiya.ext.readVirtualPacket
4 | import com.ustadmobile.meshrabiya.ext.writeVirtualPacket
5 | import org.junit.Assert
6 | import org.junit.Test
7 | import java.io.ByteArrayInputStream
8 | import java.io.ByteArrayOutputStream
9 | import kotlin.random.Random
10 |
11 | class VirtualPacketStreamTest {
12 |
13 | @Test
14 | fun givenVirtualPacketWrittenToOutputStream_whenReadFromInputStream_thenWillMatch() {
15 | val payloadSize = 1000
16 | val data = Random.nextBytes(ByteArray(1000 + VirtualPacketHeader.HEADER_SIZE))
17 | val header = VirtualPacketHeader(
18 | toAddr = 1000,
19 | toPort = 8080,
20 | fromAddr = 1002,
21 | fromPort = 8072,
22 | lastHopAddr = 1002,
23 | hopCount = 1,
24 | maxHops = 4,
25 | payloadSize = payloadSize,
26 | )
27 |
28 | val outStream = ByteArrayOutputStream()
29 | val packet = VirtualPacket.fromHeaderAndPayloadData(
30 | header = header,
31 | data = data,
32 | payloadOffset = VirtualPacketHeader.HEADER_SIZE,
33 | )
34 | outStream.writeVirtualPacket(packet)
35 | outStream.flush()
36 |
37 | val writtenBytes = outStream.toByteArray()
38 |
39 | val inStream = ByteArrayInputStream(writtenBytes)
40 |
41 | val buf = ByteArray(8000)
42 | val packetIn = inStream.readVirtualPacket(buf, 0)
43 |
44 | Assert.assertEquals("Header matches", header, packetIn?.header)
45 | data.forEachIndexed { index, byte ->
46 | Assert.assertEquals(byte, packetIn!!.data[index])
47 | }
48 | }
49 |
50 | }
--------------------------------------------------------------------------------
/test-app/src/main/res/drawable-v24/ic_launcher_foreground.xml:
--------------------------------------------------------------------------------
1 |
7 |
8 |
9 |
15 |