Fixes for replay events on queue/cleaned up a few return states we were not checking.

.bzrignore

@@ -14,6 +14,7 @@
 *rpm
 *stamp-h1
 *tar
+.gdb_history
 .hg/
 .hgignore
 .hgsub
@@ -85,6 +86,9 @@ m4/ltoptions.m4
 m4/ltsugar.m4
 m4/ltversion.m4
 m4/lt~obsolete.m4
+man/*.1
+man/*.3
+man/*.8
 out
 patch
 patch*
@@ -146,6 +150,3 @@ unittests/unittests
 util/.hg/
 util/.hgignore
 var
-man/*.1
-man/*.3
-man/*.8

ChangeLog

@@ -1,5 +1,6 @@
-0.40
+0.41
 * Switched from --having-debug to --enable-debug
+* Fix for SQLITE, it wasn't replaying its queue on startup.
 
 0.39 Wed Sep 19 03:36:06 EDT 2012
 * Added gearman_job_error() interface.

configure.ac

@@ -6,7 +6,7 @@
 # Use and distribution licensed under the BSD license.  See
 # the COPYING file in this directory for full text.
 
-AC_INIT([gearmand],[0.40],[https://bugs.launchpad.net/gearmand],[gearmand],[http://gearman.info/])
+AC_INIT([gearmand],[0.41],[https://bugs.launchpad.net/gearmand],[gearmand],[http://gearman.info/])
 AC_CONFIG_AUX_DIR([build-aux])
 AC_CONFIG_MACRO_DIR([m4])
 
@@ -117,15 +117,35 @@ AX_PROG_SPHINX_BUILD
 # Checks for header files.
 AC_HEADER_STDC
 AC_HEADER_SYS_WAIT
-AC_CHECK_HEADERS(arpa/inet.h fcntl.h inttypes.h limits.h netdb.h netinet/in.h stddef.h stdint.h stdlib.h string.h strings.h sys/socket.h sys/time.h unistd.h netinet/tcp.h)
-AC_CHECK_HEADERS(errno.h getopt.h pwd.h signal.h)
-AC_CHECK_HEADERS(stdarg.h stddef.h stdio.h)
-AC_CHECK_HEADERS(sys/resource.h sys/stat.h)
-AC_CHECK_HEADERS(sys/socket.h sys/types.h sys/utsname.h strings.h)
-AC_CHECK_HEADERS([execinfo.h])
+AC_CHECK_HEADERS([arpa/inet.h])
 AC_CHECK_HEADERS([cxxabi.h], 
                  AC_DEFINE([HAVE_CXXABI_H], [1], [Have cxxabi.h]),
                  AC_DEFINE([HAVE_CXXABI_H], [0], [Have cxxabi.h]))
+AC_CHECK_HEADERS([errno.h])
+AC_CHECK_HEADERS([execinfo.h])
+AC_CHECK_HEADERS([fcntl.h])
+AC_CHECK_HEADERS([getopt.h])
+AC_CHECK_HEADERS([inttypes.h])
+AC_CHECK_HEADERS([limits.h])
+AC_CHECK_HEADERS([netdb.h])
+AC_CHECK_HEADERS([netinet/in.h])
+AC_CHECK_HEADERS([netinet/tcp.h])
+AC_CHECK_HEADERS([pwd.h])
+AC_CHECK_HEADERS([signal.h])
+AC_CHECK_HEADERS([stdarg.h])
+AC_CHECK_HEADERS([stddef.h])
+AC_CHECK_HEADERS([stdint.h])
+AC_CHECK_HEADERS([stdio.h])
+AC_CHECK_HEADERS([stdlib.h])
+AC_CHECK_HEADERS([string.h])
+AC_CHECK_HEADERS([strings.h])
+AC_CHECK_HEADERS([sys/resource.h])
+AC_CHECK_HEADERS([sys/socket.h])
+AC_CHECK_HEADERS([sys/stat.h])
+AC_CHECK_HEADERS([sys/time.h])
+AC_CHECK_HEADERS([sys/types.h])
+AC_CHECK_HEADERS([sys/utsname.h])
+AC_CHECK_HEADERS([unistd.h])
 
 # Checks for typedefs, structures, and compiler characteristics.
 AC_HEADER_STDBOOL
@@ -146,68 +166,70 @@ AC_C_VOLATILE
 AC_CHECK_TYPES([ptrdiff_t])
 
 # Checks for library functions.
-LT_LIB_M
 AC_FUNC_ERROR_AT_LINE
-AC_REPLACE_FNMATCH
 AC_FUNC_FORK
 AC_FUNC_MALLOC
 AC_FUNC_MEMCMP
 AC_FUNC_REALLOC
 AC_FUNC_STRERROR_R
 AC_FUNC_VPRINTF
-AC_CHECK_FUNCS([dup2 gettimeofday memchr memmove memset socket strcasecmp strdup strerror strncasecmp uname])
+AC_REPLACE_FNMATCH
+AC_CHECK_FUNCS([dup2])
+AC_CHECK_FUNCS([gettimeofday])
+AC_CHECK_FUNCS([memchr])
+AC_CHECK_FUNCS([memmove])
+AC_CHECK_FUNCS([memset])
 AC_CHECK_FUNCS([pipe2], 
                AC_DEFINE([HAVE_PIPE2], [1], [Have pipe2]),
                AC_DEFINE([HAVE_PIPE2], [0], [Have pipe2]))
 AC_CHECK_FUNCS([select])
 AC_CHECK_FUNCS([setenv])
+AC_CHECK_FUNCS([socket])
+AC_CHECK_FUNCS([strcasecmp])
+AC_CHECK_FUNCS([strdup])
+AC_CHECK_FUNCS([strerror])
+AC_CHECK_FUNCS([strncasecmp])
 AC_CHECK_FUNCS([strtol])
 AC_CHECK_FUNCS([strtoul])
+AC_CHECK_FUNCS([uname])
+LT_LIB_M
 
 # Check for the ability to call dlopen (used in libhostile)
-AC_CHECK_LIB([dl], [dlopen], 
-             [
+AC_CHECK_LIB([dl], [dlopen], [
               DL_LIB="-ldl"
-              AC_SUBST(DL_LIB)
-              AC_DEFINE([HAVE_LIBDL], [ 1 ], [Have dlopen])
-              ],
-             [
-              AC_DEFINE([HAVE_LIBDL], [ 0 ], [Have dlopen])
-              ])
+              AC_SUBST([DL_LIB])
+              AC_DEFINE([HAVE_LIBDL], [1], [Have dlopen])
+              ],[
+                 AC_DEFINE([HAVE_LIBDL], [0], [Have dlopen])
+                 ])
 
 # Check for -lrt
-AC_CHECK_LIB([rt], [clock_gettime], 
-             [
+AC_CHECK_LIB([rt], [clock_gettime], [
               RT_LIB="-lrt"
               AC_SUBST(RT_LIB)
-              AC_DEFINE([HAVE_LIBRT], [ 1 ], [Have clock_gettime])
-              ], 
-             [
-              AC_DEFINE([HAVE_LIBRT], [ 0 ], [Have clock_gettime])
+              AC_DEFINE([HAVE_LIBRT], [1], [Have clock_gettime])
+              ],[
+                 AC_DEFINE([HAVE_LIBRT], [0], [Have clock_gettime])
               ])
 
 # Check for -lm
-AC_CHECK_LIB([m], [floor], 
-             [
+AC_CHECK_LIB([m], [floor], [
               M_LIB="-lm"
               AC_SUBST(M_LIB)
               AC_DEFINE([HAVE_LIBM], [ 1 ], [Have math library])
-              ], 
-             [
-              AC_DEFINE([HAVE_LIBM], [ 0 ], [Have math library])
-              ])
+              ],[
+                 AC_DEFINE([HAVE_LIBM], [ 0 ], [Have math library])
+                 ])
 
 AC_CHECK_FUNC(setsockopt, [], [AC_CHECK_LIB(socket, setsockopt)])
 AC_CHECK_FUNC(bind, [], [AC_CHECK_LIB(bind, bind)])
 
 AC_DEFINE([GEARMAND_BLOBSLAP_WORKER], [ 1 ], [Have Gearman Blobslap Worker])
 
-AX_CHECK_LIBRARY([LIBEVENT], [event.h], [event], 
-                 [
+AX_CHECK_LIBRARY([LIBEVENT], [event.h], [event], [
                   LIBEVENT_LDFLAGS="-levent"
-                  ],
-                 [
-                  AC_MSG_ERROR([Unable to find libevent])
+                  ],[
+                     AC_MSG_ERROR([Unable to find libevent])
                   ])
 
 AX_UUID_GENERATE_TIME_SAFE
@@ -215,9 +237,6 @@ AX_UUID_GENERATE_TIME_SAFE
 AS_IF([test "x${TARGET_LINUX}" = "xtrue"], [AC_DEFINE([BUILD_LIBHOSTILE], [1], [Build libhostile])], [AC_DEFINE([BUILD_LIBHOSTILE], [0], [Build libhostile])])
 AM_CONDITIONAL(TARGET_HOSTILE, [test "x${TARGET_LINUX}" = "xtrue"])
 
-AX_CHECK_SOCK_CLOEXEC([AC_DEFINE([HAVE_SOCK_CLOEXEC], [1], [Check for SOCK_CLOEXEC.])],
-                       [AC_DEFINE([HAVE_SOCK_CLOEXEC], [0], [Check for SOCK_CLOEXEC.])])
-
 AX_PTHREAD(, [AC_MSG_ERROR(could not find libpthread)])
 AX_PTHREAD_TIMEDJOIN_NP
 

libgearman-server/plugins/queue/tokyocabinet/queue.cc

@@ -164,7 +164,7 @@ static const char * _libtokyocabinet_tcaerrmsg(TCADB *db)
     }
   }
 
-  return NULL;
+  return "no TCADB file";
 }
 
 gearmand_error_t _initialize(gearman_server_st *server,
@@ -186,11 +186,11 @@ gearmand_error_t _initialize(gearman_server_st *server,
 
   if (tcadbopen(queue->db, queue->filename.c_str()) == 0)
   {
-    queue->destroy();
-
     gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, 
                        "tcadbopen(%s): %s", queue->filename.c_str(), _libtokyocabinet_tcaerrmsg(queue->db));
 
+    queue->destroy();
+
     return GEARMAN_QUEUE_ERROR;
   }
 

libgearman/connection.cc

@@ -61,7 +61,15 @@
 #endif
 
 #ifndef SOCK_CLOEXEC 
-#define SOCK_CLOEXEC 0
+#  define SOCK_CLOEXEC 0
+#endif
+
+#ifndef SOCK_NONBLOCK 
+#  define SOCK_NONBLOCK 0
+#endif
+
+#ifndef FD_CLOEXEC
+#  define FD_CLOEXEC 0
 #endif
 
 static gearman_return_t gearman_connection_set_option(gearman_connection_st *connection,
@@ -633,11 +641,16 @@ gearman_return_t gearman_connection_st::flush()
       // rewrite tye if HAVE_SOCK_CLOEXEC
       {
         int type= addrinfo_next->ai_socktype;
-        if (HAVE_SOCK_CLOEXEC)
+        if (SOCK_CLOEXEC)
         {
           type|= SOCK_CLOEXEC;
         }
 
+        if (SOCK_NONBLOCK)
+        {
+          type|= SOCK_NONBLOCK; 
+        }
+
         fd= socket(addrinfo_next->ai_family, type, addrinfo_next->ai_protocol);
       }
 
@@ -647,15 +660,26 @@ gearman_return_t gearman_connection_st::flush()
         return gearman_perror(universal, "socket");
       }
 
-      if (HAVE_SOCK_CLOEXEC == 0)
+      if (SOCK_CLOEXEC == 0)
       {
-#ifdef FD_CLOEXEC
-        int rval;
-        do
-        { 
-          rval= fcntl (fd, F_SETFD, FD_CLOEXEC);
-        } while (rval == -1 && (errno == EINTR or errno == EAGAIN));
-#endif
+        if (FD_CLOEXEC)
+        {
+          int flags;
+          do 
+          {
+            flags= fcntl(fd, F_GETFD, 0);
+          } while (flags == -1 and (errno == EINTR or errno == EAGAIN));
+
+          if (flags != -1)
+          {
+            int rval;
+            do
+            { 
+              rval= fcntl (fd, F_SETFD, flags | FD_CLOEXEC);
+            } while (rval == -1 && (errno == EINTR or errno == EAGAIN));
+            // we currently ignore the case where rval is -1
+          }
+        }
       }
 
       {
@@ -1084,42 +1108,45 @@ void gearman_connection_st::set_revents(short arg)
 
 static gearman_return_t _con_setsockopt(gearman_connection_st *connection)
 {
-  int ret;
-  struct linger linger;
-  struct timeval waittime;
-
-  ret= 1;
-  ret= setsockopt(connection->fd, IPPROTO_TCP, TCP_NODELAY, &ret,
-                  socklen_t(sizeof(int)));
-  if (ret == -1 && errno != EOPNOTSUPP)
   {
-    gearman_perror(connection->universal, "setsockopt(TCP_NODELAY)");
-    return GEARMAN_ERRNO;
+    int ret= 1;
+    ret= setsockopt(connection->fd, IPPROTO_TCP, TCP_NODELAY, &ret,
+                    socklen_t(sizeof(int)));
+    if (ret == -1 && errno != EOPNOTSUPP)
+    {
+      gearman_perror(connection->universal, "setsockopt(TCP_NODELAY)");
+      return GEARMAN_ERRNO;
+    }
   }
 
-  linger.l_onoff= 1;
-  linger.l_linger= GEARMAN_DEFAULT_SOCKET_TIMEOUT;
-  ret= setsockopt(connection->fd, SOL_SOCKET, SO_LINGER, &linger,
-                  socklen_t(sizeof(struct linger)));
-  if (ret == -1)
   {
-    gearman_perror(connection->universal, "setsockopt(SO_LINGER)");
-    return GEARMAN_ERRNO;
+    struct linger linger;
+    linger.l_onoff= 1;
+    linger.l_linger= GEARMAN_DEFAULT_SOCKET_TIMEOUT;
+    int ret= setsockopt(connection->fd, SOL_SOCKET, SO_LINGER, &linger,
+                        socklen_t(sizeof(struct linger)));
+    if (ret == -1)
+    {
+      gearman_perror(connection->universal, "setsockopt(SO_LINGER)");
+      return GEARMAN_ERRNO;
+    }
   }
 
-  waittime.tv_sec= GEARMAN_DEFAULT_SOCKET_TIMEOUT;
-  waittime.tv_usec= 0;
-  ret= setsockopt(connection->fd, SOL_SOCKET, SO_SNDTIMEO, &waittime,
-                  socklen_t(sizeof(struct timeval)));
-  if (ret == -1 && errno != ENOPROTOOPT)
+  if (0)
   {
-    gearman_perror(connection->universal, "setsockopt(SO_SNDTIMEO)");
-    return GEARMAN_ERRNO;
-  }
+    struct timeval waittime;
+    waittime.tv_sec= GEARMAN_DEFAULT_SOCKET_TIMEOUT;
+    waittime.tv_usec= 0;
+    int ret= setsockopt(connection->fd, SOL_SOCKET, SO_SNDTIMEO, &waittime,
+                        socklen_t(sizeof(struct timeval)));
+    if (ret == -1 && errno != ENOPROTOOPT)
+    {
+      gearman_perror(connection->universal, "setsockopt(SO_SNDTIMEO)");
+      return GEARMAN_ERRNO;
+    }
 
-  {
-    int optval= 1;
-    ret= setsockopt(connection->fd, SOL_SOCKET, SO_KEEPALIVE, &optval, sizeof(optval));
+    ret= setsockopt(connection->fd, SOL_SOCKET, SO_RCVTIMEO, &waittime,
+                    socklen_t(sizeof(struct timeval)));
     if (ret == -1 && errno != ENOPROTOOPT)
     {
       gearman_perror(connection->universal, "setsockopt(SO_RCVTIMEO)");
@@ -1127,21 +1154,24 @@ static gearman_return_t _con_setsockopt(gearman_connection_st *connection)
     }
   }
 
-
-  ret= setsockopt(connection->fd, SOL_SOCKET, SO_RCVTIMEO, &waittime,
-                  socklen_t(sizeof(struct timeval)));
-  if (ret == -1 && errno != ENOPROTOOPT)
   {
-    gearman_perror(connection->universal, "setsockopt(SO_RCVTIMEO)");
-    return GEARMAN_ERRNO;
+    int optval= 1;
+    int ret= setsockopt(connection->fd, SOL_SOCKET, SO_KEEPALIVE, &optval, sizeof(optval));
+    if (ret == -1 && errno != ENOPROTOOPT)
+    {
+      gearman_perror(connection->universal, "setsockopt(SO_RCVTIMEO)");
+      return GEARMAN_ERRNO;
+    }
   }
 
-  ret= GEARMAN_DEFAULT_SOCKET_SEND_SIZE;
-  ret= setsockopt(connection->fd, SOL_SOCKET, SO_SNDBUF, &ret, socklen_t(sizeof(int)));
-  if (ret == -1)
   {
-    gearman_perror(connection->universal, "setsockopt(SO_SNDBUF)");
-    return GEARMAN_ERRNO;
+    int ret= GEARMAN_DEFAULT_SOCKET_SEND_SIZE;
+    ret= setsockopt(connection->fd, SOL_SOCKET, SO_SNDBUF, &ret, socklen_t(sizeof(int)));
+    if (ret == -1)
+    {
+      gearman_perror(connection->universal, "setsockopt(SO_SNDBUF)");
+      return GEARMAN_ERRNO;
+    }
   }
 
 #if defined(__MACH__) && defined(__APPLE__) || defined(__FreeBSD__)
@@ -1157,26 +1187,43 @@ static gearman_return_t _con_setsockopt(gearman_connection_st *connection)
   }
 #endif
 
-  ret= GEARMAN_DEFAULT_SOCKET_RECV_SIZE;
-  ret= setsockopt(connection->fd, SOL_SOCKET, SO_RCVBUF, &ret, socklen_t(sizeof(int)));
-  if (ret == -1)
   {
-    gearman_perror(connection->universal, "setsockopt(SO_RCVBUF)");
-    return GEARMAN_ERRNO;
+    int ret= GEARMAN_DEFAULT_SOCKET_RECV_SIZE;
+    ret= setsockopt(connection->fd, SOL_SOCKET, SO_RCVBUF, &ret, socklen_t(sizeof(int)));
+    if (ret == -1)
+    {
+      gearman_perror(connection->universal, "setsockopt(SO_RCVBUF)");
+      return GEARMAN_ERRNO;
+    }
   }
 
-  ret= fcntl(connection->fd, F_GETFL, 0);
-  if (ret == -1)
+  if (SOCK_NONBLOCK == 0)
   {
-    gearman_perror(connection->universal, "fcntl(F_GETFL)");
-    return GEARMAN_ERRNO;
-  }
+    int flags;
+    do
+    {
+      flags= fcntl(connection->fd, F_GETFL, 0);
+    } while (flags == -1 and (errno == EINTR or errno == EAGAIN));
 
-  ret= fcntl(connection->fd, F_SETFL, ret | O_NONBLOCK);
-  if (ret == -1)
-  {
-    gearman_perror(connection->universal, "fcntl(F_SETFL)");
-    return GEARMAN_ERRNO;
+    if (flags == -1)
+    {
+      gearman_perror(connection->universal, "fcntl(F_GETFL)");
+      return GEARMAN_ERRNO;
+    }
+    else if ((flags & O_NONBLOCK) == 0)
+    {
+      int retval;
+      do
+      {
+        retval= fcntl(connection->fd, F_SETFL, flags | O_NONBLOCK);
+      } while (retval == -1 and (errno == EINTR or errno == EAGAIN));
+
+      if (retval == -1)
+      {
+        gearman_perror(connection->universal, "fcntl(F_SETFL)");
+        return GEARMAN_ERRNO;
+      }
+    }
   }
 
   return GEARMAN_SUCCESS;

libgearman/pipe.cc

@@ -48,92 +48,94 @@
 #include <fcntl.h>
 #include <unistd.h>
 
+#ifndef FD_CLOEXEC
+# define FD_CLOEXEC 0
+#endif
+
+// This is not called if HAVE_PIPE2 is true
 static inline bool set_cloexec(int pipedes_[2], const size_t x)
 {
-  int returned_flags;
-  do 
+  if (FD_CLOEXEC)
   {
-    returned_flags= fcntl(pipedes_[x], F_GETFD, 0);
-  } while (returned_flags == -1 and (errno == EINTR or errno == EAGAIN));
+    int flags;
+    do 
+    {
+      flags= fcntl(pipedes_[x], F_GETFD, 0);
+    } while (flags == -1 and (errno == EINTR or errno == EAGAIN));
+
+    if (flags != -1)
+    {
+      int retval;
+      do
+      { 
+        retval= fcntl (pipedes_[x], F_SETFD, flags | FD_CLOEXEC);
+      } while (retval == -1 && (errno == EINTR or errno == EAGAIN));
+
+      if (retval != -1)
+      {
+        return true;
+      }
 
-  if (returned_flags == -1)
-  {
 #if 0
-    perror("fcntl(pipedes_[x], F_GETFD, 0)");
+      perror("fcntl(pipedes_[x], F_GETFD, 0)");
 #endif
-    return false;
-  }
-
-  int retval;
-  do
-  { 
-    retval= fcntl (pipedes_[x], F_SETFD, FD_CLOEXEC);
-  } while (retval == -1 && (errno == EINTR or errno == EAGAIN));
+      return false;
+    }
 
-  if (retval == -1)
-  {
 #if 0
     perror("fcntl (pipedes_[x], F_SETFD, FD_CLOEXEC)");
 #endif
-    return false;
   }
 
-  return true;
+  return false;
 }
 
+// This is not called if HAVE_PIPE2 is true
 static inline bool set_nonblock(int pipedes_[2], const size_t x)
 {
-  int returned_flags;
+  int flags;
   do 
   {
-    returned_flags= fcntl(pipedes_[x], F_GETFL, 0);
-  } while (returned_flags == -1 and (errno == EINTR or errno == EAGAIN));
+    flags= fcntl(pipedes_[x], F_GETFL, 0);
+  } while (flags == -1 and (errno == EINTR or errno == EAGAIN));
 
-  if (returned_flags == -1)
+  if (flags != -1)
   {
+    int retval;
+    do
+    {
+      retval= fcntl(pipedes_[x], F_SETFL, flags | O_NONBLOCK);
+    } while (retval == -1 and (errno == EINTR or errno == EAGAIN));
+
+    if (retval != -1)
+    {
+      return true;
+    }
 #if 0
-    perror("fcntl(pipedes_[x], F_GETFL, 0)");
+    perror("fcntl(pipedes_[x], F_SETFL, flags | O_NONBLOCK)");
 #endif
-    return false;
   }
 
-  int retval;
-  do
-  {
-    retval= fcntl(pipedes_[x], F_SETFL, returned_flags | O_NONBLOCK);
-  } while (retval == -1 and (errno == EINTR or errno == EAGAIN));
-
-  if (retval == -1)
-  {
 #if 0
-    perror("fcntl(pipedes_[x], F_SETFL, returned_flags | O_NONBLOCK)");
+  perror("fcntl(pipedes_[x], F_GETFL, 0)");
 #endif
-    return false;
-  }
 
-  return true;
+  return false;
 }
 
 bool setup_shutdown_pipe(int pipedes_[2])
 {
-  if (HAVE_PIPE2)
-  {
 #if defined(HAVE_PIPE2) && HAVE_PIPE2
-    if (pipe2(pipedes_, O_NONBLOCK|O_CLOEXEC) == -1)
-    {
-      return false;
-    }
-#else
-    assert(0); // This should never be reached
-#endif
+  if (pipe2(pipedes_, O_NONBLOCK|O_CLOEXEC) == -1)
+  {
+    return false;
   }
-  else if (pipe(pipedes_) == -1)
+#else
+  if (pipe(pipedes_) == -1)
   {
-#if 0
-    perror("pipe");
-#endif
     return false;
   }
+#endif
 
   for (size_t x= 0; x < 2; ++x)
   {

libgearman/universal.cc

@@ -324,7 +324,8 @@ gearman_return_t gearman_wait(gearman_universal_st& universal)
 
   if (ret == 0)
   {
-    gearman_error(universal, GEARMAN_TIMEOUT, "timeout reached, no servers were available");
+    gearman_universal_set_error(universal, GEARMAN_TIMEOUT, GEARMAN_AT, "timeout reached, %u servers were poll(), no servers were available, pipe:%s",
+                                uint32_t(x), have_shutdown_pipe ? "true" : "false");
     return GEARMAN_TIMEOUT;
   }
 

libtest/cmdline.cc

@@ -59,6 +59,10 @@ using namespace libtest;
 static char **environ= NULL;
 #endif
 
+#ifndef FD_CLOEXEC
+# define FD_CLOEXEC 0
+#endif
+
 extern "C" {
   static int exited_successfully(int status)
   {
@@ -643,17 +647,34 @@ void Application::Pipe::reset()
 
 void Application::Pipe::cloexec()
 {
-  int ret;
-  if ((ret= fcntl(_pipe_fd[WRITE], F_GETFD, 0)) == -1)
+  //if (SOCK_CLOEXEC == 0)
   {
-    Error << "fcntl(F_GETFD) " << strerror(errno);
-    throw strerror(errno);
-  }
+    if (FD_CLOEXEC) 
+    {
+      int flags;
+      do 
+      {
+        flags= fcntl(_pipe_fd[WRITE], F_GETFD, 0);
+      } while (flags == -1 and (errno == EINTR or errno == EAGAIN));
 
-  if ((ret= fcntl(_pipe_fd[WRITE], F_SETFD, ret | FD_CLOEXEC)) == -1)
-  {
-    Error << "fcntl(F_SETFD) " << strerror(errno);
-    throw strerror(errno);
+      if (flags == -1)
+      {
+        Error << "fcntl(F_GETFD) " << strerror(errno);
+        throw strerror(errno);
+      }
+
+      int rval;
+      do
+      { 
+        rval= fcntl(_pipe_fd[WRITE], F_SETFD, flags | FD_CLOEXEC);
+      } while (rval == -1 && (errno == EINTR or errno == EAGAIN));
+
+      if (rval == -1)
+      {
+        Error << "fcntl(F_SETFD) " << strerror(errno);
+        throw strerror(errno);
+      }
+    }
   }
 }
 

libtest/gearmand.cc

@@ -76,10 +76,10 @@ public:
     gearman_client_st *client= gearman_client_create(NULL);
     if (client == NULL)
     {
-      Error << "Could not allocate memory for gearman_client_create()";
+      error("Could not allocate memory for gearman_client_create()");
       return false;
     }
-    gearman_client_set_timeout(client, 3000);
+    gearman_client_set_timeout(client, 4000);
 
     if (gearman_success(gearman_client_add_server(client, hostname().c_str(), port())))
     {
@@ -93,12 +93,12 @@ public:
       
       if (out_of_ban_killed() == false)
       {
-        Error << hostname().c_str() << ":" << port() << " " << gearman_client_error(client);
+        error(gearman_client_error(client));
       }
     }
     else
     {
-      Error << "gearman_client_add_server() " << gearman_client_error(client);
+      error(gearman_client_error(client));
     }
 
     gearman_client_free(client);

libtest/port.cc

@@ -122,8 +122,19 @@ in_port_t get_free_port()
 
   while (--retries)
   {
+    int type= SOCK_STREAM;
+    if (SOCK_CLOEXEC)
+    {
+      type|= SOCK_CLOEXEC;
+    }
+
+    if (SOCK_NONBLOCK)
+    {
+      type|= SOCK_NONBLOCK; 
+    }
+
     int sd;
-    if ((sd= socket(AF_INET, SOCK_STREAM, 0)) != -1)
+    if ((sd= socket(AF_INET, type, 0)) != -1)
     {
       int optval= 1;
       if (setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) != -1)