46543db · skrepka · git.iko.soy

115-- ============================================

116

117hexDigit = \n ->

118− let n = if n < 0 then 0 else if n > 15 then 15 else n

118+ let n = if n < 0 then 0 else if n > 15 then 15 else n in

119 if n == 0 then "0" else if n == 1 then "1" else if n == 2 then "2" else if n == 3 then "3"

120 else if n == 4 then "4" else if n == 5 then "5" else if n == 6 then "6" else if n == 7 then "7"

121 else if n == 8 then "8" else if n == 9 then "9" else if n == 10 then "a" else if n == 11 then "b"

124byteToHex = \n -> hexDigit (n / 16) ++ hexDigit (n - (n / 16) * 16)

125

126intTo3Hex = \n ->

127− let b0 = n / 65536

127+ let b0 = n / 65536 in

128− let r0 = n - b0 * 65536

128+ let r0 = n - b0 * 65536 in

129− let b1 = r0 / 256

129+ let b1 = r0 / 256 in

130− let b2 = r0 - b1 * 256

130+ let b2 = r0 - b1 * 256 in

131 byteToHex b0 ++ byteToHex b1 ++ byteToHex b2

132

133genToken = do

278 else containsInternalSuffix (drop 1 s)

279

280isBadServerName = \s ->

281− let sn = toLower (stripTrailingDot s)

281+ let sn = toLower (stripTrailingDot s) in

282 sn == ""

283 || take 1 sn == "."

284 || take 1 sn == ":"

337 else ""

338

339verifyFederationAuth = \authorization ->

340− let token = extractToken authorization

340+ let token = extractToken authorization in

341− let result = safeCompare token (if federationSecret == "" then "x" else federationSecret)

341+ let result = safeCompare token (if federationSecret == "" then "x" else federationSecret) in

342− let secretSet = if federationSecret == "" then 0 else 1

342+ let secretSet = if federationSecret == "" then 0 else 1 in

343 (if result then 1 else 0) * secretSet > 0

344

345verifyMaintenanceAuth = \authorization ->

346− let token = extractToken authorization

346+ let token = extractToken authorization in

347− let fedResult = safeCompare token (if federationSecret == "" then "x" else federationSecret)

347+ let fedResult = safeCompare token (if federationSecret == "" then "x" else federationSecret) in

348− let maintResult = safeCompare token (if maintenanceSecret == "" then "x" else maintenanceSecret)

348+ let maintResult = safeCompare token (if maintenanceSecret == "" then "x" else maintenanceSecret) in

349− let fedN = if fedResult then 1 else 0

349+ let fedN = if fedResult then 1 else 0 in

350− let maintN = if maintResult then 1 else 0

350+ let maintN = if maintResult then 1 else 0 in

351− let fedSecretSet = if federationSecret == "" then 0 else 1

351+ let fedSecretSet = if federationSecret == "" then 0 else 1 in

352− let maintSecretSet = if maintenanceSecret == "" then 0 else 1

352+ let maintSecretSet = if maintenanceSecret == "" then 0 else 1 in

353 fedN * fedSecretSet + maintN * maintSecretSet > 0

354

355clampTtl = \ttl -> if ttl < 1 then 1 else if ttl > maxPresenceTtl then maxPresenceTtl else ttl

360 let toEvict = (fold (\acc a ->

361 if acc.size < n

362 then

363− let newHeap = union acc.heap [a]

363+ let newHeap = union acc.heap [a] in

364− let newSize = count newHeap

364+ let newSize = count newHeap in

365 if newSize > acc.size

366 then {size: newSize, heap: newHeap, heapMax: if a.ackedAt > acc.heapMax then a.ackedAt else acc.heapMax}

367 else acc

370 let removed = fold (\r x ->

371 if not r.done && x.ackedAt == acc.heapMax

372 then {done: True {}, items: r.items}

373− else {done: r.done, items: union r.items [x]}) {done: False {}, items: []} acc.heap

373+ else {done: r.done, items: union r.items [x]}) {done: False {}, items: []} acc.heap in

374− let newHeap = union removed.items [a]

374+ let newHeap = union removed.items [a] in

375− let newMax = fold (\best x -> if x.ackedAt > best then x.ackedAt else best) -1 newHeap

375+ let newMax = fold (\best x -> if x.ackedAt > best then x.ackedAt else best) (-1) newHeap in

376 {size: acc.size, heap: newHeap, heapMax: newMax}

377 else acc) {size: 0, heap: [], heapMax: -1} items).heap

378 in diff items toEvict

554 let limitedMsgs = (fold (\acc m ->

555 if acc.size < maxPollEvents

556 then

557− let newHeap = union acc.heap [m]

557+ let newHeap = union acc.heap [m] in

558− let newSize = count newHeap

558+ let newSize = count newHeap in

559 if newSize > acc.size

560 then {size: newSize, heap: newHeap, heapMax: if m.receivedAt > acc.heapMax then m.receivedAt else acc.heapMax}

561 else acc

564 let removed = fold (\r x ->

565 if not r.done && x.receivedAt == acc.heapMax

566 then {done: True {}, items: r.items}

567− else {done: r.done, items: union r.items [x]}) {done: False {}, items: []} acc.heap

567+ else {done: r.done, items: union r.items [x]}) {done: False {}, items: []} acc.heap in

568− let newHeap = union removed.items [m]

568+ let newHeap = union removed.items [m] in

569− let newMax = fold (\best x -> if x.receivedAt > best then x.receivedAt else best) -1 newHeap

569+ let newMax = fold (\best x -> if x.receivedAt > best then x.receivedAt else best) (-1) newHeap in

570 {size: acc.size, heap: newHeap, heapMax: newMax}

571 else acc) {size: 0, heap: [], heapMax: -1} matchingMsgs).heap

572 let authorized = case session of

612 pr <- maybePrune t

613 challenges <- *challenges

614 let existingCount = count (do c <- challenges; where c.pubkey == pubkey; where c.expiresAt > t; yield c)

615− let oldestChallengeExpiry = fold (\acc c2 -> if c2.pubkey == pubkey && c2.expiresAt > t && (acc == -1 || c2.expiresAt < acc) then c2.expiresAt else acc) -1 challenges

615+ let oldestChallengeExpiry = fold (\acc c2 -> if c2.pubkey == pubkey && c2.expiresAt > t && (acc == -1 || c2.expiresAt < acc) then c2.expiresAt else acc) (-1) challenges

616 let cappedChallenges = if existingCount >= maxChallengesPerKey && oldestChallengeExpiry >= 0

617 then fold (\acc c ->

618 if not acc.removed && c.pubkey == pubkey && c.expiresAt == oldestChallengeExpiry

623 then do c <- cappedChallenges.items; where c.expiresAt > t; yield c

624 else cappedChallenges.items

625 let globalOldestExpiry = if count withoutExpired >= maxChallenges

626− then fold (\acc c -> if acc == -1 || c.expiresAt < acc then c.expiresAt else acc) -1 withoutExpired

626+ then fold (\acc c -> if acc == -1 || c.expiresAt < acc then c.expiresAt else acc) (-1) withoutExpired

627 else -1

628 let globalCapped = if globalOldestExpiry >= 0

629 then (fold (\acc c ->

663 then False {}

664 else verify (bytesFromHex pubkey) (textToBytes challenge) (bytesFromHex signature)

665 set *challenges = if sigValid

666− then (case matched of

666+ then case matched of

667 Just {value: _} -> do

668 c <- challenges

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

670 yield c

671− Nothing {} -> challenges)

671+ Nothing {} -> challenges

672 else challenges

673 let existingForKey = do

674 s <- sessions

675 where s.pubkey == pubkey

676 where s.expiresAt > t

677 yield s

678− let oldestExpiry = fold (\acc s -> if acc == -1 || s.expiresAt < acc then s.expiresAt else acc) -1 existingForKey

678+ let oldestExpiry = fold (\acc s -> if acc == -1 || s.expiresAt < acc then s.expiresAt else acc) (-1) existingForKey

679 let cappedFold = fold (\acc s ->

680 if not acc.removed && s.pubkey == pubkey && s.expiresAt == oldestExpiry

681 then {removed: True {}, sessions: acc.sessions}

685 else sessions

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

687 let globalOldestSessionExpiry = if count activeSessionsCapped >= maxSessions

688− then fold (\acc s -> if acc == -1 || s.expiresAt < acc then s.expiresAt else acc) -1 activeSessionsCapped

688+ then fold (\acc s -> if acc == -1 || s.expiresAt < acc then s.expiresAt else acc) (-1) activeSessionsCapped

689 else -1

690 let globalSessionsCapped = if globalOldestSessionExpiry >= 0

691 then (fold (\acc s ->

700 p <- presence

701 where not (p.pubkey == pubkey && p.server == serverHostN)

702 yield p

703− let oldestPresenceExp = fold (\acc p -> if acc == -1 || p.expiresAt < acc then p.expiresAt else acc) -1 presenceWithout

703+ let oldestPresenceExp = fold (\acc p -> if acc == -1 || p.expiresAt < acc then p.expiresAt else acc) (-1) presenceWithout

704 let presenceEvicted = if count presenceWithout >= maxPresenceEntries && oldestPresenceExp >= 0

705 then (fold (\acc p ->

706 if not acc.removed && p.expiresAt == oldestPresenceExp