/* misc.c
 * Copyright (C) 1999, 2001, 2002, 2003, 2007,
 *               2008 Free Software Foundation, Inc.
 *
 * This file is part of Libgcrypt.
 *
 * Libgcrypt is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * Libgcrypt 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <unistd.h>

#include "g10lib.h"
#include "secmem.h"
#include "mpi.h"

static int verbosity_level = 0;

#ifndef HAVE_EXPLICIT_MEMSET
/* Prevent compiler from optimizing away the call to memset by accessing
   memset through volatile pointer. */
static void *(*volatile memset_ptr)(void *, int, size_t) = (void *)memset;
#endif

static void (*fatal_error_handler)(void*,int, const char*) = NULL;
static void *fatal_error_handler_value = 0;
static void (*log_handler)(void*,int, const char*, va_list) = NULL;
static void *log_handler_value = 0;
static const char *(*user_gettext_handler)( const char * ) = NULL;

void
_gcry_set_gettext_handler (const char *(*f)(const char*))
{
    user_gettext_handler = f;
}


const char *
_gcry_gettext( const char *key )
{
    if( user_gettext_handler )
	return user_gettext_handler( key );
    /* FIXME: switch the domain to gnupg and restore later */
    return key;
}

void
_gcry_set_fatalerror_handler( void (*fnc)(void*,int, const char*), void *value)
{
    fatal_error_handler_value = value;
    fatal_error_handler = fnc;
}

static void
write2stderr( const char *s )
{
  /* Dummy variable to silence gcc warning.  */
  int res = write( 2, s, strlen(s) );
  (void) res;
}

/*
 * This function is called for fatal errors.  A caller might want to
 * set his own handler because this function simply calls abort().
 */
void
_gcry_fatal_error (int rc, const char *text)
{
  if ( !text ) /* get a default text */
    text = gpg_strerror (rc);

  if (fatal_error_handler && !fips_mode () )
    fatal_error_handler (fatal_error_handler_value, rc, text);

  fips_signal_fatal_error (text);
  write2stderr("\nFatal error: ");
  write2stderr(text);
  write2stderr("\n");
  _gcry_secmem_term ();
  abort ();
}

/* This is deprecated but very few open source software still uses
 * this.  However there is more than open source out there and thus we
 * need to keep the handler specific for Libgcrypt and can't add a
 * general handler to gpgrt.  */
void
_gcry_set_log_handler (void (*f)(void*,int, const char*, va_list), void *opaque)
{
    log_handler = f;
    log_handler_value = opaque;
}

void
_gcry_set_log_verbosity( int level )
{
    verbosity_level = level;
}

int
_gcry_log_verbosity( int level )
{
    return verbosity_level >= level;
}


/* This handler is called after log_fatal and log_info to do what we
 * used to do in our former own logging functions.  */
static void
my_gpgrt_post_fatal_handler (int level)
{
  static volatile int done;

  if (!done && (level == GPGRT_LOGLVL_FATAL || level == GPGRT_LOGLVL_BUG))
    {
      done = 1;
      fips_signal_fatal_error ("internal error (fatal or bug)");
      _gcry_secmem_term ();
    }
}


void
_gcry_set_gpgrt_post_log_handler (void)
{
  gpgrt_add_post_log_func (my_gpgrt_post_fatal_handler);
}


static enum gpgrt_log_levels
map_log_level (int level)
{
  switch (level)
    {
    case GCRY_LOG_CONT:  return GPGRT_LOGLVL_CONT;
    case GCRY_LOG_INFO:  return GPGRT_LOGLVL_INFO;
    case GCRY_LOG_WARN:  return GPGRT_LOGLVL_WARN;
    case GCRY_LOG_ERROR: return GPGRT_LOGLVL_ERROR;
    case GCRY_LOG_FATAL: return GPGRT_LOGLVL_FATAL;
    case GCRY_LOG_BUG:   return GPGRT_LOGLVL_BUG;
    case GCRY_LOG_DEBUG:
    default:             return GPGRT_LOGLVL_DEBUG;
    }
}


void
_gcry_logv (int level, const char *fmt, va_list arg_ptr)
{
  if (log_handler)
    {
      /* The deprecated log handler has been registered.  */
      log_handler (log_handler_value, level, fmt, arg_ptr);
      if (level == GCRY_LOG_FATAL || level == GCRY_LOG_BUG)
        {
          fips_signal_fatal_error ("internal error (fatal or bug)"
                                   " [legacy bug handler]");
          _gcry_secmem_term ();
          abort ();
        }
    }
  else
    {
      gpgrt_logv_domain ("gcrypt", map_log_level (level), NULL, NULL, 0,
                         fmt, arg_ptr);
    }
}


void
_gcry_log (int level, const char *fmt, ...)
{
  va_list arg_ptr;

  va_start( arg_ptr, fmt ) ;
  _gcry_logv (level, fmt, arg_ptr);
  va_end(arg_ptr);
}


#if defined(JNLIB_GCC_M_FUNCTION) || __STDC_VERSION__ >= 199901L
void
_gcry_bug( const char *file, int line, const char *func )
{
    _gcry_log (GCRY_LOG_BUG,
	     ("... this is a bug (%s:%d:%s)\n"), file, line, func );
    abort(); /* never called, but it makes the compiler happy */
}
void
_gcry_assert_failed (const char *expr, const char *file, int line,
                     const char *func)
{
  _gcry_log (GCRY_LOG_BUG,
             ("Assertion `%s' failed (%s:%d:%s)\n"), expr, file, line, func );
  abort(); /* Never called, but it makes the compiler happy. */
}
#else
void
_gcry_bug( const char *file, int line )
{
    gpgrt_log( GCRY_LOG_BUG,
	     _("you found a bug ... (%s:%d)\n"), file, line);
    abort(); /* never called, but it makes the compiler happy */
}
void
_gcry_assert_failed (const char *expr, const char *file, int line)
{
  _gcry_log (GCRY_LOG_BUG,
             ("Assertion `%s' failed (%s:%d)\n"), expr, file, line);
  abort(); /* Never called, but it makes the compiler happy. */
}
#endif

void
_gcry_log_info( const char *fmt, ... )
{
    va_list arg_ptr ;

    va_start( arg_ptr, fmt ) ;
    _gcry_logv (GCRY_LOG_INFO, fmt, arg_ptr);
    va_end(arg_ptr);
}

void
_gcry_log_error( const char *fmt, ... )
{
    va_list arg_ptr ;

    va_start( arg_ptr, fmt ) ;
    _gcry_logv (GCRY_LOG_ERROR, fmt, arg_ptr);
    va_end(arg_ptr);
}


void
_gcry_log_fatal( const char *fmt, ... )
{
    va_list arg_ptr ;

    va_start( arg_ptr, fmt ) ;
    _gcry_logv (GCRY_LOG_FATAL, fmt, arg_ptr);
    va_end(arg_ptr);
    abort(); /* never called, but it makes the compiler happy */
}

void
_gcry_log_bug( const char *fmt, ... )
{
    va_list arg_ptr ;

    va_start( arg_ptr, fmt ) ;
    _gcry_logv (GCRY_LOG_BUG, fmt, arg_ptr);
    va_end(arg_ptr);
    abort(); /* never called, but it makes the compiler happy */
}

void
_gcry_log_debug( const char *fmt, ... )
{
    va_list arg_ptr ;

    va_start( arg_ptr, fmt ) ;
    _gcry_logv (GCRY_LOG_DEBUG, fmt, arg_ptr);
    va_end(arg_ptr);
}


void
_gcry_log_printf (const char *fmt, ...)
{
  va_list arg_ptr;

  if (fmt)
    {
      va_start( arg_ptr, fmt ) ;
      _gcry_logv (GCRY_LOG_CONT, fmt, arg_ptr);
      va_end(arg_ptr);
    }
}


/* Helper for _gcry_log_printhex and _gcry_log_printmpi.  */
static void
do_printhex (const char *text, const char *text2,
             const void *buffer, size_t length)
{
  int wrap = 0;
  int cnt = 0;

  if (text && *text)
    {
      wrap = 1;
      log_debug ("%s:%s", text, text2);
      if (text2[1] == '[' && length && buffer)
        {
          /* Start with a new line so that we get nice output for
             opaque MPIS:
               "value: [31 bit]"
               "        01020300"  */
          log_printf ("\n");
          text2 = " ";
          log_debug ("%*s  ", (int)strlen(text), "");
        }
    }
  if (length && buffer)
    {
      const unsigned char *p = buffer;
      for (; length--; p++)
        {
          log_printf ("%02x", *p);
          if (wrap && ++cnt == 32 && length)
            {
              cnt = 0;
              log_printf (" \\\n");
              log_debug ("%*s %*s",
                         (int)strlen(text), "", (int)strlen(text2), "");
            }
        }
    }
  if (text)
    log_printf ("\n");
}


/* Print a hexdump of BUFFER.  With TEXT of NULL print just the raw
   dump without any wrappping, with TEXT an empty string, print a
   trailing linefeed, otherwise print an entire debug line. */
void
_gcry_log_printhex (const char *text, const void *buffer, size_t length)
{
  do_printhex (text, " ", buffer, length);
}


/* Print MPI in hex notation.  To make clear that the output is an MPI
   a sign is always printed. With TEXT of NULL print just the raw dump
   without any wrapping, with TEXT an empty string, print a trailing
   linefeed, otherwise print an entire debug line. */
void
_gcry_log_printmpi (const char *text, gcry_mpi_t mpi)
{
  unsigned char *rawmpi;
  unsigned int rawmpilen;
  int sign;

  if (!mpi)
    do_printhex (text? text:" ", " (null)", NULL, 0);
  else if (mpi_is_opaque (mpi))
    {
      unsigned int nbits;
      const unsigned char *p;
      char prefix[30];

      p = mpi_get_opaque (mpi, &nbits);
      snprintf (prefix, sizeof prefix, " [%u bit]", nbits);
      do_printhex (text? text:" ", prefix, p, (nbits+7)/8);
    }
  else
    {
      rawmpi = _gcry_mpi_get_buffer (mpi, 0, &rawmpilen, &sign);
      if (!rawmpi)
        do_printhex (text? text:" ", " [out of core]", NULL, 0);
      else
        {
          if (!rawmpilen)
            do_printhex (text, sign? "-":"+", "", 1);
          else
            do_printhex (text, sign? "-":"+", rawmpi, rawmpilen);
          xfree (rawmpi);
        }
    }
}


static int
count_closing_parens (const char *p)
{
  int count = 0;

  for (; *p; p++)
    if (*p == ')')
      count++;
    else if (!strchr ("\n \t", *p))
      return 0;

  return count;
}


/* Print SEXP in human readabale format.  With TEXT of NULL print just the raw
   dump without any wrappping, with TEXT an empty string, print a
   trailing linefeed, otherwise print the full debug output. */
void
_gcry_log_printsxp (const char *text, gcry_sexp_t sexp)
{
  int with_lf = 0;

  if (text && *text)
    {
      if ((with_lf = !!strchr (text, '\n')))
        log_debug ("%s", text);
      else
        log_debug ("%s: ", text);
    }
  if (sexp)
    {
      int any = 0;
      int n_closing;
      char *buf;
      const char *p, *pend;
      size_t size;

      size = sexp_sprint (sexp, GCRYSEXP_FMT_ADVANCED, NULL, 0);
      p = buf = xmalloc (size);
      sexp_sprint (sexp, GCRYSEXP_FMT_ADVANCED, buf, size);

      do
        {
          if (any && !with_lf)
            log_debug ("%*s  ", text?(int)strlen(text):0, "");
          else
            any = 1;
          pend = strchr (p, '\n');
          size = pend? (pend - p) : strlen (p);
          if (with_lf)
            log_debug ("%.*s", (int)size, p);
          else
            log_printf ("%.*s", (int)size, p);
          if (pend)
            p = pend + 1;
          else
            p += size;
          n_closing = count_closing_parens (p);
          if (n_closing)
            {
              while (n_closing--)
                log_printf (")");
              p = "";
            }
          log_printf ("\n");
        }
      while (*p);
      xfree (buf);
    }
  else if (text)
    log_printf ("\n");
}


/*
 * Tokenize STRING using the set of delimiters in DELIM.  Leading
 * white spaces are removed from all tokens.  The caller must xfree
 * the result.
 *
 * Returns: A malloced and NULL delimited array with the tokens.  On
 *          memory error NULL is returned and ERRNO is set.
 */
char **
_gcry_strtokenize (const char *string, const char *delim)
{
  const char *s;
  size_t fields;
  size_t bytes, n;
  char *buffer;
  char *p, *px, *pend;
  char **result;
  char const ws[] = " \t\v\f\r\n";

  if (!delim)
    delim = ws;

  /* Count the number of fields.  */
  for (fields = 1, s = strpbrk (string, delim); s; s = strpbrk (s + 1, delim))
    fields++;
  fields++; /* Add one for the terminating NULL.  */

  /* Allocate an array for all fields, a terminating NULL, and space
     for a copy of the string.  */
  bytes = fields * sizeof *result;
  if (bytes / sizeof *result != fields)
    {
      gpg_err_set_errno (ENOMEM);
      return NULL;
    }
  n = strlen (string) + 1;
  bytes += n;
  if (bytes < n)
    {
      gpg_err_set_errno (ENOMEM);
      return NULL;
    }
  result = xtrymalloc (bytes);
  if (!result)
    return NULL;
  buffer = (char*)(result + fields);

  /* Copy and parse the string.  */
  strcpy (buffer, string);
  for (n = 0, p = buffer; (pend = strpbrk (p, delim)); p = pend + 1)
    {
      *pend = 0;
      while (strchr (ws, *(byte*)p))
        p++;
      for (px = pend - 1; px >= p && strchr (ws, *(byte*)px); px--)
        *px = 0;
      result[n++] = p;
    }
  while (*p && strchr (ws, *(byte*)p))
    p++;
  for (px = p + strlen (p) - 1; px >= p && strchr (ws, *(byte*)px); px--)
    *px = 0;
  /* Traling spaces may result in an empty field.  We do not want to
     store that.  */
  result[n++] = *p? p : NULL;
  result[n] = NULL;

  gcry_assert ((char*)(result + n + 1) == buffer);

  return result;
}


void
_gcry_fast_wipememory (void *ptr, size_t len)
{
  /* Note: This function is called from wipememory/wipememory2 only if LEN
     is large or unknown at compile time. New wipe function alternatives
     need to be checked before adding to this function. New implementations
     need to be faster than wipememory/wipememory2 macros in 'g10lib.h'.

     Following implementations were found to have suboptimal performance:

     - [_WIN32/mingw32] SecureZeroMemory; Inline function, equivalent to
       volatile byte buffer set: while(buflen--) (volatile char *)(buf++)=set;
   */
#ifdef HAVE_EXPLICIT_BZERO
  explicit_bzero (ptr, len);
#elif defined(HAVE_EXPLICIT_MEMSET)
  explicit_memset (ptr, 0, len);
#else
  memset_ptr (ptr, 0, len);
#endif
}


void
_gcry_fast_wipememory2 (void *ptr, int set, size_t len)
{
#ifdef HAVE_EXPLICIT_MEMSET
  explicit_memset (ptr, set, len);
#else
#ifdef HAVE_EXPLICIT_BZERO
  if (set == 0)
    {
      explicit_bzero (ptr, len);
      return;
    }
#endif

  memset_ptr (ptr, set, len);
#endif
}


void NOINLINE_FUNC
__gcry_burn_stack (unsigned int bytes)
{
#ifdef HAVE_VLA
  /* (bytes == 0 ? 1 : bytes) == (!bytes + bytes) */
  unsigned int buflen = ((!bytes + bytes) + 63) & ~63;
  char buf[buflen];

  _gcry_fast_wipememory (buf, buflen);
#else
  volatile char buf[64];

  _gcry_fast_wipememory (buf, sizeof buf);

  if (bytes > sizeof buf)
      _gcry_burn_stack (bytes - sizeof buf);
#endif
}

#ifndef HAVE_GCC_ASM_VOLATILE_MEMORY
void
__gcry_burn_stack_dummy (void)
{
}
#endif

void
_gcry_divide_by_zero (void)
{
    gpg_err_set_errno (EDOM);
    _gcry_fatal_error (gpg_err_code_from_errno (errno), "divide by zero");
}
