No OneTemporary
Actions

Size

22 KB

Subscribers

None

View Options

	diff --git a/configure.ac b/configure.ac
	index 7e138f1..f927978 100644
	--- a/configure.ac
	+++ b/configure.ac
	@@ -1,334 +1,334 @@
	# configure.ac -- Autoconf --
	# Copyright (C) 2011, 2012 g10 Code GmbH
	# This file is part of NPTH.
	#
	# NPTH is free software; you can redistribute it and/or modify it
	# under the terms of either
	#
	# - the GNU Lesser General Public License as published by the Free
	# Software Foundation; either version 3 of the License, or (at
	# your option) any later version.
	#
	# or
	#
	# - the GNU General Public License as published by the Free
	# Software Foundation; either version 2 of the License, or (at
	# your option) any later version.
	#
	# or both in parallel, as here.
	#
	# NPTH 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/>.

	# Process this file with autoconf to produce a configure script.

	AC_PREREQ([2.67])
	min_automake_version="1.11"

	# To build a release you need to create a tag with the version number
	# (git tag -s npth-n.m) and run "./autogen.sh --force". Please bump
	# the version number immediately after the release and do another
	# commit and push so that the git magic is able to work.
	# See below for the LT versions.
	m4_define(my_version, [0.91])

	# Below is m4 magic to extract and compute the git revision number,
	# the decimalized short revision number, a beta version string and a
	# flag indicating a development version (my_isgit). The latter works
	# by requiring the final tag in the repository.
	m4_define([git_revision], m4_esyscmd([git branch -v 2>/dev/null \
	\| awk '/^\* / {printf "%s",$3}']))
	m4_define([git_revision_dec],
	m4_esyscmd_s([echo $((0x$(echo ]git_revision[\|head -c 4)))]))
	m4_define([git_betastring],
	m4_esyscmd_s([git describe --match 'npth-[0-9].*[0-9]' --long\|\
	awk -F- '$3!=0{print"-beta"$3}']))
	m4_define([my_isgit],m4_if(git_betastring,[],[no],[yes]))
	m4_define([my_full_version],[my_version[]git_betastring])

	AC_INIT([npth],[my_full_version],[gnupg-devel@gnupg.org])

	# LT Version numbers, remember to change them just before a release.
	# (Code changed: REVISION++)
	# (Interfaces added/removed/changed: CURRENT++, REVISION=0)
	# (Interfaces added: AGE++)
	# (Interfaces removed/changed: AGE=0)
	#
	LIBNPTH_LT_CURRENT=0
	LIBNPTH_LT_AGE=0
	LIBNPTH_LT_REVISION=1

	# If the API is changed in an incompatible way: increment the next counter.
	NPTH_CONFIG_API_VERSION=1
	##############################################

	PACKAGE=$PACKAGE_NAME
	VERSION=$PACKAGE_VERSION

	AC_CONFIG_SRCDIR([src/npth.c])
	AC_CONFIG_HEADERS([config.h])
	AC_CONFIG_MACRO_DIR([m4])
	AM_INIT_AUTOMAKE($PACKAGE, $VERSION)
	AM_MAINTAINER_MODE
	AC_CANONICAL_HOST

	# Enable GNU extensions on systems that have them.
	AC_GNU_SOURCE

	AH_VERBATIM([_REENTRANT],
	[#ifndef _REENTRANT
	# define _REENTRANT 1
	#endif])

	# Checks for programs.
	AC_PROG_CC

	AC_SUBST(LIBNPTH_LT_CURRENT)
	AC_SUBST(LIBNPTH_LT_AGE)
	AC_SUBST(LIBNPTH_LT_REVISION)

	AC_SUBST(PACKAGE)
	AC_SUBST(VERSION)
	AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of this package])
	AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version of this package])

	run_tests="yes"
	AC_ARG_ENABLE(tests,
	AC_HELP_STRING([--disable-tests], [disable tests]),
	run_tests=$enableval)
	AM_CONDITIONAL(RUN_TESTS, test "$run_tests" = "yes")


	# Don't default to build static libs.
	LT_PREREQ([2.2.6])
	LT_INIT([win32-dll disable-static])
	LT_LANG([Windows Resource])


	# For now we hardcode the use of version scripts. It would be better
	# to write a test for this or even implement this within libtool.
	have_ld_version_script=no
	case "${host}" in
	--linux*)
	have_ld_version_script=yes
	;;
	--gnu*)
	have_ld_version_script=yes
	;;
	-apple-darwin)
	AC_DEFINE(_XOPEN_SOURCE, 500, Activate POSIX interface on MacOS X)
	;;
	esac

	AM_CONDITIONAL(HAVE_LD_VERSION_SCRIPT, test "$have_ld_version_script" = "yes")

	# Set some default values
	config_libs="-lnpth"
	have_w32_system=no
	have_w32ce_system=no
	have_w64_system=no

	# Define OS macros
	case "${host}" in
	x86_64-mingw32)
	have_w64_system=yes
	;;
	-mingw32ce)
	have_w32ce_system=yes
	;;
	esac
	case "${host}" in
	-mingw32ce\|-mingw32)
	have_w32_system=yes
	;;
	*)
	;;
	esac

	if test "$have_w32_system" = yes; then
	AC_DEFINE(HAVE_W32_SYSTEM,1,
	[Defined if we run on any kind of W32 API based system])
	fi
	AM_CONDITIONAL(HAVE_W32_SYSTEM, test "$have_w32_system" = yes)

	if test "$have_w64_system" = yes; then
	AC_DEFINE(HAVE_W64_SYSTEM,1,
	[Defined if we run on a 64 bit W32 API based system])
	fi
	AM_CONDITIONAL(HAVE_W64_SYSTEM, test "$have_w64_system" = yes)

	#
	# Generate values for the DLL version info
	#
	if test "$have_w32_system" = yes; then
	BUILD_TIMESTAMP=`date --iso-8601=minutes`
	BUILD_ISODATE=`date --iso-8601`
	changequote(,)dnl
	BUILD_FILEVERSION=`echo "$VERSION" \| sed 's/$[0-9.]$./\1./;s/\./,/g'`
	changequote([,])dnl
	BUILD_FILEVERSION="${BUILD_FILEVERSION}git_revision_dec"
	fi
	AC_SUBST(BUILD_TIMESTAMP)
	AC_SUBST(BUILD_ISODATE)
	AC_SUBST(BUILD_FILEVERSION)


	#
	# Checks for header files.
	#
	# fixme: For what do we need the sys/socket test?
	AC_CHECK_HEADERS([sys/socket.h sys/select.h unistd.h sys/time.h time.h \
	signal.h])
	INSERT_SYS_SELECT_H=
	if test x"$ac_cv_header_sys_select_h" = xyes; then
	INSERT_SYS_SELECT_H="include <sys/select.h>"
	fi
	AC_SUBST(INSERT_SYS_SELECT_H)

	if test x"$ac_cv_header_sys_time_h" = xyes; then
	INSERT_SYS_TIME_H="include <sys/time.h>"
	fi
	AC_SUBST(INSERT_SYS_TIME_H)

	if test x"$ac_cv_header_time_h" = xyes; then
	INSERT_TIME_H="include <time.h>"
	fi
	AC_SUBST(INSERT_TIME_H)

	if test x"$ac_cv_header_signal_h" = xyes; then
	INSERT_SIGNAL_H="include <signal.h>"
	fi
	AC_SUBST(INSERT_SIGNAL_H)


	# Some systems lack socklen_t - provide a replacement.
	gl_TYPE_SOCKLEN_T
	case "${host}" in
	--mingw32*)
	# socklen_t may or may not be defined depending on what headers
	# are included. To be safe we use int as this is the actual type.
	INSERT_SOCKLEN_T="define _npth_socklen_t int"
	;;
	*)
	if test ".$gl_cv_socklen_t_equiv" = "."; then
	INSERT_SOCKLEN_T="define _npth_socklen_t socklen_t"
	else
	INSERT_SOCKLEN_T="define _npth_socklen_t ${gl_cv_socklen_t_equiv}"
	fi
	esac
	AC_SUBST(INSERT_SOCKLEN_T)


	#
	# Checks for typedefs, structures, and compiler characteristics.
	#
	AC_TYPE_PID_T
	AC_TYPE_SIZE_T
	AC_TYPE_SSIZE_T


	#
	# Checks for libraries and functions.
	#
	if test "$have_w32_system" = no; then
	AC_SEARCH_LIBS([pthread_create],[pthread])
	case "x$ac_cv_search_pthread_create" in
	xno)
	have_pthread=no
	;;
	xnone\ required)
	have_pthread=yes
	;;
	*)
	have_pthread=yes
	config_libs="$config_libs $ac_cv_search_pthread_create"
	;;
	esac
	if test "$have_pthread" != no; then
	AC_DEFINE(HAVE_PTHREAD,1,[Define if we have pthread.])
	AC_CHECK_FUNCS([pthread_tryjoin_np pthread_setname_np pthread_getname_np])
	AC_CHECK_FUNCS([pthread_mutex_timedlock])
	AC_CHECK_FUNCS([pthread_rwlock_rdlock pthread_rwlock_wrlock])
	AC_CHECK_FUNCS([pthread_rwlock_timedrdlock pthread_rwlock_timedwrlock])
	AC_CHECK_FUNCS([pthread_rwlock_tryrdlock pthread_rwlock_trywrlock])
	fi
	fi

	-AC_CHECK_FUNCS([select pselect])
	+AC_CHECK_FUNCS([select pselect gettimeofday])

	npth_LIBSOCKET
	config_libs="$config_libs $LIBSOCKET"

	AC_SEARCH_LIBS([clock_gettime],[rt posix4])
	if test "x$ac_cv_search_clock_gettime" != no; then
	AC_DEFINE(HAVE_CLOCK_GETTIME,1,
	[Define to 1 if you have the `clock_gettime' function.])
	fi


	#
	# Substitutions to set generated files in a Emacs buffer to read-only.
	#
	AC_SUBST(emacs_local_vars_begin, ['Local Variables:'])
	AC_SUBST(emacs_local_vars_read_only, ['buffer-read-only: t'])
	AC_SUBST(emacs_local_vars_end, ['End:'])


	#
	# Substitution used for npth-config
	#
	NPTH_CONFIG_LIBS="$config_libs"
	NPTH_CONFIG_CFLAGS=""
	NPTH_CONFIG_HOST="$host"
	AC_SUBST(NPTH_CONFIG_API_VERSION)
	AC_SUBST(NPTH_CONFIG_LIBS)
	AC_SUBST(NPTH_CONFIG_CFLAGS)
	AC_SUBST(NPTH_CONFIG_HOST)

	#
	# Last check.
	#
	die=no
	if test "$have_w32_system" = no; then
	if test "$have_pthread" = "no"; then
	die=yes
	AC_MSG_NOTICE([[
	***
	*** You need Pthread to build this program.
	*** Normally, this library comes with your system. On Windows, you can use:
	*** http://sourceware.org/pthreads-win32/
	***]])
	fi
	fi

	if test "$die" = "yes"; then
	AC_MSG_ERROR([[
	***
	*** Required libraries not found. Please consult the above messages
	*** and install them before running configure again.
	***]])
	fi

	#
	# Write output
	#
	AC_CONFIG_FILES([Makefile
	src/npth.h
	src/Makefile
	w32/Makefile
	tests/Makefile])
	AC_CONFIG_FILES(src/npth-config, chmod +x src/npth-config)
	AC_CONFIG_FILES(w32/npth-config, chmod +x w32/npth-config)
	AC_OUTPUT

	echo "
	$PACKAGE_NAME-$PACKAGE_VERSION prepared for make

	Revision: git_revision (git_revision_dec)
	Platform: $host
	"
	diff --git a/src/npth.c b/src/npth.c
	index c998732..56cf455 100644
	--- a/src/npth.c
	+++ b/src/npth.c
	@@ -1,649 +1,659 @@
	/* npth.c - a lightweight implementation of pth over pthread.
	Copyright (C) 2011 g10 Code GmbH

	This file is part of NPTH.

	NPTH is free software; you can redistribute it and/or modify it
	under the terms of either

	- the GNU Lesser General Public License as published by the Free
	Software Foundation; either version 3 of the License, or (at
	your option) any later version.

	or

	- the GNU General Public License as published by the Free
	Software Foundation; either version 2 of the License, or (at
	your option) any later version.

	or both in parallel, as here.

	NPTH 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 copies of the GNU General Public License
	and the GNU Lesser General Public License along with this program;
	if not, see <http://www.gnu.org/licenses/>. */

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

	#include <stdlib.h>
	#include <assert.h>
	#include <errno.h>
	#include <pthread.h>
	#include <semaphore.h>
	#ifdef HAVE_UNISTD_H
	# include <unistd.h>
	#endif
	#ifndef HAVE_PSELECT
	# include <signal.h>
	#endif

	#include "npth.h"


	/* The global lock that excludes all threads but one. This is a
	semaphore, because these can be safely used in a library even if
	the application or other libraries call fork(), including from a
	signal handler. sem_post is async-signal-safe. (The reason a
	semaphore is safe and a mutex is not safe is that a mutex has an
	owner, while a semaphore does not.) */
	static sem_t sceptre;

	/* The main thread is the active thread at the time pth_init was
	called. As of now it is only useful for debugging. The volatile
	make sure the compiler does not eliminate this set but not used
	variable. */
	static volatile pthread_t main_thread;

	/* Systems that don't have pthread_mutex_timedlock get a busy wait
	implementation that probes the lock every BUSY_WAIT_INTERVAL
	milliseconds. */
	#define BUSY_WAIT_INTERVAL 200

	typedef int (trylock_func_t) (void );

	static int
	busy_wait_for (trylock_func_t trylock, void *lock,
	const struct timespec *abstime)
	{
	int err;

	/* This is not great, but better than nothing. Only works for locks
	which are mostly uncontested. Provides absolutely no fairness at
	all. Creates many wake-ups. */
	while (1)
	{
	struct timespec ts;
	err = npth_clock_gettime (&ts);
	if (err < 0)
	{
	/* Just for safety make sure we return some error. */
	err = errno ? errno : EINVAL;
	break;
	}

	if (! npth_timercmp (abstime, &ts, <))
	{
	err = ETIMEDOUT;
	break;
	}

	err = (*trylock) (lock);
	if (err != EBUSY)
	break;

	/* Try again after waiting a bit. We could calculate the
	maximum wait time from ts and abstime, but we don't
	bother, as our granularity is pretty fine. */
	usleep (BUSY_WAIT_INTERVAL * 1000);
	}

	return err;
	}


	static void
	enter_npth (void)
	{
	int res;

	res = sem_post (&sceptre);
	assert (res == 0);
	}


	static void
	leave_npth (void)
	{
	int res;

	do {
	res = sem_wait (&sceptre);
	} while (res < 0 && errno == EINTR);

	assert (!res);
	}

	#define ENTER() enter_npth ()
	#define LEAVE() leave_npth ()


	int
	npth_init (void)
	{
	int res;

	main_thread = pthread_self();

	/* The semaphore is not shared and binary. */
	res = sem_init(&sceptre, 0, 1);
	if (res < 0)
	{
	/* POSIX.1-2001 defines the semaphore interface but does not
	specify the return value for success. Thus we better bail
	out on error only on a POSIX.1-2008 system. */
	#if _POSIX_C_SOURCE >= 200809L
	return errno;
	#endif
	}

	LEAVE();
	return 0;
	}


	int
	npth_getname_np (npth_t target_thread, char *buf, size_t buflen)
	{
	#ifdef HAVE_PTHREAD_GETNAME_NP
	return pthread_getname_np (target_thread, buf, buflen);
	#else
	(void)target_thread;
	(void)buf;
	(void)buflen;
	return ENOSYS;
	#endif
	}


	int
	npth_setname_np (npth_t target_thread, const char *name)
	{
	#ifdef HAVE_PTHREAD_SETNAME_NP
	return pthread_setname_np (target_thread, name);
	#else
	(void)target_thread;
	(void)name;
	return ENOSYS;
	#endif
	}



	struct startup_s
	{
	void (start_routine) (void *);
	void *arg;
	};


	static void *
	thread_start (void *startup_arg)
	{
	struct startup_s *startup = startup_arg;
	void (start_routine) (void *);
	void *arg;
	void *result;

	start_routine = startup->start_routine;
	arg = startup->arg;
	free (startup);

	LEAVE();
	result = (*start_routine) (arg);
	/* Note: instead of returning here, we might end up in
	npth_exit() instead. */
	ENTER();

	return result;
	}


	int
	npth_create (npth_t thread, const npth_attr_t attr,
	void (start_routine) (void ), void arg)
	{
	int err;
	struct startup_s *startup;

	startup = malloc (sizeof (*startup));
	if (!startup)
	return errno;

	startup->start_routine = start_routine;
	startup->arg = arg;
	err = pthread_create (thread, attr, thread_start, startup);
	if (err)
	{
	free (startup);
	return err;
	}

	/* Memory is released in thread_start. */
	return 0;
	}


	int
	npth_join (npth_t thread, void **retval)
	{
	int err;

	#ifdef HAVE_PTHREAD_TRYJOIN_NP
	/* No need to allow competing threads to enter when we can get the
	lock immediately. pthread_tryjoin_np is a GNU extension. */
	err = pthread_tryjoin_np (thread, retval);
	if (err != EBUSY)
	return err;
	#endif /HAVE_PTHREAD_TRYJOIN_NP/

	ENTER();
	err = pthread_join (thread, retval);
	LEAVE();
	return err;
	}


	void
	npth_exit (void *retval)
	{
	ENTER();
	pthread_exit (retval);
	/* Never reached. But just in case pthread_exit does return... */
	LEAVE();
	}


	int
	npth_mutex_lock (npth_mutex_t *mutex)
	{
	int err;

	/* No need to allow competing threads to enter when we can get the
	lock immediately. */
	err = pthread_mutex_trylock (mutex);
	if (err != EBUSY)
	return err;

	ENTER();
	err = pthread_mutex_lock (mutex);
	LEAVE();
	return err;
	}


	int
	npth_mutex_timedlock (npth_mutex_t mutex, const struct timespec abstime)
	{
	int err;

	/* No need to allow competing threads to enter when we can get the
	lock immediately. */
	err = pthread_mutex_trylock (mutex);
	if (err != EBUSY)
	return err;

	ENTER();
	#if HAVE_PTHREAD_MUTEX_TIMEDLOCK
	err = pthread_mutex_timedlock (mutex, abstime);
	#else
	err = busy_wait_for ((trylock_func_t) pthread_mutex_trylock, mutex, abstime);
	#endif
	LEAVE();
	return err;
	}


	#ifndef _NPTH_NO_RWLOCK
	int
	npth_rwlock_rdlock (npth_rwlock_t *rwlock)
	{
	int err;

	#ifdef HAVE_PTHREAD_RWLOCK_TRYRDLOCK
	/* No need to allow competing threads to enter when we can get the
	lock immediately. */
	err = pthread_rwlock_tryrdlock (rwlock);
	if (err != EBUSY)
	return err;
	#endif

	ENTER();
	err = pthread_rwlock_rdlock (rwlock);
	LEAVE();
	return err;
	}


	int
	npth_rwlock_timedrdlock (npth_rwlock_t rwlock, const struct timespec abstime)
	{
	int err;

	#ifdef HAVE_PTHREAD_RWLOCK_TRYRDLOCK
	/* No need to allow competing threads to enter when we can get the
	lock immediately. */
	err = pthread_rwlock_tryrdlock (rwlock);
	if (err != EBUSY)
	return err;
	#endif

	ENTER();
	#if HAVE_PTHREAD_RWLOCK_TIMEDRDLOCK
	err = pthread_rwlock_timedrdlock (rwlock, abstime);
	#else
	err = busy_wait_for ((trylock_func_t) pthread_rwlock_tryrdlock, rwlock,
	abstime);
	#endif
	LEAVE();
	return err;
	}


	int
	npth_rwlock_wrlock (npth_rwlock_t *rwlock)
	{
	int err;

	#ifdef HAVE_PTHREAD_RWLOCK_TRYWRLOCK
	/* No need to allow competing threads to enter when we can get the
	lock immediately. */
	err = pthread_rwlock_trywrlock (rwlock);
	if (err != EBUSY)
	return err;
	#endif

	ENTER();
	err = pthread_rwlock_wrlock (rwlock);
	LEAVE();
	return err;
	}


	int
	npth_rwlock_timedwrlock (npth_rwlock_t rwlock, const struct timespec abstime)
	{
	int err;

	#ifdef HAVE_PTHREAD_RWLOCK_TRYWRLOCK
	/* No need to allow competing threads to enter when we can get the
	lock immediately. */
	err = pthread_rwlock_trywrlock (rwlock);
	if (err != EBUSY)
	return err;
	#endif

	ENTER();
	#if HAVE_PTHREAD_RWLOCK_TIMEDWRLOCK
	err = pthread_rwlock_timedwrlock (rwlock, abstime);
	#elif HAVE_PTHREAD_RWLOCK_TRYRDLOCK
	err = busy_wait_for ((trylock_func_t) pthread_rwlock_trywrlock, rwlock,
	abstime);
	#else
	err = ENOSYS;
	#endif
	LEAVE();
	return err;
	}
	#endif


	int
	npth_cond_wait (npth_cond_t cond, npth_mutex_t mutex)
	{
	int err;

	ENTER();
	err = pthread_cond_wait (cond, mutex);
	LEAVE();
	return err;
	}


	int
	npth_cond_timedwait (npth_cond_t cond, npth_mutex_t mutex,
	const struct timespec *abstime)
	{
	int err;

	ENTER();
	err = pthread_cond_timedwait (cond, mutex, abstime);
	LEAVE();
	return err;
	}


	/* Standard POSIX Replacement API */

	int
	npth_usleep(unsigned int usec)
	{
	int res;

	ENTER();
	res = usleep(usec);
	LEAVE();
	return res;
	}


	unsigned int
	npth_sleep(unsigned int sec)
	{
	unsigned res;

	ENTER();
	res = sleep(sec);
	LEAVE();
	return res;
	}


	int
	npth_system(const char *cmd)
	{
	int res;

	ENTER();
	res = system(cmd);
	LEAVE();
	return res;
	}


	pid_t
	npth_waitpid(pid_t pid, int *status, int options)
	{
	pid_t res;

	ENTER();
	res = waitpid(pid,status, options);
	LEAVE();
	return res;
	}


	int
	npth_connect(int s, const struct sockaddr *addr, socklen_t addrlen)
	{
	int res;

	ENTER();
	res = connect(s, addr, addrlen);
	LEAVE();
	return res;
	}


	int
	npth_accept(int s, struct sockaddr addr, socklen_t addrlen)
	{
	int res;

	ENTER();
	res = accept(s, addr, addrlen);
	LEAVE();
	return res;
	}


	int
	npth_select(int nfd, fd_set rfds, fd_set wfds, fd_set *efds,
	struct timeval *timeout)
	{
	int res;

	ENTER();
	res = select(nfd, rfds, wfds, efds, timeout);
	LEAVE();
	return res;
	}


	int
	npth_pselect(int nfd, fd_set rfds, fd_set wfds, fd_set *efds,
	const struct timespec timeout, const sigset_t sigmask)
	{
	int res;

	ENTER();
	#ifdef HAVE_PSELECT
	res = pselect (nfd, rfds, wfds, efds, timeout, sigmask);
	#else /!HAVE_PSELECT/
	{
	/* A better emulation of pselect would be to create a pipe, wait
	in the select for one end and have a signal handler write to
	the other end. However, this is non-trivial to implement and
	thus we only print a compile time warning. */
	# ifdef __GNUC__
	# warning Using a non race free pselect emulation.
	# endif

	struct timeval t, *tp;

	tp = NULL;
	if (!timeout)
	;
	else if (timeout->tv_nsec >= 0 && timeout->tv_nsec < 1000000000)
	{
	t.tv_sec = timeout->tv_sec;
	t.tv_usec = (timeout->tv_nsec + 999) / 1000;
	tp = &t;
	}
	else
	{
	errno = EINVAL;
	res = -1;
	goto leave;
	}

	if (sigmask)
	{
	int save_errno;
	sigset_t savemask;

	pthread_sigmask (SIG_SETMASK, sigmask, &savemask);
	res = select (nfd, rfds, wfds, efds, tp);
	save_errno = errno;
	pthread_sigmask (SIG_SETMASK, &savemask, NULL);
	errno = save_errno;
	}
	else
	res = select (nfd, rfds, wfds, efds, tp);

	leave:
	;
	}
	#endif /!HAVE_PSELECT/
	LEAVE();
	return res;
	}


	ssize_t
	npth_read(int fd, void *buf, size_t nbytes)
	{
	ssize_t res;

	ENTER();
	res = read(fd, buf, nbytes);
	LEAVE();
	return res;
	}


	ssize_t
	npth_write(int fd, const void *buf, size_t nbytes)
	{
	ssize_t res;

	ENTER();
	res = write(fd, buf, nbytes);
	LEAVE();
	return res;
	}


	int
	npth_recvmsg (int fd, struct msghdr *msg, int flags)
	{
	int res;

	ENTER();
	res = recvmsg (fd, msg, flags);
	LEAVE();
	return res;
	}


	int
	npth_sendmsg (int fd, const struct msghdr *msg, int flags)
	{
	int res;

	ENTER();
	res = sendmsg (fd, msg, flags);
	LEAVE();
	return res;
	}


	void
	npth_unprotect (void)
	{
	ENTER();
	}


	void
	npth_protect (void)
	{
	LEAVE();
	}


	int
	npth_clock_gettime (struct timespec *ts)
	{
	-#if HAVE_CLOCK_GETTIME
	+#if defined(CLOCK_REALTIME) && HAVE_CLOCK_GETTIME
	return clock_gettime (CLOCK_REALTIME, ts);
	+#elif HAVE_GETTIMEOFDAY
	+ {
	+ struct timeval tv;
	+
	+ if (gettimeofday (&tv, NULL))
	+ return -1;
	+ ts->tv_sec = tv.tv_sec;
	+ ts->tv_nsec = tv.tv_usec * 1000;
	+ return 0;
	+ }
	#else
	/* FIXME: fall back on time() with seconds resolution. */
	# error clock_gettime not available - please provide a fallback.
	#endif
	}

File Metadata

Mime Type: text/x-diff
Expires: Thu, Feb 26, 6:40 PM (12 h, 7 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: d0/1f/32393f7fe5c8dd4c7d2db93b66bb

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions