Implement P2P protocol for device control

Author: keshavdv

.gitignore

@@ -6,3 +6,4 @@ coverage.xml
 poetry.lock
 tags
 __pycache__
+.vscode/

AUTHORS.md

@@ -3,3 +3,4 @@
 * Aaron Bach (https://github.com/bachya)
 * Alexander Bessonov (https://github.com/nonsleepr)
 * Fuzzy (https://github.com/FuzzyMistborn)
+* Keshav (https://github.com/keshavdv)

eufy_security/api.py

@@ -8,6 +8,8 @@
 
 from .camera import Camera
 from .errors import InvalidCredentialsError, RequestError, raise_error
+from .station import Station
+from .types import DeviceType
 
 _LOGGER: logging.Logger = logging.getLogger(__name__)
 
@@ -28,6 +30,7 @@ def __init__(self, email: str, password: str, websession: ClientSession) -> None
         self._token_expiration: Optional[datetime] = None
 
         self.cameras: Dict[str, Camera] = {}
+        self.stations: Dict[str, Station] = {}
 
     async def async_authenticate(self) -> None:
         """Authenticate and get an access token."""
@@ -54,17 +57,33 @@ async def async_get_history(self) -> dict:
 
     async def async_update_device_info(self) -> None:
         """Get the latest device info."""
+        # Cameras
         devices_resp = await self.request("post", "app/get_devs_list")
 
         if not devices_resp.get("data"):
             return
 
         for device_info in devices_resp["data"]:
-            if device_info["device_sn"] in self.cameras:
-                camera = self.cameras[device_info["device_sn"]]
-                camera.camera_info = device_info
-                continue
-            self.cameras[device_info["device_sn"]] = Camera(self, device_info)
+            if DeviceType(device_info["device_type"]).is_camera():
+                if device_info["device_sn"] in self.cameras:
+                    camera = self.cameras[device_info["device_sn"]]
+                    camera.camera_info = device_info
+                    continue
+                self.cameras[device_info["device_sn"]] = Camera(self, device_info)
+
+        # Stations
+        stations_resp = await self.request("post", "app/get_hub_list")
+
+        if not stations_resp.get("data"):
+            return
+
+        for device_info in stations_resp["data"]:
+            if DeviceType(device_info["device_type"]).is_station():
+                if device_info["station_sn"] in self.stations:
+                    station = self.stations[device_info["station_sn"]]
+                    station.station_info = device_info
+                    continue
+                self.stations[device_info["station_sn"]] = Station(self, device_info)
 
     async def request(
         self,

eufy_security/camera.py

@@ -2,7 +2,7 @@
 import logging
 from typing import TYPE_CHECKING
 
-from .params import ParamType
+from .types import DeviceType, ParamType
 
 if TYPE_CHECKING:
     from .api import API  # pylint: disable=cyclic-import
@@ -18,6 +18,11 @@ def __init__(self, api: "API", camera_info: dict) -> None:
         self._api = api
         self.camera_info: dict = camera_info
 
+    @property
+    def device_type(self) -> str:
+        """Return the station's device type."""
+        return DeviceType(self.camera_info["device_type"])
+
     @property
     def hardware_version(self) -> str:
         """Return the camera's hardware version."""

eufy_security/errors.py

@@ -20,6 +20,12 @@ class RequestError(EufySecurityError):
     pass
 
 
+class EufySecurityP2PError(Exception):
+    """Define a P2P related error."""
+
+    pass
+
+
 ERRORS: Dict[int, Type[EufySecurityError]] = {26006: InvalidCredentialsError}
 
 

eufy_security/p2p/discovery.py

@@ -0,0 +1,69 @@
+import asyncio
+
+from .lib32100 import BaseP2PClientProtocol
+from .types import (
+    P2PClientProtocolRequestMessageType,
+    P2PClientProtocolResponseMessageType,
+)
+
+
+class DiscoveryP2PClientProtocol(BaseP2PClientProtocol):
+    def __init__(self, loop, p2p_did: str, key: str, on_conn_lost):
+        self.loop = loop
+        self.p2p_did = p2p_did
+        self.key = key
+        self.on_conn_lost = on_conn_lost
+        self.transport = None
+        self.addresses = []
+        self.response_count = 0
+
+    def connection_made(self, transport):
+        self.transport = transport
+
+        # Build payload
+        p2p_did_components = self.p2p_did.split("-")
+        payload = bytearray(p2p_did_components[0].encode())
+        payload.extend(int(p2p_did_components[1]).to_bytes(5, byteorder="big"))
+        payload.extend(p2p_did_components[2].encode())
+        payload.extend([0x00, 0x00, 0x00, 0x00, 0x00])
+        ip, port = self.transport.get_extra_info("sockname")
+        payload.extend(port.to_bytes(2, byteorder="little"))
+        payload.extend([int(x) for x in ip.split(".")[::-1]])
+        payload.extend(
+            [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00]
+        )
+        payload.extend(self.key.encode())
+        payload.extend([0x00, 0x00, 0x00, 0x00])
+
+        self.transport.sendto(
+            self.create_message(
+                P2PClientProtocolRequestMessageType.LOOKUP_WITH_KEY, payload
+            )
+        )
+        # Manually timeout if we don't get an answer
+        self.loop.create_task(self.timeout(1.5))
+
+    async def timeout(self, seconds: float):
+        await asyncio.sleep(seconds)
+        self.transport.close()
+
+    def process_response(
+        self, msg_type: P2PClientProtocolResponseMessageType, payload: bytes
+    ):
+        msg = payload[2:]
+        if msg_type == P2PClientProtocolResponseMessageType.LOOKUP_ADDR:
+            port = payload[5] * 256 + payload[4]
+            ip = f"{payload[9]}.{payload[8]}.{payload[7]}.{payload[6]}"
+            self.addresses.append((ip, port))
+
+            # We expect at most two IP/port combos so we can bail early
+            # if we received both
+            self.response_count += 1
+            if self.response_count == 2:
+                self.transport.close()
+
+    def error_received(self, exc):
+        _LOGGER.exception("Error received", exc_info=exc)
+
+    def connection_lost(self, exc):
+        self.on_conn_lost.set_result(self.addresses)

eufy_security/p2p/lib32100.py

@@ -0,0 +1,29 @@
+import math
+
+from .types import (
+    P2PClientProtocolRequestMessageType,
+    P2PClientProtocolResponseMessageType,
+)
+
+
+class BaseP2PClientProtocol:
+    def create_message(
+        self, msg_type: P2PClientProtocolRequestMessageType, payload=bytearray()
+    ):
+        msg = bytearray()
+        msg.extend(msg_type.value)
+        payload_size = len(payload)
+        msg.append(math.floor(payload_size / 256))
+        msg.append(payload_size % 256)
+        msg.extend(payload)
+        return msg
+
+    def datagram_received(self, data, _):
+        msg_type = P2PClientProtocolResponseMessageType(bytes(data[0:2]))
+        payload = data[2:]
+        self.process_response(msg_type, payload)
+
+    def process_response(
+        self, msg_type: P2PClientProtocolResponseMessageType, payload: bytes
+    ):
+        raise NotImplementedError()