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