abduco.c

   1 /*
   2  * Copyright (c) 2013-2014 Marc André Tanner <mat at brain-dump.org>
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16 #define _GNU_SOURCE
  17 #include <errno.h>
  18 #include <fcntl.h>
  19 #include <stdio.h>
  20 #include <stdarg.h>
  21 #include <stdlib.h>
  22 #include <stdbool.h>
  23 #include <stddef.h>
  24 #include <signal.h>
  25 #include <poll.h>
  26 #include <libgen.h>
  27 #include <string.h>
  28 #include <limits.h>
  29 #include <dirent.h>
  30 #include <termios.h>
  31 #include <time.h>
  32 #include <unistd.h>
  33 #include <sys/stat.h>
  34 #include <sys/ioctl.h>
  35 #include <sys/types.h>
  36 #include <sys/wait.h>
  37 #include <sys/socket.h>
  38 #include <sys/un.h>
  39 #if defined(__linux__) || defined(__CYGWIN__)
  40 # include <pty.h>
  41 #elif defined(__FreeBSD__)
  42 # include <libutil.h>
  43 #elif defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__)
  44 # include <util.h>
  45 #endif
  46
  47 #if defined CTRL && defined _AIX
  48   #undef CTRL
  49 #endif
  50 #ifndef CTRL
  51   #define CTRL(k)   ((k) & 0x1F)
  52 #endif
  53
  54 #include "config.h"
  55
  56 #ifdef _AIX
  57 # include "forkpty-aix.c"
  58 #endif
  59
  60 #define countof(arr) (sizeof(arr) / sizeof((arr)[0]))
  61
  62 enum PacketType {
  63         MSG_CONTENT = 0,
  64         MSG_ATTACH  = 1,
  65         MSG_DETACH  = 2,
  66         MSG_RESIZE  = 3,
  67         MSG_REDRAW  = 4,
  68         MSG_EXIT    = 5,
  69 };
  70
  71 typedef struct {
  72         unsigned int type;
  73         size_t len;
  74         union {
  75                 char msg[BUFSIZ];
  76                 struct winsize ws;
  77                 int i;
  78                 bool b;
  79         } u;
  80 } Packet;
  81
  82 typedef struct Client Client;
  83 struct Client {
  84         int socket;
  85         enum {
  86                 STATE_CONNECTED,
  87                 STATE_ATTACHED,
  88                 STATE_DETACHED,
  89                 STATE_DISCONNECTED,
  90         } state;
  91         bool need_resize;
  92         bool readonly;
  93         Client *next;
  94 };
  95
  96 typedef struct {
  97         Client *clients;
  98         int socket;
  99         Packet pty_output;
 100         int pty;
 101         int exit_status;
 102         struct termios term;
 103         pid_t pid;
 104         volatile sig_atomic_t running;
 105         const char *name;
 106         const char *session_name;
 107 } Server;
 108
 109 static Server server = { .running = true, .exit_status = -1 };
 110 static Client client;
 111 static struct termios orig_term, cur_term;
 112 bool has_term;
 113
 114 static struct sockaddr_un sockaddr = {
 115         .sun_family = AF_UNIX,
 116 };
 117
 118 static int create_socket(const char *name);
 119 static void die(const char *s);
 120 static void info(const char *str, ...);
 121
 122 #include "debug.c"
 123
 124 static inline size_t packet_header_size() {
 125         return offsetof(Packet, u);
 126 }
 127
 128 static size_t packet_size(Packet *pkt) {
 129         return packet_header_size() + pkt->len;
 130 }
 131
 132 static ssize_t write_all(int fd, const char *buf, size_t len) {
 133         debug("write_all(%d)\n", len);
 134         ssize_t ret = len;
 135         while (len > 0) {
 136                 ssize_t res = write(fd, buf, len);
 137                 if (res < 0) {
 138                         if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
 139                                 continue;
 140                         return -1;
 141                 }
 142                 if (res == 0)
 143                         return ret - len;
 144                 buf += res;
 145                 len -= res;
 146         }
 147         return ret;
 148 }
 149
 150 static ssize_t read_all(int fd, char *buf, size_t len) {
 151         debug("read_all(%d)\n", len);
 152         ssize_t ret = len;
 153         while (len > 0) {
 154                 ssize_t res = read(fd, buf, len);
 155                 if (res < 0) {
 156                         if (errno == EWOULDBLOCK)
 157                                 return ret - len;
 158                         if (errno == EAGAIN || errno == EINTR)
 159                                 continue;
 160                         return -1;
 161                 }
 162                 if (res == 0)
 163                         return ret - len;
 164                 buf += res;
 165                 len -= res;
 166         }
 167         return ret;
 168 }
 169
 170 static bool send_packet(int socket, Packet *pkt) {
 171         size_t size = packet_size(pkt);
 172         return write_all(socket, (char *)pkt, size) == size;
 173 }
 174
 175 static bool recv_packet(int socket, Packet *pkt) {
 176         ssize_t len = read_all(socket, (char*)pkt, packet_header_size());
 177         if (len <= 0 || len != packet_header_size())
 178                 return false;
 179         if (pkt->len > 0) {
 180                 len = read_all(socket, pkt->u.msg, pkt->len);
 181                 if (len <= 0 || len != pkt->len)
 182                         return false;
 183         }
 184         return true;
 185 }
 186
 187 #include "client.c"
 188 #include "server.c"
 189
 190 static void info(const char *str, ...) {
 191         va_list ap;
 192         va_start(ap, str);
 193         fprintf(stderr, "\e[999H");
 194         if (str) {
 195                 fprintf(stderr, "%s: %s: ", server.name, server.session_name);
 196                 vfprintf(stderr, str, ap);
 197                 fprintf(stderr, "\r\n");
 198         }
 199         fflush(stderr);
 200         va_end(ap);
 201 }
 202
 203 static void die(const char *s) {
 204         perror(s);
 205         exit(EXIT_FAILURE);
 206 }
 207
 208 static void usage() {
 209         fprintf(stderr, "usage: abduco [-a|-A|-c|-n] [-r] [-e detachkey] name command\n");
 210         exit(EXIT_FAILURE);
 211 }
 212
 213 static int create_socket_dir() {
 214         size_t maxlen = sizeof(sockaddr.sun_path);
 215         char *dir = getenv("HOME");
 216         if (!dir)
 217                 dir = getenv("TMPDIR");
 218         if (!dir)
 219                 dir = "/tmp";
 220         int len = snprintf(sockaddr.sun_path, maxlen, "%s/.%s/", dir, server.name);
 221         if (len < 0 || (size_t)len >= maxlen)
 222                 return -1;
 223         if (mkdir(sockaddr.sun_path, 0750) == -1 && errno != EEXIST)
 224                 return -1;
 225         return len;
 226 }
 227
 228 static int create_socket(const char *name) {
 229         size_t maxlen = sizeof(sockaddr.sun_path);
 230         if (name[0] == '/') {
 231                 strncpy(sockaddr.sun_path, name, maxlen);
 232                 if (sockaddr.sun_path[maxlen-1])
 233                         return -1;
 234         } else if (name[0] == '.') {
 235                 char buf[maxlen], *cwd = getcwd(buf, sizeof buf);
 236                 if (!cwd)
 237                         return -1;
 238                 int len = snprintf(sockaddr.sun_path, maxlen, "%s/%s", cwd, name);
 239                 if (len < 0 || (size_t)len >= maxlen)
 240                         return -1;
 241         } else {
 242                 int len = create_socket_dir(), rem = strlen(name);
 243                 if (len == -1 || maxlen - len - rem <= 0)
 244                         return -1;
 245                 strncat(sockaddr.sun_path, name, maxlen - len - 1);
 246         }
 247         return socket(AF_LOCAL, SOCK_STREAM, 0);
 248 }
 249
 250 static bool create_session(const char *name, char * const argv[]) {
 251         int pipefds[2];
 252         pid_t pid;
 253         char errormsg[255];
 254         struct sigaction sa;
 255
 256         if (pipe(pipefds) == -1)
 257                 return false;
 258         if ((server.socket = server_create_socket(name)) == -1)
 259                 return false;
 260
 261         switch ((pid = fork())) {
 262         case 0: /* child process */
 263                 setsid();
 264                 close(pipefds[0]);
 265                 switch ((pid = fork())) {
 266                 case 0: /* child process */
 267                         sa.sa_flags = 0;
 268                         sigemptyset(&sa.sa_mask);
 269                         sa.sa_handler = server_pty_died_handler;
 270                         sigaction(SIGCHLD, &sa, NULL);
 271                         switch (server.pid = forkpty(&server.pty, NULL, has_term ? &server.term : NULL, NULL)) {
 272                         case 0: /* child process */
 273                                 fcntl(pipefds[1], F_SETFD, FD_CLOEXEC);
 274                                 close(server.socket);
 275                                 execvp(argv[0], argv);
 276                                 snprintf(errormsg, sizeof(errormsg), "server-execvp: %s\n", strerror(errno));
 277                                 write_all(pipefds[1], errormsg, strlen(errormsg));
 278                                 close(pipefds[1]);
 279                                 exit(EXIT_FAILURE);
 280                                 break;
 281                         case -1:
 282                                 die("server-forkpty");
 283                                 break;
 284                         default:
 285                                 /* SIGTTIN, SIGTTU */
 286                                 sa.sa_handler = server_sigterm_handler;
 287                                 sigaction(SIGTERM, &sa, NULL);
 288                                 sigaction(SIGINT, &sa, NULL);
 289                                 sa.sa_handler = server_sigusr1_handler;
 290                                 sigaction(SIGUSR1, &sa, NULL);
 291                                 sa.sa_handler = SIG_IGN;
 292                                 sigaction(SIGPIPE, &sa, NULL);
 293                                 sigaction(SIGHUP, &sa, NULL);
 294                                 chdir("/");
 295                         #ifdef NDEBUG
 296                                 int fd = open("/dev/null", O_RDWR);
 297                                 dup2(fd, 0);
 298                                 dup2(fd, 1);
 299                                 dup2(fd, 2);
 300                         #endif /* NDEBUG */
 301                                 close(pipefds[1]);
 302                                 struct pollfd pipe_status = { .fd = pipefds[0], .events = POLLIN };
 303                                 if (poll(&pipe_status, 1, -1) == 1 && pipe_status.revents == POLLHUP)
 304                                         exit(EXIT_FAILURE);
 305                                 server_mainloop();
 306                                 break;
 307                         }
 308                         break;
 309                 default:
 310                         close(pipefds[1]);
 311                         exit(EXIT_SUCCESS);
 312                         break;
 313                 }
 314                 break;
 315         case -1: /* fork failed */
 316                 return false;
 317         default: /* parent */
 318                 close(pipefds[1]);
 319                 int status;
 320                 wait(&status); /* wait for first fork */
 321                 ssize_t len = read_all(pipefds[0], errormsg, sizeof(errormsg));
 322                 if (len > 0) {
 323                         write_all(STDERR_FILENO, errormsg, len);
 324                         unlink(sockaddr.sun_path);
 325                         exit(EXIT_FAILURE);
 326                 }
 327                 close(pipefds[0]);
 328         }
 329         return true;
 330 }
 331
 332 static bool attach_session(const char *name) {
 333         if (server.socket > 0)
 334                 close(server.socket);
 335         if ((server.socket = create_socket(name)) == -1)
 336                 return false;
 337         socklen_t socklen = offsetof(struct sockaddr_un, sun_path) + strlen(sockaddr.sun_path) + 1;
 338         if (connect(server.socket, (struct sockaddr*)&sockaddr, socklen) == -1)
 339                 return false;
 340         if (server_set_socket_non_blocking(server.socket) == -1)
 341                 return false;
 342
 343         struct sigaction sa;
 344         sa.sa_flags = 0;
 345         sigemptyset(&sa.sa_mask);
 346         sa.sa_handler = client_sigwinch_handler;
 347         sigaction(SIGWINCH, &sa, NULL);
 348         sa.sa_handler = SIG_IGN;
 349         sigaction(SIGPIPE, &sa, NULL);
 350         atexit(client_restore_terminal);
 351
 352         cur_term = orig_term;
 353         cur_term.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON|IXOFF);
 354         cur_term.c_oflag &= ~(OPOST);
 355         cur_term.c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
 356         cur_term.c_cflag &= ~(CSIZE|PARENB);
 357         cur_term.c_cflag |= CS8;
 358         cur_term.c_cc[VLNEXT] = _POSIX_VDISABLE;
 359         cur_term.c_cc[VMIN] = 1;
 360         cur_term.c_cc[VTIME] = 0;
 361         tcsetattr(STDIN_FILENO, TCSADRAIN, &cur_term);
 362
 363         int status = client_mainloop();
 364         client_restore_terminal();
 365         if (status == -1) {
 366                 info("detached");
 367         } else if (status == -EIO) {
 368                 info("exited due to I/O errors");
 369         } else {
 370                 info("session terminated with exit status %d", status);
 371                 exit(status);
 372         }
 373
 374         return true;
 375 }
 376
 377 static int session_filter(const struct dirent *d) {
 378         return d->d_name[0] != '.';
 379 }
 380
 381 static int session_comparator(const struct dirent **a, const struct dirent **b) {
 382         struct stat sa, sb;
 383         if (stat((*a)->d_name, &sa) != 0)
 384                 return -1;
 385         if (stat((*b)->d_name, &sb) != 0)
 386                 return 1;
 387         return sa.st_atime < sb.st_atime ? -1 : 1;
 388 }
 389
 390 static int list_session() {
 391         if (create_socket_dir() == -1)
 392                 return 1;
 393         chdir(sockaddr.sun_path);
 394         struct dirent **namelist;
 395         int n = scandir(sockaddr.sun_path, &namelist, session_filter, session_comparator);
 396         if (n < 0)
 397                 return 1;
 398         puts("Active sessions");
 399         while (n--) {
 400                 struct stat sb; char buf[255];
 401                 if (stat(namelist[n]->d_name, &sb) == 0) {
 402                         strftime(buf, sizeof(buf), "%a%t %F %T", localtime(&sb.st_atime));
 403                         printf("%c %s\t%s\n", sb.st_mode & S_IXUSR ? '*' : ' ', buf, namelist[n]->d_name);
 404                 }
 405                 free(namelist[n]);
 406         }
 407         free(namelist);
 408         return 0;
 409 }
 410
 411 int main(int argc, char *argv[]) {
 412         char **cmd = NULL, action = '\0';
 413         server.name = basename(argv[0]);
 414         if (argc == 1)
 415                 exit(list_session());
 416         for (int arg = 1; arg < argc; arg++) {
 417                 if (argv[arg][0] != '-') {
 418                         if (!server.session_name) {
 419                                 server.session_name = argv[arg];
 420                                 continue;
 421                         } else if (!cmd) {
 422                                 cmd = &argv[arg];
 423                                 break;
 424                         }
 425                 }
 426                 if (server.session_name)
 427                         usage();
 428                 switch (argv[arg][1]) {
 429                 case 'a':
 430                 case 'A':
 431                 case 'c':
 432                 case 'n':
 433                         action = argv[arg][1];
 434                         break;
 435                 case 'e':
 436                         if (arg + 1 >= argc)
 437                                 usage();
 438                         char *esc = argv[++arg];
 439                         if (esc[0] == '^' && esc[1])
 440                                 *esc = CTRL(esc[1]);
 441                         KEY_DETACH = *esc;
 442                         break;
 443                 case 'r':
 444                         client.readonly = true;
 445                         break;
 446                 case 'v':
 447                         puts("abduco-"VERSION" © 2013-2014 Marc André Tanner");
 448                         exit(EXIT_SUCCESS);
 449                 default:
 450                         usage();
 451                 }
 452         }
 453
 454         if (!cmd) {
 455                 cmd = (char*[]){ getenv("ABDUCO_CMD"), NULL };
 456                 if (!cmd[0])
 457                         cmd[0] = "dvtm";
 458         }
 459
 460         if (!action || !server.session_name || ((action == 'c' || action == 'A') && client.readonly))
 461                 usage();
 462
 463         if (tcgetattr(STDIN_FILENO, &orig_term) != -1) {
 464                 server.term = orig_term;
 465                 has_term = true;
 466         }
 467
 468         switch (action) {
 469         redo:
 470         case 'n':
 471         case 'c':
 472                 if (!create_session(server.session_name, cmd))
 473                         die("create-session");
 474                 if (action == 'n')
 475                         break;
 476         case 'a':
 477         case 'A':
 478                 if (!attach_session(server.session_name)) {
 479                         if (action == 'A') {
 480                                 action = 'c';
 481                                 goto redo;
 482                         }
 483                         die("attach-session");
 484                 }
 485         }
 486
 487         return 0;
 488 }