lib/packet.c

   1 /* See the file COPYING for licensing information.  */
   2
   3 #if defined HAVE_CONFIG_H
   4 #include <config.h>
   5 #endif
   6
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <assert.h>
  10 #include <freeradius/libradius.h>
  11 #include <event2/event.h>
  12 #include <event2/bufferevent.h>
  13 #if defined RS_ENABLE_TLS
  14 #include <event2/bufferevent_ssl.h>
  15 #include <openssl/err.h>
  16 #endif
  17 #include <radsec/radsec.h>
  18 #include <radsec/radsec-impl.h>
  19 #include "tls.h"
  20 #if defined DEBUG
  21 #include <netdb.h>
  22 #include <sys/socket.h>
  23 #include "debug.h"
  24 #endif
  25
  26 static int
  27 _packet_create (struct rs_connection *conn, struct rs_packet **pkt_out)
  28 {
  29   struct rs_packet *p;
  30   RADIUS_PACKET *rpkt;
  31
  32   *pkt_out = NULL;
  33
  34   rpkt = rad_alloc (1);
  35   if (!rpkt)
  36     return rs_err_conn_push (conn, RSE_NOMEM, __func__);
  37   rpkt->id = conn->nextid++;
  38
  39   p = (struct rs_packet *) malloc (sizeof (struct rs_packet));
  40   if (!p)
  41     {
  42       rad_free (&rpkt);
  43       return rs_err_conn_push (conn, RSE_NOMEM, __func__);
  44     }
  45   memset (p, 0, sizeof (struct rs_packet));
  46   p->conn = conn;
  47   p->rpkt = rpkt;
  48
  49   *pkt_out = p;
  50   return RSE_OK;
  51 }
  52
  53 static int
  54 _do_send (struct rs_packet *pkt)
  55 {
  56   int err;
  57   VALUE_PAIR *vp;
  58
  59   assert (pkt->rpkt);
  60   assert (!pkt->original);
  61
  62   vp = paircreate (PW_MESSAGE_AUTHENTICATOR, PW_TYPE_OCTETS);
  63   if (!vp)
  64     return rs_err_conn_push_fl (pkt->conn, RSE_NOMEM, __FILE__, __LINE__,
  65                                 "rad_encode: %s", fr_strerror ());
  66   pairadd (&pkt->rpkt->vps, vp);
  67
  68   if (rad_encode (pkt->rpkt, NULL, pkt->conn->active_peer->secret))
  69     return rs_err_conn_push_fl (pkt->conn, RSE_FR, __FILE__, __LINE__,
  70                                 "rad_encode: %s", fr_strerror ());
  71   if (rad_sign (pkt->rpkt, NULL, pkt->conn->active_peer->secret))
  72     return rs_err_conn_push_fl (pkt->conn, RSE_FR, __FILE__, __LINE__,
  73                                 "rad_sign: %s", fr_strerror ());
  74 #if defined (DEBUG)
  75   {
  76     char host[80], serv[80];
  77
  78     getnameinfo (pkt->conn->active_peer->addr->ai_addr,
  79                  pkt->conn->active_peer->addr->ai_addrlen,
  80                  host, sizeof(host), serv, sizeof(serv),
  81                  0 /* NI_NUMERICHOST|NI_NUMERICSERV*/);
  82     fprintf (stderr, "%s: about to send this to %s:%s:\n", __func__, host,
  83              serv);
  84     rs_dump_packet (pkt);
  85   }
  86 #endif
  87   err = bufferevent_write (pkt->conn->bev, pkt->rpkt->data,
  88                            pkt->rpkt->data_len);
  89   if (err < 0)
  90     return rs_err_conn_push_fl (pkt->conn, RSE_EVENT, __FILE__, __LINE__,
  91                                 "bufferevent_write: %s",
  92                                 evutil_gai_strerror(err));
  93   return RSE_OK;
  94 }
  95
  96 static void
  97 _event_cb (struct bufferevent *bev, short events, void *ctx)
  98 {
  99   struct rs_packet *pkt = (struct rs_packet *)ctx;
 100   struct rs_connection *conn;
 101   struct rs_peer *p;
 102   unsigned long err;
 103
 104   assert (pkt);
 105   assert (pkt->conn);
 106   assert (pkt->conn->active_peer);
 107   conn = pkt->conn;
 108   p = conn->active_peer;
 109
 110   p->is_connecting = 0;
 111   if (events & BEV_EVENT_CONNECTED)
 112     {
 113       p->is_connected = 1;
 114       if (conn->callbacks.connected_cb)
 115         conn->callbacks.connected_cb (conn->user_data);
 116 #if defined (DEBUG)
 117       fprintf (stderr, "%s: connected\n", __func__);
 118 #endif
 119       if (_do_send (pkt))
 120         return;
 121       if (conn->callbacks.sent_cb)
 122         conn->callbacks.sent_cb (conn->user_data);
 123       /* Packet will be freed in write callback.  */
 124     }
 125   else if (events & BEV_EVENT_ERROR)
 126     {
 127 #if defined RS_ENABLE_TLS
 128       if (conn->tls_ssl)        /* FIXME: correct check?  */
 129         {
 130           for (err = bufferevent_get_openssl_error (conn->bev);
 131                err;
 132                err = bufferevent_get_openssl_error (conn->bev))
 133             {
 134               fprintf (stderr, "%s: openssl error: %s\n", __func__,
 135                        ERR_error_string (err, NULL)); /* DEBUG, until verified that pushed errors will actually be handled  */
 136               rs_err_conn_push_fl (pkt->conn, RSE_SSLERR, __FILE__, __LINE__,
 137                                    "%d", err);
 138             }
 139         }
 140 #endif
 141       rs_err_conn_push_fl (pkt->conn, RSE_CONNERR, __FILE__, __LINE__, NULL);
 142       fprintf (stderr, "%s: BEV_EVENT_ERROR\n", __func__); /* DEBUG, until verified that pushed errors will actually be handled  */
 143     }
 144 }
 145
 146 static void
 147 _write_cb (struct bufferevent *bev, void *ctx)
 148 {
 149   struct rs_packet *pkt = (struct rs_packet *) ctx;
 150
 151   assert (pkt);
 152   assert (pkt->conn);
 153 #if defined (DEBUG)
 154   fprintf (stderr, "%s: packet written, breaking event loop\n", __func__);
 155 #endif
 156   if (event_base_loopbreak (pkt->conn->evb) < 0)
 157     abort ();                   /* FIXME */
 158   if (!pkt->conn->callbacks.sent_cb) /* Callback owns the packet now.  */
 159     rs_packet_destroy (pkt);
 160 }
 161
 162 static void
 163 _read_cb (struct bufferevent *bev, void *ctx)
 164 {
 165   struct rs_packet *pkt = (struct rs_packet *)ctx;
 166   size_t n;
 167
 168   assert (pkt);
 169   assert (pkt->conn);
 170
 171   pkt->rpkt->sockfd = pkt->conn->active_peer->fd; /* FIXME: Why?  */
 172   pkt->rpkt->vps = NULL;                          /* FIXME: Why?  */
 173
 174   if (!pkt->hdr_read_flag)
 175     {
 176       n = bufferevent_read (pkt->conn->bev, pkt->hdr, RS_HEADER_LEN);
 177       if (n == RS_HEADER_LEN)
 178         {
 179           pkt->hdr_read_flag = 1;
 180           pkt->rpkt->data_len = (pkt->hdr[2] << 8) + pkt->hdr[3];
 181           if (pkt->rpkt->data_len < 20 /* || len > 4096 */)
 182             abort ();           /* FIXME: Read and discard packet.  */
 183           pkt->rpkt->data = rs_malloc (pkt->conn->ctx, pkt->rpkt->data_len);
 184           if (!pkt->rpkt->data)
 185             {
 186               rs_err_conn_push_fl (pkt->conn, RSE_NOMEM, __FILE__, __LINE__,
 187                                    NULL);
 188               abort ();         /* FIXME: Read and discard packet.  */
 189             }
 190           memcpy (pkt->rpkt->data, pkt->hdr, RS_HEADER_LEN);
 191           bufferevent_setwatermark (pkt->conn->bev, EV_READ,
 192                                     pkt->rpkt->data_len - RS_HEADER_LEN, 0);
 193 #if defined (DEBUG)
 194           fprintf (stderr, "%s: packet header read, total pkt len=%d\n",
 195                    __func__, pkt->rpkt->data_len);
 196 #endif
 197         }
 198       else if (n < 0)
 199         return;                 /* Buffer frozen.  */
 200       else
 201         assert (!"short header");
 202     }
 203
 204 #if defined (DEBUG)
 205   printf ("%s: trying to read %d octets of packet data\n", __func__, pkt->rpkt->data_len - RS_HEADER_LEN);
 206 #endif
 207   n = bufferevent_read (pkt->conn->bev, pkt->rpkt->data + RS_HEADER_LEN, pkt->rpkt->data_len - RS_HEADER_LEN);
 208 #if defined (DEBUG)
 209   printf ("%s: read %d octets of packet data\n", __func__, n);
 210 #endif
 211   if (n == pkt->rpkt->data_len - RS_HEADER_LEN)
 212     {
 213       bufferevent_disable (pkt->conn->bev, EV_READ);
 214       pkt->hdr_read_flag = 0;
 215       memset (pkt->hdr, 0, sizeof(*pkt->hdr));
 216 #if defined (DEBUG)
 217       fprintf (stderr, "%s: complete packet read\n", __func__);
 218 #endif
 219       if (!rad_packet_ok (pkt->rpkt, 0) != 0)
 220         return;
 221       assert (pkt->original);
 222
 223       /* Verify header and message authenticator.  */
 224       if (rad_verify (pkt->rpkt, pkt->original->rpkt,
 225                       pkt->conn->active_peer->secret))
 226         {
 227           rs_err_conn_push_fl (pkt->conn, RSE_FR, __FILE__, __LINE__,
 228                                "rad_verify: %s", fr_strerror ());
 229           return;
 230         }
 231
 232       /* Decode and decrypt.  */
 233       if (rad_decode (pkt->rpkt, pkt->original->rpkt,
 234                       pkt->conn->active_peer->secret))
 235         {
 236           rs_err_conn_push_fl (pkt->conn, RSE_FR, __FILE__, __LINE__,
 237                                "rad_decode: %s", fr_strerror ());
 238           return;
 239         }
 240
 241       if (pkt->conn->callbacks.received_cb)
 242         pkt->conn->callbacks.received_cb (pkt, pkt->conn->user_data);
 243
 244       if (event_base_loopbreak (pkt->conn->evb) < 0)
 245         abort ();               /* FIXME */
 246     }
 247   else if (n < 0)
 248     return;                     /* Buffer frozen.  */
 249   else
 250     assert (!"short packet");
 251 }
 252
 253 static void
 254 _evlog_cb (int severity, const char *msg)
 255 {
 256   const char *sevstr;
 257   switch (severity)
 258     {
 259     case _EVENT_LOG_DEBUG:
 260 #if !defined (DEBUG_LEVENT)
 261       return;
 262 #endif
 263       sevstr = "debug";
 264       break;
 265     case _EVENT_LOG_MSG:
 266       sevstr = "msg";
 267       break;
 268     case _EVENT_LOG_WARN:
 269       sevstr = "warn";
 270       break;
 271     case _EVENT_LOG_ERR:
 272       sevstr = "err";
 273       break;
 274     default:
 275       sevstr = "???";
 276       break;
 277     }
 278   fprintf (stderr, "libevent: [%s] %s\n", sevstr, msg);
 279 }
 280
 281 static int
 282 _init_evb (struct rs_connection *conn)
 283 {
 284   if (!conn->evb)
 285     {
 286 #if defined (DEBUG)
 287       event_enable_debug_mode ();
 288 #endif
 289       event_set_log_callback (_evlog_cb);
 290       conn->evb = event_base_new ();
 291       if (!conn->evb)
 292         return rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 293                                     "event_base_new");
 294     }
 295   return RSE_OK;
 296 }
 297
 298 static int
 299 _init_socket (struct rs_connection *conn, struct rs_peer *p)
 300 {
 301   if (p->fd != -1)
 302     return RSE_OK;
 303
 304   assert (p->addr);
 305   p->fd = socket (p->addr->ai_family, p->addr->ai_socktype,
 306                   p->addr->ai_protocol);
 307   if (p->fd < 0)
 308     return rs_err_conn_push_fl (conn, RSE_SOME_ERROR, __FILE__, __LINE__,
 309                                 strerror (errno));
 310   if (evutil_make_socket_nonblocking (p->fd) < 0)
 311     {
 312       evutil_closesocket (p->fd);
 313       return rs_err_conn_push_fl (conn, RSE_SOME_ERROR, __FILE__, __LINE__,
 314                                   strerror (errno));
 315     }
 316   return RSE_OK;
 317 }
 318
 319 static struct rs_peer *
 320 _pick_peer (struct rs_connection *conn)
 321 {
 322   if (!conn->active_peer)
 323     conn->active_peer = conn->peers;
 324   return conn->active_peer;
 325 }
 326
 327 static int
 328 _init_bev (struct rs_connection *conn, struct rs_peer *peer)
 329 {
 330   if (conn->bev)
 331     return RSE_OK;
 332
 333   switch (conn->type)
 334     {
 335     case RS_CONN_TYPE_UDP:
 336     case RS_CONN_TYPE_TCP:
 337       conn->bev = bufferevent_socket_new (conn->evb, peer->fd, 0);
 338       if (!conn->bev)
 339         return rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 340                                     "bufferevent_socket_new");
 341       break;
 342     case RS_CONN_TYPE_TLS:
 343       if (rs_tls_init (conn))
 344         return -1;
 345       /* Would be convenient to pass BEV_OPT_CLOSE_ON_FREE but things
 346          seem to break when be_openssl_ctrl() (in libevent) calls
 347          SSL_set_bio() after BIO_new_socket() with flag=1.  */
 348       conn->bev =
 349         bufferevent_openssl_socket_new (conn->evb, peer->fd, conn->tls_ssl,
 350                                         BUFFEREVENT_SSL_CONNECTING, 0);
 351       if (!conn->bev)
 352         return rs_err_conn_push_fl (conn, RSE_EVENT, __FILE__, __LINE__,
 353                                     "bufferevent_openssl_socket_new");
 354
 355       break;
 356     case RS_CONN_TYPE_DTLS:
 357       return rs_err_conn_push_fl (conn, RSE_NOSYS, __FILE__, __LINE__,
 358                                   "%s: NYI", __func__);
 359     default:
 360       return rs_err_conn_push_fl (conn, RSE_INTERNAL, __FILE__, __LINE__,
 361                                   "%s: invalid connection type: %d", __func__,
 362                                   conn->type);
 363     }
 364
 365   return RSE_OK;
 366 }
 367
 368 static void
 369 _do_connect (struct rs_peer *p)
 370 {
 371   int err;
 372
 373   err = bufferevent_socket_connect (p->conn->bev, p->addr->ai_addr,
 374                                     p->addr->ai_addrlen);
 375   if (err < 0)
 376     rs_err_conn_push_fl (p->conn, RSE_EVENT, __FILE__, __LINE__,
 377                          "bufferevent_socket_connect: %s",
 378                          evutil_gai_strerror(err));
 379   else
 380     p->is_connecting = 1;
 381 }
 382
 383 static int
 384 _conn_open(struct rs_connection *conn, struct rs_packet *pkt)
 385 {
 386   struct rs_peer *p;
 387
 388   if (_init_evb (conn))
 389     return -1;
 390
 391   p = _pick_peer (conn);
 392   if (!p)
 393     return rs_err_conn_push_fl (conn, RSE_NOPEER, __FILE__, __LINE__, NULL);
 394
 395   if (_init_socket (conn, p))
 396     return -1;
 397
 398   if (_init_bev (conn, p))
 399     return -1;
 400
 401   if (!p->is_connected)
 402     if (!p->is_connecting)
 403       _do_connect (p);
 404
 405   return RSE_OK;
 406 }
 407
 408 static int
 409 _conn_is_open_p (struct rs_connection *conn)
 410 {
 411   return conn->active_peer && conn->active_peer->is_connected;
 412 }
 413
 414 /* Public functions.  */
 415 int
 416 rs_packet_create_acc_request (struct rs_connection *conn,
 417                               struct rs_packet **pkt_out,
 418                               const char *user_name, const char *user_pw)
 419 {
 420   struct rs_packet *pkt;
 421   struct rs_attr *attr;
 422
 423   if (_packet_create (conn, pkt_out))
 424     return -1;
 425   pkt = *pkt_out;
 426   pkt->rpkt->code = PW_AUTHENTICATION_REQUEST;
 427
 428   if (user_name)
 429     {
 430       if (rs_attr_create (conn, &attr, "User-Name", user_name))
 431         return -1;
 432       rs_packet_add_attr (pkt, attr);
 433
 434       if (user_pw)
 435         {
 436           if (rs_attr_create (conn, &attr, "User-Password", user_pw))
 437             return -1;
 438           /* FIXME: need this too? rad_pwencode(user_pw, &pwlen, SECRET, reqauth) */
 439           rs_packet_add_attr (pkt, attr);
 440         }
 441     }
 442
 443   return RSE_OK;
 444 }
 445
 446 int
 447 rs_packet_send (struct rs_packet *pkt, void *user_data)
 448 {
 449   struct rs_connection *conn;
 450
 451   assert (pkt);
 452   conn = pkt->conn;
 453
 454   if (_conn_is_open_p (conn))
 455     _do_send (pkt);
 456   else
 457     if (_conn_open (conn, pkt))
 458       return -1;
 459
 460   assert (conn->evb);
 461   assert (conn->bev);
 462   assert (conn->active_peer);
 463   assert (conn->active_peer->fd >= 0);
 464
 465   conn->user_data = user_data;
 466   bufferevent_setcb (conn->bev, _read_cb, _write_cb, _event_cb, pkt);
 467   if (!conn->user_dispatch_flag)
 468     event_base_dispatch (conn->evb);
 469
 470 #if defined (DEBUG)
 471   fprintf (stderr, "%s: event loop done\n", __func__);
 472   assert (event_base_got_break(conn->evb));
 473 #endif
 474
 475   return RSE_OK;
 476 }
 477
 478 int
 479 rs_conn_receive_packet (struct rs_connection *conn,
 480                         struct rs_packet *request,
 481                         struct rs_packet **pkt_out)
 482 {
 483   struct rs_packet *pkt;
 484
 485   assert (conn);
 486
 487   if (_packet_create (conn, pkt_out))
 488     return -1;
 489   pkt = *pkt_out;
 490   pkt->conn = conn;
 491   pkt->original = request;
 492
 493   if (_conn_open (conn, pkt))
 494     return -1;
 495   assert (conn->evb);
 496   assert (conn->bev);
 497   assert (conn->active_peer);
 498   assert (conn->active_peer->fd >= 0);
 499
 500   bufferevent_setwatermark (conn->bev, EV_READ, RS_HEADER_LEN, 0);
 501   bufferevent_enable (conn->bev, EV_READ);
 502   bufferevent_setcb (conn->bev, _read_cb, _write_cb, _event_cb, pkt);
 503
 504   if (!conn->user_dispatch_flag)
 505     {
 506       event_base_dispatch (conn->evb);
 507 #if defined (DEBUG)
 508       fprintf (stderr, "%s: event loop done", __func__);
 509       if (event_base_got_break(conn->evb))
 510         {
 511           fprintf (stderr, ", got this:\n");
 512           rs_dump_packet (pkt);
 513         }
 514       else
 515         fprintf (stderr, ", no reply\n");
 516 #endif
 517     }
 518
 519   pkt->original = NULL;
 520
 521   return RSE_OK;
 522 }
 523
 524 void
 525 rs_packet_add_attr(struct rs_packet *pkt, struct rs_attr *attr)
 526 {
 527   pairadd (&pkt->rpkt->vps, attr->vp);
 528   attr->pkt = pkt;
 529 }
 530
 531 struct radius_packet *
 532 rs_packet_frpkt(struct rs_packet *pkt)
 533 {
 534   assert (pkt);
 535   return pkt->rpkt;
 536 }
 537
 538 void
 539 rs_packet_destroy(struct rs_packet *pkt)
 540 {
 541   if (pkt)
 542     {
 543       // TODO: free all attributes
 544       rad_free (&pkt->rpkt);
 545       rs_free (pkt->conn->ctx, pkt);
 546     }
 547 }