mirror of
https://github.com/swaywm/sway.git
synced 2024-09-11 21:37:19 +00:00
411 lines
10 KiB
C
411 lines
10 KiB
C
#define _POSIX_C_SOURCE 200809L
|
|
#include <getopt.h>
|
|
#include <pango/pangocairo.h>
|
|
#include <signal.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <sys/wait.h>
|
|
#include <sys/un.h>
|
|
#include <unistd.h>
|
|
#include <wlr/util/log.h>
|
|
#include <wlr/version.h>
|
|
#include "sway/commands.h"
|
|
#include "sway/config.h"
|
|
#include "sway/server.h"
|
|
#include "sway/swaynag.h"
|
|
#include "sway/desktop/transaction.h"
|
|
#include "sway/tree/root.h"
|
|
#include "sway/ipc-server.h"
|
|
#include "ipc-client.h"
|
|
#include "log.h"
|
|
#include "stringop.h"
|
|
#include "util.h"
|
|
|
|
static bool terminate_request = false;
|
|
static int exit_value = 0;
|
|
struct sway_server server = {0};
|
|
struct sway_debug debug = {0};
|
|
|
|
void sway_terminate(int exit_code) {
|
|
if (!server.wl_display) {
|
|
// Running as IPC client
|
|
exit(exit_code);
|
|
} else {
|
|
// Running as server
|
|
terminate_request = true;
|
|
exit_value = exit_code;
|
|
ipc_event_shutdown("exit");
|
|
wl_display_terminate(server.wl_display);
|
|
}
|
|
}
|
|
|
|
void sig_handler(int signal) {
|
|
sway_terminate(EXIT_SUCCESS);
|
|
}
|
|
|
|
void detect_proprietary(int allow_unsupported_gpu) {
|
|
FILE *f = fopen("/proc/modules", "r");
|
|
if (!f) {
|
|
return;
|
|
}
|
|
char *line = NULL;
|
|
size_t line_size = 0;
|
|
while (getline(&line, &line_size, f) != -1) {
|
|
if (strncmp(line, "nvidia ", 7) == 0) {
|
|
if (allow_unsupported_gpu) {
|
|
sway_log(SWAY_ERROR,
|
|
"!!! Proprietary Nvidia drivers are in use !!!");
|
|
} else {
|
|
sway_log(SWAY_ERROR,
|
|
"Proprietary Nvidia drivers are NOT supported. "
|
|
"Use Nouveau. To launch sway anyway, launch with "
|
|
"--my-next-gpu-wont-be-nvidia and DO NOT report issues.");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
break;
|
|
}
|
|
if (strstr(line, "fglrx")) {
|
|
if (allow_unsupported_gpu) {
|
|
sway_log(SWAY_ERROR,
|
|
"!!! Proprietary AMD drivers are in use !!!");
|
|
} else {
|
|
sway_log(SWAY_ERROR, "Proprietary AMD drivers do NOT support "
|
|
"Wayland. Use radeon. To try anyway, launch sway with "
|
|
"--unsupported-gpu and DO NOT report issues.");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
free(line);
|
|
fclose(f);
|
|
}
|
|
|
|
void run_as_ipc_client(char *command, char *socket_path) {
|
|
int socketfd = ipc_open_socket(socket_path);
|
|
uint32_t len = strlen(command);
|
|
char *resp = ipc_single_command(socketfd, IPC_COMMAND, command, &len);
|
|
printf("%s\n", resp);
|
|
free(resp);
|
|
close(socketfd);
|
|
}
|
|
|
|
static void log_env(void) {
|
|
const char *log_vars[] = {
|
|
"LD_LIBRARY_PATH",
|
|
"LD_PRELOAD",
|
|
"PATH",
|
|
"SWAYSOCK",
|
|
};
|
|
for (size_t i = 0; i < sizeof(log_vars) / sizeof(char *); ++i) {
|
|
char *value = getenv(log_vars[i]);
|
|
sway_log(SWAY_INFO, "%s=%s", log_vars[i], value != NULL ? value : "");
|
|
}
|
|
}
|
|
|
|
static void log_file(FILE *f) {
|
|
char *line = NULL;
|
|
size_t line_size = 0;
|
|
ssize_t nread;
|
|
while ((nread = getline(&line, &line_size, f)) != -1) {
|
|
if (line[nread - 1] == '\n') {
|
|
line[nread - 1] = '\0';
|
|
}
|
|
sway_log(SWAY_INFO, "%s", line);
|
|
}
|
|
free(line);
|
|
}
|
|
|
|
static void log_distro(void) {
|
|
const char *paths[] = {
|
|
"/etc/lsb-release",
|
|
"/etc/os-release",
|
|
"/etc/debian_version",
|
|
"/etc/redhat-release",
|
|
"/etc/gentoo-release",
|
|
};
|
|
for (size_t i = 0; i < sizeof(paths) / sizeof(char *); ++i) {
|
|
FILE *f = fopen(paths[i], "r");
|
|
if (f) {
|
|
sway_log(SWAY_INFO, "Contents of %s:", paths[i]);
|
|
log_file(f);
|
|
fclose(f);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void log_kernel(void) {
|
|
FILE *f = popen("uname -a", "r");
|
|
if (!f) {
|
|
sway_log(SWAY_INFO, "Unable to determine kernel version");
|
|
return;
|
|
}
|
|
log_file(f);
|
|
pclose(f);
|
|
}
|
|
|
|
|
|
static bool drop_permissions(void) {
|
|
if (getuid() != geteuid() || getgid() != getegid()) {
|
|
// Set the gid and uid in the correct order.
|
|
if (setgid(getgid()) != 0) {
|
|
sway_log(SWAY_ERROR, "Unable to drop root group, refusing to start");
|
|
return false;
|
|
}
|
|
if (setuid(getuid()) != 0) {
|
|
sway_log(SWAY_ERROR, "Unable to drop root user, refusing to start");
|
|
return false;
|
|
}
|
|
}
|
|
if (setgid(0) != -1 || setuid(0) != -1) {
|
|
sway_log(SWAY_ERROR, "Unable to drop root (we shouldn't be able to "
|
|
"restore it after setuid), refusing to start");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void enable_debug_flag(const char *flag) {
|
|
if (strcmp(flag, "damage=highlight") == 0) {
|
|
debug.damage = DAMAGE_HIGHLIGHT;
|
|
} else if (strcmp(flag, "damage=rerender") == 0) {
|
|
debug.damage = DAMAGE_RERENDER;
|
|
} else if (strcmp(flag, "noatomic") == 0) {
|
|
debug.noatomic = true;
|
|
} else if (strcmp(flag, "txn-wait") == 0) {
|
|
debug.txn_wait = true;
|
|
} else if (strcmp(flag, "txn-timings") == 0) {
|
|
debug.txn_timings = true;
|
|
} else if (strncmp(flag, "txn-timeout=", 12) == 0) {
|
|
server.txn_timeout_ms = atoi(&flag[12]);
|
|
} else {
|
|
sway_log(SWAY_ERROR, "Unknown debug flag: %s", flag);
|
|
}
|
|
}
|
|
|
|
static sway_log_importance_t convert_wlr_log_importance(
|
|
enum wlr_log_importance importance) {
|
|
switch (importance) {
|
|
case WLR_ERROR:
|
|
return SWAY_ERROR;
|
|
case WLR_INFO:
|
|
return SWAY_INFO;
|
|
default:
|
|
return SWAY_DEBUG;
|
|
}
|
|
}
|
|
|
|
static void handle_wlr_log(enum wlr_log_importance importance,
|
|
const char *fmt, va_list args) {
|
|
static char sway_fmt[1024];
|
|
snprintf(sway_fmt, sizeof(sway_fmt), "[wlr] %s", fmt);
|
|
_sway_vlog(convert_wlr_log_importance(importance), sway_fmt, args);
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
static int verbose = 0, debug = 0, validate = 0, allow_unsupported_gpu = 0;
|
|
|
|
static const struct option long_options[] = {
|
|
{"help", no_argument, NULL, 'h'},
|
|
{"config", required_argument, NULL, 'c'},
|
|
{"validate", no_argument, NULL, 'C'},
|
|
{"debug", no_argument, NULL, 'd'},
|
|
{"version", no_argument, NULL, 'v'},
|
|
{"verbose", no_argument, NULL, 'V'},
|
|
{"get-socketpath", no_argument, NULL, 'p'},
|
|
{"unsupported-gpu", no_argument, NULL, 'u'},
|
|
{"my-next-gpu-wont-be-nvidia", no_argument, NULL, 'u'},
|
|
{0, 0, 0, 0}
|
|
};
|
|
|
|
char *config_path = NULL;
|
|
|
|
const char* usage =
|
|
"Usage: sway [options] [command]\n"
|
|
"\n"
|
|
" -h, --help Show help message and quit.\n"
|
|
" -c, --config <config> Specify a config file.\n"
|
|
" -C, --validate Check the validity of the config file, then exit.\n"
|
|
" -d, --debug Enables full logging, including debug information.\n"
|
|
" -v, --version Show the version number and quit.\n"
|
|
" -V, --verbose Enables more verbose logging.\n"
|
|
" --get-socketpath Gets the IPC socket path and prints it, then exits.\n"
|
|
"\n";
|
|
|
|
int c;
|
|
while (1) {
|
|
int option_index = 0;
|
|
c = getopt_long(argc, argv, "hCdD:vVc:", long_options, &option_index);
|
|
if (c == -1) {
|
|
break;
|
|
}
|
|
switch (c) {
|
|
case 'h': // help
|
|
printf("%s", usage);
|
|
exit(EXIT_SUCCESS);
|
|
break;
|
|
case 'c': // config
|
|
free(config_path);
|
|
config_path = strdup(optarg);
|
|
break;
|
|
case 'C': // validate
|
|
validate = 1;
|
|
break;
|
|
case 'd': // debug
|
|
debug = 1;
|
|
break;
|
|
case 'D': // extended debug options
|
|
enable_debug_flag(optarg);
|
|
break;
|
|
case 'u':
|
|
allow_unsupported_gpu = 1;
|
|
break;
|
|
case 'v': // version
|
|
printf("sway version " SWAY_VERSION "\n");
|
|
exit(EXIT_SUCCESS);
|
|
break;
|
|
case 'V': // verbose
|
|
verbose = 1;
|
|
break;
|
|
case 'p': ; // --get-socketpath
|
|
if (getenv("SWAYSOCK")) {
|
|
printf("%s\n", getenv("SWAYSOCK"));
|
|
exit(EXIT_SUCCESS);
|
|
} else {
|
|
fprintf(stderr, "sway socket not detected.\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
break;
|
|
default:
|
|
fprintf(stderr, "%s", usage);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
// Since wayland requires XDG_RUNTIME_DIR to be set, abort with just the
|
|
// clear error message (when not running as an IPC client).
|
|
if (!getenv("XDG_RUNTIME_DIR") && optind == argc) {
|
|
fprintf(stderr,
|
|
"XDG_RUNTIME_DIR is not set in the environment. Aborting.\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
// As the 'callback' function for wlr_log is equivalent to that for
|
|
// sway, we do not need to override it.
|
|
if (debug) {
|
|
sway_log_init(SWAY_DEBUG, sway_terminate);
|
|
wlr_log_init(WLR_DEBUG, handle_wlr_log);
|
|
} else if (verbose) {
|
|
sway_log_init(SWAY_INFO, sway_terminate);
|
|
wlr_log_init(WLR_INFO, handle_wlr_log);
|
|
} else {
|
|
sway_log_init(SWAY_ERROR, sway_terminate);
|
|
wlr_log_init(WLR_ERROR, handle_wlr_log);
|
|
}
|
|
|
|
sway_log(SWAY_INFO, "Sway version " SWAY_VERSION);
|
|
sway_log(SWAY_INFO, "wlroots version " WLR_VERSION_STR);
|
|
log_kernel();
|
|
log_distro();
|
|
log_env();
|
|
detect_proprietary(allow_unsupported_gpu);
|
|
|
|
if (optind < argc) { // Behave as IPC client
|
|
if (optind != 1) {
|
|
sway_log(SWAY_ERROR,
|
|
"Detected both options and positional arguments. If you "
|
|
"are trying to use the IPC client, options are not "
|
|
"supported. Otherwise, check the provided arguments for "
|
|
"issues. See `man 1 sway` or `sway -h` for usage. If you "
|
|
"are trying to generate a debug log, use "
|
|
"`sway -d 2>sway.log`.");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
if (!drop_permissions()) {
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
char *socket_path = getenv("SWAYSOCK");
|
|
if (!socket_path) {
|
|
sway_log(SWAY_ERROR, "Unable to retrieve socket path");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
char *command = join_args(argv + optind, argc - optind);
|
|
run_as_ipc_client(command, socket_path);
|
|
free(command);
|
|
return 0;
|
|
}
|
|
|
|
if (!server_privileged_prepare(&server)) {
|
|
return 1;
|
|
}
|
|
|
|
if (!drop_permissions()) {
|
|
server_fini(&server);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
// handle SIGTERM signals
|
|
signal(SIGTERM, sig_handler);
|
|
signal(SIGINT, sig_handler);
|
|
|
|
// prevent ipc from crashing sway
|
|
signal(SIGPIPE, SIG_IGN);
|
|
|
|
sway_log(SWAY_INFO, "Starting sway version " SWAY_VERSION);
|
|
|
|
root = root_create();
|
|
|
|
if (!server_init(&server)) {
|
|
return 1;
|
|
}
|
|
|
|
if (validate) {
|
|
bool valid = load_main_config(config_path, false, true);
|
|
free(config_path);
|
|
return valid ? 0 : 1;
|
|
}
|
|
|
|
ipc_init(&server);
|
|
|
|
setenv("WAYLAND_DISPLAY", server.socket, true);
|
|
if (!load_main_config(config_path, false, false)) {
|
|
sway_terminate(EXIT_FAILURE);
|
|
goto shutdown;
|
|
}
|
|
|
|
if (!server_start(&server)) {
|
|
sway_terminate(EXIT_FAILURE);
|
|
goto shutdown;
|
|
}
|
|
|
|
config->active = true;
|
|
load_swaybars();
|
|
run_deferred_commands();
|
|
run_deferred_bindings();
|
|
transaction_commit_dirty();
|
|
|
|
if (config->swaynag_config_errors.client != NULL) {
|
|
swaynag_show(&config->swaynag_config_errors);
|
|
}
|
|
|
|
server_run(&server);
|
|
|
|
shutdown:
|
|
sway_log(SWAY_INFO, "Shutting down sway");
|
|
|
|
server_fini(&server);
|
|
root_destroy(root);
|
|
root = NULL;
|
|
|
|
free(config_path);
|
|
free_config(config);
|
|
|
|
pango_cairo_font_map_set_default(NULL);
|
|
|
|
return exit_value;
|
|
}
|