Merge lp:~eday/gearmand/fixes into lp:gearmand/1.0

[Eric Day]

[lp:~eday/gearmand/fixes]

251. By Eric Day on 2009-11-04

Removed va_args packet add function, replaced with array passing.

252. By Eric Day on 2009-11-30

Merged trunk.

253. By Eric Day on 2009-11-30

Updated ChangeLog

254. By Eric Day on 2009-12-02

Small fixes for release while working with Monty on packaging.

255. By Eric Day on 2009-12-16

Fixed job handle compare for work_fail bug, added test case.

256. By Eric Day on 2009-12-18

Merged Monty's build fixes.

Unmerged revisions

=== modified file 'ChangeLog'
--- ChangeLog	2009-09-28 17:47:34 +0000
+++ ChangeLog	2009-11-04 22:14:13 +0000
@@ -1,3 +1,11 @@
+0.11 - 2009-11-03
+ * Added max wakeup-worker option to gearmand. Default is still to wakeup all.
+ * API and documentation cleanup.
+ * Fixed bug where task context free function was getting called for do()
+   functions. This was PECL/Gearman bug #16899 as well.
+ * Fixed bug #458912, not flushing with multiple gearmands in client.
+ * Fixed PECL/Gearman bug #16847, was actually in C library and not in PHP.
+
 0.10 - 2009-09-28
  * Added timeout option.
  * Separated libgearman client/worker library from the server/gearmand code.
 
=== modified file 'benchmark/blobslap_worker.c'
--- benchmark/blobslap_worker.c	2009-06-14 07:26:30 +0000
+++ benchmark/blobslap_worker.c	2009-11-04 22:14:13 +0000
@@ -13,8 +13,8 @@
 
 #include "benchmark.h"
 
-static void *worker_fn(gearman_job_st *job, void *cb_arg, size_t *result_size,
-                       gearman_return_t *ret_ptr);
+static void *worker_fn(gearman_job_st *job, void *context,
+                       size_t *result_size, gearman_return_t *ret_ptr);
 
 static void usage(char *name);
 
@@ -130,10 +130,10 @@
   return 0;
 }
 
-static void *worker_fn(gearman_job_st *job, void *cb_arg, size_t *result_size,
-                       gearman_return_t *ret_ptr)
+static void *worker_fn(gearman_job_st *job, void *context,
+                       size_t *result_size, gearman_return_t *ret_ptr)
 {
-  gearman_benchmark_st *benchmark= (gearman_benchmark_st *)cb_arg;
+  gearman_benchmark_st *benchmark= (gearman_benchmark_st *)context;
 
   (void)result_size;
 
 
=== modified file 'bin/gearman.c'
--- bin/gearman.c	2009-09-28 17:47:34 +0000
+++ bin/gearman.c	2009-11-04 22:14:13 +0000
@@ -92,8 +92,8 @@
 /**
  * Callback function when worker gets a job.
  */
-static void *_worker_cb(gearman_job_st *job, void *cb_arg, size_t *result_size,
-                        gearman_return_t *ret_ptr);
+static void *_worker_cb(gearman_job_st *job, void *context,
+                        size_t *result_size, gearman_return_t *ret_ptr);
 
 /**
  * Read workload chunk from a file descriptor and put into allocated memory.
@@ -460,10 +460,10 @@
   gearman_worker_free(&worker);
 }
 
-static void *_worker_cb(gearman_job_st *job, void *cb_arg, size_t *result_size,
-                        gearman_return_t *ret_ptr)
+static void *_worker_cb(gearman_job_st *job, void *context,
+                        size_t *result_size, gearman_return_t *ret_ptr)
 {
-  gearman_args_st *args= (gearman_args_st *)cb_arg;
+  gearman_args_st *args= (gearman_args_st *)context;
   int in_fds[2];
   int out_fds[2];
   char *result= NULL;
 
=== modified file 'configure.ac'
--- configure.ac	2009-09-30 06:07:17 +0000
+++ configure.ac	2009-11-04 22:14:13 +0000
@@ -6,7 +6,7 @@
 # the COPYING file in this directory for full text.
 
 AC_PREREQ(2.59)
-AC_INIT([gearmand],[0.10],[https://launchpad.net/gearmand])
+AC_INIT([gearmand],[0.11],[https://launchpad.net/gearmand])
 AC_CONFIG_SRCDIR(libgearman/gearman.c)
 AC_CONFIG_AUX_DIR(config)
 AC_CONFIG_HEADERS([config.h])
@@ -14,7 +14,7 @@
 
 PANDORA_CANONICAL_TARGET(require-cxx)
 
-GEARMAN_LIBRARY_VERSION=2:0:0
+GEARMAN_LIBRARY_VERSION=2:1:0
 #                       | | |
 #                +------+ | +---+
 #                |        |     |
@@ -28,7 +28,7 @@
 #                +- increment if interfaces have been added, removed or changed
 AC_SUBST(GEARMAN_LIBRARY_VERSION)
 
-GEARMAN_SERVER_LIBRARY_VERSION=0:0:0
+GEARMAN_SERVER_LIBRARY_VERSION=0:1:0
 #                              | | |
 #                       +------+ | +---+
 #                       |        |     |
 
=== modified file 'docs/Doxyfile.api'
--- docs/Doxyfile.api	2009-09-25 00:04:06 +0000
+++ docs/Doxyfile.api	2009-11-04 22:14:13 +0000
@@ -534,7 +534,35 @@
 # directories like "/usr/src/myproject". Separate the files or directories 
 # with spaces.
 
-INPUT                  = docs libgearman libgearman-server examples examples/reverse_client.c examples/reverse_client_bg.c examples/reverse_client_cb.c examples/reverse_worker.c
+INPUT                  = docs/doxygen.h \
+                         libgearman/constants.h \
+                         libgearman/client.h \
+                         libgearman/task.h \
+                         libgearman/worker.h \
+                         libgearman/job.h \
+                         libgearman/gearman.h \
+                         libgearman/conn.h \
+                         libgearman/packet.h \
+                         libgearman-server/constants.h \
+                         libgearman-server/client.h \
+                         libgearman-server/conf.h \
+                         libgearman-server/conf_module.h \
+                         libgearman-server/conn.h \
+                         libgearman-server/function.h \
+                         libgearman-server/job.h \
+                         libgearman-server/packet.h \
+                         libgearman-server/server.h \
+                         libgearman-server/thread.h \
+                         libgearman-server/worker.h \
+                         libgearman-server/protocol_http.h \
+                         libgearman-server/queue_libdrizzle.h \
+                         libgearman-server/queue_libmemcached.h \
+                         libgearman-server/queue_libpq.h \
+                         libgearman-server/queue_libsqlite3.h \
+                         libgearman-server/gearmand.h \
+                         libgearman-server/gearmand_con.h \
+                         libgearman-server/gearmand_thread.h \
+                         examples
 
 # This tag can be used to specify the character encoding of the source files 
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is 
@@ -551,7 +579,7 @@
 # *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx 
 # *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90
 
-FILE_PATTERNS          = *.h
+FILE_PATTERNS          = *.h *.c
 
 # The RECURSIVE tag can be used to turn specify whether or not subdirectories 
 # should be searched for input files as well. Possible values are YES and NO. 
@@ -563,7 +591,7 @@
 # excluded from the INPUT source files. This way you can easily exclude a 
 # subdirectory from a directory tree whose root is specified with the INPUT tag.
 
-EXCLUDE                = libgearman/common.h libgearman/structs.h libgearman-server/common.h libgearman-server/structs.h
+EXCLUDE                = 
 
 # The EXCLUDE_SYMLINKS tag can be used select whether or not files or 
 # directories that are symbolic links (a Unix filesystem feature) are excluded 
@@ -747,7 +775,7 @@
 # each generated HTML page. If it is left blank doxygen will generate a 
 # standard footer.
 
-HTML_FOOTER            =
+HTML_FOOTER            = 
 
 # The HTML_STYLESHEET tag can be used to specify a user-defined cascading 
 # style sheet that is used by each HTML page. It can be used to 
 
=== modified file 'docs/Doxyfile.dev'
--- docs/Doxyfile.dev	2009-09-25 00:04:06 +0000
+++ docs/Doxyfile.dev	2009-11-04 22:14:13 +0000
@@ -534,7 +534,37 @@
 # directories like "/usr/src/myproject". Separate the files or directories 
 # with spaces.
 
-INPUT                  = docs libgearman libgearman-server examples
+INPUT                  = docs/doxygen.h \
+                         libgearman/constants.h \
+                         libgearman/client.h \
+                         libgearman/task.h \
+                         libgearman/worker.h \
+                         libgearman/job.h \
+                         libgearman/gearman.h \
+                         libgearman/conn.h \
+                         libgearman/packet.h \
+                         libgearman \
+                         libgearman-server/constants.h \
+                         libgearman-server/client.h \
+                         libgearman-server/conf.h \
+                         libgearman-server/conf_module.h \
+                         libgearman-server/conn.h \
+                         libgearman-server/function.h \
+                         libgearman-server/job.h \
+                         libgearman-server/packet.h \
+                         libgearman-server/server.h \
+                         libgearman-server/thread.h \
+                         libgearman-server/worker.h \
+                         libgearman-server/protocol_http.h \
+                         libgearman-server/queue_libdrizzle.h \
+                         libgearman-server/queue_libmemcached.h \
+                         libgearman-server/queue_libpq.h \
+                         libgearman-server/queue_libsqlite3.h \
+                         libgearman-server/gearmand.h \
+                         libgearman-server/gearmand_con.h \
+                         libgearman-server/gearmand_thread.h \
+                         libgearman-server \
+                         examples
 
 # This tag can be used to specify the character encoding of the source files 
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is 
 
=== modified file 'examples/reverse_worker.c'
--- examples/reverse_worker.c	2009-09-28 17:47:34 +0000
+++ examples/reverse_worker.c	2009-11-04 22:14:13 +0000
@@ -27,8 +27,8 @@
   REVERSE_WORKER_OPTIONS_UNIQUE= (1 << 2)
 } reverse_worker_options_t;
 
-static void *reverse(gearman_job_st *job, void *cb_arg, size_t *result_size,
-                     gearman_return_t *ret_ptr);
+static void *reverse(gearman_job_st *job, void *context,
+                     size_t *result_size, gearman_return_t *ret_ptr);
 
 static void usage(char *name);
 
@@ -136,10 +136,10 @@
   return 0;
 }
 
-static void *reverse(gearman_job_st *job, void *cb_arg, size_t *result_size,
-                     gearman_return_t *ret_ptr)
+static void *reverse(gearman_job_st *job, void *context,
+                     size_t *result_size, gearman_return_t *ret_ptr)
 {
-  reverse_worker_options_t options= *((reverse_worker_options_t *)cb_arg);
+  reverse_worker_options_t options= *((reverse_worker_options_t *)context);
   const uint8_t *workload;
   uint8_t *result;
   size_t x;
 
=== modified file 'examples/wc_worker.c'
--- examples/wc_worker.c	2009-06-14 07:26:30 +0000
+++ examples/wc_worker.c	2009-11-04 22:14:14 +0000
@@ -19,7 +19,7 @@
 
 #include <libgearman/gearman.h>
 
-static void *wc(gearman_job_st *job, void *cb_arg, size_t *result_size,
+static void *wc(gearman_job_st *job, void *context, size_t *result_size,
                 gearman_return_t *ret_ptr);
 
 static void usage(char *name);
@@ -97,14 +97,14 @@
   return 0;
 }
 
-static void *wc(gearman_job_st *job, void *cb_arg, size_t *result_size,
+static void *wc(gearman_job_st *job, void *context, size_t *result_size,
                 gearman_return_t *ret_ptr)
 {
   const uint8_t *workload;
   uint8_t *result;
   size_t x;
   uint64_t count= 0;
-  (void)cb_arg;
+  (void)context;
 
   workload= gearman_job_workload(job);
   *result_size= gearman_job_workload_size(job);
 
=== modified file 'gearmand/gearmand.c'
--- gearmand/gearmand.c	2009-09-24 23:43:15 +0000
+++ gearmand/gearmand.c	2009-11-04 22:14:14 +0000
@@ -102,6 +102,7 @@
   int backlog= GEARMAND_LISTEN_BACKLOG;
   rlim_t fds= 0;
   uint8_t job_retries= 0;
+  uint8_t worker_wakeup= 0;
   in_port_t port= 0;
   const char *host= NULL;
   const char *pid_file= NULL;
@@ -157,6 +158,9 @@
   MCO("user", 'u', "USER", "Switch to given user after startup.")
   MCO("verbose", 'v', NULL, "Increase verbosity level by one.")
   MCO("version", 'V', NULL, "Display the version of gearmand and exit.")
+  MCO("worker-wakeup", 'w', "WORKERS",
+      "Number of workers to wakeup for each job received. The default is to "
+      "wakeup all avaiable workers.")
 
   /* Make sure none of the gearman_conf_module_add_option calls failed. */
   if (gearman_conf_return(&conf) != GEARMAN_SUCCESS)
@@ -280,6 +284,8 @@
       verbose++;
     else if (!strcmp(name, "version"))
       printf("\ngearmand %s - %s\n", gearman_version(), gearman_bugreport());
+    else if (!strcmp(name, "worker-wakeup"))
+      worker_wakeup= (uint8_t)atoi(value);
     else
     {
       fprintf(stderr, "gearmand: Unknown option:%s\n", name);
@@ -331,6 +337,7 @@
   gearmand_set_backlog(_gearmand, backlog);
   gearmand_set_threads(_gearmand, threads);
   gearmand_set_job_retries(_gearmand, job_retries);
+  gearmand_set_worker_wakeup(_gearmand, worker_wakeup);
   gearmand_set_log_fn(_gearmand, _log, &log_info, verbose);
 
   if (queue_type != NULL)
 
=== modified file 'libgearman-server/client.h'
--- libgearman-server/client.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/client.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Server client declarations
+ * @brief Client Declarations
  */
 
 #ifndef __GEARMAN_SERVER_CLIENT_H__
@@ -19,10 +19,12 @@
 #endif
 
 /**
- * @addtogroup gearman_server_client Server Client Handling
+ * @addtogroup gearman_server_client Client Declarations
  * @ingroup gearman_server
+ *
  * This is a low level interface for gearman server clients. This is used
  * internally by the server interface, so you probably want to look there first.
+ *
  * @{
  */
 
 
=== modified file 'libgearman-server/common.h'
--- libgearman-server/common.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/common.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief System include files
+ * @brief System Include Files
  */
 
 #ifndef __GEARMAN_SERVER_COMMON_H__
@@ -106,8 +106,10 @@
  * Macro to log fatal errors.
  * @ingroup gearman_constants
  */
-#define GEARMAN_FATAL(__gearman, ...) \
-  GEARMAN_LOG(__gearman, GEARMAN_VERBOSE_FATAL, __VA_ARGS__)
+#define GEARMAN_FATAL(__gearman, ...) { \
+  unlikely ((__gearman)->verbose >= GEARMAN_VERBOSE_FATAL) \
+    GEARMAN_LOG(__gearman, GEARMAN_VERBOSE_FATAL, __VA_ARGS__) \
+}
 #define GEARMAN_SERVER_FATAL(__server, ...) \
   GEARMAN_FATAL((__server)->gearman, __VA_ARGS__)
 
 
=== modified file 'libgearman-server/conf.h'
--- libgearman-server/conf.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/conf.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Gearman conf declarations
+ * @brief Configuration Declarations
  */
 
 #ifndef __GEARMAN_SERVER_CONF_H__
@@ -19,7 +19,8 @@
 #endif
 
 /**
- * @addtogroup gearman_conf Gearman Conf Interface
+ * @addtogroup gearman_conf Configuration Declarations
+ * @ingroup gearman_server
  * @{
  */
 
 
=== modified file 'libgearman-server/conf_module.h'
--- libgearman-server/conf_module.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/conf_module.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Gearman conf module declarations
+ * @brief Configuration Module Declarations
  */
 
 #ifndef __GEARMAN_SERVER_CONF_MODULE_H__
@@ -19,7 +19,8 @@
 #endif
 
 /**
- * @addtogroup gearman_conf_module Gearman conf module interface
+ * @addtogroup gearman_conf_module Configuration Module Declarations
+ * @ingroup gearman_server
  * @{
  */
 
 
=== modified file 'libgearman-server/conn.c'
--- libgearman-server/conn.c	2009-09-24 23:43:15 +0000
+++ libgearman-server/conn.c	2009-11-04 22:14:14 +0000
@@ -66,7 +66,7 @@
     }
   }
 
-  if (gearman_con_create(thread->gearman, &(con->con)) == NULL)
+  if (gearman_add_con(thread->gearman, &(con->con)) == NULL)
   {
     free(con);
     return NULL;
 
=== modified file 'libgearman-server/conn.h'
--- libgearman-server/conn.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/conn.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Server connection declarations
+ * @brief Connection Declarations
  */
 
 #ifndef __GEARMAN_SERVER_CON_H__
@@ -19,10 +19,12 @@
 #endif
 
 /**
- * @addtogroup gearman_server_con Server Connection Handling
+ * @addtogroup gearman_server_con Connection Declarations
  * @ingroup gearman_server
+ *
  * This is a low level interface for gearman server connections. This is used
  * internally by the server interface, so you probably want to look there first.
+ *
  * @{
  */
 
 
=== modified file 'libgearman-server/constants.h'
--- libgearman-server/constants.h	2009-09-25 00:04:06 +0000
+++ libgearman-server/constants.h	2009-11-04 22:14:14 +0000
@@ -19,7 +19,8 @@
 #endif
 
 /**
- * @addtogroup gearman_server_constants Gearman Server Constants
+ * @addtogroup gearman_server_constants Constants
+ * @ingroup gearman_server
  * @{
  */
 
@@ -38,23 +39,6 @@
 #define GEARMAN_CONF_MAX_OPTION_SHORT 128
 #define GEARMAN_CONF_DISPLAY_WIDTH 80
 
-/* Types. */
-typedef struct gearman_server_st gearman_server_st;
-typedef struct gearman_server_thread_st gearman_server_thread_st;
-typedef struct gearman_server_con_st gearman_server_con_st;
-typedef struct gearman_server_packet_st gearman_server_packet_st;
-typedef struct gearman_server_function_st gearman_server_function_st;
-typedef struct gearman_server_client_st gearman_server_client_st;
-typedef struct gearman_server_worker_st gearman_server_worker_st;
-typedef struct gearman_server_job_st gearman_server_job_st;
-typedef struct gearmand_st gearmand_st;
-typedef struct gearmand_port_st gearmand_port_st;
-typedef struct gearmand_con_st gearmand_con_st;
-typedef struct gearmand_thread_st gearmand_thread_st;
-typedef struct gearman_conf_st gearman_conf_st;
-typedef struct gearman_conf_option_st gearman_conf_option_st;
-typedef struct gearman_conf_module_st gearman_conf_module_st;
-
 /** @} */
 
 /**
@@ -180,10 +164,28 @@
 
 
 /**
- * @addtogroup gearman_server_constants Gearman Server Constants
+ * @addtogroup gearman_server_types Types
+ * @ingroup gearman_server
  * @{
  */
 
+/* Types. */
+typedef struct gearman_server_st gearman_server_st;
+typedef struct gearman_server_thread_st gearman_server_thread_st;
+typedef struct gearman_server_con_st gearman_server_con_st;
+typedef struct gearman_server_packet_st gearman_server_packet_st;
+typedef struct gearman_server_function_st gearman_server_function_st;
+typedef struct gearman_server_client_st gearman_server_client_st;
+typedef struct gearman_server_worker_st gearman_server_worker_st;
+typedef struct gearman_server_job_st gearman_server_job_st;
+typedef struct gearmand_st gearmand_st;
+typedef struct gearmand_port_st gearmand_port_st;
+typedef struct gearmand_con_st gearmand_con_st;
+typedef struct gearmand_thread_st gearmand_thread_st;
+typedef struct gearman_conf_st gearman_conf_st;
+typedef struct gearman_conf_option_st gearman_conf_option_st;
+typedef struct gearman_conf_module_st gearman_conf_module_st;
+
 /* Function types. */
 typedef void (gearman_server_thread_run_fn)(gearman_server_thread_st *thread,
                                             void *context);
@@ -214,6 +216,16 @@
 
 /** @} */
 
+/**
+ * @addtogroup gearman_server_protocol Protocol Plugins
+ * @ingroup gearman_server
+ */
+
+/**
+ * @addtogroup gearman_server_queue Queue Plugins
+ * @ingroup gearman_server
+ */
+
 #ifdef __cplusplus
 }
 #endif
 
=== modified file 'libgearman-server/function.h'
--- libgearman-server/function.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/function.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Server function declarations
+ * @brief Function Declarations
  */
 
 #ifndef __GEARMAN_SERVER_FUNCTION_H__
@@ -19,10 +19,12 @@
 #endif
 
 /**
- * @addtogroup gearman_server_function Server Function Handling
+ * @addtogroup gearman_server_function Function Declarations
  * @ingroup gearman_server
+ *
  * This is a low level interface for gearman server functions. This is used
  * internally by the server interface, so you probably want to look there first.
+ *
  * @{
  */
 
 
=== modified file 'libgearman-server/gearmand.c'
--- libgearman-server/gearmand.c	2009-09-24 23:43:15 +0000
+++ libgearman-server/gearmand.c	2009-11-04 22:14:14 +0000
@@ -146,6 +146,11 @@
   gearman_server_set_job_retries(&(gearmand->server), job_retries);
 }
 
+void gearmand_set_worker_wakeup(gearmand_st *gearmand, uint8_t worker_wakeup)
+{
+  gearman_server_set_worker_wakeup(&(gearmand->server), worker_wakeup);
+}
+
 void gearmand_set_threads(gearmand_st *gearmand, uint32_t threads)
 {
   gearmand->threads= threads;
 
=== modified file 'libgearman-server/gearmand.h'
--- libgearman-server/gearmand.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/gearmand.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Gearmand declarations
+ * @brief Gearmand Declarations
  */
 
 #ifndef __GEARMAND_H__
@@ -23,8 +23,10 @@
 #endif
 
 /**
- * @addtogroup gearmand Gearmand
+ * @addtogroup gearmand Gearmand Declarations
+ *
  * This is a server implementation using the gearman_server interface.
+ *
  * @{
  */
 
@@ -64,6 +66,15 @@
 void gearmand_set_job_retries(gearmand_st *gearmand, uint8_t job_retries);
 
 /**
+ * Set maximum number of workers to wake up per job.
+ * @param gearmand Server instance structure previously initialized with
+ *        gearmand_create.
+ * @param worker_wakeup Number of workers to wake up.
+ */
+GEARMAN_API
+void gearmand_set_worker_wakeup(gearmand_st *gearmand, uint8_t worker_wakeup);
+
+/**
  * Set number of I/O threads for server to use.
  * @param gearmand Server instance structure previously initialized with
  *        gearmand_create.
 
=== modified file 'libgearman-server/gearmand_con.c'
--- libgearman-server/gearmand_con.c	2009-09-24 23:43:15 +0000
+++ libgearman-server/gearmand_con.c	2009-11-04 22:14:14 +0000
@@ -178,9 +178,9 @@
 }
 
 gearman_return_t gearmand_con_watch(gearman_con_st *con, short events,
-                                    void *arg __attribute__ ((unused)))
+                                    void *context __attribute__ ((unused)))
 {
-  (void) arg;
+  (void) context;
   gearmand_con_st *dcon;
   short set_events= 0;
 
 
=== modified file 'libgearman-server/gearmand_con.h'
--- libgearman-server/gearmand_con.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/gearmand_con.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Gearmand Connection Declarations
+ * @brief Connection Declarations
  */
 
 #ifndef __GEARMAND_CON_H__
@@ -19,8 +19,11 @@
 #endif
 
 /**
- * @addtogroup gearmand_con Gearmand Connections
+ * @addtogroup gearmand_con Connection Declarations
+ * @ingroup gearmand
+ *
  * Connection handling for gearmand.
+ *
  * @{
  */
 
@@ -58,7 +61,7 @@
  */
 GEARMAN_API
 gearman_return_t gearmand_con_watch(gearman_con_st *con, short events,
-                                    void *arg);
+                                    void *context);
 
 /** @} */
 
 
=== modified file 'libgearman-server/gearmand_thread.h'
--- libgearman-server/gearmand_thread.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/gearmand_thread.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Gearmand Thread Declarations
+ * @brief Thread Declarations
  */
 
 #ifndef __GEARMAND_THREAD_H__
@@ -19,8 +19,11 @@
 #endif
 
 /**
- * @addtogroup gearmand_thread Gearmand Threads
+ * @addtogroup gearmand_thread Thread Declarations
+ * @ingroup gearmand
+ *
  * Thread handling for gearmand.
+ *
  * @{
  */
 
 
=== modified file 'libgearman-server/job.c'
--- libgearman-server/job.c	2009-09-26 17:11:51 +0000
+++ libgearman-server/job.c	2009-11-04 22:14:14 +0000
@@ -380,6 +380,7 @@
 {
   gearman_server_client_st *client;
   gearman_server_worker_st *worker;
+  uint32_t noop_sent;
   gearman_return_t ret;
 
   if (job->worker != NULL)
@@ -415,22 +416,32 @@
   }
 
   /* Queue NOOP for possible sleeping workers. */
-  for (worker= job->function->worker_list; worker != NULL;
-       worker= worker->function_next)
+  if (job->function->worker_list != NULL)
   {
-    if (!(worker->con->options & GEARMAN_SERVER_CON_SLEEPING) ||
-        worker->con->options & GEARMAN_SERVER_CON_NOOP_SENT)
+    worker= job->function->worker_list;
+    noop_sent= 0;
+    do
     {
-      continue;
+      if (worker->con->options & GEARMAN_SERVER_CON_SLEEPING &&
+          !(worker->con->options & GEARMAN_SERVER_CON_NOOP_SENT))
+      {
+        ret= gearman_server_io_packet_add(worker->con, false,
+                                          GEARMAN_MAGIC_RESPONSE,
+                                          GEARMAN_COMMAND_NOOP, NULL);
+        if (ret != GEARMAN_SUCCESS)
+          return ret;
+
+        worker->con->options|= GEARMAN_SERVER_CON_NOOP_SENT;
+        noop_sent++;
+      }
+
+      worker= worker->function_next;
     }
-
-    ret= gearman_server_io_packet_add(worker->con, false,
-                                      GEARMAN_MAGIC_RESPONSE,
-                                      GEARMAN_COMMAND_NOOP, NULL);
-    if (ret != GEARMAN_SUCCESS)
-      return ret;
-
-    worker->con->options|= GEARMAN_SERVER_CON_NOOP_SENT;
+    while (worker != job->function->worker_list &&
+           (job->server->worker_wakeup == 0 ||
+           noop_sent < job->server->worker_wakeup));
+
+    job->function->worker_list= worker;
   }
 
   /* Queue the job to be run. */
 
=== modified file 'libgearman-server/job.h'
--- libgearman-server/job.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/job.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Server job declarations
+ * @brief Job Declarations
  */
 
 #ifndef __GEARMAN_SERVER_JOB_H__
@@ -19,10 +19,12 @@
 #endif
 
 /**
- * @addtogroup gearman_server_job Server Job Handling
+ * @addtogroup gearman_server_job Job Declarations
  * @ingroup gearman_server
+ *
  * This is a low level interface for gearman server jobs. This is used
  * internally by the server interface, so you probably want to look there first.
+ *
  * @{
  */
 
 
=== modified file 'libgearman-server/packet.c'
--- libgearman-server/packet.c	2009-09-24 23:43:15 +0000
+++ libgearman-server/packet.c	2009-11-04 22:14:14 +0000
@@ -101,8 +101,8 @@
   if (server_packet == NULL)
     return GEARMAN_MEMORY_ALLOCATION_FAILURE;
 
-  if (gearman_packet_create(con->thread->gearman,
-                            &(server_packet->packet)) == NULL)
+  if (gearman_add_packet(con->thread->gearman,
+                         &(server_packet->packet)) == NULL)
   {
     gearman_server_packet_free(server_packet, con->thread, false);
     return GEARMAN_MEMORY_ALLOCATION_FAILURE;
 
=== modified file 'libgearman-server/packet.h'
--- libgearman-server/packet.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/packet.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Server Packet declarations
+ * @brief Packet Declarations
  */
 
 #ifndef __GEARMAN_SERVER_PACKET_H__
@@ -19,10 +19,12 @@
 #endif
 
 /**
- * @addtogroup gearman_server_con Server Connection Handling
+ * @addtogroup gearman_server_packet Packet Declarations
  * @ingroup gearman_server
+ *
  * This is a low level interface for gearman server connections. This is used
  * internally by the server interface, so you probably want to look there first.
+ *
  * @{
  */
 
 
=== modified file 'libgearman-server/protocol_http.c'
--- libgearman-server/protocol_http.c	2009-09-24 23:43:15 +0000
+++ libgearman-server/protocol_http.c	2009-11-04 22:14:14 +0000
@@ -17,8 +17,8 @@
 #include <libgearman-server/protocol_http.h>
 
 /**
- * @addtogroup gearman_protocol_http HTTP Protocol Functions
- * @ingroup gearman_protocol
+ * @addtogroup gearman_protocol_http_static Static HTTP Protocol Definitions
+ * @ingroup gearman_protocol_http
  * @{
  */
 
@@ -27,10 +27,6 @@
  */
 #define GEARMAN_PROTOCOL_HTTP_DEFAULT_PORT 8080
 
-/*
- * Private declarations
- */
-
 /**
  * Structure for HTTP specific data.
  */
@@ -42,7 +38,7 @@
 
 /* Protocol callback functions. */
 static gearman_return_t _http_con_add(gearman_con_st *con);
-static void _http_free(gearman_con_st *con , void *data);
+static void _http_free(gearman_con_st *con, void *context);
 static size_t _http_pack(const gearman_packet_st *packet, gearman_con_st *con,
                          void *data, size_t data_size,
                          gearman_return_t *ret_ptr);
@@ -115,7 +111,7 @@
 }
 
 /*
- * Private definitions
+ * Static definitions
  */
 
 static gearman_return_t _http_con_add(gearman_con_st *con)
@@ -140,9 +136,10 @@
   return GEARMAN_SUCCESS;
 }
 
-static void _http_free(gearman_con_st *con __attribute__ ((unused)), void *data)
+static void _http_free(gearman_con_st *con __attribute__ ((unused)),
+                       void *context)
 {
-  free(data);
+  free((gearman_protocol_http_st *)context);
 }
 
 static size_t _http_pack(const gearman_packet_st *packet, gearman_con_st *con,
 
=== modified file 'libgearman-server/protocol_http.h'
--- libgearman-server/protocol_http.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/protocol_http.h	2009-11-04 22:14:14 +0000
@@ -19,20 +19,24 @@
 #endif
 
 /**
- * @addtogroup gearman_protocol_http HTTP Protocol Functions
- * @ingroup gearman_protocol
+ * @addtogroup gearman_protocol_http HTTP Protocol Declarations
+ * @ingroup gearman_server_protocol
+ *
  * This module provides a simple HTTP interface into the Gearman job server. It
  * is also meant to serve as an example of how other protocols can plug into
  * the server. This module will ignore all headers except:
+ *
  * Content-Length: SIZE
  * Connection: Keep-Alive
  * X-Gearman-Unique: UNIQUE_KEY
  * X-Gearman-Background: true
  * X-Gearman-Priority: HIGH | LOW
+ *
  * All HTTP requests are translated into SUBMIT_JOB requests, and only
  * WORK_COMPLETE, WORK_FAIL, and JOB_CREATED responses are returned.
  * JOB_CREATED packet are only sent back if the "X-Gearman-Background: true"
  * header is given.
+ *
  * @{
  */
 
 
=== modified file 'libgearman-server/queue_libdrizzle.c'
--- libgearman-server/queue_libdrizzle.c	2009-09-24 23:43:15 +0000
+++ libgearman-server/queue_libdrizzle.c	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Drizzle Queue Storage Definitions
+ * @brief libdrizzle Queue Storage Definitions
  */
 
 #include "common.h"
@@ -17,8 +17,8 @@
 #include <libdrizzle/drizzle_client.h>
 
 /**
- * @addtogroup gearman_queue_libdrizzle libdrizzle Queue Storage Functions
- * @ingroup gearman_queue
+ * @addtogroup gearman_queue_libdrizzle_static Static libdrizzle Queue Storage Definitions
+ * @ingroup gearman_queue_libdrizzle
  * @{
  */
 
@@ -29,10 +29,6 @@
 #define GEARMAN_QUEUE_LIBDRIZZLE_DEFAULT_TABLE "queue"
 #define GEARMAN_QUEUE_QUERY_BUFFER 256
 
-/*
- * Private declarations
- */
-
 /**
  * Structure for libdrizzle specific data.
  */
@@ -289,7 +285,7 @@
 }
 
 /*
- * Private definitions
+ * Static definitions
  */
 
 static drizzle_return_t _libdrizzle_query(gearman_server_st *server,
 
=== modified file 'libgearman-server/queue_libdrizzle.h'
--- libgearman-server/queue_libdrizzle.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/queue_libdrizzle.h	2009-11-04 22:14:14 +0000
@@ -19,8 +19,8 @@
 #endif
 
 /**
- * @addtogroup gearman_queue_libdrizzle libdrizzle Queue Storage Functions
- * @ingroup gearman_queue
+ * @addtogroup gearman_queue_libdrizzle libdrizzle Queue Storage Declarations
+ * @ingroup gearman_server_queue
  * @{
  */
 
 
=== modified file 'libgearman-server/queue_libmemcached.c'
--- libgearman-server/queue_libmemcached.c	2009-09-24 23:43:15 +0000
+++ libgearman-server/queue_libmemcached.c	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Drizzle Queue Storage Definitions
+ * @brief libmemcached Queue Storage Definitions
  */
 
 #include "common.h"
@@ -17,8 +17,8 @@
 #include <libmemcached/memcached.h>
 
 /**
- * @addtogroup gearman_queue_libmemcached libmemcached Queue Storage Functions
- * @ingroup gearman_queue
+ * @addtogroup gearman_queue_libmemcached_static Static libmemcached Queue Storage Functions
+ * @ingroup gearman_queue_libmemcached
  * @{
  */
 
@@ -27,10 +27,6 @@
  */
 #define GEARMAN_QUEUE_LIBMEMCACHED_DEFAULT_PREFIX "gear_"
 
-/*
- * Private declarations
- */
-
 /**
  * Structure for libmemcached specific data.
  */
@@ -191,7 +187,7 @@
 }
 
 /*
- * Private definitions
+ * Static definitions
  */
 
 static gearman_return_t _libmemcached_add(gearman_server_st *server,
 
=== modified file 'libgearman-server/queue_libmemcached.h'
--- libgearman-server/queue_libmemcached.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/queue_libmemcached.h	2009-11-04 22:14:14 +0000
@@ -19,8 +19,8 @@
 #endif
 
 /**
- * @addtogroup gearman_queue_libmemcached libmemcached Queue Storage Functions
- * @ingroup gearman_queue
+ * @addtogroup gearman_queue_libmemcached libmemcached Queue Storage Declarations
+ * @ingroup gearman_server_queue
  * @{
  */
 
 
=== modified file 'libgearman-server/queue_libpq.c'
--- libgearman-server/queue_libpq.c	2009-09-24 23:43:15 +0000
+++ libgearman-server/queue_libpq.c	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief PostgreSQL Queue Storage Definitions
+ * @brief libpq Queue Storage Definitions
  */
 
 #include "common.h"
@@ -24,8 +24,8 @@
 #endif
 
 /**
- * @addtogroup gearman_queue_libpq libpq Queue Storage Functions
- * @ingroup gearman_queue
+ * @addtogroup gearman_queue_libpq_static Static libpq Queue Storage Definitions
+ * @ingroup gearman_queue_libpq
  * @{
  */
 
@@ -35,10 +35,6 @@
 #define GEARMAN_QUEUE_LIBPQ_DEFAULT_TABLE "queue"
 #define GEARMAN_QUEUE_QUERY_BUFFER 256
 
-/*
- * Private declarations
- */
-
 /**
  * Structure for libpq specific data.
  */
@@ -241,7 +237,7 @@
 }
 
 /*
- * Private definitions
+ * Static definitions
  */
 
 static void _libpq_notice_processor(void *arg, const char *message)
 
=== modified file 'libgearman-server/queue_libpq.h'
--- libgearman-server/queue_libpq.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/queue_libpq.h	2009-11-04 22:14:14 +0000
@@ -19,8 +19,8 @@
 #endif
 
 /**
- * @addtogroup gearman_queue_libpq libpq Queue Storage Functions
- * @ingroup gearman_queue
+ * @addtogroup gearman_queue_libpq libpq Queue Storage Declarations
+ * @ingroup gearman_server_queue
  * @{
  */
 
 
=== modified file 'libgearman-server/queue_libsqlite3.c'
--- libgearman-server/queue_libsqlite3.c	2009-09-24 23:43:15 +0000
+++ libgearman-server/queue_libsqlite3.c	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Sqlite Queue Storage Definitions
+ * @brief libsqlite3 Queue Storage Definitions
  */
 
 #include "common.h"
@@ -17,8 +17,8 @@
 #include <sqlite3.h>
 
 /**
- * @addtogroup gearman_queue_sqlite sqlite Queue Storage Functions
- * @ingroup gearman_queue
+ * @addtogroup gearman_queue_libsqlite3_static Static libsqlite3 Queue Storage Definitions
+ * @ingroup gearman_queue_libsqlite3
  * @{
  */
 
@@ -27,10 +27,6 @@
  */
 #define GEARMAN_QUEUE_SQLITE_DEFAULT_TABLE "gearman_queue"
 #define GEARMAN_QUEUE_QUERY_BUFFER 256
-
-/*
- * Private declarations
- */
 #define SQLITE_MAX_TABLE_SIZE 256
 #define SQLITE_MAX_CREATE_TABLE_SIZE 1024
 
@@ -281,7 +277,7 @@
 }
 
 /*
- * Private definitions
+ * Static definitions
  */
 
 int _sqlite_query(gearman_server_st *server,
 
=== modified file 'libgearman-server/queue_libsqlite3.h'
--- libgearman-server/queue_libsqlite3.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/queue_libsqlite3.h	2009-11-04 22:14:14 +0000
@@ -19,8 +19,8 @@
 #endif
 
 /**
- * @addtogroup gearman_queue_libsqlite3 libsqlite3 Queue Storage Functions
- * @ingroup gearman_queue
+ * @addtogroup gearman_queue_libsqlite3 libsqlite3 Queue Storage Declarations
+ * @ingroup gearman_server_queue
  * @{
  */
 
 
=== modified file 'libgearman-server/server.c'
--- libgearman-server/server.c	2009-09-24 23:43:15 +0000
+++ libgearman-server/server.c	2009-11-04 22:14:14 +0000
@@ -84,6 +84,7 @@
   server->proc_wakeup= false;
   server->proc_shutdown= false;
   server->job_retries= 0;
+  server->worker_wakeup= 0;
   server->thread_count= 0;
   server->free_packet_count= 0;
   server->function_count= 0;
@@ -191,6 +192,12 @@
   server->job_retries= job_retries;
 }
 
+void gearman_server_set_worker_wakeup(gearman_server_st *server,
+                                      uint8_t worker_wakeup)
+{
+  server->worker_wakeup= worker_wakeup;
+}
+
 void gearman_server_set_log_fn(gearman_server_st *server,
                                gearman_log_fn *function,
                                const void *context, gearman_verbose_t verbose)
@@ -906,8 +913,8 @@
     return GEARMAN_MEMORY_ALLOCATION_FAILURE;
   }
 
-  if (gearman_packet_create(server_con->thread->gearman,
-                            &(server_packet->packet)) == NULL)
+  if (gearman_add_packet(server_con->thread->gearman,
+                         &(server_packet->packet)) == NULL)
   {
     free(data);
     gearman_server_packet_free(server_packet, server_con->thread, false);
 
=== modified file 'libgearman-server/server.h'
--- libgearman-server/server.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/server.h	2009-11-04 22:14:14 +0000
@@ -15,6 +15,8 @@
 #define __GEARMAN_SERVER_H__
 
 #include <libgearman/gearman.h>
+#include <event.h>
+
 #include <libgearman-server/constants.h>
 #include <libgearman-server/structs.h>
 #include <libgearman-server/conf.h>
@@ -32,7 +34,7 @@
 #endif
 
 /**
- * @addtogroup gearman_server Server Interface
+ * @addtogroup gearman_server Gearman Server Declarations
  * This is the interface gearman servers should use.
  * @{
  */
@@ -66,6 +68,16 @@
                                     uint8_t job_retries);
 
 /**
+ * Set maximum number of workers to wake up per job.
+ * @param server Server structure previously initialized with
+ *        gearman_server_create.
+ * @param worker_wakeup Number of workers to wake up.
+ */
+GEARMAN_API
+void gearman_server_set_worker_wakeup(gearman_server_st *server,
+                                      uint8_t worker_wakeup);
+
+/**
  * Set logging callback for server instance.
  * @param server Server structure previously initialized with
  *        gearman_server_create.
 
=== modified file 'libgearman-server/structs.h'
--- libgearman-server/structs.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/structs.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Struct definitions
+ * @brief Struct Definitions
  */
 
 #ifndef __GEARMAN_SERVER_STRUCTS_H__
@@ -29,6 +29,7 @@
   bool proc_wakeup;
   bool proc_shutdown;
   uint8_t job_retries;
+  uint8_t worker_wakeup;
   uint32_t job_handle_count;
   uint32_t thread_count;
   uint32_t function_count;
 
=== modified file 'libgearman-server/thread.c'
--- libgearman-server/thread.c	2009-09-24 23:43:15 +0000
+++ libgearman-server/thread.c	2009-11-04 22:14:14 +0000
@@ -227,7 +227,7 @@
   }
 
   /* Check for new activity on connections. */
-  while ((con= gearman_con_ready(thread->gearman)) != NULL)
+  while ((con= gearman_ready(thread->gearman)) != NULL)
   {
     /* Inherited classes anyone? Some people would call this a hack, I call
        it clean (avoids extra ptrs). Brian, I'll give you your C99 0-byte
 
=== modified file 'libgearman-server/thread.h'
--- libgearman-server/thread.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/thread.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Server Thread Declarations
+ * @brief Thread Declarations
  */
 
 #ifndef __GEARMAN_SERVER_THREAD_H__
@@ -19,8 +19,11 @@
 #endif
 
 /**
- * @addtogroup gearman_server_thread Server Thread Handling
+ * @addtogroup gearman_server_thread Thread Declarations
+ * @ingroup gearman_server
+ *
  * This is the interface gearman servers should use for creating threads.
+ *
  * @{
  */
 
 
=== modified file 'libgearman-server/worker.c'
--- libgearman-server/worker.c	2009-09-24 23:43:15 +0000
+++ libgearman-server/worker.c	2009-11-04 22:14:14 +0000
@@ -73,7 +73,23 @@
   worker->con= con;
   GEARMAN_LIST_ADD(con->worker, worker, con_)
   worker->function= function;
-  GEARMAN_LIST_ADD(function->worker, worker, function_)
+
+  /* Add worker to the function list, which is a double-linked circular list. */
+  if (function->worker_list == NULL)
+  {
+    function->worker_list= worker;
+    worker->function_next= worker;
+    worker->function_prev= worker;
+  }
+  else
+  {
+    worker->function_next= function->worker_list;
+    worker->function_prev= function->worker_list->function_prev;
+    worker->function_next->function_prev= worker;
+    worker->function_prev->function_next= worker;
+  }
+  function->worker_count++;
+
   worker->job_list= NULL;
 
   return worker;
@@ -88,7 +104,17 @@
     (void)gearman_server_job_queue(worker->job_list);
 
   GEARMAN_LIST_DEL(worker->con->worker, worker, con_)
-  GEARMAN_LIST_DEL(worker->function->worker, worker, function_)
+
+  if (worker == worker->function_next)
+    worker->function->worker_list= NULL;
+  else
+  {
+    worker->function_next->function_prev= worker->function_prev;
+    worker->function_prev->function_next= worker->function_next;
+    if (worker == worker->function->worker_list)
+      worker->function->worker_list= worker->function_next;
+  }
+  worker->function->worker_count--;
 
   if (worker->options & GEARMAN_SERVER_WORKER_ALLOCATED)
   {
 
=== modified file 'libgearman-server/worker.h'
--- libgearman-server/worker.h	2009-09-24 23:43:15 +0000
+++ libgearman-server/worker.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Server worker declarations
+ * @brief Worker Declarations
  */
 
 #ifndef __GEARMAN_SERVER_WORKER_H__
@@ -19,10 +19,12 @@
 #endif
 
 /**
- * @addtogroup gearman_server_worker Server Worker Handling
+ * @addtogroup gearman_server_worker Worker Declarations
  * @ingroup gearman_server
+ *
  * This is a low level interface for gearman server workers. This is used
  * internally by the server interface, so you probably want to look there first.
+ *
  * @{
  */
 
 
=== modified file 'libgearman/Makefile.am'
--- libgearman/Makefile.am	2009-09-26 16:54:44 +0000
+++ libgearman/Makefile.am	2009-11-04 22:14:14 +0000
@@ -22,7 +22,8 @@
 	worker.h
 
 noinst_HEADERS= \
-	common.h
+	common.h \
+        gearman_local.h
 
 libgearman_la_SOURCES= \
 	client.c \
 
=== modified file 'libgearman/client.c'
--- libgearman/client.c	2009-09-28 17:47:34 +0000
+++ libgearman/client.c	2009-11-04 22:14:14 +0000
@@ -8,17 +8,13 @@
 
 /**
  * @file
- * @brief Client definitions
+ * @brief Client Definitions
  */
 
 #include "common.h"
 
-/*
- * Private declarations
- */
-
 /**
- * @addtogroup gearman_client_private Private Client Functions
+ * @addtogroup gearman_client_static Static Client Declarations
  * @ingroup gearman_client
  * @{
  */
@@ -102,7 +98,7 @@
 /** @} */
 
 /*
- * Public definitions
+ * Public Definitions
  */
 
 gearman_client_st *gearman_client_create(gearman_client_st *client)
@@ -251,7 +247,7 @@
 gearman_return_t gearman_client_add_server(gearman_client_st *client,
                                            const char *host, in_port_t port)
 {
-  if (gearman_con_add(client->gearman, NULL, host, port) == NULL)
+  if (gearman_add_con_args(client->gearman, NULL, host, port) == NULL)
     return GEARMAN_MEMORY_ALLOCATION_FAILURE;
 
   return GEARMAN_SUCCESS;
@@ -265,12 +261,12 @@
 
 void gearman_client_remove_servers(gearman_client_st *client)
 {
-  gearman_con_free_all(client->gearman);
+  gearman_free_all_cons(client->gearman);
 }
 
 gearman_return_t gearman_client_wait(gearman_client_st *client)
 {
-  return gearman_con_wait(client->gearman);
+  return gearman_wait(client->gearman);
 }
 
 void *gearman_client_do(gearman_client_st *client, const char *function_name,
@@ -394,7 +390,7 @@
                                      const void *workload,
                                      size_t workload_size)
 {
-  return gearman_con_echo(client->gearman, workload, workload_size);
+  return gearman_echo(client->gearman, workload, workload_size);
 }
 
 void gearman_task_free(gearman_task_st *task)
@@ -402,8 +398,11 @@
   if (task->options & GEARMAN_TASK_SEND_IN_USE)
     gearman_packet_free(&(task->send));
 
-  if (task->context != NULL && task->client->task_context_free_fn != NULL)
-    (*(task->client->task_context_free_fn))(task, (void *)(task->context));
+  if (task != &(task->client->do_task) && task->context != NULL &&
+      task->client->task_context_free_fn != NULL)
+  {
+    task->client->task_context_free_fn(task, (void *)task->context);
+  }
 
   if (task->client->task_list == task)
     task->client->task_list= task->next;
@@ -521,6 +520,9 @@
                                                 const char *job_handle,
                                                 gearman_return_t *ret_ptr)
 {
+  const void *args[1];
+  size_t args_size[1];
+
   task= _task_create(client, task);
   if (task == NULL)
   {
@@ -531,10 +533,12 @@
   task->context= context;
   snprintf(task->job_handle, GEARMAN_JOB_HANDLE_SIZE, "%s", job_handle);
 
-  *ret_ptr= gearman_packet_add(client->gearman, &(task->send),
-                               GEARMAN_MAGIC_REQUEST,
-                               GEARMAN_COMMAND_GET_STATUS,
-                               (uint8_t *)job_handle, strlen(job_handle), NULL);
+  args[0]= job_handle;
+  args_size[0]= strlen(job_handle);
+  *ret_ptr= gearman_add_packet_args(client->gearman, &(task->send),
+                                    GEARMAN_MAGIC_REQUEST,
+                                    GEARMAN_COMMAND_GET_STATUS,
+                                    args, args_size, 1);
   if (*ret_ptr == GEARMAN_SUCCESS)
   {
     client->new_tasks++;
@@ -636,10 +640,20 @@
             return ret;
           }
         }
+
+        if (client->new_tasks == 0)
+        {
+          ret= gearman_flush_all(client->gearman);
+          if (ret != GEARMAN_SUCCESS)
+          {
+            client->gearman->options= options;
+            return ret;
+          }
+        }
       }
 
       /* See if there are any connections ready for I/O. */
-      while ((client->con= gearman_con_ready(client->gearman)) != NULL)
+      while ((client->con= gearman_ready(client->gearman)) != NULL)
       {
         if (client->con->revents & (POLLOUT | POLLERR | POLLHUP | POLLNVAL))
         {
@@ -738,7 +752,7 @@
               }
               else if (client->con->packet.command == GEARMAN_COMMAND_ERROR)
               {
-		gearman_error_set(client->gearman, "gearman_client_run_tasks",
+		gearman_set_error(client->gearman, "gearman_client_run_tasks",
 				  "%s:%.*s",
 				  (char *)(client->con->packet.arg[0]),
 				  (int)(client->con->packet.arg_size[1]),
@@ -800,7 +814,7 @@
       }
 
       /* Wait for activity on one of the connections. */
-      ret= gearman_con_wait(client->gearman);
+      ret= gearman_wait(client->gearman);
       if (ret != GEARMAN_SUCCESS && ret != GEARMAN_IO_WAIT)
       {
         client->state= GEARMAN_CLIENT_STATE_IDLE;
@@ -812,7 +826,7 @@
     break;
 
   default:
-    gearman_error_set(client->gearman, "gearman_client_run_tasks",
+    gearman_set_error(client->gearman, "gearman_client_run_tasks",
                       "unknown state: %u", client->state);
     client->gearman->options= options;
     return GEARMAN_UNKNOWN_STATE;
@@ -824,7 +838,7 @@
 }
 
 /*
- * Private definitions
+ * Static Definitions
  */
 
 static gearman_client_st *_client_allocate(gearman_client_st *client)
@@ -883,6 +897,8 @@
 {
   uuid_t uuid;
   char uuid_string[37];
+  const void *args[3];
+  size_t args_size[3];
 
   task= _task_create(client, task);
   if (task == NULL)
@@ -900,12 +916,16 @@
     unique= uuid_string;
   }
 
-  *ret_ptr= gearman_packet_add(client->gearman, &(task->send),
-                               GEARMAN_MAGIC_REQUEST, command,
-                               (uint8_t *)function_name,
-                               (size_t)(strlen(function_name) + 1),
-                               (uint8_t *)unique, (size_t)(strlen(unique) + 1),
-                               workload, workload_size, NULL);
+  args[0]= function_name;
+  args_size[0]= (size_t)strlen(function_name) + 1;
+  args[1]= unique;
+  args_size[1]= (size_t)strlen(unique) + 1;
+  args[2]= workload;
+  args_size[2]= workload_size;
+
+  *ret_ptr= gearman_add_packet_args(client->gearman, &(task->send),
+                                    GEARMAN_MAGIC_REQUEST, command,
+                                    args, args_size, 3);
   if (*ret_ptr == GEARMAN_SUCCESS)
   {
     client->new_tasks++;
@@ -930,7 +950,8 @@
     {
       client->new_tasks--;
       client->running_tasks--;
-      gearman_error_set(client->gearman, "_client_run_task", "no servers added");
+      gearman_set_error(client->gearman, "_client_run_task",
+                        "no servers added");
       return GEARMAN_NO_SERVERS;
     }
 
@@ -981,6 +1002,8 @@
               break;
           }
         }
+        else
+          task->con= NULL;
 
         if (task->con == NULL)
         {
@@ -1000,13 +1023,13 @@
     {
       if (client->workload_fn == NULL)
       {
-        gearman_error_set(client->gearman, "_client_run_task",
-                          "workload size > 0, but no data pointer or workload_fn was given");
+        gearman_set_error(client->gearman, "_client_run_task",
+             "workload size > 0, but no data pointer or workload_fn was given");
         return GEARMAN_NEED_WORKLOAD_FN;
       }
 
   case GEARMAN_TASK_STATE_WORKLOAD:
-      ret= (*(client->workload_fn))(task);
+      ret= client->workload_fn(task);
       if (ret != GEARMAN_SUCCESS)
       {
         task->state= GEARMAN_TASK_STATE_WORKLOAD;
@@ -1028,7 +1051,7 @@
   case GEARMAN_TASK_STATE_CREATED:
       if (client->created_fn != NULL)
       {
-        ret= (*(client->created_fn))(task);
+        ret= client->created_fn(task);
         if (ret != GEARMAN_SUCCESS)
         {
           task->state= GEARMAN_TASK_STATE_CREATED;
@@ -1048,7 +1071,7 @@
   case GEARMAN_TASK_STATE_DATA:
       if (client->data_fn != NULL)
       {
-        ret= (*(client->data_fn))(task);
+        ret= client->data_fn(task);
         if (ret != GEARMAN_SUCCESS)
         {
           task->state= GEARMAN_TASK_STATE_DATA;
@@ -1061,7 +1084,7 @@
   case GEARMAN_TASK_STATE_WARNING:
       if (client->warning_fn != NULL)
       {
-        ret= (*(client->warning_fn))(task);
+        ret= client->warning_fn(task);
         if (ret != GEARMAN_SUCCESS)
         {
           task->state= GEARMAN_TASK_STATE_WARNING;
@@ -1098,7 +1121,7 @@
   case GEARMAN_TASK_STATE_STATUS:
       if (client->status_fn != NULL)
       {
-        ret= (*(client->status_fn))(task);
+        ret= client->status_fn(task);
         if (ret != GEARMAN_SUCCESS)
         {
           task->state= GEARMAN_TASK_STATE_STATUS;
@@ -1114,7 +1137,7 @@
   case GEARMAN_TASK_STATE_COMPLETE:
       if (client->complete_fn != NULL)
       {
-        ret= (*(client->complete_fn))(task);
+        ret= client->complete_fn(task);
         if (ret != GEARMAN_SUCCESS)
         {
           task->state= GEARMAN_TASK_STATE_COMPLETE;
@@ -1129,7 +1152,7 @@
   case GEARMAN_TASK_STATE_EXCEPTION:
       if (client->exception_fn != NULL)
       {
-        ret= (*(client->exception_fn))(task);
+        ret= client->exception_fn(task);
         if (ret != GEARMAN_SUCCESS)
         {
           task->state= GEARMAN_TASK_STATE_EXCEPTION;
@@ -1142,7 +1165,7 @@
   case GEARMAN_TASK_STATE_FAIL:
       if (client->fail_fn != NULL)
       {
-        ret= (*(client->fail_fn))(task);
+        ret= client->fail_fn(task);
         if (ret != GEARMAN_SUCCESS)
         {
           task->state= GEARMAN_TASK_STATE_FAIL;
@@ -1160,7 +1183,7 @@
     break;
 
   default:
-    gearman_error_set(client->gearman, "_client_run_task", "unknown state: %u",
+    gearman_set_error(client->gearman, "_client_run_task", "unknown state: %u",
                       task->state);
     return GEARMAN_UNKNOWN_STATE;
   }
@@ -1311,7 +1334,7 @@
     task= malloc(sizeof(gearman_task_st));
     if (task == NULL)
     {
-      gearman_error_set(client->gearman, "_task_create", "malloc");
+      gearman_set_error(client->gearman, "_task_create", "malloc");
       return NULL;
     }
 
 
=== modified file 'libgearman/client.h'
--- libgearman/client.h	2009-10-02 01:13:31 +0000
+++ libgearman/client.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Client declarations
+ * @brief Client Declarations
  */
 
 #ifndef __GEARMAN_CLIENT_H__
@@ -19,7 +19,8 @@
 #endif
 
 /**
- * @addtogroup gearman_client Client Interface
+ * @addtogroup gearman_client Client Declarations
+ *
  * This is the interface gearman clients should use. You can run tasks one at a
  * time or concurrently.
  *
@@ -227,6 +228,8 @@
 GEARMAN_API
 gearman_return_t gearman_client_wait(gearman_client_st *client);
 
+/** @} */
+
 /**
  * @addtogroup gearman_client_single Single Task Interface
  * @ingroup gearman_client
@@ -654,8 +657,6 @@
 
 /** @} */
 
-/** @} */
-
 #ifdef __cplusplus
 }
 #endif
 
=== modified file 'libgearman/common.h'
--- libgearman/common.h	2009-09-26 16:54:44 +0000
+++ libgearman/common.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief System include files
+ * @brief System Include Files
  */
 
 #ifndef __GEARMAN_COMMON_H__
@@ -75,34 +75,6 @@
 # endif
 #endif
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * Utility function used for error logging
- * @ingroup gearman_private
- *
- * @param[in] gearman Structure previously initialized with gearman_create() or
- *  gearman_clone().
- * @param[in] function Name of function the error happened in. 
- * @param[in] format Format and variable argument list of message.
- */
-GEARMAN_LOCAL
-void gearman_error_set(gearman_st *gearman, const char *function,
-                       const char *format, ...);
-
-/**
- * Utility function used for parsing server lists.
- * @ingroup gearman_private
- */
-GEARMAN_LOCAL
-gearman_return_t gearman_parse_servers(const char *servers,
-                                       gearman_parse_server_fn *callback,
-                                       const void *context);
-
-#ifdef __cplusplus
-}
-#endif
+#include "gearman_local.h"
 
 #endif /* __GEARMAN_COMMON_H__ */
 
=== modified file 'libgearman/conn.c'
--- libgearman/conn.c	2009-09-28 17:47:34 +0000
+++ libgearman/conn.c	2009-11-04 22:14:14 +0000
@@ -8,17 +8,13 @@
 
 /**
  * @file
- * @brief Connection definitions
+ * @brief Connection Definitions
  */
 
 #include "common.h"
 
-/*
- * Private declarations
- */
-
 /**
- * @addtogroup gearman_con_private Private Connection Functions
+ * @addtogroup gearman_con_static Static Connection Declarations
  * @ingroup gearman_con
  * @{
  */
@@ -31,7 +27,7 @@
 /** @} */
 
 /*
- * Public definitions
+ * Public Definitions
  */
 
 void gearman_con_set_host(gearman_con_st *con, const char *host)
@@ -156,19 +152,18 @@
   case GEARMAN_CON_SEND_STATE_NONE:
     if (!(packet->options & GEARMAN_PACKET_COMPLETE))
     {
-      gearman_error_set(con->gearman, "gearman_con_send", "packet not complete");
+      gearman_set_error(con->gearman, "gearman_con_send",
+                        "packet not complete");
       return GEARMAN_INVALID_PACKET;
     }
 
     /* Pack first part of packet, which is everything but the payload. */
     while (1)
     {
-      send_size= (*con->packet_pack_fn)(packet, con,
-                                        con->send_buffer +
-                                        con->send_buffer_size,
-                                        GEARMAN_SEND_BUFFER_SIZE -
-                                        con->send_buffer_size,
-                                        &ret);
+      send_size= con->packet_pack_fn(packet, con,
+                                     con->send_buffer + con->send_buffer_size,
+                                     GEARMAN_SEND_BUFFER_SIZE -
+                                     con->send_buffer_size, &ret);
       if (ret == GEARMAN_SUCCESS)
       {
         con->send_buffer_size+= send_size;
@@ -182,7 +177,7 @@
       /* We were asked to flush when the buffer is already flushed! */
       if (con->send_buffer_size == 0)
       {
-        gearman_error_set(con->gearman, "gearman_con_send",
+        gearman_set_error(con->gearman, "gearman_con_send",
                           "send buffer too small (%u)",
                           GEARMAN_SEND_BUFFER_SIZE);
         return GEARMAN_SEND_BUFFER_TOO_SMALL;
@@ -264,7 +259,7 @@
     return ret;
 
   default:
-    gearman_error_set(con->gearman, "gearman_con_send", "unknown state: %u",
+    gearman_set_error(con->gearman, "gearman_con_send", "unknown state: %u",
                       con->send_state);
     return GEARMAN_UNKNOWN_STATE;
   }
@@ -290,13 +285,13 @@
 {
   if (con->send_state != GEARMAN_CON_SEND_STATE_FLUSH_DATA)
   {
-    gearman_error_set(con->gearman, "gearman_con_send_data", "not flushing");
+    gearman_set_error(con->gearman, "gearman_con_send_data", "not flushing");
     return GEARMAN_NOT_FLUSHING;
   }
 
   if (data_size > (con->send_data_size - con->send_data_offset))
   {
-    gearman_error_set(con->gearman, "gearman_con_send_data", "data too large");
+    gearman_set_error(con->gearman, "gearman_con_send_data", "data too large");
     return GEARMAN_DATA_TOO_LARGE;
   }
 
@@ -336,7 +331,7 @@
       ret= getaddrinfo(con->host, port_str, &ai, &(con->addrinfo));
       if (ret != 0)
       {
-        gearman_error_set(con->gearman, "gearman_con_flush", "getaddrinfo:%s",
+        gearman_set_error(con->gearman, "gearman_con_flush", "getaddrinfo:%s",
                           gai_strerror(ret));
         return GEARMAN_GETADDRINFO;
       }
@@ -350,7 +345,7 @@
       if (con->addrinfo_next == NULL)
       {
         con->state= GEARMAN_CON_STATE_ADDRINFO;
-        gearman_error_set(con->gearman, "gearman_con_flush",
+        gearman_set_error(con->gearman, "gearman_con_flush",
                           "could not connect");
         return GEARMAN_COULD_NOT_CONNECT;
       }
@@ -361,7 +356,8 @@
       if (con->fd == -1)
       {
         con->state= GEARMAN_CON_STATE_ADDRINFO;
-        gearman_error_set(con->gearman, "gearman_con_flush", "socket:%d", errno);
+        gearman_set_error(con->gearman, "gearman_con_flush", "socket:%d",
+                          errno);
         con->gearman->last_errno= errno;
         return GEARMAN_ERRNO;
       }
@@ -401,7 +397,8 @@
           break;
         }
 
-        gearman_error_set(con->gearman, "gearman_con_flush", "connect:%d", errno);
+        gearman_set_error(con->gearman, "gearman_con_flush", "connect:%d",
+                          errno);
         con->gearman->last_errno= errno;
         gearman_con_close(con);
         return GEARMAN_ERRNO;
@@ -435,7 +432,7 @@
           return GEARMAN_IO_WAIT;
         }
 
-        gret= gearman_con_wait(con->gearman);
+        gret= gearman_wait(con->gearman);
         if (gret != GEARMAN_SUCCESS)
           return gret;
       }
@@ -451,7 +448,7 @@
         {
           if (!(con->options & GEARMAN_CON_IGNORE_LOST_CONNECTION))
           {
-            gearman_error_set(con->gearman, "gearman_con_flush",
+            gearman_set_error(con->gearman, "gearman_con_flush",
                               "lost connection to server (EOF)");
           }
           gearman_con_close(con);
@@ -468,7 +465,7 @@
             if (con->gearman->options & GEARMAN_NON_BLOCKING)
               return GEARMAN_IO_WAIT;
 
-            gret= gearman_con_wait(con->gearman);
+            gret= gearman_wait(con->gearman);
             if (gret != GEARMAN_SUCCESS)
               return gret;
 
@@ -480,14 +477,15 @@
           {
             if (!(con->options & GEARMAN_CON_IGNORE_LOST_CONNECTION))
             {
-              gearman_error_set(con->gearman, "gearman_con_flush",
+              gearman_set_error(con->gearman, "gearman_con_flush",
                                 "lost connection to server (%d)", errno);
             }
             gearman_con_close(con);
             return GEARMAN_LOST_CONNECTION;
           }
 
-          gearman_error_set(con->gearman, "gearman_con_flush", "write:%d", errno);
+          gearman_set_error(con->gearman, "gearman_con_flush", "write:%d",
+                            errno);
           con->gearman->last_errno= errno;
           gearman_con_close(con);
           return GEARMAN_ERRNO;
@@ -518,7 +516,8 @@
       return GEARMAN_SUCCESS;
 
     default:
-      gearman_error_set(con->gearman, "gearman_con_flush", "unknown state: %u", con->state);
+      gearman_set_error(con->gearman, "gearman_con_flush", "unknown state: %u",
+                        con->state);
 
       return GEARMAN_UNKNOWN_STATE;
     }
@@ -536,12 +535,12 @@
   case GEARMAN_CON_RECV_STATE_NONE:
     if (con->state != GEARMAN_CON_STATE_CONNECTED)
     {
-      gearman_error_set(con->gearman, "gearman_con_recv", "not connected");
+      gearman_set_error(con->gearman, "gearman_con_recv", "not connected");
       *ret_ptr= GEARMAN_NOT_CONNECTED;
       return NULL;
     }
 
-    con->recv_packet= gearman_packet_create(con->gearman, packet);
+    con->recv_packet= gearman_add_packet(con->gearman, packet);
     if (con->recv_packet == NULL)
     {
       *ret_ptr= GEARMAN_MEMORY_ALLOCATION_FAILURE;
@@ -555,9 +554,9 @@
     {
       if (con->recv_buffer_size > 0)
       {
-        recv_size= (*con->packet_unpack_fn)(con->recv_packet, con,
-                                            con->recv_buffer_ptr,
-                                            con->recv_buffer_size, ret_ptr);
+        recv_size= con->packet_unpack_fn(con->recv_packet, con,
+                                         con->recv_buffer_ptr,
+                                         con->recv_buffer_size, ret_ptr);
         con->recv_buffer_ptr+= recv_size;
         con->recv_buffer_size-= recv_size;
         if (*ret_ptr == GEARMAN_SUCCESS)
@@ -602,7 +601,7 @@
     else
     {
       packet->data= packet->gearman->workload_malloc_fn(packet->data_size,
-                            (void *)(packet->gearman->workload_malloc_context));
+                              (void *)packet->gearman->workload_malloc_context);
     }
     if (packet->data == NULL)
     {
@@ -630,7 +629,7 @@
     break;
 
   default:
-    gearman_error_set(con->gearman, "gearman_con_recv", "unknown state: %u",
+    gearman_set_error(con->gearman, "gearman_con_recv", "unknown state: %u",
                       con->recv_state);
     *ret_ptr= GEARMAN_UNKNOWN_STATE;
     return NULL;
@@ -702,7 +701,7 @@
     {
       if (!(con->options & GEARMAN_CON_IGNORE_LOST_CONNECTION))
       {
-        gearman_error_set(con->gearman, "gearman_con_read",
+        gearman_set_error(con->gearman, "gearman_con_read",
                           "lost connection to server (EOF)");
       }
       gearman_con_close(con);
@@ -723,7 +722,7 @@
           return 0;
         }
 
-        *ret_ptr= gearman_con_wait(con->gearman);
+        *ret_ptr= gearman_wait(con->gearman);
         if (*ret_ptr != GEARMAN_SUCCESS)
           return 0;
 
@@ -735,14 +734,14 @@
       {
         if (!(con->options & GEARMAN_CON_IGNORE_LOST_CONNECTION))
         {
-          gearman_error_set(con->gearman, "gearman_con_read",
+          gearman_set_error(con->gearman, "gearman_con_read",
                             "lost connection to server (%d)", errno);
         }
         *ret_ptr= GEARMAN_LOST_CONNECTION;
       }
       else
       {
-        gearman_error_set(con->gearman, "gearman_con_read", "read:%d", errno);
+        gearman_set_error(con->gearman, "gearman_con_read", "read:%d", errno);
         con->gearman->last_errno= errno;
         *ret_ptr= GEARMAN_ERRNO;
       }
@@ -769,7 +768,7 @@
 
   if (con->gearman->event_watch_fn != NULL)
   {
-    ret= (con->gearman->event_watch_fn)(con, con->events,
+    ret= con->gearman->event_watch_fn(con, con->events,
                                      (void *)con->gearman->event_watch_context);
     if (ret != GEARMAN_SUCCESS)
     {
@@ -797,7 +796,7 @@
   if (revents & POLLOUT && !(con->events & POLLOUT) &&
       con->gearman->event_watch_fn != NULL)
   {
-    ret= (con->gearman->event_watch_fn)(con, con->events,
+    ret= con->gearman->event_watch_fn(con, con->events,
                                      (void *)con->gearman->event_watch_context);
     if (ret != GEARMAN_SUCCESS)
     {
@@ -840,7 +839,7 @@
 }
 
 /*
- * Private definitions
+ * Static Definitions
  */
 
 static gearman_return_t _con_setsockopt(gearman_con_st *con)
@@ -852,9 +851,9 @@
   ret= 1;
   ret= setsockopt(con->fd, IPPROTO_TCP, TCP_NODELAY, &ret,
                   (socklen_t)sizeof(int));
-  if (ret == -1)
+  if (ret == -1 && errno != EOPNOTSUPP)
   {
-    gearman_error_set(con->gearman, "_con_setsockopt",
+    gearman_set_error(con->gearman, "_con_setsockopt",
                       "setsockopt:TCP_NODELAY:%d", errno);
     return GEARMAN_ERRNO;
   }
@@ -865,7 +864,7 @@
                   (socklen_t)sizeof(struct linger));
   if (ret == -1)
   {
-    gearman_error_set(con->gearman, "_con_setsockopt",
+    gearman_set_error(con->gearman, "_con_setsockopt",
                       "setsockopt:SO_LINGER:%d", errno);
     return GEARMAN_ERRNO;
   }
@@ -876,7 +875,7 @@
                   (socklen_t)sizeof(struct timeval));
   if (ret == -1 && errno != ENOPROTOOPT)
   {
-    gearman_error_set(con->gearman, "_con_setsockopt",
+    gearman_set_error(con->gearman, "_con_setsockopt",
                       "setsockopt:SO_SNDTIMEO:%d", errno);
     return GEARMAN_ERRNO;
   }
@@ -885,7 +884,7 @@
                   (socklen_t)sizeof(struct timeval));
   if (ret == -1 && errno != ENOPROTOOPT)
   {
-    gearman_error_set(con->gearman, "_con_setsockopt",
+    gearman_set_error(con->gearman, "_con_setsockopt",
                       "setsockopt:SO_RCVTIMEO:%d", errno);
     return GEARMAN_ERRNO;
   }
@@ -894,7 +893,7 @@
   ret= setsockopt(con->fd, SOL_SOCKET, SO_SNDBUF, &ret, (socklen_t)sizeof(int));
   if (ret == -1)
   {
-    gearman_error_set(con->gearman, "_con_setsockopt",
+    gearman_set_error(con->gearman, "_con_setsockopt",
                       "setsockopt:SO_SNDBUF:%d", errno);
     return GEARMAN_ERRNO;
   }
@@ -903,7 +902,7 @@
   ret= setsockopt(con->fd, SOL_SOCKET, SO_RCVBUF, &ret, (socklen_t)sizeof(int));
   if (ret == -1)
   {
-    gearman_error_set(con->gearman, "_con_setsockopt",
+    gearman_set_error(con->gearman, "_con_setsockopt",
                       "setsockopt:SO_RCVBUF:%d", errno);
     return GEARMAN_ERRNO;
   }
@@ -911,16 +910,16 @@
   ret= fcntl(con->fd, F_GETFL, 0);
   if (ret == -1)
   {
-    gearman_error_set(con->gearman, "_con_setsockopt", "fcntl:F_GETFL:%d", errno);
-
+    gearman_set_error(con->gearman, "_con_setsockopt", "fcntl:F_GETFL:%d",
+                      errno);
     return GEARMAN_ERRNO;
   }
 
   ret= fcntl(con->fd, F_SETFL, ret | O_NONBLOCK);
   if (ret == -1)
   {
-    gearman_error_set(con->gearman, "_con_setsockopt", "fcntl:F_SETFL:%d", errno);
-
+    gearman_set_error(con->gearman, "_con_setsockopt", "fcntl:F_SETFL:%d",
+                      errno);
     return GEARMAN_ERRNO;
   }
 
 
=== modified file 'libgearman/conn.h'
--- libgearman/conn.h	2009-09-24 23:43:15 +0000
+++ libgearman/conn.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Connection declarations
+ * @brief Connection Declarations
  */
 
 #ifndef __GEARMAN_CON_H__
@@ -19,11 +19,14 @@
 #endif
 
 /**
- * @addtogroup gearman_con Connection Handling
+ * @addtogroup gearman_con Connection Declarations
+ * @ingroup gearman
+ *
  * This is a low level interface for gearman connections. This is used
  * internally by both client and worker interfaces, so you probably want to
  * look there first. This is usually used to write lower level clients, workers,
  * proxies, or your own server.
+ *
  * @{
  */
 
 
=== modified file 'libgearman/constants.h'
--- libgearman/constants.h	2009-09-28 17:47:34 +0000
+++ libgearman/constants.h	2009-11-04 22:14:14 +0000
@@ -19,7 +19,10 @@
 #endif
 
 /**
- * @addtogroup gearman_constants Gearman Constants
+ * @addtogroup gearman_constants Constants
+ * @ingroup gearman
+ * @ingroup gearman_client
+ * @ingroup gearman_worker
  * @{
  */
 
@@ -40,17 +43,6 @@
 #define GEARMAN_RECV_BUFFER_SIZE 8192
 #define GEARMAN_WORKER_WAIT_TIMEOUT (10 * 1000) /* Milliseconds */
 
-/* Types. */
-typedef struct gearman_st gearman_st;
-typedef struct gearman_con_st gearman_con_st;
-typedef struct gearman_packet_st gearman_packet_st;
-typedef struct gearman_command_info_st gearman_command_info_st;
-typedef struct gearman_task_st gearman_task_st;
-typedef struct gearman_client_st gearman_client_st;
-typedef struct gearman_job_st gearman_job_st;
-typedef struct gearman_worker_st gearman_worker_st;
-typedef struct gearman_worker_function_st gearman_worker_function_st;
-
 /**
  * Return codes.
  */
@@ -111,6 +103,7 @@
  */
 typedef enum
 {
+  GEARMAN_VERBOSE_NEVER,
   GEARMAN_VERBOSE_FATAL,
   GEARMAN_VERBOSE_ERROR,
   GEARMAN_VERBOSE_INFO,
@@ -386,10 +379,24 @@
 } gearman_worker_work_state_t;
 
 /**
- * @addtogroup gearman_constants Gearman Constants
+ * @addtogroup gearman_types Types
+ * @ingroup gearman
+ * @ingroup gearman_client
+ * @ingroup gearman_worker
  * @{
  */
 
+/* Types. */
+typedef struct gearman_st gearman_st;
+typedef struct gearman_con_st gearman_con_st;
+typedef struct gearman_packet_st gearman_packet_st;
+typedef struct gearman_command_info_st gearman_command_info_st;
+typedef struct gearman_task_st gearman_task_st;
+typedef struct gearman_client_st gearman_client_st;
+typedef struct gearman_job_st gearman_job_st;
+typedef struct gearman_worker_st gearman_worker_st;
+typedef struct gearman_worker_function_st gearman_worker_function_st;
+
 /* Function types. */
 typedef gearman_return_t (gearman_workload_fn)(gearman_task_st *task);
 typedef gearman_return_t (gearman_created_fn)(gearman_task_st *task);
 
=== modified file 'libgearman/gearman.c'
--- libgearman/gearman.c	2009-09-28 17:47:34 +0000
+++ libgearman/gearman.c	2009-11-04 22:14:14 +0000
@@ -8,17 +8,13 @@
 
 /**
  * @file
- * @brief Gearman core definitions
+ * @brief Gearman Definitions
  */
 
 #include "common.h"
 
-/*
- * Private declarations
- */
-
 /**
- * @addtogroup gearman_private Private Functions
+ * @addtogroup gearman_static Static Gearman Declarations
  * @ingroup gearman
  * @{
  */
@@ -28,6 +24,7 @@
  */
 static const char *_verbose_name[GEARMAN_VERBOSE_MAX]=
 {
+  "NEVER",
   "FATAL",
   "ERROR",
   "INFO",
@@ -38,7 +35,7 @@
 /** @} */
 
 /*
- * Public definitions
+ * Public Definitions
  */
 
 const char *gearman_version(void)
@@ -108,7 +105,7 @@
 
   for (con= from->con_list; con != NULL; con= con->next)
   {
-    if (gearman_con_clone(gearman, NULL, con) == NULL)
+    if (gearman_clone_con(gearman, NULL, con) == NULL)
     {
       gearman_free(gearman);
       return NULL;
@@ -123,8 +120,8 @@
 
 void gearman_free(gearman_st *gearman)
 {
-  gearman_con_free_all(gearman);
-  gearman_packet_free_all(gearman);
+  gearman_free_all_cons(gearman);
+  gearman_free_all_packets(gearman);
 
   if (gearman->pfds != NULL)
     free(gearman->pfds);
@@ -209,14 +206,14 @@
  * Connection related functions.
  */
 
-gearman_con_st *gearman_con_create(gearman_st *gearman, gearman_con_st *con)
+gearman_con_st *gearman_add_con(gearman_st *gearman, gearman_con_st *con)
 {
   if (con == NULL)
   {
     con= malloc(sizeof(gearman_con_st));
     if (con == NULL)
     {
-      gearman_error_set(gearman, "gearman_con_create", "malloc");
+      gearman_set_error(gearman, "gearman_add_con", "malloc");
       return NULL;
     }
 
@@ -264,10 +261,10 @@
   return con;
 }
 
-gearman_con_st *gearman_con_add(gearman_st *gearman, gearman_con_st *con,
-                                const char *host, in_port_t port)
+gearman_con_st *gearman_add_con_args(gearman_st *gearman, gearman_con_st *con,
+                                     const char *host, in_port_t port)
 {
-  con= gearman_con_create(gearman, con);
+  con= gearman_add_con(gearman, con);
   if (con == NULL)
     return NULL;
 
@@ -277,10 +274,10 @@
   return con;
 }
 
-gearman_con_st *gearman_con_clone(gearman_st *gearman, gearman_con_st *con,
+gearman_con_st *gearman_clone_con(gearman_st *gearman, gearman_con_st *con,
                                   const gearman_con_st *from)
 {
-  con= gearman_con_create(gearman, con);
+  con= gearman_add_con(gearman, con);
   if (con == NULL)
     return NULL;
 
@@ -300,7 +297,7 @@
   gearman_con_reset_addrinfo(con);
 
   if (con->protocol_context != NULL && con->protocol_context_free_fn != NULL)
-    (*con->protocol_context_free_fn)(con, (void *)con->protocol_context);
+    con->protocol_context_free_fn(con, (void *)con->protocol_context);
 
   if (con->gearman->con_list == con)
     con->gearman->con_list= con->next;
@@ -317,13 +314,13 @@
     free(con);
 }
 
-void gearman_con_free_all(gearman_st *gearman)
+void gearman_free_all_cons(gearman_st *gearman)
 {
   while (gearman->con_list != NULL)
     gearman_con_free(gearman->con_list);
 }
 
-gearman_return_t gearman_con_flush_all(gearman_st *gearman)
+gearman_return_t gearman_flush_all(gearman_st *gearman)
 {
   gearman_con_st *con;
   gearman_return_t ret;
@@ -341,8 +338,8 @@
   return GEARMAN_SUCCESS;
 }
 
-gearman_return_t gearman_con_send_all(gearman_st *gearman,
-                                      const gearman_packet_st *packet)
+gearman_return_t gearman_send_all(gearman_st *gearman,
+                                  const gearman_packet_st *packet)
 {
   gearman_return_t ret;
   gearman_con_st *con;
@@ -371,7 +368,7 @@
 
   while (gearman->sending != 0)
   {
-    while ((con= gearman_con_ready(gearman)) != NULL)
+    while ((con= gearman_ready(gearman)) != NULL)
     {
       ret= gearman_con_send(con, packet, true);
       if (ret != GEARMAN_SUCCESS)
@@ -397,7 +394,7 @@
       return GEARMAN_IO_WAIT;
     }
 
-    ret= gearman_con_wait(gearman);
+    ret= gearman_wait(gearman);
     if (ret != GEARMAN_SUCCESS)
     {
       gearman->options= options;
@@ -409,7 +406,7 @@
   return GEARMAN_SUCCESS;
 }
 
-gearman_return_t gearman_con_wait(gearman_st *gearman)
+gearman_return_t gearman_wait(gearman_st *gearman)
 {
   gearman_con_st *con;
   struct pollfd *pfds;
@@ -422,7 +419,7 @@
     pfds= realloc(gearman->pfds, gearman->con_count * sizeof(struct pollfd));
     if (pfds == NULL)
     {
-      gearman_error_set(gearman, "gearman_con_wait", "realloc");
+      gearman_set_error(gearman, "gearman_wait", "realloc");
       return GEARMAN_MEMORY_ALLOCATION_FAILURE;
     }
 
@@ -446,8 +443,7 @@
 
   if (x == 0)
   {
-    gearman_error_set(gearman, "gearman_con_wait",
-                      "no active file descriptors");
+    gearman_set_error(gearman, "gearman_wait", "no active file descriptors");
     return GEARMAN_NO_ACTIVE_FDS;
   }
 
@@ -459,7 +455,7 @@
       if (errno == EINTR)
         continue;
 
-      gearman_error_set(gearman, "gearman_con_wait", "poll:%d", errno);
+      gearman_set_error(gearman, "gearman_wait", "poll:%d", errno);
       gearman->last_errno= errno;
       return GEARMAN_ERRNO;
     }
@@ -469,7 +465,7 @@
 
   if (ret == 0)
   {
-    gearman_error_set(gearman, "gearman_con_wait", "timeout reached");
+    gearman_set_error(gearman, "gearman_wait", "timeout reached");
     return GEARMAN_TIMEOUT;
   }
 
@@ -489,7 +485,7 @@
   return GEARMAN_SUCCESS;
 }
 
-gearman_con_st *gearman_con_ready(gearman_st *gearman)
+gearman_con_st *gearman_ready(gearman_st *gearman)
 {
   gearman_con_st *con;
 
@@ -508,17 +504,17 @@
   return NULL;
 }
 
-gearman_return_t gearman_con_echo(gearman_st *gearman, const void *workload,
-                                  size_t workload_size)
+gearman_return_t gearman_echo(gearman_st *gearman, const void *workload,
+                              size_t workload_size)
 {
   gearman_con_st *con;
   gearman_options_t options= gearman->options;
   gearman_packet_st packet;
   gearman_return_t ret;
 
-  ret= gearman_packet_add(gearman, &packet, GEARMAN_MAGIC_REQUEST,
-                          GEARMAN_COMMAND_ECHO_REQ, workload, workload_size,
-                          NULL);
+  ret= gearman_add_packet_args(gearman, &packet, GEARMAN_MAGIC_REQUEST,
+                               GEARMAN_COMMAND_ECHO_REQ, &workload,
+                               &workload_size, 1);
   if (ret != GEARMAN_SUCCESS)
     return ret;
 
@@ -548,7 +544,7 @@
       gearman_packet_free(&(con->packet));
       gearman_packet_free(&packet);
       gearman->options= options;
-      gearman_error_set(gearman, "gearman_con_echo", "corruption during echo");
+      gearman_set_error(gearman, "gearman_echo", "corruption during echo");
       return GEARMAN_ECHO_DATA_CORRUPTION;
     }
 
@@ -564,15 +560,15 @@
  * Packet related functions.
  */
 
-gearman_packet_st *gearman_packet_create(gearman_st *gearman,
-                                         gearman_packet_st *packet)
+gearman_packet_st *gearman_add_packet(gearman_st *gearman,
+                                      gearman_packet_st *packet)
 {
   if (packet == NULL)
   {
     packet= malloc(sizeof(gearman_packet_st));
     if (packet == NULL)
     {
-      gearman_error_set(gearman, "gearman_packet_create", "malloc");
+      gearman_set_error(gearman, "gearman_add_packet", "malloc");
       return NULL;
     }
 
@@ -604,42 +600,34 @@
   return packet;
 }
 
-gearman_return_t gearman_packet_add(gearman_st *gearman,
-                                    gearman_packet_st *packet,
-                                    gearman_magic_t magic,
-                                    gearman_command_t command,
-                                    const void *arg, ...)
+gearman_return_t gearman_add_packet_args(gearman_st *gearman,
+                                         gearman_packet_st *packet,
+                                         gearman_magic_t magic,
+                                         gearman_command_t command,
+                                         const void *args[],
+                                         const size_t args_size[],
+                                         size_t args_count)
 {
-  va_list ap;
-  size_t arg_size;
   gearman_return_t ret;
+  size_t x;
 
-  packet= gearman_packet_create(gearman, packet);
+  packet= gearman_add_packet(gearman, packet);
   if (packet == NULL)
     return GEARMAN_MEMORY_ALLOCATION_FAILURE;
 
   packet->magic= magic;
   packet->command= command;
 
-  va_start(ap, arg);
-
-  while (arg != NULL)
+  for (x= 0; x < args_count; x++)
   {
-    arg_size = va_arg(ap, size_t);
-
-    ret= gearman_packet_add_arg(packet, arg, arg_size);
+    ret= gearman_packet_add_arg(packet, args[x], args_size[x]);
     if (ret != GEARMAN_SUCCESS)
     {
-      va_end(ap);
       gearman_packet_free(packet);
       return ret;
     }
-
-    arg = va_arg(ap, void *);
   }
 
-  va_end(ap);
-
   return gearman_packet_pack_header(packet);
 }
 
@@ -651,11 +639,11 @@
   if (packet->options & GEARMAN_PACKET_FREE_DATA && packet->data != NULL)
   {
     if (packet->gearman->workload_free_fn == NULL)
-      free((void *)(packet->data));
+      free((void *)packet->data);
     else
     {
       packet->gearman->workload_free_fn((void *)(packet->data),
-                              (void *)(packet->gearman->workload_free_context));
+                                (void *)packet->gearman->workload_free_context);
     }
   }
 
@@ -674,50 +662,65 @@
     free(packet);
 }
 
-void gearman_packet_free_all(gearman_st *gearman)
+void gearman_free_all_packets(gearman_st *gearman)
 {
   while (gearman->packet_list != NULL)
     gearman_packet_free(gearman->packet_list);
 }
 
 /*
- * Local package functions.
+ * Local Definitions
  */
-void gearman_error_set(gearman_st *gearman, const char *function,
+
+void gearman_set_error(gearman_st *gearman, const char *function,
                        const char *format, ...)
 {
-  size_t length;
+  size_t size;
   char *ptr;
   char log_buffer[GEARMAN_MAX_ERROR_SIZE];
-  va_list arg;
-
-  va_start(arg, format);
-
-  length= strlen(function);
-
-  /* Copy the function name and : before the format */
-  ptr= memcpy(log_buffer, function, length);
-  ptr+= length;
+  va_list args;
+
+  size= strlen(function);
+  ptr= memcpy(log_buffer, function, size);
+  ptr+= size;
   ptr[0]= ':';
-  length++;
+  size++;
   ptr++;
 
-  length+= (size_t)vsnprintf(ptr, GEARMAN_MAX_ERROR_SIZE - length, format, arg);
-
-  if (gearman->log_fn == NULL)
-  {
-    if (length >= GEARMAN_MAX_ERROR_SIZE)
-      length= GEARMAN_MAX_ERROR_SIZE - 1;
-
-    memcpy(gearman->last_error, log_buffer, length + 1);
-  }
-  else
-  {
-    (*(gearman->log_fn))(log_buffer, GEARMAN_VERBOSE_FATAL,
-                         (void *)(gearman)->log_context);
-  }
-
-  va_end(arg);
+  va_start(args, format);
+  size+= (size_t)vsnprintf(ptr, GEARMAN_MAX_ERROR_SIZE - size, format, args);
+  va_end(args);
+
+  if (gearman->log_fn == NULL)
+  {
+    if (size >= GEARMAN_MAX_ERROR_SIZE)
+      size= GEARMAN_MAX_ERROR_SIZE - 1;
+
+    memcpy(gearman->last_error, log_buffer, size + 1);
+  }
+  else
+  {
+    gearman->log_fn(log_buffer, GEARMAN_VERBOSE_FATAL,
+                    (void *)gearman->log_context);
+  }
+}
+
+void gearman_log(gearman_st *gearman, gearman_verbose_t verbose,
+                 const char *format, va_list args)
+{
+  char log_buffer[GEARMAN_MAX_ERROR_SIZE];
+
+  if (gearman->log_fn == NULL)
+  {
+    printf("%5s: ", gearman_verbose_name(verbose));
+    vprintf(format, args);
+    printf("\n");
+  }
+  else
+  {
+    vsnprintf(log_buffer, GEARMAN_MAX_ERROR_SIZE, format, args);
+    gearman->log_fn(log_buffer, verbose, (void *)gearman->log_context);
+  }
 }
 
 gearman_return_t gearman_parse_servers(const char *servers,
 
=== modified file 'libgearman/gearman.h'
--- libgearman/gearman.h	2009-10-02 01:13:31 +0000
+++ libgearman/gearman.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Gearman core declarations
+ * @brief Gearman Declarations
  */
 
 #ifndef __GEARMAN_H__
@@ -25,7 +25,6 @@
 #include <arpa/inet.h>
 #include <poll.h>
 #include <sys/uio.h>
-#include <event.h>
 #include <stdarg.h>
 
 #include <libgearman/visibility.h>
@@ -43,7 +42,8 @@
 #endif
 
 /**
- * @addtogroup gearman Gearman Core Interface
+ * @addtogroup gearman Gearman Declarations
+ *
  * This is a low level interface for gearman library instances. This is used
  * internally by both client and worker interfaces, so you probably want to
  * look there first. This is usually used to write lower level clients, workers,
@@ -52,6 +52,7 @@
  * There is no locking within a single gearman_st structure, so for threaded
  * applications you must either ensure isolation in the application or use
  * multiple gearman_st structures (for example, one for each thread).
+ *
  * @{
  */
 
@@ -266,7 +267,7 @@
  *  failure this will be NULL.
  */
 GEARMAN_API
-gearman_con_st *gearman_con_create(gearman_st *gearman, gearman_con_st *con);
+gearman_con_st *gearman_add_con(gearman_st *gearman, gearman_con_st *con);
 
 /**
  * Create a connection structure with the given host and port.
@@ -280,8 +281,8 @@
  *  failure this will be NULL.
  */
 GEARMAN_API
-gearman_con_st *gearman_con_add(gearman_st *gearman, gearman_con_st *con,
-                                const char *host, in_port_t port);
+gearman_con_st *gearman_add_con_args(gearman_st *gearman, gearman_con_st *con,
+                                     const char *host, in_port_t port);
 
 /**
  * Clone a connection structure.
@@ -294,14 +295,14 @@
  *  failure this will be NULL.
  */
 GEARMAN_API
-gearman_con_st *gearman_con_clone(gearman_st *gearman, gearman_con_st *con,
+gearman_con_st *gearman_clone_con(gearman_st *gearman, gearman_con_st *con,
                                   const gearman_con_st *from);
 
 /**
  * Free a connection structure.
  *
- * @param[in] con Structure previously initialized with gearman_con_create(),
- *  gearman_con_add(), or gearman_con_clone().
+ * @param[in] con Structure previously initialized with gearman_add_con(),
+ *  gearman_add_con_args(), or gearman_clone_con().
  */
 GEARMAN_API
 void gearman_con_free(gearman_con_st *con);
@@ -313,7 +314,7 @@
  *  gearman_clone().
  */
 GEARMAN_API
-void gearman_con_free_all(gearman_st *gearman);
+void gearman_free_all_cons(gearman_st *gearman);
 
 /**
  * Flush the send buffer for all connections.
@@ -323,7 +324,7 @@
  * @return Standard gearman return value.
  */
 GEARMAN_API
-gearman_return_t gearman_con_flush_all(gearman_st *gearman);
+gearman_return_t gearman_flush_all(gearman_st *gearman);
 
 /**
  * Send packet to all connections.
@@ -334,8 +335,8 @@
  * @return Standard gearman return value.
  */
 GEARMAN_API
-gearman_return_t gearman_con_send_all(gearman_st *gearman,
-                                      const gearman_packet_st *packet);
+gearman_return_t gearman_send_all(gearman_st *gearman,
+                                  const gearman_packet_st *packet);
 
 /**
  * Wait for I/O on connections.
@@ -345,7 +346,7 @@
  * @return Standard gearman return value.
  */
 GEARMAN_API
-gearman_return_t gearman_con_wait(gearman_st *gearman);
+gearman_return_t gearman_wait(gearman_st *gearman);
 
 /**
  * Get next connection that is ready for I/O.
@@ -355,7 +356,7 @@
  * @return Connection that is ready for I/O, or NULL if there are none.
  */
 GEARMAN_API
-gearman_con_st *gearman_con_ready(gearman_st *gearman);
+gearman_con_st *gearman_ready(gearman_st *gearman);
 
 /**
  * Test echo with all connections.
@@ -367,8 +368,8 @@
  * @return Standard gearman return value.
  */
 GEARMAN_API
-gearman_return_t gearman_con_echo(gearman_st *gearman, const void *workload,
-                                  size_t workload_size);
+gearman_return_t gearman_echo(gearman_st *gearman, const void *workload,
+                              size_t workload_size);
 
 /*
  * Packet related functions.
@@ -384,20 +385,27 @@
  *  failure this will be NULL.
  */
 GEARMAN_API
-gearman_packet_st *gearman_packet_create(gearman_st *gearman,
-                                         gearman_packet_st *packet);
+gearman_packet_st *gearman_add_packet(gearman_st *gearman,
+                                      gearman_packet_st *packet);
 
 /**
- * Initialize a packet with all arguments. Variable list is NULL terminated
- * alternating argument and argument size (size_t) pairs. For example:
+ * Initialize a packet with all arguments. For example:
  *
  * @code
- * ret= gearman_packet_add_args(gearman, packet,
+ * void *args[3];
+ * size_t args_suze[3];
+ *
+ * args[0]= function_name;
+ * args_size[0]= strlen(function_name) + 1;
+ * args[1]= unique_string;
+ * args_size[1]= strlen(unique_string,) + 1;
+ * args[2]= workload;
+ * args_size[2]= workload_size;
+ *
+ * ret= gearman_add_packet_args(gearman, packet,
  *                              GEARMAN_MAGIC_REQUEST,
  *                              GEARMAN_COMMAND_SUBMIT_JOB,
- *                              function_name, strlen(function_name) + 1,
- *                              unique_string, strlen(unique_string) + 1,
- *                              workload, workload_size, NULL);
+ *                              args, args_size, 3);
  * @endcode
  *
  * @param[in] gearman Structure previously initialized with gearman_create() or
@@ -405,21 +413,25 @@
  * @param[in] packet Pre-allocated packet to initialize with arguments.
  * @param[in] magic Magic type for packet header.
  * @param[in] command Command type for packet.
- * @param[in] arg NULL terminated argument list in pairs of "arg, arg_size".
+ * @param[in] args Array of arguments to add.
+ * @param[in] args_size Array of sizes of each byte array in the args array.
+ * @param[in] args_count Number of elements in args/args_sizes arrays.
  * @return Standard gearman return value.
  */
 GEARMAN_API
-gearman_return_t gearman_packet_add(gearman_st *gearman,
-                                    gearman_packet_st *packet,
-                                    gearman_magic_t magic,
-                                    gearman_command_t command,
-                                    const void *arg, ...);
+gearman_return_t gearman_add_packet_args(gearman_st *gearman,
+                                         gearman_packet_st *packet,
+                                         gearman_magic_t magic,
+                                         gearman_command_t command,
+                                         const void *args[],
+                                         const size_t args_size[],
+                                         size_t args_count);
 
 /**
  * Free a packet structure.
  *
  * @param[in] packet Structure previously initialized with
- *   gearman_packet_create() or gearman_packet_add().
+ *   gearman_add_packet() or gearman_add_packet_args().
  */
 GEARMAN_API
 void gearman_packet_free(gearman_packet_st *packet);
@@ -431,7 +443,7 @@
  *  gearman_clone().
  */
 GEARMAN_API
-void gearman_packet_free_all(gearman_st *gearman);
+void gearman_free_all_packets(gearman_st *gearman);
 
 /** @} */
 
 
=== added file 'libgearman/gearman_local.h'
--- libgearman/gearman_local.h	1970-01-01 00:00:00 +0000
+++ libgearman/gearman_local.h	2009-11-04 22:14:14 +0000
@@ -0,0 +1,150 @@
+/* Gearman server and library
+ * Copyright (C) 2008 Brian Aker, Eric Day
+ * All rights reserved.
+ *
+ * Use and distribution licensed under the BSD license.  See
+ * the COPYING file in the parent directory for full text.
+ */
+
+/**
+ * @file
+ * @brief Local Gearman Declarations
+ */
+
+#ifndef __GEARMAN_LOCAL_H__
+#define __GEARMAN_LOCAL_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @addtogroup gearman_local Local Gearman Declarations
+ * @ingroup gearman
+ * @{
+ */
+
+/**
+ * Set the error string.
+ *
+ * @param[in] gearman Structure previously initialized with gearman_create() or
+ *  gearman_clone().
+ * @param[in] function Name of function the error happened in. 
+ * @param[in] format Format and variable argument list of message.
+ */
+GEARMAN_LOCAL
+void gearman_set_error(gearman_st *gearman, const char *function,
+                       const char *format, ...);
+
+/**
+ * Log a message.
+ *
+ * @param[in] gearman Structure previously initialized with gearman_create() or
+ *  gearman_clone().
+ * @param[in] verbose Logging level of the message.
+ * @param[in] format Format and variable argument list of message.
+ * @param[in] args Variable argument list that has been initialized.
+ */
+GEARMAN_LOCAL
+void gearman_log(gearman_st *gearman, gearman_verbose_t verbose,
+                 const char *format, va_list args);
+
+/**
+ * Log a fatal message, see gearman_log() for argument details.
+ */
+static inline void gearman_log_fatal(gearman_st *gearman, const char *format,
+                                     ...)
+{
+  va_list args;
+
+  if (gearman->verbose >= GEARMAN_VERBOSE_FATAL)
+  {
+    va_start(args, format);
+    gearman_log(gearman, GEARMAN_VERBOSE_FATAL, format, args);
+    va_end(args);
+  }
+}
+/**
+ * Log an error message, see gearman_log() for argument details.
+ */
+static inline void gearman_log_error(gearman_st *gearman, const char *format,
+                                     ...)
+{
+  va_list args;
+
+  if (gearman->verbose >= GEARMAN_VERBOSE_ERROR)
+  {
+    va_start(args, format);
+    gearman_log(gearman, GEARMAN_VERBOSE_ERROR, format, args);
+    va_end(args);
+  }
+}
+
+/**
+ * Log an info message, see gearman_log() for argument details.
+ */
+static inline void gearman_log_info(gearman_st *gearman, const char *format,
+                                    ...)
+{
+  va_list args;
+
+  if (gearman->verbose >= GEARMAN_VERBOSE_INFO)
+  {
+    va_start(args, format);
+    gearman_log(gearman, GEARMAN_VERBOSE_INFO, format, args);
+    va_end(args);
+  }
+}
+
+/**
+ * Log a debug message, see gearman_log() for argument details.
+ */
+static inline void gearman_log_debug(gearman_st *gearman, const char *format,
+                                     ...)
+{
+  va_list args;
+
+  if (gearman->verbose >= GEARMAN_VERBOSE_DEBUG)
+  {
+    va_start(args, format);
+    gearman_log(gearman, GEARMAN_VERBOSE_DEBUG, format, args);
+    va_end(args);
+  }
+}
+
+/**
+ * Log a crazy message, see gearman_log() for argument details.
+ */
+static inline void gearman_log_crazy(gearman_st *gearman, const char *format,
+                                     ...)
+{
+  va_list args;
+
+  if (gearman->verbose >= GEARMAN_VERBOSE_CRAZY)
+  {
+    va_start(args, format);
+    gearman_log(gearman, GEARMAN_VERBOSE_CRAZY, format, args);
+    va_end(args);
+  }
+}
+
+/**
+ * Utility function used for parsing server lists.
+ *
+ * @param[in] servers String containing a list of servers to parse.
+ * @param[in] callback Function to call for each server that is found.
+ * @param[in] context Argument to pass along with callback function.
+ * @return Standard Gearman return value.
+ */
+GEARMAN_LOCAL
+gearman_return_t gearman_parse_servers(const char *servers,
+                                       gearman_parse_server_fn *callback,
+                                       const void *context);
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __GEARMAN_LOCAL_H__ */
 
=== modified file 'libgearman/job.c'
--- libgearman/job.c	2009-09-23 05:25:01 +0000
+++ libgearman/job.c	2009-11-04 22:14:14 +0000
@@ -8,17 +8,13 @@
 
 /**
  * @file
- * @brief Job definitions
+ * @brief Job Definitions
  */
 
 #include "common.h"
 
-/*
- * Private declarations
- */
-
 /**
- * @addtogroup gearman_job_private Private Job Functions
+ * @addtogroup gearman_job_static Static Job Declarations
  * @ingroup gearman_job
  * @{
  */
@@ -31,20 +27,26 @@
 /** @} */
 
 /*
- * Public definitions
+ * Public Definitions
  */
 
 gearman_return_t gearman_job_send_data(gearman_job_st *job, const void *data,
                                        size_t data_size)
 {
   gearman_return_t ret;
+  const void *args[2];
+  size_t args_size[2];
 
   if (!(job->options & GEARMAN_JOB_WORK_IN_USE))
   {
-    ret= gearman_packet_add(job->worker->gearman, &(job->work),
-                            GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_WORK_DATA,
-                            job->assigned.arg[0], job->assigned.arg_size[0],
-                            data, data_size, NULL);
+    args[0]= job->assigned.arg[0];
+    args_size[0]= job->assigned.arg_size[0];
+    args[1]= data;
+    args_size[1]= data_size;
+    ret= gearman_add_packet_args(job->worker->gearman, &(job->work),
+                                 GEARMAN_MAGIC_REQUEST,
+                                 GEARMAN_COMMAND_WORK_DATA,
+                                 args, args_size, 2);
     if (ret != GEARMAN_SUCCESS)
       return ret;
 
@@ -59,13 +61,19 @@
                                           size_t warning_size)
 {
   gearman_return_t ret;
+  const void *args[2];
+  size_t args_size[2];
 
   if (!(job->options & GEARMAN_JOB_WORK_IN_USE))
   {
-    ret= gearman_packet_add(job->worker->gearman, &(job->work),
-                            GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_WORK_WARNING,
-                            job->assigned.arg[0], job->assigned.arg_size[0],
-                            warning, warning_size, NULL);
+    args[0]= job->assigned.arg[0];
+    args_size[0]= job->assigned.arg_size[0];
+    args[1]= warning;
+    args_size[1]= warning_size;
+    ret= gearman_add_packet_args(job->worker->gearman, &(job->work),
+                                 GEARMAN_MAGIC_REQUEST,
+                                 GEARMAN_COMMAND_WORK_WARNING,
+                                 args, args_size, 2);
     if (ret != GEARMAN_SUCCESS)
       return ret;
 
@@ -82,18 +90,24 @@
   gearman_return_t ret;
   char numerator_string[12];
   char denominator_string[12];
+  const void *args[3];
+  size_t args_size[3];
 
   if (!(job->options & GEARMAN_JOB_WORK_IN_USE))
   {
     snprintf(numerator_string, 12, "%u", numerator);
     snprintf(denominator_string, 12, "%u", denominator);
 
-    ret= gearman_packet_add(job->worker->gearman, &(job->work),
-                            GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_WORK_STATUS,
-                            job->assigned.arg[0], job->assigned.arg_size[0],
-                            numerator_string, strlen(numerator_string) + 1,
-                            denominator_string, strlen(denominator_string),
-                            NULL);
+    args[0]= job->assigned.arg[0];
+    args_size[0]= job->assigned.arg_size[0];
+    args[1]= numerator_string;
+    args_size[1]= strlen(numerator_string) + 1;
+    args[2]= denominator_string;
+    args_size[2]= strlen(denominator_string);
+    ret= gearman_add_packet_args(job->worker->gearman, &(job->work),
+                                 GEARMAN_MAGIC_REQUEST,
+                                 GEARMAN_COMMAND_WORK_STATUS,
+                                 args, args_size, 3);
     if (ret != GEARMAN_SUCCESS)
       return ret;
 
@@ -108,17 +122,22 @@
                                            size_t result_size)
 {
   gearman_return_t ret;
+  const void *args[2];
+  size_t args_size[2];
 
   if (job->options & GEARMAN_JOB_FINISHED)
     return GEARMAN_SUCCESS;
 
   if (!(job->options & GEARMAN_JOB_WORK_IN_USE))
   {
-    ret= gearman_packet_add(job->worker->gearman, &(job->work),
-                            GEARMAN_MAGIC_REQUEST,
-                            GEARMAN_COMMAND_WORK_COMPLETE,
-                            job->assigned.arg[0], job->assigned.arg_size[0],
-                            result, result_size, NULL);
+    args[0]= job->assigned.arg[0];
+    args_size[0]= job->assigned.arg_size[0];
+    args[1]= result;
+    args_size[1]= result_size;
+    ret= gearman_add_packet_args(job->worker->gearman, &(job->work),
+                                 GEARMAN_MAGIC_REQUEST,
+                                 GEARMAN_COMMAND_WORK_COMPLETE,
+                                 args, args_size, 2);
     if (ret != GEARMAN_SUCCESS)
       return ret;
 
@@ -138,14 +157,19 @@
                                             size_t exception_size)
 {
   gearman_return_t ret;
+  const void *args[2];
+  size_t args_size[2];
 
   if (!(job->options & GEARMAN_JOB_WORK_IN_USE))
   {
-    ret= gearman_packet_add(job->worker->gearman, &(job->work),
-                            GEARMAN_MAGIC_REQUEST,
-                            GEARMAN_COMMAND_WORK_EXCEPTION,
-                            job->assigned.arg[0], job->assigned.arg_size[0],
-                            exception, exception_size, NULL);
+    args[0]= job->assigned.arg[0];
+    args_size[0]= job->assigned.arg_size[0];
+    args[1]= exception;
+    args_size[1]= exception_size;
+    ret= gearman_add_packet_args(job->worker->gearman, &(job->work),
+                                 GEARMAN_MAGIC_REQUEST,
+                                 GEARMAN_COMMAND_WORK_EXCEPTION,
+                                 args, args_size, 2);
     if (ret != GEARMAN_SUCCESS)
       return ret;
 
@@ -158,16 +182,20 @@
 gearman_return_t gearman_job_send_fail(gearman_job_st *job)
 {
   gearman_return_t ret;
+  const void *args[1];
+  size_t args_size[1];
 
   if (job->options & GEARMAN_JOB_FINISHED)
     return GEARMAN_SUCCESS;
 
   if (!(job->options & GEARMAN_JOB_WORK_IN_USE))
   {
-    ret= gearman_packet_add(job->worker->gearman, &(job->work),
-                            GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_WORK_FAIL,
-                            job->assigned.arg[0], job->assigned.arg_size[0] - 1,
-                            NULL);
+    args[0]= job->assigned.arg[0];
+    args_size[0]= job->assigned.arg_size[0] - 1;
+    ret= gearman_add_packet_args(job->worker->gearman, &(job->work),
+                                 GEARMAN_MAGIC_REQUEST,
+                                 GEARMAN_COMMAND_WORK_FAIL,
+                                 args, args_size, 2);
     if (ret != GEARMAN_SUCCESS)
       return ret;
 
@@ -215,7 +243,7 @@
 }
 
 /*
- * Private definitions
+ * Static Definitions
  */
 
 static gearman_return_t _job_send(gearman_job_st *job)
 
=== modified file 'libgearman/job.h'
--- libgearman/job.h	2009-09-23 05:25:01 +0000
+++ libgearman/job.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Job declarations
+ * @brief Job Declarations
  */
 
 #ifndef __GEARMAN_JOB_H__
@@ -19,10 +19,12 @@
 #endif
 
 /**
- * @addtogroup gearman_job Job Management
+ * @addtogroup gearman_job Job Declarations
  * @ingroup gearman_worker
+ *
  * The job functions are used to manage jobs assigned to workers. It is most
  * commonly used with the worker interface.
+ *
  * @{
  */
 
 
=== modified file 'libgearman/packet.c'
--- libgearman/packet.c	2009-09-26 08:14:01 +0000
+++ libgearman/packet.c	2009-11-04 22:14:14 +0000
@@ -8,17 +8,13 @@
 
 /**
  * @file
- * @brief Packet definitions
+ * @brief Packet Definitions
  */
 
 #include "common.h"
 
-/*
- * Private declarations
- */
-
 /**
- * @addtogroup gearman_packet_private Private Packet Functions
+ * @addtogroup gearman_packet_static Static Packet Declarations
  * @ingroup gearman_packet
  * @{
  */
@@ -71,7 +67,7 @@
 /** @} */
 
 /*
- * Public definitions
+ * Public Definitions
  */
 
 gearman_return_t gearman_packet_add_arg(gearman_packet_st *packet,
@@ -85,7 +81,7 @@
       (!(gearman_command_info_list[packet->command].data) ||
        packet->data != NULL))
   {
-    gearman_error_set(packet->gearman, "gearman_packet_add_arg",
+    gearman_set_error(packet->gearman, "gearman_packet_add_arg",
                       "too many arguments for command");
     return GEARMAN_TOO_MANY_ARGS;
   }
@@ -110,7 +106,7 @@
     new_args= realloc(packet->args, packet->args_size + arg_size);
     if (new_args == NULL)
     {
-      gearman_error_set(packet->gearman, "gearman_packet_add_arg", "realloc");
+      gearman_set_error(packet->gearman, "gearman_packet_add_arg", "realloc");
       return GEARMAN_MEMORY_ALLOCATION_FAILURE;
     }
 
@@ -169,7 +165,7 @@
     break;
 
   default:
-    gearman_error_set(packet->gearman, "gearman_packet_pack_header",
+    gearman_set_error(packet->gearman, "gearman_packet_pack_header",
                       "invalid magic value");
     return GEARMAN_INVALID_MAGIC;
   }
@@ -177,7 +173,7 @@
   if (packet->command == GEARMAN_COMMAND_TEXT ||
       packet->command >= GEARMAN_COMMAND_MAX)
   {
-    gearman_error_set(packet->gearman, "gearman_packet_pack_header",
+    gearman_set_error(packet->gearman, "gearman_packet_pack_header",
                       "invalid command value");
     return GEARMAN_INVALID_COMMAND;
   }
@@ -206,7 +202,7 @@
     packet->magic= GEARMAN_MAGIC_RESPONSE;
   else
   {
-    gearman_error_set(packet->gearman, "gearman_packet_unpack_header",
+    gearman_set_error(packet->gearman, "gearman_packet_unpack_header",
                       "invalid magic value");
     return GEARMAN_INVALID_MAGIC;
   }
@@ -217,7 +213,7 @@
   if (packet->command == GEARMAN_COMMAND_TEXT ||
       packet->command >= GEARMAN_COMMAND_MAX)
   {
-    gearman_error_set(packet->gearman, "gearman_packet_unpack_header",
+    gearman_set_error(packet->gearman, "gearman_packet_unpack_header",
                       "invalid command value");
     return GEARMAN_INVALID_COMMAND;
   }
 
=== modified file 'libgearman/packet.h'
--- libgearman/packet.h	2009-09-24 23:43:15 +0000
+++ libgearman/packet.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Packet declarations
+ * @brief Packet Declarations
  */
 
 #ifndef __GEARMAN_PACKET_H__
@@ -26,11 +26,14 @@
 gearman_command_info_st gearman_command_info_list[GEARMAN_COMMAND_MAX];
 
 /**
- * @addtogroup gearman_packet Packet Handling
+ * @addtogroup gearman_packet Packet Declarations
+ * @ingroup gearman
+ *
  * This is a low level interface for gearman packet. This is used internally
  * internally by both client and worker interfaces (or more specifically, tasks
  * and jobs), so you probably want to look there first. This is usually used to
  * write lower level clients, workers, proxies, or your own server.
+ *
  * @{
  */
 
 
=== modified file 'libgearman/structs.h'
--- libgearman/structs.h	2009-09-28 17:47:34 +0000
+++ libgearman/structs.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Struct definitions
+ * @brief Struct Definitions
  */
 
 #ifndef __GEARMAN_STRUCTS_H__
 
=== modified file 'libgearman/task.c'
--- libgearman/task.c	2009-09-23 05:25:01 +0000
+++ libgearman/task.c	2009-11-04 22:14:14 +0000
@@ -8,13 +8,13 @@
 
 /**
  * @file
- * @brief Task definitions
+ * @brief Task Definitions
  */
 
 #include "common.h"
 
 /*
- * Public definitions
+ * Public Definitions
  */
 
 void *gearman_task_context(const gearman_task_st *task)
 
=== modified file 'libgearman/task.h'
--- libgearman/task.h	2009-09-23 05:25:01 +0000
+++ libgearman/task.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Task declarations
+ * @brief Task Declarations
  */
 
 #ifndef __GEARMAN_TASK_H__
@@ -19,10 +19,12 @@
 #endif
 
 /**
- * @addtogroup gearman_task Task Management
+ * @addtogroup gearman_task Task Declarations
  * @ingroup gearman_client
+ *
  * The task functions are used to manage tasks being run by clients. They are
  * most commonly used with the client interface.
+ *
  * @{
  */
 
 
=== modified file 'libgearman/visibility.h'
--- libgearman/visibility.h	2009-09-18 02:48:06 +0000
+++ libgearman/visibility.h	2009-11-04 22:14:14 +0000
@@ -10,14 +10,13 @@
 
 /**
  * @file
- * @brief Visibility control macros
+ * @brief Visibility Control Macros
  */
 
 #ifndef __GEARMAN_VISIBILITY_H
 #define __GEARMAN_VISIBILITY_H
 
 /**
- *
  * GEARMAN_API is used for the public API symbols. It either DLL imports or
  * DLL exports (or does nothing for static build).
  *
@@ -28,6 +27,9 @@
 # if defined(HAVE_VISIBILITY)
 #  define GEARMAN_API __attribute__ ((visibility("default")))
 #  define GEARMAN_LOCAL  __attribute__ ((visibility("hidden")))
+# elif defined (__SUNPRO_C) && (__SUNPRO_C >= 0x550)
+#  define GEARMAN_API __global
+#  define GEARMAN_API __hidden
 # elif defined(_MSC_VER)
 #  define GEARMAN_API extern __declspec(dllexport)
 #  define GEARMAN_LOCAL
 
=== modified file 'libgearman/worker.c'
--- libgearman/worker.c	2009-09-28 17:47:34 +0000
+++ libgearman/worker.c	2009-11-04 22:14:14 +0000
@@ -8,17 +8,13 @@
 
 /**
  * @file
- * @brief Worker definitions
+ * @brief Worker Definitions
  */
 
 #include "common.h"
 
-/*
- * Private declarations
- */
-
 /**
- * @addtogroup gearman_worker_private Private Worker Functions
+ * @addtogroup gearman_worker_static Static Worker Declarations
  * @ingroup gearman_worker
  * @{
  */
@@ -63,7 +59,7 @@
 /** @} */
 
 /*
- * Public definitions
+ * Public Definitions
  */
 
 gearman_worker_st *gearman_worker_create(gearman_worker_st *worker)
@@ -140,7 +136,7 @@
     else
     {
       worker->gearman->workload_free_fn(worker->work_result,
-                              (void *)(worker->gearman->workload_free_context));
+                                (void *)worker->gearman->workload_free_context);
     }
   }
 
@@ -262,7 +258,7 @@
 gearman_return_t gearman_worker_add_server(gearman_worker_st *worker,
                                            const char *host, in_port_t port)
 {
-  if (gearman_con_add(worker->gearman, NULL, host, port) == NULL)
+  if (gearman_add_con_args(worker->gearman, NULL, host, port) == NULL)
     return GEARMAN_MEMORY_ALLOCATION_FAILURE;
 
   return GEARMAN_SUCCESS;
@@ -274,9 +270,14 @@
   return gearman_parse_servers(servers, _worker_add_server, worker);
 }
 
+void gearman_worker_remove_servers(gearman_worker_st *worker)
+{
+  gearman_free_all_cons(worker->gearman);
+}
+
 gearman_return_t gearman_worker_wait(gearman_worker_st *worker)
 {
-  return gearman_con_wait(worker->gearman);
+  return gearman_wait(worker->gearman);
 }
 
 gearman_return_t gearman_worker_register(gearman_worker_st *worker,
@@ -291,6 +292,8 @@
 {
   gearman_worker_function_st *function;
   gearman_return_t ret;
+  const void *args[1];
+  size_t args_size[1];
 
   for (function= worker->function_list; function != NULL;
        function= function->next)
@@ -304,10 +307,11 @@
 
   gearman_packet_free(&(function->packet));
 
-  ret= gearman_packet_add(worker->gearman, &(function->packet),
-                          GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_CANT_DO,
-                          (uint8_t *)function_name, strlen(function_name),
-                          NULL);
+  args[0]= function_name;
+  args_size[0]= strlen(function_name);
+  ret= gearman_add_packet_args(worker->gearman, &(function->packet),
+                               GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_CANT_DO,
+                               args, args_size, 1);
   if (ret != GEARMAN_SUCCESS)
   {
     function->options&=
@@ -335,9 +339,11 @@
 
   gearman_packet_free(&(worker->function_list->packet));
 
-  ret= gearman_packet_add(worker->gearman, &(worker->function_list->packet),
-                          GEARMAN_MAGIC_REQUEST,
-                          GEARMAN_COMMAND_RESET_ABILITIES, NULL);
+  ret= gearman_add_packet_args(worker->gearman,
+                               &(worker->function_list->packet),
+                               GEARMAN_MAGIC_REQUEST,
+                               GEARMAN_COMMAND_RESET_ABILITIES,
+                               NULL, NULL, 0);
   if (ret != GEARMAN_SUCCESS)
   {
     worker->function_list->options&=
@@ -419,7 +425,7 @@
 
       if (worker->function_list == NULL)
       {
-        gearman_error_set(worker->gearman, "gearman_worker_grab_job",
+        gearman_set_error(worker->gearman, "gearman_worker_grab_job",
                           "no functions have been registered");
         *ret_ptr= GEARMAN_NO_REGISTERED_FUNCTIONS;
         return NULL;
@@ -521,7 +527,7 @@
 
           if (worker->job->assigned.command != GEARMAN_COMMAND_NOOP)
           {
-            gearman_error_set(worker->gearman, "gearman_worker_grab_job",
+            gearman_set_error(worker->gearman, "gearman_worker_grab_job",
                               "unexpected packet:%s",
                               gearman_command_info_list[worker->job->assigned.command].name);
             gearman_packet_free(&(worker->job->assigned));
@@ -588,7 +594,7 @@
 
           if (worker->options & GEARMAN_WORKER_TIMEOUT_RETURN)
           {
-            gearman_error_set(worker->gearman, "gearman_worker_grab_job",
+            gearman_set_error(worker->gearman, "gearman_worker_grab_job",
                               "timeout reached");
             *ret_ptr= GEARMAN_TIMEOUT;
             return NULL;
@@ -597,7 +603,7 @@
       }
       else
       {
-        *ret_ptr= gearman_con_wait(worker->gearman);
+        *ret_ptr= gearman_wait(worker->gearman);
         if (*ret_ptr != GEARMAN_SUCCESS && (*ret_ptr != GEARMAN_TIMEOUT ||
             worker->options & GEARMAN_WORKER_TIMEOUT_RETURN))
         {
@@ -608,7 +614,7 @@
       break;
 
     default:
-      gearman_error_set(worker->gearman, "gearman_worker_grab_job",
+      gearman_set_error(worker->gearman, "gearman_worker_grab_job",
                         "unknown state: %u", worker->state);
       *ret_ptr= GEARMAN_UNKNOWN_STATE;
       return NULL;
@@ -650,14 +656,14 @@
 {
   if (function_name == NULL)
   {
-    gearman_error_set(worker->gearman, "gearman_worker_add_function",
+    gearman_set_error(worker->gearman, "gearman_worker_add_function",
                       "function name not given");
     return GEARMAN_INVALID_FUNCTION_NAME;
   }
 
   if (worker_fn == NULL)
   {
-    gearman_error_set(worker->gearman, "gearman_worker_add_function",
+    gearman_set_error(worker->gearman, "gearman_worker_add_function",
                       "function not given");
     return GEARMAN_INVALID_WORKER_FUNCTION;
   }
@@ -691,7 +697,7 @@
     if (worker->work_function == NULL)
     {
       gearman_job_free(&(worker->work_job));
-      gearman_error_set(worker->gearman, "gearman_worker_work",
+      gearman_set_error(worker->gearman, "gearman_worker_work",
                         "function not found");
       return GEARMAN_INVALID_FUNCTION_NAME;
     }
@@ -699,7 +705,7 @@
     if (worker->work_function->worker_fn == NULL)
     {
       gearman_job_free(&(worker->work_job));
-      gearman_error_set(worker->gearman, "gearman_worker_work",
+      gearman_set_error(worker->gearman, "gearman_worker_work",
                         "no callback function supplied");
       return GEARMAN_INVALID_FUNCTION_NAME;
     }
@@ -708,10 +714,9 @@
     worker->work_result_size= 0;
 
   case GEARMAN_WORKER_WORK_STATE_FUNCTION:
-    worker->work_result= (*(worker->work_function->worker_fn))(
-                         &(worker->work_job),
-                         (void *)(worker->work_function->context),
-                         &(worker->work_result_size), &ret);
+    worker->work_result= worker->work_function->worker_fn(&(worker->work_job),
+                                         (void *)worker->work_function->context,
+                                         &(worker->work_result_size), &ret);
     if (ret == GEARMAN_WORK_FAIL)
     {
       ret= gearman_job_send_fail(&(worker->work_job));
@@ -752,7 +757,7 @@
       else
       {
         worker->gearman->workload_free_fn(worker->work_result,
-                              (void *)(worker->gearman->workload_free_context));
+                                (void *)worker->gearman->workload_free_context);
       }
       worker->work_result= NULL;
     }
@@ -780,7 +785,7 @@
    break;
 
   default:
-    gearman_error_set(worker->gearman, "gearman_worker_work",
+    gearman_set_error(worker->gearman, "gearman_worker_work",
                       "unknown state: %u", worker->work_state);
     return GEARMAN_UNKNOWN_STATE;
   }
@@ -795,11 +800,11 @@
                                      const void *workload,
                                      size_t workload_size)
 {
-  return gearman_con_echo(worker->gearman, workload, workload_size);
+  return gearman_echo(worker->gearman, workload, workload_size);
 }
 
 /*
- * Private definitions
+ * Static Definitions
  */
 
 static gearman_worker_st *_worker_allocate(gearman_worker_st *worker)
@@ -836,15 +841,15 @@
 {
   gearman_return_t ret;
 
-  ret= gearman_packet_add(worker->gearman, &(worker->grab_job),
-                          GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_GRAB_JOB,
-                          NULL);
+  ret= gearman_add_packet_args(worker->gearman, &(worker->grab_job),
+                               GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_GRAB_JOB,
+                               NULL, NULL, 0);
   if (ret != GEARMAN_SUCCESS)
     return ret;
 
-  ret= gearman_packet_add(worker->gearman, &(worker->pre_sleep),
-                          GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_PRE_SLEEP,
-                          NULL);
+  ret= gearman_add_packet_args(worker->gearman, &(worker->pre_sleep),
+                               GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_PRE_SLEEP,
+                               NULL, NULL, 0);
   if (ret != GEARMAN_SUCCESS)
   {
     gearman_packet_free(&(worker->grab_job));
@@ -871,11 +876,13 @@
   gearman_worker_function_st *function;
   gearman_return_t ret;
   char timeout_buffer[11];
+  const void *args[2];
+  size_t args_size[2];
 
   function= malloc(sizeof(gearman_worker_function_st));
   if (function == NULL)
   {
-    gearman_error_set(worker->gearman, "_worker_function_add", "malloc");
+    gearman_set_error(worker->gearman, "_worker_function_add", "malloc");
     return GEARMAN_MEMORY_ALLOCATION_FAILURE;
   }
 
@@ -886,7 +893,7 @@
   if (function->function_name == NULL)
   {
     free(function);
-    gearman_error_set(worker->gearman, "gearman_worker_add_function", "strdup");
+    gearman_set_error(worker->gearman, "gearman_worker_add_function", "strdup");
     return GEARMAN_MEMORY_ALLOCATION_FAILURE;
   }
 
@@ -896,20 +903,22 @@
   if (timeout > 0)
   {
     snprintf(timeout_buffer, 11, "%u", timeout);
-    ret= gearman_packet_add(worker->gearman, &(function->packet),
-                            GEARMAN_MAGIC_REQUEST,
-                            GEARMAN_COMMAND_CAN_DO_TIMEOUT,
-                            (uint8_t *)function_name,
-                            strlen(function_name) + 1,
-                            (uint8_t *)timeout_buffer,
-                            strlen(timeout_buffer), NULL);
+    args[0]= function_name;
+    args_size[0]= strlen(function_name) + 1;
+    args[1]= timeout_buffer;
+    args_size[1]= strlen(timeout_buffer);
+    ret= gearman_add_packet_args(worker->gearman, &(function->packet),
+                                 GEARMAN_MAGIC_REQUEST,
+                                 GEARMAN_COMMAND_CAN_DO_TIMEOUT,
+                                 args, args_size, 2);
   }
   else
   {
-    ret= gearman_packet_add(worker->gearman, &(function->packet),
-                            GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_CAN_DO,
-                            (uint8_t *)function_name, strlen(function_name),
-                            NULL);
+    args[0]= function_name;
+    args_size[0]= strlen(function_name);
+    ret= gearman_add_packet_args(worker->gearman, &(function->packet),
+                                 GEARMAN_MAGIC_REQUEST, GEARMAN_COMMAND_CAN_DO,
+                                 args, args_size, 1);
   }
   if (ret != GEARMAN_SUCCESS)
   {
@@ -956,7 +965,7 @@
     job= malloc(sizeof(gearman_job_st));
     if (job == NULL)
     {
-      gearman_error_set(worker->gearman, "_job_create", "malloc");
+      gearman_set_error(worker->gearman, "_job_create", "malloc");
       return NULL;
     }
 
 
=== modified file 'libgearman/worker.h'
--- libgearman/worker.h	2009-10-02 01:13:31 +0000
+++ libgearman/worker.h	2009-11-04 22:14:14 +0000
@@ -8,7 +8,7 @@
 
 /**
  * @file
- * @brief Worker declarations
+ * @brief Worker Declarations
  */
 
 #ifndef __GEARMAN_WORKER_H__
@@ -19,7 +19,8 @@
 #endif
 
 /**
- * @addtogroup gearman_worker Worker Interface
+ * @addtogroup gearman_worker Worker Declarations
+ *
  * This is the interface gearman workers should use.
  *
  * @ref main_page_worker "See Main Page for full details."
 
=== modified file 'tests/client_test.c'
--- tests/client_test.c	2009-09-26 09:21:13 +0000
+++ tests/client_test.c	2009-11-04 22:14:14 +0000
@@ -45,8 +45,8 @@
 test_return post(void *object);
 test_return flush(void);
 
-void *client_test_worker(gearman_job_st *job, void *cb_arg, size_t *result_size,
-                         gearman_return_t *ret_ptr);
+void *client_test_worker(gearman_job_st *job, void *context,
+                         size_t *result_size, gearman_return_t *ret_ptr);
 void *world_create(void);
 void world_destroy(void *object);
 
@@ -292,7 +292,8 @@
   return TEST_SUCCESS;
 }
 
-static void log_counter(const char *line, gearman_verbose_t verbose, void *context)
+static void log_counter(const char *line, gearman_verbose_t verbose,
+                        void *context)
 {
   uint32_t *counter= (uint32_t *)context;
 
@@ -323,12 +324,12 @@
 }
 
 
-void *client_test_worker(gearman_job_st *job, void *cb_arg, size_t *result_size,
-                         gearman_return_t *ret_ptr)
+void *client_test_worker(gearman_job_st *job, void *context,
+                         size_t *result_size, gearman_return_t *ret_ptr)
 {
   const uint8_t *workload;
   uint8_t *result;
-  (void)cb_arg;
+  (void)context;
 
   workload= gearman_job_workload(job);
   *result_size= gearman_job_workload_size(job);
 
=== modified file 'tests/memcached_test.c'
--- tests/memcached_test.c	2009-07-28 07:12:24 +0000
+++ tests/memcached_test.c	2009-11-04 22:14:14 +0000
@@ -43,8 +43,7 @@
 
 /* Counter test for worker */
 static void *counter_function(gearman_job_st *job __attribute__((unused)), 
-                              void *context, 
-                              size_t *result_size,
+                              void *context, size_t *result_size,
                               gearman_return_t *ret_ptr __attribute__((unused)))
 {
   uint32_t *counter= (uint32_t *)context;
 
=== modified file 'tests/sqlite_test.c'
--- tests/sqlite_test.c	2009-10-11 07:24:42 +0000
+++ tests/sqlite_test.c	2009-11-04 22:14:14 +0000
@@ -43,8 +43,7 @@
 
 /* Counter test for worker */
 static void *counter_function(gearman_job_st *job __attribute__((unused)), 
-                              void *context, 
-                              size_t *result_size,
+                              void *context, size_t *result_size,
                               gearman_return_t *ret_ptr __attribute__((unused)))
 {
   uint32_t *counter= (uint32_t *)context;
 
=== modified file 'tests/worker_test.c'
--- tests/worker_test.c	2009-09-23 21:05:40 +0000
+++ tests/worker_test.c	2009-11-04 22:14:14 +0000
@@ -107,46 +107,51 @@
   gearman_con_st con;
   gearman_packet_st packet;
   uint32_t x;
+  const void *args[1];
+  size_t args_size[1];
 
   if (gearman_create(&gearman) == NULL)
     return TEST_FAILURE;
 
   for (x= 0; x < 2; x++)
   {
-    if (gearman_con_create(&gearman, &con) == NULL)
+    if (gearman_add_con(&gearman, &con) == NULL)
       return TEST_FAILURE;
 
     gearman_con_set_host(&con, NULL);
     gearman_con_set_port(&con, WORKER_TEST_PORT);
 
-    if (gearman_packet_add(&gearman, &packet, GEARMAN_MAGIC_REQUEST,
-                           GEARMAN_COMMAND_SET_CLIENT_ID,
-                           (uint8_t *)"testUnregisterFunction", 13,
-                           NULL) != GEARMAN_SUCCESS)
-    {
-      return TEST_FAILURE;
-    }
-
-    if (gearman_con_send(&con, &packet, true) != GEARMAN_SUCCESS)
-      return TEST_FAILURE;
-
-    gearman_packet_free(&packet);
-
-    if (gearman_packet_add(&gearman, &packet, GEARMAN_MAGIC_REQUEST,
-                           GEARMAN_COMMAND_CAN_DO, (uint8_t *)"reverse", 7,
-                           NULL) != GEARMAN_SUCCESS)
-    {
-      return TEST_FAILURE;
-    }
-
-    if (gearman_con_send(&con, &packet, true) != GEARMAN_SUCCESS)
-      return TEST_FAILURE;
-
-    gearman_packet_free(&packet);
-
-    if (gearman_packet_add(&gearman, &packet, GEARMAN_MAGIC_REQUEST,
-                           GEARMAN_COMMAND_CANT_DO, (uint8_t *)"reverse", 7,
-                           NULL) != GEARMAN_SUCCESS)
+    args[0]= "testUnregisterFunction";
+    args_size[0]= strlen("testUnregisterFunction");
+    if (gearman_add_packet_args(&gearman, &packet, GEARMAN_MAGIC_REQUEST,
+                                GEARMAN_COMMAND_SET_CLIENT_ID,
+                                args, args_size, 1) != GEARMAN_SUCCESS)
+    {
+      return TEST_FAILURE;
+    }
+
+    if (gearman_con_send(&con, &packet, true) != GEARMAN_SUCCESS)
+      return TEST_FAILURE;
+
+    gearman_packet_free(&packet);
+
+    args[0]= "reverse";
+    args_size[0]= strlen("reverse");
+    if (gearman_add_packet_args(&gearman, &packet, GEARMAN_MAGIC_REQUEST,
+                                GEARMAN_COMMAND_CAN_DO,
+                                args, args_size, 1) != GEARMAN_SUCCESS)
+    {
+      return TEST_FAILURE;
+    }
+
+    if (gearman_con_send(&con, &packet, true) != GEARMAN_SUCCESS)
+      return TEST_FAILURE;
+
+    gearman_packet_free(&packet);
+
+    if (gearman_add_packet_args(&gearman, &packet, GEARMAN_MAGIC_REQUEST,
+                                GEARMAN_COMMAND_CANT_DO,
+                                args, args_size, 1) != GEARMAN_SUCCESS)
     {
       return TEST_FAILURE;
     }
@@ -158,52 +163,57 @@
 
     gearman_con_free(&con);
 
-    if (gearman_con_create(&gearman, &con) == NULL)
+    if (gearman_add_con(&gearman, &con) == NULL)
       return TEST_FAILURE;
 
     gearman_con_set_host(&con, NULL);
     gearman_con_set_port(&con, WORKER_TEST_PORT);
 
-    if (gearman_packet_add(&gearman, &packet, GEARMAN_MAGIC_REQUEST,
-                           GEARMAN_COMMAND_SET_CLIENT_ID,
-                           (uint8_t *)"testUnregisterFunction", 13,
-                           NULL) != GEARMAN_SUCCESS)
-    {
-      return TEST_FAILURE;
-    }
-
-    if (gearman_con_send(&con, &packet, true) != GEARMAN_SUCCESS)
-      return TEST_FAILURE;
-
-    gearman_packet_free(&packet);
-
-    if (gearman_packet_add(&gearman, &packet, GEARMAN_MAGIC_REQUEST,
-                           GEARMAN_COMMAND_CAN_DO, (uint8_t *)"digest", 6,
-                           NULL) != GEARMAN_SUCCESS)
-    {
-      return TEST_FAILURE;
-    }
-
-    if (gearman_con_send(&con, &packet, true) != GEARMAN_SUCCESS)
-      return TEST_FAILURE;
-
-    gearman_packet_free(&packet);
-
-    if (gearman_packet_add(&gearman, &packet, GEARMAN_MAGIC_REQUEST,
-                           GEARMAN_COMMAND_CAN_DO, (uint8_t *)"reverse", 7,
-                           NULL) != GEARMAN_SUCCESS)
-    {
-      return TEST_FAILURE;
-    }
-
-    if (gearman_con_send(&con, &packet, true) != GEARMAN_SUCCESS)
-      return TEST_FAILURE;
-
-    gearman_packet_free(&packet);
-
-    if (gearman_packet_add(&gearman, &packet, GEARMAN_MAGIC_REQUEST,
-                           GEARMAN_COMMAND_RESET_ABILITIES,
-                           NULL) != GEARMAN_SUCCESS)
+    args[0]= "testUnregisterFunction";
+    args_size[0]= strlen("testUnregisterFunction");
+    if (gearman_add_packet_args(&gearman, &packet, GEARMAN_MAGIC_REQUEST,
+                                GEARMAN_COMMAND_SET_CLIENT_ID,
+                                args, args_size, 1) != GEARMAN_SUCCESS)
+    {
+      return TEST_FAILURE;
+    }
+
+    if (gearman_con_send(&con, &packet, true) != GEARMAN_SUCCESS)
+      return TEST_FAILURE;
+
+    gearman_packet_free(&packet);
+
+    args[0]= "digest";
+    args_size[0]= strlen("digest");
+    if (gearman_add_packet_args(&gearman, &packet, GEARMAN_MAGIC_REQUEST,
+                                GEARMAN_COMMAND_CAN_DO,
+                                args, args_size, 1) != GEARMAN_SUCCESS)
+    {
+      return TEST_FAILURE;
+    }
+
+    if (gearman_con_send(&con, &packet, true) != GEARMAN_SUCCESS)
+      return TEST_FAILURE;
+
+    gearman_packet_free(&packet);
+
+    args[0]= "reverse";
+    args_size[0]= strlen("reverse");
+    if (gearman_add_packet_args(&gearman, &packet, GEARMAN_MAGIC_REQUEST,
+                                GEARMAN_COMMAND_CAN_DO,
+                                args, args_size, 1) != GEARMAN_SUCCESS)
+    {
+      return TEST_FAILURE;
+    }
+
+    if (gearman_con_send(&con, &packet, true) != GEARMAN_SUCCESS)
+      return TEST_FAILURE;
+
+    gearman_packet_free(&packet);
+
+    if (gearman_add_packet_args(&gearman, &packet, GEARMAN_MAGIC_REQUEST,
+                                GEARMAN_COMMAND_RESET_ABILITIES,
+                                NULL, NULL, 0) != GEARMAN_SUCCESS)
     {
       return TEST_FAILURE;
     }