netool 1.0.0__py3-none-any.whl

netool/__init__.py

@@ -0,0 +1,3 @@
+from netool.cli import main
+
+__version__ = "1.0.0"

netool/__main__.py

@@ -0,0 +1,4 @@
+from netool.cli import main
+
+if __name__ == "__main__":
+    main()

netool/cli.py

@@ -0,0 +1,1011 @@
+#!/usr/bin/env python3
+
+import argparse
+import concurrent.futures
+try:
+    import fcntl
+except ImportError:
+    fcntl = None
+import ipaddress
+import json
+import os
+import re
+import shutil
+import socket
+import struct
+import subprocess
+import sys
+import time
+import urllib.error
+import urllib.request
+
+VERSION = "1.0.0"
+ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
+COLOR = sys.stdout.isatty() and not os.environ.get("NO_COLOR")
+
+TYPE_NAMES = {1: "A", 2: "NS", 5: "CNAME", 6: "SOA", 12: "PTR", 15: "MX", 16: "TXT", 28: "AAAA"}
+QTYPES = {"A": 1, "NS": 2, "CNAME": 5, "SOA": 6, "PTR": 12, "MX": 15, "TXT": 16, "AAAA": 28}
+
+
+def set_color(on):
+    global COLOR
+    COLOR = on
+
+
+def green(s):
+    return f"\x1b[32m{s}\x1b[0m" if COLOR else str(s)
+
+
+def red(s):
+    return f"\x1b[31m{s}\x1b[0m" if COLOR else str(s)
+
+
+def yellow(s):
+    return f"\x1b[33m{s}\x1b[0m" if COLOR else str(s)
+
+
+def cyan(s):
+    return f"\x1b[36m{s}\x1b[0m" if COLOR else str(s)
+
+
+def dim(s):
+    return f"\x1b[2m{s}\x1b[0m" if COLOR else str(s)
+
+
+def bold(s):
+    return f"\x1b[1m{s}\x1b[0m" if COLOR else str(s)
+
+
+def die(msg, code=1):
+    print(red(f"error: {msg}"), file=sys.stderr)
+    sys.exit(code)
+
+
+def width(s):
+    return len(ANSI_RE.sub("", str(s)))
+
+
+def show(rows, columns, json_mode, title=None):
+    if json_mode:
+        print(json.dumps({"name": title, "items": rows} if title else rows, indent=2))
+        return
+    if title:
+        print(bold(title))
+    widths = {c: len(c) for c in columns}
+    for r in rows:
+        for c in columns:
+            widths[c] = max(widths[c], width(r.get(c, "")))
+    print("  ".join(c.ljust(widths[c]) for c in columns))
+    if rows:
+        print(dim("  ".join("-" * widths[c] for c in columns)))
+    for r in rows:
+        print("  ".join(str(r.get(c, "")).ljust(widths[c]) for c in columns))
+    if not rows:
+        print(dim("(no results)"))
+
+
+def resolve_host(name):
+    try:
+        return socket.gethostbyname(name)
+    except socket.gaierror:
+        die(f"cannot resolve: {name}")
+
+
+def icmp_checksum(data):
+    if len(data) & 1:
+        data += b"\x00"
+    s = 0
+    for i in range(0, len(data), 2):
+        s += (data[i] << 8) | data[i + 1]
+    s = (s & 0xFFFF) + (s >> 16)
+    s += s >> 16
+    return (~s) & 0xFFFF
+
+
+def icmp_socket():
+    return socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP)
+
+
+def icmp_probe(ip, ident, count, timeout, interval, on_result=None):
+    sock = icmp_socket()
+    sock.settimeout(timeout)
+    rtts = []
+    ok = 0
+    try:
+        for seq in range(count):
+            payload = struct.pack("!d", time.time()) + b"\x00" * 48
+            pkt = struct.pack("!BBHHH", 8, 0, 0, ident, seq) + payload
+            pkt = struct.pack("!BBHHH", 8, 0, icmp_checksum(pkt), ident, seq) + payload
+            t0 = time.time()
+            sock.sendto(pkt, (ip, 0))
+            try:
+                data, addr = sock.recvfrom(1024)
+                rtt = (time.time() - t0) * 1000
+                rtype, _rc, _cs, rid, _rseq = struct.unpack_from("!BBHHH", data, 20)
+                if rid == ident and rtype == 0:
+                    if on_result:
+                        on_result(seq, rtt, addr[0], None)
+                    rtts.append(rtt)
+                    ok += 1
+                elif rtype == 11:
+                    if on_result:
+                        on_result(seq, None, addr[0], "TTL expired")
+            except socket.timeout:
+                if on_result:
+                    on_result(seq, None, None, "timeout")
+            if seq < count - 1 and interval:
+                time.sleep(interval)
+    finally:
+        sock.close()
+    return rtts, ok
+
+
+def ping_tcp(ip, args):
+    port = args.port or 80
+    rtts = []
+    sent = 0
+    ok = 0
+    print(bold(f"PING {ip} via TCP port {port}"))
+    for i in range(args.count):
+        t0 = time.time()
+        try:
+            with socket.create_connection((ip, port), timeout=args.timeout):
+                rtt = (time.time() - t0) * 1000
+            ok += 1
+            rtts.append(rtt)
+            print(f"seq={i}  {rtt:6.1f} ms  {green('reachable')}")
+        except (ConnectionRefusedError, ConnectionResetError):
+            rtt = (time.time() - t0) * 1000
+            ok += 1
+            rtts.append(rtt)
+            print(f"seq={i}  {rtt:6.1f} ms  {cyan('reachable (port refused)')}")
+        except OSError as e:
+            print(f"seq={i}  {red('unreachable')} ({e})")
+        sent += 1
+        if i < args.count - 1:
+            time.sleep(args.interval)
+    print_ping_summary(ip, rtts, sent, ok)
+
+
+def print_ping_summary(ip, rtts, sent, ok):
+    loss = (1 - ok / sent) * 100 if sent else 0
+    print(f"--- {ip} ping statistics ---")
+    if rtts:
+        print(f"{sent} transmitted, {ok} received, {loss:.0f}% packet loss, "
+              f"min/avg/max = {min(rtts):.1f}/{sum(rtts) / len(rtts):.1f}/{max(rtts):.1f} ms")
+    else:
+        print(f"{sent} transmitted, {ok} received, {loss:.0f}% packet loss")
+
+
+def cmd_ping(args):
+    ip = resolve_host(args.host)
+    if args.tcp:
+        ping_tcp(ip, args)
+        return
+    try:
+        icmp_socket()
+    except PermissionError:
+        print(yellow("raw ICMP requires root (sudo); falling back to TCP ping"))
+        ping_tcp(ip, args)
+        return
+
+    ident = os.getpid() & 0xFFFF
+    print(bold(f"PING {ip} via ICMP"))
+
+    def on_result(seq, rtt, addr, note):
+        if rtt is not None:
+            print(f"seq={seq}  {rtt:6.1f} ms  from {addr}")
+        elif note:
+            print(f"seq={seq}  {yellow(note)} from {addr}" if addr else f"seq={seq}  {yellow(note)}")
+
+    rtts, ok = icmp_probe(ip, ident, args.count, args.timeout, args.interval, on_result)
+    print_ping_summary(ip, rtts, args.count, ok)
+
+
+def cmd_trace(args):
+    ip = resolve_host(args.host)
+    try:
+        icmp_socket().close()
+    except PermissionError:
+        for exe in ("traceroute", "tracepath"):
+            path = shutil.which(exe)
+            if path:
+                print(dim(f"using system {exe} (raw ICMP needs root)"))
+                cmd = [path, ip]
+                if "traceroute" in exe:
+                    cmd += ["-m", str(args.hops), "-w", str(args.timeout)]
+                subprocess.call(cmd)
+                return
+        die("traceroute requires raw ICMP (run with sudo) or the 'traceroute' binary")
+
+    recv = icmp_socket()
+    recv.settimeout(args.timeout)
+    rows = []
+    try:
+        for ttl in range(1, args.hops + 1):
+            port = min(33434 + ttl - 1, 33534)
+            snd = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            snd.setsockopt(socket.IPPROTO_IP, socket.IP_TTL, ttl)
+            snd.settimeout(args.timeout)
+            t0 = time.time()
+            snd.sendto(b"", (ip, port))
+            reached = False
+            try:
+                data, addr = recv.recvfrom(1024)
+                rtt = (time.time() - t0) * 1000
+                rtype = data[20]
+                code = data[21]
+                hop = addr[0] if addr else None
+                if rtype == 11:
+                    status = "in-transit"
+                elif rtype == 3 and code == 3:
+                    status = "destination"
+                    reached = True
+                else:
+                    status = f"icmp {rtype}/{code}"
+                rows.append({"ttl": ttl, "hop": hop, "rtt": round(rtt, 1), "status": status})
+            except socket.timeout:
+                rows.append({"ttl": ttl, "hop": "*", "rtt": "", "status": "timeout"})
+            snd.close()
+            if reached:
+                break
+    finally:
+        recv.close()
+    show(rows, ["ttl", "hop", "rtt", "status"], args.json, title=f"Traceroute to {ip}")
+
+
+def parse_ports(spec):
+    ports = set()
+    for tok in spec.split(","):
+        tok = tok.strip()
+        if not tok:
+            continue
+        if "-" in tok:
+            try:
+                lo, hi = map(int, tok.split("-", 1))
+            except ValueError:
+                die(f"invalid port range: {tok}")
+            if lo < 1 or hi > 65535 or lo > hi:
+                die(f"invalid port range: {tok}")
+            ports.update(range(lo, hi + 1))
+        else:
+            try:
+                p = int(tok)
+            except ValueError:
+                die(f"invalid port: {tok}")
+            if not 1 <= p <= 65535:
+                die(f"port out of range: {p}")
+            ports.add(p)
+    if not ports:
+        die("no valid ports given")
+    return sorted(ports)
+
+
+def is_ip(s):
+    try:
+        ipaddress.ip_address(s)
+        return True
+    except ValueError:
+        return False
+
+
+def expand_ips(lo, hi):
+    if hi - lo + 1 > 4096:
+        die("target range too large (max 4096 addresses)")
+    return [str(ipaddress.ip_address(x)) for x in range(lo, hi + 1)]
+
+
+def parse_targets(spec):
+    if "/" in spec:
+        net = ipaddress.ip_network(spec, strict=False)
+        if net.prefixlen == 32:
+            return [str(net.network_address)]
+        return [str(h) for h in net.hosts()]
+    if "-" in spec:
+        left, right = spec.split("-", 1)
+        start = left if is_ip(left) else socket.gethostbyname(left)
+        if "." in right:
+            end = right
+        else:
+            end = ".".join(start.split(".")[:-1] + [right])
+        if not is_ip(start) or not is_ip(end):
+            die(f"invalid target range: {spec}")
+        return expand_ips(int(ipaddress.ip_address(start)), int(ipaddress.ip_address(end)))
+    if is_ip(spec):
+        return [spec]
+    return [socket.gethostbyname(spec)]
+
+
+def cmd_scan(args):
+    targets = parse_targets(args.target)
+    ports = parse_ports(args.ports)
+    rows = []
+
+    def probe(ip, port):
+        t0 = time.time()
+        try:
+            with socket.create_connection((ip, port), timeout=args.timeout):
+                rtt = round((time.time() - t0) * 1000, 1)
+            return {"ip": ip, "port": port, "status": "open", "rtt_ms": rtt}
+        except socket.timeout:
+            return {"ip": ip, "port": port, "status": "filtered", "rtt_ms": ""}
+        except OSError:
+            return {"ip": ip, "port": port, "status": "closed", "rtt_ms": ""}
+
+    jobs = [(ip, p) for ip in targets for p in ports]
+    print(dim(f"scanning {len(targets)} host(s) x {len(ports)} port(s) with {args.threads} threads"))
+    with concurrent.futures.ThreadPoolExecutor(max_workers=args.threads) as ex:
+        futs = {ex.submit(probe, ip, p): (ip, p) for ip, p in jobs}
+        for f in concurrent.futures.as_completed(futs):
+            r = f.result()
+            if r["status"] == "open" or args.all:
+                rows.append(r)
+    rows.sort(key=lambda r: (r["ip"], r["port"]))
+    for r in rows:
+        r["port"] = str(r["port"])
+        if args.service:
+            try:
+                r["service"] = socket.getservbyport(int(r["port"]))
+            except OSError:
+                r["service"] = "?"
+        if r["status"] == "open":
+            r["status"] = green("open")
+        elif r["status"] == "filtered":
+            r["status"] = yellow("filtered")
+        else:
+            r["status"] = dim(r["status"])
+    cols = ["ip", "port", "service", "status", "rtt_ms"] if args.service else ["ip", "port", "status", "rtt_ms"]
+    show(rows, cols, args.json, title=f"Port scan ({args.target})")
+
+
+def system_resolver():
+    try:
+        with open("/etc/resolv.conf") as f:
+            for line in f:
+                parts = line.split()
+                if len(parts) >= 2 and parts[0] == "nameserver":
+                    return parts[1]
+    except OSError:
+        pass
+    return "8.8.8.8"
+
+
+def encode_name(name):
+    out = b""
+    for part in name.strip(".").split("."):
+        b = part.encode("utf-8")
+        out += bytes([len(b)]) + b
+    return out + b"\x00"
+
+
+def parse_name(msg, off):
+    labels = []
+    while True:
+        l = msg[off]
+        if l == 0:
+            off += 1
+            break
+        if l & 0xC0 == 0xC0:
+            ptr = struct.unpack_from("!H", msg, off)[0] & 0x3FFF
+            name, _ = parse_name(msg, ptr)
+            labels.append(name)
+            off += 2
+            break
+        off += 1
+        labels.append(msg[off:off + l].decode("utf-8", "replace"))
+        off += l
+    return ".".join(labels), off
+
+
+def dns_exchange(server, query, timeout):
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    s.settimeout(timeout)
+    try:
+        s.sendto(query, (server, 53))
+        data, _ = s.recvfrom(65535)
+        return data
+    finally:
+        s.close()
+
+
+def parse_dns(msg):
+    _rid, _flags, qd, an, _ns, _ar = struct.unpack_from("!HHHHHH", msg, 0)
+    off = 12
+    for _ in range(qd):
+        _qname, off = parse_name(msg, off)
+        off += 4
+    rows = []
+    for _ in range(an):
+        rname, off = parse_name(msg, off)
+        rtype, _rclass, ttl, rdlen = struct.unpack_from("!HHIH", msg, off)
+        off += 10
+        if rtype in (2, 5, 12):
+            value, off = parse_name(msg, off)
+        elif rtype == 15:
+            pref = struct.unpack_from("!H", msg, off)[0]
+            exchange, off = parse_name(msg, off + 2)
+            value = f"{pref} {exchange}" if exchange else str(pref)
+        elif rtype == 16:
+            parts = []
+            o = off
+            while o < off + rdlen:
+                ln = msg[o]
+                parts.append(msg[o + 1:o + 1 + ln].decode("utf-8", "replace"))
+                o += 1 + ln
+            value = "".join(parts)
+            off += rdlen
+        elif rtype == 6:
+            mname, off = parse_name(msg, off)
+            rnamex, off = parse_name(msg, off)
+            serial, refresh, retry, expire, minimum = struct.unpack_from("!IIIII", msg, off)
+            off += 20
+            value = f"{mname} SOA {rnamex} serial={serial} refresh={refresh} retry={retry} expire={expire} minimum={minimum}"
+        elif rtype == 1:
+            value = socket.inet_ntoa(msg[off:off + rdlen])
+            off += rdlen
+        elif rtype == 28:
+            value = socket.inet_ntop(socket.AF_INET6, msg[off:off + rdlen])
+            off += rdlen
+        else:
+            value = msg[off:off + rdlen].hex()
+            off += rdlen
+        rows.append({"name": rname or "root", "type": TYPE_NAMES.get(rtype, str(rtype)), "ttl": ttl, "value": value})
+    return rows
+
+
+def cmd_dns(args):
+    qtype = QTYPES.get(args.type.upper())
+    if qtype is None:
+        die(f"unsupported type: {args.type}")
+    server = args.server or system_resolver()
+    qid = os.getpid() & 0xFFFF
+    header = struct.pack("!HHHHHH", qid, 0x0100, 1, 0, 0, 0)
+    query = header + encode_name(args.qname) + struct.pack("!HH", qtype, 1)
+    try:
+        reply = dns_exchange(server, query, args.timeout)
+    except (socket.timeout, OSError) as e:
+        die(f"DNS query failed against {server}: {e}")
+    rows = parse_dns(reply)
+    if not rows:
+        print(yellow(f"no {args.type.upper()} records for {args.qname}"))
+        return
+    show(rows, ["name", "type", "ttl", "value"], args.json, title=f"DNS lookup ({args.qname}) via {server}")
+
+
+def whois_query(server, query, timeout):
+    with socket.create_connection((server, 43), timeout=timeout) as s:
+        s.sendall((query + "\r\n").encode())
+        chunks = []
+        while True:
+            d = s.recv(4096)
+            if not d:
+                break
+            chunks.append(d)
+        return b"".join(chunks).decode("utf-8", "replace")
+
+
+def cmd_whois(args):
+    query = args.query
+    server = "whois.iana.org"
+    seen = set()
+    try:
+        data = whois_query(server, query, args.timeout)
+    except OSError as e:
+        die(f"whois query failed: {e}")
+    for _ in range(5):
+        m = re.search(r"(?im)^refer:\s*(\S+)", data)
+        if not m:
+            break
+        nxt = m.group(1)
+        if nxt in seen or nxt == server:
+            break
+        seen.add(nxt)
+        server = nxt
+        try:
+            data = whois_query(server, query, args.timeout)
+        except OSError as e:
+            print(yellow(f"referral to {server} failed: {e}"))
+            break
+    if args.json:
+        print(json.dumps({"query": query, "server": server, "result": data}, indent=2))
+    else:
+        print(data)
+
+
+def iface_ipv4(name):
+    try:
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        if fcntl is None:
+            # fallback for systems without fcntl (Windows)
+            try:
+                s.connect((name, 80))
+                addr = s.getsockname()[0]
+                s.close()
+                return addr
+            except OSError:
+                s.close()
+                return ""
+        res = fcntl.ioctl(s.fileno(), 0x8915, struct.pack("256s", name[:15].encode()))
+        s.close()
+        return socket.inet_ntoa(res[20:24])
+    except OSError:
+        return ""
+
+
+def read_sys(name, key):
+    try:
+        with open(f"/sys/class/net/{name}/{key}") as f:
+            return f.read().strip()
+    except OSError:
+        return ""
+
+
+def default_routes():
+    out = []
+    try:
+        with open("/proc/net/route") as f:
+            for line in f:
+                p = line.split()
+                if len(p) < 11 or p[0] == "Iface":
+                    continue
+                dst = socket.inet_ntoa(struct.pack("<I", int(p[1], 16)))
+                gw = socket.inet_ntoa(struct.pack("<I", int(p[2], 16)))
+                if gw == "0.0.0.0":
+                    continue
+                out.append({"iface": p[0], "destination": dst, "gateway": gw})
+    except OSError:
+        pass
+    return out
+
+
+def cmd_netinfo(args):
+    try:
+        hostname = socket.gethostname()
+    except OSError:
+        hostname = "?"
+    try:
+        names = sorted(n for n in os.listdir("/sys/class/net") if n != "lo")
+    except FileNotFoundError:
+        die("netinfo requires Linux with /sys/class/net")
+    interfaces = []
+    for name in names:
+        mac = read_sys(name, "address")
+        mtu = read_sys(name, "mtu")
+        state = read_sys(name, "operstate") or (read_sys(name, "carrier") and "up" or "down")
+        interfaces.append({"name": name, "ipv4": iface_ipv4(name), "mac": mac, "mtu": mtu, "state": state})
+    routes = default_routes()
+
+    if args.json:
+        print(json.dumps({
+            "hostname": hostname,
+            "primary_resolver": system_resolver(),
+            "interfaces": interfaces,
+            "routes": routes,
+        }, indent=2))
+        return
+    print(bold(f"Host: {hostname}"))
+    print(f"DNS resolver: {system_resolver()}")
+    show(interfaces, ["name", "ipv4", "mac", "mtu", "state"], False, title="Interfaces")
+    show(routes, ["iface", "destination", "gateway"], False, title="Routes")
+
+
+def cmd_arp(args):
+    rows = []
+    try:
+        with open("/proc/net/arp") as f:
+            for i, line in enumerate(f):
+                if i == 0:
+                    continue
+                p = line.split()
+                if len(p) < 6:
+                    continue
+                ip, hwtype, flags, hwaddr, _mask, iface = p[:6]
+                flags = int(flags, 16)
+                if args.state == "reachable" and not (flags & 0x2):
+                    continue
+                if args.state == "incomplete" and (flags & 0x2):
+                    continue
+                if hwaddr == "00:00:00:00:00:00":
+                    state = "incomplete"
+                elif flags & 0x2:
+                    state = "reachable"
+                elif flags & 0x4:
+                    state = "permanent"
+                else:
+                    state = "present"
+                rows.append({"ip": ip, "mac": hwaddr, "iface": iface, "state": state})
+    except OSError as e:
+        die(f"cannot read ARP table: {e}")
+    for r in rows:
+        if r["state"] == "reachable":
+            r["state"] = green(r["state"])
+        elif r["state"] == "incomplete":
+            r["state"] = yellow(r["state"])
+    show(rows, ["ip", "mac", "iface", "state"], args.json, title="ARP table")
+
+
+def cmd_subnet(args):
+    try:
+        if len(args.address) == 1 and "/" in args.address[0]:
+            net = ipaddress.ip_network(args.address[0], strict=False)
+        elif len(args.address) == 2:
+            addr = ipaddress.ip_address(args.address[0])
+            mask = ipaddress.ip_network(f"{addr}/{args.address[1]}", strict=False)
+            net = mask
+        else:
+            die("usage: subnet <CIDR> or subnet <address> <netmask>")
+    except ValueError as e:
+        die(f"invalid subnet: {e}")
+    hosts = list(net.hosts())
+    rows = [
+        {"key": "network", "value": str(net.network_address)},
+        {"key": "netmask", "value": str(net.netmask)},
+        {"key": "wildcard", "value": str(net.hostmask)},
+        {"key": "CIDR", "value": f"/{net.prefixlen}"},
+        {"key": "broadcast", "value": str(net.broadcast_address)},
+        {"key": "hosts", "value": str(len(hosts))},
+        {"key": "first host", "value": str(hosts[0]) if hosts else str(net.network_address)},
+        {"key": "last host", "value": str(hosts[-1]) if hosts else str(net.broadcast_address)},
+    ]
+    show(rows, ["key", "value"], args.json, title=f"Subnet: {net}")
+
+
+def http_get(url, timeout):
+    req = urllib.request.Request(url, headers={"User-Agent": f"netool/{VERSION}"})
+    with urllib.request.urlopen(req, timeout=timeout) as r:
+        return r.read()
+
+
+def cmd_publicip(args):
+    ip = None
+    for u in ("https://api.ipify.org", "https://ifconfig.me/ip", "https://ipinfo.io/ip"):
+        try:
+            raw = http_get(u, args.timeout)
+            candidate = raw.decode("utf-8", "replace").strip()
+            if is_ip(candidate):
+                ip = candidate
+                break
+        except OSError:
+            continue
+    if not ip:
+        die("could not determine public IP address (offline or blocked?)")
+    rows = [{"key": "public IP", "value": ip}]
+    try:
+        geo = json.loads(http_get("http://ip-api.com/json/" + ip, args.timeout))
+        for k in ("country", "regionName", "city", "isp", "org", "as", "timezone"):
+            v = geo.get(k)
+            if v:
+                rows.append({"key": k, "value": str(v)})
+        if geo.get("lat") is not None and geo.get("lon") is not None:
+            rows.append({"key": "location", "value": f"{geo['lat']},{geo['lon']}"})
+    except (OSError, ValueError):
+        pass
+    show(rows, ["key", "value"], args.json, title="Public IP")
+
+
+class RedirectRecorder(urllib.request.HTTPRedirectHandler):
+    def __init__(self):
+        self.chain = []
+
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        self.chain.append((code, newurl))
+        return super().redirect_request(req, fp, code, msg, headers, newurl)
+
+
+def cmd_http(args):
+    recorder = RedirectRecorder()
+    opener = urllib.request.build_opener(recorder)
+    req = urllib.request.Request(args.url, method=args.method, headers={"User-Agent": f"netool/{VERSION}"})
+    t0 = time.time()
+    rows = []
+    try:
+        with opener.open(req, timeout=args.timeout) as r:
+            rows.append({"key": "url", "value": r.geturl()})
+            rows.append({"key": "status", "value": green(str(r.status))})
+            rows.append({"key": "reason", "value": str(r.reason)})
+            rows.append({"key": "total time", "value": f"{round((time.time() - t0) * 1000)} ms"})
+            for h in ("content-length", "content-type", "server", "date", "location"):
+                if r.headers.get(h):
+                    rows.append({"key": h, "value": r.headers.get(h)})
+    except urllib.error.HTTPError as e:
+        rows.append({"key": "url", "value": args.url})
+        rows.append({"key": "status", "value": red(str(e.code))})
+        rows.append({"key": "reason", "value": str(e.reason)})
+        rows.append({"key": "total time", "value": f"{round((time.time() - t0) * 1000)} ms"})
+        for h in ("content-type", "server", "date"):
+            if e.headers.get(h):
+                rows.append({"key": h, "value": e.headers.get(h)})
+    except urllib.error.URLError as e:
+        rows = [{"key": "url", "value": args.url}, {"key": "error", "value": red(str(e.reason))}]
+    for code, newurl in recorder.chain:
+        rows.append({"key": f"redirect {code}", "value": newurl})
+    show(rows, ["key", "value"], args.json, title="HTTP check")
+
+
+def probe_icmp_once(ip, timeout):
+    sock = icmp_socket()
+    sock.settimeout(timeout)
+    try:
+        ident = os.getpid() & 0xFFFF
+        payload = struct.pack("!d", time.time()) + b"\x00" * 24
+        pkt = struct.pack("!BBHHH", 8, 0, 0, ident, 0) + payload
+        pkt = struct.pack("!BBHHH", 8, 0, icmp_checksum(pkt), ident, 0) + payload
+        t0 = time.time()
+        sock.sendto(pkt, (ip, 0))
+        data, _addr = sock.recvfrom(1024)
+        rtype, _rc, _cs, rid, _rseq = struct.unpack_from("!BBHHH", data, 20)
+        if rid == ident and rtype == 0:
+            return (time.time() - t0) * 1000
+        return None
+    except socket.timeout:
+        return None
+    finally:
+        sock.close()
+
+
+def probe_host(ip, args, use_icmp):
+    if use_icmp:
+        try:
+            return probe_icmp_once(ip, args.timeout)
+        except PermissionError:
+            return None
+    t0 = time.time()
+    try:
+        with socket.create_connection((ip, args.port or 80), timeout=args.timeout):
+            return (time.time() - t0) * 1000
+    except OSError:
+        return None
+
+
+def probe_http_once(url, timeout):
+    t0 = time.time()
+    try:
+        with urllib.request.urlopen(url, timeout=timeout) as r:
+            return (time.time() - t0) * 1000, r.status
+    except urllib.error.HTTPError as e:
+        return (time.time() - t0) * 1000, e.code
+    except OSError:
+        return None, None
+
+
+def cmd_monitor(args):
+    if args.mode == "http":
+        url = args.url
+        print(bold(f"Monitoring {url} every {args.interval}s (Ctrl-C to stop)"))
+        up = down = 0
+        rtts = []
+        n = 0
+        try:
+            while True:
+                n += 1
+                ts = time.strftime("%H:%M:%S")
+                rtt, code = probe_http_once(url, args.timeout)
+                if rtt is None:
+                    down += 1
+                    print(f"{ts}  {url}  {red('DOWN')}", flush=True)
+                else:
+                    up += 1
+                    rtts.append(rtt)
+                    print(f"{ts}  {url}  {green('UP')}  {rtt:.0f} ms (HTTP {code})", flush=True)
+                if args.count and n >= args.count:
+                    break
+                time.sleep(args.interval)
+        except KeyboardInterrupt:
+            pass
+        print_monitor_summary(up, down, rtts)
+        return
+
+    ip = resolve_host(args.host)
+    use_icmp = args.mode != "tcp"
+    if use_icmp:
+        try:
+            icmp_socket().close()
+        except PermissionError:
+            print(yellow("raw ICMP needs root; using TCP connect ping"))
+            use_icmp = False
+    kind = "ICMP" if use_icmp else f"TCP:{args.port or 80}"
+    print(bold(f"Monitoring {ip} ({kind}) every {args.interval}s (Ctrl-C to stop)"))
+    up = down = 0
+    rtts = []
+    n = 0
+    try:
+        while True:
+            n += 1
+            ts = time.strftime("%H:%M:%S")
+            rtt = probe_host(ip, args, use_icmp)
+            if rtt is None:
+                down += 1
+                print(f"{ts}  {ip}  {red('DOWN')}", flush=True)
+            else:
+                up += 1
+                rtts.append(rtt)
+                print(f"{ts}  {ip}  {green('UP')}  {rtt:.1f} ms", flush=True)
+            if args.count and n >= args.count:
+                break
+            time.sleep(args.interval)
+    except KeyboardInterrupt:
+        pass
+    print_monitor_summary(up, down, rtts)
+
+
+def print_monitor_summary(up, down, rtts):
+    total = up + down
+    loss = (down / total * 100) if total else 0
+    line = f"summary: {up} up, {down} down, loss {loss:.0f}%"
+    if rtts:
+        line += f", min/avg/max = {min(rtts):.1f}/{sum(rtts) / len(rtts):.1f}/{max(rtts):.1f} ms"
+    print(dim(line))
+
+
+def cmd_mtr(args):
+    ip = resolve_host(args.host)
+    path = shutil.which("mtr")
+    if path:
+        print(dim("using system mtr"))
+        subprocess.call([path, "--report", "--report-cycles", str(args.count), "-m", str(args.hops), ip])
+        return
+    try:
+        icmp_socket().close()
+    except PermissionError:
+        die("mtr requires raw ICMP (run with sudo) or the 'mtr' binary")
+
+    recv = icmp_socket()
+    recv.settimeout(args.timeout)
+    hops = []
+    try:
+        for ttl in range(1, args.hops + 1):
+            port = min(33434 + ttl - 1, 33534)
+            snd = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            snd.setsockopt(socket.IPPROTO_IP, socket.IP_TTL, ttl)
+            snd.settimeout(args.timeout)
+            snd.sendto(b"", (ip, port))
+            reached = False
+            try:
+                data, addr = recv.recvfrom(1024)
+                rtype = data[20]
+                code = data[21]
+                hops.append((ttl, addr[0] if addr else None))
+                if rtype == 3 and code == 3:
+                    reached = True
+            except socket.timeout:
+                hops.append((ttl, None))
+            snd.close()
+            if reached:
+                break
+    finally:
+        recv.close()
+
+    rows = []
+    for ttl, hop in hops:
+        if hop is None:
+            rows.append({"ttl": ttl, "hop": "*", "loss": "100%", "min": "", "avg": "", "max": ""})
+            continue
+        ident = (os.getpid() + ttl) & 0xFFFF
+        rtts, ok = icmp_probe(hop, ident, args.count, args.timeout, 0)
+        loss = (1 - ok / args.count) * 100 if args.count else 0
+        row = {"ttl": ttl, "hop": hop, "loss": f"{loss:.0f}%"}
+        if rtts:
+            row.update({"min": f"{min(rtts):.1f}", "avg": f"{sum(rtts) / len(rtts):.1f}", "max": f"{max(rtts):.1f}"})
+        else:
+            row.update({"min": "", "avg": "", "max": ""})
+        rows.append(row)
+    show(rows, ["ttl", "hop", "loss", "min", "avg", "max"], args.json, title=f"mtr {ip}")
+
+
+def build_parser():
+    p = argparse.ArgumentParser(
+        prog="netool",
+        description="All-around networking toolkit: ping, traceroute, port scan, DNS, whois, and more.",
+        epilog="Examples:\n"
+               "  netool ping example.com\n"
+               "  netool scan 192.168.1.1-20 --ports 22,80,443 -s\n"
+               "  netool dns example.com --type MX\n"
+               "  netool subnet 192.168.1.0/24\n"
+               "  netool monitor 8.8.8.8 --count 20 --interval 2",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    p.add_argument("--version", action="version", version=f"netool {VERSION}")
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--json", action="store_true", help="emit JSON output")
+    common.add_argument("--timeout", type=float, default=3.0, metavar="S", help="socket timeout in seconds (default 3)")
+    common.add_argument("--no-color", action="store_true", help="disable colored output (also honors NO_COLOR env)")
+
+    sub = p.add_subparsers(dest="command", required=True, metavar="CMD")
+
+    sp = sub.add_parser("ping", parents=[common], help="ping a host (ICMP if root, else TCP)",
+                         description="Ping a host with ICMP echo requests (requires root) or TCP connect as fallback.")
+    sp.add_argument("host")
+    sp.add_argument("-c", "--count", type=int, default=4, help="number of probes (default 4)")
+    sp.add_argument("-i", "--interval", type=float, default=1.0, help="seconds between probes (default 1)")
+    sp.add_argument("--port", type=int, help="TCP port for fallback ping (default 80)")
+    sp.add_argument("--tcp", action="store_true", help="force TCP connect ping")
+    sp.set_defaults(func=cmd_ping)
+
+    sp = sub.add_parser("trace", parents=[common], help="traceroute to a host (ICMP/UDP)",
+                         description="Trace the network path to a host using raw ICMP/UDP probes (requires root).")
+    sp.add_argument("host")
+    sp.add_argument("-m", "--hops", type=int, default=30, help="max hops (default 30)")
+    sp.set_defaults(func=cmd_trace)
+
+    sp = sub.add_parser("scan", parents=[common], help="TCP port scanner",
+                         description="Scan hosts and ports for open TCP services (concurrent connect scans).")
+    sp.add_argument("target", help="IP, hostname, CIDR, or range like 192.168.1.1-20")
+    sp.add_argument("--ports", default="22,80,443,3389,8000,8080,8888",
+                     help="ports or ranges, e.g. 1-1000,22,443 (default common set)")
+    sp.add_argument("-T", "--threads", type=int, default=150, help="concurrent threads (default 150)")
+    sp.add_argument("-a", "--all", action="store_true", help="also show closed/filtered ports")
+    sp.add_argument("-s", "--service", action="store_true", help="guess service name per port")
+    sp.set_defaults(func=cmd_scan)
+
+    sp = sub.add_parser("dns", parents=[common], help="DNS lookup",
+                         description="Query DNS records (A, AAAA, MX, NS, TXT, CNAME, PTR, SOA) over UDP.")
+    sp.add_argument("qname", help="domain or hostname to resolve")
+    sp.add_argument("-t", "--type", default="A", help="record type (default A)")
+    sp.add_argument("--server", help="DNS server to query (default: system resolver)")
+    sp.set_defaults(func=cmd_dns)
+
+    sp = sub.add_parser("whois", parents=[common], help="WHOIS lookup",
+                         description="WHOIS a domain or IP address via IANA referral querying.")
+    sp.add_argument("query", help="domain or IP to look up")
+    sp.set_defaults(func=cmd_whois)
+
+    sp = sub.add_parser("netinfo", parents=[common], help="local network interface info",
+                         description="Show local interfaces, IPs, MACs, MTU, routes, and DNS resolver.")
+    sp.set_defaults(func=cmd_netinfo)
+
+    sp = sub.add_parser("arp", parents=[common], help="show ARP/neighbor table",
+                         description="Display the kernel ARP/neighbor table (local network devices seen so far).")
+    sp.add_argument("--state", choices=["reachable", "incomplete"], help="filter by state")
+    sp.set_defaults(func=cmd_arp)
+
+    sp = sub.add_parser("subnet", parents=[common], help="subnet calculator",
+                         description="Calculate network/broadcast/host ranges for a CIDR or address+mask.")
+    sp.add_argument("address", nargs="+", help="CIDR (e.g. 192.168.1.0/24) OR address + netmask")
+    sp.set_defaults(func=cmd_subnet)
+
+    sp = sub.add_parser("publicip", parents=[common], help="show public IP and geolocation",
+                         description="Determine your public IP and physical/ASN details.")
+    sp.set_defaults(func=cmd_publicip)
+
+    sp = sub.add_parser("http", parents=[common], help="HTTP(S) endpoint check",
+                         description="Check an HTTP/S endpoint: status, latency, headers, redirect chain.")
+    sp.add_argument("url", help="full URL, e.g. https://example.com")
+    sp.add_argument("-X", "--method", choices=["GET", "HEAD"], default="GET", help="HTTP method (default GET)")
+    sp.set_defaults(func=cmd_http)
+
+    sp = sub.add_parser("monitor", parents=[common], help="continuous reachability monitor",
+                         description="Continuously probe a host or URL and report up/down transitions with a summary.")
+    sp.add_argument("host", metavar="HOST_OR_URL", help="hostname/IP or URL for --mode http")
+    sp.add_argument("-i", "--interval", type=float, default=2.0, help="seconds between probes (default 2)")
+    sp.add_argument("-c", "--count", type=int, help="number of probes (default: run until Ctrl-C)")
+    sp.add_argument("-m", "--mode", choices=["ping", "tcp", "http"], default="ping",
+                     help="probe method (default ping)")
+    sp.add_argument("--port", type=int, help="TCP port for tcp mode (default 80)")
+    sp.add_argument("--url", help="URL to probe when using --mode http")
+    sp.set_defaults(func=cmd_monitor)
+
+    sp = sub.add_parser("mtr", parents=[common], help="combined trace + per-hop stats",
+                         description="Traceroute with per-hop ping statistics (loss + min/avg/max latency). "
+                                     "Requires root or the mtr binary.")
+    sp.add_argument("host")
+    sp.add_argument("-m", "--hops", type=int, default=16, help="max hops (default 16)")
+    sp.add_argument("-c", "--count", type=int, default=3, help="probes per hop (default 3)")
+    sp.set_defaults(func=cmd_mtr)
+
+    return p
+
+
+def main(argv=None):
+    args = build_parser().parse_args(argv)
+    if getattr(args, "no_color", False):
+        set_color(False)
+    socket.setdefaulttimeout(args.timeout)
+    args.func(args)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print(dim("\ninterrupted"), file=sys.stderr)
+        sys.exit(130)

netool-1.0.0.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: netool
+Version: 1.0.0
+Summary: All-around networking toolkit: ping, traceroute, port scan, DNS, whois, and more
+Home-page: https://github.com/anomalyco/netool
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# netool
+
+All-around networking toolkit: ping, traceroute, port scan, DNS, whois,
+subnet calculator, HTTP check, monitoring, and MTR.
+
+```bash
+pip install netool
+sudo netool ping example.com
+```

netool-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+netool-1.0.0.dist-info/METADATA,sha256=GFexZJnbgkDS5p8JVUi20TqmPlsPTeTZfP9fuffn7YE,459
+netool-1.0.0.dist-info/WHEEL,sha256=f2-saOBXThY-fMTWOm_Iz3HbdXDqKhZBDfXo8NY8k6Q,86
+netool-1.0.0.dist-info/entry_points.txt,sha256=8ofKUMyMRkThBOMaakcMC5ikUcL3N7dskFQZzxDk3AA,43
+netool-1.0.0.dist-info/top_level.txt,sha256=ePy4A6vnE4Z6Jj-Z-LYaaJF_cp6n_PJk_GiIgxYOnuU,7
+netool-1.0.0.dist-info/licenses/LICENSE,sha256=Vb5Hvm6QLOQ607bb-jg4-lq5FUNWFXP46zoCeG2rE2s,1061
+netool/__init__.py,sha256=NKWmdvVx3OPW9RHC0rCjcpArEUilDS5V6xs5NgAs3LQ,50
+netool/cli.py,sha256=2bnCMOhJLFIdQZsCm9bp7i9thbwQk1kg4ir0l-5v5Z4,36697
+netool/__main__.py,sha256=PLZ7nH2oNsnx9OsKoQmpzImbxfROX4SNCxzNoRID0I0,66
+netool-1.0.0.dist-info/RECORD,,

netool-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: handclean 1.0.0
+Root-Is-Purelib: true
+Tag: py3-none-any

netool-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+netool = netool.cli:main

netool-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 gavin
+
+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.

netool-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+netool