lib/packet.c

   1 /* See the file COPYING for licensing information.  */
   2
   3 #include <string.h>
   4 #include <assert.h>
   5 #include <freeradius/libradius.h>
   6 #include <event2/event.h>
   7 #include <event2/bufferevent.h>
   8 #include <radsec/radsec.h>
   9 #include <radsec/radsec-impl.h>
  10 #if defined DEBUG
  11 #include <netdb.h>
  12 #include <sys/socket.h>
  13 #include "debug.h"
  14 #endif
  15
  16 static int
  17 _packet_create (struct rs_connection *conn, struct rs_packet **pkt_out)
  18 {
  19   struct rs_packet *p;
  20   RADIUS_PACKET *rpkt;
  21
  22   *pkt_out = NULL;
  23
  24   rpkt = rad_alloc (1);
  25   if (!rpkt)
  26     return rs_conn_err_push (conn, RSE_NOMEM, __func__);
  27   rpkt->id = -1;
  28
  29   p = (struct rs_packet *) malloc (sizeof (struct rs_packet));
  30   if (!p)
  31     {
  32       rad_free (&rpkt);
  33       return rs_conn_err_push (conn, RSE_NOMEM, __func__);
  34     }
  35   memset (p, 0, sizeof (struct rs_packet));
  36   p->conn = conn;
  37   p->rpkt = rpkt;
  38
  39   *pkt_out = p;
  40   return RSE_OK;
  41 }
  42
  43 static void
  44 _do_send (struct rs_packet *pkt)
  45 {
  46   int err;
  47
  48   rad_encode (pkt->rpkt, NULL, pkt->conn->active_peer->secret);
  49   assert (pkt->rpkt);
  50 #if defined (DEBUG)
  51   {
  52     char host[80], serv[80];
  53
  54     getnameinfo (pkt->conn->active_peer->addr->ai_addr,
  55                  pkt->conn->active_peer->addr->ai_addrlen,
  56                  host, sizeof(host), serv, sizeof(serv),
  57                  0 /* NI_NUMERICHOST|NI_NUMERICSERV*/);
  58     fprintf (stderr, "%s: about to send this to %s:%s:\n", __func__, host,
  59              serv);
  60     rs_dump_packet (pkt);
  61   }
  62 #endif
  63   err = bufferevent_write (pkt->conn->bev, pkt->rpkt->data,
  64                            pkt->rpkt->data_len);
  65   if (err < 0)
  66     rs_conn_err_push_fl (pkt->conn, RSE_EVENT, __FILE__, __LINE__,
  67                          "bufferevent_write: %s", evutil_gai_strerror(err));
  68 }
  69
  70 static void
  71 _event_cb (struct bufferevent *bev, short events, void *ctx)
  72 {
  73   struct rs_packet *pkt = (struct rs_packet *) ctx;
  74   struct rs_connection *conn;
  75   struct rs_peer *p;
  76
  77   assert (pkt);
  78   assert (pkt->conn);
  79   assert (pkt->conn->active_peer);
  80   conn = pkt->conn;
  81   p = conn->active_peer;
  82
  83   p->is_connecting = 0;
  84   if (events & BEV_EVENT_CONNECTED)
  85     {
  86       p->is_connected = 1;
  87 #if defined (DEBUG)
  88       fprintf (stderr, "%s: connected\n", __func__);
  89 #endif
  90       _do_send (pkt);
  91       /* Packet will be freed in write callback.  */
  92     }
  93   else if (events & BEV_EVENT_ERROR)
  94     rs_conn_err_push_fl (pkt->conn, RSE_CONNERR, __FILE__, __LINE__, NULL);
  95 }
  96
  97 static void
  98 _write_cb (struct bufferevent *bev, void *ctx)
  99 {
 100   struct rs_packet *pkt = (struct rs_packet *) ctx;
 101
 102   assert (pkt);
 103   assert (pkt->conn);
 104 #if defined (DEBUG)
 105   fprintf (stderr, "%s: packet written, breaking event loop\n", __func__);
 106 #endif
 107   if (event_base_loopbreak (pkt->conn->evb) < 0)
 108     abort ();                   /* FIXME */
 109   rs_packet_destroy (pkt);
 110 }
 111
 112 static void
 113 _read_cb (struct bufferevent *bev, void *ctx)
 114 {
 115   struct rs_packet *pkt = (struct rs_packet *) ctx;
 116   size_t n;
 117
 118   assert (pkt);
 119   assert (pkt->conn);
 120   if (!pkt->hdr_read_flag)
 121     {
 122       n = bufferevent_read (pkt->conn->bev, pkt->hdr, RS_HEADER_LEN);
 123       if (n == RS_HEADER_LEN)
 124         {
 125           pkt->hdr_read_flag = 1;
 126           pkt->rpkt->data_len = (pkt->hdr[2] << 8) + pkt->hdr[3];
 127           if (pkt->rpkt->data_len < 20 /* || len > 4096 */)
 128             abort ();           /* FIXME: Read and discard packet.  */
 129           pkt->rpkt->data = rs_malloc (pkt->conn->ctx, pkt->rpkt->data_len);
 130           if (!pkt->rpkt->data)
 131             {
 132               rs_conn_err_push_fl (pkt->conn, RSE_NOMEM, __FILE__, __LINE__,
 133                                    NULL);
 134               abort ();         /* FIXME: Read and discard packet.  */
 135             }
 136           memcpy (pkt->rpkt->data, pkt->hdr, RS_HEADER_LEN);
 137           bufferevent_setwatermark (pkt->conn->bev, EV_READ,
 138                                     pkt->rpkt->data_len - RS_HEADER_LEN, 0);
 139 #if defined (DEBUG)
 140           fprintf (stderr, "%s: packet header read, total pkt len=%d\n",
 141                    __func__, pkt->rpkt->data_len);
 142 #endif
 143         }
 144       else if (n < 0)
 145         return;                 /* Buffer frozen.  */
 146       else
 147         assert (!"short header");
 148     }
 149
 150 #if defined (DEBUG)
 151   printf ("%s: trying to read %d octets of packet data\n", __func__, pkt->rpkt->data_len - RS_HEADER_LEN);
 152 #endif
 153   n = bufferevent_read (pkt->conn->bev, pkt->rpkt->data + RS_HEADER_LEN, pkt->rpkt->data_len - RS_HEADER_LEN);
 154 #if defined (DEBUG)
 155   printf ("%s: read %d octets of packet data\n", __func__, n);
 156 #endif
 157   if (n == pkt->rpkt->data_len - RS_HEADER_LEN)
 158     {
 159       bufferevent_disable (pkt->conn->bev, EV_READ);
 160       pkt->hdr_read_flag = 0;
 161       memset (pkt->hdr, 0, sizeof(*pkt->hdr));
 162 #if defined (DEBUG)
 163       fprintf (stderr, "%s: complete packet read\n", __func__);
 164 #endif
 165       rad_decode (pkt->rpkt, NULL, pkt->conn->active_peer->secret);
 166       if (event_base_loopbreak (pkt->conn->evb) < 0)
 167         abort ();               /* FIXME */
 168     }
 169   else if (n < 0)
 170     return;                     /* Buffer frozen.  */
 171   else
 172     assert (!"short packet");
 173 }
 174
 175 #if defined (DEBUG)
 176 static void
 177 _evlog_cb (int severity, const char *msg)
 178 {
 179   const char *sevstr;
 180   switch (severity)
 181     {
 182     case _EVENT_LOG_DEBUG:
 183       sevstr = "debug";
 184       break;
 185     case _EVENT_LOG_MSG:
 186       sevstr = "msg";
 187       break;
 188     case _EVENT_LOG_WARN:
 189       sevstr = "warn";
 190       break;
 191     case _EVENT_LOG_ERR:
 192       sevstr = "err";
 193       break;
 194     default:
 195       sevstr = "???";
 196       break;
 197     }
 198   fprintf (stderr, "libevent: [%s] %s\n", sevstr, msg);
 199 }
 200 #endif  /* DEBUG */
 201
 202 static int
 203 _init_evb (struct rs_connection *conn)
 204 {
 205   if (!conn->evb)
 206     {
 207 #if defined (DEBUG)
 208       event_enable_debug_mode ();
 209       event_set_log_callback (_evlog_cb);
 210 #endif
 211       conn->evb = event_base_new ();
 212       if (!conn->evb)
 213         return rs_conn_err_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 214                                     "event_base_new");
 215     }
 216   return RSE_OK;
 217 }
 218
 219 static int
 220 _init_socket (struct rs_connection *conn, struct rs_peer *p)
 221 {
 222   if (p->fd != -1)
 223     return RSE_OK;
 224
 225   assert (p->addr);
 226   p->fd = socket (p->addr->ai_family, p->addr->ai_socktype,
 227                   p->addr->ai_protocol);
 228   if (p->fd < 0)
 229     return rs_conn_err_push_fl (conn, RSE_SOME_ERROR, __FILE__, __LINE__,
 230                                 strerror (errno));
 231   if (evutil_make_socket_nonblocking (p->fd) < 0)
 232     {
 233       evutil_closesocket (p->fd);
 234       return rs_conn_err_push_fl (conn, RSE_SOME_ERROR, __FILE__, __LINE__,
 235                                   strerror (errno));
 236     }
 237   return RSE_OK;
 238 }
 239
 240 static struct rs_peer *
 241 _pick_peer (struct rs_connection *conn)
 242 {
 243   if (!conn->active_peer)
 244     conn->active_peer = conn->peers;
 245   return conn->active_peer;
 246 }
 247
 248 static int
 249 _init_bev (struct rs_connection *conn, struct rs_peer *peer)
 250 {
 251   if (!conn->bev)
 252     {
 253       conn->bev = bufferevent_socket_new (conn->evb, peer->fd, 0);
 254       if (!conn->bev)
 255         return rs_conn_err_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 256                                     "bufferevent_socket_new");
 257     }
 258   return RSE_OK;
 259 }
 260
 261 static void
 262 _do_connect (struct rs_peer *p)
 263 {
 264   int err;
 265
 266   err = bufferevent_socket_connect (p->conn->bev, p->addr->ai_addr,
 267                                     p->addr->ai_addrlen);
 268   if (err < 0)
 269     rs_conn_err_push_fl (p->conn, RSE_EVENT, __FILE__, __LINE__,
 270                          "bufferevent_socket_connect: %s",
 271                          evutil_gai_strerror(err));
 272   else
 273     p->is_connecting = 1;
 274 }
 275
 276 static int
 277 _conn_open(struct rs_connection *conn, struct rs_packet *pkt)
 278 {
 279   struct rs_peer *p;
 280
 281   if (_init_evb (conn))
 282     return -1;
 283
 284   p = _pick_peer (conn);
 285   if (!p)
 286     return rs_conn_err_push_fl (conn, RSE_NOPEER, __FILE__, __LINE__, NULL);
 287
 288   if (_init_socket (conn, p))
 289     return -1;
 290
 291   if (_init_bev (conn, p))
 292     return -1;
 293
 294   if (!p->is_connected)
 295     if (!p->is_connecting)
 296       _do_connect (p);
 297
 298   return RSE_OK;
 299 }
 300
 301 static int
 302 _conn_is_open_p (struct rs_connection *conn)
 303 {
 304   return conn->active_peer && conn->active_peer->is_connected;
 305 }
 306
 307 /* Public functions.  */
 308 int
 309 rs_packet_create_acc_request (struct rs_connection *conn,
 310                               struct rs_packet **pkt_out,
 311                               const char *user_name, const char *user_pw)
 312 {
 313   struct rs_packet *pkt;
 314   struct rs_attr *attr;
 315
 316   if (_packet_create (conn, pkt_out))
 317     return -1;
 318   pkt = *pkt_out;
 319   pkt->rpkt->code = PW_AUTHENTICATION_REQUEST;
 320
 321   if (rs_attr_create (conn, &attr, "User-Name", user_name))
 322     return -1;
 323   rs_packet_add_attr (pkt, attr);
 324
 325   if (rs_attr_create (conn, &attr, "User-Password", user_pw))
 326     return -1;
 327   /* FIXME: need this too? rad_pwencode(user_pw, &pwlen, SECRET, reqauth) */
 328   rs_packet_add_attr (pkt, attr);
 329
 330   return RSE_OK;
 331 }
 332
 333 int
 334 rs_packet_send (struct rs_packet *pkt, void *user_data)
 335 {
 336   struct rs_connection *conn;
 337   assert (pkt);
 338   conn = pkt->conn;
 339
 340   if (_conn_is_open_p (conn))
 341     _do_send (pkt);
 342   else
 343     if (_conn_open (conn, pkt))
 344       return -1;
 345
 346   assert (conn->evb);
 347   assert (conn->bev);
 348   assert (conn->active_peer);
 349   assert (conn->active_peer->fd >= 0);
 350
 351   if (conn->callbacks.connected_cb || conn->callbacks.disconnected_cb
 352       || conn->callbacks.received_cb || conn->callbacks.sent_cb)
 353     ;           /* FIXME: install event callbacks, other than below */
 354   else
 355     {
 356       bufferevent_setcb (conn->bev, _read_cb, _write_cb, _event_cb, pkt);
 357       event_base_dispatch (conn->evb);
 358     }
 359
 360 #if defined (DEBUG)
 361   fprintf (stderr, "%s: event loop done\n", __func__);
 362   assert (event_base_got_break(conn->evb));
 363 #endif
 364
 365   return RSE_OK;
 366 }
 367
 368 int
 369 rs_conn_receive_packet (struct rs_connection *conn, struct rs_packet **pkt_out)
 370 {
 371   struct rs_packet *pkt;
 372
 373   assert (conn);
 374
 375   if (_packet_create (conn, pkt_out))
 376     return -1;
 377   pkt = *pkt_out;
 378   pkt->conn = conn;
 379
 380   if (_conn_open (conn, pkt))
 381     return -1;
 382   assert (conn->evb);
 383   assert (conn->bev);
 384   assert (conn->active_peer);
 385   assert (conn->active_peer->fd >= 0);
 386
 387   bufferevent_setwatermark (conn->bev, EV_READ, RS_HEADER_LEN, 0);
 388   bufferevent_enable (conn->bev, EV_READ);
 389   event_base_dispatch (conn->evb);
 390 #if defined (DEBUG)
 391   fprintf (stderr, "%s: event loop done", __func__);
 392   if (event_base_got_break(conn->evb))
 393     {
 394       fprintf (stderr, ", got this:\n");
 395       rs_dump_packet (pkt);
 396     }
 397   else
 398     fprintf (stderr, ", no reply\n");
 399 #endif
 400
 401   return RSE_OK;
 402 }
 403
 404 void
 405 rs_packet_add_attr(struct rs_packet *pkt, struct rs_attr *attr)
 406 {
 407   pairadd (&pkt->rpkt->vps, attr->vp);
 408   attr->pkt = pkt;
 409 }
 410
 411 struct radius_packet *
 412 rs_packet_frpkt(struct rs_packet *pkt)
 413 {
 414   assert (pkt);
 415   return pkt->rpkt;
 416 }
 417
 418 void
 419 rs_packet_destroy(struct rs_packet *pkt)
 420 {
 421   rad_free (&pkt->rpkt);
 422   rs_free (pkt->conn->ctx, pkt);
 423 }