marsultor/exalock
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

basic wayland structs made

Browse Source
This commit is contained in:
Mars Ultor
2025-12-21 21:35:24 -06:00
parent d4b77760fe
commit b808be03a1
7 changed files with 1187 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
CMakeLists.txt
View File

@@ -67,11 +67,19 @@ pkg_check_modules(FONTCONFIG REQUIRED fontconfig)
add_executable(${PROJECT_NAME} src/main.cpp)
# -----------------------------
# Auto-discover other source files
# Auto-discover C++ and C source files
# -----------------------------
# C++ files
file(GLOB_RECURSE ALL_CPP "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
list(REMOVE_ITEM ALL_CPP "${CMAKE_CURRENT_SOURCE_DIR}/src/main.cpp")
target_sources(${PROJECT_NAME} PRIVATE ${ALL_CPP})
# C files
file(GLOB_RECURSE ALL_C "${CMAKE_CURRENT_SOURCE_DIR}/src/*.c")
# Optionally remove main.c if you have it:
# list(REMOVE_ITEM ALL_C "${CMAKE_CURRENT_SOURCE_DIR}/src/main.c")
# Add them to the target
target_sources(${PROJECT_NAME} PRIVATE ${ALL_CPP} ${ALL_C})
# -----------------------------
# Include directories
@@ -121,3 +129,4 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
-Wdouble-promotion
)
endif()

328
protocols/ext-session-lock-v1.xml Normal file
View File

@@ -0,0 +1,328 @@
<?xml version="1.0" encoding="UTF-8"?>
<protocol name="ext_session_lock_v1">
<copyright>
Copyright 2021 Isaac Freund
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
</copyright>
<description summary="secure session locking with arbitrary graphics">
This protocol allows for a privileged Wayland client to lock the session
and display arbitrary graphics while the session is locked.
The compositor may choose to restrict this protocol to a special client
launched by the compositor itself or expose it to all privileged clients,
this is compositor policy.
The client is responsible for performing authentication and informing the
compositor when the session should be unlocked. If the client dies while
the session is locked the session remains locked, possibly permanently
depending on compositor policy.
The key words "must", "must not", "required", "shall", "shall not",
"should", "should not", "recommended", "may", and "optional" in this
document are to be interpreted as described in IETF RFC 2119.
Warning! The protocol described in this file is currently in the
testing phase. Backward compatible changes may be added together with
the corresponding interface version bump. Backward incompatible changes
can only be done by creating a new major version of the extension.
</description>
<interface name="ext_session_lock_manager_v1" version="1">
<description summary="used to lock the session">
This interface is used to request that the session be locked.
</description>
<request name="destroy" type="destructor">
<description summary="destroy the session lock manager object">
This informs the compositor that the session lock manager object will
no longer be used. Existing objects created through this interface
remain valid.
</description>
</request>
<request name="lock">
<description summary="attempt to lock the session">
This request creates a session lock and asks the compositor to lock the
session. The compositor will send either the ext_session_lock_v1.locked
or ext_session_lock_v1.finished event on the created object in
response to this request.
</description>
<arg name="id" type="new_id" interface="ext_session_lock_v1"/>
</request>
</interface>
<interface name="ext_session_lock_v1" version="1">
<description summary="manage lock state and create lock surfaces">
In response to the creation of this object the compositor must send
either the locked or finished event.
The locked event indicates that the session is locked. This means
that the compositor must stop rendering and providing input to normal
clients. Instead the compositor must blank all outputs with an opaque
color such that their normal content is fully hidden.
The only surfaces that should be rendered while the session is locked
are the lock surfaces created through this interface and optionally,
at the compositor's discretion, special privileged surfaces such as
input methods or portions of desktop shell UIs.
The locked event must not be sent until a new "locked" frame (either
from a session lock surface or the compositor blanking the output) has
been presented on all outputs and no security sensitive normal/unlocked
content is possibly visible.
The finished event should be sent immediately on creation of this
object if the compositor decides that the locked event will not be sent.
The compositor may wait for the client to create and render session lock
surfaces before sending the locked event to avoid displaying intermediate
blank frames. However, it must impose a reasonable time limit if
waiting and send the locked event as soon as the hard requirements
described above can be met if the time limit expires. Clients should
immediately create lock surfaces for all outputs on creation of this
object to make this possible.
This behavior of the locked event is required in order to prevent
possible race conditions with clients that wish to suspend the system
or similar after locking the session. Without these semantics, clients
triggering a suspend after receiving the locked event would race with
the first "locked" frame being presented and normal/unlocked frames
might be briefly visible as the system is resumed if the suspend
operation wins the race.
If the client dies while the session is locked, the compositor must not
unlock the session in response. It is acceptable for the session to be
permanently locked if this happens. The compositor may choose to continue
to display the lock surfaces the client had mapped before it died or
alternatively fall back to a solid color, this is compositor policy.
Compositors may also allow a secure way to recover the session, the
details of this are compositor policy. Compositors may allow a new
client to create a ext_session_lock_v1 object and take responsibility
for unlocking the session, they may even start a new lock client
instance automatically.
</description>
<enum name="error">
<entry name="invalid_destroy" value="0"
summary="attempted to destroy session lock while locked"/>
<entry name="invalid_unlock" value="1"
summary="unlock requested but locked event was never sent"/>
<entry name="role" value="2"
summary="given wl_surface already has a role"/>
<entry name="duplicate_output" value="3"
summary="given output already has a lock surface"/>
<entry name="already_constructed" value="4"
summary="given wl_surface has a buffer attached or committed"/>
</enum>
<request name="destroy" type="destructor">
<description summary="destroy the session lock">
This informs the compositor that the lock object will no longer be
used. Existing objects created through this interface remain valid.
After this request is made, lock surfaces created through this object
should be destroyed by the client as they will no longer be used by
the compositor.
It is a protocol error to make this request if the locked event was
sent, the unlock_and_destroy request must be used instead.
</description>
</request>
<event name="locked">
<description summary="session successfully locked">
This client is now responsible for displaying graphics while the
session is locked and deciding when to unlock the session.
The locked event must not be sent until a new "locked" frame has been
presented on all outputs and no security sensitive normal/unlocked
content is possibly visible.
If this event is sent, making the destroy request is a protocol error,
the lock object must be destroyed using the unlock_and_destroy request.
</description>
</event>
<event name="finished">
<description summary="the session lock object should be destroyed">
The compositor has decided that the session lock should be destroyed
as it will no longer be used by the compositor. Exactly when this
event is sent is compositor policy, but it must never be sent more
than once for a given session lock object.
This might be sent because there is already another ext_session_lock_v1
object held by a client, or the compositor has decided to deny the
request to lock the session for some other reason. This might also
be sent because the compositor implements some alternative, secure
way to authenticate and unlock the session.
The finished event should be sent immediately on creation of this
object if the compositor decides that the locked event will not
be sent.
If the locked event is sent on creation of this object the finished
event may still be sent at some later time in this object's
lifetime. This is compositor policy.
Upon receiving this event, the client should make either the destroy
request or the unlock_and_destroy request, depending on whether or
not the locked event was received on this object.
</description>
</event>
<request name="get_lock_surface">
<description summary="create a lock surface for a given output">
The client is expected to create lock surfaces for all outputs
currently present and any new outputs as they are advertised. These
won't be displayed by the compositor unless the lock is successful
and the locked event is sent.
Providing a wl_surface which already has a role or already has a buffer
attached or committed is a protocol error, as is attaching/committing
a buffer before the first ext_session_lock_surface_v1.configure event.
Attempting to create more than one lock surface for a given output
is a duplicate_output protocol error.
</description>
<arg name="id" type="new_id" interface="ext_session_lock_surface_v1"/>
<arg name="surface" type="object" interface="wl_surface"/>
<arg name="output" type="object" interface="wl_output"/>
</request>
<request name="unlock_and_destroy" type="destructor">
<description summary="unlock the session, destroying the object">
This request indicates that the session should be unlocked, for
example because the user has entered their password and it has been
verified by the client.
This request also informs the compositor that the lock object will
no longer be used and should be destroyed. Existing objects created
through this interface remain valid.
After this request is made, lock surfaces created through this object
should be destroyed by the client as they will no longer be used by
the compositor.
It is a protocol error to make this request if the locked event has
not been sent. In that case, the lock object must be destroyed using
the destroy request.
Note that a correct client that wishes to exit directly after unlocking
the session must use the wl_display.sync request to ensure the server
receives and processes the unlock_and_destroy request. Otherwise
there is no guarantee that the server has unlocked the session due
to the asynchronous nature of the Wayland protocol. For example,
the server might terminate the client with a protocol error before
it processes the unlock_and_destroy request.
</description>
</request>
</interface>
<interface name="ext_session_lock_surface_v1" version="1">
<description summary="a surface displayed while the session is locked">
The client may use lock surfaces to display a screensaver, render a
dialog to enter a password and unlock the session, or however else it
sees fit.
On binding this interface the compositor will immediately send the
first configure event. After making the ack_configure request in
response to this event the client should attach and commit the first
buffer. Committing the surface before acking the first configure is a
protocol error. Committing the surface with a null buffer at any time
is a protocol error.
The compositor is free to handle keyboard/pointer focus for lock
surfaces however it chooses. A reasonable way to do this would be to
give the first lock surface created keyboard focus and change keyboard
focus if the user clicks on other surfaces.
</description>
<enum name="error">
<entry name="commit_before_first_ack" value="0"
summary="surface committed before first ack_configure request"/>
<entry name="null_buffer" value="1"
summary="surface committed with a null buffer"/>
<entry name="dimensions_mismatch" value="2"
summary="failed to match ack'd width/height"/>
<entry name="invalid_serial" value="3"
summary="serial provided in ack_configure is invalid"/>
</enum>
<request name="destroy" type="destructor">
<description summary="destroy the lock surface object">
This informs the compositor that the lock surface object will no
longer be used.
It is recommended for a lock client to destroy lock surfaces if
their corresponding wl_output global is removed.
If a lock surface on an active output is destroyed before the
ext_session_lock_v1.unlock_and_destroy event is sent, the compositor
must fall back to rendering a solid color.
</description>
</request>
<request name="ack_configure">
<description summary="ack a configure event">
When a configure event is received, if a client commits the surface
in response to the configure event, then the client must make an
ack_configure request sometime before the commit request, passing
along the serial of the configure event.
If the client receives multiple configure events before it can
respond to one, it only has to ack the last configure event.
A client is not required to commit immediately after sending an
ack_configure request - it may even ack_configure several times
before its next surface commit.
A client may send multiple ack_configure requests before committing,
but only the last request sent before a commit indicates which
configure event the client really is responding to.
Sending an ack_configure request consumes the configure event
referenced by the given serial, as well as all older configure events
sent on this object.
It is a protocol error to issue multiple ack_configure requests
referencing the same configure event or to issue an ack_configure
request referencing a configure event older than the last configure
event acked for a given lock surface.
</description>
<arg name="serial" type="uint" summary="serial from the configure event"/>
</request>
<event name="configure">
<description summary="the client should resize its surface">
This event is sent once on binding the interface and may be sent again
at the compositor's discretion, for example if output geometry changes.
The width and height are in surface-local coordinates and are exact
requirements. Failing to match these surface dimensions in the next
commit after acking a configure is a protocol error.
</description>
<arg name="serial" type="uint" summary="serial for use in ack_configure"/>
<arg name="width" type="uint"/>
<arg name="height" type="uint"/>
</event>
</interface>
</protocol>

684
src/ext-session-lock-v1-client-protocol.h Normal file
View File

@@ -0,0 +1,684 @@
/* Generated by wayland-scanner 1.24.0 */
#ifndef EXT_SESSION_LOCK_V1_CLIENT_PROTOCOL_H
#define EXT_SESSION_LOCK_V1_CLIENT_PROTOCOL_H
#include <stdint.h>
#include <stddef.h>
#include "wayland-client.h"
#ifdef __cplusplus
extern "C" {
#endif
/**
* @page page_ext_session_lock_v1 The ext_session_lock_v1 protocol
* secure session locking with arbitrary graphics
*
* @section page_desc_ext_session_lock_v1 Description
*
* This protocol allows for a privileged Wayland client to lock the session
* and display arbitrary graphics while the session is locked.
*
* The compositor may choose to restrict this protocol to a special client
* launched by the compositor itself or expose it to all privileged clients,
* this is compositor policy.
*
* The client is responsible for performing authentication and informing the
* compositor when the session should be unlocked. If the client dies while
* the session is locked the session remains locked, possibly permanently
* depending on compositor policy.
*
* The key words "must", "must not", "required", "shall", "shall not",
* "should", "should not", "recommended", "may", and "optional" in this
* document are to be interpreted as described in IETF RFC 2119.
*
* Warning! The protocol described in this file is currently in the
* testing phase. Backward compatible changes may be added together with
* the corresponding interface version bump. Backward incompatible changes
* can only be done by creating a new major version of the extension.
*
* @section page_ifaces_ext_session_lock_v1 Interfaces
* - @subpage page_iface_ext_session_lock_manager_v1 - used to lock the session
* - @subpage page_iface_ext_session_lock_v1 - manage lock state and create lock surfaces
* - @subpage page_iface_ext_session_lock_surface_v1 - a surface displayed while the session is locked
* @section page_copyright_ext_session_lock_v1 Copyright
* <pre>
*
* Copyright 2021 Isaac Freund
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
* </pre>
*/
struct ext_session_lock_manager_v1;
struct ext_session_lock_surface_v1;
struct ext_session_lock_v1;
struct wl_output;
struct wl_surface;
#ifndef EXT_SESSION_LOCK_MANAGER_V1_INTERFACE
#define EXT_SESSION_LOCK_MANAGER_V1_INTERFACE
/**
* @page page_iface_ext_session_lock_manager_v1 ext_session_lock_manager_v1
* @section page_iface_ext_session_lock_manager_v1_desc Description
*
* This interface is used to request that the session be locked.
* @section page_iface_ext_session_lock_manager_v1_api API
* See @ref iface_ext_session_lock_manager_v1.
*/
/**
* @defgroup iface_ext_session_lock_manager_v1 The ext_session_lock_manager_v1 interface
*
* This interface is used to request that the session be locked.
*/
extern const struct wl_interface ext_session_lock_manager_v1_interface;
#endif
#ifndef EXT_SESSION_LOCK_V1_INTERFACE
#define EXT_SESSION_LOCK_V1_INTERFACE
/**
* @page page_iface_ext_session_lock_v1 ext_session_lock_v1
* @section page_iface_ext_session_lock_v1_desc Description
*
* In response to the creation of this object the compositor must send
* either the locked or finished event.
*
* The locked event indicates that the session is locked. This means
* that the compositor must stop rendering and providing input to normal
* clients. Instead the compositor must blank all outputs with an opaque
* color such that their normal content is fully hidden.
*
* The only surfaces that should be rendered while the session is locked
* are the lock surfaces created through this interface and optionally,
* at the compositor's discretion, special privileged surfaces such as
* input methods or portions of desktop shell UIs.
*
* The locked event must not be sent until a new "locked" frame (either
* from a session lock surface or the compositor blanking the output) has
* been presented on all outputs and no security sensitive normal/unlocked
* content is possibly visible.
*
* The finished event should be sent immediately on creation of this
* object if the compositor decides that the locked event will not be sent.
*
* The compositor may wait for the client to create and render session lock
* surfaces before sending the locked event to avoid displaying intermediate
* blank frames. However, it must impose a reasonable time limit if
* waiting and send the locked event as soon as the hard requirements
* described above can be met if the time limit expires. Clients should
* immediately create lock surfaces for all outputs on creation of this
* object to make this possible.
*
* This behavior of the locked event is required in order to prevent
* possible race conditions with clients that wish to suspend the system
* or similar after locking the session. Without these semantics, clients
* triggering a suspend after receiving the locked event would race with
* the first "locked" frame being presented and normal/unlocked frames
* might be briefly visible as the system is resumed if the suspend
* operation wins the race.
*
* If the client dies while the session is locked, the compositor must not
* unlock the session in response. It is acceptable for the session to be
* permanently locked if this happens. The compositor may choose to continue
* to display the lock surfaces the client had mapped before it died or
* alternatively fall back to a solid color, this is compositor policy.
*
* Compositors may also allow a secure way to recover the session, the
* details of this are compositor policy. Compositors may allow a new
* client to create a ext_session_lock_v1 object and take responsibility
* for unlocking the session, they may even start a new lock client
* instance automatically.
* @section page_iface_ext_session_lock_v1_api API
* See @ref iface_ext_session_lock_v1.
*/
/**
* @defgroup iface_ext_session_lock_v1 The ext_session_lock_v1 interface
*
* In response to the creation of this object the compositor must send
* either the locked or finished event.
*
* The locked event indicates that the session is locked. This means
* that the compositor must stop rendering and providing input to normal
* clients. Instead the compositor must blank all outputs with an opaque
* color such that their normal content is fully hidden.
*
* The only surfaces that should be rendered while the session is locked
* are the lock surfaces created through this interface and optionally,
* at the compositor's discretion, special privileged surfaces such as
* input methods or portions of desktop shell UIs.
*
* The locked event must not be sent until a new "locked" frame (either
* from a session lock surface or the compositor blanking the output) has
* been presented on all outputs and no security sensitive normal/unlocked
* content is possibly visible.
*
* The finished event should be sent immediately on creation of this
* object if the compositor decides that the locked event will not be sent.
*
* The compositor may wait for the client to create and render session lock
* surfaces before sending the locked event to avoid displaying intermediate
* blank frames. However, it must impose a reasonable time limit if
* waiting and send the locked event as soon as the hard requirements
* described above can be met if the time limit expires. Clients should
* immediately create lock surfaces for all outputs on creation of this
* object to make this possible.
*
* This behavior of the locked event is required in order to prevent
* possible race conditions with clients that wish to suspend the system
* or similar after locking the session. Without these semantics, clients
* triggering a suspend after receiving the locked event would race with
* the first "locked" frame being presented and normal/unlocked frames
* might be briefly visible as the system is resumed if the suspend
* operation wins the race.
*
* If the client dies while the session is locked, the compositor must not
* unlock the session in response. It is acceptable for the session to be
* permanently locked if this happens. The compositor may choose to continue
* to display the lock surfaces the client had mapped before it died or
* alternatively fall back to a solid color, this is compositor policy.
*
* Compositors may also allow a secure way to recover the session, the
* details of this are compositor policy. Compositors may allow a new
* client to create a ext_session_lock_v1 object and take responsibility
* for unlocking the session, they may even start a new lock client
* instance automatically.
*/
extern const struct wl_interface ext_session_lock_v1_interface;
#endif
#ifndef EXT_SESSION_LOCK_SURFACE_V1_INTERFACE
#define EXT_SESSION_LOCK_SURFACE_V1_INTERFACE
/**
* @page page_iface_ext_session_lock_surface_v1 ext_session_lock_surface_v1
* @section page_iface_ext_session_lock_surface_v1_desc Description
*
* The client may use lock surfaces to display a screensaver, render a
* dialog to enter a password and unlock the session, or however else it
* sees fit.
*
* On binding this interface the compositor will immediately send the
* first configure event. After making the ack_configure request in
* response to this event the client should attach and commit the first
* buffer. Committing the surface before acking the first configure is a
* protocol error. Committing the surface with a null buffer at any time
* is a protocol error.
*
* The compositor is free to handle keyboard/pointer focus for lock
* surfaces however it chooses. A reasonable way to do this would be to
* give the first lock surface created keyboard focus and change keyboard
* focus if the user clicks on other surfaces.
* @section page_iface_ext_session_lock_surface_v1_api API
* See @ref iface_ext_session_lock_surface_v1.
*/
/**
* @defgroup iface_ext_session_lock_surface_v1 The ext_session_lock_surface_v1 interface
*
* The client may use lock surfaces to display a screensaver, render a
* dialog to enter a password and unlock the session, or however else it
* sees fit.
*
* On binding this interface the compositor will immediately send the
* first configure event. After making the ack_configure request in
* response to this event the client should attach and commit the first
* buffer. Committing the surface before acking the first configure is a
* protocol error. Committing the surface with a null buffer at any time
* is a protocol error.
*
* The compositor is free to handle keyboard/pointer focus for lock
* surfaces however it chooses. A reasonable way to do this would be to
* give the first lock surface created keyboard focus and change keyboard
* focus if the user clicks on other surfaces.
*/
extern const struct wl_interface ext_session_lock_surface_v1_interface;
#endif
#define EXT_SESSION_LOCK_MANAGER_V1_DESTROY 0
#define EXT_SESSION_LOCK_MANAGER_V1_LOCK 1
/**
* @ingroup iface_ext_session_lock_manager_v1
*/
#define EXT_SESSION_LOCK_MANAGER_V1_DESTROY_SINCE_VERSION 1
/**
* @ingroup iface_ext_session_lock_manager_v1
*/
#define EXT_SESSION_LOCK_MANAGER_V1_LOCK_SINCE_VERSION 1
/** @ingroup iface_ext_session_lock_manager_v1 */
static inline void
ext_session_lock_manager_v1_set_user_data(struct ext_session_lock_manager_v1 *ext_session_lock_manager_v1, void *user_data)
{
wl_proxy_set_user_data((struct wl_proxy *) ext_session_lock_manager_v1, user_data);
}
/** @ingroup iface_ext_session_lock_manager_v1 */
static inline void *
ext_session_lock_manager_v1_get_user_data(struct ext_session_lock_manager_v1 *ext_session_lock_manager_v1)
{
return wl_proxy_get_user_data((struct wl_proxy *) ext_session_lock_manager_v1);
}
static inline uint32_t
ext_session_lock_manager_v1_get_version(struct ext_session_lock_manager_v1 *ext_session_lock_manager_v1)
{
return wl_proxy_get_version((struct wl_proxy *) ext_session_lock_manager_v1);
}
/**
* @ingroup iface_ext_session_lock_manager_v1
*
* This informs the compositor that the session lock manager object will
* no longer be used. Existing objects created through this interface
* remain valid.
*/
static inline void
ext_session_lock_manager_v1_destroy(struct ext_session_lock_manager_v1 *ext_session_lock_manager_v1)
{
wl_proxy_marshal_flags((struct wl_proxy *) ext_session_lock_manager_v1,
EXT_SESSION_LOCK_MANAGER_V1_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) ext_session_lock_manager_v1), WL_MARSHAL_FLAG_DESTROY);
}
/**
* @ingroup iface_ext_session_lock_manager_v1
*
* This request creates a session lock and asks the compositor to lock the
* session. The compositor will send either the ext_session_lock_v1.locked
* or ext_session_lock_v1.finished event on the created object in
* response to this request.
*/
static inline struct ext_session_lock_v1 *
ext_session_lock_manager_v1_lock(struct ext_session_lock_manager_v1 *ext_session_lock_manager_v1)
{
struct wl_proxy *id;
id = wl_proxy_marshal_flags((struct wl_proxy *) ext_session_lock_manager_v1,
EXT_SESSION_LOCK_MANAGER_V1_LOCK, &ext_session_lock_v1_interface, wl_proxy_get_version((struct wl_proxy *) ext_session_lock_manager_v1), 0, NULL);
return (struct ext_session_lock_v1 *) id;
}
#ifndef EXT_SESSION_LOCK_V1_ERROR_ENUM
#define EXT_SESSION_LOCK_V1_ERROR_ENUM
enum ext_session_lock_v1_error {
/**
* attempted to destroy session lock while locked
*/
EXT_SESSION_LOCK_V1_ERROR_INVALID_DESTROY = 0,
/**
* unlock requested but locked event was never sent
*/
EXT_SESSION_LOCK_V1_ERROR_INVALID_UNLOCK = 1,
/**
* given wl_surface already has a role
*/
EXT_SESSION_LOCK_V1_ERROR_ROLE = 2,
/**
* given output already has a lock surface
*/
EXT_SESSION_LOCK_V1_ERROR_DUPLICATE_OUTPUT = 3,
/**
* given wl_surface has a buffer attached or committed
*/
EXT_SESSION_LOCK_V1_ERROR_ALREADY_CONSTRUCTED = 4,
};
#endif /* EXT_SESSION_LOCK_V1_ERROR_ENUM */
/**
* @ingroup iface_ext_session_lock_v1
* @struct ext_session_lock_v1_listener
*/
struct ext_session_lock_v1_listener {
/**
* session successfully locked
*
* This client is now responsible for displaying graphics while
* the session is locked and deciding when to unlock the session.
*
* The locked event must not be sent until a new "locked" frame has
* been presented on all outputs and no security sensitive
* normal/unlocked content is possibly visible.
*
* If this event is sent, making the destroy request is a protocol
* error, the lock object must be destroyed using the
* unlock_and_destroy request.
*/
void (*locked)(void *data,
struct ext_session_lock_v1 *ext_session_lock_v1);
/**
* the session lock object should be destroyed
*
* The compositor has decided that the session lock should be
* destroyed as it will no longer be used by the compositor.
* Exactly when this event is sent is compositor policy, but it
* must never be sent more than once for a given session lock
* object.
*
* This might be sent because there is already another
* ext_session_lock_v1 object held by a client, or the compositor
* has decided to deny the request to lock the session for some
* other reason. This might also be sent because the compositor
* implements some alternative, secure way to authenticate and
* unlock the session.
*
* The finished event should be sent immediately on creation of
* this object if the compositor decides that the locked event will
* not be sent.
*
* If the locked event is sent on creation of this object the
* finished event may still be sent at some later time in this
* object's lifetime. This is compositor policy.
*
* Upon receiving this event, the client should make either the
* destroy request or the unlock_and_destroy request, depending on
* whether or not the locked event was received on this object.
*/
void (*finished)(void *data,
struct ext_session_lock_v1 *ext_session_lock_v1);
};
/**
* @ingroup iface_ext_session_lock_v1
*/
static inline int
ext_session_lock_v1_add_listener(struct ext_session_lock_v1 *ext_session_lock_v1,
const struct ext_session_lock_v1_listener *listener, void *data)
{
return wl_proxy_add_listener((struct wl_proxy *) ext_session_lock_v1,
(void (**)(void)) listener, data);
}
#define EXT_SESSION_LOCK_V1_DESTROY 0
#define EXT_SESSION_LOCK_V1_GET_LOCK_SURFACE 1
#define EXT_SESSION_LOCK_V1_UNLOCK_AND_DESTROY 2
/**
* @ingroup iface_ext_session_lock_v1
*/
#define EXT_SESSION_LOCK_V1_LOCKED_SINCE_VERSION 1
/**
* @ingroup iface_ext_session_lock_v1
*/
#define EXT_SESSION_LOCK_V1_FINISHED_SINCE_VERSION 1
/**
* @ingroup iface_ext_session_lock_v1
*/
#define EXT_SESSION_LOCK_V1_DESTROY_SINCE_VERSION 1
/**
* @ingroup iface_ext_session_lock_v1
*/
#define EXT_SESSION_LOCK_V1_GET_LOCK_SURFACE_SINCE_VERSION 1
/**
* @ingroup iface_ext_session_lock_v1
*/
#define EXT_SESSION_LOCK_V1_UNLOCK_AND_DESTROY_SINCE_VERSION 1
/** @ingroup iface_ext_session_lock_v1 */
static inline void
ext_session_lock_v1_set_user_data(struct ext_session_lock_v1 *ext_session_lock_v1, void *user_data)
{
wl_proxy_set_user_data((struct wl_proxy *) ext_session_lock_v1, user_data);
}
/** @ingroup iface_ext_session_lock_v1 */
static inline void *
ext_session_lock_v1_get_user_data(struct ext_session_lock_v1 *ext_session_lock_v1)
{
return wl_proxy_get_user_data((struct wl_proxy *) ext_session_lock_v1);
}
static inline uint32_t
ext_session_lock_v1_get_version(struct ext_session_lock_v1 *ext_session_lock_v1)
{
return wl_proxy_get_version((struct wl_proxy *) ext_session_lock_v1);
}
/**
* @ingroup iface_ext_session_lock_v1
*
* This informs the compositor that the lock object will no longer be
* used. Existing objects created through this interface remain valid.
*
* After this request is made, lock surfaces created through this object
* should be destroyed by the client as they will no longer be used by
* the compositor.
*
* It is a protocol error to make this request if the locked event was
* sent, the unlock_and_destroy request must be used instead.
*/
static inline void
ext_session_lock_v1_destroy(struct ext_session_lock_v1 *ext_session_lock_v1)
{
wl_proxy_marshal_flags((struct wl_proxy *) ext_session_lock_v1,
EXT_SESSION_LOCK_V1_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) ext_session_lock_v1), WL_MARSHAL_FLAG_DESTROY);
}
/**
* @ingroup iface_ext_session_lock_v1
*
* The client is expected to create lock surfaces for all outputs
* currently present and any new outputs as they are advertised. These
* won't be displayed by the compositor unless the lock is successful
* and the locked event is sent.
*
* Providing a wl_surface which already has a role or already has a buffer
* attached or committed is a protocol error, as is attaching/committing
* a buffer before the first ext_session_lock_surface_v1.configure event.
*
* Attempting to create more than one lock surface for a given output
* is a duplicate_output protocol error.
*/
static inline struct ext_session_lock_surface_v1 *
ext_session_lock_v1_get_lock_surface(struct ext_session_lock_v1 *ext_session_lock_v1, struct wl_surface *surface, struct wl_output *output)
{
struct wl_proxy *id;
id = wl_proxy_marshal_flags((struct wl_proxy *) ext_session_lock_v1,
EXT_SESSION_LOCK_V1_GET_LOCK_SURFACE, &ext_session_lock_surface_v1_interface, wl_proxy_get_version((struct wl_proxy *) ext_session_lock_v1), 0, NULL, surface, output);
return (struct ext_session_lock_surface_v1 *) id;
}
/**
* @ingroup iface_ext_session_lock_v1
*
* This request indicates that the session should be unlocked, for
* example because the user has entered their password and it has been
* verified by the client.
*
* This request also informs the compositor that the lock object will
* no longer be used and should be destroyed. Existing objects created
* through this interface remain valid.
*
* After this request is made, lock surfaces created through this object
* should be destroyed by the client as they will no longer be used by
* the compositor.
*
* It is a protocol error to make this request if the locked event has
* not been sent. In that case, the lock object must be destroyed using
* the destroy request.
*
* Note that a correct client that wishes to exit directly after unlocking
* the session must use the wl_display.sync request to ensure the server
* receives and processes the unlock_and_destroy request. Otherwise
* there is no guarantee that the server has unlocked the session due
* to the asynchronous nature of the Wayland protocol. For example,
* the server might terminate the client with a protocol error before
* it processes the unlock_and_destroy request.
*/
static inline void
ext_session_lock_v1_unlock_and_destroy(struct ext_session_lock_v1 *ext_session_lock_v1)
{
wl_proxy_marshal_flags((struct wl_proxy *) ext_session_lock_v1,
EXT_SESSION_LOCK_V1_UNLOCK_AND_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) ext_session_lock_v1), WL_MARSHAL_FLAG_DESTROY);
}
#ifndef EXT_SESSION_LOCK_SURFACE_V1_ERROR_ENUM
#define EXT_SESSION_LOCK_SURFACE_V1_ERROR_ENUM
enum ext_session_lock_surface_v1_error {
/**
* surface committed before first ack_configure request
*/
EXT_SESSION_LOCK_SURFACE_V1_ERROR_COMMIT_BEFORE_FIRST_ACK = 0,
/**
* surface committed with a null buffer
*/
EXT_SESSION_LOCK_SURFACE_V1_ERROR_NULL_BUFFER = 1,
/**
* failed to match ack'd width/height
*/
EXT_SESSION_LOCK_SURFACE_V1_ERROR_DIMENSIONS_MISMATCH = 2,
/**
* serial provided in ack_configure is invalid
*/
EXT_SESSION_LOCK_SURFACE_V1_ERROR_INVALID_SERIAL = 3,
};
#endif /* EXT_SESSION_LOCK_SURFACE_V1_ERROR_ENUM */
/**
* @ingroup iface_ext_session_lock_surface_v1
* @struct ext_session_lock_surface_v1_listener
*/
struct ext_session_lock_surface_v1_listener {
/**
* the client should resize its surface
*
* This event is sent once on binding the interface and may be
* sent again at the compositor's discretion, for example if output
* geometry changes.
*
* The width and height are in surface-local coordinates and are
* exact requirements. Failing to match these surface dimensions in
* the next commit after acking a configure is a protocol error.
* @param serial serial for use in ack_configure
*/
void (*configure)(void *data,
struct ext_session_lock_surface_v1 *ext_session_lock_surface_v1,
uint32_t serial,
uint32_t width,
uint32_t height);
};
/**
* @ingroup iface_ext_session_lock_surface_v1
*/
static inline int
ext_session_lock_surface_v1_add_listener(struct ext_session_lock_surface_v1 *ext_session_lock_surface_v1,
const struct ext_session_lock_surface_v1_listener *listener, void *data)
{
return wl_proxy_add_listener((struct wl_proxy *) ext_session_lock_surface_v1,
(void (**)(void)) listener, data);
}
#define EXT_SESSION_LOCK_SURFACE_V1_DESTROY 0
#define EXT_SESSION_LOCK_SURFACE_V1_ACK_CONFIGURE 1
/**
* @ingroup iface_ext_session_lock_surface_v1
*/
#define EXT_SESSION_LOCK_SURFACE_V1_CONFIGURE_SINCE_VERSION 1
/**
* @ingroup iface_ext_session_lock_surface_v1
*/
#define EXT_SESSION_LOCK_SURFACE_V1_DESTROY_SINCE_VERSION 1
/**
* @ingroup iface_ext_session_lock_surface_v1
*/
#define EXT_SESSION_LOCK_SURFACE_V1_ACK_CONFIGURE_SINCE_VERSION 1
/** @ingroup iface_ext_session_lock_surface_v1 */
static inline void
ext_session_lock_surface_v1_set_user_data(struct ext_session_lock_surface_v1 *ext_session_lock_surface_v1, void *user_data)
{
wl_proxy_set_user_data((struct wl_proxy *) ext_session_lock_surface_v1, user_data);
}
/** @ingroup iface_ext_session_lock_surface_v1 */
static inline void *
ext_session_lock_surface_v1_get_user_data(struct ext_session_lock_surface_v1 *ext_session_lock_surface_v1)
{
return wl_proxy_get_user_data((struct wl_proxy *) ext_session_lock_surface_v1);
}
static inline uint32_t
ext_session_lock_surface_v1_get_version(struct ext_session_lock_surface_v1 *ext_session_lock_surface_v1)
{
return wl_proxy_get_version((struct wl_proxy *) ext_session_lock_surface_v1);
}
/**
* @ingroup iface_ext_session_lock_surface_v1
*
* This informs the compositor that the lock surface object will no
* longer be used.
*
* It is recommended for a lock client to destroy lock surfaces if
* their corresponding wl_output global is removed.
*
* If a lock surface on an active output is destroyed before the
* ext_session_lock_v1.unlock_and_destroy event is sent, the compositor
* must fall back to rendering a solid color.
*/
static inline void
ext_session_lock_surface_v1_destroy(struct ext_session_lock_surface_v1 *ext_session_lock_surface_v1)
{
wl_proxy_marshal_flags((struct wl_proxy *) ext_session_lock_surface_v1,
EXT_SESSION_LOCK_SURFACE_V1_DESTROY, NULL, wl_proxy_get_version((struct wl_proxy *) ext_session_lock_surface_v1), WL_MARSHAL_FLAG_DESTROY);
}
/**
* @ingroup iface_ext_session_lock_surface_v1
*
* When a configure event is received, if a client commits the surface
* in response to the configure event, then the client must make an
* ack_configure request sometime before the commit request, passing
* along the serial of the configure event.
*
* If the client receives multiple configure events before it can
* respond to one, it only has to ack the last configure event.
*
* A client is not required to commit immediately after sending an
* ack_configure request - it may even ack_configure several times
* before its next surface commit.
*
* A client may send multiple ack_configure requests before committing,
* but only the last request sent before a commit indicates which
* configure event the client really is responding to.
*
* Sending an ack_configure request consumes the configure event
* referenced by the given serial, as well as all older configure events
* sent on this object.
*
* It is a protocol error to issue multiple ack_configure requests
* referencing the same configure event or to issue an ack_configure
* request referencing a configure event older than the last configure
* event acked for a given lock surface.
*/
static inline void
ext_session_lock_surface_v1_ack_configure(struct ext_session_lock_surface_v1 *ext_session_lock_surface_v1, uint32_t serial)
{
wl_proxy_marshal_flags((struct wl_proxy *) ext_session_lock_surface_v1,
EXT_SESSION_LOCK_SURFACE_V1_ACK_CONFIGURE, NULL, wl_proxy_get_version((struct wl_proxy *) ext_session_lock_surface_v1), 0, serial);
}
#ifdef __cplusplus
}
#endif
#endif

97
src/ext-session-lock-v1-protocol.c Normal file
View File

@@ -0,0 +1,97 @@
/* Generated by wayland-scanner 1.24.0 */
/*
* Copyright 2021 Isaac Freund
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <stdbool.h>
#include <stdlib.h>
#include <stdint.h>
#include "wayland-util.h"
#ifndef __has_attribute
# define __has_attribute(x) 0 /* Compatibility with non-clang compilers. */
#endif
#if (__has_attribute(visibility) || defined(__GNUC__) && __GNUC__ >= 4)
#define WL_PRIVATE __attribute__ ((visibility("hidden")))
#else
#define WL_PRIVATE
#endif
extern const struct wl_interface ext_session_lock_surface_v1_interface;
extern const struct wl_interface ext_session_lock_v1_interface;
extern const struct wl_interface wl_output_interface;
extern const struct wl_interface wl_surface_interface;
static const struct wl_interface *ext_session_lock_v1_types[] = {
NULL,
NULL,
NULL,
&ext_session_lock_v1_interface,
&ext_session_lock_surface_v1_interface,
&wl_surface_interface,
&wl_output_interface,
};
static const struct wl_message ext_session_lock_manager_v1_requests[] = {
{ "destroy", "", ext_session_lock_v1_types + 0 },
{ "lock", "n", ext_session_lock_v1_types + 3 },
};
WL_PRIVATE const struct wl_interface ext_session_lock_manager_v1_interface = {
"ext_session_lock_manager_v1", 1,
2, ext_session_lock_manager_v1_requests,
0, NULL,
};
static const struct wl_message ext_session_lock_v1_requests[] = {
{ "destroy", "", ext_session_lock_v1_types + 0 },
{ "get_lock_surface", "noo", ext_session_lock_v1_types + 4 },
{ "unlock_and_destroy", "", ext_session_lock_v1_types + 0 },
};
static const struct wl_message ext_session_lock_v1_events[] = {
{ "locked", "", ext_session_lock_v1_types + 0 },
{ "finished", "", ext_session_lock_v1_types + 0 },
};
WL_PRIVATE const struct wl_interface ext_session_lock_v1_interface = {
"ext_session_lock_v1", 1,
3, ext_session_lock_v1_requests,
2, ext_session_lock_v1_events,
};
static const struct wl_message ext_session_lock_surface_v1_requests[] = {
{ "destroy", "", ext_session_lock_v1_types + 0 },
{ "ack_configure", "u", ext_session_lock_v1_types + 0 },
};
static const struct wl_message ext_session_lock_surface_v1_events[] = {
{ "configure", "uuu", ext_session_lock_v1_types + 0 },
};
WL_PRIVATE const struct wl_interface ext_session_lock_surface_v1_interface = {
"ext_session_lock_surface_v1", 1,
2, ext_session_lock_surface_v1_requests,
1, ext_session_lock_surface_v1_events,
};

17
src/main.cpp
View File

@@ -1,4 +1,21 @@
#include "spdlog/spdlog.h"
#include <memory>
#include <stdexcept>
#include <wayland-client-core.h>
#include <wayland-client-protocol.h>
#include <wayland-egl-core.h>
#include "state.hpp"
int main (int argc, char *argv[]) {
std::shared_ptr<state::LockScreenState> application_state = std::make_shared<state::LockScreenState>();
application_state->display = wl_display_connect(nullptr);
if(!application_state->display) throw std::runtime_error("failed to initialize display");
spdlog::debug("Successfully initialized a display");
application_state->compositer_registry = wl_display_get_registry(application_state->display);
return 0;
}

17
src/state.cpp Normal file
View File

@@ -0,0 +1,17 @@
#include "state.hpp"
#include "ext-session-lock-v1-client-protocol.h"
#include <wayland-client-core.h>
#include <wayland-client-protocol.h>
#include <wayland-egl-core.h>
namespace state{
LockScreenState::~LockScreenState(){
if(display) wl_display_disconnect(display);
if(lock_manager) ext_session_lock_manager_v1_destroy(lock_manager);
if(compostier) wl_compositor_destroy(compostier);
if(compositer_registry) wl_registry_destroy(compositer_registry);
running=false;
}
Output::~Output(){
if(output) wl_output_destroy(output);
}
}

33
src/state.hpp Normal file
View File

@@ -0,0 +1,33 @@
#pragma once
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
#include <wayland-client-core.h>
#include <wayland-client-protocol.h>
#include <wayland-egl-core.h>
#include "ext-session-lock-v1-client-protocol.h"
namespace state{
struct Output{
wl_output* output = nullptr;
uint32_t registry_id = 0;
uint32_t width = uint32_t {0};
uint32_t height = uint32_t {0};
~Output();
};
struct LockScreenState{
wl_display* display = nullptr;
wl_registry* compositer_registry = nullptr;
wl_compositor* compostier = nullptr;
ext_session_lock_manager_v1* lock_manager = nullptr;
std::string username = std::string {};
std::string password = std::string {};
std::vector<std::shared_ptr<Output>> outputs = std::vector<std::shared_ptr<Output>>{};
bool running = true;
~LockScreenState();
};
}