346 lines
14 KiB
Python
346 lines
14 KiB
Python
"""Exercise AT framing, endpoint cleanup, and the experimental PPP boundary."""
|
|
import importlib.util
|
|
import os
|
|
from pathlib import Path
|
|
import select
|
|
import socket
|
|
import subprocess
|
|
import tempfile
|
|
import threading
|
|
import unittest
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
spec = importlib.util.spec_from_file_location('cellular_rpmsg', ROOT / 'scripts/phone-cellular-rpmsg.py')
|
|
rpmsg = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(rpmsg)
|
|
|
|
|
|
class FrameStatsTests(unittest.TestCase):
|
|
@staticmethod
|
|
def encode(payload):
|
|
fcs = rpmsg.PPPFrameStats.fcs(payload) ^ 0xffff
|
|
frame = payload + fcs.to_bytes(2, 'little')
|
|
escaped = bytearray(b'\x7e')
|
|
for byte in frame:
|
|
if byte < 0x20 or byte in (0x7d, 0x7e):
|
|
escaped.extend((0x7d, byte ^ 0x20))
|
|
else:
|
|
escaped.append(byte)
|
|
return bytes(escaped) + b'\x7e'
|
|
|
|
def test_fcs_matches_captured_modem_lcp_frame(self):
|
|
stats = rpmsg.PPPFrameStats()
|
|
stats.feed(bytes.fromhex('7e80210100000467c37e'))
|
|
self.assertEqual(stats.protocols, {'ipcp': 1})
|
|
self.assertEqual(stats.invalid_fcs, 0)
|
|
|
|
def test_stream_splits_and_compression_do_not_change_ip_counts(self):
|
|
stats = rpmsg.PPPFrameStats()
|
|
payload = bytes(range(40)) + b'\x7d\x7e'
|
|
data = self.encode(b'\xff\x03\x00\x21' + payload)
|
|
data += self.encode(b'\x21' + payload)
|
|
# Includes every split position, including the middle of escapes/FCS.
|
|
for byte in b'CONNECT\r\n' + data:
|
|
stats.feed(bytes([byte]))
|
|
self.assertEqual(stats.protocols, {'ipv4': 2})
|
|
self.assertEqual(stats.ipv4_bytes, len(payload) * 2)
|
|
self.assertEqual(stats.invalid_fcs, 0)
|
|
|
|
def test_corrupt_and_oversized_frames_are_not_received_ip(self):
|
|
stats = rpmsg.PPPFrameStats()
|
|
stats.feed(b'\x7e\x21\x45\x01\x02\x03\x7e')
|
|
stats.feed(b'\x7e' + b'x' * 65537 + b'\x7e')
|
|
stats.feed(self.encode(b'\xc0\x21\x09\x00\x00\x04'))
|
|
self.assertEqual(stats.invalid_fcs, 1)
|
|
self.assertEqual(stats.oversized, 1)
|
|
self.assertEqual(stats.protocols, {'lcp': 1})
|
|
self.assertEqual(stats.ipv4_bytes, 0)
|
|
|
|
|
|
class ATTests(unittest.TestCase):
|
|
def exchange(self, chunks, command='AT', timeout=1):
|
|
host, modem = socket.socketpair(type=socket.SOCK_DGRAM)
|
|
self.addCleanup(host.close)
|
|
self.addCleanup(modem.close)
|
|
observed = []
|
|
|
|
def respond():
|
|
observed.append(modem.recv(65536))
|
|
for data in chunks:
|
|
modem.send(data)
|
|
|
|
thread = threading.Thread(target=respond, daemon=True)
|
|
thread.start()
|
|
result = rpmsg.at_command(host.fileno(), command, timeout)
|
|
thread.join(timeout=1)
|
|
self.assertFalse(thread.is_alive())
|
|
self.assertEqual(observed, [command.encode() + b'\r'])
|
|
return result
|
|
|
|
def test_split_response(self):
|
|
result = self.exchange([b'AT\r\r\nO', b'K\r\n'])
|
|
self.assertEqual(result['result'], 'OK')
|
|
|
|
def test_connect_preserves_binary_ppp_bytes_in_same_message(self):
|
|
payload = b'\x7e\xff\x03\xc0\x21\x00\xff\x7d\x5e\x7e'
|
|
result = self.exchange([b'\r\nCONNECT\r\n' + payload], 'ATD*99#')
|
|
self.assertEqual(result['result'], 'CONNECT')
|
|
self.assertEqual(result['trailing'], b'\n' + payload)
|
|
|
|
def test_extended_error_is_not_success(self):
|
|
result = self.exchange([b'\r\n+CME ERROR: operation not supported\r\n'])
|
|
self.assertEqual(result['result'], '+CME ERROR: operation not supported')
|
|
|
|
def test_no_carrier(self):
|
|
result = self.exchange([b'\r\nNO CARRIER\r\n'])
|
|
self.assertEqual(result['result'], 'NO CARRIER')
|
|
|
|
def test_ok_inside_information_line_does_not_end_response(self):
|
|
result = self.exchange([b'\r\n+INFO: OK\r\n', b'\r\nERROR\r\n'])
|
|
self.assertEqual(result['result'], 'ERROR')
|
|
|
|
def test_timeout_is_not_success(self):
|
|
result = self.exchange([b'\r\n+CEREG: 0,2\r\n'], timeout=0.02)
|
|
self.assertEqual(result['result'], 'TIMEOUT')
|
|
|
|
def test_reject_command_injection(self):
|
|
with self.assertRaises(ValueError):
|
|
rpmsg.at_command(-1, 'AT\rATD*99#')
|
|
|
|
|
|
class EndpointTests(unittest.TestCase):
|
|
def test_exclusive_session_rejects_a_second_owner(self):
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
lock = str(Path(tmp) / 'session.lock')
|
|
with rpmsg.exclusive_session(lock):
|
|
with self.assertRaisesRegex(RuntimeError, 'Another'):
|
|
with rpmsg.exclusive_session(lock):
|
|
self.fail('must not acquire an owned lock')
|
|
with rpmsg.exclusive_session(lock):
|
|
pass
|
|
|
|
def test_existing_binding_is_preserved(self):
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
device = Path(tmp) / 'bus/rpmsg/devices/4080000.remoteproc:glink-edge.DS.-1.-1'
|
|
(device / 'driver').mkdir(parents=True)
|
|
(device / 'driver_override').write_text('existing\n')
|
|
with self.assertRaisesRegex(RuntimeError, 'already bound'):
|
|
with rpmsg.open_channel(sys_path=tmp):
|
|
self.fail('must not yield a busy endpoint')
|
|
self.assertEqual((device / 'driver_override').read_text(), 'existing\n')
|
|
|
|
def test_endpoint_timeout_restores_override(self):
|
|
with tempfile.TemporaryDirectory() as tmp:
|
|
root = Path(tmp)
|
|
device = root / 'bus/rpmsg/devices/4080000.remoteproc:glink-edge.DS.-1.-1'
|
|
driver = root / 'bus/rpmsg/drivers/rpmsg_chrdev'
|
|
device.mkdir(parents=True)
|
|
driver.mkdir(parents=True)
|
|
(device / 'driver_override').write_text('(null)\n')
|
|
with self.assertRaises(TimeoutError):
|
|
with rpmsg.open_channel(sys_path=tmp, timeout=0):
|
|
self.fail('must not yield a missing endpoint')
|
|
self.assertEqual((device / 'driver_override').read_text(), '\n')
|
|
|
|
def test_does_not_take_over_control_channel(self):
|
|
with self.assertRaises(ValueError):
|
|
with rpmsg.open_channel('IPCRTR'):
|
|
self.fail('must not open a control channel')
|
|
|
|
|
|
class PPPTests(unittest.TestCase):
|
|
def test_shutdown_forwards_termination_and_peer_ack(self):
|
|
host, modem = socket.socketpair(type=socket.SOCK_DGRAM)
|
|
self.addCleanup(host.close)
|
|
self.addCleanup(modem.close)
|
|
host.setblocking(False)
|
|
modem.settimeout(2)
|
|
master, slave = rpmsg.pty.openpty()
|
|
self.addCleanup(os.close, master)
|
|
self.addCleanup(os.close, slave)
|
|
rpmsg.tty.setraw(slave)
|
|
os.set_blocking(master, False)
|
|
os.set_blocking(slave, False)
|
|
termination = b'\x7e\xff\x03\xc0\x21\x05\x01\x00\x04\x7e'
|
|
ack = b'\x7e\xff\x03\xc0\x21\x06\x01\x00\x04\x7e'
|
|
observed = []
|
|
|
|
def peer():
|
|
observed.append(modem.recv(1024))
|
|
modem.send(ack)
|
|
|
|
thread = threading.Thread(target=peer, daemon=True)
|
|
thread.start()
|
|
|
|
class Process:
|
|
killed = False
|
|
returncode = None
|
|
|
|
def terminate(self):
|
|
os.write(slave, termination)
|
|
|
|
def poll(self):
|
|
if select.select([slave], [], [], 0)[0]:
|
|
if os.read(slave, 1024) == ack:
|
|
self.returncode = 0
|
|
return self.returncode
|
|
|
|
def kill(self):
|
|
self.killed = True
|
|
self.returncode = -9
|
|
|
|
def wait(self, timeout=None):
|
|
return self.returncode
|
|
|
|
process = Process()
|
|
rpmsg.stop_ppp(process, host.fileno(), master, timeout=1)
|
|
thread.join(timeout=2)
|
|
self.assertFalse(thread.is_alive())
|
|
self.assertEqual(observed, [termination])
|
|
self.assertEqual(process.returncode, 0)
|
|
self.assertFalse(process.killed)
|
|
|
|
def test_manager_is_restored_when_modem_preparation_fails(self):
|
|
calls = []
|
|
|
|
def run(command, **kwargs):
|
|
calls.append(command)
|
|
if command[0] == 'qmicli':
|
|
raise subprocess.CalledProcessError(1, command)
|
|
return subprocess.CompletedProcess(command, 0)
|
|
|
|
with patch.object(rpmsg.subprocess, 'run', side_effect=run):
|
|
with self.assertRaises(subprocess.CalledProcessError):
|
|
with rpmsg.data_session():
|
|
self.fail('must not enter a failed data session')
|
|
self.assertIn(['rc-service', 'modemmanager', 'stop'], calls)
|
|
self.assertEqual(calls[-1], ['rc-service', 'modemmanager', 'start'])
|
|
|
|
def test_initially_stopped_manager_stays_stopped(self):
|
|
calls = []
|
|
|
|
def run(command, **kwargs):
|
|
calls.append(command)
|
|
status = 3 if command == ['rc-service', 'modemmanager', 'status'] else 0
|
|
return subprocess.CompletedProcess(command, status)
|
|
|
|
with patch.object(rpmsg.subprocess, 'run', side_effect=run):
|
|
with rpmsg.data_session():
|
|
pass
|
|
self.assertNotIn(['rc-service', 'modemmanager', 'stop'], calls)
|
|
self.assertNotIn(['rc-service', 'modemmanager', 'start'], calls)
|
|
|
|
def test_dns_requires_a_matching_reply_and_binds_the_interface(self):
|
|
fake = MagicMock()
|
|
fake.__enter__.return_value = fake
|
|
fake.recv.side_effect = [b'bad', b'\x12\x34\x81\x80\x00\x01\x00\x01' + b'\x00' * 4]
|
|
with patch.object(rpmsg.socket, 'SO_BINDTODEVICE', 25, create=True), \
|
|
patch.object(rpmsg.socket, 'socket', return_value=fake), \
|
|
patch.object(rpmsg.os, 'urandom', return_value=b'\x12\x34'):
|
|
result = rpmsg.probe_dns('ppp0', '223.5.5.5')
|
|
fake.setsockopt.assert_called_once_with(socket.SOL_SOCKET, 25, b'ppp0\0')
|
|
fake.connect.assert_called_once_with(('223.5.5.5', 53))
|
|
self.assertEqual(result['exit_code'], 0)
|
|
self.assertEqual(result['answers'], 1)
|
|
|
|
def test_dns_timeouts_do_not_report_connectivity(self):
|
|
fake = MagicMock()
|
|
fake.__enter__.return_value = fake
|
|
fake.recv.side_effect = TimeoutError('timed out')
|
|
with patch.object(rpmsg.socket, 'SO_BINDTODEVICE', 25, create=True), \
|
|
patch.object(rpmsg.socket, 'socket', return_value=fake):
|
|
result = rpmsg.probe_dns('ppp0', '223.5.5.5')
|
|
self.assertEqual(result['exit_code'], 1)
|
|
self.assertEqual(len(result['errors']), 3)
|
|
|
|
def test_bridge_preserves_binary_data_in_both_directions(self):
|
|
host, modem = socket.socketpair(type=socket.SOCK_DGRAM)
|
|
self.addCleanup(host.close)
|
|
self.addCleanup(modem.close)
|
|
outgoing = b'\x7e\x00\xff\x7d\x5e\x01\x7e'
|
|
incoming = b'\x7e\x03\x00\xff\x7d\x5d\x7e'
|
|
received = []
|
|
observed = []
|
|
|
|
def modem_peer():
|
|
observed.append(modem.recv(65536))
|
|
modem.send(incoming)
|
|
|
|
class PPPPeer:
|
|
def __init__(self, command):
|
|
self.returncode = None
|
|
self.fd = os.open(command[1], os.O_RDWR | os.O_NONBLOCK | os.O_NOCTTY)
|
|
self.thread = threading.Thread(target=self.run, daemon=True)
|
|
self.thread.start()
|
|
|
|
def run(self):
|
|
try:
|
|
os.write(self.fd, outgoing)
|
|
while self.returncode is None:
|
|
if select.select([self.fd], [], [], 0.1)[0]:
|
|
received.append(os.read(self.fd, 65536))
|
|
if b''.join(received) == incoming:
|
|
self.returncode = 0
|
|
finally:
|
|
os.close(self.fd)
|
|
|
|
def poll(self):
|
|
return self.returncode
|
|
|
|
def terminate(self):
|
|
self.returncode = -15
|
|
|
|
def wait(self, timeout=None):
|
|
self.thread.join(timeout)
|
|
|
|
thread = threading.Thread(target=modem_peer, daemon=True)
|
|
thread.start()
|
|
replies = [{'result': 'OK', 'response': 'OK', 'trailing': b''} for _ in range(4)]
|
|
replies.append({'result': 'CONNECT', 'response': 'CONNECT', 'trailing': b''})
|
|
with patch.object(rpmsg, 'at_command', side_effect=replies), \
|
|
patch.object(rpmsg, 'wait_registration'), \
|
|
patch.object(rpmsg.shutil, 'which', return_value='/usr/sbin/pppd'), \
|
|
patch.object(rpmsg.subprocess, 'run', return_value=subprocess.CompletedProcess([], 0)), \
|
|
patch.object(rpmsg.subprocess, 'Popen', side_effect=PPPPeer), \
|
|
patch.object(rpmsg, 'interface_ipv4', return_value='10.0.0.2'), \
|
|
patch('builtins.print'):
|
|
result = rpmsg.connect(host.fileno(), '3gnet', duration=2)
|
|
thread.join(timeout=1)
|
|
self.assertFalse(thread.is_alive())
|
|
self.assertEqual(observed, [outgoing])
|
|
self.assertEqual(b''.join(received), incoming)
|
|
self.assertEqual(result['bridge_tx_bytes'], len(outgoing))
|
|
self.assertEqual(result['bridge_rx_bytes'], len(incoming))
|
|
self.assertFalse(result['ip_connectivity'])
|
|
|
|
def test_registration_waits_for_home_or_roaming(self):
|
|
results = [{'result': 'OK', 'response': '+CEREG: 0,2\r\n', 'trailing': b''},
|
|
{'result': 'OK', 'response': '+CEREG: 0,5\r\n', 'trailing': b''}]
|
|
with patch.object(rpmsg, 'at_command', side_effect=results), \
|
|
patch.object(rpmsg.time, 'sleep'), patch('builtins.print'):
|
|
rpmsg.wait_registration(-1, 1)
|
|
|
|
def test_command_does_not_install_default_route_or_dns(self):
|
|
command = rpmsg.ppp_command('/dev/pts/5')
|
|
self.assertIn('nodefaultroute', command)
|
|
self.assertNotIn('usepeerdns', command)
|
|
self.assertNotIn('persist', command)
|
|
self.assertIn('noauth', command)
|
|
|
|
def test_invalid_interface_rejected(self):
|
|
with self.assertRaises(ValueError):
|
|
rpmsg.ppp_command('/dev/pts/5', 'wlan0')
|
|
|
|
def test_invalid_apn_rejected_before_any_call(self):
|
|
with self.assertRaises(ValueError):
|
|
rpmsg.connect(-1, '3gnet"\rAT+CFUN=0')
|
|
|
|
def test_local_verification_target_is_not_an_internet_test(self):
|
|
with self.assertRaisesRegex(ValueError, 'public IPv4'):
|
|
rpmsg.connect(-1, '3gnet', verify_target='172.16.42.1')
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|