ns2 0.2.6__py3-none-any.whl

ns2/lib/udp_client.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+"""
+UDP Hole Punching - Peer Client
+This client registers with the rendezvous server and establishes P2P connections.
+"""
+
+import socket
+import threading
+import json
+import time
+import sys
+
+class PeerClient:
+    def __init__(self, peer_id, server_host, server_port=5000):
+        self.peer_id = peer_id
+        self.server_addr = (server_host, server_port)
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.sock.bind(('0.0.0.0', 0))  # Bind to any available port
+        self.local_port = self.sock.getsockname()[1]
+        
+        self.connected_peers = {}  # {peer_id: (ip, port)}
+        self.running = True
+        
+        print(f"Peer '{peer_id}' started on local port {self.local_port}")
+    
+    def register(self):
+        """Register with the rendezvous server"""
+        msg = {
+            'cmd': 'register',
+            'peer_id': self.peer_id
+        }
+        self.sock.sendto(json.dumps(msg).encode(), self.server_addr)
+        print(f"Registered with server at {self.server_addr}")
+    
+    def send_heartbeat(self):
+        """Send periodic heartbeats to the server"""
+        while self.running:
+            try:
+                msg = {
+                    'cmd': 'heartbeat',
+                    'peer_id': self.peer_id
+                }
+                self.sock.sendto(json.dumps(msg).encode(), self.server_addr)
+                time.sleep(10)
+            except:
+                break
+    
+    def list_peers(self):
+        """Request list of available peers from server"""
+        msg = {'cmd': 'list'}
+        self.sock.sendto(json.dumps(msg).encode(), self.server_addr)
+    
+    def connect_to_peer(self, target_id):
+        """Initiate connection to another peer"""
+        msg = {
+            'cmd': 'connect',
+            'peer_id': self.peer_id,
+            'target_id': target_id
+        }
+        self.sock.sendto(json.dumps(msg).encode(), self.server_addr)
+        print(f"Requesting connection to peer '{target_id}'...")
+    
+    def punch_hole(self, peer_addr):
+        """Send initial packets to punch through NAT"""
+        punch_msg = json.dumps({
+            'type': 'punch',
+            'peer_id': self.peer_id
+        }).encode()
+        
+        # Send multiple packets to ensure hole punching
+        for i in range(5):
+            self.sock.sendto(punch_msg, peer_addr)
+            time.sleep(0.1)
+    
+    def send_message(self, peer_id, message):
+        """Send a message to a connected peer"""
+        if peer_id not in self.connected_peers:
+            print(f"Not connected to peer '{peer_id}'")
+            return
+        
+        peer_addr = self.connected_peers[peer_id]
+        msg = {
+            'type': 'message',
+            'from': self.peer_id,
+            'text': message
+        }
+        self.sock.sendto(json.dumps(msg).encode(), peer_addr)
+    
+    def handle_incoming(self):
+        """Handle incoming messages"""
+        while self.running:
+            try:
+                data, addr = self.sock.recvfrom(4096)
+                msg = json.loads(data.decode())
+                
+                # Response from server
+                if addr == self.server_addr:
+                    if msg.get('status') == 'registered':
+                        endpoint = msg.get('your_endpoint')
+                        print(f"Server sees us at {endpoint['ip']}:{endpoint['port']}")
+                    
+                    elif 'peers' in msg:
+                        peers = msg['peers']
+                        print("\nAvailable peers:")
+                        for pid, info in peers.items():
+                            if pid != self.peer_id:
+                                print(f"  - {pid} ({info['ip']}:{info['port']})")
+                    
+                    elif msg.get('status') == 'found':
+                        peer_endpoint = msg['peer_endpoint']
+                        peer_addr = (peer_endpoint['ip'], peer_endpoint['port'])
+                        print(f"Punching hole to {peer_addr}...")
+                        self.punch_hole(peer_addr)
+                    
+                    elif msg.get('cmd') == 'incoming_connection':
+                        peer_id = msg['peer_id']
+                        peer_endpoint = msg['peer_endpoint']
+                        peer_addr = (peer_endpoint['ip'], peer_endpoint['port'])
+                        print(f"\nIncoming connection from '{peer_id}' at {peer_addr}")
+                        print("Punching hole back...")
+                        self.punch_hole(peer_addr)
+                
+                # Direct peer-to-peer messages
+                else:
+                    msg_type = msg.get('type')
+                    
+                    if msg_type == 'punch':
+                        peer_id = msg.get('peer_id')
+                        print(f"Received punch from '{peer_id}' at {addr}")
+                        self.connected_peers[peer_id] = addr
+                        
+                        # Send acknowledgment
+                        ack = json.dumps({
+                            'type': 'ack',
+                            'peer_id': self.peer_id
+                        }).encode()
+                        self.sock.sendto(ack, addr)
+                        print(f"✓ Connected to '{peer_id}'!")
+                    
+                    elif msg_type == 'ack':
+                        peer_id = msg.get('peer_id')
+                        self.connected_peers[peer_id] = addr
+                        print(f"✓ Connection established with '{peer_id}'!")
+                    
+                    elif msg_type == 'message':
+                        sender = msg.get('from')
+                        text = msg.get('text')
+                        print(f"\n[{sender}]: {text}")
+                        
+            except Exception as e:
+                if self.running:
+                    print(f"Error: {e}")
+    
+    def interactive_shell(self):
+        """Interactive command shell"""
+        print("\nCommands:")
+        print("  list              - List available peers")
+        print("  connect <peer_id> - Connect to a peer")
+        print("  send <peer_id> <message> - Send message to peer")
+        print("  quit              - Exit")
+        print()
+        
+        while self.running:
+            try:
+                cmd = input("> ").strip()
+                
+                if not cmd:
+                    continue
+                
+                parts = cmd.split(maxsplit=2)
+                
+                if parts[0] == 'list':
+                    self.list_peers()
+                
+                elif parts[0] == 'connect' and len(parts) >= 2:
+                    self.connect_to_peer(parts[1])
+                
+                elif parts[0] == 'send' and len(parts) >= 3:
+                    self.send_message(parts[1], parts[2])
+                
+                elif parts[0] == 'quit':
+                    self.running = False
+                    break
+                
+                else:
+                    print("Unknown command")
+                    
+            except KeyboardInterrupt:
+                print("\nExiting...")
+                self.running = False
+                break
+    
+    def run(self):
+        """Start the peer client"""
+        self.register()
+        
+        # Start heartbeat thread
+        heartbeat_thread = threading.Thread(target=self.send_heartbeat, daemon=True)
+        heartbeat_thread.start()
+        
+        # Start receiving thread
+        recv_thread = threading.Thread(target=self.handle_incoming, daemon=True)
+        recv_thread.start()
+        
+        time.sleep(0.5)  # Wait for registration
+        
+        # Run interactive shell
+        self.interactive_shell()
+        
+        self.sock.close()
+
+if __name__ == '__main__':
+    if len(sys.argv) < 3:
+        print("Usage: python peer_client.py <peer_id> <server_host>")
+        print("Example: python peer_client.py Alice 192.168.1.100")
+        sys.exit(1)
+    
+    peer_id = sys.argv[1]
+    server_host = sys.argv[2]
+    
+    client = PeerClient(peer_id, server_host)
+    client.run()
+
+
+    24.94.185.82
+
+    novus 73.217.240.123

ns2/lib/udp_server.py

@@ -0,0 +1,167 @@
+import os
+import socket
+import time
+from dataclasses import dataclass, asdict
+import asyncio
+from asyncio import StreamWriter, StreamReader
+from nicegui import Event, app
+
+from collections import deque
+socket_received = Event()
+
+socket_writer = None
+socket_reader = None
+
+async def socket_setup():
+    global socket_reader, socket_writer
+    try: 
+        socket_reader, socket_writer = await asyncio.open_unix_connection("/tmp/serial.sock")
+        print("SOCKET OPENED")
+        await read_socket()
+    
+    except FileNotFoundError:
+        print("SOCKET NOT AVAILABLE")
+        socket_received.emit("Socket Not Available")
+
+        #raise 
+
+    except asyncio.CancelledError:
+        print("SOCKET LISTENER CANCELLED")
+        raise
+        
+    finally:
+        await socket_cleanup()
+        
+async def socket_cleanup():
+    global socket_writer
+
+    print("SOCKET LISTENER CLOSED")
+    if socket_writer:
+        socket_writer.close()
+        await socket_writer.wait_closed()
+
+
+        
+        
+async def read_socket():
+    global socket_reader
+    while True:
+        data = await socket_reader.read(128)
+        if data:
+            record_data(data)
+            # Emit event with the data - any subscribed UI can receive it
+            socket_received.emit(data.decode('utf-8', errors='ignore'))
+        else:
+            # Socket closed by remote end
+            break
+        
+        #get_data()
+
+
+
+def record_data(data):
+    latest = data.decode('utf-8', errors='ignore')
+    with open("data.txt", "a") as f:
+        f.writelines(latest)
+    
+    with open("data.txt", "r+") as f:
+        lines = f.readlines()
+        n = len(lines)
+        if n >= 10000:
+            lines = lines[n-10000:]
+            f.seek(0)       # go to start of file
+            f.truncate() 
+            f.writelines(lines)
+
+
+
+
+async def write_socket(command: str):
+    global socket_writer
+    command = command+"\r\n"
+    socket_writer.write(command.encode())
+    await socket_writer.drain()
+
+
+
+def ReadWriteSocket(command: str) -> str:
+    command = command + "\r\n"
+    
+    try:
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        sock.connect("/tmp/serial.sock")
+        sock.settimeout(4.0)  # 4 second timeout
+        
+        try:
+            sock.sendall(command.encode('utf-8'))
+            sock_file = sock.makefile('r')
+            
+            while True:
+                line = sock_file.readline()
+                    
+                if any(marker in line for marker in ["$ER", "$RR", "$WR", "$GPNTL"]):
+                    return line, None
+            
+        finally:
+            sock.close()
+            
+    except socket.timeout:
+        return "timeout"
+    except ConnectionRefusedError as e:
+        print("socket error?")
+        return "port open error"
+    except Exception as e:
+        print(e)
+        return "port write error"
+
+
+
+
+
+def ReadNtlProperty(module: int, property :int) -> list[str]:
+    return ReadWriteSocket(f"$GPNTL,{module},{property},?")
+
+def WriteNtlProperty(module: int, property :int, value :str):
+    return ReadWriteSocket(f"$GPNTL,{module},{property},{value}")
+
+def ParseNtlResponse(response :str)->str:
+    fields = response.split(",")
+    if len(fields) == 4:
+        module = fields[1]
+        property = fields[2]
+        value = fields[3]
+        return value
+              
+
+
+def LoadConfig(file_name: str):
+
+    print("LOADING CONFIG...")
+    
+    try:
+        with open(file_name, 'r') as f:
+            data = f.read()
+    except Exception as err:
+        print(f"file err: {err}")
+        return
+    
+    for line in data.split('\n'):
+        # Skip comments
+        if "--" in line:
+            continue
+        
+        # Process $WC commands
+        if "$WC" in line:
+            line = line.strip()  # Remove whitespace and newlines
+            
+            rsp, err = ReadWriteSocket(line)
+            
+            if rsp.startswith("$ER"):
+                print("config load err")
+                return
+            
+            if err is not None:
+                print("config error")
+                return
+            
+            print(rsp)

ns2/snmp/ns_dbus_service.py

@@ -0,0 +1,38 @@
+import asyncio
+
+from dbus_next.aio import MessageBus
+from dbus_next.constants import BusType
+
+from snmp_interface import SnmpInterface
+from pam_interface import PamInterface
+from systemd_lib import *
+
+from cockpit_dbus_superuser_service import Superuser
+async def main():
+    
+    bus = await MessageBus(bus_type=BusType.SYSTEM).connect()
+    
+    snmpInterface = SnmpInterface('com.novus.ns.snmp')
+    bus.export('/com/novus/ns', snmpInterface)
+    snmpInterface.bus = bus
+
+    pamInterface = PamInterface('com.novus.ns.pam')
+    bus.export('/com/novus/ns', pamInterface)
+    
+    userInterface = Superuser('com.novus.ns.super')
+    bus.export('/com/novus/ns', userInterface)
+    
+    #firewallInterface = FirewalldInterface('com.novus.ns.firewall')
+    #bus.export('/com/novus/ns', firewallInterface)
+
+    #socketInterface = SocketInterface('com.novus.ns.socket')
+    #bus.export('/com/novus/ns', socketInterface)
+
+    print("Starting ns service... com.novus.ns")
+    
+    await bus.request_name('com.novus.ns')
+    await asyncio.Event().wait()
+
+    bus.disconnect()
+
+asyncio.run(main())

ns2/snmp/pam_interface.py

@@ -0,0 +1,19 @@
+import pam
+from dbus_next.service import ServiceInterface, method
+
+
+class PamInterface(ServiceInterface):
+    def __init__(self, name):
+        super().__init__(name)
+
+    @method()
+    def Authenticate(self, username: 's', password: 's') -> 'b':
+        p = pam.pam()
+        if p.authenticate(username, password, print_failure_messages=True):
+            print("authentication successful")
+            return True
+        else:
+            print("authentication failed")
+
+            return False
+

ns2/snmp/snmp_interface.py

@@ -0,0 +1,66 @@
+
+
+from dataclasses import asdict
+from dbus_next.service import ServiceInterface, method
+
+from snmp_lib import *
+
+class SnmpInterface(ServiceInterface):
+    def __init__(self, name):
+        super().__init__(name)
+        self.bus = None
+
+    @method()
+    async def Reset(self):
+        await ResetSnmpd(self.bus)
+
+# ====================================================================
+# V3 USERS
+# ====================================================================
+    @method()
+    async def CreateV3User(self, v3User: 'a{ss}'):
+        await AddV3User(self.bus, V3User.from_dict(v3User))
+
+    @method()
+    async def GetV3UserByUsername(self, username :'s') -> 'a{ss}':
+        return asdict(await ReadV3UserByUsername(username))
+
+    @method()
+    async def GetV3Users(self) -> 'aa{ss}':
+        return [asdict(u) for u in (await ReadV3Users())]
+
+    @method()
+    async def ModifyV3User(self, initUser: 'a{ss}', finalUser: 'a{ss}'):
+        await EditV3User(self.bus, V3User.from_dict(initUser), V3User.from_dict(finalUser))
+
+    @method()
+    async def RemoveV3User(self, v3User: 'a{ss}'):
+        await DeleteV3User(self.bus, V3User.from_dict(v3User))
+    
+# ====================================================================
+# V2 USERS
+# ====================================================================
+
+    @method()
+    async def CreateV2User(self, v2User: 'a{ss}'):
+        await AddV2User(self.bus, V2User.from_dict(v2User))
+
+    @method()
+    async def GetV2UserByCommunity(self, community :'s') -> 'a{ss}':
+        return asdict(await ReadV2UserByCommunity(community))
+
+    @method()
+    async def GetV2Users(self) -> 'aa{ss}':
+        return [asdict(u) for u in await ReadV2Users()]
+
+    @method()
+    async def ModifyV2User(self, editUser: 'a{ss}'):
+        await EditV2User(self.bus, V2User.from_dict(editUser))
+
+    @method()
+    async def RemoveV2User(self, v2User: 'a{ss}'):
+        await DeleteV2User(self.bus, V2User.from_dict(v2User))
+
+# ====================================================================
+# 
+# ====================================================================

ns2/ui/assets/NOVUS_LOGO.svg

@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   version="1.1"
+   id="svg1"
+   width="496"
+   height="59.648041"
+   viewBox="0 0 496 59.648041"
+   sodipodi:docname="NOVUS_TEMP.svg"
+   inkscape:version="1.4.2 (f4327f4, 2025-05-13)"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:svg="http://www.w3.org/2000/svg">
+  <defs
+     id="defs1">
+    <mask
+       maskUnits="userSpaceOnUse"
+       x="0"
+       y="0"
+       width="1"
+       height="1"
+       id="mask1">
+      <image
+         width="1"
+         height="1"
+         style="image-rendering:optimizeSpeed"
+         preserveAspectRatio="none"
+         xlink:href="data:image/png;base64,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"
+         id="image1" />
+    </mask>
+  </defs>
+  <sodipodi:namedview
+     id="namedview1"
+     pagecolor="#ffffff"
+     bordercolor="#000000"
+     borderopacity="0.25"
+     inkscape:showpageshadow="2"
+     inkscape:pageopacity="0.0"
+     inkscape:pagecheckerboard="0"
+     inkscape:deskcolor="#d1d1d1"
+     inkscape:zoom="2.6587786"
+     inkscape:cx="227.73615"
+     inkscape:cy="30.277061"
+     inkscape:window-width="2560"
+     inkscape:window-height="1369"
+     inkscape:window-x="1912"
+     inkscape:window-y="-8"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="g9">
+    <inkscape:page
+       x="0"
+       y="0"
+       inkscape:label="1"
+       id="page1"
+       width="496"
+       height="59.648041"
+       margin="0"
+       bleed="0" />
+  </sodipodi:namedview>
+  <g
+     id="g1"
+     inkscape:groupmode="layer"
+     inkscape:label="1"
+     transform="translate(-39.071831,-9.3639688)">
+    <g
+       id="g9">
+      <g
+         id="g10"
+         transform="translate(0.192,-287.808)">
+        <path
+           id="path8"
+           style="fill:#d40000;fill-opacity:1"
+           d="m 160.81055,309.21094 c -12.84512,-0.0652 -20.43225,0.0192 -21.86914,0.24218 -4.46679,0.69304 -7.73704,2.34066 -8.70703,4.38477 -0.43855,0.92419 -0.51383,1.92895 -0.42383,5.67773 0.10591,4.41164 0.13727,4.59226 1,5.72266 1.09141,1.43003 3.03378,2.60276 5.35742,3.23438 1.48222,0.40293 5.08007,0.46661 23.35156,0.41211 21.45449,-0.0639 21.61108,-0.0695 23.32031,-0.76954 2.28736,-0.93679 4.14144,-2.2517 4.70313,-3.33789 0.336,-0.64975 0.45703,-2.13532 0.45703,-5.58398 0,-4.13885 -0.0771,-4.82059 -0.64062,-5.73242 -0.7787,-1.25995 -2.67209,-2.55285 -5.08008,-3.4668 -1.75555,-0.66631 -2.28598,-0.6859 -21.46875,-0.7832 z m -22.41016,4.72851 h 20.47852 20.48047 v 5.28125 5.2793 h -20.48047 -20.47852 v -5.2793 z" />
+        <path
+           style="fill:#d40000;fill-opacity:1"
+           d="m 346.39982,325.83142 v -3.56843 l 33.2,-0.0815 33.2,-0.0815 0.0929,-2.64 0.0929,-2.64 H 385.3346 c -30.75812,0 -31.23633,-0.0276 -35.53424,-2.05036 -2.85159,-1.34207 -4.26887,-2.41053 -5.36764,-4.04655 -1.72803,-2.57299 -1.46458,-5.45181 0.71534,-7.81675 2.39163,-2.59461 7.60208,-4.69286 12.6517,-5.09484 1.20999,-0.0963 15.84398,-0.26177 32.51998,-0.36765 l 30.32,-0.19252 v 3.54433 3.54434 h -32.63992 -32.64 v 2.70866 2.70866 l 28.72,0.0913 28.72,0.0913 2.56,0.90168 c 10.42683,3.67251 11.86109,11.61536 2.89606,16.03829 -4.43255,2.1868 -2.95533,2.09923 -39.13606,2.32012 l -32.72,0.19976 z"
+           id="path7" />
+        <path
+           style="fill:#d40000;fill-opacity:1"
+           d="m 284.05624,328.96501 c -3.08618,-0.62385 -6.5662,-2.83146 -7.59276,-4.81661 -0.36374,-0.7034 -0.46365,-2.41703 -0.46365,-7.9525 v -7.05589 h 4.48 4.48 v 7.68 7.68 h 20.8 20.8 v -7.68 -7.68 h 4.48 4.48 v 7.63685 c 0,7.30155 -0.0299,7.67479 -0.67986,8.50114 -0.87514,1.11257 -2.78266,2.31017 -5.04617,3.16817 -1.7575,0.66619 -2.22659,0.68122 -23.07397,0.73927 -11.704,0.0326 -21.90261,-0.0666 -22.66359,-0.22043 z"
+           id="path6" />
+        <path
+           style="fill:#d40000;fill-opacity:1"
+           d="m 215.44365,328.67861 c -2.47395,-0.79086 -4.67747,-2.25736 -6.74123,-4.48646 -1.86158,-2.01073 -3.00952,-3.86657 -8.41753,-13.60839 l -3.55495,-6.40375 -33.64505,-0.0815 -33.64506,-0.0815 v -3.35853 -3.35847 l 37.6,-0.048 c 20.68,-0.0264 37.74614,-0.0624 37.92476,-0.08 0.17862,-0.0176 3.60419,5.584 7.61238,12.448 l 7.28762,12.48 2.70762,0.21294 c 3.65736,0.28763 18.403,0.33585 21.33917,0.0698 l 2.36196,-0.21403 7.42324,-12.43291 7.42325,-12.4329 37.2,-10e-4 37.2,-0.001 v 3.30763 3.30763 l -17.52,0.21205 c -9.636,0.11663 -24.5079,0.21219 -33.04866,0.21237 l -15.52865,3.2e-4 -5.42488,9.36 c -5.74382,9.91031 -7.14759,11.78822 -10.18204,13.62118 -3.21068,1.93942 -3.56417,1.9726 -20.85577,1.95781 -14.30467,-0.0122 -15.84106,-0.0649 -17.51618,-0.60039 z"
+           id="path5" />
+        <path
+           style="fill:#d40000;fill-opacity:1"
+           d="m 38.881629,317.70001 c 0.0011,-7.3024 0.129529,-12.06008 0.34659,-12.84183 0.852584,-3.0706 6.356793,-6.59257 11.344636,-7.25906 1.586502,-0.212 6.923524,-0.29784 13.92,-0.2239 10.884252,0.11504 11.429002,0.14992 13.358059,0.85547 2.82221,1.03223 6.377,3.66107 7.57671,5.60313 l 0.97221,1.57381 0.16,8.34619 0.16,8.34619 h 12.160001 12.159995 l 0.0838,-12.4 0.0838,-12.4 h 5.75624 5.75624 v 12.03164 c 0,10.43419 -0.0689,12.17686 -0.51905,13.12545 -1.14246,2.40757 -5.59618,5.3733 -9.42094,6.27342 -1.25536,0.29543 -5.17152,0.40949 -14.060005,0.40949 -12.000891,0 -12.374771,-0.0189 -14.434741,-0.73103 -3.96451,-1.37046 -7.17819,-3.88253 -8.480377,-6.62897 -0.734317,-1.54874 -0.758717,-1.85375 -0.761747,-9.52 l -0.003,-7.92 h -12.160001 -12.16 v 12.48 12.48 h -5.92 -5.92 z"
+           id="path4" />
+        <path
+           style="fill:#000000;fill-opacity:1"
+           d="m 38.879829,340.82001 v -3.2 h 247.999991 248 v 3.2 3.2 h -248 -247.999991 z"
+           id="path3"
+           sodipodi:nodetypes="ccccccccc" />
+        <path
+           style="fill:#d40000;fill-opacity:1"
+           d="m 39.005593,356.31384 c 0.10683,-0.2784 0.194236,-1.1424 0.194236,-1.92 v -1.41383 h 247.679991 247.68 v 1.92 1.92 H 286.68558 c -225.897402,0 -247.857003,-0.0449 -247.679987,-0.50617 z"
+           id="path2" />
+      </g>
+    </g>
+  </g>
+</svg>