lib/event.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 <radsec/radsec.h>
  16 #include <radsec/radsec-impl.h>
  17 #include "tcp.h"
  18 #include "udp.h"
  19 #if defined (RS_ENABLE_TLS)
  20 #include "tls.h"
  21 #endif
  22 #include "err.h"
  23 #include "radsec.h"
  24 #include "event.h"
  25 #include "packet.h"
  26 #include "conn.h"
  27 #include "debug.h"
  28
  29 #if defined (DEBUG)
  30 extern int _event_debug_mode_on;
  31 #endif
  32
  33 static void
  34 _evlog_cb (int severity, const char *msg)
  35 {
  36   const char *sevstr;
  37   switch (severity)
  38     {
  39     case _EVENT_LOG_DEBUG:
  40 #if !defined (DEBUG_LEVENT)
  41       return;
  42 #endif
  43       sevstr = "debug";
  44       break;
  45     case _EVENT_LOG_MSG:
  46       sevstr = "msg";
  47       break;
  48     case _EVENT_LOG_WARN:
  49       sevstr = "warn";
  50       break;
  51     case _EVENT_LOG_ERR:
  52       sevstr = "err";
  53       break;
  54     default:
  55       sevstr = "???";
  56       break;
  57     }
  58   fprintf (stderr, "libevent: [%s] %s\n", sevstr, msg); /* FIXME: stderr?  */
  59 }
  60
  61 void
  62 event_conn_timeout_cb (int fd, short event, void *data)
  63 {
  64   struct rs_connection *conn = NULL;
  65
  66   assert (data);
  67   conn = (struct rs_connection *) data;
  68
  69   if (event & EV_TIMEOUT)
  70     {
  71       rs_debug (("%s: connection timeout on %p (fd %d) connecting to %p\n",
  72                  __func__, conn, conn->fd, conn->active_peer));
  73       conn->is_connecting = 0;
  74       rs_err_conn_push_fl (conn, RSE_TIMEOUT_CONN, __FILE__, __LINE__, NULL);
  75       event_loopbreak (conn);
  76     }
  77 }
  78
  79 void
  80 event_retransmit_timeout_cb (int fd, short event, void *data)
  81 {
  82   struct rs_connection *conn = NULL;
  83
  84   assert (data);
  85   conn = (struct rs_connection *) data;
  86
  87   if (event & EV_TIMEOUT)
  88     {
  89       rs_debug (("%s: retransmission timeout on %p (fd %d) sending to %p\n",
  90                  __func__, conn, conn->fd, conn->active_peer));
  91       rs_err_conn_push_fl (conn, RSE_TIMEOUT_IO, __FILE__, __LINE__, NULL);
  92       event_loopbreak (conn);
  93     }
  94 }
  95
  96 int
  97 event_init_socket (struct rs_connection *conn, struct rs_peer *p)
  98 {
  99   if (conn->fd != -1)
 100     return RSE_OK;
 101
 102   if (p->addr_cache == NULL)
 103     {
 104       struct rs_error *err =
 105         rs_resolve (&p->addr_cache, p->realm->type, p->hostname, p->service);
 106       if (err != NULL)
 107         return err_conn_push_err (conn, err);
 108     }
 109
 110   conn->fd = socket (p->addr_cache->ai_family, p->addr_cache->ai_socktype,
 111                      p->addr_cache->ai_protocol);
 112   if (conn->fd < 0)
 113     return rs_err_conn_push_fl (conn, RSE_SOCKERR, __FILE__, __LINE__,
 114                                 "socket: %d (%s)",
 115                                 errno, strerror (errno));
 116   if (evutil_make_socket_nonblocking (conn->fd) < 0)
 117     {
 118       evutil_closesocket (conn->fd);
 119       conn->fd = -1;
 120       return rs_err_conn_push_fl (conn, RSE_SOCKERR, __FILE__, __LINE__,
 121                                   "evutil_make_socket_nonblocking: %d (%s)",
 122                                   errno, strerror (errno));
 123     }
 124   return RSE_OK;
 125 }
 126
 127 int
 128 event_init_bufferevent (struct rs_connection *conn, struct rs_peer *peer)
 129 {
 130   if (conn->bev)
 131     return RSE_OK;
 132
 133   if (conn->realm->type == RS_CONN_TYPE_TCP)
 134     {
 135       conn->bev = bufferevent_socket_new (conn->evb, conn->fd, 0);
 136       if (!conn->bev)
 137         return rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 138                                     "bufferevent_socket_new");
 139     }
 140 #if defined (RS_ENABLE_TLS)
 141   else if (conn->realm->type == RS_CONN_TYPE_TLS)
 142     {
 143       if (rs_tls_init (conn))
 144         return -1;
 145       /* Would be convenient to pass BEV_OPT_CLOSE_ON_FREE but things
 146          seem to break when be_openssl_ctrl() (in libevent) calls
 147          SSL_set_bio() after BIO_new_socket() with flag=1.  */
 148       conn->bev =
 149         bufferevent_openssl_socket_new (conn->evb, conn->fd, conn->tls_ssl,
 150                                         BUFFEREVENT_SSL_CONNECTING, 0);
 151       if (!conn->bev)
 152         return rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 153                                     "bufferevent_openssl_socket_new");
 154     }
 155 #endif  /* RS_ENABLE_TLS */
 156   else
 157     {
 158       return rs_err_conn_push_fl (conn, RSE_INTERNAL, __FILE__, __LINE__,
 159                                   "%s: unknown connection type: %d", __func__,
 160                                   conn->realm->type);
 161     }
 162
 163   return RSE_OK;
 164 }
 165
 166 void
 167 event_do_connect (struct rs_connection *conn)
 168 {
 169   struct rs_peer *p;
 170   int err, sockerr;
 171
 172   assert (conn);
 173   assert (conn->active_peer);
 174   p = conn->active_peer;
 175
 176 #if defined (DEBUG)
 177   {
 178     char host[80], serv[80];
 179
 180     getnameinfo (p->addr_cache->ai_addr,
 181                  p->addr_cache->ai_addrlen,
 182                  host, sizeof(host), serv, sizeof(serv),
 183                  0 /* NI_NUMERICHOST|NI_NUMERICSERV*/);
 184     rs_debug (("%s: connecting to %s:%s\n", __func__, host, serv));
 185   }
 186 #endif
 187
 188   if (p->conn->bev)             /* TCP */
 189     {
 190       conn_activate_timeout (conn); /* Connect timeout.  */
 191       err = bufferevent_socket_connect (p->conn->bev, p->addr_cache->ai_addr,
 192                                         p->addr_cache->ai_addrlen);
 193       if (err < 0)
 194         rs_err_conn_push_fl (p->conn, RSE_EVENT, __FILE__, __LINE__,
 195                              "bufferevent_socket_connect: %s",
 196                              evutil_gai_strerror (err));
 197       else
 198         p->conn->is_connecting = 1;
 199     }
 200   else                          /* UDP */
 201     {
 202       err = connect (p->conn->fd,
 203                      p->addr_cache->ai_addr,
 204                      p->addr_cache->ai_addrlen);
 205       if (err < 0)
 206         {
 207           sockerr = evutil_socket_geterror (p->conn->fd);
 208           rs_debug (("%s: %d: connect: %d (%s)\n", __func__, p->conn->fd,
 209                      sockerr, evutil_socket_error_to_string (sockerr)));
 210           rs_err_conn_push_fl (p->conn, RSE_SOCKERR, __FILE__, __LINE__,
 211                                "%d: connect: %d (%s)", p->conn->fd, sockerr,
 212                                evutil_socket_error_to_string (sockerr));
 213         }
 214     }
 215 }
 216
 217 int
 218 event_loopbreak (struct rs_connection *conn)
 219 {
 220   int err = event_base_loopbreak (conn->evb);
 221   if (err < 0)
 222     rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 223                          "event_base_loopbreak: %s",
 224                          evutil_gai_strerror (err));
 225   return err;
 226 }
 227
 228
 229 void
 230 event_on_disconnect (struct rs_connection *conn)
 231 {
 232   conn->is_connecting = 0;
 233   conn->is_connected = 0;
 234   rs_debug (("%s: %p disconnected\n", __func__, conn->active_peer));
 235   if (conn->callbacks.disconnected_cb)
 236     conn->callbacks.disconnected_cb (conn->user_data);
 237 }
 238
 239 /** Internal connect event returning 0 on success or -1 on error.  */
 240 int
 241 event_on_connect (struct rs_connection *conn, struct rs_packet *pkt)
 242 {
 243   assert (!conn->is_connecting);
 244
 245 #if defined (RS_ENABLE_TLS)
 246   if (conn->realm->type == RS_CONN_TYPE_TLS
 247       || conn->realm->type == RS_CONN_TYPE_DTLS)
 248     if (tls_verify_cert (conn) != RSE_OK)
 249       {
 250         rs_debug (("%s: server cert verification failed\n", __func__));
 251         return -1;
 252       }
 253 #endif  /* RS_ENABLE_TLS */
 254
 255   conn->is_connected = 1;
 256   rs_debug (("%s: %p connected\n", __func__, conn->active_peer));
 257
 258   if (conn->callbacks.connected_cb)
 259     conn->callbacks.connected_cb (conn->user_data);
 260
 261   if (pkt)
 262     packet_do_send (pkt);
 263
 264   return 0;
 265 }
 266
 267 int
 268 event_init_eventbase (struct rs_connection *conn)
 269 {
 270   assert (conn);
 271   if (conn->evb)
 272     return RSE_OK;
 273
 274 #if defined (DEBUG)
 275   if (!_event_debug_mode_on)
 276     event_enable_debug_mode ();
 277 #endif
 278   event_set_log_callback (_evlog_cb);
 279   conn->evb = event_base_new ();
 280   if (!conn->evb)
 281     return rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 282                                 "event_base_new");
 283
 284   return RSE_OK;
 285 }