# # Copyright OpenEmbedded Contributors # # SPDX-License-Identifier: GPL-2.0-only # import os, struct, mmap class NotELFFileError(Exception): pass class ELFFile: EI_NIDENT = 16 EI_CLASS = 4 EI_DATA = 5 EI_VERSION = 6 EI_OSABI = 7 EI_ABIVERSION = 8 E_MACHINE = 0x12 # possible values for EI_CLASS ELFCLASSNONE = 0 ELFCLASS32 = 1 ELFCLASS64 = 2 # possible value for EI_VERSION EV_CURRENT = 1 # possible values for EI_DATA EI_DATA_NONE = 0 EI_DATA_LSB = 1 EI_DATA_MSB = 2 PT_INTERP = 3 def my_assert(self, expectation, result): if not expectation == result: #print "'%x','%x' %s" % (ord(expectation), ord(result), self.name) raise NotELFFileError("%s is not an ELF" % self.name) def __init__(self, name): self.name = name self.objdump_output = {} self.data = None # Context Manager functions to close the mmap explicitly def __enter__(self): return self def __exit__(self, exc_type, exc_value, traceback): self.close() def close(self): if self.data: self.data.close() def open(self): with open(self.name, "rb") as f: try: self.data = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) except ValueError: # This means the file is empty raise NotELFFileError("%s is empty" % self.name) # Check the file has the minimum number of ELF table entries if len(self.data) < ELFFile.EI_NIDENT + 4: raise NotELFFileError("%s is not an ELF" % self.name) # ELF header self.my_assert(self.data[0], 0x7f) self.my_assert(self.data[1], ord('E')) self.my_assert(self.data[2], ord('L')) self.my_assert(self.data[3], ord('F')) if self.data[ELFFile.EI_CLASS] == ELFFile.ELFCLASS32: self.bits = 32 elif self.data[ELFFile.EI_CLASS] == ELFFile.ELFCLASS64: self.bits = 64 else: # Not 32-bit or 64.. lets assert raise NotELFFileError("ELF but not 32 or 64 bit.") self.my_assert(self.data[ELFFile.EI_VERSION], ELFFile.EV_CURRENT) self.endian = self.data[ELFFile.EI_DATA] if self.endian not in (ELFFile.EI_DATA_LSB, ELFFile.EI_DATA_MSB): raise NotELFFileError("Unexpected EI_DATA %x" % self.endian) def osAbi(self): return self.data[ELFFile.EI_OSABI] def abiVersion(self): return self.data[ELFFile.EI_ABIVERSION] def abiSize(self): return self.bits def isLittleEndian(self): return self.endian == ELFFile.EI_DATA_LSB def isBigEndian(self): return self.endian == ELFFile.EI_DATA_MSB def getStructEndian(self): return {ELFFile.EI_DATA_LSB: "<", ELFFile.EI_DATA_MSB: ">"}[self.endian] def getShort(self, offset): return struct.unpack_from(self.getStructEndian() + "H", self.data, offset)[0] def getWord(self, offset): return struct.unpack_from(self.getStructEndian() + "i", self.data, offset)[0] def isDynamic(self): """ Return True if there is a .interp segment (therefore dynamically linked), otherwise False (statically linked). """ offset = self.getWord(self.bits == 32 and 0x1C or 0x20) size = self.getShort(self.bits == 32 and 0x2A or 0x36) count = self.getShort(self.bits == 32 and 0x2C or 0x38) for i in range(0, count): p_type = self.getWord(offset + i * size) if p_type == ELFFile.PT_INTERP: return True return False def machine(self): """ We know the endian stored in self.endian and we know the position """ return self.getShort(ELFFile.E_MACHINE) def set_objdump(self, cmd, output): self.objdump_output[cmd] = output def run_objdump(self, cmd, d): import bb.process import sys if cmd in self.objdump_output: return self.objdump_output[cmd] objdump = d.getVar('OBJDUMP') env = os.environ.copy() env["LC_ALL"] = "C" env["PATH"] = d.getVar('PATH') try: bb.note("%s %s %s" % (objdump, cmd, self.name)) self.objdump_output[cmd] = bb.process.run([objdump, cmd, self.name], env=env, shell=False)[0] return self.objdump_output[cmd] except Exception as e: bb.note("%s %s %s failed: %s" % (objdump, cmd, self.name, e)) return "" def elf_machine_to_string(machine): """ Return the name of a given ELF e_machine field or the hex value as a string if it isn't recognised. """ try: return { 0x00: "Unset", 0x02: "SPARC", 0x03: "x86", 0x08: "MIPS", 0x14: "PowerPC", 0x28: "ARM", 0x2A: "SuperH", 0x32: "IA-64", 0x3E: "x86-64", 0xB7: "AArch64", 0xF7: "BPF" }[machine] except: return "Unknown (%s)" % repr(machine) def write_error(type, error, d): logfile = d.getVar('QA_LOGFILE') if logfile: p = d.getVar('P') with open(logfile, "a+") as f: f.write("%s: %s [%s]\n" % (p, error, type)) def handle_error(error_class, error_msg, d): if error_class in (d.getVar("ERROR_QA") or "").split(): write_error(error_class, error_msg, d) bb.error("QA Issue: %s [%s]" % (error_msg, error_class)) d.setVar("QA_ERRORS_FOUND", "True") return False elif error_class in (d.getVar("WARN_QA") or "").split(): write_error(error_class, error_msg, d) bb.warn("QA Issue: %s [%s]" % (error_msg, error_class)) else: bb.note("QA Issue: %s [%s]" % (error_msg, error_class)) return True def add_message(messages, section, new_msg): if section not in messages: messages[section] = new_msg else: messages[section] = messages[section] + "\n" + new_msg def exit_with_message_if_errors(message, d): qa_fatal_errors = bb.utils.to_boolean(d.getVar("QA_ERRORS_FOUND"), False) if qa_fatal_errors: bb.fatal(message) def exit_if_errors(d): exit_with_message_if_errors("Fatal QA errors were found, failing task.", d) def check_upstream_status(fullpath): import re kinda_status_re = re.compile(r"^.*upstream.*status.*$", re.IGNORECASE | re.MULTILINE) strict_status_re = re.compile(r"^Upstream-Status: (Pending|Submitted|Denied|Inappropriate|Backport|Inactive-Upstream)( .+)?$", re.MULTILINE) guidelines = "https://www.openembedded.org/wiki/Commit_Patch_Message_Guidelines#Patch_Header_Recommendations:_Upstream-Status" with open(fullpath, encoding='utf-8', errors='ignore') as f: file_content = f.read() match_kinda = kinda_status_re.search(file_content) match_strict = strict_status_re.search(file_content) if not match_strict: if match_kinda: return "Malformed Upstream-Status in patch\n%s\nPlease correct according to %s :\n%s" % (fullpath, guidelines, match_kinda.group(0)) else: return "Missing Upstream-Status in patch\n%s\nPlease add according to %s ." % (fullpath, guidelines) if __name__ == "__main__": import sys with ELFFile(sys.argv[1]) as elf: elf.open() print(elf.isDynamic())