2024-11-26 15:30:18 +00:00
9 changed files with 13 additions and 845 deletions
--- a/Examples/Buffer.py
+++ b/Examples/Buffer.py
@ -1,323 +0,0 @@
 ##########################################################
 # This RNS example demonstrates how to set up a link to  #
 # a destination, and pass binary data over it using a    #
 # using a channel buffer.                                #
 ##########################################################
 from __future__ import annotations
 import os
 import sys
 import time
 import argparse
 from datetime import datetime
 import RNS
 from RNS.vendor import umsgpack
 # Let's define an app name. We'll use this for all
 # destinations we create. Since this echo example
 # is part of a range of example utilities, we'll put
 # them all within the app namespace "example_utilities"
 APP_NAME = "example_utilities"
 ##########################################################
 #### Server Part #########################################
 ##########################################################
 # A reference to the latest client link that connected
 latest_client_link = None
 # A reference to the latest buffer object
 latest_buffer = None
 # This initialisation is executed when the users chooses
 # to run as a server
 def server(configpath):
    # We must first initialise Reticulum
    reticulum = RNS.Reticulum(configpath)
    # Randomly create a new identity for our link example
    server_identity = RNS.Identity()
    # We create a destination that clients can connect to. We
    # want clients to create links to this destination, so we
    # need to create a "single" destination type.
    server_destination = RNS.Destination(
        server_identity,
        RNS.Destination.IN,
        RNS.Destination.SINGLE,
        APP_NAME,
        "bufferexample"
    )
    # We configure a function that will get called every time
    # a new client creates a link to this destination.
    server_destination.set_link_established_callback(client_connected)
    # Everything's ready!
    # Let's Wait for client requests or user input
    server_loop(server_destination)
 def server_loop(destination):
    # Let the user know that everything is ready
    RNS.log(
        "Link example "+
        RNS.prettyhexrep(destination.hash)+
        " running, waiting for a connection."
    )
    RNS.log("Hit enter to manually send an announce (Ctrl-C to quit)")
    # We enter a loop that runs until the users exits.
    # If the user hits enter, we will announce our server
    # destination on the network, which will let clients
    # know how to create messages directed towards it.
    while True:
        entered = input()
        destination.announce()
        RNS.log("Sent announce from "+RNS.prettyhexrep(destination.hash))
 # When a client establishes a link to our server
 # destination, this function will be called with
 # a reference to the link.
 def client_connected(link):
    global latest_client_link, latest_buffer
    latest_client_link = link
    RNS.log("Client connected")
    link.set_link_closed_callback(client_disconnected)
    # If a new connection is received, the old reader
    # needs to be disconnected.
    if latest_buffer:
        latest_buffer.close()
    # Create buffer objects.
    #   The stream_id parameter to these functions is
    #   a bit like a file descriptor, except that it
    #   is unique to the *receiver*.
    #
    #   In this example, both the reader and the writer
    #   use stream_id = 0, but there are actually two
    #   separate unidirectional streams flowing in
    #   opposite directions.
    #
    channel = link.get_channel()
    latest_buffer = RNS.Buffer.create_bidirectional_buffer(0, 0, channel, server_buffer_ready)
 def client_disconnected(link):
    RNS.log("Client disconnected")
 def server_buffer_ready(ready_bytes: int):
    """
    Callback from buffer when buffer has data available
    :param ready_bytes: The number of bytes ready to read
    """
    global latest_buffer
    data = latest_buffer.read(ready_bytes)
    data = data.decode("utf-8")
    RNS.log("Received data on the link: " + data)
    reply_message = "I received \""+data+"\" over the buffer"
    reply_message = reply_message.encode("utf-8")
    latest_buffer.write(reply_message)
    latest_buffer.flush()
 ##########################################################
 #### Client Part #########################################
 ##########################################################
 # A reference to the server link
 server_link = None
 # A reference to the buffer object, needed to share the
 # object from the link connected callback to the client
 # loop.
 buffer = None
 # This initialisation is executed when the users chooses
 # to run as a client
 def client(destination_hexhash, configpath):
    # We need a binary representation of the destination
    # hash that was entered on the command line
    try:
        dest_len = (RNS.Reticulum.TRUNCATED_HASHLENGTH//8)*2
        if len(destination_hexhash) != dest_len:
            raise ValueError(
                "Destination length is invalid, must be {hex} hexadecimal characters ({byte} bytes).".format(hex=dest_len, byte=dest_len//2)
            )
        destination_hash = bytes.fromhex(destination_hexhash)
    except:
        RNS.log("Invalid destination entered. Check your input!\n")
        exit()
    # We must first initialise Reticulum
    reticulum = RNS.Reticulum(configpath)
    # Check if we know a path to the destination
    if not RNS.Transport.has_path(destination_hash):
        RNS.log("Destination is not yet known. Requesting path and waiting for announce to arrive...")
        RNS.Transport.request_path(destination_hash)
        while not RNS.Transport.has_path(destination_hash):
            time.sleep(0.1)
    # Recall the server identity
    server_identity = RNS.Identity.recall(destination_hash)
    # Inform the user that we'll begin connecting
    RNS.log("Establishing link with server...")
    # When the server identity is known, we set
    # up a destination
    server_destination = RNS.Destination(
        server_identity,
        RNS.Destination.OUT,
        RNS.Destination.SINGLE,
        APP_NAME,
        "bufferexample"
    )
    # And create a link
    link = RNS.Link(server_destination)
    # We'll also set up functions to inform the
    # user when the link is established or closed
    link.set_link_established_callback(link_established)
    link.set_link_closed_callback(link_closed)
    # Everything is set up, so let's enter a loop
    # for the user to interact with the example
    client_loop()
 def client_loop():
    global server_link
    # Wait for the link to become active
    while not server_link:
        time.sleep(0.1)
    should_quit = False
    while not should_quit:
        try:
            print("> ", end=" ")
            text = input()
            # Check if we should quit the example
            if text == "quit" or text == "q" or text == "exit":
                should_quit = True
                server_link.teardown()
            else:
                # Otherwise, encode the text and write it to the buffer.
                text = text.encode("utf-8")
                buffer.write(text)
                # Flush the buffer to force the data to be sent.
                buffer.flush()
        except Exception as e:
            RNS.log("Error while sending data over the link: "+str(e))
            should_quit = True
            server_link.teardown()
 # This function is called when a link
 # has been established with the server
 def link_established(link):
    # We store a reference to the link
    # instance for later use
    global server_link, buffer
    server_link = link
    # Create buffer, see server_client_connected() for
    # more detail about setting up the buffer.
    channel = link.get_channel()
    buffer = RNS.Buffer.create_bidirectional_buffer(0, 0, channel, client_buffer_ready)
    # Inform the user that the server is
    # connected
    RNS.log("Link established with server, enter some text to send, or \"quit\" to quit")
 # When a link is closed, we'll inform the
 # user, and exit the program
 def link_closed(link):
    if link.teardown_reason == RNS.Link.TIMEOUT:
        RNS.log("The link timed out, exiting now")
    elif link.teardown_reason == RNS.Link.DESTINATION_CLOSED:
        RNS.log("The link was closed by the server, exiting now")
    else:
        RNS.log("Link closed, exiting now")
    RNS.Reticulum.exit_handler()
    time.sleep(1.5)
    os._exit(0)
 # When the buffer has new data, read it and write it to the terminal.
 def client_buffer_ready(ready_bytes: int):
    global buffer
    data = buffer.read(ready_bytes)
    RNS.log("Received data on the link: " + data.decode("utf-8"))
    print("> ", end=" ")
    sys.stdout.flush()
 ##########################################################
 #### Program Startup #####################################
 ##########################################################
 # This part of the program runs at startup,
 # and parses input of from the user, and then
 # starts up the desired program mode.
 if __name__ == "__main__":
    try:
        parser = argparse.ArgumentParser(description="Simple buffer example")
        parser.add_argument(
            "-s",
            "--server",
            action="store_true",
            help="wait for incoming link requests from clients"
        )
        parser.add_argument(
            "--config",
            action="store",
            default=None,
            help="path to alternative Reticulum config directory",
            type=str
        )
        parser.add_argument(
            "destination",
            nargs="?",
            default=None,
            help="hexadecimal hash of the server destination",
            type=str
        )
        args = parser.parse_args()
        if args.config:
            configarg = args.config
        else:
            configarg = None
        if args.server:
            server(configarg)
        else:
            if (args.destination == None):
                print("")
                parser.print_help()
                print("")
            else:
                client(args.destination, configarg)
    except KeyboardInterrupt:
        print("")
        exit()
--- a/Examples/Channel.py
+++ b/Examples/Channel.py
@ -243,6 +243,11 @@ def client(destination_hexhash, configpath):
    # And create a link
    link = RNS.Link(server_destination)
    # We set a callback that will get executed
    # every time a packet is received over the
    # link
    link.set_packet_callback(client_message_received)
    # We'll also set up functions to inform the
    # user when the link is established or closed
    link.set_link_established_callback(link_established)
@ -325,7 +330,7 @@ def link_closed(link):
    time.sleep(1.5)
    os._exit(0)
-# When a packet is received over the channel, we
+# When a packet is received over the link, we
 # simply print out the data.
 def client_message_received(message):
    if isinstance(message, StringMessage):
@ -343,7 +348,7 @@ def client_message_received(message):
 # starts up the desired program mode.
 if __name__ == "__main__":
    try:
-        parser = argparse.ArgumentParser(description="Simple channel example")
+        parser = argparse.ArgumentParser(description="Simple link example")
        parser.add_argument(
            "-s",
--- a/RNS/Buffer.py
+++ b/RNS/Buffer.py
@ -1,305 +0,0 @@
 from __future__ import annotations
 import sys
 from threading import RLock
 from RNS.vendor import umsgpack
 from RNS.Channel import Channel, MessageBase, SystemMessageTypes
 import RNS
 from io import RawIOBase, BufferedRWPair, BufferedReader, BufferedWriter
 from typing import Callable
 from contextlib import AbstractContextManager
 class StreamDataMessage(MessageBase):
    MSGTYPE = SystemMessageTypes.SMT_STREAM_DATA
    """
    Message type for ``Channel``. ``StreamDataMessage``
    uses a system-reserved message type.
    """
    STREAM_ID_MAX = 65535
    """
    While not essential for the current message packing
    method (umsgpack), the stream id is clamped to the
    size of a UInt16 for future struct packing.
    """
    OVERHEAD = 0
    """
    The number of bytes used by this messa
    When the Buffer package is imported, this value is
    calculated based on the value of RNS.Link.MDU.
    """
    MAX_DATA_LEN = 0
    """
    When the Buffer package is imported, this value is
    calculcated based on the value of OVERHEAD
    """
    def __init__(self, stream_id: int = None, data: bytes = None, eof: bool = False):
        """
        This class is used to encapsulate binary stream
        data to be sent over a ``Channel``.
        :param stream_id: id of stream relative to receiver
        :param data: binary data
        :param eof: set to True if signalling End of File
        """
        super().__init__()
        if stream_id is not None and stream_id > self.STREAM_ID_MAX:
            raise ValueError("stream_id must be 0-65535")
        self.stream_id = stream_id
        self.data = data or bytes()
        self.eof = eof
    def pack(self) -> bytes:
        if self.stream_id is None:
            raise ValueError("stream_id")
        return umsgpack.packb((self.stream_id, self.eof, bytes(self.data)))
    def unpack(self, raw):
        self.stream_id, self.eof, self.data = umsgpack.unpackb(raw)
 _link_sized_bytes = ("\0"*RNS.Link.MDU).encode("utf-8")
 StreamDataMessage.OVERHEAD = len(StreamDataMessage(stream_id=StreamDataMessage.STREAM_ID_MAX,
                                                   data=_link_sized_bytes,
                                                   eof=True).pack()) - len(_link_sized_bytes) - 6  # 6 is envelope overhead
 StreamDataMessage.MAX_DATA_LEN = RNS.Link.MDU - StreamDataMessage.OVERHEAD
 _link_sized_bytes = None
 class RawChannelReader(RawIOBase, AbstractContextManager):
    """
    An implementation of RawIOBase that receives
    binary stream data sent over a ``Channel``.
      This class generally need not be instantiated directly.
      Use :func:`RNS.Buffer.create_reader`,
      :func:`RNS.Buffer.create_writer`, and
      :func:`RNS.Buffer.create_bidirectional_buffer` functions
      to create buffered streams with optional callbacks.
      For additional information on the API of this
      object, see the Python documentation for
      ``RawIOBase``.
    """
    def __init__(self, stream_id: int, channel: Channel):
        """
        Create a raw channel reader.
        :param stream_id: local stream id to receive at
        :param channel: ``Channel`` object to receive from
        """
        self._stream_id = stream_id
        self._channel = channel
        self._lock = RLock()
        self._buffer = bytearray()
        self._eof = False
        self._channel._register_message_type(StreamDataMessage, is_system_type=True)
        self._channel.add_message_handler(self._handle_message)
        self._listeners: [Callable[[int], None]] = []
    def add_ready_callback(self, cb: Callable[[int], None]):
        """
        Add a function to be called when new data is available.
        The function should have the signature ``(ready_bytes: int) -> None``
        :param cb: function to call
        """
        with self._lock:
            self._listeners.append(cb)
    def remove_ready_callback(self, cb: Callable[[int], None]):
        """
        Remove a function added with :func:`RNS.RawChannelReader.add_ready_callback()`
        :param cb: function to remove
        """
        with self._lock:
            self._listeners.remove(cb)
    def _handle_message(self, message: MessageBase):
        if isinstance(message, StreamDataMessage):
            if message.stream_id == self._stream_id:
                with self._lock:
                    if message.data is not None:
                        self._buffer.extend(message.data)
                    if message.eof:
                        self._eof = True
                    for listener in self._listeners:
                        try:
                            listener(len(self._buffer))
                        except Exception as ex:
                            RNS.log("Error calling RawChannelReader(" + str(self._stream_id) + ") callback: " + str(ex))
                    return True
        return False
    def _read(self, __size: int) -> bytes | None:
        with self._lock:
            result = self._buffer[:__size]
            self._buffer = self._buffer[__size:]
            return result if len(result) > 0 or self._eof else None
    def readinto(self, __buffer: bytearray) -> int | None:
        ready = self._read(len(__buffer))
        if ready:
            __buffer[:len(ready)] = ready
        return len(ready) if ready else None
    def writable(self) -> bool:
        return False
    def seekable(self) -> bool:
        return False
    def readable(self) -> bool:
        return True
    def close(self):
        with self._lock:
            self._channel.remove_message_handler(self._handle_message)
            self._listeners.clear()
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.close()
        return False
 class RawChannelWriter(RawIOBase, AbstractContextManager):
    """
    An implementation of RawIOBase that receives
    binary stream data sent over a channel.
      This class generally need not be instantiated directly.
      Use :func:`RNS.Buffer.create_reader`,
      :func:`RNS.Buffer.create_writer`, and
      :func:`RNS.Buffer.create_bidirectional_buffer` functions
      to create buffered streams with optional callbacks.
      For additional information on the API of this
      object, see the Python documentation for
      ``RawIOBase``.
    """
    def __init__(self, stream_id: int, channel: Channel):
        """
        Create a raw channel writer.
        :param stream_id: remote stream id to sent do
        :param channel: ``Channel`` object to send on
        """
        self._stream_id = stream_id
        self._channel = channel
        self._eof = False
    def write(self, __b: bytes) -> int | None:
        try:
            if self._channel.is_ready_to_send():
                chunk = __b[:StreamDataMessage.MAX_DATA_LEN]
                message = StreamDataMessage(self._stream_id, chunk, self._eof)
                self._channel.send(message)
                return len(chunk)
        except RNS.Channel.ChannelException as cex:
            if cex.type != RNS.Channel.CEType.ME_LINK_NOT_READY:
                raise
        return 0
    def close(self):
        self._eof = True
        self.write(bytes())
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.close()
        return False
    def seekable(self) -> bool:
        return False
    def readable(self) -> bool:
        return False
    def writable(self) -> bool:
        return True
 class Buffer:
    """
    Static functions for creating buffered streams that send
    and receive over a ``Channel``.
    These functions use ``BufferedReader``, ``BufferedWriter``,
    and ``BufferedRWPair`` to add buffering to
    ``RawChannelReader`` and ``RawChannelWriter``.
    """
    @staticmethod
    def create_reader(stream_id: int, channel: Channel,
                      ready_callback: Callable[[int], None] | None = None) -> BufferedReader:
        """
        Create a buffered reader that reads binary data sent
        over a ``Channel``, with an optional callback when
        new data is available.
        Callback signature: ``(ready_bytes: int) -> None``
        For more information on the reader-specific functions
        of this object, see the Python documentation for
        ``BufferedReader``
        :param stream_id: the local stream id to receive from
        :param channel: the channel to receive on
        :param ready_callback: function to call when new data is available
        :return: a BufferedReader object
        """
        reader = RawChannelReader(stream_id, channel)
        if ready_callback:
            reader.add_ready_callback(ready_callback)
        return BufferedReader(reader)
    @staticmethod
    def create_writer(stream_id: int, channel: Channel) -> BufferedWriter:
        """
        Create a buffered writer that writes binary data over
        a ``Channel``.
        For more information on the writer-specific functions
        of this object, see the Python documentation for
        ``BufferedWriter``
        :param stream_id: the remote stream id to send to
        :param channel: the channel to send on
        :return: a BufferedWriter object
        """
        writer = RawChannelWriter(stream_id, channel)
        return BufferedWriter(writer)
    @staticmethod
    def create_bidirectional_buffer(receive_stream_id: int, send_stream_id: int, channel: Channel,
                                    ready_callback: Callable[[int], None] | None = None) -> BufferedRWPair:
        """
        Create a buffered reader/writer pair that reads and
        writes binary data over a ``Channel``, with an
        optional callback when new data is available.
        Callback signature: ``(ready_bytes: int) -> None``
        For more information on the reader-specific functions
        of this object, see the Python documentation for
        ``BufferedRWPair``
        :param receive_stream_id: the local stream id to receive at
        :param send_stream_id:  the remote stream id to send to
        :param channel: the channel to send and receive on
        :param ready_callback: function to call when new data is available
        :return: a BufferedRWPair object
        """
        reader = RawChannelReader(receive_stream_id, channel)
        if ready_callback:
            reader.add_ready_callback(ready_callback)
        writer = RawChannelWriter(send_stream_id, channel)
        return BufferedRWPair(reader, writer)
--- a/RNS/Channel.py
+++ b/RNS/Channel.py
@ -34,8 +34,6 @@ import RNS
 from abc import ABC, abstractmethod
 TPacket = TypeVar("TPacket")
 class SystemMessageTypes(enum.IntEnum):
    SMT_STREAM_DATA = 0xff00
 class ChannelOutletBase(ABC, Generic[TPacket]):
    """
--- a/RNS/init.py
+++ b/RNS/init.py
@ -33,7 +33,6 @@ from .Reticulum import Reticulum
 from .Identity import Identity
 from .Link import Link, RequestReceipt
 from .Channel import MessageBase
 from .Buffer import Buffer, RawChannelReader, RawChannelWriter
 from .Transport import Transport
 from .Destination import Destination
 from .Packet import Packet
--- a/docs/source/examples.rst
+++ b/docs/source/examples.rst
@ -104,16 +104,6 @@ data between peers of a ``Link``.
 This example can also be found at `<https://github.com/markqvist/Reticulum/blob/master/Examples/Channel.py>`_.
 Buffer
 ======
 The *Buffer* example explores using buffered readers and writers to send
 binary data between peers of a ``Link``.
 .. literalinclude:: ../../Examples/Buffer.py
 This example can also be found at `<https://github.com/markqvist/Reticulum/blob/master/Examples/Buffer.py>`_.
 .. _example-filetransfer:
 Filetransfer
--- a/docs/source/reference.rst
+++ b/docs/source/reference.rst
@ -149,48 +149,6 @@ This chapter lists and explains all classes exposed by the Reticulum Network Sta
 .. autoclass:: RNS.MessageBase()
   :members:
 .. _api-buffer:
 .. only:: html
   |start-h3| Buffer |end-h3|
 .. only:: latex
   Buffer
   ------
 .. autoclass:: RNS.Buffer
   :members:
 .. _api-rawchannelreader:
 .. only:: html
   |start-h3| RawChannelReader |end-h3|
 .. only:: latex
   RawChannelReader
   ----------------
 .. autoclass:: RNS.RawChannelReader
   :members: __init__, add_ready_callback, remove_ready_callback
 .. _api-rawchannelwriter:
 .. only:: html
   |start-h3| RawChannelWriter |end-h3|
 .. only:: latex
   RawChannelWriter
   ----------------
 .. autoclass:: RNS.RawChannelWriter
   :members: __init__
 .. _api-transport:
 .. only:: html
--- a/tests/channel.py
+++ b/tests/channel.py
@ -2,7 +2,6 @@ from __future__ import annotations
 import threading
 import RNS
 from RNS.Channel import MessageState, ChannelOutletBase, Channel, MessageBase
 import RNS.Buffer
 from RNS.vendor import umsgpack
 from typing import Callable
 import contextlib
@ -92,18 +91,15 @@ class ChannelOutletTest(ChannelOutletBase):
        self._rtt = rtt
        self._usable = True
        self.packets = []
        self.lock = threading.RLock()
        self.packet_callback: Callable[[ChannelOutletBase, bytes], None] | None = None
    def send(self, raw: bytes) -> Packet:
        with self.lock:
        packet = Packet(raw)
        packet.send()
        self.packets.append(packet)
        return packet
    def resend(self, packet: Packet) -> Packet:
        with self.lock:
        packet.send()
        return packet
@ -374,105 +370,6 @@ class TestChannel(unittest.TestCase):
        self.eat_own_dog_food(message, check)
    def test_buffer_small_bidirectional(self):
        data = "Hello\n"
        with RNS.Buffer.create_bidirectional_buffer(0, 0, self.h.channel) as buffer:
            count = buffer.write(data.encode("utf-8"))
            buffer.flush()
            self.assertEqual(len(data), count)
            self.assertEqual(1, len(self.h.outlet.packets))
            packet = self.h.outlet.packets[0]
            self.h.channel._receive(packet.raw)
            result = buffer.readline()
            self.assertIsNotNone(result)
            self.assertEqual(len(result), len(data))
            decoded = result.decode("utf-8")
            self.assertEqual(data, decoded)
    def test_buffer_big(self):
        writer = RNS.Buffer.create_writer(15, self.h.channel)
        reader = RNS.Buffer.create_reader(15, self.h.channel)
        data = "01234556789"*1024  # 10 KB
        count = 0
        write_finished = False
        def write_thread():
            nonlocal count, write_finished
            count = writer.write(data.encode("utf-8"))
            writer.flush()
            writer.close()
            write_finished = True
        threading.Thread(target=write_thread, name="Write Thread", daemon=True).start()
        while not write_finished or next(filter(lambda x: x.state != MessageState.MSGSTATE_DELIVERED,
                                                self.h.outlet.packets), None) is not None:
            with self.h.outlet.lock:
                for packet in self.h.outlet.packets:
                    if packet.state != MessageState.MSGSTATE_DELIVERED:
                        self.h.channel._receive(packet.raw)
                        packet.delivered()
            time.sleep(0.0001)
        self.assertEqual(len(data), count)
        read_finished = False
        result = bytes()
        def read_thread():
            nonlocal read_finished, result
            result = reader.read()
            read_finished = True
        threading.Thread(target=read_thread, name="Read Thread", daemon=True).start()
        timeout_at = time.time() + 7
        while not read_finished and time.time() < timeout_at:
            time.sleep(0.001)
        self.assertTrue(read_finished)
        self.assertEqual(len(data), len(result))
        decoded = result.decode("utf-8")
        self.assertSequenceEqual(data, decoded)
    def test_buffer_small_with_callback(self):
        callbacks = 0
        last_cb_value = None
        def callback(ready: int):
            nonlocal callbacks, last_cb_value
            callbacks += 1
            last_cb_value = ready
        data = "Hello\n"
        with RNS.RawChannelWriter(0, self.h.channel) as writer, RNS.RawChannelReader(0, self.h.channel) as reader:
            reader.add_ready_callback(callback)
            count = writer.write(data.encode("utf-8"))
            writer.flush()
            self.assertEqual(len(data), count)
            self.assertEqual(1, len(self.h.outlet.packets))
            packet = self.h.outlet.packets[0]
            self.h.channel._receive(packet.raw)
            self.assertEqual(1, callbacks)
            self.assertEqual(len(data), last_cb_value)
            result = reader.readline()
            self.assertIsNotNone(result)
            self.assertEqual(len(result), len(data))
            decoded = result.decode("utf-8")
            self.assertEqual(data, decoded)
 if __name__ == '__main__':
    unittest.main(verbosity=2)
--- a/tests/link.py
+++ b/tests/link.py
@ -396,48 +396,6 @@ class TestLink(unittest.TestCase):
        self.assertEqual(l1.status, RNS.Link.CLOSED)
        self.assertEqual(0, len(l1._channel._rx_ring))
    def test_11_buffer_round_trip(self):
        global c_rns
        init_rns(self)
        print("")
        print("Buffer round trip test")
        # TODO: Load this from public bytes only
        id1 = RNS.Identity.from_bytes(bytes.fromhex(fixed_keys[0][0]))
        self.assertEqual(id1.hash, bytes.fromhex(fixed_keys[0][1]))
        dest = RNS.Destination(id1, RNS.Destination.OUT, RNS.Destination.SINGLE, APP_NAME, "link", "establish")
        self.assertEqual(dest.hash, bytes.fromhex("fb48da0e82e6e01ba0c014513f74540d"))
        l1 = RNS.Link(dest)
        time.sleep(1)
        self.assertEqual(l1.status, RNS.Link.ACTIVE)
        buffer = None
        received = []
        def handle_data(ready_bytes: int):
            data = buffer.read(ready_bytes)
            received.append(data)
        channel = l1.get_channel()
        buffer = RNS.Buffer.create_bidirectional_buffer(0, 0, channel, handle_data)
        buffer.write("Hi there".encode("utf-8"))
        buffer.flush()
        time.sleep(0.5)
        self.assertEqual(1 , len(received))
        rx_message = received[0].decode("utf-8")
        self.assertEqual("Hi there back at you", rx_message)
        l1.teardown()
        time.sleep(0.5)
        self.assertEqual(l1.status, RNS.Link.CLOSED)
    def size_str(self, num, suffix='B'):
        units = ['','K','M','G','T','P','E','Z']
@ -504,15 +462,6 @@ def targets(yp=False):
        channel.register_message_type(MessageTest)
        channel.add_message_handler(handle_message)
        buffer = None
        def handle_buffer(ready_bytes: int):
            data = buffer.read(ready_bytes)
            buffer.write((data.decode("utf-8") + " back at you").encode("utf-8"))
            buffer.flush()
        buffer = RNS.Buffer.create_bidirectional_buffer(0, 0, channel, handle_buffer)
    m_rns = RNS.Reticulum("./tests/rnsconfig")
    id1 = RNS.Identity.from_bytes(bytes.fromhex(fixed_keys[0][0]))
    d1 = RNS.Destination(id1, RNS.Destination.IN, RNS.Destination.SINGLE, APP_NAME, "link", "establish")