external/bsd/tmux/dist/tmux.c

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