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