Merge lp:~eday/scalestack/network-review into lp:~registry/scalestack/old-trunk

[Eric Day]

Network/UDP cleanup.

[Christopher Mooney (cmooney)]

Reviewed the diff and it looks sane to me. Ship it!

review: Approve

=== modified file 'ScaleStack/Echo/Flood/Datagram.cc'
--- ScaleStack/Echo/Flood/Datagram.cc	2010-05-04 08:58:05 +0000
+++ ScaleStack/Echo/Flood/Datagram.cc	2010-05-16 06:24:29 +0000
@@ -16,9 +16,9 @@
 #include "config.h"
 
 #include <cstring>
-#include <netdb.h>
 
 #include <ScaleStack/Echo/Flood/Datagram.h>
+#include <ScaleStack/Echo/Flood/Flood.h>
 #include <ScaleStack/Kernel/Core.h>
 #include <ScaleStack/Kernel/Module.h>
 #include <ScaleStack/Kernel/Option.h>
@@ -28,25 +28,19 @@
 namespace Flood {
 
 /*
- * Public functions.
+ * Public methods.
  */
 
-void DatagramOptions(Kernel::Module& module)
+void Datagram::Options(Kernel::Module& module)
 {
   module.addOption("iterations", "Number of iterations to run per datagram, 0 means forever.", "COUNT", "1");
-  module.addOption("count", "Number of concurrent datagrams to open.", "COUNT", "1");
-  module.addOption("send_size", "Size of packets to send.", "SEND_SIZE", "4096");
+  module.addOption("packet_size", "Size of packets to send.", "SIZE", "4096");
 }
 
-/*
- * Public methods.
- */
-
-Datagram::Datagram(Network::DatagramService& service, struct addrinfo* send_addr):
+Datagram::Datagram(Network::DatagramService& service):
   Network::Datagram(service),
-  _send_addr(send_addr),
-  _send_size(_module.getOption("send_size").getSizeValue()),
   _iterations(_module.getOption("iterations").getSizeValue()),
+  _packet_size(_module.getOption("packet_size").getSizeValue()),
   _read_offset(),
   _write_offset()
 {
@@ -61,10 +55,10 @@
   flushSend();
 }
 
-size_t Datagram::recv(uint8_t* buffer, size_t size, struct sockaddr*, socklen_t)
+size_t Datagram::receive(uint8_t* buffer, size_t size, struct sockaddr&, socklen_t)
 {
   if (memcmp(random_buffer + _read_offset, buffer, size))
-    _module.logFatal("Read data did not match what was sent");
+    _module.logFatal("Received data did not match what was sent");
 
   _read_offset += size;
 
@@ -88,15 +82,14 @@
 
 void Datagram::flushSend(void)
 {
-  size_t send_size = _send_size;
-
-  if (random_buffer_size - _write_offset < send_size)
-    send_size = random_buffer_size - _write_offset;
-
-  _write_offset += send(random_buffer + _write_offset,
-                         send_size,
-                         _send_addr->ai_addr,
-                         _send_addr->ai_addrlen);
+  size_t packet_size;
+
+  if (random_buffer_size - _write_offset < _packet_size)
+    packet_size = random_buffer_size - _write_offset;
+  else
+    packet_size = _packet_size;
+
+  _write_offset += send(random_buffer + _write_offset, packet_size);
 }
 
 void Datagram::error(void)

=== modified file 'ScaleStack/Echo/Flood/Datagram.h'
--- ScaleStack/Echo/Flood/Datagram.h	2010-05-03 00:23:08 +0000
+++ ScaleStack/Echo/Flood/Datagram.h	2010-05-16 06:24:29 +0000
@@ -16,11 +16,8 @@
 #ifndef SCALESTACK_ECHO_FLOOD_DATAGRAM_H
 #define SCALESTACK_ECHO_FLOOD_DATAGRAM_H
 
-#include <sys/types.h>
-#include <sys/socket.h>
 #include <ScaleStack/Common/Macros.h>
 #include <ScaleStack/Network/Datagram.h>
-#include <ScaleStack/Echo/Flood/Flood.h>
 
 namespace ScaleStack {
 namespace Kernel {
@@ -33,16 +30,18 @@
 namespace Flood {
 
 /**
- * Add common options for stream services.
+ * Class for handling datagram requests.
  */
-SCALESTACK_API
-void DatagramOptions(Kernel::Module& module);
-
 class SCALESTACK_API Datagram: public Network::Datagram
 {
 public:
 
-  Datagram(Network::DatagramService& service, struct addrinfo *send_addr);
+  /**
+   * Add common options for datagrams.
+   */
+  static void Options(Kernel::Module& module);
+
+  Datagram(Network::DatagramService& service);
 
   ~Datagram();
 
@@ -52,12 +51,15 @@
   void ready(void);
 
   /**
-   * See Network::Datagram::read().
+   * See Network::Datagram::receive().
    */
-  size_t recv(uint8_t* buffer, size_t size, struct sockaddr *, socklen_t socklen);
+  size_t receive(uint8_t* buffer,
+                 size_t size,
+                 struct sockaddr& peer,
+                 socklen_t peer_size);
 
   /**
-   * See Network::Datagram::flushWrite().
+   * See Network::Datagram::flushSend().
    */
   void flushSend(void);
 
@@ -78,9 +80,8 @@
    */
   Datagram& operator=(const Datagram&);
 
-  struct addrinfo* _send_addr;
-  size_t _send_size;
   size_t _iterations;
+  size_t _packet_size;
   size_t _read_offset;
   size_t _write_offset;
 };

=== modified file 'ScaleStack/Echo/Flood/Flood.h'
--- ScaleStack/Echo/Flood/Flood.h	2010-05-02 23:02:34 +0000
+++ ScaleStack/Echo/Flood/Flood.h	2010-05-16 06:24:29 +0000
@@ -10,7 +10,7 @@
 
 /**
  * @file
- * @brief Echo Flood Declarations
+ * @brief Echo Flood Module Declarations
  */
 
 #ifndef SCALESTACK_ECHO_FLOOD_FLOOD_H
@@ -20,16 +20,10 @@
 #include <sys/types.h>
 
 namespace ScaleStack {
-namespace Kernel {
-
-class Module;
-
-} /* namespace Kernel */
-
 namespace Echo {
 namespace Flood {
 
-const size_t random_buffer_size = 8385637;
+const size_t random_buffer_size = 385637;
 extern uint8_t random_buffer[random_buffer_size];
 
 } /* namespace Flood */

=== modified file 'ScaleStack/Echo/Flood/Stream.cc'
--- ScaleStack/Echo/Flood/Stream.cc	2010-05-02 23:02:34 +0000
+++ ScaleStack/Echo/Flood/Stream.cc	2010-05-16 06:24:29 +0000
@@ -17,6 +17,7 @@
 
 #include <cstring>
 
+#include <ScaleStack/Echo/Flood/Flood.h>
 #include <ScaleStack/Echo/Flood/Stream.h>
 #include <ScaleStack/Kernel/Core.h>
 #include <ScaleStack/Kernel/Module.h>
@@ -27,20 +28,15 @@
 namespace Flood {
 
 /*
- * Public functions.
+ * Public methods.
  */
 
-void StreamOptions(Kernel::Module& module)
+void Stream::Options(Kernel::Module& module)
 {
   module.addOption("iterations", "Number of iterations to run per stream, 0 means forever.", "COUNT", "1");
-  module.addOption("count", "Number of concurrent streams to open.", "COUNT", "1");
   module.addOption("reconnect", "Whether to reconnect between iterations.", "BOOLEAN", "False");
 }
 
-/*
- * Public methods.
- */
-
 Stream::Stream(Network::StreamService& service):
   Network::Stream(service),
   _iterations(_module.getOption("iterations").getSizeValue()),
@@ -53,6 +49,11 @@
 {
 }
 
+void Stream::connected(void)
+{
+  flushWrite();
+}
+
 size_t Stream::read(uint8_t* buffer, size_t size)
 {
   if (memcmp(random_buffer + _read_offset, buffer, size))
@@ -86,11 +87,6 @@
                          true);
 }
 
-void Stream::connected(void)
-{
-  flushWrite();
-}
-
 void Stream::error(void)
 {
   _module.getCore().shutdown();

=== modified file 'ScaleStack/Echo/Flood/Stream.h'
--- ScaleStack/Echo/Flood/Stream.h	2010-05-02 23:02:34 +0000
+++ ScaleStack/Echo/Flood/Stream.h	2010-05-16 06:24:29 +0000
@@ -18,7 +18,6 @@
 
 #include <ScaleStack/Common/Macros.h>
 #include <ScaleStack/Network/Stream.h>
-#include <ScaleStack/Echo/Flood/Flood.h>
 
 namespace ScaleStack {
 namespace Kernel {
@@ -31,20 +30,27 @@
 namespace Flood {
 
 /**
- * Add common options for stream services.
+ * Class for handling stream requests.
  */
-SCALESTACK_API
-void StreamOptions(Kernel::Module& module);
-
 class SCALESTACK_API Stream: public Network::Stream
 {
 public:
 
+  /**
+   * Add common options for streams.
+   */
+  static void Options(Kernel::Module& module);
+
   Stream(Network::StreamService& service);
 
   ~Stream();
 
   /**
+   * See Network::Stream::connected().
+   */
+  void connected(void);
+
+  /**
    * See Network::Stream::read().
    */
   size_t read(uint8_t* buffer, size_t size);
@@ -55,11 +61,6 @@
   void flushWrite(void);
 
   /**
-   * See Network::Stream::connected().
-   */
-  void connected(void);
-
-  /**
    * See Network::Stream::error().
    */
   void error(void);

=== modified file 'ScaleStack/Echo/Flood/TCP/TCP.cc'
--- ScaleStack/Echo/Flood/TCP/TCP.cc	2010-05-01 05:23:39 +0000
+++ ScaleStack/Echo/Flood/TCP/TCP.cc	2010-05-16 06:24:29 +0000
@@ -28,7 +28,8 @@
 {
   module.addOption("host", "Host to connect to.", "HOST", "localhost");
   module.addOption("port", "Port to connect to.", "PORT", "7");
-  Echo::Flood::StreamOptions(module);
+  module.addOption("count", "Number of concurrent connections to open.", "COUNT", "1");
+  Echo::Flood::Stream::Options(module);
 }
 
 static void start(Kernel::Module& module)

=== modified file 'ScaleStack/Echo/Flood/UDP/Service.cc'
--- ScaleStack/Echo/Flood/UDP/Service.cc	2010-05-02 23:02:34 +0000
+++ ScaleStack/Echo/Flood/UDP/Service.cc	2010-05-16 06:24:29 +0000
@@ -15,8 +15,6 @@
 
 #include "config.h"
 
-#include <ScaleStack/Kernel/Module.h>
-#include <ScaleStack/Kernel/Option.h>
 #include <ScaleStack/Echo/Flood/Datagram.h>
 #include <ScaleStack/Echo/Flood/UDP/Service.h>
 
@@ -30,21 +28,18 @@
  */
 
 Service::Service(Kernel::Module& module):
-  Network::IP::UDP::SocketService(module),
-  _send_addr(getaddrinfo(module.getOption("host").getValue(),
-                         module.getOption("port").getValue()))
+  Network::IP::UDP::SocketService(module)
 {
 }
 
 Service::~Service()
 {
-  freeaddrinfo(_send_addr);
   shutdown();
 }
 
 Network::Datagram* Service::addDatagram(void)
 {
-  return new Datagram(*this, _send_addr);
+  return new Datagram(*this);
 }
 
 void Service::removeDatagram(Network::Datagram* datagram)

=== modified file 'ScaleStack/Echo/Flood/UDP/Service.h'
--- ScaleStack/Echo/Flood/UDP/Service.h	2010-05-02 23:02:34 +0000
+++ ScaleStack/Echo/Flood/UDP/Service.h	2010-05-16 06:24:29 +0000
@@ -39,7 +39,7 @@
   /**
    * See Network::DatagramService::removeDatagram().
    */
-  void removeDatagram(Network::Datagram* stream);
+  void removeDatagram(Network::Datagram* datagram);
 
 private:
 
@@ -52,8 +52,6 @@
    * Don't allow assignment of objects.
    */
   Service& operator=(const Service&);
-
-  struct addrinfo* _send_addr;
 };
 
 } /* namespace UDP */

=== modified file 'ScaleStack/Echo/Flood/UDP/UDP.cc'
--- ScaleStack/Echo/Flood/UDP/UDP.cc	2010-05-04 01:00:14 +0000
+++ ScaleStack/Echo/Flood/UDP/UDP.cc	2010-05-16 06:24:29 +0000
@@ -26,9 +26,9 @@
 
 static void options(Kernel::Module& module)
 {
-  module.addOption("host", "Host to send to.", "HOST", "localhost");
-  module.addOption("port", "Port to send to.", "PORT", "7");
-  Echo::Flood::DatagramOptions(module);
+  Network::IP::UDP::SocketService::Options(module, ":7");
+  module.addOption("count", "Number of concurrent sockets to open.", "COUNT", "1");
+  Echo::Flood::Datagram::Options(module);
 }
 
 static void start(Kernel::Module& module)
@@ -53,17 +53,13 @@
 static void run(Kernel::Module& module)
 {
   Echo::Flood::UDP::Service& service = static_cast<Echo::Flood::UDP::Service&>(module.getCore().getService("Echo::Flood::UDP"));
-  struct addrinfo *addrinfo = service.getaddrinfo("0.0.0.0", "0"); /* random port */
 
   for (int count = module.getOption("count").getIntValue();
        count != 0;
        --count)
   {
-    /* bind to random local port */
-    service.addSocket(addrinfo);
+    service.addSocketWithPeer();
   }
-
-  service.freeaddrinfo(addrinfo);
 }
 
 SCALESTACK_KERNEL_MODULE(options, start, stop, run, NULL);

=== modified file 'ScaleStack/Echo/Flood/UnixStream/UnixStream.cc'
--- ScaleStack/Echo/Flood/UnixStream/UnixStream.cc	2010-05-01 05:23:39 +0000
+++ ScaleStack/Echo/Flood/UnixStream/UnixStream.cc	2010-05-16 06:24:29 +0000
@@ -27,7 +27,8 @@
 static void options(Kernel::Module& module)
 {
   module.addOption("unix_socket", "Unix socket to connect to.", "SOCKET", "/tmp/echoserver.socket");
-  Echo::Flood::StreamOptions(module);
+  module.addOption("count", "Number of concurrent connections to open.", "COUNT", "1");
+  Echo::Flood::Stream::Options(module);
 }
 
 static void start(Kernel::Module& module)

=== modified file 'ScaleStack/Echo/Flood/plugin.ini'
--- ScaleStack/Echo/Flood/plugin.ini	2010-05-02 23:02:34 +0000
+++ ScaleStack/Echo/Flood/plugin.ini	2010-05-16 06:24:29 +0000
@@ -4,6 +4,6 @@
 version=0.1
 author=Eric Day <[e-mail]>
 license=BSD
-sources=Flood.cc Stream.cc Datagram.cc
-headers=Stream.h Datagram.h
+sources=Datagram.cc Flood.cc Stream.cc
+headers=Datagram.h Flood.h Stream.h
 dependencies=Network

=== modified file 'ScaleStack/Echo/Server/Datagram.cc'
--- ScaleStack/Echo/Server/Datagram.cc	2010-05-03 04:56:24 +0000
+++ ScaleStack/Echo/Server/Datagram.cc	2010-05-16 06:24:29 +0000
@@ -15,8 +15,6 @@
 
 #include "config.h"
 
-#include <string.h>
-#include <ScaleStack/Kernel/Module.h>
 #include <ScaleStack/Echo/Server/Datagram.h>
 
 namespace ScaleStack {
@@ -30,9 +28,7 @@
 Datagram::Datagram(Network::DatagramService& service):
   Network::Datagram(service),
   _size(),
-  _buffer(),
-  _sockaddr(),
-  _socklen(0)
+  _buffer()
 {
 }
 
@@ -40,13 +36,10 @@
 {
 }
 
-size_t Datagram::recv(uint8_t* buffer, size_t size, struct sockaddr *sockaddr, socklen_t socklen)
+size_t Datagram::receive(uint8_t* buffer, size_t size, struct sockaddr&, socklen_t)
 {
   _size = size;
   _buffer = buffer;
-  _sockaddr = sockaddr;
-  _socklen = socklen;
-
   return _echo();
 }
 
@@ -61,7 +54,7 @@
 
 size_t Datagram::_echo(void)
 {
-  return send(_buffer, _size, _sockaddr, _socklen);
+  return send(_buffer, _size);
 }
 
 } /* namespace Server */

=== modified file 'ScaleStack/Echo/Server/Datagram.h'
--- ScaleStack/Echo/Server/Datagram.h	2010-05-03 04:56:24 +0000
+++ ScaleStack/Echo/Server/Datagram.h	2010-05-16 06:24:29 +0000
@@ -32,9 +32,12 @@
   ~Datagram();
 
   /**
-   * See Network::Datagram::recv().
+   * See Network::Datagram::receive().
    */
-  size_t recv(uint8_t* buffer, size_t size, struct sockaddr *sockaddr, socklen_t socklen);
+  size_t receive(uint8_t* buffer,
+                 size_t size,
+                 struct sockaddr& peer,
+                 socklen_t peer_size);
 
   /**
    * See Network::Datagram::flushSend().
@@ -54,15 +57,14 @@
   Datagram& operator=(const Datagram&);
 
   /**
-   * Echo the data back to the stream by writing any data that was
-   * read. This is used by both the read() and flushWrite() methods.
+   * Echo the data received back to the sender. This is used by both the
+   * receive() and flushSend() methods.
    */
+  SCALESTACK_LOCAL
   size_t _echo(void);
 
   size_t _size;
   uint8_t* _buffer;
-  struct sockaddr* _sockaddr;
-  socklen_t _socklen;
 };
 
 } /* namespace Server */

=== modified file 'ScaleStack/Echo/Server/Stream.h'
--- ScaleStack/Echo/Server/Stream.h	2010-05-01 05:23:39 +0000
+++ ScaleStack/Echo/Server/Stream.h	2010-05-16 06:24:29 +0000
@@ -54,9 +54,10 @@
   Stream& operator=(const Stream&);
 
   /**
-   * Echo the data back to the stream by writing any data that was
-   * read. This is used by both the read() and flushWrite() methods.
+   * Echo the data read back to the client. This is used by both the read()
+   * and flushWrite() methods.
    */
+  SCALESTACK_LOCAL
   size_t _echo(void);
 
   size_t _size;

=== modified file 'ScaleStack/Echo/Server/TCP/TCP.cc'
--- ScaleStack/Echo/Server/TCP/TCP.cc	2010-04-29 07:39:49 +0000
+++ ScaleStack/Echo/Server/TCP/TCP.cc	2010-05-16 06:24:29 +0000
@@ -33,6 +33,16 @@
   try
   {
     module.getCore().addService("Echo::Server::TCP", service);
+
+    try
+    {
+      //service->addListeners();
+    }
+    catch (exception&)
+    {
+      module.getCore().removeService("Echo::Server::TCP");
+      throw;
+    }
   }
   catch (exception&)
   {

=== modified file 'ScaleStack/Echo/Server/UDP/Service.h'
--- ScaleStack/Echo/Server/UDP/Service.h	2010-05-02 23:02:34 +0000
+++ ScaleStack/Echo/Server/UDP/Service.h	2010-05-16 06:24:29 +0000
@@ -39,7 +39,7 @@
   /**
    * See Network::DatagramService::removeDatagram().
    */
-  void removeDatagram(Network::Datagram* stream);
+  void removeDatagram(Network::Datagram* datagram);
 
 private:
 

=== modified file 'ScaleStack/Echo/Server/UDP/Test/Run.cc'
--- ScaleStack/Echo/Server/UDP/Test/Run.cc	2010-05-04 01:00:14 +0000
+++ ScaleStack/Echo/Server/UDP/Test/Run.cc	2010-05-16 06:24:29 +0000
@@ -15,17 +15,32 @@
 
 #include <ScaleStack/Common/Test.h>
 
+static const char* test_hosts = "127.0.0.1:32123";
+
 TEST_SUITE_BEGIN
 
-TEST_BEGIN(TestEchoServer)
-  const char* test_port = "32123";
-  const char* test_host = "127.0.0.1";
-  const char* test_hostport = "127.0.0.1:32123";
-
-  core.addModuleOptionValue("Event::Service", "", TEST_EVENT_SERVICE);
-  core.addModuleOptionValue("Echo::Server::UDP", "udp_hosts", test_hostport);
-  core.addModuleOptionValue("Echo::Flood::UDP", "port", test_port);
-  core.addModuleOptionValue("Echo::Flood::UDP", "host", test_host);
+TEST_BEGIN(default)
+  core.addModuleOptionValue("Event::Service", "", TEST_EVENT_SERVICE);
+  core.addModuleOptionValue("Echo::Server::UDP", "hosts", test_hosts);
+  core.addModuleOptionValue("Echo::Flood::UDP", "hosts", test_hosts);
+  core.setSignalHandlers();
+  core.run();
+TEST_END
+
+TEST_BEGIN(iterations)
+  core.addModuleOptionValue("Event::Service", "", TEST_EVENT_SERVICE);
+  core.addModuleOptionValue("Echo::Server::UDP", "hosts", test_hosts);
+  core.addModuleOptionValue("Echo::Flood::UDP", "hosts", test_hosts);
+  core.addModuleOptionValue("Echo::Flood::UDP", "iterations", "5");
+  core.setSignalHandlers();
+  core.run();
+TEST_END
+
+TEST_BEGIN(packet_size)
+  core.addModuleOptionValue("Event::Service", "", TEST_EVENT_SERVICE);
+  core.addModuleOptionValue("Echo::Server::UDP", "hosts", test_hosts);
+  core.addModuleOptionValue("Echo::Flood::UDP", "hosts", test_hosts);
+  core.addModuleOptionValue("Echo::Flood::UDP", "packet_size", "16384");
   core.setSignalHandlers();
   core.run();
 TEST_END

=== modified file 'ScaleStack/Echo/Server/UDP/UDP.cc'
--- ScaleStack/Echo/Server/UDP/UDP.cc	2010-05-04 08:58:05 +0000
+++ ScaleStack/Echo/Server/UDP/UDP.cc	2010-05-16 06:24:29 +0000
@@ -25,7 +25,7 @@
 
 static void options(Kernel::Module& module)
 {
-  Network::IP::UDP::SocketOptions(module, "7");
+  Network::IP::UDP::SocketService::Options(module, ":7");
 }
 
 static void start(Kernel::Module& module)
@@ -37,7 +37,7 @@
 
     try
     {
-      service->processSocketOptions();
+      service->addSockets();
     }
     catch (exception&)
     {

=== modified file 'ScaleStack/Echo/Server/plugin.ini'
--- ScaleStack/Echo/Server/plugin.ini	2010-05-02 23:02:34 +0000
+++ ScaleStack/Echo/Server/plugin.ini	2010-05-16 06:24:29 +0000
@@ -4,6 +4,6 @@
 version=0.1
 author=Eric Day <[e-mail]>
 license=BSD
-sources=Server.cc Stream.cc Datagram.cc
-headers=Stream.h Datagram.h
+sources=Datagram.cc Server.cc Stream.cc
+headers=Datagram.h Stream.h
 dependencies=Network

=== modified file 'ScaleStack/Network/Datagram.cc'
--- ScaleStack/Network/Datagram.cc	2010-05-04 08:58:05 +0000
+++ ScaleStack/Network/Datagram.cc	2010-05-16 06:24:29 +0000
@@ -36,11 +36,11 @@
 DatagramProvider::DatagramProvider(Event::Service& service):
   Event::Handler(service),
   _file_descriptor(-1),
-  _peer_address_size(),
-  _recv_buffer_size(),
+  _peer_size(),
+  _receive_buffer_size(),
   _datagram(NULL),
-  _peer_address(reinterpret_cast<struct sockaddr*>(&_peer_address_storage)),
-  _peer_address_storage()
+  _peer(reinterpret_cast<struct sockaddr*>(&_peer_storage)),
+  _peer_storage()
 {
 }
 
@@ -63,51 +63,60 @@
     watchRead();
 }
 
-void DatagramProvider::consume(size_t size)
-{
-  _consume(size);
-}
-
-void DatagramProvider::bind(const struct addrinfo& address)
-{
-  int file_descriptor = socket(address.ai_family,
-                               address.ai_socktype,
-                               address.ai_protocol);
+void DatagramProvider::create(int family)
+{
+  int file_descriptor = socket(family, SOCK_DGRAM, 0);
   if (file_descriptor == -1)
     _module.logFatal("Error creating datagram socket: %d", errno);
 
-  int return_code = ::bind(file_descriptor,
-                           address.ai_addr,
-                           address.ai_addrlen);
+  setFileDescriptor(file_descriptor);
+}
+
+void DatagramProvider::bind(const struct sockaddr& address,
+                            socklen_t address_size)
+{
+  create(address.sa_family);
+
+  int return_code = ::bind(_file_descriptor, &address, address_size);
   if (return_code == -1)
   {
-    close(file_descriptor);
-
     if (errno == EADDRINUSE)
       _module.logFatal("Bind failed, address already in use");
 
     _module.logFatal("Error binding datagram socket, bind: %d", errno);
   }
-
-  setFileDescriptor(file_descriptor);
+}
+
+void DatagramProvider::setPeer(const struct sockaddr& peer, socklen_t peer_size)
+{
+  memcpy(_peer, &peer, peer_size);
+  _peer_size = peer_size;
+}
+
+void DatagramProvider::consume(size_t size)
+{
+  _consume(size);
 }
 
 size_t DatagramProvider::send(uint8_t* buffer,
                               size_t size,
-                              const sockaddr* peer_address,
-                              socklen_t peer_address_size)
+                              const struct sockaddr& peer,
+                              socklen_t peer_size)
 {
   if (size == 0)
     return 0;
 
-  ssize_t written = ::sendto(_file_descriptor, buffer, size, 0,
-                             peer_address, peer_address_size);
-
+  ssize_t written = ::sendto(_file_descriptor,
+                             buffer,
+                             size,
+                             0,
+                             &peer,
+                             peer_size);
   if (written > 0)
   {
     if (written != static_cast<ssize_t>(size))
     {
-      _module.logFatal("Datagram sendto() returned %d, but tried to send %d",
+      _module.logError("Datagram sendto() returned %d, but tried to send %d",
                        written, size);
       error();
       return 0;
@@ -121,9 +130,7 @@
   }
 
   if (written == 0)
-  {
     return 0;
-  }
 
   if (errno == EAGAIN)
   {
@@ -134,7 +141,15 @@
   _module.logError("Datagram sendto() returned %d", errno);
   error();
   return 0;
-}  
+}
+
+size_t DatagramProvider::send(uint8_t* buffer, size_t size)
+{
+  if (_peer_size == 0)
+    _module.logFatal("No peer address was set.");
+
+  return send(buffer, size, *_peer, _peer_size);
+}
 
 void DatagramProvider::run(void)
 {
@@ -143,36 +158,36 @@
 
 void DatagramProvider::readReady(int)
 {
-  if (_recv_buffer_size > 0)
+  if (_receive_buffer_size > 0)
   {
-    /* Can only buffer a single packet, and we alrecvy have one */
+    /* Can only buffer a single packet, and we already have one */
     return;
   }
 
-  _peer_address_size = sizeof(_peer_address_storage);
+  _peer_size = sizeof(_peer_storage);
 
   ssize_t return_size = ::recvfrom(_file_descriptor,
-                                   _recv_buffer, _recv_buffer_max_size, 0,
-                                   _peer_address, &_peer_address_size);
+                                   _receive_buffer, _receive_buffer_max_size, 0,
+                                   _peer, &_peer_size);
 
   if (return_size > 0)
   {
     _module.logDebug("Recved %d bytes", return_size);
 
-    _recv_buffer_size = static_cast<size_t>(return_size);
-
-    _consume(recv(_recv_buffer, _recv_buffer_size, _peer_address, _peer_address_size));
-
-    if (_recv_buffer_size == 0)
+    _receive_buffer_size = static_cast<size_t>(return_size);
+
+    _consume(receive(_receive_buffer, _receive_buffer_size, *_peer, _peer_size));
+
+    if (_receive_buffer_size == 0)
     {
       return;
     }
 
-    if (_recv_buffer_size != static_cast<size_t>(return_size))
+    if (_receive_buffer_size != static_cast<size_t>(return_size))
     {
-      /* caller must consume all or none of the recv buffer */
+      /* caller must consume all or none of the receive buffer */
 
-      _module.logFatal("Caller consumed partial datagram recv buffer");
+      _module.logFatal("Caller consumed partial datagram receive buffer");
       return;
     }
 
@@ -212,16 +227,19 @@
   if (size == 0)
     return;
 
-  if (size != _recv_buffer_size)
+  if (size > _receive_buffer_size)
   {
-    _module.logFatal("Tried to consume incorrect size on recv buffer for datagram socket");
+    _module.logError("Consumed more data than is in buffer: %u > %u",
+                     size, _receive_buffer_size);
     error();
-    return;
-  }
-
-  _recv_buffer_size = 0;
-
-  watchRead();
+  }
+  else if (size == _receive_buffer_size)
+  {
+    _receive_buffer_size = 0;
+    watchRead();
+  }
+  else
+    _receive_buffer_size -= size;
 }
 
 } /* namespace Network */

=== modified file 'ScaleStack/Network/Datagram.h'
--- ScaleStack/Network/Datagram.h	2010-05-04 08:58:05 +0000
+++ ScaleStack/Network/Datagram.h	2010-05-16 06:24:29 +0000
@@ -24,8 +24,6 @@
 #include <ScaleStack/Event/Handler.h>
 #include <ScaleStack/Network/DatagramService.h>
 
-struct addrinfo;
-
 namespace ScaleStack {
 namespace Kernel {
 
@@ -62,20 +60,20 @@
    *
    * @param[in] buffer Data that was read.
    * @param[in] size Size of data available in buffer.
-   * @param[in] peer_address Socket address received from.
-   * @param[in] peer_address_size Socket address length.
+   * @param[in] peer Socket address the packet was received from.
+   * @param[in] peer_size Socket address length.
    * @return Amount of data that was consumed.
    */
-  virtual size_t recv(uint8_t* buffer,
-                      size_t size,
-                      struct sockaddr* peer_address,
-                      socklen_t peer_address_size) = 0;
+  virtual size_t receive(uint8_t* buffer,
+                         size_t size,
+                         struct sockaddr& peer,
+                         socklen_t peer_size) = 0;
 
   /**
-   * Notify the connection that the recv buffer has been consumed.
-   * This is required after a recv() call was not able to consume
+   * Notify the connection that the receive buffer has been consumed.
+   * This is required after a receive() call was not able to consume
    * all the data. This can be called at a later time to remove the data
-   * from the read buffer, such as in flushSend(). After the recv buffer
+   * from the read buffer, such as in flushSend(). After the receive buffer
    * has been flushed, the connection will start watching for new data.
    *
    * @param[in] size The amount of data to consume.
@@ -88,14 +86,24 @@
    *
    * @param[in] buffer Buffer to write.
    * @param[in] size Size of buffer.
-   * @param[in] peer_address Socket address to send to.
-   * @param[in] peer_address_size Socket address length.
+   * @param[in] peer Socket address to send to.
+   * @param[in] peer_size Socket address length.
    * @return Amount of data sent.
    */
   size_t send(uint8_t* buffer,
               size_t size,
-              const struct sockaddr* peer_address,
-              socklen_t peer_address_size);
+              const struct sockaddr& peer,
+              socklen_t peer_size);
+
+  /**
+   * Same as send(), but use the default peer address this datagram was
+   * created with.
+   *
+   * @param[in] buffer Buffer to write.
+   * @param[in] size Size of buffer.
+   * @return Amount of data sent.
+   */
+  size_t send(uint8_t* buffer, size_t size);
 
   /**
    * This is called to notify derived classes that they should trying sending
@@ -192,37 +200,56 @@
   virtual void setFileDescriptor(int file_descriptor);
 
   /**
+   * Create the socket using a random local address.
+   */
+  void create(int family);
+
+  /**
+   * Create the socket and bind to a specific local address.
+   *
+   * @param[in] address Address to bind to.
+   * @param[in] address_size Size of the address structure.
+   */
+  void bind(const struct sockaddr& address, socklen_t address_size);
+
+  /**
+   * Set the initial peer address for sending packets.
+   *
+   * @param[in] peer Peer address to set.
+   * @param[in] peer_size Size of peer address structure.
+   */
+  void setPeer(const struct sockaddr& peer, socklen_t peer_size);
+
+  /**
    * See Datagram::ready().
    */
   void ready(void);
 
   /**
-   * See Datagram::recv().
-   */
-  size_t recv(uint8_t* buffer,
-              size_t size,
-              struct sockaddr *peer_address,
-              socklen_t peer_address_size);
-
-  /**
-   * Create and bind a datagram socket.
-   *
-   * @param[in] address Address to bind.
-   */
-  void bind(const struct addrinfo& addrinfo);
+   * See Datagram::receive().
+   */
+  size_t receive(uint8_t* buffer,
+                 size_t size,
+                 struct sockaddr& peer,
+                 socklen_t peer_size);
 
   /**
    * See Datagram::consume().
    */
-  virtual void consume(size_t size);
-
-  /**
-   * See Datagram::send().
-   */
-  virtual size_t send(uint8_t* buffer,
-                      size_t size,
-                      const struct sockaddr* peer_address,
-                      socklen_t peer_address_size);
+  void consume(size_t size);
+
+  /**
+   * See Datagram::send().
+   */
+  size_t send(uint8_t* buffer,
+              size_t size,
+              const struct sockaddr& peer,
+              socklen_t peer_size);
+
+  /**
+   * See Datagram::send().
+   */
+  size_t send(uint8_t* buffer, size_t size);
 
   /**
    * See Datagram::flushSend().
@@ -263,8 +290,8 @@
   DatagramProvider& operator=(const DatagramProvider&);
 
   /**
-   * This will recv data from the connection into the buffer and call
-   * recv(). This implements a method in the base class so does not have
+   * This will receive data from the connection into the buffer and call
+   * receive(). This implements a method in the base class so does not have
    * the _ prefix.
    *
    * @param[in] file_descriptor File descriptor to read data on.
@@ -280,23 +307,23 @@
   void writeReady(int file_descriptor);
 
   /**
-   * Perform the recv buffer consumption, used by both readReady() and
-   * consume().
+   * Perform the receive buffer consumption, used by both readReady()
+   * and consume().
    *
    * @param[in] size Amount of buffer to consume.
    */
   SCALESTACK_LOCAL
   void _consume(size_t size);
 
-  static const size_t _recv_buffer_max_size = 64 * 1024; /* max Datagram size */
+  static const size_t _receive_buffer_max_size = 64 * 1024; /* max datagram size */
 
   int _file_descriptor;
-  socklen_t _peer_address_size;
-  size_t _recv_buffer_size;
+  socklen_t _peer_size;
+  size_t _receive_buffer_size;
   Datagram* _datagram;
-  struct sockaddr* _peer_address;
-  struct sockaddr_storage _peer_address_storage;
-  uint8_t _recv_buffer[_recv_buffer_max_size];
+  struct sockaddr* _peer;
+  struct sockaddr_storage _peer_storage;
+  uint8_t _receive_buffer[_receive_buffer_max_size];
 };
 
 /*
@@ -325,10 +352,15 @@
 
 inline size_t Datagram::send(uint8_t* buffer,
                              size_t size,
-                             const struct sockaddr* peer_address,
-                             socklen_t peer_address_size)
-{
-  return _datagram_provider->send(buffer, size, peer_address, peer_address_size);
+                             const struct sockaddr& peer,
+                             socklen_t peer_size)
+{
+  return _datagram_provider->send(buffer, size, peer, peer_size);
+}
+
+inline size_t Datagram::send(uint8_t* buffer, size_t size)
+{
+  return _datagram_provider->send(buffer, size);
 }
 
 inline void Datagram::remove(void)
@@ -379,12 +411,12 @@
   _datagram->ready();
 }
 
-inline size_t DatagramProvider::recv(uint8_t* buffer,
-                                     size_t size,
-                                     struct sockaddr* peer_address,
-                                     socklen_t peer_address_size)
+inline size_t DatagramProvider::receive(uint8_t* buffer,
+                                        size_t size,
+                                        struct sockaddr& peer,
+                                        socklen_t peer_size)
 {
-  return _datagram->recv(buffer, size, peer_address, peer_address_size);
+  return _datagram->receive(buffer, size, peer, peer_size);
 }
 
 inline void DatagramProvider::flushSend(void)

=== modified file 'ScaleStack/Network/IP/Common.cc'
--- ScaleStack/Network/IP/Common.cc	2010-05-04 08:58:05 +0000
+++ ScaleStack/Network/IP/Common.cc	2010-05-16 06:24:29 +0000
@@ -15,13 +15,10 @@
 
 #include "config.h"
 
-#include <vector>
-#include <cerrno>
-#include <cstring>
-#include <sys/types.h> /* Must be before socket headers for FreeBSD. */
+#include <exception>
+#include <netdb.h>
 #include <sys/socket.h>
-#include <netdb.h>
-#include <unistd.h>
+#include <sys/types.h>
 
 #include <ScaleStack/Kernel/Module.h>
 #include <ScaleStack/Network/IP/Common.h>
@@ -44,49 +41,39 @@
 {
 }
 
-void Common::processHostsandPorts(vector<pair<string,string>> hosts,
-                                  vector<string> ports,
-                                  const struct addrinfo* addrinfo_options)
+void Common::parseHosts(Kernel::Module& module,
+                        const std::vector<std::pair<std::string,std::string> >& hosts,
+                        const struct addrinfo& address_options,
+                        bool local_only)
 {
-  for (vector<pair<string,string> >::iterator host = hosts.begin();
+  for (vector<pair<string,string> >::const_iterator host = hosts.begin();
        host != hosts.end();
        ++host)
   {
-    if (host->second == "")
-    {
-      for (vector<string>::iterator port = ports.begin();
-           port != ports.end();
-           ++port)
-      {
-        _processAddrinfo(host->first, *port, addrinfo_options);
-      }
-    }
-    else
-      _processAddrinfo(host->first, host->second, addrinfo_options);
-  }
-}
-
-/*
- * Private methods.
- */
-
-void Common::_processAddrinfo(string host, string port,
-                              const struct addrinfo* addrinfo_options)
-{
-  struct addrinfo* addrinfo;
-
-  int return_code = ::getaddrinfo(host == "" ? NULL : host.c_str(),
-                                  port.c_str(),
-                                  addrinfo_options,
-                                  &addrinfo);
-  if (return_code != 0)
-  {
-    ScaleStack::Common::Exception("Error doing getaddrinfo: %s", gai_strerror(return_code));
-  }
-
-  processAddrinfo(addrinfo);
-
-  freeaddrinfo(addrinfo);
+    struct addrinfo* address_list;
+
+    int return_code = ::getaddrinfo(host->first == "" ? NULL : host->first.c_str(),
+                                    host->second == "" ? NULL : host->second.c_str(),
+                                    &address_options,
+                                    &address_list);
+    if (return_code != 0)
+      module.logFatal("Failed getaddrinfo: %s", gai_strerror(return_code));
+
+    try
+    {
+      if (local_only)
+        addAddressList(address_list, NULL);
+      else
+        addAddressList(NULL, address_list);
+    }
+    catch (exception&)
+    {
+      freeaddrinfo(address_list);
+      throw;
+    }
+
+    freeaddrinfo(address_list);
+  }
 }
 
 } /* namespace IP */

=== modified file 'ScaleStack/Network/IP/Common.h'
--- ScaleStack/Network/IP/Common.h	2010-05-04 08:58:05 +0000
+++ ScaleStack/Network/IP/Common.h	2010-05-16 06:24:29 +0000
@@ -16,24 +16,23 @@
 #ifndef SCALESTACK_NETWORK_IP_COMMON_H
 #define SCALESTACK_NETWORK_IP_COMMON_H
 
+#include <string>
 #include <vector>
-#include <stdint.h>
-#include <string>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netdb.h>
 
 #include <ScaleStack/Common/Macros.h>
 #include <ScaleStack/Event/Handler.h>
 
+struct addrinfo;
+
 namespace ScaleStack {
 namespace Network {
+
+class Module;
+
+} /* namespace Module */
+namespace Network {
 namespace IP {
 
-/**
- * Public functions
- */
-
 class SCALESTACK_API Common
 {
 public:
@@ -42,11 +41,13 @@
 
   virtual ~Common();
 
-  void processHostsandPorts(std::vector<std::pair<std::string,std::string>> hosts,
-                            std::vector<std::string> ports,
-                            const struct addrinfo* addrinfo_options);
+  void parseHosts(Kernel::Module& module,
+                  const std::vector<std::pair<std::string,std::string> >& hosts,
+                  const struct addrinfo& address_options,
+                  bool local_only);
 
-  virtual void processAddrinfo(struct addrinfo* addrinfo);
+  virtual void addAddressList(const struct addrinfo* local,
+                              const struct addrinfo* peer);
 
 private:
 
@@ -61,17 +62,13 @@
    */
   SCALESTACK_LOCAL
   Common& operator=(const Common&);
-
-  /**
-   * Add a struct addrinfo* for a host:port to addrinfos vector
-   */
-  SCALESTACK_LOCAL
-  void _processAddrinfo(std::string host, std::string port,
-                        const struct addrinfo* addrinfo_options);
-
 };
 
-inline void Common::processAddrinfo(struct addrinfo*)
+/*
+ * Public methods.
+ */
+
+inline void Common::addAddressList(const struct addrinfo*, const struct addrinfo*)
 {
 }
 

=== modified file 'ScaleStack/Network/IP/TCP/ConnectionService.cc'
--- ScaleStack/Network/IP/TCP/ConnectionService.cc	2010-05-04 08:58:05 +0000
+++ ScaleStack/Network/IP/TCP/ConnectionService.cc	2010-05-16 06:24:29 +0000
@@ -42,14 +42,14 @@
 }
 
 Network::Stream* ConnectionService::addAccepted(int file_descriptor,
-                                                struct sockaddr& peer_address,
-                                                socklen_t)
+                                                struct sockaddr& peer,
+                                                socklen_t peer_size)
 {
   char host_name[NI_MAXHOST];
   char port_name[NI_MAXSERV];
 
-  int return_code = getnameinfo(&peer_address,
-                                sizeof(struct sockaddr),
+  int return_code = getnameinfo(&peer,
+                                peer_size,
                                 host_name, NI_MAXHOST,
                                 port_name, NI_MAXSERV,
                                 NI_NUMERICHOST | NI_NUMERICSERV);
@@ -70,7 +70,7 @@
 }
 
 Network::Stream* ConnectionService::addConnect(const std::string& host,
-                                   const std::string& port)
+                                               const std::string& port)
 {
   Connection* connection;
   Network::Stream* stream = _addConnection(&connection);

=== modified file 'ScaleStack/Network/IP/TCP/ConnectionService.h'
--- ScaleStack/Network/IP/TCP/ConnectionService.h	2010-05-03 08:30:52 +0000
+++ ScaleStack/Network/IP/TCP/ConnectionService.h	2010-05-16 06:24:29 +0000
@@ -41,8 +41,8 @@
    * See StreamService::addAccepted().
    */
   Network::Stream* addAccepted(int file_descriptor,
-                               struct sockaddr& peer_address,
-                               socklen_t peer_address_size);
+                               struct sockaddr& peer,
+                               socklen_t peer_size);
 
   /**
    * Add a new connection and connect to the given host:port.

=== modified file 'ScaleStack/Network/IP/UDP/Socket.cc'
--- ScaleStack/Network/IP/UDP/Socket.cc	2010-05-03 00:23:08 +0000
+++ ScaleStack/Network/IP/UDP/Socket.cc	2010-05-16 06:24:29 +0000
@@ -15,15 +15,6 @@
 
 #include "config.h"
 
-#include <cerrno>
-#include <cstring>
-#include <sys/types.h> /* Must be before socket headers for FreeBSD. */
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <sys/socket.h>
-#include <unistd.h>
-
-#include <ScaleStack/Kernel/Module.h>
 #include <ScaleStack/Network/IP/UDP/Socket.h>
 #include <ScaleStack/Network/IP/UDP/SocketService.h>
 
@@ -49,7 +40,7 @@
 
 void Socket::setFileDescriptor(int file_descriptor)
 {
-  /* any setsockopts go here */
+  /* Any setsockopts go here. */
 
   Network::DatagramProvider::setFileDescriptor(file_descriptor);
 }

=== modified file 'ScaleStack/Network/IP/UDP/SocketService.cc'
--- ScaleStack/Network/IP/UDP/SocketService.cc	2010-05-04 08:58:05 +0000
+++ ScaleStack/Network/IP/UDP/SocketService.cc	2010-05-16 06:24:29 +0000
@@ -30,26 +30,18 @@
 namespace IP {
 namespace UDP {
 
-#define UDP_OPTION_HOSTS_NONE ":NONE"
-#define UDP_OPTION_PORTS_NONE ":NONE"
-
-/*
- * Public Functions.
- */
-
-void SocketOptions(Kernel::Module& module, const char* port)
-{
-  module.addOption("udp_hosts", "List of host/port pairs to bind.",
-                   "HOST[:PORT][,HOST[:PORT]]...",
-                   UDP_OPTION_HOSTS_NONE);
-  module.addOption("udp_ports", "List of ports to bind.", "PORT[,PORT]...",
-                   port);
-}
-
 /*
  * Public methods.
  */
 
+void SocketService::Options(Kernel::Module& module, const char* hosts)
+{
+  module.addOption("hosts",
+                   "List of host/port pairs.",
+                   "[HOST][:PORT][,[HOST][:PORT]]...",
+                   hosts);
+}
+
 SocketService::SocketService(Kernel::Module& module):
   DatagramService(module)
 {
@@ -59,106 +51,81 @@
 {
 }
 
-struct addrinfo* SocketService::getaddrinfo(string host, string port)
-{
-  struct addrinfo *addrinfo_list;
-  struct addrinfo addrinfo_options;
-
-  memset(&addrinfo_options, 0, sizeof(struct addrinfo));
-  addrinfo_options.ai_flags  = AI_PASSIVE;
-  addrinfo_options.ai_family = AF_UNSPEC;
-  addrinfo_options.ai_socktype = SOCK_DGRAM;
-  addrinfo_options.ai_protocol = IPPROTO_UDP;
-
-  int return_code = ::getaddrinfo(host == "" ? NULL : host.c_str(),
-                                port.c_str(),
-                                &addrinfo_options,
-                                &addrinfo_list);
-  if (return_code != 0)
-  {
-    _module.logFatal("Couldn't getaddrinfo for %s:%s", host.c_str(), port.c_str());
-  }
-
-  return addrinfo_list;
-}
-
-void SocketService::freeaddrinfo(struct addrinfo *addrinfo)
-{
-  ::freeaddrinfo(addrinfo);
-}
-
-void SocketService::addSocket(struct addrinfo *addrinfo)
-{
-  /* We only require one host:port pair from the list to succeed. */
-  bool added = false;
-  for (; addrinfo != NULL; addrinfo = addrinfo->ai_next)
-  {
-    try
-    {
-      _addSocket(addrinfo);
-      added = true;
-    }
-    catch (exception&)
-    {
-    }
-  }
-
-  if (!added)
-  {
-    _module.logFatal("Could not add any UDP sockets");
-  }
-}
-
-void SocketService::processSocketOptions(void)
-{
-  Kernel::Option& hosts_opt = _module.getOption("udp_hosts");
-  Kernel::Option& ports_opt = _module.getOption("udp_ports");
-  vector<pair<string,string> > hosts_list;
-  vector<string> ports_list;
-
-  if (strcmp(hosts_opt.getValue().c_str(), UDP_OPTION_HOSTS_NONE))
-    hosts_list = hosts_opt.getHostListValue();
-
-  if (strcmp(ports_opt.getValue().c_str(), UDP_OPTION_PORTS_NONE))
-    ports_list = ports_opt.getListValue();
-
-  struct addrinfo addrinfo_options;
-
-  memset(&addrinfo_options, 0, sizeof(struct addrinfo));
-  addrinfo_options.ai_flags  = AI_PASSIVE;
-  addrinfo_options.ai_family = AF_UNSPEC;
-  addrinfo_options.ai_socktype = SOCK_DGRAM;
-  addrinfo_options.ai_protocol = IPPROTO_UDP;
-
-  processHostsandPorts(hosts_list, ports_list, &addrinfo_options);
+void SocketService::addSockets(void)
+{
+  struct addrinfo address_options;
+
+  memset(&address_options, 0, sizeof(struct addrinfo));
+  address_options.ai_flags  = AI_PASSIVE;
+  address_options.ai_family = AF_UNSPEC;
+  address_options.ai_socktype = SOCK_DGRAM;
+  address_options.ai_protocol = IPPROTO_UDP;
+
+  parseHosts(_module,
+             _module.getOption("hosts").getHostListValue(),
+             address_options,
+             true);
+}
+
+void SocketService::addSocketWithPeer(void)
+{
+  struct addrinfo address_options;
+
+  memset(&address_options, 0, sizeof(struct addrinfo));
+  address_options.ai_flags  = AI_PASSIVE;
+  address_options.ai_family = AF_UNSPEC;
+  address_options.ai_socktype = SOCK_DGRAM;
+  address_options.ai_protocol = IPPROTO_UDP;
+
+  parseHosts(_module,
+             _module.getOption("hosts").getHostListValue(),
+             address_options,
+             false);
 }
 
 /*
  * Private methods.
  */
 
-Network::Datagram* SocketService::_addSocket(struct addrinfo *addrinfo)
+void SocketService::removeHandler(Event::Handler* handler)
+{
+  removeDatagram(reinterpret_cast<Socket*>(handler)->getDatagram());
+  delete handler;
+}
+
+Network::Datagram* SocketService::_addSocket(const struct addrinfo *local,
+                                             const struct addrinfo *peer)
 {
   Network::Datagram* datagram = NULL;
   Socket* socket = NULL;
-
   char host_name[NI_MAXHOST];
   char port_name[NI_MAXSERV];
   int return_code;
 
-  return_code = getnameinfo(addrinfo->ai_addr,
-                            addrinfo->ai_addrlen,
-                            host_name, NI_MAXHOST,
-                            port_name, NI_MAXSERV,
-                            NI_NUMERICHOST | NI_NUMERICSERV);
+  if (local != NULL)
+  {
+    return_code = getnameinfo(local->ai_addr,
+                              local->ai_addrlen,
+                              host_name, NI_MAXHOST,
+                              port_name, NI_MAXSERV,
+                              NI_NUMERICHOST | NI_NUMERICSERV);
+    if (return_code == 0)
+      _module.logInfo("UDP socket bound to %s:%s", host_name, port_name);
+    else
+      _module.logInfo("Failed getnameinfo: %s", gai_strerror(return_code));
+  }
 
-  if (return_code == 0)
-  {
-    _module.logInfo("Adding UDP socket bound to %s:%s", host_name, port_name);
-  }
-  else
-  {
-    _module.logInfo("Adding UDP socket bound to <unknown>");
+  if (peer != NULL)
+  {
+    return_code = getnameinfo(peer->ai_addr,
+                              peer->ai_addrlen,
+                              host_name, NI_MAXHOST,
+                              port_name, NI_MAXSERV,
+                              NI_NUMERICHOST | NI_NUMERICSERV);
+    if (return_code == 0)
+      _module.logInfo("UDP socket with peer %s:%s", host_name, port_name);
+    else
+      _module.logInfo("Failed getnameinfo: %s", gai_strerror(return_code));
   }
 
   try
@@ -176,21 +143,44 @@
     throw;
   }
 
-  socket->bind(*addrinfo);
+  if (local == NULL)
+  {
+    socket->create(peer->ai_family);
+    socket->setPeer(*(peer->ai_addr), peer->ai_addrlen);
+  }
+  else
+    socket->bind(*(local->ai_addr), local->ai_addrlen);
+
   socket->ready();
 
   return datagram;
 }
 
-void SocketService::removeHandler(Event::Handler* handler)
-{
-  removeDatagram(reinterpret_cast<Socket*>(handler)->getDatagram());
-  delete handler;
-}
-
-void SocketService::processAddrinfo(struct addrinfo *addrinfo)
-{
-  addSocket(addrinfo);
+void SocketService::addAddressList(const struct addrinfo* local,
+                                   const struct addrinfo* peer)
+{
+  if (local == NULL)
+  {
+    _addSocket(NULL, peer);
+    return;
+  }
+
+  /* We only require one local address from the list to succeed. */
+  bool added = false;
+  for (; local != NULL; local = local->ai_next)
+  {
+    try
+    {
+      _addSocket(local, peer);
+      added = true;
+    }
+    catch (exception&)
+    {
+    }
+  }
+
+  if (!added)
+    _module.logFatal("Could not add any UDP sockets");
 }
 
 } /* namespace UDP */

=== modified file 'ScaleStack/Network/IP/UDP/SocketService.h'
--- ScaleStack/Network/IP/UDP/SocketService.h	2010-05-04 01:00:14 +0000
+++ ScaleStack/Network/IP/UDP/SocketService.h	2010-05-16 06:24:29 +0000
@@ -34,58 +34,33 @@
 
 class Socket;
 
-
-/**
- * Add common options for binding UDP sockets.
- *
- * @param[in] module Module that the service is associated with.
- * @param[in] port Default port to use.
- */
-SCALESTACK_API
-void SocketOptions(Kernel::Module& module, const char* port);
-
-
 class SCALESTACK_API SocketService: public DatagramService, public Common
 {
 public:
 
+  /**
+   * Add common options for binding UDP sockets.
+   *
+   * @param[in] module Module that the service is associated with.
+   * @param[in] hosts Default hosts to use.
+   */
+  static void Options(Kernel::Module& module, const char* hosts);
+
   SocketService(Kernel::Module& module);
 
   virtual ~SocketService();
 
   /**
-   * Free the addrinfos vector
-   * @param[in] addrinfos The vector to free.
-   */
-  void freeaddrinfos(std::vector<struct addrinfo*> addrinfos);
-
-  /**
-   * Return a struct addrinfo* from a single host and port
-   *
-   * @param[in] host Host part of the address
-   * @param[in] port Port part of the address
-   * @return The full address
-   */
-  struct addrinfo* getaddrinfo(std::string host, std::string port);
-
-  /**
-   * Free a struct addrinfo*
-   */
-  void freeaddrinfo(struct addrinfo* addrinfo);
-
-  /**
-   * Create a new UDP socket and bind it.
-   *
-   * @param[in] addrinfos A list of addresses to try to to bind
-   * @param[in] watch_write True if we need to write data immediately
-   */
-  void addSocket(struct addrinfo *addrinfo);
-
-  /**
-   * Process the socket options previously added via
-   * 'SocketService::SocketOptions'
-   */
-  void processSocketOptions(void);
+   * Add sockets specified by the 'hosts' variable in the module options
+   * and bind to those addresses.
+   */
+  void addSockets(void);
+
+  /**
+   * Add sockets specified by the 'hosts' variable in the module options
+   * and use those addresses as peers.
+   */
+  void addSocketWithPeer(void);
 
 private:
 
@@ -102,25 +77,24 @@
   SocketService& operator=(const SocketService&);
 
   /**
-   * Create a new UDP socket and bind to the given address.
-   *
-   * @param[in] addrinfo Address to bind.
-   */
-  SCALESTACK_LOCAL
-  Network::Datagram* _addSocket(struct addrinfo *addrinfo);
-
-  /**
    * See Event::Service::removeHandler().
    */
   void removeHandler(Event::Handler* handler);
 
   /**
-   * See Network::IP::Common::processAddrinfo()
-   * This implements a method from a base class, so it has no leading
-   * underscore.
+   * Create a new UDP socket and bind to the given address.
+   *
+   * @param[in] local Local address to bind to.
+   * @param[in] peer Default peer address to send to.
    */
-  void processAddrinfo(struct addrinfo* addrinfo);
+  SCALESTACK_LOCAL
+  Network::Datagram* _addSocket(const struct addrinfo *local,
+                                const struct addrinfo *peer);
 
+  /**
+   * See Network::IP::Common::addAddressList().
+   */
+  void addAddressList(const struct addrinfo* local, const struct addrinfo* peer);
 };
 
 } /* namespace UDP */

=== modified file 'ScaleStack/Network/StreamService.h'
--- ScaleStack/Network/StreamService.h	2010-05-03 08:30:52 +0000
+++ ScaleStack/Network/StreamService.h	2010-05-16 06:24:29 +0000
@@ -53,13 +53,13 @@
    * Add a new stream that has been accepted.
    *
    * @param[in] file_descriptor File descriptor for the new stream.
-   * @param[in] peer_address Address information for the remote peer.
-   * @param[in] peer_address_size Size of peer_address structure.
+   * @param[in] peer Address information for the remote peer.
+   * @param[in] peer_size Size of peer structure.
    * @return Stream that was added.
    */
   virtual Network::Stream* addAccepted(int file_descriptor,
-                                       struct sockaddr& peer_address,
-                                       socklen_t peer_address_size) = 0;
+                                       struct sockaddr& peer,
+                                       socklen_t peer_size) = 0;
 
 private:
 

=== modified file 'ScaleStack/Network/Unix/Stream/Connection.h'
--- ScaleStack/Network/Unix/Stream/Connection.h	2010-04-30 03:54:30 +0000
+++ ScaleStack/Network/Unix/Stream/Connection.h	2010-05-16 06:24:29 +0000
@@ -61,8 +61,7 @@
   /**
    * Connect to a remote host.
    *
-   * @param[in] host Host to connect to.
-   * @param[in] port Port to connect to.
+   * @param[in] socket_name Socket to connect to.
    */
   void connect(const std::string& socket_name);
 

=== modified file 'ScaleStack/Network/Unix/Stream/ConnectionService.h'
--- ScaleStack/Network/Unix/Stream/ConnectionService.h	2010-05-03 08:30:52 +0000
+++ ScaleStack/Network/Unix/Stream/ConnectionService.h	2010-05-16 06:24:29 +0000
@@ -41,8 +41,8 @@
    * See StreamService::addAccepted().
    */
   Network::Stream* addAccepted(int file_descriptor,
-                               struct sockaddr& peer_address,
-                               socklen_t peer_address_size);
+                               struct sockaddr& peer,
+                               socklen_t peer_size);
 
   /**
    * Add a new connection and connect to the given Unix Domain Socket.

=== modified file 'ScaleStack/Network/Unix/Stream/Listener.h'
--- ScaleStack/Network/Unix/Stream/Listener.h	2010-04-30 00:03:45 +0000
+++ ScaleStack/Network/Unix/Stream/Listener.h	2010-05-16 06:24:29 +0000
@@ -40,7 +40,7 @@
    * @param[in] service Service this Listener is associated with.
    * @param[in] connection_service Service this Listener should add
    *  connections to when accepted.
-   * @param[in] addrinfo Address information to use for socket.
+   * @param[in] unix_socket Address information to use for socket.
    */
   Listener(ListenerService& service,
            ConnectionService& connection_service,