/* ABI compatibility for obsolete sigvec function from 4.2BSD.

   Copyright (C) 1991-2018 Free Software Foundation, Inc.

   This file is part of the GNU C Library.

   The GNU C Library 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.

   The GNU C Library 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 the GNU C Library; if not, see

   <http://www.gnu.org/licenses/>.  */

#include <shlib-compat.h>

#if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_21)

# include <signal.h>

# include <errno.h>

# include <stddef.h>

/* These are the struct sigvec and SV_* bit definitions that

   used to be in <signal.h>.  The whole interface now exists

   solely for ABI compatibility, so it can just be here.  */

struct sigvec

  {

    __sighandler_t sv_handler;	/* Signal handler.  */

    int sv_mask;		/* Mask of signals to be blocked.  */

    int sv_flags;		/* Flags (see below).  */

  };

# define SV_ONSTACK	(1 << 0)/* Take the signal on the signal stack.  */

# define SV_INTERRUPT	(1 << 1)/* Do not restart system calls.  */

# define SV_RESETHAND	(1 << 2)/* Reset handler to SIG_DFL on receipt.  */

/* Include macros to convert between `sigset_t' and old-style mask. */

# include <sigset-cvt-mask.h>

# ifndef SA_RESETHAND

/* When sigaction lacks the extension bit for it,

   we use a wrapper handler to support SV_RESETHAND.  */

struct sigvec_wrapper_data

{

  __sighandler_t sw_handler;

  unsigned int sw_mask;

};

static void sigvec_wrapper_handler (int sig) __THROW;

static struct sigvec_wrapper_data sigvec_wrapper_data[NSIG];

# endif

/* If VEC is non-NULL, set the handler for SIG to the `sv_handler' member

   of VEC.  The signals in `sv_mask' will be blocked while the handler runs.

   If the SV_RESETHAND bit is set in `sv_flags', the handler for SIG will be

   reset to SIG_DFL before `sv_handler' is entered.  If OVEC is non-NULL,

   it is filled in with the old information for SIG.  */

int

__sigvec (int sig,

          const struct sigvec *vec,

          struct sigvec *ovec)

{

  struct sigaction old;

# ifndef SA_RESETHAND

  if (vec == NULL || !(vec->sv_flags & SV_RESETHAND))

# endif

    {

      struct sigaction new, *n;

      if (vec == NULL)

	n = NULL;

      else

	{

	  __sighandler_t handler;

	  unsigned int mask;

	  unsigned int sv_flags;

	  unsigned int sa_flags;

	  handler = vec->sv_handler;

	  mask = vec->sv_mask;

	  sv_flags = vec->sv_flags;

	  sa_flags = 0;

	  if (sv_flags & SV_ONSTACK)

	    {

# ifdef SA_ONSTACK

	      sa_flags |= SA_ONSTACK;

# else

	      __set_errno (ENOSYS);

	      return -1;

# endif

	    }

# ifdef SA_RESTART

	  if (!(sv_flags & SV_INTERRUPT))

	    sa_flags |= SA_RESTART;

# endif

# ifdef SA_RESETHAND

	  if (sv_flags & SV_RESETHAND)

	    sa_flags |= SA_RESETHAND;

# endif

	  n = &new;

	  new.sa_handler = handler;

	  if (sigset_set_old_mask (&new.sa_mask, mask) < 0)

	    return -1;

	  new.sa_flags = sa_flags;

	}

      if (__sigaction (sig, n, &old) < 0)

	return -1;

    }

# ifndef SA_RESETHAND

  else

    {

      __sighandler_t handler;

      unsigned int mask;

      struct sigvec_wrapper_data *data;

      struct sigaction wrapper;

      handler = vec->sv_handler;

      mask = (unsigned int)vec->sv_mask;

      data = &sigvec_wrapper_data[sig];

      wrapper.sa_handler = sigvec_wrapper_handler;

      /* FIXME: should we set wrapper.sa_mask, wrapper.sa_flags??  */

      data->sw_handler = handler;

      data->sw_mask = mask;

      if (__sigaction (sig, &wrapper, &old) < 0)

	return -1;

    }

# endif

  if (ovec != NULL)

    {

      __sighandler_t handler;

      unsigned int sv_flags;

      unsigned int sa_flags;

      unsigned int mask;

      handler = old.sa_handler;

      sv_flags = 0;

      sa_flags = old.sa_flags;

# ifndef SA_RESETHAND

      if (handler == sigvec_wrapper_handler)

	{

	  handler = sigvec_wrapper_data[sig].sw_handler;

	  /* should we use data->sw_mask?? */

	  sv_flags |= SV_RESETHAND;

	}

# else

     if (sa_flags & SA_RESETHAND)

	sv_flags |= SV_RESETHAND;

# endif

      mask = sigset_get_old_mask (&old.sa_mask);

# ifdef SA_ONSTACK

     if (sa_flags & SA_ONSTACK)

	sv_flags |= SV_ONSTACK;

# endif

# ifdef SA_RESTART

     if (!(sa_flags & SA_RESTART))

# endif

	sv_flags |= SV_INTERRUPT;

      ovec->sv_handler = handler;

      ovec->sv_mask = (int)mask;

      ovec->sv_flags = (int)sv_flags;

    }

  return 0;

}

compat_symbol (libc, __sigvec, sigvec, GLIBC_2_0);

# ifndef SA_RESETHAND

static void

sigvec_wrapper_handler (int sig)

{

  struct sigvec_wrapper_data *data;

  struct sigaction act;

  int save;

  __sighandler_t handler;

  data = &sigvec_wrapper_data[sig];

  act.sa_handler = SIG_DFL;

  act.sa_flags = 0;

  sigset_set_old_mask (&act.sa_mask, data->sw_mask);

  handler = data->sw_handler;

  save = errno;

  (void) __sigaction (sig, &act, (struct sigaction *) NULL);

  __set_errno (save);

  (*handler) (sig);

}

# endif  /* No SA_RESETHAND.  */

#endif  /* SHLIB_COMPAT */