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 "event.h"
  23 #include "packet.h"
  24 #include "debug.h"
  25
  26 static void
  27 _evlog_cb (int severity, const char *msg)
  28 {
  29   const char *sevstr;
  30   switch (severity)
  31     {
  32     case _EVENT_LOG_DEBUG:
  33 #if !defined (DEBUG_LEVENT)
  34       return;
  35 #endif
  36       sevstr = "debug";
  37       break;
  38     case _EVENT_LOG_MSG:
  39       sevstr = "msg";
  40       break;
  41     case _EVENT_LOG_WARN:
  42       sevstr = "warn";
  43       break;
  44     case _EVENT_LOG_ERR:
  45       sevstr = "err";
  46       break;
  47     default:
  48       sevstr = "???";
  49       break;
  50     }
  51   fprintf (stderr, "libevent: [%s] %s\n", sevstr, msg); /* FIXME: stderr?  */
  52 }
  53
  54 int
  55 event_init_socket (struct rs_connection *conn, struct rs_peer *p)
  56 {
  57   if (conn->fd != -1)
  58     return RSE_OK;
  59
  60   assert (p->addr);
  61   conn->fd = socket (p->addr->ai_family, p->addr->ai_socktype,
  62                      p->addr->ai_protocol);
  63   if (conn->fd < 0)
  64     return rs_err_conn_push_fl (conn, RSE_SOCKERR, __FILE__, __LINE__,
  65                                 "socket: %d (%s)",
  66                                 errno, strerror (errno));
  67   if (evutil_make_socket_nonblocking (conn->fd) < 0)
  68     {
  69       evutil_closesocket (conn->fd);
  70       conn->fd = -1;
  71       return rs_err_conn_push_fl (conn, RSE_SOCKERR, __FILE__, __LINE__,
  72                                   "evutil_make_socket_nonblocking: %d (%s)",
  73                                   errno, strerror (errno));
  74     }
  75   return RSE_OK;
  76 }
  77
  78 int
  79 event_init_bufferevent (struct rs_connection *conn, struct rs_peer *peer)
  80 {
  81   if (conn->bev)
  82     return RSE_OK;
  83
  84   if (conn->realm->type == RS_CONN_TYPE_TCP)
  85     {
  86       conn->bev = bufferevent_socket_new (conn->evb, conn->fd, 0);
  87       if (!conn->bev)
  88         return rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
  89                                     "bufferevent_socket_new");
  90     }
  91 #if defined (RS_ENABLE_TLS)
  92   else if (conn->realm->type == RS_CONN_TYPE_TLS)
  93     {
  94       if (rs_tls_init (conn))
  95         return -1;
  96       /* Would be convenient to pass BEV_OPT_CLOSE_ON_FREE but things
  97          seem to break when be_openssl_ctrl() (in libevent) calls
  98          SSL_set_bio() after BIO_new_socket() with flag=1.  */
  99       conn->bev =
 100         bufferevent_openssl_socket_new (conn->evb, conn->fd, conn->tls_ssl,
 101                                         BUFFEREVENT_SSL_CONNECTING, 0);
 102       if (!conn->bev)
 103         return rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 104                                     "bufferevent_openssl_socket_new");
 105     }
 106 #endif  /* RS_ENABLE_TLS */
 107   else
 108     {
 109       return rs_err_conn_push_fl (conn, RSE_INTERNAL, __FILE__, __LINE__,
 110                                   "%s: unknown connection type: %d", __func__,
 111                                   conn->realm->type);
 112     }
 113
 114   return RSE_OK;
 115 }
 116
 117 void
 118 event_do_connect (struct rs_connection *conn)
 119 {
 120   struct rs_peer *p;
 121   int err, sockerr;
 122
 123   assert (conn);
 124   assert (conn->active_peer);
 125   p = conn->active_peer;
 126
 127 #if defined (DEBUG)
 128   {
 129     char host[80], serv[80];
 130
 131     getnameinfo (p->addr->ai_addr,
 132                  p->addr->ai_addrlen,
 133                  host, sizeof(host), serv, sizeof(serv),
 134                  0 /* NI_NUMERICHOST|NI_NUMERICSERV*/);
 135     rs_debug (("%s: connecting to %s:%s\n", __func__, host, serv));
 136   }
 137 #endif
 138
 139   if (p->conn->bev)             /* TCP */
 140     {
 141       tcp_set_connect_timeout (conn);
 142       err = bufferevent_socket_connect (p->conn->bev, p->addr->ai_addr,
 143                                         p->addr->ai_addrlen);
 144       if (err < 0)
 145         rs_err_conn_push_fl (p->conn, RSE_EVENT, __FILE__, __LINE__,
 146                              "bufferevent_socket_connect: %s",
 147                              evutil_gai_strerror (err));
 148       else
 149         p->conn->is_connecting = 1;
 150     }
 151   else                          /* UDP */
 152     {
 153       err = connect (p->conn->fd, p->addr->ai_addr, p->addr->ai_addrlen);
 154       if (err < 0)
 155         {
 156           sockerr = evutil_socket_geterror (p->conn->fd);
 157           rs_debug (("%s: %d: connect: %d (%s)\n", __func__, p->conn->fd,
 158                      sockerr, evutil_socket_error_to_string (sockerr)));
 159           rs_err_conn_push_fl (p->conn, RSE_SOCKERR, __FILE__, __LINE__,
 160                                "%d: connect: %d (%s)", p->conn->fd, sockerr,
 161                                evutil_socket_error_to_string (sockerr));
 162         }
 163     }
 164 }
 165
 166 int
 167 event_loopbreak (struct rs_connection *conn)
 168 {
 169   int err = event_base_loopbreak (conn->evb);
 170   if (err < 0)
 171     rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 172                          "event_base_loopbreak: %s",
 173                          evutil_gai_strerror (err));
 174   return err;
 175 }
 176
 177
 178 void
 179 event_on_disconnect (struct rs_connection *conn)
 180 {
 181   conn->is_connecting = 0;
 182   conn->is_connected = 0;
 183   rs_debug (("%s: %p disconnected\n", __func__, conn->active_peer));
 184   if (conn->callbacks.disconnected_cb)
 185     conn->callbacks.disconnected_cb (conn->user_data);
 186 }
 187
 188 void
 189 event_on_connect (struct rs_connection *conn, struct rs_packet *pkt)
 190 {
 191   assert (!conn->is_connecting);
 192   conn->is_connected = 1;
 193   rs_debug (("%s: %p connected\n", __func__, conn->active_peer));
 194   if (conn->tev)
 195     evtimer_del (conn->tev);
 196   if (conn->callbacks.connected_cb)
 197     conn->callbacks.connected_cb (conn->user_data);
 198   if (pkt)
 199     packet_do_send (pkt);
 200 }
 201
 202 int
 203 event_init_eventbase (struct rs_connection *conn)
 204 {
 205   if (conn->evb)
 206     return RSE_OK;
 207
 208 #if defined (DEBUG)
 209   event_enable_debug_mode ();
 210 #endif
 211   event_set_log_callback (_evlog_cb);
 212   conn->evb = event_base_new ();
 213   if (!conn->evb)
 214     return rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 215                                 "event_base_new");
 216
 217   return RSE_OK;
 218 }