src/modules/rlm_eap/mem.c

   1 /*
   2  * mem.c  Memory allocation, deallocation stuff.
   3  *
   4  * Version:     $Id$
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; either version 2 of the License, or
   9  *   (at your option) any later version.
  10  *
  11  *   This program is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *   GNU General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU General Public License
  17  *   along with this program; if not, write to the Free Software
  18  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * Copyright 2000,2001,2006  The FreeRADIUS server project
  21  * Copyright 2001  hereUare Communications, Inc. <raghud@hereuare.com>
  22  */
  23
  24 #include <freeradius-devel/ident.h>
  25 RCSID("$Id$")
  26
  27 #include <stdio.h>
  28 #include "rlm_eap.h"
  29
  30 /*
  31  * Allocate a new EAP_PACKET
  32  */
  33 EAP_PACKET *eap_packet_alloc(void)
  34 {
  35         EAP_PACKET   *rp;
  36
  37         rp = rad_malloc(sizeof(EAP_PACKET));
  38         memset(rp, 0, sizeof(EAP_PACKET));
  39         return rp;
  40 }
  41
  42 /*
  43  * Free EAP_PACKET
  44  */
  45 void eap_packet_free(EAP_PACKET **eap_packet_ptr)
  46 {
  47         EAP_PACKET *eap_packet;
  48
  49         if (!eap_packet_ptr) return;
  50         eap_packet = *eap_packet_ptr;
  51         if (!eap_packet) return;
  52
  53         if (eap_packet->type.data) {
  54                 /*
  55                  *      There's no packet, OR the type data isn't
  56                  *      pointing inside of the packet: free it.
  57                  */
  58                 if ((eap_packet->packet == NULL) ||
  59                     (eap_packet->type.data != (eap_packet->packet + 5))) {
  60                         free(eap_packet->type.data);
  61                 }
  62                 eap_packet->type.data = NULL;
  63         }
  64
  65         if (eap_packet->packet) {
  66                 free(eap_packet->packet);
  67                 eap_packet->packet = NULL;
  68         }
  69
  70         free(eap_packet);
  71
  72         *eap_packet_ptr = NULL;
  73 }
  74
  75 /*
  76  * Allocate a new EAP_PACKET
  77  */
  78 EAP_DS *eap_ds_alloc(void)
  79 {
  80         EAP_DS  *eap_ds;
  81
  82         eap_ds = rad_malloc(sizeof(EAP_DS));
  83         memset(eap_ds, 0, sizeof(EAP_DS));
  84         if ((eap_ds->response = eap_packet_alloc()) == NULL) {
  85                 eap_ds_free(&eap_ds);
  86                 return NULL;
  87         }
  88         if ((eap_ds->request = eap_packet_alloc()) == NULL) {
  89                 eap_ds_free(&eap_ds);
  90                 return NULL;
  91         }
  92
  93         return eap_ds;
  94 }
  95
  96 void eap_ds_free(EAP_DS **eap_ds_p)
  97 {
  98         EAP_DS *eap_ds;
  99
 100         if (!eap_ds_p) return;
 101
 102         eap_ds = *eap_ds_p;
 103         if (!eap_ds) return;
 104
 105         if (eap_ds->response) eap_packet_free(&(eap_ds->response));
 106         if (eap_ds->request) eap_packet_free(&(eap_ds->request));
 107
 108         free(eap_ds);
 109         *eap_ds_p = NULL;
 110 }
 111
 112 /*
 113  * Allocate a new EAP_HANDLER
 114  */
 115 EAP_HANDLER *eap_handler_alloc(void)
 116 {
 117         EAP_HANDLER     *handler;
 118
 119         handler = rad_malloc(sizeof(EAP_HANDLER));
 120         memset(handler, 0, sizeof(EAP_HANDLER));
 121         return handler;
 122 }
 123
 124 void eap_handler_free(EAP_HANDLER *handler)
 125 {
 126         if (!handler)
 127                 return;
 128
 129         if (handler->identity) {
 130                 free(handler->identity);
 131                 handler->identity = NULL;
 132         }
 133
 134         if (handler->prev_eapds) eap_ds_free(&(handler->prev_eapds));
 135         if (handler->eap_ds) eap_ds_free(&(handler->eap_ds));
 136
 137         if ((handler->opaque) && (handler->free_opaque)) {
 138                 handler->free_opaque(handler->opaque);
 139                 handler->opaque = NULL;
 140         }
 141         else if ((handler->opaque) && (handler->free_opaque == NULL))
 142                 radlog(L_ERR, "Possible memory leak ...");
 143
 144         handler->opaque = NULL;
 145         handler->free_opaque = NULL;
 146
 147         free(handler);
 148 }
 149
 150 void eaptype_free(EAP_TYPES *i)
 151 {
 152         if (i->type->detach) (i->type->detach)(i->type_data);
 153         i->type_data = NULL;
 154         if (i->handle) lt_dlclose(i->handle);
 155         free(i);
 156 }
 157
 158
 159 void eaplist_free(rlm_eap_t *inst)
 160 {
 161         EAP_HANDLER *node, *next;
 162
 163         for (node = inst->session_head; node != NULL; node = next) {
 164                 next = node->next;
 165                 eap_handler_free(node);
 166         }
 167
 168         inst->session_head = inst->session_tail = NULL;
 169 }
 170
 171 /*
 172  *      Return a 32-bit random number.
 173  */
 174 static uint32_t eap_rand(fr_randctx *ctx)
 175 {
 176         uint32_t num;
 177
 178         num = ctx->randrsl[ctx->randcnt++];
 179         if (ctx->randcnt == 256) {
 180                 ctx->randcnt = 0;
 181                 fr_isaac(ctx);
 182         }
 183
 184         return num;
 185 }
 186
 187 /*
 188  *      Add a handler to the set of active sessions.
 189  *
 190  *      Since we're adding it to the list, we guess that this means
 191  *      the packet needs a State attribute.  So add one.
 192  */
 193 int eaplist_add(rlm_eap_t *inst, EAP_HANDLER *handler)
 194 {
 195         int             i, status;
 196         uint32_t        lvalue;
 197         VALUE_PAIR      *state;
 198
 199         rad_assert(handler != NULL);
 200         rad_assert(handler->request != NULL);
 201
 202         /*
 203          *      Generate State, since we've been asked to add it to
 204          *      the list.
 205          */
 206         state = pairmake("State", "0x00", T_OP_EQ);
 207         if (!state) return 0;
 208         pairadd(&(handler->request->reply->vps), state);
 209         state->length = EAP_STATE_LEN;
 210
 211         /*
 212          *      The time at which this request was made was the time
 213          *      at which it was received by the RADIUS server.
 214          */
 215         handler->timestamp = handler->request->timestamp;
 216         handler->status = 1;
 217
 218         handler->src_ipaddr = handler->request->packet->src_ipaddr;
 219         handler->eap_id = handler->eap_ds->request->id;
 220
 221         /*
 222          *      We don't need this any more.
 223          */
 224         handler->request = NULL;
 225
 226         /*
 227          *      Playing with a data structure shared among threads
 228          *      means that we need a lock, to avoid conflict.
 229          */
 230         pthread_mutex_lock(&(inst->session_mutex));
 231
 232         /*
 233          *      Create a completely random state.
 234          */
 235         for (i = 0; i < 4; i++) {
 236                 lvalue = eap_rand(&inst->rand_pool);
 237                 memcpy(state->vp_octets + i * 4, &lvalue, sizeof(lvalue));
 238         }
 239         state->vp_octets[15] = handler->eap_id;
 240         memcpy(handler->state, state->vp_strvalue, sizeof(handler->state));
 241
 242         /*
 243          *      Big-time failure.
 244          */
 245         status = rbtree_insert(inst->session_tree, handler);
 246
 247         if (status) {
 248                 EAP_HANDLER *prev;
 249
 250                 prev = inst->session_tail;
 251                 if (prev) {
 252                         prev->next = handler;
 253                         handler->prev = prev;
 254                         handler->next = NULL;
 255                         inst->session_tail = handler;
 256                 } else {
 257                         inst->session_head = inst->session_tail = handler;
 258                         handler->next = handler->prev = NULL;
 259                 }
 260         }
 261
 262         /*
 263          *      Now that we've finished mucking with the list,
 264          *      unlock it.
 265          */
 266         pthread_mutex_unlock(&(inst->session_mutex));
 267
 268         if (!status) {
 269                 radlog(L_ERR, "rlm_eap: Failed to remember handler!");
 270                 eap_handler_free(handler);
 271                 return 0;
 272         }
 273
 274         return 1;
 275 }
 276
 277 /*
 278  *      Find a a previous EAP-Request sent by us, which matches
 279  *      the current EAP-Response.
 280  *
 281  *      Then, release the handle from the list, and return it to
 282  *      the caller.
 283  *
 284  *      Also since we fill the eap_ds with the present EAP-Response we
 285  *      got to free the prev_eapds & move the eap_ds to prev_eapds
 286  */
 287 EAP_HANDLER *eaplist_find(rlm_eap_t *inst, REQUEST *request,
 288                           eap_packet_t *eap_packet)
 289 {
 290         int             i;
 291         VALUE_PAIR      *state;
 292         rbnode_t        *node;
 293         EAP_HANDLER     *handler, myHandler;
 294
 295         /*
 296          *      We key the sessions off of the 'state' attribute, so it
 297          *      must exist.
 298          */
 299         state = pairfind(request->packet->vps, PW_STATE);
 300         if (!state ||
 301             (state->length != EAP_STATE_LEN)) {
 302                 return NULL;
 303         }
 304
 305         myHandler.src_ipaddr = request->packet->src_ipaddr;
 306         myHandler.eap_id = eap_packet->id;
 307         memcpy(myHandler.state, state->vp_strvalue, sizeof(myHandler.state));
 308
 309         /*
 310          *      Playing with a data structure shared among threads
 311          *      means that we need a lock, to avoid conflict.
 312          */
 313         pthread_mutex_lock(&(inst->session_mutex));
 314
 315         /*
 316          *      Check the first few handlers in the list, and delete
 317          *      them if they're too old.  We don't need to check them
 318          *      all, as incoming requests will quickly cause older
 319          *      handlers to be deleted.
 320          *
 321          */
 322         for (i = 0; i < 2; i++) {
 323                 handler = inst->session_head;
 324                 if (handler &&
 325                     ((request->timestamp - handler->timestamp) > inst->timer_limit)) {
 326                         node = rbtree_find(inst->session_tree, handler);
 327                         rad_assert(node != NULL);
 328                         rbtree_delete(inst->session_tree, node);
 329
 330                         /*
 331                          *      handler == inst->session_head
 332                          */
 333                         inst->session_head = handler->next;
 334                         if (handler->next) {
 335                                 handler->next->prev = NULL;
 336                         } else {
 337                                 inst->session_head = NULL;
 338                         }
 339                         eap_handler_free(handler);
 340                 }
 341         }
 342
 343         handler = NULL;
 344         node = rbtree_find(inst->session_tree, &myHandler);
 345         if (node) {
 346                 handler = rbtree_node2data(inst->session_tree, node);
 347
 348                 /*
 349                  *      Delete old handler from the tree.
 350                  */
 351                 rbtree_delete(inst->session_tree, node);
 352
 353                 /*
 354                  *      And unsplice it from the linked list.
 355                  */
 356                 if (handler->prev) {
 357                         handler->prev->next = handler->next;
 358                 } else {
 359                         inst->session_head = handler->next;
 360                 }
 361                 if (handler->next) {
 362                         handler->next->prev = handler->prev;
 363                 } else {
 364                         inst->session_tail = handler->prev;
 365                 }
 366                 handler->prev = handler->next = NULL;
 367         }
 368
 369         pthread_mutex_unlock(&(inst->session_mutex));
 370
 371         /*
 372          *      Not found.
 373          */
 374         if (!node) {
 375                 DEBUG2("  rlm_eap: Request not found in the list");
 376                 return NULL;
 377         }
 378
 379         /*
 380          *      Found, but state verification failed.
 381          */
 382         if (!handler) {
 383                 radlog(L_ERR, "rlm_eap: State verification failed.");
 384                 return NULL;
 385         }
 386
 387         if (handler->trips >= 50) {
 388                 DEBUG2("  rlm_eap: More than 50 authentication packets for this EAP session.  Aborted.");
 389                 eap_handler_free(handler);
 390                 return NULL;
 391         }
 392         handler->trips++;
 393
 394         DEBUG2("  rlm_eap: Request found, released from the list");
 395
 396         /*
 397          *      Remember what the previous request was.
 398          */
 399         eap_ds_free(&(handler->prev_eapds));
 400         handler->prev_eapds = handler->eap_ds;
 401         handler->eap_ds = NULL;
 402
 403         return handler;
 404 }