1 #define _POSIX_C_SOURCE 200809
2 #include <ctype.h>
3 #include <stdarg.h>
4 #include <stdlib.h>
5 #include <string.h>
6 #include <strings.h>
7 #include <stdio.h>
8 #include <json.h>
9 #include "sway/commands.h"
10 #include "sway/config.h"
11 #include "sway/criteria.h"
12 #include "sway/input/input-manager.h"
13 #include "sway/input/seat.h"
14 #include "sway/tree/view.h"
15 #include "stringop.h"
16 #include "log.h"
17
18 // Returns error object, or NULL if check succeeds.
checkarg(int argc,const char * name,enum expected_args type,int val)19 struct cmd_results *checkarg(int argc, const char *name, enum expected_args type, int val) {
20 const char *error_name = NULL;
21 switch (type) {
22 case EXPECTED_AT_LEAST:
23 if (argc < val) {
24 error_name = "at least ";
25 }
26 break;
27 case EXPECTED_AT_MOST:
28 if (argc > val) {
29 error_name = "at most ";
30 }
31 break;
32 case EXPECTED_EQUAL_TO:
33 if (argc != val) {
34 error_name = "";
35 }
36 }
37 return error_name ?
38 cmd_results_new(CMD_INVALID, "Invalid %s command "
39 "(expected %s%d argument%s, got %d)",
40 name, error_name, val, val != 1 ? "s" : "", argc)
41 : NULL;
42 }
43
44 /* Keep alphabetized */
45 static struct cmd_handler handlers[] = {
46 { "assign", cmd_assign },
47 { "bar", cmd_bar },
48 { "bindcode", cmd_bindcode },
49 { "bindswitch", cmd_bindswitch },
50 { "bindsym", cmd_bindsym },
51 { "client.background", cmd_client_noop },
52 { "client.focused", cmd_client_focused },
53 { "client.focused_inactive", cmd_client_focused_inactive },
54 { "client.placeholder", cmd_client_noop },
55 { "client.unfocused", cmd_client_unfocused },
56 { "client.urgent", cmd_client_urgent },
57 { "default_border", cmd_default_border },
58 { "default_floating_border", cmd_default_floating_border },
59 { "exec", cmd_exec },
60 { "exec_always", cmd_exec_always },
61 { "floating_maximum_size", cmd_floating_maximum_size },
62 { "floating_minimum_size", cmd_floating_minimum_size },
63 { "floating_modifier", cmd_floating_modifier },
64 { "focus", cmd_focus },
65 { "focus_follows_mouse", cmd_focus_follows_mouse },
66 { "focus_on_window_activation", cmd_focus_on_window_activation },
67 { "focus_wrapping", cmd_focus_wrapping },
68 { "font", cmd_font },
69 { "for_window", cmd_for_window },
70 { "force_display_urgency_hint", cmd_force_display_urgency_hint },
71 { "force_focus_wrapping", cmd_force_focus_wrapping },
72 { "fullscreen", cmd_fullscreen },
73 { "gaps", cmd_gaps },
74 { "hide_edge_borders", cmd_hide_edge_borders },
75 { "include", cmd_include },
76 { "input", cmd_input },
77 { "mode", cmd_mode },
78 { "mouse_warping", cmd_mouse_warping },
79 { "new_float", cmd_new_float },
80 { "new_window", cmd_new_window },
81 { "no_focus", cmd_no_focus },
82 { "output", cmd_output },
83 { "popup_during_fullscreen", cmd_popup_during_fullscreen },
84 { "seat", cmd_seat },
85 { "set", cmd_set },
86 { "show_marks", cmd_show_marks },
87 { "smart_borders", cmd_smart_borders },
88 { "smart_gaps", cmd_smart_gaps },
89 { "tiling_drag", cmd_tiling_drag },
90 { "tiling_drag_threshold", cmd_tiling_drag_threshold },
91 { "title_align", cmd_title_align },
92 { "titlebar_border_thickness", cmd_titlebar_border_thickness },
93 { "titlebar_padding", cmd_titlebar_padding },
94 { "unbindcode", cmd_unbindcode },
95 { "unbindswitch", cmd_unbindswitch },
96 { "unbindsym", cmd_unbindsym },
97 { "workspace", cmd_workspace },
98 { "workspace_auto_back_and_forth", cmd_ws_auto_back_and_forth },
99 #if HAVE_XWAYLAND
100 { "xwayland", cmd_xwayland },
101 #endif
102 };
103
104 /* Config-time only commands. Keep alphabetized */
105 static struct cmd_handler config_handlers[] = {
106 { "default_orientation", cmd_default_orientation },
107 { "swaybg_command", cmd_swaybg_command },
108 { "swaynag_command", cmd_swaynag_command },
109 { "workspace_layout", cmd_workspace_layout },
110 };
111
112 /* Runtime-only commands. Keep alphabetized */
113 static struct cmd_handler command_handlers[] = {
114 { "border", cmd_border },
115 { "create_output", cmd_create_output },
116 { "exit", cmd_exit },
117 { "floating", cmd_floating },
118 { "fullscreen", cmd_fullscreen },
119 { "inhibit_idle", cmd_inhibit_idle },
120 { "kill", cmd_kill },
121 { "layout", cmd_layout },
122 { "mark", cmd_mark },
123 { "max_render_time", cmd_max_render_time },
124 { "move", cmd_move },
125 { "nop", cmd_nop },
126 { "opacity", cmd_opacity },
127 { "reload", cmd_reload },
128 { "rename", cmd_rename },
129 { "resize", cmd_resize },
130 { "scratchpad", cmd_scratchpad },
131 { "shortcuts_inhibitor", cmd_shortcuts_inhibitor },
132 { "split", cmd_split },
133 { "splith", cmd_splith },
134 { "splitt", cmd_splitt },
135 { "splitv", cmd_splitv },
136 { "sticky", cmd_sticky },
137 { "swap", cmd_swap },
138 { "title_format", cmd_title_format },
139 { "unmark", cmd_unmark },
140 { "urgent", cmd_urgent },
141 };
142
handler_compare(const void * _a,const void * _b)143 static int handler_compare(const void *_a, const void *_b) {
144 const struct cmd_handler *a = _a;
145 const struct cmd_handler *b = _b;
146 return strcasecmp(a->command, b->command);
147 }
148
find_handler(char * line,struct cmd_handler * handlers,size_t handlers_size)149 struct cmd_handler *find_handler(char *line, struct cmd_handler *handlers,
150 size_t handlers_size) {
151 if (!handlers || !handlers_size) {
152 return NULL;
153 }
154 struct cmd_handler query = { .command = line };
155 return bsearch(&query, handlers,
156 handlers_size / sizeof(struct cmd_handler),
157 sizeof(struct cmd_handler), handler_compare);
158 }
159
find_handler_ex(char * line,struct cmd_handler * config_handlers,size_t config_handlers_size,struct cmd_handler * command_handlers,size_t command_handlers_size,struct cmd_handler * handlers,size_t handlers_size)160 static struct cmd_handler *find_handler_ex(char *line,
161 struct cmd_handler *config_handlers, size_t config_handlers_size,
162 struct cmd_handler *command_handlers, size_t command_handlers_size,
163 struct cmd_handler *handlers, size_t handlers_size) {
164 struct cmd_handler *handler = NULL;
165 if (config->reading) {
166 handler = find_handler(line, config_handlers, config_handlers_size);
167 } else if (config->active) {
168 handler = find_handler(line, command_handlers, command_handlers_size);
169 }
170 return handler ? handler : find_handler(line, handlers, handlers_size);
171 }
172
find_core_handler(char * line)173 static struct cmd_handler *find_core_handler(char *line) {
174 return find_handler_ex(line, config_handlers, sizeof(config_handlers),
175 command_handlers, sizeof(command_handlers),
176 handlers, sizeof(handlers));
177 }
178
set_config_node(struct sway_node * node)179 static void set_config_node(struct sway_node *node) {
180 config->handler_context.node = node;
181 config->handler_context.container = NULL;
182 config->handler_context.workspace = NULL;
183
184 if (node == NULL) {
185 return;
186 }
187
188 switch (node->type) {
189 case N_CONTAINER:
190 config->handler_context.container = node->sway_container;
191 config->handler_context.workspace = node->sway_container->workspace;
192 break;
193 case N_WORKSPACE:
194 config->handler_context.workspace = node->sway_workspace;
195 break;
196 case N_ROOT:
197 case N_OUTPUT:
198 break;
199 }
200 }
201
execute_command(char * _exec,struct sway_seat * seat,struct sway_container * con)202 list_t *execute_command(char *_exec, struct sway_seat *seat,
203 struct sway_container *con) {
204 char *cmd;
205 char matched_delim = ';';
206 list_t *containers = NULL;
207
208 if (seat == NULL) {
209 // passing a NULL seat means we just pick the default seat
210 seat = input_manager_get_default_seat();
211 if (!sway_assert(seat, "could not find a seat to run the command on")) {
212 return NULL;
213 }
214 }
215
216 char *exec = strdup(_exec);
217 char *head = exec;
218 list_t *res_list = create_list();
219
220 if (!res_list || !exec) {
221 return NULL;
222 }
223
224 config->handler_context.seat = seat;
225
226 do {
227 for (; isspace(*head); ++head) {}
228 // Extract criteria (valid for this command list only).
229 if (matched_delim == ';') {
230 config->handler_context.using_criteria = false;
231 if (*head == '[') {
232 char *error = NULL;
233 struct criteria *criteria = criteria_parse(head, &error);
234 if (!criteria) {
235 list_add(res_list,
236 cmd_results_new(CMD_INVALID, "%s", error));
237 free(error);
238 goto cleanup;
239 }
240 list_free(containers);
241 containers = criteria_get_containers(criteria);
242 head += strlen(criteria->raw);
243 criteria_destroy(criteria);
244 config->handler_context.using_criteria = true;
245 // Skip leading whitespace
246 for (; isspace(*head); ++head) {}
247 }
248 }
249 // Split command list
250 cmd = argsep(&head, ";,", &matched_delim);
251 for (; isspace(*cmd); ++cmd) {}
252
253 if (strcmp(cmd, "") == 0) {
254 sway_log(SWAY_INFO, "Ignoring empty command.");
255 continue;
256 }
257 sway_log(SWAY_INFO, "Handling command '%s'", cmd);
258 //TODO better handling of argv
259 int argc;
260 char **argv = split_args(cmd, &argc);
261 if (strcmp(argv[0], "exec") != 0 &&
262 strcmp(argv[0], "exec_always") != 0 &&
263 strcmp(argv[0], "mode") != 0) {
264 for (int i = 1; i < argc; ++i) {
265 if (*argv[i] == '\"' || *argv[i] == '\'') {
266 strip_quotes(argv[i]);
267 }
268 }
269 }
270 struct cmd_handler *handler = find_core_handler(argv[0]);
271 if (!handler) {
272 list_add(res_list, cmd_results_new(CMD_INVALID,
273 "Unknown/invalid command '%s'", argv[0]));
274 free_argv(argc, argv);
275 goto cleanup;
276 }
277
278 // Var replacement, for all but first argument of set
279 for (int i = handler->handle == cmd_set ? 2 : 1; i < argc; ++i) {
280 argv[i] = do_var_replacement(argv[i]);
281 }
282
283 if (!config->handler_context.using_criteria) {
284 // The container or workspace which this command will run on.
285 struct sway_node *node = con ? &con->node :
286 seat_get_focus_inactive(seat, &root->node);
287 set_config_node(node);
288 struct cmd_results *res = handler->handle(argc-1, argv+1);
289 list_add(res_list, res);
290 if (res->status == CMD_INVALID) {
291 free_argv(argc, argv);
292 goto cleanup;
293 }
294 } else if (containers->length == 0) {
295 list_add(res_list,
296 cmd_results_new(CMD_FAILURE, "No matching node."));
297 } else {
298 struct cmd_results *fail_res = NULL;
299 for (int i = 0; i < containers->length; ++i) {
300 struct sway_container *container = containers->items[i];
301 set_config_node(&container->node);
302 struct cmd_results *res = handler->handle(argc-1, argv+1);
303 if (res->status == CMD_SUCCESS) {
304 free_cmd_results(res);
305 } else {
306 // last failure will take precedence
307 if (fail_res) {
308 free_cmd_results(fail_res);
309 }
310 fail_res = res;
311 if (res->status == CMD_INVALID) {
312 list_add(res_list, fail_res);
313 free_argv(argc, argv);
314 goto cleanup;
315 }
316 }
317 }
318 list_add(res_list,
319 fail_res ? fail_res : cmd_results_new(CMD_SUCCESS, NULL));
320 }
321 free_argv(argc, argv);
322 } while(head);
323 cleanup:
324 free(exec);
325 list_free(containers);
326 return res_list;
327 }
328
329 // this is like execute_command above, except:
330 // 1) it ignores empty commands (empty lines)
331 // 2) it does variable substitution
332 // 3) it doesn't split commands (because the multiple commands are supposed to
333 // be chained together)
334 // 4) execute_command handles all state internally while config_command has
335 // some state handled outside (notably the block mode, in read_config)
config_command(char * exec,char ** new_block)336 struct cmd_results *config_command(char *exec, char **new_block) {
337 struct cmd_results *results = NULL;
338 int argc;
339 char **argv = split_args(exec, &argc);
340
341 // Check for empty lines
342 if (!argc) {
343 results = cmd_results_new(CMD_SUCCESS, NULL);
344 goto cleanup;
345 }
346
347 // Check for the start of a block
348 if (argc > 1 && strcmp(argv[argc - 1], "{") == 0) {
349 *new_block = join_args(argv, argc - 1);
350 results = cmd_results_new(CMD_BLOCK, NULL);
351 goto cleanup;
352 }
353
354 // Check for the end of a block
355 if (strcmp(argv[argc - 1], "}") == 0) {
356 results = cmd_results_new(CMD_BLOCK_END, NULL);
357 goto cleanup;
358 }
359
360 // Make sure the command is not stored in a variable
361 if (*argv[0] == '$') {
362 argv[0] = do_var_replacement(argv[0]);
363 char *temp = join_args(argv, argc);
364 free_argv(argc, argv);
365 argv = split_args(temp, &argc);
366 free(temp);
367 if (!argc) {
368 results = cmd_results_new(CMD_SUCCESS, NULL);
369 goto cleanup;
370 }
371 }
372
373 // Determine the command handler
374 sway_log(SWAY_INFO, "Config command: %s", exec);
375 struct cmd_handler *handler = find_core_handler(argv[0]);
376 if (!handler || !handler->handle) {
377 const char *error = handler
378 ? "Command '%s' is shimmed, but unimplemented"
379 : "Unknown/invalid command '%s'";
380 results = cmd_results_new(CMD_INVALID, error, argv[0]);
381 goto cleanup;
382 }
383
384 // Do variable replacement
385 if (handler->handle == cmd_set && argc > 1 && *argv[1] == '$') {
386 // Escape the variable name so it does not get replaced by one shorter
387 char *temp = calloc(1, strlen(argv[1]) + 2);
388 temp[0] = '$';
389 strcpy(&temp[1], argv[1]);
390 free(argv[1]);
391 argv[1] = temp;
392 }
393 char *command = do_var_replacement(join_args(argv, argc));
394 sway_log(SWAY_INFO, "After replacement: %s", command);
395 free_argv(argc, argv);
396 argv = split_args(command, &argc);
397 free(command);
398
399 // Strip quotes and unescape the string
400 for (int i = handler->handle == cmd_set ? 2 : 1; i < argc; ++i) {
401 if (handler->handle != cmd_exec && handler->handle != cmd_exec_always
402 && handler->handle != cmd_mode
403 && handler->handle != cmd_bindsym
404 && handler->handle != cmd_bindcode
405 && handler->handle != cmd_bindswitch
406 && handler->handle != cmd_set
407 && handler->handle != cmd_for_window
408 && (*argv[i] == '\"' || *argv[i] == '\'')) {
409 strip_quotes(argv[i]);
410 }
411 unescape_string(argv[i]);
412 }
413
414 // Run command
415 results = handler->handle(argc - 1, argv + 1);
416
417 cleanup:
418 free_argv(argc, argv);
419 return results;
420 }
421
config_subcommand(char ** argv,int argc,struct cmd_handler * handlers,size_t handlers_size)422 struct cmd_results *config_subcommand(char **argv, int argc,
423 struct cmd_handler *handlers, size_t handlers_size) {
424 char *command = join_args(argv, argc);
425 sway_log(SWAY_DEBUG, "Subcommand: %s", command);
426 free(command);
427
428 struct cmd_handler *handler = find_handler(argv[0], handlers,
429 handlers_size);
430 if (!handler) {
431 return cmd_results_new(CMD_INVALID,
432 "Unknown/invalid command '%s'", argv[0]);
433 }
434 if (handler->handle) {
435 return handler->handle(argc - 1, argv + 1);
436 }
437 return cmd_results_new(CMD_INVALID,
438 "The command '%s' is shimmed, but unimplemented", argv[0]);
439 }
440
config_commands_command(char * exec)441 struct cmd_results *config_commands_command(char *exec) {
442 struct cmd_results *results = NULL;
443 int argc;
444 char **argv = split_args(exec, &argc);
445 if (!argc) {
446 results = cmd_results_new(CMD_SUCCESS, NULL);
447 goto cleanup;
448 }
449
450 // Find handler for the command this is setting a policy for
451 char *cmd = argv[0];
452
453 if (strcmp(cmd, "}") == 0) {
454 results = cmd_results_new(CMD_BLOCK_END, NULL);
455 goto cleanup;
456 }
457
458 struct cmd_handler *handler = find_handler(cmd, NULL, 0);
459 if (!handler && strcmp(cmd, "*") != 0) {
460 results = cmd_results_new(CMD_INVALID,
461 "Unknown/invalid command '%s'", cmd);
462 goto cleanup;
463 }
464
465 enum command_context context = 0;
466
467 struct {
468 char *name;
469 enum command_context context;
470 } context_names[] = {
471 { "config", CONTEXT_CONFIG },
472 { "binding", CONTEXT_BINDING },
473 { "ipc", CONTEXT_IPC },
474 { "criteria", CONTEXT_CRITERIA },
475 { "all", CONTEXT_ALL },
476 };
477
478 for (int i = 1; i < argc; ++i) {
479 size_t j;
480 for (j = 0; j < sizeof(context_names) / sizeof(context_names[0]); ++j) {
481 if (strcmp(context_names[j].name, argv[i]) == 0) {
482 break;
483 }
484 }
485 if (j == sizeof(context_names) / sizeof(context_names[0])) {
486 results = cmd_results_new(CMD_INVALID,
487 "Invalid command context %s", argv[i]);
488 goto cleanup;
489 }
490 context |= context_names[j].context;
491 }
492
493 results = cmd_results_new(CMD_SUCCESS, NULL);
494
495 cleanup:
496 free_argv(argc, argv);
497 return results;
498 }
499
cmd_results_new(enum cmd_status status,const char * format,...)500 struct cmd_results *cmd_results_new(enum cmd_status status,
501 const char *format, ...) {
502 struct cmd_results *results = malloc(sizeof(struct cmd_results));
503 if (!results) {
504 sway_log(SWAY_ERROR, "Unable to allocate command results");
505 return NULL;
506 }
507 results->status = status;
508 if (format) {
509 char *error = malloc(256);
510 va_list args;
511 va_start(args, format);
512 if (error) {
513 vsnprintf(error, 256, format, args);
514 }
515 va_end(args);
516 results->error = error;
517 } else {
518 results->error = NULL;
519 }
520 return results;
521 }
522
free_cmd_results(struct cmd_results * results)523 void free_cmd_results(struct cmd_results *results) {
524 if (results->error) {
525 free(results->error);
526 }
527 free(results);
528 }
529
cmd_results_to_json(list_t * res_list)530 char *cmd_results_to_json(list_t *res_list) {
531 json_object *result_array = json_object_new_array();
532 for (int i = 0; i < res_list->length; ++i) {
533 struct cmd_results *results = res_list->items[i];
534 json_object *root = json_object_new_object();
535 json_object_object_add(root, "success",
536 json_object_new_boolean(results->status == CMD_SUCCESS));
537 if (results->error) {
538 json_object_object_add(root, "parse_error",
539 json_object_new_boolean(results->status == CMD_INVALID));
540 json_object_object_add(
541 root, "error", json_object_new_string(results->error));
542 }
543 json_object_array_add(result_array, root);
544 }
545 const char *json = json_object_to_json_string(result_array);
546 char *res = strdup(json);
547 json_object_put(result_array);
548 return res;
549 }
550