/*	$OpenBSD: file_media.c,v 1.48 2016/01/30 17:21:10 krw Exp $	*/

/*
 * file_media.c -
 *
 * Written by Eryk Vershen
 */

/*
 * Copyright 1997,1998 by Apple Computer, Inc.
 *              All Rights Reserved
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation for any purpose and without fee is hereby granted,
 * provided that the above copyright notice appears in all copies and
 * that both the copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * APPLE COMPUTER DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE.
 *
 * IN NO EVENT SHALL APPLE COMPUTER BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
 * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/param.h>		/* DEV_BSIZE */
#include <sys/queue.h>

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

#include "partition_map.h"
#include "file_media.h"

struct ddmap_ondisk {
    uint8_t	ddBlock[4];
    uint8_t	ddSize[2];
    uint8_t	ddType[2];
};

struct block0_ondisk {
    uint8_t	sbSig[2];
    uint8_t	sbBlkSize[2];
    uint8_t	sbBlkCount[4];
    uint8_t	sbDevType[2];
    uint8_t	sbDevId[2];
    uint8_t	sbData[4];
    uint8_t	sbDrvrCount[2];
    uint8_t	sbDDMap[64];	/* ddmap_ondisk[8] */
    uint8_t	reserved[430];
};

struct dpme_ondisk {
    uint8_t	dpme_signature[2];
    uint8_t	dpme_reserved_1[2];
    uint8_t	dpme_map_entries[4];
    uint8_t	dpme_pblock_start[4];
    uint8_t	dpme_pblocks[4];
    uint8_t	dpme_name[DPISTRLEN];
    uint8_t	dpme_type[DPISTRLEN];
    uint8_t	dpme_lblock_start[4];
    uint8_t	dpme_lblocks[4];
    uint8_t	dpme_flags[4];
    uint8_t	dpme_boot_block[4];
    uint8_t	dpme_boot_bytes[4];
    uint8_t	dpme_load_addr[4];
    uint8_t	dpme_reserved_2[4];
    uint8_t	dpme_goto_addr[4];
    uint8_t	dpme_reserved_3[4];
    uint8_t	dpme_checksum[4];
    uint8_t	dpme_processor_id[16];
    uint8_t	dpme_reserved_4[376];
};

static int	read_block(int, uint64_t, void *);
static int	write_block(int, uint64_t, void *);

static int
read_block(int fd, uint64_t sector, void *address)
{
	ssize_t off;

	off = pread(fd, address, DEV_BSIZE, sector * DEV_BSIZE);
	if (off == DEV_BSIZE)
		return 1;

	if (off == 0)
		fprintf(stderr, "end of file encountered");
	else if (off == -1)
		warn("reading file failed");
	else
		fprintf(stderr, "short read");

	return 0;
}

static int
write_block(int fd, uint64_t sector, void *address)
{
	ssize_t off;

	off = pwrite(fd, address, DEV_BSIZE, sector * DEV_BSIZE);
	if (off == DEV_BSIZE)
		return 1;

	warn("writing to file failed");
	return 0;
}

int
read_block0(int fd, struct partition_map *map)
{
	struct block0_ondisk *block0_ondisk;
	struct ddmap_ondisk ddmap_ondisk;
	int i;

	block0_ondisk = malloc(sizeof(struct block0_ondisk));
	if (block0_ondisk == NULL)
		errx(1, "No memory to read block0");

	if (read_block(fd, 0, block0_ondisk) == 0)
		return 0;

	memcpy(&map->sbSig, block0_ondisk->sbSig,
	    sizeof(map->sbSig));
	map->sbSig = betoh16(map->sbSig);
	memcpy(&map->sbBlkSize, block0_ondisk->sbBlkSize,
	    sizeof(map->sbBlkSize));
	map->sbBlkSize = betoh16(map->sbBlkSize);
	memcpy(&map->sbBlkCount, block0_ondisk->sbBlkCount,
	    sizeof(map->sbBlkCount));
	map->sbBlkCount = betoh32(map->sbBlkCount);
	memcpy(&map->sbDevType, block0_ondisk->sbDevType,
	    sizeof(map->sbDevType));
	map->sbDevType = betoh16(map->sbDevType);
	memcpy(&map->sbDevId, block0_ondisk->sbDevId,
	    sizeof(map->sbDevId));
	map->sbDevId = betoh16(map->sbDevId);
	memcpy(&map->sbData, block0_ondisk->sbData,
	    sizeof(map->sbData));
	map->sbData = betoh32(map->sbData);
	memcpy(&map->sbDrvrCount, block0_ondisk->sbDrvrCount,
	    sizeof(map->sbDrvrCount));
	map->sbDrvrCount = betoh16(map->sbDrvrCount);

	for (i = 0; i < 8; i++) {
		memcpy(&ddmap_ondisk,
		    map->sbDDMap+i*sizeof(struct ddmap_ondisk),
		    sizeof(ddmap_ondisk));
		memcpy(&map->sbDDMap[i].ddBlock, &ddmap_ondisk.ddBlock,
		    sizeof(map->sbDDMap[i].ddBlock));
		map->sbDDMap[i].ddBlock =
		    betoh32(map->sbDDMap[i].ddBlock);
		memcpy(&map->sbDDMap[i].ddSize, &ddmap_ondisk.ddSize,
		    sizeof(map->sbDDMap[i].ddSize));
		map->sbDDMap[i].ddSize = betoh16(map->sbDDMap[i].ddSize);
		memcpy(&map->sbDDMap[i].ddType, &ddmap_ondisk.ddType,
		    sizeof(map->sbDDMap[i].ddType));
		map->sbDDMap[i].ddType = betoh32(map->sbDDMap[i].ddType);
	}

	free(block0_ondisk);
	return 1;
}

int
write_block0(int fd, struct partition_map *map)
{
	struct block0_ondisk *block0_ondisk;
	struct ddmap_ondisk ddmap_ondisk;
	int i, rslt;
	uint32_t tmp32;
	uint16_t tmp16;

	block0_ondisk = malloc(sizeof(struct block0_ondisk));
	if (block0_ondisk == NULL)
		errx(1, "No memory to write block 0");

	tmp16 = htobe16(map->sbSig);
	memcpy(block0_ondisk->sbSig, &tmp16,
	    sizeof(block0_ondisk->sbSig));
	tmp16 = htobe16(map->sbBlkSize);
	memcpy(block0_ondisk->sbBlkSize, &tmp16,
	    sizeof(block0_ondisk->sbBlkSize));
	tmp32 = htobe32(map->sbBlkCount);
	memcpy(block0_ondisk->sbBlkCount, &tmp32,
	    sizeof(block0_ondisk->sbBlkCount));
	tmp16 = htobe16(map->sbDevType);
	memcpy(block0_ondisk->sbDevType, &tmp16,
	    sizeof(block0_ondisk->sbDevType));
	tmp16 = htobe16(map->sbDevId);
	memcpy(block0_ondisk->sbDevId, &tmp16,
	    sizeof(block0_ondisk->sbDevId));
	tmp32 = htobe32(map->sbData);
	memcpy(block0_ondisk->sbData, &tmp32,
	    sizeof(block0_ondisk->sbData));
	tmp16 = htobe16(map->sbDrvrCount);
	memcpy(block0_ondisk->sbDrvrCount, &tmp16,
	    sizeof(block0_ondisk->sbDrvrCount));

	for (i = 0; i < 8; i++) {
		tmp32 = htobe32(map->sbDDMap[i].ddBlock);
		memcpy(ddmap_ondisk.ddBlock, &tmp32,
		    sizeof(ddmap_ondisk.ddBlock));
		tmp16 = htobe16(map->sbDDMap[i].ddSize);
		memcpy(&ddmap_ondisk.ddSize, &tmp16,
		    sizeof(ddmap_ondisk.ddSize));
		tmp16 = betoh32(map->sbDDMap[i].ddType);
		memcpy(&ddmap_ondisk.ddType, &tmp16,
		    sizeof(ddmap_ondisk.ddType));
		memcpy(map->sbDDMap+i*sizeof(struct ddmap_ondisk),
		    &ddmap_ondisk, sizeof(ddmap_ondisk));
	}

	rslt = write_block(fd, 0, block0_ondisk);
	free(block0_ondisk);
	return rslt;
}

int
read_dpme(int fd, uint64_t sector, struct entry *entry)
{
	struct dpme_ondisk *dpme_ondisk;

	dpme_ondisk = malloc(sizeof(struct dpme_ondisk));
	if (dpme_ondisk == NULL)
		errx(1, "No memory to read dpme");

	if (read_block(fd, sector, dpme_ondisk) == 0)
		return 0;

	memcpy(&entry->dpme_signature, dpme_ondisk->dpme_signature,
	    sizeof(entry->dpme_signature));
	memcpy(&entry->dpme_map_entries, dpme_ondisk->dpme_map_entries,
	    sizeof(entry->dpme_map_entries));
	memcpy(&entry->dpme_pblock_start, dpme_ondisk->dpme_pblock_start,
	    sizeof(entry->dpme_pblock_start));
	memcpy(&entry->dpme_pblocks, dpme_ondisk->dpme_pblocks,
	    sizeof(entry->dpme_pblocks));
	memcpy(&entry->dpme_lblock_start, dpme_ondisk->dpme_lblock_start,
	    sizeof(entry->dpme_lblock_start));
	memcpy(&entry->dpme_lblocks, dpme_ondisk->dpme_lblocks,
	    sizeof(entry->dpme_lblocks));
	memcpy(&entry->dpme_flags, dpme_ondisk->dpme_flags,
	    sizeof(entry->dpme_flags));
	memcpy(&entry->dpme_boot_block, dpme_ondisk->dpme_boot_block,
	    sizeof(entry->dpme_boot_block));
	memcpy(&entry->dpme_boot_bytes, dpme_ondisk->dpme_boot_bytes,
	    sizeof(entry->dpme_boot_bytes));
	memcpy(&entry->dpme_load_addr, dpme_ondisk->dpme_load_addr,
	    sizeof(entry->dpme_load_addr));
	memcpy(&entry->dpme_goto_addr, dpme_ondisk->dpme_goto_addr,
	    sizeof(entry->dpme_goto_addr));
	memcpy(&entry->dpme_checksum, dpme_ondisk->dpme_checksum,
	    sizeof(entry->dpme_checksum));

	entry->dpme_signature = betoh16(entry->dpme_signature);
	entry->dpme_map_entries = betoh32(entry->dpme_map_entries);
	entry->dpme_pblock_start = betoh32(entry->dpme_pblock_start);
	entry->dpme_pblocks = betoh32(entry->dpme_pblocks);
	entry->dpme_lblock_start = betoh32(entry->dpme_lblock_start);
	entry->dpme_lblocks = betoh32(entry->dpme_lblocks);
	entry->dpme_flags = betoh32(entry->dpme_flags);
	entry->dpme_boot_block = betoh32(entry->dpme_boot_block);
	entry->dpme_boot_bytes = betoh32(entry->dpme_boot_bytes);
	entry->dpme_load_addr = betoh32(entry->dpme_load_addr);
	entry->dpme_goto_addr = betoh32(entry->dpme_goto_addr);
	entry->dpme_checksum = betoh32(entry->dpme_checksum);

	memcpy(entry->dpme_reserved_1, dpme_ondisk->dpme_reserved_1,
	    sizeof(entry->dpme_reserved_1));
	memcpy(entry->dpme_reserved_2, dpme_ondisk->dpme_reserved_2,
	    sizeof(entry->dpme_reserved_2));
	memcpy(entry->dpme_reserved_3, dpme_ondisk->dpme_reserved_3,
	    sizeof(entry->dpme_reserved_3));
	memcpy(entry->dpme_reserved_4, dpme_ondisk->dpme_reserved_4,
	    sizeof(entry->dpme_reserved_4));

	strlcpy(entry->dpme_name, dpme_ondisk->dpme_name,
	    sizeof(entry->dpme_name));
	strlcpy(entry->dpme_type, dpme_ondisk->dpme_type,
	    sizeof(entry->dpme_type));
	strlcpy(entry->dpme_processor_id, dpme_ondisk->dpme_processor_id,
	    sizeof(entry->dpme_processor_id));

	free(dpme_ondisk);
	return 1;
}

int
write_dpme(int fd, uint64_t sector, struct entry *entry)
{
	struct dpme_ondisk *dpme_ondisk;
	int rslt;
	uint32_t tmp32;
	uint16_t tmp16;

	dpme_ondisk = malloc(sizeof(struct dpme_ondisk));
	if (dpme_ondisk == NULL)
		errx(1, "No memory to write dpme");

	memcpy(dpme_ondisk->dpme_name, entry->dpme_name,
	    sizeof(dpme_ondisk->dpme_name));
	memcpy(dpme_ondisk->dpme_type, entry->dpme_type,
	    sizeof(dpme_ondisk->dpme_type));
	memcpy(dpme_ondisk->dpme_processor_id, entry->dpme_processor_id,
	    sizeof(dpme_ondisk->dpme_processor_id));

	memcpy(dpme_ondisk->dpme_reserved_1, entry->dpme_reserved_1,
	    sizeof(dpme_ondisk->dpme_reserved_1));
	memcpy(dpme_ondisk->dpme_reserved_2, entry->dpme_reserved_2,
	    sizeof(dpme_ondisk->dpme_reserved_2));
	memcpy(dpme_ondisk->dpme_reserved_3, entry->dpme_reserved_3,
	    sizeof(dpme_ondisk->dpme_reserved_3));
	memcpy(dpme_ondisk->dpme_reserved_4, entry->dpme_reserved_4,
	    sizeof(dpme_ondisk->dpme_reserved_4));

	tmp16 = htobe16(entry->dpme_signature);
	memcpy(dpme_ondisk->dpme_signature, &tmp16,
	    sizeof(dpme_ondisk->dpme_signature));
	tmp32 = htobe32(entry->dpme_map_entries);
	memcpy(dpme_ondisk->dpme_map_entries, &tmp32,
	    sizeof(dpme_ondisk->dpme_map_entries));
	tmp32 = htobe32(entry->dpme_pblock_start);
	memcpy(dpme_ondisk->dpme_pblock_start, &tmp32,
	    sizeof(dpme_ondisk->dpme_pblock_start));
	tmp32 = htobe32(entry->dpme_pblocks);
	memcpy(dpme_ondisk->dpme_pblocks, &tmp32,
	    sizeof(dpme_ondisk->dpme_pblocks));
	tmp32 = htobe32(entry->dpme_lblock_start);
	memcpy(dpme_ondisk->dpme_lblock_start, &tmp32,
	    sizeof(dpme_ondisk->dpme_lblock_start));
	tmp32 = betoh32(entry->dpme_lblocks);
	memcpy(dpme_ondisk->dpme_lblocks, &tmp32,
	    sizeof(dpme_ondisk->dpme_lblocks));
	tmp32 = betoh32(entry->dpme_flags);
	memcpy(dpme_ondisk->dpme_flags, &tmp32,
	    sizeof(dpme_ondisk->dpme_flags));
	tmp32 = htobe32(entry->dpme_boot_block);
	memcpy(dpme_ondisk->dpme_boot_block, &tmp32,
	    sizeof(dpme_ondisk->dpme_boot_block));
	tmp32 = htobe32(entry->dpme_boot_bytes);
	memcpy(dpme_ondisk->dpme_boot_bytes, &tmp32,
	    sizeof(dpme_ondisk->dpme_boot_bytes));
	tmp32 = betoh32(entry->dpme_load_addr);
	memcpy(dpme_ondisk->dpme_load_addr, &tmp32,
	    sizeof(dpme_ondisk->dpme_load_addr));
	tmp32 = betoh32(entry->dpme_goto_addr);
	memcpy(dpme_ondisk->dpme_goto_addr, &tmp32,
	    sizeof(dpme_ondisk->dpme_goto_addr));
	tmp32 = betoh32(entry->dpme_checksum);
	memcpy(dpme_ondisk->dpme_checksum, &tmp32,
	    sizeof(dpme_ondisk->dpme_checksum));

	rslt = write_block(fd, sector, dpme_ondisk);
	free(dpme_ondisk);
	return rslt;
}