1 files changed, 97 insertions, 87 deletions

diff --git a/lib/tcp.c b/lib/tcp.c
index e2b1a2f..8c7263f 100644
--- a/lib/tcp.c
+++ b/lib/tcp.c
@@ -16,7 +16,7 @@
 #include <radsec/radsec.h>
 #include <radsec/radsec-impl.h>
 #include "tcp.h"
-#include "packet.h"
+#include "message.h"
 #include "conn.h"
 #include "debug.h"
 #include "event.h"
@@ -25,133 +25,131 @@
 #include <event2/buffer.h>
 #endif
 
-/** Read one RADIUS packet header. Return !0 on error. */
+/** Read one RADIUS message header. Return !0 on error. */
 static int
-_read_header (struct rs_packet *pkt)
+_read_header (struct rs_message *msg)
 {
   size_t n = 0;
 
-  n = bufferevent_read (pkt->conn->bev, pkt->hdr, RS_HEADER_LEN);
+  n = bufferevent_read (TO_BASE_CONN(msg->conn)->bev, msg->hdr, RS_HEADER_LEN);
   if (n == RS_HEADER_LEN)
     {
-      pkt->flags |= RS_PACKET_HEADER_READ;
-      pkt->rpkt->length = (pkt->hdr[2] << 8) + pkt->hdr[3];
-      if (pkt->rpkt->length < 20 || pkt->rpkt->length > RS_MAX_PACKET_LEN)
-	{
-          rs_debug (("%s: invalid packet length: %d\n",
-                     __func__, pkt->rpkt->length));
-          rs_conn_disconnect (pkt->conn);
-	  return rs_err_conn_push (pkt->conn, RSE_INVALID_PKT,
-				   "invalid packet length: %d",
-				   pkt->rpkt->length);
-	}
-      memcpy (pkt->rpkt->data, pkt->hdr, RS_HEADER_LEN);
-      bufferevent_setwatermark (pkt->conn->bev, EV_READ,
-				pkt->rpkt->length - RS_HEADER_LEN, 0);
-      rs_debug (("%s: packet header read, total pkt len=%d\n",
-		 __func__, pkt->rpkt->length));
+      msg->flags |= RS_MESSAGE_HEADER_READ;
+      msg->rpkt->length = (msg->hdr[2] << 8) + msg->hdr[3];
+      if (msg->rpkt->length < 20 || msg->rpkt->length > RS_MAX_PACKET_LEN)
+        {
+          rs_debug (("%s: invalid packet length: %d\n", __func__,
+                     msg->rpkt->length));
+          rs_conn_disconnect (msg->conn);
+          return  rs_err_conn_push (msg->conn, RSE_INVALID_MSG,
+                                    "invalid message length: %d",
+                                    msg->rpkt->length);
+        }
+      memcpy (msg->rpkt->data, msg->hdr, RS_HEADER_LEN);
+      bufferevent_setwatermark (TO_BASE_CONN(msg->conn)->bev, EV_READ,
+				msg->rpkt->length - RS_HEADER_LEN, 0);
+      rs_debug (("%s: message header read, total msg len=%d\n",
+		 __func__, msg->rpkt->length));
     }
   else if (n < 0)
-    {
-      rs_debug (("%s: buffer frozen while reading header\n", __func__));
-    }
+    rs_debug (("%s: buffer frozen while reading header\n", __func__));
   else	    /* Error: libevent gave us less than the low watermark. */
     {
       rs_debug (("%s: got: %d octets reading header\n", __func__, n));
-      rs_conn_disconnect (pkg->conn);
-      return rs_err_conn_push_fl (pkt->conn, RSE_INTERNAL, __FILE__, __LINE__,
-				  "got %d octets reading header", n);
+      rs_conn_disconnect (msg->conn);
+      return rs_err_conn_push (msg->conn, RSE_INTERNAL,
+                               "got %d octets reading header", n);
     }
 
-  return 0;
+  return RSE_OK;
 }
 
 /** Read a message, check that it's valid RADIUS and hand it off to
     registered user callback.
 
-    The packet is read from the bufferevent associated with \a pkt and
-    the data is stored in \a pkt->rpkt.
+    The message is read from the bufferevent associated with \a msg and
+    the data is stored in \a msg->rpkt.
 
     Return 0 on success and !0 on failure. */
 static int
-_read_packet (struct rs_packet *pkt)
+_read_message (struct rs_message *msg)
 {
   size_t n = 0;
   int err;
 
-  rs_debug (("%s: trying to read %d octets of packet data\n", __func__,
-	     pkt->rpkt->length - RS_HEADER_LEN));
+  rs_debug (("%s: trying to read %d octets of message data\n", __func__,
+	     msg->rpkt->length - RS_HEADER_LEN));
 
-  n = bufferevent_read (pkt->conn->bev,
-			pkt->rpkt->data + RS_HEADER_LEN,
-			pkt->rpkt->length - RS_HEADER_LEN);
+  n = bufferevent_read (msg->conn->base_.bev,
+			msg->rpkt->data + RS_HEADER_LEN,
+			msg->rpkt->length - RS_HEADER_LEN);
 
-  rs_debug (("%s: read %ld octets of packet data\n", __func__, n));
+  rs_debug (("%s: read %ld octets of message data\n", __func__, n));
 
-  if (n == pkt->rpkt->length - RS_HEADER_LEN)
+  if (n == msg->rpkt->length - RS_HEADER_LEN)
     {
-      bufferevent_disable (pkt->conn->bev, EV_READ);
-      rs_debug (("%s: complete packet read\n", __func__));
-      pkt->flags &= ~RS_PACKET_HEADER_READ;
-      memset (pkt->hdr, 0, sizeof(*pkt->hdr));
+      bufferevent_disable (msg->conn->base_.bev, EV_READ);
+      rs_debug (("%s: complete message read\n", __func__));
+      msg->flags &= ~RS_MESSAGE_HEADER_READ;
+      memset (msg->hdr, 0, sizeof(*msg->hdr));
 
-      /* Checks done by rad_packet_ok:
+      /* Checks done by nr_packet_ok:
 	 - lenghts (FIXME: checks really ok for tcp?)
 	 - invalid code field
 	 - attribute lengths >= 2
 	 - attribute sizes adding up correctly  */
-      err = nr_packet_ok (pkt->rpkt);
-      if (err != RSE_OK)
+      err = nr_packet_ok (msg->rpkt);
+      if (err)
 	{
           rs_debug (("%s: %d: invalid packet\n", __func__, -err));
-          rs_conn_disconnect (pkt->conn);
-	  return rs_err_conn_push_fl (pkt->conn, -err, __FILE__, __LINE__,
-				      "invalid packet");
-	}
+          rs_conn_disconnect (msg->conn);
+          return rs_err_conn_push (msg->conn, -err, "invalid message");
+        }
 
 #if defined (DEBUG)
       /* Find out what happens if there's data left in the buffer.  */
       {
 	size_t rest = 0;
-	rest = evbuffer_get_length (bufferevent_get_input (pkt->conn->bev));
+	rest =
+          evbuffer_get_length (bufferevent_get_input (msg->conn->base_.bev));
 	if (rest)
 	  rs_debug (("%s: returning with %d octets left in buffer\n", __func__,
 		     rest));
       }
 #endif
 
-      /* Hand over message to user.  This changes ownership of pkt.
+      /* Hand over message to user.  This changes ownership of msg.
 	 Don't touch it afterwards -- it might have been freed.  */
-      if (pkt->conn->callbacks.received_cb)
-	pkt->conn->callbacks.received_cb (pkt, pkt->conn->user_data);
+      if (msg->conn->callbacks.received_cb)
+	msg->conn->callbacks.received_cb (msg, msg->conn->base_.user_data);
     }
   else if (n < 0)		/* Buffer frozen.  */
-    rs_debug (("%s: buffer frozen when reading packet\n", __func__));
-  else				/* Short packet.  */
+    rs_debug (("%s: buffer frozen when reading message\n", __func__));
+  else				/* Short message.  */
     rs_debug (("%s: waiting for another %d octets\n", __func__,
-	       pkt->rpkt->length - RS_HEADER_LEN - n));
+	       msg->rpkt->length - RS_HEADER_LEN - n));
 
   return 0;
 }
 
 /* The read callback for TCP.
 
-   Read exactly one RADIUS message from BEV and store it in struct
-   rs_packet passed in USER_DATA.
+   Read exactly one RADIUS message from \a bev and store it in the
+   struct rs_message passed in \a user_data.
 
    Inform upper layer about successful reception of received RADIUS
-   message by invoking conn->callbacks.recevied_cb(), if !NULL.  */
+   message by invoking conn->callbacks.recevied_cb(), if not NULL. */
 void
 tcp_read_cb (struct bufferevent *bev, void *user_data)
 {
-  struct rs_packet *pkt = (struct rs_packet *) user_data;
+  struct rs_message *msg = (struct rs_message *) user_data;
 
-  assert (pkt);
-  assert (pkt->conn);
-  assert (pkt->rpkt);
+  assert (msg);
+  assert (msg->conn);
+  assert (msg->rpkt);
 
-  pkt->rpkt->sockfd = pkt->conn->fd;
-  pkt->rpkt->vps = NULL;        /* FIXME: can this be done when initializing pkt? */
+  msg->rpkt->sockfd = msg->conn->base_.fd;
+  msg->rpkt->vps = NULL; /* FIXME: can this be done when initializing msg? */
 
   /* Read a message header if not already read, return if that
      fails. Read a message and have it dispatched to the user
@@ -159,16 +157,16 @@ tcp_read_cb (struct bufferevent *bev, void *user_data)
 
      Room for improvement: Peek inside buffer (evbuffer_copyout()) to
      avoid the extra copying. */
-  if ((pkt->flags & RS_PACKET_HEADER_READ) == 0)
-    if (_read_header (pkt))
-      return;			/* Error.  */
-  _read_packet (pkt);
+  if ((msg->flags & RS_MESSAGE_HEADER_READ) == 0)
+    if (_read_header (msg))
+      return;                   /* Invalid header. */
+  _read_message (msg);
 }
 
 void
 tcp_event_cb (struct bufferevent *bev, short events, void *user_data)
 {
-  struct rs_packet *pkt = (struct rs_packet *) user_data;
+  struct rs_message *msg = (struct rs_message *) user_data;
   struct rs_connection *conn = NULL;
   int sockerr = 0;
 #if defined (RS_ENABLE_TLS)
@@ -178,20 +176,31 @@ tcp_event_cb (struct bufferevent *bev, short events, void *user_data)
   struct rs_peer *p = NULL;
 #endif
 
-  assert (pkt);
-  assert (pkt->conn);
-  conn = pkt->conn;
+  assert (msg);
+  assert (msg->conn);
+  conn = msg->conn;
 #if defined (DEBUG)
-  assert (pkt->conn->active_peer);
+  assert (conn->active_peer);
   p = conn->active_peer;
 #endif
 
-  conn->is_connecting = 0;
   if (events & BEV_EVENT_CONNECTED)
     {
-      if (conn->tev)
-	evtimer_del (conn->tev); /* Cancel connect timer.  */
-      if (event_on_connect (conn, pkt))
+      int err = -1;
+
+      if (conn_originating_p (conn)) /* We're a client. */
+        {
+          assert (conn->tev);
+          if (conn->tev)
+            evtimer_del (conn->tev); /* Cancel connect timer.  */
+          err = event_on_connect_orig (conn, msg);
+        }
+      else                      /* We're a server. */
+        {
+          assert (conn->tev == NULL);
+          err = event_on_connect_term (conn, msg);
+        }
+      if (err)
         {
           event_on_disconnect (conn);
           event_loopbreak (conn);
@@ -217,18 +226,18 @@ tcp_event_cb (struct bufferevent *bev, short events, void *user_data)
 	}
       else
 	{
-	  rs_debug (("%s: %d: %d (%s)\n", __func__, conn->fd, sockerr,
+	  rs_debug (("%s: %d: %d (%s)\n", __func__, conn->base_.fd, sockerr,
 		     evutil_socket_error_to_string (sockerr)));
 	  rs_err_conn_push_fl (conn, RSE_SOCKERR, __FILE__, __LINE__,
-			       "%d: %d (%s)", conn->fd, sockerr,
+			       "%d: %d (%s)", conn->base_.fd, sockerr,
 			       evutil_socket_error_to_string (sockerr));
 	}
 #if defined (RS_ENABLE_TLS)
       if (conn->tls_ssl)	/* FIXME: correct check?  */
 	{
-	  for (tlserr = bufferevent_get_openssl_error (conn->bev);
+	  for (tlserr = bufferevent_get_openssl_error (conn->base_.bev);
 	       tlserr;
-	       tlserr = bufferevent_get_openssl_error (conn->bev))
+	       tlserr = bufferevent_get_openssl_error (conn->base_.bev))
 	    {
 	      rs_debug (("%s: openssl error: %s\n", __func__,
 			 ERR_error_string (tlserr, NULL)));
@@ -249,23 +258,24 @@ tcp_event_cb (struct bufferevent *bev, short events, void *user_data)
 void
 tcp_write_cb (struct bufferevent *bev, void *ctx)
 {
-  struct rs_packet *pkt = (struct rs_packet *) ctx;
+  struct rs_message *msg = (struct rs_message *) ctx;
 
-  assert (pkt);
-  assert (pkt->conn);
+  assert (msg);
+  assert (msg->conn);
 
-  if (pkt->conn->callbacks.sent_cb)
-    pkt->conn->callbacks.sent_cb (pkt->conn->user_data);
+  if (msg->conn->callbacks.sent_cb)
+    msg->conn->callbacks.sent_cb (msg->conn->base_.user_data);
 }
 
 int
 tcp_init_connect_timer (struct rs_connection *conn)
 {
   assert (conn);
+  assert (conn->base_.ctx);
 
   if (conn->tev)
     event_free (conn->tev);
-  conn->tev = evtimer_new (conn->evb, event_conn_timeout_cb, conn);
+  conn->tev = evtimer_new (conn->base_.ctx->evb, event_conn_timeout_cb, conn);
   if (!conn->tev)
     return rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 				"evtimer_new");