Annotation of src/usr.bin/tmux/cmd-queue.c, Revision 1.15
1.15 ! nicm 1: /* $OpenBSD: cmd-queue.c,v 1.14 2013/10/10 12:26:35 nicm Exp $ */
1.1 nicm 2:
3: /*
4: * Copyright (c) 2013 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 <ctype.h>
22: #include <stdlib.h>
1.7 nicm 23: #include <time.h>
1.1 nicm 24:
25: #include "tmux.h"
26:
27: /* Create new command queue. */
28: struct cmd_q *
29: cmdq_new(struct client *c)
30: {
31: struct cmd_q *cmdq;
32:
33: cmdq = xcalloc(1, sizeof *cmdq);
34: cmdq->references = 1;
35: cmdq->dead = 0;
36:
37: cmdq->client = c;
1.11 nicm 38: cmdq->client_exit = -1;
1.1 nicm 39:
40: TAILQ_INIT(&cmdq->queue);
41: cmdq->item = NULL;
42: cmdq->cmd = NULL;
43:
44: return (cmdq);
45: }
46:
47: /* Free command queue */
48: int
49: cmdq_free(struct cmd_q *cmdq)
50: {
51: if (--cmdq->references != 0)
52: return (cmdq->dead);
53:
54: cmdq_flush(cmdq);
55: free(cmdq);
56: return (1);
57: }
58:
59: /* Show message from command. */
60: void printflike2
61: cmdq_print(struct cmd_q *cmdq, const char *fmt, ...)
62: {
63: struct client *c = cmdq->client;
64: struct window *w;
65: va_list ap;
66:
67: va_start(ap, fmt);
68:
69: if (c == NULL)
70: /* nothing */;
71: else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
72: evbuffer_add_vprintf(c->stdout_data, fmt, ap);
73:
74: evbuffer_add(c->stdout_data, "\n", 1);
75: server_push_stdout(c);
76: } else {
77: w = c->session->curw->window;
78: if (w->active->mode != &window_copy_mode) {
79: window_pane_reset_mode(w->active);
80: window_pane_set_mode(w->active, &window_copy_mode);
81: window_copy_init_for_output(w->active);
82: }
83: window_copy_vadd(w->active, fmt, ap);
84: }
85:
86: va_end(ap);
87: }
88:
89: /* Show info from command. */
90: void printflike2
91: cmdq_info(struct cmd_q *cmdq, const char *fmt, ...)
92: {
93: struct client *c = cmdq->client;
94: va_list ap;
95: char *msg;
96:
97: if (options_get_number(&global_options, "quiet"))
98: return;
99:
100: va_start(ap, fmt);
101:
102: if (c == NULL)
103: /* nothing */;
104: else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
105: evbuffer_add_vprintf(c->stdout_data, fmt, ap);
106:
107: evbuffer_add(c->stdout_data, "\n", 1);
108: server_push_stdout(c);
109: } else {
110: xvasprintf(&msg, fmt, ap);
111: *msg = toupper((u_char) *msg);
112: status_message_set(c, "%s", msg);
113: free(msg);
114: }
115:
116: va_end(ap);
117:
118: }
119:
120: /* Show error from command. */
121: void printflike2
122: cmdq_error(struct cmd_q *cmdq, const char *fmt, ...)
123: {
124: struct client *c = cmdq->client;
125: struct cmd *cmd = cmdq->cmd;
126: va_list ap;
127: char *msg, *cause;
128: size_t msglen;
129:
130: va_start(ap, fmt);
131: msglen = xvasprintf(&msg, fmt, ap);
132: va_end(ap);
133:
134: if (c == NULL) {
135: xasprintf(&cause, "%s:%u: %s", cmd->file, cmd->line, msg);
136: ARRAY_ADD(&cfg_causes, cause);
137: } else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) {
138: evbuffer_add(c->stderr_data, msg, msglen);
139: evbuffer_add(c->stderr_data, "\n", 1);
140:
141: server_push_stderr(c);
1.13 nicm 142: c->retval = 1;
1.1 nicm 143: } else {
144: *msg = toupper((u_char) *msg);
145: status_message_set(c, "%s", msg);
146: }
147:
148: free(msg);
149: }
150:
1.4 nicm 151: /* Print a guard line. */
1.6 nicm 152: int
1.10 nicm 153: cmdq_guard(struct cmd_q *cmdq, const char *guard, int flags)
1.4 nicm 154: {
155: struct client *c = cmdq->client;
156:
1.8 nicm 157: if (c == NULL)
1.6 nicm 158: return 0;
1.4 nicm 159: if (!(c->flags & CLIENT_CONTROL))
1.6 nicm 160: return 0;
1.4 nicm 161:
1.9 nicm 162: evbuffer_add_printf(c->stdout_data, "%%%s %ld %u %d\n", guard,
163: (long) cmdq->time, cmdq->number, flags);
1.4 nicm 164: server_push_stdout(c);
1.6 nicm 165: return 1;
1.4 nicm 166: }
167:
1.1 nicm 168: /* Add command list to queue and begin processing if needed. */
169: void
170: cmdq_run(struct cmd_q *cmdq, struct cmd_list *cmdlist)
171: {
172: cmdq_append(cmdq, cmdlist);
173:
174: if (cmdq->item == NULL) {
175: cmdq->cmd = NULL;
176: cmdq_continue(cmdq);
177: }
178: }
179:
180: /* Add command list to queue. */
181: void
182: cmdq_append(struct cmd_q *cmdq, struct cmd_list *cmdlist)
183: {
184: struct cmd_q_item *item;
185:
186: item = xcalloc(1, sizeof *item);
187: item->cmdlist = cmdlist;
188: TAILQ_INSERT_TAIL(&cmdq->queue, item, qentry);
189: cmdlist->references++;
190: }
191:
192: /* Continue processing command queue. Returns 1 if finishes empty. */
193: int
194: cmdq_continue(struct cmd_q *cmdq)
195: {
196: struct cmd_q_item *next;
197: enum cmd_retval retval;
1.10 nicm 198: int empty, guard, flags;
1.3 nicm 199: char s[1024];
1.1 nicm 200:
201: notify_disable();
202:
203: empty = TAILQ_EMPTY(&cmdq->queue);
204: if (empty)
205: goto empty;
206:
207: if (cmdq->item == NULL) {
208: cmdq->item = TAILQ_FIRST(&cmdq->queue);
209: cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list);
210: } else
211: cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry);
212:
213: do {
214: next = TAILQ_NEXT(cmdq->item, qentry);
215:
216: while (cmdq->cmd != NULL) {
1.3 nicm 217: cmd_print(cmdq->cmd, s, sizeof s);
218: log_debug("cmdq %p: %s (client %d)", cmdq, s,
219: cmdq->client != NULL ? cmdq->client->ibuf.fd : -1);
220:
1.4 nicm 221: cmdq->time = time(NULL);
222: cmdq->number++;
223:
1.10 nicm 224: flags = !!(cmdq->cmd->flags & CMD_CONTROL);
225: guard = cmdq_guard(cmdq, "begin", flags);
226:
1.1 nicm 227: retval = cmdq->cmd->entry->exec(cmdq->cmd, cmdq);
1.10 nicm 228:
1.6 nicm 229: if (guard) {
230: if (retval == CMD_RETURN_ERROR)
1.10 nicm 231: cmdq_guard(cmdq, "error", flags);
1.6 nicm 232: else
1.10 nicm 233: cmdq_guard(cmdq, "end", flags);
1.6 nicm 234: }
1.1 nicm 235:
236: if (retval == CMD_RETURN_ERROR)
237: break;
238: if (retval == CMD_RETURN_WAIT)
239: goto out;
240: if (retval == CMD_RETURN_STOP) {
241: cmdq_flush(cmdq);
242: goto empty;
243: }
244:
245: cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry);
246: }
247:
248: TAILQ_REMOVE(&cmdq->queue, cmdq->item, qentry);
249: cmd_list_free(cmdq->item->cmdlist);
250: free(cmdq->item);
251:
252: cmdq->item = next;
253: if (cmdq->item != NULL)
254: cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list);
255: } while (cmdq->item != NULL);
256:
257: empty:
1.11 nicm 258: if (cmdq->client_exit > 0)
1.1 nicm 259: cmdq->client->flags |= CLIENT_EXIT;
260: if (cmdq->emptyfn != NULL)
261: cmdq->emptyfn(cmdq); /* may free cmdq */
262: empty = 1;
263:
264: out:
265: notify_enable();
266: return (empty);
267: }
268:
269: /* Flush command queue. */
270: void
271: cmdq_flush(struct cmd_q *cmdq)
272: {
273: struct cmd_q_item *item, *item1;
274:
275: TAILQ_FOREACH_SAFE(item, &cmdq->queue, qentry, item1) {
276: TAILQ_REMOVE(&cmdq->queue, item, qentry);
277: cmd_list_free(item->cmdlist);
278: free(item);
279: }
280: cmdq->item = NULL;
281: }