diff -Nurp xinetd-2.3.14-orig/config.h.in xinetd-2.3.14-poll/config.h.in

--- xinetd-2.3.14-orig/config.h.in	2009-07-27 13:27:59.000000000 +0200

+++ xinetd-2.3.14-poll/config.h.in	2009-09-02 11:30:27.000000000 +0200

@@ -106,6 +106,8 @@

 #undef HAVE_HOWL

+#undef HAVE_POLL

+

 /* OS specific */

 #undef solaris

diff -Nurp xinetd-2.3.14-orig/configure.in xinetd-2.3.14-poll/configure.in

--- xinetd-2.3.14-orig/configure.in	2009-09-02 11:32:54.000000000 +0200

+++ xinetd-2.3.14-poll/configure.in	2009-09-02 11:30:27.000000000 +0200

@@ -35,6 +35,7 @@ AC_CHECK_LIB(c, sys_siglist, [AC_DEFINE(

 AC_CHECK_FUNC(gai_strerror,[AC_DEFINE(HAVE_GAI_STRERROR, 1, "")])

 AC_CHECK_FUNC(freeaddrinfo,[AC_DEFINE(HAVE_FREEADDRINFO, 1, "")])

 AC_CHECK_FUNC(getaddrinfo,[AC_DEFINE(HAVE_GETADDRINFO, 1, "")])

+AC_CHECK_FUNC(poll, [AC_DEFINE(HAVE_POLL, 1, "")])

 AC_CHECK_HEADERS(sys/types.h sys/termios.h termios.h sys/ioctl.h sys/select.h rpc/rpc.h rpc/rpcent.h sys/file.h ftw.h machine/reg.h netdb.h)

 AC_CHECK_HEADER(sys/resource.h, [AC_DEFINE(HAVE_SYS_RESOURCE_H, 1, "")])

diff -Nurp xinetd-2.3.14-orig/xinetd/conf.c xinetd-2.3.14-poll/xinetd/conf.c

--- xinetd-2.3.14-orig/xinetd/conf.c	2003-12-30 14:44:09.000000000 +0100

+++ xinetd-2.3.14-poll/xinetd/conf.c	2009-09-02 11:30:27.000000000 +0200

@@ -209,8 +209,13 @@ unsigned cnf_start_services( struct conf

    pset_clear( sconfs ) ;

    if ( debug.on )

+#ifdef HAVE_POLL

+      msg( LOG_DEBUG, func, "pfds_last = %d, services_started = %d",

+            ps.rws.pfds_last, services_started ) ;

+#else

       msg( LOG_DEBUG, func, "mask_max = %d, services_started = %d",

             ps.rws.mask_max, services_started ) ;

+#endif

    return( services_started ) ;

 }

diff -Nurp xinetd-2.3.14-orig/xinetd/defs.h xinetd-2.3.14-poll/xinetd/defs.h

--- xinetd-2.3.14-orig/xinetd/defs.h	2005-03-29 17:50:34.000000000 +0200

+++ xinetd-2.3.14-poll/xinetd/defs.h	2009-09-02 11:30:27.000000000 +0200

@@ -111,6 +111,15 @@ union xsockaddr {

 #define LISTEN_BACKLOG               64

 /*

+ * constants for limiting ps.rws.fd_list 

+ */

+

+#ifdef HAVE_POLL

+#define INIT_POLLFDS                 1024

+#define MAX_POLLFDS                  8192

+#endif

+

+/*

  * When explicit values are given for enum's, that is because the structures 

  * that the enum's are in may be initialized by a memory clear operation.

  */

diff -Nurp xinetd-2.3.14-orig/xinetd/child.c xinetd-2.3.14-poll/xinetd/child.c

--- xinetd-2.3.14-orig/xinetd/child.c	2003-09-06 16:41:59.000000000 +0200

+++ xinetd-2.3.14-poll/xinetd/child.c	2009-09-02 11:30:27.000000000 +0200

@@ -109,8 +109,7 @@ void exec_server( const struct server *s

 #ifdef RLIMIT_NOFILE

-   rl.rlim_max = ps.ros.orig_max_descriptors ;

-   rl.rlim_cur = ps.ros.max_descriptors ;

+   rl.rlim_max = rl.rlim_cur = ps.ros.max_descriptors ;

    (void) setrlimit( RLIMIT_NOFILE, &rl ) ;

 #endif

 #ifdef RLIMIT_AS

diff -Nurp xinetd-2.3.14-orig/xinetd/init.c xinetd-2.3.14-poll/xinetd/init.c

--- xinetd-2.3.14-orig/xinetd/init.c	2003-09-06 16:41:59.000000000 +0200

+++ xinetd-2.3.14-poll/xinetd/init.c	2009-09-02 11:30:27.000000000 +0200

@@ -17,7 +17,7 @@

 #include <unistd.h>

 #include <stdio.h>

 #include <errno.h>

-

+#include <malloc.h>

 #include "sio.h"

 #include "init.h"

 #include "defs.h"

@@ -140,7 +140,6 @@ static void set_fd_limit(void)

 {

 #ifdef RLIMIT_NOFILE

    struct rlimit rl ;

-   rlim_t maxfd ;

    /*

     * Set the soft file descriptor limit to the hard limit.

@@ -151,25 +150,9 @@ static void set_fd_limit(void)

       exit( 1 ) ;

    }

-   maxfd = rl.rlim_max;

    if ( rl.rlim_max == RLIM_INFINITY ) 

       rl.rlim_max = FD_SETSIZE;

-   /* XXX: a dumb way to prevent fd_set overflow possibilities; the rest

-    * of xinetd should be changed to use an OpenBSD inetd-like fd_grow(). */

-   if ( rl.rlim_max > FD_SETSIZE )

-      rl.rlim_max = FD_SETSIZE;

-     

-   rl.rlim_cur = rl.rlim_max ;

-   if ( setrlimit( RLIMIT_NOFILE, &rl ) == -1 )

-   {

-      syscall_failed("setrlimit(RLIMIT_NOFILE)");

-      ps.ros.max_descriptors = FD_SETSIZE;

-      ps.ros.orig_max_descriptors = FD_SETSIZE;

-      return ;

-   }

-

-   ps.ros.orig_max_descriptors = maxfd ;

    ps.ros.max_descriptors = rl.rlim_max ;

 #else      /* ! RLIMIT_NOFILE */

    ps.ros.max_descriptors = getdtablesize() ;

@@ -292,15 +275,27 @@ static pset_h new_table( unsigned size )

  */

 static void init_rw_state( void )

 {

+   const char *func = "init_rw_state" ;

    SERVERS( ps ) = new_table( 0 ) ;

    RETRIES( ps ) = new_table( 0 ) ;

    SERVICES( ps ) = new_table( 0 ) ;

    ps.rws.descriptors_free = ps.ros.max_descriptors - DESCRIPTORS_RESERVED ;

+#ifdef HAVE_POLL

+   ps.rws.pfds_allocated = INIT_POLLFDS ;

+   ps.rws.pfd_array = (struct pollfd *) 

+                      malloc( sizeof( struct pollfd ) * ps.rws.pfds_allocated ) ;

+   if ( ps.rws.pfd_array == NULL ) 

+   {

+      out_of_memory(func);

+      exit( 1 ) ;

+   }

+   ps.rws.pfds_last = 0 ;

+#else

    FD_ZERO( &ps.rws.socket_mask ) ;

    ps.rws.mask_max = 0 ;

-

+#endif /* HAVE_POLL */

 }

diff -Nurp xinetd-2.3.14-orig/xinetd/intcommon.c xinetd-2.3.14-poll/xinetd/intcommon.c

--- xinetd-2.3.14-orig/xinetd/intcommon.c	2003-08-06 08:12:10.000000000 +0200

+++ xinetd-2.3.14-poll/xinetd/intcommon.c	2009-09-03 16:15:49.000000000 +0200

@@ -14,6 +14,9 @@

 #include <errno.h>

 #include <stdlib.h>

 #include <unistd.h>

+#ifdef HAVE_POLL

+#include <poll.h>

+#endif

 #include "intcommon.h"

 #include "msg.h"

@@ -36,27 +39,38 @@ void int_fail( const struct intercept_s 

 /*

  * Returns either a positive number or -1

  */

+#ifdef HAVE_POLL

+int int_poll( int pfds_last, struct pollfd *pfd_array )

+{

+   const char *func = "int_poll" ;

+#else

 int int_select( int max, fd_set *read_mask )

 {

    const char *func = "int_select" ;

+#endif

    for ( ;; )

    {

       int n_ready ;

-      n_ready = select( max+1, read_mask,

-                                 FD_SET_NULL, FD_SET_NULL, TIMEVAL_NULL ) ;

+      do {

+#ifdef HAVE_POLL

+         n_ready = poll( pfd_array, pfds_last, -1 );

+#else

+         n_ready = select( max+1, read_mask,

+                           FD_SET_NULL, FD_SET_NULL, TIMEVAL_NULL ) ;

+#endif

+      } while (n_ready == -1 && errno == EINTR);

+

+

       if ( n_ready > 0 )

          return( n_ready ) ;

-      else if ( n_ready == -1 ) {

-         if ( errno == EINTR )

-            continue ;

-         else

-         {

-            msg( LOG_ERR, func, "select: %m" ) ;

-            return( -1 ) ;

-         }

-      }

+#ifdef HAVE_POLL

+      msg( LOG_ERR, func, "poll: %m" ) ;

+#else

+      msg( LOG_ERR, func, "select: %m" ) ;

+#endif

+      return( -1 ) ;

    }

 }

diff -Nurp xinetd-2.3.14-orig/xinetd/internals.c xinetd-2.3.14-poll/xinetd/internals.c

--- xinetd-2.3.14-orig/xinetd/internals.c	2003-09-06 16:41:59.000000000 +0200

+++ xinetd-2.3.14-poll/xinetd/internals.c	2009-09-03 10:38:29.000000000 +0200

@@ -53,6 +53,9 @@ void dump_internal_state(void)

    const char *dump_file = DUMP_FILE ;

    time_t current_time ;

    int fd ;

+#ifdef HAVE_POLL

+   int *listed_fds;

+#endif

    unsigned u ;

    const char *func = "dump_internal_state" ;

@@ -104,6 +107,41 @@ void dump_internal_state(void)

       server_dump( SERP( pset_pointer( RETRIES( ps ), u ) ), dump_fd ) ;

    Sputchar( dump_fd, '\n' ) ;

+#ifdef HAVE_POLL

+   /*

+    * Dump the socket mask

+    */

+   listed_fds = (int *)calloc(sizeof(int),ps.ros.max_descriptors);

+   if (listed_fds != NULL)

+   {

+      Sprint( dump_fd, "Socket mask:" ) ;

+      for ( fd = 0 ; fd < ps.rws.pfds_last ; fd++ )

+      {

+         listed_fds[ps.rws.pfd_array[fd].fd] = 1;

+         Sprint( dump_fd, " %d", ps.rws.pfd_array[fd].fd ) ;

+      }

+      Sputchar( dump_fd, '\n' ) ;

+      Sprint( dump_fd, "pfds_last = %d\n", ps.rws.pfds_last ) ;

+

+      /*

+       * Dump the descriptors that are open and are *not* in the socket list

+       */

+      Sprint( dump_fd, "Open descriptors (not in socket mask):" ) ;

+      for ( fd = 0 ; (unsigned)fd < ps.ros.max_descriptors ; fd++ )

+      {

+         struct stat st ;

+

+         if ( !listed_fds[fd] && fstat( fd, &st ) != -1 )

+            Sprint( dump_fd, " %d", fd ) ;

+      }

+

+      Sputchar( dump_fd, '\n' ) ;

+      Sputchar( dump_fd, '\n' ) ;

+      free(listed_fds);

+   }

+   else

+     Sprint( dump_fd, "Could not dump open descriptors, not enough memory!\n" );

+#else /* !HAVE_POLL */

    /*

     * Dump the socket mask

     */

@@ -114,6 +152,7 @@ void dump_internal_state(void)

    Sputchar( dump_fd, '\n' ) ;

    Sprint( dump_fd, "mask_max = %d\n", ps.rws.mask_max ) ;

+

    /*

     * Dump the descriptors that are open and are *not* in the socket mask

     */

@@ -130,6 +169,7 @@ void dump_internal_state(void)

    }

    Sputchar( dump_fd, '\n' ) ;

    Sputchar( dump_fd, '\n' ) ;

+#endif /* !HAVE_POLL */

    Sprint( dump_fd, "active_services = %d\n", ps.rws.active_services ) ;

    Sprint( dump_fd, "available_services = %d\n", ps.rws.available_services ) ;

@@ -162,7 +202,6 @@ enum check_type { PERIODIC, USER_REQUEST

 static void consistency_check( enum check_type type )

 {

    int         fd ;

-   fd_set      socket_mask_copy ;

    unsigned    u ;

    int         errors ;

    unsigned    total_running_servers        = 0 ;

@@ -171,7 +210,19 @@ static void consistency_check( enum chec

    bool_int    service_count_check_failed   = FALSE ;

    const char  *func                        = "consistency_check" ;

+

+#ifdef HAVE_POLL

+  struct pollfd *pfd_array_copy = calloc(sizeof(struct pollfd), ps.rws.pfds_last);

+  if (pfd_array_copy == NULL)

+  {

+     msg( LOG_ERR, func, "Could not run consistency check! Not enough memory!\n" ) ;

+     return;

+  }

+  memcpy(pfd_array_copy, ps.rws.pfd_array, ps.rws.pfds_last*sizeof(struct pollfd));

+#else /* !HAVE_POLL */

+   fd_set      socket_mask_copy ;

    socket_mask_copy = ps.rws.socket_mask ;

+#endif /* HAVE_POLL */

    for ( u = 0 ; u < pset_count( SERVICES( ps ) ) ; u++ )

    {

@@ -184,9 +235,22 @@ static void consistency_check( enum chec

       if ( SVC_IS_AVAILABLE( sp ) || SVC_IS_DISABLED ( sp ) )

       {

+

          /*

           * In this case, there may be some servers running

           */

+#ifdef HAVE_POLL

+         if ( pfd_array_copy[ SVC_POLLFD_OFF( sp ) ].events )

+         {

+            if ( SVC_IS_DISABLED( sp ) )

+            {

+               msg( LOG_ERR, func,

+                  "fd of disabled service %s still in socket mask", sid ) ;

+               error_count++ ;

+            }

+            pfd_array_copy[ SVC_POLLFD_OFF( sp ) ].events = 0;

+         }

+#else /* !HAVE_POLL */

          if ( FD_ISSET( SVC_FD( sp ), &socket_mask_copy ) )

          {

             if ( SVC_IS_DISABLED( sp ) )

@@ -197,8 +261,9 @@ static void consistency_check( enum chec

             }

             FD_CLR( SVC_FD( sp ), &socket_mask_copy ) ;

          }

-         error_count += thread_check( sp, running_servers, retry_servers ) ;

+#endif /* HAVE_POLL */

+         error_count += thread_check( sp, running_servers, retry_servers ) ;

          errors = service_count_check( sp, running_servers, retry_servers ) ;

          if ( ! errors && ! service_count_check_failed )

          {

@@ -248,6 +313,18 @@ static void consistency_check( enum chec

    /*

     * Check if there are any descriptors set in socket_mask_copy

     */

+#ifdef HAVE_POLL

+   for ( fd = 0 ; fd < ps.rws.pfds_last ; fd++)

+     if ( pfd_array_copy[fd].events && pfd_array_copy[fd].fd != signals_pending[0] && 

+          pfd_array_copy[fd].fd != signals_pending[1] )

+     {

+         msg( LOG_ERR, func,

+            "descriptor %d set in socket mask but there is no service for it",

+               fd ) ;

+         error_count++ ;

+     }

+   free(pfd_array_copy);

+#else /* !HAVE_POLL */

    for ( fd = 0 ; (unsigned)fd < ps.ros.max_descriptors ; fd++ )

       if ( FD_ISSET( fd, &socket_mask_copy ) && ((fd != signals_pending[0]) && fd != signals_pending[1]))

       {

@@ -256,6 +333,7 @@ static void consistency_check( enum chec

                fd ) ;

          error_count++ ;

       }

+#endif /* !HAVE_POLL */

    if ( error_count != 0 )

       msg( LOG_WARNING, func,

@@ -304,7 +382,6 @@ static unsigned service_count_check( str

 }

-

 /*

  * If the service is single-threaded:

  *         if the descriptor is set in the socket mask, there must

@@ -317,7 +394,11 @@ static unsigned thread_check( struct ser

                                unsigned retry_servers )

 {

    unsigned error_count = 0 ;

+#ifdef HAVE_POLL

+   struct pollfd *pfd= SVC_POLLFD( sp ) ;

+#else

    int sd = SVC_FD( sp ) ;

+#endif

    char *sid = SVC_ID( sp ) ;

    const char *func = "thread_check" ;

@@ -325,13 +406,21 @@ static unsigned thread_check( struct ser

    {

       bool_int has_servers = ( running_servers + retry_servers != 0 ) ;

+#ifdef HAVE_POLL

+      if ( has_servers && pfd->events )

+#else

       if ( has_servers && FD_ISSET( sd, &ps.rws.socket_mask ) )

+#endif

       {

          msg( LOG_ERR, func,

 "Active single-threaded service %s: server running, descriptor set", sid ) ;

          error_count++ ;

       }

+#ifdef HAVE_POLL

+      if ( !has_servers && !pfd->events )

+#else

       if ( !has_servers && !FD_ISSET( sd, &ps.rws.socket_mask ) )

+#endif

       {

          msg( LOG_ERR, func,

 "Active single-threaded service %s: no server running, descriptor not set",

@@ -340,7 +429,11 @@ static unsigned thread_check( struct ser

       }

    }

    else

+#ifdef HAVE_POLL

+      if ( ! pfd->events )

+#else

       if ( ! FD_ISSET( sd, &ps.rws.socket_mask ) )

+#endif

       {

          msg( LOG_ERR, func,

             "Active multi-threaded service %s: descriptor not set", sid ) ;

diff -Nurp xinetd-2.3.14-orig/xinetd/main.c xinetd-2.3.14-poll/xinetd/main.c

--- xinetd-2.3.14-orig/xinetd/main.c	2009-07-27 13:27:59.000000000 +0200

+++ xinetd-2.3.14-poll/xinetd/main.c	2009-09-03 16:23:11.000000000 +0200

@@ -25,6 +25,9 @@

 #include "xtimer.h"

 #include "sensor.h"

 #include "xmdns.h"

+#ifdef HAVE_POLL

+#include "xpoll.h"

+#endif

 #ifdef __GNUC__

 __attribute__ ((noreturn))

@@ -119,16 +122,24 @@ static void main_loop(void)

 {

    const char      *func = "main_loop" ;

    struct timeval   tv, *tvptr = NULL;

+#ifdef HAVE_POLL

+   struct pollfd   *signal_pfd;

-   FD_SET(signals_pending[0], &ps.rws.socket_mask);

+   ps.rws.pfd_array[ps.rws.pfds_last].fd = signals_pending[0] ;

+   ps.rws.pfd_array[ps.rws.pfds_last].events = POLLIN ;

+   signal_pfd = &ps.rws.pfd_array[ps.rws.pfds_last] ;

+   ps.rws.pfds_last++;

+#else

+   FD_SET(signals_pending[0], &ps.rws.socket_mask) ;

    if ( signals_pending[0] > ps.rws.mask_max )

       ps.rws.mask_max = signals_pending[0] ;

-   if ( signals_pending[1] > ps.rws.mask_max )

-      ps.rws.mask_max = signals_pending[1] ;

+#endif /* HAVE_POLL */

    for ( ;; )

    {

+#ifndef HAVE_POLL

       fd_set read_mask ;

+#endif

       int n_active ;

       unsigned u ;

@@ -144,9 +155,14 @@ static void main_loop(void)

          tvptr = NULL;

       }

+#ifdef HAVE_POLL

+      n_active = poll( ps.rws.pfd_array, ps.rws.pfds_last,

+                       tvptr == NULL ? -1 : tvptr->tv_sec*1000 ) ;

+#else

       read_mask = ps.rws.socket_mask ;

       n_active = select( ps.rws.mask_max+1, &read_mask,

                         FD_SET_NULL, FD_SET_NULL, tvptr ) ;

+#endif

       if ( n_active == -1 )

       {

          if ( errno == EINTR ) {

@@ -165,11 +181,27 @@ static void main_loop(void)

       xtimer_poll();

-      if( FD_ISSET(signals_pending[0], &read_mask) ) {

+#ifdef HAVE_POLL

+      if ( POLLFD_REVENTS( signal_pfd ) ) 

+      {

+        if ( POLLFD_REVENTS( signal_pfd ) & (POLLERR | POLLHUP | 

+            POLLNVAL) ) 

+          find_bad_fd();

+        else

+        {

+          check_pipe();

+          if ( --n_active == 0 )

+            continue ;

+        }

+      }

+#else

+      if( FD_ISSET(signals_pending[0], &read_mask) ) 

+      {

          check_pipe();

             if ( --n_active == 0 )

                continue ;

       }

+#endif

 #ifdef HAVE_MDNS

       if( xinetd_mdns_poll() == 0 )

@@ -186,19 +218,33 @@ static void main_loop(void)

          if ( ! SVC_IS_ACTIVE( sp ) )

             continue ;

+#ifdef HAVE_POLL

+         if ( SVC_REVENTS( sp ) )

+         {

+           if ( SVC_REVENTS( sp ) & (POLLERR | POLLHUP | 

+               POLLNVAL) ) 

+             find_bad_fd();

+           else

+           {

+             svc_request( sp ) ;

+             if ( --n_active == 0 )

+               break ;

+           }

+         }

+#else

          if ( FD_ISSET( SVC_FD( sp ), &read_mask ) )

          {

             svc_request( sp ) ;

             if ( --n_active == 0 )

                break ;

          }

+#endif

       }

       if ( n_active > 0 )

          msg( LOG_ERR, func, "%d descriptors still set", n_active ) ;

    }

 }

-

 /*

  * This function identifies if any of the fd's in the socket mask

  * is bad. We use it in case select(2) returns EBADF

@@ -208,13 +254,29 @@ static void main_loop(void)

 static void find_bad_fd(void)

 {

    int fd ;

+#ifdef HAVE_POLL

+   const char *reason;

+#else

    struct stat st ;

+#endif

    unsigned bad_fd_count = 0 ;

    const char *func = "find_bad_fd" ;

+#ifdef HAVE_POLL

+   for ( fd = 0 ; (unsigned)fd < ps.rws.pfds_last ; fd++ )

+      if ( ps.rws.pfd_array[fd].revents & ( POLLHUP|POLLNVAL|POLLERR ) )

+      {

+         if ( ps.rws.pfd_array[fd].revents & POLLHUP )

+            reason = "hung up";

+         else if ( ps.rws.pfd_array[fd].revents & POLLNVAL )

+            reason = "been closed";

+         else if ( ps.rws.pfd_array[fd].revents & POLLERR )

+            reason = "reported error condition";

+#else

    for ( fd = 0 ; (unsigned)fd < ps.ros.max_descriptors ; fd++ )

       if ( FD_ISSET( fd, &ps.rws.socket_mask ) && fstat( fd, &st ) == -1 )

       {

+#endif

          int found = FALSE ;

          unsigned u ;

@@ -239,7 +301,11 @@ static void find_bad_fd(void)

          }

          if ( ! found )

          {

+#ifdef HAVE_POLL

+            ps.rws.pfd_array[fd].events = 0;

+#else

             FD_CLR( fd, &ps.rws.socket_mask ) ;

+#endif

             msg( LOG_ERR, func,

                "No active service for file descriptor %d\n", fd ) ;

             bad_fd_count++ ;

diff -Nurp xinetd-2.3.14-orig/xinetd/redirect.c xinetd-2.3.14-poll/xinetd/redirect.c

--- xinetd-2.3.14-orig/xinetd/redirect.c	2009-07-27 13:27:59.000000000 +0200

+++ xinetd-2.3.14-poll/xinetd/redirect.c	2009-09-02 16:00:34.000000000 +0200

@@ -58,14 +58,19 @@ void redir_handler( struct server *serp 

    struct service *sp = SERVER_SERVICE( serp );

    struct service_config *scp = SVC_CONF( sp );

    int RedirDescrip = SERVER_FD( serp );

-   int maxfd;

    ssize_t num_read, num_wrote=0, ret=0;

    unsigned int sin_len = 0;

    unsigned long bytes_in = 0, bytes_out = 0;

    int no_to_nagle = 1;

    int on = 1, v6on;

    char buff[NET_BUFFER];

+#ifdef HAVE_POLL

+   struct pollfd *pfd_array;

+   int            pfds_last = 0;

+#else

    fd_set rdfd, msfd;

+   int maxfd;

+#endif

    struct timeval *timep = NULL;

    const char *func = "redir_handler";

    union xsockaddr serveraddr ;

@@ -141,19 +146,43 @@ void redir_handler( struct server *serp 

          msg(LOG_ERR, func, "setsockopt RedirDescrip failed: %m");

       }

+#ifdef HAVE_POLL

+#define REDIR_DESCRIP_INDEX 0

+#define REDIR_SERVER_INDEX 1

+      pfd_array = (struct pollfd *)calloc(sizeof(struct pollfd),INIT_POLLFDS);

+      if (pfd_array == NULL)

+      {

+         msg( LOG_ERR, func, "Cannot allocate memory for file descriptors!\n");

+         exit( 1 );

+      }

+      pfd_array[ REDIR_DESCRIP_INDEX ].fd = RedirDescrip;

+      pfd_array[ REDIR_DESCRIP_INDEX ].events = POLLIN;

+      pfd_array[ REDIR_SERVER_INDEX ].fd = RedirServerFd;

+      pfd_array[ REDIR_SERVER_INDEX ].events = POLLIN;

+      pfds_last += 2;

+#else

       maxfd = (RedirServerFd > RedirDescrip)?RedirServerFd:RedirDescrip;

       FD_ZERO(&msfd);

       FD_SET(RedirDescrip, &msfd);

       FD_SET(RedirServerFd, &msfd);

+#endif

       while(1) {

+#ifdef HAVE_POLL

+         if ( poll( pfd_array, pfds_last, -1 ) <= 0 ) {

+#else

          memcpy(&rdfd, &msfd, sizeof(rdfd));

          if (select(maxfd + 1, &rdfd, (fd_set *)0, (fd_set *)0, timep) <= 0) {

+#endif

             /* place for timeout code, currently does not time out */

             break;

          }

+#ifdef HAVE_POLL

+         if ( pfd_array[REDIR_DESCRIP_INDEX].revents ) {

+#else

          if (FD_ISSET(RedirDescrip, &rdfd)) {

+#endif

             do {

                num_read = read(RedirDescrip,

                   buff, sizeof(buff));

@@ -179,7 +208,11 @@ void redir_handler( struct server *serp 

             }

          }

+#ifdef HAVE_POLL

+         if ( pfd_array[REDIR_SERVER_INDEX].revents ) {

+#else

          if (FD_ISSET(RedirServerFd, &rdfd)) {

+#endif

             do {

                num_read = read(RedirServerFd,

                   buff, sizeof(buff));

diff -Nurp xinetd-2.3.14-orig/xinetd/server.c xinetd-2.3.14-poll/xinetd/server.c

--- xinetd-2.3.14-orig/xinetd/server.c	2005-03-29 17:50:34.000000000 +0200

+++ xinetd-2.3.14-poll/xinetd/server.c	2009-09-02 11:30:27.000000000 +0200

@@ -298,7 +298,11 @@ void server_end( struct server *serp )

       /* Added this for when accepting wait=yes services */

       if( SVC_WAITS( sp ) )

+#ifdef HAVE_POLL

+         SVC_EVENTS( sp ) = POLLIN ;

+#else

          FD_SET( SVC_FD( sp ), &ps.rws.socket_mask ) ;

+#endif /* HAVE_POLL */

       svc_postmortem( sp, serp ) ;

       server_release( serp ) ;

diff -Nurp xinetd-2.3.14-orig/xinetd/service.c xinetd-2.3.14-poll/xinetd/service.c

--- xinetd-2.3.14-orig/xinetd/service.c	2009-07-27 13:27:59.000000000 +0200

+++ xinetd-2.3.14-poll/xinetd/service.c	2009-09-02 17:03:49.000000000 +0200

@@ -71,8 +71,6 @@ static const struct name_value service_s

       { "BAD STATE",          0                        }

    } ;

-

-

 /*

  * Allocate a new struct service and initialize it from scp 

  */

@@ -115,6 +113,10 @@ struct service *svc_make_special( struct

 void svc_free( struct service *sp )

 {

+#ifdef HAVE_POLL

+   *SVC_POLLFD( sp ) = ps.rws.pfd_array[--ps.rws.pfds_last] ;

+#endif /* HAVE_POLL */

+

    sc_free( SVC_CONF(sp) ) ;

    CLEAR( *sp ) ;

    FREE_SVC( sp ) ;

@@ -325,6 +327,25 @@ status_e svc_activate( struct service *s

       return( OK );

    }

+#ifdef HAVE_POLL

+   if ( ps.rws.pfds_last >= ps.rws.pfds_allocated )

+   {

+     int pos;

+     ps.rws.pfds_allocated += INIT_POLLFDS;

+     struct pollfd *tmp = (struct pollfd *)realloc( ps.rws.pfd_array,

+       ps.rws.pfds_allocated*sizeof(struct pollfd));

+     if ( tmp == NULL )

+     {

+       out_of_memory( func );

+       return( FAILED );