lib/packet.c

   1 /* Copyright 2010, 2011 NORDUnet A/S. All rights reserved.
   2    See the file COPYING for licensing information.  */
   3
   4 #if defined HAVE_CONFIG_H
   5 #include <config.h>
   6 #endif
   7
   8 #include <assert.h>
   9 #include <radius/client.h>
  10 #include <event2/bufferevent.h>
  11 #include <radsec/radsec.h>
  12 #include <radsec/radsec-impl.h>
  13 #include "conn.h"
  14 #include "debug.h"
  15 #include "packet.h"
  16
  17 #if defined (DEBUG)
  18 #include <netdb.h>
  19 #include <sys/socket.h>
  20 #include <event2/buffer.h>
  21 #endif
  22
  23 int
  24 packet_verify_response (struct rs_connection *conn,
  25                         struct rs_packet *response,
  26                         struct rs_packet *request)
  27 {
  28   int err;
  29
  30   assert (conn);
  31   assert (conn->active_peer);
  32   assert (conn->active_peer->secret);
  33   assert (response);
  34   assert (response->rpkt);
  35   assert (request);
  36   assert (request->rpkt);
  37
  38   response->rpkt->secret = conn->active_peer->secret;
  39   response->rpkt->sizeof_secret = strlen (conn->active_peer->secret);
  40
  41   /* Verify header and message authenticator.  */
  42   err = nr_packet_verify (response->rpkt, request->rpkt);
  43   if (err)
  44     {
  45       if (conn->is_connected)
  46         rs_conn_disconnect(conn);
  47       return rs_err_conn_push_fl (conn, -err, __FILE__, __LINE__,
  48                                   "nr_packet_verify");
  49     }
  50
  51   /* Decode and decrypt.  */
  52   err = nr_packet_decode (response->rpkt, request->rpkt);
  53   if (err)
  54     {
  55       if (conn->is_connected)
  56         rs_conn_disconnect(conn);
  57       return rs_err_conn_push_fl (conn, -err, __FILE__, __LINE__,
  58                                   "nr_packet_decode");
  59     }
  60
  61   return RSE_OK;
  62 }
  63
  64
  65 /* Badly named function for preparing a RADIUS message and queue it.
  66    FIXME: Rename.  */
  67 int
  68 packet_do_send (struct rs_packet *pkt)
  69 {
  70   int err;
  71
  72   assert (pkt);
  73   assert (pkt->conn);
  74   assert (pkt->conn->active_peer);
  75   assert (pkt->conn->active_peer->secret);
  76   assert (pkt->rpkt);
  77
  78   pkt->rpkt->secret = pkt->conn->active_peer->secret;
  79   pkt->rpkt->sizeof_secret = strlen (pkt->rpkt->secret);
  80
  81   /* Encode message.  */
  82   err = nr_packet_encode (pkt->rpkt, NULL);
  83   if (err < 0)
  84     return rs_err_conn_push_fl (pkt->conn, -err, __FILE__, __LINE__,
  85                                 "nr_packet_encode");
  86   /* Sign message.  */
  87   err = nr_packet_sign (pkt->rpkt, NULL);
  88   if (err < 0)
  89     return rs_err_conn_push_fl (pkt->conn, -err, __FILE__, __LINE__,
  90                                 "nr_packet_sign");
  91 #if defined (DEBUG)
  92   {
  93     char host[80], serv[80];
  94
  95     getnameinfo (pkt->conn->active_peer->addr_cache->ai_addr,
  96                  pkt->conn->active_peer->addr_cache->ai_addrlen,
  97                  host, sizeof(host), serv, sizeof(serv),
  98                  0 /* NI_NUMERICHOST|NI_NUMERICSERV*/);
  99     rs_debug (("%s: about to send this to %s:%s:\n", __func__, host, serv));
 100     rs_dump_packet (pkt);
 101   }
 102 #endif
 103
 104   /* Put message in output buffer.  */
 105   if (pkt->conn->bev)           /* TCP.  */
 106     {
 107       int err = bufferevent_write (pkt->conn->bev, pkt->rpkt->data,
 108                                    pkt->rpkt->length);
 109       if (err < 0)
 110         return rs_err_conn_push_fl (pkt->conn, RSE_EVENT, __FILE__, __LINE__,
 111                                     "bufferevent_write: %s",
 112                                     evutil_gai_strerror (err));
 113     }
 114   else                          /* UDP.  */
 115     {
 116       struct rs_packet **pp = &pkt->conn->out_queue;
 117
 118       while (*pp && (*pp)->next)
 119         *pp = (*pp)->next;
 120       *pp = pkt;
 121     }
 122
 123   return RSE_OK;
 124 }
 125
 126 /* Public functions.  */
 127 int
 128 rs_packet_create (struct rs_connection *conn, struct rs_packet **pkt_out)
 129 {
 130   struct rs_packet *p;
 131   RADIUS_PACKET *rpkt;
 132   int err;
 133
 134   *pkt_out = NULL;
 135
 136   rpkt = rs_malloc (conn->ctx, sizeof(*rpkt) + RS_MAX_PACKET_LEN);
 137   if (rpkt == NULL)
 138     return rs_err_conn_push (conn, RSE_NOMEM, __func__);
 139
 140   /*
 141    * This doesn't make sense; the packet identifier is constant for
 142    * an entire conversation. A separate API should be provided to
 143    * allow the application to set the packet ID, or a conversation
 144    * object should group related packets together.
 145    */
 146 #if 0
 147   rpkt->id = conn->nextid++
 148 #endif
 149
 150   err = nr_packet_init (rpkt, NULL, NULL,
 151                         PW_ACCESS_REQUEST,
 152                         rpkt + 1, RS_MAX_PACKET_LEN);
 153   if (err < 0)
 154     return rs_err_conn_push (conn, -err, __func__);
 155
 156   p = (struct rs_packet *) rs_calloc (conn->ctx, 1, sizeof (*p));
 157   if (p == NULL)
 158     {
 159       rs_free (conn->ctx, rpkt);
 160       return rs_err_conn_push (conn, RSE_NOMEM, __func__);
 161     }
 162   p->conn = conn;
 163   p->rpkt = rpkt;
 164
 165   *pkt_out = p;
 166   return RSE_OK;
 167 }
 168
 169 int
 170 rs_packet_create_authn_request (struct rs_connection *conn,
 171                                 struct rs_packet **pkt_out,
 172                                 const char *user_name,
 173                                 const char *user_pw,
 174                                 const char *secret)
 175 {
 176   struct rs_packet *pkt;
 177   int err;
 178
 179   if (rs_packet_create (conn, pkt_out))
 180     return -1;
 181
 182   pkt = *pkt_out;
 183   pkt->rpkt->code = PW_ACCESS_REQUEST;
 184
 185   if (user_name)
 186     {
 187       err = rs_packet_append_avp (pkt, PW_USER_NAME, 0, user_name, 0);
 188       if (err)
 189         return err;
 190     }
 191
 192   if (user_pw)
 193     {
 194       pkt->rpkt->secret = secret;
 195       err = rs_packet_append_avp (pkt, PW_USER_PASSWORD, 0, user_pw, 0);
 196       if (err)
 197         return err;
 198     }
 199
 200   return RSE_OK;
 201 }
 202
 203 void
 204 rs_packet_destroy (struct rs_packet *pkt)
 205 {
 206   assert (pkt);
 207   assert (pkt->conn);
 208   assert (pkt->conn->ctx);
 209
 210   rs_avp_free (&pkt->rpkt->vps);
 211   rs_free (pkt->conn->ctx, pkt->rpkt);
 212   rs_free (pkt->conn->ctx, pkt);
 213 }
 214
 215 int
 216 rs_packet_append_avp (struct rs_packet *pkt,
 217                       unsigned int attr, unsigned int vendor,
 218                       const void *data, size_t data_len)
 219 {
 220   const DICT_ATTR *da;
 221   int err;
 222
 223   assert (pkt);
 224
 225   da = nr_dict_attr_byvalue (attr, vendor);
 226   if (da == NULL)
 227     return RSE_ATTR_TYPE_UNKNOWN;
 228
 229   err = nr_packet_attr_append (pkt->rpkt, NULL, da, data, data_len);
 230   if (err < 0)
 231     return rs_err_conn_push (pkt->conn, -err, __func__);
 232
 233   return RSE_OK;
 234 }
 235
 236 void
 237 rs_packet_avps (struct rs_packet *pkt, rs_avp ***vps)
 238 {
 239   assert (pkt);
 240   *vps = &pkt->rpkt->vps;
 241 }
 242
 243 unsigned int
 244 rs_packet_code (struct rs_packet *pkt)
 245 {
 246   assert (pkt);
 247   return pkt->rpkt->code;
 248 }
 249
 250 rs_const_avp *
 251 rs_packet_find_avp (struct rs_packet *pkt, unsigned int attr, unsigned int vendor)
 252 {
 253   assert (pkt);
 254   return rs_avp_find_const (pkt->rpkt->vps, attr, vendor);
 255 }
 256
 257 int
 258 rs_packet_set_id (struct rs_packet *pkt, int id)
 259 {
 260   int old = pkt->rpkt->id;
 261
 262   pkt->rpkt->id = id;
 263
 264   return old;
 265 }