def _resolve(self, x):
     if x is None or isinstance(x, int):
         return x
     for y in [self.plt, self.symbols, self.sections]:
         if x in y:
             return y[x]
     die('Could not resolve `%s\'' % x)

 def __coerce__ (self, other):
     if pwn.isint(other) and self._load_addr:
         return (self._load_addr, other)
     elif isinstance(other, str):
         return (self.flush(), other)
     else:
         pwn.die('Could not coerce ROP.  Other value was: %r' % other)

    def _parse_host(self, host):
        # Split off the optional authentication
        host_ = host.split('@', 1)
        if len(host_) == 1:
            auth, host_ = None, host_[0]
        else:
            auth, host_ = host_

        # Parse the authentication
        if auth:
            auth_ = auth.split(':', 1)
            if len(auth_) == 1:
                self._user = auth_[0]
            else:
                self._user, self._password = auth_

        # Parse the optional port
        host_ = host_.split(':', 1)

        if len(host_) == 1:
            self.host = host_[0]
        else:
            self.host, port = host_

            if not (port and port.isdigit()):
                pwn.die('Port "%s" is not a number' % port)

            self._port = int(port)

def p(x, arch = None):
    """Packs an integer into a string based on the current context"""
    if arch == 'amd64':
        return p64(x)
    elif arch == 'i386':
        return p32(x)
    pwn.die('Architecture not set in the context while calling p(%d)' % x)

def u(x, arch = None):
    """Unpacks a string into an integer based on the current context"""
    if arch == 'amd64':
        return u64(x)
    elif arch == 'i386':
        return u32(x)
    pwn.die('Architecture not set in the context while calling u(%s)' % repr(x))

 def gadget(self, what, avoid = ''):
     if what in self._gadget_cache:
         return self._gadget_cache[(what, avoid)]
     gs = []
     err = 'Unknown gadget type: "%s"' % what
     if   what == 'ret':
         gs = self._gadgets.get('popret', {}).get(0, [])
     elif what == 'leave':
         gs = self._gadgets.get('leave', [])
     elif what == 'popebp':
         gs = self._gadgets.get('popebp', [])
     elif what.startswith('pop'):
         if what.startswith('popret'):
             offset = what[6:]
         else:
             if what[-3:] == 'ret':
                 what = what[:-3]
             offset = what[3:]
         if offset.isdigit():
             offset = int(offset)
         elif offset == '':
             offset = 1
         else:
             pwn.die(err)
         gs = self._gadgets.get('popret', {}).get(offset, [])
     else:
         pwn.die(err)
     for g in gs:
         gstr = pwn.pint(g)
         if all(c not in gstr for c in avoid):
             self._gadget_cache[(avoid, what)] = g
             return g

    def __init__(self, file):
        waitfor('Loading ELF file `%s\'' % os.path.basename(file))
        self.sections = {}
        self.symbols = {}
        self.plt = {}
        self.got = {}
        self.elfclass = None
        self._file_data = None

        if not (os.access(file, os.R_OK) and os.path.isfile(file)):
            die('File %s is not readable or does not exist' % file)

        self._file = file

        def check(f):
            if not (os.access(f, os.X_OK) and os.path.isfile(f)):
                die('Executable %s needed for readelf.py, please install binutils' % f)

        check(_READELF)
        check(_OBJDUMP)

        self._load_elfclass()
        self._load_sections()
        self._load_symbols()
        self._load_plt_got()
        succeeded()

 def flush(self, loaded_at = None):
     if loaded_at is not None:
         self._load_addr = loaded_at
     if self.elf.elfclass == 'ELF32':
         return self._generate32()
     else:
         pwn.die('Only 32bit ELF supported')

    def _download_to_cache(self, remote):
        self._initialize_sftp()
        fingerprint = self._get_fingerprint(remote)
        if fingerprint == None:
            import time
            local = os.path.normpath(remote)
            local = os.path.basename(local)
            local += time.strftime('-%Y-%m-d-%H:%M:%S')
            local = os.path.join(self._cachedir, local)

            self._download_raw(remote, local)
            return local

        local = self._get_cachefile(fingerprint)

        if self._verify_local_fingerprint(fingerprint):
            if not self.silent:
                pwn.log.success('Found %s in ssh cache' % remote)
        else:
            self._download_raw(remote, local)

            if not self._verify_local_fingerprint(fingerprint):
                pwn.die('Could not download file "%s"' % remote)

        return local

    def __init__(self, blob, **kwargs):
        self.arch = kwargs.get('arch')
        self.os   = kwargs.get('os')
        self.blob = blob

        if not isinstance(blob, str):
            pwn.die('Trying to create an AssemblerBlob class, but the blob does not have type str.\nThe type is ' + str(type(blob)) + ' with the value:\n' + repr(blob)[:100])

def unbits(s, endian = 'big'):
    out = []

    state = {'cur': ''}
    count = 0

    def flush():
        cur = state['cur'].ljust(8, '0')
        state['cur'] = ''
        if endian == 'little':
            out.append(chr(int(cur[::-1], 2)))
        elif endian == 'big':
            out.append(chr(int(cur, 2)))
        else:
            pwn.die('Wat (endian style)')

    for c in s:
        if c not in ['0', '1', 0, 1, True, False]:
            pwn.die('Unbits called with a funky argument')

        state['cur'] += '1' if c in ['1', 1, True] else '0'
        count += 1

        if count == 8:
            count = 0
            flush()
    if count:
        flush()

    return ''.join(out)

 def call(self, target, args = (), pivot = None):
     '''Irrelevant arguments should be marked by a None'''
     target_addr = self._resolve(target)
     if not target_addr:
         pwn.die('symbol {} not found'.format(target))
     self._chain.append(('call', (target_addr, pivot, pwn.tuplify(args))))
     return self

 def flush():
     cur = state['cur'].ljust(8, '0')
     state['cur'] = ''
     if endian == 'little':
         out.append(chr(int(cur[::-1], 2)))
     elif endian == 'big':
         out.append(chr(int(cur, 2)))
     else:
         pwn.die('Wat (endian style)')

 def section(self, name):
     if name in self.sections:
         self._load_data()
         sec = self.sections[name]
         offset = sec['offset']
         size = sec['size']
         return ''.join(self._data[offset:offset + size])
     else:
         pwn.die('No section named %s' % name)

 def section(self, name):
     if name in self.sections:
         self._load_data()
         sec = self.sections[name]
         offset = sec['offset']
         size = sec['size']
         return self._file_data[offset:offset + size]
     else:
         die('No section named %s' % name)

    def set_name(self, name):
        if name == self.name:
            return

        if self.name in Block._roots:
            if name in Block._roots:
                pwn.die('A root block with the name "%s" already exicsts' % self.name)
            del Block._roots[self.name]
            Block._roots[name] = self
        self.name = name

 def read(self, addr, numb):
     out = []
     while numb > 0:
         data = self._read(addr, numb)
         if data is None:
             die('Offset %x does not live in any section' % addr)
         out.append(data)
         size = len(data)
         numb -= size
         addr += size
     return ''.join(out)

def _run(cmd):
    import subprocess, errno
    try:
        p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        stdout, stderr = p.communicate()
        exitcode = p.wait()
    except OSError, e:
        if e.errno == errno.ENOENT:
            pwn.die('%s is not installed' % cmd[0])
        else:
            raise

 def fix(s):
     s_list = set([s])
     for n in range(100):
         s = s.subs(Block.symbols)
         if s.is_integer:
             break
         if s in s_list:
             break
         if repr(s) > 200:
             pwn.die('The expression "%s" is misbehaving' % repr(s))
         s_list.add(s)
     return s

 def read_symbol(self, name):
     if name in self.symbols:
         sym = self.symbols[name]
         addr = sym['addr']
         size = sym['size']
         data = self.read(addr, size)
         if data is None:
             pwn.die('Symbol %s does not live in any section' % name)
         else:
             return data
     else:
         pwn.die('No symbol named %s' % name)