Updated version

Add Windows log static tail

README.md

@@ -8,7 +8,7 @@ Nomad Network allows you to build private and resilient communications platforms
 
 Nomad Network is build on [LXMF](https://github.com/markqvist/LXMF) and [Reticulum](https://github.com/markqvist/Reticulum), which together provides the cryptographic mesh functionality and peer-to-peer message routing that Nomad Network relies on. This foundation also makes it possible to use the program over a very wide variety of communication mediums, from packet radio to fiber optics.
 
-Nomad Network does not need any connections to the public internet to work. In fact, it doesn't even need an IP or Ethernet network. You can use it entirely over packet radio, LoRa or even serial lines. But if you wish, you can bridge islanded networks over the Internet or private ethernet networks, or you can build networks running completely over the Internet. The choice is yours.
+Nomad Network does not need any connections to the public internet to work. In fact, it doesn't even need an IP or Ethernet network. You can use it entirely over packet radio, LoRa or even serial lines. But if you wish, you can bridge islanded networks over the Internet or private ethernet networks, or you can build networks running completely over the Internet. The choice is yours. Since Nomad Network uses Reticulum, it is efficient enough to run even over *extremely* low-bandwidth medium, and has been succesfully used over 300bps radio links.
 
 If you'd rather want to use an LXMF client with a graphical user interface, you may want to take a look at [Sideband](https://github.com/markqvist/sideband), which is available for Linux, Android and macOS.
 
@@ -161,7 +161,6 @@ You can help support the continued development of open, free and private communi
 - New major features
     - Network-wide propagated bulletins and discussion threads
     - Collaborative maps and geospatial information sharing
-    - Facilitation of trade and barter
 - Minor improvements and fixes
     - Link status (RSSI and SNR) in conversation or conv list
     - Ctrl-M shorcut for jumping to menu

nomadnet/Conversation.py

@@ -27,6 +27,13 @@ class Conversation:
                     if Conversation.created_callback != None:
                         Conversation.created_callback()
 
+            # This reformats the new v0.5.0 announce data back to the expected format
+            # for nomadnets storage and other handling functions.
+            dn = LXMF.display_name_from_app_data(app_data)
+            app_data = b""
+            if dn != None:
+                app_data = dn.encode("utf-8")
+            
             # Add the announce to the directory announce
             # stream logger
             app.directory.lxmf_announce_received(destination_hash, app_data)
@@ -95,7 +102,7 @@ class Conversation:
                         unread = True
 
                     if display_name == None and app_data:
-                        display_name = app_data.decode("utf-8")
+                        display_name = LXMF.display_name_from_app_data(app_data)
 
                     if display_name == None:
                         sort_name = ""
@@ -209,8 +216,16 @@ class Conversation:
             if self.app.directory.preferred_delivery(dest.hash) == DirectoryEntry.PROPAGATED:
                 if self.app.message_router.get_outbound_propagation_node() != None:
                     desired_method = LXMF.LXMessage.PROPAGATED
+            else:
+                if not self.app.message_router.delivery_link_available(dest.hash) and RNS.Identity.current_ratchet_id(dest.hash) != None:
+                    RNS.log(f"Have ratchet for {RNS.prettyhexrep(dest.hash)}, requesting opportunistic delivery of message", RNS.LOG_DEBUG)
+                    desired_method = LXMF.LXMessage.OPPORTUNISTIC
 
-            lxm = LXMF.LXMessage(dest, source, content, title=title, desired_method=desired_method)
+            dest_is_trusted = False
+            if self.app.directory.trust_level(dest.hash) == DirectoryEntry.TRUSTED:
+                dest_is_trusted = True
+
+            lxm = LXMF.LXMessage(dest, source, content, title=title, desired_method=desired_method, include_ticket=dest_is_trusted)
             lxm.register_delivery_callback(self.message_notification)
             lxm.register_failed_callback(self.message_notification)
 
@@ -281,13 +296,17 @@ class Conversation:
 
     def message_notification(self, message):
         if message.state == LXMF.LXMessage.FAILED and hasattr(message, "try_propagation_on_fail") and message.try_propagation_on_fail:
-            RNS.log("Direct delivery of "+str(message)+" failed. Retrying as propagated message.", RNS.LOG_VERBOSE)
-            message.try_propagation_on_fail = None
-            message.delivery_attempts = 0
-            del message.next_delivery_attempt
-            message.packed = None
-            message.desired_method = LXMF.LXMessage.PROPAGATED
-            self.app.message_router.handle_outbound(message)
+            if hasattr(message, "stamp_generation_failed") and message.stamp_generation_failed == True:
+                RNS.log(f"Could not send {message} due to a stamp generation failure", RNS.LOG_ERROR)
+            else:
+                RNS.log("Direct delivery of "+str(message)+" failed. Retrying as propagated message.", RNS.LOG_VERBOSE)
+                message.try_propagation_on_fail = None
+                message.delivery_attempts = 0
+                if hasattr(message, "next_delivery_attempt"):
+                    del message.next_delivery_attempt
+                message.packed = None
+                message.desired_method = LXMF.LXMessage.PROPAGATED
+                self.app.message_router.handle_outbound(message)
         else:
             message_path = Conversation.ingest(message, self.app, originator=True)
 
@@ -318,12 +337,17 @@ class ConversationMessage:
             self.timestamp = self.lxm.timestamp
             self.sort_timestamp = os.path.getmtime(self.file_path)
 
-            if self.lxm.state > LXMF.LXMessage.DRAFT and self.lxm.state < LXMF.LXMessage.SENT:
+            if self.lxm.state > LXMF.LXMessage.GENERATING and self.lxm.state < LXMF.LXMessage.SENT:
                 found = False
+
                 for pending in nomadnet.NomadNetworkApp.get_shared_instance().message_router.pending_outbound:
                     if pending.hash == self.lxm.hash:
                         found = True
 
+                for pending_id in nomadnet.NomadNetworkApp.get_shared_instance().message_router.pending_deferred_stamps:
+                    if pending_id == self.lxm.hash:
+                        found = True
+
                 if not found:
                     self.lxm.state = LXMF.LXMessage.FAILED
 

nomadnet/Directory.py

@@ -257,11 +257,12 @@ class Directory:
             if announced_display_name == None:
                 return self.directory_entries[source_hash].trust_level
             else:
-                for entry in self.directory_entries:
-                    e = self.directory_entries[entry]
-                    if e.display_name == announced_display_name:
-                        if e.source_hash != source_hash:
-                            return DirectoryEntry.WARNING
+                if not self.directory_entries[source_hash].trust_level == DirectoryEntry.TRUSTED:
+                    for entry in self.directory_entries:
+                        e = self.directory_entries[entry]
+                        if e.display_name == announced_display_name:
+                            if e.source_hash != source_hash:
+                                return DirectoryEntry.WARNING
 
                 return self.directory_entries[source_hash].trust_level
         else:

nomadnet/NomadNetworkApp.py

@@ -135,6 +135,10 @@ class NomadNetworkApp:
         self.lxmf_sync_limit    = 8
         self.compact_stream     = False
         
+        self.required_stamp_cost   = None
+        self.accept_invalid_stamps = False
+
+
         if not os.path.isdir(self.storagepath):
             os.makedirs(self.storagepath)
 
@@ -296,8 +300,9 @@ class NomadNetworkApp:
         for destination_hash in self.ignored_list:
             self.message_router.ignore_destination(destination_hash)
 
-        self.lxmf_destination = self.message_router.register_delivery_identity(self.identity, display_name=self.peer_settings["display_name"])
-        self.lxmf_destination.set_default_app_data(self.get_display_name_bytes)
+        self.lxmf_destination = self.message_router.register_delivery_identity(self.identity, display_name=self.peer_settings["display_name"], stamp_cost=self.required_stamp_cost)
+        if not self.accept_invalid_stamps:
+            self.message_router.enforce_stamps()
 
         RNS.Identity.remember(
             packet_hash=None,
@@ -492,7 +497,9 @@ class NomadNetworkApp:
             self.message_router.cancel_propagation_node_requests()
 
     def announce_now(self):
-        self.lxmf_destination.announce()
+        self.message_router.set_inbound_stamp_cost(self.lxmf_destination.hash, self.required_stamp_cost)
+        self.lxmf_destination.display_name = self.peer_settings["display_name"]
+        self.message_router.announce(self.lxmf_destination.hash)
         self.peer_settings["last_announce"] = time.time()
         self.save_peer_settings()
 
@@ -738,6 +745,24 @@ class NomadNetworkApp:
                     else:
                         self.lxmf_sync_limit = None
 
+                if option == "required_stamp_cost":
+                    value = self.config["client"][option]
+                    if value.lower() == "none":
+                        self.required_stamp_cost = None
+                    else:
+                        value = self.config["client"].as_int(option)
+
+                        if value > 0:
+                            if value > 255:
+                                value = 255
+                            self.required_stamp_cost = value
+                        else:
+                            self.required_stamp_cost = None
+
+                if option == "accept_invalid_stamps":
+                    value = self.config["client"].as_bool(option)
+                    self.accept_invalid_stamps = value
+
                 if option == "max_accepted_size":
                     value = self.config["client"].as_float(option)    
 
@@ -1017,6 +1042,24 @@ lxmf_sync_interval = 360
 # the limit, and download everything every time.
 lxmf_sync_limit = 8
 
+# You can specify a required stamp cost for
+# inbound messages to be accepted. Specifying
+# a stamp cost will require untrusted senders
+# that message you to include a cryptographic
+# stamp in their messages. Performing this
+# operation takes the sender an amount of time
+# proportional to the stamp cost. As a rough
+# estimate, a stamp cost of 8 will take less
+# than a second to compute, and a stamp cost
+# of 20 could take several minutes, even on
+# a fast computer.
+required_stamp_cost = None
+
+# You can signal stamp requirements to senders,
+# but still accept messages with invalid stamps
+# by setting this option to True.
+accept_invalid_stamps = False
+
 # The maximum accepted unpacked size for mes-
 # sages received directly from other peers,
 # specified in kilobytes. Messages larger than

nomadnet/_version.py

@@ -1 +1 @@
-__version__ = "0.4.7"
+__version__ = "0.5.4"

nomadnet/ui/TextUI.py

@@ -97,10 +97,10 @@ GLYPHSETS = {
 }
 
 if platform.system() == "Darwin":
-    urm_char = " \uf0e0 "
+    urm_char = " \uf0e0"
     ur_char = "\uf0e0 "
 else:
-    urm_char = " \uf003 "
+    urm_char = " \uf003"
     ur_char = "\uf003 "
 
 GLYPHS = {
@@ -115,17 +115,17 @@ GLYPHS = {
     ("arrow_u",         "/\\",       "\u2191",      "\u2191"),
     ("arrow_d",         "\\/",       "\u2193",      "\u2193"),
     ("warning",         "!",         "\u26a0",      "\uf12a"),
-    ("info",            "i",         "\u2139",      "\ufb4d"),
+    ("info",            "i",         "\u2139",      "\U000f064e"),
     ("unread",          "[!]",       "\u2709",      ur_char),
     ("divider1",        "-",         "\u2504",      "\u2504"),
     ("peer",            "[P]",       "\u24c5 ",     "\uf415"),
-    ("node",            "[N]",       "\u24c3 ",     "\uf502"),
+    ("node",            "[N]",       "\u24c3 ",     "\U000f0002"),
     ("page",            "",          "\u25a4 ",     "\uf719 "),
-    ("speed",           "",          "\u25F7 ",     "\uf9c4"),
-    ("decoration_menu", " +",        " +",          " \uf93a"),
+    ("speed",           "",          "\u25F7 ",     "\U000f04c5 "),
+    ("decoration_menu", " +",        " +",          " \U000f043b"),
     ("unread_menu",     " !",        " \u2709",     urm_char),
     ("globe",           "",          "",            "\uf484"),
-    ("sent",            "/\\",       "\u2191",      "\ufbf4"),
+    ("sent",            "/\\",       "\u2191",      "\U000f0cd8"),
     ("papermsg",        "P",         "\u25a4",      "\uf719"),
     ("qrcode",          "QR",        "\u25a4",      "\uf029"),
 }

nomadnet/ui/textui/Conversations.py

@@ -1056,7 +1056,7 @@ class ConversationWidget(urwid.WidgetWrap):
             else:
                 warning = urwid.AttrMap(
                     urwid.Padding(urwid.Text(
-                        "\n"+g["info"]+"\n\nYou cannot currently message this peer, since it's identity keys are not known. "
+                        "\n"+g["info"]+"\n\nYou cannot currently message this peer, since its identity keys are not known. "
                                        "The keys have been requested from the network and should arrive shortly, if available. "
                                        "Close this conversation and reopen it to try again.\n\n"
                                        "To query the network manually, select this conversation in the conversation list, "

nomadnet/ui/textui/Guide.py

@@ -485,6 +485,12 @@ Selects which interface to use. Currently, only the `!text`! interface is availa
 Sets the filesystem path to store downloaded files in.
 <
 
+>>>
+`!notify_on_new_message = yes`!
+>>>>
+Sets whether to output a notification character (bell or flash) to the terminal when a new message is received.
+<
+
 >>>
 `!announce_at_start = yes`!
 >>>>
@@ -515,6 +521,18 @@ The number of minutes between each automatic sync. The default is equal to 6 hou
 On low-bandwidth networks, it can be useful to limit the amount of messages downloaded in each sync. The default is 8. Set to 0 to download all available messages every time a sync occurs.
 <
 
+>>>
+`!required_stamp_cost = None`!
+>>>>
+You can specify a required stamp cost for inbound messages to be accepted. Specifying a stamp cost will require untrusted senders that message you to include a cryptographic stamp in their messages. Performing this operation takes the sender an amount of time proportional to the stamp cost. As a rough estimate, a stamp cost of 8 will take less than a second to compute, and a stamp cost of 20 could take several minutes, even on a fast computer.
+<
+
+>>>
+`!accept_invalid_stamps = False`!
+>>>>
+You can signal stamp requirements to senders, but still accept messages with invalid stamps by setting this option to True.
+<
+
 >>>
 `!max_accepted_size = 500`!
 >>>>
@@ -733,12 +751,11 @@ If you have Internet access, and just want to get started experimenting, you are
 The Testnet also runs the latest version of Reticulum, often even a short while before it is publicly released, which means strange behaviour might occur. If none of that scares you, add the following interface to your Reticulum configuration file to join:
 
 >>
-[[RNS Testnet Zurich]]
+[[RNS Testnet Dublin]]
   type = TCPClientInterface
-  interface_enabled = yes
-  outgoing = True
-  target_host = zurich.connect.reticulum.network
-  target_port = 4242
+  enabled = yes
+  target_host = dublin.connect.reticulum.network
+  target_port = 4965
 <
 
 If you connect to the testnet, you can leave nomadnet running for a while and wait for it to receive announces from other nodes on the network that host pages or services, or you can try connecting directly to some nodes listed here:
@@ -783,7 +800,7 @@ The following line should contain a grayscale gradient bar:
 
 Unicode Glyphs   : \u2713  \u2715  \u26a0  \u24c3  \u2193
 
-Nerd Font Glyphs : \uf484  \uf9c4 \uf719  \uf502  \uf415  \uf023  \uf06e
+Nerd Font Glyphs : \uf484  \U000f04c5  \U000f0219  \U000f0002  \uf415  \uf023  \uf06e
 '''
 
 
@@ -1064,7 +1081,7 @@ Links can contain request variables and a list of fields to submit to the node-s
 `=
 ``
 
-Note the `!*`! following the extra `!\``! at the end of the path. This `!*`! denotes `*all fields`*. You can also specify a list of fields to include:
+Note the `!*`! following the extra `!\\``! at the end of the path. This `!*`! denotes `*all fields`*. You can also specify a list of fields to include:
 
 `Faaa
 `=

nomadnet/ui/textui/Log.py

@@ -1,6 +1,11 @@
+import os
+import sys
+import itertools
+import mmap
 import urwid
 import nomadnet
 
+
 class LogDisplayShortcuts():
     def __init__(self, app):
         import urwid
@@ -8,28 +13,31 @@ class LogDisplayShortcuts():
 
         self.widget = urwid.AttrMap(urwid.Text(""), "shortcutbar")
 
+
 class LogDisplay():
     def __init__(self, app):
         self.app = app
-        self.log_term = None
 
         self.shortcuts_display = LogDisplayShortcuts(self.app)
         self.widget = None
 
+    @property
+    def log_term(self):
+        return self.widget
+
     def show(self):
-        if self.log_term == None:
-            self.log_term = LogTerminal(self.app)
-            self.widget = urwid.LineBox(self.log_term)
+        if self.widget is None:
+            self.widget = log_widget(self.app)
 
     def kill(self):
-        if self.log_term != None:
-            self.log_term.terminate()
-            self.log_term = None
+        if self.widget is not None:
+            self.widget.terminate()
             self.widget = None
         
     def shortcuts(self):
         return self.shortcuts_display
 
+
 class LogTerminal(urwid.WidgetWrap):
     def __init__(self, app):
         self.app = app
@@ -39,7 +47,8 @@ class LogTerminal(urwid.WidgetWrap):
             escape_sequence="up",
             main_loop=self.app.ui.loop,
         )
-        super().__init__(self.log_term)
+        self.widget = urwid.LineBox(self.log_term)
+        super().__init__(self.widget)
 
     def terminate(self):
         self.log_term.terminate()
@@ -50,3 +59,69 @@ class LogTerminal(urwid.WidgetWrap):
             nomadnet.NomadNetworkApp.get_shared_instance().ui.main_display.frame.focus_position = "header"
             
         return super(LogTerminal, self).keypress(size, key)
+
+
+class LogTail(urwid.WidgetWrap):
+    def __init__(self, app):
+        self.app = app
+        self.log_tail = urwid.Text(tail(self.app.logfilepath, 50))
+        self.log = urwid.Scrollable(self.log_tail)
+        self.log.set_scrollpos(-1)
+        self.log_scrollbar = urwid.ScrollBar(self.log)
+        # We have this here because ui.textui.Main depends on this field to kill it
+        self.log_term = None
+
+        super().__init__(self.log_scrollbar)
+
+    def terminate(self):
+        pass
+
+
+def log_widget(app, platform=sys.platform):
+    if platform == "win32":
+        return LogTail(app)
+    else:
+        return LogTerminal(app)
+
+# https://stackoverflow.com/a/34029605/3713120
+def _tail(f_name, n, offset=0):
+    def skip_back_lines(mm: mmap.mmap, numlines: int, startidx: int) -> int:
+        '''Factored out to simplify handling of n and offset'''
+        for _ in itertools.repeat(None, numlines):
+            startidx = mm.rfind(b'\n', 0, startidx)
+            if startidx < 0:
+                break
+        return startidx
+
+    # Open file in binary mode
+    with open(f_name, 'rb') as binf, mmap.mmap(binf.fileno(), 0, access=mmap.ACCESS_READ) as mm:
+        # len(mm) - 1 handles files ending w/newline by getting the prior line
+        startofline = skip_back_lines(mm, offset, len(mm) - 1)
+        if startofline < 0:
+            return []  # Offset lines consumed whole file, nothing to return
+            # If using a generator function (yield-ing, see below),
+            # this should be a plain return, no empty list
+
+        endoflines = startofline + 1  # Slice end to omit offset lines
+
+        # Find start of lines to capture (add 1 to move from newline to beginning of following line)
+        startofline = skip_back_lines(mm, n, startofline) + 1
+
+        # Passing True to splitlines makes it return the list of lines without
+        # removing the trailing newline (if any), so list mimics f.readlines()
+        # return mm[startofline:endoflines].splitlines(True)
+        # If Windows style \r\n newlines need to be normalized to \n
+        return mm[startofline:endoflines].replace(os.linesep.encode(sys.getdefaultencoding()), b'\n').splitlines(True)
+
+
+def tail(f_name, n):
+    """
+    Return the last n lines of a given file name, f_name.
+    Akin to `tail -<n> <f_name>`
+    """
+    def decode(b):
+        return b.decode(encoding)
+
+    encoding = sys.getdefaultencoding()
+    lines = map(decode, _tail(f_name=f_name, n=n))
+    return ''.join(lines)

requirements.txt

@@ -1,6 +0,0 @@
-compiler==0.2.0
-configobj==5.0.8
-lxmf==0.3.2
-rns==0.5.7
-setuptools==68.0.0
-urwid==2.1.2

setup.py

@@ -30,6 +30,6 @@ setuptools.setup(
     entry_points= {
         'console_scripts': ['nomadnet=nomadnet.nomadnet:main']
     },
-    install_requires=["rns>=0.7.2", "lxmf>=0.4.0", "urwid>=2.4.2,!=2.4.3", "qrcode"],
+    install_requires=["rns>=0.8.2", "lxmf>=0.5.5", "urwid>=2.4.4", "qrcode"],
     python_requires=">=3.6",
 )