lib/packet.c

   1 /* Copyright 2010, 2011 NORDUnet A/S. All rights reserved.
   2    See LICENSE 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   err = nr_packet_init (rpkt, NULL, NULL,
 141                         PW_ACCESS_REQUEST,
 142                         rpkt + 1, RS_MAX_PACKET_LEN);
 143   if (err < 0)
 144     return rs_err_conn_push (conn, -err, __func__);
 145
 146   p = (struct rs_packet *) rs_calloc (conn->ctx, 1, sizeof (*p));
 147   if (p == NULL)
 148     {
 149       rs_free (conn->ctx, rpkt);
 150       return rs_err_conn_push (conn, RSE_NOMEM, __func__);
 151     }
 152   p->conn = conn;
 153   p->rpkt = rpkt;
 154
 155   *pkt_out = p;
 156   return RSE_OK;
 157 }
 158
 159 int
 160 rs_packet_create_authn_request (struct rs_connection *conn,
 161                                 struct rs_packet **pkt_out,
 162                                 const char *user_name,
 163                                 const char *user_pw,
 164                                 const char *secret)
 165 {
 166   struct rs_packet *pkt;
 167   int err;
 168
 169   if (rs_packet_create (conn, pkt_out))
 170     return -1;
 171
 172   pkt = *pkt_out;
 173   pkt->rpkt->code = PW_ACCESS_REQUEST;
 174
 175   if (user_name)
 176     {
 177       err = rs_packet_append_avp (pkt, PW_USER_NAME, 0, user_name, 0);
 178       if (err)
 179         return err;
 180     }
 181
 182   if (user_pw)
 183     {
 184       pkt->rpkt->secret = secret;
 185       err = rs_packet_append_avp (pkt, PW_USER_PASSWORD, 0, user_pw, 0);
 186       if (err)
 187         return err;
 188     }
 189
 190   return RSE_OK;
 191 }
 192
 193 void
 194 rs_packet_destroy (struct rs_packet *pkt)
 195 {
 196   assert (pkt);
 197   assert (pkt->conn);
 198   assert (pkt->conn->ctx);
 199
 200   rs_avp_free (&pkt->rpkt->vps);
 201   rs_free (pkt->conn->ctx, pkt->rpkt);
 202   rs_free (pkt->conn->ctx, pkt);
 203 }
 204
 205 int
 206 rs_packet_append_avp (struct rs_packet *pkt,
 207                       unsigned int attr, unsigned int vendor,
 208                       const void *data, size_t data_len)
 209 {
 210   const DICT_ATTR *da;
 211   int err;
 212
 213   assert (pkt);
 214
 215   da = nr_dict_attr_byvalue (attr, vendor);
 216   if (da == NULL)
 217     return RSE_ATTR_TYPE_UNKNOWN;
 218
 219   err = nr_packet_attr_append (pkt->rpkt, NULL, da, data, data_len);
 220   if (err < 0)
 221     return rs_err_conn_push (pkt->conn, -err, __func__);
 222
 223   return RSE_OK;
 224 }
 225
 226 void
 227 rs_packet_avps (struct rs_packet *pkt, rs_avp ***vps)
 228 {
 229   assert (pkt);
 230   *vps = &pkt->rpkt->vps;
 231 }
 232
 233 unsigned int
 234 rs_packet_code (struct rs_packet *pkt)
 235 {
 236   assert (pkt);
 237   return pkt->rpkt->code;
 238 }
 239
 240 rs_const_avp *
 241 rs_packet_find_avp (struct rs_packet *pkt, unsigned int attr, unsigned int vendor)
 242 {
 243   assert (pkt);
 244   return rs_avp_find_const (pkt->rpkt->vps, attr, vendor);
 245 }
 246
 247 int
 248 rs_packet_set_id (struct rs_packet *pkt, int id)
 249 {
 250   int old = pkt->rpkt->id;
 251
 252   pkt->rpkt->id = id;
 253
 254   return old;
 255 }