ffado-webmixer 1.2.1__py3-none-any.whl

ffado_webmixer/__init__.py

@@ -0,0 +1,3 @@
+"""FFADO WebMixer package and distribution version."""
+
+__version__ = '1.2.1'

ffado_webmixer/__main__.py

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

ffado_webmixer/access.py

@@ -0,0 +1,125 @@
+"""Listener policy and browser request checks for local and LAN control."""
+from dataclasses import dataclass, field
+from ipaddress import ip_address
+from typing import TYPE_CHECKING
+from urllib.parse import urlsplit
+from .remote_access import DEFAULT_PORT
+
+if TYPE_CHECKING:
+    from .remote_access import RemoteAccessConfig
+
+
+def bind_address(value):
+    """Accept explicit IP addresses, with localhost as a loopback shorthand."""
+    if value == 'localhost':
+        return '127.0.0.1'
+    try:
+        return str(ip_address(value))
+    except ValueError as exc:
+        raise ValueError('--host must be an IP address or localhost') from exc
+
+
+def _loopback(value):
+    try:
+        address = ip_address(value)
+        if address.version == 6 and address.ipv4_mapped:
+            address = address.ipv4_mapped
+        return address.is_loopback
+    except ValueError:
+        return False
+
+
+@dataclass(frozen=True)
+class AccessPolicy:
+    host: str = '127.0.0.1'
+    remote_access: 'RemoteAccessConfig | None' = field(default=None, repr=False)
+
+    def __post_init__(self):
+        object.__setattr__(self, 'host', bind_address(self.host))
+        if not _loopback(self.host) and not (
+                self.remote_access and self.remote_access.enabled and self.remote_access.configured):
+            raise ValueError('LAN access requires a saved username and password; run --enable-remote-access first')
+
+    def permits_local(self, remote_address, hostname):
+        # Requiring a loopback Host as well prevents DNS rebinding from turning
+        # a hostile website into a password-free local client. Forwarded headers
+        # are deliberately not trusted to grant this exception.
+        return _loopback(remote_address or '') and (
+            hostname == 'localhost' or _loopback(hostname or ''))
+
+
+def register(app, policy):
+    from flask import jsonify, request
+
+    app.ffado_host = policy.host
+    app.ffado_port = policy.remote_access.port if policy.remote_access else DEFAULT_PORT
+
+    @app.before_request
+    def check_access():
+        try:
+            hostname = urlsplit(request.host_url).hostname
+        except ValueError:
+            hostname = None
+        local = policy.permits_local(request.remote_addr, hostname)
+        if not local:
+            auth = request.authorization
+            revision = None
+            if policy.remote_access and auth and auth.type.lower() == 'basic':
+                revision = policy.remote_access.authenticate_revision(auth.username, auth.password or '')
+            if revision is None:
+                return jsonify(error='Mixer access requires authentication'), 401, {
+                    'WWW-Authenticate': 'Basic realm="FFADO WebMixer", charset="UTF-8"',
+                }
+            request.environ['ffado_webmixer.remote_authorization'] = (policy.remote_access, revision)
+
+        if request.method not in ('GET', 'HEAD', 'OPTIONS'):
+            # Browser credentials (including cached Basic auth) are ambient.
+            # Validate the origin even for loopback requests and reject simple
+            # form submissions to JSON APIs. Native API clients omit Origin.
+            origin = request.headers.get('Origin')
+            if (request.headers.get('Sec-Fetch-Site') == 'cross-site'
+                    or (origin is not None and origin != request.host_url.rstrip('/'))):
+                return jsonify(error='Cross-origin mixer writes are forbidden'), 403
+            if request.path.startswith('/api/') and not request.is_json:
+                return jsonify(error='Mixer writes require application/json'), 415
+        return None
+
+    @app.after_request
+    def access_headers(response):
+        response.headers['X-Content-Type-Options'] = 'nosniff'
+        response.headers['X-Frame-Options'] = 'DENY'
+        response.headers['Referrer-Policy'] = 'same-origin'
+        return response
+
+    # Remote users can operate the mixer, but credential management stays local.
+    @app.get('/api/remote-access')
+    def remote_access_status():
+        local = policy.permits_local(request.remote_addr, urlsplit(request.host_url).hostname)
+        config = policy.remote_access
+        status = config.status() if config else {'enabled': False, 'username': '', 'configured': False,
+                                                'port': DEFAULT_PORT}
+        return jsonify(**status, can_manage=bool(local and config and config.writable),
+                       listening=not _loopback(policy.host),
+                       listening_port=app.ffado_port,
+                       restart_required=(status['enabled'] != (not _loopback(policy.host))
+                                         or status['port'] != app.ffado_port))
+
+    @app.post('/api/remote-access')
+    def update_remote_access():
+        if not policy.permits_local(request.remote_addr, urlsplit(request.host_url).hostname):
+            return jsonify(error='Manage remote access from the local application or localhost browser'), 403
+        config = policy.remote_access
+        if config is None or not config.writable:
+            return jsonify(error='Remote-access settings cannot be changed in demo or debug mode'), 403
+        payload = request.get_json(silent=True)
+        if not isinstance(payload, dict):
+            return jsonify(error='Remote-access settings must be a JSON object'), 400
+        try:
+            config.update(enabled=payload.get('enabled'), username=payload.get('username'),
+                          password=payload.get('password', ''),
+                          **({'port': payload['port']} if 'port' in payload else {}))
+        except ValueError as exc:
+            return jsonify(error=str(exc)), 400
+        except OSError:
+            return jsonify(error='Could not save remote-access settings; previous settings remain active'), 500
+        return remote_access_status()

ffado_webmixer/api/__init__.py

@@ -0,0 +1 @@
+"""Flask route modules."""

ffado_webmixer/api/events.py

@@ -0,0 +1,50 @@
+import json
+import queue
+from flask import Response, jsonify, request
+from ..services.streams import StreamClosed, StreamSubscription
+
+def register(app, hub, device_manager=None):
+    @app.get("/api/events")
+    def events():
+        """Server-sent events: one long-lived response per open page."""
+        # Resolve the selected GUID before streaming; the session proxy must
+        # never be accessed from the SSE generator after its request context
+        # has finished. Only forward events for this device.
+        selected = device_manager.current_guid if device_manager else None
+        # EventSource cannot set the device header used by other API requests.
+        # Reject an old tab reconnecting after a shared session changes devices.
+        expected = request.args.get('device')
+        if expected and expected != selected:
+            return jsonify(error='Selected mixer changed in another tab; reload this page'), 409
+        client = hub.subscribe(selected)
+        subscription = StreamSubscription(client, lambda: hub.unsubscribe(client),
+                                          request.environ.get('ffado_webmixer.remote_authorization'))
+
+        def stream():
+            try:
+                if subscription.closed.is_set():
+                    return
+                yield "retry: 1000\n\n"
+
+                while True:
+                    try:
+                        event = subscription.get(timeout=15)
+                    except StreamClosed:
+                        return
+                    except queue.Empty:
+                        # Also lets the server notice pages that have closed.
+                        yield ": keepalive\n\n"
+                        continue
+
+                    yield f"data: {json.dumps(event)}\n\n"
+            finally:
+                subscription.close()
+
+        response = Response(
+            stream(),
+            mimetype="text/event-stream",
+            headers={"X-Accel-Buffering": "no", "Cache-Control": "no-store"},
+        )
+        # Closing a response before iteration also needs to remove its client.
+        response.call_on_close(subscription.close)
+        return response

ffado_webmixer/api/integrations.py

@@ -0,0 +1,41 @@
+"""Optional QjackCtl actions and external-browser launches for the desktop window."""
+import webbrowser
+from flask import jsonify, request
+from .. import qjackctl
+
+
+def register(app, config, mixer_url, debug=False):
+    @app.get("/api/qjackctl/status")
+    def qjackctl_status():
+        if debug or not config.settings.get("enable_qjackctl", False):
+            return jsonify(enabled=False, running=False)
+        return jsonify(enabled=True, running=qjackctl.is_running())
+
+    @app.post("/api/qjackctl")
+    def open_qjackctl():
+        if debug or not config.settings.get("enable_qjackctl", False):
+            return jsonify(error="QjackCtl support is disabled in General settings"), 403
+        payload = request.get_json(force=True)
+        if not isinstance(payload, dict) or not isinstance(payload.get('window'), str):
+            return jsonify(error='QjackCtl window must be a string'), 400
+        window = payload['window']
+        try:
+            qjackctl.open_window(window)
+        except ValueError as exc:
+            return jsonify(error=str(exc)), 400
+        except qjackctl.QjackCtlError as exc:
+            return jsonify(error=str(exc)), 503
+        return jsonify(ok=True)
+
+    @app.post("/api/open-github")
+    def open_github():
+        if not webbrowser.open("https://github.com/Sokoloft/ffado-webmixer"):
+            return jsonify(error="Could not launch the default browser"), 503
+        return jsonify(ok=True)
+
+    @app.post("/api/open-mixer")
+    def open_mixer():
+        # The URL is built by the server, never accepted from the browser.
+        if not webbrowser.open(mixer_url()):
+            return jsonify(error="Could not launch the default browser"), 503
+        return jsonify(ok=True)