lib/tcp.c

   1 /* Copyright 2011 NORDUnet A/S. All rights reserved.
   2    See the file COPYING for licensing information.  */
   3
   4 #if defined HAVE_CONFIG_H
   5 #include <config.h>
   6 #endif
   7
   8 #include <assert.h>
   9 #include <event2/event.h>
  10 #include <event2/bufferevent.h>
  11 #if defined (RS_ENABLE_TLS)
  12 #include <event2/bufferevent_ssl.h>
  13 #include <openssl/err.h>
  14 #endif
  15 #include <radius/client.h>
  16 #include <radsec/radsec.h>
  17 #include <radsec/radsec-impl.h>
  18 #include "tcp.h"
  19 #include "packet.h"
  20 #include "conn.h"
  21 #include "debug.h"
  22 #include "event.h"
  23
  24 #if defined (DEBUG)
  25 #include <event2/buffer.h>
  26 #endif
  27
  28 /* Read one RADIUS packet header.  Return !0 on error.  A return value
  29    of 0 means that we need more data.  */
  30 static int
  31 _read_header (struct rs_packet *pkt)
  32 {
  33   size_t n = 0;
  34
  35   n = bufferevent_read (pkt->conn->bev, pkt->hdr, RS_HEADER_LEN);
  36   if (n == RS_HEADER_LEN)
  37     {
  38       pkt->flags |= rs_packet_hdr_read_flag;
  39       pkt->rpkt->length = (pkt->hdr[2] << 8) + pkt->hdr[3];
  40       if (pkt->rpkt->length < 20 || pkt->rpkt->length > RS_MAX_PACKET_LEN)
  41         {
  42           conn_close (&pkt->conn);
  43           return rs_err_conn_push (pkt->conn, RSE_INVALID_PKT,
  44                                    "invalid packet length: %d",
  45                                    pkt->rpkt->length);
  46         }
  47       memcpy (pkt->rpkt->data, pkt->hdr, RS_HEADER_LEN);
  48       bufferevent_setwatermark (pkt->conn->bev, EV_READ,
  49                                 pkt->rpkt->length - RS_HEADER_LEN, 0);
  50       rs_debug (("%s: packet header read, total pkt len=%d\n",
  51                  __func__, pkt->rpkt->length));
  52     }
  53   else if (n < 0)
  54     {
  55       rs_debug (("%s: buffer frozen while reading header\n", __func__));
  56     }
  57   else      /* Error: libevent gave us less than the low watermark. */
  58     {
  59       conn_close (&pkt->conn);
  60       return rs_err_conn_push_fl (pkt->conn, RSE_INTERNAL, __FILE__, __LINE__,
  61                                   "got %d octets reading header", n);
  62     }
  63
  64   return 0;
  65 }
  66
  67 static int
  68 _read_packet (struct rs_packet *pkt)
  69 {
  70   size_t n = 0;
  71   int err;
  72
  73   rs_debug (("%s: trying to read %d octets of packet data\n", __func__,
  74              pkt->rpkt->length - RS_HEADER_LEN));
  75
  76   n = bufferevent_read (pkt->conn->bev,
  77                         pkt->rpkt->data + RS_HEADER_LEN,
  78                         pkt->rpkt->length - RS_HEADER_LEN);
  79
  80   rs_debug (("%s: read %ld octets of packet data\n", __func__, n));
  81
  82   if (n == pkt->rpkt->length - RS_HEADER_LEN)
  83     {
  84       bufferevent_disable (pkt->conn->bev, EV_READ);
  85       rs_debug (("%s: complete packet read\n", __func__));
  86       pkt->flags &= ~rs_packet_hdr_read_flag;
  87       memset (pkt->hdr, 0, sizeof(*pkt->hdr));
  88
  89       /* Checks done by rad_packet_ok:
  90          - lenghts (FIXME: checks really ok for tcp?)
  91          - invalid code field
  92          - attribute lengths >= 2
  93          - attribute sizes adding up correctly  */
  94       err = nr_packet_ok (pkt->rpkt);
  95       if (err != RSE_OK)
  96         {
  97           conn_close (&pkt->conn);
  98           return rs_err_conn_push_fl (pkt->conn, err, __FILE__, __LINE__,
  99                                       "invalid packet");
 100         }
 101
 102 #if defined (DEBUG)
 103       /* Find out what happens if there's data left in the buffer.  */
 104       {
 105         size_t rest = 0;
 106         rest = evbuffer_get_length (bufferevent_get_input (pkt->conn->bev));
 107         if (rest)
 108           rs_debug (("%s: returning with %d octets left in buffer\n", __func__,
 109                      rest));
 110       }
 111 #endif
 112
 113       /* Hand over message to user.  This changes ownership of pkt.
 114          Don't touch it afterwards -- it might have been freed.  */
 115       if (pkt->conn->callbacks.received_cb)
 116         pkt->conn->callbacks.received_cb (pkt, pkt->conn->user_data);
 117     }
 118   else if (n < 0)               /* Buffer frozen.  */
 119     rs_debug (("%s: buffer frozen when reading packet\n", __func__));
 120   else                          /* Short packet.  */
 121     rs_debug (("%s: waiting for another %d octets\n", __func__,
 122                pkt->rpkt->length - RS_HEADER_LEN - n));
 123
 124   return 0;
 125 }
 126
 127 /* The read callback for TCP.
 128
 129    Read exactly one RADIUS message from BEV and store it in struct
 130    rs_packet passed in USER_DATA.
 131
 132    Inform upper layer about successful reception of received RADIUS
 133    message by invoking conn->callbacks.recevied_cb(), if !NULL.  */
 134 void
 135 tcp_read_cb (struct bufferevent *bev, void *user_data)
 136 {
 137   struct rs_packet *pkt = (struct rs_packet *) user_data;
 138
 139   assert (pkt);
 140   assert (pkt->conn);
 141   assert (pkt->rpkt);
 142
 143   pkt->rpkt->sockfd = pkt->conn->fd;
 144   pkt->rpkt->vps = NULL;
 145
 146   if ((pkt->flags & rs_packet_hdr_read_flag) == 0)
 147     if (_read_header (pkt))
 148       return;                   /* Error.  */
 149   _read_packet (pkt);
 150 }
 151
 152 void
 153 tcp_event_cb (struct bufferevent *bev, short events, void *user_data)
 154 {
 155   struct rs_packet *pkt = (struct rs_packet *) user_data;
 156   struct rs_connection *conn = NULL;
 157   int sockerr = 0;
 158 #if defined (RS_ENABLE_TLS)
 159   unsigned long tlserr = 0;
 160 #endif
 161
 162   assert (pkt);
 163   assert (pkt->conn);
 164   assert (pkt->conn->active_peer);
 165   conn = pkt->conn;
 166
 167   conn->is_connecting = 0;
 168   if (events & BEV_EVENT_CONNECTED)
 169     {
 170       if (conn->tev)
 171         evtimer_del (conn->tev); /* Cancel connect timer.  */
 172       event_on_connect (conn, pkt);
 173     }
 174   else if (events & BEV_EVENT_EOF)
 175     {
 176       event_on_disconnect (conn);
 177     }
 178   else if (events & BEV_EVENT_TIMEOUT)
 179     {
 180       rs_debug (("%s: %p times out on %s\n", __func__, p,
 181                  (events & BEV_EVENT_READING) ? "read" : "write"));
 182       rs_err_conn_push_fl (pkt->conn, RSE_TIMEOUT_IO, __FILE__, __LINE__, NULL);
 183     }
 184   else if (events & BEV_EVENT_ERROR)
 185     {
 186       sockerr = evutil_socket_geterror (conn->active_peer->fd);
 187       if (sockerr == 0) /* FIXME: True that errno == 0 means closed? */
 188         {
 189           event_on_disconnect (conn);
 190           rs_err_conn_push_fl (pkt->conn, RSE_DISCO, __FILE__, __LINE__, NULL);
 191         }
 192       else
 193         {
 194           rs_debug (("%s: %d: %d (%s)\n", __func__, conn->fd, sockerr,
 195                      evutil_socket_error_to_string (sockerr)));
 196           rs_err_conn_push_fl (pkt->conn, RSE_SOCKERR, __FILE__, __LINE__,
 197                                "%d: %d (%s)", conn->fd, sockerr,
 198                                evutil_socket_error_to_string (sockerr));
 199         }
 200 #if defined (RS_ENABLE_TLS)
 201       if (conn->tls_ssl)        /* FIXME: correct check?  */
 202         {
 203           for (tlserr = bufferevent_get_openssl_error (conn->bev);
 204                tlserr;
 205                tlserr = bufferevent_get_openssl_error (conn->bev))
 206             {
 207               rs_debug (("%s: openssl error: %s\n", __func__,
 208                          ERR_error_string (tlserr, NULL)));
 209               rs_err_conn_push_fl (pkt->conn, RSE_SSLERR, __FILE__, __LINE__,
 210                                    ERR_error_string (tlserr, NULL));
 211             }
 212         }
 213 #endif  /* RS_ENABLE_TLS */
 214       event_loopbreak (conn);
 215     }
 216
 217 #if defined (DEBUG)
 218   if (events & BEV_EVENT_ERROR && events != BEV_EVENT_ERROR)
 219     rs_debug (("%s: BEV_EVENT_ERROR and more: 0x%x\n", __func__, events));
 220 #endif
 221 }
 222
 223 void
 224 tcp_write_cb (struct bufferevent *bev, void *ctx)
 225 {
 226   struct rs_packet *pkt = (struct rs_packet *) ctx;
 227
 228   assert (pkt);
 229   assert (pkt->conn);
 230
 231   if (pkt->conn->callbacks.sent_cb)
 232     pkt->conn->callbacks.sent_cb (pkt->conn->user_data);
 233 }
 234
 235 int
 236 tcp_init_connect_timer (struct rs_connection *conn)
 237 {
 238   assert (conn);
 239
 240   if (conn->tev)
 241     event_free (conn->tev);
 242   conn->tev = evtimer_new (conn->evb, event_conn_timeout_cb, conn);
 243   if (!conn->tev)
 244     return rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 245                                 "evtimer_new");
 246
 247   return RSE_OK;
 248 }