Skip to content

StreamVault is a TV-first free IPTV player for Android TV built with Kotlin, Jetpack Compose, Room, Hilt, and Media3.

Fix Stalker endpoint and auth session reuse

David Nashashe18bb94c047a
diff --git a/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt b/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt
index 71804b93..bb49a075 100644
--- a/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt
+++ b/data/src/main/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiService.kt
@@ -778,7 +778,7 @@ class OkHttpStalkerApiService @Inject constructor(
StalkerStreamKind.MOVIE,
StalkerStreamKind.EPISODE -> "0"
}
- val playbackLoadUrl = createLinkLoadUrl(session, kind)
+ val playbackLoadUrl = createLinkLoadUrl(session)
val payload = requestJson(
url = playbackLoadUrl,
profile = profile,
@@ -817,23 +817,8 @@ class OkHttpStalkerApiService @Inject constructor(
?: throw IOException("Portal did not return a playable URL.")
}
- private fun createLinkLoadUrl(
- session: StalkerSession,
- kind: StalkerStreamKind
- ): String {
- if (kind != StalkerStreamKind.LIVE && kind != StalkerStreamKind.ARCHIVE) {
- return session.loadUrl
- }
- if (session.fingerprintEvidence.playbackBackendHint != StalkerPlaybackBackendHint.TEMP_LINK_STRICT) {
- return session.loadUrl
- }
- val normalized = StalkerUrlFactory.normalizePortalUrl(session.loadUrl)
- if (!normalized.lowercase(Locale.ROOT).endsWith("/server/load.php")) {
- return session.loadUrl
- }
- return siblingLoadUrl(normalized)
- ?.takeIf { it.lowercase(Locale.ROOT).endsWith("/portal.php") }
- ?: session.loadUrl
+ private fun createLinkLoadUrl(session: StalkerSession): String {
+ return session.loadUrl
}
override fun currentCookieHeader(session: StalkerSession): String =
@@ -2319,14 +2304,27 @@ class OkHttpStalkerApiService @Inject constructor(
recipe: StalkerRecipeSpec
): List<String> {
val baseCandidates = StalkerUrlFactory.loadUrlCandidates(profile.portalUrl)
+ when (profile.endpointPreference) {
+ StalkerEndpointPreference.PORTAL -> {
+ return baseCandidates.filter { candidate ->
+ candidate.lowercase(Locale.ROOT).endsWith("/portal.php")
+ }.ifEmpty { baseCandidates }
+ }
+ StalkerEndpointPreference.SERVER_LOAD -> {
+ return baseCandidates.filter { candidate ->
+ candidate.lowercase(Locale.ROOT).endsWith("/server/load.php")
+ }.ifEmpty { baseCandidates }
+ }
+ StalkerEndpointPreference.AUTO -> Unit
+ }
val preferred = recipe.endpointPreference.takeUnless { it == StalkerEndpointPreference.AUTO }
- ?: profile.endpointPreference
return when (preferred) {
StalkerEndpointPreference.PORTAL ->
baseCandidates.sortedByDescending { candidate -> candidate.lowercase(Locale.ROOT).endsWith("/portal.php") }
StalkerEndpointPreference.SERVER_LOAD ->
baseCandidates.sortedByDescending { candidate -> candidate.lowercase(Locale.ROOT).endsWith("/server/load.php") }
- StalkerEndpointPreference.AUTO -> baseCandidates
+ StalkerEndpointPreference.AUTO,
+ null -> baseCandidates
}
}
diff --git a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerProvider.kt b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerProvider.kt
index 5aa36e0a..9f09114a 100644
--- a/data/src/main/java/com/streamvault/data/remote/stalker/StalkerProvider.kt
+++ b/data/src/main/java/com/streamvault/data/remote/stalker/StalkerProvider.kt
@@ -30,6 +30,7 @@ import java.net.URI
import java.net.URLEncoder
import java.util.Base64
import java.util.Locale
+import java.util.concurrent.ConcurrentHashMap
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
@@ -82,10 +83,20 @@ class StalkerProvider(
private val signature: String = "",
private val stalkerAdvancedOptionsJson: String = ""
) : IptvProvider {
- private companion object {
+ internal companion object {
private const val TAG = "StalkerProvider"
+ private val sharedAuthCache = ConcurrentHashMap<String, CachedAuth>()
+
+ fun clearSharedAuthCacheForTests() {
+ sharedAuthCache.clear()
+ }
}
+ private data class CachedAuth(
+ val session: StalkerSession,
+ val profile: StalkerProviderProfile
+ )
+
private data class CategorySeed(
val id: Long,
val rawId: String,
@@ -102,6 +113,7 @@ class StalkerProvider(
sessionCache = null
accountProfileCache = null
categoryCache.clear()
+ sharedAuthCache.remove(authCacheKey())
}
}
@@ -785,6 +797,11 @@ class StalkerProvider(
if (cachedSession != null && cachedProfile != null) {
return@withLock Result.success(cachedSession to cachedProfile)
}
+ sharedAuthCache[authCacheKey()]?.let { cachedAuth ->
+ sessionCache = cachedAuth.session
+ accountProfileCache = cachedAuth.profile
+ return@withLock Result.success(cachedAuth.session to cachedAuth.profile)
+ }
val profile = buildStalkerDeviceProfile(
portalUrl = portalUrl,
@@ -813,6 +830,10 @@ class StalkerProvider(
is Result.Success -> {
sessionCache = authResult.data.first
accountProfileCache = authResult.data.second
+ sharedAuthCache[authCacheKey()] = CachedAuth(
+ session = authResult.data.first,
+ profile = authResult.data.second
+ )
Result.success(authResult.data)
}
is Result.Error -> Result.error(authResult.message, authResult.exception)
@@ -1496,6 +1517,33 @@ class StalkerProvider(
private fun normalizedSignature(): String =
signature.trim().uppercase(Locale.ROOT)
+ private fun authCacheKey(): String = listOf(
+ providerId.toString(),
+ StalkerUrlFactory.normalizePortalUrl(portalUrl),
+ normalizedMacAddress(),
+ authMode.name,
+ normalizedUsername(),
+ normalizedPassword(),
+ httpUserAgent.trim(),
+ httpHeaders,
+ portalFingerprintHint.name,
+ magPresetHint.name,
+ bootstrapRecipeHint.name,
+ endpointPreferenceHint.name,
+ cookieModeHint.name,
+ playbackBackendHint.name,
+ portalProfileHint.name,
+ preferredPlaybackMode?.name.orEmpty(),
+ normalizedDeviceProfile(),
+ normalizedTimezone(),
+ normalizedLocale(),
+ normalizedSerialNumber(),
+ normalizedDeviceId(),
+ normalizedDeviceId2(),
+ normalizedSignature(),
+ stalkerAdvancedOptionsJson
+ ).joinToString(separator = "\u001f")
+
private fun resolveProviderStatus(profile: StalkerProviderProfile): ProviderStatus {
val normalizedStatus = profile.statusLabel?.trim()?.lowercase(Locale.ROOT).orEmpty()
if (normalizedStatus in setOf("disabled", "blocked", "banned")) {
diff --git a/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt b/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt
index bd55285d..185b9720 100644
--- a/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt
+++ b/data/src/test/java/com/streamvault/data/remote/stalker/OkHttpStalkerApiServiceTest.kt
@@ -4,6 +4,7 @@ import com.google.common.truth.Truth.assertThat
import com.streamvault.domain.model.Result
import com.streamvault.domain.model.StalkerAuthMode
import com.streamvault.domain.model.StalkerBootstrapRecipe
+import com.streamvault.domain.model.StalkerEndpointPreference
import com.streamvault.domain.model.StalkerMagPreset
import com.streamvault.domain.model.StalkerPlaybackBackendHint
import kotlinx.coroutines.test.runTest
@@ -153,6 +154,113 @@ class OkHttpStalkerApiServiceTest {
assertThat(requestedPaths).contains("/server/load.php")
}
+ @Test
+ fun authenticate_usesOnlyLearnedServerLoadEndpoint() = runTest {
+ val requestedPaths = mutableListOf<String>()
+ val service = OkHttpStalkerApiService(
+ okHttpClient = OkHttpClient.Builder()
+ .addInterceptor { chain ->
+ val request = chain.request()
+ requestedPaths += request.url.encodedPath
+ val action = request.url.queryParameter("action").orEmpty()
+ if (request.url.encodedPath == "/portal.php") {
+ Response.Builder()
+ .request(request)
+ .protocol(Protocol.HTTP_1_1)
+ .code(404)
+ .message("Not Found")
+ .body("""{"js":{}}""".toResponseBody("application/json".toMediaType()))
+ .build()
+ } else {
+ val body = when (action) {
+ "handshake" -> """{"js":{"token":"token-123"}}"""
+ "get_profile" -> """{"js":{"name":"Server Load","status":"1","auth_access":true}}"""
+ else -> """{"js":{}}"""
+ }
+ Response.Builder()
+ .request(request)
+ .protocol(Protocol.HTTP_1_1)
+ .code(200)
+ .message("OK")
+ .body(body.toResponseBody("application/json".toMediaType()))
+ .build()
+ }
+ }
+ .build(),
+ json = Json { ignoreUnknownKeys = true }
+ )
+
+ val result = service.authenticate(
+ buildStalkerDeviceProfile(
+ portalUrl = "https://portal.example.com/c",
+ macAddress = "00:1A:79:12:34:56",
+ authMode = StalkerAuthMode.AUTO,
+ endpointPreferenceHint = StalkerEndpointPreference.SERVER_LOAD,
+ deviceProfile = "MAG250",
+ timezone = "UTC",
+ locale = "en"
+ )
+ )
+
+ assertThat(result).isInstanceOf(Result.Success::class.java)
+ assertThat(requestedPaths).contains("/server/load.php")
+ assertThat(requestedPaths).doesNotContain("/portal.php")
+ }
+
+ @Test
+ fun createLink_usesSessionEndpointForTempLinkStrictLivePlayback() = runTest {
+ val requestedPaths = mutableListOf<String>()
+ val service = OkHttpStalkerApiService(
+ okHttpClient = OkHttpClient.Builder()
+ .addInterceptor { chain ->
+ val request = chain.request()
+ requestedPaths += request.url.encodedPath
+ val body = when (request.url.queryParameter("action")) {
+ "create_link" -> """{"js":{"cmd":"ffmpeg http://cdn.example.com/live/1.ts"}}"""
+ else -> error("Unexpected action '${request.url.queryParameter("action")}'")
+ }
+ Response.Builder()
+ .request(request)
+ .protocol(Protocol.HTTP_1_1)
+ .code(200)
+ .message("OK")
+ .body(body.toResponseBody("application/json".toMediaType()))
+ .build()
+ }
+ .build(),
+ json = Json { ignoreUnknownKeys = true }
+ )
+ val session = StalkerSession(
+ loadUrl = "https://portal.example.com/server/load.php",
+ portalReferer = "https://portal.example.com/c/",
+ token = "token-123",
+ fingerprintEvidence = StalkerFingerprintEvidence(
+ endpointPreference = StalkerEndpointPreference.SERVER_LOAD,
+ playbackBackendHint = StalkerPlaybackBackendHint.TEMP_LINK_STRICT
+ )
+ )
+
+ val result = service.createLink(
+ session = session,
+ profile = buildStalkerDeviceProfile(
+ portalUrl = "https://portal.example.com/c",
+ macAddress = "00:1A:79:12:34:56",
+ endpointPreferenceHint = StalkerEndpointPreference.SERVER_LOAD,
+ deviceProfile = "MAG250",
+ timezone = "UTC",
+ locale = "en"
+ ),
+ kind = StalkerStreamKind.LIVE,
+ cmd = "ffmpeg http://cdn.example.com/live/1.ts",
+ seriesNumber = null,
+ archiveStartSeconds = null,
+ archiveEndSeconds = null
+ )
+
+ assertThat(result).isInstanceOf(Result.Success::class.java)
+ assertThat(requestedPaths).containsExactly("/server/load.php")
+ }
+
@Test
fun authenticate_applies_getProfile_param_overrides_and_keeps_jshttprequest_last() = runTest {
var profileRawQuery = ""
@@ -475,7 +583,7 @@ class OkHttpStalkerApiServiceTest {
}
@Test
- fun createLink_prefers_portal_endpoint_for_strict_live_temp_links() = runTest {
+ fun createLink_keeps_session_endpoint_for_strict_live_temp_links() = runTest {
val requestedPaths = mutableListOf<String>()
val service = OkHttpStalkerApiService(
okHttpClient = OkHttpClient.Builder()
@@ -518,7 +626,7 @@ class OkHttpStalkerApiServiceTest {
)
assertThat(result).isInstanceOf(Result.Success::class.java)
- assertThat(requestedPaths).containsExactly("/portal.php")
+ assertThat(requestedPaths).containsExactly("/server/load.php")
}
@Test
diff --git a/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt b/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt
index e90d3681..2f44f518 100644
--- a/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt
+++ b/data/src/test/java/com/streamvault/data/remote/stalker/StalkerProviderTest.kt
@@ -5,10 +5,16 @@ import com.streamvault.domain.model.ProviderStatus
import com.streamvault.domain.model.Result
import java.time.Instant
import kotlinx.coroutines.test.runTest
+import org.junit.Before
import org.junit.Test
class StalkerProviderTest {
+ @Before
+ fun clearSharedAuthCache() {
+ StalkerProvider.clearSharedAuthCacheForTests()
+ }
+
@Test
fun authenticate_treats_status_zero_as_partial_not_expired() = runTest {
val provider = StalkerProvider(
@@ -82,6 +88,64 @@ class StalkerProviderTest {
assertThat(authProfile.signature).isEmpty()
}
+ @Test
+ fun authenticate_reusesSessionAcrossEquivalentProviderInstances() = runTest {
+ val api = FakeStalkerApiService(profile = StalkerProviderProfile(accountName = "Room"))
+ val firstProvider = StalkerProvider(
+ providerId = 7,
+ api = api,
+ portalUrl = "https://portal.example.com/c/",
+ macAddress = "00:1A:79:12:34:56",
+ deviceProfile = "MAG250",
+ timezone = "UTC",
+ locale = "en"
+ )
+ val secondProvider = StalkerProvider(
+ providerId = 7,
+ api = api,
+ portalUrl = "https://portal.example.com/c/",
+ macAddress = "00:1A:79:12:34:56",
+ deviceProfile = "MAG250",
+ timezone = "UTC",
+ locale = "en"
+ )
+
+ assertThat(firstProvider.authenticate()).isInstanceOf(Result.Success::class.java)
+ assertThat(secondProvider.authenticate()).isInstanceOf(Result.Success::class.java)
+
+ assertThat(api.authenticateCalls).isEqualTo(1)
+ }
+
+ @Test
+ fun invalidateAuthenticationClearsSharedSessionForEquivalentProviderInstances() = runTest {
+ val api = FakeStalkerApiService(profile = StalkerProviderProfile(accountName = "Room"))
+ val firstProvider = StalkerProvider(
+ providerId = 7,
+ api = api,
+ portalUrl = "https://portal.example.com/c/",
+ macAddress = "00:1A:79:12:34:56",
+ deviceProfile = "MAG250",
+ timezone = "UTC",
+ locale = "en"
+ )
+ val secondProvider = StalkerProvider(
+ providerId = 7,
+ api = api,
+ portalUrl = "https://portal.example.com/c/",
+ macAddress = "00:1A:79:12:34:56",
+ deviceProfile = "MAG250",
+ timezone = "UTC",
+ locale = "en"
+ )
+
+ assertThat(firstProvider.authenticate()).isInstanceOf(Result.Success::class.java)
+ firstProvider.invalidateAuthentication()
+ assertThat(secondProvider.authenticate()).isInstanceOf(Result.Success::class.java)
+
+ assertThat(api.authenticateCalls).isEqualTo(2)
+ }
+
+
@Test
fun getLiveStreams_maps_archive_capabilities_to_catch_up_fields() = runTest {
val provider = StalkerProvider(
@@ -521,10 +585,13 @@ class StalkerProviderTest {
) : StalkerApiService {
var createLinkCalls: Int = 0
private set
+ var authenticateCalls: Int = 0
+ private set
var lastAuthenticateProfile: StalkerDeviceProfile? = null
private set
override suspend fun authenticate(profile: StalkerDeviceProfile): Result<Pair<StalkerSession, StalkerProviderProfile>> {
+ authenticateCalls += 1
lastAuthenticateProfile = profile
return Result.success(
StalkerSession(