e692eb5 · skrepka · git.iko.soy

462 else {removed: acc.removed, items: union acc.items [x]}) {removed: False {}, items: []} items).items

463

464capPerKey = \items matchKey maxPerKey getExpiry t ->

465− let activeCount = count (do x <- items; where matchKey x; where getExpiry x > t; yield x) in

465+ let active = do x <- items; where getExpiry x > t; yield x in

466+ let activeForKeyCount = count (do x <- active; where matchKey x; yield x) in

466− if activeCount >= maxPerKey

467+ if activeForKeyCount >= maxPerKey

467− then let forKey = do x <- items; where matchKey x; yield x in

468+ then let forKey = do x <- active; where matchKey x; yield x in

468− let others = do x <- items; where not (matchKey x); yield x in

469+ let others = do x <- active; where not (matchKey x); yield x in

469 union others (evictOneOldest forKey getExpiry)

470 union others (evictOneOldest forKey getExpiry)

470− else items

471+ else active

471

472

472capGlobal = \items maxCount getKey ->

473capGlobal = \items maxCount getKey ->

473 if count items >= maxCount

474 if count items >= maxCount

735 pruneResult <- atomic do

736 pruneResult <- atomic do

736 pr <- maybePrune t

737 pr <- maybePrune t

737 challenges <- *challenges

738 challenges <- *challenges

738− let challengesCapped = capPerKey challenges (\c -> c.pubkey == pubkey) maxChallengesPerKey (\c -> c.expiresAt) t

739+ let activeChallenges = capPerKey challenges (\c -> c.pubkey == pubkey) maxChallengesPerKey (\c -> c.expiresAt) t

739− let activeChallenges = do c <- challengesCapped; where c.expiresAt > t; yield c

740 let globalCapped = capGlobal activeChallenges maxChallenges (\c -> c.expiresAt)

741 set *challenges = union

742 globalCapped

771 c <- challenges

772 where not (c.pubkey == pubkey && c.challenge == challenge)

773 yield c

774− let sessionsCapped = capPerKey sessions (\s -> s.pubkey == pubkey) maxSessionsPerKey (\s -> s.expiresAt) t

774+ let activeSessions = capPerKey sessions (\s -> s.pubkey == pubkey) maxSessionsPerKey (\s -> s.expiresAt) t

775− let activeSessionsCapped = do s <- sessionsCapped; where s.expiresAt > t; yield s

776− let globalSessionsCapped = capGlobal activeSessionsCapped maxSessions (\s -> s.expiresAt)

775+ let globalSessionsCapped = capGlobal activeSessions maxSessions (\s -> s.expiresAt)

777 set *sessions = union globalSessionsCapped [{token: token, pubkey: pubkey, expiresAt: expiry}]

776 set *sessions = union globalSessionsCapped [{token: token, pubkey: pubkey, expiresAt: expiry}]

778 let presenceWithout = do

777 let presenceWithout = do

779 p <- presence

778 p <- presence

845 let remoteServers = do p <- toPresence; where not (p.server == serverHostN); yield p.server

844 let remoteServers = do p <- toPresence; where not (p.server == serverHostN); yield p.server

846 forwards <- *forwards

845 forwards <- *forwards

847 let forwardServers = takeN remoteServers (maxForwardsEntries - count forwards)

846 let forwardServers = takeN remoteServers (maxForwardsEntries - count forwards)

847+ let shouldForward = federationEnabled && count forwardServers > 0

848 let status = if localOnline then "delivered"

849− else if federationEnabled && count forwardServers > 0 then "federated"

849+ else if shouldForward then "federated"

850 else "queued"

851− set *forwards = if federationEnabled && count forwardServers > 0

851+ set *forwards = if shouldForward

852 then union forwards (do s <- forwardServers; yield {messageId: msgId, toServer: s, createdAt: t, toKey: to, fromKey: fromKey, encryptedBlob: encryptedBlob, timestamp: clampedTs})

853 else forwards

854 yield {pr: pr, send: SendDone {status: status, remoteServers: remoteServers, fromKey: fromKey}}

866 Err _ -> yield {}))

867 when (status == "queued" && count remoteServers > 0 && federationEnabled)

868 (println ("sendMessage: forwards at capacity (" ++ show maxForwardsEntries ++ "), skipping forward tracking"))

869+ SendUnauthorized {} -> yield {}

869− _ -> yield {}

870+ SendRejected {} -> yield {}

870 broadcastOfflineGossip t result.pr.peerServers result.pr.expiredLocal)

871 broadcastOfflineGossip t result.pr.peerServers result.pr.expiredLocal)

871 yield (case result.send of

872 yield (case result.send of

872 SendUnauthorized _ -> respond {status: "unauthorized", messageId: ""}

873 SendUnauthorized _ -> respond {status: "unauthorized", messageId: ""}

936 when (dropped > 0)

937 when (dropped > 0)

937 (println ("ackMessages: ackedIds at capacity (" ++ show maxAckedIds ++ "), " ++ show dropped ++ " ack entries permanently lost for " ++ server))

938 (println ("ackMessages: ackedIds at capacity (" ++ show maxAckedIds ++ "), " ++ show dropped ++ " ack entries permanently lost for " ++ server))

938 _ -> yield {}))

939 _ -> yield {}))

939− _ -> yield {}

940+ AckUnauthorized {} -> yield {}

940 broadcastOfflineGossip t result.pr.peerServers result.pr.expiredLocal)

941 broadcastOfflineGossip t result.pr.peerServers result.pr.expiredLocal)

941 yield (case result.ack of

942 yield (case result.ack of

942 AckUnauthorized _ -> respond {ok: False {}}

943 AckUnauthorized _ -> respond {ok: False {}}

1063 t <- now

1064 t <- now

1064 let authorized = verifyFederationAuth authorization

1065 let authorized = verifyFederationAuth authorization

1065 let validOrigin = isFederatedOrigin originServer

1066 let validOrigin = isFederatedOrigin originServer

1067+ let clampedTs = clampTimestamp timestamp t

1068+ result <- atomic do

1069+ pr <- maybePrune t

1066− if not (authorized && validOrigin)

1070+ if not (authorized && validOrigin)

1067− then do

1068− pruneResult <- atomic do maybePrune t

1069− forkBroadcastOffline t pruneResult

1070− yield (respond {ok: False {}})

1071+ then yield {pr: pr, ok: False {}}

1071− else do

1072+ else do

1072− let clampedTs = clampTimestamp timestamp t

1073− result <- atomic do

1074− pr <- maybePrune t

1075 messages <- *messages

1073 messages <- *messages

1076 ackedIds <- *ackedIds

1074 ackedIds <- *ackedIds

1077 if any messages (\m -> m.messageId == messageId && m.toKey == toKey)

1075 if any messages (\m -> m.messageId == messageId && m.toKey == toKey)

1087 [{messageId: messageId, toKey: toKey, fromKey: fromKey,

1085 [{messageId: messageId, toKey: toKey, fromKey: fromKey,

1088 encryptedBlob: encryptedBlob, timestamp: clampedTs, originServer: originServer, receivedAt: seqTs}]

1086 encryptedBlob: encryptedBlob, timestamp: clampedTs, originServer: originServer, receivedAt: seqTs}]

1089 yield {pr: pr, ok: True {}}

1087 yield {pr: pr, ok: True {}}

1090− forkBroadcastOffline t result.pr

1088+ forkBroadcastOffline t result.pr

1091− yield (respond {ok: result.ok})

1089+ yield (respond {ok: result.ok})

1092

1090

1093 FederationAck {messageIds, originServer, fromServer, authorization, respond} -> do

1091 FederationAck {messageIds, originServer, fromServer, authorization, respond} -> do

1094 let fromServer = normalizeServerName fromServer

1092 let fromServer = normalizeServerName fromServer