fatelf-utils.c

/**
 * FatELF; support multiple ELF binaries in one file.
 *
 * Please see the file LICENSE.txt in the source's root directory.
 *
 *  This file written by Ryan C. Gordon.
 */

/* code shared between all FatELF utilities... */

#define FATELF_UTILS 1
#include "fatelf-utils.h"

#include <errno.h>
#include <unistd.h>
#include <stdarg.h>

const char *unlink_on_xfail = NULL;
static uint8_t zerobuf[4096];


#ifndef APPID
#define APPID fatelf
#endif

#ifndef APPREV
#define APPREV "???"
#endif

#if (defined __GNUC__)
#   define VERSTR2(x) #x
#   define VERSTR(x) VERSTR2(x)
#   define COMPILERVER " " VERSTR(__GNUC__) "." VERSTR(__GNUC_MINOR__) "." VERSTR(__GNUC_PATCHLEVEL__)
#elif (defined __SUNPRO_C)
#   define VERSTR2(x) #x
#   define VERSTR(x) VERSTR2(x)
#   define COMPILERVER " " VERSTR(__SUNPRO_C)
#elif (defined __VERSION__)
#   define COMPILERVER " " __VERSION__
#else
#   define COMPILERVER ""
#endif

#ifndef __DATE__
#define __DATE__ "(Unknown build date)"
#endif

#ifndef __TIME__
#define __TIME__ "(Unknown build time)"
#endif

#ifndef COMPILER
  #if (defined __GNUC__)
    #define COMPILER "GCC"
  #elif (defined _MSC_VER)
    #define COMPILER "Visual Studio"
  #elif (defined __SUNPRO_C)
    #define COMPILER "Sun Studio"
  #else
    #error Please define your platform.
  #endif
#endif

// macro mess so we can turn APPID and APPREV into a string literal...
#define MAKEBUILDVERSTRINGLITERAL2(id, rev) \
    #id ", revision " rev ", built " __DATE__ " " __TIME__ \
    ", by " COMPILER COMPILERVER

#define MAKEBUILDVERSTRINGLITERAL(id, rev) MAKEBUILDVERSTRINGLITERAL2(id, rev)

const char *fatelf_build_version = MAKEBUILDVERSTRINGLITERAL(APPID, APPREV);



// Report an error to stderr and terminate immediately with exit(1).
void xfail(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    vfprintf(stderr, fmt, ap);
    va_end(ap);
    fprintf(stderr, "\n");
    fflush(stderr);

    if (unlink_on_xfail != NULL)
        unlink(unlink_on_xfail);  // don't care if this fails.
    unlink_on_xfail = NULL;

    exit(1);
} // xfail


// Wrap malloc() with an xfail(), so this returns memory or calls exit().
// Memory is guaranteed to be initialized to zero.
void *xmalloc(const size_t len)
{
    void *retval = calloc(1, len);
    if (retval == NULL)
        xfail("Out of memory!");
    return retval;
} // xmalloc


// Allocate a copy of (str), xfail() on allocation failure.
char *xstrdup(const char *str)
{
    char *retval = (char *) xmalloc(strlen(str) + 1);
    strcpy(retval, str);
    return retval;
} // xstrdup


// xfail() on error.
int xopen(const char *fname, const int flags, const int perms)
{
    const int retval = open(fname, flags, perms);
    if (retval == -1)
        xfail("Failed to open '%s': %s", fname, strerror(errno));
    return retval;
} // xopen


// xfail() on error, handle EINTR.
ssize_t xread(const char *fname, const int fd, void *buf,
              const size_t len, const int must_read)
{
    ssize_t rc;
    while (((rc = read(fd,buf,len)) == -1) && (errno == EINTR)) { /* spin */ }
    if ( (rc == -1) || ((must_read) && (rc != len)) )
        xfail("Failed to read '%s': %s", fname, strerror(errno));
    return rc;
} // xread


// xfail() on error, handle EINTR.
ssize_t xwrite(const char *fname, const int fd,
               const void *buf, const size_t len)
{
    ssize_t rc;
    while (((rc = write(fd,buf,len)) == -1) && (errno == EINTR)) { /* spin */ }
    if (rc == -1)
        xfail("Failed to write '%s': %s", fname, strerror(errno));
    return rc;
} // xwrite

// xfail() on error, handle EINTR.
void xwrite_zeros(const char *fname, const int fd, size_t len)
{
    while (len > 0)
    {
        const size_t count = (len < sizeof (zerobuf)) ? len : sizeof (zerobuf);
        xwrite(fname, fd, zerobuf, count);
        len -= count;
    } // while
} // xwrite_zeros

// xfail() on error, handle EINTR.
void xclose(const char *fname, const int fd)
{
    int rc;
    while ( ((rc = close(fd)) == -1) && (errno == EINTR) ) { /* spin. */ }
    if (rc == -1)
        xfail("Failed to close '%s': %s", fname, strerror(errno));
} // xopen


// xfail() on error.
void xlseek(const char *fname, const int fd,
            const off_t offset, const int whence)
{
    if (lseek(fd, offset, whence) == -1)
        xfail("Failed to seek in '%s': %s", fname, strerror(errno));
} // xlseek


uint64_t xget_file_size(const char *fname, const int fd)
{
    struct stat statbuf;
    if (fstat(fd, &statbuf) == -1)
        xfail("Failed to fstat '%s': %s", fname, strerror(errno));
    return (uint64_t) statbuf.st_size;
} // xget_file_size


static uint8_t copybuf[256 * 1024];

// xfail() on error.
uint64_t xcopyfile(const char *in, const int infd,
                   const char *out, const int outfd)
{
    uint64_t retval = 0;
    ssize_t rc = 0;
    xlseek(in, infd, 0, SEEK_SET);
    while ( (rc = xread(in, infd, copybuf, sizeof (copybuf), 0)) > 0 )
    {
        xwrite(out, outfd, copybuf, rc);
        retval += (uint64_t) rc;
    } // while

    return retval;
} // xcopyfile


static inline uint64_t minui64(const uint64_t a, const uint64_t b)
{
    return (a < b) ? a : b;
} // minui64


void xcopyfile_range(const char *in, const int infd,
                     const char *out, const int outfd,
                     const uint64_t offset, const uint64_t size)
{
    uint64_t remaining = size;
    xlseek(in, infd, (off_t) offset, SEEK_SET);
    while (remaining)
    {
        const size_t cpysize = minui64(remaining, sizeof (copybuf));
        xread(in, infd, copybuf, cpysize, 1);
        xwrite(out, outfd, copybuf, cpysize);
        remaining -= (uint64_t) cpysize;
    } // while
} // xcopyfile_range


void xread_elf_header(const char *fname, const int fd, const uint64_t offset,
                      FATELF_record *record)
{
    const uint8_t magic[4] = { 0x7F, 0x45, 0x4C, 0x46 };
    uint8_t buf[20];  // we only care about the first 20 bytes.
    xlseek(fname, fd, offset, SEEK_SET);
    xread(fname, fd, buf, sizeof (buf), 1);
    if (memcmp(magic, buf, sizeof (magic)) != 0)
        xfail("'%s' is not an ELF binary", fname);

    record->osabi = buf[7];
    record->osabi_version = buf[8];
    record->word_size = buf[4];
    record->byte_order = buf[5];
    record->reserved0 = 0;
    record->reserved1 = 0;
    record->offset = 0;
    record->size = 0;

    if ((record->word_size != FATELF_32BITS) &&
        (record->word_size != FATELF_64BITS))
    {
        xfail("Unexpected word size (%d) in '%s'", record->word_size, fname);
    } // if

    if (record->byte_order == FATELF_BIGENDIAN)
        record->machine = (((uint16_t)buf[18]) << 8) | (((uint16_t)buf[19]));
    else if (record->byte_order == FATELF_LITTLEENDIAN)
        record->machine = (((uint16_t)buf[19]) << 8) | (((uint16_t)buf[18]));
    else
    {
        xfail("Unexpected byte order (%d) in '%s'",
              (int) record->byte_order, fname);
    } // else
} // xread_elf_header


size_t fatelf_header_size(const int bincount)
{
    return (sizeof (FATELF_header) + (sizeof (FATELF_record) * bincount));
} // fatelf_header_size


// Write a uint8_t to a buffer.
static inline uint8_t *putui8(uint8_t *ptr, const uint8_t val)
{
    *(ptr++) = val;
    return ptr;
} // putui8


// Write a native uint16_t to a buffer in littleendian format.
static inline uint8_t *putui16(uint8_t *ptr, const uint16_t val)
{
    *(ptr++) = ((uint8_t) ((val >> 0) & 0xFF));
    *(ptr++) = ((uint8_t) ((val >> 8) & 0xFF));
    return ptr;
} // putui16


// Write a native uint32_t to a buffer in littleendian format.
static inline uint8_t *putui32(uint8_t *ptr, const uint32_t val)
{
    *(ptr++) = ((uint8_t) ((val >> 0) & 0xFF));
    *(ptr++) = ((uint8_t) ((val >> 8) & 0xFF));
    *(ptr++) = ((uint8_t) ((val >> 16) & 0xFF));
    *(ptr++) = ((uint8_t) ((val >> 24) & 0xFF));
    return ptr;
} // putui32


// Write a native uint64_t to a buffer in littleendian format.
static inline uint8_t *putui64(uint8_t *ptr, const uint64_t val)
{
    *(ptr++) = ((uint8_t) ((val >> 0) & 0xFF));
    *(ptr++) = ((uint8_t) ((val >> 8) & 0xFF));
    *(ptr++) = ((uint8_t) ((val >> 16) & 0xFF));
    *(ptr++) = ((uint8_t) ((val >> 24) & 0xFF));
    *(ptr++) = ((uint8_t) ((val >> 32) & 0xFF));
    *(ptr++) = ((uint8_t) ((val >> 40) & 0xFF));
    *(ptr++) = ((uint8_t) ((val >> 48) & 0xFF));
    *(ptr++) = ((uint8_t) ((val >> 56) & 0xFF));
    return ptr;
} // putui64


// Read a uint8_t from a buffer.
static inline uint8_t *getui8(uint8_t *ptr, uint8_t *val)
{
    *val = *ptr;
    return ptr + sizeof (*val);
} // getui8


// Read a littleendian uint16_t from a buffer in native format.
static inline uint8_t *getui16(uint8_t *ptr, uint16_t *val)
{
    *val = ( (((uint16_t) ptr[0]) << 0) | (((uint16_t) ptr[1]) << 8) );
    return ptr + sizeof (*val);
} // getui16


// Read a littleendian uint32_t from a buffer in native format.
static inline uint8_t *getui32(uint8_t *ptr, uint32_t *val)
{
    *val = ( (((uint32_t) ptr[0]) << 0)  |
             (((uint32_t) ptr[1]) << 8)  |
             (((uint32_t) ptr[2]) << 16) |
             (((uint32_t) ptr[3]) << 24) );
    return ptr + sizeof (*val);
} // getui32


// Read a littleendian uint64_t from a buffer in native format.
static inline uint8_t *getui64(uint8_t *ptr, uint64_t *val)
{
    *val = ( (((uint64_t) ptr[0]) << 0)  |
             (((uint64_t) ptr[1]) << 8)  |
             (((uint64_t) ptr[2]) << 16) |
             (((uint64_t) ptr[3]) << 24) |
             (((uint64_t) ptr[4]) << 32) |
             (((uint64_t) ptr[5]) << 40) |
             (((uint64_t) ptr[6]) << 48) |
             (((uint64_t) ptr[7]) << 56) );
    return ptr + sizeof (*val);
} // getui64


void xwrite_fatelf_header(const char *fname, const int fd,
                          const FATELF_header *header)
{
    const size_t buflen = FATELF_DISK_FORMAT_SIZE(header->num_records);
    uint8_t *buf = (uint8_t *) xmalloc(buflen);
    uint8_t *ptr = buf;
    int i;

    ptr = putui32(ptr, header->magic);
    ptr = putui16(ptr, header->version);
    ptr = putui8(ptr, header->num_records);
    ptr = putui8(ptr, header->reserved0);

    for (i = 0; i < header->num_records; i++)
    {
        ptr = putui16(ptr, header->records[i].machine);
        ptr = putui8(ptr, header->records[i].osabi);
        ptr = putui8(ptr, header->records[i].osabi_version);
        ptr = putui8(ptr, header->records[i].word_size);
        ptr = putui8(ptr, header->records[i].byte_order);
        ptr = putui8(ptr, header->records[i].reserved0);
        ptr = putui8(ptr, header->records[i].reserved1);
        ptr = putui64(ptr, header->records[i].offset);
        ptr = putui64(ptr, header->records[i].size);
    } // for

    assert(ptr == (buf + buflen));

    xlseek(fname, fd, 0, SEEK_SET);  // jump to start of file again.
    xwrite(fname, fd, buf, buflen);

    free(buf);
} // xwrite_fatelf_header

// don't forget to free() the returned pointer!
FATELF_header *xread_fatelf_header(const char *fname, const int fd)
{
    FATELF_header *header = NULL;
    uint8_t buf[8];
    uint8_t *fullbuf = NULL;
    uint8_t *ptr = buf;
    uint32_t magic = 0;
    uint16_t version = 0;
    uint8_t bincount = 0;
    uint8_t reserved0 = 0;
    size_t buflen = 0;
    int i = 0;

    xlseek(fname, fd, 0, SEEK_SET);  // just in case.
    xread(fname, fd, buf, sizeof (buf), 1);
    ptr = getui32(ptr, &magic);
    ptr = getui16(ptr, &version);
    ptr = getui8(ptr, &bincount);
    ptr = getui8(ptr, &reserved0);

    if (magic != FATELF_MAGIC)
        xfail("'%s' is not a FatELF binary.", fname);
    else if (version != 1)
        xfail("'%s' uses an unknown FatELF version.", fname);
    
    buflen = FATELF_DISK_FORMAT_SIZE(bincount) - sizeof (buf);
    ptr = fullbuf = (uint8_t *) xmalloc(buflen);
    xread(fname, fd, fullbuf, buflen, 1);

    header = (FATELF_header *) xmalloc(fatelf_header_size(bincount));
    header->magic = magic;
    header->version = version;
    header->num_records = bincount;
    header->reserved0 = reserved0;

    for (i = 0; i < bincount; i++)
    {
        ptr = getui16(ptr, &header->records[i].machine);
        ptr = getui8(ptr, &header->records[i].osabi);
        ptr = getui8(ptr, &header->records[i].osabi_version);
        ptr = getui8(ptr, &header->records[i].word_size);
        ptr = getui8(ptr, &header->records[i].byte_order);
        ptr = getui8(ptr, &header->records[i].reserved0);
        ptr = getui8(ptr, &header->records[i].reserved1);
        ptr = getui64(ptr, &header->records[i].offset);
        ptr = getui64(ptr, &header->records[i].size);
    } // for

    assert(ptr == (fullbuf + buflen));

    free(fullbuf);
    return header;
} // xread_fatelf_header


uint64_t align_to_page(const uint64_t offset)
{
    const size_t pagesize = 4096;  // !!! FIXME: hardcoded pagesize.
    const size_t overflow = (offset % pagesize);
    return overflow ? (offset + (pagesize - overflow)) : offset;
} // align_to_page


// !!! FIXME: these names/descs aren't set in stone.
// List from: http://www.sco.com/developers/gabi/latest/ch4.eheader.html
static const fatelf_machine_info machines[] =
{
    // MUST BE SORTED BY ID!
    { 0, "none", "No machine" },
    { 1, "m32", "AT&T WE 32100" },
    { 2, "sparc", "SPARC" },
    { 3, "i386", "Intel 80386" },
    { 4, "68k", "Motorola 68000" },
    { 5, "88k", "Motorola 88000" },
    { 7, "860", "Intel 80860" },
    { 8, "mips", "MIPS I" },
    { 9, "s370", "IBM System/370" },
    { 10, "mips-rs3", "MIPS RS3000" },
    { 15, "pa-risc", "Hewlett-Packard PA-RISC" },
    { 17, "vpp500", "Fujitsu VPP500" },
    { 18, "sparc32plus", "Enhanced instruction set SPARC" },
    { 19, "960", "Intel 80960" },
    { 20, "ppc", "PowerPC" },
    { 21, "ppc64", "64-bit PowerPC" },
    { 22, "s390", "IBM System/390" },
    { 36, "v800", "NEC V800" },
    { 37, "fr20", "Fujitsu FR20" },
    { 38, "rh32", "TRW RH-32" },
    { 39, "rce", "Motorola RCE" },
    { 40, "arm", "Advanced RISC Machines ARM" },
    { 41, "alpha", "Digital Alpha" },
    { 42, "sh", "Hitachi SH" },
    { 43, "sparcv9", "SPARC Version 9" },
    { 44, "tricore", "Siemens Tricore embedded" },
    { 45, "arc", "Argonaut RISC Core" },
    { 46, "h8-300", "Hitachi H8/300" },
    { 47, "h8-300h", "Hitachi H8/300H" },
    { 48, "h8s", "Hitachi H8S" },
    { 49, "h8-500", "Hitachi H8/500" },
    { 50, "ia64", "Intel IA-64" },
    { 51, "mipsx", "Stanford MIPS-X" },
    { 52, "coldfire", "Motorola Coldfire" },
    { 53, "m68hc12", "Motorola M68HC12" },
    { 54, "mma", "Fujitsu MMA Multimedia Accelerator" },
    { 55, "pcp", "Siemens PCP" },
    { 56, "ncpu", "Sony nCPU embedded RISC" },
    { 57, "ndr1", "Denso NDR1" },
    { 58, "starcore", "Motorola Star*Core" },
    { 59, "me16", "Toyota ME16" },
    { 60, "st100", "STMicroelectronics ST100" },
    { 61, "tinyj", "Advanced Logic Corp. TinyJ" },
    { 62, "x86_64", "AMD x86-64" },
    { 63, "pdsp", "Sony DSP" },
    { 64, "pdp10", "Digital Equipment Corp. PDP-10" },
    { 65, "pdp11", "Digital Equipment Corp. PDP-11" },
    { 66, "fx66", "Siemens FX66" },
    { 67, "st9plus", "STMicroelectronics ST9+" },
    { 68, "st7", "STMicroelectronics ST7" },
    { 69, "68hc16", "Motorola MC68HC16" },
    { 70, "68hc11", "Motorola MC68HC11" },
    { 70, "68hc11", "Motorola MC68HC11" },
    { 71, "68hc08", "Motorola MC68HC08" },
    { 72, "68hc05", "Motorola MC68HC05" },
    { 73, "svx", "Silicon Graphics SVx" },
    { 74, "st19", "STMicroelectronics ST19" },
    { 75, "vax", "Digital VAX" },
    { 76, "cris", "Axis Communications 32-bit embedded processor" },
    { 77, "javelin", "Infineon Technologies 32-bit embedded processor" },
    { 78, "firepath", "Element 14 64-bit DSP Processor" },
    { 79, "zsp", "LSI Logic 16-bit DSP Processor" },
    { 80, "mmix", "Donald Knuth's educational 64-bit processor" },
    { 81, "huany", "Harvard University machine-independent object files" },
    { 82, "prism", "SiTera Prism" },
    { 83, "avr", "Atmel AVR" },
    { 84, "fr30", "Fujitsu FR30" },
    { 85, "d10v", "Mitsubishi D10V" },
    { 86, "d30v", "Mitsubishi D30V" },
    { 87, "v850", "NEC v850" },
    { 88, "m32r", "Mitsubishi M32R" },
    { 89, "mn10300", "Matsushita MN10300" },
    { 90, "mn10200", "Matsushita MN10200" },
    { 91, "pj", "picoJava" },
    { 92, "openrisc", "OpenRISC" },
    { 93, "arc_a5", "ARC Cores Tangent-A5" },
    { 94, "xtensa", "Tensilica Xtensa" },
    { 95, "videocore", "Alphamosaic VideoCore" },
    { 96, "tmm_gpp", "Thompson Multimedia General Purpose Processor" },
    { 97, "ns32k", "National Semiconductor 32000 series" },
    { 98, "tpc", "Tenor Network TPC" },
    { 99, "snp1k", "Trebia SNP 1000" },
    { 100, "st200", "STMicroelectronics ST200" },
    { 101, "ip2k", "Ubicom IP2xxx" },
    { 102, "max", "MAX Processor" },
    { 103, "cr", "National Semiconductor CompactRISC" },
    { 104, "f2mc16", "Fujitsu F2MC16" },
    { 105, "msp430", "Texas Instruments msp430" },
    { 106, "blackfin", "Analog Devices Blackfin" },
    { 107, "se_c33", "S1C33 Family of Seiko Epson processors" },
    { 108, "sep", "Sharp embedded microprocessor" },
    { 109, "arca", "Arca RISC Microprocessor" },
    { 110, "unicore", "Microprocessor series from PKU-Unity Ltd. and MPRC of Peking University" },
    { 0x9026, "alpha", "Digital Alpha" },  // linux headers use this.
    { 0x9080, "v850", "NEC v850" },  // old tools use this, apparently.
    { 0x9041, "m32r", "Mitsubishi M32R" },  // old tools use this, apparently.
    { 0xA390, "s390", "IBM System/390" },  // legacy value.
    { 0xBEEF, "mn10300", "Matsushita MN10300" },  // old tools.
};


// !!! FIXME: these names/descs aren't set in stone.
// List from: http://www.sco.com/developers/gabi/latest/ch4.eheader.html
static const fatelf_osabi_info osabis[] =
{
    // MUST BE SORTED BY ID!
    { 0, "sysv", "UNIX System V" },
    { 1, "hpux", "Hewlett-Packard HP-UX" },
    { 2, "netbsd", "NetBSD" },
    { 3, "linux", "Linux" },
    { 4, "hurd", "Hurd" },
    { 5, "86open", "86Open common IA32" },
    { 6, "solaris", "Sun Solaris" },
    { 7, "aix", "AIX" },
    { 8, "irix", "IRIX" },
    { 9, "freebsd", "FreeBSD" },
    { 10, "tru64", "Compaq TRU64 UNIX" },
    { 11, "modesto", "Novell Modesto" },
    { 12, "openbsd", "OpenBSD" },
    { 13, "openvms", "OpenVMS" },
    { 14, "nsk", "Hewlett-Packard Non-Stop Kernel" },
    { 15, "aros", "Amiga Research OS" },
    { 97, "armabi", "ARM" },
    { 255, "standalone", "Standalone application" },
};


const fatelf_machine_info *get_machine_by_id(const uint16_t id)
{
    int i;
    for (i = 0; i < (sizeof (machines) / sizeof (machines[0])); i++)
    {
        if (machines[i].id == id)
            return &machines[i];
        else if (machines[i].id > id)
            break;  // not found (sorted by id).
    } // for

    return NULL;
} // get_machine_by_id


const fatelf_machine_info *get_machine_by_name(const char *name)
{
    int i;
    for (i = 0; i < (sizeof (machines) / sizeof (machines[0])); i++)
    {
        if (strcmp(machines[i].name, name) == 0)
            return &machines[i];
    } // for

    return NULL;
} // get_machine_by_name


const fatelf_osabi_info *get_osabi_by_id(const uint8_t id)
{
    int i;
    for (i = 0; i < (sizeof (osabis) / sizeof (osabis[0])); i++)
    {
        if (osabis[i].id == id)
            return &osabis[i];
        else if (osabis[i].id > id)
            break;  // not found (sorted by id).
    } // for

    return NULL;
} // get_osabi_by_id


const fatelf_osabi_info *get_osabi_by_name(const char *name)
{
    int i;
    for (i = 0; i < (sizeof (osabis) / sizeof (osabis[0])); i++)
    {
        if (strcmp(osabis[i].name, name) == 0)
            return &osabis[i];
    } // for

    return NULL;
} // get_osabi_by_name


static int parse_abi_version_string(const char *str)
{
    long num = 0;
    char *endptr = NULL;
    const char *prefix = "osabiver";
    const size_t prefix_len = 8;
    assert(strlen(prefix) == prefix_len);
    if (strncmp(str, prefix, prefix_len) != 0)
        return -1;

    str += prefix_len;
    num = strtol(str, &endptr, 0);
    return ( ((endptr == str) || (*endptr != '\0')) ? -1 : ((int) num) );
} // parse_abi_version_string


static int xfind_fatelf_record_by_fields(const FATELF_header *header,
                                         const char *target)
{
    char *buf = xstrdup(target);
    const fatelf_osabi_info *osabi = NULL;
    const fatelf_machine_info *machine = NULL;
    FATELF_record rec;
    int wants = 0;
    int abiver = 0;
    char *str = buf;
    char *ptr = buf;
    int retval = -1;
    int i = 0;

    memset(&rec, '\0', sizeof (rec));

    while (1)
    {
        const char ch = *ptr;
        if ((ch == ':') || (ch == '\0'))
        {
            *ptr = '\0';

            if (ptr == str)
            {
                // no-op for empty string.
            } // if
            else if ((strcmp(str,"be")==0) || (strcmp(str,"bigendian")==0))
            {
                wants |= FATELF_WANT_BYTEORDER;
                rec.byte_order = FATELF_BIGENDIAN;
            } // if
            else if ((strcmp(str,"le")==0) || (strcmp(str,"littleendian")==0))
            {
                wants |= FATELF_WANT_BYTEORDER;
                rec.byte_order = FATELF_LITTLEENDIAN;
            } // else if
            else if (strcmp(str,"32bit") == 0)
            {
                wants |= FATELF_WANT_WORDSIZE;
                rec.word_size = FATELF_32BITS;
            } // else if
            else if (strcmp(str,"64bit") == 0)
            {
                wants |= FATELF_WANT_WORDSIZE;
                rec.word_size = FATELF_64BITS;
            } // else if
            else if ((machine = get_machine_by_name(str)) != NULL)
            {
                wants |= FATELF_WANT_MACHINE;
                rec.machine = machine->id;
            } // else if
            else if ((osabi = get_osabi_by_name(str)) != NULL)
            {
                wants |= FATELF_WANT_OSABI;
                rec.osabi = osabi->id;
            } // else if
            else if ((abiver = parse_abi_version_string(str)) != -1)
            {
                wants |= FATELF_WANT_OSABIVER;
                rec.osabi_version = (uint8_t) abiver;
            } // else if
            else
            {
                xfail("Unknown target '%s'", str);
            } // else

            if (ch == '\0')
                break;  // we're done.

            str = ptr + 1;
        } // if

        ptr++;
    } // while

    free(buf);

    for (i = 0; i < ((int) header->num_records); i++)
    {
        const FATELF_record *prec = &header->records[i];
        if ((wants & FATELF_WANT_MACHINE) && (rec.machine != prec->machine))
            continue;
        else if ((wants & FATELF_WANT_OSABI) && (rec.osabi != prec->osabi))
            continue;
        else if ((wants & FATELF_WANT_OSABIVER) && (rec.osabi_version != prec->osabi_version))
            continue;
        else if ((wants & FATELF_WANT_WORDSIZE) && (rec.word_size != prec->word_size))
            continue;
        else if ((wants & FATELF_WANT_BYTEORDER) && (rec.byte_order != prec->byte_order))
            continue;

        if (retval != -1)
            xfail("Ambiguous target '%s'", target);
        retval = i;
    } // for

    return retval;
} // xfind_fatelf_record_by_fields


int xfind_fatelf_record(const FATELF_header *header, const char *target)
{
    if (strncmp(target, "record", 6) == 0)
    {
        char *endptr = NULL;
        const long num = strtol(target+6, &endptr, 0);
        if ((endptr != target+6) && (*endptr == '\0'))  // a numeric index?
        {
            const long recs = (long) header->num_records;
            if ((num < 0) || (num > recs))
            {
                xfail("No record #%ld in FatELF header (max %d)",
                      num, (int) recs);
            } // if
            return (int) num;
        } // if
    } // if

    return xfind_fatelf_record_by_fields(header, target);
} // xfind_fatelf_record


int fatelf_record_matches(const FATELF_record *a, const FATELF_record *b)
{
    return ( (a->machine == b->machine) &&
             (a->osabi == b->osabi) &&
             (a->osabi_version == b->osabi_version) &&
             (a->word_size == b->word_size) &&
             (a->byte_order == b->byte_order) );
} // fatelf_record_matches


int find_furthest_record(const FATELF_header *header)
{
    // there's nothing that says the records have to be in order, although
    //  we probably _should_. Just in case, check them all.
    const int total = (int) header->num_records;
    uint64_t furthest = 0;
    int retval = -1;
    int i;

    for (i = 0; i < total; i++)
    {
        const FATELF_record *rec = &header->records[i];
        const uint64_t edge = rec->offset + rec->size;
        if (edge > furthest)
        {
            retval = i;
            furthest = edge;
        } // if
    } // for

    return retval;
} // find_furthest_record


const char *fatelf_get_wordsize_string(const uint8_t wordsize)
{
    if (wordsize == FATELF_32BITS)
        return "32";
    else if (wordsize == FATELF_64BITS)
        return "64";
    return "???";
} // fatelf_get_wordsize_string


const char *fatelf_get_byteorder_name(const uint8_t byteorder)
{
    if (byteorder == FATELF_LITTLEENDIAN)
        return "Littleendian";
    else if (byteorder == FATELF_BIGENDIAN)
        return "Bigendian";
    return "???";
} // get_byteorder_name


const char *fatelf_get_byteorder_target_name(const uint8_t byteorder)
{
    if (byteorder == FATELF_LITTLEENDIAN)
        return "le";
    else if (byteorder == FATELF_BIGENDIAN)
        return "be";
    return NULL;
} // fatelf_get_byteorder_target_name


const char *fatelf_get_wordsize_target_name(const uint8_t wordsize)
{
    if (wordsize == FATELF_32BITS)
        return "32bits";
    else if (wordsize == FATELF_64BITS)
        return "64bits";
    return NULL;
} // fatelf_get_wordsize_target_name



const char *fatelf_get_target_name(const FATELF_record *rec, const int wants)
{
    // !!! FIXME: this code is sort of stinky.
    static char buffer[128];
    const fatelf_osabi_info *osabi = get_osabi_by_id(rec->osabi);
    const fatelf_machine_info *machine = get_machine_by_id(rec->machine);
    const char *order = fatelf_get_byteorder_target_name(rec->byte_order);
    const char *wordsize = fatelf_get_wordsize_target_name(rec->word_size);

    buffer[0] = '\0';

    if ((wants & FATELF_WANT_MACHINE) && (machine))
    {
        if (buffer[0])
            strcat(buffer, ":");
        strcat(buffer, machine->name);
    } // if

    if ((wants & FATELF_WANT_WORDSIZE) && (wordsize))
    {
        if (buffer[0])
            strcat(buffer, ":");
        strcat(buffer, wordsize);
    } // if

    if ((wants & FATELF_WANT_BYTEORDER) && (order))
    {
        if (buffer[0])
            strcat(buffer, ":");
        strcat(buffer, order);
    } // if

    if ((wants & FATELF_WANT_OSABI) && (osabi))
    {
        if (buffer[0])
            strcat(buffer, ":");
        strcat(buffer, osabi->name);
    } // if

    if (wants & FATELF_WANT_OSABIVER)
    {
        char tmp[32];
        if (buffer[0])
            strcat(buffer, ":");
        snprintf(tmp, sizeof (tmp), "osabiver%d", (int) rec->osabi_version);
        strcat(buffer, tmp);
    } // if

    return buffer;
} // fatelf_get_target_name


int xfind_junk(const char *fname, const int fd, const FATELF_header *header,
               uint64_t *offset, uint64_t *size)
{
    const int furthest = find_furthest_record(header);

    if (furthest >= 0)  // presumably, we failed elsewhere, but oh well.
    {
        const uint64_t fsize = xget_file_size(fname, fd);
        const FATELF_record *rec = &header->records[furthest];
        const uint64_t edge = rec->offset + rec->size;
        if (fsize > edge)
        {
            *offset = edge;
            *size = fsize - edge;
            return 1;
        } // if
    } // if

    return 0;
} // xfind_junk


void xappend_junk(const char *fname, const int fd,
                  const char *out, const int outfd,
                  const FATELF_header *header)
{
    uint64_t offset, size;
    if (xfind_junk(fname, fd, header, &offset, &size))
        xcopyfile_range(fname, fd, out, outfd, offset, size);
} // xappend_junk


void xfatelf_init(int argc, const char **argv)
{
    memset(zerobuf, '\0', sizeof (zerobuf));  // just in case.
    if ((argc >= 2) && (strcmp(argv[1], "--version") == 0))
    {
        printf("%s\n", fatelf_build_version);
        exit(0);
    } // if
} // xfatelf_init

// end of fatelf-utils.c ...