def list (self):
        if self.ppds:
		return self.ppds

        signal.alarm (60)
        p = subprocess.Popen ([self.exe, "list"],
                              stdout=subprocess.PIPE,
                              stderr=subprocess.PIPE)
        try:
            (stdout, stderr) = p.communicate ()
            signal.alarm (0)
        except TimedOut:
            posix.kill (p.pid, signal.SIGKILL)
            raise

	if stderr:
		print(stderr, file=sys.stderr)

	ppds = []
	lines = stdout.split ('\n')
	for line in lines:
		l = shlex.split (line)
		if len (l) < 1:
			continue
		ppds.append (l[0])

	self.ppds = ppds
	return ppds
예제 #2
0
 def test_set_wakeup_fd(self):
     import signal, posix, fcntl
     def myhandler(signum, frame):
         pass
     signal.signal(signal.SIGUSR1, myhandler)
     #
     def cannot_read():
         try:
             posix.read(fd_read, 1)
         except OSError:
             pass
         else:
             raise AssertionError, "os.read(fd_read, 1) succeeded?"
     #
     fd_read, fd_write = posix.pipe()
     flags = fcntl.fcntl(fd_write, fcntl.F_GETFL, 0)
     flags = flags | posix.O_NONBLOCK
     fcntl.fcntl(fd_write, fcntl.F_SETFL, flags)
     flags = fcntl.fcntl(fd_read, fcntl.F_GETFL, 0)
     flags = flags | posix.O_NONBLOCK
     fcntl.fcntl(fd_read, fcntl.F_SETFL, flags)
     #
     old_wakeup = signal.set_wakeup_fd(fd_write)
     try:
         cannot_read()
         posix.kill(posix.getpid(), signal.SIGUSR1)
         res = posix.read(fd_read, 1)
         assert res == '\x00'
         cannot_read()
     finally:
         old_wakeup = signal.set_wakeup_fd(old_wakeup)
     #
     signal.signal(signal.SIGUSR1, signal.SIG_DFL)
예제 #3
0
    def __init__(self,
                 manager,
                 pid,
                 record,
                 old_debugger=None,
                 is_thread=False):
        """
        Create a new tracing thread
        :param manager: overall tracing management instance
        :param pid: Process to trace
        :param record: Action recording instance
        :param old_debugger: Old debugger the process might be attached to at the moment
        :param is_thread: True if the pid is a thread else False
        """
        super().__init__()
        self.manager = manager

        # Save tracing record
        self.record = record
        self.record.runtime_log(RuntimeActionRecord.TYPE_STARTED)
        self._debugger_options = FunctionCallOptions(replace_socketcall=False)

        self.is_thread = is_thread
        self.process = psutil.Process(pid)
        self.debugger = None
        self.traced_item = None
        self.stopped = False

        # Check if the process is attached to the debugger
        if old_debugger is not None and old_debugger.dict.get(
                self.process.pid):
            old_debugger.dict.get(self.process.pid).detach()
            posix.kill(self.process.pid, signal.SIGSTOP)
예제 #4
0
	def kill (self, signal=9):
		import posix
		if self.running:
			posix.kill(self.pid, signal)
			return self.finish()
		else:
			return 0
예제 #5
0
    def start(self):
        # Configure the tracing instance
        if not self.config:
            self.tracer.runtime_tracing = False
            self.tracer.file_access_tracing = False
            self.tracer.syscall_tracing = False
        else:
            self.tracer.runtime_tracing = self.config.get('enabled', False)
            file_access_tracing = self.config.get('file_access', 'none')
            if file_access_tracing != 'none':
                self.tracer.file_access_tracing = (
                    file_access_tracing == 'short')
                self.tracer.file_access_detailed_tracing = (
                    file_access_tracing == 'full')
            else:
                self.tracer.file_access_tracing = False

            syscall_tracing = self.config.get('syscall', 'none')
            if syscall_tracing != 'none':
                self.tracer.syscall_tracing = (syscall_tracing == 'short')
                self.tracer.syscall_argument_tracing = (
                    syscall_tracing == 'full')
            else:
                self.tracer.set_file_access_tracing_enabled = False

        # Start the tracing process (if tracing is requested)
        if self.tracer.runtime_tracing or self.tracer.file_access_tracing or self.tracer.syscall_tracing:
            self.tracer.start()
        else:
            posix.kill(self.process, signal.SIGCONT)
예제 #6
0
    def list(self):
        if self.ppds:
            return self.ppds

        signal.alarm(60)
        p = subprocess.Popen([self.exe, "list"],
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE)
        try:
            (stdout, stderr) = p.communicate()
            signal.alarm(0)
        except TimedOut:
            posix.kill(p.pid, signal.SIGKILL)
            raise

        if stderr:
            print >> sys.stderr, stderr

        ppds = []
        lines = stdout.split('\n')
        for line in lines:
            l = shlex.split(line)
            if len(l) < 1:
                continue
            ppds.append(l[0])

        self.ppds = ppds
        return ppds
예제 #7
0
    def start(self):
        """
        Start the process tracing
        :return: True if a new tracing action was executed or False if tracing is already running
        """
        if self.is_running():
            return False

        self._debugger_threads = {}
        self._process_records = {}

        # Spawn the debugger thread for the start process
        if self.process.status() != psutil.STATUS_STOPPED:
            posix.kill(self.process.pid, signal.SIGSTOP)

        self.trace_create_thread(self.process.pid)

        # Start debugger for all existing process children
        processes = [self.process] + self.process.children(recursive=True)
        for p in processes:
            # Don't double start tracing of a process
            if p.pid not in self._debugger_threads.keys():
                self.trace_create_thread(p.pid)

            # Start tracing of process threads
            for t in p.threads():
                if t.id not in self._debugger_threads.keys():
                    self.trace_create_thread(t.id, is_thread=True)

        # Mark running
        self._running = True
        return True
예제 #8
0
파일: intercom.py 프로젝트: 8Banana/py1.0
def ioloop1(s, otheraddr):
    #
    # Watch out! data is in bytes, but the port counts in samples,
    # which are two bytes each (for 16-bit samples).
    # Luckily, we use mono, else it would be worse (2 samples/frame...)
    #
    SAMPSPERBUF = 500
    BYTESPERSAMP = 2  # AL.SAMPLE_16
    BUFSIZE = BYTESPERSAMP * SAMPSPERBUF
    QSIZE = 4 * SAMPSPERBUF
    #
    config = al.newconfig()
    config.setqueuesize(QSIZE)
    config.setwidth(AL.SAMPLE_16)
    config.setchannels(AL.MONO)
    #
    pid = posix.fork()
    if pid:
        # Parent -- speaker/headphones handler
        log('parent started')
        spkr = al.openport('spkr', 'w', config)
        while 1:
            data = s.recv(BUFSIZE)
            if len(data) == 0:
                # EOF packet
                log('parent got empty packet; killing child')
                posix.kill(pid, 15)
                return
            # Discard whole packet if we are too much behind
            if spkr.getfillable() > len(data) / BYTESPERSAMP:
                if len(debug) >= 2:
                    log('parent Q full; dropping packet')
                spkr.writesamps(data)
    else:
        # Child -- microphone handler
        log('child started')
        try:
            try:
                mike = al.openport('mike', 'r', config)
                # Sleep a while to let the other side get started
                time.sleep(1)
                # Drain the queue before starting to read
                data = mike.readsamps(mike.getfilled())
                # Loop, sending packets from the mike to the net
                while 1:
                    data = mike.readsamps(SAMPSPERBUF)
                    s.sendto(data, otheraddr)
            except KeyboardInterrupt:
                log('child got interrupt; exiting')
                posix._exit(0)
            except error:
                log('child got error; exiting')
                posix._exit(1)
        finally:
            log('child got unexpected error; leaving w/ traceback')
예제 #9
0
def ioloop1(s, otheraddr):
	#
	# Watch out! data is in bytes, but the port counts in samples,
	# which are two bytes each (for 16-bit samples).
	# Luckily, we use mono, else it would be worse (2 samples/frame...)
	#
	SAMPSPERBUF = 500
	BYTESPERSAMP = 2 # AL.SAMPLE_16
	BUFSIZE = BYTESPERSAMP*SAMPSPERBUF
	QSIZE = 4*SAMPSPERBUF
	#
	config = al.newconfig()
	config.setqueuesize(QSIZE)
	config.setwidth(AL.SAMPLE_16)
	config.setchannels(AL.MONO)
	#
	pid = posix.fork()
	if pid:
		# Parent -- speaker/headphones handler
		log('parent started')
		spkr = al.openport('spkr', 'w', config)
		while 1:
			data = s.recv(BUFSIZE)
			if len(data) == 0:
				# EOF packet
				log('parent got empty packet; killing child')
				posix.kill(pid, 15)
				return
			# Discard whole packet if we are too much behind
			if spkr.getfillable() > len(data) / BYTESPERSAMP:
				if len(debug) >= 2:
					log('parent Q full; dropping packet')
				spkr.writesamps(data)
	else:
		# Child -- microphone handler
		log('child started')
		try:
		    try:
			    mike = al.openport('mike', 'r', config)
			    # Sleep a while to let the other side get started
			    time.sleep(1)
			    # Drain the queue before starting to read
			    data = mike.readsamps(mike.getfilled())
			    # Loop, sending packets from the mike to the net
			    while 1:
				    data = mike.readsamps(SAMPSPERBUF)
				    s.sendto(data, otheraddr)
		    except KeyboardInterrupt:
			    log('child got interrupt; exiting')
			    posix._exit(0)
		    except error:
			    log('child got error; exiting')
			    posix._exit(1)
		finally:
			log('child got unexpected error; leaving w/ traceback')
예제 #10
0
 def stop(self):
     """Stops the slapd server, and waits for it to terminate"""
     if self._proc is not None:
         self._log.debug("stopping slapd")
         if hasattr(self._proc, 'terminate'):
             self._proc.terminate()
         else:
             import posix
             import signal
             posix.kill(self._proc.pid, signal.SIGTERM)
         self.wait()
예제 #11
0
파일: slapd.py 프로젝트: cajus/python3-ldap
 def stop(self):
     """Stops the slapd server, and waits for it to terminate"""
     if self._proc is not None:
         self._log.debug("stopping slapd")
         if hasattr(self._proc, 'terminate'):
             self._proc.terminate()
         else:
             import posix, signal
             posix.kill(self._proc.pid, signal.SIGHUP)
             #time.sleep(1)
             #posix.kill(self._proc.pid, signal.SIGTERM)
             #posix.kill(self._proc.pid, signal.SIGKILL)
         self.wait()
예제 #12
0
 def send_cancel(self, ev):
     if not self.running:
         return "break"
     #print "ctrl-c"
     #print ev.char, ev.keycode, ev.keysym
     posix.kill(self.pid, signal.SIGINT)
     #self.stdin.write(chr(3))
     #self.stdin.write('\n')
     #self.stdin.flush()
     self.temphistory = self.history[:]
     self.temphistory.append("")
     self.currentline = ""
     self.historypos = 1
     self.cursor_pos = 0
     self.input_modified = False
     self.output_modified = False
     self.tab_pressed = False
예제 #13
0
파일: TerminalFrame.py 프로젝트: jfmc/logen
 def send_cancel(self, ev):
     if not self.running:
         return  "break"    
     #print "ctrl-c"
     #print ev.char, ev.keycode, ev.keysym
     posix.kill(self.pid, signal.SIGINT)
     #self.stdin.write(chr(3))
     #self.stdin.write('\n')
     #self.stdin.flush()
     self.temphistory = self.history[:]
     self.temphistory.append("")
     self.currentline = ""
     self.historypos = 1
     self.cursor_pos = 0
     self.input_modified = False
     self.output_modified = False
     self.tab_pressed = False
예제 #14
0
 def stop(self):
     """Stops the slapd server, and waits for it to terminate"""
     if self._proc is not None:
         self._log.debug("stopping slapd")
         if hasattr(self._proc, 'terminate'):
             self._proc.terminate()
         else:
             import posix
             import signal
             posix.kill(self._proc.pid, signal.SIGHUP)
             # time.sleep(1)
             # posix.kill(self._proc.pid, signal.SIGTERM)
             # posix.kill(self._proc.pid, signal.SIGKILL)
         self.wait()
     if self._tmpdir is not None:
         import shutil
         shutil.rmtree(self._tmpdir)
         self._tmpdir = None
예제 #15
0
    def test_sigmask(self):
        import _signal as signal, posix
        signum1 = signal.SIGUSR1
        signum2 = signal.SIGUSR2

        def handler(signum, frame):
            pass

        signal.signal(signum1, handler)
        signal.signal(signum2, handler)

        signal.pthread_sigmask(signal.SIG_BLOCK, (signum1, signum2))
        posix.kill(posix.getpid(), signum1)
        posix.kill(posix.getpid(), signum2)
        assert signal.sigpending() == set((signum1, signum2))
        # Unblocking the 2 signals calls the C signal handler twice
        signal.pthread_sigmask(signal.SIG_UNBLOCK, (signum1, signum2))
        assert signal.sigpending() == set()
예제 #16
0
    def cat(self, name):
        try:
            return self.files[name]
        except KeyError:
            signal.alarm(10)
            p = subprocess.Popen([self.exe, "cat", name],
                                 stdout=subprocess.PIPE,
                                 stderr=subprocess.PIPE)
            try:
                (stdout, stderr) = p.communicate()
                signal.alarm(0)
            except TimedOut:
                posix.kill(p.pid, signal.SIGKILL)
                raise

            if stderr:
                print >> sys.stderr, stderr

            self.files[name] = stdout
            return stdout
    def cat (self, name):
        try:
            return self.files[name]
	except KeyError:
            signal.alarm (10)
            p = subprocess.Popen ([self.exe, "cat", name],
                                  stdout=subprocess.PIPE,
                                  stderr=subprocess.PIPE)
            try:
                (stdout, stderr) = p.communicate ()
                signal.alarm (0)
            except TimedOut:
                posix.kill (p.pid, signal.SIGKILL)
                raise

            if stderr:
                print(stderr, file=sys.stderr)

            self.files[name] = stdout
            return stdout
예제 #18
0
    def test_set_wakeup_fd(self):
        try:
            import _signal as signal, posix, fcntl
        except ImportError:
            skip('cannot import posix or fcntl')

        def myhandler(signum, frame):
            pass

        signal.signal(signal.SIGINT, myhandler)

        #
        def cannot_read():
            try:
                posix.read(fd_read, 1)
            except OSError:
                pass
            else:
                raise AssertionError("os.read(fd_read, 1) succeeded?")

        #
        fd_read, fd_write = posix.pipe()
        flags = fcntl.fcntl(fd_write, fcntl.F_GETFL, 0)
        flags = flags | posix.O_NONBLOCK
        fcntl.fcntl(fd_write, fcntl.F_SETFL, flags)
        flags = fcntl.fcntl(fd_read, fcntl.F_GETFL, 0)
        flags = flags | posix.O_NONBLOCK
        fcntl.fcntl(fd_read, fcntl.F_SETFL, flags)
        #
        old_wakeup = signal.set_wakeup_fd(fd_write)
        try:
            cannot_read()
            posix.kill(posix.getpid(), signal.SIGINT)
            res = posix.read(fd_read, 1)
            assert res == bytes([signal.SIGINT])
            cannot_read()
        finally:
            old_wakeup = signal.set_wakeup_fd(old_wakeup)
        #
        signal.signal(signal.SIGINT, signal.SIG_DFL)
예제 #19
0
    def test_usr1(self):
        import types, posix
        signal = self.signal   # the signal module to test

        received = []
        def myhandler(signum, frame):
            assert isinstance(frame, types.FrameType)
            received.append(signum)
        signal.signal(signal.SIGUSR1, myhandler)

        posix.kill(posix.getpid(), signal.SIGUSR1)
        # the signal should be delivered to the handler immediately
        assert received == [signal.SIGUSR1]
        del received[:]

        posix.kill(posix.getpid(), signal.SIGUSR1)
        # the signal should be delivered to the handler immediately
        assert received == [signal.SIGUSR1]
        del received[:]

        signal.signal(signal.SIGUSR1, signal.SIG_IGN)

        posix.kill(posix.getpid(), signal.SIGUSR1)
        for i in range(10000):
            # wait a bit - signal should not arrive
            if received:
                break
        assert received == []

        signal.signal(signal.SIGUSR1, signal.SIG_DFL)
예제 #20
0
    def operate(self, **kwargs):
        self.runningThreads += 1
        r, w = os.pipe()
        pid = os.fork()
        if pid:  # PARENT
            os.close(w)

            tmpParam = kwargs[self.parameter]
            r = os.fdopen(r, "rb")
            try:
                tmpResult = cPickle.load(r)
            except:
                try:
                    posix.kill(pid, -1)  # Kill the child
                except:
                    pass

                if self.verbose:
                    self.write("An error occured in job " + str(pid))  # Tell the reader

                self.jobs.append(kwargs[self.parameter])  # Append the job to be done later
                self.runningThreads -= 1  # Tell your master that you've one it
                self.sigPause.set()
                return
            os.waitpid(pid, 0)

        else:  # CHILD
            posix.nice(self.nice)
            os.close(r)
            w = os.fdopen(w, "wb")
            cPickle.dump(self.function(**kwargs), w, 2)
            w.close()
            sys.exit(0)

        self.writeLock.acquire()
        self.operate_return(tmpParam, tmpResult)
        self.runningThreads -= 1
        self.sigPause.set()
        self.writeLock.release()
예제 #21
0
	def operate(self,**kwargs):
		self.runningThreads+=1
		r, w = os.pipe()
		pid = os.fork()
		if pid:	# PARENT
			os.close(w)

			tmpParam = kwargs[self.parameter]
			r = os.fdopen(r, 'rb')
			try: tmpResult = cPickle.load(r)
			except:
				try: posix.kill(pid, -1)				# Kill the child
				except: pass

				if self.verbose: self.write("An error occured in job "+str(pid))	# Tell the reader

				self.jobs.append(kwargs[self.parameter])		# Append the job to be done later
				self.runningThreads -= 1			# Tell your master that you've one it
				self.sigPause.set()
				return
			os.waitpid(pid, 0)

		else:	# CHILD
			posix.nice(self.nice)
			os.close(r)
			w = os.fdopen(w, 'wb')
			cPickle.dump(self.function(**kwargs), w, 2)
			w.close()
			sys.exit(0)


		self.writeLock.acquire()
		self.operate_return(tmpParam, tmpResult)
		self.runningThreads -= 1
		self.sigPause.set()
		self.writeLock.release()
예제 #22
0
    def run(self):
        """
        Trace the given process or thread for one syscall
        """
        finished = False
        self.record.log("Attaching debugger")
        try:
            self.debugger = PtraceDebugger()
            self.debugger.traceFork()
            self.debugger.traceExec()
            self.debugger.traceClone()

            self.traced_item = self.debugger.addProcess(
                self.process.pid, False, is_thread=self.is_thread)
            self.record.log("PTrace debugger attached successfully")
            TracingThread._trace_continue(self.traced_item)

        except Exception as e:
            self.record.log(
                "PTrace debugger attachment failed with reason: {}".format(e))
            finished = True

        # Trace process until finished
        while not finished and not self.stopped:
            finished = self._trace(self.traced_item, self.record)

        if self.traced_item:
            self.traced_item.detach()
            # Keep in mind that the process maybe already gone
            try:
                if self.process.status() == psutil.STATUS_STOPPED:
                    posix.kill(self.process.pid, signal.SIGCONT)
            except psutil.NoSuchProcess:
                pass

        self.record.log("Tracee appears to have ended and thread will finish")
예제 #23
0
	#
	if pid == 0:
		# child -- read stdin, write socket
		while 1:
			line = sys.stdin.readline()
			s.send(line)
	else:
		# parent -- read socket, write stdout
		iac = 0		# Interpret next char as command
		opt = ''	# Interpret next char as option
		while 1:
			data = s.recv(BUFSIZE)
			if not data:
				# EOF; kill child and exit
				sys.stderr.write( '(Closed by remote host)\n')
				posix.kill(pid, 9)
				sys.exit(1)
			cleandata = ''
			for c in data:
				if opt:
					print ord(c)
					s.send(opt + c)
					opt = ''
				elif iac:
					iac = 0
					if c == IAC:
						cleandata = cleandata + c
					elif c in (DO, DONT):
						if c == DO: print '(DO)',
						else: print '(DONT)',
						opt = IAC + WONT
예제 #24
0
# intercom -- use mike and headset to *talk* to a person on another host.
예제 #25
0
def master_sig_handler_stop_server(signum, frame):
    print("Signal {} received, server will be stopped".format(signum))
    posix.kill(0, signal.SIGINT)
    posix.wait()
    sys.exit(0)
예제 #26
0
    def __init__(self,
                 process,
                 stop=False,
                 recording_mode=TRACING_RECORD_MODE_MEMORY,
                 log_filename=None,
                 log_callback=None):
        """
        Create a new tracing instance
        This will bind to the given process and enable process observation
        using the capabilities of ptrace
        :param process: psutil.Process instance or pid of the process to trace
        :param stop: Specify true to send SIGSTOP to the process to temporary halt it
        :param recording_mode: Mask to configure how recorded events should be saved
        :param log_filename: If the recording_mode contains TRACING_RECORD_MODE_FILE you must specify a filename
                             where you want to write the log data to - writing to the file will be thread save
        :param log_callback: If the recording_mode contains TRACING_RECORD_MODE_CALLBACK you must specify a function to
                             invoke for every log entry
        """
        if type(process) == int:
            self.process = psutil.Process(process)
        elif type(process) == psutil.Process:
            self.process = process
        else:
            raise AttributeError(
                "The specified process needs to be a valid PID or psutil.Process instance"
            )

        if stop:
            posix.kill(self.process.pid, signal.SIGSTOP)

        # Initialize debugger
        self._debugger_threads = None

        # Recorded process data
        self._process_records = None

        # Filters that may be used to trace only a subset of caught syscalls
        # If this parameters are valid iterables traced syscalls will be checked if they
        # are in the given filter list. If not they won't get recorded
        self.syscall_filter = None
        self.file_access_filter = [
            "open", "stat", "lstat", "access", "connect", "chdir", "rename",
            "mkdir", "rmdir", "creat", "link", "unlink", "symlink", "readlink",
            "chmod", "chown", "lchown", "utime"
            "mknod", "statfs", "chroot", "pivot_root"
        ]

        self.syscall_filter_exclude = None
        self.file_access_filter_exclude = None

        # We start in Process runtime tracing mode only
        self._mode = TRACING_MODE_RUNTIME_TRACING
        self._running = False

        self._recording_mode = recording_mode
        self._log_filename = log_filename
        self._log_callback = log_callback

        if self._recording_mode & TRACING_RECORD_MODE_FILE and not self._log_filename:
            raise AttributeError(
                "File recording requested but no log file specified")

        if self._recording_mode & TRACING_RECORD_MODE_CALLBACK and not self._log_callback:
            raise AttributeError(
                "Callback invocation recording requested but no callback method specified"
            )
예제 #27
0
def main():
    host = sys.argv[1]
    try:
        hostaddr = gethostbyname(host)
    except error:
        sys.stderr.write(sys.argv[1] + ': bad host name\n')
        sys.exit(2)
    #
    if len(sys.argv) > 2:
        servname = sys.argv[2]
    else:
        servname = 'telnet'
    #
    if '0' <= servname[:1] <= '9':
        port = eval(servname)
    else:
        try:
            port = getservbyname(servname, 'tcp')
        except error:
            sys.stderr.write(servname + ': bad tcp service name\n')
            sys.exit(2)
    #
    s = socket(AF_INET, SOCK_STREAM)
    #
    try:
        s.connect((host, port))
    except error as msg:
        sys.stderr.write('connect failed: ' + repr(msg) + '\n')
        sys.exit(1)
    #
    pid = posix.fork()
    #
    if pid == 0:
        # child -- read stdin, write socket
        while 1:
            line = sys.stdin.readline()
            s.send(line)
    else:
        # parent -- read socket, write stdout
        iac = 0  # Interpret next char as command
        opt = ''  # Interpret next char as option
        while 1:
            data = s.recv(BUFSIZE)
            if not data:
                # EOF; kill child and exit
                sys.stderr.write('(Closed by remote host)\n')
                posix.kill(pid, 9)
                sys.exit(1)
            cleandata = ''
            for c in data:
                if opt:
                    print(ord(c))
                    s.send(opt + c)
                    opt = ''
                elif iac:
                    iac = 0
                    if c == IAC:
                        cleandata = cleandata + c
                    elif c in (DO, DONT):
                        if c == DO: print('(DO)', end=' ')
                        else: print('(DONT)', end=' ')
                        opt = IAC + WONT
                    elif c in (WILL, WONT):
                        if c == WILL: print('(WILL)', end=' ')
                        else: print('(WONT)', end=' ')
                        opt = IAC + DONT
                    else:
                        print('(command)', ord(c))
                elif c == IAC:
                    iac = 1
                    print('(IAC)', end=' ')
                else:
                    cleandata = cleandata + c
            sys.stdout.write(cleandata)
            sys.stdout.flush()
예제 #28
0
def main():
    host = sys.argv[1]
    try:
        hostaddr = gethostbyname(host)
    except error:
        sys.stderr.write(sys.argv[1] + ': bad host name\n')
        sys.exit(2)
    #
    if len(sys.argv) > 2:
        servname = sys.argv[2]
    else:
        servname = 'telnet'
    #
    if '0' <= servname[:1] <= '9':
        port = eval(servname)
    else:
        try:
            port = getservbyname(servname, 'tcp')
        except error:
            sys.stderr.write(servname + ': bad tcp service name\n')
            sys.exit(2)
    #
    s = socket(AF_INET, SOCK_STREAM)
    #
    try:
        s.connect((host, port))
    except error as msg:
        sys.stderr.write('connect failed: ' + repr(msg) + '\n')
        sys.exit(1)
    #
    pid = posix.fork()
    #
    if pid == 0:
        # child -- read stdin, write socket
        while 1:
            line = sys.stdin.readline()
            s.send(line)
    else:
        # parent -- read socket, write stdout
        iac = 0         # Interpret next char as command
        opt = ''        # Interpret next char as option
        while 1:
            data = s.recv(BUFSIZE)
            if not data:
                # EOF; kill child and exit
                sys.stderr.write( '(Closed by remote host)\n')
                posix.kill(pid, 9)
                sys.exit(1)
            cleandata = ''
            for c in data:
                if opt:
                    print(ord(c))
                    s.send(opt + c)
                    opt = ''
                elif iac:
                    iac = 0
                    if c == IAC:
                        cleandata = cleandata + c
                    elif c in (DO, DONT):
                        if c == DO: print('(DO)', end=' ')
                        else: print('(DONT)', end=' ')
                        opt = IAC + WONT
                    elif c in (WILL, WONT):
                        if c == WILL: print('(WILL)', end=' ')
                        else: print('(WONT)', end=' ')
                        opt = IAC + DONT
                    else:
                        print('(command)', ord(c))
                elif c == IAC:
                    iac = 1
                    print('(IAC)', end=' ')
                else:
                    cleandata = cleandata + c
            sys.stdout.write(cleandata)
            sys.stdout.flush()
예제 #29
0
파일: ptf.py 프로젝트: mahdi0011/darkcode
 def handle (self):

	# Init server data variable (for while())
	server_input=client_input="DEADBEEF"

	# Get FD from listener
	client_fd=self.request

	# Open socket to serving machine and connect
	server_fd=socket(AF_INET,SOCK_STREAM)
	server_fd.connect (foreign_host,foreign_port)

	# Now, we fork and handle data in both directions
	CPID=fork()

	# Where are we?
	if (CPID<0):
 	  # oops, somehting went wrong
	  print "Could not fork."
	  return(0)

	if (CPID==0):
	  # This is the child, get parent pid
	  PPID=getppid()

	  # infinite loop with break condition
	  # XXX this is not elegant all
	  while(1):
	   # read 1024 bytes from FD
	   server_input=server_fd.recv(1024)

	   # if we couldn't read, back out
	   if not server_input: break;

	   # write data to client
	   client_fd.send(server_input)

	  # If we were disconnected, kill away the parent
	  kill (PPID, SIGTERM);

        else:
	  # This is the parent, child PID is CPID

	  # infinite loop with break condition 
          # XXX this is not elegant

	  while (1):
	   # Fetch signals and back out if kid is dead
	   if (not waitpid(CPID,WNOHANG)): break;

	   # Read from client FD
	   client_input=client_fd.recv(1024)

	   # Back out if we couldn't read anything
	   if not client_input: break; 

	   # Write data to server
	   server_fd.send(client_input)

	  # Get rid of the kid
	  kill (CPID, SIGTERM);

	# This actually should be a "can't happen",
	# but I am not sure
	# Close remaining FDs
	client_fd.close()
	server_fd.close()
def Method1():
    global code
    user_id = getUserID(input('# Type your user login ID : '))
    for entry in posix.listdir('/proc/'):
        if entry.isnumeric() == True:
            if posix.stat('/proc/' + entry).st_uid == user_id:
                code = 'Continue'
                break
    if code == 'Continue':
        print('# Any process belonged to typed user is found.')
        while True:
            option = input(
                '# Do you want to send signal to these processes for closing? (Y/N) : '
            )
            if option in ['Y', 'N']:
                break
        if option == 'N':
            code = 'Cancelled'
            return
        else:
            print('# Retriving processes list...')
            pids = []
            for entry in posix.listdir('/proc/'):
                if entry.isnumeric() == True:
                    if posix.stat('/proc/' + entry).st_uid == user_id:
                        pids.append(int(entry))
            print('# Quitting processes...')
            if posix.getuid() != user_id and posix.getuid() != 0:
                print(
                    '# Error : Don\'t have enough permission. Make sure to run this troubleshooter as root.'
                )
                code = 'RequiredRoot'
                return
            for pid in pids:
                posix.kill(pid, 15)
            input(
                'Waiting for processes to be closed properly (Recommended at 20 seconds). When ready then press enter.'
            )
            print('# Retriving processes list...')
            pids = []
            for entry in posix.listdir('/proc/'):
                if entry.isnumeric() == True:
                    if posix.stat('/proc/' + entry).st_uid == user_id:
                        pids.append(int(entry))
            if pids:
                while True:
                    option = input(
                        '# There are processes not quitted by the signal. Do you want to force killing it? (Y/N) : '
                    )
                    if option in ['Y', 'N']:
                        break
                if option == 'N':
                    code = 'Cancelled'
                    return
                print('# Killing processes...')
                for pid in pids:
                    posix.kill(pid, 9)
            code = 'Complete'
            return
    else:
        print('# No any process belonged to typed user is found.')
        code = 'NoSolution'
        return
예제 #31
0
    if pid == 0:
        # child -- read stdin, write socket
        while 1:
            line = sys.stdin.readline()
            s.send(line)
    else:
        # parent -- read socket, write stdout
        iac = 0  # Interpret next char as command
        opt = ''  # Interpret next char as option
        while 1:
            data = s.recv(BUFSIZE)
            if not data:
                # EOF; kill child and exit
                sys.stderr.write('(Closed by remote host)\n')
                posix.kill(pid, 9)
                sys.exit(1)
            cleandata = ''
            for c in data:
                if opt:
                    print ord(c)
                    s.send(opt + c)
                    opt = ''
                elif iac:
                    iac = 0
                    if c == IAC:
                        cleandata = cleandata + c
                    elif c in (DO, DONT):
                        if c == DO: print '(DO)',
                        else: print '(DONT)',
                        opt = IAC + WONT
예제 #32
0
파일: telnet.py 프로젝트: mcyril/ravel-ftn
#! /usr/bin/env python
# Minimal interface to the Internet telnet protocol.
#
# It refuses all telnet options and does not recognize any of the other
# telnet commands, but can still be used to connect in line-by-line mode.
# It's also useful to play with a number of other services,
# like time, finger, smtp and even ftp.
#
# Usage: telnet host [port]
#
# The port may be a service name or a decimal port number;
# it defaults to 'telnet'.

import sys, posix, time
from socket import *
BUFSIZE = 1024
# Telnet protocol characters
IAC  = chr(255)	# Interpret as command
DONT = chr(254)
DO   = chr(253)
WONT = chr(252)
WILL = chr(251)
def main():
	host = sys.argv[1]
	try:
		hostaddr = gethostbyname(host)
	except error:
		sys.stderr.write(sys.argv[1] + ': bad host name\n')
		sys.exit(2)
	#