def write_packet(self, packet: NetRomPacket) -> bool:
source = NetRomAddress(packet.source.callsign, packet.source.ssid,
"SOURCE")
dest = NetRomAddress(packet.dest.callsign, packet.dest.ssid, "DEST")
payload = L3Payload(source, dest, 0xCF, packet.buffer, -1, QoS.Default,
True)
if self.l3_protocol is not None:
return self.l3_protocol.send_packet(payload)
else:
self.warning("Cannot send, L3 not attached")
return False
def nl_data_request(self, my_circuit_id: int, remote_call: AX25Call,
local_call: AX25Call, data: bytes) -> None:
dest = NetRomAddress(remote_call.callsign, remote_call.ssid)
routed, mtu = self.l3_protocol.route_packet(dest)
if routed:
event = NetRomStateEvent.nl_data(my_circuit_id, remote_call, data,
mtu)
self.sm.handle_internal_event_sync(event)
else:
self.debug(f"No route to {dest}, dropping")
def bind_server(self, l3_call: AX25Call, l3_alias: str,
protocol_factory: Callable[[], Protocol]):
"""
Bind a protocol factory to a NetRom destination address
:param l3_call: The callsign for the destination
:param l3_alias: An alias for this destination (used in NODES broadcast)
:param protocol_factory: The protocol factory
:return:
"""
self.l3_servers[l3_call] = protocol_factory
self.l3_protocol.listen(
NetRomAddress(l3_call.callsign, l3_call.ssid, l3_alias))
self.l3_destinations.add(l3_call)
def open(self, protocol_factory: Callable[[], Protocol],
local_call: AX25Call, remote_call: AX25Call,
origin_node: AX25Call, origin_user: AX25Call) -> Protocol:
# This a new connection, create the transport and protocol
nl_connect = NetRomStateEvent.nl_connect(-1, remote_call, local_call,
origin_node, origin_user)
self.sm.handle_internal_event_sync(nl_connect)
protocol = protocol_factory()
self.l3_half_open[nl_connect.circuit_id] = protocol
self.l3_protocol.listen(
NetRomAddress(local_call.callsign, local_call.ssid, ""))
self.l3_destinations.add(local_call)
return protocol
async def wait_for_network():
tty = TTY()
loop.add_reader(sys.stdin, tty.handle_stdin)
loop.add_signal_handler(signal.SIGTERM, tty.handle_signal, loop, scheduler)
loop.add_signal_handler(signal.SIGINT, tty.handle_signal, loop, scheduler)
remote_call = AX25Call.parse(args.remote_call)
while True:
(found, mtu) = netrom_l3.route_packet(NetRomAddress.from_call(remote_call))
if found:
break
await asyncio.sleep(0.200)
main_logger.info(f"Learned route to {remote_call}")
await asyncio.sleep(1.200)
netrom_l4.open(protocol_factory=lambda: tty,
local_call=AX25Call.parse(args.local_call),
remote_call=AX25Call.parse(args.remote_call),
origin_user=AX25Call(args.local_alias),
origin_node=AX25Call(args.local_call))
def local_address(self) -> Optional[NetRomAddress]:
return NetRomAddress(self.local_call.callsign, self.local_call.ssid)
def network_address(self) -> NetRomAddress:
return NetRomAddress(callsign=self.callsign, ssid=self.ssid)