#include <elf.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

inline int
checkHeader(Elf32_Ehdr *header)
{
    const char message[] = "Not supported ELF file";
    if (header->e_ident[EI_MAG0] != ELFMAG0 || header->e_ident[EI_MAG1] != ELFMAG1 ||
    header->e_ident[EI_MAG2] != ELFMAG2 || header->e_ident[EI_MAG3] != ELFMAG3) {
        fprintf(stderr, "Not an ELF file\n");
        return 1;
    } else if (header->e_ident[EI_CLASS] != ELFCLASS32) {
        fprintf(stderr, "%s\n", message);
        return 1; /* wrong architecture */
    } else if (header->e_ident[EI_DATA] != ELFDATA2LSB) {
        fprintf(stderr, "%s\n", message);
        return 1; /* wrong byte order */
    } else if (header->e_ident[EI_VERSION] != EV_CURRENT) {
        fprintf(stderr, "%s\n", message);
        return 1; /* our elf version stinks */
    } else if (header->e_ident[7] != 0) {
        fprintf(stderr, "%s\n", message);
        return 1; /* missed smth Linux-specific */
    } else if (header->e_ident[8] != 0) {
        fprintf(stderr, "%s\n", message);
        return 1; /* same reason as previous */
    } else if (!(header->e_type == ET_NONE || header->e_type == ET_REL ||
        header->e_type == ET_EXEC || header->e_type == ET_DYN || header->e_type == ET_CORE)) {
        fprintf(stderr, "%s\n", message);
        return 1; /* we don't know which type this ELF is */
    } else if (header->e_machine != EM_386) {
        fprintf(stderr, "%s\n", message);
        return 1; /* wrong processor */
    } else if (header->e_version != EV_CURRENT) {
        fprintf(stderr, "%s\n", message);
        return 1; /* version mismatch */
    }
    return 0; /* this is a perfectly valid Elf32 header for i386 */
}

inline void
displayType(Elf32_Ehdr *header)
{
    switch (header->e_type) {
        case 0:
            printf("TYPE: NONE\n");
            break;
        case 1:
            printf("TYPE: REL\n");
            break;
        case 2:
            printf("TYPE: EXEC\n");
            break;
        case 3:
            printf("TYPE: DYN\n");
            break;
        case 4:
            printf("TYPE: CORE\n");
            break;
        default:
            break;
    }
}

inline int
performRead(int fd, void *target, int size, int offset)
{
    int i = 0, j = 0;
    if (lseek(fd, offset, SEEK_SET) == -1) {
        fprintf(stderr, "Error while reading ELF Header\n");
        return 1;
    }
    while (i < size) {
        i += (j = read(fd, (char *) target + i, size - i));
        if (j == -1 || (j == 0 && i < size)) {
            fprintf(stderr, "Error while reading ELF Header\n");
            return 1;
        }
    }
    return 0;
}

int
main(int argc, char **argv)
{
    int elffile = open(argv[1], O_RDONLY);
    if (elffile == -1) {
        fprintf(stderr, "Couldn't open input file\n");
        return 1;
    }

    Elf32_Ehdr *elf_header = (Elf32_Ehdr *) calloc(1, sizeof(Elf32_Ehdr));
    if (performRead(elffile, elf_header, sizeof(Elf32_Ehdr), 0)) { /* are we literate? */
        return 1;
    }
    if (checkHeader(elf_header)) { /* is this the wrong header for i386? */
        return 1;
    }

    displayType(elf_header);
    Elf32_Shdr *section_header = (Elf32_Shdr *) calloc(1, sizeof(Elf32_Shdr));
    /* retrieve section that stores other sections' names */
    /* if ther's none - that should not be a problem */
    if (performRead(elffile, section_header, sizeof(Elf32_Shdr),
        elf_header->e_shoff + elf_header->e_shstrndx * sizeof(Elf32_Shdr))) {
        return 1;
    }
    char *names = (char *) malloc(section_header->sh_size);
    if (elf_header->e_shnum > 1) { /* since 0th section reserved but counted */
        printf("%20s %10s %10s %10s %6s\n", "NAME", "ADDR", "OFFSET", "SIZE", "ALGN");
        if (performRead(elffile, names, section_header->sh_size, section_header->sh_offset)) {
            return 1;
        }
    }
    for (int i = 1; i < elf_header->e_shnum; i++) {
        if (performRead(elffile, section_header, sizeof(Elf32_Shdr),
            elf_header->e_shoff + i * sizeof(Elf32_Shdr))) {
            return 1;
        }
        printf("%20s 0x%08x %10d %10d 0x%04x\n", &names[section_header->sh_name],
        section_header->sh_addr, section_header->sh_offset, section_header->sh_size,
        section_header->sh_addralign);
    }
    close(elffile);
    free(section_header);
    free(elf_header);
    free(names);
    return 0;
}