1 /* $OpenBSD: cmd-queue.c,v 1.22 2015/02/12 09:56:19 nicm Exp $ */ 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> 23 #include <time.h> 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; 38 cmdq->client_exit = -1; 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 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 error from command. */ 90 void 91 cmdq_error(struct cmd_q *cmdq, const char *fmt, ...) 92 { 93 struct client *c = cmdq->client; 94 struct cmd *cmd = cmdq->cmd; 95 va_list ap; 96 char *msg; 97 size_t msglen; 98 99 va_start(ap, fmt); 100 msglen = xvasprintf(&msg, fmt, ap); 101 va_end(ap); 102 103 if (c == NULL) 104 cfg_add_cause("%s:%u: %s", cmd->file, cmd->line, msg); 105 else if (c->session == NULL || (c->flags & CLIENT_CONTROL)) { 106 evbuffer_add(c->stderr_data, msg, msglen); 107 evbuffer_add(c->stderr_data, "\n", 1); 108 109 server_push_stderr(c); 110 c->retval = 1; 111 } else { 112 *msg = toupper((u_char) *msg); 113 status_message_set(c, "%s", msg); 114 } 115 116 free(msg); 117 } 118 119 /* Print a guard line. */ 120 void 121 cmdq_guard(struct cmd_q *cmdq, const char *guard, int flags) 122 { 123 struct client *c = cmdq->client; 124 125 if (c == NULL || !(c->flags & CLIENT_CONTROL)) 126 return; 127 128 evbuffer_add_printf(c->stdout_data, "%%%s %ld %u %d\n", guard, 129 (long) cmdq->time, cmdq->number, flags); 130 server_push_stdout(c); 131 } 132 133 /* Add command list to queue and begin processing if needed. */ 134 void 135 cmdq_run(struct cmd_q *cmdq, struct cmd_list *cmdlist) 136 { 137 cmdq_append(cmdq, cmdlist); 138 139 if (cmdq->item == NULL) { 140 cmdq->cmd = NULL; 141 cmdq_continue(cmdq); 142 } 143 } 144 145 /* Add command list to queue. */ 146 void 147 cmdq_append(struct cmd_q *cmdq, struct cmd_list *cmdlist) 148 { 149 struct cmd_q_item *item; 150 151 item = xcalloc(1, sizeof *item); 152 item->cmdlist = cmdlist; 153 TAILQ_INSERT_TAIL(&cmdq->queue, item, qentry); 154 cmdlist->references++; 155 } 156 157 /* Continue processing command queue. Returns 1 if finishes empty. */ 158 int 159 cmdq_continue(struct cmd_q *cmdq) 160 { 161 struct cmd_q_item *next; 162 enum cmd_retval retval; 163 int empty, flags; 164 char s[1024]; 165 166 cmdq->references++; 167 notify_disable(); 168 169 empty = TAILQ_EMPTY(&cmdq->queue); 170 if (empty) 171 goto empty; 172 173 if (cmdq->item == NULL) { 174 cmdq->item = TAILQ_FIRST(&cmdq->queue); 175 cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list); 176 } else 177 cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry); 178 179 do { 180 while (cmdq->cmd != NULL) { 181 cmd_print(cmdq->cmd, s, sizeof s); 182 log_debug("cmdq %p: %s (client %d)", cmdq, s, 183 cmdq->client != NULL ? cmdq->client->ibuf.fd : -1); 184 185 cmdq->time = time(NULL); 186 cmdq->number++; 187 188 flags = !!(cmdq->cmd->flags & CMD_CONTROL); 189 cmdq_guard(cmdq, "begin", flags); 190 191 retval = cmdq->cmd->entry->exec(cmdq->cmd, cmdq); 192 193 if (retval == CMD_RETURN_ERROR) 194 cmdq_guard(cmdq, "error", flags); 195 else 196 cmdq_guard(cmdq, "end", flags); 197 198 if (retval == CMD_RETURN_ERROR) 199 break; 200 if (retval == CMD_RETURN_WAIT) 201 goto out; 202 if (retval == CMD_RETURN_STOP) { 203 cmdq_flush(cmdq); 204 goto empty; 205 } 206 207 cmdq->cmd = TAILQ_NEXT(cmdq->cmd, qentry); 208 } 209 next = TAILQ_NEXT(cmdq->item, qentry); 210 211 TAILQ_REMOVE(&cmdq->queue, cmdq->item, qentry); 212 cmd_list_free(cmdq->item->cmdlist); 213 free(cmdq->item); 214 215 cmdq->item = next; 216 if (cmdq->item != NULL) 217 cmdq->cmd = TAILQ_FIRST(&cmdq->item->cmdlist->list); 218 } while (cmdq->item != NULL); 219 220 empty: 221 if (cmdq->client_exit > 0) 222 cmdq->client->flags |= CLIENT_EXIT; 223 if (cmdq->emptyfn != NULL) 224 cmdq->emptyfn(cmdq); 225 empty = 1; 226 227 out: 228 notify_enable(); 229 cmdq_free(cmdq); 230 231 return (empty); 232 } 233 234 /* Flush command queue. */ 235 void 236 cmdq_flush(struct cmd_q *cmdq) 237 { 238 struct cmd_q_item *item, *item1; 239 240 TAILQ_FOREACH_SAFE(item, &cmdq->queue, qentry, item1) { 241 TAILQ_REMOVE(&cmdq->queue, item, qentry); 242 cmd_list_free(item->cmdlist); 243 free(item); 244 } 245 cmdq->item = NULL; 246 } 247