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