swayfx/sway/commands.c

590 lines
16 KiB
C
Raw Normal View History

#define _XOPEN_SOURCE 500
#include <ctype.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <stdio.h>
#include <json-c/json.h>
#include "sway/commands.h"
2017-12-05 20:40:55 +11:00
#include "sway/config.h"
2018-01-21 08:21:45 +11:00
#include "sway/criteria.h"
2017-12-05 20:40:55 +11:00
#include "sway/security.h"
2017-12-11 20:17:14 +11:00
#include "sway/input/input-manager.h"
#include "sway/input/seat.h"
#include "sway/tree/view.h"
#include "stringop.h"
#include "log.h"
// Returns error object, or NULL if check succeeds.
struct cmd_results *checkarg(int argc, const char *name, enum expected_args type, int val) {
struct cmd_results *error = NULL;
switch (type) {
case EXPECTED_MORE_THAN:
if (argc > val) {
return NULL;
}
error = cmd_results_new(CMD_INVALID, name, "Invalid %s command "
"(expected more than %d argument%s, got %d)",
name, val, (char*[2]){"s", ""}[argc==1], argc);
break;
case EXPECTED_AT_LEAST:
if (argc >= val) {
return NULL;
}
error = cmd_results_new(CMD_INVALID, name, "Invalid %s command "
"(expected at least %d argument%s, got %d)",
name, val, (char*[2]){"s", ""}[argc==1], argc);
break;
case EXPECTED_LESS_THAN:
if (argc < val) {
return NULL;
};
error = cmd_results_new(CMD_INVALID, name, "Invalid %s command "
"(expected less than %d argument%s, got %d)",
name, val, (char*[2]){"s", ""}[argc==1], argc);
break;
case EXPECTED_EQUAL_TO:
if (argc == val) {
return NULL;
};
error = cmd_results_new(CMD_INVALID, name, "Invalid %s command "
"(expected %d arguments, got %d)", name, val, argc);
break;
}
return error;
}
2017-12-17 04:14:24 +11:00
void apply_input_config(struct input_config *input) {
2017-12-11 20:17:14 +11:00
int i;
i = list_seq_find(config->input_configs, input_identifier_cmp, input->identifier);
if (i >= 0) {
// merge existing config
struct input_config *ic = config->input_configs->items[i];
merge_input_config(ic, input);
free_input_config(input);
input = ic;
} else {
list_add(config->input_configs, input);
}
2018-04-02 22:49:38 +10:00
input_manager_apply_input_config(input_manager, input);
2017-12-15 03:11:56 +11:00
}
2018-04-03 01:44:42 +10:00
void apply_seat_config(struct seat_config *seat_config) {
2017-12-15 03:11:56 +11:00
int i;
2018-04-03 01:44:42 +10:00
i = list_seq_find(config->seat_configs, seat_name_cmp, seat_config->name);
2017-12-15 03:11:56 +11:00
if (i >= 0) {
// merge existing config
struct seat_config *sc = config->seat_configs->items[i];
2018-04-03 01:44:42 +10:00
merge_seat_config(sc, seat_config);
free_seat_config(seat_config);
seat_config = sc;
2017-12-15 03:11:56 +11:00
} else {
2018-04-03 01:44:42 +10:00
list_add(config->seat_configs, seat_config);
2017-12-15 03:11:56 +11:00
}
2018-04-03 01:44:42 +10:00
input_manager_apply_seat_config(input_manager, seat_config);
2017-12-11 20:17:14 +11:00
}
2018-03-30 08:20:03 +11:00
/* Keep alphabetized */
static struct cmd_handler handlers[] = {
{ "assign", cmd_assign },
2018-03-30 08:20:03 +11:00
{ "bar", cmd_bar },
2017-12-28 02:08:18 +11:00
{ "bindcode", cmd_bindcode },
{ "bindsym", cmd_bindsym },
{ "client.focused", cmd_client_focused },
{ "client.focused_inactive", cmd_client_focused_inactive },
{ "client.unfocused", cmd_client_unfocused },
{ "client.urgent", cmd_client_urgent },
2018-05-01 21:46:28 +10:00
{ "default_border", cmd_default_border },
{ "default_floating_border", cmd_default_floating_border },
2017-12-05 08:43:49 +11:00
{ "exec", cmd_exec },
{ "exec_always", cmd_exec_always },
{ "floating_maximum_size", cmd_floating_maximum_size },
{ "floating_minimum_size", cmd_floating_minimum_size },
{ "floating_modifier", cmd_floating_modifier },
2018-07-19 16:41:02 +10:00
{ "focus", cmd_focus },
{ "focus_follows_mouse", cmd_focus_follows_mouse },
2018-05-28 13:20:21 +10:00
{ "focus_wrapping", cmd_focus_wrapping },
2018-05-02 23:07:52 +10:00
{ "font", cmd_font },
2018-05-03 23:24:13 +10:00
{ "for_window", cmd_for_window },
{ "force_display_urgency_hint", cmd_force_display_urgency_hint },
{ "force_focus_wrapping", cmd_force_focus_wrapping },
2018-06-09 23:34:56 +10:00
{ "fullscreen", cmd_fullscreen },
{ "gaps", cmd_gaps },
2018-05-12 08:44:56 +10:00
{ "hide_edge_borders", cmd_hide_edge_borders },
2017-12-06 04:47:57 +11:00
{ "include", cmd_include },
2017-12-11 20:17:14 +11:00
{ "input", cmd_input },
2018-03-30 13:10:33 +11:00
{ "mode", cmd_mode },
2018-04-01 01:49:52 +11:00
{ "mouse_warping", cmd_mouse_warping },
2018-07-16 22:18:12 +10:00
{ "no_focus", cmd_no_focus },
2017-12-06 22:36:06 +11:00
{ "output", cmd_output },
2017-12-15 03:11:56 +11:00
{ "seat", cmd_seat },
{ "set", cmd_set },
2018-05-15 13:14:18 +10:00
{ "show_marks", cmd_show_marks },
2018-06-09 23:34:56 +10:00
{ "smart_gaps", cmd_smart_gaps },
2018-01-31 15:09:21 +11:00
{ "workspace", cmd_workspace },
{ "workspace_auto_back_and_forth", cmd_ws_auto_back_and_forth },
};
2018-03-30 08:20:03 +11:00
/* Config-time only commands. Keep alphabetized */
2018-02-25 05:34:47 +11:00
static struct cmd_handler config_handlers[] = {
2018-03-31 01:43:55 +11:00
{ "default_orientation", cmd_default_orientation },
2018-03-30 08:49:44 +11:00
{ "swaybg_command", cmd_swaybg_command },
{ "swaynag_command", cmd_swaynag_command },
{ "workspace_layout", cmd_workspace_layout },
2018-02-25 05:34:47 +11:00
};
2018-03-30 08:20:03 +11:00
/* Runtime-only commands. Keep alphabetized */
static struct cmd_handler command_handlers[] = {
{ "border", cmd_border },
{ "exit", cmd_exit },
2018-05-04 22:24:25 +10:00
{ "floating", cmd_floating },
{ "fullscreen", cmd_fullscreen },
{ "kill", cmd_kill },
{ "layout", cmd_layout },
2018-05-14 22:47:10 +10:00
{ "mark", cmd_mark },
{ "move", cmd_move },
2018-04-03 14:47:45 +10:00
{ "opacity", cmd_opacity },
{ "reload", cmd_reload },
{ "rename", cmd_rename },
2018-04-05 11:32:31 +10:00
{ "resize", cmd_resize },
{ "scratchpad", cmd_scratchpad },
2018-03-31 15:44:17 +11:00
{ "split", cmd_split },
{ "splith", cmd_splith },
{ "splitt", cmd_splitt },
{ "splitv", cmd_splitv },
2018-05-24 22:30:44 +10:00
{ "sticky", cmd_sticky },
2018-05-27 01:02:21 +10:00
{ "swap", cmd_swap },
{ "title_format", cmd_title_format },
2018-05-14 22:47:10 +10:00
{ "unmark", cmd_unmark },
{ "urgent", cmd_urgent },
};
static int handler_compare(const void *_a, const void *_b) {
const struct cmd_handler *a = _a;
const struct cmd_handler *b = _b;
return strcasecmp(a->command, b->command);
}
struct cmd_handler *find_handler(char *line, struct cmd_handler *cmd_handlers,
int handlers_size) {
struct cmd_handler d = { .command=line };
struct cmd_handler *res = NULL;
2018-07-10 07:54:30 +10:00
wlr_log(WLR_DEBUG, "find_handler(%s)", line);
2017-12-11 20:17:14 +11:00
bool config_loading = config->reading || !config->active;
if (!config_loading) {
res = bsearch(&d, command_handlers,
sizeof(command_handlers) / sizeof(struct cmd_handler),
2017-12-11 20:17:14 +11:00
sizeof(struct cmd_handler), handler_compare);
if (res) {
return res;
}
2017-12-11 20:17:14 +11:00
}
2018-02-25 05:34:47 +11:00
if (config->reading) {
res = bsearch(&d, config_handlers,
sizeof(config_handlers) / sizeof(struct cmd_handler),
sizeof(struct cmd_handler), handler_compare);
if (res) {
return res;
}
}
if (!cmd_handlers) {
cmd_handlers = handlers;
handlers_size = sizeof(handlers);
}
res = bsearch(&d, cmd_handlers,
handlers_size / sizeof(struct cmd_handler),
sizeof(struct cmd_handler), handler_compare);
return res;
}
struct cmd_results *execute_command(char *_exec, struct sway_seat *seat) {
// Even though this function will process multiple commands we will only
// return the last error, if any (for now). (Since we have access to an
// error string we could e.g. concatenate all errors there.)
struct cmd_results *results = NULL;
char *exec = strdup(_exec);
char *head = exec;
char *cmdlist;
char *cmd;
list_t *views = NULL;
if (seat == NULL) {
// passing a NULL seat means we just pick the default seat
2018-04-02 22:49:38 +10:00
seat = input_manager_get_default_seat(input_manager);
if (!sway_assert(seat, "could not find a seat to run the command on")) {
return NULL;
}
}
config->handler_context.seat = seat;
head = exec;
do {
2018-01-21 08:21:45 +11:00
// Extract criteria (valid for this command list only).
config->handler_context.using_criteria = false;
2018-01-21 08:21:45 +11:00
if (*head == '[') {
char *error = NULL;
struct criteria *criteria = criteria_parse(head, &error);
if (!criteria) {
results = cmd_results_new(CMD_INVALID, head,
"%s", error);
free(error);
2018-01-21 08:21:45 +11:00
goto cleanup;
}
views = criteria_get_views(criteria);
head += strlen(criteria->raw);
criteria_destroy(criteria);
config->handler_context.using_criteria = true;
2018-01-21 08:21:45 +11:00
// Skip leading whitespace
head += strspn(head, whitespace);
}
// Split command list
cmdlist = argsep(&head, ";");
cmdlist += strspn(cmdlist, whitespace);
do {
// Split commands
cmd = argsep(&cmdlist, ",");
cmd += strspn(cmd, whitespace);
if (strcmp(cmd, "") == 0) {
2018-07-10 07:54:30 +10:00
wlr_log(WLR_INFO, "Ignoring empty command.");
continue;
}
2018-07-10 07:54:30 +10:00
wlr_log(WLR_INFO, "Handling command '%s'", cmd);
//TODO better handling of argv
int argc;
char **argv = split_args(cmd, &argc);
if (strcmp(argv[0], "exec") != 0) {
int i;
for (i = 1; i < argc; ++i) {
if (*argv[i] == '\"' || *argv[i] == '\'') {
strip_quotes(argv[i]);
}
}
}
struct cmd_handler *handler = find_handler(argv[0], NULL, 0);
if (!handler) {
if (results) {
free_cmd_results(results);
}
results = cmd_results_new(CMD_INVALID, cmd, "Unknown/invalid command");
free_argv(argc, argv);
goto cleanup;
}
2018-01-21 08:21:45 +11:00
// Var replacement, for all but first argument of set
for (int i = handler->handle == cmd_set ? 2 : 1; i < argc; ++i) {
argv[i] = do_var_replacement(argv[i]);
unescape_string(argv[i]);
}
if (!config->handler_context.using_criteria) {
// without criteria, the command acts upon the focused
// container
config->handler_context.current_container =
2018-04-02 22:45:37 +10:00
seat_get_focus_inactive(seat, &root_container);
if (!sway_assert(config->handler_context.current_container,
"could not get focus-inactive for root container")) {
return NULL;
}
struct cmd_results *res = handler->handle(argc-1, argv+1);
if (res->status != CMD_SUCCESS) {
free_argv(argc, argv);
if (results) {
free_cmd_results(results);
2018-01-21 08:21:45 +11:00
}
results = res;
goto cleanup;
2018-01-21 08:21:45 +11:00
}
free_cmd_results(res);
2018-01-21 08:21:45 +11:00
} else {
for (int i = 0; i < views->length; ++i) {
struct sway_view *view = views->items[i];
config->handler_context.current_container = view->swayc;
2018-01-21 08:21:45 +11:00
struct cmd_results *res = handler->handle(argc-1, argv+1);
if (res->status != CMD_SUCCESS) {
free_argv(argc, argv);
if (results) {
free_cmd_results(results);
}
results = res;
goto cleanup;
}
free_cmd_results(res);
2017-11-23 13:39:35 +11:00
}
}
free_argv(argc, argv);
} while(cmdlist);
} while(head);
cleanup:
free(exec);
list_free(views);
if (!results) {
results = cmd_results_new(CMD_SUCCESS, NULL, NULL);
}
return results;
}
// this is like execute_command above, except:
2017-12-05 20:40:55 +11:00
// 1) it ignores empty commands (empty lines)
// 2) it does variable substitution
// 3) it doesn't split commands (because the multiple commands are supposed to
// be chained together)
// 4) execute_command handles all state internally while config_command has
// some state handled outside (notably the block mode, in read_config)
struct cmd_results *config_command(char *exec) {
2017-12-05 20:40:55 +11:00
struct cmd_results *results = NULL;
int argc;
char **argv = split_args(exec, &argc);
if (!argc) {
results = cmd_results_new(CMD_SUCCESS, NULL, NULL);
goto cleanup;
}
// Start block
if (argc > 1 && strcmp(argv[argc - 1], "{") == 0) {
char *block = join_args(argv, argc - 1);
results = cmd_results_new(CMD_BLOCK, block, NULL);
free(block);
goto cleanup;
}
2017-12-05 20:40:55 +11:00
// Endblock
if (strcmp(argv[argc - 1], "}") == 0) {
2017-12-05 20:40:55 +11:00
results = cmd_results_new(CMD_BLOCK_END, NULL, NULL);
goto cleanup;
}
2018-07-10 07:54:30 +10:00
wlr_log(WLR_INFO, "handling config command '%s'", exec);
struct cmd_handler *handler = find_handler(argv[0], NULL, 0);
2017-12-05 20:40:55 +11:00
if (!handler) {
char *input = argv[0] ? argv[0] : "(empty)";
results = cmd_results_new(CMD_INVALID, input, "Unknown/invalid command");
goto cleanup;
}
int i;
// Var replacement, for all but first argument of set
// TODO commands
2017-12-30 01:31:04 +11:00
for (i = handler->handle == cmd_set ? 2 : 1; i < argc; ++i) {
2017-12-05 20:40:55 +11:00
argv[i] = do_var_replacement(argv[i]);
unescape_string(argv[i]);
}
2017-12-11 20:17:14 +11:00
// Strip quotes for first argument.
// TODO This part needs to be handled much better
2017-12-05 20:40:55 +11:00
if (argc>1 && (*argv[1] == '\"' || *argv[1] == '\'')) {
strip_quotes(argv[1]);
}
if (handler->handle) {
results = handler->handle(argc-1, argv+1);
} else {
results = cmd_results_new(CMD_INVALID, argv[0], "This command is shimmed, but unimplemented");
}
cleanup:
free_argv(argc, argv);
return results;
}
struct cmd_results *config_subcommand(char **argv, int argc,
struct cmd_handler *handlers, size_t handlers_size) {
char *command = join_args(argv, argc);
2018-07-10 07:54:30 +10:00
wlr_log(WLR_DEBUG, "Subcommand: %s", command);
free(command);
struct cmd_handler *handler = find_handler(argv[0], handlers,
handlers_size);
if (!handler) {
char *input = argv[0] ? argv[0] : "(empty)";
return cmd_results_new(CMD_INVALID, input, "Unknown/invalid command");
}
// Strip quotes for first argument.
// TODO This part needs to be handled much better
if (argc > 1 && (*argv[1] == '\"' || *argv[1] == '\'')) {
strip_quotes(argv[1]);
}
if (handler->handle) {
return handler->handle(argc - 1, argv + 1);
}
return cmd_results_new(CMD_INVALID, argv[0],
"This command is shimmed, but unimplemented");
}
2017-12-05 20:40:55 +11:00
struct cmd_results *config_commands_command(char *exec) {
struct cmd_results *results = NULL;
int argc;
char **argv = split_args(exec, &argc);
if (!argc) {
results = cmd_results_new(CMD_SUCCESS, NULL, NULL);
goto cleanup;
}
// Find handler for the command this is setting a policy for
char *cmd = argv[0];
if (strcmp(cmd, "}") == 0) {
results = cmd_results_new(CMD_BLOCK_END, NULL, NULL);
goto cleanup;
}
struct cmd_handler *handler = find_handler(cmd, NULL, 0);
2017-12-05 20:40:55 +11:00
if (!handler && strcmp(cmd, "*") != 0) {
results = cmd_results_new(CMD_INVALID, cmd, "Unknown/invalid command");
2017-12-05 20:40:55 +11:00
goto cleanup;
}
enum command_context context = 0;
struct {
char *name;
enum command_context context;
} context_names[] = {
{ "config", CONTEXT_CONFIG },
{ "binding", CONTEXT_BINDING },
{ "ipc", CONTEXT_IPC },
{ "criteria", CONTEXT_CRITERIA },
{ "all", CONTEXT_ALL },
};
for (int i = 1; i < argc; ++i) {
size_t j;
for (j = 0; j < sizeof(context_names) / sizeof(context_names[0]); ++j) {
if (strcmp(context_names[j].name, argv[i]) == 0) {
break;
}
}
if (j == sizeof(context_names) / sizeof(context_names[0])) {
results = cmd_results_new(CMD_INVALID, cmd,
"Invalid command context %s", argv[i]);
goto cleanup;
}
context |= context_names[j].context;
}
struct command_policy *policy = NULL;
for (int i = 0; i < config->command_policies->length; ++i) {
struct command_policy *p = config->command_policies->items[i];
if (strcmp(p->command, cmd) == 0) {
policy = p;
break;
}
}
if (!policy) {
policy = alloc_command_policy(cmd);
if (!sway_assert(policy, "Unable to allocate security policy")) {
results = cmd_results_new(CMD_INVALID, cmd,
"Unable to allocate memory");
goto cleanup;
2017-12-05 20:40:55 +11:00
}
list_add(config->command_policies, policy);
2017-12-05 20:40:55 +11:00
}
policy->context = context;
2018-07-10 07:54:30 +10:00
wlr_log(WLR_INFO, "Set command policy for %s to %d",
2017-12-05 20:40:55 +11:00
policy->command, policy->context);
results = cmd_results_new(CMD_SUCCESS, NULL, NULL);
cleanup:
free_argv(argc, argv);
return results;
}
struct cmd_results *cmd_results_new(enum cmd_status status,
const char *input, const char *format, ...) {
struct cmd_results *results = malloc(sizeof(struct cmd_results));
if (!results) {
2018-07-10 07:54:30 +10:00
wlr_log(WLR_ERROR, "Unable to allocate command results");
return NULL;
}
results->status = status;
if (input) {
results->input = strdup(input); // input is the command name
} else {
results->input = NULL;
}
if (format) {
char *error = malloc(256);
va_list args;
va_start(args, format);
if (error) {
vsnprintf(error, 256, format, args);
}
va_end(args);
results->error = error;
} else {
results->error = NULL;
}
return results;
}
void free_cmd_results(struct cmd_results *results) {
if (results->input) {
free(results->input);
}
if (results->error) {
free(results->error);
}
free(results);
}
char *cmd_results_to_json(struct cmd_results *results) {
json_object *result_array = json_object_new_array();
json_object *root = json_object_new_object();
json_object_object_add(root, "success",
json_object_new_boolean(results->status == CMD_SUCCESS));
if (results->input) {
json_object_object_add(
root, "input", json_object_new_string(results->input));
}
if (results->error) {
json_object_object_add(
root, "error", json_object_new_string(results->error));
}
json_object_array_add(result_array, root);
const char *json = json_object_to_json_string(result_array);
char *res = strdup(json);
json_object_put(result_array);
return res;
}
2018-03-30 08:20:03 +11:00
/**
* Check and add color to buffer.
*
* return error object, or NULL if color is valid.
*/
struct cmd_results *add_color(const char *name,
char *buffer, const char *color) {
int len = strlen(color);
if (len != 7 && len != 9) {
return cmd_results_new(CMD_INVALID, name,
"Invalid color definition %s", color);
}
if (color[0] != '#') {
return cmd_results_new(CMD_INVALID, name,
"Invalid color definition %s", color);
}
for (int i = 1; i < len; ++i) {
if (!isxdigit(color[i])) {
return cmd_results_new(CMD_INVALID, name,
"Invalid color definition %s", color);
}
}
2018-04-13 23:35:23 +10:00
strcpy(buffer, color);
2018-03-30 08:20:03 +11:00
// add default alpha channel if color was defined without it
if (len == 7) {
buffer[7] = 'f';
buffer[8] = 'f';
}
buffer[9] = '\0';
return NULL;
}