Datasets:

Variable-role
/

sajaniemi_variable_dataset_large

Languages:

code

Tags:

code

variable-roles

sajaniemi

Dataset card Files Files and versions

xet

Community

sajaniemi_variable_dataset_large / pool /shard009 /Python /0080245_posix.py

Pendigard

Upload folder using huggingface_hub (part 105)

8d55ddb verified about 1 month ago

Raw History Blame Contribute Delete

8.73 kB

"""
Posix Signaling Module
"""
# Copyright (C) 2007 Invisigoth - See LICENSE file for details
import sys
import os
import struct
import signal
import platform


import vtrace
import vtrace.util as v_util
import vtrace.platforms.base as v_base

import Elf
from ctypes import *
import ctypes.util as cutil

import envi.resolver as e_resolv
import envi.memory as e_mem
import envi.cli as e_cli


libc = None

class PosixMixin:

    """
    A mixin for systems which use POSIX signals and
    things like wait()
    """

    def __init__(self):
        """
        Setup for the fact that we support signal driven
        debugging on posix platforms
        """
        self.stepping = False # Set this on stepi to diff the TRAP
        self.execing  = False # Set this on exec to diff the TRAP
        self.pthreads = [] # Some platforms make a pthread list

        self.fireTracerThread()

    def platformKill(self):
        self.sendSignal(signal.SIGKILL)

    def sendSignal(self, signo):
        self.requireAttached()
        os.kill(self.pid, signo)

    def platformSendBreak(self):
        self.sendSignal(signal.SIGTRAP) # FIXME maybe change to SIGSTOP

    def posixLibraryLoadHack(self):
        """
        Posix systems don't have library load events, so
        fake it out here... (including pre-populating the
        entire known library bases metadata
        """
        # GHETTO: just look for magic based on binary
        magix = ["\x7fELF",]
        done = []
        for addr,size,perms,fname in self.getMemoryMaps():
            if fname in done:
                continue
            done.append(fname)
            if perms & e_mem.MM_READ:
                try:
                    buf = self.readMemory(addr, 20)
                    for m in magix:
                        if buf.find(m) == 0:
                            self.addLibraryBase(fname, addr)
                            break
                except: #FIXME why can't i read all maps?
                    pass

    def platformWait(self):
        pid, status = os.waitpid(self.pid,0)
        return status

    def posixCreateThreadHack(self):
        '''
        For systems which don't use their debug APIs to
        generate thread creation events on startup, 
        '''
        initid = self.getMeta('ThreadId')
        for tid in self.platformGetThreads().keys():
            self.setMeta('ThreadId', tid)
            self.fireNotifiers(vtrace.NOTIFY_CREATE_THREAD)
        self.setMeta('ThreadId', initid)

    def handleAttach(self):
        self.fireNotifiers(vtrace.NOTIFY_ATTACH)
        self.posixLibraryLoadHack()
        self.posixCreateThreadHack()
        # We'll emulate windows here and send an additional
        # break after our library load events to make things easy
        self.runAgain(False) # Clear this, if they want BREAK to run, it will
        self.fireNotifiers(vtrace.NOTIFY_BREAK)

    def platformProcessEvent(self, status):

        if os.WIFEXITED(status):
            tid = self.getMeta("ThreadId", -1)
            if tid != self.getPid():
                # Set the selected thread ID to the pid cause
                # the old one's invalid
                if tid in self.pthreads:
                    self.pthreads.remove(tid)
                self.setMeta("ThreadId", self.getPid())
                self._fireExitThread(tid, os.WEXITSTATUS(status))
            else:
                self._fireExit(os.WEXITSTATUS(status))

        elif os.WIFSIGNALED(status):
            self.setMeta("ExitCode", os.WTERMSIG(status))
            self.fireNotifiers(vtrace.NOTIFY_EXIT)

        elif os.WIFSTOPPED(status):
            sig = os.WSTOPSIG(status)
            self.handlePosixSignal(sig)

        else:
            print "OMG WTF JUST HAPPENED??!?11/!?1?>!"

    def handlePosixSignal(self, sig):
        """
        Handle a basic posix signal for this trace.  This was seperated from
        platformProcessEvent so extenders could skim events and still use this logic.
        """
        if sig == signal.SIGTRAP:

            # Traps on posix systems are a little complicated
            if self.stepping:
                #FIXME try out was single step thing for intel
                self.stepping = False
                self._fireStep()

            elif self.checkWatchpoints():
                return

            elif self.checkBreakpoints():
                # It was either a known BP or a sendBreak()
                return

            elif self.execing:
                self.execing = False
                self.handleAttach()

            else:
                self._fireSignal(sig)

        elif sig == signal.SIGSTOP:
            #FIXME only on attaching..
            self.handleAttach()

        else:
            self._fireSignal(sig)


class ElfMixin:
    """
    A platform mixin to parse Elf binaries
    """
    def __init__(self):
        self.setMeta('Format','elf')

    def platformParseBinary(self, filename, baseaddr, normname):
        typemap = {
            Elf.STT_FUNC:e_resolv.FunctionSymbol,
            Elf.STT_SECTION:e_resolv.SectionSymbol,
        }

        fd = file(filename,'rb')
        elf = Elf.Elf(fd)
        addbase = 0
        if not elf.isPreLinked() and elf.isSharedObject():
            addbase = baseaddr

        for sec in elf.sections:
            sym = e_resolv.SectionSymbol(sec.name, sec.sh_addr+addbase, sec.sh_size, normname)
            self.addSymbol(sym)

        for sym in elf.symbols:
            symclass = typemap.get((sym.st_info & 0xf), e_resolv.Symbol)
            sym = symclass(sym.name, sym.st_value+addbase, sym.st_size, normname)
            self.addSymbol(sym)

        for sym in elf.dynamic_symbols:
            symclass = typemap.get((sym.st_info & 0xf), e_resolv.Symbol)
            sym = symclass(sym.name, sym.st_value+addbase, sym.st_size, normname)
            self.addSymbol(sym)

# As much as I would *love* if all the ptrace defines were the same all the time,
# there seem to be small platform differences...
# These are the ones upon which most agree
PT_TRACE_ME     = 0   # child declares it's being traced */
PT_READ_I       = 1   # read word in child's I space */
PT_READ_D       = 2   # read word in child's D space */
PT_READ_U       = 3   # read word in child's user structure */
PT_WRITE_I      = 4   # write word in child's I space */
PT_WRITE_D      = 5   # write word in child's D space */
PT_WRITE_U      = 6   # write word in child's user structure */
PT_CONTINUE     = 7   # continue the child */
PT_KILL         = 8   # kill the child process */
PT_STEP         = 9   # single step the child */

def ptrace(code, pid, addr, data):
    """
    The contents of this call are basically cleanly
    passed to the libc implementation of ptrace.
    """
    global libc
    if not libc:
        cloc = cutil.find_library("c")
        if not cloc:
            raise Exception("ERROR: can't find C library on posix system!")
        libc = CDLL(cloc)
        libc.ptrace.restype = c_size_t
        libc.ptrace.argtypes = [c_int, c_uint32, c_size_t, c_size_t]
    return libc.ptrace(code, pid, c_size_t(addr), c_size_t(data))

class PtraceMixin:
    """
    A platform mixin for using the ptrace functions
    to attach/detach/continue/stepi etc. Many *nix systems
    will probably use this...
    NOTE: if you get a PT_FOO undefined, it *probably* means that
    the PT_FOO macro isn't defined for that platform (which means
    it need to be done another way like PT_GETREGS on darwin doesn't
    exist... but the darwin mixin over-rides platformGetRegs)
    """

    def __init__(self):
        """
        Setup supported modes
        """

        self.conthack = 0
        if sys.platform == "darwin":
            self.conthack = 1

        self.fireTracerThread()

    @v_base.threadwrap
    def platformExec(self, cmdline):
        self.execing = True
        cmdlist = e_cli.splitargs(cmdline)
        os.stat(cmdlist[0])
        pid = os.fork()
        if pid == 0:
            ptrace(PT_TRACE_ME, 0, 0, 0)
            os.execv(cmdlist[0], cmdlist)
            sys.exit(-1)
        return pid

    @v_base.threadwrap
    def platformWriteMemory(self, address, bytes):
        wordsize = len(struct.pack("P",0))
        remainder = len(bytes) % wordsize

        if remainder:
            pad = self.readMemory(address+(len(bytes)-remainder), wordsize)
            bytes += pad[remainder:]

        for i in range(len(bytes)/wordsize):
            offset = wordsize*i
            dword = struct.unpack("L",bytes[offset:offset+wordsize])[0]
            if ptrace(PT_WRITE_D, self.pid, long(address+offset), long(dword)) != 0:
                raise Exception("ERROR ptrace PT_WRITE_D failed!")

	"""
	Posix Signaling Module
	"""
	# Copyright (C) 2007 Invisigoth - See LICENSE file for details
	import sys
	import os
	import struct
	import signal
	import platform


	import vtrace
	import vtrace.util as v_util
	import vtrace.platforms.base as v_base

	import Elf
	from ctypes import *
	import ctypes.util as cutil

	import envi.resolver as e_resolv
	import envi.memory as e_mem
	import envi.cli as e_cli


	libc = None

	class PosixMixin:

	"""
	A mixin for systems which use POSIX signals and
	things like wait()
	"""

	def __init__(self):
	"""
	Setup for the fact that we support signal driven
	debugging on posix platforms
	"""
	self.stepping = False # Set this on stepi to diff the TRAP
	self.execing = False # Set this on exec to diff the TRAP
	self.pthreads = [] # Some platforms make a pthread list

	self.fireTracerThread()

	def platformKill(self):
	self.sendSignal(signal.SIGKILL)

	def sendSignal(self, signo):
	self.requireAttached()
	os.kill(self.pid, signo)

	def platformSendBreak(self):
	self.sendSignal(signal.SIGTRAP) # FIXME maybe change to SIGSTOP

	def posixLibraryLoadHack(self):
	"""
	Posix systems don't have library load events, so
	fake it out here... (including pre-populating the
	entire known library bases metadata
	"""
	# GHETTO: just look for magic based on binary
	magix = ["\x7fELF",]
	done = []
	for addr,size,perms,fname in self.getMemoryMaps():
	if fname in done:
	continue
	done.append(fname)
	if perms & e_mem.MM_READ:
	try:
	buf = self.readMemory(addr, 20)
	for m in magix:
	if buf.find(m) == 0:
	self.addLibraryBase(fname, addr)
	break
	except: #FIXME why can't i read all maps?
	pass

	def platformWait(self):
	pid, status = os.waitpid(self.pid,0)
	return status

	def posixCreateThreadHack(self):
	'''
	For systems which don't use their debug APIs to
	generate thread creation events on startup,
	'''
	initid = self.getMeta('ThreadId')
	for tid in self.platformGetThreads().keys():
	self.setMeta('ThreadId', tid)
	self.fireNotifiers(vtrace.NOTIFY_CREATE_THREAD)
	self.setMeta('ThreadId', initid)

	def handleAttach(self):
	self.fireNotifiers(vtrace.NOTIFY_ATTACH)
	self.posixLibraryLoadHack()
	self.posixCreateThreadHack()
	# We'll emulate windows here and send an additional
	# break after our library load events to make things easy
	self.runAgain(False) # Clear this, if they want BREAK to run, it will
	self.fireNotifiers(vtrace.NOTIFY_BREAK)

	def platformProcessEvent(self, status):

	if os.WIFEXITED(status):
	tid = self.getMeta("ThreadId", -1)
	if tid != self.getPid():
	# Set the selected thread ID to the pid cause
	# the old one's invalid
	if tid in self.pthreads:
	self.pthreads.remove(tid)
	self.setMeta("ThreadId", self.getPid())
	self._fireExitThread(tid, os.WEXITSTATUS(status))
	else:
	self._fireExit(os.WEXITSTATUS(status))

	elif os.WIFSIGNALED(status):
	self.setMeta("ExitCode", os.WTERMSIG(status))
	self.fireNotifiers(vtrace.NOTIFY_EXIT)

	elif os.WIFSTOPPED(status):
	sig = os.WSTOPSIG(status)
	self.handlePosixSignal(sig)

	else:
	print "OMG WTF JUST HAPPENED??!?11/!?1?>!"

	def handlePosixSignal(self, sig):
	"""
	Handle a basic posix signal for this trace. This was seperated from
	platformProcessEvent so extenders could skim events and still use this logic.
	"""
	if sig == signal.SIGTRAP:

	# Traps on posix systems are a little complicated
	if self.stepping:
	#FIXME try out was single step thing for intel
	self.stepping = False
	self._fireStep()

	elif self.checkWatchpoints():
	return

	elif self.checkBreakpoints():
	# It was either a known BP or a sendBreak()
	return

	elif self.execing:
	self.execing = False
	self.handleAttach()

	else:
	self._fireSignal(sig)

	elif sig == signal.SIGSTOP:
	#FIXME only on attaching..
	self.handleAttach()

	else:
	self._fireSignal(sig)


	class ElfMixin:
	"""
	A platform mixin to parse Elf binaries
	"""
	def __init__(self):
	self.setMeta('Format','elf')

	def platformParseBinary(self, filename, baseaddr, normname):
	typemap = {
	Elf.STT_FUNC:e_resolv.FunctionSymbol,
	Elf.STT_SECTION:e_resolv.SectionSymbol,
	}

	fd = file(filename,'rb')
	elf = Elf.Elf(fd)
	addbase = 0
	if not elf.isPreLinked() and elf.isSharedObject():
	addbase = baseaddr

	for sec in elf.sections:
	sym = e_resolv.SectionSymbol(sec.name, sec.sh_addr+addbase, sec.sh_size, normname)
	self.addSymbol(sym)

	for sym in elf.symbols:
	symclass = typemap.get((sym.st_info & 0xf), e_resolv.Symbol)
	sym = symclass(sym.name, sym.st_value+addbase, sym.st_size, normname)
	self.addSymbol(sym)

	for sym in elf.dynamic_symbols:
	symclass = typemap.get((sym.st_info & 0xf), e_resolv.Symbol)
	sym = symclass(sym.name, sym.st_value+addbase, sym.st_size, normname)
	self.addSymbol(sym)

	# As much as I would love if all the ptrace defines were the same all the time,
	# there seem to be small platform differences...
	# These are the ones upon which most agree
	PT_TRACE_ME = 0 # child declares it's being traced */
	PT_READ_I = 1 # read word in child's I space */
	PT_READ_D = 2 # read word in child's D space */
	PT_READ_U = 3 # read word in child's user structure */
	PT_WRITE_I = 4 # write word in child's I space */
	PT_WRITE_D = 5 # write word in child's D space */
	PT_WRITE_U = 6 # write word in child's user structure */
	PT_CONTINUE = 7 # continue the child */
	PT_KILL = 8 # kill the child process */
	PT_STEP = 9 # single step the child */

	def ptrace(code, pid, addr, data):
	"""
	The contents of this call are basically cleanly
	passed to the libc implementation of ptrace.
	"""
	global libc
	if not libc:
	cloc = cutil.find_library("c")
	if not cloc:
	raise Exception("ERROR: can't find C library on posix system!")
	libc = CDLL(cloc)
	libc.ptrace.restype = c_size_t
	libc.ptrace.argtypes = [c_int, c_uint32, c_size_t, c_size_t]
	return libc.ptrace(code, pid, c_size_t(addr), c_size_t(data))

	class PtraceMixin:
	"""
	A platform mixin for using the ptrace functions
	to attach/detach/continue/stepi etc. Many *nix systems
	will probably use this...

	NOTE: if you get a PT_FOO undefined, it probably means that
	the PT_FOO macro isn't defined for that platform (which means
	it need to be done another way like PT_GETREGS on darwin doesn't
	exist... but the darwin mixin over-rides platformGetRegs)
	"""

	def __init__(self):
	"""
	Setup supported modes
	"""

	self.conthack = 0
	if sys.platform == "darwin":
	self.conthack = 1

	self.fireTracerThread()

	@v_base.threadwrap
	def platformExec(self, cmdline):
	self.execing = True
	cmdlist = e_cli.splitargs(cmdline)
	os.stat(cmdlist[0])
	pid = os.fork()
	if pid == 0:
	ptrace(PT_TRACE_ME, 0, 0, 0)
	os.execv(cmdlist[0], cmdlist)
	sys.exit(-1)
	return pid

	@v_base.threadwrap
	def platformWriteMemory(self, address, bytes):
	wordsize = len(struct.pack("P",0))
	remainder = len(bytes) % wordsize

	if remainder:
	pad = self.readMemory(address+(len(bytes)-remainder), wordsize)
	bytes += pad[remainder:]

	for i in range(len(bytes)/wordsize):
	offset = wordsize*i
	dword = struct.unpack("L",bytes[offset:offset+wordsize])[0]
	if ptrace(PT_WRITE_D, self.pid, long(address+offset), long(dword)) != 0:
	raise Exception("ERROR ptrace PT_WRITE_D failed!")