lldb/third_party/Python/module/ptyprocess-0.6.0/ptyprocess/ptyprocess.py

   1 import codecs
   2 import errno
   3 import fcntl
   4 import io
   5 import os
   6 import pty
   7 import resource
   8 import signal
   9 import struct
  10 import sys
  11 import termios
  12 import time
  13
  14 try:
  15     import builtins  # Python 3
  16 except ImportError:
  17     import __builtin__ as builtins  # Python 2
  18
  19 # Constants
  20 from pty import (STDIN_FILENO, CHILD)
  21
  22 from .util import which, PtyProcessError
  23
  24 _platform = sys.platform.lower()
  25
  26 # Solaris uses internal __fork_pty(). All others use pty.fork().
  27 _is_solaris = (
  28     _platform.startswith('solaris') or
  29     _platform.startswith('sunos'))
  30
  31 if _is_solaris:
  32     use_native_pty_fork = False
  33     from . import _fork_pty
  34 else:
  35     use_native_pty_fork = True
  36
  37 PY3 = sys.version_info[0] >= 3
  38
  39 if PY3:
  40     def _byte(i):
  41         return bytes([i])
  42 else:
  43     def _byte(i):
  44         return chr(i)
  45
  46     class FileNotFoundError(OSError): pass
  47     class TimeoutError(OSError): pass
  48
  49 _EOF, _INTR = None, None
  50
  51 def _make_eof_intr():
  52     """Set constants _EOF and _INTR.
  53
  54     This avoids doing potentially costly operations on module load.
  55     """
  56     global _EOF, _INTR
  57     if (_EOF is not None) and (_INTR is not None):
  58         return
  59
  60     # inherit EOF and INTR definitions from controlling process.
  61     try:
  62         from termios import VEOF, VINTR
  63         fd = None
  64         for name in 'stdin', 'stdout':
  65             stream = getattr(sys, '__%s__' % name, None)
  66             if stream is None or not hasattr(stream, 'fileno'):
  67                 continue
  68             try:
  69                 fd = stream.fileno()
  70             except ValueError:
  71                 continue
  72         if fd is None:
  73             # no fd, raise ValueError to fallback on CEOF, CINTR
  74             raise ValueError("No stream has a fileno")
  75         intr = ord(termios.tcgetattr(fd)[6][VINTR])
  76         eof = ord(termios.tcgetattr(fd)[6][VEOF])
  77     except (ImportError, OSError, IOError, ValueError, termios.error):
  78         # unless the controlling process is also not a terminal,
  79         # such as cron(1), or when stdin and stdout are both closed.
  80         # Fall-back to using CEOF and CINTR. There
  81         try:
  82             from termios import CEOF, CINTR
  83             (intr, eof) = (CINTR, CEOF)
  84         except ImportError:
  85             #                         ^C, ^D
  86             (intr, eof) = (3, 4)
  87
  88     _INTR = _byte(intr)
  89     _EOF = _byte(eof)
  90
  91 # setecho and setwinsize are pulled out here because on some platforms, we need
  92 # to do this from the child before we exec()
  93
  94 def _setecho(fd, state):
  95     errmsg = 'setecho() may not be called on this platform (it may still be possible to enable/disable echo when spawning the child process)'
  96
  97     try:
  98         attr = termios.tcgetattr(fd)
  99     except termios.error as err:
 100         if err.args[0] == errno.EINVAL:
 101             raise IOError(err.args[0], '%s: %s.' % (err.args[1], errmsg))
 102         raise
 103
 104     if state:
 105         attr[3] = attr[3] | termios.ECHO
 106     else:
 107         attr[3] = attr[3] & ~termios.ECHO
 108
 109     try:
 110         # I tried TCSADRAIN and TCSAFLUSH, but these were inconsistent and
 111         # blocked on some platforms. TCSADRAIN would probably be ideal.
 112         termios.tcsetattr(fd, termios.TCSANOW, attr)
 113     except IOError as err:
 114         if err.args[0] == errno.EINVAL:
 115             raise IOError(err.args[0], '%s: %s.' % (err.args[1], errmsg))
 116         raise
 117
 118 def _setwinsize(fd, rows, cols):
 119     # Some very old platforms have a bug that causes the value for
 120     # termios.TIOCSWINSZ to be truncated. There was a hack here to work
 121     # around this, but it caused problems with newer platforms so has been
 122     # removed. For details see https://github.com/pexpect/pexpect/issues/39
 123     TIOCSWINSZ = getattr(termios, 'TIOCSWINSZ', -2146929561)
 124     # Note, assume ws_xpixel and ws_ypixel are zero.
 125     s = struct.pack('HHHH', rows, cols, 0, 0)
 126     fcntl.ioctl(fd, TIOCSWINSZ, s)
 127
 128 class PtyProcess(object):
 129     '''This class represents a process running in a pseudoterminal.
 130
 131     The main constructor is the :meth:`spawn` classmethod.
 132     '''
 133     string_type = bytes
 134     if PY3:
 135         linesep = os.linesep.encode('ascii')
 136         crlf = '\r\n'.encode('ascii')
 137
 138         @staticmethod
 139         def write_to_stdout(b):
 140             try:
 141                 return sys.stdout.buffer.write(b)
 142             except AttributeError:
 143                 # If stdout has been replaced, it may not have .buffer
 144                 return sys.stdout.write(b.decode('ascii', 'replace'))
 145     else:
 146         linesep = os.linesep
 147         crlf = '\r\n'
 148         write_to_stdout = sys.stdout.write
 149
 150     encoding = None
 151
 152     argv = None
 153     env = None
 154     launch_dir = None
 155
 156     def __init__(self, pid, fd):
 157         _make_eof_intr()  # Ensure _EOF and _INTR are calculated
 158         self.pid = pid
 159         self.fd = fd
 160         readf = io.open(fd, 'rb', buffering=0)
 161         writef = io.open(fd, 'wb', buffering=0, closefd=False)
 162         self.fileobj = io.BufferedRWPair(readf, writef)
 163
 164         self.terminated = False
 165         self.closed = False
 166         self.exitstatus = None
 167         self.signalstatus = None
 168         # status returned by os.waitpid
 169         self.status = None
 170         self.flag_eof = False
 171         # Used by close() to give kernel time to update process status.
 172         # Time in seconds.
 173         self.delayafterclose = 0.1
 174         # Used by terminate() to give kernel time to update process status.
 175         # Time in seconds.
 176         self.delayafterterminate = 0.1
 177
 178     @classmethod
 179     def spawn(
 180             cls, argv, cwd=None, env=None, echo=True, preexec_fn=None,
 181             dimensions=(24, 80)):
 182         '''Start the given command in a child process in a pseudo terminal.
 183
 184         This does all the fork/exec type of stuff for a pty, and returns an
 185         instance of PtyProcess.
 186
 187         If preexec_fn is supplied, it will be called with no arguments in the
 188         child process before exec-ing the specified command.
 189         It may, for instance, set signal handlers to SIG_DFL or SIG_IGN.
 190
 191         Dimensions of the psuedoterminal used for the subprocess can be
 192         specified as a tuple (rows, cols), or the default (24, 80) will be used.
 193         '''
 194         # Note that it is difficult for this method to fail.
 195         # You cannot detect if the child process cannot start.
 196         # So the only way you can tell if the child process started
 197         # or not is to try to read from the file descriptor. If you get
 198         # EOF immediately then it means that the child is already dead.
 199         # That may not necessarily be bad because you may have spawned a child
 200         # that performs some task; creates no stdout output; and then dies.
 201
 202         if not isinstance(argv, (list, tuple)):
 203             raise TypeError("Expected a list or tuple for argv, got %r" % argv)
 204
 205         # Shallow copy of argv so we can modify it
 206         argv = argv[:]
 207         command = argv[0]
 208
 209         command_with_path = which(command)
 210         if command_with_path is None:
 211             raise FileNotFoundError('The command was not found or was not ' +
 212                                     'executable: %s.' % command)
 213         command = command_with_path
 214         argv[0] = command
 215
 216         # [issue #119] To prevent the case where exec fails and the user is
 217         # stuck interacting with a python child process instead of whatever
 218         # was expected, we implement the solution from
 219         # http://stackoverflow.com/a/3703179 to pass the exception to the
 220         # parent process
 221
 222         # [issue #119] 1. Before forking, open a pipe in the parent process.
 223         exec_err_pipe_read, exec_err_pipe_write = os.pipe()
 224
 225         if use_native_pty_fork:
 226             pid, fd = pty.fork()
 227         else:
 228             # Use internal fork_pty, for Solaris
 229             pid, fd = _fork_pty.fork_pty()
 230
 231         # Some platforms must call setwinsize() and setecho() from the
 232         # child process, and others from the primary process. We do both,
 233         # allowing IOError for either.
 234
 235         if pid == CHILD:
 236             # set window size
 237             try:
 238                 _setwinsize(STDIN_FILENO, *dimensions)
 239             except IOError as err:
 240                 if err.args[0] not in (errno.EINVAL, errno.ENOTTY):
 241                     raise
 242
 243             # disable echo if spawn argument echo was unset
 244             if not echo:
 245                 try:
 246                     _setecho(STDIN_FILENO, False)
 247                 except (IOError, termios.error) as err:
 248                     if err.args[0] not in (errno.EINVAL, errno.ENOTTY):
 249                         raise
 250
 251             # [issue #119] 3. The child closes the reading end and sets the
 252             # close-on-exec flag for the writing end.
 253             os.close(exec_err_pipe_read)
 254             fcntl.fcntl(exec_err_pipe_write, fcntl.F_SETFD, fcntl.FD_CLOEXEC)
 255
 256             # Do not allow child to inherit open file descriptors from parent,
 257             # with the exception of the exec_err_pipe_write of the pipe
 258             # Impose ceiling on max_fd: AIX bugfix for users with unlimited
 259             # nofiles where resource.RLIMIT_NOFILE is 2^63-1 and os.closerange()
 260             # occasionally raises out of range error
 261             max_fd = min(1048576, resource.getrlimit(resource.RLIMIT_NOFILE)[0])
 262             os.closerange(3, exec_err_pipe_write)
 263             os.closerange(exec_err_pipe_write+1, max_fd)
 264
 265             if cwd is not None:
 266                 os.chdir(cwd)
 267
 268             if preexec_fn is not None:
 269                 try:
 270                     preexec_fn()
 271                 except Exception as e:
 272                     ename = type(e).__name__
 273                     tosend = '{}:0:{}'.format(ename, str(e))
 274                     if PY3:
 275                         tosend = tosend.encode('utf-8')
 276
 277                     os.write(exec_err_pipe_write, tosend)
 278                     os.close(exec_err_pipe_write)
 279                     os._exit(1)
 280
 281             try:
 282                 if env is None:
 283                     os.execv(command, argv)
 284                 else:
 285                     os.execvpe(command, argv, env)
 286             except OSError as err:
 287                 # [issue #119] 5. If exec fails, the child writes the error
 288                 # code back to the parent using the pipe, then exits.
 289                 tosend = 'OSError:{}:{}'.format(err.errno, str(err))
 290                 if PY3:
 291                     tosend = tosend.encode('utf-8')
 292                 os.write(exec_err_pipe_write, tosend)
 293                 os.close(exec_err_pipe_write)
 294                 os._exit(os.EX_OSERR)
 295
 296         # Parent
 297         inst = cls(pid, fd)
 298
 299         # Set some informational attributes
 300         inst.argv = argv
 301         if env is not None:
 302             inst.env = env
 303         if cwd is not None:
 304             inst.launch_dir = cwd
 305
 306         # [issue #119] 2. After forking, the parent closes the writing end
 307         # of the pipe and reads from the reading end.
 308         os.close(exec_err_pipe_write)
 309         exec_err_data = os.read(exec_err_pipe_read, 4096)
 310         os.close(exec_err_pipe_read)
 311
 312         # [issue #119] 6. The parent reads eof (a zero-length read) if the
 313         # child successfully performed exec, since close-on-exec made
 314         # successful exec close the writing end of the pipe. Or, if exec
 315         # failed, the parent reads the error code and can proceed
 316         # accordingly. Either way, the parent blocks until the child calls
 317         # exec.
 318         if len(exec_err_data) != 0:
 319             try:
 320                 errclass, errno_s, errmsg = exec_err_data.split(b':', 2)
 321                 exctype = getattr(builtins, errclass.decode('ascii'), Exception)
 322
 323                 exception = exctype(errmsg.decode('utf-8', 'replace'))
 324                 if exctype is OSError:
 325                     exception.errno = int(errno_s)
 326             except:
 327                 raise Exception('Subprocess failed, got bad error data: %r'
 328                                     % exec_err_data)
 329             else:
 330                 raise exception
 331
 332         try:
 333             inst.setwinsize(*dimensions)
 334         except IOError as err:
 335             if err.args[0] not in (errno.EINVAL, errno.ENOTTY, errno.ENXIO):
 336                 raise
 337
 338         return inst
 339
 340     def __repr__(self):
 341         clsname = type(self).__name__
 342         if self.argv is not None:
 343             args = [repr(self.argv)]
 344             if self.env is not None:
 345                 args.append("env=%r" % self.env)
 346             if self.launch_dir is not None:
 347                 args.append("cwd=%r" % self.launch_dir)
 348
 349             return "{}.spawn({})".format(clsname, ", ".join(args))
 350
 351         else:
 352             return "{}(pid={}, fd={})".format(clsname, self.pid, self.fd)
 353
 354     @staticmethod
 355     def _coerce_send_string(s):
 356         if not isinstance(s, bytes):
 357             return s.encode('utf-8')
 358         return s
 359
 360     @staticmethod
 361     def _coerce_read_string(s):
 362         return s
 363
 364     def __del__(self):
 365         '''This makes sure that no system resources are left open. Python only
 366         garbage collects Python objects. OS file descriptors are not Python
 367         objects, so they must be handled explicitly. If the child file
 368         descriptor was opened outside of this class (passed to the constructor)
 369         then this does not close it. '''
 370
 371         if not self.closed:
 372             # It is possible for __del__ methods to execute during the
 373             # teardown of the Python VM itself. Thus self.close() may
 374             # trigger an exception because os.close may be None.
 375             try:
 376                 self.close()
 377             # which exception, shouldn't we catch explicitly .. ?
 378             except:
 379                 pass
 380
 381
 382     def fileno(self):
 383         '''This returns the file descriptor of the pty for the child.
 384         '''
 385         return self.fd
 386
 387     def close(self, force=True):
 388         '''This closes the connection with the child application. Note that
 389         calling close() more than once is valid. This emulates standard Python
 390         behavior with files. Set force to True if you want to make sure that
 391         the child is terminated (SIGKILL is sent if the child ignores SIGHUP
 392         and SIGINT). '''
 393         if not self.closed:
 394             self.flush()
 395             self.fileobj.close() # Closes the file descriptor
 396             # Give kernel time to update process status.
 397             time.sleep(self.delayafterclose)
 398             if self.isalive():
 399                 if not self.terminate(force):
 400                     raise PtyProcessError('Could not terminate the child.')
 401             self.fd = -1
 402             self.closed = True
 403             #self.pid = None
 404
 405     def flush(self):
 406         '''This does nothing. It is here to support the interface for a
 407         File-like object. '''
 408
 409         pass
 410
 411     def isatty(self):
 412         '''This returns True if the file descriptor is open and connected to a
 413         tty(-like) device, else False.
 414
 415         On SVR4-style platforms implementing streams, such as SunOS and HP-UX,
 416         the child pty may not appear as a terminal device.  This means
 417         methods such as setecho(), setwinsize(), getwinsize() may raise an
 418         IOError. '''
 419
 420         return os.isatty(self.fd)
 421
 422     def waitnoecho(self, timeout=None):
 423         '''This waits until the terminal ECHO flag is set False. This returns
 424         True if the echo mode is off. This returns False if the ECHO flag was
 425         not set False before the timeout. This can be used to detect when the
 426         child is waiting for a password. Usually a child application will turn
 427         off echo mode when it is waiting for the user to enter a password. For
 428         example, instead of expecting the "password:" prompt you can wait for
 429         the child to set ECHO off::
 430
 431             p = pexpect.spawn('ssh user@example.com')
 432             p.waitnoecho()
 433             p.sendline(mypassword)
 434
 435         If timeout==None then this method to block until ECHO flag is False.
 436         '''
 437
 438         if timeout is not None:
 439             end_time = time.time() + timeout
 440         while True:
 441             if not self.getecho():
 442                 return True
 443             if timeout < 0 and timeout is not None:
 444                 return False
 445             if timeout is not None:
 446                 timeout = end_time - time.time()
 447             time.sleep(0.1)
 448
 449     def getecho(self):
 450         '''This returns the terminal echo mode. This returns True if echo is
 451         on or False if echo is off. Child applications that are expecting you
 452         to enter a password often set ECHO False. See waitnoecho().
 453
 454         Not supported on platforms where ``isatty()`` returns False.  '''
 455
 456         try:
 457             attr = termios.tcgetattr(self.fd)
 458         except termios.error as err:
 459             errmsg = 'getecho() may not be called on this platform'
 460             if err.args[0] == errno.EINVAL:
 461                 raise IOError(err.args[0], '%s: %s.' % (err.args[1], errmsg))
 462             raise
 463
 464         self.echo = bool(attr[3] & termios.ECHO)
 465         return self.echo
 466
 467     def setecho(self, state):
 468         '''This sets the terminal echo mode on or off. Note that anything the
 469         child sent before the echo will be lost, so you should be sure that
 470         your input buffer is empty before you call setecho(). For example, the
 471         following will work as expected::
 472
 473             p = pexpect.spawn('cat') # Echo is on by default.
 474             p.sendline('1234') # We expect see this twice from the child...
 475             p.expect(['1234']) # ... once from the tty echo...
 476             p.expect(['1234']) # ... and again from cat itself.
 477             p.setecho(False) # Turn off tty echo
 478             p.sendline('abcd') # We will set this only once (echoed by cat).
 479             p.sendline('wxyz') # We will set this only once (echoed by cat)
 480             p.expect(['abcd'])
 481             p.expect(['wxyz'])
 482
 483         The following WILL NOT WORK because the lines sent before the setecho
 484         will be lost::
 485
 486             p = pexpect.spawn('cat')
 487             p.sendline('1234')
 488             p.setecho(False) # Turn off tty echo
 489             p.sendline('abcd') # We will set this only once (echoed by cat).
 490             p.sendline('wxyz') # We will set this only once (echoed by cat)
 491             p.expect(['1234'])
 492             p.expect(['1234'])
 493             p.expect(['abcd'])
 494             p.expect(['wxyz'])
 495
 496
 497         Not supported on platforms where ``isatty()`` returns False.
 498         '''
 499         _setecho(self.fd, state)
 500
 501         self.echo = state
 502
 503     def read(self, size=1024):
 504         """Read and return at most ``size`` bytes from the pty.
 505
 506         Can block if there is nothing to read. Raises :exc:`EOFError` if the
 507         terminal was closed.
 508
 509         Unlike Pexpect's ``read_nonblocking`` method, this doesn't try to deal
 510         with the vagaries of EOF on platforms that do strange things, like IRIX
 511         or older Solaris systems. It handles the errno=EIO pattern used on
 512         Linux, and the empty-string return used on BSD platforms and (seemingly)
 513         on recent Solaris.
 514         """
 515         try:
 516             s = self.fileobj.read1(size)
 517         except (OSError, IOError) as err:
 518             if err.args[0] == errno.EIO:
 519                 # Linux-style EOF
 520                 self.flag_eof = True
 521                 raise EOFError('End Of File (EOF). Exception style platform.')
 522             raise
 523         if s == b'':
 524             # BSD-style EOF (also appears to work on recent Solaris (OpenIndiana))
 525             self.flag_eof = True
 526             raise EOFError('End Of File (EOF). Empty string style platform.')
 527
 528         return s
 529
 530     def readline(self):
 531         """Read one line from the pseudoterminal, and return it as unicode.
 532
 533         Can block if there is nothing to read. Raises :exc:`EOFError` if the
 534         terminal was closed.
 535         """
 536         try:
 537             s = self.fileobj.readline()
 538         except (OSError, IOError) as err:
 539             if err.args[0] == errno.EIO:
 540                 # Linux-style EOF
 541                 self.flag_eof = True
 542                 raise EOFError('End Of File (EOF). Exception style platform.')
 543             raise
 544         if s == b'':
 545             # BSD-style EOF (also appears to work on recent Solaris (OpenIndiana))
 546             self.flag_eof = True
 547             raise EOFError('End Of File (EOF). Empty string style platform.')
 548
 549         return s
 550
 551     def _writeb(self, b, flush=True):
 552         n = self.fileobj.write(b)
 553         if flush:
 554             self.fileobj.flush()
 555         return n
 556
 557     def write(self, s, flush=True):
 558         """Write bytes to the pseudoterminal.
 559
 560         Returns the number of bytes written.
 561         """
 562         return self._writeb(s, flush=flush)
 563
 564     def sendcontrol(self, char):
 565         '''Helper method that wraps send() with mnemonic access for sending control
 566         character to the child (such as Ctrl-C or Ctrl-D).  For example, to send
 567         Ctrl-G (ASCII 7, bell, '\a')::
 568
 569             child.sendcontrol('g')
 570
 571         See also, sendintr() and sendeof().
 572         '''
 573         char = char.lower()
 574         a = ord(char)
 575         if 97 <= a <= 122:
 576             a = a - ord('a') + 1
 577             byte = _byte(a)
 578             return self._writeb(byte), byte
 579         d = {'@': 0, '`': 0,
 580             '[': 27, '{': 27,
 581             '\\': 28, '|': 28,
 582             ']': 29, '}': 29,
 583             '^': 30, '~': 30,
 584             '_': 31,
 585             '?': 127}
 586         if char not in d:
 587             return 0, b''
 588
 589         byte = _byte(d[char])
 590         return self._writeb(byte), byte
 591
 592     def sendeof(self):
 593         '''This sends an EOF to the child. This sends a character which causes
 594         the pending parent output buffer to be sent to the waiting child
 595         program without waiting for end-of-line. If it is the first character
 596         of the line, the read() in the user program returns 0, which signifies
 597         end-of-file. This means to work as expected a sendeof() has to be
 598         called at the beginning of a line. This method does not send a newline.
 599         It is the responsibility of the caller to ensure the eof is sent at the
 600         beginning of a line. '''
 601
 602         return self._writeb(_EOF), _EOF
 603
 604     def sendintr(self):
 605         '''This sends a SIGINT to the child. It does not require
 606         the SIGINT to be the first character on a line. '''
 607
 608         return self._writeb(_INTR), _INTR
 609
 610     def eof(self):
 611         '''This returns True if the EOF exception was ever raised.
 612         '''
 613
 614         return self.flag_eof
 615
 616     def terminate(self, force=False):
 617         '''This forces a child process to terminate. It starts nicely with
 618         SIGHUP and SIGINT. If "force" is True then moves onto SIGKILL. This
 619         returns True if the child was terminated. This returns False if the
 620         child could not be terminated. '''
 621
 622         if not self.isalive():
 623             return True
 624         try:
 625             self.kill(signal.SIGHUP)
 626             time.sleep(self.delayafterterminate)
 627             if not self.isalive():
 628                 return True
 629             self.kill(signal.SIGCONT)
 630             time.sleep(self.delayafterterminate)
 631             if not self.isalive():
 632                 return True
 633             self.kill(signal.SIGINT)
 634             time.sleep(self.delayafterterminate)
 635             if not self.isalive():
 636                 return True
 637             if force:
 638                 self.kill(signal.SIGKILL)
 639                 time.sleep(self.delayafterterminate)
 640                 if not self.isalive():
 641                     return True
 642                 else:
 643                     return False
 644             return False
 645         except OSError:
 646             # I think there are kernel timing issues that sometimes cause
 647             # this to happen. I think isalive() reports True, but the
 648             # process is dead to the kernel.
 649             # Make one last attempt to see if the kernel is up to date.
 650             time.sleep(self.delayafterterminate)
 651             if not self.isalive():
 652                 return True
 653             else:
 654                 return False
 655
 656     def wait(self):
 657         '''This waits until the child exits. This is a blocking call. This will
 658         not read any data from the child, so this will block forever if the
 659         child has unread output and has terminated. In other words, the child
 660         may have printed output then called exit(), but, the child is
 661         technically still alive until its output is read by the parent. '''
 662
 663         if self.isalive():
 664             pid, status = os.waitpid(self.pid, 0)
 665         else:
 666             return self.exitstatus
 667         self.exitstatus = os.WEXITSTATUS(status)
 668         if os.WIFEXITED(status):
 669             self.status = status
 670             self.exitstatus = os.WEXITSTATUS(status)
 671             self.signalstatus = None
 672             self.terminated = True
 673         elif os.WIFSIGNALED(status):
 674             self.status = status
 675             self.exitstatus = None
 676             self.signalstatus = os.WTERMSIG(status)
 677             self.terminated = True
 678         elif os.WIFSTOPPED(status):  # pragma: no cover
 679             # You can't call wait() on a child process in the stopped state.
 680             raise PtyProcessError('Called wait() on a stopped child ' +
 681                     'process. This is not supported. Is some other ' +
 682                     'process attempting job control with our child pid?')
 683         return self.exitstatus
 684
 685     def isalive(self):
 686         '''This tests if the child process is running or not. This is
 687         non-blocking. If the child was terminated then this will read the
 688         exitstatus or signalstatus of the child. This returns True if the child
 689         process appears to be running or False if not. It can take literally
 690         SECONDS for Solaris to return the right status. '''
 691
 692         if self.terminated:
 693             return False
 694
 695         if self.flag_eof:
 696             # This is for Linux, which requires the blocking form
 697             # of waitpid to get the status of a defunct process.
 698             # This is super-lame. The flag_eof would have been set
 699             # in read_nonblocking(), so this should be safe.
 700             waitpid_options = 0
 701         else:
 702             waitpid_options = os.WNOHANG
 703
 704         try:
 705             pid, status = os.waitpid(self.pid, waitpid_options)
 706         except OSError as e:
 707             # No child processes
 708             if e.errno == errno.ECHILD:
 709                 raise PtyProcessError('isalive() encountered condition ' +
 710                         'where "terminated" is 0, but there was no child ' +
 711                         'process. Did someone else call waitpid() ' +
 712                         'on our process?')
 713             else:
 714                 raise
 715
 716         # I have to do this twice for Solaris.
 717         # I can't even believe that I figured this out...
 718         # If waitpid() returns 0 it means that no child process
 719         # wishes to report, and the value of status is undefined.
 720         if pid == 0:
 721             try:
 722                 ### os.WNOHANG) # Solaris!
 723                 pid, status = os.waitpid(self.pid, waitpid_options)
 724             except OSError as e:  # pragma: no cover
 725                 # This should never happen...
 726                 if e.errno == errno.ECHILD:
 727                     raise PtyProcessError('isalive() encountered condition ' +
 728                             'that should never happen. There was no child ' +
 729                             'process. Did someone else call waitpid() ' +
 730                             'on our process?')
 731                 else:
 732                     raise
 733
 734             # If pid is still 0 after two calls to waitpid() then the process
 735             # really is alive. This seems to work on all platforms, except for
 736             # Irix which seems to require a blocking call on waitpid or select,
 737             # so I let read_nonblocking take care of this situation
 738             # (unfortunately, this requires waiting through the timeout).
 739             if pid == 0:
 740                 return True
 741
 742         if pid == 0:
 743             return True
 744
 745         if os.WIFEXITED(status):
 746             self.status = status
 747             self.exitstatus = os.WEXITSTATUS(status)
 748             self.signalstatus = None
 749             self.terminated = True
 750         elif os.WIFSIGNALED(status):
 751             self.status = status
 752             self.exitstatus = None
 753             self.signalstatus = os.WTERMSIG(status)
 754             self.terminated = True
 755         elif os.WIFSTOPPED(status):
 756             raise PtyProcessError('isalive() encountered condition ' +
 757                     'where child process is stopped. This is not ' +
 758                     'supported. Is some other process attempting ' +
 759                     'job control with our child pid?')
 760         return False
 761
 762     def kill(self, sig):
 763         """Send the given signal to the child application.
 764
 765         In keeping with UNIX tradition it has a misleading name. It does not
 766         necessarily kill the child unless you send the right signal. See the
 767         :mod:`signal` module for constants representing signal numbers.
 768         """
 769
 770         # Same as os.kill, but the pid is given for you.
 771         if self.isalive():
 772             os.kill(self.pid, sig)
 773
 774     def getwinsize(self):
 775         """Return the window size of the pseudoterminal as a tuple (rows, cols).
 776         """
 777         TIOCGWINSZ = getattr(termios, 'TIOCGWINSZ', 1074295912)
 778         s = struct.pack('HHHH', 0, 0, 0, 0)
 779         x = fcntl.ioctl(self.fd, TIOCGWINSZ, s)
 780         return struct.unpack('HHHH', x)[0:2]
 781
 782     def setwinsize(self, rows, cols):
 783         """Set the terminal window size of the child tty.
 784
 785         This will cause a SIGWINCH signal to be sent to the child. This does not
 786         change the physical window size. It changes the size reported to
 787         TTY-aware applications like vi or curses -- applications that respond to
 788         the SIGWINCH signal.
 789         """
 790         return _setwinsize(self.fd, rows, cols)
 791
 792
 793 class PtyProcessUnicode(PtyProcess):
 794     """Unicode wrapper around a process running in a pseudoterminal.
 795
 796     This class exposes a similar interface to :class:`PtyProcess`, but its read
 797     methods return unicode, and its :meth:`write` accepts unicode.
 798     """
 799     if PY3:
 800         string_type = str
 801     else:
 802         string_type = unicode   # analysis:ignore
 803
 804     def __init__(self, pid, fd, encoding='utf-8', codec_errors='strict'):
 805         super(PtyProcessUnicode, self).__init__(pid, fd)
 806         self.encoding = encoding
 807         self.codec_errors = codec_errors
 808         self.decoder = codecs.getincrementaldecoder(encoding)(errors=codec_errors)
 809
 810     def read(self, size=1024):
 811         """Read at most ``size`` bytes from the pty, return them as unicode.
 812
 813         Can block if there is nothing to read. Raises :exc:`EOFError` if the
 814         terminal was closed.
 815
 816         The size argument still refers to bytes, not unicode code points.
 817         """
 818         b = super(PtyProcessUnicode, self).read(size)
 819         return self.decoder.decode(b, final=False)
 820
 821     def readline(self):
 822         """Read one line from the pseudoterminal, and return it as unicode.
 823
 824         Can block if there is nothing to read. Raises :exc:`EOFError` if the
 825         terminal was closed.
 826         """
 827         b = super(PtyProcessUnicode, self).readline()
 828         return self.decoder.decode(b, final=False)
 829
 830     def write(self, s):
 831         """Write the unicode string ``s`` to the pseudoterminal.
 832
 833         Returns the number of bytes written.
 834         """
 835         b = s.encode(self.encoding)
 836         return super(PtyProcessUnicode, self).write(b)