wolsocketproxy 0.1.0__tar.gz

wolsocketproxy-0.1.0/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2024 Song Fuchang
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

wolsocketproxy-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.1
+Name: wolsocketproxy
+Version: 0.1.0
+Summary: A socket proxy with wake-on-lan feature.
+License: Apache-2.0
+Author: Song Fuchang
+Author-email: song.fc@gmail.com
+Requires-Python: >=3.11,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Networking
+Requires-Dist: dataclass-wizard (==0.28.0)
+Requires-Dist: icmplib (==3.0.4)
+Requires-Dist: wakeonlan (==3.1.0)
+Project-URL: Changelog, https://github.com/notsyncing/wol-socket-proxy/releases
+Project-URL: Issues, https://github.com/notsyncing/wol-socket-proxy/issues
+Description-Content-Type: text/markdown
+
+# wol-socket-proxy
+
+A socket proxy with wake-on-lan feature.
+
+It can forward TCP(bidirectional) and UDP(send-only) traffic from local machine to remote machine, and send a magic packet to wake it (wake-on-lan) before forwarding traffic if the remote machine does not respond to ICMP ping.
+
+## Requirements
+
+Python 3.11+
+
+The remote machine must accept and respond to ICMP ping requests.
+
+## Usage
+
+You can install it from PyPI or use a prebuilt docker image.
+
+### Install from PyPI
+
+Simply install it:
+
+```
+pip install wolsocketproxy
+```
+
+Then create a config file:
+
+```
+cp wolsocketproxy.conf.example /etc/wolsocketproxy.conf
+```
+
+Modify the config file as your requirements.
+
+Finally, run it
+
+```
+wolsocketproxy
+```
+
+### Use prebuilt docker image
+
+See `docker/docker-compose.yml` for more details.
+
+## Config
+
+The `wolsocketproxy.conf` has the following structure:
+
+```json5
+{
+    // NOTE: Comments are not allowed in actual config file
+    // Define forwarding routes
+    "routes": [
+        {
+            "local_address": "0.0.0.0",         // The local address to listen
+            "local_port": 12345,                // The local port to listen
+            "target_address": "192.168.0.100",  // The target address forwarding to
+            "target_port": 22,                  // The target port forwarding to
+            "protocol": "tcp"                   // The protocol to use
+        },
+        // ... more routes ...
+    ],
+
+    // Tell the program about the MAC address of each IP in routes
+    "mac_mappings": {
+        // Key is IP address, and value is MAC address, case-insensitive
+        "192.168.0.100": "11:22:33:44:55:66",
+        // ... more items ...
+    }
+}
+```
+

wolsocketproxy-0.1.0/README.md

@@ -0,0 +1,69 @@
+# wol-socket-proxy
+
+A socket proxy with wake-on-lan feature.
+
+It can forward TCP(bidirectional) and UDP(send-only) traffic from local machine to remote machine, and send a magic packet to wake it (wake-on-lan) before forwarding traffic if the remote machine does not respond to ICMP ping.
+
+## Requirements
+
+Python 3.11+
+
+The remote machine must accept and respond to ICMP ping requests.
+
+## Usage
+
+You can install it from PyPI or use a prebuilt docker image.
+
+### Install from PyPI
+
+Simply install it:
+
+```
+pip install wolsocketproxy
+```
+
+Then create a config file:
+
+```
+cp wolsocketproxy.conf.example /etc/wolsocketproxy.conf
+```
+
+Modify the config file as your requirements.
+
+Finally, run it
+
+```
+wolsocketproxy
+```
+
+### Use prebuilt docker image
+
+See `docker/docker-compose.yml` for more details.
+
+## Config
+
+The `wolsocketproxy.conf` has the following structure:
+
+```json5
+{
+    // NOTE: Comments are not allowed in actual config file
+    // Define forwarding routes
+    "routes": [
+        {
+            "local_address": "0.0.0.0",         // The local address to listen
+            "local_port": 12345,                // The local port to listen
+            "target_address": "192.168.0.100",  // The target address forwarding to
+            "target_port": 22,                  // The target port forwarding to
+            "protocol": "tcp"                   // The protocol to use
+        },
+        // ... more routes ...
+    ],
+
+    // Tell the program about the MAC address of each IP in routes
+    "mac_mappings": {
+        // Key is IP address, and value is MAC address, case-insensitive
+        "192.168.0.100": "11:22:33:44:55:66",
+        // ... more items ...
+    }
+}
+```

wolsocketproxy-0.1.0/pyproject.toml

@@ -0,0 +1,69 @@
+[tool.poetry]
+name = "wolsocketproxy"
+version = "0.1.0"
+description = "A socket proxy with wake-on-lan feature."
+authors = ["Song Fuchang <song.fc@gmail.com>"]
+license = "Apache-2.0"
+readme = "README.md"
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "Topic :: System :: Networking"
+]
+
+[tool.poetry.urls]
+Changelog = "https://github.com/notsyncing/wol-socket-proxy/releases"
+Issues = "https://github.com/notsyncing/wol-socket-proxy/issues"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+wakeonlan = "3.1.0"
+dataclass-wizard = "0.28.0"
+icmplib = "3.0.4"
+
+[tool.poetry.dev-dependencies]
+mypy = { version = "*", python = ">=3.11" }
+ruff = { version = "*", python = ">=3.11" }
+
+[tool.poetry.scripts]
+wolsocketproxy = "wolsocketproxy:main"
+
+[tool.ruff]
+line-length = 120
+src = ["wolsocketproxy"]
+target-version = "py311"
+lint.select = ["ALL"]
+lint.ignore = [
+    "COM812",
+    "D100",
+    "D101",
+    "D102",
+    "D103",
+    "D104",
+    "D107",
+    "D203",
+    "D211",
+    "D213",
+    "EM102",
+    "FBT001",
+    "FBT003",
+    "ISC001",
+    "TRY003",
+    "TRY201",
+]
+
+[tool.mypy]
+disallow_untyped_defs = true # Functions need to be annotated
+warn_unused_ignores = true
+ignore_missing_imports = true
+
+
+[[tool.poetry.source]]
+name = "mirrors"
+url = "https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple/"
+priority = "primary"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

wolsocketproxy-0.1.0/wolsocketproxy/__init__.py

@@ -0,0 +1,44 @@
+import json
+import logging
+from argparse import ArgumentParser
+from pathlib import Path
+
+import dataclass_wizard
+
+from wolsocketproxy.proxy import Proxy, ProxyConfig
+
+
+def main() -> None:
+    logging.basicConfig(level=logging.INFO)
+    log = logging.getLogger()
+
+    parser = ArgumentParser(prog="wolsocketproxy", description="A socket proxy with wake-on-lan feature.")
+
+    parser.add_argument(
+        "-c",
+        "--config",
+        help="The config file to use, default lookup order: /etc/wolsocketproxy.conf, ./wolsocketproxy.conf",
+    )
+
+    args = parser.parse_args()
+    config_path: Path
+
+    if "config" in args and args.config is not None:
+        config_path = Path(args.config)
+    else:
+        config_path = Path("/etc/wolsocketproxy.conf")
+
+        if not config_path.exists():
+            config_path = Path("./wolsocketproxy.conf")
+
+    if not config_path.exists():
+        log.error("Config file path %s does not exist!", config_path)
+        return
+
+    config_data = json.loads(config_path.read_text())
+    config = dataclass_wizard.fromdict(ProxyConfig, config_data)
+
+    log.info("Loaded config from %s", config_path)
+
+    proxy = Proxy(config)
+    proxy.start()

wolsocketproxy-0.1.0/wolsocketproxy/__main__.py

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

wolsocketproxy-0.1.0/wolsocketproxy/monitor.py

@@ -0,0 +1,48 @@
+import logging
+import time
+from collections.abc import Collection
+from logging import Logger
+from threading import Thread
+
+from icmplib import multiping
+
+
+class Monitor:
+    _log: Logger = logging.getLogger()
+    _ip_state: dict[str, bool]
+
+    def __init__(self, watching_ip_list: Collection[str]) -> None:
+        self._ip_state = {}
+
+        for ip in watching_ip_list:
+            self._ip_state[ip] = False
+
+    def start(self) -> None:
+        t = Thread(target=self.__check_ip_state)
+        t.daemon = True
+        t.start()
+
+    def __check_ip_state(self) -> None:
+        self._log.info("IP monitor is started.")
+
+        while True:
+            ip_list = self._ip_state.keys()
+            results = multiping(ip_list, count=3, timeout=2, privileged=False)
+
+            for result in results:
+                original_state = self._ip_state[result.address]
+                self._ip_state[result.address] = result.is_alive
+
+                if original_state != result.is_alive:
+                    if original_state is False:
+                        self._log.info("Target %s now online.", result.address)
+                    else:
+                        self._log.info("Target %s now offline.", result.address)
+
+            time.sleep(1)
+
+    def report_availablity(self, ip: str, available: bool) -> None:
+        self._ip_state[ip] = available
+
+    def is_available(self, ip: str) -> bool:
+        return self._ip_state.get(ip, False)

wolsocketproxy-0.1.0/wolsocketproxy/proxy.py

@@ -0,0 +1,175 @@
+import asyncio
+import contextlib
+import logging
+import time
+from dataclasses import dataclass
+from logging import Logger
+from typing import Any, Literal, override
+
+import wakeonlan
+
+from wolsocketproxy.monitor import Monitor
+
+WOL_MAX_WAIT_COUNT = 60
+
+
+@dataclass
+class ProxyRoute:
+    local_address: str
+    local_port: int
+    target_address: str
+    target_port: int
+    protocol: Literal["tcp", "udp"]
+
+
+@dataclass
+class ProxyConfig:
+    routes: list[ProxyRoute]
+    mac_mappings: dict[str, str]
+
+
+class ProxyUdpProtocol(asyncio.DatagramProtocol):
+    _proxy: "Proxy"
+    _monitor: Monitor
+    _transport: asyncio.transports.DatagramTransport
+    _target_address: str
+    _target_port: int
+    _target_pair: tuple[str, int]
+
+    def __init__(self, proxy: "Proxy", monitor: Monitor, target_address: str, target_port: int) -> None:
+        self._proxy = proxy
+        self._monitor = monitor
+        self._target_address = target_address
+        self._target_port = target_port
+        self._target_pair = (target_address, target_port)
+
+    @override
+    def connection_made(self, transport: asyncio.transports.DatagramTransport) -> None:     # type: ignore[override]
+        self._transport = transport
+
+    @override
+    def datagram_received(self, data: bytes, addr: tuple[str | Any, int]) -> None:
+        if addr == self._target_address:
+            return
+
+        if not self._monitor.is_available(self._target_address):
+            self._proxy._wake_up_target(self._target_address)  # noqa: SLF001
+
+        self._transport.sendto(data, self._target_pair)
+
+
+class Proxy:
+    _log: Logger = logging.getLogger()
+    _config: ProxyConfig
+    _monitor: Monitor
+    _routes: list[ProxyRoute]
+    _mac_mappings: dict[str, str]
+
+    def __init__(self, config: ProxyConfig) -> None:
+        self._config = config
+        self._routes = config.routes
+        self._mac_mappings = config.mac_mappings
+
+        target_ip_set = set()
+
+        for r in self._routes:
+            target_ip_set.add(r.target_address)
+
+        self._monitor = Monitor(watching_ip_list=target_ip_set)
+
+    def start(self) -> None:
+        self._monitor.start()
+
+        for route in self._routes:
+            self.__create_route(route)
+
+        loop = asyncio.get_event_loop()
+
+        self._log.info("Proxy server started.")
+
+        with contextlib.suppress(KeyboardInterrupt):
+            loop.run_forever()
+
+        self._log.info("Proxy server is stopping...")
+
+        loop.close()
+
+    def __create_route(self, route: ProxyRoute) -> None:
+        if route.protocol == "tcp":
+            self.__create_tcp_route(route)
+        elif route.protocol == "udp":
+            self.__create_udp_route(route)
+        else:
+            raise ValueError(
+                f"Unsupported protocol {route.protocol} in route from {route.local_address}:{route.local_port} to "
+                f"{route.target_address}:{route.target_port}"
+            )
+
+    def __create_tcp_route(self, route: ProxyRoute) -> None:
+        cr = asyncio.start_server(
+            self.__make_tcp_route_handler(route.target_address, route.target_port),
+            route.local_address,
+            route.local_port,
+        )
+
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(cr)
+
+        self._log.info(
+            f"Created {route.protocol} proxy from {route.local_address}:{route.local_port} to "
+            f"{route.target_address}:{route.target_port}"
+        )
+
+    async def __pipe(self, target_address: str, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
+        try:
+            while not reader.at_eof():
+                writer.write(await reader.read(2048))
+        except ConnectionResetError:
+            self._log.warning("Connection reset by target %s", target_address)
+        finally:
+            writer.close()
+
+    def __make_tcp_route_handler(self, target_address: str, target_port: int) -> Any:   # noqa: ANN401
+        async def handler(local_reader: asyncio.StreamReader, local_writer: asyncio.StreamWriter) -> None:
+            if not self._monitor.is_available(target_address):
+                self._wake_up_target(target_address)
+
+            try:
+                target_reader, target_writer = await asyncio.open_connection(target_address, target_port)
+            except OSError as e:
+                self._monitor.report_availablity(target_address, False)
+                self._log.error("Unable to open connection to %s:%d", target_address, target_port)
+                raise e
+
+            send_pipe = self.__pipe(target_address, local_reader, target_writer)
+            recv_pipe = self.__pipe(target_address, target_reader, local_writer)
+            await asyncio.gather(send_pipe, recv_pipe)
+
+        return handler
+
+    def __create_udp_route(self, route: ProxyRoute) -> None:
+        loop = asyncio.get_event_loop()
+
+        cr = loop.create_datagram_endpoint(
+            lambda: ProxyUdpProtocol(self, self._monitor, route.target_address, route.target_port),
+            local_addr=(route.local_address, route.local_port),
+        )
+
+        loop.run_until_complete(cr)
+
+    def _wake_up_target(self, target_address: str) -> None:
+        target_mac_addr = self._mac_mappings[target_address]
+
+        self._log.info("Waking up target %s at %s", target_address, target_mac_addr)
+
+        wakeonlan.send_magic_packet(target_mac_addr)
+
+        count = 0
+
+        while not self._monitor.is_available(target_address):
+            count = count + 1
+            time.sleep(1)
+
+            if count > WOL_MAX_WAIT_COUNT:
+                self._log.warning("Target %s still not online after %d seconds!", target_address, count)
+                return