riverguile/riverguile.c

#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>

#ifdef __linux__
#include <features.h>
#include <linux/landlock.h>
#include <sys/syscall.h>
#ifdef __GLIBC__
#include<execinfo.h>
#endif
#endif

#include "river-layout-v3.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;

struct Output
{
	struct wl_list link;
	struct wl_output *wl_output;
	struct river_layout_v3 *layout;
	uint32_t name;
	bool configured;
};

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;
	for (size_t i = 0; i < view_count; i++)
	{
		river_layout_v3_push_view_dimensions(
			output->layout, 0, 0,
			width, height, serial
		);
	}
	river_layout_v3_commit(output->layout, "()", serial);
}

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 void layout_handle_user_command (void *data,
		struct river_layout_v3 *river_layout_manager_v3,
		const char *command)
{
}

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,
};

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, 1
		);
	}
	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);
}

int main(int argc, char *argv[])
{
	signal(SIGSEGV, handle_error);
	signal(SIGFPE, handle_error);
	signal(SIGINT, handle_interrupt);
	wl_list_init(&outputs);

	/* 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 cleanup;
	}

	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 cleanup;
	}

	wl_registry = wl_display_get_registry(wl_display);
	wl_registry_add_listener(wl_registry, &registry_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;
cleanup:
	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);

	return ret;
}