/*-
 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
 *
 * Copyright (c) 2002 Jake Burkholder
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>

#include <sys/types.h>
#include <sys/mman.h>
#include <sys/stat.h>

#include <err.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <elf.h>

int elf2aout32(void *v, int fd);
int elf2aout64(void *v, int fd);

#define	xe16toh(x)	((data == ELFDATA2MSB) ? be16toh(x) : le16toh(x))
#define	xe32toh(x)	((data == ELFDATA2MSB) ? be32toh(x) : le32toh(x))
#define	xe64toh(x)	((data == ELFDATA2MSB) ? be64toh(x) : le64toh(x))
#define	htoxe32(x)	((data == ELFDATA2MSB) ? htobe32(x) : htole32(x))

struct exec {
	u_int32_t	a_magic;
	u_int32_t	a_text;
	u_int32_t	a_data;
	u_int32_t	a_bss;
	u_int32_t	a_syms;
	u_int32_t	a_entry;
	u_int32_t	a_trsize;
	u_int32_t	a_drsize;
};

/* we only support OMAGIC */
#define OMAGIC 0407

static void usage(void);

/* parts from NetBSD */

#define	MID_ZERO	0x000	/* unknown - implementation dependent */
#define	MID_SUN010	0x001	/* sun 68010/68020 binary */
#define	MID_SUN020	0x002	/* sun 68020-only binary */

#define	MID_PC386	0x064	/* 386 PC binary. (so quoth BFD) */

#define	MID_I386	0x086	/* i386 BSD binary */
#define	MID_M68K	0x087	/* m68k BSD binary with 8K page sizes */
#define	MID_M68K4K	0x088	/* m68k BSD binary with 4K page sizes */
#define	MID_NS32532	0x089	/* ns32532 */
#define	MID_SPARC	0x08a	/* sparc */
#define	MID_PMAX	0x08b	/* pmax */
#define	MID_VAX1K	0x08c	/* VAX 1K page size binaries */
#define	MID_ALPHA	0x08d	/* Alpha BSD binary */
#define	MID_MIPS	0x08e	/* big-endian MIPS */
#define	MID_ARM6	0x08f	/* ARM6 */
#define	MID_M680002K	0x090	/* m68000 with 2K page sizes */
#define	MID_SH3		0x091	/* SH3 */

#define	MID_POWERPC64	0x094	/* big-endian PowerPC 64 */
#define	MID_POWERPC	0x095	/* big-endian PowerPC */
#define	MID_VAX		0x096	/* VAX */
#define	MID_MIPS1	0x097	/* MIPS1 */
#define	MID_MIPS2	0x098	/* MIPS2 */
#define	MID_M88K	0x099	/* m88k BSD */
#define	MID_HPPA	0x09a	/* HP PARISC */
#define	MID_SH5_64	0x09b	/* LP64 SH5 */
#define	MID_SPARC64	0x09c	/* LP64 sparc */
#define	MID_X86_64	0x09d	/* AMD x86-64 */
#define	MID_SH5_32	0x09e	/* ILP32 SH5 */
#define	MID_IA64	0x09f	/* Itanium */

#define	MID_AARCH64	0x0b7	/* ARM AARCH64 */
#define	MID_OR1K	0x0b8	/* OpenRISC 1000 */
#define	MID_RISCV	0x0b9	/* Risc-V */

#define	MID_HP200	0x0c8	/* hp200 (68010) BSD binary */

#define	MID_HP300	0x12c	/* hp300 (68020+68881) BSD binary */

#define	MID_HPUX800     0x20b   /* hp800 HP-UX binary */
#define	MID_HPUX	0x20c	/* hp200/300 HP-UX binary */

//(ex->e_machine, ex->e_ident[EI_DATA], ex->e_ident[EI_CLASS])
static uint32_t
get_mid(int m, int e, int c)
{
	switch (m) {
	case EM_AARCH64:
		return MID_AARCH64;
	case EM_ALPHA:
		return MID_ALPHA;
	case EM_ARM:
		return MID_ARM6;
	case EM_PARISC:
		return MID_HPPA;
	case EM_386:
		return MID_I386;
	case EM_68K:
		return MID_M68K;
/*	case EM_OR1K:
		return MID_OR1K;*/
	case EM_MIPS:
		if (e == ELFDATA2LSB)
			return MID_PMAX;
		else
			return MID_MIPS;
	case EM_PPC:
		return MID_POWERPC;
	case EM_PPC64:
		return MID_POWERPC64;
		break;
	case EM_RISCV:
		return MID_RISCV;
	case EM_SH:
		return MID_SH3;
	case EM_SPARC:
	case EM_SPARC32PLUS:
	case EM_SPARCV9:
		if (c == ELFCLASS32)
			return MID_SPARC;
		return MID_SPARC64;
	case EM_X86_64:
		return MID_X86_64;
	case EM_VAX:
		return MID_VAX;
	case EM_NONE:
		return MID_ZERO;
	default:
		break;
	}
	return MID_ZERO;
}

int
elf2aout32(void *v, int fd)
{
	Elf32_Half phentsize;
	Elf32_Half phnum;
	Elf32_Word filesz;
	Elf32_Word memsz;
	Elf32_Addr entry;
	Elf32_Off offset;
	Elf32_Off phoff;
	Elf32_Word type;

	Elf32_Phdr *p;
	Elf32_Ehdr *e = v;

	unsigned char data = e->e_ident[EI_DATA];
	struct exec a;
	int i;
	uint32_t mid;

	mid = get_mid(xe16toh(e->e_machine), e->e_ident[EI_DATA], e->e_ident[EI_CLASS]);
	phentsize = xe16toh(e->e_phentsize);
	if (phentsize != sizeof(*p))
		errx(1, "phdr size mismatch");

	entry = xe32toh(e->e_entry);
	phoff = xe32toh(e->e_phoff);
	phnum = xe16toh(e->e_phnum);
	p = (Elf32_Phdr *)((char *)e + phoff);
	bzero(&a, sizeof(a));
	for (i = 0; i < phnum; i++) {
		type = xe32toh(p[i].p_type);
		switch (type) {
		case PT_LOAD:
			if (a.a_magic != 0)
				errx(1, "too many loadable segments");
			filesz = xe32toh(p[i].p_filesz);
			memsz = xe32toh(p[i].p_memsz);
			offset = xe32toh(p[i].p_offset);
			a.a_magic = htoxe32(((uint32_t)mid << 16) | OMAGIC);
			a.a_text = htoxe32(filesz);
			a.a_bss = htoxe32(memsz - filesz);
			a.a_entry = htoxe32(entry);
			if (write(fd, &a, sizeof(a)) != sizeof(a) ||
			    write(fd, (char *)e + offset, filesz) != (ssize_t)filesz)
				err(1, NULL);
			break;
		default:
			break;
		}
	}
	return (0);
}


int
elf2aout64(void *v, int fd)
{
	Elf64_Half phentsize;
	Elf64_Half phnum;
	Elf64_Xword filesz;
	Elf64_Xword memsz;
	Elf64_Addr entry;
	Elf64_Off offset;
	Elf64_Off phoff;
	Elf64_Word type;

	Elf64_Phdr *p;
	Elf64_Ehdr *e = v;

	unsigned char data = e->e_ident[EI_DATA];
	struct exec a;
	int i;
	uint32_t mid;

	mid = get_mid(xe16toh(e->e_machine), e->e_ident[EI_DATA], e->e_ident[EI_CLASS]);
	phentsize = xe16toh(e->e_phentsize);
	if (phentsize != sizeof(*p))
		errx(1, "phdr size mismatch");

	entry = xe64toh(e->e_entry);
	phoff = xe64toh(e->e_phoff);
	phnum = xe16toh(e->e_phnum);
	p = (Elf64_Phdr *)((char *)e + phoff);
	bzero(&a, sizeof(a));
	for (i = 0; i < phnum; i++) {
		type = xe32toh(p[i].p_type);
		switch (type) {
		case PT_LOAD:
			if (a.a_magic != 0)
				errx(1, "too many loadable segments");
			filesz = xe64toh(p[i].p_filesz);
			memsz = xe64toh(p[i].p_memsz);
			offset = xe64toh(p[i].p_offset);
			a.a_magic = htoxe32(((uint32_t)mid << 16) | OMAGIC);
			a.a_text = htoxe32(filesz);
			a.a_bss = htoxe32(memsz - filesz);
			a.a_entry = htoxe32(entry);
			if (write(fd, &a, sizeof(a)) != sizeof(a) ||
			    write(fd, (char *)e + offset, filesz) != (ssize_t)filesz)
				err(1, NULL);
			break;
		default:
			break;
		}
	}
	return (0);
}


/*
 * elf to a.out converter for freebsd/sparc64 bootblocks.
 */
int
main(int ac, char **av)
{
	unsigned char data;
	struct stat sb;
	Elf64_Ehdr *e;
	void *v;
	int efd;
	int fd;
	int c;

	fd = STDIN_FILENO;
	while ((c = getopt(ac, av, "o:")) != -1)
		switch (c) {
		case 'o':
			if ((fd = open(optarg, O_CREAT|O_RDWR, 0644)) < 0)
				err(1, "%s", optarg);
			break;
		case '?':
		default:
			usage();
		}
	ac -= optind;
	av += optind;
	if (ac == 0)
		usage();

	if ((efd = open(*av, O_RDONLY)) < 0 || fstat(efd, &sb) < 0)
		err(1, NULL);
	v = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, efd, 0);
	if ((e = v) == MAP_FAILED)
		err(1, NULL);

	if (!IS_ELF(*e))
		errx(1, "not an elf file");
	if (e->e_ident[EI_CLASS] != ELFCLASS64 && e->e_ident[EI_CLASS] != ELFCLASS32)
		errx(1, "wrong class");
	data = e->e_ident[EI_DATA];
	if (data != ELFDATA2MSB && data != ELFDATA2LSB)
		errx(1, "wrong data format");
	if (e->e_ident[EI_VERSION] != EV_CURRENT)
		errx(1, "wrong elf version");

	if (e->e_ident[EI_CLASS] == ELFCLASS64)
		return elf2aout64(v, fd);
	else
		return elf2aout32(v, fd);
}

static void
usage(void)
{

	fprintf(stderr, "usage: elf2aout [-o outfile] infile\n");
	exit(1);
}