Python signal.SIGTTOU Examples

def __init__(self, name, pid_dir='/var/run', signals=None):
        """
        Constructor.

        ``name`` is a string that identifies the daemon. The name is
        used for the name of the daemon process, the PID file and for
        the messages to syslog.

        ``pid_dir`` is the directory in which the PID file is stored.

        ``signals`` list of operating signals, that should be available
        for use with :py:meth:`.send_signal`, :py:meth:`.got_signal`,
        :py:meth:`.wait_for_signal`, and :py:meth:`.check_signal`. Note
        that SIGTERM is always supported, and that SIGTTIN, SIGTTOU, and
        SIGTSTP are never supported.
        """
        self.name = name
        self.pid_file = _PIDFile(os.path.join(pid_dir, name + '.pid'))
        self._signal_events = {int(s): threading.Event()
                               for s in ((signals or []) + [signal.SIGTERM])}
        self.logger = logging.getLogger(name)
        if not self.logger.handlers:
            self.logger.addHandler(logging.NullHandler())
        self.files_preserve = [] 

def make_default_signal_map():
    """ Make the default signal map for this system.

        The signals available differ by system. The map will not
        contain any signals not defined on the running system.

        """
    name_map = {
        'SIGTSTP': None,
        'SIGTTIN': None,
        'SIGTTOU': None,
        'SIGTERM': 'terminate',
        }
    signal_map = dict(
        (getattr(signal, name), target)
        for (name, target) in name_map.items()
        if hasattr(signal, name))

    return signal_map 

def make_default_signal_map():
    """ Make the default signal map for this system.

        The signals available differ by system. The map will not
        contain any signals not defined on the running system.

        """
    name_map = {
        'SIGTSTP': None,
        'SIGTTIN': None,
        'SIGTTOU': None,
        'SIGTERM': 'terminate',
    }
    signal_map = dict(
        (getattr(signal, name), target)
        for (name, target) in name_map.items()
        if hasattr(signal, name))

    return signal_map 

def _handle_sigttou(self, signum, frame):
        #Had some issues that when memory corruptions occured in a subprocess
        #(no matter if shielded by multiprocess and subprocess module), 
        #that a SIGTTOU was sent to the entire Python main process.
        #According to https://en.wikipedia.org/wiki/SIGTTOU this
        #results in the process being stopped (and it looks like SIGSTP on the cmd):
        #[1]+  Stopped                 ./AflCrashAnalyzer.py
        #Of course we don't want that. Debugging was hard but then
        #realized after this program was stopped:
        #$ echo $?
        #150
        #So that's SIGTTOU on Linux at least.
        #This handler will prevent the process to stop.
        self.sigttou_flag = True
        try:
            self.current_process.kill()
        except OSError as ose:
            Logger.info("Kill failed. Sometimes the process exactly exits before we try to kill it... coward. Nothing to worry about.", ose) 

def test_default_rewrites_can_be_overriden_with_setsid_enabled():
    """In setsid mode, dumb-init should allow overwriting the default
    rewrites (but still suspend itself).
    """
    rewrite_map = {
        signal.SIGTTIN: signal.SIGTERM,
        signal.SIGTTOU: signal.SIGINT,
        signal.SIGTSTP: signal.SIGHUP,
    }
    with print_signals(_rewrite_map_to_args(rewrite_map)) as (proc, _):
        for send, expect_receive in rewrite_map.items():
            assert process_state(proc.pid) in ['running', 'sleeping']
            proc.send_signal(send)

            assert proc.stdout.readline() == '{}\n'.format(expect_receive).encode('ascii')
            os.waitpid(proc.pid, os.WUNTRACED)
            assert process_state(proc.pid) == 'stopped'

            proc.send_signal(signal.SIGCONT)
            assert proc.stdout.readline() == '{}\n'.format(signal.SIGCONT).encode('ascii')
            assert process_state(proc.pid) in ['running', 'sleeping'] 

def _kill_old_workers(self, count: int) -> None:
        """
        Send signal to kill the worker.

        :param count: The number of workers to kill
        """
        for _ in range(count):
            count -= 1
            # TTOU: Decrement the number of processes by one
            self.gunicorn_master_proc.send_signal(signal.SIGTTOU)
            self._wait_until_true(
                lambda: self.num_workers_expected + count == self._get_num_workers_running(),
                timeout=self.master_timeout) 

def is_stop_signal(signum):
    return signum in (signal.SIGSTOP, signal.SIGTSTP,
                      signal.SIGTTIN, signal.SIGTTOU) 

def _stop_backdoor_server(signum, frame):
    def _stop():
        server = ServeBackdoor.get_instance()
        if server:
            logger.info('stopping backdoor server on %r...', server.addr)
            server.kill()

    ignore_sig(signal.SIGTTOU)
    gevent.spawn(_stop()) 

def run_command(self, command, timeout=None, env={}, stdout=file("/dev/null"), stderr=file("/dev/null")):
        #TODO: make stdout / stderr configurable
        if not timeout:
            timeout = self.config.run_timeout
        process = subprocess.Popen(command, stdin=None, shell=False, stdout=stdout, stderr=stderr)
        self.current_process = process
        signal.signal(signal.SIGALRM, self._handle_alarm)
        #We also had a problem that memory corruptions...
        signal.signal(signal.SIGTTOU, self._handle_sigttou)
        signal.alarm(timeout)
        self.timeout_flag = False
        self.sigttou_flag = False
        #TODO: get rid of magic number
        ret_signal = self.TIMEOUT_SIGNAL
        #blocking call:
        process.communicate()
        signal.alarm(0)
        #This line is reached when timeout_flag was set by _handle_alarm if it was called
        if self.timeout_flag:
            Logger.debug("Process was killed as it exceeded the time limit", debug_level=3)
            ret_signal = self.TIMEOUT_SIGNAL
        elif self.sigttou_flag:
            Logger.debug("Some memory corruption resulted in a SIGTTOU signal being thrown (usually stops process). We caught it.", debug_level=3)
            ret_signal = signal.SIGTTOU
        else:
            ret_signal = process.returncode
        return ret_signal