sigint

I am currently trying to write (Python 2.7.3) kind of a wrapper for GDB, which will allow me to dynamically switch from scripted input to interactive communication with GDB. So far I use self.process = subprocess.Popen(["gdb vuln"], stdin = subprocess.PIPE, shell = True) to start gdb within my script. ( vuln is the binary I want to examine) Since a key feature of gdb is to pause the execution of the attached process and allow the user to inspect registers and memory on receiving SIGINT (STRG+C) I do need some way to pass a SIGINT signal to it. Neither self.process.send_signal(signal.SIGINT)

I don't manage to understand why my SIGINT is never catched by the piece of code below. #!/usr/bin/env python from threading import Thread from time import sleep import signal class MyThread(Thread): def __init__(self): Thread.__init__(self) self.running = True def stop(self): self.running = False def run(self): while self.running: for i in range(500): col = i**i print col sleep(0.01) global threads threads = [] for w in range(150): threads.append(MyThread()) def stop(s, f): for t in threads: t.stop() signal.signal(signal.SIGINT, stop) for t in threads: t.start() for t in threads: t.join() To

I've read every post I could find about how to gracefully handle a script with an asyncio event loop getting terminated with Ctrl-C, and I haven't been able to get any of them to work without printing one or more tracebacks as I do so. The answers are pretty much all over the place, and I haven't been able implement any of them into this small script: import asyncio import datetime import functools import signal async def display_date(loop): end_time = loop.time() + 5.0 while True: print(datetime.datetime.now()) if (loop.time() + 1.0) >= end_time: break await asyncio.sleep(1) def stopper

I have been studying signals in Linux. And I've done a test program to capture SIGINT. #include <unistd.h> #include <signal.h> #include <iostream> void signal_handler(int signal_no); int main() { signal(SIGINT, signal_handler); for (int i = 0; i < 10; ++i) { std::cout << "I'm sleeping..." << std::endl; unsigned int one_ms = 1000; usleep(200* one_ms); } return 0; } void signal_handler(int signal_no) { if (signal_no == SIGINT) std::cout << "Oops, you pressed Ctrl+C!\n"; return; } While the output looks like this: I'm sleeping... I'm sleeping... ^COops, you pressed Ctrl+C! I'm sleeping... I'm

I am unable to trap a signal when running in a child / background process. Here is my simple bash script : #!/bin/bash echo "in child" trap "got_signal" SIGINT function got_signal { echo "trapped" exit 0 } while [ true ]; do sleep 2 done When running this and later do kill -SIGINT (pid) Everything works as expected, it prints 'trapped' and exits. Now, if I start the same script from a parent script like this : #!/bin/bash echo "starting the child" ./child.sh & Then the child does not trap the signal anymore.... ? After changing to use SIGTERM instead of SIGINT, it seems to be working correctly

I am designing a script to launch a process inside a named screen session. as_user "screen -p 0 -S **$command** -X eval 'stuff \"wine LFS.exe /cfg=**$command**.cfg\"\015'" So bash myscript.sh start test will create a screen named test and run the test.cfg with the software. Now I want my script to access the specific screen session and do a CTRL + C to stop the running process so i can kill the screen session. Something like this: as_user "screen -p 0 -S **$command** **... kill the process with ctrl-c...**" as_user "screen -p 0 -S **$command** -X eval 'stuff \"exit\"\015'" I don't quite

In a multithreaded Python program, one thread sometimes asks for console input using the built-in raw_input() . I'd like to be able to be able to close the program while at a raw_input prompt by typing ^C at the shell (i.e., with a SIGINT signal). However, when the child thread is executing raw_input, typing ^C does nothing -- the KeyboardInterrupt is not raised until I hit return (leaving raw_input). For example, in the following program: import threading class T(threading.Thread): def run(self): x = raw_input() print x if __name__ == '__main__': t = T() t.start() t.join() Typing ^C does

I've got code similar to the following, using readline: #include <errno.h> #include <error.h> #include <getopt.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <signal.h> #include <readline/readline.h> #include <readline/history.h> void handle_signals(int signo) { if (signo == SIGINT) { printf("You pressed Ctrl+C\n"); } } int main (int argc, char **argv) { //printf("path is: %s\n", path_string); char * input; char * shell_prompt = "i-shell> "; if (signal(SIGINT, handle_signals) == SIG_ERR) { printf("failed to register interrupts with kernel\n"); } //set up custom