Thanks! I could think of multiple ways to do this:
1) Add a input parameter to `get_sync` to indicate that the sync is retrieved for client-side signaling, and check whether this is allowed in every get_sync implementations. This however isn't future proof for inproc syncs, as they will be retrieved once and cached on the client-side, we need a way to inspect what is allowed or not.
2) Add an output parameter to `get_sync`, to retrieve whether the sync is internal or not, or to retrieve some allowed `access` mask, then use that when `select` tries to signal the object. Having an `internal` flag seemed a bit too specific, while an `access` parameter still didn't allow to check for access rights because of different object types rights / or check for object type itself and mismach easily.
3) Move the access checks out of the individual object signal methods, and implement the checks directly in `signal_object`, inspecting the object types and mapping access directly. As `signal_object` already lists the expected object types in its comment it seems alright to check the object types here.
I went with 3) and moved the signal checks out of the individual objects and into a specific `check_signal_object` helper. Later on, with inproc syncs, we can use that same helper when syncs are retrieved to be cached, and check the status to tell what the client will be allowed to do with the objects.