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 "message.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->base_.fd, conn->base_.active_peer));
  76       conn->state = RS_CONN_STATE_UNDEFINED;
  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->base_.fd, conn->base_.active_peer));
  94       rs_err_conn_push_fl (conn, RSE_TIMEOUT_IO, __FILE__, __LINE__, NULL);
  95       event_loopbreak (conn);
  96     }
  97 }
  98
  99 int
 100 event_init_socket (struct rs_connection *conn, struct rs_peer *p)
 101 {
 102   if (conn->base_.fd != -1)
 103     return RSE_OK;
 104
 105   if (p->addr_cache == NULL)
 106     {
 107       struct rs_error *err =
 108         rs_resolve (&p->addr_cache, p->realm->type, p->hostname, p->service);
 109       if (err != NULL)
 110         return err_connbase_push_err (TO_BASE_CONN (conn), err);
 111     }
 112
 113   conn->base_.fd = socket (p->addr_cache->ai_family, p->addr_cache->ai_socktype,
 114                      p->addr_cache->ai_protocol);
 115   if (conn->base_.fd < 0)
 116     return rs_err_conn_push_fl (conn, RSE_SOCKERR, __FILE__, __LINE__,
 117                                 "socket: %d (%s)",
 118                                 errno, strerror (errno));
 119   if (evutil_make_socket_nonblocking (conn->base_.fd) < 0)
 120     {
 121       evutil_closesocket (conn->base_.fd);
 122       conn->base_.fd = -1;
 123       return rs_err_conn_push_fl (conn, RSE_SOCKERR, __FILE__, __LINE__,
 124                                   "evutil_make_socket_nonblocking: %d (%s)",
 125                                   errno, strerror (errno));
 126     }
 127   return RSE_OK;
 128 }
 129
 130 int
 131 event_init_bufferevent (struct rs_connection *conn, struct rs_peer *peer)
 132 {
 133   if (conn->base_.bev)
 134     return RSE_OK;
 135
 136   if (conn->base_.realm->type == RS_CONN_TYPE_TCP)
 137     {
 138       conn->base_.bev = bufferevent_socket_new (conn->base_.ctx->evb,
 139                                               conn->base_.fd, 0);
 140       if (!conn->base_.bev)
 141         return rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 142                                     "bufferevent_socket_new");
 143     }
 144 #if defined (RS_ENABLE_TLS)
 145   else if (conn->base_.realm->type == RS_CONN_TYPE_TLS)
 146     {
 147       if (rs_tls_init (conn))
 148         return -1;
 149       /* Would be convenient to pass BEV_OPT_CLOSE_ON_FREE but things
 150          seem to break when be_openssl_ctrl() (in libevent) calls
 151          SSL_set_bio() after BIO_new_socket() with flag=1.  */
 152       conn->base_.bev =
 153         bufferevent_openssl_socket_new (conn->base_.ctx->evb, conn->base_.fd,
 154                                         conn->tls_ssl,
 155                                         BUFFEREVENT_SSL_CONNECTING, 0);
 156       if (!conn->base_.bev)
 157         return rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 158                                     "bufferevent_openssl_socket_new");
 159     }
 160 #endif  /* RS_ENABLE_TLS */
 161   else
 162     {
 163       return rs_err_conn_push_fl (conn, RSE_INTERNAL, __FILE__, __LINE__,
 164                                   "%s: unknown connection type: %d", __func__,
 165                                   conn->base_.realm->type);
 166     }
 167
 168   return RSE_OK;
 169 }
 170
 171 void
 172 event_do_connect (struct rs_connection *conn)
 173 {
 174   int err, sockerr;
 175   struct sockaddr *peer_addr;
 176   size_t peer_addrlen;
 177
 178   assert (conn);
 179   assert (conn->base_.active_peer);
 180   assert (conn->base_.active_peer->addr_cache);
 181   peer_addr = conn->base_.active_peer->addr_cache->ai_addr;
 182   peer_addrlen = conn->base_.active_peer->addr_cache->ai_addrlen;
 183
 184   /* We don't connect listeners. */
 185   assert (conn->base_.magic == RS_CONN_MAGIC_GENERIC);
 186
 187 #if defined (DEBUG)
 188   {
 189     char host[80], serv[80];
 190
 191     getnameinfo (peer_addr, peer_addrlen,
 192                  host, sizeof(host),
 193                  serv, sizeof(serv),
 194                  0 /* NI_NUMERICHOST|NI_NUMERICSERV*/);
 195     rs_debug (("%s: connecting to %s:%s\n", __func__, host, serv));
 196   }
 197 #endif
 198
 199   if (conn->base_.bev)          /* TCP */
 200     {
 201       conn_activate_timeout (conn); /* Connect timeout.  */
 202       err = bufferevent_socket_connect (conn->base_.bev,
 203                                         peer_addr, peer_addrlen);
 204       if (err < 0)
 205         rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 206                              "bufferevent_socket_connect: %s",
 207                              evutil_gai_strerror (err));
 208       else
 209         conn->state = RS_CONN_STATE_CONNECTING;
 210     }
 211   else                          /* UDP */
 212     {
 213       err = connect (conn->base_.fd, peer_addr, peer_addrlen);
 214       if (err < 0)
 215         {
 216           sockerr = evutil_socket_geterror (conn->base_.fd);
 217           rs_debug (("%s: %d: connect: %d (%s)\n", __func__,
 218                      conn->base_.fd,
 219                      sockerr, evutil_socket_error_to_string (sockerr)));
 220           rs_err_conn_push_fl (conn, RSE_SOCKERR,
 221                                __FILE__, __LINE__,
 222                                "%d: connect: %d (%s)", conn->base_.fd,
 223                                sockerr,
 224                                evutil_socket_error_to_string (sockerr));
 225         }
 226       else
 227         conn->state = RS_CONN_STATE_CONNECTING;
 228     }
 229 }
 230
 231 int
 232 event_loopbreak (struct rs_connection *conn)
 233 {
 234   int err = event_base_loopbreak (TO_BASE_CONN(conn)->ctx->evb);
 235   if (err < 0)
 236     rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 237                          "event_base_loopbreak: %s",
 238                          evutil_gai_strerror (err));
 239   return err;
 240 }
 241
 242
 243 void
 244 event_on_disconnect (struct rs_connection *conn)
 245 {
 246   conn->state = RS_CONN_STATE_UNDEFINED;
 247   rs_debug (("%s: %p disconnected\n", __func__,
 248              TO_BASE_CONN(conn)->active_peer));
 249   if (conn->callbacks.disconnected_cb)
 250     conn->callbacks.disconnected_cb (conn->base_.user_data);
 251 }
 252
 253 /** Internal connect event returning 0 on success or -1 on error.  */
 254 int
 255 event_on_connect (struct rs_connection *conn, struct rs_message *msg)
 256 {
 257   assert (conn->state == RS_CONN_STATE_CONNECTING);
 258   assert (conn->base_.active_peer);
 259
 260 #if defined (RS_ENABLE_TLS)
 261   if (conn_type_tls(conn) && !conn_cred_psk(conn))
 262     if (tls_verify_cert (conn) != RSE_OK)
 263       {
 264         rs_debug (("%s: server cert verification failed\n", __func__));
 265         return -1;
 266       }
 267 #endif  /* RS_ENABLE_TLS */
 268
 269   conn->state = RS_CONN_STATE_CONNECTED;
 270   rs_debug (("%s: %p connected\n", __func__, TO_BASE_CONN(conn)->active_peer));
 271
 272   if (conn->callbacks.connected_cb)
 273     conn->callbacks.connected_cb (conn->base_.user_data);
 274
 275   if (msg)
 276     message_do_send (msg);
 277
 278   return 0;
 279 }
 280
 281 int
 282 event_init_eventbase (struct rs_connection *conn)
 283 {
 284   assert (conn);
 285   assert (conn->base_.ctx);
 286   if (conn->base_.ctx->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->base_.ctx->evb = event_base_new ();
 295   if (!conn->base_.ctx->evb)
 296     return rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 297                                 "event_base_new");
 298
 299   return RSE_OK;
 300 }