radius.c

   1 // L2TPNS Radius Stuff
   2
   3 char const *cvs_id_radius = "$Id: radius.c,v 1.9 2004-07-26 00:20:41 fred_nerk Exp $";
   4
   5 #include <time.h>
   6 #include <stdio.h>
   7 #include <sys/types.h>
   8 #include <sys/socket.h>
   9 #include <malloc.h>
  10 #include <string.h>
  11 #include <fcntl.h>
  12 #include <arpa/inet.h>
  13 #include <ctype.h>
  14 #include <netinet/in.h>
  15 #include "md5.h"
  16 #include "constants.h"
  17 #include "l2tpns.h"
  18 #include "plugin.h"
  19 #include "util.h"
  20
  21 extern radiust *radius;
  22 extern sessiont *session;
  23 extern tunnelt *tunnel;
  24 extern u32 sessionid;
  25 extern struct configt *config;
  26 extern int *radfds;
  27
  28 const char *radius_state(int state)
  29 {
  30         static char *tmp = NULL;
  31         int i;
  32         for (i = 0; radius_states[i]; i++)
  33                 if (i == state) return radius_states[i];
  34
  35         if (tmp == NULL) tmp = (char *)calloc(64, 1);
  36         sprintf(tmp, "%d", state);
  37         return tmp;
  38 }
  39
  40 // Set up socket for radius requests
  41 void initrad(void)
  42 {
  43         int i;
  44         log(3, 0, 0, 0, "Creating %d sockets for RADIUS queries\n", config->num_radfds);
  45         radfds = calloc(sizeof(int), config->num_radfds);
  46         for (i = 0; i < config->num_radfds; i++)
  47         {
  48                 int flags;
  49                 if (!radfds[i]) radfds[i] = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
  50                 flags = fcntl(radfds[i], F_GETFL, 0);
  51                 fcntl(radfds[i], F_SETFL, flags | O_NONBLOCK);
  52         }
  53 }
  54
  55 void radiusclear(u16 r, sessionidt s)
  56 {
  57         if (s) session[s].radius = 0;
  58         memset(&radius[r], 0, sizeof(radius[r])); // radius[r].state = RADIUSNULL;
  59 }
  60
  61
  62 static u16 get_free_radius()
  63 {
  64         int count;
  65         static u32 next_radius_id = 0;
  66
  67         for (count = MAXRADIUS; count > 0 ; --count)
  68         {
  69                 ++next_radius_id;               // Find the next ID to check.
  70                 if (next_radius_id >= MAXRADIUS)
  71                         next_radius_id = 1;
  72
  73                 if (radius[next_radius_id].state == RADIUSNULL)
  74                 {
  75                         return next_radius_id;
  76                 }
  77         }
  78
  79         log(0, 0, 0, 0, "Can't find a free radius session! This is very bad!\n");
  80         return 0;
  81 }
  82
  83 u16 radiusnew(sessionidt s)
  84 {
  85         u16 r = session[s].radius;
  86
  87         /* re-use */
  88         if (r)
  89         {
  90                 log(3, 0, s, session[s].tunnel, "Re-used radius %d\n", r);
  91                 return r;
  92         }
  93
  94         if (!(r = get_free_radius()))
  95         {
  96                 log(1, 0, s, session[s].tunnel, "No free RADIUS sessions\n");
  97                 STAT(radius_overflow);
  98                 return 0;
  99         };
 100
 101         memset(&radius[r], 0, sizeof(radius[r]));
 102         session[s].radius = r;
 103         radius[r].session = s;
 104         radius[r].state = RADIUSWAIT;
 105         radius[r].retry = TIME + 1200; // Wait at least 120 seconds to re-claim this.
 106
 107         log(3,0,s, session[s].tunnel, "Allocated radius %d\n", r);
 108         return r;
 109 }
 110
 111 // Send a RADIUS request
 112 void radiussend(u16 r, u8 state)
 113 {
 114         struct sockaddr_in addr;
 115         u8 b[4096];            // RADIUS packet
 116         char pass[129];
 117         int pl;
 118         u8 *p;
 119         sessionidt s;
 120
 121         CSTAT(call_radiussend);
 122
 123         s = radius[r].session;
 124         if (!config->numradiusservers)
 125         {
 126                 log(0, 0, s, session[s].tunnel, "No RADIUS servers\n");
 127                 return;
 128         }
 129         if (!*config->radiussecret)
 130         {
 131                 log(0, 0, s, session[s].tunnel, "No RADIUS secret\n");
 132                 return;
 133         }
 134
 135         if (state != RADIUSAUTH && !config->radius_accounting)
 136         {
 137                 // Radius accounting is turned off
 138                 radiusclear(r, s);
 139                 return;
 140         }
 141
 142         if (radius[r].state != state)
 143                 radius[r].try = 0;
 144         radius[r].state = state;
 145         radius[r].retry = backoff(radius[r].try++);
 146         log(4, 0, s, session[s].tunnel, "Send RADIUS id %d sock %d state %s try %d\n",
 147                         r >> RADIUS_SHIFT, r & RADIUS_MASK,
 148                         radius_state(radius[r].state), radius[r].try);
 149         if (radius[r].try > config->numradiusservers * 2)
 150         {
 151                 if (s)
 152                 {
 153                         if (state == RADIUSAUTH)
 154                                 sessionshutdown(s, "RADIUS timeout");
 155                         else
 156                         {
 157                                 log(1, 0, s, session[s].tunnel, "RADIUS timeout, but in state %s so don't timeout session\n",
 158                                         radius_states[state]);
 159                                 radiusclear(r, s);
 160                         }
 161                         STAT(radius_timeout);
 162                 }
 163                 else
 164                 {
 165                         STAT(radius_retries);
 166                         radius[r].state = RADIUSWAIT;
 167                         radius[r].retry = 100;
 168                 }
 169                 return ;
 170         }
 171         // contruct RADIUS access request
 172         switch (state)
 173         {
 174                 case RADIUSAUTH:
 175                         b[0] = 1;               // access request
 176                         break;
 177                 case RADIUSSTART:
 178                 case RADIUSSTOP:
 179                         b[0] = 4;               // accounting request
 180                         break;
 181                 default:
 182                         log(0, 0, 0, 0, "Unknown radius state %d\n", state);
 183         }
 184         b[1] = r >> RADIUS_SHIFT;       // identifier
 185         memcpy(b + 4, radius[r].auth, 16);
 186         p = b + 20;
 187         if (s)
 188         {
 189                 *p = 1;                 // user name
 190                 p[1] = strlen(session[s].user) + 2;
 191                 strcpy(p + 2, session[s].user);
 192                 p += p[1];
 193         }
 194         if (state == RADIUSAUTH)
 195         {
 196                 if (radius[r].chap)
 197                 {
 198                         *p = 3;            // CHAP password
 199                         p[1] = 19;         // length
 200                         p[2] = radius[r].id; // ID
 201                         memcpy(p + 3, radius[r].pass, 16); // response from CHAP request
 202                         p += p[1];
 203                         *p = 60;           // CHAP Challenge
 204                         p[1] = 18;         // length
 205                         memcpy(p + 2, radius[r].auth, 16);
 206                         p += p[1];
 207                 }
 208                 else
 209                 {
 210                         strcpy(pass, radius[r].pass);
 211                         pl = strlen(pass);
 212                         while (pl & 15)
 213                                 pass[pl++] = 0; // pad
 214                         if (pl)
 215                         {                // encrypt
 216                                 hasht hash;
 217                                 int p = 0;
 218                                 while (p < pl)
 219                                 {
 220                                         MD5_CTX ctx;
 221                                         MD5Init(&ctx);
 222                                         MD5Update(&ctx, config->radiussecret, strlen(config->radiussecret));
 223                                         if (p)
 224                                                 MD5Update(&ctx, pass + p - 16, 16);
 225                                         else
 226                                                 MD5Update(&ctx, radius[r].auth, 16);
 227                                         MD5Final(hash, &ctx);
 228                                         do
 229                                         {
 230                                                 pass[p] ^= hash[p & 15];
 231                                                 p++;
 232                                         }
 233                                         while (p & 15);
 234                                 }
 235                         }
 236                         *p = 2;            // password
 237                         p[1] = pl + 2;
 238                         if (pl)
 239                                 memcpy(p + 2, pass, pl);
 240                         p += p[1];
 241                 }
 242         }
 243         else if (state == RADIUSSTART || state == RADIUSSTOP)
 244         {                          // accounting
 245                 *p = 40;                // accounting type
 246                 p[1] = 6;
 247                 *(u32 *) (p + 2) = htonl((state == RADIUSSTART) ? 1 : 2);
 248                 p += p[1];
 249                 if (s)
 250                 {
 251                         *p = 44;           // session ID
 252                         p[1] = 18;
 253                         sprintf(p + 2, "%08X%08X", session[s].id, session[s].opened);
 254                         p += p[1];
 255                         if (state == RADIUSSTOP)
 256                         {                // stop
 257                                 *p = 42;      // input octets
 258                                 p[1] = 6;
 259                                 *(u32 *) (p + 2) = htonl(session[s].cin);
 260                                 p += p[1];
 261                                 *p = 43;      // output octets
 262                                 p[1] = 6;
 263                                 *(u32 *) (p + 2) = htonl(session[s].cout);
 264                                 p += p[1];
 265                                 *p = 46;      // session time
 266                                 p[1] = 6;
 267                                 *(u32 *) (p + 2) = htonl(time(NULL) - session[s].opened);
 268                                 p += p[1];
 269                                 *p = 47;      // input packets
 270                                 p[1] = 6;
 271                                 *(u32 *) (p + 2) = htonl(session[s].pin);
 272                                 p += p[1];
 273                                 *p = 48;      // output spackets
 274                                 p[1] = 6;
 275                                 *(u32 *) (p + 2) = htonl(session[s].pout);
 276                                 p += p[1];
 277                         }
 278                         else
 279                         {                // start
 280                                 *p = 41;      // delay
 281                                 p[1] = 6;
 282                                 *(u32 *) (p + 2) = htonl(time(NULL) - session[s].opened);
 283                                 p += p[1];
 284                         }
 285                 }
 286         }
 287         if (s)
 288         {
 289                 *p = 5; // NAS-Port
 290                 p[1] = 6;
 291                 *(u32 *) (p + 2) = htonl(s);
 292                 p += p[1];
 293         }
 294         if (s && session[s].ip)
 295         {
 296                 *p = 8;                 // Framed-IP-Address
 297                 p[1] = 6;
 298                 *(u32 *) (p + 2) = htonl(session[s].ip);
 299                 p += p[1];
 300         }
 301         if (*session[s].called)
 302         {
 303                 *p = 30;                // called
 304                 p[1] = strlen(session[s].called) + 2;
 305                 strcpy(p + 2, session[s].called);
 306                 p += p[1];
 307         }
 308         if (*radius[r].calling)
 309         {
 310                 *p = 31;                // calling
 311                 p[1] = strlen(radius[r].calling) + 2;
 312                 strcpy(p + 2, radius[r].calling);
 313                 p += p[1];
 314         }
 315         else if (*session[s].calling)
 316         {
 317                 *p = 31;                // calling
 318                 p[1] = strlen(session[s].calling) + 2;
 319                 strcpy(p + 2, session[s].calling);
 320                 p += p[1];
 321         }
 322         // NAS-IP-Address
 323         *p = 4;
 324         p[1] = 6;
 325         *(u32 *)(p + 2) = config->bind_address;
 326         p += p[1];
 327
 328         // All AVpairs added
 329         *(u16 *) (b + 2) = htons(p - b);
 330         if (state != RADIUSAUTH)
 331         {
 332             // Build auth for accounting packet
 333             char z[16] = {0};
 334             char hash[16] = {0};
 335             MD5_CTX ctx;
 336             MD5Init(&ctx);
 337             MD5Update(&ctx, b, 4);
 338             MD5Update(&ctx, z, 16);
 339             MD5Update(&ctx, b + 20, (p - b) - 20);
 340             MD5Update(&ctx, config->radiussecret, strlen(config->radiussecret));
 341             MD5Final(hash, &ctx);
 342             memcpy(b + 4, hash, 16);
 343             memcpy(radius[r].auth, hash, 16);
 344         }
 345         memset(&addr, 0, sizeof(addr));
 346         addr.sin_family = AF_INET;
 347         *(u32 *) & addr.sin_addr = config->radiusserver[(radius[r].try - 1) % config->numradiusservers];
 348         {
 349             // get radius port
 350             u16 port = config->radiusport[(radius[r].try - 1) % config->numradiusservers];
 351             // no need to define the accounting port for itself:
 352             //  the accounting port is as far as I know always one more
 353             //  than the auth port    JK 20040713
 354             addr.sin_port = htons((state == RADIUSAUTH) ? port : port+1);
 355         }
 356
 357         log_hex(5, "RADIUS Send", b, (p - b));
 358         sendto(radfds[r & RADIUS_MASK], b, p - b, 0, (void *) &addr, sizeof(addr));
 359 }
 360
 361 // process RADIUS response
 362 void processrad(u8 *buf, int len, char socket_index)
 363 {
 364         u8 b[MAXCONTROL];
 365         MD5_CTX ctx;
 366         u16 r;
 367         sessionidt s;
 368         tunnelidt t = 0;
 369         hasht hash;
 370         u8 routes = 0;
 371
 372         int r_code, r_id ; // Radius code.
 373
 374         r_code = buf[0]; // First byte in radius packet.
 375         r_id = buf[1]; // radius reply indentifier.
 376
 377
 378         CSTAT(call_processrad);
 379
 380         log_hex(5, "RADIUS Response", buf, len);
 381         if (len < 20 || len < ntohs(*(u16 *) (buf + 2)))
 382         {
 383                 log(1, 0, 0, 0, "Duff RADIUS response length %d\n", len);
 384                 return ;
 385         }
 386         len = ntohs(*(u16 *) (buf + 2));
 387         r = socket_index | (r_id << RADIUS_SHIFT);
 388         s = radius[r].session;
 389         log(3, 0, s, session[s].tunnel, "Received %s, radius %d response for session %u (code %d, id %d)\n",
 390                         radius_states[radius[r].state], r, s, r_code, r_id);
 391         if (!s && radius[r].state != RADIUSSTOP)
 392         {
 393                 log(1, 0, s, session[s].tunnel, "   Unexpected RADIUS response\n");
 394                 return;
 395         }
 396         if (radius[r].state != RADIUSAUTH && radius[r].state != RADIUSSTART && radius[r].state != RADIUSSTOP)
 397         {
 398                 log(1, 0, s, session[s].tunnel, "   Unexpected RADIUS response\n");
 399                 return;
 400         }
 401         t = session[s].tunnel;
 402         MD5Init(&ctx);
 403         MD5Update(&ctx, buf, 4);
 404         MD5Update(&ctx, radius[r].auth, 16);
 405         MD5Update(&ctx, buf + 20, len - 20);
 406         MD5Update(&ctx, config->radiussecret, strlen(config->radiussecret));
 407         MD5Final(hash, &ctx);
 408         do {
 409                 if (memcmp(hash, buf + 4, 16))
 410                 {
 411                         log(0, 0, s, session[s].tunnel, "   Incorrect auth on RADIUS response!! (wrong secret in radius config?)\n");
 412                         return; // Do nothing. On timeout, it will try the next radius server.
 413                 }
 414                 if ((radius[r].state == RADIUSAUTH && *buf != 2 && *buf != 3) ||
 415                         ((radius[r].state == RADIUSSTART || radius[r].state == RADIUSSTOP) && *buf != 5))
 416                 {
 417                         log(1, 0, s, session[s].tunnel, "   Unexpected RADIUS response %d\n", *buf);
 418                         return; // We got something we didn't expect. Let the timeouts take
 419                                 // care off finishing the radius session if that's really correct.
 420                 }
 421                 if (radius[r].state == RADIUSAUTH)
 422                 {
 423                         log(4, 0, s, session[s].tunnel, "   Original response is \"%s\"\n", (*buf == 2) ? "accept" : "reject");
 424                         // process auth response
 425                         if (radius[r].chap)
 426                         {
 427                                 // CHAP
 428                                 u8 *p = makeppp(b, sizeof(b), 0, 0, t, s, PPPCHAP);
 429                                 if (!p) {
 430                                         return; // Abort!
 431                                 }
 432                                 {
 433                                         struct param_post_auth packet = { &tunnel[t], &session[s], session[s].user, (*buf == 2), PPPCHAP };
 434                                         run_plugins(PLUGIN_POST_AUTH, &packet);
 435                                         *buf = packet.auth_allowed ? 2 : 3;
 436                                 }
 437
 438                                 log(3, 0, s, session[s].tunnel, "   CHAP User %s authentication %s.\n", session[s].user,
 439                                                 (*buf == 2) ? "allowed" : "denied");
 440                                 *p = (*buf == 2) ? 3 : 4;     // ack/nak
 441                                 p[1] = radius[r].id;
 442                                 *(u16 *) (p + 2) = ntohs(4); // no message
 443                                 tunnelsend(b, (p - b) + 4, t); // send it
 444                         }
 445                         else
 446                         {
 447                                 // PAP
 448                                 u8 *p = makeppp(b, sizeof(b), 0, 0, t, s, PPPPAP);
 449                                 if (!p)
 450                                         return;         // Abort!
 451
 452                                 {
 453                                         struct param_post_auth packet = { &tunnel[t], &session[s], session[s].user, (*buf == 2), PPPPAP };
 454                                         run_plugins(PLUGIN_POST_AUTH, &packet);
 455                                         *buf = packet.auth_allowed ? 2 : 3;
 456                                 }
 457
 458                                 log(3, 0, s, session[s].tunnel, "   PAP User %s authentication %s.\n", session[s].user,
 459                                                 (*buf == 2) ? "allowed" : "denied");
 460                                 // ack/nak
 461                                 *p = *buf;
 462                                 p[1] = radius[r].id;
 463                                 *(u16 *) (p + 2) = ntohs(5);
 464                                 p[4] = 0; // no message
 465                                 tunnelsend(b, (p - b) + 5, t); // send it
 466                         }
 467
 468                         if (*buf == 2)
 469                         {
 470                                 // Login successful
 471                                 // Extract IP, routes, etc
 472                                 u8 *p = buf + 20;
 473                                 u8 *e = buf + len;
 474                                 for (p = buf + 20; p < e && p[1]; p += p[1])
 475                                 {
 476                                         if (*p == 8)
 477                                         {
 478                                                 // Statically assigned address
 479                                                 log(3, 0, s, session[s].tunnel, "   Radius reply contains IP address %s\n", inet_toa(*(u32 *) (p + 2)));
 480                                                 session[s].ip = ntohl(*(u32 *) (p + 2));
 481                                                 session[s].ip_pool_index = -1;
 482                                         }
 483                                         else if (*p == 135)
 484                                         {
 485                                                 // DNS address
 486                                                 log(3, 0, s, session[s].tunnel, "   Radius reply contains primary DNS address %s\n", inet_toa(*(u32 *) (p + 2)));
 487                                                 session[s].dns1 = ntohl(*(u32 *) (p + 2));
 488                                         }
 489                                         else if (*p == 136)
 490                                         {
 491                                                 // DNS address
 492                                                 log(3, 0, s, session[s].tunnel, "   Radius reply contains secondary DNS address %s\n", inet_toa(*(u32 *) (p + 2)));
 493                                                 session[s].dns2 = ntohl(*(u32 *) (p + 2));
 494                                         }
 495                                         else if (*p == 22)
 496                                         {
 497                                                 // framed-route
 498                                                 ipt ip = 0, mask = 0;
 499                                                 u8 u = 0;
 500                                                 u8 bits = 0;
 501                                                 u8 *n = p + 2;
 502                                                 u8 *e = p + p[1];
 503                                                 while (n < e && (isdigit(*n) || *n == '.'))
 504                                                 {
 505                                                         if (*n == '.')
 506                                                         {
 507                                                                 ip = (ip << 8) + u;
 508                                                                 u = 0;
 509                                                         }
 510                                                         else
 511                                                                 u = u * 10 + *n - '0';
 512                                                         n++;
 513                                                 }
 514                                                 ip = (ip << 8) + u;
 515                                                 if (*n == '/')
 516                                                 {
 517                                                         n++;
 518                                                         while (n < e && isdigit(*n))
 519                                                                 bits = bits * 10 + *n++ - '0';
 520                                                         mask = (( -1) << (32 - bits));
 521                                                 }
 522                                                 else if ((ip >> 24) < 128)
 523                                                         mask = 0xFF0000;
 524                                                 else if ((ip >> 24) < 192)
 525                                                         mask = 0xFFFF0000;
 526                                                 else
 527                                                         mask = 0xFFFFFF00;
 528                                                 if (routes == MAXROUTE)
 529                                                 {
 530                                                         log(1, 0, s, session[s].tunnel, "   Too many routes\n");
 531                                                 }
 532                                                 else if (ip)
 533                                                 {
 534                                                         char *ips, *masks;
 535                                                         ips = strdup(inet_toa(htonl(ip)));
 536                                                         masks = strdup(inet_toa(htonl(mask)));
 537                                                         log(3, 0, s, session[s].tunnel, "   Radius reply contains route for %s/%s\n", ips, masks);
 538                                                         free(ips);
 539                                                         free(masks);
 540                                                         session[s].route[routes].ip = ip;
 541                                                         session[s].route[routes].mask = mask;
 542                                                         routes++;
 543                                                 }
 544                                         }
 545                                         else if (*p == 26)
 546                                         {
 547                                                 // Vendor-Specific Attribute
 548                                                 int vendor = ntohl(*(int *)(p + 2));
 549                                                 char attrib = *(p + 6);
 550                                                 char attrib_length = *(p + 7) - 2;
 551                                                 log(3, 0, s, session[s].tunnel, "   Radius reply contains Vendor-Specific. Vendor=%d Attrib=%d Length=%d\n", vendor, attrib, attrib_length);
 552                                                 if (attrib_length == 0) continue;
 553                                                 if (attrib != 1)
 554                                                         log(3, 0, s, session[s].tunnel, "      Unknown vendor-specific\n");
 555                                                 else
 556                                                 {
 557                                                         char *avpair, *value, *key, *newp;
 558                                                         avpair = key = calloc(attrib_length + 1, 1);
 559                                                         memcpy(avpair, p + 8, attrib_length);
 560                                                         log(3, 0, s, session[s].tunnel, "      Cisco-Avpair value: %s\n", avpair);
 561                                                         do {
 562                                                                 value = strchr(key, '=');
 563                                                                 if (!value) break;
 564                                                                 *value++ = 0;
 565
 566                                                                 // Trim quotes off reply string
 567                                                                 if (*value == '\'' || *value == '\"')
 568                                                                 {
 569                                                                         char *x;
 570                                                                         value++;
 571                                                                         x = value + strlen(value) - 1;
 572                                                                         if (*x == '\'' || *x == '\"')
 573                                                                                 *x = 0;
 574                                                                 }
 575
 576                                                                 // Run hooks
 577                                                                 newp = strchr(value, ',');
 578                                                                 if (newp) *newp++ = 0;
 579                                                                 {
 580                                                                         struct param_radius_response p = { &tunnel[session[s].tunnel], &session[s], key, value };
 581                                                                         run_plugins(PLUGIN_RADIUS_RESPONSE, &p);
 582                                                                 }
 583                                                                 key = newp;
 584                                                         } while (newp);
 585                                                         free(avpair);
 586                                                 }
 587                                         }
 588                                 }
 589                         }
 590                         else if (*buf == 3)
 591                         {
 592                                 log(2, 0, s, session[s].tunnel, "   Authentication denied for %s\n", session[s].user);
 593 //FIXME: We should tear down the session here!
 594                                 break;
 595                         }
 596
 597                         if (!session[s].dns1 && config->default_dns1)
 598                         {
 599                                 session[s].dns1 = htonl(config->default_dns1);
 600                                 log(3, 0, s, t, "   Sending dns1 = %s\n", inet_toa(config->default_dns1));
 601                         }
 602                         if (!session[s].dns2 && config->default_dns2)
 603                         {
 604                                 session[s].dns2 = htonl(config->default_dns2);
 605                                 log(3, 0, s, t, "   Sending dns2 = %s\n", inet_toa(config->default_dns2));
 606                         }
 607
 608                         // Valid Session, set it up
 609                         session[s].sid = 0;
 610                         sessionsetup(t, s);
 611                 }
 612                 else
 613                 {
 614                                 // An ack for a stop or start record.
 615                         log(3, 0, s, t, "   RADIUS accounting ack recv in state %s\n", radius_states[radius[r].state]);
 616                         break;
 617                 }
 618         } while (0);
 619
 620         // finished with RADIUS
 621         radiusclear(r, s);
 622 }
 623
 624 // Send a retry for RADIUS/CHAP message
 625 void radiusretry(u16 r)
 626 {
 627         sessionidt s = radius[r].session;
 628         tunnelidt t = 0;
 629
 630         CSTAT(call_radiusretry);
 631
 632         if (s)
 633                 t = session[s].tunnel;
 634         radius[r].retry = backoff(radius[r].try + 1);
 635         switch (radius[r].state)
 636         {
 637                 case RADIUSCHAP:           // sending CHAP down PPP
 638                         sendchap(t, s);
 639                         break;
 640                 case RADIUSIPCP:
 641                         sendipcp(t, s);         // send IPCP
 642                         break;
 643                 case RADIUSAUTH:           // sending auth to RADIUS server
 644                         radiussend(r, RADIUSAUTH);
 645                         break;
 646                 case RADIUSSTART:          // sending start accounting to RADIUS server
 647                         radiussend(r, RADIUSSTART);
 648                         break;
 649                 case RADIUSSTOP:           // sending stop accounting to RADIUS server
 650                         radiussend(r, RADIUSSTOP);
 651                         break;
 652                 default:
 653                 case RADIUSNULL:           // Not in use
 654                 case RADIUSWAIT:           // waiting timeout before available, in case delayed reply from RADIUS server
 655                         // free up RADIUS task
 656                         radiusclear(r, s);
 657                         log(3, 0, s, session[s].tunnel, "Freeing up radius session %d\n", r);
 658                         break;
 659         }
 660 }
 661
 662 void radius_clean()
 663 {
 664         int i;
 665
 666         log(1, 0, 0, 0, "Cleaning radius session array\n");
 667
 668         for (i = 1; i < MAXRADIUS; i++)
 669         {
 670                 if (radius[i].retry == 0
 671                                 || !session[radius[i].session].opened
 672                                 || session[radius[i].session].die
 673                                 || session[radius[i].session].tunnel == 0)
 674                         radiusclear(i, radius[i].session);
 675         }
 676 }