sshpty.c

   1 /* $OpenBSD: sshpty.c,v 1.20 2006/07/02 22:45:59 stevesk Exp $ */
   2 /*
   3  * Author: Tatu Ylonen <ylo@cs.hut.fi>
   4  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   5  *                    All rights reserved
   6  * Allocating a pseudo-terminal, and making it the controlling tty.
   7  *
   8  * As far as I am concerned, the code I have written for this software
   9  * can be used freely for any purpose.  Any derived versions of this
  10  * software must be clearly marked as such, and if the derived work is
  11  * incompatible with the protocol description in the RFC file, it must be
  12  * called by a name other than "ssh" or "Secure Shell".
  13  */
  14
  15 #include "includes.h"
  16
  17 #include <sys/ioctl.h>
  18 #include <sys/types.h>
  19 #include <sys/stat.h>
  20 #include <signal.h>
  21
  22 #include <grp.h>
  23 #ifdef HAVE_PATHS_H
  24 # include <paths.h>
  25 #endif
  26 #include <termios.h>
  27 #ifdef HAVE_UTIL_H
  28 # include <util.h>
  29 #endif /* HAVE_UTIL_H */
  30
  31 #include "sshpty.h"
  32 #include "log.h"
  33 #include "misc.h"
  34
  35 #ifdef HAVE_PTY_H
  36 # include <pty.h>
  37 #endif
  38
  39 #ifndef O_NOCTTY
  40 #define O_NOCTTY 0
  41 #endif
  42
  43 /*
  44  * Allocates and opens a pty.  Returns 0 if no pty could be allocated, or
  45  * nonzero if a pty was successfully allocated.  On success, open file
  46  * descriptors for the pty and tty sides and the name of the tty side are
  47  * returned (the buffer must be able to hold at least 64 characters).
  48  */
  49
  50 int
  51 pty_allocate(int *ptyfd, int *ttyfd, char *namebuf, size_t namebuflen)
  52 {
  53         /* openpty(3) exists in OSF/1 and some other os'es */
  54         char *name;
  55         int i;
  56
  57         i = openpty(ptyfd, ttyfd, NULL, NULL, NULL);
  58         if (i < 0) {
  59                 error("openpty: %.100s", strerror(errno));
  60                 return 0;
  61         }
  62         name = ttyname(*ttyfd);
  63         if (!name)
  64                 fatal("openpty returns device for which ttyname fails.");
  65
  66         strlcpy(namebuf, name, namebuflen);     /* possible truncation */
  67         return 1;
  68 }
  69
  70 /* Releases the tty.  Its ownership is returned to root, and permissions to 0666. */
  71
  72 void
  73 pty_release(const char *tty)
  74 {
  75         if (chown(tty, (uid_t) 0, (gid_t) 0) < 0)
  76                 error("chown %.100s 0 0 failed: %.100s", tty, strerror(errno));
  77         if (chmod(tty, (mode_t) 0666) < 0)
  78                 error("chmod %.100s 0666 failed: %.100s", tty, strerror(errno));
  79 }
  80
  81 /* Makes the tty the process's controlling tty and sets it to sane modes. */
  82
  83 void
  84 pty_make_controlling_tty(int *ttyfd, const char *tty)
  85 {
  86         int fd;
  87 #ifdef USE_VHANGUP
  88         void *old;
  89 #endif /* USE_VHANGUP */
  90
  91 #ifdef _UNICOS
  92         if (setsid() < 0)
  93                 error("setsid: %.100s", strerror(errno));
  94
  95         fd = open(tty, O_RDWR|O_NOCTTY);
  96         if (fd != -1) {
  97                 signal(SIGHUP, SIG_IGN);
  98                 ioctl(fd, TCVHUP, (char *)NULL);
  99                 signal(SIGHUP, SIG_DFL);
 100                 setpgid(0, 0);
 101                 close(fd);
 102         } else {
 103                 error("Failed to disconnect from controlling tty.");
 104         }
 105
 106         debug("Setting controlling tty using TCSETCTTY.");
 107         ioctl(*ttyfd, TCSETCTTY, NULL);
 108         fd = open("/dev/tty", O_RDWR);
 109         if (fd < 0)
 110                 error("%.100s: %.100s", tty, strerror(errno));
 111         close(*ttyfd);
 112         *ttyfd = fd;
 113 #else /* _UNICOS */
 114
 115         /* First disconnect from the old controlling tty. */
 116 #ifdef TIOCNOTTY
 117         fd = open(_PATH_TTY, O_RDWR | O_NOCTTY);
 118         if (fd >= 0) {
 119                 (void) ioctl(fd, TIOCNOTTY, NULL);
 120                 close(fd);
 121         }
 122 #endif /* TIOCNOTTY */
 123         if (setsid() < 0)
 124                 error("setsid: %.100s", strerror(errno));
 125
 126         /*
 127          * Verify that we are successfully disconnected from the controlling
 128          * tty.
 129          */
 130         fd = open(_PATH_TTY, O_RDWR | O_NOCTTY);
 131         if (fd >= 0) {
 132                 error("Failed to disconnect from controlling tty.");
 133                 close(fd);
 134         }
 135         /* Make it our controlling tty. */
 136 #ifdef TIOCSCTTY
 137         debug("Setting controlling tty using TIOCSCTTY.");
 138         if (ioctl(*ttyfd, TIOCSCTTY, NULL) < 0)
 139                 error("ioctl(TIOCSCTTY): %.100s", strerror(errno));
 140 #endif /* TIOCSCTTY */
 141 #ifdef NEED_SETPGRP
 142         if (setpgrp(0,0) < 0)
 143                 error("SETPGRP %s",strerror(errno));
 144 #endif /* NEED_SETPGRP */
 145 #ifdef USE_VHANGUP
 146         old = signal(SIGHUP, SIG_IGN);
 147         vhangup();
 148         signal(SIGHUP, old);
 149 #endif /* USE_VHANGUP */
 150         fd = open(tty, O_RDWR);
 151         if (fd < 0) {
 152                 error("%.100s: %.100s", tty, strerror(errno));
 153         } else {
 154 #ifdef USE_VHANGUP
 155                 close(*ttyfd);
 156                 *ttyfd = fd;
 157 #else /* USE_VHANGUP */
 158                 close(fd);
 159 #endif /* USE_VHANGUP */
 160         }
 161         /* Verify that we now have a controlling tty. */
 162         fd = open(_PATH_TTY, O_WRONLY);
 163         if (fd < 0)
 164                 error("open /dev/tty failed - could not set controlling tty: %.100s",
 165                     strerror(errno));
 166         else
 167                 close(fd);
 168 #endif /* _UNICOS */
 169 }
 170
 171 /* Changes the window size associated with the pty. */
 172
 173 void
 174 pty_change_window_size(int ptyfd, u_int row, u_int col,
 175         u_int xpixel, u_int ypixel)
 176 {
 177         struct winsize w;
 178
 179         /* may truncate u_int -> u_short */
 180         w.ws_row = row;
 181         w.ws_col = col;
 182         w.ws_xpixel = xpixel;
 183         w.ws_ypixel = ypixel;
 184         (void) ioctl(ptyfd, TIOCSWINSZ, &w);
 185 }
 186
 187 void
 188 pty_setowner(struct passwd *pw, const char *tty)
 189 {
 190         struct group *grp;
 191         gid_t gid;
 192         mode_t mode;
 193         struct stat st;
 194
 195         /* Determine the group to make the owner of the tty. */
 196         grp = getgrnam("tty");
 197         if (grp) {
 198                 gid = grp->gr_gid;
 199                 mode = S_IRUSR | S_IWUSR | S_IWGRP;
 200         } else {
 201                 gid = pw->pw_gid;
 202                 mode = S_IRUSR | S_IWUSR | S_IWGRP | S_IWOTH;
 203         }
 204
 205         /*
 206          * Change owner and mode of the tty as required.
 207          * Warn but continue if filesystem is read-only and the uids match/
 208          * tty is owned by root.
 209          */
 210         if (stat(tty, &st))
 211                 fatal("stat(%.100s) failed: %.100s", tty,
 212                     strerror(errno));
 213
 214 #ifdef WITH_SELINUX
 215         ssh_selinux_setup_pty(pw->pw_name, tty);
 216 #endif
 217
 218         if (st.st_uid != pw->pw_uid || st.st_gid != gid) {
 219                 if (chown(tty, pw->pw_uid, gid) < 0) {
 220                         if (errno == EROFS &&
 221                             (st.st_uid == pw->pw_uid || st.st_uid == 0))
 222                                 debug("chown(%.100s, %u, %u) failed: %.100s",
 223                                     tty, (u_int)pw->pw_uid, (u_int)gid,
 224                                     strerror(errno));
 225                         else
 226                                 fatal("chown(%.100s, %u, %u) failed: %.100s",
 227                                     tty, (u_int)pw->pw_uid, (u_int)gid,
 228                                     strerror(errno));
 229                 }
 230         }
 231
 232         if ((st.st_mode & (S_IRWXU|S_IRWXG|S_IRWXO)) != mode) {
 233                 if (chmod(tty, mode) < 0) {
 234                         if (errno == EROFS &&
 235                             (st.st_mode & (S_IRGRP | S_IROTH)) == 0)
 236                                 debug("chmod(%.100s, 0%o) failed: %.100s",
 237                                     tty, (u_int)mode, strerror(errno));
 238                         else
 239                                 fatal("chmod(%.100s, 0%o) failed: %.100s",
 240                                     tty, (u_int)mode, strerror(errno));
 241                 }
 242         }
 243 }