1/* $Id: cmd-set-option.c,v 1.1.1.2 2011/08/17 18:40:04 jmmv Exp $ */
2
3/*
4 * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19#include <sys/types.h>
20
21#include <stdlib.h>
22#include <string.h>
23
24#include "tmux.h"
25
26/*
27 * Set an option.
28 */
29
30int	cmd_set_option_exec(struct cmd *, struct cmd_ctx *);
31
32int	cmd_set_option_find(const char *, const struct options_table_entry **,
33	    const struct options_table_entry **);
34
35int	cmd_set_option_unset(struct cmd *, struct cmd_ctx *,
36	    const struct options_table_entry *, struct options *,
37	    const char *);
38int	cmd_set_option_set(struct cmd *, struct cmd_ctx *,
39	    const struct options_table_entry *, struct options *,
40	    const char *);
41
42struct options_entry *cmd_set_option_string(struct cmd *, struct cmd_ctx *,
43	    const struct options_table_entry *, struct options *,
44	    const char *);
45struct options_entry *cmd_set_option_number(struct cmd *, struct cmd_ctx *,
46	    const struct options_table_entry *, struct options *,
47	    const char *);
48struct options_entry *cmd_set_option_keys(struct cmd *, struct cmd_ctx *,
49	    const struct options_table_entry *, struct options *,
50	    const char *);
51struct options_entry *cmd_set_option_colour(struct cmd *, struct cmd_ctx *,
52	    const struct options_table_entry *, struct options *,
53	    const char *);
54struct options_entry *cmd_set_option_attributes(struct cmd *, struct cmd_ctx *,
55	    const struct options_table_entry *, struct options *,
56	    const char *);
57struct options_entry *cmd_set_option_flag(struct cmd *, struct cmd_ctx *,
58	    const struct options_table_entry *, struct options *,
59	    const char *);
60struct options_entry *cmd_set_option_choice(struct cmd *, struct cmd_ctx *,
61	    const struct options_table_entry *, struct options *,
62	    const char *);
63
64const struct cmd_entry cmd_set_option_entry = {
65	"set-option", "set",
66	"agst:uw", 1, 2,
67	"[-agsuw] [-t target-session|target-window] option [value]",
68	0,
69	NULL,
70	NULL,
71	cmd_set_option_exec
72};
73
74const struct cmd_entry cmd_set_window_option_entry = {
75	"set-window-option", "setw",
76	"agt:u", 1, 2,
77	"[-agu] " CMD_TARGET_WINDOW_USAGE " option [value]",
78	0,
79	NULL,
80	NULL,
81	cmd_set_option_exec
82};
83
84/* Look for an option in all three tables. */
85int
86cmd_set_option_find(
87    const char *optstr, const struct options_table_entry **table,
88    const struct options_table_entry **oe)
89{
90	static const struct options_table_entry	*tables[] = {
91		server_options_table,
92		window_options_table,
93		session_options_table
94	};
95	const struct options_table_entry	*oe_loop;
96	u_int					 i;
97
98	for (i = 0; i < nitems(tables); i++) {
99		for (oe_loop = tables[i]; oe_loop->name != NULL; oe_loop++) {
100			if (strncmp(oe_loop->name, optstr, strlen(optstr)) != 0)
101				continue;
102
103			/* If already found, ambiguous. */
104			if (*oe != NULL)
105				return (-1);
106			*oe = oe_loop;
107			*table = tables[i];
108
109			/* Bail now if an exact match. */
110			if (strcmp((*oe)->name, optstr) == 0)
111				break;
112		}
113	}
114	return (0);
115}
116
117int
118cmd_set_option_exec(struct cmd *self, struct cmd_ctx *ctx)
119{
120	struct args				*args = self->args;
121	const struct options_table_entry	*table, *oe;
122	struct session				*s;
123	struct winlink				*wl;
124	struct client				*c;
125	struct options				*oo;
126	const char				*optstr, *valstr;
127	u_int					 i;
128
129	/* Get the option name and value. */
130	optstr = args->argv[0];
131	if (*optstr == '\0') {
132		ctx->error(ctx, "invalid option");
133		return (-1);
134	}
135	if (args->argc < 2)
136		valstr = NULL;
137	else
138		valstr = args->argv[1];
139
140	/* Find the option entry, try each table. */
141	table = oe = NULL;
142	if (cmd_set_option_find(optstr, &table, &oe) != 0) {
143		ctx->error(ctx, "ambiguous option: %s", optstr);
144		return (-1);
145	}
146	if (oe == NULL) {
147		ctx->error(ctx, "unknown option: %s", optstr);
148		return (-1);
149	}
150
151	/* Work out the tree from the table. */
152	if (table == server_options_table)
153		oo = &global_options;
154	else if (table == window_options_table) {
155		if (args_has(self->args, 'g'))
156			oo = &global_w_options;
157		else {
158			wl = cmd_find_window(ctx, args_get(args, 't'), NULL);
159			if (wl == NULL)
160				return (-1);
161			oo = &wl->window->options;
162		}
163	} else if (table == session_options_table) {
164		if (args_has(self->args, 'g'))
165			oo = &global_s_options;
166		else {
167			s = cmd_find_session(ctx, args_get(args, 't'), 0);
168			if (s == NULL)
169				return (-1);
170			oo = &s->options;
171		}
172	} else {
173		ctx->error(ctx, "unknown table");
174		return (-1);
175	}
176
177	/* Unset or set the option. */
178	if (args_has(args, 'u')) {
179		if (cmd_set_option_unset(self, ctx, oe, oo, valstr) != 0)
180			return (-1);
181	} else {
182		if (cmd_set_option_set(self, ctx, oe, oo, valstr) != 0)
183			return (-1);
184	}
185
186	/* Update sizes and redraw. May not need it but meh. */
187	recalculate_sizes();
188	for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
189		c = ARRAY_ITEM(&clients, i);
190		if (c != NULL && c->session != NULL)
191			server_redraw_client(c);
192	}
193
194	return (0);
195}
196
197/* Unset an option. */
198int
199cmd_set_option_unset(struct cmd *self, struct cmd_ctx *ctx,
200    const struct options_table_entry *oe, struct options *oo, const char *value)
201{
202	struct args	*args = self->args;
203
204	if (args_has(args, 'g')) {
205		ctx->error(ctx, "can't unset global option: %s", oe->name);
206		return (-1);
207	}
208	if (value != NULL) {
209		ctx->error(ctx, "value passed to unset option: %s", oe->name);
210		return (-1);
211	}
212
213	options_remove(oo, oe->name);
214	ctx->info(ctx, "unset option: %s", oe->name);
215	return (0);
216}
217
218/* Set an option. */
219int
220cmd_set_option_set(struct cmd *self, struct cmd_ctx *ctx,
221    const struct options_table_entry *oe, struct options *oo, const char *value)
222{
223	struct options_entry	*o;
224	const char		*s;
225
226	if (oe->type != OPTIONS_TABLE_FLAG && value == NULL) {
227		ctx->error(ctx, "empty value");
228		return (-1);
229	}
230
231	o = NULL;
232	switch (oe->type) {
233	case OPTIONS_TABLE_STRING:
234		o = cmd_set_option_string(self, ctx, oe, oo, value);
235		break;
236	case OPTIONS_TABLE_NUMBER:
237		o = cmd_set_option_number(self, ctx, oe, oo, value);
238		break;
239	case OPTIONS_TABLE_KEYS:
240		o = cmd_set_option_keys(self, ctx, oe, oo, value);
241		break;
242	case OPTIONS_TABLE_COLOUR:
243		o = cmd_set_option_colour(self, ctx, oe, oo, value);
244		break;
245	case OPTIONS_TABLE_ATTRIBUTES:
246		o = cmd_set_option_attributes(self, ctx, oe, oo, value);
247		break;
248	case OPTIONS_TABLE_FLAG:
249		o = cmd_set_option_flag(self, ctx, oe, oo, value);
250		break;
251	case OPTIONS_TABLE_CHOICE:
252		o = cmd_set_option_choice(self, ctx, oe, oo, value);
253		break;
254	}
255	if (o == NULL)
256		return (-1);
257
258	s = options_table_print_entry(oe, o);
259	ctx->info(ctx, "set option: %s -> %s", oe->name, s);
260	return (0);
261}
262
263/* Set a string option. */
264struct options_entry *
265cmd_set_option_string(struct cmd *self, unused struct cmd_ctx *ctx,
266    const struct options_table_entry *oe, struct options *oo, const char *value)
267{
268	struct args	*args = self->args;
269	struct options_entry	*o;
270	char			*oldval, *newval;
271
272	if (args_has(args, 'a')) {
273		oldval = options_get_string(oo, oe->name);
274		xasprintf(&newval, "%s%s", oldval, value);
275	} else
276		newval = xstrdup(value);
277
278	o = options_set_string(oo, oe->name, "%s", newval);
279
280	xfree(newval);
281	return (o);
282}
283
284/* Set a number option. */
285struct options_entry *
286cmd_set_option_number(unused struct cmd *self, struct cmd_ctx *ctx,
287    const struct options_table_entry *oe, struct options *oo, const char *value)
288{
289	long long	 ll;
290	const char     	*errstr;
291
292	ll = strtonum(value, oe->minimum, oe->maximum, &errstr);
293	if (errstr != NULL) {
294		ctx->error(ctx, "value is %s: %s", errstr, value);
295		return (NULL);
296	}
297
298	return (options_set_number(oo, oe->name, ll));
299}
300
301/* Set a keys option. */
302struct options_entry *
303cmd_set_option_keys(unused struct cmd *self, struct cmd_ctx *ctx,
304    const struct options_table_entry *oe, struct options *oo, const char *value)
305{
306	struct keylist	*keylist;
307	char		*copy, *ptr, *s;
308	int		 key;
309
310	keylist = xmalloc(sizeof *keylist);
311	ARRAY_INIT(keylist);
312
313	ptr = copy = xstrdup(value);
314	while ((s = strsep(&ptr, ",")) != NULL) {
315		if ((key = key_string_lookup_string(s)) == KEYC_NONE) {
316			ctx->error(ctx, "unknown key: %s", s);
317			xfree(copy);
318			xfree(keylist);
319			return (NULL);
320		}
321		ARRAY_ADD(keylist, key);
322	}
323	xfree(copy);
324
325	return (options_set_data(oo, oe->name, keylist, xfree));
326}
327
328/* Set a colour option. */
329struct options_entry *
330cmd_set_option_colour(unused struct cmd *self, struct cmd_ctx *ctx,
331    const struct options_table_entry *oe, struct options *oo, const char *value)
332{
333	int	colour;
334
335	if ((colour = colour_fromstring(value)) == -1) {
336		ctx->error(ctx, "bad colour: %s", value);
337		return (NULL);
338	}
339
340	return (options_set_number(oo, oe->name, colour));
341}
342
343/* Set an attributes option. */
344struct options_entry *
345cmd_set_option_attributes(unused struct cmd *self, struct cmd_ctx *ctx,
346    const struct options_table_entry *oe, struct options *oo, const char *value)
347{
348	int	attr;
349
350	if ((attr = attributes_fromstring(value)) == -1) {
351		ctx->error(ctx, "bad attributes: %s", value);
352		return (NULL);
353	}
354
355	return (options_set_number(oo, oe->name, attr));
356}
357
358/* Set a flag option. */
359struct options_entry *
360cmd_set_option_flag(unused struct cmd *self, struct cmd_ctx *ctx,
361    const struct options_table_entry *oe, struct options *oo, const char *value)
362{
363	int	flag;
364
365	if (value == NULL || *value == '\0')
366		flag = !options_get_number(oo, oe->name);
367	else {
368		if ((value[0] == '1' && value[1] == '\0') ||
369		    strcasecmp(value, "on") == 0 ||
370		    strcasecmp(value, "yes") == 0)
371			flag = 1;
372		else if ((value[0] == '0' && value[1] == '\0') ||
373		    strcasecmp(value, "off") == 0 ||
374		    strcasecmp(value, "no") == 0)
375			flag = 0;
376		else {
377			ctx->error(ctx, "bad value: %s", value);
378			return (NULL);
379		}
380	}
381
382	return (options_set_number(oo, oe->name, flag));
383}
384
385/* Set a choice option. */
386struct options_entry *
387cmd_set_option_choice(unused struct cmd *self, struct cmd_ctx *ctx,
388    const struct options_table_entry *oe, struct options *oo, const char *value)
389{
390	const char	**choicep;
391	int		  n, choice = -1;
392
393	n = 0;
394	for (choicep = oe->choices; *choicep != NULL; choicep++) {
395		n++;
396		if (strncmp(*choicep, value, strlen(value)) != 0)
397			continue;
398
399		if (choice != -1) {
400			ctx->error(ctx, "ambiguous value: %s", value);
401			return (NULL);
402		}
403		choice = n - 1;
404	}
405	if (choice == -1) {
406		ctx->error(ctx, "unknown value: %s", value);
407		return (NULL);
408	}
409
410	return (options_set_number(oo, oe->name, choice));
411}
412