new API
and code cleanup
This commit is contained in:
Leon Henrik Plickat
424
src/riverguile.c
Normal file
424
src/riverguile.c
Normal file
@@ -0,0 +1,424 @@
|
||||
#include <ctype.h>
|
||||
#include <signal.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
#include <assert.h>
|
||||
#include <setjmp.h>
|
||||
#include <wayland-client.h>
|
||||
#include <libguile.h>
|
||||
|
||||
#ifdef __linux__
|
||||
#include <features.h>
|
||||
#ifdef __GLIBC__
|
||||
#include<execinfo.h>
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include "river-layout-v3.h"
|
||||
|
||||
#include "types.h"
|
||||
#include "call-layout-demand-handler.h"
|
||||
#include "call-user-command-handler.h"
|
||||
#include "load-script.h"
|
||||
|
||||
bool loop = true;
|
||||
int ret = EXIT_SUCCESS;
|
||||
|
||||
jmp_buf skip_main_loop;
|
||||
|
||||
struct wl_display *wl_display = NULL;
|
||||
struct wl_registry *wl_registry = NULL;
|
||||
struct wl_callback *sync_callback = NULL;
|
||||
struct river_layout_manager_v3 *layout_manager = NULL;
|
||||
|
||||
struct wl_list outputs;
|
||||
|
||||
/* Handlers are initially NULL instead of SCM_EOL because I am not sure whether
|
||||
* scm_null_p() is safe to use outside of a guile context and if yes, whether
|
||||
* that is intended or will disappear in the future. Special care must be taken
|
||||
* to never call any scm_* function on these while they are NULL.
|
||||
*/
|
||||
SCM layout_demand_handler = NULL;
|
||||
SCM user_command_handler = NULL;
|
||||
|
||||
static void layout_handle_layout_demand (void *data, struct river_layout_v3 *river_layout_v3,
|
||||
uint32_t view_count, uint32_t width, uint32_t height, uint32_t tags, uint32_t serial)
|
||||
{
|
||||
struct Output *output = (struct Output *)data;
|
||||
|
||||
struct Call_layout_demand_handler_parameters params = {
|
||||
.view_count = view_count,
|
||||
.width = width,
|
||||
.height = height,
|
||||
.serial = serial,
|
||||
.tags = tags,
|
||||
.output = output,
|
||||
};
|
||||
|
||||
void *res = scm_with_guile(call_layout_demand_handler, (void *)¶ms);
|
||||
if ( res != NULL )
|
||||
{
|
||||
fputs(res, stderr);
|
||||
fputs("INFO: This error is not fatal.\n", stderr);
|
||||
return;
|
||||
}
|
||||
|
||||
// TODO allow setting layout name from user installed layout demand handler
|
||||
river_layout_v3_commit(output->layout, "(🐦)", serial);
|
||||
}
|
||||
|
||||
static void layout_handle_user_command (void *data,
|
||||
struct river_layout_v3 *river_layout, const char *command)
|
||||
{
|
||||
if ( user_command_handler == NULL )
|
||||
return;
|
||||
|
||||
struct Output *output = (struct Output *)data;
|
||||
|
||||
struct Call_user_command_parameters params = {
|
||||
.cmd = command,
|
||||
.output = output,
|
||||
};
|
||||
|
||||
void *res = scm_with_guile(call_user_command_handler, (void *)¶ms);
|
||||
if ( res != NULL )
|
||||
{
|
||||
fputs(res, stderr);
|
||||
fputs("INFO: This error is not fatal.\n", stderr);
|
||||
}
|
||||
}
|
||||
|
||||
static void layout_handle_user_command_tags (void *data,
|
||||
struct river_layout_v3 *river_layout, uint32_t tags)
|
||||
{
|
||||
struct Output *output = (struct Output *)data;
|
||||
output->user_command_tags = tags;
|
||||
}
|
||||
|
||||
static void layout_handle_namespace_in_use (void *data, struct river_layout_v3 *river_layout_v3)
|
||||
{
|
||||
fputs("ERROR: Namespace already in use.\n", stderr);
|
||||
ret = EXIT_FAILURE;
|
||||
loop = false;
|
||||
}
|
||||
|
||||
static const struct river_layout_v3_listener layout_listener = {
|
||||
.namespace_in_use = layout_handle_namespace_in_use,
|
||||
.layout_demand = layout_handle_layout_demand,
|
||||
.user_command = layout_handle_user_command,
|
||||
.user_command_tags = layout_handle_user_command_tags,
|
||||
};
|
||||
|
||||
static void output_configure (struct Output *output)
|
||||
{
|
||||
if ( layout_manager == NULL )
|
||||
return;
|
||||
if (output->configured)
|
||||
return;
|
||||
|
||||
output->layout = river_layout_manager_v3_get_layout(
|
||||
layout_manager, output->wl_output, "riverguile"
|
||||
);
|
||||
river_layout_v3_add_listener(output->layout, &layout_listener, output);
|
||||
output->configured = true;
|
||||
}
|
||||
|
||||
static struct Output *output_create (struct wl_output *wl_output)
|
||||
{
|
||||
struct Output *output = calloc(1, sizeof(struct Output));
|
||||
if ( output == NULL )
|
||||
{
|
||||
fprintf(stderr, "ERROR: calloc: %s\n", strerror(errno));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
output->wl_output = wl_output;
|
||||
output_configure(output);
|
||||
return output;
|
||||
}
|
||||
|
||||
static void output_destroy (struct Output *output)
|
||||
{
|
||||
if ( output->layout != NULL )
|
||||
river_layout_v3_destroy(output->layout);
|
||||
assert(output->wl_output != NULL);
|
||||
wl_output_destroy(output->wl_output);
|
||||
free(output);
|
||||
}
|
||||
|
||||
static void registry_handle_global (void *data, struct wl_registry *registry,
|
||||
uint32_t name, const char *interface, uint32_t version)
|
||||
{
|
||||
if ( strcmp(interface, river_layout_manager_v3_interface.name) == 0 )
|
||||
{
|
||||
layout_manager = wl_registry_bind(
|
||||
registry, name, &river_layout_manager_v3_interface, 2
|
||||
);
|
||||
}
|
||||
else if ( strcmp(interface, wl_output_interface.name) == 0 )
|
||||
{
|
||||
struct wl_output *wl_output = wl_registry_bind(
|
||||
registry, name, &wl_output_interface, 1
|
||||
);
|
||||
struct Output *output = output_create(wl_output);
|
||||
if ( output == NULL )
|
||||
{
|
||||
wl_output_destroy(wl_output);
|
||||
ret = EXIT_FAILURE;
|
||||
loop = false;
|
||||
return;
|
||||
}
|
||||
wl_list_insert(&outputs, &output->link);
|
||||
}
|
||||
}
|
||||
|
||||
static void registry_handle_global_remove (void *data, struct wl_registry *registry,
|
||||
uint32_t name)
|
||||
{
|
||||
struct Output *output, *tmp;
|
||||
wl_list_for_each_safe(output, tmp, &outputs, link)
|
||||
{
|
||||
if ( output->name != name )
|
||||
continue;
|
||||
wl_list_remove(&output->link);
|
||||
output_destroy(output);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
static const struct wl_registry_listener registry_listener = {
|
||||
.global = registry_handle_global,
|
||||
.global_remove = registry_handle_global_remove,
|
||||
};
|
||||
|
||||
static void sync_handle_done (void *data, struct wl_callback *wl_callback, uint32_t other_data)
|
||||
{
|
||||
wl_callback_destroy(wl_callback);
|
||||
sync_callback = NULL;
|
||||
|
||||
if ( layout_manager == NULL )
|
||||
{
|
||||
fputs("ERROR: Wayland server does not support river-layout-v3.\n", stderr);
|
||||
ret = EXIT_FAILURE;
|
||||
loop = false;
|
||||
return;
|
||||
}
|
||||
|
||||
/* If outputs were registered before the river_layout_manager is
|
||||
* available, they won't have a river_layout, so we need to create
|
||||
* those here.
|
||||
*/
|
||||
struct Output *output;
|
||||
wl_list_for_each(output, &outputs, link)
|
||||
output_configure(output);
|
||||
}
|
||||
|
||||
static const struct wl_callback_listener sync_callback_listener = {
|
||||
.done = sync_handle_done,
|
||||
};
|
||||
|
||||
static void handle_interrupt (int signum)
|
||||
{
|
||||
fputs("Killed 💀\n", stderr);
|
||||
loop = false;
|
||||
longjmp(skip_main_loop, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Intercept error signals (like SIGSEGV and SIGFPE) so that we can try to
|
||||
* print a fancy error message and a backtracke before letting the system kill us.
|
||||
*/
|
||||
static void handle_error (int signum)
|
||||
{
|
||||
const char *msg =
|
||||
"\n"
|
||||
"┌──────────────────────────────────────────┐\n"
|
||||
"│ │\n"
|
||||
"│ riverguile has crashed. │\n"
|
||||
"│ │\n"
|
||||
"│ This is most likely a bug, so please │\n"
|
||||
"│ report this to the mailing list. │\n"
|
||||
"│ │\n"
|
||||
"│ ~leon_plickat/public-inbox@lists.sr.ht │\n"
|
||||
"│ │\n"
|
||||
"└──────────────────────────────────────────┘\n"
|
||||
"\n";
|
||||
fputs(msg, stderr);
|
||||
|
||||
/* Set up the default handlers to deal with the rest. We do this before
|
||||
* attempting to get a backtrace, because sometimes that could also
|
||||
* cause a SEGFAULT and we don't want a funny signal loop to happen.
|
||||
*/
|
||||
signal(signum, SIG_DFL);
|
||||
|
||||
#ifdef __linux__
|
||||
#ifdef __GLIBC__
|
||||
fputs("Attempting to get backtrace:\n", stderr);
|
||||
void *buffer[255];
|
||||
const int calls = backtrace(buffer, sizeof(buffer) / sizeof(void *));
|
||||
backtrace_symbols_fd(buffer, calls, fileno(stderr));
|
||||
fputs("\n", stderr);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* Easiest way of calling the default signal handler. */
|
||||
kill(getpid(), signum);
|
||||
}
|
||||
|
||||
|
||||
static char *formatted_buffer (const char *fmt, ...)
|
||||
{
|
||||
/* Determine length of formatted text. */
|
||||
va_list args;
|
||||
va_start(args, fmt);
|
||||
/* +1 for NULL. */
|
||||
unsigned long len = (unsigned long)vsnprintf(NULL, 0, fmt, args) + 1;
|
||||
va_end(args);
|
||||
|
||||
char *buffer = calloc(1, len);
|
||||
if ( buffer == NULL )
|
||||
{
|
||||
fprintf(stderr, "ERROR: calloc: %s\n", strerror(errno));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Finally write formatted text into buffer. */
|
||||
va_start(args, fmt);
|
||||
vsnprintf(buffer, len, fmt, args);
|
||||
va_end(args);
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
static char *get_script_path (void)
|
||||
{
|
||||
struct {
|
||||
const char *fmt;
|
||||
bool needs_env;
|
||||
const char *env;
|
||||
} paths[] = {
|
||||
{ .fmt = "layout.scm", .needs_env = false, .env = NULL },
|
||||
{ .fmt = "%s/riverguile/layout.scm", .needs_env = true, .env = getenv("XDG_CONFIG_HOME") },
|
||||
{ .fmt = "%s/river/layout.scm", .needs_env = true, .env = getenv("XDG_CONFIG_HOME") },
|
||||
{ .fmt = "%s/.config/riverguile/layout.scm", .needs_env = true, .env = getenv("HOME") },
|
||||
{ .fmt = "%s/.config/river/layout.scm", .needs_env = true, .env = getenv("HOME") },
|
||||
{ .fmt = "/etc/riverguile/layout.scm", .needs_env = false, .env = NULL }
|
||||
};
|
||||
|
||||
char *path = NULL;
|
||||
for (size_t i = 0; i < (sizeof(paths) / sizeof(paths[0])); i++)
|
||||
{
|
||||
if ( path != NULL )
|
||||
{
|
||||
free(path);
|
||||
path = NULL;
|
||||
}
|
||||
|
||||
/* Path needs env var, but it is not set. */
|
||||
if ( paths[i].needs_env && paths[i].env == NULL )
|
||||
continue;
|
||||
|
||||
path = formatted_buffer(paths[i].fmt, paths[i].env);
|
||||
if ( path == NULL )
|
||||
return NULL;
|
||||
|
||||
/* Does the path exist? */
|
||||
if ( access(path, F_OK) != 0 )
|
||||
continue;
|
||||
|
||||
/* Is it readable? */
|
||||
if ( access(path, R_OK) != 0 )
|
||||
{
|
||||
fprintf(stderr, "ERROR: Script '%s' exists, but is not readable.\n", path);
|
||||
free(path);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return path;
|
||||
}
|
||||
|
||||
if ( path != NULL )
|
||||
free(path);
|
||||
|
||||
fputs("ERROR: No layout script found.\n", stderr);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
signal(SIGSEGV, handle_error);
|
||||
signal(SIGFPE, handle_error);
|
||||
signal(SIGINT, handle_interrupt);
|
||||
wl_list_init(&outputs);
|
||||
|
||||
// TODO use argv[1] if present
|
||||
char *path = get_script_path();
|
||||
if ( path == NULL )
|
||||
{
|
||||
ret = EXIT_FAILURE;
|
||||
goto early_exit;
|
||||
}
|
||||
|
||||
void *res = scm_with_guile(load_script, (void *)path);
|
||||
if ( res != NULL )
|
||||
{
|
||||
fputs((char *)res, stderr);
|
||||
ret = EXIT_FAILURE;
|
||||
loop = false;
|
||||
goto early_exit;
|
||||
}
|
||||
|
||||
/* We query the display name here instead of letting wl_display_connect()
|
||||
* figure it out itself, because libwayland (for legacy reasons) falls
|
||||
* back to using "wayland-0" when $WAYLAND_DISPLAY is not set, which is
|
||||
* generally not desirable.
|
||||
*/
|
||||
const char *display_name = getenv("WAYLAND_DISPLAY");
|
||||
if ( display_name == NULL )
|
||||
{
|
||||
fputs("ERROR: WAYLAND_DISPLAY is not set.\n", stderr);
|
||||
ret = EXIT_FAILURE;
|
||||
goto early_exit;
|
||||
}
|
||||
|
||||
wl_display = wl_display_connect(display_name);
|
||||
if ( wl_display == NULL )
|
||||
{
|
||||
fputs("ERROR: Can not connect to wayland display.\n", stderr);
|
||||
ret = EXIT_FAILURE;
|
||||
goto early_exit;
|
||||
}
|
||||
|
||||
wl_registry = wl_display_get_registry(wl_display);
|
||||
wl_registry_add_listener(wl_registry, ®istry_listener, NULL);
|
||||
|
||||
sync_callback = wl_display_sync(wl_display);
|
||||
wl_callback_add_listener(sync_callback, &sync_callback_listener, NULL);
|
||||
|
||||
if ( setjmp(skip_main_loop) == 0 )
|
||||
while ( loop && wl_display_dispatch(wl_display) > 0 );
|
||||
|
||||
struct Output *output, *tmp;
|
||||
wl_list_for_each_safe(output, tmp, &outputs, link)
|
||||
{
|
||||
wl_list_remove(&output->link);
|
||||
output_destroy(output);
|
||||
}
|
||||
|
||||
if ( sync_callback != NULL )
|
||||
wl_callback_destroy(sync_callback);
|
||||
if ( wl_registry != NULL )
|
||||
wl_registry_destroy(wl_registry);
|
||||
wl_display_disconnect(wl_display);
|
||||
|
||||
early_exit:
|
||||
if ( path != NULL )
|
||||
free(path);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user