335 lines
15 KiB
Kotlin
335 lines
15 KiB
Kotlin
package be.mygod.vpnhotspot
|
|
|
|
import android.app.Service
|
|
import android.content.Context
|
|
import android.content.Intent
|
|
import android.net.NetworkInfo
|
|
import android.net.wifi.WpsInfo
|
|
import android.net.wifi.p2p.WifiP2pGroup
|
|
import android.net.wifi.p2p.WifiP2pInfo
|
|
import android.net.wifi.p2p.WifiP2pManager
|
|
import android.os.Binder
|
|
import android.os.Handler
|
|
import android.os.Looper
|
|
import android.support.annotation.StringRes
|
|
import android.support.v4.content.LocalBroadcastManager
|
|
import android.util.Log
|
|
import android.widget.Toast
|
|
import be.mygod.vpnhotspot.App.Companion.app
|
|
import be.mygod.vpnhotspot.net.Routing
|
|
import be.mygod.vpnhotspot.net.VpnMonitor
|
|
import java.net.InetAddress
|
|
import java.util.regex.Pattern
|
|
|
|
class RepeaterService : Service(), WifiP2pManager.ChannelListener, VpnMonitor.Callback {
|
|
companion object {
|
|
const val ACTION_STATUS_CHANGED = "be.mygod.vpnhotspot.RepeaterService.STATUS_CHANGED"
|
|
const val KEY_NET_ID = "netId"
|
|
private const val TAG = "RepeaterService"
|
|
private const val TEMPORARY_NET_ID = -1
|
|
|
|
/**
|
|
* Matches the output of dumpsys wifip2p. This part is available since Android 4.2.
|
|
*
|
|
* Related sources:
|
|
* https://android.googlesource.com/platform/frameworks/base/+/f0afe4144d09aa9b980cffd444911ab118fa9cbe%5E%21/wifi/java/android/net/wifi/p2p/WifiP2pService.java
|
|
* https://android.googlesource.com/platform/frameworks/opt/net/wifi/+/a8d5e40/service/java/com/android/server/wifi/p2p/WifiP2pServiceImpl.java#639
|
|
*
|
|
* https://android.googlesource.com/platform/frameworks/base.git/+/android-5.0.0_r1/core/java/android/net/NetworkInfo.java#433
|
|
* https://android.googlesource.com/platform/frameworks/base.git/+/220871a/core/java/android/net/NetworkInfo.java#415
|
|
*/
|
|
private val patternNetworkInfo = "^mNetworkInfo .* (isA|a)vailable: (true|false)".toPattern(Pattern.MULTILINE)
|
|
|
|
/**
|
|
* Available since Android 4.3.
|
|
*
|
|
* Source: https://android.googlesource.com/platform/frameworks/base/+/android-4.3_r0.9/wifi/java/android/net/wifi/p2p/WifiP2pManager.java#958
|
|
*/
|
|
private val startWps = WifiP2pManager::class.java.getDeclaredMethod("startWps",
|
|
WifiP2pManager.Channel::class.java, WpsInfo::class.java, WifiP2pManager.ActionListener::class.java)
|
|
private fun WifiP2pManager.startWps(c: WifiP2pManager.Channel, wps: WpsInfo,
|
|
listener: WifiP2pManager.ActionListener) {
|
|
startWps.invoke(this, c, wps, listener)
|
|
}
|
|
|
|
/**
|
|
* Available since Android 4.2.
|
|
*
|
|
* Source: https://android.googlesource.com/platform/frameworks/base/+/android-4.2_r1/wifi/java/android/net/wifi/p2p/WifiP2pManager.java#1353
|
|
*/
|
|
private val deletePersistentGroup = WifiP2pManager::class.java.getDeclaredMethod("deletePersistentGroup",
|
|
WifiP2pManager.Channel::class.java, Int::class.java, WifiP2pManager.ActionListener::class.java)
|
|
private fun WifiP2pManager.deletePersistentGroup(c: WifiP2pManager.Channel, netId: Int,
|
|
listener: WifiP2pManager.ActionListener) {
|
|
deletePersistentGroup.invoke(this, c, netId, listener)
|
|
}
|
|
|
|
/**
|
|
* Available since Android 4.2.
|
|
*
|
|
* Source: https://android.googlesource.com/platform/frameworks/base/+/android-4.2_r1/wifi/java/android/net/wifi/p2p/WifiP2pGroup.java#253
|
|
*/
|
|
private val getNetworkId = WifiP2pGroup::class.java.getDeclaredMethod("getNetworkId")
|
|
private val WifiP2pGroup.netId get() = getNetworkId.invoke(this) as Int
|
|
}
|
|
|
|
enum class Status {
|
|
IDLE, STARTING, ACTIVE
|
|
}
|
|
|
|
inner class RepeaterBinder : Binder() {
|
|
val service get() = this@RepeaterService
|
|
var data: RepeaterFragment.Data? = null
|
|
val active get() = status == Status.ACTIVE
|
|
|
|
fun startWps(pin: String? = null) {
|
|
if (status != Status.ACTIVE) return
|
|
val wps = WpsInfo()
|
|
if (pin == null) wps.setup = WpsInfo.PBC else {
|
|
wps.setup = WpsInfo.KEYPAD
|
|
wps.pin = pin
|
|
}
|
|
p2pManager.startWps(channel, wps, object : WifiP2pManager.ActionListener {
|
|
override fun onSuccess() = Toast.makeText(this@RepeaterService,
|
|
if (pin == null) R.string.repeater_wps_success_pbc else R.string.repeater_wps_success_keypad,
|
|
Toast.LENGTH_SHORT).show()
|
|
override fun onFailure(reason: Int) = Toast.makeText(this@RepeaterService,
|
|
formatReason(R.string.repeater_wps_failure, reason), Toast.LENGTH_SHORT).show()
|
|
})
|
|
}
|
|
|
|
fun shutdown() {
|
|
if (status == Status.ACTIVE) removeGroup()
|
|
}
|
|
|
|
fun resetCredentials() {
|
|
val netId = app.pref.getInt(KEY_NET_ID, TEMPORARY_NET_ID)
|
|
if (netId == TEMPORARY_NET_ID) return
|
|
p2pManager.deletePersistentGroup(channel, netId, object : WifiP2pManager.ActionListener {
|
|
override fun onSuccess() = Toast.makeText(this@RepeaterService,
|
|
R.string.repeater_reset_credentials_success, Toast.LENGTH_SHORT).show()
|
|
override fun onFailure(reason: Int) = Toast.makeText(this@RepeaterService,
|
|
formatReason(R.string.repeater_reset_credentials_failure, reason), Toast.LENGTH_SHORT).show()
|
|
})
|
|
}
|
|
}
|
|
|
|
private val handler = Handler()
|
|
private val p2pManager by lazy { getSystemService(Context.WIFI_P2P_SERVICE) as WifiP2pManager }
|
|
private var _channel: WifiP2pManager.Channel? = null
|
|
private val channel: WifiP2pManager.Channel get() {
|
|
if (_channel == null) onChannelDisconnected()
|
|
return _channel!!
|
|
}
|
|
var group: WifiP2pGroup? = null
|
|
private set(value) {
|
|
field = value
|
|
if (value != null) app.pref.edit().putInt(KEY_NET_ID, value.netId).apply()
|
|
}
|
|
private val binder = RepeaterBinder()
|
|
private var receiverRegistered = false
|
|
private val receiver = broadcastReceiver { _, intent ->
|
|
when (intent.action) {
|
|
WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION ->
|
|
if (intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, 0) ==
|
|
WifiP2pManager.WIFI_P2P_STATE_DISABLED) clean() // ignore P2P enabled
|
|
WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION -> onP2pConnectionChanged(
|
|
intent.getParcelableExtra(WifiP2pManager.EXTRA_WIFI_P2P_INFO),
|
|
intent.getParcelableExtra(WifiP2pManager.EXTRA_NETWORK_INFO),
|
|
intent.getParcelableExtra(WifiP2pManager.EXTRA_WIFI_P2P_GROUP))
|
|
App.ACTION_CLEAN_ROUTINGS -> {
|
|
val routing = routing
|
|
routing!!.started = false
|
|
if (status == Status.ACTIVE && !initRouting(upstream!!, routing.downstream, routing.hostAddress))
|
|
Toast.makeText(this@RepeaterService, R.string.noisy_su_failure, Toast.LENGTH_SHORT).show()
|
|
}
|
|
}
|
|
}
|
|
private val onVpnUnavailable = Runnable { startFailure(getString(R.string.repeater_vpn_unavailable)) }
|
|
|
|
val ssid get() = if (status == Status.ACTIVE) group?.networkName else null
|
|
val password get() = if (status == Status.ACTIVE) group?.passphrase else null
|
|
|
|
private var upstream: String? = null
|
|
private var routing: Routing? = null
|
|
|
|
var status = Status.IDLE
|
|
private set(value) {
|
|
if (field == value) return
|
|
field = value
|
|
LocalBroadcastManager.getInstance(this).sendBroadcast(Intent(ACTION_STATUS_CHANGED))
|
|
}
|
|
|
|
private fun formatReason(@StringRes resId: Int, reason: Int) = getString(resId, when (reason) {
|
|
WifiP2pManager.ERROR -> getString(R.string.repeater_failure_reason_error)
|
|
WifiP2pManager.P2P_UNSUPPORTED -> getString(R.string.repeater_failure_reason_p2p_unsupported)
|
|
WifiP2pManager.BUSY -> getString(R.string.repeater_failure_reason_busy)
|
|
WifiP2pManager.NO_SERVICE_REQUESTS -> getString(R.string.repeater_failure_reason_no_service_requests)
|
|
else -> getString(R.string.repeater_failure_reason_unknown, reason)
|
|
})
|
|
|
|
override fun onBind(intent: Intent) = binder
|
|
|
|
override fun onChannelDisconnected() {
|
|
_channel = p2pManager.initialize(this, Looper.getMainLooper(), this)
|
|
}
|
|
|
|
/**
|
|
* startService 1st stop
|
|
*/
|
|
override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
|
|
if (status != Status.IDLE) return START_NOT_STICKY
|
|
status = Status.STARTING
|
|
handler.postDelayed(onVpnUnavailable, 4000)
|
|
VpnMonitor.registerCallback(this)
|
|
return START_NOT_STICKY
|
|
}
|
|
private fun startFailure(msg: CharSequence?, group: WifiP2pGroup? = null) {
|
|
Toast.makeText(this, msg, Toast.LENGTH_SHORT).show()
|
|
showNotification()
|
|
if (group != null) removeGroup() else clean()
|
|
}
|
|
|
|
/**
|
|
* startService 2nd stop, also called when VPN re-established
|
|
*/
|
|
override fun onAvailable(ifname: String) {
|
|
handler.removeCallbacks(onVpnUnavailable)
|
|
when (status) {
|
|
Status.STARTING -> {
|
|
val matcher = patternNetworkInfo.matcher(loggerSu("dumpsys ${Context.WIFI_P2P_SERVICE}") ?: "")
|
|
when {
|
|
!matcher.find() -> startFailure(getString(R.string.root_unavailable))
|
|
matcher.group(2) == "true" -> {
|
|
unregisterReceiver()
|
|
registerReceiver(receiver, intentFilter(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION,
|
|
WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION))
|
|
LocalBroadcastManager.getInstance(this)
|
|
.registerReceiver(receiver, intentFilter(App.ACTION_CLEAN_ROUTINGS))
|
|
receiverRegistered = true
|
|
upstream = ifname
|
|
p2pManager.requestGroupInfo(channel, {
|
|
when {
|
|
it == null -> doStart()
|
|
it.isGroupOwner -> doStart(it)
|
|
else -> {
|
|
Log.i(TAG, "Removing old group ($it)")
|
|
p2pManager.removeGroup(channel, object : WifiP2pManager.ActionListener {
|
|
override fun onSuccess() = doStart()
|
|
override fun onFailure(reason: Int) {
|
|
Toast.makeText(this@RepeaterService,
|
|
formatReason(R.string.repeater_remove_old_group_failure, reason),
|
|
Toast.LENGTH_SHORT).show()
|
|
}
|
|
})
|
|
}
|
|
}
|
|
})
|
|
}
|
|
else -> startFailure(getString(R.string.repeater_p2p_unavailable))
|
|
}
|
|
}
|
|
Status.ACTIVE -> {
|
|
val routing = routing
|
|
check(!routing!!.started)
|
|
if (!initRouting(ifname, routing.downstream, routing.hostAddress))
|
|
Toast.makeText(this, getText(R.string.noisy_su_failure), Toast.LENGTH_SHORT).show()
|
|
}
|
|
else -> throw IllegalStateException("RepeaterService is in unexpected state when receiving onAvailable")
|
|
}
|
|
}
|
|
override fun onLost(ifname: String) {
|
|
if (routing?.stop() == false)
|
|
Toast.makeText(this, getText(R.string.noisy_su_failure), Toast.LENGTH_SHORT).show()
|
|
upstream = null
|
|
}
|
|
|
|
private fun doStart() = p2pManager.createGroup(channel, object : WifiP2pManager.ActionListener {
|
|
override fun onFailure(reason: Int) = startFailure(formatReason(R.string.repeater_create_group_failure, reason))
|
|
override fun onSuccess() { } // wait for WIFI_P2P_CONNECTION_CHANGED_ACTION to fire
|
|
})
|
|
private fun doStart(group: WifiP2pGroup) {
|
|
this.group = group
|
|
status = Status.ACTIVE
|
|
showNotification(group)
|
|
}
|
|
|
|
/**
|
|
* startService 3rd stop (if a group isn't already available), also called when connection changed
|
|
*/
|
|
private fun onP2pConnectionChanged(info: WifiP2pInfo, net: NetworkInfo?, group: WifiP2pGroup) {
|
|
if (routing == null) onGroupCreated(info, group) else if (!group.isGroupOwner) { // P2P shutdown
|
|
clean()
|
|
return
|
|
}
|
|
this.group = group
|
|
binder.data?.onGroupChanged(group)
|
|
showNotification(group)
|
|
debugLog(TAG, "P2P connection changed: $info\n$net\n$group")
|
|
}
|
|
private fun onGroupCreated(info: WifiP2pInfo, group: WifiP2pGroup) {
|
|
if (!info.groupFormed || !info.isGroupOwner) return
|
|
val owner = info.groupOwnerAddress ?: return
|
|
val downstream = group.`interface` ?: return
|
|
receiverRegistered = true
|
|
try {
|
|
if (initRouting(upstream!!, downstream, owner)) doStart(group)
|
|
else startFailure(getText(R.string.noisy_su_failure), group)
|
|
} catch (e: Routing.InterfaceNotFoundException) {
|
|
startFailure(e.message, group)
|
|
return
|
|
}
|
|
}
|
|
private fun initRouting(upstream: String, downstream: String, owner: InetAddress): Boolean {
|
|
val routing = Routing(upstream, downstream, owner)
|
|
.ipForward() // Wi-Fi direct doesn't enable ip_forward
|
|
.rule().forward().dnsRedirect(app.dns)
|
|
return if (routing.start()) {
|
|
this.routing = routing
|
|
true
|
|
} else {
|
|
routing.stop()
|
|
false
|
|
}
|
|
}
|
|
|
|
private fun showNotification(group: WifiP2pGroup? = null) = ServiceNotification.startForeground(this,
|
|
if (group == null) emptyMap() else mapOf(Pair(group.`interface`, group.clientList?.size ?: 0)))
|
|
|
|
private fun removeGroup() {
|
|
p2pManager.removeGroup(channel, object : WifiP2pManager.ActionListener {
|
|
override fun onSuccess() = clean()
|
|
override fun onFailure(reason: Int) {
|
|
if (reason == WifiP2pManager.BUSY) clean() else { // assuming it's already gone
|
|
Toast.makeText(this@RepeaterService,
|
|
formatReason(R.string.repeater_remove_group_failure, reason), Toast.LENGTH_SHORT).show()
|
|
status = Status.ACTIVE
|
|
LocalBroadcastManager.getInstance(this@RepeaterService).sendBroadcast(Intent(ACTION_STATUS_CHANGED))
|
|
}
|
|
}
|
|
})
|
|
}
|
|
private fun unregisterReceiver() {
|
|
if (receiverRegistered) {
|
|
unregisterReceiver(receiver)
|
|
LocalBroadcastManager.getInstance(this).unregisterReceiver(receiver)
|
|
receiverRegistered = false
|
|
}
|
|
}
|
|
private fun clean() {
|
|
VpnMonitor.unregisterCallback(this)
|
|
unregisterReceiver()
|
|
if (routing?.stop() == false)
|
|
Toast.makeText(this, getText(R.string.noisy_su_failure), Toast.LENGTH_SHORT).show()
|
|
routing = null
|
|
status = Status.IDLE
|
|
ServiceNotification.stopForeground(this)
|
|
stopSelf()
|
|
}
|
|
|
|
override fun onDestroy() {
|
|
if (status != Status.IDLE) binder.shutdown()
|
|
super.onDestroy()
|
|
}
|
|
}
|