cmd-new-session.c

   1 /* $OpenBSD$ */
   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 <pwd.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <termios.h>
  25 #include <unistd.h>
  26
  27 #include "tmux.h"
  28
  29 /*
  30  * Create a new session and attach to the current terminal unless -d is given.
  31  */
  32
  33 int     cmd_new_session_check(struct args *);
  34 int     cmd_new_session_exec(struct cmd *, struct cmd_ctx *);
  35
  36 const struct cmd_entry cmd_new_session_entry = {
  37         "new-session", "new",
  38         "dn:s:t:x:y:", 0, 1,
  39         "[-d] [-n window-name] [-s session-name] [-t target-session] "
  40         "[-x width] [-y height] [command]",
  41         CMD_STARTSERVER|CMD_CANTNEST|CMD_SENDENVIRON,
  42         NULL,
  43         cmd_new_session_check,
  44         cmd_new_session_exec
  45 };
  46
  47 int
  48 cmd_new_session_check(struct args *args)
  49 {
  50         if (args_has(args, 't') && (args->argc != 0 || args_has(args, 'n')))
  51                 return (-1);
  52         return (0);
  53 }
  54
  55 int
  56 cmd_new_session_exec(struct cmd *self, struct cmd_ctx *ctx)
  57 {
  58         struct args             *args = self->args;
  59         struct session          *s, *old_s, *groupwith;
  60         struct window           *w;
  61         struct window_pane      *wp;
  62         struct environ           env;
  63         struct termios           tio, *tiop;
  64         struct passwd           *pw;
  65         const char              *newname, *target, *update, *cwd, *errstr;
  66         char                    *overrides, *cmd, *cause;
  67         int                      detached, idx;
  68         u_int                    sx, sy, i;
  69
  70         newname = args_get(args, 's');
  71         if (newname != NULL) {
  72                 if (!session_check_name(newname)) {
  73                         ctx->error(ctx, "bad session name: %s", newname);
  74                         return (-1);
  75                 }
  76                 if (session_find(newname) != NULL) {
  77                         ctx->error(ctx, "duplicate session: %s", newname);
  78                         return (-1);
  79                 }
  80         }
  81
  82         target = args_get(args, 't');
  83         if (target != NULL) {
  84                 groupwith = cmd_find_session(ctx, target, 0);
  85                 if (groupwith == NULL)
  86                         return (-1);
  87         } else
  88                 groupwith = NULL;
  89
  90         /*
  91          * There are three cases:
  92          *
  93          * 1. If cmdclient is non-NULL, new-session has been called from the
  94          *    command-line - cmdclient is to become a new attached, interactive
  95          *    client. Unless -d is given, the terminal must be opened and then
  96          *    the client sent MSG_READY.
  97          *
  98          * 2. If cmdclient is NULL, new-session has been called from an
  99          *    existing client (such as a key binding).
 100          *
 101          * 3. Both are NULL, the command was in the configuration file. Treat
 102          *    this as if -d was given even if it was not.
 103          *
 104          * In all cases, a new additional session needs to be created and
 105          * (unless -d) set as the current session for the client.
 106          */
 107
 108         /* Set -d if no client. */
 109         detached = args_has(args, 'd');
 110         if (ctx->cmdclient == NULL && ctx->curclient == NULL)
 111                 detached = 1;
 112
 113         /*
 114          * Save the termios settings, part of which is used for new windows in
 115          * this session.
 116          *
 117          * This is read again with tcgetattr() rather than using tty.tio as if
 118          * detached, tty_open won't be called. Because of this, it must be done
 119          * before opening the terminal as that calls tcsetattr() to prepare for
 120          * tmux taking over.
 121          */
 122         if (ctx->cmdclient != NULL && ctx->cmdclient->tty.fd != -1) {
 123                 if (tcgetattr(ctx->cmdclient->tty.fd, &tio) != 0)
 124                         fatal("tcgetattr failed");
 125                 tiop = &tio;
 126         } else
 127                 tiop = NULL;
 128
 129         /* Open the terminal if necessary. */
 130         if (!detached && ctx->cmdclient != NULL) {
 131                 if (!(ctx->cmdclient->flags & CLIENT_TERMINAL)) {
 132                         ctx->error(ctx, "not a terminal");
 133                         return (-1);
 134                 }
 135
 136                 overrides =
 137                     options_get_string(&global_s_options, "terminal-overrides");
 138                 if (tty_open(&ctx->cmdclient->tty, overrides, &cause) != 0) {
 139                         ctx->error(ctx, "open terminal failed: %s", cause);
 140                         xfree(cause);
 141                         return (-1);
 142                 }
 143         }
 144
 145         /* Get the new session working directory. */
 146         if (ctx->cmdclient != NULL && ctx->cmdclient->cwd != NULL)
 147                 cwd = ctx->cmdclient->cwd;
 148         else {
 149                 pw = getpwuid(getuid());
 150                 if (pw->pw_dir != NULL && *pw->pw_dir != '\0')
 151                         cwd = pw->pw_dir;
 152                 else
 153                         cwd = "/";
 154         }
 155
 156         /* Find new session size. */
 157         if (ctx->cmdclient != NULL) {
 158                 sx = ctx->cmdclient->tty.sx;
 159                 sy = ctx->cmdclient->tty.sy;
 160         } else if (ctx->curclient != NULL) {
 161                 sx = ctx->curclient->tty.sx;
 162                 sy = ctx->curclient->tty.sy;
 163         } else {
 164                 sx = 80;
 165                 sy = 24;
 166         }
 167         if (detached) {
 168                 if (args_has(args, 'x')) {
 169                         sx = strtonum(
 170                             args_get(args, 'x'), 1, USHRT_MAX, &errstr);
 171                         if (errstr != NULL) {
 172                                 ctx->error(ctx, "width %s", errstr);
 173                                 return (-1);
 174                         }
 175                 }
 176                 if (args_has(args, 'y')) {
 177                         sy = strtonum(
 178                             args_get(args, 'y'), 1, USHRT_MAX, &errstr);
 179                         if (errstr != NULL) {
 180                                 ctx->error(ctx, "height %s", errstr);
 181                                 return (-1);
 182                         }
 183                 }
 184         }
 185         if (sy > 0 && options_get_number(&global_s_options, "status"))
 186                 sy--;
 187         if (sx == 0)
 188                 sx = 1;
 189         if (sy == 0)
 190                 sy = 1;
 191
 192         /* Figure out the command for the new window. */
 193         if (target != NULL)
 194                 cmd = NULL;
 195         else if (args->argc != 0)
 196                 cmd = args->argv[0];
 197         else
 198                 cmd = options_get_string(&global_s_options, "default-command");
 199
 200         /* Construct the environment. */
 201         environ_init(&env);
 202         update = options_get_string(&global_s_options, "update-environment");
 203         if (ctx->cmdclient != NULL)
 204                 environ_update(update, &ctx->cmdclient->environ, &env);
 205
 206         /* Create the new session. */
 207         idx = -1 - options_get_number(&global_s_options, "base-index");
 208         s = session_create(newname, cmd, cwd, &env, tiop, idx, sx, sy, &cause);
 209         if (s == NULL) {
 210                 ctx->error(ctx, "create session failed: %s", cause);
 211                 xfree(cause);
 212                 return (-1);
 213         }
 214         environ_free(&env);
 215
 216         /* Set the initial window name if one given. */
 217         if (cmd != NULL && args_has(args, 'n')) {
 218                 w = s->curw->window;
 219
 220                 window_set_name(w, args_get(args, 'n'));
 221
 222                 options_set_number(&w->options, "automatic-rename", 0);
 223         }
 224
 225         /*
 226          * If a target session is given, this is to be part of a session group,
 227          * so add it to the group and synchronize.
 228          */
 229         if (groupwith != NULL) {
 230                 session_group_add(groupwith, s);
 231                 session_group_synchronize_to(s);
 232                 session_select(s, RB_ROOT(&s->windows)->idx);
 233         }
 234
 235         /*
 236          * Set the client to the new session. If a command client exists, it is
 237          * taking this session and needs to get MSG_READY and stay around.
 238          */
 239         if (!detached) {
 240                 if (ctx->cmdclient != NULL) {
 241                         server_write_client(ctx->cmdclient, MSG_READY, NULL, 0);
 242
 243                         old_s = ctx->cmdclient->session;
 244                         if (old_s != NULL)
 245                                 ctx->cmdclient->last_session = old_s;
 246                         ctx->cmdclient->session = s;
 247                         notify_attached_session_changed(ctx->cmdclient);
 248                         session_update_activity(s);
 249                         server_redraw_client(ctx->cmdclient);
 250                 } else {
 251                         old_s = ctx->curclient->session;
 252                         if (old_s != NULL)
 253                                 ctx->curclient->last_session = old_s;
 254                         ctx->curclient->session = s;
 255                         notify_attached_session_changed(ctx->curclient);
 256                         session_update_activity(s);
 257                         server_redraw_client(ctx->curclient);
 258                 }
 259         }
 260         recalculate_sizes();
 261         server_update_socket();
 262
 263         /*
 264          * If there are still configuration file errors to display, put the new
 265          * session's current window into more mode and display them now.
 266          */
 267         if (cfg_finished && !ARRAY_EMPTY(&cfg_causes)) {
 268                 wp = s->curw->window->active;
 269                 window_pane_set_mode(wp, &window_copy_mode);
 270                 window_copy_init_for_output(wp);
 271                 for (i = 0; i < ARRAY_LENGTH(&cfg_causes); i++) {
 272                         cause = ARRAY_ITEM(&cfg_causes, i);
 273                         window_copy_add(wp, "%s", cause);
 274                         xfree(cause);
 275                 }
 276                 ARRAY_FREE(&cfg_causes);
 277         }
 278
 279         return (!detached);     /* 1 means don't tell command client to exit */
 280 }