mx-remote 8.0.2__tar.gz → 8.1.0__tar.gz

{mx_remote-8.0.2 → mx_remote-8.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mx_remote
-Version: 8.0.2
+Version: 8.1.0
 Summary: Python 3 library for interfacing with MX Remote compatible devices
 Project-URL: Homepage, https://github.com/opdenkamp/mx-remote/
 Project-URL: Documentation, https://opdenkamp.github.io/mx-remote/

{mx_remote-8.0.2 → mx_remote-8.1.0}/docs/api.md

@@ -240,6 +240,18 @@ What an output plays from a session description, and how it is timed.
 .. autodata:: mx_remote.proto.Constants.ONEIP_SDP_MAX
 ```
 
+## OneIP stream encryption
+
+How a source unit encrypts its streams, as it reports it.
+
+```{eval-rst}
+.. autoclass:: mx_remote.OneIPPrivacy
+   :members:
+
+.. autoclass:: mx_remote.OneIPPrivacyStream
+   :members:
+```
+
 ## OneIP test card
 
 A sink's test pattern, tone and lip-sync flash, and the ranges it accepts.

{mx_remote-8.0.2 → mx_remote-8.1.0}/docs/oneip.md

@@ -247,6 +247,10 @@ that takes a power save level switches it off, so a level write, this client's
 or another sender's, clears it unless the same frame states it. Firmware
 without the bit never reports it, and the switch is refused there.
 
+`OneIPDeviceSetting.CLOUD` is a switch for whether a device connects to the
+cloud service. A device that does not report it connects regardless, and the
+switch is refused there.
+
 ### PTP
 
 A device's PTP mode, domain and grandmaster priority1 are settings like the
@@ -408,10 +412,30 @@ await mx.clear_osd_sync()          # stop answering for it
 Each unit asks for the settings it lacks and takes only those, so this client
 holds the content and answers until it is replaced or cleared, announcing
 itself meanwhile as the mesh's overlay sync manager: a unit waking from power
-save then takes this content rather than the controller's. Logo images are
+save then takes this content rather than the controller's. The controller
+still answers a unit that asks for settings without naming whose sync they are
+from, as an older overlay module does, with its own sync, which replaces this
+client's on that unit. Logo images are
 served over HTTP from this client, on `logo_port` or a free port. Content a unit
 would refuse is refused before anything is sent; see `send_osd_sync`.
 
+### Stream encryption
+
+A source unit from protocol 0x30 encrypts its video, audio and ancillary
+streams, and reports what a receiver needs to decrypt them whenever that
+changes and at least once a minute. The key itself never travels: every unit of
+a mesh holds the same one, and this library holds none.
+
+```python
+await source.request_oneip_privacy()    # report now
+await mx.request_all_oneip_privacy()    # every source unit of the mesh
+
+print(source.oneip_privacy)   # None until the unit has reported
+```
+
+A request to a unit that is not a source, or that is below protocol 0x30, is
+refused before it is sent.
+
 ### Every device at once
 
 One broadcast changes settings on every OneIP device of the mesh. Each device

{mx_remote-8.0.2 → mx_remote-8.1.0}/mx_remote/Interface.py

@@ -2471,6 +2471,59 @@ class OneIPSinkSdp:
         return (f"'{self.name}' {self.group}:{self.port} {encoding} {self.channels}ch {self.rate_hz}Hz"
                 f"{' audio only' if (OneIPSdpFlag.AUDIO_ONLY in self.flags) else ''}")
 
+@dataclass(frozen=True)
+class OneIPPrivacyStream:
+    """
+    How one of a OneIP source unit's streams is encrypted, as the unit reports
+    it: the values of the stream's ``a=privacy`` and ``a=extmap`` session
+    description attributes.
+
+    A receiver needs these to decrypt the stream. The key itself never travels:
+    every unit of a mesh holds the same one. This library holds no key and
+    decrypts nothing.
+    """
+    group: str = '0.0.0.0'
+    """The stream's destination address."""
+    port: int = 0
+    """The stream's UDP port."""
+    version: int = 0
+    """Steps whenever the parameters change."""
+    on: bool = False
+    """Whether the stream is encrypted. Without it the stream goes out in the
+    clear, and the fields below mean nothing."""
+    full_id: int = 0
+    """The RTP header extension id of the full IV counter."""
+    short_id: int = 0
+    """The RTP header extension id of the short IV counter."""
+    iv: bytes = bytes(8)
+    """The initialisation vector, 8 bytes."""
+    key_generator: bytes = bytes(16)
+    """The key generator, 16 bytes."""
+    key_id: bytes = bytes(8)
+    """Names the mesh's key, 8 bytes. A receiver holding another drops the stream."""
+    key_version: int = 0
+    """The key version."""
+
+    def __str__(self) -> str:
+        if not self.on:
+            return f"{self.group}:{self.port} clear"
+        return f"{self.group}:{self.port} encrypted, key {self.key_id.hex()} v{self.key_version}"
+
+@dataclass(frozen=True)
+class OneIPPrivacy:
+    """
+    How a OneIP source unit's streams are encrypted, as it last reported it. A
+    unit reports this whenever it changes, at least once a minute, and when
+    asked. A unit that is in no mesh sends in the clear.
+    """
+    video: OneIPPrivacyStream
+    audio: OneIPPrivacyStream
+    anc: OneIPPrivacyStream
+    """The ancillary data stream."""
+
+    def __str__(self) -> str:
+        return f"video {self.video}, audio {self.audio}, anc {self.anc}"
+
 @dataclass(frozen=True)
 class OneIPTestTone:
     """A OneIP sink's test tone."""
@@ -3459,6 +3512,17 @@ class DeviceBase(ABC):
         reported it, None until it has. It reports when that changes and at
         least once a minute.'''
 
+    @property
+    @abstractmethod
+    def oneip_privacy(self) -> OneIPPrivacy|None:
+        '''How this OneIP source unit's streams are encrypted, as it last
+        reported it, None until it has. It reports when that changes and at
+        least once a minute.'''
+
+    @abstractmethod
+    async def request_oneip_privacy(self) -> bool:
+        '''ask this OneIP source unit how its streams are encrypted now'''
+
     @abstractmethod
     async def play_oneip_sdp(self, sdp:str) -> bool:
         '''have this OneIP output play the stream a session description describes'''

{mx_remote-8.0.2 → mx_remote-8.1.0}/mx_remote/Interface.pyi

@@ -891,6 +891,25 @@ class OneIPSinkSdp:
     @property
     def active(self) -> bool: ...
 
+@dataclass(frozen=True)
+class OneIPPrivacyStream:
+    group: str = ...
+    port: int = ...
+    version: int = ...
+    on: bool = ...
+    full_id: int = ...
+    short_id: int = ...
+    iv: bytes = ...
+    key_generator: bytes = ...
+    key_id: bytes = ...
+    key_version: int = ...
+
+@dataclass(frozen=True)
+class OneIPPrivacy:
+    video: OneIPPrivacyStream
+    audio: OneIPPrivacyStream
+    anc: OneIPPrivacyStream
+
 @dataclass(frozen=True)
 class OneIPTestTone:
     mode: OneIPToneMode | int = ...
@@ -1306,6 +1325,11 @@ class DeviceBase(ABC):
     @property
     @abstractmethod
     def oneip_sink_sdp(self) -> OneIPSinkSdp | None: ...
+    @property
+    @abstractmethod
+    def oneip_privacy(self) -> OneIPPrivacy | None: ...
+    @abstractmethod
+    async def request_oneip_privacy(self) -> bool: ...
     @abstractmethod
     async def play_oneip_sdp(self, sdp: str) -> bool: ...
     @abstractmethod

{mx_remote-8.0.2 → mx_remote-8.1.0}/mx_remote/const.py

@@ -14,7 +14,7 @@ Default communication modes:
 """
 import os
 
-VERSION = '8.0.2'
+VERSION = '8.1.0'
 __version__ = VERSION
 
 MX_BCAST_UDP_PORT = 8811

{mx_remote-8.0.2 → mx_remote-8.1.0}/mx_remote/proto/Constants.py

@@ -10,7 +10,7 @@
 from enum import IntEnum, IntFlag
 from typing import TypeVar
 
-MXR_PROTOCOL_VERSION = 0x2F
+MXR_PROTOCOL_VERSION = 0x30
 """Highest mx_remote protocol version this library understands.
 
 Mirrors the firmware's own protocol version. Bump
@@ -31,7 +31,8 @@ every 20-30s once every device it knows is on 0x2A.
 0x2B.
 
 0x2E is the row of V2IP_SINK_SDP, so an output's session description report
-arrives stamped 0x2E, and 0x2F the row of V2IP_OSD_SYNC."""
+arrives stamped 0x2E, 0x2F the row of V2IP_OSD_SYNC and 0x30 the row of
+V2IP_PRIVACY."""
 
 MXR_PROTOCOL_VERSION_SLOW_HELLO = 0x2A
 """First protocol version whose devices may hello only every 20-30s."""
@@ -121,6 +122,7 @@ MXR_OPCODE_VERSIONS: dict[int, int] = {
     0x51: 0x2D,  # BAY_CONTENT
     0x52: 0x2E,  # V2IP_SINK_SDP
     0x53: 0x2F,  # V2IP_OSD_SYNC
+    0x54: 0x30,  # V2IP_PRIVACY
 }
 """Per-opcode minimum compatible protocol version, mirroring the firmware's
 own opcode table. Transmitters stamp the
@@ -374,9 +376,13 @@ class OneIPDeviceSetting(IntFlag):
 	STREAM_TTL         = (1 << 29)
 	'''The TTL of the device's streams, video, audio and ancillary alike.
 	Reported only by a device with an encoder.'''
+	CLOUD              = (1 << 30)
+	'''Connects to the cloud service. A device that does not report it
+	connects regardless.'''
 
 ONEIP_DEVICE_SETTING_SWITCHES = OneIPDeviceSetting(0xFF) | OneIPDeviceSetting.AES67 \
-	| OneIPDeviceSetting.SAP_LISTEN | OneIPDeviceSetting.SAP_ANNOUNCE | OneIPDeviceSetting.POWER_SAVE_DISABLED
+	| OneIPDeviceSetting.SAP_LISTEN | OneIPDeviceSetting.SAP_ANNOUNCE | OneIPDeviceSetting.POWER_SAVE_DISABLED \
+	| OneIPDeviceSetting.CLOUD
 """The settings that are on or off, as opposed to carrying a value, and that
 can be written."""
 

{mx_remote-8.0.2 → mx_remote-8.1.0}/mx_remote/proto/Constants.pyi

@@ -108,6 +108,7 @@ class OneIPDeviceSetting(IntFlag):
     SAP_INTERVAL: Incomplete
     POWER_SAVE_DISABLED: Incomplete
     STREAM_TTL: Incomplete
+    CLOUD: Incomplete
 
 ONEIP_DEVICE_SETTING_SWITCHES: Incomplete
 ONEIP_DEVICE_SETTINGS_REPORTED_ONLY: Incomplete

{mx_remote-8.0.2 → mx_remote-8.1.0}/mx_remote/proto/Factory.py

@@ -246,6 +246,9 @@ def _mxr_frame_factory(hdr:FrameHeader, timestamp:float) -> FrameBase|None:
 	if hdr.opcode == 0x53:
 		from .FrameV2IPOsdSync import FrameV2IPOsdSync
 		return FrameV2IPOsdSync(header=hdr, timestamp=timestamp)
+	if hdr.opcode == 0x54:
+		from .FrameV2IPPrivacy import FrameV2IPPrivacy
+		return FrameV2IPPrivacy(header=hdr, timestamp=timestamp)
 	if hdr.opcode == 0x50:
 		from .FrameUnitCommand import FrameUnitCommand
 		return FrameUnitCommand(header=hdr, timestamp=timestamp)

mx_remote-8.1.0/mx_remote/proto/FrameV2IPPrivacy.py

@@ -0,0 +1,83 @@
+######################################################
+##            MX Remote Python Interface            ##
+##                                                  ##
+## author: Lars Op den Kamp (lars@opdenkamp-it.nl)  ##
+## copyright (c) 2021-2026 Op den Kamp IT Solutions ##
+######################################################
+'''Protocol frame for V2IP_PRIVACY (opcode 0x54): how a OneIP source unit
+encrypts its streams, and the request that asks it.'''
+
+from functools import cached_property
+import ipaddress
+import struct
+from typing import Any
+from ..compat import override
+from .FrameBase import FrameBase
+from ..Interface import DeviceRegistry, OneIPPrivacy, OneIPPrivacyStream
+from ..Uid import MxrDeviceUid
+
+# Every frame opens with a uid, the frame type at 16, the count of streams that
+# follow at 17 and two reserved bytes.
+#
+# A report follows with its streams, video, audio and ancillary data first, each
+# PRIVACY_STREAM_SIZE bytes: the IPv4 group at 0, u16 port at 4, the version at
+# 6, a reserved byte, then whether it is encrypted at 8, the two header extension
+# ids at 9 and 10, the 8-byte IV at 11, the 16-byte key generator at 19, the
+# 8-byte key id at 35 and u32 key version at 43, unaligned, and a reserved byte.
+PRIVACY_HEADER_SIZE = 20
+PRIVACY_STREAM_SIZE = 48
+PRIVACY_STREAMS = 3
+
+PRIVACY_REPORT = 0
+'''A source unit's report.'''
+PRIVACY_REQUEST = 1
+'''Report now.'''
+
+def _stream(s:bytes) -> OneIPPrivacyStream:
+    port, = struct.unpack_from('<H', s, 4)
+    key_version, = struct.unpack_from('<I', s, 43)
+    return OneIPPrivacyStream(group=str(ipaddress.IPv4Address(s[0:4])), port=port, version=s[6],
+                              on=(s[8] != 0), full_id=s[9], short_id=s[10], iv=bytes(s[11:19]),
+                              key_generator=bytes(s[19:35]), key_id=bytes(s[35:43]),
+                              key_version=key_version)
+
+class FrameV2IPPrivacy(FrameBase):
+    '''A OneIP source unit's report of how it encrypts its streams, or a request
+    for one.'''
+    @staticmethod
+    def construct_request(mxr:DeviceRegistry, target:Any, target_uid:MxrDeviceUid|None) -> FrameBase|None:
+        '''A request naming the source unit asked, or the zero uid for every one.'''
+        uid = target_uid.byte_value if (target_uid is not None) else bytes(16)
+        payload = uid + bytes([PRIVACY_REQUEST, 0, 0, 0])
+        return FrameBase.construct_base(target=target, mxr=mxr, opcode=0x54, payload=payload)
+
+    @cached_property
+    def kind(self) -> int|None:
+        '''The frame type, None for a frame shorter than its header.'''
+        if (len(self.payload or b'') < PRIVACY_HEADER_SIZE):
+            return None
+        return self.payload_u8(16)
+
+    @cached_property
+    def privacy(self) -> OneIPPrivacy|None:
+        '''What the unit reports, None for a request and for a report missing
+        any of the three streams.'''
+        p = self.payload or b''
+        if (self.kind != PRIVACY_REPORT) or (p[17] < PRIVACY_STREAMS) \
+                or (len(p) < PRIVACY_HEADER_SIZE + PRIVACY_STREAMS * PRIVACY_STREAM_SIZE):
+            return None
+        at = lambda i: _stream(p[PRIVACY_HEADER_SIZE + i * PRIVACY_STREAM_SIZE:])
+        return OneIPPrivacy(video=at(0), audio=at(1), anc=at(2))
+
+    @override
+    def process(self) -> None:
+        '''Record a report against the unit that sent it, whatever uid its
+        header names, as units file it. A request is for a unit with an encoder
+        to answer, which this client is not.'''
+        if ((privacy := self.privacy) is not None) and ((dev := self.remote_device) is not None):
+            dev.on_mxr_update(privacy)
+
+    def __str__(self) -> str:
+        if (self.privacy is not None):
+            return f"OneIP privacy: {self.privacy}"
+        return f"OneIP privacy request for {self.uid_to_user_string(self.payload_uuid(0))}"

mx_remote-8.1.0/mx_remote/proto/FrameV2IPPrivacy.pyi

@@ -0,0 +1,22 @@
+from ..Interface import DeviceRegistry as DeviceRegistry, OneIPPrivacy as OneIPPrivacy, OneIPPrivacyStream as OneIPPrivacyStream
+from ..Uid import MxrDeviceUid as MxrDeviceUid
+from ..compat import override as override
+from .FrameBase import FrameBase as FrameBase
+from functools import cached_property
+from typing import Any
+
+PRIVACY_HEADER_SIZE: int
+PRIVACY_STREAM_SIZE: int
+PRIVACY_STREAMS: int
+PRIVACY_REPORT: int
+PRIVACY_REQUEST: int
+
+class FrameV2IPPrivacy(FrameBase):
+    @staticmethod
+    def construct_request(mxr: DeviceRegistry, target: Any, target_uid: MxrDeviceUid | None) -> FrameBase | None: ...
+    @cached_property
+    def kind(self) -> int | None: ...
+    @cached_property
+    def privacy(self) -> OneIPPrivacy | None: ...
+    @override
+    def process(self) -> None: ...

{mx_remote-8.0.2 → mx_remote-8.1.0}/mx_remote/remote/Device.py

@@ -31,6 +31,7 @@ from ..Interface import (
 	OneIPVlan,
 	OneIPTestcard,
 	OneIPSinkSdp,
+	OneIPPrivacy,
 	OsdSync,
 	OsdSyncReport,
 	OneIPTestSync,
@@ -89,6 +90,7 @@ from ..proto.Constants import (MXR_PROTOCOL_VERSION_SLOW_HELLO, BayFeaturesMask,
 from ..proto.FrameUnitCommand import FrameUnitCommand
 from ..proto.FrameV2IPAudio import AUDIO_LAYOUT_SINCE, FrameV2IPAudio
 from ..proto.FrameV2IPDeviceConfiguration import FrameV2IPDeviceConfiguration
+from ..proto.FrameV2IPPrivacy import FrameV2IPPrivacy
 from ..proto.FrameV2IPSinkSdp import FrameV2IPSinkSdp, SDP_REQUEST, SDP_SCREEN, SDP_STOP
 from ..proto.FrameV2IPTestcard import (FrameV2IPTestcard, TESTCARD_REQUEST, TESTCARD_SET,
                                        TESTCARD_PART_PATTERN, TESTCARD_PART_TONE, TESTCARD_PART_SYNC)
@@ -171,6 +173,7 @@ class Device(DeviceBase):
 		self._unit_status:UnitStatus|None = None
 		self._v2ip_testcard:OneIPTestcard|None = None
 		self._v2ip_sink_sdp:OneIPSinkSdp|None = None
+		self._v2ip_privacy:OneIPPrivacy|None = None
 		self._osd_sync:OsdSync|None = None
 		self._osd_sync_report:OsdSyncReport|None = None
 		self._time_zone:TimeZone|None = None
@@ -1060,6 +1063,10 @@ class Device(DeviceBase):
 			if (self._v2ip_sink_sdp != data):
 				self._v2ip_sink_sdp = data
 				self.call_callbacks()
+		elif isinstance(data, OneIPPrivacy):
+			if (self._v2ip_privacy != data):
+				self._v2ip_privacy = data
+				self.call_callbacks()
 		elif isinstance(data, TimeZone):
 			if (self._time_zone != data):
 				self._time_zone = data
@@ -1744,6 +1751,24 @@ class Device(DeviceBase):
 		play_oneip_sdp().'''
 		return self._send_sink_sdp_command(SDP_REQUEST, 0)
 
+	@property
+	@override
+	def oneip_privacy(self) -> OneIPPrivacy|None:
+		return self._v2ip_privacy
+
+	async def request_oneip_privacy(self) -> bool:
+		'''Ask this OneIP source unit how its streams are encrypted now, rather
+		than at its next report, which comes at least once a minute and whenever
+		they change. Refused for a device that is not a OneIP source, and for
+		one below protocol 0x30, which predates the report.'''
+		if (self.features is None) or (DeviceFeature.ONEIP_SOURCE not in self.features):
+			_LOGGER.warning(f"not asking {self} how its streams are encrypted: it is not a OneIP source")
+			return False
+		frame = FrameV2IPPrivacy.construct_request(mxr=self.registry, target=self, target_uid=self.remote_id)
+		if (frame is None):
+			return False
+		return self.registry.transmit(frame.frame) == len(frame.frame)
+
 	def _send_sink_sdp_command(self, kind:int, value:int) -> bool:
 		'''The one send behind the session description commands.'''
 		if not self.is_oneip_sink:

{mx_remote-8.0.2 → mx_remote-8.1.0}/mx_remote/remote/Device.pyi

@@ -1,4 +1,4 @@
-from ..Interface import AmpDolbySettings as AmpDolbySettings, AudioChangeSource as AudioChangeSource, AudioEndpoint as AudioEndpoint, AudioEndpoints as AudioEndpoints, AudioLinks as AudioLinks, BayBase as BayBase, DeviceBase as DeviceBase, DeviceClock as DeviceClock, DeviceOneIPDetails as DeviceOneIPDetails, DeviceOneIPScalingSettings as DeviceOneIPScalingSettings, DeviceOneIPSink as DeviceOneIPSink, DeviceRegistry as DeviceRegistry, DeviceStatus as DeviceStatus, Multiviewer as Multiviewer, MxrCallbacks as MxrCallbacks, OneIPDeviceSettings as OneIPDeviceSettings, OneIPOutputMode as OneIPOutputMode, OneIPPowerSaveSchedule as OneIPPowerSaveSchedule, OneIPPtpMessages as OneIPPtpMessages, OneIPPtpState as OneIPPtpState, OneIPScalingSettings as OneIPScalingSettings, OneIPSinkSdp as OneIPSinkSdp, OneIPStreamSources as OneIPStreamSources, OneIPStreamSourcesList as OneIPStreamSourcesList, OneIPTestSync as OneIPTestSync, OneIPTestTone as OneIPTestTone, OneIPTestcard as OneIPTestcard, OneIPVlan as OneIPVlan, OsdSync as OsdSync, OsdSyncReport as OsdSyncReport, SystemTemperature as SystemTemperature, TimeZone as TimeZone, UnitNetConfig as UnitNetConfig, UnitStatus as UnitStatus
+from ..Interface import AmpDolbySettings as AmpDolbySettings, AudioChangeSource as AudioChangeSource, AudioEndpoint as AudioEndpoint, AudioEndpoints as AudioEndpoints, AudioLinks as AudioLinks, BayBase as BayBase, DeviceBase as DeviceBase, DeviceClock as DeviceClock, DeviceOneIPDetails as DeviceOneIPDetails, DeviceOneIPScalingSettings as DeviceOneIPScalingSettings, DeviceOneIPSink as DeviceOneIPSink, DeviceRegistry as DeviceRegistry, DeviceStatus as DeviceStatus, Multiviewer as Multiviewer, MxrCallbacks as MxrCallbacks, OneIPDeviceSettings as OneIPDeviceSettings, OneIPOutputMode as OneIPOutputMode, OneIPPowerSaveSchedule as OneIPPowerSaveSchedule, OneIPPrivacy as OneIPPrivacy, OneIPPtpMessages as OneIPPtpMessages, OneIPPtpState as OneIPPtpState, OneIPScalingSettings as OneIPScalingSettings, OneIPSinkSdp as OneIPSinkSdp, OneIPStreamSources as OneIPStreamSources, OneIPStreamSourcesList as OneIPStreamSourcesList, OneIPTestSync as OneIPTestSync, OneIPTestTone as OneIPTestTone, OneIPTestcard as OneIPTestcard, OneIPVlan as OneIPVlan, OsdSync as OsdSync, OsdSyncReport as OsdSyncReport, SystemTemperature as SystemTemperature, TimeZone as TimeZone, UnitNetConfig as UnitNetConfig, UnitStatus as UnitStatus
 from ..Uid import MxrDeviceUid as MxrDeviceUid
 from ..compat import override as override
 from ..const import MXR_CONFIG_TIMEOUT as MXR_CONFIG_TIMEOUT
@@ -18,6 +18,7 @@ from ..proto.FrameV2IPAudio import AUDIO_LAYOUT_SINCE as AUDIO_LAYOUT_SINCE, Fra
 from ..proto.FrameV2IPBayMapping import FrameV2IPBayMapping as FrameV2IPBayMapping
 from ..proto.FrameV2IPDeviceConfiguration import FrameV2IPDeviceConfiguration as FrameV2IPDeviceConfiguration
 from ..proto.FrameV2IPMultiviewer import FrameV2IPMultiviewer as FrameV2IPMultiviewer, V2IPMultiviewerConfig as V2IPMultiviewerConfig
+from ..proto.FrameV2IPPrivacy import FrameV2IPPrivacy as FrameV2IPPrivacy
 from ..proto.FrameV2IPSinkSdp import FrameV2IPSinkSdp as FrameV2IPSinkSdp, SDP_REQUEST as SDP_REQUEST, SDP_SCREEN as SDP_SCREEN, SDP_STOP as SDP_STOP
 from ..proto.FrameV2IPStats import FrameV2IPStats as FrameV2IPStats
 from ..proto.FrameV2IPTestcard import FrameV2IPTestcard as FrameV2IPTestcard, TESTCARD_PART_PATTERN as TESTCARD_PART_PATTERN, TESTCARD_PART_SYNC as TESTCARD_PART_SYNC, TESTCARD_PART_TONE as TESTCARD_PART_TONE, TESTCARD_REQUEST as TESTCARD_REQUEST, TESTCARD_SET as TESTCARD_SET
@@ -286,6 +287,10 @@ class Device(DeviceBase):
     async def stop_oneip_sdp(self) -> bool: ...
     async def set_oneip_sdp_screen(self, screen: int) -> bool: ...
     async def request_oneip_sink_sdp(self) -> bool: ...
+    @property
+    @override
+    def oneip_privacy(self) -> OneIPPrivacy | None: ...
+    async def request_oneip_privacy(self) -> bool: ...
     def __eq__(self, other: Any) -> bool: ...
 
 class MultiviewerImpl(Multiviewer):

{mx_remote-8.0.2 → mx_remote-8.1.0}/mx_remote/remote/Remote.py

@@ -31,6 +31,7 @@ from ..proto.FramePing import FramePing
 from ..proto.FrameBase import FrameBase
 from ..proto.FrameTime import FrameTime
 from ..proto.FrameTimeZone import FrameTimeZone
+from ..proto.FrameV2IPPrivacy import FrameV2IPPrivacy
 from ..proto.FrameV2IPSettingsAll import FrameV2IPSettingsAll
 from ..proto.FrameV2IPOsdSync import FrameV2IPOsdSync
 from .OsdSync import LogoServer, OsdSender, PASS_GAP, osd_content_refusal
@@ -529,6 +530,12 @@ class Remote(DeviceRegistry, ConnectionCallbacks):
             return False
         return self._send_to_all(FrameV2IPSettingsAll.construct(mxr=self, settings=settings))
 
+    async def request_all_oneip_privacy(self) -> bool:
+        '''Ask every OneIP source unit of the mesh how its streams are
+        encrypted, as Device.request_oneip_privacy() asks one. A unit below
+        protocol 0x30 ignores it.'''
+        return self._send_to_all(FrameV2IPPrivacy.construct_request(mxr=self, target=None, target_uid=None))
+
     async def set_mesh_time_zone(self, zone:str, rule:str) -> bool:
         '''Set the time zone of every device that hears it.
 
@@ -692,7 +699,10 @@ class Remote(DeviceRegistry, ConnectionCallbacks):
         it announces itself as the mesh's overlay sync manager, so a unit waking
         from power save takes this content too, rather than the controller's.
         The controller can still send its own over it; the last sync a unit
-        took is what it shows. Each unit's osd_sync_report says how it went.
+        took is what it shows. It does so whenever a unit asks for settings
+        without naming whose sync they are from, as an older overlay module
+        does, and nothing this client sends prevents that. Each unit's
+        osd_sync_report says how it went.
 
         Refused for content a unit would refuse: copying nothing, more than
         OSD_SYNC_RECORDS_MAX settings, a caption font over OSD_SYNC_FONT_MAX or

{mx_remote-8.0.2 → mx_remote-8.1.0}/mx_remote/remote/Remote.pyi

@@ -12,6 +12,7 @@ from ..proto.FramePing import FramePing as FramePing
 from ..proto.FrameTime import FrameTime as FrameTime
 from ..proto.FrameTimeZone import FrameTimeZone as FrameTimeZone
 from ..proto.FrameV2IPOsdSync import FrameV2IPOsdSync as FrameV2IPOsdSync
+from ..proto.FrameV2IPPrivacy import FrameV2IPPrivacy as FrameV2IPPrivacy
 from ..proto.FrameV2IPSettingsAll import FrameV2IPSettingsAll as FrameV2IPSettingsAll
 from ..proto.Svd import SvdMap as SvdMap
 from .ConnectionAsync import ConnectionAsync as ConnectionAsync
@@ -72,6 +73,7 @@ class Remote(DeviceRegistry, ConnectionCallbacks):
     def transmit(self, data: bytes) -> int: ...
     def tx_discover(self) -> int: ...
     async def set_all_oneip_device_settings(self, settings: OneIPDeviceSettings) -> bool: ...
+    async def request_all_oneip_privacy(self) -> bool: ...
     async def set_mesh_time_zone(self, zone: str, rule: str) -> bool: ...
     async def clear_mesh_time_zone(self) -> bool: ...
     async def set_mesh_time(self, when: datetime | None = None) -> bool: ...

{mx_remote-8.0.2 → mx_remote-8.1.0}/tests/handlers.py

@@ -81,6 +81,7 @@ BASELINE = {
     'FrameV2IPManualSourceSwitch.FrameV2IPManualSourceSwitch',
     'FrameV2IPMultiviewer.FrameV2IPMultiviewer',
     'FrameV2IPPowerSave.FrameV2IPPowerSave',
+    'FrameV2IPPrivacy.FrameV2IPPrivacy',
     'FrameV2IPSinkSdp.FrameV2IPSinkSdp',
     'FrameV2IPSourceSwitch.FrameV2IPSourceSwitch',
     'FrameV2IPOsdSync.FrameV2IPOsdSync',

mx_remote-8.1.0/tests/privacy.py

@@ -0,0 +1,112 @@
+######################################################
+##            MX Remote Python Interface            ##
+##                                                  ##
+## author: Lars Op den Kamp (lars@opdenkamp-it.nl)  ##
+## copyright (c) 2021-2026 Op den Kamp IT Solutions ##
+######################################################
+'''How a OneIP source unit encrypts its streams (0x54), and asking it.
+
+Every field of every stream is distinct from the others and from stream to
+stream, with a port and a key version too wide for a narrower read and the
+reserved bytes set, so a field read at a neighbour's offset shows.
+'''
+
+import asyncio, os, struct, sys, logging
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+logging.disable(logging.CRITICAL)
+import mx_remote
+from mx_remote import DeviceFeature, MxrDeviceUid, OneIPPrivacyStream
+from mx_remote.proto.Factory import create_mxr_frame
+
+ADDR = ('192.0.2.9', 8812)
+mx = mx_remote.Remote(open_connection=False)
+mx._uid = bytes(range(0x20, 0x30))
+sent = []
+mx.transmit = lambda data: (sent.append(bytes(data)), len(data))[1]
+
+def uid(n):
+    return bytes([n]) * 16
+
+def name(s, sz=16):
+    b = s.encode('ascii')[:sz]
+    return b + bytes(sz - len(b))
+
+def rx(sender, opcode, payload=b'', protocol=0x30):
+    frame = bytearray(create_mxr_frame(sender, opcode, payload))
+    frame[2] = protocol
+    mx.process_frame(0.0, bytes(frame), ADDR)
+
+def hello(sender, protocol, features):
+    rx(sender, 0x00, struct.pack('<H', protocol) + name('ONEIP') + name('P8SN%08d' % sender[0])
+                   + name('5.0.0') + struct.pack('<I', int(features)), protocol=0x01)
+    return mx.get_by_uid(MxrDeviceUid(sender))
+
+def call(coro):
+    return asyncio.run(coro)
+
+def stream(n):
+    '''Stream n; stream 2 is in the clear.'''
+    s = bytes([239, 0, 0, n]) + struct.pack('<H', 5000 + n * 0x101) + bytes([0x10 + n, 0xEE])
+    s += bytes([int(n != 2), 0x20 + n, 0x30 + n])
+    s += bytes(0x40 + n * 16 + i for i in range(8))
+    s += bytes(0x80 + n * 16 + i for i in range(16))
+    s += bytes(0xC0 + n * 8 + i for i in range(8))
+    s += struct.pack('<I', 0x01020304 * n) + bytes([0xEE])
+    assert len(s) == 48, len(s)
+    return s
+
+def expected(n):
+    return OneIPPrivacyStream(group=f'239.0.0.{n}', port=5000 + n * 0x101, version=0x10 + n, on=(n != 2),
+                              full_id=0x20 + n, short_id=0x30 + n,
+                              iv=bytes(0x40 + n * 16 + i for i in range(8)),
+                              key_generator=bytes(0x80 + n * 16 + i for i in range(16)),
+                              key_id=bytes(0xC0 + n * 8 + i for i in range(8)),
+                              key_version=0x01020304 * n)
+
+def report(header_uid, count=3):
+    return header_uid + bytes([0, count, 0xA5, 0x5A]) + b''.join(stream(n) for n in range(1, count + 1))
+
+# ------------------------------------------------------------------- reading
+# A report is filed under its sender, whatever uid its header names.
+src = hello(uid(0x10), 0x30, DeviceFeature.ONEIP_SOURCE)
+assert src.oneip_privacy is None
+rx(uid(0x10), 0x54, report(uid(0x11)))
+p = src.oneip_privacy
+assert p is not None, 'no report was kept'
+assert (p.video, p.audio, p.anc) == (expected(1), expected(2), expected(3)), p
+assert mx.get_by_uid(MxrDeviceUid(uid(0x11))) is None
+print('decode      :', p)
+
+# Only a whole report of three streams is kept; a longer one is read for its
+# first three.
+other = hello(uid(0x12), 0x30, DeviceFeature.ONEIP_SOURCE)
+whole = report(uid(0x12))
+request = whole[:16] + bytes([1]) + whole[17:]
+two = whole[:17] + bytes([2]) + whole[18:]
+for what, frame in (('a request', request), ('a count of two', two), ('a frame a byte short', whole[:-1])):
+    rx(uid(0x12), 0x54, frame)
+    assert other.oneip_privacy is None, f'{what} was kept'
+rx(uid(0x12), 0x54, report(uid(0x12), count=4))
+assert other.oneip_privacy is not None and other.oneip_privacy.anc == expected(3), 'a longer report was dropped'
+print('whole       : only a report of all three streams is kept')
+
+# ------------------------------------------------------------------- asking
+sent.clear()
+assert call(src.request_oneip_privacy()) is True
+frame = sent[-1]
+assert int.from_bytes(frame[20:22], 'little') == 0x54 and frame[2] == 0x30, frame[:24].hex()
+assert frame[24:] == uid(0x10) + bytes([1, 0, 0, 0]), frame[24:].hex()
+sent.clear()
+assert call(mx.request_all_oneip_privacy()) is True
+assert sent[-1][24:] == bytes(16) + bytes([1, 0, 0, 0]) and sent[-1][2] == 0x30, sent[-1].hex()
+print('request     : names the unit asked, or the zero uid for every one, stamped 0x30')
+
+def refused(coro, why):
+    n = len(sent)
+    assert call(coro) is False, why
+    assert len(sent) == n, f'{why}: refused, but transmitted anyway'
+refused(hello(uid(0x13), 0x2F, DeviceFeature.ONEIP_SOURCE).request_oneip_privacy(), 'a source below 0x30')
+refused(hello(uid(0x14), 0x30, DeviceFeature.ONEIP_SINK).request_oneip_privacy(), 'a unit that is not a source')
+print('refusals    : nothing a unit would ignore is sent')
+
+print('ALL OK')

{mx_remote-8.0.2 → mx_remote-8.1.0}/tests/proto_stamp.py

@@ -40,6 +40,7 @@ ABOVE_CAP = {
     0x50: 'SYS_UNIT_COMMAND',
     0x52: 'V2IP_SINK_SDP',
     0x53: 'V2IP_OSD_SYNC',
+    0x54: 'V2IP_PRIVACY',
 }
 root = pathlib.Path(os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'mx_remote', 'proto'))
 # Calls only. The pattern also matches the def in FrameBase, which carries a

{mx_remote-8.0.2 → mx_remote-8.1.0}/tests/run.py

@@ -58,6 +58,7 @@ SUITES = [
     'routes',       # what a OneIP output is routed to, as the frames a unit acts on move it
     'meshbays',     # the bays a unit lists for other units, from its mappings
     'v2ipsdp',      # what a OneIP output plays from a session description
+    'privacy',      # how a OneIP source unit encrypts its streams
     'baycontent',   # what the source on an input is showing
     'osdsync',      # overlay sync, watched and sent
     'deprecated',   # the V2IP names 5.11.0 exported still resolve, with a warning

{mx_remote-8.0.2 → mx_remote-8.1.0}/tests/smoke.py

@@ -11,6 +11,7 @@ print('version', mx_remote.const.VERSION, 'proto', hex(MXR_PROTOCOL_VERSION))
 # handles is stamped at.
 assert MXR_PROTOCOL_VERSION == max(MXR_OPCODE_VERSIONS.values()), hex(MXR_PROTOCOL_VERSION)
 assert MXR_OPCODE_VERSIONS[0x52] == 0x2E and MXR_OPCODE_VERSIONS[0x53] == 0x2F  # V2IP_SINK_SDP, V2IP_OSD_SYNC
+assert MXR_OPCODE_VERSIONS[0x54] == 0x30  # V2IP_PRIVACY
 assert MXR_OPCODE_VERSIONS[0x49] == 0x28 and MXR_OPCODE_VERSIONS[0x3C] == 0x11
 assert MXR_OPCODE_VERSIONS[0x4F] == 0x2C and MXR_OPCODE_VERSIONS[0x50] == 0x2C  # SYS_UNIT_STATUS, SYS_UNIT_COMMAND
 assert DeviceFeature.VIDEO_WALL == (1 << 24)