mirror of
https://github.com/aclist/dztui.git
synced 2026-08-25 17:32:36 +02:00
473 lines
11 KiB
Python
473 lines
11 KiB
Python
import json
|
|
import math
|
|
import os
|
|
import re
|
|
import socket
|
|
import subprocess
|
|
import sys
|
|
import typing # noqa
|
|
|
|
from dataclasses import dataclass
|
|
from urllib import request, parse
|
|
from urllib.error import HTTPError
|
|
from typing import Union
|
|
|
|
sys.path.append("a2s")
|
|
import a2s # noqa
|
|
from a2s import dayzquery # noqa
|
|
|
|
params = [
|
|
r"\nor\1\map\chernarusplus\nor\1\map\sakhal\nor\1\map\enoch\empty\1\nor\1\map\namalsk", # noqa
|
|
r"\map\namalsk\empty\1",
|
|
r"\map\namalsk\noplayers\1",
|
|
r"\map\chernarusplus\empty\1",
|
|
r"\map\chernarusplus\noplayers\1",
|
|
r"\map\sakhal\empty\1",
|
|
r"\map\sakhal\noplayers\1",
|
|
r"\map\enoch\empty\1",
|
|
r"\map\enoch\noplayers\1",
|
|
]
|
|
|
|
|
|
class BmAPIError(Exception):
|
|
pass
|
|
|
|
|
|
class BmIdError(Exception):
|
|
pass
|
|
|
|
|
|
class InvalidIpError(Exception):
|
|
pass
|
|
|
|
|
|
def get_netmask() -> str:
|
|
hostname = os.uname()[1]
|
|
i = socket.gethostbyname(hostname)
|
|
netmask = i.rsplit(".", 1)[0]
|
|
return netmask
|
|
|
|
|
|
def test_ip(suffix: int, port: int) -> dict | None:
|
|
netmask = get_netmask()
|
|
hostname = f"{netmask}.{str(suffix)}"
|
|
ping = ["ping", "-c1", "-i", "0.1", "-w", "1"]
|
|
output = subprocess.run(ping + [hostname], capture_output=True)
|
|
if output.returncode == 0:
|
|
return query_direct(hostname, port)
|
|
return None
|
|
|
|
|
|
def sanitize(name: str) -> str:
|
|
name = re.sub(r"\r", r"", name)
|
|
name = re.sub(r"\n", r"", name)
|
|
name = re.sub(r"\x01", r"", name)
|
|
name = re.sub(r"\ufeff", r"", name)
|
|
name = re.sub(r"(^!\s*)", r"-", name)
|
|
name = re.sub(r"(^-\s*)", r"", name)
|
|
name = re.sub(r"(^-)", r"", name)
|
|
name = re.sub(r"(^\s*)", r"", name)
|
|
name = re.sub(r"\t", "", name)
|
|
return name
|
|
|
|
|
|
def parse_json(json: list) -> list:
|
|
"""
|
|
Server metadata is underspecified and server operators
|
|
tend to insert random garbage in the headers. In case
|
|
sanitization failed, discard malformed rows rather than
|
|
aborting outright.
|
|
"""
|
|
rows = []
|
|
for row in json:
|
|
try:
|
|
name = sanitize(row["name"])
|
|
if name == "":
|
|
continue
|
|
except KeyError:
|
|
continue
|
|
|
|
malformed = False
|
|
for key in [
|
|
"map",
|
|
"gametype",
|
|
"players",
|
|
"max_players",
|
|
"addr",
|
|
"gameport",
|
|
]:
|
|
try:
|
|
row[key]
|
|
except KeyError:
|
|
malformed = True
|
|
break
|
|
|
|
if malformed is True:
|
|
continue
|
|
|
|
try:
|
|
r = row["gametype"].split(",")
|
|
except KeyError:
|
|
continue
|
|
|
|
if "no3rd" in r:
|
|
view = "1PP"
|
|
else:
|
|
view = "3PP"
|
|
|
|
if "external" in r:
|
|
provider = "Unoffic."
|
|
else:
|
|
provider = "Official"
|
|
|
|
if "mod" in r:
|
|
modded = True
|
|
else:
|
|
modded = False
|
|
|
|
try:
|
|
r = row["gametype"].split("lqs")
|
|
queue = r[1].split(",")[0]
|
|
except IndexError:
|
|
queue = 0
|
|
|
|
try:
|
|
test_time = re.search(r"[0-9]{2}:[0-9]{2}", row["gametype"])
|
|
if test_time:
|
|
time = test_time.group(0)
|
|
else:
|
|
time = "Unknown"
|
|
except AttributeError:
|
|
time = "Unknown"
|
|
|
|
try:
|
|
ip = row["addr"].split(":")[0] + ":" + str(row["gameport"])
|
|
qport = row["addr"].split(":")[1]
|
|
except IndexError:
|
|
continue
|
|
|
|
try:
|
|
ping = row["ping"]
|
|
except KeyError:
|
|
ping = 9999
|
|
|
|
mapname = row["map"].lower()
|
|
players = row["players"]
|
|
max_players = row["max_players"]
|
|
raw = [
|
|
name,
|
|
mapname,
|
|
view,
|
|
time,
|
|
int(players),
|
|
int(max_players),
|
|
int(queue),
|
|
ip,
|
|
int(qport),
|
|
ping,
|
|
provider,
|
|
modded,
|
|
]
|
|
rows.append(raw)
|
|
return rows
|
|
|
|
|
|
def query_direct(ip: str, qport: int, TIMEOUT: float=3.0) -> dict | None:
|
|
try:
|
|
info = a2s.info((ip, qport), TIMEOUT)
|
|
|
|
name = info.server_name
|
|
mapname = info.map_name
|
|
address = ip + ":" + str(qport)
|
|
gameport = str(info.port)
|
|
players = info.player_count
|
|
max_players = info.max_players
|
|
keywords = info.keywords
|
|
|
|
try:
|
|
ping = info.ping
|
|
ping = math.floor(info.ping * 1000)
|
|
except AttributeError:
|
|
ping = 9999
|
|
|
|
res = {}
|
|
res["name"] = name
|
|
res["map"] = mapname
|
|
res["gametype"] = keywords
|
|
res["players"] = players
|
|
res["max_players"] = max_players
|
|
res["addr"] = address
|
|
res["gameport"] = gameport
|
|
res["ping"] = ping
|
|
return res
|
|
except TimeoutError:
|
|
return None
|
|
except KeyError:
|
|
return None
|
|
|
|
|
|
@dataclass(slots=True, frozen=True)
|
|
class Res:
|
|
status: int
|
|
parsed: bool
|
|
json: Union[str, None]
|
|
|
|
|
|
@dataclass(slots=True, frozen=True)
|
|
class Ping:
|
|
addr: str
|
|
iteration: int
|
|
ping: int
|
|
|
|
|
|
@dataclass(slots=True, frozen=True)
|
|
class Details:
|
|
data: Union[list, None]
|
|
description: str
|
|
success: bool
|
|
|
|
|
|
@dataclass(slots=True, frozen=True)
|
|
class Prereqs:
|
|
password: bool
|
|
gameport: int
|
|
appid: Union[int, None]
|
|
version: Union[str, None]
|
|
|
|
|
|
@dataclass(slots=True)
|
|
class Record:
|
|
"""
|
|
The gameport field is manipulated by the RowType.CONN_BY_IP method
|
|
"""
|
|
ip: str
|
|
gameport: int
|
|
qport: int
|
|
|
|
|
|
def get_prereqs(ip: str, qport: int) -> Prereqs:
|
|
try:
|
|
info = a2s.info((ip, qport))
|
|
except TimeoutError:
|
|
return Prereqs(False, 0, None, None)
|
|
|
|
gameport = getattr(info, "port", 0)
|
|
is_password = getattr(info, "password_protected", False)
|
|
appid = getattr(info, "game_id", None)
|
|
version = getattr(info, "version", None)
|
|
|
|
return Prereqs(is_password, gameport, appid, version)
|
|
|
|
|
|
def details(ip: str, qport: int) -> Details:
|
|
default_str = "None provided"
|
|
|
|
try:
|
|
info = a2s.info((ip, qport))
|
|
except TimeoutError:
|
|
return Details(None, default_str, False)
|
|
try:
|
|
rules = dayzquery.dayz_rules((ip, int(qport)))
|
|
except TimeoutError:
|
|
return Details(None, default_str, False)
|
|
|
|
try:
|
|
keywords = info.keywords.split(",")
|
|
except AttributeError:
|
|
return Details(None, default_str, False)
|
|
|
|
battleye = "Disabled"
|
|
if "battleye" in keywords:
|
|
battleye = "Enabled"
|
|
|
|
day_accel = 0.0
|
|
night_accel = 0.0
|
|
for keyword in keywords:
|
|
if "etm" in keyword:
|
|
day_accel = float(keyword.lstrip("etm"))
|
|
day_accel = float(f"{day_accel:g}")
|
|
if "entm" in keywords:
|
|
night_accel = float(keyword.lstrip("entm"))
|
|
night_accel = float(f"{night_accel:g}")
|
|
|
|
try:
|
|
password = info.password_protected
|
|
if password is False:
|
|
password = "Disabled"
|
|
else:
|
|
password = "Enabled"
|
|
except AttributeError:
|
|
password = "-"
|
|
|
|
try:
|
|
vac = info.vac_enabled
|
|
if vac is False:
|
|
vac = "Disabled"
|
|
else:
|
|
vac = "Enabled"
|
|
except AttributeError:
|
|
vac = "-"
|
|
|
|
try:
|
|
version = info.version
|
|
except AttributeError:
|
|
version = "-"
|
|
|
|
try:
|
|
dlc = rules.dlc_flags
|
|
if dlc == 0:
|
|
dlc = "None"
|
|
if dlc == 2:
|
|
dlc = "Frostline"
|
|
except AttributeError:
|
|
dlc = "not specified"
|
|
|
|
try:
|
|
platform = rules.platform
|
|
if platform == "win":
|
|
platform = "Windows"
|
|
if platform == "?":
|
|
platform = "Linux"
|
|
except AttributeError:
|
|
platform = "not specified"
|
|
|
|
try:
|
|
description = rules.description.strip()
|
|
if description == "":
|
|
description = default_str
|
|
except AttributeError:
|
|
description = default_str
|
|
|
|
rows = [
|
|
["Battleye", battleye],
|
|
["Daytime acceleration", f"{day_accel}x"],
|
|
["DLC", dlc],
|
|
["Night-time acceleration", f"{night_accel}x"],
|
|
["Password", password],
|
|
["Platform", platform],
|
|
["Valve Anti-Cheat", vac],
|
|
["Version", version],
|
|
]
|
|
|
|
return Details(rows, description, True)
|
|
|
|
|
|
def ping(iteration: int, row: list) -> Ping:
|
|
addr = row[7]
|
|
qport = row[8]
|
|
|
|
res = None
|
|
|
|
if row[9] != 9999:
|
|
return Ping(addr, iteration, row[9])
|
|
|
|
try:
|
|
ip = addr.split(":")[0]
|
|
except IndexError:
|
|
ping = 9999
|
|
|
|
try:
|
|
res = query_direct(ip, qport, 0.5)
|
|
except Exception:
|
|
pass
|
|
|
|
if res is None:
|
|
ping = 9999
|
|
else:
|
|
ping = res["ping"]
|
|
|
|
return Ping(addr, iteration, ping)
|
|
|
|
|
|
def query_api(key: str, appid: int, param: str) -> Res:
|
|
LIMIT = 10000
|
|
url = "https://api.steampowered.com/IGameServersService/GetServerList/v1/?"
|
|
|
|
payload: dict[str, Union[int, str]] = {
|
|
"filter": r"\appid" + fr"\{appid}" + param,
|
|
"limit": LIMIT,
|
|
"key": key,
|
|
}
|
|
par = parse.urlencode(payload)
|
|
url = f"{url}{par}"
|
|
|
|
status = 200
|
|
parsed = True
|
|
data = None
|
|
|
|
try:
|
|
with request.urlopen(url) as response:
|
|
if response.status != 200:
|
|
status = response.status
|
|
try:
|
|
parsed = True
|
|
data = json.load(response)
|
|
except json.decoder.JSONDecodeError:
|
|
parsed = False
|
|
data = None
|
|
except HTTPError:
|
|
status = 403
|
|
parsed = False
|
|
data = None
|
|
finally:
|
|
return Res(status, parsed, data)
|
|
|
|
|
|
def query_bm_api(api_key: str, bm_id: str) -> Record:
|
|
if bm_id.isnumeric() is False:
|
|
raise BmIdError("ID must be numeric only")
|
|
|
|
payload: dict[str, Union[int, str]] = {
|
|
"sort": "-players",
|
|
"filter[game]": "dayz",
|
|
"filter[ids][whitelist]": bm_id,
|
|
}
|
|
|
|
url = "https://api.battlemetrics.com/servers?"
|
|
par = parse.urlencode(payload)
|
|
url = f"{url}{par}"
|
|
|
|
hdr = {"Authorization": "Bearer " + api_key}
|
|
r = request.Request(url, headers=hdr)
|
|
|
|
try:
|
|
with request.urlopen(r) as response:
|
|
try:
|
|
j = json.load(response)
|
|
except json.decoder.JSONDecodeError:
|
|
raise BmAPIError("Malformed response from Battlemetrics")
|
|
|
|
if len(j["data"]) < 1:
|
|
raise BmAPIError("Not a valid Battlemetrics ID")
|
|
j = j["data"][0]["attributes"]
|
|
return Record(j["ip"], j["port"], j["portQuery"])
|
|
except HTTPError:
|
|
raise BmAPIError("Failed to query Battlemetrics")
|
|
|
|
|
|
def validate_ip(addr: str) -> Record:
|
|
fields = addr.split(":")
|
|
if len(fields) != 2:
|
|
raise InvalidIpError("Address must be formatted as IP:Queryport")
|
|
|
|
ip = fields[0]
|
|
port = fields[1]
|
|
|
|
try:
|
|
int(port)
|
|
except ValueError:
|
|
raise InvalidIpError(f"'{port}' is not a valid port")
|
|
|
|
if int(port) > 65535 or int(port) < 0:
|
|
raise InvalidIpError(f"'{port}' is not a valid port")
|
|
|
|
try:
|
|
socket.inet_aton(ip)
|
|
except OSError:
|
|
raise InvalidIpError(f"'{ip}' is not a valid IP")
|
|
|
|
ip = addr.split(":")[0]
|
|
qport = int(addr.split(":")[1])
|
|
record = Record(ip, 0, qport)
|
|
return record
|