[BACK]Return to cmd.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / tmux

Annotation of src/usr.bin/tmux/cmd.c, Revision 1.104

1.104   ! nicm        1: /* $OpenBSD: cmd.c,v 1.103 2015/04/25 18:33:59 nicm Exp $ */
1.1       nicm        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: #include <sys/time.h>
                     21:
1.5       nicm       22: #include <fnmatch.h>
                     23: #include <paths.h>
1.61      nicm       24: #include <pwd.h>
1.1       nicm       25: #include <stdlib.h>
                     26: #include <string.h>
                     27: #include <unistd.h>
                     28:
                     29: #include "tmux.h"
                     30:
                     31: const struct cmd_entry *cmd_table[] = {
                     32:        &cmd_attach_session_entry,
                     33:        &cmd_bind_key_entry,
                     34:        &cmd_break_pane_entry,
1.34      nicm       35:        &cmd_capture_pane_entry,
1.42      nicm       36:        &cmd_choose_buffer_entry,
1.15      nicm       37:        &cmd_choose_client_entry,
1.1       nicm       38:        &cmd_choose_session_entry,
1.67      nicm       39:        &cmd_choose_tree_entry,
1.1       nicm       40:        &cmd_choose_window_entry,
                     41:        &cmd_clear_history_entry,
                     42:        &cmd_clock_mode_entry,
                     43:        &cmd_command_prompt_entry,
                     44:        &cmd_confirm_before_entry,
                     45:        &cmd_copy_mode_entry,
                     46:        &cmd_delete_buffer_entry,
                     47:        &cmd_detach_client_entry,
1.7       nicm       48:        &cmd_display_message_entry,
1.16      nicm       49:        &cmd_display_panes_entry,
1.1       nicm       50:        &cmd_find_window_entry,
                     51:        &cmd_has_session_entry,
1.4       nicm       52:        &cmd_if_shell_entry,
1.37      nicm       53:        &cmd_join_pane_entry,
1.1       nicm       54:        &cmd_kill_pane_entry,
                     55:        &cmd_kill_server_entry,
                     56:        &cmd_kill_session_entry,
                     57:        &cmd_kill_window_entry,
1.45      nicm       58:        &cmd_last_pane_entry,
1.1       nicm       59:        &cmd_last_window_entry,
                     60:        &cmd_link_window_entry,
                     61:        &cmd_list_buffers_entry,
                     62:        &cmd_list_clients_entry,
                     63:        &cmd_list_commands_entry,
                     64:        &cmd_list_keys_entry,
1.23      nicm       65:        &cmd_list_panes_entry,
1.1       nicm       66:        &cmd_list_sessions_entry,
                     67:        &cmd_list_windows_entry,
                     68:        &cmd_load_buffer_entry,
1.19      nicm       69:        &cmd_lock_client_entry,
1.1       nicm       70:        &cmd_lock_server_entry,
1.19      nicm       71:        &cmd_lock_session_entry,
1.63      nicm       72:        &cmd_move_pane_entry,
1.1       nicm       73:        &cmd_move_window_entry,
                     74:        &cmd_new_session_entry,
                     75:        &cmd_new_window_entry,
                     76:        &cmd_next_layout_entry,
                     77:        &cmd_next_window_entry,
                     78:        &cmd_paste_buffer_entry,
1.24      nicm       79:        &cmd_pipe_pane_entry,
1.1       nicm       80:        &cmd_previous_layout_entry,
                     81:        &cmd_previous_window_entry,
                     82:        &cmd_refresh_client_entry,
                     83:        &cmd_rename_session_entry,
                     84:        &cmd_rename_window_entry,
                     85:        &cmd_resize_pane_entry,
1.56      nicm       86:        &cmd_respawn_pane_entry,
1.1       nicm       87:        &cmd_respawn_window_entry,
                     88:        &cmd_rotate_window_entry,
1.17      nicm       89:        &cmd_run_shell_entry,
1.1       nicm       90:        &cmd_save_buffer_entry,
                     91:        &cmd_select_layout_entry,
                     92:        &cmd_select_pane_entry,
                     93:        &cmd_select_window_entry,
                     94:        &cmd_send_keys_entry,
                     95:        &cmd_send_prefix_entry,
                     96:        &cmd_server_info_entry,
                     97:        &cmd_set_buffer_entry,
1.13      nicm       98:        &cmd_set_environment_entry,
1.1       nicm       99:        &cmd_set_option_entry,
                    100:        &cmd_set_window_option_entry,
                    101:        &cmd_show_buffer_entry,
1.13      nicm      102:        &cmd_show_environment_entry,
1.32      nicm      103:        &cmd_show_messages_entry,
1.1       nicm      104:        &cmd_show_options_entry,
                    105:        &cmd_show_window_options_entry,
                    106:        &cmd_source_file_entry,
                    107:        &cmd_split_window_entry,
                    108:        &cmd_start_server_entry,
                    109:        &cmd_suspend_client_entry,
                    110:        &cmd_swap_pane_entry,
                    111:        &cmd_swap_window_entry,
                    112:        &cmd_switch_client_entry,
                    113:        &cmd_unbind_key_entry,
                    114:        &cmd_unlink_window_entry,
1.82      nicm      115:        &cmd_wait_for_entry,
1.1       nicm      116:        NULL
                    117: };
                    118:
1.10      nicm      119: int
                    120: cmd_pack_argv(int argc, char **argv, char *buf, size_t len)
                    121: {
                    122:        size_t  arglen;
                    123:        int     i;
1.91      nicm      124:
                    125:        if (argc == 0)
                    126:                return (0);
1.10      nicm      127:
                    128:        *buf = '\0';
                    129:        for (i = 0; i < argc; i++) {
                    130:                if (strlcpy(buf, argv[i], len) >= len)
                    131:                        return (-1);
                    132:                arglen = strlen(argv[i]) + 1;
                    133:                buf += arglen;
                    134:                len -= arglen;
                    135:        }
                    136:
                    137:        return (0);
                    138: }
                    139:
                    140: int
                    141: cmd_unpack_argv(char *buf, size_t len, int argc, char ***argv)
                    142: {
                    143:        int     i;
                    144:        size_t  arglen;
                    145:
                    146:        if (argc == 0)
                    147:                return (0);
                    148:        *argv = xcalloc(argc, sizeof **argv);
                    149:
                    150:        buf[len - 1] = '\0';
                    151:        for (i = 0; i < argc; i++) {
                    152:                if (len == 0) {
                    153:                        cmd_free_argv(argc, *argv);
                    154:                        return (-1);
                    155:                }
                    156:
                    157:                arglen = strlen(buf) + 1;
                    158:                (*argv)[i] = xstrdup(buf);
                    159:                buf += arglen;
                    160:                len -= arglen;
                    161:        }
                    162:
                    163:        return (0);
1.46      nicm      164: }
                    165:
                    166: char **
1.93      nicm      167: cmd_copy_argv(int argc, char **argv)
1.46      nicm      168: {
                    169:        char    **new_argv;
                    170:        int       i;
                    171:
                    172:        if (argc == 0)
                    173:                return (NULL);
1.94      nicm      174:        new_argv = xcalloc(argc + 1, sizeof *new_argv);
1.46      nicm      175:        for (i = 0; i < argc; i++) {
                    176:                if (argv[i] != NULL)
                    177:                        new_argv[i] = xstrdup(argv[i]);
                    178:        }
                    179:        return (new_argv);
1.10      nicm      180: }
                    181:
                    182: void
                    183: cmd_free_argv(int argc, char **argv)
                    184: {
                    185:        int     i;
                    186:
                    187:        if (argc == 0)
1.35      nicm      188:                return;
1.68      nicm      189:        for (i = 0; i < argc; i++)
                    190:                free(argv[i]);
                    191:        free(argv);
1.94      nicm      192: }
                    193:
                    194: char *
                    195: cmd_stringify_argv(int argc, char **argv)
                    196: {
                    197:        char    *buf;
                    198:        int      i;
                    199:        size_t   len;
                    200:
                    201:        if (argc == 0)
                    202:                return (xstrdup(""));
                    203:
                    204:        len = 0;
                    205:        buf = NULL;
                    206:
                    207:        for (i = 0; i < argc; i++) {
                    208:                len += strlen(argv[i]) + 1;
1.98      nicm      209:                buf = xrealloc(buf, len);
1.94      nicm      210:
                    211:                if (i == 0)
                    212:                        *buf = '\0';
                    213:                else
                    214:                        strlcat(buf, " ", len);
                    215:                strlcat(buf, argv[i], len);
                    216:        }
                    217:        return (buf);
1.10      nicm      218: }
                    219:
1.1       nicm      220: struct cmd *
1.80      nicm      221: cmd_parse(int argc, char **argv, const char *file, u_int line, char **cause)
1.1       nicm      222: {
                    223:        const struct cmd_entry **entryp, *entry;
1.27      deraadt   224:        struct cmd              *cmd;
1.49      nicm      225:        struct args             *args;
1.1       nicm      226:        char                     s[BUFSIZ];
1.49      nicm      227:        int                      ambiguous = 0;
1.1       nicm      228:
                    229:        *cause = NULL;
1.2       nicm      230:        if (argc == 0) {
                    231:                xasprintf(cause, "no command");
1.1       nicm      232:                return (NULL);
1.2       nicm      233:        }
1.1       nicm      234:
                    235:        entry = NULL;
                    236:        for (entryp = cmd_table; *entryp != NULL; entryp++) {
                    237:                if ((*entryp)->alias != NULL &&
                    238:                    strcmp((*entryp)->alias, argv[0]) == 0) {
1.3       nicm      239:                        ambiguous = 0;
1.1       nicm      240:                        entry = *entryp;
                    241:                        break;
                    242:                }
                    243:
                    244:                if (strncmp((*entryp)->name, argv[0], strlen(argv[0])) != 0)
                    245:                        continue;
                    246:                if (entry != NULL)
1.3       nicm      247:                        ambiguous = 1;
1.1       nicm      248:                entry = *entryp;
                    249:
                    250:                /* Bail now if an exact match. */
                    251:                if (strcmp(entry->name, argv[0]) == 0)
                    252:                        break;
                    253:        }
1.3       nicm      254:        if (ambiguous)
                    255:                goto ambiguous;
1.1       nicm      256:        if (entry == NULL) {
                    257:                xasprintf(cause, "unknown command: %s", argv[0]);
                    258:                return (NULL);
                    259:        }
                    260:
1.49      nicm      261:        args = args_parse(entry->args_template, argc, argv);
                    262:        if (args == NULL)
                    263:                goto usage;
                    264:        if (entry->args_lower != -1 && args->argc < entry->args_lower)
                    265:                goto usage;
                    266:        if (entry->args_upper != -1 && args->argc > entry->args_upper)
                    267:                goto usage;
1.1       nicm      268:
1.80      nicm      269:        cmd = xcalloc(1, sizeof *cmd);
1.1       nicm      270:        cmd->entry = entry;
1.49      nicm      271:        cmd->args = args;
1.80      nicm      272:
                    273:        if (file != NULL)
                    274:                cmd->file = xstrdup(file);
                    275:        cmd->line = line;
                    276:
1.1       nicm      277:        return (cmd);
                    278:
                    279: ambiguous:
                    280:        *s = '\0';
                    281:        for (entryp = cmd_table; *entryp != NULL; entryp++) {
                    282:                if (strncmp((*entryp)->name, argv[0], strlen(argv[0])) != 0)
                    283:                        continue;
                    284:                if (strlcat(s, (*entryp)->name, sizeof s) >= sizeof s)
                    285:                        break;
                    286:                if (strlcat(s, ", ", sizeof s) >= sizeof s)
                    287:                        break;
                    288:        }
                    289:        s[strlen(s) - 2] = '\0';
                    290:        xasprintf(cause, "ambiguous command: %s, could be: %s", argv[0], s);
                    291:        return (NULL);
                    292:
                    293: usage:
1.49      nicm      294:        if (args != NULL)
                    295:                args_free(args);
1.1       nicm      296:        xasprintf(cause, "usage: %s %s", entry->name, entry->usage);
                    297:        return (NULL);
                    298: }
                    299:
                    300: size_t
                    301: cmd_print(struct cmd *cmd, char *buf, size_t len)
                    302: {
1.49      nicm      303:        size_t  off, used;
                    304:
                    305:        off = xsnprintf(buf, len, "%s ", cmd->entry->name);
1.85      nicm      306:        if (off + 1 < len) {
                    307:                used = args_print(cmd->args, buf + off, len - off - 1);
1.49      nicm      308:                if (used == 0)
1.64      nicm      309:                        off--;
                    310:                else
1.49      nicm      311:                        off += used;
1.64      nicm      312:                buf[off] = '\0';
1.49      nicm      313:        }
                    314:        return (off);
1.1       nicm      315: }
                    316:
1.99      nicm      317: /* Adjust current mouse position for a pane. */
                    318: int
                    319: cmd_mouse_at(struct window_pane *wp, struct mouse_event *m, u_int *xp,
                    320:     u_int *yp, int last)
                    321: {
                    322:        u_int   x, y;
                    323:
                    324:        if (last) {
                    325:                x = m->lx;
                    326:                y = m->ly;
                    327:        } else {
                    328:                x = m->x;
                    329:                y = m->y;
                    330:        }
                    331:
                    332:        if (m->statusat == 0 && y > 0)
                    333:                y--;
                    334:        else if (m->statusat > 0 && y >= (u_int)m->statusat)
                    335:                y = m->statusat - 1;
                    336:
                    337:        if (x < wp->xoff || x >= wp->xoff + wp->sx)
                    338:                return (-1);
                    339:        if (y < wp->yoff || y >= wp->yoff + wp->sy)
                    340:                return (-1);
                    341:
                    342:        *xp = x - wp->xoff;
                    343:        *yp = y - wp->yoff;
                    344:        return (0);
                    345: }
                    346:
                    347: /* Get current mouse window if any. */
                    348: struct winlink *
                    349: cmd_mouse_window(struct mouse_event *m, struct session **sp)
                    350: {
                    351:        struct session  *s;
                    352:        struct window   *w;
                    353:
                    354:        if (!m->valid || m->s == -1 || m->w == -1)
                    355:                return (NULL);
                    356:        if ((s = session_find_by_id(m->s)) == NULL)
                    357:                return (NULL);
                    358:        if ((w = window_find_by_id(m->w)) == NULL)
                    359:                return (NULL);
                    360:
                    361:        if (sp != NULL)
                    362:                *sp = s;
                    363:        return (winlink_find_by_window(&s->windows, w));
                    364: }
                    365:
                    366: /* Get current mouse pane if any. */
                    367: struct window_pane *
1.104   ! nicm      368: cmd_mouse_pane(struct mouse_event *m, struct session **sp,
        !           369:     struct winlink **wlp)
1.99      nicm      370: {
                    371:        struct winlink          *wl;
                    372:        struct window_pane      *wp;
                    373:
                    374:        if ((wl = cmd_mouse_window(m, sp)) == NULL)
                    375:                return (NULL);
                    376:        if ((wp = window_pane_find_by_id(m->wp)) == NULL)
                    377:                return (NULL);
                    378:        if (!window_has_pane(wl->window, wp))
                    379:                return (NULL);
                    380:
                    381:        if (wlp != NULL)
                    382:                *wlp = wl;
1.43      nicm      383:        return (wp);
1.15      nicm      384: }
                    385:
                    386: /* Replace the first %% or %idx in template by s. */
                    387: char *
1.75      nicm      388: cmd_template_replace(const char *template, const char *s, int idx)
1.15      nicm      389: {
1.75      nicm      390:        char             ch, *buf;
                    391:        const char      *ptr;
1.84      nicm      392:        int              replaced;
                    393:        size_t           len;
1.15      nicm      394:
1.76      nicm      395:        if (strchr(template, '%') == NULL)
1.15      nicm      396:                return (xstrdup(template));
                    397:
                    398:        buf = xmalloc(1);
                    399:        *buf = '\0';
                    400:        len = 0;
                    401:        replaced = 0;
                    402:
                    403:        ptr = template;
                    404:        while (*ptr != '\0') {
                    405:                switch (ch = *ptr++) {
                    406:                case '%':
                    407:                        if (*ptr < '1' || *ptr > '9' || *ptr - '0' != idx) {
                    408:                                if (*ptr != '%' || replaced)
                    409:                                        break;
                    410:                                replaced = 1;
                    411:                        }
                    412:                        ptr++;
                    413:
                    414:                        len += strlen(s);
1.98      nicm      415:                        buf = xrealloc(buf, len + 1);
1.15      nicm      416:                        strlcat(buf, s, len + 1);
                    417:                        continue;
                    418:                }
1.98      nicm      419:                buf = xrealloc(buf, len + 2);
1.15      nicm      420:                buf[len++] = ch;
                    421:                buf[len] = '\0';
                    422:        }
                    423:
                    424:        return (buf);
1.1       nicm      425: }