lib/event.c

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