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