tmux.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 #include <sys/stat.h>
  21
  22 #include <errno.h>
  23 #include <event.h>
  24 #include <fcntl.h>
  25 #include <locale.h>
  26 #include <paths.h>
  27 #include <pwd.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31
  32 #include "tmux.h"
  33
  34 #ifdef DEBUG
  35 extern char     *malloc_options;
  36 #endif
  37
  38 struct options   global_options;        /* server options */
  39 struct options   global_s_options;      /* session options */
  40 struct options   global_w_options;      /* window options */
  41 struct environ   global_environ;
  42
  43 struct event_base *ev_base;
  44
  45 char            *cfg_file;
  46 char            *shell_cmd;
  47 int              debug_level;
  48 time_t           start_time;
  49 char             socket_path[MAXPATHLEN];
  50 int              login_shell;
  51 char            *environ_path;
  52
  53 __dead void      usage(void);
  54 char            *makesocketpath(const char *);
  55
  56 __dead void
  57 usage(void)
  58 {
  59         fprintf(stderr,
  60             "usage: %s [-2lquv] [-c shell-command] [-f file] [-L socket-name]\n"
  61             "            [-S socket-path] [command [flags]]\n",
  62             __progname);
  63         exit(1);
  64 }
  65
  66 void
  67 logfile(const char *name)
  68 {
  69         char    *path;
  70
  71         if (debug_level > 0) {
  72                 xasprintf(&path, "tmux-%s-%ld.log", name, (long) getpid());
  73                 log_open(debug_level, path);
  74                 free(path);
  75         }
  76 }
  77
  78 const char *
  79 getshell(void)
  80 {
  81         struct passwd   *pw;
  82         const char      *shell;
  83
  84         shell = getenv("SHELL");
  85         if (checkshell(shell))
  86                 return (shell);
  87
  88         pw = getpwuid(getuid());
  89         if (pw != NULL && checkshell(pw->pw_shell))
  90                 return (pw->pw_shell);
  91
  92         return (_PATH_BSHELL);
  93 }
  94
  95 int
  96 checkshell(const char *shell)
  97 {
  98         if (shell == NULL || *shell == '\0' || *shell != '/')
  99                 return (0);
 100         if (areshell(shell))
 101                 return (0);
 102         if (access(shell, X_OK) != 0)
 103                 return (0);
 104         return (1);
 105 }
 106
 107 int
 108 areshell(const char *shell)
 109 {
 110         const char      *progname, *ptr;
 111
 112         if ((ptr = strrchr(shell, '/')) != NULL)
 113                 ptr++;
 114         else
 115                 ptr = shell;
 116         progname = __progname;
 117         if (*progname == '-')
 118                 progname++;
 119         if (strcmp(ptr, progname) == 0)
 120                 return (1);
 121         return (0);
 122 }
 123
 124 char *
 125 makesocketpath(const char *label)
 126 {
 127         char            base[MAXPATHLEN], realbase[MAXPATHLEN], *path, *s;
 128         struct stat     sb;
 129         u_int           uid;
 130
 131         uid = getuid();
 132         if ((s = getenv("TMUX_TMPDIR")) != NULL && *s != '\0')
 133                 xsnprintf(base, sizeof base, "%s/", s);
 134         else if ((s = getenv("TMPDIR")) != NULL && *s != '\0')
 135                 xsnprintf(base, sizeof base, "%s/tmux-%u", s, uid);
 136         else
 137                 xsnprintf(base, sizeof base, "%s/tmux-%u", _PATH_TMP, uid);
 138
 139         if (mkdir(base, S_IRWXU) != 0 && errno != EEXIST)
 140                 return (NULL);
 141
 142         if (lstat(base, &sb) != 0)
 143                 return (NULL);
 144         if (!S_ISDIR(sb.st_mode)) {
 145                 errno = ENOTDIR;
 146                 return (NULL);
 147         }
 148         if (sb.st_uid != uid || (!S_ISDIR(sb.st_mode) &&
 149                 sb.st_mode & (S_IRWXG|S_IRWXO)) != 0) {
 150                 errno = EACCES;
 151                 return (NULL);
 152         }
 153
 154         if (realpath(base, realbase) == NULL)
 155                 strlcpy(realbase, base, sizeof realbase);
 156
 157         xasprintf(&path, "%s/%s", realbase, label);
 158         return (path);
 159 }
 160
 161 void
 162 setblocking(int fd, int state)
 163 {
 164         int mode;
 165
 166         if ((mode = fcntl(fd, F_GETFL)) != -1) {
 167                 if (!state)
 168                         mode |= O_NONBLOCK;
 169                 else
 170                         mode &= ~O_NONBLOCK;
 171                 fcntl(fd, F_SETFL, mode);
 172         }
 173 }
 174
 175 __dead void
 176 shell_exec(const char *shell, const char *shellcmd)
 177 {
 178         const char      *shellname, *ptr;
 179         char            *argv0;
 180
 181         ptr = strrchr(shell, '/');
 182         if (ptr != NULL && *(ptr + 1) != '\0')
 183                 shellname = ptr + 1;
 184         else
 185                 shellname = shell;
 186         if (login_shell)
 187                 xasprintf(&argv0, "-%s", shellname);
 188         else
 189                 xasprintf(&argv0, "%s", shellname);
 190         setenv("SHELL", shell, 1);
 191
 192         setblocking(STDIN_FILENO, 1);
 193         setblocking(STDOUT_FILENO, 1);
 194         setblocking(STDERR_FILENO, 1);
 195         closefrom(STDERR_FILENO + 1);
 196
 197         execl(shell, argv0, "-c", shellcmd, (char *) NULL);
 198         fatal("execl failed");
 199 }
 200
 201 int
 202 main(int argc, char **argv)
 203 {
 204         struct passwd   *pw;
 205         char            *s, *path, *label, **var, tmp[MAXPATHLEN];
 206         char             in[256];
 207         const char      *home;
 208         long long        pid;
 209         int              opt, flags, quiet, keys, session;
 210
 211 #ifdef DEBUG
 212         malloc_options = (char *) "AFGJPX";
 213 #endif
 214
 215         setlocale(LC_TIME, "");
 216
 217         quiet = flags = 0;
 218         label = path = NULL;
 219         login_shell = (**argv == '-');
 220         while ((opt = getopt(argc, argv, "2c:Cdf:lL:qS:uUv")) != -1) {
 221                 switch (opt) {
 222                 case '2':
 223                         flags |= CLIENT_256COLOURS;
 224                         break;
 225                 case 'c':
 226                         free(shell_cmd);
 227                         shell_cmd = xstrdup(optarg);
 228                         break;
 229                 case 'C':
 230                         if (flags & CLIENT_CONTROL)
 231                                 flags |= CLIENT_CONTROLCONTROL;
 232                         else
 233                                 flags |= CLIENT_CONTROL;
 234                         break;
 235                 case 'f':
 236                         free(cfg_file);
 237                         cfg_file = xstrdup(optarg);
 238                         break;
 239                 case 'l':
 240                         login_shell = 1;
 241                         break;
 242                 case 'L':
 243                         free(label);
 244                         label = xstrdup(optarg);
 245                         break;
 246                 case 'q':
 247                         quiet = 1;
 248                         break;
 249                 case 'S':
 250                         free(path);
 251                         path = xstrdup(optarg);
 252                         break;
 253                 case 'u':
 254                         flags |= CLIENT_UTF8;
 255                         break;
 256                 case 'v':
 257                         debug_level++;
 258                         break;
 259                 default:
 260                         usage();
 261                 }
 262         }
 263         argc -= optind;
 264         argv += optind;
 265
 266         if (shell_cmd != NULL && argc != 0)
 267                 usage();
 268
 269         if (!(flags & CLIENT_UTF8)) {
 270                 /*
 271                  * If the user has set whichever of LC_ALL, LC_CTYPE or LANG
 272                  * exist (in that order) to contain UTF-8, it is a safe
 273                  * assumption that either they are using a UTF-8 terminal, or
 274                  * if not they know that output from UTF-8-capable programs may
 275                  * be wrong.
 276                  */
 277                 if ((s = getenv("LC_ALL")) == NULL || *s == '\0') {
 278                         if ((s = getenv("LC_CTYPE")) == NULL || *s == '\0')
 279                                 s = getenv("LANG");
 280                 }
 281                 if (s != NULL && (strcasestr(s, "UTF-8") != NULL ||
 282                     strcasestr(s, "UTF8") != NULL))
 283                         flags |= CLIENT_UTF8;
 284         }
 285
 286         environ_init(&global_environ);
 287         for (var = environ; *var != NULL; var++)
 288                 environ_put(&global_environ, *var);
 289         if (getcwd(tmp, sizeof tmp) != NULL)
 290                 environ_set(&global_environ, "PWD", tmp);
 291
 292         options_init(&global_options, NULL);
 293         options_table_populate_tree(server_options_table, &global_options);
 294         options_set_number(&global_options, "quiet", quiet);
 295
 296         options_init(&global_s_options, NULL);
 297         options_table_populate_tree(session_options_table, &global_s_options);
 298         options_set_string(&global_s_options, "default-shell", "%s", getshell());
 299
 300         options_init(&global_w_options, NULL);
 301         options_table_populate_tree(window_options_table, &global_w_options);
 302
 303         /* Enable UTF-8 if the first client is on UTF-8 terminal. */
 304         if (flags & CLIENT_UTF8) {
 305                 options_set_number(&global_s_options, "status-utf8", 1);
 306                 options_set_number(&global_s_options, "mouse-utf8", 1);
 307                 options_set_number(&global_w_options, "utf8", 1);
 308         }
 309
 310         /* Override keys to vi if VISUAL or EDITOR are set. */
 311         if ((s = getenv("VISUAL")) != NULL || (s = getenv("EDITOR")) != NULL) {
 312                 if (strrchr(s, '/') != NULL)
 313                         s = strrchr(s, '/') + 1;
 314                 if (strstr(s, "vi") != NULL)
 315                         keys = MODEKEY_VI;
 316                 else
 317                         keys = MODEKEY_EMACS;
 318                 options_set_number(&global_s_options, "status-keys", keys);
 319                 options_set_number(&global_w_options, "mode-keys", keys);
 320         }
 321
 322         /* Locate the configuration file. */
 323         if (cfg_file == NULL) {
 324                 home = getenv("HOME");
 325                 if (home == NULL || *home == '\0') {
 326                         pw = getpwuid(getuid());
 327                         if (pw != NULL)
 328                                 home = pw->pw_dir;
 329                         else
 330                                 home = NULL;
 331                 }
 332                 if (home != NULL) {
 333                         xasprintf(&cfg_file, "%s/.tmux.conf", home);
 334                         if (access(cfg_file, R_OK) != 0 && errno == ENOENT) {
 335                                 free(cfg_file);
 336                                 cfg_file = NULL;
 337                         }
 338                 }
 339         }
 340
 341         /* Get path from environment. */
 342         s = getenv("TMUX");
 343         if (s != NULL && sscanf(s, "%255[^,],%lld,%d", in, &pid, &session) == 3)
 344                 environ_path = xstrdup(in);
 345
 346         /*
 347          * Figure out the socket path. If specified on the command-line with -S
 348          * or -L, use it, otherwise try $TMUX or assume -L default.
 349          */
 350         if (path == NULL) {
 351                 /* If no -L, use the environment. */
 352                 if (label == NULL) {
 353                         if (environ_path != NULL)
 354                                 path = xstrdup(environ_path);
 355                         else
 356                                 label = xstrdup("default");
 357                 }
 358
 359                 /* -L or default set. */
 360                 if (label != NULL) {
 361                         if ((path = makesocketpath(label)) == NULL) {
 362                                 fprintf(stderr, "can't create socket: %s\n",
 363                                         strerror(errno));
 364                                 exit(1);
 365                         }
 366                 }
 367         }
 368         free(label);
 369
 370         if (strlcpy(socket_path, path, sizeof socket_path) >= sizeof socket_path) {
 371                 fprintf(stderr, "socket path too long: %s\n", path);
 372                 exit(1);
 373         }
 374         free(path);
 375
 376         /* Set process title. */
 377         setproctitle("%s (%s)", __progname, socket_path);
 378
 379         /* Pass control to the client. */
 380         ev_base = event_init();
 381         exit(client_main(argc, argv, flags));
 382 }