runtime/kioslave/sftp/process.cpp

   1 /* vi: ts=8 sts=4 sw=4
   2  *
   3  *
   4  * This file is part of the KDE project, module kdesu.
   5  * Copyright (C) 1999,2000 Geert Jansen <jansen@kde.org>
   6  *
   7  * This file contains code from TEShell.C of the KDE konsole.
   8  * Copyright (c) 1997,1998 by Lars Doelle <lars.doelle@on-line.de>
   9  *
  10  * This is free software; you can use this library under the GNU Library
  11  * General Public License, version 2. See the file "COPYING.LIB" for the
  12  * exact licensing terms.
  13  *
  14  * process.cpp: Functionality to build a front end to password asking
  15  *  terminal programs.
  16  */
  17
  18 #include "process.h"
  19
  20 #include <config-runtime.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
  30 #ifndef Q_WS_WIN
  31 #include <termios.h>
  32 #endif
  33
  34 #include <sys/types.h>
  35 #include <sys/wait.h>
  36 #include <sys/stat.h>
  37 #include <sys/time.h>
  38 #include <sys/resource.h>
  39 #include <sys/socket.h>
  40
  41 #if defined(__SVR4) && defined(sun)
  42 #include <stropts.h>
  43 #include <sys/stream.h>
  44 #endif
  45
  46 #ifdef HAVE_SYS_SELECT_H
  47 #include <sys/select.h>         // Needed on some systems.
  48 #endif
  49
  50 #include <QtCore/QBool>
  51 #include <QFile>
  52
  53 #include <kdebug.h>
  54 #include <kstandarddirs.h>
  55
  56 MyPtyProcess::MyPtyProcess()
  57 {
  58     m_bTerminal = false;
  59     m_bErase = false;
  60     m_pPTY = 0L;
  61     m_Pid = -1;
  62 }
  63
  64
  65 int MyPtyProcess::init()
  66 {
  67     delete m_pPTY;
  68 #ifndef Q_WS_WIN
  69     m_pPTY = new KPty();
  70     if (!m_pPTY->open())
  71     {
  72         kError(PTYPROC) << k_lineinfo << "Master setup failed.\n" << endl;
  73         return -1;
  74     }
  75 #else
  76     m_pPTY = new KProcess();
  77     m_pPTY->setOutputChannelMode(KProcess::MergedChannels);
  78 #endif
  79
  80     m_stdoutBuf.resize(0);
  81     m_stderrBuf.resize(0);
  82     m_ptyBuf.resize(0);
  83     return 0;
  84 }
  85
  86
  87 MyPtyProcess::~MyPtyProcess()
  88 {
  89     delete m_pPTY;
  90 }
  91
  92
  93 /*
  94  * Read one line of input. The terminal is in canonical mode, so you always
  95  * read a line at at time, but it's possible to receive multiple lines in
  96  * one time.
  97  */
  98
  99
 100 QByteArray MyPtyProcess::readLineFrom(int fd, QByteArray& inbuf, bool block)
 101 {
 102     int pos;
 103     QByteArray ret;
 104
 105     if (!inbuf.isEmpty())
 106     {
 107         pos = inbuf.indexOf('\n');
 108         if (pos == -1)
 109         {
 110             ret = inbuf;
 111             inbuf.resize(0);
 112         } else
 113         {
 114             ret = inbuf.left(pos);
 115 #ifdef Q_WS_WIN
 116             if( ret.endsWith('\r') )
 117             {
 118                 ret.chop(1);
 119             }
 120 #endif
 121             inbuf = inbuf.mid(pos+1);
 122         }
 123         return ret;
 124
 125     }
 126
 127 #ifdef Q_WS_WIN
 128     if( m_pPTY->waitForReadyRead(60000) )
 129     {
 130         inbuf = m_pPTY->readAll();
 131         pos = inbuf.indexOf('\n');
 132         if (pos == -1)
 133         {
 134             ret = inbuf;
 135             inbuf.resize(0);
 136         } else
 137         {
 138             ret = inbuf.left(pos);
 139             if( ret.endsWith('\r') )
 140             {
 141                 ret.chop(1);
 142             }
 143             inbuf = inbuf.mid(pos+1);
 144         }
 145     }
 146     return ret;
 147 #else
 148     int flags = fcntl(fd, F_GETFL);
 149     if (flags < 0)
 150     {
 151         kError(PTYPROC) << k_lineinfo << "fcntl(F_GETFL): " << perror << "\n";
 152         return ret;
 153     }
 154     if (block)
 155         flags &= ~O_NONBLOCK;
 156     else
 157         flags |= O_NONBLOCK;
 158     if (fcntl(fd, F_SETFL, flags) < 0)
 159     {
 160         kError(PTYPROC) << k_lineinfo << "fcntl(F_SETFL): " << perror << "\n";
 161         return ret;
 162     }
 163
 164     int nbytes;
 165     char buf[256];
 166     while (1)
 167     {
 168         nbytes = read(fd, buf, 255);
 169         if (nbytes == -1)
 170         {
 171             if (errno == EINTR)
 172                 continue;
 173             else break;
 174         }
 175         if (nbytes == 0)
 176             break;      // eof
 177
 178         buf[nbytes] = '\000';
 179         inbuf += buf;
 180
 181         pos = inbuf.indexOf('\n');
 182         if (pos == -1)
 183         {
 184             ret = inbuf;
 185             inbuf.resize(0);
 186         } else
 187         {
 188             ret = inbuf.left(pos);
 189             inbuf = inbuf.mid(pos+1);
 190         }
 191         break;
 192
 193     }
 194
 195     return ret;
 196 #endif
 197 }
 198
 199 void MyPtyProcess::writeLine(QByteArray line, bool addnl)
 200 {
 201     if (!line.isEmpty())
 202 #ifndef Q_WS_WIN
 203         write(fd(), line, line.length());
 204 #else
 205         m_pPTY->write(line);
 206 #endif
 207     if (addnl)
 208 #ifndef Q_WS_WIN
 209         write(fd(), "\n", 1);
 210 #else
 211         m_pPTY->write("\r\n");
 212 #endif
 213 }
 214
 215 void MyPtyProcess::unreadLineFrom(QByteArray inbuf, QByteArray line, bool addnl)
 216 {
 217     if (addnl)
 218         line += '\n';
 219     if (!line.isEmpty())
 220         inbuf.prepend(line);
 221 }
 222
 223
 224 /*
 225  * Fork and execute the command. This returns in the parent.
 226  */
 227
 228 int MyPtyProcess::exec(QByteArray command, QCStringList args)
 229 {
 230   kDebug(PTYPROC) << "MyPtyProcess::exec(): " << command;// << ", args = " << args ;
 231     if (init() < 0)
 232         return -1;
 233 #ifdef Q_WS_WIN
 234     QStringList ar;
 235     for(int i = 0; i < args.size(); ++i)
 236     {
 237         ar << args[i];
 238     }
 239     m_pPTY->setProgram(command, ar);
 240     m_pPTY->start();
 241     return 0;
 242 #else
 243     // Open the pty slave before forking. See SetupTTY()
 244     int slave = open(m_pPTY->ttyName(), O_RDWR);
 245     if (slave < 0)
 246     {
 247         kError(PTYPROC) << k_lineinfo << "Could not open slave pty.\n";
 248         return -1;
 249     }
 250
 251     // Also create a socket pair to connect to standard in/out.
 252     // This will allow use to bypass the terminal.
 253     int inout[2];
 254     int err[2];
 255     int ok = 1;
 256     ok &= socketpair(AF_UNIX, SOCK_STREAM, 0, inout) >= 0;
 257     ok &= socketpair(AF_UNIX, SOCK_STREAM, 0, err  ) >= 0;
 258     if( !ok ) {
 259         kDebug(PTYPROC) << "Could not create socket";
 260         close(slave);
 261         return -1;
 262     }
 263     m_stdinout = inout[0];
 264     m_err = err[0];
 265
 266     if ((m_Pid = fork()) == -1)
 267     {
 268         kError(PTYPROC) << k_lineinfo << "fork(): " << perror << "\n";
 269         return -1;
 270     }
 271
 272     // Parent
 273     if (m_Pid)
 274     {
 275             close(slave);
 276         close(inout[1]);
 277             close(err[1]);
 278         return 0;
 279     }
 280
 281     // Child
 282
 283     ok = 1;
 284     ok &= dup2(inout[1], STDIN_FILENO)  >= 0;
 285     ok &= dup2(inout[1], STDOUT_FILENO) >= 0;
 286     ok &= dup2(err[1],  STDERR_FILENO) >= 0;
 287
 288     if( !ok )
 289     {
 290         kError(PTYPROC) << "dup of socket descriptor failed" << endl;
 291         _exit(1);
 292     }
 293
 294     close(inout[1]);
 295     close(inout[0]);
 296     close(err[1]);
 297     close(err[0]);
 298
 299     if (setupTTY() < 0)
 300             _exit(1);
 301
 302     // From now on, terminal output goes through the tty.
 303     QByteArray path;
 304     if (command.contains('/'))
 305             path = command;
 306     else
 307     {
 308             QString file = KStandardDirs::findExe(command);
 309         if (file.isEmpty())
 310             {
 311                 kError(PTYPROC) << k_lineinfo << command << " not found\n";
 312             _exit(1);
 313             }
 314         path = QFile::encodeName(file);
 315     }
 316
 317     int i;
 318     const char * argp[32];
 319     argp[0] = path;
 320     QCStringList::Iterator it;
 321     for (i=1, it=args.begin(); it!=args.end() && i<31; it++) {
 322         argp[i++] = *it;
 323         kDebug(PTYPROC) << *it;
 324     }
 325     argp[i] = 0L;
 326     execv(path, (char * const *)argp);
 327     kError(PTYPROC) << k_lineinfo << "execv(\"" << path << "\"): " << perror << "\n";
 328     _exit(1);
 329     return -1; // Shut up compiler. Never reached.
 330 #endif
 331 }
 332
 333 /*
 334  * Wait until the terminal is set into no echo mode. At least one su
 335  * (RH6 w/ Linux-PAM patches) sets noecho mode AFTER writing the Password:
 336  * prompt, using TCSAFLUSH. This flushes the terminal I/O queues, possibly
 337  * taking the password  with it. So we wait until no echo mode is set
 338  * before writing the password.
 339  * Note that this is done on the slave fd. While Linux allows tcgetattr() on
 340  * the master side, Solaris doesn't.
 341  */
 342
 343 int MyPtyProcess::WaitSlave()
 344 {
 345 #ifndef Q_WS_WIN
 346     int slave = open(m_pPTY->ttyName(), O_RDWR);
 347     if (slave < 0)
 348     {
 349         kError(PTYPROC) << k_lineinfo << "Could not open slave tty.\n";
 350         return -1;
 351     }
 352
 353     struct termios tio;
 354     struct timeval tv;
 355     while (1)
 356     {
 357         if (tcgetattr(slave, &tio) < 0)
 358         {
 359             kError(PTYPROC) << k_lineinfo << "tcgetattr(): " << perror << "\n";
 360             close(slave);
 361             return -1;
 362         }
 363         if (tio.c_lflag & ECHO)
 364         {
 365             kDebug(PTYPROC) << k_lineinfo << "Echo mode still on.";
 366             // sleep 1/10 sec
 367             tv.tv_sec = 0; tv.tv_usec = 100000;
 368             select(slave, 0L, 0L, 0L, &tv);
 369             continue;
 370         }
 371         break;
 372     }
 373     close(slave);
 374 #endif
 375     return 0;
 376 }
 377
 378
 379 int MyPtyProcess::enableLocalEcho(bool enable)
 380 {
 381 #ifdef Q_WS_WIN
 382     return -1;
 383 #else
 384     return m_pPTY->setEcho(enable) ? 0 : -1;
 385 #endif
 386 }
 387
 388
 389 /*
 390  * Copy output to stdout until the child process exists, or a line of output
 391  * matches `m_Exit'.
 392  * We have to use waitpid() to test for exit. Merely waiting for EOF on the
 393  * pty does not work, because the target process may have children still
 394  * attached to the terminal.
 395  */
 396
 397 int MyPtyProcess::waitForChild()
 398 {
 399 #ifdef Q_WS_WIN
 400     return -1;
 401 #else
 402     int ret, state, retval = 1;
 403     struct timeval tv;
 404
 405     fd_set fds;
 406
 407     while (1)
 408     {
 409         int _fd = fd();
 410         tv.tv_sec = 1; tv.tv_usec = 0;
 411         FD_ZERO(&fds);
 412         if (_fd >= 0)
 413             FD_SET(_fd, &fds);
 414         ret = select(_fd+1, &fds, 0L, 0L, &tv);
 415         if (ret == -1)
 416         {
 417             if (errno == EINTR) continue;
 418             else
 419             {
 420                 kError(PTYPROC) << k_lineinfo << "select(): " << perror << "\n";
 421                 return -1;
 422             }
 423         }
 424
 425         if (ret)
 426         {
 427             QByteArray line = readLine(false);
 428             while (!line.isNull())
 429             {
 430                 if (!m_Exit.isEmpty() && !qstrnicmp(line, m_Exit, m_Exit.length()))
 431                     kill(m_Pid, SIGTERM);
 432                 if (m_bTerminal)
 433                 {
 434                     fputs(line, stdout);
 435                     fputc('\n', stdout);
 436                 }
 437                 line = readLine(false);
 438             }
 439         }
 440
 441         // Check if the process is still alive
 442         ret = waitpid(m_Pid, &state, WNOHANG);
 443         if (ret < 0)
 444         {
 445             if (errno == ECHILD)
 446                 retval = 0;
 447             else
 448                 kError(PTYPROC) << k_lineinfo << "waitpid(): " << perror << "\n";
 449             break;
 450         }
 451         if (ret == m_Pid)
 452         {
 453             if (WIFEXITED(state))
 454                 retval = WEXITSTATUS(state);
 455             break;
 456         }
 457     }
 458
 459     return -retval;
 460 #endif
 461 }
 462
 463 /*
 464  * SetupTTY: Creates a new session. The filedescriptor "fd" should be
 465  * connected to the tty. It is closed after the tty is reopened to make it
 466  * our controlling terminal. This way the tty is always opened at least once
 467  * so we'll never get EIO when reading from it.
 468  */
 469
 470 int MyPtyProcess::setupTTY()
 471 {
 472 #ifndef Q_WS_WIN
 473     // Reset signal handlers
 474     for (int sig = 1; sig < NSIG; sig++)
 475        signal(sig, SIG_DFL);
 476     signal(SIGHUP, SIG_IGN);
 477
 478     // Close all file handles
 479 //    struct rlimit rlp;
 480 //    getrlimit(RLIMIT_NOFILE, &rlp);
 481 //    for (int i = 0; i < (int)rlp.rlim_cur; i++)
 482 //    if (i != fd) close(i);
 483
 484     m_pPTY->setCTty();
 485
 486     // Disable OPOST processing. Otherwise, '\n' are (on Linux at least)
 487     // translated to '\r\n'.
 488     struct ::termios tio;
 489     if (m_pPTY->tcGetAttr(&tio) < 0)
 490     {
 491         kError(PTYPROC) << k_lineinfo << "tcgetattr(): " << perror << "\n";
 492         return -1;
 493     }
 494     tio.c_oflag &= ~OPOST;
 495     if (m_pPTY->tcSetAttr(&tio) < 0)
 496     {
 497         kError(PTYPROC) << k_lineinfo << "tcsetattr(): " << perror << "\n";
 498         return -1;
 499     }
 500 #endif
 501     return 0;
 502 }