Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/tmux/cmd-queue.c	Lines:	0	160	0.0 %
Date:	2016-12-06	Branches:	0	84	0.0 %


/* $OpenBSD: cmd-queue.c,v 1.36 2016/04/29 14:05:24 nicm Exp $ */

/*
 * Copyright (c) 2013 Nicholas Marriott <nicholas.marriott@gmail.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>

#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include "tmux.h"

static enum cmd_retval	cmdq_continue_one(struct cmd_q *);

/* Create new command queue. */
struct cmd_q *
cmdq_new(struct client *c)
{
	struct cmd_q	*cmdq;

	cmdq = xcalloc(1, sizeof *cmdq);
	cmdq->references = 1;
	cmdq->flags = 0;

	cmdq->client = c;
	cmdq->client_exit = -1;

	TAILQ_INIT(&cmdq->queue);
	cmdq->item = NULL;
	cmdq->cmd = NULL;

	cmd_find_clear_state(&cmdq->current, NULL, 0);
	cmdq->parent = NULL;

	return (cmdq);
}

/* Free command queue */
int
cmdq_free(struct cmd_q *cmdq)
{
	if (--cmdq->references != 0) {
		if (cmdq->flags & CMD_Q_DEAD)
			return (1);
		return (0);
	}

	cmdq_flush(cmdq);
	free(cmdq);
	return (1);
}

/* Show message from command. */
void
cmdq_print(struct cmd_q *cmdq, const char *fmt, ...)
{
	struct client	*c = cmdq->client;
	struct window	*w;
	va_list		 ap;
	char		*tmp, *msg;

	va_start(ap, fmt);

	if (c == NULL)
		/* nothing */;
	else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
		if (~c->flags & CLIENT_UTF8) {
			vasprintf(&tmp, fmt, ap);
			msg = utf8_sanitize(tmp);
			free(tmp);
			evbuffer_add(c->stdout_data, msg, strlen(msg));
			free(msg);
		} else
			evbuffer_add_vprintf(c->stdout_data, fmt, ap);
		evbuffer_add(c->stdout_data, "\n", 1);
		server_client_push_stdout(c);
	} else {
		w = c->session->curw->window;
		if (w->active->mode != &window_copy_mode) {
			window_pane_reset_mode(w->active);
			window_pane_set_mode(w->active, &window_copy_mode);
			window_copy_init_for_output(w->active);
		}
		window_copy_vadd(w->active, fmt, ap);
	}

	va_end(ap);
}

/* Show error from command. */
void
cmdq_error(struct cmd_q *cmdq, const char *fmt, ...)
{
	struct client	*c = cmdq->client;
	struct cmd	*cmd = cmdq->cmd;
	va_list		 ap;
	char		*msg;
	size_t		 msglen;
	char		*tmp;

	va_start(ap, fmt);
	msglen = xvasprintf(&msg, fmt, ap);
	va_end(ap);

	if (c == NULL)
		cfg_add_cause("%s:%u: %s", cmd->file, cmd->line, msg);
	else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
		if (~c->flags & CLIENT_UTF8) {
			tmp = msg;
			msg = utf8_sanitize(tmp);
			free(tmp);
			msglen = strlen(msg);
		}
		evbuffer_add(c->stderr_data, msg, msglen);
		evbuffer_add(c->stderr_data, "\n", 1);
		server_client_push_stderr(c);
		c->retval = 1;
	} else {
		*msg = toupper((u_char) *msg);
		status_message_set(c, "%s", msg);
	}

	free(msg);
}

/* Print a guard line. */
void
cmdq_guard(struct cmd_q *cmdq, const char *guard, int flags)
{
	struct client	*c = cmdq->client;

	if (c == NULL || !(c->flags & CLIENT_CONTROL))
		return;

	evbuffer_add_printf(c->stdout_data, "%%%s %ld %u %d\n", guard,
	    (long) cmdq->time, cmdq->number, flags);
	server_client_push_stdout(c);
}

/* Add command list to queue and begin processing if needed. */
void
cmdq_run(struct cmd_q *cmdq, struct cmd_list *cmdlist, struct mouse_event *m)
{
	cmdq_append(cmdq, cmdlist, m);

	if (cmdq->item == NULL) {
		cmdq->cmd = NULL;
		cmdq_continue(cmdq);
	}
}

/* Add command list to queue. */
void
cmdq_append(struct cmd_q *cmdq, struct cmd_list *cmdlist, struct mouse_event *m)
{
	struct cmd_q_item	*item;

	item = xcalloc(1, sizeof *item);
	item->cmdlist = cmdlist;
	TAILQ_INSERT_TAIL(&cmdq->queue, item, qentry);
	cmdlist->references++;

	if (m != NULL)
		memcpy(&item->mouse, m, sizeof item->mouse);
	else
		item->mouse.valid = 0;
}

/* Process one command. */
static enum cmd_retval
cmdq_continue_one(struct cmd_q *cmdq)
{
	struct cmd	*cmd = cmdq->cmd;
	const char	*name = cmd->entry->name;
	struct session	*s;
	struct hooks	*hooks;
	enum cmd_retval	 retval;
	char		*tmp;
	int		 flags = !!(cmd->flags & CMD_CONTROL);

	tmp = cmd_print(cmd);
	log_debug("cmdq %p: %s", cmdq, tmp);
	free(tmp);

	cmdq->time = time(NULL);
	cmdq->number++;

	if (~cmdq->flags & CMD_Q_REENTRY)
		cmdq_guard(cmdq, "begin", flags);

	if (cmd_prepare_state(cmd, cmdq, cmdq->parent) != 0)
		goto error;

	if (~cmdq->flags & CMD_Q_NOHOOKS) {
		s = NULL;
		if (cmdq->state.tflag.s != NULL)
			s = cmdq->state.tflag.s;
		else if (cmdq->state.sflag.s != NULL)
			s = cmdq->state.sflag.s;
		else if (cmdq->state.c != NULL)
			s = cmdq->state.c->session;
		if (s != NULL)
			hooks = s->hooks;
		else
			hooks = global_hooks;

		if (~cmdq->flags & CMD_Q_REENTRY) {
			cmdq->flags |= CMD_Q_REENTRY;
			if (hooks_wait(hooks, cmdq, NULL,
			    "before-%s", name) == 0)
				return (CMD_RETURN_WAIT);
			if (cmd_prepare_state(cmd, cmdq, cmdq->parent) != 0)
				goto error;
		}
	} else
		hooks = NULL;
	cmdq->flags &= ~CMD_Q_REENTRY;

	retval = cmd->entry->exec(cmd, cmdq);
	if (retval == CMD_RETURN_ERROR)
		goto error;

	if (hooks != NULL && hooks_wait(hooks, cmdq, NULL,
	    "after-%s", name) == 0)
		retval = CMD_RETURN_WAIT;
	cmdq_guard(cmdq, "end", flags);

	return (retval);

error:
	cmdq_guard(cmdq, "error", flags);
	cmdq->flags &= ~CMD_Q_REENTRY;
	return (CMD_RETURN_ERROR);
}

/* Continue processing command queue. Returns 1 if finishes empty. */
int
cmdq_continue(struct cmd_q *cmdq)
{
	struct client		*c = cmdq->client;
	struct cmd_q_item	*next;
	enum cmd_retval		 retval;
	int			 empty;

	cmdq->references++;
	notify_disable();

	log_debug("continuing cmdq %p: flags %#x, client %p", cmdq, cmdq->flags,
	    c);

	empty = TAILQ_EMPTY(&cmdq->queue);
	if (empty)
		goto empty;

	/*
	 * If the command isn't in the middle of running hooks (due to
	 * CMD_RETURN_WAIT), move onto the next command; otherwise, leave the
	 * state of the queue as it is.
	 */
	if (~cmdq->flags & CMD_Q_REENTRY) {
		if (cmdq->item == NULL) {
			cmdq->item = TAILQ_FIRST(&cmdq->queue);
			cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list);
		} else
			cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry);
	}

	do {
		while (cmdq->cmd != NULL) {
			retval = cmdq_continue_one(cmdq);
			if (retval == CMD_RETURN_ERROR)
				break;
			if (retval == CMD_RETURN_WAIT)
				goto out;
			if (retval == CMD_RETURN_STOP) {
				cmdq_flush(cmdq);
				goto empty;
			}
			cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry);
		}
		next = TAILQ_NEXT(cmdq->item, qentry);

		TAILQ_REMOVE(&cmdq->queue, cmdq->item, qentry);
		cmd_list_free(cmdq->item->cmdlist);
		free(cmdq->item);

		cmdq->item = next;
		if (cmdq->item != NULL)
			cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list);
	} while (cmdq->item != NULL);

empty:
	if (cmdq->client_exit > 0)
		cmdq->client->flags |= CLIENT_EXIT;
	if (cmdq->emptyfn != NULL)
		cmdq->emptyfn(cmdq);
	empty = 1;

out:
	notify_enable();
	cmdq_free(cmdq);

	return (empty);
}

/* Flush command queue. */
void
cmdq_flush(struct cmd_q *cmdq)
{
	struct cmd_q_item	*item, *item1;

	TAILQ_FOREACH_SAFE(item, &cmdq->queue, qentry, item1) {
		TAILQ_REMOVE(&cmdq->queue, item, qentry);
		cmd_list_free(item->cmdlist);
		free(item);
	}
	cmdq->item = NULL;
}



Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: cmd-queue.c,v 1.36 2016/04/29 14:05:24 nicm Exp $ */
2
3			/*
4			* Copyright (c) 2013 Nicholas Marriott <nicholas.marriott@gmail.com>
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 <ctype.h>
22			#include <stdlib.h>
23			#include <string.h>
24			#include <time.h>
25
26			#include "tmux.h"
27
28			static enum cmd_retval cmdq_continue_one(struct cmd_q *);
29
30			/* Create new command queue. */
31			struct cmd_q *
32			cmdq_new(struct client *c)
33			{
34			struct cmd_q *cmdq;
35
36			cmdq = xcalloc(1, sizeof *cmdq);
37			cmdq->references = 1;
38			cmdq->flags = 0;
39
40			cmdq->client = c;
41			cmdq->client_exit = -1;
42
43			TAILQ_INIT(&cmdq->queue);
44			cmdq->item = NULL;
45			cmdq->cmd = NULL;
46
47			cmd_find_clear_state(&cmdq->current, NULL, 0);
48			cmdq->parent = NULL;
49
50			return (cmdq);
51			}
52
53			/* Free command queue */
54			int
55			cmdq_free(struct cmd_q *cmdq)
56			{
57			if (--cmdq->references != 0) {
58			if (cmdq->flags & CMD_Q_DEAD)
59			return (1);
60			return (0);
61			}
62
63			cmdq_flush(cmdq);
64			free(cmdq);
65			return (1);
66			}
67
68			/* Show message from command. */
69			void
70			cmdq_print(struct cmd_q cmdq, const char fmt, ...)
71			{
72			struct client *c = cmdq->client;
73			struct window *w;
74			va_list ap;
75			char tmp, msg;
76
77			va_start(ap, fmt);
78
79			if (c == NULL)
80			/* nothing */;
81			else if (c->session == NULL \|\| (c->flags & CLIENT_CONTROL)) {
82			if (~c->flags & CLIENT_UTF8) {
83			vasprintf(&tmp, fmt, ap);
84			msg = utf8_sanitize(tmp);
85			free(tmp);
86			evbuffer_add(c->stdout_data, msg, strlen(msg));
87			free(msg);
88			} else
89			evbuffer_add_vprintf(c->stdout_data, fmt, ap);
90			evbuffer_add(c->stdout_data, "\n", 1);
91			server_client_push_stdout(c);
92			} else {
93			w = c->session->curw->window;
94			if (w->active->mode != &window_copy_mode) {
95			window_pane_reset_mode(w->active);
96			window_pane_set_mode(w->active, &window_copy_mode);
97			window_copy_init_for_output(w->active);
98			}
99			window_copy_vadd(w->active, fmt, ap);
100			}
101
102			va_end(ap);
103			}
104
105			/* Show error from command. */
106			void
107			cmdq_error(struct cmd_q cmdq, const char fmt, ...)
108			{
109			struct client *c = cmdq->client;
110			struct cmd *cmd = cmdq->cmd;
111			va_list ap;
112			char *msg;
113			size_t msglen;
114			char *tmp;
115
116			va_start(ap, fmt);
117			msglen = xvasprintf(&msg, fmt, ap);
118			va_end(ap);
119
120			if (c == NULL)
121			cfg_add_cause("%s:%u: %s", cmd->file, cmd->line, msg);
122			else if (c->session == NULL \|\| (c->flags & CLIENT_CONTROL)) {
123			if (~c->flags & CLIENT_UTF8) {
124			tmp = msg;
125			msg = utf8_sanitize(tmp);
126			free(tmp);
127			msglen = strlen(msg);
128			}
129			evbuffer_add(c->stderr_data, msg, msglen);
130			evbuffer_add(c->stderr_data, "\n", 1);
131			server_client_push_stderr(c);
132			c->retval = 1;
133			} else {
134			msg = toupper((u_char) msg);
135			status_message_set(c, "%s", msg);
136			}
137
138			free(msg);
139			}
140
141			/* Print a guard line. */
142			void
143			cmdq_guard(struct cmd_q cmdq, const char guard, int flags)
144			{
145			struct client *c = cmdq->client;
146
147			if (c == NULL \|\| !(c->flags & CLIENT_CONTROL))
148			return;
149
150			evbuffer_add_printf(c->stdout_data, "%%%s %ld %u %d\n", guard,
151			(long) cmdq->time, cmdq->number, flags);
152			server_client_push_stdout(c);
153			}
154
155			/* Add command list to queue and begin processing if needed. */
156			void
157			cmdq_run(struct cmd_q cmdq, struct cmd_list cmdlist, struct mouse_event *m)
158			{
159			cmdq_append(cmdq, cmdlist, m);
160
161			if (cmdq->item == NULL) {
162			cmdq->cmd = NULL;
163			cmdq_continue(cmdq);
164			}
165			}
166
167			/* Add command list to queue. */
168			void
169			cmdq_append(struct cmd_q cmdq, struct cmd_list cmdlist, struct mouse_event *m)
170			{
171			struct cmd_q_item *item;
172
173			item = xcalloc(1, sizeof *item);
174			item->cmdlist = cmdlist;
175			TAILQ_INSERT_TAIL(&cmdq->queue, item, qentry);
176			cmdlist->references++;
177
178			if (m != NULL)
179			memcpy(&item->mouse, m, sizeof item->mouse);
180			else
181			item->mouse.valid = 0;
182			}
183
184			/* Process one command. */
185			static enum cmd_retval
186			cmdq_continue_one(struct cmd_q *cmdq)
187			{
188			struct cmd *cmd = cmdq->cmd;
189			const char *name = cmd->entry->name;
190			struct session *s;
191			struct hooks *hooks;
192			enum cmd_retval retval;
193			char *tmp;
194			int flags = !!(cmd->flags & CMD_CONTROL);
195
196			tmp = cmd_print(cmd);
197			log_debug("cmdq %p: %s", cmdq, tmp);
198			free(tmp);
199
200			cmdq->time = time(NULL);
201			cmdq->number++;
202
203			if (~cmdq->flags & CMD_Q_REENTRY)
204			cmdq_guard(cmdq, "begin", flags);
205
206			if (cmd_prepare_state(cmd, cmdq, cmdq->parent) != 0)
207			goto error;
208
209			if (~cmdq->flags & CMD_Q_NOHOOKS) {
210			s = NULL;
211			if (cmdq->state.tflag.s != NULL)
212			s = cmdq->state.tflag.s;
213			else if (cmdq->state.sflag.s != NULL)
214			s = cmdq->state.sflag.s;
215			else if (cmdq->state.c != NULL)
216			s = cmdq->state.c->session;
217			if (s != NULL)
218			hooks = s->hooks;
219			else
220			hooks = global_hooks;
221
222			if (~cmdq->flags & CMD_Q_REENTRY) {
223			cmdq->flags \|= CMD_Q_REENTRY;
224			if (hooks_wait(hooks, cmdq, NULL,
225			"before-%s", name) == 0)
226			return (CMD_RETURN_WAIT);
227			if (cmd_prepare_state(cmd, cmdq, cmdq->parent) != 0)
228			goto error;
229			}
230			} else
231			hooks = NULL;
232			cmdq->flags &= ~CMD_Q_REENTRY;
233
234			retval = cmd->entry->exec(cmd, cmdq);
235			if (retval == CMD_RETURN_ERROR)
236			goto error;
237
238			if (hooks != NULL && hooks_wait(hooks, cmdq, NULL,
239			"after-%s", name) == 0)
240			retval = CMD_RETURN_WAIT;
241			cmdq_guard(cmdq, "end", flags);
242
243			return (retval);
244
245			error:
246			cmdq_guard(cmdq, "error", flags);
247			cmdq->flags &= ~CMD_Q_REENTRY;
248			return (CMD_RETURN_ERROR);
249			}
250
251			/* Continue processing command queue. Returns 1 if finishes empty. */
252			int
253			cmdq_continue(struct cmd_q *cmdq)
254			{
255			struct client *c = cmdq->client;
256			struct cmd_q_item *next;
257			enum cmd_retval retval;
258			int empty;
259
260			cmdq->references++;
261			notify_disable();
262
263			log_debug("continuing cmdq %p: flags %#x, client %p", cmdq, cmdq->flags,
264			c);
265
266			empty = TAILQ_EMPTY(&cmdq->queue);
267			if (empty)
268			goto empty;
269
270			/*
271			* If the command isn't in the middle of running hooks (due to
272			* CMD_RETURN_WAIT), move onto the next command; otherwise, leave the
273			* state of the queue as it is.
274			*/
275			if (~cmdq->flags & CMD_Q_REENTRY) {
276			if (cmdq->item == NULL) {
277			cmdq->item = TAILQ_FIRST(&cmdq->queue);
278			cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list);
279			} else
280			cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry);
281			}
282
283			do {
284			while (cmdq->cmd != NULL) {
285			retval = cmdq_continue_one(cmdq);
286			if (retval == CMD_RETURN_ERROR)
287			break;
288			if (retval == CMD_RETURN_WAIT)
289			goto out;
290			if (retval == CMD_RETURN_STOP) {
291			cmdq_flush(cmdq);
292			goto empty;
293			}
294			cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry);
295			}
296			next = TAILQ_NEXT(cmdq->item, qentry);
297
298			TAILQ_REMOVE(&cmdq->queue, cmdq->item, qentry);
299			cmd_list_free(cmdq->item->cmdlist);
300			free(cmdq->item);
301
302			cmdq->item = next;
303			if (cmdq->item != NULL)
304			cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list);
305			} while (cmdq->item != NULL);
306
307			empty:
308			if (cmdq->client_exit > 0)
309			cmdq->client->flags \|= CLIENT_EXIT;
310			if (cmdq->emptyfn != NULL)
311			cmdq->emptyfn(cmdq);
312			empty = 1;
313
314			out:
315			notify_enable();
316			cmdq_free(cmdq);
317
318			return (empty);
319			}
320
321			/* Flush command queue. */
322			void
323			cmdq_flush(struct cmd_q *cmdq)
324			{
325			struct cmd_q_item item, item1;
326
327			TAILQ_FOREACH_SAFE(item, &cmdq->queue, qentry, item1) {
328			TAILQ_REMOVE(&cmdq->queue, item, qentry);
329			cmd_list_free(item->cmdlist);
330			free(item);
331			}
332			cmdq->item = NULL;
333			}
334