lib/packet.c

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