Merge lp:~mordred/gearmand/visibility-changes into lp:gearmand/1.0

[Monty Taylor]

[Monty Taylor (mordred)]

Fixed the visibility issues on solaris.

[lp:~mordred/gearmand/visibility-changes]

277. By Monty Taylor on 2009-12-30

Updated memcached test to check that we actually _have_ memcached before trying
to test against it.

278. By Monty Taylor on 2009-12-30

Bumped version numbers for release.

279. By Monty Taylor on 2009-12-30

Fixed header install.

280. By Monty Taylor on 2009-12-30

Change libgearman-server to a noinst lib.

281. By Monty Taylor on 2009-12-30

Made libgearman-server a noinst lib.

282. By Monty Taylor on 2009-12-30

Don't install the libgearman-server headers.

=== modified file '.bzrignore'
--- .bzrignore	2009-08-10 21:22:21 +0000
+++ .bzrignore	2009-12-30 19:24:13 +0000
@@ -1,20 +1,28 @@
+*.deps
+*.dirstamp
+*.la
+*.libs
+*.lo
+*.moved
+*.o
+*.orig
+*.rej
 *Makefile
 *Makefile.in
-*.o
-*.lo
-*.la
-*.deps
-*.libs
+*gz
+*rpm
 *stamp-h1
+INSTALL
+TAGS
 aclocal.m4
 autom4te.cache
+benchmark/blobslap_client
+benchmark/blobslap_worker
+bin/gearman
+config.h
+config.h.in
 config.log
 config.status
-config.h
-config.h.in
-configure
-libtool
-INSTALL
 config/compile
 config/config.guess
 config/config.sub
@@ -22,11 +30,12 @@
 config/install-sh
 config/ltmain.sh
 config/missing
+config/plugin.ac
+configure
 docs/api
 docs/dev
 docs/man/man3/*.3
 docs/man_list
-gearmand/gearmand
 examples/echo_client
 examples/echo_worker
 examples/reverse_client
@@ -34,31 +43,30 @@
 examples/reverse_client_cb
 examples/reverse_worker
 examples/wc_worker
+gearmand/gearmand
+libtool
+m4/libtool.m4
+m4/ltoptions.m4
+m4/ltsugar.m4
+m4/ltversion.m4
+m4/lt~obsolete.m4
+out
+patch
+patch*
+scripts/gearmand
+scripts/gearmand-init
+scripts/gearmand.xml
+scripts/smf_install.sh
+support/gearmand.pc
+support/gearmand.spec
 tests/client_test
 tests/client_test.res
-tests/worker_test
-tests/worker_test.res
+tests/cpp_test
+tests/internals_test
 tests/memcached_test
 tests/memcached_test.res
+tests/regression_test
 tests/sqlite_test
 tests/sqlite_test.res
-support/gearmand.pc
-support/gearmand.spec
-benchmark/blobslap_client
-benchmark/blobslap_worker
-bin/gearman
-tests/cpp_test
-scripts/gearmand-init
-scripts/gearmand
-scripts/gearmand.xml
-scripts/smf_install.sh
-m4/libtool.m4
-m4/ltoptions.m4
-m4/ltsugar.m4
-m4/ltversion.m4
-m4/lt~obsolete.m4
-TAGS
-*rpm
-*gz
-*.moved
-config/plugin.ac
+tests/worker_test
+tests/worker_test.res

=== modified file 'ChangeLog'
--- ChangeLog	2009-12-18 20:37:36 +0000
+++ ChangeLog	2009-12-30 19:24:13 +0000
@@ -1,3 +1,11 @@
+0.13
+ * Fixed bug where setting an option off in mass would not trip any 
+   triggers on the option (for both worker and client).
+ * Options that are internal can no longer be set by external
+   callers.
+ * Deprecated gearman_client_set_event_watch_fn() and
+   gearman_worker_set_event_watch_fn.
+
 0.12 - 2010-01-??
  * Fixed job handle comparison bug with WORK_FAIL responses.
  * Fixed disable assert configure option.

=== modified file 'Makefile.am'
--- Makefile.am	2009-12-18 19:18:51 +0000
+++ Makefile.am	2009-12-30 19:24:13 +0000
@@ -13,7 +13,7 @@
 noinst_PROGRAMS =
 lib_LTLIBRARIES =
 noinst_LTLIBRARIES =
-nobase_pkginclude_HEADERS =
+nobase_include_HEADERS =
 noinst_HEADERS =
 EXTRA_DIST = 
 CLEANFILES =
@@ -35,11 +35,7 @@
 	docs/api_header.html \
 	docs/dev_header.html \
 	docs/doxygen.h \
-  scripts/gearmand-init \
-	scripts/gearmand.xml \
-	scripts/gearmand \
-	scripts/README.solaris \
-	support/gearmand.spec
+	scripts/README.solaris
 
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = support/gearmand.pc
@@ -50,9 +46,14 @@
 
 test: check
 
-
 rpm: all dist
 	cp gearmand-$(VERSION).tar.gz ~/rpmbuild/SOURCES/
 	rpmbuild -ba support/gearmand.spec
 	cp ~/rpmbuild/RPMS/x86_64/gearmand-$(VERSION)*.rpm .
 	cp ~/rpmbuild/SRPMS/gearmand-$(VERSION)*.rpm .
+
+merge-clean:
+	find ./ | $(GREP) \.orig | xargs rm -f
+	find ./ | $(GREP) \.rej | xargs rm -f
+	find ./ | $(GREP) \~$$ | xargs rm -f
+	bzr unknowns

=== modified file 'benchmark/benchmark.c'
--- benchmark/benchmark.c	2009-01-19 20:39:38 +0000
+++ benchmark/benchmark.c	2009-12-30 19:24:13 +0000
@@ -30,7 +30,7 @@
 
   gettimeofday(&(benchmark->end), NULL);
   if (benchmark->end.tv_sec != benchmark->begin.tv_sec)
-  { 
+  {
     benchmark->total_jobs+= benchmark->jobs;
 
     printf("[Current: %6"PRIu64" jobs/s, Total: %6"PRIu64" jobs/s]\n",

=== modified file 'benchmark/include.am'
--- benchmark/include.am	2009-12-18 18:54:27 +0000
+++ benchmark/include.am	2009-12-30 19:24:13 +0000
@@ -12,11 +12,11 @@
 
 
 noinst_PROGRAMS+= \
-	benchmark/blobslap_client \
-	benchmark/blobslap_worker
+		  benchmark/blobslap_client \
+		  benchmark/blobslap_worker
 
 noinst_HEADERS+= \
-	benchmark/benchmark.h
+		 benchmark/benchmark.h
 
 noinst_LTLIBRARIES+= benchmark/libbenchmark.la
 benchmark_libbenchmark_la_SOURCES= benchmark/benchmark.c

=== modified file 'config/pre_hook.sh'
--- config/pre_hook.sh	2009-09-25 00:04:06 +0000
+++ config/pre_hook.sh	2009-12-30 19:24:13 +0000
@@ -6,5 +6,5 @@
   fi
 fi
 echo "Generating docs..."
-cat libgearman/*.h libgearman-server/*.h | $PERL docs/man_gen.perl > docs/man_list
+cat libgearman/*.h | $PERL docs/man_gen.perl > docs/man_list
 

=== modified file 'configure.ac'
--- configure.ac	2009-12-18 19:25:00 +0000
+++ configure.ac	2009-12-30 19:24:13 +0000
@@ -6,7 +6,7 @@
 # the COPYING file in this directory for full text.
 
 AC_PREREQ(2.59)
-AC_INIT([gearmand],[0.11],[https://launchpad.net/gearmand])
+AC_INIT([gearmand],[0.12],[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=3:0:0
+GEARMAN_LIBRARY_VERSION=4:0:0
 #                       | | |
 #                +------+ | +---+
 #                |        |     |
@@ -28,21 +28,6 @@
 #                +- increment if interfaces have been added, removed or changed
 AC_SUBST(GEARMAN_LIBRARY_VERSION)
 
-GEARMAN_SERVER_LIBRARY_VERSION=0:1:0
-#                              | | |
-#                       +------+ | +---+
-#                       |        |     |
-#                    current:revision:age
-#                       |        |     |
-#                       |        |     +- increment if interfaces have been
-#                       |        |        added, set to zero if interfaces
-#                       |        |        have been removed or changed
-#                       |        +- increment if source code has changed
-#                       |           set to zero if current is incremented
-#                       +- increment if interfaces have been added, removed
-#                          or changed
-AC_SUBST(GEARMAN_SERVER_LIBRARY_VERSION)
-
 
 PANDORA_REQUIRE_PTHREAD
 PANDORA_REQUIRE_LIBEVENT

=== modified file 'docs/man_gen.perl'
--- docs/man_gen.perl	2009-09-29 04:34:21 +0000
+++ docs/man_gen.perl	2009-12-30 19:24:13 +0000
@@ -81,7 +81,8 @@
       }
 
       $func= join(" ", @func_lines);
-      if ($name)
+
+      if ($name and ($func =~ m/GEARMAN_API/ or $func =~ m/GEARMAN_DEPRECATED_API/ ))
       {
         # We have a function! Output a man page.
         print " \\\n\t$path/man$section/$name.$section";

=== modified file 'libgearman-server/common.h'
--- libgearman-server/common.h	2009-10-29 00:11:45 +0000
+++ libgearman-server/common.h	2009-12-30 19:24:13 +0000
@@ -16,6 +16,7 @@
 
 #include "config.h"
 
+#define GEARMAN_CORE
 #include "server.h"
 
 #ifdef HAVE_ASSERT_H

=== renamed file 'libgearman-server/conn.c' => 'libgearman-server/connection.c'
--- libgearman-server/conn.c	2009-10-29 00:11:45 +0000
+++ libgearman-server/connection.c	2009-12-30 19:24:13 +0000
@@ -27,7 +27,7 @@
   if (con == NULL)
     return NULL;
 
-  if (gearman_con_set_fd(&(con->con), fd) != GEARMAN_SUCCESS)
+  if (gearman_connection_set_fd(&(con->con), fd) != GEARMAN_SUCCESS)
   {
     gearman_server_con_free(con);
     return NULL;
@@ -35,7 +35,7 @@
 
   con->con.context= data;
 
-  ret= gearman_con_set_events(&(con->con), POLLIN);
+  ret= gearman_connection_set_events(&(con->con), POLLIN);
   if (ret != GEARMAN_SUCCESS)
   {
     gearman_server_con_free(con);
@@ -66,14 +66,13 @@
     }
   }
 
-  if (gearman_add_con(thread->gearman, &(con->con)) == NULL)
+  gearman_connection_options_t options[] = { GEARMAN_CON_IGNORE_LOST_CONNECTION, GEARMAN_CON_MAX };
+  if (gearman_connection_create(thread->gearman, &(con->con), options) == NULL)
   {
     free(con);
     return NULL;
   }
 
-  gearman_con_add_options(&(con->con), GEARMAN_CON_IGNORE_LOST_CONNECTION);
-
   con->options= 0;
   con->ret= 0;
   con->io_list= false;
@@ -122,7 +121,7 @@
     return;
   }
 
-  gearman_con_free(&(con->con));
+  gearman_connection_free(&(con->con));
 
   if (con->proc_list)
     gearman_server_con_proc_remove(con);
@@ -162,19 +161,19 @@
     free(con);
 }
 
-gearman_con_st *gearman_server_con_con(gearman_server_con_st *con)
+gearman_connection_st *gearman_server_con_con(gearman_server_con_st *con)
 {
   return &con->con;
 }
 
 void *gearman_server_con_data(gearman_server_con_st *con)
 {
-  return gearman_con_context(&(con->con));
+  return gearman_connection_context(&(con->con));
 }
 
 void gearman_server_con_set_data(gearman_server_con_st *con, void *data)
 {
-  gearman_con_set_context(&(con->con), data);
+  gearman_connection_set_context(&(con->con), data);
 }
 
 const char *gearman_server_con_host(gearman_server_con_st *con)

=== renamed file 'libgearman-server/conn.h' => 'libgearman-server/connection.h'
--- libgearman-server/conn.h	2009-10-29 00:11:45 +0000
+++ libgearman-server/connection.h	2009-12-30 19:24:13 +0000
@@ -58,7 +58,7 @@
  * Get gearman connection pointer the server connection uses.
  */
 GEARMAN_API
-gearman_con_st *gearman_server_con_con(gearman_server_con_st *con);
+gearman_connection_st *gearman_server_con_con(gearman_server_con_st *con);
 
 /**
  * Get application data pointer.

=== modified file 'libgearman-server/constants.h'
--- libgearman-server/constants.h	2009-10-29 00:11:45 +0000
+++ libgearman-server/constants.h	2009-12-30 19:24:13 +0000
@@ -212,7 +212,7 @@
                                                    gearman_queue_add_fn *add_fn,
                                                    void *add_context);
 
-typedef gearman_return_t (gearman_con_add_fn)(gearman_con_st *con);
+typedef gearman_return_t (gearman_connection_add_fn)(gearman_connection_st *con);
 
 /** @} */
 

=== modified file 'libgearman-server/gearmand.c'
--- libgearman-server/gearmand.c	2009-12-02 19:09:59 +0000
+++ libgearman-server/gearmand.c	2009-12-30 19:24:13 +0000
@@ -166,7 +166,7 @@
 }
 
 gearman_return_t gearmand_port_add(gearmand_st *gearmand, in_port_t port,
-                                   gearman_con_add_fn *function)
+                                   gearman_connection_add_fn *function)
 {
   gearmand_port_st *port_list;
 

=== modified file 'libgearman-server/gearmand.h'
--- libgearman-server/gearmand.h	2009-10-29 22:01:39 +0000
+++ libgearman-server/gearmand.h	2009-12-30 19:24:13 +0000
@@ -106,7 +106,7 @@
  */
 GEARMAN_API
 gearman_return_t gearmand_port_add(gearmand_st *gearmand, in_port_t port,
-                                   gearman_con_add_fn *function);
+                                   gearman_connection_add_fn *function);
 
 /**
  * Run the server instance.

=== modified file 'libgearman-server/gearmand_con.c'
--- libgearman-server/gearmand_con.c	2009-12-02 19:09:59 +0000
+++ libgearman-server/gearmand_con.c	2009-12-30 19:24:13 +0000
@@ -37,7 +37,7 @@
 
 gearman_return_t gearmand_con_create(gearmand_st *gearmand, int fd,
                                      const char *host, const char *port,
-                                     gearman_con_add_fn *add_fn)
+                                     gearman_connection_add_fn *add_fn)
 {
   gearmand_con_st *dcon;
   gearmand_con_st *free_dcon_list;
@@ -179,14 +179,14 @@
   }
 }
 
-gearman_return_t gearmand_con_watch(gearman_con_st *con, short events,
+gearman_return_t gearmand_connection_watch(gearman_connection_st *con, short events,
                                     void *context __attribute__ ((unused)))
 {
   (void) context;
   gearmand_con_st *dcon;
   short set_events= 0;
 
-  dcon= (gearmand_con_st *)gearman_con_context(con);
+  dcon= (gearmand_con_st *)gearman_connection_context(con);
   dcon->con= con;
 
   if (events & POLLIN)
@@ -238,7 +238,7 @@
   if (events & EV_WRITE)
     revents|= POLLOUT;
 
-  ret= gearman_con_set_revents(dcon->con, revents);
+  ret= gearman_connection_set_revents(dcon->con, revents);
   if (ret != GEARMAN_SUCCESS)
   {
     gearmand_con_free(dcon);

=== modified file 'libgearman-server/gearmand_con.h'
--- libgearman-server/gearmand_con.h	2009-10-29 20:18:00 +0000
+++ libgearman-server/gearmand_con.h	2009-12-30 19:24:13 +0000
@@ -41,7 +41,7 @@
 GEARMAN_API
 gearman_return_t gearmand_con_create(gearmand_st *gearmand, int fd,
                                      const char *host, const char *port,
-                                     gearman_con_add_fn *add_fn);
+                                     gearman_connection_add_fn *add_fn);
 
 /**
  * Free resources used by a connection.
@@ -60,7 +60,7 @@
  * Callback function used for setting events in libevent.
  */
 GEARMAN_API
-gearman_return_t gearmand_con_watch(gearman_con_st *con, short events,
+gearman_return_t gearmand_connection_watch(gearman_connection_st *con, short events,
                                     void *context);
 
 /** @} */

=== modified file 'libgearman-server/gearmand_thread.c'
--- libgearman-server/gearmand_thread.c	2009-12-02 19:09:59 +0000
+++ libgearman-server/gearmand_thread.c	2009-12-30 19:24:13 +0000
@@ -65,7 +65,7 @@
   gearman_server_thread_set_log_fn(&(thread->server_thread), _log, thread,
                                    gearmand->verbose);
   gearman_server_thread_set_event_watch(&(thread->server_thread),
-                                        gearmand_con_watch, NULL);
+                                        gearmand_connection_watch, NULL);
 
   thread->options= 0;
   thread->count= 0;

=== modified file 'libgearman-server/include.am'
--- libgearman-server/include.am	2009-12-18 19:25:00 +0000
+++ libgearman-server/include.am	2009-12-30 19:24:13 +0000
@@ -30,10 +30,10 @@
 QUEUE_LIBPQ_C= libgearman-server/queue_libpq.c
 endif
 
-lib_LTLIBRARIES+= libgearman-server/libgearman-server.la
-
-
-nobase_pkginclude_HEADERS += \
+noinst_LTLIBRARIES+= libgearman-server/libgearman-server.la
+
+
+noinst_HEADERS += \
 	$(QUEUE_LIBDRIZZLE_H) \
 	$(QUEUE_LIBMEMCACHED_H) \
 	$(QUEUE_LIBPQ_H) \
@@ -41,7 +41,7 @@
 	libgearman-server/client.h \
 	libgearman-server/conf.h \
 	libgearman-server/conf_module.h \
-	libgearman-server/conn.h \
+	libgearman-server/connection.h \
 	libgearman-server/constants.h \
 	libgearman-server/function.h \
 	libgearman-server/gearmand.h \
@@ -66,7 +66,7 @@
 	libgearman-server/client.c \
 	libgearman-server/conf.c \
 	libgearman-server/conf_module.c \
-	libgearman-server/conn.c \
+	libgearman-server/connection.c \
 	libgearman-server/function.c \
 	libgearman-server/gearmand.c \
 	libgearman-server/gearmand_con.c \
@@ -82,15 +82,11 @@
 	${AM_CFLAGS} \
 	-DBUILDING_LIBGEARMAN
 
-libgearman_server_libgearman_server_la_LDFLAGS= \
-	$(AM_LDFLAGS) \
-	-version-info \
-	$(GEARMAN_SERVER_LIBRARY_VERSION)
-
 libgearman_server_libgearman_server_la_LIBADD= \
 	$(LTLIBDRIZZLE) \
 	$(LTLIBEVENT) \
 	$(LTLIBMEMCACHED) \
 	$(LTLIBPQ) \
 	$(LTLIBSQLITE3) \
-	libgearman/libgearman.la
+	libgearman/libgearman.la \
+	libgearman/libgearmancore.la

=== modified file 'libgearman-server/packet.c'
--- libgearman-server/packet.c	2009-10-29 00:11:45 +0000
+++ libgearman-server/packet.c	2009-12-30 19:24:13 +0000
@@ -101,8 +101,8 @@
   if (server_packet == NULL)
     return GEARMAN_MEMORY_ALLOCATION_FAILURE;
 
-  if (gearman_add_packet(con->thread->gearman,
-                         &(server_packet->packet)) == NULL)
+  if (gearman_packet_create(con->thread->gearman,
+                            &(server_packet->packet)) == NULL)
   {
     gearman_server_packet_free(server_packet, con->thread, false);
     return GEARMAN_MEMORY_ALLOCATION_FAILURE;
@@ -117,7 +117,7 @@
   {
     arg_size = va_arg(ap, size_t);
 
-    ret= gearman_packet_add_arg(&(server_packet->packet), arg, arg_size);
+    ret= gearman_packet_create_arg(&(server_packet->packet), arg, arg_size);
     if (ret != GEARMAN_SUCCESS)
     {
       va_end(ap);
@@ -140,7 +140,7 @@
   }
 
   if (take_data)
-    server_packet->packet.options|= GEARMAN_PACKET_FREE_DATA;
+    server_packet->packet.options.free_data= true;
 
   GEARMAN_SERVER_THREAD_LOCK(con->thread)
   GEARMAN_FIFO_ADD(con->io_packet, server_packet,)

=== modified file 'libgearman-server/protocol_http.c'
--- libgearman-server/protocol_http.c	2009-10-29 20:18:00 +0000
+++ libgearman-server/protocol_http.c	2009-12-30 19:24:13 +0000
@@ -37,12 +37,12 @@
 } gearman_protocol_http_st;
 
 /* Protocol callback functions. */
-static gearman_return_t _http_con_add(gearman_con_st *con);
-static void _http_free(gearman_con_st *con, void *context);
-static size_t _http_pack(const gearman_packet_st *packet, gearman_con_st *con,
+static gearman_return_t _http_con_add(gearman_connection_st *con);
+static void _http_free(gearman_connection_st *con, void *context);
+static size_t _http_pack(const gearman_packet_st *packet, gearman_connection_st *con,
                          void *data, size_t data_size,
                          gearman_return_t *ret_ptr);
-static size_t _http_unpack(gearman_packet_st *packet, gearman_con_st *con,
+static size_t _http_unpack(gearman_packet_st *packet, gearman_connection_st *con,
                            const void *data, size_t data_size,
                            gearman_return_t *ret_ptr);
 
@@ -114,7 +114,7 @@
  * Static definitions
  */
 
-static gearman_return_t _http_con_add(gearman_con_st *con)
+static gearman_return_t _http_con_add(gearman_connection_st *con)
 {
   gearman_protocol_http_st *http;
 
@@ -128,28 +128,28 @@
   http->background= false;
   http->keep_alive= false;
 
-  gearman_con_set_protocol_context(con, http);
-  gearman_con_set_protocol_context_free_fn(con, _http_free);
-  gearman_con_set_packet_pack_fn(con, _http_pack);
-  gearman_con_set_packet_unpack_fn(con, _http_unpack);
+  gearman_connection_set_protocol_context(con, http);
+  gearman_connection_set_protocol_context_free_fn(con, _http_free);
+  gearman_connection_set_packet_pack_fn(con, _http_pack);
+  gearman_connection_set_packet_unpack_fn(con, _http_unpack);
 
   return GEARMAN_SUCCESS;
 }
 
-static void _http_free(gearman_con_st *con __attribute__ ((unused)),
+static void _http_free(gearman_connection_st *con __attribute__ ((unused)),
                        void *context)
 {
   free((gearman_protocol_http_st *)context);
 }
 
-static size_t _http_pack(const gearman_packet_st *packet, gearman_con_st *con,
+static size_t _http_pack(const gearman_packet_st *packet, gearman_connection_st *con,
                          void *data, size_t data_size,
                          gearman_return_t *ret_ptr)
 {
   size_t pack_size;
   gearman_protocol_http_st *http;
 
-  http= (gearman_protocol_http_st *)gearman_con_protocol_context(con);
+  http= (gearman_protocol_http_st *)gearman_connection_protocol_context(con);
 
   if (packet->command != GEARMAN_COMMAND_WORK_COMPLETE &&
       packet->command != GEARMAN_COMMAND_WORK_FAIL &&
@@ -178,14 +178,16 @@
     return 0;
   }
 
-  if (!(http->keep_alive))
-    gearman_con_add_options(con, GEARMAN_CON_CLOSE_AFTER_FLUSH);
+  if (! (http->keep_alive))
+  {
+    gearman_connection_set_option(con, GEARMAN_CON_CLOSE_AFTER_FLUSH, true);
+  }
 
   *ret_ptr= GEARMAN_SUCCESS;
   return pack_size;
 }
 
-static size_t _http_unpack(gearman_packet_st *packet, gearman_con_st *con,
+static size_t _http_unpack(gearman_packet_st *packet, gearman_connection_st *con,
                            const void *data, size_t data_size,
                            gearman_return_t *ret_ptr)
 {
@@ -214,7 +216,7 @@
     return offset;
   }
 
-  http= (gearman_protocol_http_st *)gearman_con_protocol_context(con);
+  http= (gearman_protocol_http_st *)gearman_connection_protocol_context(con);
   http->background= false;
   http->keep_alive= false;
 
@@ -355,11 +357,11 @@
   if (*ret_ptr != GEARMAN_SUCCESS)
     return 0;
 
-  *ret_ptr= gearman_packet_add_arg(packet, uri, (size_t)uri_size + 1);
+  *ret_ptr= gearman_packet_create_arg(packet, uri, (size_t)uri_size + 1);
   if (*ret_ptr != GEARMAN_SUCCESS)
     return 0;
 
-  *ret_ptr= gearman_packet_add_arg(packet, unique, unique_size + 1);
+  *ret_ptr= gearman_packet_create_arg(packet, unique, unique_size + 1);
   if (*ret_ptr != GEARMAN_SUCCESS)
     return 0;
 

=== modified file 'libgearman-server/server.c'
--- libgearman-server/server.c	2009-10-29 22:01:39 +0000
+++ libgearman-server/server.c	2009-12-30 19:24:13 +0000
@@ -111,7 +111,7 @@
   memset(server->unique_hash, 0,
          sizeof(gearman_server_job_st *) * GEARMAN_JOB_HASH_SIZE);
 
-  server->gearman= gearman_create(&(server->gearman_static));
+  server->gearman= gearman_universal_create(&(server->gearman_universal_static), NULL);
   if (server->gearman == NULL)
   {
     gearman_server_free(server);
@@ -180,7 +180,7 @@
   }
 
   if (server->gearman != NULL)
-    gearman_free(server->gearman);
+    gearman_universal_free(server->gearman);
 
   if (server->options & GEARMAN_SERVER_ALLOCATED)
     free(server);
@@ -237,7 +237,7 @@
     if (ret != GEARMAN_SUCCESS)
       return ret;
 
-    packet->options&= (gearman_packet_options_t)~GEARMAN_PACKET_FREE_DATA;
+    packet->options.free_data= false;
 
     break;
 
@@ -284,7 +284,9 @@
                                        packet->data_size, priority,
                                        server_client, &ret);
     if (ret == GEARMAN_SUCCESS)
-      packet->options&= (gearman_packet_options_t)~GEARMAN_PACKET_FREE_DATA;
+    {
+      packet->options.free_data= false;
+    }
     else if (ret == GEARMAN_JOB_QUEUE_FULL)
     {
       return _server_error_packet(server_con, "queue_full",
@@ -913,8 +915,8 @@
     return GEARMAN_MEMORY_ALLOCATION_FAILURE;
   }
 
-  if (gearman_add_packet(server_con->thread->gearman,
-                         &(server_packet->packet)) == NULL)
+  if (gearman_packet_create(server_con->thread->gearman,
+                            &(server_packet->packet)) == NULL)
   {
     free(data);
     gearman_server_packet_free(server_packet, server_con->thread, false);
@@ -923,8 +925,9 @@
 
   server_packet->packet.magic= GEARMAN_MAGIC_TEXT;
   server_packet->packet.command= GEARMAN_COMMAND_TEXT;
-  server_packet->packet.options|= (GEARMAN_PACKET_COMPLETE |
-                                   GEARMAN_PACKET_FREE_DATA);
+  server_packet->packet.options.complete= true;
+  server_packet->packet.options.free_data= true;
+
   server_packet->packet.data= data;
   server_packet->packet.data_size= strlen(data);
 
@@ -956,11 +959,11 @@
 
     if (packet->data_size > 0)
     {
-      if (packet->options & GEARMAN_PACKET_FREE_DATA &&
+      if (packet->options.free_data &&
           server_client->job_next == NULL)
       {
         data= (uint8_t *)(packet->data);
-        packet->options&= (gearman_packet_options_t)~GEARMAN_PACKET_FREE_DATA;
+        packet->options.free_data= false;
       }
       else
       {

=== modified file 'libgearman-server/server.h'
--- libgearman-server/server.h	2009-10-29 22:01:39 +0000
+++ libgearman-server/server.h	2009-12-30 19:24:13 +0000
@@ -21,7 +21,7 @@
 #include <libgearman-server/structs.h>
 #include <libgearman-server/conf.h>
 #include <libgearman-server/conf_module.h>
-#include <libgearman-server/conn.h>
+#include <libgearman-server/connection.h>
 #include <libgearman-server/packet.h>
 #include <libgearman-server/function.h>
 #include <libgearman-server/client.h>

=== modified file 'libgearman-server/structs.h'
--- libgearman-server/structs.h	2009-10-29 22:01:39 +0000
+++ libgearman-server/structs.h	2009-12-30 19:24:13 +0000
@@ -39,7 +39,7 @@
   uint32_t free_job_count;
   uint32_t free_client_count;
   uint32_t free_worker_count;
-  gearman_st *gearman;
+  gearman_universal_st *gearman;
   gearman_server_thread_st *thread_list;
   gearman_server_function_st *function_list;
   gearman_server_packet_st *free_packet_list;
@@ -53,7 +53,7 @@
   gearman_queue_flush_fn *queue_flush_fn;
   gearman_queue_done_fn *queue_done_fn;
   gearman_queue_replay_fn *queue_replay_fn;
-  gearman_st gearman_static;
+  gearman_universal_st gearman_universal_static;
   pthread_mutex_t proc_lock;
   pthread_cond_t proc_cond;
   pthread_t proc_id;
@@ -73,7 +73,7 @@
   uint32_t proc_count;
   uint32_t free_con_count;
   uint32_t free_packet_count;
-  gearman_st *gearman;
+  gearman_universal_st *gearman;
   gearman_server_st *server;
   gearman_server_thread_st *next;
   gearman_server_thread_st *prev;
@@ -86,7 +86,7 @@
   gearman_server_con_st *proc_list;
   gearman_server_con_st *free_con_list;
   gearman_server_packet_st *free_packet_list;
-  gearman_st gearman_static;
+  gearman_universal_st gearman_universal_static;
   pthread_mutex_t lock;
 };
 
@@ -95,7 +95,7 @@
  */
 struct gearman_server_con_st
 {
-  gearman_con_st con; /* This must be the first struct member. */
+  gearman_connection_st con; /* This must be the first struct member. */
   gearman_server_con_options_t options;
   gearman_return_t ret;
   bool io_list;
@@ -250,7 +250,7 @@
   in_port_t port;
   uint32_t listen_count;
   gearmand_st *gearmand;
-  gearman_con_add_fn *add_fn;
+  gearman_connection_add_fn *add_fn;
   int *listen_fd;
   struct event *listen_event;
 };
@@ -290,8 +290,8 @@
   gearmand_con_st *next;
   gearmand_con_st *prev;
   gearman_server_con_st *server_con;
-  gearman_con_st *con;
-  gearman_con_add_fn *add_fn;
+  gearman_connection_st *con;
+  gearman_connection_add_fn *add_fn;
   struct event event;
   char host[NI_MAXHOST];
   char port[NI_MAXSERV];

=== modified file 'libgearman-server/thread.c'
--- libgearman-server/thread.c	2009-10-29 20:18:00 +0000
+++ libgearman-server/thread.c	2009-12-30 19:24:13 +0000
@@ -107,18 +107,16 @@
     return NULL;
   }
 
-  GEARMAN_LIST_ADD(server->thread, thread,)
+  GEARMAN_LIST_ADD(server->thread, thread,);
 
-  thread->gearman= gearman_create(&(thread->gearman_static));
+  gearman_options_t options[]= { GEARMAN_NON_BLOCKING, GEARMAN_DONT_TRACK_PACKETS, GEARMAN_MAX};
+  thread->gearman= gearman_universal_create(&(thread->gearman_universal_static), options);
   if (thread->gearman == NULL)
   {
     gearman_server_thread_free(thread);
     return NULL;
   }
 
-  gearman_set_options(thread->gearman,
-                      GEARMAN_NON_BLOCKING | GEARMAN_DONT_TRACK_PACKETS);
-
   return thread;
 }
 
@@ -147,7 +145,7 @@
   }
 
   if (thread->gearman != NULL)
-    gearman_free(thread->gearman);
+    gearman_universal_free(thread->gearman);
 
   pthread_mutex_destroy(&(thread->lock));
 
@@ -159,12 +157,12 @@
 
 const char *gearman_server_thread_error(gearman_server_thread_st *thread)
 {
-  return gearman_error(thread->gearman);
+  return gearman_universal_error(thread->gearman);
 }
 
 int gearman_server_thread_errno(gearman_server_thread_st *thread)
 {
-  return gearman_errno(thread->gearman);
+  return gearman_universal_errno(thread->gearman);
 }
 
 void gearman_server_thread_set_event_watch(gearman_server_thread_st *thread,
@@ -196,7 +194,7 @@
 gearman_server_thread_run(gearman_server_thread_st *thread,
                           gearman_return_t *ret_ptr)
 {
-  gearman_con_st *con;
+  gearman_connection_st *con;
   gearman_server_con_st *server_con;
 
   /* If we are multi-threaded, we may have packets to flush or connections that
@@ -295,7 +293,7 @@
         return GEARMAN_MEMORY_ALLOCATION_FAILURE;
     }
 
-    (void)gearman_con_recv(&(con->con), &(con->packet->packet), &ret, true);
+    (void)gearman_connection_recv(&(con->con), &(con->packet->packet), &ret, true);
     if (ret != GEARMAN_SUCCESS)
     {
       if (ret == GEARMAN_IO_WAIT)
@@ -343,7 +341,7 @@
 
   while (con->io_packet_list != NULL)
   {
-    ret= gearman_con_send(&(con->con), &(con->io_packet_list->packet),
+    ret= gearman_connection_send(&(con->con), &(con->io_packet_list->packet),
                           con->io_packet_list->next == NULL ? true : false);
     if (ret != GEARMAN_SUCCESS)
       return ret;
@@ -357,7 +355,7 @@
   }
 
   /* Clear the POLLOUT flag. */
-  return gearman_con_set_events(&(con->con), POLLIN);
+  return gearman_connection_set_events(&(con->con), POLLIN);
 }
 
 static gearman_return_t _proc_thread_start(gearman_server_st *server)

=== modified file 'libgearman/client.c'
--- libgearman/client.c	2009-12-16 22:46:32 +0000
+++ libgearman/client.c	2009-12-30 19:24:13 +0000
@@ -22,7 +22,7 @@
 /**
  * Allocate a client structure.
  */
-static gearman_client_st *_client_allocate(gearman_client_st *client);
+static gearman_client_st *_client_allocate(gearman_client_st *client, bool is_clone);
 
 /**
  * Callback function used when parsing server lists.
@@ -83,18 +83,6 @@
  */
 static gearman_return_t _client_do_fail(gearman_task_st *task);
 
-/**
- * Initialize a task structure.
- *
- * @param[in] client Structure previously initialized with
- *  gearman_client_create() or gearman_client_clone().
- * @param[in] task Caller allocated structure, or NULL to allocate one.
- * @return On success, a pointer to the (possibly allocated) structure. On
- *  failure this will be NULL.
- */
-static gearman_task_st *_task_create(gearman_client_st *client,
-                                     gearman_task_st *task);
-
 /** @} */
 
 /*
@@ -103,35 +91,34 @@
 
 gearman_client_st *gearman_client_create(gearman_client_st *client)
 {
-  client= _client_allocate(client);
-  if (client == NULL)
-    return NULL;
-
-  client->gearman= gearman_create(&(client->gearman_static));
-  if (client->gearman == NULL)
-  {
-    gearman_client_free(client);
-    return NULL;
-  }
-
-  return client;
+  return _client_allocate(client, false);
 }
 
 gearman_client_st *gearman_client_clone(gearman_client_st *client,
                                         const gearman_client_st *from)
 {
-  if (from == NULL)
-    return NULL;
-
-  client= _client_allocate(client);
+  gearman_universal_st *check;
+
+  if (! from)
+  {
+    return _client_allocate(client, false);
+  }
+
+  client= _client_allocate(client, false);
+
   if (client == NULL)
-    return NULL;
-
-  client->options|= (from->options &
-                     (gearman_client_options_t)~GEARMAN_CLIENT_ALLOCATED);
-
-  client->gearman= gearman_clone(&(client->gearman_static), from->gearman);
-  if (client->gearman == NULL)
+  {
+    return client;
+  }
+
+  client->options.non_blocking= from->options.non_blocking;
+  client->options.task_in_use= from->options.task_in_use;
+  client->options.unbuffered_result= from->options.unbuffered_result;
+  client->options.no_new= from->options.no_new;
+  client->options.free_tasks= from->options.free_tasks;
+
+  check= gearman_universal_clone((&client->universal), &(from->universal));
+  if (! check)
   {
     gearman_client_free(client);
     return NULL;
@@ -142,68 +129,122 @@
 
 void gearman_client_free(gearman_client_st *client)
 {
-  if (client->options & GEARMAN_CLIENT_TASK_IN_USE)
+  if (client->options.task_in_use)
     gearman_task_free(&(client->do_task));
 
   gearman_client_task_free_all(client);
 
-  if (client->gearman != NULL)
-    gearman_free(client->gearman);
+  gearman_universal_free(&client->universal);
 
-  if (client->options & GEARMAN_CLIENT_ALLOCATED)
+  if (client->options.allocated)
     free(client);
 }
 
 const char *gearman_client_error(const gearman_client_st *client)
 {
-  return gearman_error(client->gearman);
+  return gearman_universal_error(&client->universal);
 }
 
 int gearman_client_errno(const gearman_client_st *client)
 {
-  return gearman_errno(client->gearman);
+  return gearman_universal_errno(&client->universal);
 }
 
 gearman_client_options_t gearman_client_options(const gearman_client_st *client)
 {
-  return client->options;
+  gearman_client_options_t options;
+  memset(&options, 0, sizeof(gearman_client_options_t));
+
+  if (client->options.allocated)
+    options|= GEARMAN_CLIENT_ALLOCATED;
+  if (client->options.non_blocking)
+    options|= GEARMAN_CLIENT_NON_BLOCKING;
+  if (client->options.task_in_use)
+    options|= GEARMAN_CLIENT_TASK_IN_USE;
+  if (client->options.unbuffered_result)
+    options|= GEARMAN_CLIENT_UNBUFFERED_RESULT;
+  if (client->options.no_new)
+    options|= GEARMAN_CLIENT_NO_NEW;
+  if (client->options.free_tasks)
+    options|= GEARMAN_CLIENT_FREE_TASKS;
+
+  return options;
 }
 
 void gearman_client_set_options(gearman_client_st *client,
                                 gearman_client_options_t options)
 {
-  /* Call this to catch any special triggers. */
-  gearman_client_add_options(client, options);
-
-  client->options= options;
+  gearman_client_options_t usable_options[]= {
+    GEARMAN_CLIENT_NON_BLOCKING,
+    GEARMAN_CLIENT_UNBUFFERED_RESULT,
+    GEARMAN_CLIENT_FREE_TASKS,
+    GEARMAN_CLIENT_MAX
+  };
+
+  gearman_client_options_t *ptr;
+
+
+  for (ptr= usable_options; *ptr != GEARMAN_CLIENT_MAX ; ptr++)
+  {
+    if (options & *ptr)
+    {
+      gearman_client_add_options(client, *ptr);
+    }
+    else
+    {
+      gearman_client_remove_options(client, *ptr);
+    }
+  }
 }
 
 void gearman_client_add_options(gearman_client_st *client,
                                 gearman_client_options_t options)
 {
   if (options & GEARMAN_CLIENT_NON_BLOCKING)
-    gearman_add_options(client->gearman, GEARMAN_NON_BLOCKING);
-
-  client->options|= options;
+  {
+    gearman_universal_add_options(&client->universal, GEARMAN_NON_BLOCKING);
+    client->options.non_blocking= true;
+  }
+
+  if (options & GEARMAN_CLIENT_UNBUFFERED_RESULT)
+  {
+    client->options.unbuffered_result= true;
+  }
+
+  if (options & GEARMAN_CLIENT_FREE_TASKS)
+  {
+    client->options.free_tasks= true;
+  }
 }
 
 void gearman_client_remove_options(gearman_client_st *client,
                                    gearman_client_options_t options)
 {
   if (options & GEARMAN_CLIENT_NON_BLOCKING)
-    gearman_remove_options(client->gearman, GEARMAN_NON_BLOCKING);
-
-  client->options&= ~options;
+  {
+    gearman_universal_remove_options(&client->universal, GEARMAN_NON_BLOCKING);
+    client->options.non_blocking= false;
+  }
+
+  if (options & GEARMAN_CLIENT_UNBUFFERED_RESULT)
+  {
+    client->options.unbuffered_result= false;
+  }
+
+  if (options & GEARMAN_CLIENT_FREE_TASKS)
+  {
+    client->options.free_tasks= false;
+  }
 }
 
 int gearman_client_timeout(gearman_client_st *client)
 {
-  return gearman_timeout(client->gearman);
+  return gearman_universal_timeout(&client->universal);
 }
 
 void gearman_client_set_timeout(gearman_client_st *client, int timeout)
 {
-  gearman_set_timeout(client->gearman, timeout);
+  gearman_universal_set_timeout(&client->universal, timeout);
 }
 
 void *gearman_client_context(const gearman_client_st *client)
@@ -220,34 +261,27 @@
                                gearman_log_fn *function, const void *context,
                                gearman_verbose_t verbose)
 {
-  gearman_set_log_fn(client->gearman, function, context, verbose);
-}
-
-void gearman_client_set_event_watch_fn(gearman_client_st *client,
-                                       gearman_event_watch_fn *function,
-                                       const void *context)
-{
-  gearman_set_event_watch_fn(client->gearman, function, context);
+  gearman_set_log_fn(&client->universal, function, context, verbose);
 }
 
 void gearman_client_set_workload_malloc_fn(gearman_client_st *client,
                                            gearman_malloc_fn *function,
                                            const void *context)
 {
-  gearman_set_workload_malloc_fn(client->gearman, function, context);
+  gearman_set_workload_malloc_fn(&client->universal, function, context);
 }
 
 void gearman_client_set_workload_free_fn(gearman_client_st *client,
                                          gearman_free_fn *function,
                                          const void *context)
 {
-  gearman_set_workload_free_fn(client->gearman, function, context);
+  gearman_set_workload_free_fn(&client->universal, function, context);
 }
 
 gearman_return_t gearman_client_add_server(gearman_client_st *client,
                                            const char *host, in_port_t port)
 {
-  if (gearman_add_con_args(client->gearman, NULL, host, port) == NULL)
+  if (gearman_connection_create_args(&client->universal, NULL, host, port) == NULL)
     return GEARMAN_MEMORY_ALLOCATION_FAILURE;
 
   return GEARMAN_SUCCESS;
@@ -261,12 +295,12 @@
 
 void gearman_client_remove_servers(gearman_client_st *client)
 {
-  gearman_free_all_cons(client->gearman);
+  gearman_free_all_cons(&client->universal);
 }
 
 gearman_return_t gearman_client_wait(gearman_client_st *client)
 {
-  return gearman_wait(client->gearman);
+  return gearman_wait(&client->universal);
 }
 
 void *gearman_client_do(gearman_client_st *client, const char *function_name,
@@ -355,14 +389,14 @@
 {
   gearman_return_t ret;
 
-  if (!(client->options & GEARMAN_CLIENT_TASK_IN_USE))
+  if (! (client->options.task_in_use))
   {
     (void)gearman_client_add_task_status(client, &(client->do_task), client,
                                          job_handle, &ret);
     if (ret != GEARMAN_SUCCESS)
       return ret;
 
-    client->options|= GEARMAN_CLIENT_TASK_IN_USE;
+    client->options.task_in_use= true;
   }
 
   gearman_client_clear_fn(client);
@@ -380,7 +414,7 @@
       *denominator= client->do_task.denominator;
 
     gearman_task_free(&(client->do_task));
-    client->options&= (gearman_client_options_t)~GEARMAN_CLIENT_TASK_IN_USE;
+    client->options.task_in_use= false;
   }
 
   return ret;
@@ -390,30 +424,7 @@
                                      const void *workload,
                                      size_t workload_size)
 {
-  return gearman_echo(client->gearman, workload, workload_size);
-}
-
-void gearman_task_free(gearman_task_st *task)
-{
-  if (task->options & GEARMAN_TASK_SEND_IN_USE)
-    gearman_packet_free(&(task->send));
-
-  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;
-  if (task->prev != NULL)
-    task->prev->next= task->next;
-  if (task->next != NULL)
-    task->next->prev= task->prev;
-  task->client->task_count--;
-
-  if (task->options & GEARMAN_TASK_ALLOCATED)
-    free(task);
+  return gearman_echo(&client->universal, workload, workload_size);
 }
 
 void gearman_client_task_free_all(gearman_client_st *client)
@@ -523,7 +534,7 @@
   const void *args[1];
   size_t args_size[1];
 
-  task= _task_create(client, task);
+  task= gearman_task_create(client, task);
   if (task == NULL)
   {
     *ret_ptr= GEARMAN_MEMORY_ALLOCATION_FAILURE;
@@ -535,15 +546,15 @@
 
   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);
+  *ret_ptr= gearman_packet_create_args(&client->universal, &(task->send),
+                                       GEARMAN_MAGIC_REQUEST,
+                                       GEARMAN_COMMAND_GET_STATUS,
+                                       args, args_size, 1);
   if (*ret_ptr == GEARMAN_SUCCESS)
   {
     client->new_tasks++;
     client->running_tasks++;
-    task->options|= GEARMAN_TASK_SEND_IN_USE;
+    task->options.send_in_use= true;
   }
 
   return task;
@@ -574,7 +585,7 @@
 }
 
 void gearman_client_set_status_fn(gearman_client_st *client,
-                                  gearman_status_fn *function)
+                                  gearman_universal_status_fn *function)
 {
   client->status_fn= function;
 }
@@ -611,11 +622,9 @@
 
 gearman_return_t gearman_client_run_tasks(gearman_client_st *client)
 {
-  gearman_options_t options;
   gearman_return_t ret;
 
-  options= client->gearman->options;
-  client->gearman->options|= GEARMAN_NON_BLOCKING;
+  gearman_universal_push_non_blocking(&client->universal);
 
   switch(client->state)
   {
@@ -623,7 +632,7 @@
     while (1)
     {
       /* Start any new tasks. */
-      if (client->new_tasks > 0 && !(client->options & GEARMAN_CLIENT_NO_NEW))
+      if (client->new_tasks > 0 && ! (client->options.no_new))
       {
         for (client->task= client->task_list; client->task != NULL;
              client->task= client->task->next)
@@ -636,24 +645,24 @@
           if (ret != GEARMAN_SUCCESS && ret != GEARMAN_IO_WAIT)
           {
             client->state= GEARMAN_CLIENT_STATE_NEW;
-            client->gearman->options= options;
+            gearman_universal_pop_non_blocking(&client->universal);
             return ret;
           }
         }
 
         if (client->new_tasks == 0)
         {
-          ret= gearman_flush_all(client->gearman);
+          ret= gearman_flush_all(&client->universal);
           if (ret != GEARMAN_SUCCESS)
           {
-            client->gearman->options= options;
+            gearman_universal_pop_non_blocking(&client->universal);
             return ret;
           }
         }
       }
 
       /* See if there are any connections ready for I/O. */
-      while ((client->con= gearman_ready(client->gearman)) != NULL)
+      while ((client->con= gearman_ready(&client->universal)) != NULL)
       {
         if (client->con->revents & (POLLOUT | POLLERR | POLLHUP | POLLNVAL))
         {
@@ -673,7 +682,7 @@
             if (ret != GEARMAN_SUCCESS && ret != GEARMAN_IO_WAIT)
             {
               client->state= GEARMAN_CLIENT_STATE_SUBMIT;
-              client->gearman->options= options;
+              gearman_universal_pop_non_blocking(&client->universal);
               return ret;
             }
           }
@@ -686,7 +695,7 @@
         while (1)
         {
           /* Read packet on connection and find which task it belongs to. */
-          if (client->options & GEARMAN_CLIENT_UNBUFFERED_RESULT)
+          if (client->options.unbuffered_result)
           {
             /* If client is handling the data read, make sure it's complete. */
             if (client->con->recv_state == GEARMAN_CON_RECV_STATE_READ_DATA)
@@ -708,7 +717,7 @@
             {
               /* Read the next packet, without buffering the data part. */
               client->task= NULL;
-              (void)gearman_con_recv(client->con, &(client->con->packet), &ret,
+              (void)gearman_connection_recv(client->con, &(client->con->packet), &ret,
                                      false);
             }
           }
@@ -716,24 +725,24 @@
           {
             /* Read the next packet, buffering the data part. */
             client->task= NULL;
-            (void)gearman_con_recv(client->con, &(client->con->packet), &ret,
+            (void)gearman_connection_recv(client->con, &(client->con->packet), &ret,
                                    true);
           }
 
           if (client->task == NULL)
           {
-            /* Check the return of the gearman_con_recv() calls above. */
+            /* Check the return of the gearman_connection_recv() calls above. */
             if (ret != GEARMAN_SUCCESS)
             {
               if (ret == GEARMAN_IO_WAIT)
                 break;
 
               client->state= GEARMAN_CLIENT_STATE_IDLE;
-              client->gearman->options= options;
+              gearman_universal_pop_non_blocking(&client->universal);
               return ret;
             }
 
-            client->con->options|= GEARMAN_CON_PACKET_IN_USE;
+            client->con->options.packet_in_use= true;
 
             /* We have a packet, see which task it belongs to. */
             for (client->task= client->task_list; client->task != NULL;
@@ -752,7 +761,7 @@
               }
               else if (client->con->packet.command == GEARMAN_COMMAND_ERROR)
               {
-		gearman_set_error(client->gearman, "gearman_client_run_tasks",
+		gearman_universal_set_error(&client->universal, "gearman_client_run_tasks",
 				  "%s:%.*s",
 				  (char *)(client->con->packet.arg[0]),
 				  (int)(client->con->packet.arg_size[1]),
@@ -788,14 +797,13 @@
           if (ret != GEARMAN_SUCCESS)
           {
             client->state= GEARMAN_CLIENT_STATE_PACKET;
-            client->gearman->options= options;
+            gearman_universal_pop_non_blocking(&client->universal);
             return ret;
           }
 
           /* Clean up the packet. */
           gearman_packet_free(&(client->con->packet));
-          client->con->options&=
-                           (gearman_client_options_t)~GEARMAN_CON_PACKET_IN_USE;
+          client->con->options.packet_in_use= false;
 
           /* If all tasks are done, return. */
           if (client->running_tasks == 0)
@@ -807,23 +815,24 @@
       if (client->running_tasks == 0)
         break;
 
-      if (client->new_tasks > 0 && !(client->options & GEARMAN_CLIENT_NO_NEW))
+      if (client->new_tasks > 0 && ! (client->options.no_new))
         continue;
 
-      if (options & GEARMAN_NON_BLOCKING)
+      if (gearman_universal_is_stored_non_blocking(&client->universal))
       {
         /* Let the caller wait for activity. */
         client->state= GEARMAN_CLIENT_STATE_IDLE;
-        client->gearman->options= options;
+        gearman_universal_pop_non_blocking(&client->universal);
+
         return GEARMAN_IO_WAIT;
       }
 
       /* Wait for activity on one of the connections. */
-      ret= gearman_wait(client->gearman);
+      ret= gearman_wait(&client->universal);
       if (ret != GEARMAN_SUCCESS && ret != GEARMAN_IO_WAIT)
       {
         client->state= GEARMAN_CLIENT_STATE_IDLE;
-        client->gearman->options= options;
+        gearman_universal_pop_non_blocking(&client->universal);
         return ret;
       }
     }
@@ -831,14 +840,16 @@
     break;
 
   default:
-    gearman_set_error(client->gearman, "gearman_client_run_tasks",
+    gearman_universal_set_error(&client->universal, "gearman_client_run_tasks",
                       "unknown state: %u", client->state);
-    client->gearman->options= options;
+    gearman_universal_pop_non_blocking(&client->universal);
+
     return GEARMAN_UNKNOWN_STATE;
   }
 
   client->state= GEARMAN_CLIENT_STATE_IDLE;
-  client->gearman->options= options;
+  gearman_universal_pop_non_blocking(&client->universal);
+
   return GEARMAN_SUCCESS;
 }
 
@@ -846,7 +857,7 @@
  * Static Definitions
  */
 
-static gearman_client_st *_client_allocate(gearman_client_st *client)
+static gearman_client_st *_client_allocate(gearman_client_st *client, bool is_clone)
 {
   if (client == NULL)
   {
@@ -854,10 +865,18 @@
     if (client == NULL)
       return NULL;
 
-    client->options= GEARMAN_CLIENT_ALLOCATED;
+    client->options.allocated= true;
   }
   else
-    client->options= 0;
+  {
+    client->options.allocated= false;
+  }
+
+  client->options.non_blocking= false;
+  client->options.task_in_use= false;
+  client->options.unbuffered_result= false;
+  client->options.no_new= false;
+  client->options.free_tasks= false;
 
   client->state= 0;
   client->do_ret= 0;
@@ -865,7 +884,6 @@
   client->running_tasks= 0;
   client->task_count= 0;
   client->do_data_size= 0;
-  client->gearman= NULL;
   client->context= NULL;
   client->con= NULL;
   client->task= NULL;
@@ -881,6 +899,18 @@
   client->exception_fn= NULL;
   client->fail_fn= NULL;
 
+  if (! is_clone)
+  {
+    gearman_universal_st *check;
+
+    check= gearman_universal_create(&client->universal, NULL);
+    if (check == NULL)
+    {
+      gearman_client_free(client);
+      return NULL;
+    }
+  }
+
   return client;
 }
 
@@ -905,7 +935,7 @@
   const void *args[3];
   size_t args_size[3];
 
-  task= _task_create(client, task);
+  task= gearman_task_create(client, task);
   if (task == NULL)
   {
     *ret_ptr= GEARMAN_MEMORY_ALLOCATION_FAILURE;
@@ -928,14 +958,14 @@
   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);
+  *ret_ptr= gearman_packet_create_args(&client->universal, &(task->send),
+                                       GEARMAN_MAGIC_REQUEST, command,
+                                       args, args_size, 3);
   if (*ret_ptr == GEARMAN_SUCCESS)
   {
     client->new_tasks++;
     client->running_tasks++;
-    task->options|= GEARMAN_TASK_SEND_IN_USE;
+    task->options.send_in_use= true;
   }
 
   return task;
@@ -951,16 +981,16 @@
   switch(task->state)
   {
   case GEARMAN_TASK_STATE_NEW:
-    if (task->client->gearman->con_list == NULL)
+    if (task->client->universal.con_list == NULL)
     {
       client->new_tasks--;
       client->running_tasks--;
-      gearman_set_error(client->gearman, "_client_run_task",
+      gearman_universal_set_error(&client->universal, "_client_run_task",
                         "no servers added");
       return GEARMAN_NO_SERVERS;
     }
 
-    for (task->con= task->client->gearman->con_list; task->con != NULL;
+    for (task->con= task->client->universal.con_list; task->con != NULL;
          task->con= task->con->next)
     {
       if (task->con->send_state == GEARMAN_CON_SEND_STATE_NONE)
@@ -969,7 +999,7 @@
 
     if (task->con == NULL)
     {
-      client->options|= GEARMAN_CLIENT_NO_NEW;
+      client->options.no_new= true;
       return GEARMAN_IO_WAIT;
     }
 
@@ -984,7 +1014,7 @@
   case GEARMAN_TASK_STATE_SUBMIT:
     while (1)
     {
-      ret= gearman_con_send(task->con, &(task->send),
+      ret= gearman_connection_send(task->con, &(task->send),
                             client->new_tasks == 0 ? true : false);
       if (ret == GEARMAN_SUCCESS)
         break;
@@ -1028,8 +1058,8 @@
     {
       if (client->workload_fn == NULL)
       {
-        gearman_set_error(client->gearman, "_client_run_task",
-             "workload size > 0, but no data pointer or workload_fn was given");
+        gearman_universal_set_error(&client->universal, "_client_run_task",
+                                    "workload size > 0, but no data pointer or workload_fn was given");
         return GEARMAN_NEED_WORKLOAD_FN;
       }
 
@@ -1042,9 +1072,9 @@
       }
     }
 
-    client->options&= (gearman_client_options_t)~GEARMAN_CLIENT_NO_NEW;
+    client->options.no_new= false;
     task->state= GEARMAN_TASK_STATE_WORK;
-    return gearman_con_set_events(task->con, POLLIN);
+    return gearman_connection_set_events(task->con, POLLIN);
 
   case GEARMAN_TASK_STATE_WORK:
     if (task->recv->command == GEARMAN_COMMAND_JOB_CREATED)
@@ -1188,15 +1218,15 @@
     break;
 
   default:
-    gearman_set_error(client->gearman, "_client_run_task", "unknown state: %u",
-                      task->state);
+    gearman_universal_set_error(&client->universal, "_client_run_task", "unknown state: %u",
+                                task->state);
     return GEARMAN_UNKNOWN_STATE;
   }
 
   client->running_tasks--;
   task->state= GEARMAN_TASK_STATE_FINISHED;
 
-  if (client->options & GEARMAN_CLIENT_FREE_TASKS)
+  if (client->options.free_tasks)
     gearman_task_free(task);
 
   return GEARMAN_SUCCESS;
@@ -1207,7 +1237,7 @@
                         const void *workload, size_t workload_size,
                         size_t *result_size, gearman_return_t *ret_ptr)
 {
-  if (!(client->options & GEARMAN_CLIENT_TASK_IN_USE))
+  if (! client->options.task_in_use)
   {
     (void)_client_add_task(client, &(client->do_task), client, command,
                            function_name, unique, workload, workload_size,
@@ -1215,7 +1245,7 @@
     if (*ret_ptr != GEARMAN_SUCCESS)
       return NULL;
 
-    client->options|= GEARMAN_CLIENT_TASK_IN_USE;
+    client->options.task_in_use= true;
   }
 
   client->workload_fn= NULL;
@@ -1232,7 +1262,7 @@
       client->do_ret == GEARMAN_WORK_FAIL))
   {
     gearman_task_free(&(client->do_task));
-    client->options&= (gearman_client_options_t)~GEARMAN_CLIENT_TASK_IN_USE;
+    client->options.task_in_use= false;
   }
 
   workload= NULL;
@@ -1259,7 +1289,7 @@
 {
   gearman_return_t ret;
 
-  if (!(client->options & GEARMAN_CLIENT_TASK_IN_USE))
+  if (! client->options.task_in_use)
   {
     (void)_client_add_task(client, &(client->do_task), client, command,
                            function_name, unique, workload, workload_size,
@@ -1267,7 +1297,7 @@
     if (ret != GEARMAN_SUCCESS)
       return ret;
 
-    client->options|= GEARMAN_CLIENT_TASK_IN_USE;
+    client->options.task_in_use= true;
   }
 
   gearman_client_clear_fn(client);
@@ -1279,7 +1309,7 @@
       strcpy(job_handle, client->do_task.job_handle);
 
     gearman_task_free(&(client->do_task));
-    client->options&= (gearman_client_options_t)~GEARMAN_CLIENT_TASK_IN_USE;
+    client->options.task_in_use= false;
   }
 
   return ret;
@@ -1330,43 +1360,3 @@
   client->do_ret= GEARMAN_WORK_FAIL;
   return GEARMAN_SUCCESS;
 }
-
-static gearman_task_st *_task_create(gearman_client_st *client,
-                                     gearman_task_st *task)
-{
-  if (task == NULL)
-  {
-    task= malloc(sizeof(gearman_task_st));
-    if (task == NULL)
-    {
-      gearman_set_error(client->gearman, "_task_create", "malloc");
-      return NULL;
-    }
-
-    task->options= GEARMAN_TASK_ALLOCATED;
-  }
-  else
-    task->options= 0;
-
-  task->state= 0;
-  task->is_known= false;
-  task->is_running= false;
-  task->created_id= 0;
-  task->numerator= 0;
-  task->denominator= 0;
-  task->client= client;
-
-  if (client->task_list != NULL)
-    client->task_list->prev= task;
-  task->next= client->task_list;
-  task->prev= NULL;
-  client->task_list= task;
-  client->task_count++;
-
-  task->context= NULL;
-  task->con= NULL;
-  task->recv= NULL;
-  task->job_handle[0]= 0;
-
-  return task;
-}

=== modified file 'libgearman/client.h'
--- libgearman/client.h	2009-11-06 00:38:02 +0000
+++ libgearman/client.h	2009-12-30 19:24:13 +0000
@@ -28,6 +28,49 @@
  * @{
  */
 
+
+/**
+ * @ingroup gearman_client
+ */
+struct gearman_client_st
+{
+  struct {
+    bool allocated:1;
+    bool non_blocking:1;
+    bool task_in_use:1;
+    bool unbuffered_result:1;
+    bool no_new:1;
+    bool free_tasks:1;
+  } options;
+  enum {
+    GEARMAN_CLIENT_STATE_IDLE,
+    GEARMAN_CLIENT_STATE_NEW,
+    GEARMAN_CLIENT_STATE_SUBMIT,
+    GEARMAN_CLIENT_STATE_PACKET
+  } state;
+  gearman_return_t do_ret;
+  uint32_t new_tasks;
+  uint32_t running_tasks;
+  uint32_t task_count;
+  size_t do_data_size;
+  const void *context;
+  gearman_connection_st *con;
+  gearman_task_st *task;
+  gearman_task_st *task_list;
+  gearman_task_context_free_fn *task_context_free_fn;
+  void *do_data;
+  gearman_workload_fn *workload_fn;
+  gearman_created_fn *created_fn;
+  gearman_data_fn *data_fn;
+  gearman_warning_fn *warning_fn;
+  gearman_universal_status_fn *status_fn;
+  gearman_complete_fn *complete_fn;
+  gearman_exception_fn *exception_fn;
+  gearman_fail_fn *fail_fn;
+  gearman_universal_st universal;
+  gearman_task_st do_task;
+};
+
 /**
  * Initialize a client structure. Always check the return value even if passing
  * in a pre-allocated structure. Some other initialization may have failed. It
@@ -116,13 +159,13 @@
                                    gearman_client_options_t options);
 
 /**
- * See gearman_timeout() for details.
+ * See gearman_universal_timeout() for details.
  */
 GEARMAN_API
 int gearman_client_timeout(gearman_client_st *client);
 
 /**
- * See gearman_set_timeout() for details.
+ * See gearman_universal_set_timeout() for details.
  */
 GEARMAN_API
 void gearman_client_set_timeout(gearman_client_st *client, int timeout);
@@ -156,14 +199,6 @@
                                gearman_verbose_t verbose);
 
 /**
- * See gearman_set_event_watch_fn() for details.
- */
-GEARMAN_API
-void gearman_client_set_event_watch_fn(gearman_client_st *client,
-                                       gearman_event_watch_fn *function,
-                                       const void *context);
-
-/**
  * See gearman_set_workload_malloc_fn() for details.
  */
 GEARMAN_API
@@ -403,15 +438,6 @@
  */
 
 /**
- * Free a task structure.
- *
- * @param[in] task Structure previously initialized with one of the
- *  gearman_client_add_task() functions.
- */
-GEARMAN_API
-void gearman_task_free(gearman_task_st *task);
-
-/**
  * Free all tasks for a gearman structure.
  *
  * @param[in] client Structure previously initialized with
@@ -601,7 +627,7 @@
  */
 GEARMAN_API
 void gearman_client_set_status_fn(gearman_client_st *client,
-                                  gearman_status_fn *function);
+                                  gearman_universal_status_fn *function);
 
 /**
  * Callback function when a task is complete.

=== renamed file 'libgearman/structs.h' => 'libgearman/command.h'
--- libgearman/structs.h	2009-10-29 00:11:45 +0000
+++ libgearman/command.h	2009-12-30 19:24:13 +0000
@@ -8,64 +8,17 @@
 
 /**
  * @file
- * @brief Struct Definitions
+ * @brief Definition for gearman_command_info_st
  */
 
-#ifndef __GEARMAN_STRUCTS_H__
-#define __GEARMAN_STRUCTS_H__
+#ifndef __GEARMAN_COMMAND_H__
+#define __GEARMAN_COMMAND_H__
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-/**
- * @ingroup gearman
- */
-struct gearman_st
-{
-  gearman_options_t options;
-  gearman_verbose_t verbose;
-  uint32_t con_count;
-  uint32_t packet_count;
-  uint32_t pfds_size;
-  uint32_t sending;
-  int last_errno;
-  int timeout;
-  gearman_con_st *con_list;
-  gearman_packet_st *packet_list;
-  struct pollfd *pfds;
-  gearman_log_fn *log_fn;
-  const void *log_context;
-  gearman_event_watch_fn *event_watch_fn;
-  const void *event_watch_context;
-  gearman_malloc_fn *workload_malloc_fn;
-  const void *workload_malloc_context;
-  gearman_free_fn *workload_free_fn;
-  const void *workload_free_context;
-  char last_error[GEARMAN_MAX_ERROR_SIZE];
-};
-
-/**
- * @ingroup gearman_packet
- */
-struct gearman_packet_st
-{
-  gearman_packet_options_t options;
-  gearman_magic_t magic;
-  gearman_command_t command;
-  uint8_t argc;
-  size_t args_size;
-  size_t data_size;
-  gearman_st *gearman;
-  gearman_packet_st *next;
-  gearman_packet_st *prev;
-  uint8_t *args;
-  const void *data;
-  uint8_t *arg[GEARMAN_MAX_COMMAND_ARGS];
-  size_t arg_size[GEARMAN_MAX_COMMAND_ARGS];
-  uint8_t args_buffer[GEARMAN_ARGS_BUFFER_SIZE];
-};
-
+#ifdef GEARMAN_CORE
 /**
  * @ingroup gearman_packet
  */
@@ -75,156 +28,10 @@
   const uint8_t argc;
   const bool data;
 };
-
-/**
- * @ingroup gearman_con
- */
-struct gearman_con_st
-{
-  gearman_con_options_t options;
-  gearman_con_state_t state;
-  gearman_con_send_state_t send_state;
-  gearman_con_recv_state_t recv_state;
-  in_port_t port;
-  short events;
-  short revents;
-  int fd;
-  uint32_t created_id;
-  uint32_t created_id_next;
-  size_t send_buffer_size;
-  size_t send_data_size;
-  size_t send_data_offset;
-  size_t recv_buffer_size;
-  size_t recv_data_size;
-  size_t recv_data_offset;
-  gearman_st *gearman;
-  gearman_con_st *next;
-  gearman_con_st *prev;
-  const void *context;
-  struct addrinfo *addrinfo;
-  struct addrinfo *addrinfo_next;
-  uint8_t *send_buffer_ptr;
-  gearman_packet_st *recv_packet;
-  uint8_t *recv_buffer_ptr;
-  const void *protocol_context;
-  gearman_con_protocol_context_free_fn *protocol_context_free_fn;
-  gearman_packet_pack_fn *packet_pack_fn;
-  gearman_packet_unpack_fn *packet_unpack_fn;
-  gearman_packet_st packet;
-  char host[NI_MAXHOST];
-  uint8_t send_buffer[GEARMAN_SEND_BUFFER_SIZE];
-  uint8_t recv_buffer[GEARMAN_RECV_BUFFER_SIZE];
-};
-
-/**
- * @ingroup gearman_task
- */
-struct gearman_task_st
-{
-  gearman_task_options_t options;
-  gearman_task_state_t state;
-  bool is_known;
-  bool is_running;
-  uint32_t created_id;
-  uint32_t numerator;
-  uint32_t denominator;
-  gearman_client_st *client;
-  gearman_task_st *next;
-  gearman_task_st *prev;
-  const void *context;
-  gearman_con_st *con;
-  gearman_packet_st *recv;
-  gearman_packet_st send;
-  char job_handle[GEARMAN_JOB_HANDLE_SIZE];
-};
-
-/**
- * @ingroup gearman_job
- */
-struct gearman_job_st
-{
-  gearman_job_options_t options;
-  gearman_worker_st *worker;
-  gearman_job_st *next;
-  gearman_job_st *prev;
-  gearman_con_st *con;
-  gearman_packet_st assigned;
-  gearman_packet_st work;
-};
-
-/**
- * @ingroup gearman_client
- */
-struct gearman_client_st
-{
-  gearman_client_options_t options;
-  gearman_client_state_t state;
-  gearman_return_t do_ret;
-  uint32_t new_tasks;
-  uint32_t running_tasks;
-  uint32_t task_count;
-  size_t do_data_size;
-  gearman_st *gearman;
-  const void *context;
-  gearman_con_st *con;
-  gearman_task_st *task;
-  gearman_task_st *task_list;
-  gearman_task_context_free_fn *task_context_free_fn;
-  void *do_data;
-  gearman_workload_fn *workload_fn;
-  gearman_created_fn *created_fn;
-  gearman_data_fn *data_fn;
-  gearman_warning_fn *warning_fn;
-  gearman_status_fn *status_fn;
-  gearman_complete_fn *complete_fn;
-  gearman_exception_fn *exception_fn;
-  gearman_fail_fn *fail_fn;
-  gearman_st gearman_static;
-  gearman_task_st do_task;
-};
-
-/**
- * @ingroup gearman_worker
- */
-struct gearman_worker_st
-{
-  gearman_worker_options_t options;
-  gearman_worker_state_t state;
-  gearman_worker_work_state_t work_state;
-  uint32_t function_count;
-  uint32_t job_count;
-  size_t work_result_size;
-  gearman_st *gearman;
-  const void *context;
-  gearman_con_st *con;
-  gearman_job_st *job;
-  gearman_job_st *job_list;
-  gearman_worker_function_st *function;
-  gearman_worker_function_st *function_list;
-  gearman_worker_function_st *work_function;
-  void *work_result;
-  gearman_st gearman_static;
-  gearman_packet_st grab_job;
-  gearman_packet_st pre_sleep;
-  gearman_job_st work_job;
-};
-
-/**
- * @ingroup gearman_worker
- */
-struct gearman_worker_function_st
-{
-  gearman_worker_function_options_t options;
-  gearman_worker_function_st *next;
-  gearman_worker_function_st *prev;
-  char *function_name;
-  gearman_worker_fn *worker_fn;
-  const void *context;
-  gearman_packet_st packet;
-};
+#endif /* GEARMAN_CORE */
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* __GEARMAN_STRUCTS_H__ */
+#endif /* __GEARMAN_COMMAND_H__ */

=== modified file 'libgearman/common.h'
--- libgearman/common.h	2009-10-29 00:11:45 +0000
+++ libgearman/common.h	2009-12-30 19:24:13 +0000
@@ -16,6 +16,7 @@
 
 #include "config.h"
 
+#define GEARMAN_CORE
 #include "gearman.h"
 
 #ifdef HAVE_ASSERT_H
@@ -75,6 +76,4 @@
 # endif
 #endif
 
-#include "gearman_local.h"
-
 #endif /* __GEARMAN_COMMON_H__ */

=== renamed file 'libgearman/conn.c' => 'libgearman/connection.c'
--- libgearman/conn.c	2009-10-29 20:18:00 +0000
+++ libgearman/connection.c	2009-12-30 19:24:13 +0000
@@ -13,16 +13,181 @@
 
 #include "common.h"
 
+static void gearman_connection_reset_addrinfo(gearman_connection_st *connection);
+
+
 /**
- * @addtogroup gearman_con_static Static Connection Declarations
- * @ingroup gearman_con
+ * @addtogroup gearman_connection_static Static Connection Declarations
+ * @ingroup gearman_connection
  * @{
  */
 
+
+gearman_connection_st *gearman_connection_create(gearman_universal_st *gearman,
+                                                 gearman_connection_st *connection,
+                                                 gearman_connection_options_t *options)
+{
+  if (connection == NULL)
+  {
+    connection= malloc(sizeof(gearman_connection_st));
+    if (connection == NULL)
+    {
+      gearman_universal_set_error(gearman, "gearman_connection_create", "malloc");
+      return NULL;
+    }
+
+    connection->options.allocated= true;
+  }
+  else
+  {
+    connection->options.allocated= false;
+  }
+
+  connection->options.ready= false;
+  connection->options.packet_in_use= false;
+  connection->options.external_fd= false;
+  connection->options.ignore_lost_connection= false;
+  connection->options.close_after_flush= false;
+
+  if (options)
+  {
+    while (*options != GEARMAN_CON_MAX)
+    {
+      gearman_connection_set_option(connection, *options, true);
+      options++;
+    }
+  }
+
+
+  connection->state= 0;
+  connection->send_state= 0;
+  connection->recv_state= 0;
+  connection->port= 0;
+  connection->events= 0;
+  connection->revents= 0;
+  connection->fd= -1;
+  connection->created_id= 0;
+  connection->created_id_next= 0;
+  connection->send_buffer_size= 0;
+  connection->send_data_size= 0;
+  connection->send_data_offset= 0;
+  connection->recv_buffer_size= 0;
+  connection->recv_data_size= 0;
+  connection->recv_data_offset= 0;
+  connection->gearman= gearman;
+
+  if (gearman->con_list != NULL)
+    gearman->con_list->prev= connection;
+  connection->next= gearman->con_list;
+  connection->prev= NULL;
+  gearman->con_list= connection;
+  gearman->con_count++;
+
+  connection->context= NULL;
+  connection->addrinfo= NULL;
+  connection->addrinfo_next= NULL;
+  connection->send_buffer_ptr= connection->send_buffer;
+  connection->recv_packet= NULL;
+  connection->recv_buffer_ptr= connection->recv_buffer;
+  connection->protocol_context= NULL;
+  connection->protocol_context_free_fn= NULL;
+  connection->packet_pack_fn= gearman_packet_pack;
+  connection->packet_unpack_fn= gearman_packet_unpack;
+  connection->host[0]= 0;
+
+  return connection;
+}
+
+gearman_connection_st *gearman_connection_create_args(gearman_universal_st *gearman, gearman_connection_st *connection,
+                                                      const char *host, in_port_t port)
+{
+  connection= gearman_connection_create(gearman, connection, NULL);
+  if (connection == NULL)
+    return NULL;
+
+  gearman_connection_set_host(connection, host, port);
+
+  return connection;
+}
+
+gearman_connection_st *gearman_connection_clone(gearman_universal_st *gearman, gearman_connection_st *connection,
+                                                const gearman_connection_st *from)
+{
+  connection= gearman_connection_create(gearman, connection, NULL);
+
+  if (from || connection == NULL)
+    return connection;
+
+  connection->options.ready= from->options.ready;
+  connection->options.packet_in_use= from->options.packet_in_use;
+  connection->options.external_fd= from->options.external_fd;
+  connection->options.ignore_lost_connection= from->options.ignore_lost_connection;
+  connection->options.close_after_flush= from->options.close_after_flush;
+
+  strcpy(connection->host, from->host);
+  connection->port= from->port;
+
+  return connection;
+}
+
+void gearman_connection_free(gearman_connection_st *connection)
+{
+  if (connection->fd != -1)
+    gearman_connection_close(connection);
+
+  gearman_connection_reset_addrinfo(connection);
+
+  if (connection->protocol_context != NULL && connection->protocol_context_free_fn != NULL)
+    connection->protocol_context_free_fn(connection, (void *)connection->protocol_context);
+
+  if (connection->gearman->con_list == connection)
+    connection->gearman->con_list= connection->next;
+  if (connection->prev != NULL)
+    connection->prev->next= connection->next;
+  if (connection->next != NULL)
+    connection->next->prev= connection->prev;
+  connection->gearman->con_count--;
+
+  if (connection->options.packet_in_use)
+    gearman_packet_free(&(connection->packet));
+
+  if (connection->options.allocated)
+    free(connection);
+}
+
+gearman_return_t gearman_connection_set_option(gearman_connection_st *connection,
+                                               gearman_connection_options_t options,
+                                               bool value)
+{
+  switch (options)
+  {
+  case GEARMAN_CON_READY:
+    connection->options.ready= value;
+    break;
+  case GEARMAN_CON_PACKET_IN_USE:
+    connection->options.packet_in_use= value;
+    break;
+  case GEARMAN_CON_EXTERNAL_FD:
+    connection->options.external_fd= value;
+    break;
+  case GEARMAN_CON_IGNORE_LOST_CONNECTION:
+    connection->options.ignore_lost_connection= value;
+    break;
+  case GEARMAN_CON_CLOSE_AFTER_FLUSH:
+    connection->options.close_after_flush= value;
+    break;
+  case GEARMAN_CON_MAX:
+  default:
+    return GEARMAN_INVALID_COMMAND;
+  }
+
+  return GEARMAN_SUCCESS;
+}
+
 /**
  * Set socket options for a connection.
  */
-static gearman_return_t _con_setsockopt(gearman_con_st *con);
+static gearman_return_t _con_setsockopt(gearman_connection_st *connection);
 
 /** @} */
 
@@ -30,129 +195,103 @@
  * Public Definitions
  */
 
-void gearman_con_set_host(gearman_con_st *con, const char *host)
+void gearman_connection_set_host(gearman_connection_st *connection,
+                                 const char *host,
+                                 in_port_t port)
 {
-  gearman_con_reset_addrinfo(con);
+  gearman_connection_reset_addrinfo(connection);
 
-  strncpy(con->host, host == NULL ? GEARMAN_DEFAULT_TCP_HOST : host,
+  strncpy(connection->host, host == NULL ? GEARMAN_DEFAULT_TCP_HOST : host,
           NI_MAXHOST);
-  con->host[NI_MAXHOST - 1]= 0;
-}
-
-void gearman_con_set_port(gearman_con_st *con, in_port_t port)
-{
-  gearman_con_reset_addrinfo(con);
-
-  con->port= (in_port_t)(port == 0 ? GEARMAN_DEFAULT_TCP_PORT : port);
-}
-
-gearman_con_options_t gearman_con_options(const gearman_con_st *con)
-{
-  return con->options;
-}
-
-void gearman_con_set_options(gearman_con_st *con,
-                             gearman_con_options_t options)
-{
-  con->options= options;
-}
-
-void gearman_con_add_options(gearman_con_st *con,
-                             gearman_con_options_t options)
-{
-  con->options|= options;
-}
-
-void gearman_con_remove_options(gearman_con_st *con,
-                                gearman_con_options_t options)
-{
-  con->options&= ~options;
-}
-
-gearman_return_t gearman_con_set_fd(gearman_con_st *con, int fd)
+  connection->host[NI_MAXHOST - 1]= 0;
+
+  connection->port= (in_port_t)(port == 0 ? GEARMAN_DEFAULT_TCP_PORT : port);
+}
+
+gearman_return_t gearman_connection_set_fd(gearman_connection_st *connection, int fd)
 {
   gearman_return_t ret;
 
-  con->options|= GEARMAN_CON_EXTERNAL_FD;
-  con->fd= fd;
-  con->state= GEARMAN_CON_STATE_CONNECTED;
+  connection->options.external_fd= true;
+  connection->fd= fd;
+  connection->state= GEARMAN_CON_UNIVERSAL_CONNECTED;
 
-  ret= _con_setsockopt(con);
+  ret= _con_setsockopt(connection);
   if (ret != GEARMAN_SUCCESS)
   {
-    con->gearman->last_errno= errno;
+    connection->gearman->last_errno= errno;
     return ret;
   }
 
   return GEARMAN_SUCCESS;
 }
 
-void *gearman_con_context(const gearman_con_st *con)
-{
-  return (void *)con->context;
-}
-
-void gearman_con_set_context(gearman_con_st *con, const void *context)
-{
-  con->context= context;
-}
-
-gearman_return_t gearman_con_connect(gearman_con_st *con)
-{
-  return gearman_con_flush(con);
-}
-
-void gearman_con_close(gearman_con_st *con)
-{
-  if (con->fd == -1)
+void *gearman_connection_context(const gearman_connection_st *connection)
+{
+  return (void *)connection->context;
+}
+
+void gearman_connection_set_context(gearman_connection_st *connection, const void *context)
+{
+  connection->context= context;
+}
+
+gearman_return_t gearman_connection_connect(gearman_connection_st *connection)
+{
+  return gearman_connection_flush(connection);
+}
+
+void gearman_connection_close(gearman_connection_st *connection)
+{
+  if (connection->fd == -1)
     return;
 
-  if (con->options & GEARMAN_CON_EXTERNAL_FD)
-    con->options&= (gearman_con_options_t)~GEARMAN_CON_EXTERNAL_FD;
+  if (connection->options.external_fd)
+    connection->options.external_fd= false;
   else
-    (void)close(con->fd);
-
-  con->state= GEARMAN_CON_STATE_ADDRINFO;
-  con->fd= -1;
-  con->events= 0;
-  con->revents= 0;
-
-  con->send_state= GEARMAN_CON_SEND_STATE_NONE;
-  con->send_buffer_ptr= con->send_buffer;
-  con->send_buffer_size= 0;
-  con->send_data_size= 0;
-  con->send_data_offset= 0;
-
-  con->recv_state= GEARMAN_CON_RECV_STATE_NONE;
-  if (con->recv_packet != NULL)
-    gearman_packet_free(con->recv_packet);
-  con->recv_buffer_ptr= con->recv_buffer;
-  con->recv_buffer_size= 0;
+    (void)close(connection->fd);
+
+  connection->state= GEARMAN_CON_UNIVERSAL_ADDRINFO;
+  connection->fd= -1;
+  connection->events= 0;
+  connection->revents= 0;
+
+  connection->send_state= GEARMAN_CON_SEND_STATE_NONE;
+  connection->send_buffer_ptr= connection->send_buffer;
+  connection->send_buffer_size= 0;
+  connection->send_data_size= 0;
+  connection->send_data_offset= 0;
+
+  connection->recv_state= GEARMAN_CON_RECV_UNIVERSAL_NONE;
+  if (connection->recv_packet != NULL)
+    gearman_packet_free(connection->recv_packet);
+  connection->recv_buffer_ptr= connection->recv_buffer;
+  connection->recv_buffer_size= 0;
 }
 
-void gearman_con_reset_addrinfo(gearman_con_st *con)
+void gearman_connection_reset_addrinfo(gearman_connection_st *connection)
 {
-  if (con->addrinfo != NULL)
+  if (connection->addrinfo != NULL)
   {
-    freeaddrinfo(con->addrinfo);
-    con->addrinfo= NULL;
+    freeaddrinfo(connection->addrinfo);
+    connection->addrinfo= NULL;
   }
 
-  con->addrinfo_next= NULL;
+  connection->addrinfo_next= NULL;
 }
 
-gearman_return_t gearman_con_send(gearman_con_st *con,
-                                  const gearman_packet_st *packet, bool flush)
+gearman_return_t gearman_connection_send(gearman_connection_st *connection,
+                                         const gearman_packet_st *packet, bool flush)
 {
   gearman_return_t ret;
   size_t send_size;
 
-  switch (con->send_state)
+  switch (connection->send_state)
   {
   case GEARMAN_CON_SEND_STATE_NONE:
-    if (!(packet->options & GEARMAN_PACKET_COMPLETE))
+    if (! (packet->options.complete))
     {
-      gearman_set_error(con->gearman, "gearman_con_send",
+      gearman_universal_set_error(connection->gearman, "gearman_connection_send",
                         "packet not complete");
       return GEARMAN_INVALID_PACKET;
     }
@@ -160,13 +299,13 @@
     /* 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,
+      send_size= connection->packet_pack_fn(packet, connection,
+                                     connection->send_buffer + connection->send_buffer_size,
                                      GEARMAN_SEND_BUFFER_SIZE -
-                                     con->send_buffer_size, &ret);
+                                     connection->send_buffer_size, &ret);
       if (ret == GEARMAN_SUCCESS)
       {
-        con->send_buffer_size+= send_size;
+        connection->send_buffer_size+= send_size;
         break;
       }
       else if (ret == GEARMAN_IGNORE_PACKET)
@@ -175,19 +314,19 @@
         return ret;
 
       /* We were asked to flush when the buffer is already flushed! */
-      if (con->send_buffer_size == 0)
+      if (connection->send_buffer_size == 0)
       {
-        gearman_set_error(con->gearman, "gearman_con_send",
+        gearman_universal_set_error(connection->gearman, "gearman_connection_send",
                           "send buffer too small (%u)",
                           GEARMAN_SEND_BUFFER_SIZE);
         return GEARMAN_SEND_BUFFER_TOO_SMALL;
       }
 
       /* Flush buffer now if first part of packet won't fit in. */
-      con->send_state= GEARMAN_CON_SEND_STATE_PRE_FLUSH;
+      connection->send_state= GEARMAN_CON_SEND_UNIVERSAL_PRE_FLUSH;
 
-  case GEARMAN_CON_SEND_STATE_PRE_FLUSH:
-      ret= gearman_con_flush(con);
+    case GEARMAN_CON_SEND_UNIVERSAL_PRE_FLUSH:
+      ret= gearman_connection_flush(connection);
       if (ret != GEARMAN_SUCCESS)
         return ret;
     }
@@ -198,112 +337,112 @@
 
     /* If there is any room in the buffer, copy in data. */
     if (packet->data != NULL &&
-        (GEARMAN_SEND_BUFFER_SIZE - con->send_buffer_size) > 0)
+        (GEARMAN_SEND_BUFFER_SIZE - connection->send_buffer_size) > 0)
     {
-      con->send_data_offset= GEARMAN_SEND_BUFFER_SIZE - con->send_buffer_size;
-      if (con->send_data_offset > packet->data_size)
-        con->send_data_offset= packet->data_size;
+      connection->send_data_offset= GEARMAN_SEND_BUFFER_SIZE - connection->send_buffer_size;
+      if (connection->send_data_offset > packet->data_size)
+        connection->send_data_offset= packet->data_size;
 
-      memcpy(con->send_buffer + con->send_buffer_size, packet->data,
-             con->send_data_offset);
-      con->send_buffer_size+= con->send_data_offset;
+      memcpy(connection->send_buffer + connection->send_buffer_size, packet->data,
+             connection->send_data_offset);
+      connection->send_buffer_size+= connection->send_data_offset;
 
       /* Return if all data fit in the send buffer. */
-      if (con->send_data_offset == packet->data_size)
+      if (connection->send_data_offset == packet->data_size)
       {
-        con->send_data_offset= 0;
+        connection->send_data_offset= 0;
         break;
       }
     }
 
     /* Flush buffer now so we can start writing directly from data buffer. */
-    con->send_state= GEARMAN_CON_SEND_STATE_FORCE_FLUSH;
+    connection->send_state= GEARMAN_CON_SEND_UNIVERSAL_FORCE_FLUSH;
 
-  case GEARMAN_CON_SEND_STATE_FORCE_FLUSH:
-    ret= gearman_con_flush(con);
+  case GEARMAN_CON_SEND_UNIVERSAL_FORCE_FLUSH:
+    ret= gearman_connection_flush(connection);
     if (ret != GEARMAN_SUCCESS)
       return ret;
 
-    con->send_data_size= packet->data_size;
+    connection->send_data_size= packet->data_size;
 
-    /* If this is NULL, then gearman_con_send_data function will be used. */
+    /* If this is NULL, then gearman_connection_send_data function will be used. */
     if (packet->data == NULL)
     {
-      con->send_state= GEARMAN_CON_SEND_STATE_FLUSH_DATA;
+      connection->send_state= GEARMAN_CON_SEND_UNIVERSAL_FLUSH_DATA;
       return GEARMAN_SUCCESS;
     }
 
     /* Copy into the buffer if it fits, otherwise flush from packet buffer. */
-    con->send_buffer_size= packet->data_size - con->send_data_offset;
-    if (con->send_buffer_size < GEARMAN_SEND_BUFFER_SIZE)
+    connection->send_buffer_size= packet->data_size - connection->send_data_offset;
+    if (connection->send_buffer_size < GEARMAN_SEND_BUFFER_SIZE)
     {
-      memcpy(con->send_buffer,
-             ((uint8_t *)(packet->data)) + con->send_data_offset,
-             con->send_buffer_size);
-      con->send_data_size= 0;
-      con->send_data_offset= 0;
+      memcpy(connection->send_buffer,
+             ((uint8_t *)(packet->data)) + connection->send_data_offset,
+             connection->send_buffer_size);
+      connection->send_data_size= 0;
+      connection->send_data_offset= 0;
       break;
     }
 
-    con->send_buffer_ptr= ((uint8_t *)(packet->data)) + con->send_data_offset;
-    con->send_state= GEARMAN_CON_SEND_STATE_FLUSH_DATA;
+    connection->send_buffer_ptr= ((uint8_t *)(packet->data)) + connection->send_data_offset;
+    connection->send_state= GEARMAN_CON_SEND_UNIVERSAL_FLUSH_DATA;
 
-  case GEARMAN_CON_SEND_STATE_FLUSH:
-  case GEARMAN_CON_SEND_STATE_FLUSH_DATA:
-    ret= gearman_con_flush(con);
-    if (ret == GEARMAN_SUCCESS && con->options & GEARMAN_CON_CLOSE_AFTER_FLUSH)
+  case GEARMAN_CON_SEND_UNIVERSAL_FLUSH:
+  case GEARMAN_CON_SEND_UNIVERSAL_FLUSH_DATA:
+    ret= gearman_connection_flush(connection);
+    if (ret == GEARMAN_SUCCESS && connection->options.close_after_flush)
     {
-      gearman_con_close(con);
+      gearman_connection_close(connection);
       ret= GEARMAN_LOST_CONNECTION;
     }
     return ret;
 
   default:
-    gearman_set_error(con->gearman, "gearman_con_send", "unknown state: %u",
-                      con->send_state);
+    gearman_universal_set_error(connection->gearman, "gearman_connection_send", "unknown state: %u",
+                      connection->send_state);
     return GEARMAN_UNKNOWN_STATE;
   }
 
   if (flush)
   {
-    con->send_state= GEARMAN_CON_SEND_STATE_FLUSH;
-    ret= gearman_con_flush(con);
-    if (ret == GEARMAN_SUCCESS && con->options & GEARMAN_CON_CLOSE_AFTER_FLUSH)
+    connection->send_state= GEARMAN_CON_SEND_UNIVERSAL_FLUSH;
+    ret= gearman_connection_flush(connection);
+    if (ret == GEARMAN_SUCCESS && connection->options.close_after_flush)
     {
-      gearman_con_close(con);
+      gearman_connection_close(connection);
       ret= GEARMAN_LOST_CONNECTION;
     }
     return ret;
   }
 
-  con->send_state= GEARMAN_CON_SEND_STATE_NONE;
+  connection->send_state= GEARMAN_CON_SEND_STATE_NONE;
   return GEARMAN_SUCCESS;
 }
 
-size_t gearman_con_send_data(gearman_con_st *con, const void *data,
-                             size_t data_size, gearman_return_t *ret_ptr)
+size_t gearman_connection_send_data(gearman_connection_st *connection, const void *data,
+                                    size_t data_size, gearman_return_t *ret_ptr)
 {
-  if (con->send_state != GEARMAN_CON_SEND_STATE_FLUSH_DATA)
+  if (connection->send_state != GEARMAN_CON_SEND_UNIVERSAL_FLUSH_DATA)
   {
-    gearman_set_error(con->gearman, "gearman_con_send_data", "not flushing");
+    gearman_universal_set_error(connection->gearman, "gearman_connection_send_data", "not flushing");
     return GEARMAN_NOT_FLUSHING;
   }
 
-  if (data_size > (con->send_data_size - con->send_data_offset))
+  if (data_size > (connection->send_data_size - connection->send_data_offset))
   {
-    gearman_set_error(con->gearman, "gearman_con_send_data", "data too large");
+    gearman_universal_set_error(connection->gearman, "gearman_connection_send_data", "data too large");
     return GEARMAN_DATA_TOO_LARGE;
   }
 
-  con->send_buffer_ptr= (uint8_t *)data;
-  con->send_buffer_size= data_size;
-
-  *ret_ptr= gearman_con_flush(con);
-
-  return data_size - con->send_buffer_size;
+  connection->send_buffer_ptr= (uint8_t *)data;
+  connection->send_buffer_size= data_size;
+
+  *ret_ptr= gearman_connection_flush(connection);
+
+  return data_size - connection->send_buffer_size;
 }
 
-gearman_return_t gearman_con_flush(gearman_con_st *con)
+gearman_return_t gearman_connection_flush(gearman_connection_st *connection)
 {
   char port_str[NI_MAXSERV];
   struct addrinfo ai;
@@ -313,71 +452,71 @@
 
   while (1)
   {
-    switch (con->state)
+    switch (connection->state)
     {
-    case GEARMAN_CON_STATE_ADDRINFO:
-      if (con->addrinfo != NULL)
+    case GEARMAN_CON_UNIVERSAL_ADDRINFO:
+      if (connection->addrinfo != NULL)
       {
-        freeaddrinfo(con->addrinfo);
-        con->addrinfo= NULL;
+        freeaddrinfo(connection->addrinfo);
+        connection->addrinfo= NULL;
       }
 
-      snprintf(port_str, NI_MAXSERV, "%u", con->port);
+      snprintf(port_str, NI_MAXSERV, "%u", connection->port);
 
       memset(&ai, 0, sizeof(struct addrinfo));
       ai.ai_socktype= SOCK_STREAM;
       ai.ai_protocol= IPPROTO_TCP;
 
-      ret= getaddrinfo(con->host, port_str, &ai, &(con->addrinfo));
+      ret= getaddrinfo(connection->host, port_str, &ai, &(connection->addrinfo));
       if (ret != 0)
       {
-        gearman_set_error(con->gearman, "gearman_con_flush", "getaddrinfo:%s",
+        gearman_universal_set_error(connection->gearman, "gearman_connection_flush", "getaddrinfo:%s",
                           gai_strerror(ret));
         return GEARMAN_GETADDRINFO;
       }
 
-      con->addrinfo_next= con->addrinfo;
-
-    case GEARMAN_CON_STATE_CONNECT:
-      if (con->fd != -1)
-        gearman_con_close(con);
-
-      if (con->addrinfo_next == NULL)
+      connection->addrinfo_next= connection->addrinfo;
+
+    case GEARMAN_CON_UNIVERSAL_CONNECT:
+      if (connection->fd != -1)
+        gearman_connection_close(connection);
+
+      if (connection->addrinfo_next == NULL)
       {
-        con->state= GEARMAN_CON_STATE_ADDRINFO;
-        gearman_set_error(con->gearman, "gearman_con_flush",
+        connection->state= GEARMAN_CON_UNIVERSAL_ADDRINFO;
+        gearman_universal_set_error(connection->gearman, "gearman_connection_flush",
                           "could not connect");
         return GEARMAN_COULD_NOT_CONNECT;
       }
 
-      con->fd= socket(con->addrinfo_next->ai_family,
-                      con->addrinfo_next->ai_socktype,
-                      con->addrinfo_next->ai_protocol);
-      if (con->fd == -1)
+      connection->fd= socket(connection->addrinfo_next->ai_family,
+                      connection->addrinfo_next->ai_socktype,
+                      connection->addrinfo_next->ai_protocol);
+      if (connection->fd == -1)
       {
-        con->state= GEARMAN_CON_STATE_ADDRINFO;
-        gearman_set_error(con->gearman, "gearman_con_flush", "socket:%d",
+        connection->state= GEARMAN_CON_UNIVERSAL_ADDRINFO;
+        gearman_universal_set_error(connection->gearman, "gearman_connection_flush", "socket:%d",
                           errno);
-        con->gearman->last_errno= errno;
+        connection->gearman->last_errno= errno;
         return GEARMAN_ERRNO;
       }
 
-      gret= _con_setsockopt(con);
+      gret= _con_setsockopt(connection);
       if (gret != GEARMAN_SUCCESS)
       {
-        con->gearman->last_errno= errno;
-        gearman_con_close(con);
+        connection->gearman->last_errno= errno;
+        gearman_connection_close(connection);
         return gret;
       }
 
       while (1)
       {
-        ret= connect(con->fd, con->addrinfo_next->ai_addr,
-                     con->addrinfo_next->ai_addrlen);
+        ret= connect(connection->fd, connection->addrinfo_next->ai_addr,
+                     connection->addrinfo_next->ai_addrlen);
         if (ret == 0)
         {
-          con->state= GEARMAN_CON_STATE_CONNECTED;
-          con->addrinfo_next= NULL;
+          connection->state= GEARMAN_CON_UNIVERSAL_CONNECTED;
+          connection->addrinfo_next= NULL;
           break;
         }
 
@@ -386,86 +525,86 @@
 
         if (errno == EINPROGRESS)
         {
-          con->state= GEARMAN_CON_STATE_CONNECTING;
+          connection->state= GEARMAN_CON_UNIVERSAL_CONNECTING;
           break;
         }
 
         if (errno == ECONNREFUSED || errno == ENETUNREACH || errno == ETIMEDOUT)
         {
-          con->state= GEARMAN_CON_STATE_CONNECT;
-          con->addrinfo_next= con->addrinfo_next->ai_next;
+          connection->state= GEARMAN_CON_UNIVERSAL_CONNECT;
+          connection->addrinfo_next= connection->addrinfo_next->ai_next;
           break;
         }
 
-        gearman_set_error(con->gearman, "gearman_con_flush", "connect:%d",
+        gearman_universal_set_error(connection->gearman, "gearman_connection_flush", "connect:%d",
                           errno);
-        con->gearman->last_errno= errno;
-        gearman_con_close(con);
+        connection->gearman->last_errno= errno;
+        gearman_connection_close(connection);
         return GEARMAN_ERRNO;
       }
 
-      if (con->state != GEARMAN_CON_STATE_CONNECTING)
+      if (connection->state != GEARMAN_CON_UNIVERSAL_CONNECTING)
         break;
 
-    case GEARMAN_CON_STATE_CONNECTING:
+    case GEARMAN_CON_UNIVERSAL_CONNECTING:
       while (1)
       {
-        if (con->revents & POLLOUT)
+        if (connection->revents & POLLOUT)
         {
-          con->state= GEARMAN_CON_STATE_CONNECTED;
+          connection->state= GEARMAN_CON_UNIVERSAL_CONNECTED;
           break;
         }
-        else if (con->revents & (POLLERR | POLLHUP | POLLNVAL))
+        else if (connection->revents & (POLLERR | POLLHUP | POLLNVAL))
         {
-          con->state= GEARMAN_CON_STATE_CONNECT;
-          con->addrinfo_next= con->addrinfo_next->ai_next;
+          connection->state= GEARMAN_CON_UNIVERSAL_CONNECT;
+          connection->addrinfo_next= connection->addrinfo_next->ai_next;
           break;
         }
 
-        gret= gearman_con_set_events(con, POLLOUT);
+        gret= gearman_connection_set_events(connection, POLLOUT);
         if (gret != GEARMAN_SUCCESS)
           return gret;
 
-        if (con->gearman->options & GEARMAN_NON_BLOCKING)
+        if (gearman_universal_is_non_blocking(connection->gearman))
         {
-          con->state= GEARMAN_CON_STATE_CONNECTING;
+          connection->state= GEARMAN_CON_UNIVERSAL_CONNECTING;
           return GEARMAN_IO_WAIT;
         }
 
-        gret= gearman_wait(con->gearman);
+        gret= gearman_wait(connection->gearman);
         if (gret != GEARMAN_SUCCESS)
           return gret;
       }
 
-      if (con->state != GEARMAN_CON_STATE_CONNECTED)
+      if (connection->state != GEARMAN_CON_UNIVERSAL_CONNECTED)
         break;
 
-    case GEARMAN_CON_STATE_CONNECTED:
-      while (con->send_buffer_size != 0)
+    case GEARMAN_CON_UNIVERSAL_CONNECTED:
+      while (connection->send_buffer_size != 0)
       {
-        write_size= write(con->fd, con->send_buffer_ptr, con->send_buffer_size);
+        write_size= write(connection->fd, connection->send_buffer_ptr, connection->send_buffer_size);
         if (write_size == 0)
         {
-          if (!(con->options & GEARMAN_CON_IGNORE_LOST_CONNECTION))
+          if (! (connection->options.ignore_lost_connection))
           {
-            gearman_set_error(con->gearman, "gearman_con_flush",
+            gearman_universal_set_error(connection->gearman, "gearman_connection_flush",
                               "lost connection to server (EOF)");
           }
-          gearman_con_close(con);
+          gearman_connection_close(connection);
           return GEARMAN_LOST_CONNECTION;
         }
         else if (write_size == -1)
         {
           if (errno == EAGAIN)
           {
-            gret= gearman_con_set_events(con, POLLOUT);
+            gret= gearman_connection_set_events(connection, POLLOUT);
             if (gret != GEARMAN_SUCCESS)
               return gret;
 
-            if (con->gearman->options & GEARMAN_NON_BLOCKING)
+            if (gearman_universal_is_non_blocking(connection->gearman))
               return GEARMAN_IO_WAIT;
 
-            gret= gearman_wait(con->gearman);
+            gret= gearman_wait(connection->gearman);
             if (gret != GEARMAN_SUCCESS)
               return gret;
 
@@ -475,124 +614,124 @@
             continue;
           else if (errno == EPIPE || errno == ECONNRESET)
           {
-            if (!(con->options & GEARMAN_CON_IGNORE_LOST_CONNECTION))
+            if (! (connection->options.ignore_lost_connection))
             {
-              gearman_set_error(con->gearman, "gearman_con_flush",
+              gearman_universal_set_error(connection->gearman, "gearman_connection_flush",
                                 "lost connection to server (%d)", errno);
             }
-            gearman_con_close(con);
+            gearman_connection_close(connection);
             return GEARMAN_LOST_CONNECTION;
           }
 
-          gearman_set_error(con->gearman, "gearman_con_flush", "write:%d",
+          gearman_universal_set_error(connection->gearman, "gearman_connection_flush", "write:%d",
                             errno);
-          con->gearman->last_errno= errno;
-          gearman_con_close(con);
+          connection->gearman->last_errno= errno;
+          gearman_connection_close(connection);
           return GEARMAN_ERRNO;
         }
 
-        con->send_buffer_size-= (size_t)write_size;
-        if (con->send_state == GEARMAN_CON_SEND_STATE_FLUSH_DATA)
+        connection->send_buffer_size-= (size_t)write_size;
+        if (connection->send_state == GEARMAN_CON_SEND_UNIVERSAL_FLUSH_DATA)
         {
-          con->send_data_offset+= (size_t)write_size;
-          if (con->send_data_offset == con->send_data_size)
+          connection->send_data_offset+= (size_t)write_size;
+          if (connection->send_data_offset == connection->send_data_size)
           {
-            con->send_data_size= 0;
-            con->send_data_offset= 0;
+            connection->send_data_size= 0;
+            connection->send_data_offset= 0;
             break;
           }
 
-          if (con->send_buffer_size == 0)
+          if (connection->send_buffer_size == 0)
             return GEARMAN_SUCCESS;
         }
-        else if (con->send_buffer_size == 0)
+        else if (connection->send_buffer_size == 0)
           break;
 
-        con->send_buffer_ptr+= write_size;
+        connection->send_buffer_ptr+= write_size;
       }
 
-      con->send_state= GEARMAN_CON_SEND_STATE_NONE;
-      con->send_buffer_ptr= con->send_buffer;
+      connection->send_state= GEARMAN_CON_SEND_STATE_NONE;
+      connection->send_buffer_ptr= connection->send_buffer;
       return GEARMAN_SUCCESS;
 
     default:
-      gearman_set_error(con->gearman, "gearman_con_flush", "unknown state: %u",
-                        con->state);
+      gearman_universal_set_error(connection->gearman, "gearman_connection_flush", "unknown state: %u",
+                        connection->state);
 
       return GEARMAN_UNKNOWN_STATE;
     }
   }
 }
 
-gearman_packet_st *gearman_con_recv(gearman_con_st *con,
-                                    gearman_packet_st *packet,
-                                    gearman_return_t *ret_ptr, bool recv_data)
+gearman_packet_st *gearman_connection_recv(gearman_connection_st *connection,
+                                           gearman_packet_st *packet,
+                                           gearman_return_t *ret_ptr, bool recv_data)
 {
   size_t recv_size;
 
-  switch (con->recv_state)
+  switch (connection->recv_state)
   {
-  case GEARMAN_CON_RECV_STATE_NONE:
-    if (con->state != GEARMAN_CON_STATE_CONNECTED)
+  case GEARMAN_CON_RECV_UNIVERSAL_NONE:
+    if (connection->state != GEARMAN_CON_UNIVERSAL_CONNECTED)
     {
-      gearman_set_error(con->gearman, "gearman_con_recv", "not connected");
+      gearman_universal_set_error(connection->gearman, "gearman_connection_recv", "not connected");
       *ret_ptr= GEARMAN_NOT_CONNECTED;
       return NULL;
     }
 
-    con->recv_packet= gearman_add_packet(con->gearman, packet);
-    if (con->recv_packet == NULL)
+    connection->recv_packet= gearman_packet_create(connection->gearman, packet);
+    if (connection->recv_packet == NULL)
     {
       *ret_ptr= GEARMAN_MEMORY_ALLOCATION_FAILURE;
       return NULL;
     }
 
-    con->recv_state= GEARMAN_CON_RECV_STATE_READ;
+    connection->recv_state= GEARMAN_CON_RECV_UNIVERSAL_READ;
 
-  case GEARMAN_CON_RECV_STATE_READ:
+  case GEARMAN_CON_RECV_UNIVERSAL_READ:
     while (1)
     {
-      if (con->recv_buffer_size > 0)
+      if (connection->recv_buffer_size > 0)
       {
-        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;
+        recv_size= connection->packet_unpack_fn(connection->recv_packet, connection,
+                                         connection->recv_buffer_ptr,
+                                         connection->recv_buffer_size, ret_ptr);
+        connection->recv_buffer_ptr+= recv_size;
+        connection->recv_buffer_size-= recv_size;
         if (*ret_ptr == GEARMAN_SUCCESS)
           break;
         else if (*ret_ptr != GEARMAN_IO_WAIT)
         {
-          gearman_con_close(con);
+          gearman_connection_close(connection);
           return NULL;
         }
       }
 
       /* Shift buffer contents if needed. */
-      if (con->recv_buffer_size > 0)
-        memmove(con->recv_buffer, con->recv_buffer_ptr, con->recv_buffer_size);
-      con->recv_buffer_ptr= con->recv_buffer;
+      if (connection->recv_buffer_size > 0)
+        memmove(connection->recv_buffer, connection->recv_buffer_ptr, connection->recv_buffer_size);
+      connection->recv_buffer_ptr= connection->recv_buffer;
 
-      recv_size= gearman_con_read(con, con->recv_buffer + con->recv_buffer_size,
-                               GEARMAN_RECV_BUFFER_SIZE - con->recv_buffer_size,
-                               ret_ptr);
+      recv_size= gearman_connection_read(connection, connection->recv_buffer + connection->recv_buffer_size,
+                                         GEARMAN_RECV_BUFFER_SIZE - connection->recv_buffer_size,
+                                         ret_ptr);
       if (*ret_ptr != GEARMAN_SUCCESS)
         return NULL;
 
-      con->recv_buffer_size+= recv_size;
+      connection->recv_buffer_size+= recv_size;
     }
 
     if (packet->data_size == 0)
     {
-      con->recv_state= GEARMAN_CON_RECV_STATE_NONE;
+      connection->recv_state= GEARMAN_CON_RECV_UNIVERSAL_NONE;
       break;
     }
 
-    con->recv_data_size= packet->data_size;
+    connection->recv_data_size= packet->data_size;
 
     if (!recv_data)
     {
-      con->recv_state= GEARMAN_CON_RECV_STATE_READ_DATA;
+      connection->recv_state= GEARMAN_CON_RECV_STATE_READ_DATA;
       break;
     }
 
@@ -601,110 +740,110 @@
     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)
     {
       *ret_ptr= GEARMAN_MEMORY_ALLOCATION_FAILURE;
-      gearman_con_close(con);
+      gearman_connection_close(connection);
       return NULL;
     }
 
-    packet->options|= GEARMAN_PACKET_FREE_DATA;
-    con->recv_state= GEARMAN_CON_RECV_STATE_READ_DATA;
+    packet->options.free_data= true;
+    connection->recv_state= GEARMAN_CON_RECV_STATE_READ_DATA;
 
   case GEARMAN_CON_RECV_STATE_READ_DATA:
-    while (con->recv_data_size != 0)
+    while (connection->recv_data_size != 0)
     {
-      (void)gearman_con_recv_data(con,
-                                  ((uint8_t *)(packet->data)) +
-                                  con->recv_data_offset,
-                                  packet->data_size -
-                                  con->recv_data_offset, ret_ptr);
+      (void)gearman_connection_recv_data(connection,
+                                         ((uint8_t *)(packet->data)) +
+                                         connection->recv_data_offset,
+                                         packet->data_size -
+                                         connection->recv_data_offset, ret_ptr);
       if (*ret_ptr != GEARMAN_SUCCESS)
         return NULL;
     }
 
-    con->recv_state= GEARMAN_CON_RECV_STATE_NONE;
+    connection->recv_state= GEARMAN_CON_RECV_UNIVERSAL_NONE;
     break;
 
   default:
-    gearman_set_error(con->gearman, "gearman_con_recv", "unknown state: %u",
-                      con->recv_state);
+    gearman_universal_set_error(connection->gearman, "gearman_connection_recv", "unknown state: %u",
+                      connection->recv_state);
     *ret_ptr= GEARMAN_UNKNOWN_STATE;
     return NULL;
   }
 
-  packet= con->recv_packet;
-  con->recv_packet= NULL;
+  packet= connection->recv_packet;
+  connection->recv_packet= NULL;
 
   return packet;
 }
 
-size_t gearman_con_recv_data(gearman_con_st *con, void *data, size_t data_size,
-                             gearman_return_t *ret_ptr)
+size_t gearman_connection_recv_data(gearman_connection_st *connection, void *data, size_t data_size,
+                                    gearman_return_t *ret_ptr)
 {
   size_t recv_size= 0;
 
-  if (con->recv_data_size == 0)
+  if (connection->recv_data_size == 0)
   {
     *ret_ptr= GEARMAN_SUCCESS;
     return 0;
   }
 
-  if ((con->recv_data_size - con->recv_data_offset) < data_size)
-    data_size= con->recv_data_size - con->recv_data_offset;
+  if ((connection->recv_data_size - connection->recv_data_offset) < data_size)
+    data_size= connection->recv_data_size - connection->recv_data_offset;
 
-  if (con->recv_buffer_size > 0)
+  if (connection->recv_buffer_size > 0)
   {
-    if (con->recv_buffer_size < data_size)
-      recv_size= con->recv_buffer_size;
+    if (connection->recv_buffer_size < data_size)
+      recv_size= connection->recv_buffer_size;
     else
       recv_size= data_size;
 
-    memcpy(data, con->recv_buffer_ptr, recv_size);
-    con->recv_buffer_ptr+= recv_size;
-    con->recv_buffer_size-= recv_size;
+    memcpy(data, connection->recv_buffer_ptr, recv_size);
+    connection->recv_buffer_ptr+= recv_size;
+    connection->recv_buffer_size-= recv_size;
   }
 
   if (data_size != recv_size)
   {
-    recv_size+= gearman_con_read(con, ((uint8_t *)data) + recv_size,
-                                 data_size - recv_size, ret_ptr);
-    con->recv_data_offset+= recv_size;
+    recv_size+= gearman_connection_read(connection, ((uint8_t *)data) + recv_size,
+                                        data_size - recv_size, ret_ptr);
+    connection->recv_data_offset+= recv_size;
   }
   else
   {
-    con->recv_data_offset+= recv_size;
+    connection->recv_data_offset+= recv_size;
     *ret_ptr= GEARMAN_SUCCESS;
   }
 
-  if (con->recv_data_size == con->recv_data_offset)
+  if (connection->recv_data_size == connection->recv_data_offset)
   {
-    con->recv_data_size= 0;
-    con->recv_data_offset= 0;
-    con->recv_state= GEARMAN_CON_RECV_STATE_NONE;
+    connection->recv_data_size= 0;
+    connection->recv_data_offset= 0;
+    connection->recv_state= GEARMAN_CON_RECV_UNIVERSAL_NONE;
   }
 
   return recv_size;
 }
 
-size_t gearman_con_read(gearman_con_st *con, void *data, size_t data_size,
-                        gearman_return_t *ret_ptr)
+size_t gearman_connection_read(gearman_connection_st *connection, void *data, size_t data_size,
+                               gearman_return_t *ret_ptr)
 {
   ssize_t read_size;
 
   while (1)
   {
-    read_size= read(con->fd, data, data_size);
+    read_size= read(connection->fd, data, data_size);
     if (read_size == 0)
     {
-      if (!(con->options & GEARMAN_CON_IGNORE_LOST_CONNECTION))
+      if (! (connection->options.ignore_lost_connection))
       {
-        gearman_set_error(con->gearman, "gearman_con_read",
+        gearman_universal_set_error(connection->gearman, "gearman_connection_read",
                           "lost connection to server (EOF)");
       }
-      gearman_con_close(con);
+      gearman_connection_close(connection);
       *ret_ptr= GEARMAN_LOST_CONNECTION;
       return 0;
     }
@@ -712,17 +851,17 @@
     {
       if (errno == EAGAIN)
       {
-        *ret_ptr= gearman_con_set_events(con, POLLIN);
+        *ret_ptr= gearman_connection_set_events(connection, POLLIN);
         if (*ret_ptr != GEARMAN_SUCCESS)
           return 0;
 
-        if (con->gearman->options & GEARMAN_NON_BLOCKING)
+        if (gearman_universal_is_non_blocking(connection->gearman))
         {
           *ret_ptr= GEARMAN_IO_WAIT;
           return 0;
         }
 
-        *ret_ptr= gearman_wait(con->gearman);
+        *ret_ptr= gearman_wait(connection->gearman);
         if (*ret_ptr != GEARMAN_SUCCESS)
           return 0;
 
@@ -732,21 +871,21 @@
         continue;
       else if (errno == EPIPE || errno == ECONNRESET)
       {
-        if (!(con->options & GEARMAN_CON_IGNORE_LOST_CONNECTION))
+        if (! (connection->options.ignore_lost_connection))
         {
-          gearman_set_error(con->gearman, "gearman_con_read",
+          gearman_universal_set_error(connection->gearman, "gearman_connection_read",
                             "lost connection to server (%d)", errno);
         }
         *ret_ptr= GEARMAN_LOST_CONNECTION;
       }
       else
       {
-        gearman_set_error(con->gearman, "gearman_con_read", "read:%d", errno);
-        con->gearman->last_errno= errno;
+        gearman_universal_set_error(connection->gearman, "gearman_connection_read", "read:%d", errno);
+        connection->gearman->last_errno= errno;
         *ret_ptr= GEARMAN_ERRNO;
       }
 
-      gearman_con_close(con);
+      gearman_connection_close(connection);
       return 0;
     }
 
@@ -757,22 +896,22 @@
   return (size_t)read_size;
 }
 
-gearman_return_t gearman_con_set_events(gearman_con_st *con, short events)
+gearman_return_t gearman_connection_set_events(gearman_connection_st *connection, short events)
 {
   gearman_return_t ret;
 
-  if ((con->events | events) == con->events)
+  if ((connection->events | events) == connection->events)
     return GEARMAN_SUCCESS;
 
-  con->events|= events;
+  connection->events|= events;
 
-  if (con->gearman->event_watch_fn != NULL)
+  if (connection->gearman->event_watch_fn != NULL)
   {
-    ret= con->gearman->event_watch_fn(con, con->events,
-                                     (void *)con->gearman->event_watch_context);
+    ret= connection->gearman->event_watch_fn(connection, connection->events,
+                                      (void *)connection->gearman->event_watch_context);
     if (ret != GEARMAN_SUCCESS)
     {
-      gearman_con_close(con);
+      gearman_connection_close(connection);
       return ret;
     }
   }
@@ -780,145 +919,145 @@
   return GEARMAN_SUCCESS;
 }
 
-gearman_return_t gearman_con_set_revents(gearman_con_st *con, short revents)
+gearman_return_t gearman_connection_set_revents(gearman_connection_st *connection, short revents)
 {
   gearman_return_t ret;
 
   if (revents != 0)
-    con->options|= GEARMAN_CON_READY;
+    connection->options.ready= true;
 
-  con->revents= revents;
+  connection->revents= revents;
 
   /* Remove external POLLOUT watch if we didn't ask for it. Otherwise we spin
-     forever until another POLLIN state change. This is much more efficient
-     than removing POLLOUT on every state change since some external polling
-     mechanisms need to use a system call to change flags (like Linux epoll). */
-  if (revents & POLLOUT && !(con->events & POLLOUT) &&
-      con->gearman->event_watch_fn != NULL)
+    forever until another POLLIN state change. This is much more efficient
+    than removing POLLOUT on every state change since some external polling
+    mechanisms need to use a system call to change flags (like Linux epoll). */
+  if (revents & POLLOUT && !(connection->events & POLLOUT) &&
+      connection->gearman->event_watch_fn != NULL)
   {
-    ret= con->gearman->event_watch_fn(con, con->events,
-                                     (void *)con->gearman->event_watch_context);
+    ret= connection->gearman->event_watch_fn(connection, connection->events,
+                                      (void *)connection->gearman->event_watch_context);
     if (ret != GEARMAN_SUCCESS)
     {
-      gearman_con_close(con);
+      gearman_connection_close(connection);
       return ret;
     }
   }
 
-  con->events&= (short)~revents;
+  connection->events&= (short)~revents;
 
   return GEARMAN_SUCCESS;
 }
 
-void *gearman_con_protocol_context(const gearman_con_st *con)
-{
-  return (void *)con->protocol_context;
-}
-
-void gearman_con_set_protocol_context(gearman_con_st *con, const void *context)
-{
-  con->protocol_context= context;
-}
-
-void gearman_con_set_protocol_context_free_fn(gearman_con_st *con,
-                                gearman_con_protocol_context_free_fn *function)
-{
-  con->protocol_context_free_fn= function;
-}
-
-void gearman_con_set_packet_pack_fn(gearman_con_st *con,
-                                    gearman_packet_pack_fn *function)
-{
-  con->packet_pack_fn= function;
-}
-
-void gearman_con_set_packet_unpack_fn(gearman_con_st *con,
-                                      gearman_packet_unpack_fn *function)
-{
-  con->packet_unpack_fn= function;
+void *gearman_connection_protocol_context(const gearman_connection_st *connection)
+{
+  return (void *)connection->protocol_context;
+}
+
+void gearman_connection_set_protocol_context(gearman_connection_st *connection, const void *context)
+{
+  connection->protocol_context= context;
+}
+
+void gearman_connection_set_protocol_context_free_fn(gearman_connection_st *connection,
+                                                     gearman_connection_protocol_context_free_fn *function)
+{
+  connection->protocol_context_free_fn= function;
+}
+
+void gearman_connection_set_packet_pack_fn(gearman_connection_st *connection,
+                                           gearman_packet_pack_fn *function)
+{
+  connection->packet_pack_fn= function;
+}
+
+void gearman_connection_set_packet_unpack_fn(gearman_connection_st *connection,
+                                             gearman_packet_unpack_fn *function)
+{
+  connection->packet_unpack_fn= function;
 }
 
 /*
  * Static Definitions
  */
 
-static gearman_return_t _con_setsockopt(gearman_con_st *con)
+static gearman_return_t _con_setsockopt(gearman_connection_st *connection)
 {
   int ret;
   struct linger linger;
   struct timeval waittime;
 
   ret= 1;
-  ret= setsockopt(con->fd, IPPROTO_TCP, TCP_NODELAY, &ret,
+  ret= setsockopt(connection->fd, IPPROTO_TCP, TCP_NODELAY, &ret,
                   (socklen_t)sizeof(int));
   if (ret == -1 && errno != EOPNOTSUPP)
   {
-    gearman_set_error(con->gearman, "_con_setsockopt",
+    gearman_universal_set_error(connection->gearman, "_con_setsockopt",
                       "setsockopt:TCP_NODELAY:%d", errno);
     return GEARMAN_ERRNO;
   }
 
   linger.l_onoff= 1;
   linger.l_linger= GEARMAN_DEFAULT_SOCKET_TIMEOUT;
-  ret= setsockopt(con->fd, SOL_SOCKET, SO_LINGER, &linger,
+  ret= setsockopt(connection->fd, SOL_SOCKET, SO_LINGER, &linger,
                   (socklen_t)sizeof(struct linger));
   if (ret == -1)
   {
-    gearman_set_error(con->gearman, "_con_setsockopt",
+    gearman_universal_set_error(connection->gearman, "_con_setsockopt",
                       "setsockopt:SO_LINGER:%d", errno);
     return GEARMAN_ERRNO;
   }
 
   waittime.tv_sec= GEARMAN_DEFAULT_SOCKET_TIMEOUT;
   waittime.tv_usec= 0;
-  ret= setsockopt(con->fd, SOL_SOCKET, SO_SNDTIMEO, &waittime,
+  ret= setsockopt(connection->fd, SOL_SOCKET, SO_SNDTIMEO, &waittime,
                   (socklen_t)sizeof(struct timeval));
   if (ret == -1 && errno != ENOPROTOOPT)
   {
-    gearman_set_error(con->gearman, "_con_setsockopt",
+    gearman_universal_set_error(connection->gearman, "_con_setsockopt",
                       "setsockopt:SO_SNDTIMEO:%d", errno);
     return GEARMAN_ERRNO;
   }
 
-  ret= setsockopt(con->fd, SOL_SOCKET, SO_RCVTIMEO, &waittime,
+  ret= setsockopt(connection->fd, SOL_SOCKET, SO_RCVTIMEO, &waittime,
                   (socklen_t)sizeof(struct timeval));
   if (ret == -1 && errno != ENOPROTOOPT)
   {
-    gearman_set_error(con->gearman, "_con_setsockopt",
+    gearman_universal_set_error(connection->gearman, "_con_setsockopt",
                       "setsockopt:SO_RCVTIMEO:%d", errno);
     return GEARMAN_ERRNO;
   }
 
   ret= GEARMAN_DEFAULT_SOCKET_SEND_SIZE;
-  ret= setsockopt(con->fd, SOL_SOCKET, SO_SNDBUF, &ret, (socklen_t)sizeof(int));
+  ret= setsockopt(connection->fd, SOL_SOCKET, SO_SNDBUF, &ret, (socklen_t)sizeof(int));
   if (ret == -1)
   {
-    gearman_set_error(con->gearman, "_con_setsockopt",
+    gearman_universal_set_error(connection->gearman, "_con_setsockopt",
                       "setsockopt:SO_SNDBUF:%d", errno);
     return GEARMAN_ERRNO;
   }
 
   ret= GEARMAN_DEFAULT_SOCKET_RECV_SIZE;
-  ret= setsockopt(con->fd, SOL_SOCKET, SO_RCVBUF, &ret, (socklen_t)sizeof(int));
+  ret= setsockopt(connection->fd, SOL_SOCKET, SO_RCVBUF, &ret, (socklen_t)sizeof(int));
   if (ret == -1)
   {
-    gearman_set_error(con->gearman, "_con_setsockopt",
+    gearman_universal_set_error(connection->gearman, "_con_setsockopt",
                       "setsockopt:SO_RCVBUF:%d", errno);
     return GEARMAN_ERRNO;
   }
 
-  ret= fcntl(con->fd, F_GETFL, 0);
+  ret= fcntl(connection->fd, F_GETFL, 0);
   if (ret == -1)
   {
-    gearman_set_error(con->gearman, "_con_setsockopt", "fcntl:F_GETFL:%d",
+    gearman_universal_set_error(connection->gearman, "_con_setsockopt", "fcntl:F_GETFL:%d",
                       errno);
     return GEARMAN_ERRNO;
   }
 
-  ret= fcntl(con->fd, F_SETFL, ret | O_NONBLOCK);
+  ret= fcntl(connection->fd, F_SETFL, ret | O_NONBLOCK);
   if (ret == -1)
   {
-    gearman_set_error(con->gearman, "_con_setsockopt", "fcntl:F_SETFL:%d",
+    gearman_universal_set_error(connection->gearman, "_con_setsockopt", "fcntl:F_SETFL:%d",
                       errno);
     return GEARMAN_ERRNO;
   }

=== renamed file 'libgearman/conn.h' => 'libgearman/connection.h'
--- libgearman/conn.h	2009-10-29 00:11:45 +0000
+++ libgearman/connection.h	2009-12-30 19:24:13 +0000
@@ -11,8 +11,8 @@
  * @brief Connection Declarations
  */
 
-#ifndef __GEARMAN_CON_H__
-#define __GEARMAN_CON_H__
+#ifndef __GEARMAN_CONNECTION_H__
+#define __GEARMAN_CONNECTION_H__
 
 #ifdef __cplusplus
 extern "C" {
@@ -20,7 +20,7 @@
 
 /**
  * @addtogroup gearman_con Connection Declarations
- * @ingroup gearman
+ * @ingroup gearman_universal
  *
  * This is a low level interface for gearman connections. This is used
  * internally by both client and worker interfaces, so you probably want to
@@ -31,172 +31,263 @@
  */
 
 /**
+ * @ingroup gearman_connection
+ */
+struct gearman_connection_st
+{
+  struct {
+    bool allocated:1;
+    bool ready:1;
+    bool packet_in_use:1;
+    bool external_fd:1;
+    bool ignore_lost_connection:1;
+    bool close_after_flush:1;
+  } options;
+  enum {
+    GEARMAN_CON_UNIVERSAL_ADDRINFO,
+    GEARMAN_CON_UNIVERSAL_CONNECT,
+    GEARMAN_CON_UNIVERSAL_CONNECTING,
+    GEARMAN_CON_UNIVERSAL_CONNECTED
+  } state;
+  enum {
+    GEARMAN_CON_SEND_STATE_NONE,
+    GEARMAN_CON_SEND_UNIVERSAL_PRE_FLUSH,
+    GEARMAN_CON_SEND_UNIVERSAL_FORCE_FLUSH,
+    GEARMAN_CON_SEND_UNIVERSAL_FLUSH,
+    GEARMAN_CON_SEND_UNIVERSAL_FLUSH_DATA
+  } send_state;
+  enum {
+    GEARMAN_CON_RECV_UNIVERSAL_NONE,
+    GEARMAN_CON_RECV_UNIVERSAL_READ,
+    GEARMAN_CON_RECV_STATE_READ_DATA
+  } recv_state;
+  in_port_t port;
+  short events;
+  short revents;
+  int fd;
+  uint32_t created_id;
+  uint32_t created_id_next;
+  size_t send_buffer_size;
+  size_t send_data_size;
+  size_t send_data_offset;
+  size_t recv_buffer_size;
+  size_t recv_data_size;
+  size_t recv_data_offset;
+  gearman_universal_st *gearman;
+  gearman_connection_st *next;
+  gearman_connection_st *prev;
+  const void *context;
+  struct addrinfo *addrinfo;
+  struct addrinfo *addrinfo_next;
+  uint8_t *send_buffer_ptr;
+  gearman_packet_st *recv_packet;
+  uint8_t *recv_buffer_ptr;
+  const void *protocol_context;
+  gearman_connection_protocol_context_free_fn *protocol_context_free_fn;
+  gearman_packet_pack_fn *packet_pack_fn;
+  gearman_packet_unpack_fn *packet_unpack_fn;
+  gearman_packet_st packet;
+  char host[NI_MAXHOST];
+  uint8_t send_buffer[GEARMAN_SEND_BUFFER_SIZE];
+  uint8_t recv_buffer[GEARMAN_RECV_BUFFER_SIZE];
+};
+
+#ifdef GEARMAN_CORE
+
+/**
+ * Initialize a connection structure. Always check the return value even if
+ * passing in a pre-allocated structure. Some other initialization may have
+ * failed.
+ *
+ * @param[in] gearman Structure previously initialized with gearman_create() or
+ *  gearman_clone().
+ * @param[in] connection Caller allocated structure, or NULL to allocate one.
+ * @return On success, a pointer to the (possibly allocated) structure. On
+ *  failure this will be NULL.
+ */
+GEARMAN_INTERNAL_API
+gearman_connection_st *gearman_connection_create(gearman_universal_st *gearman,
+                                                 gearman_connection_st *connection,
+                                                 gearman_connection_options_t *options);
+
+/**
+ * Create a connection structure with the given host and port.
+ *
+ * @param[in] gearman Structure previously initialized with gearman_create() or
+ *  gearman_clone().
+ * @param[in] connection Caller allocated structure, or NULL to allocate one.
+ * @param[in] host Host or IP address to connect to.
+ * @param[in] port Port to connect to.
+ * @return On success, a pointer to the (possibly allocated) structure. On
+ *  failure this will be NULL.
+ */
+GEARMAN_INTERNAL_API
+gearman_connection_st *gearman_connection_create_args(gearman_universal_st *gearman,
+                                                      gearman_connection_st *connection,
+                                                      const char *host, in_port_t port);
+
+/**
+ * Clone a connection structure.
+ *
+ * @param[in] gearman Structure previously initialized with gearman_create() or
+ *  gearman_clone().
+ * @param[in] connection Caller allocated structure, or NULL to allocate one.
+ * @param[in] from Structure to use as a source to clone from.
+ * @return On success, a pointer to the (possibly allocated) structure. On
+ *  failure this will be NULL.
+ */
+GEARMAN_INTERNAL_API
+gearman_connection_st *gearman_connection_clone(gearman_universal_st *gearman, gearman_connection_st *src,
+                                                const gearman_connection_st *from);
+
+/**
+ * Free a connection structure.
+ *
+ * @param[in] connection Structure previously initialized with gearman_connection_create(),
+ *  gearman_connection_create_args(), or gearman_connection_clone().
+ */
+GEARMAN_INTERNAL_API
+void gearman_connection_free(gearman_connection_st *connection);
+
+
+GEARMAN_INTERNAL_API
+gearman_return_t gearman_connection_set_option(gearman_connection_st *connection,
+                                               gearman_connection_options_t options,
+                                               bool value);
+
+
+/**
  * Set host for a connection.
  */
-GEARMAN_API
-void gearman_con_set_host(gearman_con_st *con, const char *host);
-
-/**
- * Set port for a connection.
- */
-GEARMAN_API
-void gearman_con_set_port(gearman_con_st *con, in_port_t port);
-
-/**
- * Get options for a connection.
- */
-GEARMAN_API
-gearman_con_options_t gearman_con_options(const gearman_con_st *con);
-
-/**
- * Set options for a connection.
- */
-GEARMAN_API
-void gearman_con_set_options(gearman_con_st *con,
-                             gearman_con_options_t options);
-
-/**
- * Add options for a connection.
- */
-GEARMAN_API
-void gearman_con_add_options(gearman_con_st *con,
-                             gearman_con_options_t options);
-
-/**
- * Remove options for a connection.
- */
-GEARMAN_API
-void gearman_con_remove_options(gearman_con_st *con,
-                                gearman_con_options_t options);
+GEARMAN_INTERNAL_API
+void gearman_connection_set_host(gearman_connection_st *connection,
+                                 const char *host,
+                                 in_port_t port);
 
 /**
  * Set connection to an already open file descriptor.
  */
-GEARMAN_API
-gearman_return_t gearman_con_set_fd(gearman_con_st *con, int fd);
+GEARMAN_INTERNAL_API
+gearman_return_t gearman_connection_set_fd(gearman_connection_st *connection, int fd);
 
 /**
  * Get application context pointer.
  */
-GEARMAN_API
-void *gearman_con_context(const gearman_con_st *con);
+GEARMAN_INTERNAL_API
+void *gearman_connection_context(const gearman_connection_st *connection);
 
 /**
  * Set application context pointer.
  */
-GEARMAN_API
-void gearman_con_set_context(gearman_con_st *con, const void *context);
+GEARMAN_INTERNAL_API
+void gearman_connection_set_context(gearman_connection_st *connection, const void *context);
 
 /**
  * Connect to server.
  */
-GEARMAN_API
-gearman_return_t gearman_con_connect(gearman_con_st *con);
+GEARMAN_INTERNAL_API
+gearman_return_t gearman_connection_connect(gearman_connection_st *connection);
 
 /**
  * Close a connection.
  */
-GEARMAN_API
-void gearman_con_close(gearman_con_st *con);
-
-/**
- * Clear address info, freeing structs if needed.
- */
-GEARMAN_API
-void gearman_con_reset_addrinfo(gearman_con_st *con);
+GEARMAN_INTERNAL_API
+void gearman_connection_close(gearman_connection_st *connection);
 
 /**
  * Send packet to a connection.
  */
-GEARMAN_API
-gearman_return_t gearman_con_send(gearman_con_st *con,
-                                  const gearman_packet_st *packet, bool flush);
+GEARMAN_INTERNAL_API
+gearman_return_t gearman_connection_send(gearman_connection_st *connection,
+                                         const gearman_packet_st *packet, bool flush);
 
 /**
  * Send packet data to a connection.
  */
-GEARMAN_API
-size_t gearman_con_send_data(gearman_con_st *con, const void *data,
-                             size_t data_size, gearman_return_t *ret_ptr);
+GEARMAN_INTERNAL_API
+size_t gearman_connection_send_data(gearman_connection_st *connection, const void *data,
+                                    size_t data_size, gearman_return_t *ret_ptr);
 
 /**
  * Flush the send buffer.
  */
-GEARMAN_API
-gearman_return_t gearman_con_flush(gearman_con_st *con);
+GEARMAN_INTERNAL_API
+gearman_return_t gearman_connection_flush(gearman_connection_st *connection);
 
 /**
  * Receive packet from a connection.
  */
-GEARMAN_API
-gearman_packet_st *gearman_con_recv(gearman_con_st *con,
-                                    gearman_packet_st *packet,
-                                    gearman_return_t *ret_ptr, bool recv_data);
+GEARMAN_INTERNAL_API
+gearman_packet_st *gearman_connection_recv(gearman_connection_st *connection,
+                                           gearman_packet_st *packet,
+                                           gearman_return_t *ret_ptr, bool recv_data);
 
 /**
  * Receive packet data from a connection.
  */
-GEARMAN_API
-size_t gearman_con_recv_data(gearman_con_st *con, void *data, size_t data_size,
-                             gearman_return_t *ret_ptr);
+GEARMAN_INTERNAL_API
+size_t gearman_connection_recv_data(gearman_connection_st *connection, void *data, size_t data_size,
+                                    gearman_return_t *ret_ptr);
 
 /**
  * Read data from a connection.
  */
-GEARMAN_API
-size_t gearman_con_read(gearman_con_st *con, void *data, size_t data_size,
-                        gearman_return_t *ret_ptr);
+GEARMAN_INTERNAL_API
+size_t gearman_connection_read(gearman_connection_st *connection, void *data, size_t data_size,
+                               gearman_return_t *ret_ptr);
 
 /**
  * Set events to be watched for a connection.
  */
-GEARMAN_API
-gearman_return_t gearman_con_set_events(gearman_con_st *con, short events);
+GEARMAN_INTERNAL_API
+gearman_return_t gearman_connection_set_events(gearman_connection_st *connection, short events);
 
 /**
  * Set events that are ready for a connection. This is used with the external
  * event callbacks.
  */
-GEARMAN_API
-gearman_return_t gearman_con_set_revents(gearman_con_st *con, short revents);
+GEARMAN_INTERNAL_API
+gearman_return_t gearman_connection_set_revents(gearman_connection_st *connection, short revents);
 
 /**
  * Get protocol context pointer.
  */
-GEARMAN_API
-void *gearman_con_protocol_context(const gearman_con_st *con);
+GEARMAN_INTERNAL_API
+void *gearman_connection_protocol_context(const gearman_connection_st *connection);
 
 /**
  * Set protocol context pointer.
  */
-GEARMAN_API
-void gearman_con_set_protocol_context(gearman_con_st *con, const void *context);
+GEARMAN_INTERNAL_API
+void gearman_connection_set_protocol_context(gearman_connection_st *connection, const void *context);
 
 /**
  * Set function to call when protocol_data should be freed.
  */
-GEARMAN_API
-void gearman_con_set_protocol_context_free_fn(gearman_con_st *con,
-                                gearman_con_protocol_context_free_fn *function);
+GEARMAN_INTERNAL_API
+void gearman_connection_set_protocol_context_free_fn(gearman_connection_st *connection,
+                                                     gearman_connection_protocol_context_free_fn *function);
 
 /**
  * Set custom packet_pack function
  */
-GEARMAN_API
-void gearman_con_set_packet_pack_fn(gearman_con_st *con,
-                                    gearman_packet_pack_fn *function);
+GEARMAN_INTERNAL_API
+void gearman_connection_set_packet_pack_fn(gearman_connection_st *connection,
+                                           gearman_packet_pack_fn *function);
 
 /**
  * Set custom packet_unpack function
  */
-GEARMAN_API
-void gearman_con_set_packet_unpack_fn(gearman_con_st *con,
-                                      gearman_packet_unpack_fn *function);
+GEARMAN_INTERNAL_API
+void gearman_connection_set_packet_unpack_fn(gearman_connection_st *connection,
+                                             gearman_packet_unpack_fn *function);
 
 /** @} */
 
+#endif /* GEARMAN_CORE */
+
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* __GEARMAN_CON_H__ */
+#endif /* __GEARMAN_CONNECTION_H__ */

=== modified file 'libgearman/constants.h'
--- libgearman/constants.h	2009-10-29 20:18:00 +0000
+++ libgearman/constants.h	2009-12-30 19:24:13 +0000
@@ -20,7 +20,7 @@
 
 /**
  * @addtogroup gearman_constants Constants
- * @ingroup gearman
+ * @ingroup gearman_universal
  * @ingroup gearman_client
  * @ingroup gearman_worker
  * @{
@@ -115,81 +115,34 @@
 /** @} */
 
 /**
- * @ingroup gearman
- * Options for gearman_st.
+ * @ingroup gearman_universal
+ * Options for gearman_universal_st.
  */
 typedef enum
 {
-  GEARMAN_ALLOCATED=          (1 << 0),
-  GEARMAN_NON_BLOCKING=       (1 << 1),
-  GEARMAN_DONT_TRACK_PACKETS= (1 << 2)
+  GEARMAN_NON_BLOCKING,
+  GEARMAN_DONT_TRACK_PACKETS,
+  GEARMAN_MAX
 } gearman_options_t;
 
 /**
  * @ingroup gearman_con
- * Options for gearman_con_st.
- */
-typedef enum
-{
-  GEARMAN_CON_ALLOCATED=              (1 << 0),
-  GEARMAN_CON_READY=                  (1 << 1),
-  GEARMAN_CON_PACKET_IN_USE=          (1 << 2),
-  GEARMAN_CON_EXTERNAL_FD=            (1 << 3),
-  GEARMAN_CON_IGNORE_LOST_CONNECTION= (1 << 4),
-  GEARMAN_CON_CLOSE_AFTER_FLUSH=      (1 << 5)
-} gearman_con_options_t;
-
-/**
- * @ingroup gearman_con
- * States for gearman_con_st.
- */
-typedef enum
-{
-  GEARMAN_CON_STATE_ADDRINFO,
-  GEARMAN_CON_STATE_CONNECT,
-  GEARMAN_CON_STATE_CONNECTING,
-  GEARMAN_CON_STATE_CONNECTED
-} gearman_con_state_t;
-
-/**
- * @ingroup gearman_con
- * Send states for gearman_con_st.
- */
-typedef enum
-{
-  GEARMAN_CON_SEND_STATE_NONE,
-  GEARMAN_CON_SEND_STATE_PRE_FLUSH,
-  GEARMAN_CON_SEND_STATE_FORCE_FLUSH,
-  GEARMAN_CON_SEND_STATE_FLUSH,
-  GEARMAN_CON_SEND_STATE_FLUSH_DATA
-} gearman_con_send_state_t;
-
-/**
- * @ingroup gearman_con
- * Recv states for gearman_con_st.
- */
-typedef enum
-{
-  GEARMAN_CON_RECV_STATE_NONE,
-  GEARMAN_CON_RECV_STATE_READ,
-  GEARMAN_CON_RECV_STATE_READ_DATA
-} gearman_con_recv_state_t;
-
-/**
- * @ingroup gearman_packet
- * Options for gearman_packet_st.
- */
-typedef enum
-{
-  GEARMAN_PACKET_ALLOCATED= (1 << 0),
-  GEARMAN_PACKET_COMPLETE=  (1 << 1),
-  GEARMAN_PACKET_FREE_DATA= (1 << 2)
-} gearman_packet_options_t;
+ * Options for gearman_connection_st.
+ */
+typedef enum
+{
+  GEARMAN_CON_READY,
+  GEARMAN_CON_PACKET_IN_USE,
+  GEARMAN_CON_EXTERNAL_FD,
+  GEARMAN_CON_IGNORE_LOST_CONNECTION,
+  GEARMAN_CON_CLOSE_AFTER_FLUSH,
+  GEARMAN_CON_MAX
+} gearman_connection_options_t;
 
 /**
  * @ingroup gearman_packet
  * Magic types.
- */
+*/
 typedef enum
 {
   GEARMAN_MAGIC_TEXT,
@@ -245,48 +198,6 @@
 } gearman_command_t;
 
 /**
- * @ingroup gearman_task
- * Options for gearman_task_st.
- */
-typedef enum
-{
-  GEARMAN_TASK_ALLOCATED=   (1 << 0),
-  GEARMAN_TASK_SEND_IN_USE= (1 << 1)
-} gearman_task_options_t;
-
-/**
- * @ingroup gearman_task
- * States for gearman_task_st.
- */
-typedef enum
-{
-  GEARMAN_TASK_STATE_NEW,
-  GEARMAN_TASK_STATE_SUBMIT,
-  GEARMAN_TASK_STATE_WORKLOAD,
-  GEARMAN_TASK_STATE_WORK,
-  GEARMAN_TASK_STATE_CREATED,
-  GEARMAN_TASK_STATE_DATA,
-  GEARMAN_TASK_STATE_WARNING,
-  GEARMAN_TASK_STATE_STATUS,
-  GEARMAN_TASK_STATE_COMPLETE,
-  GEARMAN_TASK_STATE_EXCEPTION,
-  GEARMAN_TASK_STATE_FAIL,
-  GEARMAN_TASK_STATE_FINISHED
-} gearman_task_state_t;
-
-/**
- * @ingroup gearman_job
- * Options for gearman_job_st.
- */
-typedef enum
-{
-  GEARMAN_JOB_ALLOCATED=       (1 << 0),
-  GEARMAN_JOB_ASSIGNED_IN_USE= (1 << 1),
-  GEARMAN_JOB_WORK_IN_USE=     (1 << 2),
-  GEARMAN_JOB_FINISHED=        (1 << 3)
-} gearman_job_options_t;
-
-/**
  * @ingroup gearman_job
  * Priority levels for a job.
  */
@@ -309,22 +220,11 @@
   GEARMAN_CLIENT_TASK_IN_USE=       (1 << 2),
   GEARMAN_CLIENT_UNBUFFERED_RESULT= (1 << 3),
   GEARMAN_CLIENT_NO_NEW=            (1 << 4),
-  GEARMAN_CLIENT_FREE_TASKS=        (1 << 5)
+  GEARMAN_CLIENT_FREE_TASKS=        (1 << 5),
+  GEARMAN_CLIENT_MAX=               (1 << 6)
 } gearman_client_options_t;
 
 /**
- * @ingroup gearman_client
- * States for gearman_client_st.
- */
-typedef enum
-{
-  GEARMAN_CLIENT_STATE_IDLE,
-  GEARMAN_CLIENT_STATE_NEW,
-  GEARMAN_CLIENT_STATE_SUBMIT,
-  GEARMAN_CLIENT_STATE_PACKET
-} gearman_client_state_t;
-
-/**
  * @ingroup gearman_worker
  * Options for gearman_worker_st.
  */
@@ -338,57 +238,21 @@
   GEARMAN_WORKER_WORK_JOB_IN_USE=  (1 << 5),
   GEARMAN_WORKER_CHANGE=           (1 << 6),
   GEARMAN_WORKER_GRAB_UNIQ=        (1 << 7),
-  GEARMAN_WORKER_TIMEOUT_RETURN=   (1 << 8)
+  GEARMAN_WORKER_TIMEOUT_RETURN=   (1 << 8),
+  GEARMAN_WORKER_MAX=   (1 << 9)
 } gearman_worker_options_t;
 
 /**
- * @ingroup gearman_worker
- * States for gearman_worker_st.
- */
-typedef enum
-{
-  GEARMAN_WORKER_STATE_START,
-  GEARMAN_WORKER_STATE_FUNCTION_SEND,
-  GEARMAN_WORKER_STATE_CONNECT,
-  GEARMAN_WORKER_STATE_GRAB_JOB_SEND,
-  GEARMAN_WORKER_STATE_GRAB_JOB_RECV,
-  GEARMAN_WORKER_STATE_PRE_SLEEP
-} gearman_worker_state_t;
-
-/**
- * @ingroup gearman_worker
- * Options for gearman_worker_function_st.
- */
-typedef enum
-{
-  GEARMAN_WORKER_FUNCTION_PACKET_IN_USE= (1 << 0),
-  GEARMAN_WORKER_FUNCTION_CHANGE=        (1 << 1),
-  GEARMAN_WORKER_FUNCTION_REMOVE=        (1 << 2)
-} gearman_worker_function_options_t;
-
-/**
- * @ingroup gearman_worker
- * Work states for gearman_worker_st.
- */
-typedef enum
-{
-  GEARMAN_WORKER_WORK_STATE_GRAB_JOB,
-  GEARMAN_WORKER_WORK_STATE_FUNCTION,
-  GEARMAN_WORKER_WORK_STATE_COMPLETE,
-  GEARMAN_WORKER_WORK_STATE_FAIL
-} gearman_worker_work_state_t;
-
-/**
  * @addtogroup gearman_types Types
- * @ingroup gearman
+ * @ingroup gearman_universal
  * @ingroup gearman_client
  * @ingroup gearman_worker
  * @{
  */
 
 /* Types. */
-typedef struct gearman_st gearman_st;
-typedef struct gearman_con_st gearman_con_st;
+typedef struct gearman_universal_st gearman_universal_st;
+typedef struct gearman_connection_st gearman_connection_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;
@@ -402,7 +266,7 @@
 typedef gearman_return_t (gearman_created_fn)(gearman_task_st *task);
 typedef gearman_return_t (gearman_data_fn)(gearman_task_st *task);
 typedef gearman_return_t (gearman_warning_fn)(gearman_task_st *task);
-typedef gearman_return_t (gearman_status_fn)(gearman_task_st *task);
+typedef gearman_return_t (gearman_universal_status_fn)(gearman_task_st *task);
 typedef gearman_return_t (gearman_complete_fn)(gearman_task_st *task);
 typedef gearman_return_t (gearman_exception_fn)(gearman_task_st *task);
 typedef gearman_return_t (gearman_fail_fn)(gearman_task_st *task);
@@ -415,7 +279,10 @@
                                   size_t *result_size,
                                   gearman_return_t *ret_ptr);
 
-typedef gearman_return_t (gearman_event_watch_fn)(gearman_con_st *con,
+/**
+  @todo this is only used by the server and should be made private.
+ */
+typedef gearman_return_t (gearman_event_watch_fn)(gearman_connection_st *con,
                                                   short events, void *context);
 
 typedef void* (gearman_malloc_fn)(size_t size, void *context);
@@ -427,15 +294,15 @@
 typedef void (gearman_log_fn)(const char *line, gearman_verbose_t verbose,
                               void *context);
 
-typedef void (gearman_con_protocol_context_free_fn)(gearman_con_st *con,
-                                                    void *context);
+typedef void (gearman_connection_protocol_context_free_fn)(gearman_connection_st *con,
+                                                           void *context);
 
 typedef size_t (gearman_packet_pack_fn)(const gearman_packet_st *packet,
-                                        gearman_con_st *con,
+                                        gearman_connection_st *con,
                                         void *data, size_t data_size,
                                         gearman_return_t *ret_ptr);
 typedef size_t (gearman_packet_unpack_fn)(gearman_packet_st *packet,
-                                          gearman_con_st *con, const void *data,
+                                          gearman_connection_st *con, const void *data,
                                           size_t data_size,
                                           gearman_return_t *ret_ptr);
 

=== added file 'libgearman/core.c'
--- libgearman/core.c	1970-01-01 00:00:00 +0000
+++ libgearman/core.c	2009-12-30 19:24:13 +0000
@@ -0,0 +1,73 @@
+/* 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 Gearman State Definitions
+ */
+
+#include "common.h"
+
+
+gearman_return_t gearman_parse_servers(const char *servers,
+                                       gearman_parse_server_fn *function,
+                                       const void *context)
+{
+  const char *ptr= servers;
+  size_t x;
+  char host[NI_MAXHOST];
+  char port[NI_MAXSERV];
+  gearman_return_t ret;
+
+  if (ptr == NULL)
+    return (*function)(NULL, 0, (void *)context);
+
+  while (1)
+  {
+    x= 0;
+
+    while (*ptr != 0 && *ptr != ',' && *ptr != ':')
+    {
+      if (x < (NI_MAXHOST - 1))
+        host[x++]= *ptr;
+
+      ptr++;
+    }
+
+    host[x]= 0;
+
+    if (*ptr == ':')
+    {
+      ptr++;
+      x= 0;
+
+      while (*ptr != 0 && *ptr != ',')
+      {
+        if (x < (NI_MAXSERV - 1))
+          port[x++]= *ptr;
+
+        ptr++;
+      }
+
+      port[x]= 0;
+    }
+    else
+      port[0]= 0;
+
+    ret= (*function)(host, (in_port_t)atoi(port), (void *)context);
+    if (ret != GEARMAN_SUCCESS)
+      return ret;
+
+    if (*ptr == 0)
+      break;
+
+    ptr++;
+  }
+
+  return GEARMAN_SUCCESS;
+}

=== added file 'libgearman/core.h'
--- libgearman/core.h	1970-01-01 00:00:00 +0000
+++ libgearman/core.h	2009-12-30 19:24:13 +0000
@@ -0,0 +1,49 @@
+/* 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 Gearman Declarations
+ */
+
+#ifndef __GEARMAN_CORE_H__
+#define __GEARMAN_CORE_H__
+
+#include <libgearman/universal.h>
+#include <libgearman/command.h>
+#include <libgearman/packet.h>
+#include <libgearman/connection.h>
+#include <libgearman/log.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @ingroup gearman_universal
+ */
+/**
+ * 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_API
+gearman_return_t gearman_parse_servers(const char *servers,
+                                       gearman_parse_server_fn *callback,
+                                       const void *context);
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __GEARMAN_CORE_H__ */

=== added file 'libgearman/gearman.c'
--- libgearman/gearman.c	1970-01-01 00:00:00 +0000
+++ libgearman/gearman.c	2009-12-30 19:24:13 +0000
@@ -0,0 +1,57 @@
+/* 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 Gearman State Definitions
+ */
+
+#include "common.h"
+
+/**
+ * @addtogroup gearman_universal_static Static Gearman Declarations
+ * @ingroup gearman_universal
+ * @{
+ */
+
+/**
+ * Names of the verbose levels provided.
+ */
+static const char *_verbose_name[GEARMAN_VERBOSE_MAX]=
+{
+  "NEVER",
+  "FATAL",
+  "ERROR",
+  "INFO",
+  "DEBUG",
+  "CRAZY"
+};
+
+/** @} */
+
+/*
+ * Public Definitions
+ */
+
+const char *gearman_version(void)
+{
+    return PACKAGE_VERSION;
+}
+
+const char *gearman_bugreport(void)
+{
+    return PACKAGE_BUGREPORT;
+}
+
+const char *gearman_verbose_name(gearman_verbose_t verbose)
+{
+  if (verbose >= GEARMAN_VERBOSE_MAX)
+    return "UNKNOWN";
+
+  return _verbose_name[verbose];
+}

=== added file 'libgearman/gearman.h'
--- libgearman/gearman.h	1970-01-01 00:00:00 +0000
+++ libgearman/gearman.h	2009-12-30 19:24:13 +0000
@@ -0,0 +1,112 @@
+/* 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 Gearman Declarations
+ */
+
+#ifndef __GEARMAN_H__
+#define __GEARMAN_H__
+
+#include <inttypes.h>
+#ifndef __cplusplus
+#  include <stdbool.h>
+#endif
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <arpa/inet.h>
+#include <poll.h>
+#include <sys/uio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+
+#include <libgearman/visibility.h>
+#include <libgearman/constants.h>
+
+// Everything above this line must be in the order specified.
+#include <libgearman/core.h>
+#include <libgearman/task.h>
+#include <libgearman/job.h>
+
+#include <libgearman/worker.h>
+#include <libgearman/client.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @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,
+ * proxies, or your own server.
+ *
+ * There is no locking within a single gearman_universal_st structure, so for threaded
+ * applications you must either ensure isolation in the application or use
+ * multiple gearman_universal_st structures (for example, one for each thread).
+ *
+ * @{
+ */
+
+/**
+ * Get Gearman library version.
+ *
+ * @return Version string of library.
+ */
+GEARMAN_API
+const char *gearman_version(void);
+
+/**
+ * Get bug report URL.
+ *
+ * @return Bug report URL string.
+ */
+GEARMAN_API
+const char *gearman_bugreport(void);
+
+/**
+ * Get string with the name of the given verbose level.
+ *
+ * @param[in] verbose Verbose logging level.
+ * @return String form of verbose level.
+ */
+GEARMAN_API
+const char *gearman_verbose_name(gearman_verbose_t verbose);
+
+/**
+ * Get current socket I/O activity timeout value.
+ *
+ * @param[in] gearman_client_st or gearman_worker_st Structure previously initialized.
+ * @return Timeout in milliseconds to wait for I/O activity. A negative value
+ *  means an infinite timeout.
+ * @note This is a utility macro.
+ */
+#define gearman_timeout(__object) ((__object)->gearman.timeout)
+
+/**
+ * Set socket I/O activity timeout for connections in a Gearman structure.
+ *
+ * @param[in] gearman_client_st or gearman_worker_st Structure previously initialized.
+ * @param[in] timeout Milliseconds to wait for I/O activity. A negative value
+ *  means an infinite timeout.
+ * @note This is a utility macro.
+ */
+#define gearman_set_timeout(__object, __value) ((__object)->gearman.timeout)=(__value);
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __GEARMAN_H__ */

=== modified file 'libgearman/include.am'
--- libgearman/include.am	2009-12-18 19:25:00 +0000
+++ libgearman/include.am	2009-12-30 19:24:13 +0000
@@ -10,32 +10,53 @@
 # Included from Top Level Makefile.am
 # All paths should be given relative to the root
 
+nobase_include_HEADERS += \
+			     libgearman/client.h \
+			     libgearman/command.h \
+			     libgearman/connection.h \
+			     libgearman/constants.h \
+			     libgearman/core.h \
+			     libgearman/gearman.h \
+			     libgearman/job.h \
+			     libgearman/packet.h \
+			     libgearman/task.h \
+			     libgearman/universal.h \
+			     libgearman/visibility.h \
+			     libgearman/worker.h
+
+noinst_HEADERS+= \
+		 libgearman/common.h \
+		 libgearman/log.h
+
+noinst_LTLIBRARIES+= libgearman/libgearmancore.la
+libgearman_libgearmancore_la_SOURCES= \
+				       libgearman/connection.c \
+				       libgearman/core.c \
+				       libgearman/log.c \
+				       libgearman/packet.c \
+				       libgearman/universal.c
+
+libgearman_libgearmancore_la_CFLAGS= \
+				     ${AM_CFLAGS} \
+				     -DBUILDING_LIBGEARMAN
+
+#libgearman_libgearmancore_la_LDFLAGS= \
+#				      $(AM_LDFLAGS) \
+#				      -version-info \
+#				      $(GEARMAN_LIBRARY_VERSION)
+#
+#libgearman_libgearmancore_la_LIBADD= \
+#				     $(LTLIBUUID)
+
 lib_LTLIBRARIES+= libgearman/libgearman.la
-
-nobase_pkginclude_HEADERS += \
-	libgearman/client.h \
-	libgearman/conn.h \
-	libgearman/constants.h \
-	libgearman/gearman.h \
-	libgearman/job.h \
-	libgearman/packet.h \
-	libgearman/structs.h \
-	libgearman/task.h \
-	libgearman/visibility.h \
-	libgearman/worker.h
-
-noinst_HEADERS+= \
-	libgearman/common.h \
-	libgearman/gearman_local.h
-
 libgearman_libgearman_la_SOURCES= \
-	libgearman/client.c \
-	libgearman/conn.c \
-	libgearman/gearman.c \
-	libgearman/job.c \
-	libgearman/packet.c \
-	libgearman/task.c \
-	libgearman/worker.c
+				  libgearman/client.c \
+				  libgearman/gearman.c \
+				  libgearman/job.c \
+				  libgearman/task.c \
+				  libgearman/worker.c
+
+libgearman_libgearman_la_DEPENDENCIES= libgearman/libgearmancore.la
 
 libgearman_libgearman_la_CFLAGS= \
 	${AM_CFLAGS} \
@@ -47,5 +68,6 @@
 	$(GEARMAN_LIBRARY_VERSION)
 
 libgearman_libgearman_la_LIBADD= \
+	libgearman/libgearmancore.la \
 	$(LTLIBUUID)
 

=== modified file 'libgearman/job.c'
--- libgearman/job.c	2009-11-09 10:05:31 +0000
+++ libgearman/job.c	2009-12-30 19:24:13 +0000
@@ -30,6 +30,44 @@
  * Public Definitions
  */
 
+gearman_job_st *gearman_job_create(gearman_worker_st *worker,
+                                   gearman_job_st *job)
+{
+  if (job == NULL)
+  {
+    job= malloc(sizeof(gearman_job_st));
+    if (job == NULL)
+    {
+      gearman_universal_set_error(worker->gearman, "_job_create", "malloc");
+      return NULL;
+    }
+
+    job->options.allocated= true;
+  }
+  else
+  {
+    job->options.allocated= false;
+  }
+
+  job->options.assigned_in_use= false;
+  job->options.work_in_use= false;
+  job->options.finished= false;
+
+  job->worker= worker;
+
+  if (worker->job_list != NULL)
+    worker->job_list->prev= job;
+  job->next= worker->job_list;
+  job->prev= NULL;
+  worker->job_list= job;
+  worker->job_count++;
+
+  job->con= NULL;
+
+  return job;
+}
+
+
 gearman_return_t gearman_job_send_data(gearman_job_st *job, const void *data,
                                        size_t data_size)
 {
@@ -37,20 +75,20 @@
   const void *args[2];
   size_t args_size[2];
 
-  if (!(job->options & GEARMAN_JOB_WORK_IN_USE))
+  if (! (job->options.work_in_use))
   {
     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);
+    ret= gearman_packet_create_args(job->worker->gearman, &(job->work),
+                                    GEARMAN_MAGIC_REQUEST,
+                                    GEARMAN_COMMAND_WORK_DATA,
+                                    args, args_size, 2);
     if (ret != GEARMAN_SUCCESS)
       return ret;
 
-    job->options|= GEARMAN_JOB_WORK_IN_USE;
+    job->options.work_in_use= true;
   }
 
   return _job_send(job);
@@ -64,20 +102,20 @@
   const void *args[2];
   size_t args_size[2];
 
-  if (!(job->options & GEARMAN_JOB_WORK_IN_USE))
+  if (! (job->options.work_in_use))
   {
     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);
+    ret= gearman_packet_create_args(job->worker->gearman, &(job->work),
+                                    GEARMAN_MAGIC_REQUEST,
+                                    GEARMAN_COMMAND_WORK_WARNING,
+                                    args, args_size, 2);
     if (ret != GEARMAN_SUCCESS)
       return ret;
 
-    job->options|= GEARMAN_JOB_WORK_IN_USE;
+    job->options.work_in_use= true;
   }
 
   return _job_send(job);
@@ -93,7 +131,7 @@
   const void *args[3];
   size_t args_size[3];
 
-  if (!(job->options & GEARMAN_JOB_WORK_IN_USE))
+  if (! (job->options.work_in_use))
   {
     snprintf(numerator_string, 12, "%u", numerator);
     snprintf(denominator_string, 12, "%u", denominator);
@@ -104,14 +142,14 @@
     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),
+    ret= gearman_packet_create_args(job->worker->gearman, &(job->work),
                                  GEARMAN_MAGIC_REQUEST,
                                  GEARMAN_COMMAND_WORK_STATUS,
                                  args, args_size, 3);
     if (ret != GEARMAN_SUCCESS)
       return ret;
 
-    job->options|= GEARMAN_JOB_WORK_IN_USE;
+    job->options.work_in_use= true;
   }
 
   return _job_send(job);
@@ -125,30 +163,31 @@
   const void *args[2];
   size_t args_size[2];
 
-  if (job->options & GEARMAN_JOB_FINISHED)
+  if (job->options.finished)
     return GEARMAN_SUCCESS;
 
-  if (!(job->options & GEARMAN_JOB_WORK_IN_USE))
+  if (! (job->options.work_in_use))
   {
     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),
+    ret= gearman_packet_create_args(job->worker->gearman, &(job->work),
                                  GEARMAN_MAGIC_REQUEST,
                                  GEARMAN_COMMAND_WORK_COMPLETE,
                                  args, args_size, 2);
     if (ret != GEARMAN_SUCCESS)
       return ret;
 
-    job->options|= GEARMAN_JOB_WORK_IN_USE;
+    job->options.work_in_use= true;
   }
 
   ret= _job_send(job);
   if (ret != GEARMAN_SUCCESS)
     return ret;
 
-  job->options|= GEARMAN_JOB_FINISHED;
+  job->options.finished= true;
+
   return GEARMAN_SUCCESS;
 }
 
@@ -160,20 +199,20 @@
   const void *args[2];
   size_t args_size[2];
 
-  if (!(job->options & GEARMAN_JOB_WORK_IN_USE))
+  if (! (job->options.work_in_use))
   {
     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),
+    ret= gearman_packet_create_args(job->worker->gearman, &(job->work),
                                  GEARMAN_MAGIC_REQUEST,
                                  GEARMAN_COMMAND_WORK_EXCEPTION,
                                  args, args_size, 2);
     if (ret != GEARMAN_SUCCESS)
       return ret;
 
-    job->options|= GEARMAN_JOB_WORK_IN_USE;
+    job->options.work_in_use= true;
   }
 
   return _job_send(job);
@@ -185,28 +224,28 @@
   const void *args[1];
   size_t args_size[1];
 
-  if (job->options & GEARMAN_JOB_FINISHED)
+  if (job->options.finished)
     return GEARMAN_SUCCESS;
 
-  if (!(job->options & GEARMAN_JOB_WORK_IN_USE))
+  if (! (job->options.work_in_use))
   {
     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, 1);
+    ret= gearman_packet_create_args(job->worker->gearman, &(job->work),
+                                    GEARMAN_MAGIC_REQUEST,
+                                    GEARMAN_COMMAND_WORK_FAIL,
+                                    args, args_size, 1);
     if (ret != GEARMAN_SUCCESS)
       return ret;
 
-    job->options|= GEARMAN_JOB_WORK_IN_USE;
+    job->options.work_in_use= true;
   }
 
   ret= _job_send(job);
   if (ret != GEARMAN_SUCCESS)
     return ret;
 
-  job->options|= GEARMAN_JOB_FINISHED;
+  job->options.finished= true;
   return GEARMAN_SUCCESS;
 }
 
@@ -250,12 +289,12 @@
 {
   gearman_return_t ret;
 
-  ret= gearman_con_send(job->con, &(job->work), true);
+  ret= gearman_connection_send(job->con, &(job->work), true);
   if (ret != GEARMAN_SUCCESS)
     return ret;
 
   gearman_packet_free(&(job->work));
-  job->options&= (gearman_job_options_t)~GEARMAN_JOB_WORK_IN_USE;
+  job->options.work_in_use= false;
 
   return GEARMAN_SUCCESS;
 }

=== modified file 'libgearman/job.h'
--- libgearman/job.h	2009-10-29 00:11:45 +0000
+++ libgearman/job.h	2009-12-30 19:24:13 +0000
@@ -28,6 +28,50 @@
  * @{
  */
 
+
+/**
+ * @ingroup gearman_job
+ */
+struct gearman_job_st
+{
+  struct {
+    bool allocated:1;
+    bool assigned_in_use:1;
+    bool work_in_use:1;
+    bool finished:1;
+  } options;
+  gearman_worker_st *worker;
+  gearman_job_st *next;
+  gearman_job_st *prev;
+  gearman_connection_st *con;
+  gearman_packet_st assigned;
+  gearman_packet_st work;
+};
+
+/**
+ * Initialize a job structure. Always check the return value even if passing
+ * in a pre-allocated structure. Some other initialization may have failed. It
+ * is not required to memset() a structure before providing it.
+ *
+ * @param[in] A valid gearman_worker_st.
+ * @param[in] gearman_job_st allocated structure, or NULL to allocate one.
+ * @return On success, a pointer to the (possibly allocated) structure. On
+ *  failure this will be NULL.
+ */
+GEARMAN_LOCAL
+gearman_job_st *gearman_job_create(gearman_worker_st *worker,
+                                   gearman_job_st *job);
+
+/**
+ * Free a job structure.
+ *
+ * @param[in] job Structure previously initialized with
+ *  gearman_worker_grab_job().
+ */
+GEARMAN_API
+void gearman_job_free(gearman_job_st *job);
+
+
 /**
  * Send data for a running job.
  */

=== added file 'libgearman/log.c'
--- libgearman/log.c	1970-01-01 00:00:00 +0000
+++ libgearman/log.c	2009-12-30 19:24:13 +0000
@@ -0,0 +1,101 @@
+/* Gearman server and library
+ * Copyright (C) 2008-2009 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 Gearman State Definitions
+ */
+
+#include "common.h"
+
+
+void gearman_log(gearman_universal_st *state, gearman_verbose_t verbose,
+                 const char *format, va_list args)
+{
+  char log_buffer[GEARMAN_MAX_ERROR_SIZE];
+
+  if (state->log_fn == NULL)
+  {
+    printf("%5s: ", gearman_verbose_name(verbose));
+    vprintf(format, args);
+    printf("\n");
+  }
+  else
+  {
+    vsnprintf(log_buffer, GEARMAN_MAX_ERROR_SIZE, format, args);
+    state->log_fn(log_buffer, verbose, (void *)state->log_context);
+  }
+}
+
+
+void gearman_log_fatal(gearman_universal_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);
+  }
+}
+
+void gearman_log_error(gearman_universal_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);
+  }
+}
+
+void gearman_log_info(gearman_universal_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);
+  }
+}
+
+void gearman_log_debug(gearman_universal_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);
+  }
+}
+
+void gearman_log_crazy(gearman_universal_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);
+  }
+}
+
+

=== renamed file 'libgearman/gearman_local.h' => 'libgearman/log.h'
--- libgearman/gearman_local.h	2009-10-29 00:11:45 +0000
+++ libgearman/log.h	2009-12-30 19:24:13 +0000
@@ -11,8 +11,8 @@
  * @brief Local Gearman Declarations
  */
 
-#ifndef __GEARMAN_LOCAL_H__
-#define __GEARMAN_LOCAL_H__
+#ifndef __GEARMAN_LOG_H__
+#define __GEARMAN_LOG_H__
 
 #ifdef __cplusplus