Revamping for listeners.

Split rs_connection into rs_baseconn plus rs_connection and rs_listener.

Connections now has a state variable.

Connect buffer event and fd of _source_ connection, not that of
conn->active_peer. The connection object referred to by a peer is not
meant for using as a connection, only for reporting errors on.

Make sure things are sane even when not using a config file.

Bump library interface version to 1.0.0 since it's changed.

1 files changed, 70 insertions, 28 deletions

diff --git a/lib/peer.c b/lib/peer.c
index 3e0069b..b6ec167 100644
--- a/lib/peer.c
+++ b/lib/peer.c
@@ -1,5 +1,5 @@
 /* Copyright 2010,2011,2013 NORDUnet A/S. All rights reserved.
-   See LICENSE for licensing information.  */
+   See LICENSE for licensing information. */
 
 #if defined HAVE_CONFIG_H
 #include <config.h>
@@ -20,12 +20,12 @@ peer_pick_peer (struct rs_connection *conn)
 {
   assert (conn);
 
-  if (conn->active_peer)
-    conn->active_peer = conn->active_peer->next; /* Next.  */
-  if (!conn->active_peer)
-    conn->active_peer = conn->base_.peers; /* From the top.  */
+  if (conn->base_.active_peer)
+    conn->base_.active_peer = conn->base_.active_peer->next; /* Next.  */
+  if (!conn->base_.active_peer)
+    conn->base_.active_peer = conn->base_.peers; /* From the top.  */
 
-  return conn->active_peer;
+  return conn->base_.active_peer;
 }
 
 struct rs_peer *
@@ -33,10 +33,9 @@ peer_create (struct rs_context *ctx, struct rs_peer **rootp)
 {
   struct rs_peer *p;
 
-  p = (struct rs_peer *) rs_malloc (ctx, sizeof(*p));
+  p = (struct rs_peer *) rs_calloc (ctx, 1, sizeof(*p));
   if (p)
     {
-      memset (p, 0, sizeof(struct rs_peer));
       if (*rootp)
 	{
 	  p->next = (*rootp)->next;
@@ -48,36 +47,49 @@ peer_create (struct rs_context *ctx, struct rs_peer **rootp)
   return p;
 }
 
-/* Public functions.  */
 int
-rs_peer_create (struct rs_connection *conn, struct rs_peer **peer_out)
+peer_create_for_connbase (struct rs_conn_base *connbase,
+                          struct rs_peer **peer_out)
 {
   struct rs_peer *peer;
 
-  peer = peer_create (conn->base_.ctx, &conn->base_.peers);
-  if (peer)
-    {
-      peer->conn = conn;
-      peer->realm->timeout = 2;	/* FIXME: Why?  */
-      peer->realm->retries = 2;	/* FIXME: Why?  */
-    }
-  else
-    return rs_err_conn_push_fl (conn, RSE_NOMEM, __FILE__, __LINE__, NULL);
+  peer = peer_create (connbase->ctx, &connbase->peers);
+  if (peer == NULL)
+    return rs_err_connbase_push_fl (connbase, RSE_NOMEM, __FILE__, __LINE__,
+                                    NULL);
+  peer->connbase = connbase;
+  peer->realm = connbase->realm;
+
   if (*peer_out)
     *peer_out = peer;
   return RSE_OK;
 }
 
+/* Public functions.  */
+int
+rs_peer_create_for_conn (struct rs_connection *conn, struct rs_peer **peer_out)
+{
+  return peer_create_for_connbase (TO_BASE_CONN (conn), peer_out);
+}
+
 int
-rs_peer_set_address (struct rs_peer *peer, const char *hostname,
+rs_peer_create_for_listener (struct rs_listener *listener,
+                             struct rs_peer **peer_out)
+{
+  return peer_create_for_connbase (TO_BASE_CONN (listener), peer_out);
+}
+
+int
+rs_peer_set_address (struct rs_peer *peer,
+                     const char *hostname,
                      const char *service)
 {
   assert (peer);
-  assert (peer->conn);
-  assert (peer->conn->base_.ctx);
+  assert (peer->connbase);
+  assert (peer->connbase->ctx);
 
-  peer->hostname = rs_strdup (peer->conn->base_.ctx, hostname);
-  peer->service = rs_strdup (peer->conn->base_.ctx, service);
+  peer->hostname = rs_strdup (peer->connbase->ctx, hostname);
+  peer->service = rs_strdup (peer->connbase->ctx, service);
   if (peer->hostname == NULL || peer->service == NULL)
     return RSE_NOMEM;
 
@@ -85,12 +97,28 @@ rs_peer_set_address (struct rs_peer *peer, const char *hostname,
 }
 
 void
+rs_peer_free_address (struct rs_peer *peer)
+{
+  assert (peer);
+  assert (peer->connbase);
+  assert (peer->connbase->ctx);
+
+  if (peer->hostname)
+    rs_free (peer->connbase->ctx, peer->hostname);
+  peer->hostname = NULL;
+  if (peer->service)
+    rs_free (peer->connbase->ctx, peer->service);
+  peer->service = NULL;
+}
+
+void
 rs_peer_set_timeout (struct rs_peer *peer, int timeout)
 {
   assert (peer);
   assert (peer->realm);
   peer->realm->timeout = timeout;
 }
+
 void
 rs_peer_set_retries (struct rs_peer *peer, int retries)
 {
@@ -102,12 +130,26 @@ rs_peer_set_retries (struct rs_peer *peer, int retries)
 int
 rs_peer_set_secret (struct rs_peer *peer, const char *secret)
 {
-  if (peer->secret)
-    free (peer->secret);
-  peer->secret = (char *) malloc (strlen(secret) + 1);
+  assert (peer);
+  assert (peer->connbase);
+  assert (peer->connbase->ctx);
+
+  rs_peer_free_secret (peer);
+  peer->secret = rs_calloc (peer->connbase->ctx, 1, strlen(secret) + 1);
   if (!peer->secret)
-    return rs_err_conn_push (peer->conn, RSE_NOMEM, NULL);
+    return rs_err_connbase_push (peer->connbase, RSE_NOMEM, NULL);
   strcpy (peer->secret, secret);
   return RSE_OK;
 }
 
+void
+rs_peer_free_secret (struct rs_peer *peer)
+{
+  assert (peer);
+  assert (peer->connbase);
+  assert (peer->connbase->ctx);
+
+  if (peer->secret)
+    rs_free (peer->connbase->ctx, peer->secret);
+  peer->secret = NULL;
+}