abduco.c

   1 /*
   2  * Copyright (c) 2013-2016 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 #include <errno.h>
  17 #include <fcntl.h>
  18 #include <stdio.h>
  19 #include <stdarg.h>
  20 #include <stdlib.h>
  21 #include <stdbool.h>
  22 #include <stddef.h>
  23 #include <signal.h>
  24 #include <libgen.h>
  25 #include <string.h>
  26 #include <limits.h>
  27 #include <dirent.h>
  28 #include <termios.h>
  29 #include <time.h>
  30 #include <unistd.h>
  31 #include <pwd.h>
  32 #include <sys/select.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__) || defined(__DragonFly__)
  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 #if defined(_AIX)
  57 # include "forkpty-aix.c"
  58 #elif defined(__sun)
  59 # include "forkpty-sunos.c"
  60 #endif
  61
  62 #define countof(arr) (sizeof(arr) / sizeof((arr)[0]))
  63
  64 enum PacketType {
  65         MSG_CONTENT = 0,
  66         MSG_ATTACH  = 1,
  67         MSG_DETACH  = 2,
  68         MSG_RESIZE  = 3,
  69         MSG_REDRAW  = 4,
  70         MSG_EXIT    = 5,
  71 };
  72
  73 typedef struct {
  74         unsigned int type;
  75         size_t len;
  76         union {
  77                 char msg[BUFSIZ];
  78                 struct winsize ws;
  79                 int i;
  80         } u;
  81 } Packet;
  82
  83 typedef struct Client Client;
  84 struct Client {
  85         int socket;
  86         enum {
  87                 STATE_CONNECTED,
  88                 STATE_ATTACHED,
  89                 STATE_DETACHED,
  90                 STATE_DISCONNECTED,
  91         } state;
  92         bool need_resize;
  93         enum {
  94                 CLIENT_READONLY = 1 << 0,
  95                 CLIENT_LOWPRIORITY = 1 << 1,
  96         } flags;
  97         Client *next;
  98 };
  99
 100 typedef struct {
 101         Client *clients;
 102         int socket;
 103         Packet pty_output;
 104         int pty;
 105         int exit_status;
 106         struct termios term;
 107         struct winsize winsize;
 108         pid_t pid;
 109         volatile sig_atomic_t running;
 110         const char *name;
 111         const char *session_name;
 112         char host[255];
 113         bool read_pty;
 114 } Server;
 115
 116 static Server server = { .running = true, .exit_status = -1, .host = "@localhost" };
 117 static Client client;
 118 static struct termios orig_term, cur_term;
 119 static bool has_term, alternate_buffer;
 120
 121 static struct sockaddr_un sockaddr = {
 122         .sun_family = AF_UNIX,
 123 };
 124
 125 static bool set_socket_name(struct sockaddr_un *sockaddr, const char *name);
 126 static void die(const char *s);
 127 static void info(const char *str, ...);
 128
 129 #include "debug.c"
 130
 131 static inline size_t packet_header_size() {
 132         return offsetof(Packet, u);
 133 }
 134
 135 static size_t packet_size(Packet *pkt) {
 136         return packet_header_size() + pkt->len;
 137 }
 138
 139 static ssize_t write_all(int fd, const char *buf, size_t len) {
 140         debug("write_all(%d)\n", len);
 141         ssize_t ret = len;
 142         while (len > 0) {
 143                 ssize_t res = write(fd, buf, len);
 144                 if (res < 0) {
 145                         if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
 146                                 continue;
 147                         return -1;
 148                 }
 149                 if (res == 0)
 150                         return ret - len;
 151                 buf += res;
 152                 len -= res;
 153         }
 154         return ret;
 155 }
 156
 157 static ssize_t read_all(int fd, char *buf, size_t len) {
 158         debug("read_all(%d)\n", len);
 159         ssize_t ret = len;
 160         while (len > 0) {
 161                 ssize_t res = read(fd, buf, len);
 162                 if (res < 0) {
 163                         if (errno == EWOULDBLOCK)
 164                                 return ret - len;
 165                         if (errno == EAGAIN || errno == EINTR)
 166                                 continue;
 167                         return -1;
 168                 }
 169                 if (res == 0)
 170                         return ret - len;
 171                 buf += res;
 172                 len -= res;
 173         }
 174         return ret;
 175 }
 176
 177 static bool send_packet(int socket, Packet *pkt) {
 178         size_t size = packet_size(pkt);
 179         if (size > sizeof(*pkt))
 180                 return false;
 181         return write_all(socket, (char *)pkt, size) == size;
 182 }
 183
 184 static bool recv_packet(int socket, Packet *pkt) {
 185         ssize_t len = read_all(socket, (char*)pkt, packet_header_size());
 186         if (len <= 0 || len != packet_header_size())
 187                 return false;
 188         if (pkt->len > sizeof(pkt->u.msg)) {
 189                 pkt->len = 0;
 190                 return false;
 191         }
 192         if (pkt->len > 0) {
 193                 len = read_all(socket, pkt->u.msg, pkt->len);
 194                 if (len <= 0 || len != pkt->len)
 195                         return false;
 196         }
 197         return true;
 198 }
 199
 200 #include "client.c"
 201 #include "server.c"
 202
 203 static void info(const char *str, ...) {
 204         va_list ap;
 205         va_start(ap, str);
 206         if (str) {
 207                 fprintf(stderr, "%s: %s: ", server.name, server.session_name);
 208                 vfprintf(stderr, str, ap);
 209                 fprintf(stderr, "\r\n");
 210         }
 211         fflush(stderr);
 212         va_end(ap);
 213 }
 214
 215 static void die(const char *s) {
 216         perror(s);
 217         exit(EXIT_FAILURE);
 218 }
 219
 220 static void usage(void) {
 221         fprintf(stderr, "usage: abduco [-a|-A|-c|-n] [-r] [-l] [-f] [-e detachkey] name command\n");
 222         exit(EXIT_FAILURE);
 223 }
 224
 225 static bool xsnprintf(char *buf, size_t size, const char *fmt, ...) {
 226         va_list ap;
 227         if (size > INT_MAX)
 228                 return false;
 229         va_start(ap, fmt);
 230         int n = vsnprintf(buf, size, fmt, ap);
 231         va_end(ap);
 232         if (n == -1)
 233                 return false;
 234         if (n >= size) {
 235                 errno = ENAMETOOLONG;
 236                 return false;
 237         }
 238         return true;
 239 }
 240
 241 static int session_connect(const char *name) {
 242         int fd;
 243         struct stat sb;
 244         if (!set_socket_name(&sockaddr, name) || (fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
 245                 return -1;
 246         socklen_t socklen = offsetof(struct sockaddr_un, sun_path) + strlen(sockaddr.sun_path) + 1;
 247         if (connect(fd, (struct sockaddr*)&sockaddr, socklen) == -1) {
 248                 if (errno == ECONNREFUSED && stat(sockaddr.sun_path, &sb) == 0 && S_ISSOCK(sb.st_mode))
 249                         unlink(sockaddr.sun_path);
 250                 close(fd);
 251                 return -1;
 252         }
 253         return fd;
 254 }
 255
 256 static bool session_exists(const char *name) {
 257         int fd = session_connect(name);
 258         if (fd != -1)
 259                 close(fd);
 260         return fd != -1;
 261 }
 262
 263 static bool session_alive(const char *name) {
 264         struct stat sb;
 265         return session_exists(name) &&
 266                stat(sockaddr.sun_path, &sb) == 0 &&
 267                S_ISSOCK(sb.st_mode) && (sb.st_mode & S_IXGRP) == 0;
 268 }
 269
 270 static bool create_socket_dir(struct sockaddr_un *sockaddr) {
 271         sockaddr->sun_path[0] = '\0';
 272         int socketfd = socket(AF_UNIX, SOCK_STREAM, 0);
 273         if (socketfd == -1)
 274                 return false;
 275
 276         size_t maxlen = sizeof(sockaddr->sun_path);
 277         uid_t uid = getuid();
 278         struct passwd *pw = getpwuid(uid);
 279
 280         for (unsigned int i = 0; i < countof(socket_dirs); i++) {
 281                 struct stat sb;
 282                 struct Dir *dir = &socket_dirs[i];
 283                 bool ishome = false;
 284                 if (dir->env) {
 285                         dir->path = getenv(dir->env);
 286                         ishome = !strcmp(dir->env, "HOME");
 287                         if (ishome && (!dir->path || !dir->path[0]) && pw)
 288                                 dir->path = pw->pw_dir;
 289                 }
 290                 if (!dir->path || !dir->path[0])
 291                         continue;
 292                 if (!xsnprintf(sockaddr->sun_path, maxlen, "%s/%s%s/", dir->path, ishome ? "." : "", server.name))
 293                         continue;
 294                 mode_t mask = umask(0);
 295                 int r = mkdir(sockaddr->sun_path, dir->personal ? S_IRWXU : S_IRWXU|S_IRWXG|S_IRWXO|S_ISVTX);
 296                 umask(mask);
 297                 if (r != 0 && errno != EEXIST)
 298                         continue;
 299                 if (lstat(sockaddr->sun_path, &sb) != 0)
 300                         continue;
 301                 if (!S_ISDIR(sb.st_mode)) {
 302                         errno = ENOTDIR;
 303                         continue;
 304                 }
 305
 306                 size_t dirlen = strlen(sockaddr->sun_path);
 307                 if (!dir->personal) {
 308                         /* create subdirectory only accessible to user */
 309                         if (pw && !xsnprintf(sockaddr->sun_path+dirlen, maxlen-dirlen, "%s/", pw->pw_name))
 310                                 continue;
 311                         if (!pw && !xsnprintf(sockaddr->sun_path+dirlen, maxlen-dirlen, "%d/", uid))
 312                                 continue;
 313                         if (mkdir(sockaddr->sun_path, S_IRWXU) != 0 && errno != EEXIST)
 314                                 continue;
 315                         if (lstat(sockaddr->sun_path, &sb) != 0)
 316                                 continue;
 317                         if (!S_ISDIR(sb.st_mode)) {
 318                                 errno = ENOTDIR;
 319                                 continue;
 320                         }
 321                         dirlen = strlen(sockaddr->sun_path);
 322                 }
 323
 324                 if (sb.st_uid != uid || sb.st_mode & (S_IRWXG|S_IRWXO)) {
 325                         errno = EACCES;
 326                         continue;
 327                 }
 328
 329                 if (!xsnprintf(sockaddr->sun_path+dirlen, maxlen-dirlen, ".abduco-%d", getpid()))
 330                         continue;
 331
 332                 socklen_t socklen = offsetof(struct sockaddr_un, sun_path) + strlen(sockaddr->sun_path) + 1;
 333                 if (bind(socketfd, (struct sockaddr*)sockaddr, socklen) == -1)
 334                         continue;
 335                 unlink(sockaddr->sun_path);
 336                 close(socketfd);
 337                 sockaddr->sun_path[dirlen] = '\0';
 338                 return true;
 339         }
 340
 341         close(socketfd);
 342         return false;
 343 }
 344
 345 static bool set_socket_name(struct sockaddr_un *sockaddr, const char *name) {
 346         size_t maxlen = sizeof(sockaddr->sun_path);
 347         if (name[0] == '/') {
 348                 if (strlen(name) >= maxlen) {
 349                         errno = ENAMETOOLONG;
 350                         return false;
 351                 }
 352                 strncpy(sockaddr->sun_path, name, maxlen);
 353         } else if (name[0] == '.' && (name[1] == '.' || name[1] == '/')) {
 354                 char buf[maxlen], *cwd = getcwd(buf, sizeof buf);
 355                 if (!cwd)
 356                         return false;
 357                 if (!xsnprintf(sockaddr->sun_path, maxlen, "%s/%s", cwd, name))
 358                         return false;
 359         } else {
 360                 if (!create_socket_dir(sockaddr))
 361                         return false;
 362                 if (strlen(sockaddr->sun_path) + strlen(name) + strlen(server.host) >= maxlen) {
 363                         errno = ENAMETOOLONG;
 364                         return false;
 365                 }
 366                 strncat(sockaddr->sun_path, name, maxlen - strlen(sockaddr->sun_path) - 1);
 367                 strncat(sockaddr->sun_path, server.host, maxlen - strlen(sockaddr->sun_path) - 1);
 368         }
 369         return true;
 370 }
 371
 372 static bool create_session(const char *name, char * const argv[]) {
 373         /* this uses the well known double fork strategy as described in section 1.7 of
 374          *
 375          *  http://www.faqs.org/faqs/unix-faq/programmer/faq/
 376          *
 377          * pipes are used for synchronization and error reporting i.e. the child sets
 378          * the close on exec flag before calling execvp(3) the parent blocks on a read(2)
 379          * in case of failure the error message is written to the pipe, success is
 380          * indicated by EOF on the pipe.
 381          */
 382         int client_pipe[2], server_pipe[2];
 383         pid_t pid;
 384         char errormsg[255];
 385         struct sigaction sa;
 386
 387         if (session_exists(name)) {
 388                 errno = EADDRINUSE;
 389                 return false;
 390         }
 391
 392         if (pipe(client_pipe) == -1)
 393                 return false;
 394         if ((server.socket = server_create_socket(name)) == -1)
 395                 return false;
 396
 397         switch ((pid = fork())) {
 398         case 0: /* child process */
 399                 setsid();
 400                 close(client_pipe[0]);
 401                 switch ((pid = fork())) {
 402                 case 0: /* child process */
 403                         if (pipe(server_pipe) == -1) {
 404                                 snprintf(errormsg, sizeof(errormsg), "server-pipe: %s\n", strerror(errno));
 405                                 write_all(client_pipe[1], errormsg, strlen(errormsg));
 406                                 close(client_pipe[1]);
 407                                 _exit(EXIT_FAILURE);
 408                         }
 409                         sa.sa_flags = 0;
 410                         sigemptyset(&sa.sa_mask);
 411                         sa.sa_handler = server_pty_died_handler;
 412                         sigaction(SIGCHLD, &sa, NULL);
 413                         switch (server.pid = forkpty(&server.pty, NULL, has_term ? &server.term : NULL, &server.winsize)) {
 414                         case 0: /* child = user application process */
 415                                 close(server.socket);
 416                                 close(server_pipe[0]);
 417                                 if (fcntl(client_pipe[1], F_SETFD, FD_CLOEXEC) == 0 &&
 418                                     fcntl(server_pipe[1], F_SETFD, FD_CLOEXEC) == 0)
 419                                         execvp(argv[0], argv);
 420                                 snprintf(errormsg, sizeof(errormsg), "server-execvp: %s: %s\n",
 421                                                  argv[0], strerror(errno));
 422                                 write_all(client_pipe[1], errormsg, strlen(errormsg));
 423                                 write_all(server_pipe[1], errormsg, strlen(errormsg));
 424                                 close(client_pipe[1]);
 425                                 close(server_pipe[1]);
 426                                 _exit(EXIT_FAILURE);
 427                                 break;
 428                         case -1: /* forkpty failed */
 429                                 snprintf(errormsg, sizeof(errormsg), "server-forkpty: %s\n", strerror(errno));
 430                                 write_all(client_pipe[1], errormsg, strlen(errormsg));
 431                                 close(client_pipe[1]);
 432                                 close(server_pipe[0]);
 433                                 close(server_pipe[1]);
 434                                 _exit(EXIT_FAILURE);
 435                                 break;
 436                         default: /* parent = server process */
 437                                 sa.sa_handler = server_sigterm_handler;
 438                                 sigaction(SIGTERM, &sa, NULL);
 439                                 sigaction(SIGINT, &sa, NULL);
 440                                 sa.sa_handler = server_sigusr1_handler;
 441                                 sigaction(SIGUSR1, &sa, NULL);
 442                                 sa.sa_handler = SIG_IGN;
 443                                 sigaction(SIGPIPE, &sa, NULL);
 444                                 sigaction(SIGHUP, &sa, NULL);
 445                                 chdir("/");
 446                         #ifdef NDEBUG
 447                                 int fd = open("/dev/null", O_RDWR);
 448                                 if (fd != -1) {
 449                                         dup2(fd, 0);
 450                                         dup2(fd, 1);
 451                                         dup2(fd, 2);
 452                                         close(fd);
 453                                 }
 454                         #endif /* NDEBUG */
 455                                 close(client_pipe[1]);
 456                                 close(server_pipe[1]);
 457                                 if (read_all(server_pipe[0], errormsg, sizeof(errormsg)) > 0)
 458                                         _exit(EXIT_FAILURE);
 459                                 close(server_pipe[0]);
 460                                 server_mainloop();
 461                                 break;
 462                         }
 463                         break;
 464                 case -1: /* fork failed */
 465                         snprintf(errormsg, sizeof(errormsg), "server-fork: %s\n", strerror(errno));
 466                         write_all(client_pipe[1], errormsg, strlen(errormsg));
 467                         close(client_pipe[1]);
 468                         _exit(EXIT_FAILURE);
 469                         break;
 470                 default: /* parent = intermediate process */
 471                         close(client_pipe[1]);
 472                         _exit(EXIT_SUCCESS);
 473                         break;
 474                 }
 475                 break;
 476         case -1: /* fork failed */
 477                 close(client_pipe[0]);
 478                 close(client_pipe[1]);
 479                 return false;
 480         default: /* parent = client process */
 481                 close(client_pipe[1]);
 482                 int status;
 483                 wait(&status); /* wait for first fork */
 484                 ssize_t len = read_all(client_pipe[0], errormsg, sizeof(errormsg));
 485                 if (len > 0) {
 486                         write_all(STDERR_FILENO, errormsg, len);
 487                         unlink(sockaddr.sun_path);
 488                         exit(EXIT_FAILURE);
 489                 }
 490                 close(client_pipe[0]);
 491         }
 492         return true;
 493 }
 494
 495 static bool attach_session(const char *name, const bool terminate) {
 496         if (server.socket > 0)
 497                 close(server.socket);
 498         if ((server.socket = session_connect(name)) == -1)
 499                 return false;
 500         if (server_set_socket_non_blocking(server.socket) == -1)
 501                 return false;
 502
 503         struct sigaction sa;
 504         sa.sa_flags = 0;
 505         sigemptyset(&sa.sa_mask);
 506         sa.sa_handler = client_sigwinch_handler;
 507         sigaction(SIGWINCH, &sa, NULL);
 508         sa.sa_handler = SIG_IGN;
 509         sigaction(SIGPIPE, &sa, NULL);
 510
 511         client_setup_terminal();
 512         int status = client_mainloop();
 513         client_restore_terminal();
 514         if (status == -1) {
 515                 info("detached");
 516         } else if (status == -EIO) {
 517                 info("exited due to I/O errors");
 518         } else {
 519                 info("session terminated with exit status %d", status);
 520                 if (terminate)
 521                         exit(status);
 522         }
 523
 524         return terminate;
 525 }
 526
 527 static int session_filter(const struct dirent *d) {
 528         return strstr(d->d_name, server.host) != NULL;
 529 }
 530
 531 static int session_comparator(const struct dirent **a, const struct dirent **b) {
 532         struct stat sa, sb;
 533         if (stat((*a)->d_name, &sa) != 0)
 534                 return -1;
 535         if (stat((*b)->d_name, &sb) != 0)
 536                 return 1;
 537         return sa.st_atime < sb.st_atime ? -1 : 1;
 538 }
 539
 540 static int list_session(void) {
 541         if (!create_socket_dir(&sockaddr))
 542                 return 1;
 543         chdir(sockaddr.sun_path);
 544         struct dirent **namelist;
 545         int n = scandir(sockaddr.sun_path, &namelist, session_filter, session_comparator);
 546         if (n < 0)
 547                 return 1;
 548         printf("Active sessions (on host %s)\n", server.host+1);
 549         while (n--) {
 550                 struct stat sb; char buf[255];
 551                 if (stat(namelist[n]->d_name, &sb) == 0 && S_ISSOCK(sb.st_mode)) {
 552                         strftime(buf, sizeof(buf), "%a%t %F %T", localtime(&sb.st_mtime));
 553                         char status = ' ';
 554                         char *local = strstr(namelist[n]->d_name, server.host);
 555                         if (local) {
 556                                 *local = '\0'; /* truncate hostname if we are local */
 557                                 if (!session_exists(namelist[n]->d_name))
 558                                         continue;
 559                         }
 560                         if (sb.st_mode & S_IXUSR)
 561                                 status = '*';
 562                         else if (sb.st_mode & S_IXGRP)
 563                                 status = '+';
 564                         printf("%c %s\t%s\n", status, buf, namelist[n]->d_name);
 565                 }
 566                 free(namelist[n]);
 567         }
 568         free(namelist);
 569         return 0;
 570 }
 571
 572 int main(int argc, char *argv[]) {
 573         int opt;
 574         bool force = false;
 575         char **cmd = NULL, action = '\0';
 576
 577         char *default_cmd[4] = { "/bin/sh", "-c", getenv("ABDUCO_CMD"), NULL };
 578         if (!default_cmd[2]) {
 579                 default_cmd[0] = ABDUCO_CMD;
 580                 default_cmd[1] = NULL;
 581         }
 582
 583         server.name = basename(argv[0]);
 584         gethostname(server.host+1, sizeof(server.host) - 1);
 585
 586         while ((opt = getopt(argc, argv, "aAclne:frv")) != -1) {
 587                 switch (opt) {
 588                 case 'a':
 589                 case 'A':
 590                 case 'c':
 591                 case 'n':
 592                         action = opt;
 593                         break;
 594                 case 'e':
 595                         if (!optarg)
 596                                 usage();
 597                         if (optarg[0] == '^' && optarg[1])
 598                                 optarg[0] = CTRL(optarg[1]);
 599                         KEY_DETACH = optarg[0];
 600                         break;
 601                 case 'f':
 602                         force = true;
 603                         break;
 604                 case 'r':
 605                         client.flags |= CLIENT_READONLY;
 606                         break;
 607                 case 'l':
 608                         client.flags |= CLIENT_LOWPRIORITY;
 609                         break;
 610                 case 'v':
 611                         puts("abduco-"VERSION" © 2013-2015 Marc André Tanner");
 612                         exit(EXIT_SUCCESS);
 613                 default:
 614                         usage();
 615                 }
 616         }
 617
 618         /* collect the session name if trailing args */
 619         if (optind < argc)
 620                 server.session_name = argv[optind];
 621
 622         /* if yet more trailing arguments, they must be the command */
 623         if (optind + 1 < argc)
 624                 cmd = &argv[optind + 1];
 625         else
 626                 cmd = default_cmd;
 627
 628         if (!action && !server.session_name)
 629                 exit(list_session());
 630         if (!action || !server.session_name)
 631                 usage();
 632
 633         if (tcgetattr(STDIN_FILENO, &orig_term) != -1) {
 634                 server.term = orig_term;
 635                 has_term = true;
 636         }
 637
 638         if (ioctl(STDIN_FILENO, TIOCGWINSZ, &server.winsize) == -1) {
 639                 server.winsize.ws_col = 80;
 640                 server.winsize.ws_row = 25;
 641         }
 642
 643         server.read_pty = (action == 'n');
 644
 645         redo:
 646         switch (action) {
 647         case 'n':
 648         case 'c':
 649                 if (force) {
 650                         if (session_alive(server.session_name)) {
 651                                 info("session exists and has not yet terminated");
 652                                 return 1;
 653                         }
 654                         if (session_exists(server.session_name))
 655                                 attach_session(server.session_name, false);
 656                 }
 657                 if (!create_session(server.session_name, cmd))
 658                         die("create-session");
 659                 if (action == 'n')
 660                         break;
 661         case 'a':
 662                 if (!attach_session(server.session_name, true))
 663                         die("attach-session");
 664                 break;
 665         case 'A':
 666                 if (session_alive(server.session_name)) {
 667                         if (!attach_session(server.session_name, true))
 668                                 die("attach-session");
 669                 } else if (!attach_session(server.session_name, !force)) {
 670                         force = false;
 671                         action = 'c';
 672                         goto redo;
 673                 }
 674                 break;
 675         }
 676
 677         return 0;
 678 }