498 lines
20 KiB
Python
498 lines
20 KiB
Python
#!/usr/bin/env python3
|
|
|
|
# MIT License
|
|
#
|
|
# Copyright (c) 2016-2022 Mark Qvist / unsigned.io
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
# of this software and associated documentation files (the "Software"), to deal
|
|
# in the Software without restriction, including without limitation the rights
|
|
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
# copies of the Software, and to permit persons to whom the Software is
|
|
# furnished to do so, subject to the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be included in all
|
|
# copies or substantial portions of the Software.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
# SOFTWARE.
|
|
|
|
import RNS
|
|
import os
|
|
import sys
|
|
import time
|
|
import argparse
|
|
|
|
from RNS._version import __version__
|
|
|
|
def size_str(num, suffix='B'):
|
|
units = ['','K','M','G','T','P','E','Z']
|
|
last_unit = 'Y'
|
|
|
|
if suffix == 'b':
|
|
num *= 8
|
|
units = ['','K','M','G','T','P','E','Z']
|
|
last_unit = 'Y'
|
|
|
|
for unit in units:
|
|
if abs(num) < 1000.0:
|
|
if unit == "":
|
|
return "%.0f %s%s" % (num, unit, suffix)
|
|
else:
|
|
return "%.2f %s%s" % (num, unit, suffix)
|
|
num /= 1000.0
|
|
|
|
return "%.2f%s%s" % (num, last_unit, suffix)
|
|
|
|
request_result = None
|
|
request_concluded = False
|
|
def get_remote_status(destination_hash, include_lstats, identity, no_output=False, timeout=RNS.Transport.PATH_REQUEST_TIMEOUT):
|
|
global request_result, request_concluded
|
|
link_count = None
|
|
|
|
if not RNS.Transport.has_path(destination_hash):
|
|
if not no_output:
|
|
print("Path to "+RNS.prettyhexrep(destination_hash)+" requested", end=" ")
|
|
sys.stdout.flush()
|
|
RNS.Transport.request_path(destination_hash)
|
|
pr_time = time.time()
|
|
while not RNS.Transport.has_path(destination_hash):
|
|
time.sleep(0.1)
|
|
if time.time() - pr_time > timeout:
|
|
if not no_output:
|
|
print("\r \r", end="")
|
|
print("Path request timed out")
|
|
exit(12)
|
|
|
|
remote_identity = RNS.Identity.recall(destination_hash)
|
|
|
|
def remote_link_closed(link):
|
|
if link.teardown_reason == RNS.Link.TIMEOUT:
|
|
if not no_output:
|
|
print("\r \r", end="")
|
|
print("The link timed out, exiting now")
|
|
elif link.teardown_reason == RNS.Link.DESTINATION_CLOSED:
|
|
if not no_output:
|
|
print("\r \r", end="")
|
|
print("The link was closed by the server, exiting now")
|
|
else:
|
|
if not no_output:
|
|
print("\r \r", end="")
|
|
print("Link closed unexpectedly, exiting now")
|
|
exit(10)
|
|
|
|
def request_failed(request_receipt):
|
|
global request_result, request_concluded
|
|
if not no_output:
|
|
print("\r \r", end="")
|
|
print("The remote status request failed. Likely authentication failure.")
|
|
request_concluded = True
|
|
|
|
def got_response(request_receipt):
|
|
global request_result, request_concluded
|
|
response = request_receipt.response
|
|
if isinstance(response, list):
|
|
status = response[0]
|
|
if len(response) > 1:
|
|
link_count = response[1]
|
|
else:
|
|
link_count = None
|
|
|
|
request_result = (status, link_count)
|
|
|
|
request_concluded = True
|
|
|
|
def remote_link_established(link):
|
|
if not no_output:
|
|
print("\r \r", end="")
|
|
print("Sending request...", end=" ")
|
|
sys.stdout.flush()
|
|
link.identify(identity)
|
|
link.request("/status", data = [include_lstats], response_callback = got_response, failed_callback = request_failed)
|
|
|
|
if not no_output:
|
|
print("\r \r", end="")
|
|
print("Establishing link with remote transport instance...", end=" ")
|
|
sys.stdout.flush()
|
|
|
|
remote_destination = RNS.Destination(remote_identity, RNS.Destination.OUT, RNS.Destination.SINGLE, "rnstransport", "remote", "management")
|
|
link = RNS.Link(remote_destination)
|
|
link.set_link_established_callback(remote_link_established)
|
|
link.set_link_closed_callback(remote_link_closed)
|
|
|
|
while not request_concluded:
|
|
time.sleep(0.1)
|
|
|
|
if request_result != None:
|
|
print("\r \r", end="")
|
|
|
|
return request_result
|
|
|
|
def program_setup(configdir, dispall=False, verbosity=0, name_filter=None, json=False, astats=False,
|
|
lstats=False, sorting=None, sort_reverse=False, remote=None, management_identity=None,
|
|
remote_timeout=RNS.Transport.PATH_REQUEST_TIMEOUT):
|
|
reticulum = RNS.Reticulum(configdir = configdir, loglevel = 3+verbosity)
|
|
|
|
link_count = None
|
|
stats = None
|
|
if remote:
|
|
try:
|
|
dest_len = (RNS.Reticulum.TRUNCATED_HASHLENGTH//8)*2
|
|
if len(remote) != dest_len:
|
|
raise ValueError("Destination length is invalid, must be {hex} hexadecimal characters ({byte} bytes).".format(hex=dest_len, byte=dest_len//2))
|
|
try:
|
|
identity_hash = bytes.fromhex(remote)
|
|
destination_hash = RNS.Destination.hash_from_name_and_identity("rnstransport.remote.management", identity_hash)
|
|
except Exception as e:
|
|
raise ValueError("Invalid destination entered. Check your input.")
|
|
|
|
identity = RNS.Identity.from_file(os.path.expanduser(management_identity))
|
|
if identity == None:
|
|
raise ValueError("Could not load management identity from "+str(management_identity))
|
|
|
|
try:
|
|
remote_status = get_remote_status(destination_hash, lstats, identity, no_output=json, timeout=remote_timeout)
|
|
if remote_status != None:
|
|
stats, link_count = remote_status
|
|
except Exception as e:
|
|
raise e
|
|
|
|
except Exception as e:
|
|
print(str(e))
|
|
exit(20)
|
|
|
|
else:
|
|
if lstats:
|
|
try:
|
|
link_count = reticulum.get_link_count()
|
|
except Exception as e:
|
|
pass
|
|
|
|
try:
|
|
stats = reticulum.get_interface_stats()
|
|
except Exception as e:
|
|
pass
|
|
|
|
if stats != None:
|
|
if json:
|
|
import json
|
|
for s in stats:
|
|
if isinstance(stats[s], bytes):
|
|
stats[s] = RNS.hexrep(stats[s], delimit=False)
|
|
|
|
if isinstance(stats[s], dict) or isinstance(stats[s], list):
|
|
for i in stats[s]:
|
|
if isinstance(i, dict):
|
|
for k in i:
|
|
if isinstance(i[k], bytes):
|
|
i[k] = RNS.hexrep(i[k], delimit=False)
|
|
|
|
print(json.dumps(stats))
|
|
exit()
|
|
|
|
interfaces = stats["interfaces"]
|
|
if sorting != None and isinstance(sorting, str):
|
|
sorting = sorting.lower()
|
|
if sorting == "rate" or sorting == "bitrate":
|
|
interfaces.sort(key=lambda i: i["bitrate"], reverse=not sort_reverse)
|
|
if sorting == "rx":
|
|
interfaces.sort(key=lambda i: i["rxb"], reverse=not sort_reverse)
|
|
if sorting == "tx":
|
|
interfaces.sort(key=lambda i: i["txb"], reverse=not sort_reverse)
|
|
if sorting == "traffic":
|
|
interfaces.sort(key=lambda i: i["rxb"]+i["txb"], reverse=not sort_reverse)
|
|
if sorting == "announces" or sorting == "announce":
|
|
interfaces.sort(key=lambda i: i["incoming_announce_frequency"]+i["outgoing_announce_frequency"], reverse=not sort_reverse)
|
|
if sorting == "arx":
|
|
interfaces.sort(key=lambda i: i["incoming_announce_frequency"], reverse=not sort_reverse)
|
|
if sorting == "atx":
|
|
interfaces.sort(key=lambda i: i["outgoing_announce_frequency"], reverse=not sort_reverse)
|
|
if sorting == "held":
|
|
interfaces.sort(key=lambda i: i["held_announces"], reverse=not sort_reverse)
|
|
|
|
|
|
for ifstat in interfaces:
|
|
name = ifstat["name"]
|
|
|
|
if dispall or not (
|
|
name.startswith("LocalInterface[") or
|
|
name.startswith("TCPInterface[Client") or
|
|
name.startswith("I2PInterfacePeer[Connected peer") or
|
|
(name.startswith("I2PInterface[") and ("i2p_connectable" in ifstat and ifstat["i2p_connectable"] == False))
|
|
):
|
|
|
|
if not (name.startswith("I2PInterface[") and ("i2p_connectable" in ifstat and ifstat["i2p_connectable"] == False)):
|
|
if name_filter == None or name_filter.lower() in name.lower():
|
|
print("")
|
|
|
|
if ifstat["status"]:
|
|
ss = "Up"
|
|
else:
|
|
ss = "Down"
|
|
|
|
if ifstat["mode"] == RNS.Interfaces.Interface.Interface.MODE_ACCESS_POINT:
|
|
modestr = "Access Point"
|
|
elif ifstat["mode"] == RNS.Interfaces.Interface.Interface.MODE_POINT_TO_POINT:
|
|
modestr = "Point-to-Point"
|
|
elif ifstat["mode"] == RNS.Interfaces.Interface.Interface.MODE_ROAMING:
|
|
modestr = "Roaming"
|
|
elif ifstat["mode"] == RNS.Interfaces.Interface.Interface.MODE_BOUNDARY:
|
|
modestr = "Boundary"
|
|
elif ifstat["mode"] == RNS.Interfaces.Interface.Interface.MODE_GATEWAY:
|
|
modestr = "Gateway"
|
|
else:
|
|
modestr = "Full"
|
|
|
|
|
|
if ifstat["clients"] != None:
|
|
clients = ifstat["clients"]
|
|
if name.startswith("Shared Instance["):
|
|
cnum = max(clients-1,0)
|
|
if cnum == 1:
|
|
spec_str = " program"
|
|
else:
|
|
spec_str = " programs"
|
|
|
|
clients_string = "Serving : "+str(cnum)+spec_str
|
|
elif name.startswith("I2PInterface["):
|
|
if "i2p_connectable" in ifstat and ifstat["i2p_connectable"] == True:
|
|
cnum = clients
|
|
if cnum == 1:
|
|
spec_str = " connected I2P endpoint"
|
|
else:
|
|
spec_str = " connected I2P endpoints"
|
|
|
|
clients_string = "Peers : "+str(cnum)+spec_str
|
|
else:
|
|
clients_string = ""
|
|
else:
|
|
clients_string = "Clients : "+str(clients)
|
|
|
|
else:
|
|
clients = None
|
|
|
|
print(" {n}".format(n=ifstat["name"]))
|
|
|
|
if "ifac_netname" in ifstat and ifstat["ifac_netname"] != None:
|
|
print(" Network : {nn}".format(nn=ifstat["ifac_netname"]))
|
|
|
|
print(" Status : {ss}".format(ss=ss))
|
|
|
|
if clients != None and clients_string != "":
|
|
print(" "+clients_string)
|
|
|
|
if not (name.startswith("Shared Instance[") or name.startswith("TCPInterface[Client") or name.startswith("LocalInterface[")):
|
|
print(" Mode : {mode}".format(mode=modestr))
|
|
|
|
if "bitrate" in ifstat and ifstat["bitrate"] != None:
|
|
print(" Rate : {ss}".format(ss=speed_str(ifstat["bitrate"])))
|
|
|
|
if "battery_percent" in ifstat and ifstat["battery_percent"] != None:
|
|
try:
|
|
bpi = int(ifstat["battery_percent"])
|
|
print(" Battery : {bp}%".format(bp=bpi))
|
|
except:
|
|
pass
|
|
|
|
if "airtime_short" in ifstat and "airtime_long" in ifstat:
|
|
print(" Airtime : {ats}% (15s), {atl}% (1h)".format(ats=str(ifstat["airtime_short"]),atl=str(ifstat["airtime_long"])))
|
|
|
|
if "channel_load_short" in ifstat and "channel_load_long" in ifstat:
|
|
print(" Ch.Load : {ats}% (15s), {atl}% (1h)".format(ats=str(ifstat["channel_load_short"]),atl=str(ifstat["channel_load_long"])))
|
|
|
|
if "peers" in ifstat and ifstat["peers"] != None:
|
|
print(" Peers : {np} reachable".format(np=ifstat["peers"]))
|
|
|
|
if "tunnelstate" in ifstat and ifstat["tunnelstate"] != None:
|
|
print(" I2P : {ts}".format(ts=ifstat["tunnelstate"]))
|
|
|
|
if "ifac_signature" in ifstat and ifstat["ifac_signature"] != None:
|
|
sigstr = "<…"+RNS.hexrep(ifstat["ifac_signature"][-5:], delimit=False)+">"
|
|
print(" Access : {nb}-bit IFAC by {sig}".format(nb=ifstat["ifac_size"]*8, sig=sigstr))
|
|
|
|
if "i2p_b32" in ifstat and ifstat["i2p_b32"] != None:
|
|
print(" I2P B32 : {ep}".format(ep=str(ifstat["i2p_b32"])))
|
|
|
|
if astats and "announce_queue" in ifstat and ifstat["announce_queue"] != None and ifstat["announce_queue"] > 0:
|
|
aqn = ifstat["announce_queue"]
|
|
if aqn == 1:
|
|
print(" Queued : {np} announce".format(np=aqn))
|
|
else:
|
|
print(" Queued : {np} announces".format(np=aqn))
|
|
|
|
if astats and "held_announces" in ifstat and ifstat["held_announces"] != None and ifstat["held_announces"] > 0:
|
|
aqn = ifstat["held_announces"]
|
|
if aqn == 1:
|
|
print(" Held : {np} announce".format(np=aqn))
|
|
else:
|
|
print(" Held : {np} announces".format(np=aqn))
|
|
|
|
if astats and "incoming_announce_frequency" in ifstat and ifstat["incoming_announce_frequency"] != None:
|
|
print(" Announces : {iaf}↑".format(iaf=RNS.prettyfrequency(ifstat["outgoing_announce_frequency"])))
|
|
print(" {iaf}↓".format(iaf=RNS.prettyfrequency(ifstat["incoming_announce_frequency"])))
|
|
|
|
print(" Traffic : {txb}↑\n {rxb}↓".format(rxb=size_str(ifstat["rxb"]), txb=size_str(ifstat["txb"])))
|
|
|
|
lstr = ""
|
|
if link_count != None and lstats:
|
|
ms = "y" if link_count == 1 else "ies"
|
|
if "transport_id" in stats and stats["transport_id"] != None:
|
|
lstr = f", {link_count} entr{ms} in link table"
|
|
else:
|
|
lstr = f" {link_count} entr{ms} in link table"
|
|
|
|
if "transport_id" in stats and stats["transport_id"] != None:
|
|
print("\n Transport Instance "+RNS.prettyhexrep(stats["transport_id"])+" running")
|
|
if "probe_responder" in stats and stats["probe_responder"] != None:
|
|
print(" Probe responder at "+RNS.prettyhexrep(stats["probe_responder"])+ " active")
|
|
if "transport_uptime" in stats and stats["transport_uptime"] != None:
|
|
print(" Uptime is "+RNS.prettytime(stats["transport_uptime"])+lstr)
|
|
else:
|
|
if lstr != "":
|
|
print(f"\n{lstr}")
|
|
|
|
print("")
|
|
|
|
else:
|
|
if not remote:
|
|
print("Could not get RNS status")
|
|
else:
|
|
print("Could not get RNS status from remote transport instance "+RNS.prettyhexrep(identity_hash))
|
|
exit(1)
|
|
|
|
def main():
|
|
try:
|
|
parser = argparse.ArgumentParser(description="Reticulum Network Stack Status")
|
|
parser.add_argument("--config", action="store", default=None, help="path to alternative Reticulum config directory", type=str)
|
|
parser.add_argument("--version", action="version", version="rnstatus {version}".format(version=__version__))
|
|
|
|
parser.add_argument(
|
|
"-a",
|
|
"--all",
|
|
action="store_true",
|
|
help="show all interfaces",
|
|
default=False
|
|
)
|
|
|
|
parser.add_argument(
|
|
"-A",
|
|
"--announce-stats",
|
|
action="store_true",
|
|
help="show announce stats",
|
|
default=False
|
|
)
|
|
|
|
parser.add_argument(
|
|
"-l",
|
|
"--link-stats",
|
|
action="store_true",
|
|
help="show link stats",
|
|
default=False,
|
|
)
|
|
|
|
parser.add_argument(
|
|
"-s",
|
|
"--sort",
|
|
action="store",
|
|
help="sort interfaces by [rate, traffic, rx, tx, announces, arx, atx, held]",
|
|
default=None,
|
|
type=str
|
|
)
|
|
|
|
parser.add_argument(
|
|
"-r",
|
|
"--reverse",
|
|
action="store_true",
|
|
help="reverse sorting",
|
|
default=False,
|
|
)
|
|
|
|
parser.add_argument(
|
|
"-j",
|
|
"--json",
|
|
action="store_true",
|
|
help="output in JSON format",
|
|
default=False
|
|
)
|
|
|
|
parser.add_argument(
|
|
"-R",
|
|
action="store",
|
|
metavar="hash",
|
|
help="transport identity hash of remote instance to get status from",
|
|
default=None,
|
|
type=str
|
|
)
|
|
|
|
parser.add_argument(
|
|
"-i",
|
|
action="store",
|
|
metavar="path",
|
|
help="path to identity used for remote management",
|
|
default=None,
|
|
type=str
|
|
)
|
|
|
|
parser.add_argument(
|
|
"-w",
|
|
action="store",
|
|
metavar="seconds",
|
|
type=float,
|
|
help="timeout before giving up on remote queries",
|
|
default=RNS.Transport.PATH_REQUEST_TIMEOUT
|
|
)
|
|
|
|
parser.add_argument('-v', '--verbose', action='count', default=0)
|
|
|
|
parser.add_argument("filter", nargs="?", default=None, help="only display interfaces with names including filter", type=str)
|
|
|
|
args = parser.parse_args()
|
|
|
|
if args.config:
|
|
configarg = args.config
|
|
else:
|
|
configarg = None
|
|
|
|
program_setup(
|
|
configdir = configarg,
|
|
dispall = args.all,
|
|
verbosity=args.verbose,
|
|
name_filter=args.filter,
|
|
json=args.json,
|
|
astats=args.announce_stats,
|
|
lstats=args.link_stats,
|
|
sorting=args.sort,
|
|
sort_reverse=args.reverse,
|
|
remote=args.R,
|
|
management_identity=args.i,
|
|
remote_timeout=args.w,
|
|
)
|
|
|
|
except KeyboardInterrupt:
|
|
print("")
|
|
exit()
|
|
|
|
def speed_str(num, suffix='bps'):
|
|
units = ['','k','M','G','T','P','E','Z']
|
|
last_unit = 'Y'
|
|
|
|
if suffix == 'Bps':
|
|
num /= 8
|
|
units = ['','K','M','G','T','P','E','Z']
|
|
last_unit = 'Y'
|
|
|
|
for unit in units:
|
|
if abs(num) < 1000.0:
|
|
return "%3.2f %s%s" % (num, unit, suffix)
|
|
num /= 1000.0
|
|
|
|
return "%.2f %s%s" % (num, last_unit, suffix)
|
|
|
|
if __name__ == "__main__":
|
|
main()
|