/* estream.c - Extended Stream I/O Library

 * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010, 2011,

 *               2014, 2015, 2016, 2017 g10 Code GmbH

 *

 * This file is part of Libestream.

 *

 * Libestream 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.

 *

 * Libestream 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 Libestream; if not, see <https://www.gnu.org/licenses/>.

 *

 * ALTERNATIVELY, Libestream may be distributed under the terms of the

 * following license, in which case the provisions of this license are

 * required INSTEAD OF the GNU General Public License. If you wish to

 * allow use of your version of this file only under the terms of the

 * GNU General Public License, and not to allow others to use your

 * version of this file under the terms of the following license,

 * indicate your decision by deleting this paragraph and the license

 * below.

 *

 * 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, and the entire permission notice in its entirety,

 *    including the disclaimer of warranties.

 * 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.

 * 3. The name of the author may not be used to endorse or promote

 *    products derived from this software without specific prior

 *    written permission.

 *

 * THIS SOFTWARE IS PROVIDED "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 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.

 */

#ifdef USE_ESTREAM_SUPPORT_H

# include <estream-support.h>

#endif

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#if defined(_WIN32) && !defined(HAVE_W32_SYSTEM)

# define HAVE_W32_SYSTEM 1

# if defined(__MINGW32CE__) && !defined (HAVE_W32CE_SYSTEM)

#  define HAVE_W32CE_SYSTEM

# endif

#endif

#ifdef HAVE_SYS_SELECT_H

# include <sys/select.h>

#endif

#ifdef HAVE_SYS_TIME_H

# include <sys/time.h>

#endif

#include <sys/types.h>

#include <sys/file.h>

#include <sys/stat.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <stdarg.h>

#include <fcntl.h>

#include <errno.h>

#include <stddef.h>

#include <assert.h>

#ifdef HAVE_W32_SYSTEM

# ifdef HAVE_WINSOCK2_H

#  include <winsock2.h>

# endif

# include <windows.h>

#endif

/* Enable tracing.  The value is the module name to be printed.  */

/*#define ENABLE_TRACING "estream"*/

#include "gpgrt-int.h"

#include "estream-printf.h"

#include "thread.h"

#include "lock.h"

#ifndef O_BINARY

# define O_BINARY 0

#endif

#ifndef HAVE_DOSISH_SYSTEM

# ifdef HAVE_W32_SYSTEM

#  define HAVE_DOSISH_SYSTEM 1

# endif

#endif

#ifdef HAVE_W32_SYSTEM

# ifndef  S_IRGRP

#  define S_IRGRP S_IRUSR

# endif

# ifndef  S_IROTH

#  define S_IROTH S_IRUSR

# endif

# ifndef  S_IWGRP

#  define S_IWGRP S_IWUSR

# endif

# ifndef  S_IWOTH

#  define S_IWOTH S_IWUSR

# endif

# ifndef  S_IXGRP

#  define S_IXGRP S_IXUSR

# endif

# ifndef  S_IXOTH

#  define S_IXOTH S_IXUSR

# endif

#endif

#if !defined (EWOULDBLOCK) && defined (HAVE_W32_SYSTEM)

/* Compatibility with errno.h from mingw-2.0 */

# define EWOULDBLOCK 140

#endif

#ifndef EAGAIN

# define EAGAIN  EWOULDBLOCK

#endif

#ifdef HAVE_W32CE_SYSTEM

# define _set_errno(a)  gpg_err_set_errno ((a))

/* Setmode is missing in cegcc but available since CE 5.0.  */

int _setmode (int handle, int mode);

# define setmode(a,b)   _setmode ((a),(b))

#else

# define _set_errno(a)  do { errno = (a); } while (0)

#endif

#ifdef HAVE_W32_SYSTEM

# define IS_INVALID_FD(a)    ((void*)(a) == (void*)(-1)) /* ?? FIXME.  */

#else

# define IS_INVALID_FD(a)    ((a) == -1)

#endif

/* Calculate array dimension.  */

#ifndef DIM

#define DIM(array) (sizeof (array) / sizeof (*array))

#endif

/* A helper macro used to convert to a hex string.  */

#define tohex(n) ((n) < 10 ? ((n) + '0') : (((n) - 10) + 'A'))

/* Generally used types.  */

typedef void *(*func_realloc_t) (void *mem, size_t size);

typedef void (*func_free_t) (void *mem);

/*

 * A linked list to hold active stream objects.

 * Protected by ESTREAM_LIST_LOCK.

 */

struct estream_list_s

{

  struct estream_list_s *next;

  estream_t stream;  /* Entry is not used if NULL.  */

};

typedef struct estream_list_s *estream_list_t;

static estream_list_t estream_list;

/*

 * File descriptors registered for use as the standard file handles.

 * Protected by ESTREAM_LIST_LOCK.

 */

static int custom_std_fds[3];

static unsigned char custom_std_fds_valid[3];

/*

 * A lock object to protect ESTREAM LIST, CUSTOM_STD_FDS and

 * CUSTOM_STD_FDS_VALID.  Used by lock_list() and unlock_list().

 */

GPGRT_LOCK_DEFINE (estream_list_lock);

/*

 * Error code replacements.

 */

#ifndef EOPNOTSUPP

# define EOPNOTSUPP ENOSYS

#endif

/* Local prototypes.  */

static void fname_set_internal (estream_t stream, const char *fname, int quote);

/*

 * Memory allocation wrappers used in this file.

 */

static void *

mem_alloc (size_t n)

{

  return _gpgrt_malloc (n);

}

static void *

mem_realloc (void *p, size_t n)

{

  return _gpgrt_realloc (p, n);

}

static void

mem_free (void *p)

{

  if (p)

    _gpgrt_free (p);

}

/*

 * A Windows helper function to map a W32 API error code to a standard

 * system error code.

 */

#ifdef HAVE_W32_SYSTEM

static int

map_w32_to_errno (DWORD w32_err)

{

  switch (w32_err)

    {

    case 0:

      return 0;

    case ERROR_FILE_NOT_FOUND:

      return ENOENT;

    case ERROR_PATH_NOT_FOUND:

      return ENOENT;

    case ERROR_ACCESS_DENIED:

      return EPERM;

    case ERROR_INVALID_HANDLE:

    case ERROR_INVALID_BLOCK:

      return EINVAL;

    case ERROR_NOT_ENOUGH_MEMORY:

      return ENOMEM;

    case ERROR_NO_DATA:

      return EPIPE;

    default:

      return EIO;

    }

}

#endif /*HAVE_W32_SYSTEM*/

/*

 * Replacement for a missing memrchr.

 */

#ifndef HAVE_MEMRCHR

static void *

memrchr (const void *buffer, int c, size_t n)

{

  const unsigned char *p = buffer;

  for (p += n; n ; n--)

    if (*--p == c)

      return (void *)p;

  return NULL;

}

#endif /*HAVE_MEMRCHR*/

/*

 * Wrappers to lock a stream or the list of streams.

 */

#if 0

# define dbg_lock_0(f)        fprintf (stderr, "estream: " f);

# define dbg_lock_1(f, a)     fprintf (stderr, "estream: " f, (a));

# define dbg_lock_2(f, a, b)  fprintf (stderr, "estream: " f, (a), (b));

#else

# define dbg_lock_0(f)

# define dbg_lock_1(f, a)

# define dbg_lock_2(f, a, b)

#endif

static int

init_stream_lock (estream_t _GPGRT__RESTRICT stream)

{

  int rc;

  if (!stream->intern->samethread)

    {

      dbg_lock_1 ("enter init_stream_lock for %p\n", stream);

      memset (&stream->intern->lock, 0 , sizeof stream->intern->lock);

      rc = _gpgrt_lock_init (&stream->intern->lock);

      dbg_lock_2 ("leave init_stream_lock for %p: rc=%d\n", stream, rc);

    }

  else

    rc = 0;

  return rc;

}

static void

destroy_stream_lock (estream_t _GPGRT__RESTRICT stream)

{

  if (!stream->intern->samethread)

    {

      dbg_lock_1 ("enter destroy_stream_lock for %p\n", stream);

      _gpgrt_lock_destroy (&stream->intern->lock);

      dbg_lock_1 ("leave destroy_stream_lock for %p\n", stream);

    }

}

static void

lock_stream (estream_t _GPGRT__RESTRICT stream)

{

  if (!stream->intern->samethread)

    {

      dbg_lock_1 ("enter lock_stream for %p\n", stream);

      _gpgrt_lock_lock (&stream->intern->lock);

      dbg_lock_1 ("leave lock_stream for %p\n", stream);

    }

}

static int

trylock_stream (estream_t _GPGRT__RESTRICT stream)

{

  int rc;

  if (!stream->intern->samethread)

    {

      dbg_lock_1 ("enter trylock_stream for %p\n", stream);

      rc = _gpgrt_lock_trylock (&stream->intern->lock)? 0 : -1;

      dbg_lock_2 ("leave trylock_stream for %p: rc=%d\n", stream, rc);

    }

  else

    rc = 0;

  return rc;

}

static void

unlock_stream (estream_t _GPGRT__RESTRICT stream)

{

  if (!stream->intern->samethread)

    {

      dbg_lock_1 ("enter unlock_stream for %p\n", stream);

      _gpgrt_lock_unlock (&stream->intern->lock);

      dbg_lock_1 ("leave unlock_stream for %p\n", stream);

    }

}

static void

lock_list (void)

{

  dbg_lock_0 ("enter lock_list\n");

  _gpgrt_lock_lock (&estream_list_lock);

  dbg_lock_0 ("leave lock_list\n");

}

static void

unlock_list (void)

{

  dbg_lock_0 ("enter unlock_list\n");

  _gpgrt_lock_unlock (&estream_list_lock);

  dbg_lock_0 ("leave unlock_list\n");

}

#undef dbg_lock_0

#undef dbg_lock_1

#undef dbg_lock_2

/*

 * Manipulation of the list of stream.

 */

/*

 * Add STREAM to the list of registered stream objects.  If

 * WITH_LOCKED_LIST is true it is assumed that the list of streams is

 * already locked.  The implementation is straightforward: We first

 * look for an unused entry in the list and use that; if none is

 * available we put a new item at the head.  We drawback of the

 * strategy never to shorten the list is that a one time allocation of

 * many streams will lead to scanning unused entries later.  If that

 * turns out to be a problem, we may either free some items from the

 * list or append new entries at the end; or use a table.  Returns 0

 * on success; on error or non-zero is returned and ERRNO set.

 */

static int

do_list_add (estream_t stream, int with_locked_list)

{

  estream_list_t item;

  if (!with_locked_list)

    lock_list ();

  for (item = estream_list; item && item->stream; item = item->next)

    ;

  if (!item)

    {

      item = mem_alloc (sizeof *item);

      if (item)

        {

          item->next = estream_list;

          estream_list = item;

        }

    }

  if (item)

    item->stream = stream;

  if (!with_locked_list)

    unlock_list ();

  return item? 0 : -1;

}

/*

 * Remove STREAM from the list of registered stream objects.

 */

static void

do_list_remove (estream_t stream, int with_locked_list)

{

  estream_list_t item, item_prev = NULL;

  if (!with_locked_list)

    lock_list ();

  for (item = estream_list; item; item = item->next)

    if (item->stream == stream)

      break;

    else

      item_prev = item;

  if (item_prev)

    {

      item_prev->next = item->next;

      mem_free (item);

    }

  else

    {

      if (item)

        {

          estream_list = item->next;

          mem_free (item);

        }

    }

  if (!with_locked_list)

    unlock_list ();

}

/*

 * The atexit handler for the entire gpgrt.

 */

static void

do_deinit (void)

{

  /* Flush all streams. */

  _gpgrt_fflush (NULL);

  /* We should release the estream_list.  However there is one

     problem: That list is also used to search for the standard

     estream file descriptors.  If we would remove the entire list,

     any use of es_foo in another atexit function may re-create the

     list and the streams with possible undesirable effects.  Given

     that we don't close the stream either, it should not matter that

     we keep the list and let the OS clean it up at process end.  */

  /* Reset the syscall clamp.  */

  _gpgrt_set_syscall_clamp (NULL, NULL);

}

/*

 * Initialization of the estream module.

 */

int

_gpgrt_estream_init (void)

{

  static int initialized;

  if (!initialized)

    {

      initialized = 1;

      atexit (do_deinit);

    }

  return 0;

}

/*

 * Implementation of memory based I/O.

 */

/* Cookie for memory objects.  */

typedef struct estream_cookie_mem

{

  unsigned int modeflags;	/* Open flags.  */

  unsigned char *memory;	/* Allocated data buffer.  */

  size_t memory_size;		/* Allocated size of MEMORY.  */

  size_t memory_limit;          /* Caller supplied maximum allowed

                                   allocation size or 0 for no limit.  */

  size_t offset;		/* Current offset in MEMORY.  */

  size_t data_len;		/* Used length of data in MEMORY.  */

  size_t block_size;		/* Block size.  */

  struct {

    unsigned int grow: 1;	/* MEMORY is allowed to grow.  */

  } flags;

  func_realloc_t func_realloc;

  func_free_t func_free;

} *estream_cookie_mem_t;

/*

 * Create function for memory objects.  DATA is either NULL or a user

 * supplied buffer with the initial conetnt of the memory buffer.  If

 * DATA is NULL, DATA_N and DATA_LEN need to be 0 as well.  If DATA is

 * not NULL, DATA_N gives the allocated size of DATA and DATA_LEN the

 * used length in DATA.  If this function succeeds DATA is now owned

 * by this function.  If GROW is false FUNC_REALLOC is not

 * required.

 */

static int

func_mem_create (void *_GPGRT__RESTRICT *_GPGRT__RESTRICT cookie,

                 unsigned char *_GPGRT__RESTRICT data, size_t data_n,

                 size_t data_len,

                 size_t block_size, unsigned int grow,

                 func_realloc_t func_realloc, func_free_t func_free,

                 unsigned int modeflags,

                 size_t memory_limit)

{

  estream_cookie_mem_t mem_cookie;

  int err;

  if (!data && (data_n || data_len))

    {

      _set_errno (EINVAL);

      return -1;

    }

  if (grow && func_free && !func_realloc)

    {

      _set_errno (EINVAL);

      return -1;

    }

  /* Round a memory limit up to the next block length.  */

  if (memory_limit && block_size)

    {

      memory_limit += block_size - 1;

      memory_limit /= block_size;

      memory_limit *= block_size;

    }

  mem_cookie = mem_alloc (sizeof (*mem_cookie));

  if (!mem_cookie)

    err = -1;

  else

    {

      mem_cookie->modeflags = modeflags;

      mem_cookie->memory = data;

      mem_cookie->memory_size = data_n;

      mem_cookie->memory_limit = memory_limit;

      mem_cookie->offset = 0;

      mem_cookie->data_len = data_len;

      mem_cookie->block_size = block_size;

      mem_cookie->flags.grow = !!grow;

      mem_cookie->func_realloc

        = grow? (func_realloc ? func_realloc : mem_realloc) : NULL;

      mem_cookie->func_free = func_free ? func_free : mem_free;

      *cookie = mem_cookie;

      err = 0;

    }

  return err;

}

/*

 * Read function for memory objects.

 */

static gpgrt_ssize_t

func_mem_read (void *cookie, void *buffer, size_t size)

{

  estream_cookie_mem_t mem_cookie = cookie;

  gpgrt_ssize_t ret;

  if (!size)  /* Just the pending data check.  */

    return (mem_cookie->data_len - mem_cookie->offset)? 0 : -1;

  if (size > mem_cookie->data_len - mem_cookie->offset)

    size = mem_cookie->data_len - mem_cookie->offset;

  if (size)

    {

      memcpy (buffer, mem_cookie->memory + mem_cookie->offset, size);

      mem_cookie->offset += size;

    }

  ret = size;

  return ret;

}

/*

 * Write function for memory objects.

 */

static gpgrt_ssize_t

func_mem_write (void *cookie, const void *buffer, size_t size)

{

  estream_cookie_mem_t mem_cookie = cookie;

  gpgrt_ssize_t ret;

  size_t nleft;

  if (!size)

    return 0;  /* A flush is a NOP for memory objects.  */

  if (mem_cookie->modeflags & O_APPEND)

    {

      /* Append to data.  */

      mem_cookie->offset = mem_cookie->data_len;

    }

  assert (mem_cookie->memory_size >= mem_cookie->offset);

  nleft = mem_cookie->memory_size - mem_cookie->offset;

  /* If we are not allowed to grow the buffer, limit the size to the

     left space.  */

  if (!mem_cookie->flags.grow && size > nleft)

    size = nleft;

  /* Enlarge the memory buffer if needed.  */

  if (size > nleft)

    {

      unsigned char *newbuf;

      size_t newsize;

      if (!mem_cookie->memory_size)

        newsize = size;  /* Not yet allocated.  */

      else

        newsize = mem_cookie->memory_size + (size - nleft);

      if (newsize < mem_cookie->offset)

        {

          _set_errno (EINVAL);

          return -1;

        }

      /* Round up to the next block length.  BLOCK_SIZE should always

         be set; we check anyway.  */

      if (mem_cookie->block_size)

        {

          newsize += mem_cookie->block_size - 1;

          if (newsize < mem_cookie->offset)

            {

              _set_errno (EINVAL);

              return -1;

            }

          newsize /= mem_cookie->block_size;

          newsize *= mem_cookie->block_size;

        }

      /* Check for a total limit.  */

      if (mem_cookie->memory_limit && newsize > mem_cookie->memory_limit)

        {

          _set_errno (ENOSPC);

          return -1;

        }

      assert (mem_cookie->func_realloc);

      newbuf = mem_cookie->func_realloc (mem_cookie->memory, newsize);

      if (!newbuf)

        return -1;

      mem_cookie->memory = newbuf;

      mem_cookie->memory_size = newsize;

      assert (mem_cookie->memory_size >= mem_cookie->offset);

      nleft = mem_cookie->memory_size - mem_cookie->offset;

      assert (size <= nleft);

    }

  memcpy (mem_cookie->memory + mem_cookie->offset, buffer, size);

  if (mem_cookie->offset + size > mem_cookie->data_len)

    mem_cookie->data_len = mem_cookie->offset + size;

  mem_cookie->offset += size;

  ret = size;

  return ret;

}

/*

 * Seek function for memory objects.

 */

static int

func_mem_seek (void *cookie, gpgrt_off_t *offset, int whence)

{

  estream_cookie_mem_t mem_cookie = cookie;

  gpgrt_off_t pos_new;

  switch (whence)

    {

    case SEEK_SET:

      pos_new = *offset;

      break;

    case SEEK_CUR:

      pos_new = mem_cookie->offset += *offset;

      break;

    case SEEK_END:

      pos_new = mem_cookie->data_len += *offset;

      break;

    default:

      _set_errno (EINVAL);

      return -1;

    }

  if (pos_new > mem_cookie->memory_size)

    {

      size_t newsize;

      void *newbuf;

      if (!mem_cookie->flags.grow)

	{

	  _set_errno (ENOSPC);

	  return -1;

        }

      newsize = pos_new + mem_cookie->block_size - 1;

      if (newsize < pos_new)

        {

          _set_errno (EINVAL);

          return -1;

        }

      newsize /= mem_cookie->block_size;

      newsize *= mem_cookie->block_size;

      if (mem_cookie->memory_limit && newsize > mem_cookie->memory_limit)

        {

          _set_errno (ENOSPC);

          return -1;

        }

      assert (mem_cookie->func_realloc);

      newbuf = mem_cookie->func_realloc (mem_cookie->memory, newsize);

      if (!newbuf)

        return -1;

      mem_cookie->memory = newbuf;

      mem_cookie->memory_size = newsize;

    }

  if (pos_new > mem_cookie->data_len)

    {

      /* Fill spare space with zeroes.  */

      memset (mem_cookie->memory + mem_cookie->data_len,

              0, pos_new - mem_cookie->data_len);

      mem_cookie->data_len = pos_new;

    }

  mem_cookie->offset = pos_new;

  *offset = pos_new;

  return 0;

}

/*

 * The IOCTL function for memory objects.

 */

static int

func_mem_ioctl (void *cookie, int cmd, void *ptr, size_t *len)

{

  estream_cookie_mem_t mem_cookie = cookie;

  int ret;

  if (cmd == COOKIE_IOCTL_SNATCH_BUFFER)

    {

      /* Return the internal buffer of the stream to the caller and

         invalidate it for the stream.  */

      *(void**)ptr = mem_cookie->memory;

      *len = mem_cookie->data_len;

      mem_cookie->memory = NULL;

      mem_cookie->memory_size = 0;

      mem_cookie->offset = 0;

      ret = 0;

    }

  else

    {

      _set_errno (EINVAL);

      ret = -1;

    }

  return ret;

}

/*

 * The destroy function for memory objects.

 */

static int

func_mem_destroy (void *cookie)

{

  estream_cookie_mem_t mem_cookie = cookie;

  if (cookie)

    {

      mem_cookie->func_free (mem_cookie->memory);

      mem_free (mem_cookie);

    }

  return 0;

}

/*

 * Access object for the memory functions.

 */

static struct cookie_io_functions_s estream_functions_mem =

  {

    {

      func_mem_read,

      func_mem_write,

      func_mem_seek,

      func_mem_destroy,

    },

    func_mem_ioctl,

  };

/*

 * Implementation of file descriptor based I/O.

 */

/* Cookie for fd objects.  */

typedef struct estream_cookie_fd

{

  int fd;        /* The file descriptor we are using for actual output.  */

  int no_close;  /* If set we won't close the file descriptor.  */

  int nonblock;  /* Non-blocking mode is enabled.  */

} *estream_cookie_fd_t;

/*

 * Create function for objects indentified by a libc file descriptor.

 */