/*
 *  VAS_EBOOT  --  GRand Unified Bootloader
 *  Copyright (C) 2002,2003,2005,2006,2007,2008,2009,2010  Free Software Foundation, Inc.
 *
 *  VAS_EBOOT 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 3 of the License, or
 *  (at your option) any later version.
 *
 *  VAS_EBOOT is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with VAS_EBOOT.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef VAS_EBOOT_BUILD
#include <config-util.h>
#endif
#include <config.h>

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include <VasEBoot/mm.h>
#include <VasEBoot/err.h>
#include <VasEBoot/env.h>
#include <VasEBoot/types.h>
#include <VasEBoot/misc.h>
#include <VasEBoot/i18n.h>
#include <VasEBoot/time.h>
#include <VasEBoot/emu/misc.h>

int verbosity;
int kexecute;

static int VasEBoot_util_tpm_fd = -1;

void
VasEBoot_util_warn (const char *fmt, ...)
{
  va_list ap;

  fprintf (stderr, _("%s: warning:"), program_name);
  fprintf (stderr, " ");
  va_start (ap, fmt);
  vfprintf (stderr, fmt, ap);
  va_end (ap);
  fprintf (stderr, ".\n");
  fflush (stderr);
}

void
VasEBoot_util_info (const char *fmt, ...)
{
  if (verbosity > 0)
    {
      va_list ap;

      fprintf (stderr, _("%s: info:"), program_name);
      fprintf (stderr, " ");
      va_start (ap, fmt);
      vfprintf (stderr, fmt, ap);
      va_end (ap);
      fprintf (stderr, ".\n");
      fflush (stderr);
    }
}

void
VasEBoot_util_error (const char *fmt, ...)
{
  va_list ap;

  fprintf (stderr, _("%s: error:"), program_name);
  fprintf (stderr, " ");
  va_start (ap, fmt);
  vfprintf (stderr, fmt, ap);
  va_end (ap);
  fprintf (stderr, ".\n");
  VasEBoot_exit ();
}

void *
xcalloc (VasEBoot_size_t nmemb, VasEBoot_size_t size)
{
  void *p;

  p = calloc (nmemb, size);
  if (!p)
    VasEBoot_util_error ("%s", _("out of memory"));

  return p;
}

void *
xmalloc (VasEBoot_size_t size)
{
  void *p;

  p = malloc (size);
  if (! p)
    VasEBoot_util_error ("%s", _("out of memory"));

  return p;
}

void *
xrealloc (void *ptr, VasEBoot_size_t size)
{
  ptr = realloc (ptr, size);
  if (! ptr)
    VasEBoot_util_error ("%s", _("out of memory"));

  return ptr;
}

char *
xstrdup (const char *str)
{
  size_t len;
  char *newstr;

  len = strlen (str);
  newstr = (char *) xmalloc (len + 1);
  memcpy (newstr, str, len + 1);

  return newstr;
}

#if !defined (VAS_EBOOT_MKFONT) && !defined (VAS_EBOOT_BUILD)
char *
xasprintf (const char *fmt, ...)
{
  va_list ap;
  char *result;

  va_start (ap, fmt);
  result = VasEBoot_xvasprintf (fmt, ap);
  va_end (ap);
  if (!result)
    VasEBoot_util_error ("%s", _("out of memory"));

  return result;
}
#endif

#if !defined (VAS_EBOOT_MACHINE_EMU) || defined (VAS_EBOOT_UTIL)
void
VasEBoot_exit (void)
{
#if defined (VAS_EBOOT_KERNEL)
  VasEBoot_reboot ();
#endif
  exit (1);
}
#endif

VasEBoot_uint64_t
VasEBoot_get_time_ms (void)
{
  struct timeval tv;

  gettimeofday (&tv, 0);

  return (tv.tv_sec * 1000 + tv.tv_usec / 1000);
}

size_t
VasEBoot_util_get_image_size (const char *path)
{
  FILE *f;
  size_t ret;
  off_t sz;

  f = VasEBoot_util_fopen (path, "rb");

  if (!f)
    VasEBoot_util_error (_("cannot open `%s': %s"), path, strerror (errno));

  fseeko (f, 0, SEEK_END);

  sz = ftello (f);
  if (sz < 0)
    VasEBoot_util_error (_("cannot open `%s': %s"), path, strerror (errno));
  if (sz != (size_t) sz)
    VasEBoot_util_error (_("file `%s' is too big"), path);
  ret = (size_t) sz;

  fclose (f);

  return ret;
}

void
VasEBoot_util_load_image (const char *path, char *buf)
{
  FILE *fp;
  size_t size;

  VasEBoot_util_info ("reading %s", path);

  size = VasEBoot_util_get_image_size (path);

  fp = VasEBoot_util_fopen (path, "rb");
  if (! fp)
    VasEBoot_util_error (_("cannot open `%s': %s"), path,
		     strerror (errno));

  if (fread (buf, 1, size, fp) != size)
    VasEBoot_util_error (_("cannot read `%s': %s"), path,
		     strerror (errno));

  fclose (fp);
}

void
VasEBoot_util_set_kexecute (void)
{
  kexecute++;
}

int
VasEBoot_util_get_kexecute (void)
{
  return kexecute;
}

VasEBoot_err_t
VasEBoot_util_tpm_open (const char *tpm_dev)
{
  if (VasEBoot_util_tpm_fd != -1)
    return VAS_EBOOT_ERR_NONE;

  VasEBoot_util_tpm_fd = open (tpm_dev, O_RDWR);
  if (VasEBoot_util_tpm_fd == -1)
    VasEBoot_util_error (_("cannot open TPM device '%s': %s"), tpm_dev, strerror (errno));

  return VAS_EBOOT_ERR_NONE;
}

VasEBoot_err_t
VasEBoot_util_tpm_close (void)
{
  int err;

  if (VasEBoot_util_tpm_fd == -1)
    return VAS_EBOOT_ERR_NONE;

  err = close (VasEBoot_util_tpm_fd);
  if (err != VAS_EBOOT_ERR_NONE)
    VasEBoot_util_error (_("cannot close TPM device: %s"), strerror (errno));

  VasEBoot_util_tpm_fd = -1;
  return VAS_EBOOT_ERR_NONE;
}

VasEBoot_size_t
VasEBoot_util_tpm_read (void *output, VasEBoot_size_t size)
{
  if (VasEBoot_util_tpm_fd == -1)
    return -1;

  return read (VasEBoot_util_tpm_fd, output, size);
}

VasEBoot_size_t
VasEBoot_util_tpm_write (const void *input, VasEBoot_size_t size)
{
  if (VasEBoot_util_tpm_fd == -1)
    return -1;

  return write (VasEBoot_util_tpm_fd, input, size);
}