/* ----------------------------------------------------------------------- *
 *
 *   Copyright 2007-2008 H. Peter Anvin - All Rights Reserved
 *   Copyright 2012 Intel Corporation; author: H. Peter Anvin
 *   Chandramouli Narayanan
 *
 *   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, Inc., 53 Temple Place Ste 330,
 *   Boston MA 02111-1307, USA; either version 2 of the License, or
 *   (at your option) any later version; incorporated herein by reference.
 *
 * ----------------------------------------------------------------------- */

/*
 * adv.c
 *
 * Core ADV I/O
 * Code consolidated from libinstaller/adv*.c and core/adv.inc with the
 * addition of EFI support
 *
 * Return 0 on success, -1 on error, and set errno.
 *
 */
#define  _GNU_SOURCE

#include <syslinux/config.h>
#include <string.h>
#include "adv.h"

unsigned char syslinux_adv[2 * ADV_SIZE];

static void cleanup_adv(unsigned char *advbuf)
{
    int i;
    uint32_t csum;

    /* Make sure both copies agree, and update the checksum */
    *(uint32_t *)advbuf =  ADV_MAGIC1;

    csum = ADV_MAGIC2;
    for (i = 8; i < ADV_SIZE - 4; i += 4)
	csum -= *(uint32_t *)(advbuf + i);

    *(uint32_t *)(advbuf + 4) =  csum;
    *(uint32_t *)(advbuf + ADV_SIZE - 4) =  ADV_MAGIC3;

    memcpy(advbuf + ADV_SIZE, advbuf, ADV_SIZE);
}

void syslinux_reset_adv(unsigned char *advbuf)
{
    /* Create an all-zero ADV */
    memset(advbuf + 2 * 4, 0, ADV_LEN);
    cleanup_adv(advbuf);
}

static int adv_consistent(const unsigned char *p)
{
    int i;
    uint32_t csum;

    if (*(uint32_t *)p != ADV_MAGIC1 ||
	*(uint32_t *)(p + ADV_SIZE - 4) != ADV_MAGIC3)
	return 0;

    csum = 0;
    for (i = 4; i < ADV_SIZE - 4; i += 4)
	csum += *(uint32_t *)(p + i);

    return csum == ADV_MAGIC2;
}

/*
 * Verify that an in-memory ADV is consistent, making the copies consistent.
 * If neither copy is OK, return -1 and call syslinux_reset_adv().
 */
int syslinux_validate_adv(unsigned char *advbuf)
{
    if (adv_consistent(advbuf + 0 * ADV_SIZE)) {
	memcpy(advbuf + ADV_SIZE, advbuf, ADV_SIZE);
	return 0;
    } else if (adv_consistent(advbuf + 1 * ADV_SIZE)) {
	memcpy(advbuf, advbuf + ADV_SIZE, ADV_SIZE);
	return 0;
    } else {
	syslinux_reset_adv(advbuf);
	return -1;
    }
}

/*
 * Read the ADV from an existing instance, or initialize if invalid.
 * Returns -1 on fatal errors, 0 if ADV is okay, 1 if the ADV is
 * invalid, and 2 if the file does not exist.
 */

/* make_filespec
 * Take the ASCII pathname and filename and concatenate them
 * into an allocated memory space as unicode file specification string.
 * The path and cfg ASCII strings are assumed to be null-terminated.
 * For EFI, the separation character in the path name is '\'
 * and therefore it is assumed that the file spec uses '\' as separation char
 *
 * The function returns
 * 	 0  if successful and fspec is a valid allocated CHAR16 pointer
 * 	    Caller is responsible to free up the allocated filespec string
 * 	-1  otherwise
 *
 */
static int make_filespec(CHAR16 **fspec, const char *path, const char *cfg)
{
	CHAR16 *p;
	int size, append;

	/* allocate size for a CHAR16 string */
	size = sizeof(CHAR16) * (strlena((CHAR8 *)path)+strlena((CHAR8 *)cfg)+2);	/* including null */
	*fspec = malloc(size);
	if (!*fspec) return -1;

	append = path[strlena((CHAR8 *)path) - 1] != '\\';
	for (p = *fspec; *path; path++, p++)
		*p = (CHAR16)*path;
	/* append the separation character to the path if need be */
	if (append) *p++ = (CHAR16)'\\';
	for (; *cfg; cfg++, p++)
		*p = (CHAR16)*cfg;
	*p = (CHAR16)CHAR_NULL;

	return 0;
}


/* TODO:
 * set_attributes() and clear_attributes() are supported for VFAT only
 */
int read_adv(const char *path, const char *cfg)
{
    CHAR16 *file;
    EFI_FILE_HANDLE fd;
    EFI_FILE_INFO st;
    int err = 0;
    int rv;

    rv = make_filespec(&file, path, cfg);
    if (rv < 0 || !file) {
	efi_perror(L"read_adv");
	return -1;
    }

    /* TBD: Not sure if EFI accepts the attribute read only
     * even if an existing file is opened for read access
     */
    fd = efi_open(file, EFI_FILE_MODE_READ);
    if (!fd) {
	if (efi_errno != EFI_NOT_FOUND) {
	    err = -1;
	} else {
	    syslinux_reset_adv(syslinux_adv);
	    err = 2;		/* Nonexistence is not a fatal error */
	}
    } else if (!efi_fstat(fd, &st)) {
	err = -1;
    } else if (st.FileSize < 2 * ADV_SIZE) {
	/* Too small to be useful */
	syslinux_reset_adv(syslinux_adv);
	err = 0;		/* Nothing to read... */
    } else if (efi_xpread(fd, syslinux_adv, 2 * ADV_SIZE,
		      st.FileSize - 2 * ADV_SIZE) != 2 * ADV_SIZE) {
	err = -1;
    } else {
	/* We got it... maybe? */
	err = syslinux_validate_adv(syslinux_adv) ? 1 : 0;
    }

    if (err < 0)
	efi_perror(file);
    if (fd)
	efi_close(fd);
    free(file);

    return err;
}

/* For EFI platform, initialize ADV by opening ldlinux.sys
 * as configured and return the primary (adv0) and alternate (adv1)
 * data into caller's buffer. File remains open for subsequent
 * operations. This routine is to be called from comboot vector.
 */
void efi_adv_init(void)
{
    union syslinux_derivative_info sdi;

    get_derivative_info(&sdi);

    if (sdi.c.filesystem == SYSLINUX_FS_SYSLINUX)
	read_adv("", SYSLINUX_FILE);
    else {
	__syslinux_adv_ptr = &syslinux_adv[8]; /* skip head, csum */
	__syslinux_adv_size = ADV_LEN;

	syslinux_validate_adv(syslinux_adv);
    }
}

/* For EFI platform, write 2 * ADV_SIZE data to the file opened
 * at ADV initialization. (i.e ldlinux.sys).
 *
 * TODO:
 * 1. Validate assumption: write back to file from __syslinux_adv_ptr
 * 2. What if there errors?
 * 3. Do we need to set the attributes of the sys file?
 *
 */
int efi_adv_write(void)
{
    char *name;
    unsigned char advtmp[2 * ADV_SIZE];
    unsigned char *advbuf = syslinux_adv;
    int rv;
    int err = 0;
    EFI_FILE_HANDLE	fd;	/* handle to ldlinux.sys */
    CHAR16 *file;
    EFI_FILE_INFO st, xst;
    union syslinux_derivative_info sdi;

    get_derivative_info(&sdi);
    if (sdi.c.filesystem != SYSLINUX_FS_SYSLINUX)
	return -1;

    name = SYSLINUX_FILE;
    rv = make_filespec(&file, "", name);
    if (rv < 0 || !file) {
	efi_errno = EFI_OUT_OF_RESOURCES;
	efi_perror(L"efi_adv_write:");
	return -1;
    }

    fd = efi_open(file, EFI_FILE_MODE_READ);
    if (fd == (EFI_FILE_HANDLE)NULL) {
	err = -1;
	efi_printerr(L"efi_adv_write: Unable to open file %s\n", file);
    } else if (efi_fstat(fd, &st)) {
	err = -1;
	efi_printerr(L"efi_adv_write: Unable to get info for file %s\n", file);
    } else if (st.FileSize < 2 * ADV_SIZE) {
	/* Too small to be useful */
	err = -2;
	efi_printerr(L"efi_adv_write: File size too small to be useful for file %s\n", file);
    } else if (efi_xpread(fd, advtmp, 2 * ADV_SIZE,
		      st.FileSize - 2 * ADV_SIZE) != 2 * ADV_SIZE) {
	err = -1;
	efi_printerr(L"efi_adv_write: Error reading ADV data from file %s\n", file);
    } else {
	cleanup_adv(advbuf);
	err = syslinux_validate_adv(advbuf) ? -2 : 0;

	if (!err) {
	    /* Got a good one, write our own ADV here */
	    efi_clear_attributes(fd);

	    /* Need to re-open read-write */
	    efi_close(fd);
		/* There is no SYNC attribute with EFI open */
	    fd = efi_open(file, EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE);
	    if (fd == (EFI_FILE_HANDLE)NULL) {
		err = -1;
	    } else if (efi_fstat(fd, &xst) || xst.FileSize != st.FileSize) {
		efi_perror(L"efi_adv_write: file status error/mismatch");
		err = -2;
	    }
	    /* Write our own version ... */
	    if (efi_xpwrite(fd, advbuf, 2 * ADV_SIZE,
			st.FileSize - 2 * ADV_SIZE) != 2 * ADV_SIZE) {
		err = -1;
		efi_printerr(L"efi_adv_write: Error write ADV data to file %s\n", file);
	    }
	    if (!err) {
		efi_sync(fd);
		efi_set_attributes(fd);
	    }
	}
    }

    if (err == -2)
	efi_printerr(L"%s: cannot write auxiliary data (need --update)?\n",
		file);
    else if (err == -1)
	efi_perror(L"efi_adv_write:");

    if (fd)
	efi_close(fd);
    if (file)
	free(file);

    return err;
}