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