Utilities/cmlibuv/src/unix/tty.c

   1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
   2  *
   3  * Permission is hereby granted, free of charge, to any person obtaining a copy
   4  * of this software and associated documentation files (the "Software"), to
   5  * deal in the Software without restriction, including without limitation the
   6  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   7  * sell copies of the Software, and to permit persons to whom the Software is
   8  * furnished to do so, subject to the following conditions:
   9  *
  10  * The above copyright notice and this permission notice shall be included in
  11  * all copies or substantial portions of the Software.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  18  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  19  * IN THE SOFTWARE.
  20  */
  21
  22 #include "uv.h"
  23 #include "internal.h"
  24 #include "spinlock.h"
  25
  26 #include <stdlib.h>
  27 #include <assert.h>
  28 #include <unistd.h>
  29 #include <termios.h>
  30 #include <errno.h>
  31 #include <sys/ioctl.h>
  32
  33 #if defined(__MVS__) && !defined(IMAXBEL)
  34 #define IMAXBEL 0
  35 #endif
  36
  37 #if defined(__PASE__)
  38 /* On IBM i PASE, for better compatibility with running interactive programs in
  39  * a 5250 environment, isatty() will return true for the stdin/stdout/stderr
  40  * streams created by QSH/QP2TERM.
  41  *
  42  * For more, see docs on PASE_STDIO_ISATTY in
  43  * https://www.ibm.com/support/knowledgecenter/ssw_ibm_i_74/apis/pase_environ.htm
  44  *
  45  * This behavior causes problems for Node as it expects that if isatty() returns
  46  * true that TTY ioctls will be supported by that fd (which is not an
  47  * unreasonable expectation) and when they don't it crashes with assertion
  48  * errors.
  49  *
  50  * Here, we create our own version of isatty() that uses ioctl() to identify
  51  * whether the fd is *really* a TTY or not.
  52  */
  53 static int isreallyatty(int file) {
  54   int rc;
  55
  56   rc = !ioctl(file, TXISATTY + 0x81, NULL);
  57   if (!rc && errno != EBADF)
  58       errno = ENOTTY;
  59
  60   return rc;
  61 }
  62 #define isatty(fd) isreallyatty(fd)
  63 #endif
  64
  65 #if !defined(CMAKE_BOOTSTRAP)
  66
  67 static int orig_termios_fd = -1;
  68 static struct termios orig_termios;
  69 static uv_spinlock_t termios_spinlock = UV_SPINLOCK_INITIALIZER;
  70
  71 int uv__tcsetattr(int fd, int how, const struct termios *term) {
  72   int rc;
  73
  74   do
  75     rc = tcsetattr(fd, how, term);
  76   while (rc == -1 && errno == EINTR);
  77
  78   if (rc == -1)
  79     return UV__ERR(errno);
  80
  81   return 0;
  82 }
  83
  84 static int uv__tty_is_slave(const int fd) {
  85   int result;
  86 #if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
  87   int dummy;
  88
  89   result = ioctl(fd, TIOCGPTN, &dummy) != 0;
  90 #elif defined(__APPLE__)
  91   char dummy[256];
  92
  93   result = ioctl(fd, TIOCPTYGNAME, &dummy) != 0;
  94 #elif defined(__NetBSD__)
  95   /*
  96    * NetBSD as an extension returns with ptsname(3) and ptsname_r(3) the slave
  97    * device name for both descriptors, the master one and slave one.
  98    *
  99    * Implement function to compare major device number with pts devices.
 100    *
 101    * The major numbers are machine-dependent, on NetBSD/amd64 they are
 102    * respectively:
 103    *  - master tty: ptc - major 6
 104    *  - slave tty:  pts - major 5
 105    */
 106
 107   struct stat sb;
 108   /* Lookup device's major for the pts driver and cache it. */
 109   static devmajor_t pts = NODEVMAJOR;
 110
 111   if (pts == NODEVMAJOR) {
 112     pts = getdevmajor("pts", S_IFCHR);
 113     if (pts == NODEVMAJOR)
 114       abort();
 115   }
 116
 117   /* Lookup stat structure behind the file descriptor. */
 118   if (fstat(fd, &sb) != 0)
 119     abort();
 120
 121   /* Assert character device. */
 122   if (!S_ISCHR(sb.st_mode))
 123     abort();
 124
 125   /* Assert valid major. */
 126   if (major(sb.st_rdev) == NODEVMAJOR)
 127     abort();
 128
 129   result = (pts == major(sb.st_rdev));
 130 #else
 131   /* Fallback to ptsname
 132    */
 133   result = ptsname(fd) == NULL;
 134 #endif
 135   return result;
 136 }
 137
 138 int uv_tty_init(uv_loop_t* loop, uv_tty_t* tty, int fd, int unused) {
 139   uv_handle_type type;
 140   int flags = 0;
 141   int newfd = -1;
 142   int r;
 143   int saved_flags;
 144   int mode;
 145   char path[256];
 146   (void)unused; /* deprecated parameter is no longer needed */
 147
 148   /* File descriptors that refer to files cannot be monitored with epoll.
 149    * That restriction also applies to character devices like /dev/random
 150    * (but obviously not /dev/tty.)
 151    */
 152   type = uv_guess_handle(fd);
 153   if (type == UV_FILE || type == UV_UNKNOWN_HANDLE)
 154     return UV_EINVAL;
 155
 156   /* Save the fd flags in case we need to restore them due to an error. */
 157   do
 158     saved_flags = fcntl(fd, F_GETFL);
 159   while (saved_flags == -1 && errno == EINTR);
 160
 161   if (saved_flags == -1)
 162     return UV__ERR(errno);
 163   mode = saved_flags & O_ACCMODE;
 164
 165   /* Reopen the file descriptor when it refers to a tty. This lets us put the
 166    * tty in non-blocking mode without affecting other processes that share it
 167    * with us.
 168    *
 169    * Example: `node | cat` - if we put our fd 0 in non-blocking mode, it also
 170    * affects fd 1 of `cat` because both file descriptors refer to the same
 171    * struct file in the kernel. When we reopen our fd 0, it points to a
 172    * different struct file, hence changing its properties doesn't affect
 173    * other processes.
 174    */
 175   if (type == UV_TTY) {
 176     /* Reopening a pty in master mode won't work either because the reopened
 177      * pty will be in slave mode (*BSD) or reopening will allocate a new
 178      * master/slave pair (Linux). Therefore check if the fd points to a
 179      * slave device.
 180      */
 181     if (uv__tty_is_slave(fd) && ttyname_r(fd, path, sizeof(path)) == 0)
 182       r = uv__open_cloexec(path, mode | O_NOCTTY);
 183     else
 184       r = -1;
 185
 186     if (r < 0) {
 187       /* fallback to using blocking writes */
 188       if (mode != O_RDONLY)
 189         flags |= UV_HANDLE_BLOCKING_WRITES;
 190       goto skip;
 191     }
 192
 193     newfd = r;
 194
 195     r = uv__dup2_cloexec(newfd, fd);
 196     if (r < 0 && r != UV_EINVAL) {
 197       /* EINVAL means newfd == fd which could conceivably happen if another
 198        * thread called close(fd) between our calls to isatty() and open().
 199        * That's a rather unlikely event but let's handle it anyway.
 200        */
 201       uv__close(newfd);
 202       return r;
 203     }
 204
 205     fd = newfd;
 206   }
 207
 208 skip:
 209   uv__stream_init(loop, (uv_stream_t*) tty, UV_TTY);
 210
 211   /* If anything fails beyond this point we need to remove the handle from
 212    * the handle queue, since it was added by uv__handle_init in uv_stream_init.
 213    */
 214
 215   if (!(flags & UV_HANDLE_BLOCKING_WRITES))
 216     uv__nonblock(fd, 1);
 217
 218 #if defined(__APPLE__)
 219   r = uv__stream_try_select((uv_stream_t*) tty, &fd);
 220   if (r) {
 221     int rc = r;
 222     if (newfd != -1)
 223       uv__close(newfd);
 224     QUEUE_REMOVE(&tty->handle_queue);
 225     do
 226       r = fcntl(fd, F_SETFL, saved_flags);
 227     while (r == -1 && errno == EINTR);
 228     return rc;
 229   }
 230 #endif
 231
 232   if (mode != O_WRONLY)
 233     flags |= UV_HANDLE_READABLE;
 234   if (mode != O_RDONLY)
 235     flags |= UV_HANDLE_WRITABLE;
 236
 237   uv__stream_open((uv_stream_t*) tty, fd, flags);
 238   tty->mode = UV_TTY_MODE_NORMAL;
 239
 240   return 0;
 241 }
 242
 243 static void uv__tty_make_raw(struct termios* tio) {
 244   assert(tio != NULL);
 245
 246 #if defined __sun || defined __MVS__ || defined __hpux
 247   /*
 248    * This implementation of cfmakeraw for Solaris and derivatives is taken from
 249    * http://www.perkin.org.uk/posts/solaris-portability-cfmakeraw.html.
 250    */
 251   tio->c_iflag &= ~(IMAXBEL | IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR |
 252                     IGNCR | ICRNL | IXON);
 253   tio->c_oflag &= ~OPOST;
 254   tio->c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
 255   tio->c_cflag &= ~(CSIZE | PARENB);
 256   tio->c_cflag |= CS8;
 257
 258   /*
 259    * By default, most software expects a pending read to block until at
 260    * least one byte becomes available.  As per termio(7I), this requires
 261    * setting the MIN and TIME parameters appropriately.
 262    *
 263    * As a somewhat unfortunate artifact of history, the MIN and TIME slots
 264    * in the control character array overlap with the EOF and EOL slots used
 265    * for canonical mode processing.  Because the EOF character needs to be
 266    * the ASCII EOT value (aka Control-D), it has the byte value 4.  When
 267    * switching to raw mode, this is interpreted as a MIN value of 4; i.e.,
 268    * reads will block until at least four bytes have been input.
 269    *
 270    * Other platforms with a distinct MIN slot like Linux and FreeBSD appear
 271    * to default to a MIN value of 1, so we'll force that value here:
 272    */
 273   tio->c_cc[VMIN] = 1;
 274   tio->c_cc[VTIME] = 0;
 275 #else
 276   cfmakeraw(tio);
 277 #endif /* #ifdef __sun */
 278 }
 279
 280 int uv_tty_set_mode(uv_tty_t* tty, uv_tty_mode_t mode) {
 281   struct termios tmp;
 282   int fd;
 283   int rc;
 284
 285   if (tty->mode == (int) mode)
 286     return 0;
 287
 288   fd = uv__stream_fd(tty);
 289   if (tty->mode == UV_TTY_MODE_NORMAL && mode != UV_TTY_MODE_NORMAL) {
 290     do
 291       rc = tcgetattr(fd, &tty->orig_termios);
 292     while (rc == -1 && errno == EINTR);
 293
 294     if (rc == -1)
 295       return UV__ERR(errno);
 296
 297     /* This is used for uv_tty_reset_mode() */
 298     uv_spinlock_lock(&termios_spinlock);
 299     if (orig_termios_fd == -1) {
 300       orig_termios = tty->orig_termios;
 301       orig_termios_fd = fd;
 302     }
 303     uv_spinlock_unlock(&termios_spinlock);
 304   }
 305
 306   tmp = tty->orig_termios;
 307   switch (mode) {
 308     case UV_TTY_MODE_NORMAL:
 309       break;
 310     case UV_TTY_MODE_RAW:
 311       tmp.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
 312       tmp.c_oflag |= (ONLCR);
 313       tmp.c_cflag |= (CS8);
 314       tmp.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
 315       tmp.c_cc[VMIN] = 1;
 316       tmp.c_cc[VTIME] = 0;
 317       break;
 318     case UV_TTY_MODE_IO:
 319       uv__tty_make_raw(&tmp);
 320       break;
 321   }
 322
 323   /* Apply changes after draining */
 324   rc = uv__tcsetattr(fd, TCSADRAIN, &tmp);
 325   if (rc == 0)
 326     tty->mode = mode;
 327
 328   return rc;
 329 }
 330
 331
 332 int uv_tty_get_winsize(uv_tty_t* tty, int* width, int* height) {
 333   struct winsize ws;
 334   int err;
 335
 336   do
 337     err = ioctl(uv__stream_fd(tty), TIOCGWINSZ, &ws);
 338   while (err == -1 && errno == EINTR);
 339
 340   if (err == -1)
 341     return UV__ERR(errno);
 342
 343   *width = ws.ws_col;
 344   *height = ws.ws_row;
 345
 346   return 0;
 347 }
 348
 349 #endif
 350
 351 uv_handle_type uv_guess_handle(uv_file file) {
 352   struct sockaddr_storage ss;
 353   struct stat s;
 354   socklen_t len;
 355   int type;
 356
 357   if (file < 0)
 358     return UV_UNKNOWN_HANDLE;
 359
 360   if (isatty(file))
 361     return UV_TTY;
 362
 363   if (fstat(file, &s)) {
 364 #if defined(__PASE__)
 365     /* On ibmi receiving RST from TCP instead of FIN immediately puts fd into
 366      * an error state. fstat will return EINVAL, getsockname will also return
 367      * EINVAL, even if sockaddr_storage is valid. (If file does not refer to a
 368      * socket, ENOTSOCK is returned instead.)
 369      * In such cases, we will permit the user to open the connection as uv_tcp
 370      * still, so that the user can get immediately notified of the error in
 371      * their read callback and close this fd.
 372      */
 373     len = sizeof(ss);
 374     if (getsockname(file, (struct sockaddr*) &ss, &len)) {
 375       if (errno == EINVAL)
 376         return UV_TCP;
 377     }
 378 #endif
 379     return UV_UNKNOWN_HANDLE;
 380   }
 381
 382   if (S_ISREG(s.st_mode))
 383     return UV_FILE;
 384
 385   if (S_ISCHR(s.st_mode))
 386     return UV_FILE;  /* XXX UV_NAMED_PIPE? */
 387
 388   if (S_ISFIFO(s.st_mode))
 389     return UV_NAMED_PIPE;
 390
 391   if (!S_ISSOCK(s.st_mode))
 392     return UV_UNKNOWN_HANDLE;
 393
 394   len = sizeof(ss);
 395   if (getsockname(file, (struct sockaddr*) &ss, &len)) {
 396 #if defined(_AIX)
 397     /* On aix receiving RST from TCP instead of FIN immediately puts fd into
 398      * an error state. In such case getsockname will return EINVAL, even if
 399      * sockaddr_storage is valid.
 400      * In such cases, we will permit the user to open the connection as uv_tcp
 401      * still, so that the user can get immediately notified of the error in
 402      * their read callback and close this fd.
 403      */
 404     if (errno == EINVAL) {
 405       return UV_TCP;
 406     }
 407 #endif
 408     return UV_UNKNOWN_HANDLE;
 409   }
 410
 411   len = sizeof(type);
 412   if (getsockopt(file, SOL_SOCKET, SO_TYPE, &type, &len))
 413     return UV_UNKNOWN_HANDLE;
 414
 415   if (type == SOCK_DGRAM)
 416     if (ss.ss_family == AF_INET || ss.ss_family == AF_INET6)
 417       return UV_UDP;
 418
 419   if (type == SOCK_STREAM) {
 420 #if defined(_AIX) || defined(__DragonFly__)
 421     /* on AIX/DragonFly the getsockname call returns an empty sa structure
 422      * for sockets of type AF_UNIX.  For all other types it will
 423      * return a properly filled in structure.
 424      */
 425     if (len == 0)
 426       return UV_NAMED_PIPE;
 427 #endif /* defined(_AIX) || defined(__DragonFly__) */
 428
 429     if (ss.ss_family == AF_INET || ss.ss_family == AF_INET6)
 430       return UV_TCP;
 431     if (ss.ss_family == AF_UNIX)
 432       return UV_NAMED_PIPE;
 433   }
 434
 435   return UV_UNKNOWN_HANDLE;
 436 }
 437
 438 #if !defined(CMAKE_BOOTSTRAP)
 439
 440 /* This function is async signal-safe, meaning that it's safe to call from
 441  * inside a signal handler _unless_ execution was inside uv_tty_set_mode()'s
 442  * critical section when the signal was raised.
 443  */
 444 int uv_tty_reset_mode(void) {
 445   int saved_errno;
 446   int err;
 447
 448   saved_errno = errno;
 449   if (!uv_spinlock_trylock(&termios_spinlock))
 450     return UV_EBUSY;  /* In uv_tty_set_mode(). */
 451
 452   err = 0;
 453   if (orig_termios_fd != -1)
 454     err = uv__tcsetattr(orig_termios_fd, TCSANOW, &orig_termios);
 455
 456   uv_spinlock_unlock(&termios_spinlock);
 457   errno = saved_errno;
 458
 459   return err;
 460 }
 461
 462 void uv_tty_set_vterm_state(uv_tty_vtermstate_t state) {
 463 }
 464
 465 int uv_tty_get_vterm_state(uv_tty_vtermstate_t* state) {
 466   return UV_ENOTSUP;
 467 }
 468
 469 #endif