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_err_conn_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_err_conn_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_err_conn_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_err_conn_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_err_conn_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 static void
 176 _evlog_cb (int severity, const char *msg)
 177 {
 178   const char *sevstr;
 179   switch (severity)
 180     {
 181     case _EVENT_LOG_DEBUG:
 182 #if !defined (DEBUG_LEVENT)
 183       return;
 184 #endif
 185       sevstr = "debug";
 186       break;
 187     case _EVENT_LOG_MSG:
 188       sevstr = "msg";
 189       break;
 190     case _EVENT_LOG_WARN:
 191       sevstr = "warn";
 192       break;
 193     case _EVENT_LOG_ERR:
 194       sevstr = "err";
 195       break;
 196     default:
 197       sevstr = "???";
 198       break;
 199     }
 200   fprintf (stderr, "libevent: [%s] %s\n", sevstr, msg);
 201 }
 202
 203 static int
 204 _init_evb (struct rs_connection *conn)
 205 {
 206   if (!conn->evb)
 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 }
 219
 220 static int
 221 _init_socket (struct rs_connection *conn, struct rs_peer *p)
 222 {
 223   if (p->fd != -1)
 224     return RSE_OK;
 225
 226   assert (p->addr);
 227   p->fd = socket (p->addr->ai_family, p->addr->ai_socktype,
 228                   p->addr->ai_protocol);
 229   if (p->fd < 0)
 230     return rs_err_conn_push_fl (conn, RSE_SOME_ERROR, __FILE__, __LINE__,
 231                                 strerror (errno));
 232   if (evutil_make_socket_nonblocking (p->fd) < 0)
 233     {
 234       evutil_closesocket (p->fd);
 235       return rs_err_conn_push_fl (conn, RSE_SOME_ERROR, __FILE__, __LINE__,
 236                                   strerror (errno));
 237     }
 238   return RSE_OK;
 239 }
 240
 241 static struct rs_peer *
 242 _pick_peer (struct rs_connection *conn)
 243 {
 244   if (!conn->active_peer)
 245     conn->active_peer = conn->peers;
 246   return conn->active_peer;
 247 }
 248
 249 static int
 250 _init_bev (struct rs_connection *conn, struct rs_peer *peer)
 251 {
 252   if (!conn->bev)
 253     {
 254       conn->bev = bufferevent_socket_new (conn->evb, peer->fd, 0);
 255       if (!conn->bev)
 256         return rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 257                                     "bufferevent_socket_new");
 258     }
 259   return RSE_OK;
 260 }
 261
 262 static void
 263 _do_connect (struct rs_peer *p)
 264 {
 265   int err;
 266
 267   err = bufferevent_socket_connect (p->conn->bev, p->addr->ai_addr,
 268                                     p->addr->ai_addrlen);
 269   if (err < 0)
 270     rs_err_conn_push_fl (p->conn, RSE_EVENT, __FILE__, __LINE__,
 271                          "bufferevent_socket_connect: %s",
 272                          evutil_gai_strerror(err));
 273   else
 274     p->is_connecting = 1;
 275 }
 276
 277 static int
 278 _conn_open(struct rs_connection *conn, struct rs_packet *pkt)
 279 {
 280   struct rs_peer *p;
 281
 282   if (_init_evb (conn))
 283     return -1;
 284
 285   p = _pick_peer (conn);
 286   if (!p)
 287     return rs_err_conn_push_fl (conn, RSE_NOPEER, __FILE__, __LINE__, NULL);
 288
 289   if (_init_socket (conn, p))
 290     return -1;
 291
 292   if (_init_bev (conn, p))
 293     return -1;
 294
 295   if (!p->is_connected)
 296     if (!p->is_connecting)
 297       _do_connect (p);
 298
 299   return RSE_OK;
 300 }
 301
 302 static int
 303 _conn_is_open_p (struct rs_connection *conn)
 304 {
 305   return conn->active_peer && conn->active_peer->is_connected;
 306 }
 307
 308 /* Public functions.  */
 309 int
 310 rs_packet_create_acc_request (struct rs_connection *conn,
 311                               struct rs_packet **pkt_out,
 312                               const char *user_name, const char *user_pw)
 313 {
 314   struct rs_packet *pkt;
 315   struct rs_attr *attr;
 316
 317   if (_packet_create (conn, pkt_out))
 318     return -1;
 319   pkt = *pkt_out;
 320   pkt->rpkt->code = PW_AUTHENTICATION_REQUEST;
 321
 322   if (rs_attr_create (conn, &attr, "User-Name", user_name))
 323     return -1;
 324   rs_packet_add_attr (pkt, attr);
 325
 326   if (rs_attr_create (conn, &attr, "User-Password", user_pw))
 327     return -1;
 328   /* FIXME: need this too? rad_pwencode(user_pw, &pwlen, SECRET, reqauth) */
 329   rs_packet_add_attr (pkt, attr);
 330
 331   return RSE_OK;
 332 }
 333
 334 int
 335 rs_packet_send (struct rs_packet *pkt, void *user_data)
 336 {
 337   struct rs_connection *conn;
 338   assert (pkt);
 339   conn = pkt->conn;
 340
 341   if (_conn_is_open_p (conn))
 342     _do_send (pkt);
 343   else
 344     if (_conn_open (conn, pkt))
 345       return -1;
 346
 347   assert (conn->evb);
 348   assert (conn->bev);
 349   assert (conn->active_peer);
 350   assert (conn->active_peer->fd >= 0);
 351
 352   if (conn->callbacks.connected_cb || conn->callbacks.disconnected_cb
 353       || conn->callbacks.received_cb || conn->callbacks.sent_cb)
 354     ;           /* FIXME: install event callbacks, other than below */
 355   else
 356     {
 357       bufferevent_setcb (conn->bev, _read_cb, _write_cb, _event_cb, pkt);
 358       event_base_dispatch (conn->evb);
 359     }
 360
 361 #if defined (DEBUG)
 362   fprintf (stderr, "%s: event loop done\n", __func__);
 363   assert (event_base_got_break(conn->evb));
 364 #endif
 365
 366   return RSE_OK;
 367 }
 368
 369 int
 370 rs_conn_receive_packet (struct rs_connection *conn, struct rs_packet **pkt_out)
 371 {
 372   struct rs_packet *pkt;
 373
 374   assert (conn);
 375
 376   if (_packet_create (conn, pkt_out))
 377     return -1;
 378   pkt = *pkt_out;
 379   pkt->conn = conn;
 380
 381   if (_conn_open (conn, pkt))
 382     return -1;
 383   assert (conn->evb);
 384   assert (conn->bev);
 385   assert (conn->active_peer);
 386   assert (conn->active_peer->fd >= 0);
 387
 388   bufferevent_setwatermark (conn->bev, EV_READ, RS_HEADER_LEN, 0);
 389   bufferevent_enable (conn->bev, EV_READ);
 390   event_base_dispatch (conn->evb);
 391 #if defined (DEBUG)
 392   fprintf (stderr, "%s: event loop done", __func__);
 393   if (event_base_got_break(conn->evb))
 394     {
 395       fprintf (stderr, ", got this:\n");
 396       rs_dump_packet (pkt);
 397     }
 398   else
 399     fprintf (stderr, ", no reply\n");
 400 #endif
 401
 402   return RSE_OK;
 403 }
 404
 405 void
 406 rs_packet_add_attr(struct rs_packet *pkt, struct rs_attr *attr)
 407 {
 408   pairadd (&pkt->rpkt->vps, attr->vp);
 409   attr->pkt = pkt;
 410 }
 411
 412 struct radius_packet *
 413 rs_packet_frpkt(struct rs_packet *pkt)
 414 {
 415   assert (pkt);
 416   return pkt->rpkt;
 417 }
 418
 419 void
 420 rs_packet_destroy(struct rs_packet *pkt)
 421 {
 422   if (pkt)
 423     {
 424       rad_free (&pkt->rpkt);
 425       rs_free (pkt->conn->ctx, pkt);
 426     }
 427 }