/***************************************************************************
 *             __________               __   ___.
 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
 *                     \/            \/     \/    \/            \/
 * $Id$
 *
 * Copyright (C) 2016 Amaury Pouly
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
 * KIND, either express or implied.
 *
 ****************************************************************************/

#include <cstdio>
#include <stdint.h>
#include <cstdlib>
#include <cstring>
#include <getopt.h>
#include <cstdarg>
#include <string>
#include <fstream>
#include <elf.h>

bool g_verbose = false;
bool g_unsafe = false;

uint8_t *read_file(const std::string& path, size_t& size)
{
    std::ifstream fin(path.c_str(), std::ios::binary);
    if(!fin)
    {
        printf("Error: cannot open '%s'\n", path.c_str());
        return 0;
    }
    fin.seekg(0, std::ios::end);
    size = fin.tellg();
    fin.seekg(0, std::ios::beg);
    uint8_t *buf = new uint8_t[size];
    fin.read((char *)buf, size);
    return buf;
}

bool write_file(const std::string& path, uint8_t *buf, size_t size)
{
    std::ofstream fout(path.c_str(), std::ios::binary);
    if(!fout)
    {
        printf("Error: cannot open '%s'\n", path.c_str());
        return false;
    }
    fout.write((char *)buf, size);
    fout.close();
    return true;
}

/* ELF code */
uint8_t *g_elf_buf;
size_t g_elf_size;
Elf32_Shdr *g_elf_symtab;
Elf32_Shdr *g_elf_symtab_strtab;
Elf32_Shdr *g_elf_shstrtab;

Elf32_Ehdr *elf_ehdr()
{
    return (Elf32_Ehdr *)g_elf_buf;
}

#define NTH_SHDR_OFF(n) \
    (elf_ehdr()->e_shoff + elf_ehdr()->e_shentsize * (n))

Elf32_Shdr *elf_shdr(size_t index)
{
    if(index >= elf_ehdr()->e_shnum)
    {
        printf("Warning: section index is out of bounds\n");
        return nullptr;
    }
    return (Elf32_Shdr *)(g_elf_buf + NTH_SHDR_OFF(index));
}

size_t elf_shnum()
{
    return elf_ehdr()->e_shnum;
}

const char *elf_get_str(Elf32_Shdr *strtab, Elf32_Word index)
{
    /* sanity checks */
    if(strtab->sh_type != SHT_STRTAB)
    {
        printf("Warning: string access to a non-string-table section\n");
        return nullptr;
    }
    if(strtab->sh_offset + strtab->sh_size > g_elf_size)
    {
        printf("Warning: string table section does not fit in the file\n");
        return nullptr;
    }
    if(index >= strtab->sh_size)
    {
        printf("Warning: string access to string table is out of bounds\n");
        return nullptr;
    }
    char *buf = (char *)(g_elf_buf + strtab->sh_offset);
    if(buf[strtab->sh_size - 1] != 0)
    {
        printf("Warning: string table is not zero terminated\n");
        return nullptr;
    }
    return buf + index;
}

const char *elf_get_section_name(size_t index)
{
    Elf32_Shdr *shdr = elf_shdr(index);
    return shdr ? elf_get_str(g_elf_shstrtab, shdr->sh_name) : nullptr;
}

const char *elf_get_symbol_name(Elf32_Sym *sym)
{
    if(ELF32_ST_TYPE(sym->st_info) == STT_SECTION)
        return elf_get_section_name(sym->st_shndx);
    else
        return elf_get_str(g_elf_symtab_strtab, sym->st_name);
}

Elf32_Sym *elf_get_symbol_by_name(const char *name)
{
    Elf32_Sym *sym = (Elf32_Sym *)(g_elf_buf + g_elf_symtab->sh_offset);
    size_t nr_syms = g_elf_symtab->sh_size / sizeof(Elf32_Sym);
    for(size_t i = 0; i < nr_syms; i++)
    {
        const char *s = elf_get_symbol_name(&sym[i]);
        if(s != nullptr && strcmp(name, s) == 0)
            return &sym[i];
    }
    return nullptr;
}

Elf32_Sym *elf_get_symbol_by_address(size_t shndx, Elf32_Word address)
{
    Elf32_Sym *sym = (Elf32_Sym *)(g_elf_buf + g_elf_symtab->sh_offset);
    size_t nr_syms = g_elf_symtab->sh_size / sizeof(Elf32_Sym);
    for(size_t i = 0; i < nr_syms; i++)
    {
        if(sym[i].st_shndx == shndx && sym[i].st_value == address)
            return &sym[i];
    }
    return nullptr;
}

Elf32_Sym *elf_get_symbol_by_index(size_t index)
{
    Elf32_Sym *sym = (Elf32_Sym *)(g_elf_buf + g_elf_symtab->sh_offset);
    size_t nr_syms = g_elf_symtab->sh_size / sizeof(Elf32_Sym);
    if(index >= nr_syms)
        return nullptr;
    return &sym[index];
}

void *elf_get_section_ptr(size_t shndx, Elf32_Word address, size_t size)
{
    Elf32_Shdr *shdr = elf_shdr(shndx);
    if(shdr == nullptr)
        return nullptr;
    if(address + size > shdr->sh_size)
        return nullptr;
    if(shdr->sh_offset + shdr->sh_size > g_elf_size)
        return nullptr;
    return g_elf_buf + shdr->sh_offset + address;
}

/* make sure the string has a final zero in the section, optionally check characters
 * are printable */
const char *elf_get_string_ptr_safe(size_t shndx, Elf32_Word offset, bool want_print = true)
{
    Elf32_Shdr *shdr = elf_shdr(shndx);
    if(shdr == nullptr)
        return nullptr;
    /* address must be in the section */
    if(offset >= shdr->sh_size)
        return nullptr;
    /* determine maximum size */
    size_t max_sz = shdr->sh_size - offset;
    const char *ptr = (const char *)(g_elf_buf + shdr->sh_offset + offset);
    for(size_t i = 0; i < max_sz; i++)
    {
        if(ptr[i] == 0) /* found final 0, everything is fine */
            return ptr;
        if(want_print && !isprint(ptr[i]))
            return nullptr;
    }
    return nullptr;
}

size_t elf_find_reloc_section(size_t shndx)
{
    /* find the relocation section */
    for(size_t i = 0; i < elf_ehdr()->e_shnum; i++)
    {
        Elf32_Shdr *shdr = elf_shdr(i);
        if(shdr->sh_type != SHT_REL && shdr->sh_type != SHT_RELA)
            continue;
        if(shdr->sh_info != shndx)
            continue;
        return i;
    }
    return 0;
}

void *elf_get_symbol_ptr(Elf32_Sym *sym, size_t size)
{
    /* NOTE: also works for STT_SECTION since offset will be 0 */
    return elf_get_section_ptr(sym->st_shndx, sym->st_value, size);
}

/* take the position of a 32-bit address in the section and apply relocation if
 * any */
void *elf_reloc_addr32(size_t shndx, Elf32_Word offset)
{
    /* read value */
    uint32_t *val = (uint32_t *)elf_get_section_ptr(shndx, offset, 4);
    if(val == nullptr)
        return 0; /* invalid */
    /* find reloc section if any */
    size_t relshndx = elf_find_reloc_section(shndx);
    if(relshndx == 0)
        return g_elf_buf + *val; /* no relocation applies */
    Elf32_Shdr *shdr = elf_shdr(relshndx);
    /* find relocation that applies */
    if(shdr->sh_type == SHT_RELA)
    {
        printf("Warning: unsupported RELA relocation type\n");
        return 0;
    }
    Elf32_Rel *rel = (Elf32_Rel *)elf_get_section_ptr(relshndx, 0, shdr->sh_size);
    if(rel == nullptr)
    {
        printf("Warning: invalid relocation section\n");
        return 0;
    }
    size_t sym_count = shdr->sh_size / sizeof(Elf32_Rel);
    for(size_t i = 0; i < sym_count; i++)
    {
        /* for relocatable files, r_offset is the offset in the section */
        if(rel[i].r_offset != offset)
            continue;
        /* find symbol, ignore shdr->sh_link and assume it is g_elf_symtab
         * since the file should have only one symbol table anyway */
        Elf32_Sym *sym = elf_get_symbol_by_index(ELF32_R_SYM(rel[i].r_info));
        /* found it! */
        if(g_verbose)
        {
            printf("[section %zu (%s) offset %#x reloc val %#x type %d sym %d (%s)]\n",
                shndx, elf_get_section_name(shndx), offset, *val,
                ELF32_R_TYPE(rel[i].r_info), ELF32_R_SYM(rel[i].r_info),
                sym ? elf_get_symbol_name(sym) : "<undef>");
        }
        /* apply reloc */
        if(ELF32_R_TYPE(rel[i].r_info) == R_ARM_ABS32)
        {
            if(sym == nullptr)
            {
                printf("Warning: R_ARM_ABS32 reloc with invalid symbol reference\n");
                return 0;
            }
            return *val + (uint8_t *)elf_get_symbol_ptr(sym, 0);
        }
        else
        {
            printf("Warning: unsupported relocation type %d\n", ELF32_R_TYPE(rel[i].r_info));
            return 0;
        }
    }
    /* no reloc applies */
    if(g_verbose)
    {
        printf("[section %zu (%s) offset %#x no reloc found]\n", shndx,
            elf_get_section_name(shndx), offset);
    }
    return g_elf_buf + *val; /* no relocation applies */
}

size_t elf_map_virt_addr(uint32_t address, Elf32_Word& out_off)
{
    /* for relocatable file, this is trivial */
    for(size_t i = 0; i < elf_ehdr()->e_shnum; i++)
    {
        Elf32_Shdr *shdr = elf_shdr(i);
        if(shdr->sh_offset <= address && address < shdr->sh_offset + shdr->sh_size)
        {
            out_off = address - shdr->sh_offset;
            if(g_verbose)
            {
                printf("[map %#x to section %zi (%s) at %#x]\n", address, i,
                    elf_get_section_name(i), out_off);
            }
            return i;
        }
    }
    return 0; /* section 0 is always invalid */
}

size_t elf_map_ptr(void *ptr, Elf32_Word& out_off)
{
    uint32_t addr = (uint32_t)((uint8_t *)ptr - g_elf_buf);
    return elf_map_virt_addr(addr, out_off);
}

/* same as elf_reloc_addr32 but find section automatically from pointer */
void *elf_reloc_addr32_ptr(uint32_t *val)
{
    Elf32_Word off;
    size_t sec = elf_map_ptr((void *)val, off);
    /* if it does not belong to any section, don't do anything */
    if(sec == 0)
    {
        printf("Warning: reloc addr pointer not in any section\n");
        return g_elf_buf + *val;
    }
    return elf_reloc_addr32(sec, off);
}

Elf32_Sym *elf_get_symbol_by_ptr(void *ptr)
{
    Elf32_Word off;
    size_t sec = elf_map_ptr(ptr, off);
    return sec ? elf_get_symbol_by_address(sec, off) : nullptr;
}

/* check if a string is safe */
bool elf_is_str_ptr_safe(const char *str)
{
    Elf32_Word name_off;
    /* find the section it belongs to */
    size_t name_shndx = elf_map_ptr((void *)str, name_off);
    if(name_shndx == 0)
        return false;
    /* check the string fit in the section */
    return elf_get_string_ptr_safe(name_shndx, name_off) != nullptr;
}

bool elf_is_ptr_safe(void *ptr, size_t sz)
{
    Elf32_Word ptr_off;
    /* find the section it belongs to */
    size_t ptr_shndx = elf_map_ptr((void *)ptr, ptr_off);
    if(ptr_shndx == 0)
        return false;
    /* check the string fit in the section */
    return elf_get_section_ptr(ptr_shndx, ptr_off, sz) != nullptr;
}

bool elf_init()
{
    if(g_elf_size < sizeof(Elf32_Ehdr))
    {
        printf("Invalid ELF file: too small\n");
        return false;
    }
    Elf32_Ehdr *ehdr = elf_ehdr();
    if(ehdr->e_ident[EI_MAG0] != ELFMAG0 ||
            ehdr->e_ident[EI_MAG1] != ELFMAG1 ||
            ehdr->e_ident[EI_MAG2] != ELFMAG2 ||
            ehdr->e_ident[EI_MAG3] != ELFMAG3)
    {
        printf("Invalid ELF file: invalid ident\n");
        return false;
    }
    /* we only support relocatable files */
    if(ehdr->e_type != ET_REL)
    {
        printf("Unsupported ELF file: this is not a relocatable file\n");
        return false;
    }
    if(ehdr->e_ident[EI_CLASS] != ELFCLASS32 || ehdr->e_machine != EM_ARM)
    {
        printf("Unsupported ELF file: this is not a 32-bit ARM ELF file\n");
        return false;
    }
    /* go through sections */
    if(ehdr->e_shoff == 0)
    {
        printf("Invalid ELF file: no sections\n");
        return false;
    }
    if(ehdr->e_shentsize < sizeof(Elf32_Shdr))
    {
        printf("Invalid ELF file: section entry size too small\n");
        return false;
    }
    if(NTH_SHDR_OFF(ehdr->e_shnum) > g_elf_size)
    {
        printf("Invalid ELF file: sections header does not fit in the file\n");
        return false;
    }
    for(size_t i = 0; i < ehdr->e_shnum; i++)
    {
        Elf32_Shdr *shdr = (Elf32_Shdr *)(g_elf_buf + NTH_SHDR_OFF(i));
        if(shdr->sh_type == SHT_SYMTAB)
            g_elf_symtab = shdr;
    }
    /* handle symbol table */
    if(g_elf_symtab)
    {
        if(g_elf_symtab->sh_offset + g_elf_symtab->sh_size > g_elf_size)
        {
            printf("Invalid ELF file: symtab does not file in the file\n");
            return false;
        }
        g_elf_symtab_strtab = elf_shdr(g_elf_symtab->sh_link);
        if(g_elf_symtab_strtab == nullptr)
        {
            printf("Invalid ELF file: symtab's strtab is not valid\n");
        }
        if(g_elf_symtab_strtab->sh_type != SHT_STRTAB)
        {
            printf("Invalid ELF file: symtab's strtab is not a string table\n");
            return false;
        }
    }
    /* handle section string table */
    if(ehdr->e_shstrndx != SHN_UNDEF)
    {
        g_elf_shstrtab = elf_shdr(ehdr->e_shstrndx);
        if(g_elf_shstrtab == nullptr)
        {
            printf("Invalid ELF file: section string table is invalid\n");
            return false;
        }
    }

    return true;
}

/* main code */

void usage()
{
    printf("usage: nvptool [options] inputs...\n");
    printf("options:\n");
    printf("  -h/--help        Display help\n");
    printf("  -x/--extract     Extract nvp map from icx_nvp_emmc.ko\n");
    printf("  -o/--output      Set output file\n");
    printf("  -v/--verbose     Enable debug output\n");
    printf("  -u/--unsafe      Perform potentially unsafe operations\n");
    exit(1);
}

struct zone_info_v1_t
{
    uint32_t node;
    uint32_t start;
    uint32_t count;
    uint32_t size;
    uint32_t semaphore[4]; /* a 16-byte structure, useless for us */
    uint32_t name; /* pointer to string */
} __attribute__((packed));

struct zone_info_v2_t
{
    uint32_t node;
    uint32_t start;
    uint32_t count;
    uint32_t size;
    uint32_t semaphore[3]; /* a 12-byte structure, useless for us */
    uint32_t name; /* pointer to string */
} __attribute__((packed));

struct area_info_v1_t
{
    uint32_t type; /* 1 = large, 2 = small */
    uint32_t zoneinfo; /* pointer to zone_info_t[] */
    uint32_t zonecount;
    uint32_t semaphore[4]; /* a 16-byte structure, useless for us */
    uint32_t name; /* pointer to string */
} __attribute__((packed));

struct area_info_v2_t
{
    uint32_t type; /* 1 = large, 2 = small */
    uint32_t zoneinfo; /* pointer to zone_info_t[] */
    uint32_t zonecount;
    uint32_t semaphore[3]; /* a 16-byte structure, useless for us */
    uint32_t name; /* pointer to string */
} __attribute__((packed));

int guess_version(void *area_info_ptr)
{
    /* the "semaphore" part is always filled with zeroes, so simply check if there
     * are 3 or 4 of them */
    area_info_v1_t *ai_v1 = (area_info_v1_t *)area_info_ptr;
    if(ai_v1->semaphore[3] == 0)
        return 1; /* v1: semaphore has 4 fields */
    else
        return 2; /* v2: semaphore has 3 fields */
}

int do_extract(const char *output, int argc, char **argv)
{
    if(argc != 1)
    {
        printf("You need to specify exactly one input file to extract from.\n");
        return 3;
    }
    FILE *fout = NULL;
    if(output)
    {
        fout = fopen(output, "w");
        if(fout == NULL)
        {
            printf("Cannot open output file '%s'\n", output);
            return 4;
        }
    }
    /* read elf file */
    g_elf_buf = read_file(argv[0], g_elf_size);
    if(g_elf_buf == nullptr)
    {
        printf("Cannot open input file '%s'\n", argv[0]);
        return 1;
    }
    if(!elf_init())
    {
        printf("This is not a valid ELF file\n");
        return 1;
    }
    if(g_elf_symtab == nullptr)
    {
        printf("This ELF file does not have a symbol table\n");
        return 1;
    }
    /* look for symbol 'AreaInfo' */
    Elf32_Sym *sym_AreaInfo = elf_get_symbol_by_name("AreaInfo");
    if(sym_AreaInfo == nullptr)
    {
        printf("Cannot find symbol 'AreaInfo'\n");
        return 1;
    }
    printf("AreaInfo:\n");
    if(g_verbose)
    {
        printf("[%u bytes at address %#x in section %u (%s)]\n",
            (unsigned)sym_AreaInfo->st_size, (unsigned)sym_AreaInfo->st_value,
            (unsigned)sym_AreaInfo->st_shndx, elf_get_section_name(sym_AreaInfo->st_shndx));
    }
    /* guess version */
    int ver = guess_version(elf_get_symbol_ptr(sym_AreaInfo, sizeof(area_info_v1_t)));
    if(g_verbose)
        printf("[guessed version: %d]\n", ver);
    size_t sizeof_area_info = (ver == 1) ? sizeof(area_info_v1_t) : sizeof(area_info_v2_t);
    size_t sizeof_zone_info = (ver == 1) ? sizeof(zone_info_v1_t) : sizeof(zone_info_v2_t);
    /* sanity check AreaInfo */
    size_t area_count = sym_AreaInfo->st_size / sizeof_area_info;
    if(!g_unsafe && (sym_AreaInfo->st_size % sizeof_area_info) != 0)
    {
        printf("AreaInfo size (%u) is a not a multiple of area_info_t size (%zu).\n",
            (unsigned)sym_AreaInfo->st_size, sizeof_area_info);
        printf("Use unsafe option to override this check\n");
        return 1;
    }
    area_info_v1_t *AreaInfo_v1 = (area_info_v1_t *)elf_get_symbol_ptr(sym_AreaInfo,
        sym_AreaInfo->st_size);
    area_info_v2_t *AreaInfo_v2 = (area_info_v2_t *)AreaInfo_v1;
    if(AreaInfo_v1 == nullptr)
    {
        printf("Symbol does not point to a valid address\n");
        return 1;
    }
    for(size_t i = 0; i < area_count; i++)
    {
        uint32_t type;
        uint32_t *zoneinfo_ptr;
        uint32_t zonecount;
        uint32_t *name_ptr;

        if(ver == 1)
        {
            type = AreaInfo_v1[i].type;
            zoneinfo_ptr = &AreaInfo_v1[i].zoneinfo;
            zonecount = AreaInfo_v1[i].zonecount;
            name_ptr = &AreaInfo_v1[i].name;
        }
        else
        {
            type = AreaInfo_v2[i].type;
            zoneinfo_ptr = &AreaInfo_v2[i].zoneinfo;
            zonecount = AreaInfo_v2[i].zonecount;
            name_ptr = &AreaInfo_v2[i].name;
        }

        if(g_verbose)
        {
            printf("  [type=%u info=%#x count=%u name=%#x]\n", type, *zoneinfo_ptr,
                zonecount, *name_ptr);
        }
        /* translate name address */
        const char *name = (const char *)elf_reloc_addr32_ptr(name_ptr);
        if(name == nullptr || !elf_is_str_ptr_safe(name))
        {
            printf("  Entry name is not a string\n");
            continue;
        }
        /* skip reserved entries */
        if(*zoneinfo_ptr == 0)
        {
            printf("  %s\n", name);
            continue;
        }
        /* relocate the zoneinfo pointer */
        void *Zone = elf_reloc_addr32_ptr(zoneinfo_ptr);
        if(Zone == nullptr)
        {
            printf("  %s\n", name);
            printf("  Zone info pointer is not valid\n");
            continue;
        }
        /* in safe mode, make sure the zone info pointer is a symbol */
        Elf32_Sym *zoneinfo_sym = elf_get_symbol_by_ptr((void *)Zone);
        const char *zoneinfo_sym_name = "<no symbol>";
        if(zoneinfo_sym)
            zoneinfo_sym_name = elf_get_symbol_name(zoneinfo_sym);
        printf("  %s (%s)\n", name, zoneinfo_sym_name);
        if(!g_unsafe && !zoneinfo_sym)
        {
            printf("  Zone info pointer does not correspond to any symbol.\n");
            printf("  Use unsafe option to override this check\n");
            continue;
        }
        /* if we have the symbol, make sure the claimed size match */
        if(!g_unsafe && zoneinfo_sym)
        {
            if(zoneinfo_sym->st_size != sizeof_zone_info * zonecount)
            {
                printf("  Zone info symbol size (%u) does not match expected size (%zu)\n",
                    (unsigned)zoneinfo_sym->st_size, sizeof_zone_info * zonecount);
                printf("  Use unsafe option to override this check\n");
                continue;
            }
        }
        /* sanity check */
        if(!elf_is_ptr_safe((void *)Zone, sizeof_zone_info * zonecount))
        {
            printf("  Zone info pointer is not valid\n");
            continue;
        }
        /* read zone */
        zone_info_v1_t *Zone_v1 = (zone_info_v1_t *)Zone;
        zone_info_v2_t *Zone_v2 = (zone_info_v2_t *)Zone;
        for(size_t j = 0; j < zonecount; j++)
        {
            uint32_t node, start, count, size;
            uint32_t *name_ptr;

            if(ver == 1)
            {
                node = Zone_v1[j].node;
                start = Zone_v1[j].start;
                count = Zone_v1[j].count;
                size = Zone_v1[j].size;
                name_ptr = &Zone_v1[j].name;
            }
            else
            {
                node = Zone_v2[j].node;
                start = Zone_v2[j].start;
                count = Zone_v2[j].count;
                size = Zone_v2[j].size;
                name_ptr = &Zone_v2[j].name;
            }

            if(g_verbose)
            {
                printf("    [node=%u start=%#x count=%u size=%u name=%#x]\n",
                    node, start, count, size, *name_ptr);
            }
            /* translate name address */
            const char *name = (const char *)elf_reloc_addr32_ptr(name_ptr);
            if(name == nullptr || !elf_is_str_ptr_safe(name))
            {
                printf("    Entry name is not a string\n");
                continue;
            }
            printf("    %s: node %03u, size %u\n", name, node, size);
            if(fout)
                fprintf(fout, "%u,%u,%s\n", node, size, name);
        }
    }
    if(fout)
        fclose(fout);
    /* success */
    return 0;
}

int main(int argc, char **argv)
{
    const char *output = NULL;
    bool extract = false;

    if(argc <= 1)
        usage();

    while(1)
    {
        static struct option long_options[] =
        {
            {"help", no_argument, 0, 'h'},
            {"extract", no_argument, 0, 'x'},
            {"output", required_argument, 0, 'o'},
            {"verbose", no_argument, 0, 'v'},
            {"unsafe", no_argument, 0, 'u'},
            {0, 0, 0, 0}
        };

        int c = getopt_long(argc, argv, "hxo:vu", long_options, NULL);
        if(c == -1)
            break;
        switch(c)
        {
            case -1:
                break;
            case 'h':
                usage();
                break;
            case 'o':
                output = optarg;
                break;
            case 'x':
                extract = true;
                break;
            case 'v':
                g_verbose = true;
                break;
            case 'u':
                g_unsafe = true;
                break;
            default:
                abort();
        }
    }

    if(extract)
        return do_extract(output, argc - optind, argv + optind);
    printf("You need to specify an operation. Run nvptool -h for help\n");
    return 1;
}