mirror of
https://github.com/kalarina-bit/Matewave.git
synced 2026-11-22 16:16:10 +00:00
Validate what the opponent sends and keep friend images in files
- Images from another device are size-checked before they are decoded, shown or stored: more than 4096 px on a side is refused, decoding is capped and OutOfMemoryError is caught. A crafted avatar or background could otherwise crash the app every time the friend card was drawn. - Profiles with an out-of-range name, user id, rating or time control are refused and the connection is closed; nothing is stored for them. Names and ratings from presence are bounded in the friends list too. - The opponent's clock claim may not exceed what our clock gives them plus increment and slack, so a modified client cannot keep its time. The increment was also added twice on the receiving side; fixed. - Joining a player from the nearby list checks that the profile belongs to the announced player and flags the opponent as unverified otherwise. - Friend avatars and backgrounds move from one large settings value to one file per image; existing entries are migrated on first read. - The in-game chat keeps the last 200 messages.
This commit is contained in:
@@ -333,9 +333,12 @@ private fun AppNavHost() {
|
||||
viewModel.startVsPlayerNetwork(transport, PieceColor.WHITE, timeControl, isHost = true)
|
||||
navController.navigate("game")
|
||||
},
|
||||
onJoin = { type, timeControl, targetId ->
|
||||
onJoin = { type, timeControl, targetId, expectedUserId ->
|
||||
val transport = if (type == TransportType.BLUETOOTH) bleTransport else lanTransport
|
||||
viewModel.startVsPlayerNetwork(transport, PieceColor.BLACK, timeControl, isHost = false, targetId = targetId)
|
||||
viewModel.startVsPlayerNetwork(
|
||||
transport, PieceColor.BLACK, timeControl, isHost = false,
|
||||
targetId = targetId, expectedUserId = expectedUserId
|
||||
)
|
||||
navController.navigate("game")
|
||||
},
|
||||
onBack = { navController.popBackStack() }
|
||||
|
||||
@@ -98,6 +98,12 @@ class GameClock(private val timeControl: TimeControl, private val scope: Corouti
|
||||
publish()
|
||||
}
|
||||
|
||||
/** Time left for [side] right now, including the part of the current second already used. */
|
||||
fun remainingMillis(side: PieceColor): Long {
|
||||
account()
|
||||
return if (side == PieceColor.WHITE) whiteLeft else blackLeft
|
||||
}
|
||||
|
||||
fun restore(whiteMillis: Long, blackMillis: Long) {
|
||||
if (unlimited) return
|
||||
account()
|
||||
|
||||
@@ -2,8 +2,12 @@ package cc.skysparkle.matewave.data
|
||||
|
||||
import cc.skysparkle.matewave.ai.AiDifficulty
|
||||
import android.content.Context
|
||||
import cc.skysparkle.matewave.network.PeerLimits
|
||||
import cc.skysparkle.matewave.security.toHex
|
||||
import org.json.JSONArray
|
||||
import org.json.JSONObject
|
||||
import java.io.File
|
||||
import java.security.MessageDigest
|
||||
import kotlin.math.pow
|
||||
import kotlin.math.roundToInt
|
||||
|
||||
@@ -111,6 +115,7 @@ object FriendsStore {
|
||||
private const val PREFS = "chess_friends_prefs"
|
||||
private const val KEY_LIST = "friends_json"
|
||||
private const val MAX_FRIENDS = 30
|
||||
private const val IMAGE_DIR = "friend_images"
|
||||
|
||||
private var appContext: Context? = null
|
||||
|
||||
@@ -125,6 +130,36 @@ object FriendsStore {
|
||||
|
||||
private fun prefs() = appContext?.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
|
||||
|
||||
// Avatars and backgrounds live in files, one per image: in the settings XML they made a file
|
||||
// of up to tens of megabytes that was read at start and rewritten on every change.
|
||||
private fun imageDir(): File? = appContext?.let { File(it.filesDir, IMAGE_DIR) }
|
||||
|
||||
private fun imageFile(userId: String, kind: String): File? {
|
||||
val dir = imageDir() ?: return null
|
||||
val digest = MessageDigest.getInstance("SHA-256").digest(userId.toByteArray(Charsets.UTF_8))
|
||||
return File(dir, "${digest.toHex(16)}_$kind")
|
||||
}
|
||||
|
||||
private fun readImage(userId: String, kind: String): String? =
|
||||
imageFile(userId, kind)?.takeIf { it.isFile }?.let { runCatching { it.readText() }.getOrNull() }
|
||||
|
||||
private fun writeImage(userId: String, kind: String, base64: String?) {
|
||||
val file = imageFile(userId, kind) ?: return
|
||||
if (base64 == null) {
|
||||
file.delete()
|
||||
return
|
||||
}
|
||||
runCatching {
|
||||
file.parentFile?.mkdirs()
|
||||
val tmp = File(file.parentFile, file.name + ".tmp")
|
||||
tmp.writeText(base64)
|
||||
if (!tmp.renameTo(file)) {
|
||||
file.delete()
|
||||
tmp.renameTo(file)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun list(): List<FriendEntry> = synchronized(lock) { readAll() }
|
||||
|
||||
private fun readAll(): List<FriendEntry> {
|
||||
@@ -136,15 +171,21 @@ object FriendsStore {
|
||||
return emptyList()
|
||||
}
|
||||
val result = ArrayList<FriendEntry>()
|
||||
var hasInlineImages = false
|
||||
for (i in 0 until arr.length()) {
|
||||
try {
|
||||
val o = arr.getJSONObject(i)
|
||||
val userId = o.optString("uid", "").ifBlank { o.getString("name") }
|
||||
// Older versions kept the images inline; they move to files on the next write.
|
||||
val inlineAvatar = if (o.has("avatar")) o.getString("avatar") else null
|
||||
val inlineBackground = if (o.has("background")) o.getString("background") else null
|
||||
if (inlineAvatar != null || inlineBackground != null) hasInlineImages = true
|
||||
result.add(
|
||||
FriendEntry(
|
||||
userId = o.optString("uid", "").ifBlank { o.getString("name") },
|
||||
userId = userId,
|
||||
name = o.getString("name"),
|
||||
avatarBase64 = if (o.has("avatar")) o.getString("avatar") else null,
|
||||
backgroundBase64 = if (o.has("background")) o.getString("background") else null,
|
||||
avatarBase64 = inlineAvatar ?: if (o.optBoolean("a")) readImage(userId, "a") else null,
|
||||
backgroundBase64 = inlineBackground ?: if (o.optBoolean("b")) readImage(userId, "b") else null,
|
||||
elo = o.optInt("elo", 1200),
|
||||
lastPlayedMs = o.optLong("t", 0),
|
||||
favorite = o.optBoolean("fav", false),
|
||||
@@ -156,24 +197,35 @@ object FriendsStore {
|
||||
}
|
||||
val sorted = result.sortedByDescending { it.lastPlayedMs }
|
||||
cached = sorted
|
||||
if (hasInlineImages) writeAll(sorted, previous = emptyList())
|
||||
return sorted
|
||||
}
|
||||
|
||||
private fun writeAll(entries: List<FriendEntry>) {
|
||||
private fun writeAll(entries: List<FriendEntry>, previous: List<FriendEntry> = readAll()) {
|
||||
val p = prefs() ?: return
|
||||
val before = previous.associateBy { it.userId }
|
||||
val arr = JSONArray()
|
||||
entries.forEach { f ->
|
||||
val old = before[f.userId]
|
||||
// Image files are touched only when the image itself changed.
|
||||
if (old == null || old.avatarBase64 != f.avatarBase64) writeImage(f.userId, "a", f.avatarBase64)
|
||||
if (old == null || old.backgroundBase64 != f.backgroundBase64) writeImage(f.userId, "b", f.backgroundBase64)
|
||||
val o = JSONObject()
|
||||
o.put("uid", f.userId)
|
||||
o.put("name", f.name)
|
||||
if (f.avatarBase64 != null) o.put("avatar", f.avatarBase64)
|
||||
if (f.backgroundBase64 != null) o.put("background", f.backgroundBase64)
|
||||
if (f.avatarBase64 != null) o.put("a", true)
|
||||
if (f.backgroundBase64 != null) o.put("b", true)
|
||||
o.put("elo", f.elo)
|
||||
o.put("t", f.lastPlayedMs)
|
||||
if (f.favorite) o.put("fav", true)
|
||||
if (f.lastSeenMs > 0) o.put("s", f.lastSeenMs)
|
||||
arr.put(o)
|
||||
}
|
||||
val kept = entries.mapTo(HashSet()) { it.userId }
|
||||
previous.filter { it.userId !in kept }.forEach { gone ->
|
||||
writeImage(gone.userId, "a", null)
|
||||
writeImage(gone.userId, "b", null)
|
||||
}
|
||||
p.edit().putString(KEY_LIST, arr.toString()).apply()
|
||||
cached = entries.sortedByDescending { it.lastPlayedMs }
|
||||
}
|
||||
@@ -182,6 +234,11 @@ object FriendsStore {
|
||||
synchronized(lock) { readAll() }
|
||||
}
|
||||
|
||||
// Names and ratings also arrive from presence announcements, so they are bounded here too.
|
||||
private fun cleanName(name: String): String = name.filterNot { it.isISOControl() }.take(PeerLimits.MAX_NAME_CHARS)
|
||||
|
||||
private fun cleanElo(elo: Int): Int = elo.coerceIn(PeerLimits.MIN_ELO, PeerLimits.MAX_ELO)
|
||||
|
||||
fun updateProfile(
|
||||
userId: String,
|
||||
name: String,
|
||||
@@ -192,8 +249,8 @@ object FriendsStore {
|
||||
synchronized(lock) {
|
||||
val existing = readAll().firstOrNull { it.userId == userId } ?: return
|
||||
val updated = existing.copy(
|
||||
name = name.ifBlank { existing.name },
|
||||
elo = if (elo > 0) elo else existing.elo,
|
||||
name = cleanName(name).ifBlank { existing.name },
|
||||
elo = if (elo > 0) cleanElo(elo) else existing.elo,
|
||||
avatarBase64 = avatarBase64 ?: existing.avatarBase64,
|
||||
backgroundBase64 = backgroundBase64 ?: existing.backgroundBase64
|
||||
)
|
||||
@@ -217,12 +274,13 @@ object FriendsStore {
|
||||
backgroundBase64: String? = null
|
||||
): FriendEntry = synchronized(lock) {
|
||||
val existing = readAll().firstOrNull { it.userId == userId }
|
||||
val clean = cleanName(name)
|
||||
val merged = FriendEntry(
|
||||
userId = userId,
|
||||
name = name.ifBlank { existing?.name ?: name },
|
||||
name = clean.ifBlank { existing?.name ?: clean },
|
||||
avatarBase64 = avatarBase64 ?: existing?.avatarBase64,
|
||||
backgroundBase64 = backgroundBase64 ?: existing?.backgroundBase64,
|
||||
elo = if (elo > 0) elo else (existing?.elo ?: 1200),
|
||||
elo = if (elo > 0) cleanElo(elo) else (existing?.elo ?: 1200),
|
||||
lastPlayedMs = System.currentTimeMillis(),
|
||||
favorite = existing?.favorite ?: false,
|
||||
lastSeenMs = existing?.lastSeenMs ?: 0
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
package cc.skysparkle.matewave.network
|
||||
|
||||
/** Bounds for what another device may send us; anything outside them is not stored or used. */
|
||||
object PeerLimits {
|
||||
const val MAX_NAME_CHARS = 40
|
||||
const val MAX_USER_ID_CHARS = 64
|
||||
const val MIN_ELO = 100
|
||||
const val MAX_ELO = 3000
|
||||
const val MAX_INITIAL_SECONDS = 3 * 60 * 60
|
||||
const val MAX_INCREMENT_SECONDS = 180
|
||||
|
||||
/** "No time limit" is sent as Int.MAX_VALUE; 0 means the peer sent no time control. */
|
||||
private fun isTimeControl(initialSeconds: Int, incrementSeconds: Int): Boolean =
|
||||
(initialSeconds == 0 || initialSeconds == Int.MAX_VALUE || initialSeconds in 1..MAX_INITIAL_SECONDS) &&
|
||||
incrementSeconds in 0..MAX_INCREMENT_SECONDS
|
||||
|
||||
fun isPlausibleName(name: String): Boolean =
|
||||
name.isNotBlank() && name.length <= MAX_NAME_CHARS && name.none { it.isISOControl() }
|
||||
|
||||
fun isPlausibleUserId(userId: String): Boolean =
|
||||
userId.isNotBlank() && userId.length <= MAX_USER_ID_CHARS && userId.none { it.isISOControl() }
|
||||
|
||||
/**
|
||||
* Checked before the profile is trusted or stored. The fields are signed as they are, so an
|
||||
* out-of-range profile is refused rather than trimmed.
|
||||
*/
|
||||
fun isPlausibleProfile(msg: GameMessage.ProfileMsg): Boolean =
|
||||
isPlausibleUserId(msg.userId) &&
|
||||
isPlausibleName(msg.name) &&
|
||||
msg.elo in MIN_ELO..MAX_ELO &&
|
||||
isTimeControl(msg.initialSeconds, msg.incrementSeconds)
|
||||
|
||||
/**
|
||||
* The most the opponent's clock may show after their move: what our clock gives them, plus
|
||||
* the increment and some slack for network delay. A higher claim would mean time not spent.
|
||||
*/
|
||||
fun maxOpponentClockAfterMove(localRemainingMs: Long, incrementMs: Long, toleranceMs: Long): Long =
|
||||
localRemainingMs.coerceAtLeast(0) + incrementMs + toleranceMs
|
||||
}
|
||||
@@ -86,21 +86,46 @@ private object DecodedImageCache {
|
||||
fun put(key: String, bitmap: Bitmap) { cache.put(key, bitmap) }
|
||||
}
|
||||
|
||||
/** Larger images (from the opponent) are refused; ours never exceed [MAX_DIMENSION_PX]. */
|
||||
const val MAX_INCOMING_IMAGE_PX = 4096
|
||||
|
||||
/** Upper bound for the decoded size when the caller does not ask for a smaller one. */
|
||||
private const val DEFAULT_DECODE_PX = 1280
|
||||
|
||||
/** Width and height of an encoded image, or null if it is not a readable image. */
|
||||
private fun imageBounds(bytes: ByteArray): Pair<Int, Int>? {
|
||||
val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
|
||||
BitmapFactory.decodeByteArray(bytes, 0, bytes.size, bounds)
|
||||
return if (bounds.outWidth > 0 && bounds.outHeight > 0) bounds.outWidth to bounds.outHeight else null
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks an image received from another device before it is shown or stored: it must be a
|
||||
* readable image no larger than [MAX_INCOMING_IMAGE_PX] on either side. A small file can
|
||||
* declare a huge resolution, and decoding it at full size would run out of memory.
|
||||
*/
|
||||
fun isAcceptableIncomingImage(base64: String): Boolean = try {
|
||||
val size = imageBounds(Base64.decode(base64, Base64.NO_WRAP))
|
||||
size != null && size.first <= MAX_INCOMING_IMAGE_PX && size.second <= MAX_INCOMING_IMAGE_PX
|
||||
} catch (e: Exception) {
|
||||
false
|
||||
}
|
||||
|
||||
fun decodeChatImage(base64: String, maxDimension: Int = 0): Bitmap? {
|
||||
return try {
|
||||
val bytes = Base64.decode(base64, Base64.NO_WRAP)
|
||||
if (maxDimension <= 0) {
|
||||
BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
|
||||
} else {
|
||||
val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
|
||||
BitmapFactory.decodeByteArray(bytes, 0, bytes.size, bounds)
|
||||
var sample = 1
|
||||
while (maxOf(bounds.outWidth, bounds.outHeight) / (sample * 2) >= maxDimension) sample *= 2
|
||||
val options = BitmapFactory.Options().apply { inSampleSize = sample }
|
||||
BitmapFactory.decodeByteArray(bytes, 0, bytes.size, options)
|
||||
}
|
||||
// The size is always checked first: the image may come from another device.
|
||||
val (width, height) = imageBounds(bytes) ?: return null
|
||||
if (width > MAX_INCOMING_IMAGE_PX || height > MAX_INCOMING_IMAGE_PX) return null
|
||||
val target = if (maxDimension > 0) maxDimension else DEFAULT_DECODE_PX
|
||||
var sample = 1
|
||||
while (maxOf(width, height) / (sample * 2) >= target) sample *= 2
|
||||
val options = BitmapFactory.Options().apply { inSampleSize = sample }
|
||||
BitmapFactory.decodeByteArray(bytes, 0, bytes.size, options)
|
||||
} catch (e: Exception) {
|
||||
null
|
||||
} catch (e: OutOfMemoryError) {
|
||||
null
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -77,14 +77,16 @@ private data class NearbyEntry(
|
||||
val elo: Int?,
|
||||
val type: TransportType,
|
||||
val address: String,
|
||||
val avatar: String?
|
||||
val avatar: String?,
|
||||
/** Player id from the signed Wi-Fi announcement; checked against the profile after connecting. */
|
||||
val playerId: String? = null
|
||||
)
|
||||
|
||||
@Composable
|
||||
fun ConnectionScreen(
|
||||
presence: LocalPresence,
|
||||
onStartHost: (TimeControl) -> Unit,
|
||||
onJoin: (TransportType, TimeControl, targetId: String) -> Unit,
|
||||
onJoin: (TransportType, TimeControl, targetId: String, expectedUserId: String?) -> Unit,
|
||||
onBack: () -> Unit
|
||||
) {
|
||||
val context = LocalContext.current
|
||||
@@ -146,7 +148,8 @@ fun ConnectionScreen(
|
||||
elo = peer.elo,
|
||||
type = TransportType.LAN,
|
||||
address = peer.address,
|
||||
avatar = friends.firstOrNull { it.userId == peer.playerId }?.avatarBase64
|
||||
avatar = friends.firstOrNull { it.userId == peer.playerId }?.avatarBase64,
|
||||
playerId = peer.playerId
|
||||
)
|
||||
}
|
||||
val lanFingerprints = peers.values.map { it.fingerprint }.filter { it.isNotEmpty() }
|
||||
@@ -263,7 +266,7 @@ fun ConnectionScreen(
|
||||
modifier = Modifier
|
||||
.clip(RoundedCornerShape(50))
|
||||
.background(Lime)
|
||||
.clickable { onJoin(entry.type, timeControl, entry.address) }
|
||||
.clickable { onJoin(entry.type, timeControl, entry.address, entry.playerId) }
|
||||
.padding(horizontal = 14.dp, vertical = 6.dp)
|
||||
)
|
||||
}
|
||||
|
||||
@@ -26,6 +26,7 @@ import cc.skysparkle.matewave.network.ConnectionTransport
|
||||
import cc.skysparkle.matewave.network.GameMessage
|
||||
import cc.skysparkle.matewave.network.NetworkLog
|
||||
import cc.skysparkle.matewave.network.NetworkMetrics
|
||||
import cc.skysparkle.matewave.network.PeerLimits
|
||||
import cc.skysparkle.matewave.network.TransportType
|
||||
import cc.skysparkle.matewave.puzzles.Puzzle
|
||||
import cc.skysparkle.matewave.security.DeviceKeys
|
||||
@@ -43,6 +44,7 @@ import cc.skysparkle.matewave.spectate.SpectatorResult
|
||||
import cc.skysparkle.matewave.spectate.SpectatorResults
|
||||
import cc.skysparkle.matewave.spectate.SpectatorSnapshot
|
||||
import cc.skysparkle.matewave.stats.Stats
|
||||
import cc.skysparkle.matewave.ui.components.isAcceptableIncomingImage
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.Job
|
||||
import kotlinx.coroutines.delay
|
||||
@@ -185,8 +187,10 @@ class GameViewModel : ViewModel() {
|
||||
private var sessionGeneration = 0
|
||||
private var networkGameId: String = ""
|
||||
private var pendingOpponentImages: Pair<String?, String?>? = null
|
||||
|
||||
// The player picked in the nearby list; whoever answers must be that player.
|
||||
private var expectedOpponentUserId: String? = null
|
||||
private var currentPly: Int = 0
|
||||
private var lastOpponentRemaining: Long = Long.MAX_VALUE
|
||||
|
||||
// Spectating: the host serves spectators, both players announce the game's tag.
|
||||
private var spectators: SpectatorBroadcaster? = null
|
||||
@@ -711,7 +715,8 @@ class GameViewModel : ViewModel() {
|
||||
myColor: PieceColor,
|
||||
timeControl: TimeControl,
|
||||
isHost: Boolean,
|
||||
targetId: String? = null
|
||||
targetId: String? = null,
|
||||
expectedUserId: String? = null
|
||||
) {
|
||||
pendingLeave?.let { (job, oldTransport) ->
|
||||
job.cancel()
|
||||
@@ -730,6 +735,7 @@ class GameViewModel : ViewModel() {
|
||||
this.transport = transport
|
||||
lastNetworkTimeControl = timeControl
|
||||
isNetworkHost = isHost
|
||||
expectedOpponentUserId = expectedUserId?.takeIf { it.isNotBlank() }
|
||||
|
||||
ephemeralKeys = DeviceKeys.generateEphemeral()
|
||||
|
||||
@@ -739,7 +745,6 @@ class GameViewModel : ViewModel() {
|
||||
opponentFlagJob = null
|
||||
networkGameId = if (isHost) java.util.UUID.randomUUID().toString() else ""
|
||||
currentPly = 0
|
||||
lastOpponentRemaining = Long.MAX_VALUE
|
||||
|
||||
_clockState.value = null
|
||||
_uiState.value = GameUiState(
|
||||
@@ -848,6 +853,13 @@ class GameViewModel : ViewModel() {
|
||||
)
|
||||
}
|
||||
|
||||
/** The image if it may be shown and stored, otherwise null (and a log line). */
|
||||
private fun acceptedIncomingImage(base64: String): String? {
|
||||
if (base64.length <= MAX_CHAT_IMAGE_CHARS && isAcceptableIncomingImage(base64)) return base64
|
||||
NetworkLog.log("GAME", "Unreadable or oversized profile image rejected")
|
||||
return null
|
||||
}
|
||||
|
||||
private fun belongsToCurrentGame(gameId: String): Boolean =
|
||||
gameId.isEmpty() || networkGameId.isEmpty() || gameId == networkGameId
|
||||
|
||||
@@ -901,9 +913,14 @@ class GameViewModel : ViewModel() {
|
||||
NetworkLog.log("GAME", "Oversized chat message rejected")
|
||||
return
|
||||
}
|
||||
if (msg.imageBase64 != null && !isAcceptableIncomingImage(msg.imageBase64)) {
|
||||
NetworkLog.log("GAME", "Unreadable or oversized chat image rejected")
|
||||
return
|
||||
}
|
||||
val state = _uiState.value
|
||||
_uiState.value = state.copy(
|
||||
chatMessages = state.chatMessages + ChatEntry(msg.text, msg.imageBase64, fromMe = false),
|
||||
chatMessages = (state.chatMessages + ChatEntry(msg.text, msg.imageBase64, fromMe = false))
|
||||
.takeLast(MAX_CHAT_ENTRIES),
|
||||
unreadChatCount = state.unreadChatCount + 1
|
||||
)
|
||||
}
|
||||
@@ -976,8 +993,8 @@ class GameViewModel : ViewModel() {
|
||||
}
|
||||
is GameMessage.ProfileImagesMsg -> {
|
||||
if (!belongsToCurrentGame(msg.gameId)) return
|
||||
val avatar = msg.avatarBase64?.takeIf { it.length <= MAX_CHAT_IMAGE_CHARS }
|
||||
val background = msg.backgroundBase64?.takeIf { it.length <= MAX_CHAT_IMAGE_CHARS }
|
||||
val avatar = msg.avatarBase64?.let(::acceptedIncomingImage)
|
||||
val background = msg.backgroundBase64?.let(::acceptedIncomingImage)
|
||||
if (avatar == null && background == null) return
|
||||
val current = _uiState.value.opponentProfile
|
||||
if (current == null) {
|
||||
@@ -1051,17 +1068,17 @@ class GameViewModel : ViewModel() {
|
||||
|
||||
val limit = lastNetworkTimeControl?.let { it.initialSeconds * 1000L + 60_000L }
|
||||
val increment = lastNetworkTimeControl?.let { it.incrementSeconds * 1000L } ?: 0L
|
||||
val allowedMax = if (lastOpponentRemaining == Long.MAX_VALUE) {
|
||||
limit ?: Long.MAX_VALUE
|
||||
} else {
|
||||
lastOpponentRemaining + increment + CLOCK_TOLERANCE_MS
|
||||
}
|
||||
// Our own clock has been running the opponent's time while they thought, so their claim
|
||||
// may not exceed it by more than the increment and network slack.
|
||||
val allowedMax = clock?.remainingMillis(opponentColor)
|
||||
?.let { PeerLimits.maxOpponentClockAfterMove(it, increment, CLOCK_TOLERANCE_MS) }
|
||||
?: limit ?: Long.MAX_VALUE
|
||||
if (msg.remainingMillisSelf >= 0 &&
|
||||
(limit == null || msg.remainingMillisSelf <= limit) &&
|
||||
msg.remainingMillisSelf <= allowedMax
|
||||
) {
|
||||
lastOpponentRemaining = msg.remainingMillisSelf
|
||||
clock?.applyRemoteTime(opponentColor, msg.remainingMillisSelf)
|
||||
// The reported time already includes the increment; makeMove below adds it again.
|
||||
clock?.applyRemoteTime(opponentColor, (msg.remainingMillisSelf - increment).coerceAtLeast(0))
|
||||
} else if (msg.remainingMillisSelf > 0) {
|
||||
NetworkLog.log("GAME", "Invalid clock value from opponent rejected: ${msg.remainingMillisSelf}")
|
||||
}
|
||||
@@ -1077,6 +1094,12 @@ class GameViewModel : ViewModel() {
|
||||
NetworkLog.log("GAME", "Repeated profile in current session ignored")
|
||||
return
|
||||
}
|
||||
if (!PeerLimits.isPlausibleProfile(msg)) {
|
||||
// Nothing of it is stored: no key, no friend entry. The connection is closed.
|
||||
NetworkLog.log("GAME", "Profile with out-of-range fields rejected, disconnecting")
|
||||
transport?.disconnect()
|
||||
return
|
||||
}
|
||||
val peers = knownPeers
|
||||
if (peers == null) {
|
||||
NetworkLog.log("GAME", "Key store not ready, profile rejected")
|
||||
@@ -1125,7 +1148,11 @@ class GameViewModel : ViewModel() {
|
||||
}
|
||||
markReadyIfPossible()
|
||||
|
||||
_uiState.value = _uiState.value.copy(opponentUnverified = trust == TrustResult.UNSIGNED)
|
||||
val unexpected = expectedOpponentUserId?.let { it != msg.userId } == true
|
||||
if (unexpected) {
|
||||
NetworkLog.log("GAME", "Opponent is not the player picked in the nearby list")
|
||||
}
|
||||
_uiState.value = _uiState.value.copy(opponentUnverified = trust == TrustResult.UNSIGNED || unexpected)
|
||||
|
||||
val pending = pendingOpponentImages
|
||||
pendingOpponentImages = null
|
||||
@@ -1133,8 +1160,8 @@ class GameViewModel : ViewModel() {
|
||||
userId = msg.userId,
|
||||
name = msg.name,
|
||||
elo = msg.elo,
|
||||
avatarBase64 = msg.avatarBase64 ?: pending?.first,
|
||||
backgroundBase64 = msg.backgroundBase64 ?: pending?.second
|
||||
avatarBase64 = msg.avatarBase64?.let(::acceptedIncomingImage) ?: pending?.first,
|
||||
backgroundBase64 = msg.backgroundBase64?.let(::acceptedIncomingImage) ?: pending?.second
|
||||
)
|
||||
_uiState.value = _uiState.value.copy(
|
||||
opponentProfile = Profile(
|
||||
@@ -1240,7 +1267,6 @@ class GameViewModel : ViewModel() {
|
||||
opponentFlagJob?.cancel()
|
||||
opponentFlagJob = null
|
||||
currentPly = 0
|
||||
lastOpponentRemaining = Long.MAX_VALUE
|
||||
val start = Board.startPosition()
|
||||
resetHistory(start)
|
||||
|
||||
@@ -1349,7 +1375,8 @@ class GameViewModel : ViewModel() {
|
||||
val trimmed = text.trim().take(MAX_CHAT_TEXT_CHARS)
|
||||
if (!sendGameMessage(GameMessage.ChatMsg(text = trimmed, gameId = networkGameId))) return
|
||||
_uiState.value = _uiState.value.copy(
|
||||
chatMessages = _uiState.value.chatMessages + ChatEntry(trimmed, null, fromMe = true)
|
||||
chatMessages = (_uiState.value.chatMessages + ChatEntry(trimmed, null, fromMe = true))
|
||||
.takeLast(MAX_CHAT_ENTRIES)
|
||||
)
|
||||
}
|
||||
|
||||
@@ -1362,7 +1389,8 @@ class GameViewModel : ViewModel() {
|
||||
}
|
||||
if (!sendGameMessage(GameMessage.ChatMsg(imageBase64 = base64, gameId = networkGameId))) return
|
||||
_uiState.value = _uiState.value.copy(
|
||||
chatMessages = _uiState.value.chatMessages + ChatEntry(null, base64, fromMe = true)
|
||||
chatMessages = (_uiState.value.chatMessages + ChatEntry(null, base64, fromMe = true))
|
||||
.takeLast(MAX_CHAT_ENTRIES)
|
||||
)
|
||||
}
|
||||
|
||||
@@ -1400,7 +1428,10 @@ class GameViewModel : ViewModel() {
|
||||
viewModelScope.launch {
|
||||
var serving = false
|
||||
try {
|
||||
val port = withContext(Dispatchers.IO) { runCatching { hub.start() }.getOrNull() }
|
||||
// Spectators come over Wi-Fi; other interfaces (mobile data) are not listened on.
|
||||
val port = withContext(Dispatchers.IO) {
|
||||
runCatching { hub.start(cc.skysparkle.matewave.share.LocalNetwork.wifiInet4()) }.getOrNull()
|
||||
}
|
||||
if (port == null) NetworkLog.log("SPECTATE", "Could not open the spectator port")
|
||||
// The game may have ended while the port was opening.
|
||||
if (port == null || generation != sessionGeneration || !spectatingDecided || spectateTag.isEmpty()) return@launch
|
||||
@@ -1589,6 +1620,7 @@ class GameViewModel : ViewModel() {
|
||||
const val MAX_CHAT_TEXT_CHARS = 8_000
|
||||
const val MAX_CHAT_IMAGE_CHARS = 400_000
|
||||
const val CLOCK_TOLERANCE_MS = 2_000L
|
||||
const val MAX_CHAT_ENTRIES = 200
|
||||
const val HANDSHAKE_TIMEOUT_MS = 20_000L
|
||||
const val OPPONENT_FLAG_GRACE_MS = 4_000L
|
||||
const val LEAVE_FLUSH_MS = 700L
|
||||
|
||||
Reference in New Issue
Block a user