One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.
"""The responder's races and resource bounds, each found by the cold reviews of step 4a (a fresh
Opus as an attacker, and Gemini 3.1 Pro on the handshake), written before its fix."""
import os
import socket
import struct
import threading
import time
import unittest
from unittest import mock
from core import protocol, receiver
from core.tests import pngs
from core.tests.responder_harness import B, C, TOKENS, Initiator, Machine, entry, wait_for
ACCEPT, REFUSE = protocol.MSG_ACCEPT, protocol.MSG_REFUSE
class Case(unittest.TestCase):
peers = None
zones = ()
def setUp(self):
self.machine = Machine(self.peers or [entry(B, "Bee"), entry(C, "Sea")], self.zones).start()
self.addCleanup(self.machine.stop)
def link(self, peer=B, **kwargs):
link = Initiator(self.machine, peer)
self.addCleanup(link.close)
link.handshake(**kwargs)
return link
def own(self, link, **fields):
route = link.take(**fields)
self.assertEqual(link.answer(route), (ACCEPT, {"route": route}))
return route
class TheClipboardAndTheOwnerCallbacks(Case):
def test_a_let_go_never_sends_the_next_owners_clipboard_and_the_callbacks_keep_their_order(self):
clipboard = self.machine.clipboard
b, c = self.link(B), self.link(C)
self.own(b)
clipboard.copy("copied here")
clipboard.slow_get = 0.4
b.let_go(target=C)
self.assertTrue(wait_for(lambda: self.machine.responder.owner is None))
self.own(c)
c.send(protocol.clipboard_msg("C's secret"))
self.assertTrue(wait_for(lambda: ("set", "C's secret") in self.machine.events))
sent = b.expect(protocol.MSG_CLIPBOARD, timeout=1.0)
self.assertNotEqual(sent, {"text": "C's secret"})
self.assertTrue(wait_for(lambda: len(self.machine.owners) == 3))
self.assertEqual(self.machine.owners, [B, None, C])
def test_a_clipboard_waiting_behind_a_slow_write_is_not_set_once_its_senders_ownership_ended(self):
b = self.link(B)
self.own(b)
self.machine.clipboard.slow_set = 0.4
b.send(protocol.clipboard_msg("first"))
b.send(protocol.clipboard_msg("second"))
time.sleep(0.1)
self.machine.settings.peer(TOKENS[B])["allow_drive"] = False
self.machine.responder.peers_changed()
self.assertTrue(wait_for(lambda: ("owner", None) in self.machine.events))
# The first write was already under way and cannot be taken back; the second had not begun.
self.assertTrue(wait_for(lambda: ("set", "first") in self.machine.events))
time.sleep(0.6)
self.assertNotIn(("set", "second"), self.machine.events)
def test_a_let_go_during_a_slow_write_does_not_send_the_owners_own_clipboard_back(self):
b = self.link(B)
self.own(b)
self.machine.clipboard.slow_set = 0.4
b.send(protocol.clipboard_msg("from b"))
time.sleep(0.1)
b.let_go()
self.assertTrue(wait_for(lambda: self.machine.responder.owner is None))
self.assertTrue(wait_for(lambda: ("set", "from b") in self.machine.events))
self.assertIsNone(b.expect(protocol.MSG_CLIPBOARD, timeout=1.0))
def test_a_clipboard_write_that_blocks_for_seconds_does_not_delay_the_next_input_acknowledgement(self):
b = self.link(B)
self.own(b)
self.machine.clipboard.slow_set = 3.0
b.send(protocol.clipboard_msg("slow"))
started = time.monotonic()
self.assertIsNotNone(b.acked(b.move(5, 0), timeout=1.0))
self.assertLess(time.monotonic() - started, 1.0)
self.assertEqual(self.machine.clipboard.set_calls, [])
self.assertTrue(wait_for(lambda: self.machine.clipboard.set_calls == [("slow", None)], timeout=5.0))
class ALargeFrameToASlowReader(Case):
def test_a_slow_but_working_reader_keeps_the_link(self):
with mock.patch.object(receiver, "LINK_READ_TIMEOUT_SECONDS", 0.5):
b = Initiator(self.machine, B)
self.addCleanup(b.close)
b.handshake(reader=False)
b.send(protocol.focus_v6(1, receiver_id(self.machine)))
deadline = time.monotonic() + 3
while time.monotonic() < deadline:
if protocol.recv_msg(b.sock, b.session).get("type") == ACCEPT:
break
self.machine.clipboard.image = pngs.png(64, 64, pngs.chunk(b"tEXt", b"noise\x00" + os.urandom(3_000_000)))
self.machine.clipboard.stamp += 1
b.send(protocol.focus_v6(2, B))
received, started = 0, time.monotonic()
b.sock.settimeout(0.05)
while received < 4_000_000 and time.monotonic() - started < 10:
try:
chunk = b.sock.recv(65536)
except socket.timeout:
chunk = None
if chunk == b"":
break
received += len(chunk or b"")
b.send(protocol.ping_msg())
time.sleep(0.03)
self.assertGreaterEqual(received, 4_000_000)
self.assertIn(B, self.machine.responder.links())
class AFrameThatNeverFinishes(Case):
def test_a_frame_still_arriving_past_its_deadline_from_its_first_byte_ends_the_link(self):
# A byte every tenth of a second keeps the link alive, so only the frame's own deadline,
# counted from its first length byte, can end it.
with mock.patch.object(protocol, "FRAME_COMPLETE_SECONDS", 0.8):
b = Initiator(self.machine, B)
self.addCleanup(b.close)
b.handshake()
self.assertTrue(wait_for(lambda: B in self.machine.responder.links()))
started = time.monotonic()
b.sock.sendall(struct.pack(">I", 1000))
while B in self.machine.responder.links() and time.monotonic() - started < 3:
try:
b.sock.sendall(b"\x00")
except OSError:
break
time.sleep(0.1)
self.assertNotIn(B, self.machine.responder.links())
self.assertLess(time.monotonic() - started, 2.0)
def receiver_id(machine):
return machine.responder._identity()["id"]
class BusyIsDecidedAfterTheClaimIsVisible(Case):
def test_the_take_is_visible_to_the_app_before_away_is_read(self):
seen = []
def away():
seen.append(self.machine.responder.driven)
return False
self.machine.responder._away = away
b = self.link(B)
self.own(b)
self.assertEqual(seen, [True])
self.assertTrue(self.machine.responder.driven)
def test_a_busy_refusal_leaves_nothing_claimed(self):
self.machine.away = True
b = self.link(B)
route = b.take()
self.assertEqual(b.answer(route), (REFUSE, {"route": route, "why": "busy"}))
self.assertFalse(self.machine.responder.driven)
self.assertIsNone(self.machine.responder.owner)
class AnAppCallbackThatRaises(Case):
def test_a_zones_callback_that_raises_leaves_the_link_working(self):
def broken():
raise RuntimeError("the settings are being rewritten")
self.machine.responder._zones = broken
b = self.link(B)
self.own(b)
self.assertEqual(self.machine.responder.links(), {B})
class Unlocking(Case):
class Unlock:
def __init__(self):
self.locked = False
def is_locked(self):
return self.locked
def ensure_unlocked(self):
time.sleep(0.8)
self.locked = False
return True
def test_releases_still_reach_the_injector_while_it_unlocks(self):
unlock = self.Unlock()
self.machine.responder._unlock = unlock
b = self.link(B)
self.own(b)
b.key("keydown", "shift")
self.assertTrue(wait_for(lambda: ("key", "shift", True) in self.machine.injected()))
unlock.locked = True
self.own(b, edge="left", offset=0.5)
self.assertTrue(wait_for(lambda: self.machine.responder._unlocking.is_set()))
b.key("keyup", "shift")
b.key("keydown", "x")
self.assertTrue(wait_for(lambda: ("key", "shift", False) in self.machine.injected(), timeout=0.5))
self.assertNotIn(("key", "x", True), self.machine.injected())
self.assertEqual(self.machine.responder.owner, B)
def test_only_the_owner_hears_that_the_machine_is_locked(self):
unlock = self.Unlock()
unlock.locked = True
self.machine.responder._unlock = unlock
b, c = self.link(B), self.link(C)
self.own(b, edge="left", offset=0.5)
self.assertTrue(wait_for(lambda: self.machine.responder._unlocking.is_set()))
self.assertTrue(b.expect(protocol.MSG_ACK, timeout=1.0).get("locked"))
ack = c.expect(protocol.MSG_ACK, timeout=1.0)
self.assertNotIn("locked", ack)
class TheLinkReplaced(Case):
def test_a_take_on_a_replaced_link_is_never_accepted(self):
first = self.link(B)
old = self.machine.responder._links[B]
real_close = receiver._Link.close
def slow_close(link):
time.sleep(0.4)
real_close(link)
with mock.patch.object(receiver._Link, "close", slow_close):
second = Initiator(self.machine, B)
self.addCleanup(second.close)
done = threading.Thread(target=second.handshake)
done.start()
self.assertTrue(wait_for(lambda: self.machine.responder._links.get(B) not in (None, old)))
route = first.take()
self.assertIsNone(first.answer(route, timeout=1.0))
done.join(3)
self.assertNotIn(B, self.machine.owners)
class ZonesArmedFromFreshSettings(Case):
zones = [{"peer": protocol.id_text(C), "kind": "edge", "off": True}]
def setUp(self):
super().setUp()
for item in self.machine.settings.data["peers"]:
item["side"] = "right" if item["token"] == TOKENS[C] else "left"
def test_a_zone_change_during_a_take_is_not_lost(self):
stale = [dict(zone) for zone in self.machine.settings.data["zones"]]
calls = []
def zones():
calls.append(1)
if len(calls) == 1:
self.machine.settings.data["zones"][0]["off"] = False
changer = threading.Thread(target=self.machine.responder.rearm)
changer.start()
changer.join(2)
return stale
return self.machine.settings.data["zones"]
b = self.link(B)
self.machine.responder._zones = zones
route = self.own(b, reach=[C])
self.machine.desktop.cursor = (1919, 500)
b.move(200, 0)
switch = b.expect(protocol.MSG_SWITCH, timeout=1.0)
self.assertIsNotNone(switch)
self.assertEqual((switch["route"], switch["next"]), (route, protocol.id_text(C)))
if __name__ == "__main__":
unittest.main()