kdesu/process.cpp

   1 /* vi: ts=8 sts=4 sw=4
   2  *
   3  * This file is part of the KDE project, module kdesu.
   4  * Copyright (C) 1999,2000 Geert Jansen <jansen@kde.org>
   5  *
   6  * This file contains code from TEShell.C of the KDE konsole.
   7  * Copyright (c) 1997,1998 by Lars Doelle <lars.doelle@on-line.de>
   8  *
   9  * This is free software; you can use this library under the GNU Library
  10  * General Public License, version 2. See the file "COPYING.LIB" for the
  11  * exact licensing terms.
  12  *
  13  * process.cpp: Functionality to build a front end to password asking
  14  *  terminal programs.
  15  */
  16
  17 #include "process.h"
  18 #include "kcookie.h"
  19
  20 #include <config.h>
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25 #include <fcntl.h>
  26 #include <signal.h>
  27 #include <errno.h>
  28 #include <string.h>
  29 #include <termios.h>
  30
  31 #include <sys/types.h>
  32 #include <sys/wait.h>
  33 #include <sys/stat.h>
  34 #include <sys/time.h>
  35 #include <sys/resource.h>
  36
  37 #ifdef HAVE_SYS_SELECT_H
  38 #include <sys/select.h>                // Needed on some systems.
  39 #endif
  40
  41 #include <QtCore/QBool>
  42 #include <QtCore/QFile>
  43
  44 #include <ksharedconfig.h>
  45 #include <kconfiggroup.h>
  46 #include <kdebug.h>
  47 #include <kstandarddirs.h>
  48 #include <kde_file.h>
  49
  50
  51 namespace KDESu {
  52
  53 using namespace KDESuPrivate;
  54
  55 /*
  56 ** Wait for @p ms miliseconds
  57 ** @param fd file descriptor
  58 ** @param ms time to wait in miliseconds
  59 ** @return
  60 */
  61 int PtyProcess::waitMS(int fd,int ms)
  62 {
  63         struct timeval tv;
  64         tv.tv_sec = 0;
  65         tv.tv_usec = 1000*ms;
  66
  67         fd_set fds;
  68         FD_ZERO(&fds);
  69         FD_SET(fd,&fds);
  70         return select(fd+1, &fds, 0L, 0L, &tv);
  71 }
  72
  73 // XXX this function is nonsense:
  74 // - for our child, we could use waitpid().
  75 // - the configurability at this place it *complete* braindamage
  76 /*
  77 ** Basic check for the existence of @p pid.
  78 ** Returns true iff @p pid is an extant process.
  79 */
  80 bool PtyProcess::checkPid(pid_t pid)
  81 {
  82     KSharedConfig::Ptr config = KGlobal::config();
  83     KConfigGroup cg(config, "super-user-command");
  84     QString superUserCommand = cg.readEntry("super-user-command", "sudo");
  85     //sudo does not accept signals from user so we except it
  86     if (superUserCommand == "sudo") {
  87         return true;
  88     } else {
  89         return kill(pid, 0) == 0;
  90     }
  91 }
  92
  93 /*
  94 ** Check process exit status for process @p pid.
  95 ** On error (no child, no exit), return Error (-1).
  96 ** If child @p pid has exited, return its exit status,
  97 ** (which may be zero).
  98 ** If child @p has not exited, return NotExited (-2).
  99 */
 100
 101 int PtyProcess::checkPidExited(pid_t pid)
 102 {
 103         int state, ret;
 104         ret = waitpid(pid, &state, WNOHANG);
 105
 106         if (ret < 0)
 107         {
 108                 kError(900) << k_lineinfo << "waitpid(): " << perror << "\n";
 109                 return Error;
 110         }
 111         if (ret == pid)
 112         {
 113                 if (WIFEXITED(state))
 114                         return WEXITSTATUS(state);
 115                 return Killed;
 116         }
 117
 118         return NotExited;
 119 }
 120
 121
 122 class PtyProcess::PtyProcessPrivate
 123 {
 124 public:
 125     PtyProcessPrivate() : m_pPTY(0L) {}
 126     ~PtyProcessPrivate()
 127     {
 128         delete m_pPTY;
 129     }
 130     QList<QByteArray> env;
 131     KPty *m_pPTY;
 132     QByteArray m_Inbuf;
 133 };
 134
 135
 136 PtyProcess::PtyProcess()
 137     :d(new PtyProcessPrivate)
 138 {
 139     m_bTerminal = false;
 140     m_bErase = false;
 141 }
 142
 143
 144 int PtyProcess::init()
 145 {
 146     delete d->m_pPTY;
 147     d->m_pPTY = new KPty();
 148     if (!d->m_pPTY->open())
 149     {
 150         kError(900) << k_lineinfo << "Failed to open PTY.\n";
 151         return -1;
 152     }
 153     d->m_Inbuf.resize(0);
 154     return 0;
 155 }
 156
 157
 158 PtyProcess::~PtyProcess()
 159 {
 160     delete d;
 161 }
 162
 163 /** Set additional environment variables. */
 164 void PtyProcess::setEnvironment( const QList<QByteArray> &env )
 165 {
 166     d->env = env;
 167 }
 168
 169 int PtyProcess::fd() const
 170 {
 171     return d->m_pPTY ? d->m_pPTY->masterFd() : -1;
 172 }
 173
 174 int PtyProcess::pid() const
 175 {
 176     return m_Pid;
 177 }
 178
 179 /** Returns the additional environment variables set by setEnvironment() */
 180 QList<QByteArray> PtyProcess::environment() const
 181 {
 182     return d->env;
 183 }
 184
 185
 186 QByteArray PtyProcess::readAll(bool block)
 187 {
 188     QByteArray ret;
 189     if (!d->m_Inbuf.isEmpty())
 190     {
 191         // if there is still something in the buffer, we need not block.
 192         // we should still try to read any further output, from the fd, though.
 193         block = false;
 194         ret = d->m_Inbuf;
 195         d->m_Inbuf.resize(0);
 196     }
 197
 198     int flags = fcntl(fd(), F_GETFL);
 199     if (flags < 0)
 200     {
 201         kError(900) << k_lineinfo << "fcntl(F_GETFL): " << perror << "\n";
 202         return ret;
 203     }
 204     int oflags = flags;
 205     if (block)
 206         flags &= ~O_NONBLOCK;
 207     else
 208         flags |= O_NONBLOCK;
 209
 210     if ((flags != oflags) && (fcntl(fd(), F_SETFL, flags) < 0))
 211     {
 212        // We get an error here when the child process has closed
 213        // the file descriptor already.
 214        return ret;
 215     }
 216
 217     int nbytes;
 218     char buf[256];
 219     while (1)
 220     {
 221         nbytes = read(fd(), buf, 255);
 222         if (nbytes == -1)
 223         {
 224             if (errno == EINTR)
 225                 continue;
 226             else break;
 227         }
 228         if (nbytes == 0)
 229             break;        // nothing available / eof
 230
 231         buf[nbytes] = '\000';
 232         ret += buf;
 233         break;
 234     }
 235
 236     return ret;
 237 }
 238
 239
 240 QByteArray PtyProcess::readLine(bool block)
 241 {
 242     d->m_Inbuf = readAll(block);
 243
 244     int pos;
 245     QByteArray ret;
 246     if (!d->m_Inbuf.isEmpty())
 247     {
 248         pos = d->m_Inbuf.indexOf('\n');
 249         if (pos == -1)
 250         {
 251             // NOTE: this means we return something even if there in no full line!
 252             ret = d->m_Inbuf;
 253             d->m_Inbuf.resize(0);
 254         } else
 255         {
 256             ret = d->m_Inbuf.left(pos);
 257             d->m_Inbuf = d->m_Inbuf.mid(pos+1);
 258         }
 259     }
 260
 261     return ret;
 262 }
 263
 264
 265 void PtyProcess::writeLine(const QByteArray &line, bool addnl)
 266 {
 267     if (!line.isEmpty())
 268         write(fd(), line, line.length());
 269     if (addnl)
 270         write(fd(), "\n", 1);
 271 }
 272
 273
 274 void PtyProcess::unreadLine(const QByteArray &line, bool addnl)
 275 {
 276     QByteArray tmp = line;
 277     if (addnl)
 278         tmp += '\n';
 279     if (!tmp.isEmpty())
 280         d->m_Inbuf.prepend(tmp);
 281 }
 282
 283 void PtyProcess::setExitString(const QByteArray &exit)
 284 {
 285     m_Exit = exit;
 286 }
 287
 288 /*
 289  * Fork and execute the command. This returns in the parent.
 290  */
 291
 292 int PtyProcess::exec(const QByteArray &command, const QList<QByteArray> &args)
 293 {
 294     kDebug(900) << k_lineinfo << "Running `" << command << "'\n";
 295     int i;
 296
 297     if (init() < 0)
 298         return -1;
 299
 300     if ((m_Pid = fork()) == -1)
 301     {
 302         kError(900) << k_lineinfo << "fork(): " << perror << "\n";
 303         return -1;
 304     }
 305
 306     // Parent
 307     if (m_Pid)
 308     {
 309         d->m_pPTY->closeSlave();
 310         return 0;
 311     }
 312
 313     // Child
 314     if (setupTTY() < 0)
 315         _exit(1);
 316
 317     for (i = 0; i < d->env.count(); ++i)
 318     {
 319         putenv(const_cast<char *>(d->env.at(i).constData()));
 320     }
 321     unsetenv("KDE_FULL_SESSION");
 322     // for : Qt: Session management error
 323     unsetenv("SESSION_MANAGER");
 324     // QMutex::lock , deadlocks without that.
 325     // <thiago> you cannot connect to the user's session bus from another UID
 326     unsetenv("DBUS_SESSION_BUS_ADDRESS");
 327
 328     // set temporarily LC_ALL to C, for su (to be able to parse "Password:")
 329     const QByteArray old_lc_all = qgetenv( "LC_ALL" );
 330     if( !old_lc_all.isEmpty() )
 331         qputenv( "KDESU_LC_ALL", old_lc_all );
 332     else
 333         unsetenv( "KDESU_LC_ALL" );
 334     qputenv("LC_ALL", "C");
 335
 336     // From now on, terminal output goes through the tty.
 337
 338     QByteArray path;
 339     if (command.contains('/'))
 340         path = command;
 341     else
 342     {
 343         QString file = KStandardDirs::findExe(command);
 344         if (file.isEmpty())
 345         {
 346             kError(900) << k_lineinfo << command << " not found\n";
 347             _exit(1);
 348         }
 349         path = QFile::encodeName(file);
 350     }
 351
 352     const char **argp = (const char **)malloc((args.count()+2)*sizeof(char *));
 353
 354     i = 0;
 355     argp[i++] = path;
 356     for (QList<QByteArray>::ConstIterator it=args.begin(); it!=args.end(); ++it, ++i)
 357         argp[i] = *it;
 358
 359     argp[i] = NULL;
 360
 361     execv(path, const_cast<char **>(argp));
 362     kError(900) << k_lineinfo << "execv(\"" << path << "\"): " << perror << "\n";
 363     _exit(1);
 364     return -1; // Shut up compiler. Never reached.
 365 }
 366
 367
 368 /*
 369  * Wait until the terminal is set into no echo mode. At least one su
 370  * (RH6 w/ Linux-PAM patches) sets noecho mode AFTER writing the Password:
 371  * prompt, using TCSAFLUSH. This flushes the terminal I/O queues, possibly
 372  * taking the password  with it. So we wait until no echo mode is set
 373  * before writing the password.
 374  * Note that this is done on the slave fd. While Linux allows tcgetattr() on
 375  * the master side, Solaris doesn't.
 376  */
 377
 378 int PtyProcess::WaitSlave()
 379 {
 380     kDebug(900) << k_lineinfo << "Child pid " << m_Pid;
 381
 382     struct termios tio;
 383     while (1)
 384     {
 385         if (!checkPid(m_Pid))
 386         {
 387             return -1;
 388         }
 389         if (!d->m_pPTY->tcGetAttr(&tio))
 390         {
 391             kError(900) << k_lineinfo << "tcgetattr(): " << perror << "\n";
 392             return -1;
 393         }
 394         if (tio.c_lflag & ECHO)
 395         {
 396             kDebug(900) << k_lineinfo << "Echo mode still on.\n";
 397             usleep(10000);
 398             continue;
 399         }
 400         break;
 401     }
 402     return 0;
 403 }
 404
 405
 406 int PtyProcess::enableLocalEcho(bool enable)
 407 {
 408     return d->m_pPTY->setEcho(enable) ? 0 : -1;
 409 }
 410
 411
 412 void PtyProcess::setTerminal(bool terminal)
 413 {
 414     m_bTerminal = terminal;
 415 }
 416
 417 void PtyProcess::setErase(bool erase)
 418 {
 419     m_bErase = erase;
 420 }
 421
 422 /*
 423  * Copy output to stdout until the child process exists, or a line of output
 424  * matches `m_Exit'.
 425  * We have to use waitpid() to test for exit. Merely waiting for EOF on the
 426  * pty does not work, because the target process may have children still
 427  * attached to the terminal.
 428  */
 429
 430 int PtyProcess::waitForChild()
 431 {
 432     fd_set fds;
 433     FD_ZERO(&fds);
 434
 435     while (1)
 436     {
 437         FD_SET(fd(), &fds);
 438
 439         // specify timeout to make sure select() does not block, even if the
 440         // process is dead / non-responsive. It does not matter if we abort too
 441         // early. In that case 0 is returned, and we'll try again in the next
 442         // iteration. (As long as we don't consitently time out in each iteration)
 443         timeval timeout;
 444         timeout.tv_sec = 0;
 445         timeout.tv_usec = 100000;
 446         int ret = select(fd()+1, &fds, 0L, 0L, &timeout);
 447         if (ret == -1)
 448         {
 449             if (errno != EINTR)
 450             {
 451                 kError(900) << k_lineinfo << "select(): " << perror << "\n";
 452                 return -1;
 453             }
 454             ret = 0;
 455         }
 456
 457         if (ret)
 458         {
 459             QByteArray output = readAll(false);
 460             bool lineStart = true;
 461             while (!output.isNull())
 462             {
 463                 if (!m_Exit.isEmpty())
 464                 {
 465                     // match exit string only at line starts
 466                     int pos = output.indexOf(m_Exit);
 467                     if ((pos >= 0) && ((pos == 0 && lineStart) || (output.at (pos - 1) == '\n')))
 468                     {
 469                         kill(m_Pid, SIGTERM);
 470                     }
 471                 }
 472                 if (m_bTerminal)
 473                 {
 474                     fputs(output, stdout);
 475                     fflush(stdout);
 476                 }
 477                 lineStart = output.endsWith( '\n' );
 478                 output = readAll(false);
 479             }
 480         }
 481
 482         ret = checkPidExited(m_Pid);
 483         if (ret == Error)
 484         {
 485             if (errno == ECHILD) return 0;
 486             else return 1;
 487         }
 488         else if (ret == Killed)
 489         {
 490             return 0;
 491         }
 492         else if (ret == NotExited)
 493         {
 494             // keep checking
 495         }
 496         else
 497         {
 498             return ret;
 499         }
 500     }
 501 }
 502
 503 /*
 504  * SetupTTY: Creates a new session. The filedescriptor "fd" should be
 505  * connected to the tty. It is closed after the tty is reopened to make it
 506  * our controlling terminal. This way the tty is always opened at least once
 507  * so we'll never get EIO when reading from it.
 508  */
 509
 510 int PtyProcess::setupTTY()
 511 {
 512     // Reset signal handlers
 513     for (int sig = 1; sig < NSIG; sig++)
 514         KDE_signal(sig, SIG_DFL);
 515     KDE_signal(SIGHUP, SIG_IGN);
 516
 517     d->m_pPTY->setCTty();
 518
 519     // Connect stdin, stdout and stderr
 520     int slave = d->m_pPTY->slaveFd();
 521     dup2(slave, 0); dup2(slave, 1); dup2(slave, 2);
 522
 523     // Close all file handles
 524     // XXX this caused problems in KProcess - not sure why anymore. -- ???
 525     // Because it will close the start notification pipe. -- ossi
 526     struct rlimit rlp;
 527     getrlimit(RLIMIT_NOFILE, &rlp);
 528     for (int i = 3; i < (int)rlp.rlim_cur; i++)
 529         close(i);
 530
 531     // Disable OPOST processing. Otherwise, '\n' are (on Linux at least)
 532     // translated to '\r\n'.
 533     struct ::termios tio;
 534     if (tcgetattr(0, &tio) < 0)
 535     {
 536         kError(900) << k_lineinfo << "tcgetattr(): " << perror << "\n";
 537         return -1;
 538     }
 539     tio.c_oflag &= ~OPOST;
 540     if (tcsetattr(0, TCSANOW, &tio) < 0)
 541     {
 542         kError(900) << k_lineinfo << "tcsetattr(): " << perror << "\n";
 543         return -1;
 544     }
 545
 546     return 0;
 547 }
 548
 549 void PtyProcess::virtual_hook( int, void* )
 550 { /*BASE::virtual_hook( id, data );*/ }
 551
 552 }