Fix for fork test.

.bzrignore

@@ -119,3 +119,4 @@ tmp_chroot
 tests/protocol
 libgearman/command.hpp
 libgearman/error_code.hpp
+TAGS

configure.ac

@@ -224,7 +224,15 @@ AC_CHECK_LIB([rt],[clock_gettime],
 LT_LIB_M
 
 # Check for CyaSSL
-AX_CHECK_LIBRARY([CYASSL],[cyassl/ssl.h],[cyassl])
+AC_DEFUN([AX_ENABLE_SSL],
+         [AC_PREREQ([2.63])dnl
+         AC_ARG_ENABLE([SSL],
+                       [AS_HELP_STRING([--enable-ssl],
+                                       [Enable ssl support for Gearman --enable-debug (yes|no) @<:@default=no@:>@])],
+                                       [AX_CHECK_LIBRARY([CYASSL],[cyassl/ssl.h],[cyassl])],
+                                       [AC_MSG_WARN([ssl will not be enabled])])
+         ])
+AX_ENABLE_SSL
 #AC_SUBST([CYASSL])
 #AC_SUBST([CYASSL_LIB])
 AX_ENABLE_LIBMEMCACHED
@@ -289,6 +297,7 @@ echo "   * Building with libmemcached $ax_enable_libmemcached"
 echo "   * Building with libpq        $ac_cv_libpq"
 echo "   * Building with tokyocabinet $ac_enable_libtokyocabinet"
 echo "   * Building with libmysql     $found_mysql"
+echo "   * SSL enabled:               $enable_SSL"
 echo "   * make -j:                   $enable_jobserver"
 echo "   * VCS checkout:              $ac_cv_vcs_checkout"
 echo ""

libgearman-server/plugins/protocol/gear/protocol.cc

@@ -230,7 +230,7 @@ public:
       }
     }
 
-    if (packet->command == GEARMAN_COMMAND_ECHO_RES)
+    if (packet->command == GEARMAN_COMMAND_ECHO_RES or packet->command == GEARMAN_COMMAND_ECHO_REQ)
     {
       gearmand_log_debug(GEARMAN_DEFAULT_LOG_PARAM,
                          "GEAR length: %" PRIu64 " gearmand_command_t: %s echo: %.*s",

libgearman/check.cc

@@ -41,6 +41,8 @@
 
 #include "libgearman/error_code.h"
 
+#include <algorithm>
+
 EchoCheck::EchoCheck(gearman_universal_st& universal_,
     const void *workload_, const size_t workload_size_) :
     _universal(universal_),
@@ -56,10 +58,29 @@ gearman_return_t EchoCheck::success(gearman_connection_st* con)
     return gearman_error(_universal, GEARMAN_INVALID_COMMAND, "Wrong command sent in response to ECHO request");
   }
 
-  if (con->_packet.data_size != _workload_size or
-      memcmp(_workload, con->_packet.data, _workload_size))
+  size_t compared= std::min(con->_packet.size(), _workload_size);
+
+  if (compared != _workload_size or compared != con->_packet.size())
+  {
+    // If the workload_size is smaller
+    if (memcmp(_workload, con->_packet.value(), compared) == 0)
+    {
+      return gearman_universal_set_error(_universal, GEARMAN_ECHO_DATA_CORRUPTION, GEARMAN_AT,
+                                         "Truncation occured, Expected %u, received %u",
+                                         uint32_t(_workload_size), uint32_t(con->_packet.data_size));
+    }
+
+    return gearman_universal_set_error(_universal, GEARMAN_ECHO_DATA_CORRUPTION, GEARMAN_AT,
+                                       "Expected data was not received, expected %u, received %u",
+                                       uint32_t(_workload_size), uint32_t(con->_packet.data_size));
+  }
+  assert(compared == _workload_size);
+
+  if (memcmp(_workload, con->_packet.value(), compared))
   {
-    return gearman_error(_universal, GEARMAN_ECHO_DATA_CORRUPTION, "corruption during echo");
+    return gearman_universal_set_error(_universal, GEARMAN_ECHO_DATA_CORRUPTION, GEARMAN_AT,
+                                       "Data sent was not what was received %u == %u == %u",
+                                       uint32_t(_workload_size), uint32_t(con->_packet.data_size), uint32_t(compared));
   }
 
   return GEARMAN_SUCCESS;

libgearman/connection.cc

@@ -433,8 +433,10 @@ gearman_return_t gearman_connection_st::send_packet(const gearman_packet_st& pac
 
       if (gearman_failed(ret))
       {
+        assert(universal.error_code());
+        assert(universal.error());
         gearman_packet_free(&message);
-        return gearman_error(universal, GEARMAN_MEMORY_ALLOCATION_FAILURE, "gearman_packet_create_args()");
+        return universal.error_code();
       }
 
       PUSH_BLOCKING(universal);
@@ -442,8 +444,10 @@ gearman_return_t gearman_connection_st::send_packet(const gearman_packet_st& pac
       ret= _send_packet(message, true);
       if (gearman_failed(ret))
       {
+        assert(universal.error_code());
+        assert(universal.error());
         gearman_packet_free(&message);
-        return gearman_error(universal, ret, "Failed to send server-options packet");
+        return universal.error_code();
       }
 
       options.packet_in_use= true;
@@ -718,7 +722,7 @@ gearman_return_t gearman_connection_st::flush()
         {
           type|= SOCK_NONBLOCK; 
         }
-
+        
         fd= socket(addrinfo_next->ai_family, type, addrinfo_next->ai_protocol);
       }
 
@@ -946,11 +950,12 @@ gearman_packet_st *gearman_connection_st::receiving(gearman_packet_st& packet_ar
       return NULL;
     }
 
+    // This should not fail
     _recv_packet= gearman_packet_create(universal, packet_arg);
     assert(_recv_packet == &packet_arg);
     if (_recv_packet == NULL)
     {
-      ret= gearman_error(universal, GEARMAN_MEMORY_ALLOCATION_FAILURE, "gearman_packet_create()");
+      ret= gearman_error(universal, GEARMAN_MEMORY_ALLOCATION_FAILURE, "Programmer error, gearman_packet_create() failed which should not be possible");
       return NULL;
     }
 
@@ -974,6 +979,7 @@ gearman_packet_st *gearman_connection_st::receiving(gearman_packet_st& packet_ar
         }
         else if (ret != GEARMAN_IO_WAIT)
         {
+          assert(universal.error_code());
           close_socket();
           return NULL;
         }
@@ -1025,8 +1031,8 @@ gearman_packet_st *gearman_connection_st::receiving(gearman_packet_st& packet_ar
     while (recv_data_size)
     {
       (void)receive_data(static_cast<uint8_t *>(const_cast<void *>(packet_arg.data)) +
-                      recv_data_offset,
-                      packet_arg.data_size -recv_data_offset, ret);
+                         recv_data_offset,
+                         packet_arg.data_size -recv_data_offset, ret);
       if (gearman_failed(ret))
       {
         return NULL;

libgearman/error.cc

@@ -48,6 +48,9 @@
 #include <cstdio>
 #include <cstring>
 
+#include <sys/types.h>
+#include <unistd.h>
+
 static void correct_from_errno(gearman_universal_st& universal)
 {
   if (universal.error_code() == GEARMAN_ERRNO)
@@ -93,9 +96,9 @@ gearman_return_t gearman_universal_set_error(gearman_universal_st& universal,
                                              const char *position,
                                              const char *format, ...)
 {
-  if (rc == GEARMAN_SUCCESS)
+  if (rc == GEARMAN_SUCCESS or rc == GEARMAN_IO_WAIT)
   {
-    return GEARMAN_SUCCESS;
+    return universal._error.rc= rc;
   }
 
   va_list args;
@@ -115,7 +118,8 @@ gearman_return_t gearman_universal_set_error(gearman_universal_st& universal,
     universal._error.last_error[GEARMAN_MAX_ERROR_SIZE -1]= 0;
   }
 
-  length= snprintf(universal._error.last_error, GEARMAN_MAX_ERROR_SIZE, "%s(%s) %s -> %s", function, gearman_strerror(universal._error.rc), last_error, position);
+  length= snprintf(universal._error.last_error, GEARMAN_MAX_ERROR_SIZE, "%s(%s) %s -> %s pid(%u)", 
+                   function, gearman_strerror(universal._error.rc), last_error, position, getpid());
   if (length > int(GEARMAN_MAX_ERROR_SIZE) or length < 0)
   {
     assert(length > int(GEARMAN_MAX_ERROR_SIZE));
@@ -139,19 +143,19 @@ gearman_return_t gearman_universal_set_gerror(gearman_universal_st& universal,
 {
   if (rc == GEARMAN_SUCCESS or rc == GEARMAN_IO_WAIT)
   {
-    return rc;
+    return universal._error.rc= rc;
   }
 
   universal._error.rc= rc;
   correct_from_errno(universal);
 
-  int length= snprintf(universal._error.last_error, GEARMAN_MAX_ERROR_SIZE, "%s(%s) -> %s", func, gearman_strerror(rc), position);
+  int length= snprintf(universal._error.last_error, GEARMAN_MAX_ERROR_SIZE, "%s(%s) -> %s pid(%u)",
+                       func, gearman_strerror(rc), position, getpid());
   if (length > int(GEARMAN_MAX_ERROR_SIZE) or length < 0)
   {
     assert(length > int(GEARMAN_MAX_ERROR_SIZE));
     assert(length < 0);
     universal._error.last_error[GEARMAN_MAX_ERROR_SIZE -1]= 0;
-    return GEARMAN_ARGUMENT_TOO_LARGE;
   }
 
   gearman_log_error(universal,
@@ -200,11 +204,11 @@ gearman_return_t gearman_universal_set_perror(gearman_universal_st &universal,
   int length;
   if (message)
   {
-    length= snprintf(universal._error.last_error, GEARMAN_MAX_ERROR_SIZE, "%s(%s) %s -> %s", function, errmsg_ptr, message, position);
+    length= snprintf(universal._error.last_error, GEARMAN_MAX_ERROR_SIZE, "%s(%s) %s -> %s pid(%d)", function, errmsg_ptr, message, position, getpid());
   }
   else
   {
-    length= snprintf(universal._error.last_error, GEARMAN_MAX_ERROR_SIZE, "%s(%s) -> %s", function, errmsg_ptr, position);
+    length= snprintf(universal._error.last_error, GEARMAN_MAX_ERROR_SIZE, "%s(%s) -> %s pid(%d)", function, errmsg_ptr, position, getpid());
   }
 
   if (length > int(GEARMAN_MAX_ERROR_SIZE) or length < 0)

libgearman/interface/packet.hpp

@@ -102,7 +102,12 @@ struct gearman_packet_st
     return false;
   }
 
-  const char* value(size_t& length_)
+  size_t size() const
+  {
+    return data_size;
+  }
+
+  const char* value(size_t& length_) const
   {
     length_= data_size;
 
@@ -114,6 +119,16 @@ struct gearman_packet_st
     return NULL;
   }
 
+  const char* value() const
+  {
+    if (data_size)
+    {
+      return (const char*)data;
+    }
+
+    return NULL;
+  }
+
   void reset()
   {
     if (args != args_buffer and args)

libgearman/packet.cc

@@ -383,8 +383,7 @@ gearman_return_t gearman_packet_unpack_header(gearman_packet_st *packet)
   if (packet->command == GEARMAN_COMMAND_TEXT ||
       packet->command >= GEARMAN_COMMAND_MAX)
   {
-    gearman_error(*packet->universal, GEARMAN_INVALID_COMMAND, "invalid command value");
-    return GEARMAN_INVALID_COMMAND;
+    return gearman_error(*packet->universal, GEARMAN_INVALID_COMMAND, "invalid command value");
   }
 
   memcpy(&tmp, packet->args + 8, 4);

libgearman/universal.cc

@@ -362,7 +362,7 @@ gearman_return_t gearman_wait(gearman_universal_st& universal)
       gearman_return_t local_ret= gearman_kill(gearman_universal_id(universal), GEARMAN_INTERRUPT);
       if (gearman_failed(local_ret))
       {
-        return GEARMAN_SHUTDOWN;
+        return gearman_gerror(universal, GEARMAN_SHUTDOWN);
       }
 
       return GEARMAN_SHUTDOWN_GRACEFUL;
@@ -370,7 +370,7 @@ gearman_return_t gearman_wait(gearman_universal_st& universal)
 
     if (read_length == 0)
     {
-      return GEARMAN_SHUTDOWN;
+      return gearman_gerror(universal, GEARMAN_SHUTDOWN);
     }
 
 #if 0
@@ -542,7 +542,10 @@ static gearman_return_t connection_loop(gearman_universal_st& universal,
     gearman_packet_st *packet_ptr= con->receiving(con->_packet, ret, true);
     if (packet_ptr == NULL)
     {
-      assert(&con->_packet == universal.packet_list);
+      if (ret != GEARMAN_NOT_CONNECTED and ret != GEARMAN_LOST_CONNECTION)
+      {
+        assert(&con->_packet == universal.packet_list);
+      }
       con->options.packet_in_use= false;
       break;
     }

libtest/run.gdb

@@ -2,6 +2,7 @@ set logging on
 set logging overwrite on
 set environment LIBTEST_IN_GDB=1
 #set ASAN_OPTIONS=abort_on_error=1
+set detach-on-fork on
 handle SIGVTALRM stop
 run
 thread apply all bt