fix: decrypt DAL reads, read the uplink and facts from the gateway's answers #31
No files matched your search
+27
-3
@@ -13,13 +13,37 @@ All notable changes to this driver. The format follows
|
||||
3.12 venv no longer has.
|
||||
|
||||
### Fixed
|
||||
- `get_wan_status()` reports the gateway's uplink as the gateway does (#29). It read
|
||||
`WanIp`, `WanAccessType`, `SystemUpTime`, `MaxUpstream` and `MaxDownstream` from
|
||||
`getBasicInformation`, which a VMG4005-B50A does not send them in, and reported
|
||||
every uplink as down, with no address and no sync rate. It now reads the DAL's
|
||||
`cardpage_status`: a bridge is connected when its DSL line is in sync and has no
|
||||
external address of its own; a router is connected when a WAN interface that is
|
||||
not a bridge is up with an address, which is then `external_ip`. `link_status` is
|
||||
`"Up"` while the DSL line is in sync, the sync rates are those of the channels in
|
||||
sync (added up for bonded lines), and `connection_type` is `"DSL"` for a bridge,
|
||||
the WAN's encapsulation (`"PPPoE"`, `"IPoE"`) for a router. Byte counters are not
|
||||
read and stay `0`.
|
||||
- `get_nat_translations()` translates to the gateway's WAN address from the same page,
|
||||
and to `0.0.0.0` when it has none; it reported `":<port>"` (#29).
|
||||
- `get_hosts()`, `get_arp_table()` and `get_port_forwards()` report what the gateway
|
||||
has (#25). They parsed the DAL's answer without decrypting it, found none of their
|
||||
keys in the sealed envelope and reported nothing, on every gateway; the Wi-Fi
|
||||
getters did the same. Every DAL answer is now decrypted and read from its `Object`.
|
||||
Hosts come from `lanhosts` and port forwards from `nat`, the names the gateway's own
|
||||
web interface reads them by: the gateway answers the names the driver used
|
||||
(`LAN_HOSTS`, `NAT_PORTMAP`) like any name it does not know, with nothing. A host
|
||||
the gateway has no name for (`"Unknown"`) has the host name `""`, a host's
|
||||
interface type is `LAN` or `WLAN`, only a DHCP host reports the time left on its
|
||||
lease, a TCP-and-UDP forward is reported once per protocol, and a forward limited
|
||||
to one source address reports it as `remote_host`.
|
||||
- `get_facts()` reports the gateway's serial number and uptime (#27). It read them
|
||||
from `getBasicInformation`, which a VMG4005-B50A does not send them in, and reported
|
||||
`""` and `0`. They now come from `DeviceInfo` in the DAL's `cardpage_status`, the
|
||||
answer the interfaces are read from; `get_facts()` reads that answer once for both.
|
||||
- `get_facts()` reports the gateway's host name and domain: `hostname` is the name on
|
||||
the gateway's System page (`GET /cgi-bin/System?oid=snmp`), `fqdn` that name with its
|
||||
domain (`VMG4005-B50A.home`). Both were read from `getBasicInformation`, which a
|
||||
- `get_facts()` reports the gateway's host name and domain (#24): `hostname` is the
|
||||
name on the gateway's System page (`GET /cgi-bin/System?oid=snmp`), `fqdn` that name
|
||||
with its domain (`VMG4005-B50A.home`). Both were read from `getBasicInformation`, which a
|
||||
VMG4005-B50A does not send them in, so they fell back to the address the driver
|
||||
connects to and netOrk kept the device named `192.168.1.1`. A gateway with no name
|
||||
set reports `""`; `get_facts()` raises when the System page cannot be read.
|
||||
|
||||
@@ -35,18 +35,23 @@ with driver("192.0.2.1", "admin", "secret", optional_args={"use_tls": True}) as
|
||||
|
||||
| Getter / action | Source |
|
||||
|---|---|
|
||||
| `get_facts` | basic device information |
|
||||
| `get_facts` | basic device information (model, firmware), the System page (host name, domain), DAL `cardpage_status` (serial number, uptime, interfaces) |
|
||||
| `get_interfaces`, `get_interfaces_ip` | basic device information (WAN, LAN, Wi-Fi) |
|
||||
| `get_arp_table` | derived from the active LAN hosts |
|
||||
| `get_wan_status` | basic device information |
|
||||
| `get_hosts` | DAL `LAN_HOSTS`, else the DHCP page |
|
||||
| `get_port_forwards`, `get_nat_translations` | DAL `NAT_PORTMAP`, else the status page |
|
||||
| `get_wan_status` | DAL `cardpage_status`: the DSL line and the WAN interfaces |
|
||||
| `get_hosts` | DAL `lanhosts`, else the DHCP page |
|
||||
| `get_port_forwards`, `get_nat_translations` | DAL `nat`, else the status page |
|
||||
| `get_wireless_clients`, `get_ssids`, `get_radio_status` | DAL, else the wireless page |
|
||||
| `get_diagnostics` | DAL `DIAGNOSTICS` |
|
||||
| `is_alive` | the session is open and the web port answers; without a session `False`, no connection |
|
||||
| `reboot_host` | DAL `REBOOT` |
|
||||
| `restart_wifi` | DAL `WIFI_RESTART` |
|
||||
|
||||
Every DAL answer is read the way the gateway sends it: AES-encrypted, with its data
|
||||
under `Object`. The Wi-Fi getters read `WIFI_CLIENTS`, `WIFI_SSIDS` and `WIFI_RADIO`,
|
||||
names that have not been checked against a gateway with Wi-Fi yet; a VMG4005-B50A
|
||||
has no Wi-Fi.
|
||||
|
||||
## Not supported
|
||||
|
||||
Configuration changes (`load_merge_candidate` and `load_replace_candidate` raise
|
||||
|
||||
@@ -0,0 +1,149 @@
|
||||
"""Pure parsers: the gateway's decrypted DAL answers in, NAPALM's typed dicts out."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
from napalm_device_types.models import HostDict, PortForwardDict, WANStatusDict
|
||||
|
||||
#: The name ``lanhosts`` gives a host the gateway has no name for.
|
||||
_UNKNOWN_HOST = "Unknown"
|
||||
|
||||
#: ``Protocol`` of a ``nat`` rule, as the protocols it forwards.
|
||||
_FORWARD_PROTOCOLS = {"TCP": ("TCP",), "UDP": ("UDP",), "ALL": ("TCP", "UDP")}
|
||||
|
||||
|
||||
def _host(entry: dict[str, Any]) -> HostDict:
|
||||
"""One host of the DAL's ``lanhosts`` answer."""
|
||||
name = str(entry.get("HostName") or "")
|
||||
connection = str(entry.get("X_ZYXEL_ConnectionType") or "")
|
||||
host: HostDict = {
|
||||
"mac": str(entry.get("PhysAddress") or "").lower(),
|
||||
"ip": str(entry.get("IPAddress") or ""),
|
||||
"hostname": "" if name == _UNKNOWN_HOST else name,
|
||||
"interface_type": "WLAN" if "Wi-Fi" in connection else "LAN",
|
||||
"is_active": bool(entry.get("Active")),
|
||||
}
|
||||
if entry.get("AddressSource") == "DHCP":
|
||||
host["lease_time_remaining"] = int(entry.get("LeaseTimeRemaining") or 0)
|
||||
return host
|
||||
|
||||
|
||||
def hosts(objects: list[dict[str, Any]]) -> list[HostDict]:
|
||||
"""The hosts of the DAL's ``lanhosts`` answer (``Object[].lanhosts[]``)."""
|
||||
return [
|
||||
_host(entry)
|
||||
for obj in objects
|
||||
for entry in obj.get("lanhosts") or []
|
||||
if isinstance(entry, dict)
|
||||
]
|
||||
|
||||
|
||||
def port_forwards(objects: list[dict[str, Any]]) -> list[PortForwardDict]:
|
||||
"""The rules of the DAL's ``nat`` answer, one per protocol they forward.
|
||||
|
||||
A port range is reported by its first port.
|
||||
"""
|
||||
forwards: list[PortForwardDict] = []
|
||||
for rule in objects:
|
||||
protocol = str(rule.get("Protocol") or "").upper()
|
||||
for proto in _FORWARD_PROTOCOLS.get(protocol, (protocol,)):
|
||||
forward: PortForwardDict = {
|
||||
"name": str(rule.get("Description") or ""),
|
||||
"protocol": proto,
|
||||
"external_port": int(rule.get("ExternalPortStart") or 0),
|
||||
"internal_ip": str(rule.get("InternalClient") or ""),
|
||||
"internal_port": int(rule.get("InternalPortStart") or 0),
|
||||
"enabled": bool(rule.get("Enable")),
|
||||
}
|
||||
if rule.get("SetOriginatingIP") and rule.get("OriginatingIpAddress"):
|
||||
forward["remote_host"] = str(rule["OriginatingIpAddress"])
|
||||
forwards.append(forward)
|
||||
return forwards
|
||||
|
||||
|
||||
def _channels_in_sync(page: dict[str, Any]) -> list[dict[str, Any]]:
|
||||
"""The DSL channels of a ``cardpage_status`` page that are in sync."""
|
||||
return [
|
||||
channel
|
||||
for channel in page.get("DslChannelInfo") or []
|
||||
if isinstance(channel, dict) and channel.get("Status") == "Up"
|
||||
]
|
||||
|
||||
|
||||
def _routed_wans(page: dict[str, Any]) -> list[dict[str, Any]]:
|
||||
"""The enabled WAN interfaces of a ``cardpage_status`` page that are not bridges."""
|
||||
return [
|
||||
entry
|
||||
for entry in page.get("WanLanInfo") or []
|
||||
if isinstance(entry, dict)
|
||||
and entry.get("X_ZYXEL_Type") == "WAN"
|
||||
and entry.get("Enable")
|
||||
and entry.get("X_ZYXEL_ConnectionType") != "IP_Bridged"
|
||||
]
|
||||
|
||||
|
||||
def _address(entry: dict[str, Any]) -> str:
|
||||
"""The first enabled IPv4 address of a ``WanLanInfo`` entry, else ``""``."""
|
||||
for addr in entry.get("IPv4Address") or []:
|
||||
if isinstance(addr, dict) and addr.get("Enable") and addr.get("IPAddress"):
|
||||
return str(addr["IPAddress"])
|
||||
return ""
|
||||
|
||||
|
||||
def _connected_wan(page: dict[str, Any]) -> dict[str, Any] | None:
|
||||
"""The routed WAN interface that is up with an address, if there is one."""
|
||||
for entry in _routed_wans(page):
|
||||
if entry.get("Status") == "Up" and _address(entry):
|
||||
return entry
|
||||
return None
|
||||
|
||||
|
||||
def wan_address(page: dict[str, Any]) -> str:
|
||||
"""The gateway's own WAN address on a ``cardpage_status`` page; ``""`` for a bridge
|
||||
or a router whose WAN is not up."""
|
||||
wan = _connected_wan(page)
|
||||
return _address(wan) if wan is not None else ""
|
||||
|
||||
|
||||
def _seconds(value: Any) -> int:
|
||||
"""*value* as a number of seconds; ``0`` (unknown) when it is not a number."""
|
||||
text = str(value if value is not None else "").strip()
|
||||
return int(text) if text.isdigit() else 0
|
||||
|
||||
|
||||
def _uplink(page: dict[str, Any], channels: list[dict[str, Any]]) -> tuple[bool, str, int]:
|
||||
"""Whether the uplink is connected, its type and how long it has been up."""
|
||||
routed = _routed_wans(page)
|
||||
if not routed: # a bridge: the DSL line is the uplink
|
||||
uptime = _seconds(channels[0].get("DSLUpTime")) if channels else 0
|
||||
return bool(channels), "DSL", uptime
|
||||
wan = _connected_wan(page)
|
||||
connection_type = str(routed[0].get("Encapsulation") or "")
|
||||
if wan is None:
|
||||
return False, connection_type, 0
|
||||
return True, connection_type, _seconds(wan.get("X_ZYXEL_UpTime"))
|
||||
|
||||
|
||||
def wan_status(page: dict[str, Any]) -> WANStatusDict:
|
||||
"""The uplink of a ``cardpage_status`` page.
|
||||
|
||||
A router (a WAN interface that is not ``IP_Bridged``) is connected when such an
|
||||
interface is up with an address. A bridge has no WAN address of its own: it is
|
||||
connected when its DSL line is in sync. The sync rates (kbit/s) are those of the
|
||||
channels in sync, added up for bonded lines; a channel out of sync keeps the rates
|
||||
of its last sync, which are not reported.
|
||||
"""
|
||||
channels = _channels_in_sync(page)
|
||||
connected, connection_type, uptime = _uplink(page, channels)
|
||||
return {
|
||||
"connection_type": connection_type,
|
||||
"is_connected": connected,
|
||||
"external_ip": wan_address(page),
|
||||
"uptime": uptime,
|
||||
"bytes_sent": 0,
|
||||
"bytes_received": 0,
|
||||
"max_bitrate_up": sum(int(c.get("UpstreamCurrRate") or 0) for c in channels),
|
||||
"max_bitrate_down": sum(int(c.get("DownstreamCurrRate") or 0) for c in channels),
|
||||
"link_status": "Up" if channels else "Down",
|
||||
}
|
||||
+83
-120
@@ -36,6 +36,8 @@ from napalm_device_types.models import (
|
||||
WirelessClientDict,
|
||||
)
|
||||
|
||||
from napalm_zyxel import parsers
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
#: Answers that mean the session is not (or no longer) accepted.
|
||||
@@ -43,6 +45,10 @@ _SESSION_REFUSED = (401, 403)
|
||||
|
||||
_T = TypeVar("_T")
|
||||
|
||||
#: The inside-global address of a port forward when the gateway has no WAN address
|
||||
#: (an address reported, not one bound to).
|
||||
_ANY_ADDRESS = "0.0.0.0" # nosec B104
|
||||
|
||||
_PING_UNSUPPORTED = "Not supported on Zyxel VMG: the DAL does not report ping replies"
|
||||
|
||||
|
||||
@@ -171,6 +177,10 @@ class ZyxelVMGDriver(ResidentialGatewayDriver):
|
||||
_BASIC_INFO_PATH = "getBasicInformation"
|
||||
_DAL_PATH = "cgi-bin/DAL"
|
||||
_SYSTEM_PATH = "cgi-bin/System?oid=snmp"
|
||||
_STATUS_OID = "cardpage_status"
|
||||
#: The DAL names the gateway's own web interface reads hosts and port forwards by.
|
||||
_HOSTS_OID = "lanhosts"
|
||||
_NAT_OID = "nat"
|
||||
|
||||
#: Discovery also fetches the DAL's key exchange, which answers without a login
|
||||
#: (``open()`` needs it). The port answering is no evidence; the answer is (#13).
|
||||
@@ -359,12 +369,46 @@ class ZyxelVMGDriver(ResidentialGatewayDriver):
|
||||
return ConnectionException(detail)
|
||||
return RuntimeError(detail)
|
||||
|
||||
def _unseal(self, text: str, what: str) -> Any:
|
||||
"""*text* as JSON, decrypted when the gateway sealed it as ``{"content", "iv"}``.
|
||||
|
||||
A GET of the DAL or the System page answers sealed, like a DAL PUT does (#25).
|
||||
"""
|
||||
if self._crypto is None:
|
||||
raise ConnectionClosedException("Not connected")
|
||||
try:
|
||||
answer = json.loads(text)
|
||||
if isinstance(answer, dict) and {"content", "iv"} <= answer.keys():
|
||||
answer = self._crypto.decrypt_response(answer)
|
||||
except (ValueError, TypeError, KeyError) as exc:
|
||||
raise RuntimeError(f"{what} on {self._base_url}: {exc}") from exc
|
||||
return answer
|
||||
|
||||
def _dal_get(self, oid: str) -> list[dict[str, Any]]:
|
||||
"""The ``Object`` list of the DAL's answer to a GET of *oid*, decrypted.
|
||||
|
||||
Raises when the request fails or the gateway does not answer ``ZCFG_SUCCESS``
|
||||
with an ``Object`` list. A name the gateway does not know is answered with an
|
||||
empty ``Object``, like a known one with nothing in it.
|
||||
"""
|
||||
what = f"DAL {oid}"
|
||||
answer = self._unseal(self._fetch_page(f"{self._DAL_PATH}?oid={oid}"), what)
|
||||
result = answer.get("result") if isinstance(answer, dict) else None
|
||||
objects = answer.get("Object") if result == "ZCFG_SUCCESS" else None
|
||||
if not isinstance(objects, list):
|
||||
raise RuntimeError(f"{what} on {self._base_url} answered {result!r}")
|
||||
return [obj for obj in objects if isinstance(obj, dict)]
|
||||
|
||||
def _read_dal_or_page(
|
||||
self, oid: str, page: str, parse_dal: Callable[[Any], _T], parse_page: Callable[[str], _T]
|
||||
self,
|
||||
oid: str,
|
||||
page: str,
|
||||
parse_dal: Callable[[list[dict[str, Any]]], _T],
|
||||
parse_page: Callable[[str], _T],
|
||||
) -> _T:
|
||||
"""The DAL's answer to *oid*, else the HTML *page*; raises when neither can be read."""
|
||||
try:
|
||||
return parse_dal(json.loads(self._fetch_page(f"cgi-bin/DAL?oid={oid}")))
|
||||
return parse_dal(self._dal_get(oid))
|
||||
except (ConnectionException, RuntimeError, ValueError, TypeError) as exc:
|
||||
logger.debug("DAL %s not read (%s), reading %s", oid, exc, page)
|
||||
return parse_page(self._fetch_page(page))
|
||||
@@ -397,15 +441,7 @@ class ZyxelVMGDriver(ResidentialGatewayDriver):
|
||||
|
||||
The answer is a one-entry list, sealed ``{"content", "iv"}`` like a DAL answer.
|
||||
"""
|
||||
text = self._fetch_page(self._SYSTEM_PATH)
|
||||
if self._crypto is None:
|
||||
raise ConnectionClosedException("Not connected")
|
||||
try:
|
||||
answer = json.loads(text)
|
||||
if isinstance(answer, dict) and {"content", "iv"} <= answer.keys():
|
||||
answer = self._crypto.decrypt_response(answer)
|
||||
except (ValueError, TypeError, KeyError) as exc:
|
||||
raise RuntimeError(f"{self._SYSTEM_PATH} on {self._base_url}: {exc}") from exc
|
||||
answer = self._unseal(self._fetch_page(self._SYSTEM_PATH), self._SYSTEM_PATH)
|
||||
if not isinstance(answer, list) or not answer or not isinstance(answer[0], dict):
|
||||
raise RuntimeError(f"{self._SYSTEM_PATH} on {self._base_url} answered {answer!r}")
|
||||
hostname, domain = (
|
||||
@@ -414,23 +450,10 @@ class ZyxelVMGDriver(ResidentialGatewayDriver):
|
||||
return hostname, domain
|
||||
|
||||
def _status_page(self) -> dict[str, Any]:
|
||||
"""The DAL's ``cardpage_status``, decrypted; raises when it cannot be read.
|
||||
|
||||
A GET of the DAL answers sealed, ``{"content", "iv"}``, like the PUT does.
|
||||
"""
|
||||
text = self._fetch_page("cgi-bin/DAL?oid=cardpage_status")
|
||||
if self._crypto is None:
|
||||
raise ConnectionClosedException("Not connected")
|
||||
try:
|
||||
answer = json.loads(text)
|
||||
if isinstance(answer, dict) and {"content", "iv"} <= answer.keys():
|
||||
answer = self._crypto.decrypt_response(answer)
|
||||
except (ValueError, TypeError, KeyError) as exc:
|
||||
raise RuntimeError(f"DAL cardpage_status on {self._base_url}: {exc}") from exc
|
||||
result = answer.get("result") if isinstance(answer, dict) else None
|
||||
objects = answer.get("Object") if result == "ZCFG_SUCCESS" else None
|
||||
if not objects or not isinstance(objects[0], dict):
|
||||
raise RuntimeError(f"DAL cardpage_status on {self._base_url} answered {result!r}")
|
||||
"""The DAL's ``cardpage_status``, decrypted; raises when it cannot be read."""
|
||||
objects = self._dal_get(self._STATUS_OID)
|
||||
if not objects:
|
||||
raise RuntimeError(f"DAL {self._STATUS_OID} on {self._base_url} answered no object")
|
||||
return objects[0]
|
||||
|
||||
def get_interfaces(self) -> dict[str, dict[str, Any]]:
|
||||
@@ -610,51 +633,20 @@ class ZyxelVMGDriver(ResidentialGatewayDriver):
|
||||
pass
|
||||
|
||||
def get_wan_status(self) -> WANStatusDict:
|
||||
"""Return WAN connection status from cached device info."""
|
||||
info = self._device_info or {}
|
||||
wan_ip = info.get("WanIp", "")
|
||||
return {
|
||||
"connection_type": info.get("WanAccessType", "VDSL"),
|
||||
"is_connected": bool(wan_ip),
|
||||
"external_ip": wan_ip,
|
||||
"uptime": int(info.get("SystemUpTime", 0) or 0),
|
||||
"bytes_sent": 0,
|
||||
"bytes_received": 0,
|
||||
"max_bitrate_up": int(info.get("MaxUpstream", 0) or 0) // 1000,
|
||||
"max_bitrate_down": int(info.get("MaxDownstream", 0) or 0) // 1000,
|
||||
"link_status": "Up" if wan_ip else "Down",
|
||||
}
|
||||
"""The uplink as the gateway's status page (``cardpage_status``) reports it (#29).
|
||||
|
||||
A bridge is connected when its DSL line is in sync and has no external address;
|
||||
a router is connected when its WAN interface is up with an address. Byte
|
||||
counters are not read: 0.
|
||||
"""
|
||||
return parsers.wan_status(self._status_page())
|
||||
|
||||
def get_port_forwards(self) -> list[PortForwardDict]:
|
||||
"""Return port forwarding rules from DAL or HTML fallback."""
|
||||
"""The gateway's port forwards (DAL ``nat``), else the status page's."""
|
||||
return self._read_dal_or_page(
|
||||
"NAT_PORTMAP",
|
||||
"Status.htm",
|
||||
self._parse_port_forwards_dal,
|
||||
self._parse_port_forwards_html,
|
||||
self._NAT_OID, "Status.htm", parsers.port_forwards, self._parse_port_forwards_html
|
||||
)
|
||||
|
||||
def _parse_port_forwards_dal(self, data: dict) -> list[PortForwardDict]:
|
||||
forwards: list[PortForwardDict] = []
|
||||
rules = data.get("rules", data.get("NATPortMap", data.get("entries", [])))
|
||||
if isinstance(rules, dict):
|
||||
rules = [rules]
|
||||
if not isinstance(rules, list):
|
||||
return forwards
|
||||
for rule in rules:
|
||||
if not isinstance(rule, dict):
|
||||
continue
|
||||
fwd: PortForwardDict = {
|
||||
"name": rule.get("Description", rule.get("name", "")),
|
||||
"protocol": rule.get("Protocol", rule.get("protocol", "TCP")),
|
||||
"external_port": int(rule.get("ExternalPort", rule.get("external_port", 0)) or 0),
|
||||
"internal_ip": rule.get("InternalIP", rule.get("internal_ip", "")),
|
||||
"internal_port": int(rule.get("InternalPort", rule.get("internal_port", 0)) or 0),
|
||||
"enabled": bool(rule.get("Enabled", rule.get("enabled", True))),
|
||||
}
|
||||
forwards.append(fwd)
|
||||
return forwards
|
||||
|
||||
_PORT_FORWARD_RE = re.compile(
|
||||
r"(?P<name>[^|]+?)\s*\|\s*(?P<proto>TCP|UDP|BOTH)\s*\|\s*"
|
||||
r"(?P<ext_port>\d+)\s*\|\s*(?P<int_ip>[0-9.]+)\s*\|\s*"
|
||||
@@ -678,33 +670,14 @@ class ZyxelVMGDriver(ResidentialGatewayDriver):
|
||||
return forwards
|
||||
|
||||
def get_hosts(self) -> list[HostDict]:
|
||||
"""Return DHCP host entries from DAL or HTML fallback."""
|
||||
return self._read_dal_or_page(
|
||||
"LAN_HOSTS", "dhcp.htm", self._parse_hosts_dal, self._parse_hosts_html
|
||||
)
|
||||
"""The hosts the gateway knows on its LAN (DAL ``lanhosts``), else the DHCP page's.
|
||||
|
||||
def _parse_hosts_dal(self, data: dict) -> list[HostDict]:
|
||||
hosts: list[HostDict] = []
|
||||
entries = data.get("hosts", data.get("LANHosts", data.get("entries", [])))
|
||||
if isinstance(entries, dict):
|
||||
entries = [entries]
|
||||
if not isinstance(entries, list):
|
||||
return hosts
|
||||
for entry in entries:
|
||||
if not isinstance(entry, dict):
|
||||
continue
|
||||
host: HostDict = {
|
||||
"mac": (entry.get("MACAddress", entry.get("mac", "")) or "").lower(),
|
||||
"ip": entry.get("IPAddress", entry.get("ip", "")),
|
||||
"hostname": entry.get("HostName", entry.get("hostname", "")),
|
||||
"interface_type": entry.get("InterfaceType", entry.get("interface_type", "lan")),
|
||||
"is_active": bool(entry.get("Active", entry.get("active", True))),
|
||||
}
|
||||
lease = entry.get("LeaseTime", entry.get("lease_time"))
|
||||
if lease is not None:
|
||||
host["lease_time_remaining"] = int(lease)
|
||||
hosts.append(host)
|
||||
return hosts
|
||||
A host the gateway has no name for (``"Unknown"``) has ``hostname`` ``""``; only a
|
||||
host that got its address by DHCP has ``lease_time_remaining``.
|
||||
"""
|
||||
return self._read_dal_or_page(
|
||||
self._HOSTS_OID, "dhcp.htm", parsers.hosts, self._parse_hosts_html
|
||||
)
|
||||
|
||||
_HOST_RE = re.compile(
|
||||
r"(?P<ip>[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)"
|
||||
@@ -729,12 +702,17 @@ class ZyxelVMGDriver(ResidentialGatewayDriver):
|
||||
return hosts
|
||||
|
||||
def get_nat_translations(self) -> list[NATTranslationDict]:
|
||||
"""Return NAT translations derived from enabled port forwards."""
|
||||
wan_ip = (self._device_info or {}).get("WanIp", "")
|
||||
"""The enabled port forwards as translations to the gateway's WAN address.
|
||||
|
||||
Without a WAN address of its own (a bridge, or a WAN that is down) the
|
||||
translation is to any address, ``0.0.0.0``.
|
||||
"""
|
||||
forwards = [forward for forward in self.get_port_forwards() if forward["enabled"]]
|
||||
if not forwards:
|
||||
return []
|
||||
wan_ip = parsers.wan_address(self._status_page()) or _ANY_ADDRESS
|
||||
translations: list[NATTranslationDict] = []
|
||||
for forward in self.get_port_forwards():
|
||||
if not forward["enabled"]:
|
||||
continue
|
||||
for forward in forwards:
|
||||
translations.append(
|
||||
{
|
||||
"protocol": forward["protocol"].lower(),
|
||||
@@ -760,16 +738,11 @@ class ZyxelVMGDriver(ResidentialGatewayDriver):
|
||||
self._parse_wireless_clients_html,
|
||||
)
|
||||
|
||||
def _parse_wireless_clients_dal(self, data: dict) -> list[WirelessClientDict]:
|
||||
def _parse_wireless_clients_dal(
|
||||
self, entries: list[dict[str, Any]]
|
||||
) -> list[WirelessClientDict]:
|
||||
clients: list[WirelessClientDict] = []
|
||||
entries = data.get("clients", data.get("assoc", data.get("entries", [])))
|
||||
if isinstance(entries, dict):
|
||||
entries = [entries]
|
||||
if not isinstance(entries, list):
|
||||
return clients
|
||||
for entry in entries:
|
||||
if not isinstance(entry, dict):
|
||||
continue
|
||||
client: WirelessClientDict = {
|
||||
"mac": (entry.get("MACAddress", entry.get("mac", "")) or "").lower(),
|
||||
"ssid": entry.get("SSID", entry.get("ssid", "")),
|
||||
@@ -818,16 +791,9 @@ class ZyxelVMGDriver(ResidentialGatewayDriver):
|
||||
"WIFI_SSIDS", "wireless.htm", self._parse_ssids_dal, self._parse_ssids_html
|
||||
)
|
||||
|
||||
def _parse_ssids_dal(self, data: dict) -> dict[str, SSIDDict]:
|
||||
def _parse_ssids_dal(self, entries: list[dict[str, Any]]) -> dict[str, SSIDDict]:
|
||||
ssids: dict[str, SSIDDict] = {}
|
||||
entries = data.get("ssids", data.get("entries", []))
|
||||
if isinstance(entries, dict):
|
||||
entries = [entries]
|
||||
if not isinstance(entries, list):
|
||||
return ssids
|
||||
for entry in entries:
|
||||
if not isinstance(entry, dict):
|
||||
continue
|
||||
ssid_name = (entry.get("SSID", entry.get("ssid", "")) or "").strip()
|
||||
if not ssid_name:
|
||||
continue
|
||||
@@ -866,12 +832,9 @@ class ZyxelVMGDriver(ResidentialGatewayDriver):
|
||||
self._parse_radio_status_html,
|
||||
)
|
||||
|
||||
def _parse_radio_status_dal(self, data: dict) -> dict[str, RadioStatusDict]:
|
||||
def _parse_radio_status_dal(self, entries: list[dict[str, Any]]) -> dict[str, RadioStatusDict]:
|
||||
radios: dict[str, RadioStatusDict] = {}
|
||||
entries = data.get("radios", data.get("entries", []))
|
||||
if isinstance(entries, dict):
|
||||
entries = [entries]
|
||||
for entry in entries if isinstance(entries, list) else []:
|
||||
for entry in entries:
|
||||
name = entry.get("Name", entry.get("name", ""))
|
||||
channel = int(entry.get("Channel", entry.get("channel", 0)) or 0)
|
||||
radios[name] = {
|
||||
|
||||
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"result": "ZCFG_SUCCESS",
|
||||
"ReplyMsg": "",
|
||||
"ReplyMsgMultiLang": "",
|
||||
"Object": []
|
||||
}
|
||||
@@ -0,0 +1,357 @@
|
||||
{
|
||||
"result": "ZCFG_SUCCESS",
|
||||
"ReplyMsg": "DeviceSource",
|
||||
"ReplyMsgMultiLang": "",
|
||||
"Object": [
|
||||
{
|
||||
"WanLanInfo": [
|
||||
{
|
||||
"Enable": true,
|
||||
"IpIfacePath": "IP.Interface.1",
|
||||
"wanIdx": 1,
|
||||
"BindToIntfGrp": false,
|
||||
"X_ZYXEL_Type": "LAN",
|
||||
"Encapsulation": "",
|
||||
"MACAddress": "6c:4f:89:00:00:50",
|
||||
"LowerlayerUp": "",
|
||||
"pppConnectionStatus": "",
|
||||
"wanpppIdx": 0,
|
||||
"DHCPtr181Path": "Device.DHCPv4.Server.Pool.1",
|
||||
"Status": "Up",
|
||||
"X_ZYXEL_ConnectionType": "IP_Routed",
|
||||
"X_ZYXEL_SrvName": "Default",
|
||||
"Name": "LAN",
|
||||
"Type": "Normal",
|
||||
"IPv4Enable": true,
|
||||
"IPv6Enable": false,
|
||||
"X_ZYXEL_IfName": "br0",
|
||||
"X_ZYXEL_UpTime": 13554113,
|
||||
"IPv6Origin": "DelegateFromWan",
|
||||
"IPv6PrefixDelegateWAN": "Default",
|
||||
"X_ZYXEL_DefaultGatewayIface": false,
|
||||
"X_ZYXEL_IPv6LocalAddress": "fe80::6e4f:89ff:fe00:50",
|
||||
"IPv4Address": [
|
||||
{
|
||||
"Enable": true,
|
||||
"Alias": "",
|
||||
"IPAddress": "192.0.2.1",
|
||||
"SubnetMask": "255.255.255.248",
|
||||
"Status": "Enabled",
|
||||
"AddressingType": "Static",
|
||||
"X_ZYXEL_IfName": "",
|
||||
"X_ZYXEL_Alias": false,
|
||||
"X_ZYXEL_Dhcp4Subnet_Ref": "",
|
||||
"ipIfaceIdx": 1
|
||||
}
|
||||
],
|
||||
"IPv6Address": [],
|
||||
"IPv6Prefix": [],
|
||||
"v4Gateway": "192.0.2.2",
|
||||
"dnsv4Server": [],
|
||||
"dnsv6Server": [],
|
||||
"rtinfoIntf": [],
|
||||
"ipoeConnectionUpTime": 13554213,
|
||||
"BridgingBrPath": "Bridging.Bridge.1",
|
||||
"Group_WAN_IpIface": "",
|
||||
"DHCPStatus": "Disable",
|
||||
"Gateway": "",
|
||||
"LeaseTime": 0,
|
||||
"LeaseTimeRemaining": 0,
|
||||
"DHCPoption42Enable": false,
|
||||
"DHCPoption43Enable": false,
|
||||
"DHCPoption60Enable": false,
|
||||
"DHCPoption42Value": "",
|
||||
"DHCPoption43Value": "",
|
||||
"DHCPoption60Value": ""
|
||||
},
|
||||
{
|
||||
"Enable": true,
|
||||
"IpIfacePath": "IP.Interface.2",
|
||||
"wanIdx": 2,
|
||||
"BindToIntfGrp": false,
|
||||
"X_ZYXEL_Type": "WAN",
|
||||
"Encapsulation": "IPoE",
|
||||
"MACAddress": "",
|
||||
"LowerlayerUp": "",
|
||||
"pppConnectionStatus": "",
|
||||
"wanpppIdx": 0,
|
||||
"DHCPtr181Path": "",
|
||||
"X_ZYXEL_ConnectionType": "IP_Bridged",
|
||||
"X_ZYXEL_SrvName": "Bridge_ATM",
|
||||
"Name": "WAN",
|
||||
"Type": "Normal",
|
||||
"IPv4Enable": false,
|
||||
"IPv6Enable": false,
|
||||
"X_ZYXEL_IfName": "atm0.1",
|
||||
"IPv6Origin": "",
|
||||
"IPv6PrefixDelegateWAN": "Default",
|
||||
"X_ZYXEL_DefaultGatewayIface": false,
|
||||
"X_ZYXEL_IPv6LocalAddress": "",
|
||||
"IPv4Address": [],
|
||||
"IPv6Address": [],
|
||||
"IPv6Prefix": [],
|
||||
"dnsv4Server": [],
|
||||
"dnsv6Server": [],
|
||||
"rtinfoIntf": [],
|
||||
"ipoeConnectionUpTime": 0,
|
||||
"LinkType": "ATM",
|
||||
"DHCPStatus": "Disable",
|
||||
"Gateway": "",
|
||||
"LeaseTime": 0,
|
||||
"LeaseTimeRemaining": 0,
|
||||
"DHCPoption42Enable": false,
|
||||
"DHCPoption43Enable": false,
|
||||
"DHCPoption60Enable": false,
|
||||
"DHCPoption42Value": "",
|
||||
"DHCPoption43Value": "",
|
||||
"DHCPoption60Value": ""
|
||||
},
|
||||
{
|
||||
"Enable": true,
|
||||
"IpIfacePath": "IP.Interface.3",
|
||||
"wanIdx": 3,
|
||||
"BindToIntfGrp": false,
|
||||
"X_ZYXEL_Type": "WAN",
|
||||
"Encapsulation": "IPoE",
|
||||
"MACAddress": "",
|
||||
"LowerlayerUp": "",
|
||||
"pppConnectionStatus": "",
|
||||
"wanpppIdx": 0,
|
||||
"DHCPtr181Path": "",
|
||||
"Status": "LowerLayerDown",
|
||||
"X_ZYXEL_ConnectionType": "IP_Bridged",
|
||||
"X_ZYXEL_SrvName": "Bridge_PTM",
|
||||
"Name": "WAN",
|
||||
"Type": "Normal",
|
||||
"IPv4Enable": false,
|
||||
"IPv6Enable": false,
|
||||
"X_ZYXEL_IfName": "ptm0.2",
|
||||
"X_ZYXEL_UpTime": 0,
|
||||
"IPv6Origin": "",
|
||||
"IPv6PrefixDelegateWAN": "Default",
|
||||
"X_ZYXEL_DefaultGatewayIface": false,
|
||||
"X_ZYXEL_IPv6LocalAddress": "",
|
||||
"IPv4Address": [],
|
||||
"IPv6Address": [],
|
||||
"IPv6Prefix": [],
|
||||
"dnsv4Server": [],
|
||||
"dnsv6Server": [],
|
||||
"rtinfoIntf": [],
|
||||
"ipoeConnectionUpTime": 0,
|
||||
"LinkType": "PTM",
|
||||
"DHCPStatus": "Disable",
|
||||
"Gateway": "",
|
||||
"LeaseTime": 0,
|
||||
"LeaseTimeRemaining": 0,
|
||||
"DHCPoption42Enable": false,
|
||||
"DHCPoption43Enable": false,
|
||||
"DHCPoption60Enable": false,
|
||||
"DHCPoption42Value": "",
|
||||
"DHCPoption43Value": "",
|
||||
"DHCPoption60Value": ""
|
||||
}
|
||||
],
|
||||
"DeviceInfo": {
|
||||
"Manufacturer": "ZYXEL",
|
||||
"ManufacturerOUI": "6C4F89",
|
||||
"FixManufacturerOUI": "",
|
||||
"ModelName": "VMG4005-B50A",
|
||||
"Description": "VDSL2 17a Bonding and 35b Single Line Bridge",
|
||||
"ProductClass": "VMG4005-B50A",
|
||||
"SerialNumber": "S000Y00000001",
|
||||
"HardwareVersion": "VMG4005-B50A",
|
||||
"SoftwareVersion": "V5.17(ABQA.3.1)C0",
|
||||
"AdditionalHardwareVersion": "",
|
||||
"AdditionalSoftwareVersion": "",
|
||||
"ProvisioningCode": "",
|
||||
"X_ZYXEL_ProvisioningCodeIntf": "",
|
||||
"X_ZYXEL_ProvisioningKey": "",
|
||||
"X_ZYXEL_GponSerialNumber": "",
|
||||
"X_ZYXEL_Ploam_Password": "",
|
||||
"UpTime": 13554213,
|
||||
"FirstUseDate": "0001-01-01T00:00:00Z",
|
||||
"VendorConfigFileNumberOfEntries": 0,
|
||||
"SupportedDataModelNumberOfEntries": 0,
|
||||
"ProcessorNumberOfEntries": 0,
|
||||
"VendorLogFileNumberOfEntries": 0,
|
||||
"LocationNumberOfEntries": 0,
|
||||
"BootVersion": "",
|
||||
"WiFiDriverVersion": "",
|
||||
"DSLVersion": ""
|
||||
},
|
||||
"LanPortInfo": {
|
||||
"LanMac": "6c:4f:89:00:00:53",
|
||||
"ethPortExist": false
|
||||
},
|
||||
"Dhcp4SerPoolInfo": {
|
||||
"Enable": false,
|
||||
"X_ZYXEL_SetEnable": false,
|
||||
"X_ZYXEL_AutoReserveLanIp": false,
|
||||
"Status": "Enabled",
|
||||
"Alias": "",
|
||||
"Order": 1,
|
||||
"Interface": "IP.Interface.1",
|
||||
"VendorClassID": "",
|
||||
"VendorClassIDExclude": false,
|
||||
"VendorClassIDMode": "",
|
||||
"ClientID": "",
|
||||
"ClientIDExclude": false,
|
||||
"UserClassID": "",
|
||||
"ChaddrExclude": false,
|
||||
"Chaddr": "",
|
||||
"ChaddrMask": "",
|
||||
"MinAddress": "192.0.2.2",
|
||||
"MaxAddress": "192.0.2.254",
|
||||
"ReservedAddresses": "",
|
||||
"SubnetMask": "255.255.255.0",
|
||||
"DNSServers": "192.0.2.1",
|
||||
"X_ZYXEL_ServerConfigurable": true,
|
||||
"X_ZYXEL_DNS_Type": "DNS Proxy",
|
||||
"DomainName": "",
|
||||
"IPRouters": "",
|
||||
"LeaseTime": 86400,
|
||||
"X_ZYXEL_STB_VENDORID": "",
|
||||
"X_ZYXEL_STB_URL": "",
|
||||
"X_ZYXEL_STB_PrCode": "",
|
||||
"X_ZYXEL_STB_URL_subcode": 1,
|
||||
"X_ZYXEL_STB_PrCode_subcode": 2,
|
||||
"StaticAddressNumberOfEntries": 0,
|
||||
"OptionNumberOfEntries": 0,
|
||||
"ClientNumberOfEntries": 0
|
||||
},
|
||||
"LanInfo": [
|
||||
{
|
||||
"Enable": true,
|
||||
"Status": "Up",
|
||||
"Alias": "",
|
||||
"Name": "eth1",
|
||||
"LastChange": 13554195,
|
||||
"LowerLayers": "",
|
||||
"Upstream": false,
|
||||
"MACAddress": "6c:4f:89:00:00:53",
|
||||
"IntfEnable": true,
|
||||
"IntfStatus": "Up",
|
||||
"MaxBitRate": 1000,
|
||||
"DuplexMode": "Full",
|
||||
"EEECapability": false,
|
||||
"EEEEnable": true,
|
||||
"X_ZYXEL_DuplexMode": "Auto",
|
||||
"X_ZYXEL_MaxBitRate": -1,
|
||||
"X_ZYXEL_LanPort": "LAN1",
|
||||
"X_ZYXEL_SFP": false,
|
||||
"X_ZYXEL_SwitchToWAN": false,
|
||||
"X_ZYXEL_Upstream": false,
|
||||
"X_ZYXEL_UpTime": 13554195,
|
||||
"X_ZYXEL_LastChangeTime": 18
|
||||
}
|
||||
],
|
||||
"DslChannelInfo": [
|
||||
{
|
||||
"Enable": true,
|
||||
"Status": "Down",
|
||||
"Alias": "",
|
||||
"Name": "",
|
||||
"LastChange": 0,
|
||||
"LowerLayers": "DSL.Line.1",
|
||||
"LinkEncapsulationSupported": "G.992.3_Annex_K_ATM",
|
||||
"LinkEncapsulationUsed": "G.992.3_Annex_K_ATM",
|
||||
"LPATH": 0,
|
||||
"INTLVDEPTH": 0,
|
||||
"INTLVBLOCK": 0,
|
||||
"ActualInterleavingDelay": 0,
|
||||
"ACTINP": 0,
|
||||
"INPREPORT": false,
|
||||
"NFEC": 0,
|
||||
"RFEC": 0,
|
||||
"LSYMB": 0,
|
||||
"UpstreamCurrRate": 0,
|
||||
"DownstreamCurrRate": 0,
|
||||
"DSLUpTime": "",
|
||||
"X_ZYXEL_BondingLineNumber": 0
|
||||
},
|
||||
{
|
||||
"Enable": true,
|
||||
"Status": "LowerLayerDown",
|
||||
"Alias": "",
|
||||
"Name": "",
|
||||
"LastChange": 0,
|
||||
"LowerLayers": "DSL.Line.1",
|
||||
"LinkEncapsulationSupported": "G.992.3_Annex_K_PTM",
|
||||
"LinkEncapsulationUsed": "G.992.3_Annex_K_PTM",
|
||||
"LPATH": 0,
|
||||
"INTLVDEPTH": 0,
|
||||
"INTLVBLOCK": 0,
|
||||
"ActualInterleavingDelay": 0,
|
||||
"ACTINP": 0,
|
||||
"INPREPORT": false,
|
||||
"NFEC": 0,
|
||||
"RFEC": 0,
|
||||
"LSYMB": 0,
|
||||
"UpstreamCurrRate": 0,
|
||||
"DownstreamCurrRate": 0,
|
||||
"DSLUpTime": "",
|
||||
"X_ZYXEL_BondingLineNumber": 0
|
||||
},
|
||||
{
|
||||
"Enable": true,
|
||||
"Status": "Down",
|
||||
"Alias": "",
|
||||
"Name": "",
|
||||
"LastChange": 0,
|
||||
"LowerLayers": "DSL.Line.2",
|
||||
"LinkEncapsulationSupported": "G.992.3_Annex_K_ATM",
|
||||
"LinkEncapsulationUsed": "G.992.3_Annex_K_ATM",
|
||||
"LPATH": 0,
|
||||
"INTLVDEPTH": 0,
|
||||
"INTLVBLOCK": 0,
|
||||
"ActualInterleavingDelay": 0,
|
||||
"ACTINP": 0,
|
||||
"INPREPORT": false,
|
||||
"NFEC": 0,
|
||||
"RFEC": 0,
|
||||
"LSYMB": 0,
|
||||
"UpstreamCurrRate": 0,
|
||||
"DownstreamCurrRate": 0,
|
||||
"DSLUpTime": "",
|
||||
"X_ZYXEL_BondingLineNumber": 1
|
||||
},
|
||||
{
|
||||
"Enable": true,
|
||||
"Status": "LowerLayerDown",
|
||||
"Alias": "",
|
||||
"Name": "",
|
||||
"LastChange": 0,
|
||||
"LowerLayers": "DSL.Line.2",
|
||||
"LinkEncapsulationSupported": "G.992.3_Annex_K_PTM",
|
||||
"LinkEncapsulationUsed": "G.992.3_Annex_K_PTM",
|
||||
"LPATH": 0,
|
||||
"INTLVDEPTH": 0,
|
||||
"INTLVBLOCK": 0,
|
||||
"ActualInterleavingDelay": 0,
|
||||
"ACTINP": 0,
|
||||
"INPREPORT": false,
|
||||
"NFEC": 0,
|
||||
"RFEC": 0,
|
||||
"LSYMB": 0,
|
||||
"UpstreamCurrRate": 45875,
|
||||
"DownstreamCurrRate": 274098,
|
||||
"DSLUpTime": "",
|
||||
"X_ZYXEL_BondingLineNumber": 1
|
||||
}
|
||||
],
|
||||
"OptIntfInfo": [],
|
||||
"GponStatsInfo": {
|
||||
"RxPowerSignal": "0",
|
||||
"TxPowerSignal": "0",
|
||||
"Temperature": "0",
|
||||
"SFP_Vendor": "",
|
||||
"SFP_Model": "",
|
||||
"SFP_Serial": "",
|
||||
"SFP_Presence": false
|
||||
},
|
||||
"WanType": "",
|
||||
"WanRate_RX": "",
|
||||
"WanRate_TX": ""
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
{
|
||||
"result": "ZCFG_SUCCESS",
|
||||
"ModelName": "VMG4005-B50A",
|
||||
"SoftwareVersion": "V5.17(ABQA.3.1)C0",
|
||||
"CurrentLanguage": "de",
|
||||
"AvailableLanguages": "en,cz,it,nl,pt,ru,tr,fr,de,es",
|
||||
"RememberPassword": 0,
|
||||
"FWUpgradeProgressST": 0
|
||||
}
|
||||
+167
@@ -0,0 +1,167 @@
|
||||
{
|
||||
"result": "ZCFG_SUCCESS",
|
||||
"ReplyMsg": "DeviceSource",
|
||||
"ReplyMsgMultiLang": "",
|
||||
"Object": [
|
||||
{
|
||||
"wanInfo": {
|
||||
"wanStatus": 0,
|
||||
"wanIfaceExist": 1,
|
||||
"wanType": ""
|
||||
},
|
||||
"lanhosts": [
|
||||
{
|
||||
"Alias": "",
|
||||
"PhysAddress": "02:00:00:00:00:02",
|
||||
"IPAddress": "192.0.2.2",
|
||||
"IPAddress6": "",
|
||||
"IPLinkLocalAddress6": "N/A",
|
||||
"AddressSource": "Static",
|
||||
"DHCPClient": "",
|
||||
"LeaseTimeRemaining": 0,
|
||||
"AssociatedDevice": "",
|
||||
"Layer1Interface": "Device.Ethernet.Interface.1",
|
||||
"Layer3Interface": "Device.IP.Interface.1",
|
||||
"VendorClassID": "",
|
||||
"ClientID": "",
|
||||
"UserClassID": "",
|
||||
"HostName": "Unknown",
|
||||
"Active": true,
|
||||
"X_ZYXEL_DeleteLease": false,
|
||||
"X_ZYXEL_ConnectionType": "Ethernet",
|
||||
"X_ZYXEL_ConnectedAP": "",
|
||||
"X_ZYXEL_HostType": "",
|
||||
"X_ZYXEL_CapabilityType": "",
|
||||
"X_ZYXEL_PhyRate": 1000,
|
||||
"X_ZYXEL_WiFiStatus": false,
|
||||
"X_ZYXEL_SignalStrength": 0,
|
||||
"X_ZYXEL_SNR": 0,
|
||||
"X_ZYXEL_RSSI": 0,
|
||||
"X_ZYXEL_SoftwareVersion": "",
|
||||
"X_ZYXEL_LastUpdate": 1769202204,
|
||||
"X_ZYXEL_Address6Source": "",
|
||||
"X_ZYXEL_DHCP6Client": "",
|
||||
"X_ZYXEL_BytesSent": 0,
|
||||
"X_ZYXEL_BytesReceived": 0,
|
||||
"X_ZYXEL_OperatingStandard": "",
|
||||
"X_ZYXEL_LastDataDownlinkRate": 0,
|
||||
"X_ZYXEL_LastDataUplinkRate": 0,
|
||||
"IPv4AddressNumberOfEntries": 0,
|
||||
"IPv6AddressNumberOfEntries": 0,
|
||||
"ClientDuid": "",
|
||||
"ExpireTime": "",
|
||||
"SupportedFrequencyBands": "",
|
||||
"WiFiname": "",
|
||||
"DeviceSource": "HOSTS_HOST",
|
||||
"DeviceIcon": "",
|
||||
"Internet_Blocking_Enable": false,
|
||||
"DeviceName": "Unknown",
|
||||
"curHostName": "",
|
||||
"dhcp4PoolExist": true,
|
||||
"dhcp4PoolIid": [
|
||||
1,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0
|
||||
],
|
||||
"dhcp4StaticAddrExist": false,
|
||||
"dhcp4StaticAddrIid": [
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0
|
||||
],
|
||||
"dhcp4StaticAddrEnable": false,
|
||||
"dhcp4StaticAddr": "",
|
||||
"dhcp4StaticAddrNum": 0,
|
||||
"dhcp4StaticAddrUsedByOtherHost": false,
|
||||
"icon": "ipc",
|
||||
"staticIP": ""
|
||||
},
|
||||
{
|
||||
"Alias": "",
|
||||
"PhysAddress": "02:00:00:00:00:03",
|
||||
"IPAddress": "192.0.2.3",
|
||||
"IPAddress6": "",
|
||||
"IPLinkLocalAddress6": "N/A",
|
||||
"AddressSource": "Static",
|
||||
"DHCPClient": "",
|
||||
"LeaseTimeRemaining": 0,
|
||||
"AssociatedDevice": "",
|
||||
"Layer1Interface": "",
|
||||
"Layer3Interface": "Device.IP.Interface.1",
|
||||
"VendorClassID": "",
|
||||
"ClientID": "",
|
||||
"UserClassID": "",
|
||||
"HostName": "Unknown",
|
||||
"Active": true,
|
||||
"X_ZYXEL_DeleteLease": false,
|
||||
"X_ZYXEL_ConnectionType": "Ethernet",
|
||||
"X_ZYXEL_ConnectedAP": "",
|
||||
"X_ZYXEL_HostType": "",
|
||||
"X_ZYXEL_CapabilityType": "",
|
||||
"X_ZYXEL_PhyRate": 0,
|
||||
"X_ZYXEL_WiFiStatus": false,
|
||||
"X_ZYXEL_SignalStrength": 0,
|
||||
"X_ZYXEL_SNR": 0,
|
||||
"X_ZYXEL_RSSI": 0,
|
||||
"X_ZYXEL_SoftwareVersion": "",
|
||||
"X_ZYXEL_LastUpdate": 1769202204,
|
||||
"X_ZYXEL_Address6Source": "",
|
||||
"X_ZYXEL_DHCP6Client": "",
|
||||
"X_ZYXEL_BytesSent": 0,
|
||||
"X_ZYXEL_BytesReceived": 0,
|
||||
"X_ZYXEL_OperatingStandard": "",
|
||||
"X_ZYXEL_LastDataDownlinkRate": 0,
|
||||
"X_ZYXEL_LastDataUplinkRate": 0,
|
||||
"IPv4AddressNumberOfEntries": 0,
|
||||
"IPv6AddressNumberOfEntries": 0,
|
||||
"ClientDuid": "",
|
||||
"ExpireTime": "",
|
||||
"SupportedFrequencyBands": "",
|
||||
"WiFiname": "",
|
||||
"DeviceSource": "HOSTS_HOST",
|
||||
"DeviceIcon": "",
|
||||
"Internet_Blocking_Enable": false,
|
||||
"DeviceName": "Unknown",
|
||||
"curHostName": "",
|
||||
"dhcp4PoolExist": true,
|
||||
"dhcp4PoolIid": [
|
||||
1,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0
|
||||
],
|
||||
"dhcp4StaticAddrExist": false,
|
||||
"dhcp4StaticAddrIid": [
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0,
|
||||
0
|
||||
],
|
||||
"dhcp4StaticAddrEnable": false,
|
||||
"dhcp4StaticAddr": "",
|
||||
"dhcp4StaticAddrNum": 0,
|
||||
"dhcp4StaticAddrUsedByOtherHost": false,
|
||||
"icon": "ipc",
|
||||
"staticIP": ""
|
||||
}
|
||||
],
|
||||
"STBVendorID": {
|
||||
"STBVendorID1": "",
|
||||
"STBVendorID2": "",
|
||||
"STBVendorID3": "",
|
||||
"STBVendorID4": "",
|
||||
"STBVendorID5": ""
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"result": "ZCFG_SUCCESS",
|
||||
"ReplyMsg": "InternalClient",
|
||||
"ReplyMsgMultiLang": "",
|
||||
"Object": []
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
"""A logged-in driver whose gateway answers GETs from recorded fixtures, sealed.
|
||||
|
||||
The fixtures in ``fixtures/`` are a VMG4005-B50A's (firmware V5.17(ABQA.3.1)C0)
|
||||
answers, anonymised: addresses under 192.0.2.0/24, MAC addresses replaced by
|
||||
placeholders, the serial number replaced, the provisioning key and PLOAM password
|
||||
emptied. The gateway seals a DAL answer as ``{"content", "iv"}``; :func:`driver`
|
||||
seals each fixture with a real :class:`ZyxelCrypto` and the driver's own key, so
|
||||
what the driver reads has gone through the decryption.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
from unittest.mock import MagicMock
|
||||
|
||||
import requests
|
||||
|
||||
from napalm_zyxel import ZyxelVMGDriver
|
||||
from napalm_zyxel.zyxel_driver import ZyxelCrypto
|
||||
|
||||
FIXTURES = Path(__file__).parent / "fixtures"
|
||||
FIRMWARE = "vmg4005-b50a-ABQA.3.1"
|
||||
AES_KEY = bytes(range(32))
|
||||
|
||||
|
||||
def fixture(name: str) -> Any:
|
||||
"""The recorded answer *name* (``cardpage_status``, ``lanhosts``, ...)."""
|
||||
return json.loads((FIXTURES / f"{FIRMWARE}-{name}.json").read_text())
|
||||
|
||||
|
||||
def dal(oid: str) -> str:
|
||||
"""The path a DAL GET of *oid* is sent to."""
|
||||
return f"cgi-bin/DAL?oid={oid}"
|
||||
|
||||
|
||||
def response(status: int, text: str = "") -> requests.Response:
|
||||
resp = requests.Response()
|
||||
resp.status_code = status
|
||||
resp._content = text.encode()
|
||||
resp.url = "http://192.0.2.1/"
|
||||
return resp
|
||||
|
||||
|
||||
def _crypto() -> ZyxelCrypto:
|
||||
crypto = ZyxelCrypto()
|
||||
crypto.aes_key = AES_KEY
|
||||
return crypto
|
||||
|
||||
|
||||
def sealed(answer: Any) -> requests.Response:
|
||||
"""*answer* the way the gateway sends it: AES-encrypted, ``{"content", "iv"}``."""
|
||||
envelope = _crypto().encrypt_json(answer)
|
||||
return response(200, json.dumps({"content": envelope["content"], "iv": envelope["iv"]}))
|
||||
|
||||
|
||||
def driver(answers: dict[str, Any]) -> ZyxelVMGDriver:
|
||||
"""A logged-in driver whose gateway answers a GET of each path in *answers*:
|
||||
a response as it is, anything else sealed. Any other path answers 404."""
|
||||
drv = ZyxelVMGDriver("192.0.2.1", "admin", "password")
|
||||
# NAPALM's __del__ asks is_alive(), which opens a TCP connection: not in a test.
|
||||
drv.is_alive = lambda: {"is_alive": False} # type: ignore[method-assign]
|
||||
|
||||
def get(url: str, params: dict[str, Any] | None = None, **_: Any) -> requests.Response:
|
||||
for path, answer in answers.items():
|
||||
if url.endswith(f"/{path}"):
|
||||
return answer if isinstance(answer, requests.Response) else sealed(answer)
|
||||
return response(404)
|
||||
|
||||
session = MagicMock(spec=requests.Session)
|
||||
session.get.side_effect = get
|
||||
drv._session = session
|
||||
drv._sessionkey = "1"
|
||||
drv._crypto = _crypto()
|
||||
drv._device_info = fixture("getBasicInformation")
|
||||
return drv
|
||||
|
||||
|
||||
def requested(drv: ZyxelVMGDriver) -> list[str]:
|
||||
"""The URLs the driver sent a GET to, in order."""
|
||||
return [call.args[0] for call in drv._session.get.call_args_list] # type: ignore[union-attr]
|
||||
@@ -1,8 +1,6 @@
|
||||
{
|
||||
"coverage_floor": 68.0,
|
||||
"function_complexity": {
|
||||
"napalm_zyxel/zyxel_driver.py::ZyxelVMGDriver._parse_wireless_clients_dal": 12
|
||||
},
|
||||
"function_complexity": {},
|
||||
"function_lines": {},
|
||||
"mypy_relaxed": [
|
||||
"napalm_zyxel.zyxel_driver"
|
||||
|
||||
@@ -0,0 +1,229 @@
|
||||
"""A DAL GET is read the way the gateway sends it: sealed, with its data under ``Object`` (#25).
|
||||
|
||||
``_read_dal_or_page`` parsed the answer to ``GET /cgi-bin/DAL?oid=...`` as it came,
|
||||
but the gateway seals it (``{"content", "iv"}``) like the answer to a PUT. The
|
||||
parsers found none of their keys in the envelope and reported no hosts, ARP
|
||||
entries, port forwards, SSIDs, radios or Wi-Fi clients, and since nothing raised,
|
||||
the HTML fallback never ran either.
|
||||
|
||||
Decrypted, the answer is ``{"result": "ZCFG_SUCCESS", "Object": [...]}``. The host
|
||||
list is the one the gateway's own web interface reads, ``oid=lanhosts``: the
|
||||
driver asked for ``LAN_HOSTS``, a name the gateway does not know and answers, like
|
||||
any unknown name, with an empty ``Object``. Port forwards are ``oid=nat`` (the
|
||||
driver asked for ``NAT_PORTMAP``).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import json
|
||||
from typing import Any
|
||||
|
||||
import pytest
|
||||
import requests
|
||||
from napalm.base.exceptions import ConnectionException
|
||||
|
||||
from tests.gateway import dal, driver, fixture, requested, response
|
||||
|
||||
LANHOSTS = fixture("lanhosts")
|
||||
|
||||
|
||||
def _with_host(**changes: Any) -> dict[str, Any]:
|
||||
"""The recorded host list, its first host changed by *changes*."""
|
||||
answer = copy.deepcopy(LANHOSTS)
|
||||
answer["Object"][0]["lanhosts"][0].update(changes)
|
||||
return answer
|
||||
|
||||
|
||||
#: A port forward as the gateway's web interface edits it (the rule object its NAT
|
||||
#: page sends to ``oid=nat``). The recorded gateway is a bridge and has none, so the
|
||||
#: values are placeholders; the field names are the gateway's.
|
||||
RULE: dict[str, Any] = {
|
||||
"Index": 1,
|
||||
"Enable": True,
|
||||
"Protocol": "TCP",
|
||||
"Description": "web",
|
||||
"Interface": "IP.Interface.3",
|
||||
"ExternalPortStart": 8443,
|
||||
"ExternalPortEnd": 8443,
|
||||
"InternalPortStart": 443,
|
||||
"InternalPortEnd": 443,
|
||||
"InternalClient": "192.0.2.3",
|
||||
"SetOriginatingIP": False,
|
||||
"OriginatingIpAddress": "",
|
||||
"OriginatingSubnetMask": "255.255.255.255",
|
||||
"WANIP": "",
|
||||
"X_ZYXEL_AutoDetectWanStatus": False,
|
||||
}
|
||||
|
||||
|
||||
def _nat(*rules: dict[str, Any]) -> dict[str, Any]:
|
||||
return {**fixture("nat"), "Object": list(rules)}
|
||||
|
||||
|
||||
# --- the sealed answer ------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_the_sealed_host_list_is_decrypted_and_read():
|
||||
hosts = driver({dal("lanhosts"): LANHOSTS}).get_hosts()
|
||||
assert [(h["mac"], h["ip"]) for h in hosts] == [
|
||||
("02:00:00:00:00:02", "192.0.2.2"),
|
||||
("02:00:00:00:00:03", "192.0.2.3"),
|
||||
]
|
||||
|
||||
|
||||
def test_the_host_list_is_the_one_the_web_interface_reads():
|
||||
drv = driver({dal("lanhosts"): LANHOSTS})
|
||||
drv.get_hosts()
|
||||
assert requested(drv) == ["http://192.0.2.1:80/cgi-bin/DAL?oid=lanhosts"]
|
||||
|
||||
|
||||
def test_an_unsealed_answer_is_read_as_it_is():
|
||||
hosts = driver({dal("lanhosts"): response(200, json.dumps(LANHOSTS))}).get_hosts()
|
||||
assert len(hosts) == 2
|
||||
|
||||
|
||||
def test_an_answer_the_gateway_refused_falls_back_to_the_page():
|
||||
refused = {"result": "ZCFG_NO_SUCH_OBJECT", "Object": []}
|
||||
page = response(200, "192.0.2.4 02:00:00:00:00:04 tablet")
|
||||
hosts = driver({dal("lanhosts"): refused, "dhcp.htm": page}).get_hosts()
|
||||
assert [h["ip"] for h in hosts] == ["192.0.2.4"]
|
||||
|
||||
|
||||
def test_an_answer_that_cannot_be_decrypted_falls_back_to_the_page():
|
||||
garbled = response(
|
||||
200, json.dumps({"content": "bm90IHNlYWxlZA==", "iv": "AAAAAAAAAAAAAAAAAAAAAA=="})
|
||||
)
|
||||
page = response(200, "192.0.2.4 02:00:00:00:00:04 tablet")
|
||||
hosts = driver({dal("lanhosts"): garbled, "dhcp.htm": page}).get_hosts()
|
||||
assert [h["ip"] for h in hosts] == ["192.0.2.4"]
|
||||
|
||||
|
||||
def test_a_gateway_with_no_hosts_has_none():
|
||||
empty = copy.deepcopy(LANHOSTS)
|
||||
empty["Object"][0]["lanhosts"] = []
|
||||
assert driver({dal("lanhosts"): empty}).get_hosts() == []
|
||||
|
||||
|
||||
# --- the hosts --------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_a_recorded_host_reads_as_it_is_on_the_gateway():
|
||||
host = driver({dal("lanhosts"): LANHOSTS}).get_hosts()[0]
|
||||
assert host == {
|
||||
"mac": "02:00:00:00:00:02",
|
||||
"ip": "192.0.2.2",
|
||||
"hostname": "", # the gateway says "Unknown"
|
||||
"interface_type": "LAN",
|
||||
"is_active": True,
|
||||
}
|
||||
|
||||
|
||||
def test_a_host_name_the_gateway_knows_is_reported():
|
||||
hosts = driver({dal("lanhosts"): _with_host(HostName="printer")}).get_hosts()
|
||||
assert hosts[0]["hostname"] == "printer"
|
||||
|
||||
|
||||
def test_a_wifi_host_is_on_the_wlan():
|
||||
answer = _with_host(X_ZYXEL_ConnectionType="Wi-Fi 2.4GHz")
|
||||
assert driver({dal("lanhosts"): answer}).get_hosts()[0]["interface_type"] == "WLAN"
|
||||
|
||||
|
||||
def test_only_a_dhcp_host_has_a_lease():
|
||||
answer = _with_host(AddressSource="DHCP", LeaseTimeRemaining=3600)
|
||||
hosts = driver({dal("lanhosts"): answer}).get_hosts()
|
||||
assert hosts[0]["lease_time_remaining"] == 3600
|
||||
assert "lease_time_remaining" not in hosts[1] # AddressSource "Static"
|
||||
|
||||
|
||||
def test_an_inactive_host_is_reported_inactive():
|
||||
hosts = driver({dal("lanhosts"): _with_host(Active=False)}).get_hosts()
|
||||
assert hosts[0]["is_active"] is False
|
||||
|
||||
|
||||
def test_the_arp_table_holds_the_active_hosts():
|
||||
drv = driver({dal("lanhosts"): _with_host(Active=False)})
|
||||
assert drv.get_arp_table() == [
|
||||
{"interface": "LAN", "mac": "02:00:00:00:00:03", "ip": "192.0.2.3", "age": -1.0}
|
||||
]
|
||||
|
||||
|
||||
# --- port forwards ----------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_the_recorded_bridge_has_no_port_forwards():
|
||||
assert driver({dal("nat"): fixture("nat")}).get_port_forwards() == []
|
||||
|
||||
|
||||
def test_a_port_forward_reads_as_the_gateway_lists_it():
|
||||
forwards = driver({dal("nat"): _nat(RULE)}).get_port_forwards()
|
||||
assert forwards == [
|
||||
{
|
||||
"name": "web",
|
||||
"protocol": "TCP",
|
||||
"external_port": 8443,
|
||||
"internal_ip": "192.0.2.3",
|
||||
"internal_port": 443,
|
||||
"enabled": True,
|
||||
}
|
||||
]
|
||||
|
||||
|
||||
def test_a_forward_for_tcp_and_udp_is_one_per_protocol():
|
||||
forwards = driver({dal("nat"): _nat({**RULE, "Protocol": "ALL"})}).get_port_forwards()
|
||||
assert [f["protocol"] for f in forwards] == ["TCP", "UDP"]
|
||||
|
||||
|
||||
def test_a_disabled_forward_is_reported_disabled():
|
||||
forwards = driver({dal("nat"): _nat({**RULE, "Enable": False})}).get_port_forwards()
|
||||
assert forwards[0]["enabled"] is False
|
||||
|
||||
|
||||
def test_a_forward_limited_to_one_source_names_it():
|
||||
rule = {**RULE, "SetOriginatingIP": True, "OriginatingIpAddress": "198.51.100.7"}
|
||||
forwards = driver({dal("nat"): _nat(rule)}).get_port_forwards()
|
||||
assert forwards[0]["remote_host"] == "198.51.100.7"
|
||||
|
||||
|
||||
def test_port_forwards_are_read_from_the_nat_oid():
|
||||
drv = driver({dal("nat"): fixture("nat")})
|
||||
drv.get_port_forwards()
|
||||
assert requested(drv) == ["http://192.0.2.1:80/cgi-bin/DAL?oid=nat"]
|
||||
|
||||
|
||||
# --- Wi-Fi ------------------------------------------------------------------------------
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("getter", "oid", "empty"),
|
||||
[
|
||||
("get_wireless_clients", "WIFI_CLIENTS", []),
|
||||
("get_ssids", "WIFI_SSIDS", {}),
|
||||
("get_radio_status", "WIFI_RADIO", {}),
|
||||
],
|
||||
)
|
||||
def test_a_sealed_wifi_answer_is_decrypted(getter, oid, empty):
|
||||
"""The recorded gateway has no Wi-Fi: it answers these with an empty ``Object``."""
|
||||
assert getattr(driver({dal(oid): fixture("LAN_HOSTS")}), getter)() == empty
|
||||
|
||||
|
||||
def test_a_wifi_answer_without_object_falls_back_to_the_page():
|
||||
answer = {"result": "ZCFG_SUCCESS"}
|
||||
drv = driver({dal("WIFI_SSIDS"): answer, "wireless.htm": response(200, "")})
|
||||
drv.get_ssids()
|
||||
assert requested(drv)[-1].endswith("/wireless.htm")
|
||||
|
||||
|
||||
def test_a_wifi_client_under_object_is_read():
|
||||
"""Not recorded: the field names are the parser's, not yet checked against a gateway."""
|
||||
client = {"MACAddress": "02:00:00:00:00:05", "SSID": "guest", "Signal": -61}
|
||||
answer = {"result": "ZCFG_SUCCESS", "Object": [client]}
|
||||
clients = driver({dal("WIFI_CLIENTS"): answer}).get_wireless_clients()
|
||||
assert [(c["mac"], c["signal"]) for c in clients] == [("02:00:00:00:00:05", -61)]
|
||||
|
||||
|
||||
def test_a_failed_request_still_raises():
|
||||
drv = driver({dal("lanhosts"): requests.Response()})
|
||||
drv._session.get.side_effect = requests.ConnectTimeout("timed out") # type: ignore[union-attr]
|
||||
with pytest.raises(ConnectionException, match="timed out"):
|
||||
drv.get_hosts()
|
||||
@@ -26,6 +26,7 @@ import pytest
|
||||
import requests
|
||||
|
||||
from napalm_zyxel import ZyxelVMGDriver
|
||||
from tests import gateway
|
||||
|
||||
BASIC_INFO: dict[str, Any] = {
|
||||
"result": "ZCFG_SUCCESS",
|
||||
@@ -174,3 +175,29 @@ def test_get_facts_reads_the_status_page_once():
|
||||
def test_get_facts_raises_when_the_status_page_cannot_be_read():
|
||||
with pytest.raises(RuntimeError, match="cardpage_status"):
|
||||
_driver(status=_response(500)).get_facts()
|
||||
|
||||
|
||||
# --- the recorded answers (#24) ---------------------------------------------------------
|
||||
|
||||
|
||||
def test_the_facts_of_the_recorded_gateway():
|
||||
"""``getBasicInformation`` gives model and firmware only; nothing else is read from
|
||||
it. The status page is the full recorded one, sealed (``tests/gateway.py``)."""
|
||||
drv = gateway.driver(
|
||||
{gateway.dal("cardpage_status"): gateway.fixture("cardpage_status"), SYSTEM_PATH: SYSTEM}
|
||||
)
|
||||
assert drv._device_info == gateway.fixture("getBasicInformation")
|
||||
assert drv.get_facts() == {
|
||||
"vendor": "Zyxel",
|
||||
"model": "VMG4005-B50A",
|
||||
"serial_number": "S000Y00000001",
|
||||
"os_version": "V5.17(ABQA.3.1)C0",
|
||||
"hostname": "VMG4005-B50A",
|
||||
"fqdn": "VMG4005-B50A.home",
|
||||
"uptime": 13554213,
|
||||
"interface_list": ["br0", "atm0.1", "ptm0.2", "eth1"],
|
||||
}
|
||||
|
||||
|
||||
def test_basic_information_is_the_recorded_answer():
|
||||
assert BASIC_INFO == gateway.fixture("getBasicInformation")
|
||||
@@ -18,8 +18,9 @@ import requests
|
||||
from napalm.base.exceptions import ConnectionException
|
||||
|
||||
from napalm_zyxel import ZyxelVMGDriver
|
||||
from tests.gateway import fixture
|
||||
|
||||
HOSTS_DAL = {"hosts": [{"MACAddress": "AA:BB:CC:DD:EE:01", "IPAddress": "192.168.1.33"}]}
|
||||
HOSTS_DAL = fixture("lanhosts") # tests/gateway.py
|
||||
HOSTS_PAGE = "192.168.1.34 aa:bb:cc:dd:ee:02 tablet"
|
||||
|
||||
|
||||
@@ -102,8 +103,8 @@ def test_a_reboot_that_fails_to_reach_the_gateway_raises():
|
||||
@pytest.mark.parametrize(
|
||||
("getter", "oid", "page"),
|
||||
[
|
||||
("get_hosts", "LAN_HOSTS", "dhcp.htm"),
|
||||
("get_port_forwards", "NAT_PORTMAP", "Status.htm"),
|
||||
("get_hosts", "lanhosts", "dhcp.htm"),
|
||||
("get_port_forwards", "nat", "Status.htm"),
|
||||
("get_wireless_clients", "WIFI_CLIENTS", "wireless.htm"),
|
||||
("get_ssids", "WIFI_SSIDS", "wireless.htm"),
|
||||
("get_radio_status", "WIFI_RADIO", "wireless.htm"),
|
||||
@@ -118,25 +119,26 @@ def test_a_getter_raises_when_neither_the_dal_nor_the_page_can_be_read(getter, o
|
||||
|
||||
|
||||
def test_get_arp_table_raises_when_the_hosts_cannot_be_read():
|
||||
driver = _driver({"cgi-bin/DAL?oid=LAN_HOSTS": _response(500), "dhcp.htm": _response(500)})
|
||||
driver = _driver({"cgi-bin/DAL?oid=lanhosts": _response(500), "dhcp.htm": _response(500)})
|
||||
with pytest.raises(RuntimeError):
|
||||
driver.get_arp_table()
|
||||
|
||||
|
||||
def test_a_failed_dal_request_falls_back_to_the_page():
|
||||
driver = _driver(
|
||||
{"cgi-bin/DAL?oid=LAN_HOSTS": _response(500), "dhcp.htm": _response(200, HOSTS_PAGE)}
|
||||
{"cgi-bin/DAL?oid=lanhosts": _response(500), "dhcp.htm": _response(200, HOSTS_PAGE)}
|
||||
)
|
||||
assert [h["ip"] for h in driver.get_hosts()] == ["192.168.1.34"]
|
||||
|
||||
|
||||
def test_the_dal_answer_is_used_when_there_is_one():
|
||||
driver = _driver({"cgi-bin/DAL?oid=LAN_HOSTS": _response(200, json.dumps(HOSTS_DAL))})
|
||||
assert [h["ip"] for h in driver.get_hosts()] == ["192.168.1.33"]
|
||||
driver = _driver({"cgi-bin/DAL?oid=lanhosts": _response(200, json.dumps(HOSTS_DAL))})
|
||||
assert [h["ip"] for h in driver.get_hosts()] == ["192.0.2.2", "192.0.2.3"]
|
||||
|
||||
|
||||
def test_a_gateway_that_lists_no_hosts_has_none():
|
||||
driver = _driver({"cgi-bin/DAL?oid=LAN_HOSTS": _response(200, '{"hosts": []}')})
|
||||
answer = {"result": "ZCFG_SUCCESS", "Object": [{"lanhosts": []}]}
|
||||
driver = _driver({"cgi-bin/DAL?oid=lanhosts": _response(200, json.dumps(answer))})
|
||||
assert driver.get_hosts() == []
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,192 @@
|
||||
"""The uplink's state is the gateway's own: the DSL line and the WAN interfaces (#29).
|
||||
|
||||
``get_wan_status`` built its answer from ``WanIp``, ``WanAccessType``,
|
||||
``SystemUpTime``, ``MaxUpstream`` and ``MaxDownstream`` in ``getBasicInformation``.
|
||||
A VMG4005-B50A sends none of them there, so every gateway's uplink read as down,
|
||||
with no address and no sync rate, whatever its line did. ``get_nat_translations``
|
||||
built ``inside_global`` from the same ``WanIp`` and reported ``":<port>"``.
|
||||
|
||||
The line state is in the DAL's ``cardpage_status``: ``DslChannelInfo[]`` (a channel
|
||||
whose ``Status`` is ``Up`` is in sync; its rates are in kbit/s) and the
|
||||
``WanLanInfo[]`` entries of ``X_ZYXEL_Type`` ``WAN``. A bridge has no WAN address
|
||||
of its own: there, connected means the DSL line is in sync.
|
||||
|
||||
``STATUS`` is that answer from a VMG4005-B50A bridge whose line was not in sync
|
||||
when it was recorded (``tests/gateway.py``). The other states change it the way
|
||||
TR-181 and the recorded fields describe them: they were not recorded.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
from typing import Any
|
||||
|
||||
import pytest
|
||||
|
||||
from tests.gateway import dal, driver, fixture, requested, response
|
||||
|
||||
STATUS = fixture("cardpage_status")
|
||||
PTM_LINE_2 = 3 # DslChannelInfo: the channel that carries the recorded sync rates
|
||||
|
||||
|
||||
def _status(
|
||||
channels: dict[int, dict[str, Any]] | None = None, wan: dict[str, Any] | None = None
|
||||
) -> dict[str, Any]:
|
||||
"""The recorded status page with *channels* (index: changes) and *wan* (changes to
|
||||
the ``ptm0.2`` WAN interface) applied."""
|
||||
answer = copy.deepcopy(STATUS)
|
||||
page = answer["Object"][0]
|
||||
for index, changes in (channels or {}).items():
|
||||
page["DslChannelInfo"][index].update(changes)
|
||||
for entry in page["WanLanInfo"]:
|
||||
if entry["X_ZYXEL_IfName"] == "ptm0.2":
|
||||
entry.update(wan or {})
|
||||
return answer
|
||||
|
||||
|
||||
IN_SYNC = _status({PTM_LINE_2: {"Status": "Up"}}, {"Status": "Up"})
|
||||
|
||||
ROUTED = {
|
||||
"X_ZYXEL_ConnectionType": "IP_Routed",
|
||||
"Encapsulation": "PPPoE",
|
||||
"Status": "Up",
|
||||
"X_ZYXEL_UpTime": 7200,
|
||||
"IPv4Address": [
|
||||
{
|
||||
"Enable": True,
|
||||
"IPAddress": "203.0.113.10",
|
||||
"SubnetMask": "255.255.255.255",
|
||||
"Status": "Enabled",
|
||||
}
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
def _wan(answer: dict[str, Any]) -> Any:
|
||||
return driver({dal("cardpage_status"): answer}).get_wan_status()
|
||||
|
||||
|
||||
# --- a bridge -----------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_a_bridge_whose_line_is_not_in_sync_is_down():
|
||||
assert _wan(STATUS) == {
|
||||
"connection_type": "DSL",
|
||||
"is_connected": False,
|
||||
"external_ip": "",
|
||||
"uptime": 0,
|
||||
"bytes_sent": 0,
|
||||
"bytes_received": 0,
|
||||
"max_bitrate_up": 0,
|
||||
"max_bitrate_down": 0,
|
||||
"link_status": "Down",
|
||||
}
|
||||
|
||||
|
||||
def test_a_bridge_whose_line_is_in_sync_is_connected():
|
||||
status = _wan(IN_SYNC)
|
||||
assert (status["is_connected"], status["link_status"]) == (True, "Up")
|
||||
assert status["external_ip"] == "" # a bridge has no WAN address
|
||||
|
||||
|
||||
def test_the_sync_rates_are_the_channels_in_kbit_per_second():
|
||||
status = _wan(IN_SYNC)
|
||||
assert (status["max_bitrate_up"], status["max_bitrate_down"]) == (45875, 274098)
|
||||
|
||||
|
||||
def test_the_rates_of_a_line_out_of_sync_are_not_reported():
|
||||
"""The recorded channel keeps the rates of its last sync while it is down."""
|
||||
status = _wan(STATUS)
|
||||
assert (status["max_bitrate_up"], status["max_bitrate_down"]) == (0, 0)
|
||||
|
||||
|
||||
def test_bonded_lines_add_up():
|
||||
rates = {"UpstreamCurrRate": 40000, "DownstreamCurrRate": 100000}
|
||||
answer = _status({1: {"Status": "Up", **rates}, PTM_LINE_2: {"Status": "Up"}})
|
||||
status = _wan(answer)
|
||||
assert (status["max_bitrate_up"], status["max_bitrate_down"]) == (85875, 374098)
|
||||
|
||||
|
||||
def test_the_line_uptime_is_reported_when_the_gateway_gives_one():
|
||||
answer = _status({PTM_LINE_2: {"Status": "Up", "DSLUpTime": "5400"}})
|
||||
assert _wan(answer)["uptime"] == 5400
|
||||
|
||||
|
||||
def test_a_line_uptime_that_is_not_a_number_is_unknown():
|
||||
answer = _status({PTM_LINE_2: {"Status": "Up", "DSLUpTime": ""}})
|
||||
assert _wan(answer)["uptime"] == 0
|
||||
|
||||
|
||||
# --- a router -----------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_a_router_with_a_wan_address_is_connected_with_it():
|
||||
status = _wan(_status({PTM_LINE_2: {"Status": "Up"}}, ROUTED))
|
||||
assert status["is_connected"] is True
|
||||
assert status["external_ip"] == "203.0.113.10"
|
||||
assert status["connection_type"] == "PPPoE"
|
||||
assert status["uptime"] == 7200
|
||||
|
||||
|
||||
def test_a_router_whose_line_is_in_sync_but_its_wan_down_is_not_connected():
|
||||
wan = {**ROUTED, "Status": "Down", "IPv4Address": []}
|
||||
status = _wan(_status({PTM_LINE_2: {"Status": "Up"}}, wan))
|
||||
assert (status["is_connected"], status["link_status"]) == (False, "Up")
|
||||
assert status["external_ip"] == ""
|
||||
|
||||
|
||||
def test_a_disabled_wan_address_is_not_the_external_one():
|
||||
addresses = [{**ROUTED["IPv4Address"][0], "Enable": False}]
|
||||
status = _wan(_status({PTM_LINE_2: {"Status": "Up"}}, {**ROUTED, "IPv4Address": addresses}))
|
||||
assert (status["is_connected"], status["external_ip"]) == (False, "")
|
||||
|
||||
|
||||
# --- reading ------------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_basic_information_is_not_read_for_it():
|
||||
drv = driver({dal("cardpage_status"): IN_SYNC})
|
||||
drv._device_info = {**fixture("getBasicInformation"), "WanIp": "198.51.100.1"}
|
||||
assert drv.get_wan_status()["external_ip"] == ""
|
||||
|
||||
|
||||
def test_get_wan_status_raises_when_the_status_page_cannot_be_read():
|
||||
with pytest.raises(RuntimeError, match="cardpage_status"):
|
||||
_wan(response(500)) # type: ignore[arg-type]
|
||||
|
||||
|
||||
# --- NAT translations ---------------------------------------------------------------------
|
||||
|
||||
RULE = {
|
||||
"Enable": True,
|
||||
"Protocol": "TCP",
|
||||
"Description": "web",
|
||||
"ExternalPortStart": 8443,
|
||||
"InternalPortStart": 443,
|
||||
"InternalClient": "192.0.2.3",
|
||||
}
|
||||
|
||||
|
||||
def _nat_driver(status: Any) -> Any:
|
||||
return driver(
|
||||
{dal("nat"): {**fixture("nat"), "Object": [RULE]}, dal("cardpage_status"): status}
|
||||
)
|
||||
|
||||
|
||||
def test_a_translation_is_to_the_wan_address():
|
||||
status = _status({PTM_LINE_2: {"Status": "Up"}}, ROUTED)
|
||||
nat = _nat_driver(status).get_nat_translations()
|
||||
assert [(t["inside_local"], t["inside_global"]) for t in nat] == [
|
||||
("192.0.2.3:443", "203.0.113.10:8443")
|
||||
]
|
||||
|
||||
|
||||
def test_without_a_wan_address_a_translation_is_to_any_address():
|
||||
nat = _nat_driver(STATUS).get_nat_translations()
|
||||
assert [t["inside_global"] for t in nat] == ["0.0.0.0:8443"]
|
||||
|
||||
|
||||
def test_without_port_forwards_the_status_page_is_not_read():
|
||||
drv = driver({dal("nat"): fixture("nat")})
|
||||
assert drv.get_nat_translations() == []
|
||||
assert requested(drv) == ["http://192.0.2.1:80/cgi-bin/DAL?oid=nat"]
|
||||
+34
-92
@@ -6,18 +6,11 @@ import requests
|
||||
from napalm.base.exceptions import ConnectionException
|
||||
|
||||
from napalm_zyxel import ZyxelVMGDriver
|
||||
from tests.gateway import fixture
|
||||
|
||||
MOCK_BASIC_INFO = {
|
||||
"ModelName": "VMG4005-B50A",
|
||||
"SoftwareVersion": "V5.13(ABKS.1)C0",
|
||||
"WanIp": "85.2.34.56",
|
||||
"LanIp": "192.168.1.1",
|
||||
"MacAddress": "00:1A:2B:3C:4D:5E",
|
||||
"SystemUpTime": "1234567",
|
||||
"WanAccessType": "VDSL",
|
||||
"MaxUpstream": "30000000",
|
||||
"MaxDownstream": "100000000",
|
||||
}
|
||||
#: The recorded getBasicInformation answer of a VMG4005-B50A: model and firmware, no
|
||||
#: serial number, host name, uptime, MAC or WAN state (#24). tests/gateway.py
|
||||
MOCK_BASIC_INFO = fixture("getBasicInformation")
|
||||
|
||||
MOCK_RSA_KEY = (
|
||||
"-----BEGIN PUBLIC KEY-----\n"
|
||||
@@ -86,10 +79,9 @@ class TestZyxelVMGDriver:
|
||||
if "getRSAPublickKey" in url:
|
||||
return MockResponse({"RSAPublicKey": MOCK_RSA_KEY})
|
||||
if "cgi-bin/System?oid=snmp" in url: # tests/test_facts.py
|
||||
return MockResponse([{"HostName": "ZyxelVMG", "DomainName": "home"}])
|
||||
return MockResponse([{"HostName": "VMG4005-B50A", "DomainName": "home"}])
|
||||
if "cgi-bin/DAL?oid=cardpage_status" in url: # tests/test_facts.py
|
||||
device = {"SerialNumber": "S220L12345678", "UpTime": 1234567}
|
||||
return MockResponse({"result": "ZCFG_SUCCESS", "Object": [{"DeviceInfo": device}]})
|
||||
return MockResponse(fixture("cardpage_status"))
|
||||
if "UserLogout" in url:
|
||||
return MockResponse({})
|
||||
return MockResponse({})
|
||||
@@ -182,18 +174,11 @@ class TestZyxelVMGDriver:
|
||||
facts = self.driver.get_facts()
|
||||
assert facts["vendor"] == "Zyxel"
|
||||
assert facts["model"] == "VMG4005-B50A"
|
||||
assert facts["serial_number"] == "S220L12345678"
|
||||
assert facts["os_version"] == "V5.13(ABKS.1)C0"
|
||||
assert facts["hostname"] == "ZyxelVMG"
|
||||
assert facts["fqdn"] == "ZyxelVMG.home"
|
||||
assert facts["uptime"] == 1234567
|
||||
|
||||
def test_get_wan_status(self):
|
||||
self._setup_mocked_http()
|
||||
status = self.driver.get_wan_status()
|
||||
assert status["is_connected"] is True
|
||||
assert status["external_ip"] == "85.2.34.56"
|
||||
assert status["connection_type"] == "VDSL"
|
||||
assert facts["serial_number"] == "S000Y00000001"
|
||||
assert facts["os_version"] == "V5.17(ABQA.3.1)C0"
|
||||
assert facts["hostname"] == "VMG4005-B50A"
|
||||
assert facts["fqdn"] == "VMG4005-B50A.home"
|
||||
assert facts["uptime"] == 13554213
|
||||
|
||||
def test_get_port_forwards_empty(self):
|
||||
self._setup_mocked_http()
|
||||
@@ -333,61 +318,20 @@ class TestZyxelVMGDriver:
|
||||
with pytest.raises(ConnectionClosedException):
|
||||
self.driver._dal_query("PINGTEST", {})
|
||||
|
||||
def test_parse_port_forwards_dal(self):
|
||||
self._setup_mocked_http()
|
||||
data = {
|
||||
"NATPortMap": [
|
||||
{
|
||||
"Description": "Web Server",
|
||||
"Protocol": "TCP",
|
||||
"ExternalPort": 80,
|
||||
"InternalIP": "192.168.1.10",
|
||||
"InternalPort": 8080,
|
||||
"Enabled": True,
|
||||
}
|
||||
]
|
||||
}
|
||||
result = self.driver._parse_port_forwards_dal(data)
|
||||
assert len(result) == 1
|
||||
assert result[0]["name"] == "Web Server"
|
||||
assert result[0]["external_port"] == 80
|
||||
assert result[0]["internal_ip"] == "192.168.1.10"
|
||||
|
||||
def test_parse_hosts_dal(self):
|
||||
self._setup_mocked_http()
|
||||
data = {
|
||||
"LANHosts": [
|
||||
{
|
||||
"MACAddress": "aa:bb:cc:dd:ee:ff",
|
||||
"IPAddress": "192.168.1.100",
|
||||
"HostName": "laptop",
|
||||
"InterfaceType": "lan",
|
||||
"Active": True,
|
||||
}
|
||||
]
|
||||
}
|
||||
result = self.driver._parse_hosts_dal(data)
|
||||
assert len(result) == 1
|
||||
assert result[0]["mac"] == "aa:bb:cc:dd:ee:ff"
|
||||
assert result[0]["ip"] == "192.168.1.100"
|
||||
assert result[0]["hostname"] == "laptop"
|
||||
|
||||
def test_parse_wireless_clients_dal(self):
|
||||
self._setup_mocked_http()
|
||||
data = {
|
||||
"assoc": [
|
||||
{
|
||||
"MACAddress": "11:22:33:44:55:66",
|
||||
"SSID": "MyWiFi",
|
||||
"Radio": "wlan0",
|
||||
"Signal": -45,
|
||||
"TxRate": 300.0,
|
||||
"RxRate": 150.0,
|
||||
"Uptime": 3600,
|
||||
"IPAddress": "192.168.1.50",
|
||||
}
|
||||
]
|
||||
}
|
||||
data = [
|
||||
{
|
||||
"MACAddress": "11:22:33:44:55:66",
|
||||
"SSID": "MyWiFi",
|
||||
"Radio": "wlan0",
|
||||
"Signal": -45,
|
||||
"TxRate": 300.0,
|
||||
"RxRate": 150.0,
|
||||
"Uptime": 3600,
|
||||
"IPAddress": "192.168.1.50",
|
||||
}
|
||||
]
|
||||
result = self.driver._parse_wireless_clients_dal(data)
|
||||
assert len(result) == 1
|
||||
assert result[0]["mac"] == "11:22:33:44:55:66"
|
||||
@@ -396,19 +340,17 @@ class TestZyxelVMGDriver:
|
||||
|
||||
def test_parse_ssids_dal(self):
|
||||
self._setup_mocked_http()
|
||||
data = {
|
||||
"ssids": [
|
||||
{
|
||||
"SSID": "MyWiFi",
|
||||
"Radio": "wlan0",
|
||||
"BSSID": "00:1a:2b:3c:4d:5e",
|
||||
"Encryption": "WPA2",
|
||||
"Enabled": True,
|
||||
"Hidden": False,
|
||||
"Clients": 3,
|
||||
}
|
||||
]
|
||||
}
|
||||
data = [
|
||||
{
|
||||
"SSID": "MyWiFi",
|
||||
"Radio": "wlan0",
|
||||
"BSSID": "00:1a:2b:3c:4d:5e",
|
||||
"Encryption": "WPA2",
|
||||
"Enabled": True,
|
||||
"Hidden": False,
|
||||
"Clients": 3,
|
||||
}
|
||||
]
|
||||
result = self.driver._parse_ssids_dal(data)
|
||||
assert "MyWiFi" in result
|
||||
assert result["MyWiFi"]["encryption"] == "WPA2"
|
||||
|
||||
Reference in new issue
Block a user