path: root/csvncgi/wrapper.c

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdlib.h>
#include <stdio.h>
#include <sys/sysinfo.h>
#include <sys/types.h>
#include <stdint.h>
#include <dirent.h>
#include <sys/stat.h> /* chmod(2)    */
#include <sys/file.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <limits.h>
#include <string.h>   /* strdup(3)   */
#include <libgen.h>   /* basename(3) */
#include <ctype.h>    /* tolower(3)  */
#include <errno.h>
#include <time.h>
#include <sys/time.h>
#include <pwd.h>
#include <grp.h>
#include <stdarg.h>
#include <poll.h>
#include <unistd.h>

#include <defs.h>
#include <wrapper.h>


#define WRAPPER_ERRMSG_SIZE 4096

void wrapper_error( const char *fmt, ... )
{
  va_list arg_ptr;
  char  buf[WRAPPER_ERRMSG_SIZE];
  char  msg[WRAPPER_ERRMSG_SIZE];
  char *format = "%s: %s\n";

  va_start( arg_ptr, fmt );

  vsnprintf( msg, WRAPPER_ERRMSG_SIZE, (const void *)fmt, arg_ptr );

  va_end( arg_ptr ); /* Reset variable arguments. */

  snprintf( buf, WRAPPER_ERRMSG_SIZE, format, "wrapper", msg );

  (void)write( STDERR_FILENO, buf, strlen( buf ) );

  exit( 1 );
}

wrapper_errfunc wrapper_fatal = wrapper_error;


char *xstrdup( const char *str )
{
  char *ret;

  ret = strdup( str );
  if( !ret )
    wrapper_fatal( "Out of memory, strdup failed" );
  return ret;
}

void *xmalloc( size_t size )
{
  void *ret;

  ret = malloc( size );
  if( !ret )
  {
    wrapper_fatal( "Out of memory, malloc failed (tried to allocate %lu bytes)", (unsigned long)size );
    return NULL;
  }
  memset( ret, 0, size );
  return ret;
}

void *xrealloc( void *ptr, size_t size )
{
  void *ret = NULL;

  ret = realloc( ptr, size );
  if( !ret && !size )
    ret = realloc( ptr, 1 );
  if( !ret )
    wrapper_fatal( "Out of memory, realloc failed" );
  return ret;
}

/************************************************************************
  Limit size of IO chunks, because huge chunks only cause pain.
  OS X 64-bit is buggy, returning EINVAL if len >= INT_MAX; and even in
  the absence of bugs, large chunks can result in bad latencies when
  you decide to kill the process.

  We pick 8 MiB as our default, but if the platform defines SSIZE_MAX
  that is smaller than that, clip it to SSIZE_MAX, as a call to read(2)
  or write(2) larger than that is allowed to fail. As the last resort,
  we allow a port to pass via CFLAGS e.g. "-DMAX_IO_SIZE=value" to
  override this, if the definition of SSIZE_MAX given by the platform
  is broken.
 ************************************************************************/
#ifndef MAX_IO_SIZE
# define MAX_IO_SIZE_DEFAULT (8*1024*1024)
# if defined(SSIZE_MAX) && (SSIZE_MAX < MAX_IO_SIZE_DEFAULT)
#  define MAX_IO_SIZE SSIZE_MAX
# else
#  define MAX_IO_SIZE MAX_IO_SIZE_DEFAULT
# endif
#endif

/*
  xopen() is the same as open(), but it die()s if the open() fails.
 */
int xopen( const char *path, int oflag, ... )
{
  mode_t mode = 0;
  va_list ap;

  /*
    va_arg() will have undefined behavior if the specified type is not
    compatible with the argument type. Since integers are promoted to
    ints, we fetch the next argument as an int, and then cast it to a
    mode_t to avoid undefined behavior.
   */
  va_start( ap, oflag );
  if( oflag & O_CREAT )
    mode = va_arg( ap, int );
  va_end( ap );

  for( ;; )
  {
    int fd = open( path, oflag, mode );
    if( fd >= 0 )
      return fd;
    if( errno == EINTR )
      continue;

    if( (oflag & O_RDWR) == O_RDWR )
      wrapper_fatal( "could not open '%s' for reading and writing", path );
    else if( (oflag & O_WRONLY) == O_WRONLY )
      wrapper_fatal( "could not open '%s' for writing", path );
    else
      wrapper_fatal( "could not open '%s' for reading", path );
  }
}

static int handle_nonblock( int fd, short poll_events, int err )
{
  struct pollfd pfd;

  if( err != EAGAIN && err != EWOULDBLOCK )
    return 0;

  pfd.fd = fd;
  pfd.events = poll_events;

  /*
    no need to check for errors, here;
    a subsequent read/write will detect unrecoverable errors
   */
  poll( &pfd, 1, -1 );
  return 1;
}

/*
  xread() is the same a read(), but it automatically restarts read()
  operations with a recoverable error (EAGAIN and EINTR). xread()
  DOES NOT GUARANTEE that "len" bytes is read even if the data is available.
 */
ssize_t xread(int fd, void *buf, size_t len)
{
  ssize_t nr;

  if( len > MAX_IO_SIZE )
    len = MAX_IO_SIZE;

  while( 1 )
  {
    nr = read( fd, buf, len );
    if( nr < 0 )
    {
      if( errno == EINTR )
        continue;
      if( handle_nonblock(fd, POLLIN, errno) )
        continue;
    }
    return nr;
  }
}

/*
  xwrite() is the same a write(), but it automatically restarts write()
  operations with a recoverable error (EAGAIN and EINTR). xwrite() DOES NOT
  GUARANTEE that "len" bytes is written even if the operation is successful.
 */
ssize_t xwrite( int fd, const void *buf, size_t len )
{
  ssize_t nr;

  if( len > MAX_IO_SIZE )
    len = MAX_IO_SIZE;

  while( 1 )
  {
    nr = write( fd, buf, len );
    if( nr < 0 )
    {
      if( errno == EINTR )
        continue;
      if( handle_nonblock(fd, POLLOUT, errno) )
        continue;
    }
    return nr;
  }
}

ssize_t read_in_full( int fd, void *buf, size_t count )
{
  char *p = buf;
  ssize_t total = 0;

  while( count > 0 )
  {
    ssize_t loaded = xread( fd, p, count );

    if (loaded < 0)
      return -1;

    if (loaded == 0)
      return total;

    count -= loaded;
        p += loaded;
    total += loaded;
  }

  return total;
}

ssize_t write_in_full( int fd, const void *buf, size_t count )
{
  const char *p = buf;
  ssize_t total = 0;

  while( count > 0 )
  {
    ssize_t written = xwrite( fd, p, count );
    if( written < 0 )
       return -1;

    if( !written )
    {
      errno = ENOSPC;
      return -1;
    }
    count -= written;
        p += written;
    total += written;
  }

  return total;
}

int xdup( int fd )
{
  int ret = dup( fd );
  if( ret < 0 )
    wrapper_fatal( "dup failed" );
  return ret;
}

/*
  xfopen() is the same as fopen(), but it die()s if the fopen() fails.
 */
FILE *xfopen( const char *path, const char *mode )
{
  for( ;;  )
  {
    FILE *fp = fopen( path, mode );
    if (fp)
      return fp;
    if (errno == EINTR)
      continue;

    if( *mode && mode[1] == '+' )
      wrapper_fatal( "could not open '%s' for reading and writing", path );
    else if( *mode == 'w' || *mode == 'a' )
      wrapper_fatal( "could not open '%s' for writing", path );
    else
      wrapper_fatal( "could not open '%s' for reading", path );
  }
}

FILE *xfdopen( int fd, const char *mode )
{
  FILE *stream = fdopen( fd, mode );
  if( stream == NULL )
    wrapper_fatal( "Out of memory? fdopen failed" );
  return stream;
}