src/main/radius_snmp.c

   1 /*
   2  * radius_snmp.c        Radius SNMP support
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * Copyright 2000  The FreeRADIUS server project
  21  * Copyright 2000  Jochen Friedrich <jochen@scram.de>
  22  */
  23
  24 static const char rcsid[] =
  25 "$Id$";
  26
  27 #include "autoconf.h"
  28
  29 #ifdef WITH_SNMP
  30
  31 #include "libradius.h"
  32
  33 #ifdef HAVE_NETINET_IN_H
  34 #       include <netinet/in.h>
  35 #endif
  36
  37 #include <string.h>
  38
  39 #include "smux.h"
  40 #include "radius_snmp.h"
  41 #include "radiusd.h"
  42 #include "conffile.h"
  43
  44 extern int need_reload;
  45
  46 /*
  47  *      More globals (sigh);
  48  */
  49 rad_snmp_t              rad_snmp;
  50
  51 \f
  52 #define RADACCOID 1,3,6,1,2,1,67,2,1,1,1
  53 #define RADAUTHOID 1,3,6,1,2,1,67,1,1,1,1
  54 #define RADIUSOID 1,3,6,1,4,1,3317,1,3,1
  55
  56 static oid radacc_oid [] = { RADACCOID };
  57 static oid radauth_oid [] = { RADAUTHOID };
  58 static oid radius_oid [] = { RADIUSOID };
  59
  60 #define COUNTER ASN_COUNTER
  61 #define INTEGER ASN_INTEGER
  62 #define GAUGE ASN_GAUGE
  63 #define TIMETICKS ASN_TIMETICKS
  64 #define IPADDRESS ASN_IPADDRESS
  65 #define STRING ASN_OCTET_STR
  66
  67 #define RADIUSACCSERVIDENT               1
  68 #define RADIUSACCSERVUPTIME              2
  69 #define RADIUSACCSERVRESETTIME           3
  70 #define RADIUSACCSERVCONFIGRESET         4
  71 #define RADIUSACCSERVTOTALREQUESTS       5
  72 #define RADIUSACCSERVTOTALINVALIDREQUESTS 6
  73 #define RADIUSACCSERVTOTALDUPREQUESTS    7
  74 #define RADIUSACCSERVTOTALRESPONSES      8
  75 #define RADIUSACCSERVTOTALMALFORMEDREQUESTS 9
  76 #define RADIUSACCSERVTOTALBADAUTHENTICATORS 10
  77 #define RADIUSACCSERVTOTALPACKETSDROPPED 11
  78 #define RADIUSACCSERVTOTALNORECORDS      12
  79 #define RADIUSACCSERVTOTALUNKNOWNTYPES   13
  80 /* */
  81 #define RADIUSACCCLIENTADDRESS           2
  82 #define RADIUSACCCLIENTID                3
  83 #define RADIUSACCSERVPACKETSDROPPED      4
  84 #define RADIUSACCSERVREQUESTS            5
  85 #define RADIUSACCSERVDUPREQUESTS         6
  86 #define RADIUSACCSERVRESPONSES           7
  87 #define RADIUSACCSERVBADAUTHENTICATORS   8
  88 #define RADIUSACCSERVMALFORMEDREQUESTS   9
  89 #define RADIUSACCSERVNORECORDS           10
  90 #define RADIUSACCSERVUNKNOWNTYPES        11
  91 /* */
  92 #define RADIUSAUTHSERVIDENT              1
  93 #define RADIUSAUTHSERVUPTIME             2
  94 #define RADIUSAUTHSERVRESETTIME          3
  95 #define RADIUSAUTHSERVCONFIGRESET        4
  96 #define RADIUSAUTHSERVTOTALACCESSREQUESTS 5
  97 #define RADIUSAUTHSERVTOTALINVALIDREQUESTS 6
  98 #define RADIUSAUTHSERVTOTALDUPACCESSREQUESTS 7
  99 #define RADIUSAUTHSERVTOTALACCESSACCEPTS 8
 100 #define RADIUSAUTHSERVTOTALACCESSREJECTS 9
 101 #define RADIUSAUTHSERVTOTALACCESSCHALLENGES 10
 102 #define RADIUSAUTHSERVTOTALMALFORMEDACCESSREQUESTS 11
 103 #define RADIUSAUTHSERVTOTALBADAUTHENTICATORS 12
 104 #define RADIUSAUTHSERVTOTALPACKETSDROPPED 13
 105 #define RADIUSAUTHSERVTOTALUNKNOWNTYPES  14
 106 /* */
 107 #define RADIUSAUTHCLIENTADDRESS          2
 108 #define RADIUSAUTHCLIENTID               3
 109 #define RADIUSAUTHSERVACCESSREQUESTS     4
 110 #define RADIUSAUTHSERVDUPACCESSREQUESTS  5
 111 #define RADIUSAUTHSERVACCESSACCEPTS      6
 112 #define RADIUSAUTHSERVACCESSREJECTS      7
 113 #define RADIUSAUTHSERVACCESSCHALLENGES   8
 114 #define RADIUSAUTHSERVMALFORMEDACCESSREQUESTS 9
 115 #define RADIUSAUTHSERVBADAUTHENTICATORS  10
 116 #define RADIUSAUTHSERVPACKETSDROPPED     11
 117 #define RADIUSAUTHSERVUNKNOWNTYPES       12
 118
 119 /* Hook functions. */
 120 static const unsigned char *radAccServ(struct variable *vp,
 121         oid     *name,
 122         size_t  *length,
 123         int     exact,
 124         size_t  *var_len,
 125         WriteMethod **write_method);
 126 static const unsigned char *radAccEntry(struct variable *vp,
 127         oid     *name,
 128         size_t  *length,
 129         int     exact,
 130         size_t  *var_len,
 131         WriteMethod **write_method);
 132 static const u_char *radAuthServ(struct variable *vp,
 133         oid     *name,
 134         size_t  *length,
 135         int     exact,
 136         size_t  *var_len,
 137         WriteMethod **write_method);
 138 static const unsigned char *radAuthEntry(struct variable *vp,
 139         oid     *name,
 140         size_t  *length,
 141         int     exact,
 142         size_t  *var_len,
 143         WriteMethod **write_method);
 144
 145 static struct variable radiusacc_variables[] =
 146 {
 147         {RADIUSACCSERVIDENT, STRING, RONLY, radAccServ, 1, {1}},
 148         {RADIUSACCSERVUPTIME, TIMETICKS, RONLY, radAccServ, 1, {2}},
 149         {RADIUSACCSERVRESETTIME, TIMETICKS, RONLY, radAccServ, 1, {3}},
 150         {RADIUSACCSERVCONFIGRESET, INTEGER, RWRITE, radAccServ, 1, {4}},
 151         {RADIUSACCSERVTOTALREQUESTS, COUNTER, RONLY, radAccServ, 1, {5}},
 152         {RADIUSACCSERVTOTALINVALIDREQUESTS, COUNTER, RONLY, radAccServ, 1, {6}},
 153         {RADIUSACCSERVTOTALDUPREQUESTS, COUNTER, RONLY, radAccServ, 1, {7}},
 154         {RADIUSACCSERVTOTALRESPONSES, COUNTER, RONLY, radAccServ, 1, {8}},
 155         {RADIUSACCSERVTOTALMALFORMEDREQUESTS, COUNTER, RONLY, radAccServ, 1, {9}},
 156         {RADIUSACCSERVTOTALBADAUTHENTICATORS, COUNTER, RONLY, radAccServ, 1, {10}},
 157         {RADIUSACCSERVTOTALPACKETSDROPPED, COUNTER, RONLY, radAccServ, 1, {11}},
 158         {RADIUSACCSERVTOTALNORECORDS, COUNTER, RONLY, radAccServ, 1, {12}},
 159         {RADIUSACCSERVTOTALUNKNOWNTYPES, COUNTER, RONLY, radAccServ, 1, {13}},
 160         {RADIUSACCCLIENTADDRESS, IPADDRESS, RONLY, radAccEntry, 3, {14,1,2}},
 161         {RADIUSACCCLIENTID, STRING, RONLY, radAccEntry, 3, {14,1,3}},
 162         {RADIUSACCSERVPACKETSDROPPED, COUNTER, RONLY, radAccEntry, 3, {14,1,4}},
 163         {RADIUSACCSERVREQUESTS, COUNTER, RONLY, radAccEntry, 3, {14,1,5}},
 164         {RADIUSACCSERVDUPREQUESTS, COUNTER, RONLY, radAccEntry, 3, {14,1,6}},
 165         {RADIUSACCSERVRESPONSES, COUNTER, RONLY, radAccEntry, 3, {14,1,7}},
 166         {RADIUSACCSERVBADAUTHENTICATORS, COUNTER, RONLY, radAccEntry, 3, {14,1,8}},
 167         {RADIUSACCSERVMALFORMEDREQUESTS, COUNTER, RONLY, radAccEntry, 3, {14,1,9}},
 168         {RADIUSACCSERVNORECORDS, COUNTER, RONLY, radAccEntry, 3, {14,1,10}},
 169         {RADIUSACCSERVUNKNOWNTYPES, COUNTER, RONLY, radAccEntry, 3, {14,1,11}},
 170 };
 171
 172 static struct variable radiusauth_variables[] =
 173 {
 174         {RADIUSAUTHSERVIDENT, STRING, RONLY, radAuthServ, 1, {1}},
 175         {RADIUSAUTHSERVUPTIME, TIMETICKS, RONLY, radAuthServ, 1, {2}},
 176         {RADIUSAUTHSERVRESETTIME, TIMETICKS, RONLY, radAuthServ, 1, {3}},
 177         {RADIUSAUTHSERVCONFIGRESET, INTEGER, RWRITE, radAuthServ, 1, {4}},
 178         {RADIUSAUTHSERVTOTALACCESSREQUESTS, COUNTER, RONLY, radAuthServ, 1, {5}},
 179         {RADIUSAUTHSERVTOTALINVALIDREQUESTS, COUNTER, RONLY, radAuthServ, 1, {6}},
 180         {RADIUSAUTHSERVTOTALDUPACCESSREQUESTS, COUNTER, RONLY, radAuthServ, 1, {7}},
 181         {RADIUSAUTHSERVTOTALACCESSACCEPTS, COUNTER, RONLY, radAuthServ, 1, {8}},
 182         {RADIUSAUTHSERVTOTALACCESSREJECTS, COUNTER, RONLY, radAuthServ, 1, {9}},
 183         {RADIUSAUTHSERVTOTALACCESSCHALLENGES, COUNTER, RONLY, radAuthServ, 1, {10}},
 184         {RADIUSAUTHSERVTOTALMALFORMEDACCESSREQUESTS, COUNTER, RONLY, radAuthServ, 1, {11}},
 185         {RADIUSAUTHSERVTOTALBADAUTHENTICATORS, COUNTER, RONLY, radAuthServ, 1, {12}},
 186         {RADIUSAUTHSERVTOTALPACKETSDROPPED, COUNTER, RONLY, radAuthServ, 1, {13}},
 187         {RADIUSAUTHSERVTOTALUNKNOWNTYPES, COUNTER, RONLY, radAuthServ, 1, {14}},
 188         {RADIUSAUTHCLIENTADDRESS, IPADDRESS, RONLY, radAuthEntry, 3, {15,1,2}},
 189         {RADIUSAUTHCLIENTID, STRING, RONLY, radAuthEntry, 3, {15,1,3}},
 190         {RADIUSAUTHSERVACCESSREQUESTS, COUNTER, RONLY, radAuthEntry, 3, {15,1,4}},
 191         {RADIUSAUTHSERVDUPACCESSREQUESTS, COUNTER, RONLY, radAuthEntry, 3, {15,1,5}},
 192         {RADIUSAUTHSERVACCESSACCEPTS, COUNTER, RONLY, radAuthEntry, 3, {15,1,6}},
 193         {RADIUSAUTHSERVACCESSREJECTS, COUNTER, RONLY, radAuthEntry, 3, {15,1,7}},
 194         {RADIUSAUTHSERVACCESSCHALLENGES, COUNTER, RONLY, radAuthEntry, 3, {15,1,8}},
 195         {RADIUSAUTHSERVMALFORMEDACCESSREQUESTS, COUNTER, RONLY, radAuthEntry, 3, {15,1,9}},
 196         {RADIUSAUTHSERVBADAUTHENTICATORS, COUNTER, RONLY, radAuthEntry, 3, {15,1,10}},
 197         {RADIUSAUTHSERVPACKETSDROPPED, COUNTER, RONLY, radAuthEntry, 3, {15,1,11}},
 198         {RADIUSAUTHSERVUNKNOWNTYPES, COUNTER, RONLY, radAuthEntry, 3, {15,1,12}},
 199 };
 200
 201 \f
 202 static RADCLIENT *
 203 get_client(struct variable *v, oid objid[], size_t *objid_len, int exact) {
 204
 205         RADCLIENT *c;
 206         int i, len;
 207
 208         len = *objid_len - v->namelen;
 209
 210         if (!mainconfig.clients)
 211                 return NULL;
 212
 213         if (exact) {
 214                 /* Check the length. */
 215                 if (len != 1)
 216                         return NULL;
 217                 if (objid[v->namelen] == 0)
 218                         return NULL;
 219
 220                 i = objid[v->namelen]-1;
 221                 c = mainconfig.clients;
 222                 while (i && c)
 223                 {
 224                         c = c->next;
 225                         i--;
 226                 }
 227                 if (c)
 228                         return c;
 229                 return NULL;
 230         }
 231         i = objid[v->namelen]-1;
 232         *objid_len = v->namelen + 1;
 233         if (!len || (objid[v->namelen] == 0)) {
 234                 objid[v->namelen]=1;
 235                 return mainconfig.clients;
 236         }
 237         c = mainconfig.clients->next;
 238         while (i && c) {
 239                 c = c->next;
 240                 i--;
 241         }
 242         if (c) {
 243                 objid[v->namelen]++;
 244                 return c;
 245         } else
 246                 return NULL;
 247 }
 248
 249 static int
 250 radServReset (int action, u_char *var_val, u_char var_val_type,
 251                 size_t var_val_len, const unsigned char *statP, oid *name,
 252                 size_t name_len) {
 253
 254         long i;
 255         int big = SNMP_MAX_LEN;
 256
 257         switch (action) {
 258                 case RESERVE1:
 259                         if (var_val_type != INTEGER)
 260                                 return SNMP_ERR_WRONGTYPE;
 261                         if (var_val_len != sizeof (long))
 262                                 return SNMP_ERR_WRONGLENGTH;
 263                         if (! asn_parse_int(var_val, &big, &var_val_type, &i, sizeof(long)))
 264                                 return SNMP_ERR_WRONGENCODING;
 265                         if (i != 2)
 266                                 return SNMP_ERR_WRONGVALUE;
 267                         break;
 268                 case COMMIT:
 269                         need_reload = TRUE;
 270                         break;
 271                 case FREE:
 272                         break;
 273                 default:
 274                         return SNMP_ERR_GENERR;
 275         }
 276         return SNMP_ERR_NOERROR;
 277 }
 278
 279 static const unsigned char *
 280 radAccServ(struct variable *vp, oid *name, size_t *length, int exact,
 281                 size_t *var_len, WriteMethod **write_method) {
 282
 283         static int result;
 284
 285         /* check whether the instance identifier is valid */
 286         if (smux_header_generic(vp, name, length, exact, var_len,
 287                 write_method) == MATCH_FAILED) {
 288                 return NULL;
 289         }
 290
 291         /* return the current value of the variable */
 292         switch (vp->magic) {
 293                 case RADIUSACCSERVIDENT:
 294                         *var_len = strlen(rad_snmp.acct.ident);
 295                         return (const unsigned char *) rad_snmp.acct.ident;
 296
 297                 case RADIUSACCSERVUPTIME:
 298                         rad_snmp.acct.uptime = (time(NULL) - rad_snmp.acct.start_time) * 100;
 299                         *var_len = sizeof(int32_t);
 300                         return (unsigned char *) &rad_snmp.acct.uptime;
 301
 302                 case RADIUSACCSERVRESETTIME:
 303                         rad_snmp.acct.reset_time = (time(NULL) - rad_snmp.acct.last_reset_time) * 100;
 304                         *var_len = sizeof(int32_t);
 305                         return (unsigned char *) &rad_snmp.acct.reset_time;
 306
 307                 case RADIUSACCSERVCONFIGRESET:
 308                         *write_method = radServReset;
 309                         result = 4;
 310                         return (unsigned char *) &result;
 311
 312                 case RADIUSACCSERVTOTALREQUESTS:
 313                         *var_len = sizeof(int32_t);
 314                         return (unsigned char *) &rad_snmp.acct.total_requests;
 315
 316                 case RADIUSACCSERVTOTALINVALIDREQUESTS:
 317                         *var_len = sizeof(int32_t);
 318                         return (unsigned char *) &rad_snmp.acct.total_invalid_requests;
 319
 320                 case RADIUSACCSERVTOTALDUPREQUESTS:
 321                         *var_len = sizeof(int32_t);
 322                         return (unsigned char *) &rad_snmp.acct.total_dup_requests;
 323
 324                 case RADIUSACCSERVTOTALRESPONSES:
 325                         *var_len = sizeof(int32_t);
 326                         return (unsigned char *) &rad_snmp.acct.total_responses;
 327
 328                 case RADIUSACCSERVTOTALMALFORMEDREQUESTS:
 329                         *var_len = sizeof(int32_t);
 330                         return (unsigned char *) &rad_snmp.acct.total_malformed_requests;
 331
 332                 case RADIUSACCSERVTOTALBADAUTHENTICATORS:
 333                         *var_len = sizeof(int32_t);
 334                         return (unsigned char *) &rad_snmp.acct.total_bad_authenticators;
 335
 336                 case RADIUSACCSERVTOTALPACKETSDROPPED:
 337                         *var_len = sizeof(int32_t);
 338                         return (unsigned char *) &rad_snmp.acct.total_packets_dropped;
 339
 340                 case RADIUSACCSERVTOTALNORECORDS:
 341                         *var_len = sizeof(int32_t);
 342                         return (unsigned char *) &rad_snmp.acct.total_no_records;
 343
 344                 case RADIUSACCSERVTOTALUNKNOWNTYPES:
 345                         *var_len = sizeof(int32_t);
 346                         return (unsigned char *) &rad_snmp.acct.total_unknown_types;
 347
 348         }
 349
 350         return NULL;
 351 }
 352
 353 static const unsigned char *
 354 radAccEntry(struct variable *vp, oid *name, size_t *length, int exact,
 355                 size_t *var_len, WriteMethod **write_method) {
 356
 357         RADCLIENT *c;
 358
 359         *write_method = NULL; /* table is read only */
 360         c = get_client(vp, name, length, exact);
 361         if (!c)
 362                 return NULL;
 363
 364         /* return the current value of the variable */
 365
 366         switch (vp->magic) {
 367                 case RADIUSACCCLIENTADDRESS:
 368                         *var_len = sizeof(c->ipaddr);
 369                         return (unsigned char *)&(c->ipaddr);
 370
 371                 case RADIUSACCCLIENTID:
 372                         if (strlen(c->shortname)) {
 373                                 *var_len = strlen(c->shortname);
 374                                 return c->shortname;
 375                         }
 376                         *var_len = strlen(c->longname);
 377                         return c->longname;
 378
 379                 case RADIUSACCSERVPACKETSDROPPED:
 380                         return (unsigned char *) NULL;
 381
 382                 case RADIUSACCSERVREQUESTS:
 383                         return (unsigned char *) NULL;
 384
 385                 case RADIUSACCSERVDUPREQUESTS:
 386                         return (unsigned char *) NULL;
 387
 388                 case RADIUSACCSERVRESPONSES:
 389                         return (unsigned char *) NULL;
 390
 391                 case RADIUSACCSERVBADAUTHENTICATORS:
 392                         return (unsigned char *) NULL;
 393
 394                 case RADIUSACCSERVMALFORMEDREQUESTS:
 395                         return (unsigned char *) NULL;
 396
 397                 case RADIUSACCSERVNORECORDS:
 398                         return (unsigned char *) NULL;
 399
 400                 case RADIUSACCSERVUNKNOWNTYPES:
 401                         return (unsigned char *) NULL;
 402
 403         }
 404         return NULL;
 405 }
 406
 407 static const unsigned char *
 408 radAuthServ(struct variable *vp, oid *name, size_t *length, int exact,
 409                 size_t *var_len, WriteMethod **write_method) {
 410
 411         static int result;
 412         /* check whether the instance identifier is valid */
 413
 414         if (smux_header_generic(vp, name, length, exact, var_len,
 415                         write_method) == MATCH_FAILED) {
 416                 return NULL;
 417         }
 418
 419         /* return the current value of the variable */
 420
 421         switch (vp->magic) {
 422
 423                 case RADIUSAUTHSERVIDENT:
 424                         *var_len = strlen(rad_snmp.auth.ident);
 425                         return (const unsigned char *) rad_snmp.auth.ident;
 426
 427                 case RADIUSAUTHSERVUPTIME:
 428                         rad_snmp.auth.uptime = (time(NULL) - rad_snmp.auth.start_time) * 100;
 429                         *var_len = sizeof(int32_t);
 430                         return (unsigned char *) &rad_snmp.auth.uptime;
 431
 432                 case RADIUSAUTHSERVRESETTIME:
 433                         rad_snmp.auth.reset_time = (time(NULL) - rad_snmp.auth.last_reset_time) * 100;
 434                         *var_len = sizeof(int32_t);
 435                         return (unsigned char *) &rad_snmp.auth.reset_time;
 436
 437                 case RADIUSAUTHSERVCONFIGRESET:
 438                         *write_method = radServReset;
 439                         result = 4;
 440                         return (unsigned char *) &result;
 441
 442                 case RADIUSAUTHSERVTOTALACCESSREQUESTS:
 443                         *var_len = sizeof(int32_t);
 444                         return (unsigned char *) &rad_snmp.auth.total_requests;
 445
 446                 case RADIUSAUTHSERVTOTALINVALIDREQUESTS:
 447                         *var_len = sizeof(int32_t);
 448                         return (unsigned char *) &rad_snmp.auth.total_invalid_requests;
 449
 450                 case RADIUSAUTHSERVTOTALDUPACCESSREQUESTS:
 451                         *var_len = sizeof(int32_t);
 452                         return (unsigned char *) &rad_snmp.auth.total_dup_requests;
 453
 454                 case RADIUSAUTHSERVTOTALACCESSACCEPTS:
 455                         *var_len = sizeof(int32_t);
 456                         return (unsigned char *) &rad_snmp.auth.total_access_accepts;
 457
 458                 case RADIUSAUTHSERVTOTALACCESSREJECTS:
 459                         *var_len = sizeof(int32_t);
 460                         return (unsigned char *) &rad_snmp.auth.total_access_rejects;
 461
 462                 case RADIUSAUTHSERVTOTALACCESSCHALLENGES:
 463                         *var_len = sizeof(int32_t);
 464                         return (unsigned char *) &rad_snmp.auth.total_access_challenges;
 465
 466                 case RADIUSAUTHSERVTOTALMALFORMEDACCESSREQUESTS:
 467                         *var_len = sizeof(int32_t);
 468                         return (unsigned char *) &rad_snmp.auth.total_malformed_requests;
 469
 470                 case RADIUSAUTHSERVTOTALBADAUTHENTICATORS:
 471                         *var_len = sizeof(int32_t);
 472                         return (unsigned char *) &rad_snmp.auth.total_bad_authenticators;
 473
 474                 case RADIUSAUTHSERVTOTALPACKETSDROPPED:
 475                         *var_len = sizeof(int32_t);
 476                         return (unsigned char *) &rad_snmp.auth.total_packets_dropped;
 477
 478                 case RADIUSAUTHSERVTOTALUNKNOWNTYPES:
 479                         *var_len = sizeof(int32_t);
 480                         return (unsigned char *) &rad_snmp.auth.total_unknown_types;
 481
 482         }
 483
 484     return NULL;
 485 }
 486
 487 static const unsigned char *
 488 radAuthEntry(struct variable *vp, oid    *name, size_t *length, int exact,
 489                 size_t *var_len, WriteMethod **write_method) {
 490
 491         RADCLIENT *c;
 492
 493         *write_method = NULL; /* table is read only */
 494         c = get_client(vp, name, length, exact);
 495         if (!c)
 496                 return NULL;
 497
 498         /* return the current value of the variable */
 499
 500         switch (vp->magic) {
 501
 502                 case RADIUSAUTHCLIENTADDRESS:
 503                         *var_len = sizeof(c->ipaddr);
 504                         return (unsigned char *)&(c->ipaddr);
 505
 506                 case RADIUSAUTHCLIENTID:
 507                         if (strlen(c->shortname)) {
 508                                 *var_len = strlen(c->shortname);
 509                                         return c->shortname;
 510                         }
 511                 *var_len = strlen(c->longname);
 512                         return c->longname;
 513
 514                 case RADIUSAUTHSERVACCESSREQUESTS:
 515                         return (unsigned char *) NULL;
 516
 517                 case RADIUSAUTHSERVDUPACCESSREQUESTS:
 518                         return (unsigned char *) NULL;
 519
 520                 case RADIUSAUTHSERVACCESSACCEPTS:
 521                         return (unsigned char *) NULL;
 522
 523                 case RADIUSAUTHSERVACCESSREJECTS:
 524                         return (unsigned char *) NULL;
 525
 526                 case RADIUSAUTHSERVACCESSCHALLENGES:
 527                         return (unsigned char *) NULL;
 528
 529                 case RADIUSAUTHSERVMALFORMEDACCESSREQUESTS:
 530                         return (unsigned char *) NULL;
 531
 532                 case RADIUSAUTHSERVBADAUTHENTICATORS:
 533                         return (unsigned char *) NULL;
 534
 535                 case RADIUSAUTHSERVPACKETSDROPPED:
 536                         return (unsigned char *) NULL;
 537
 538                 case RADIUSAUTHSERVUNKNOWNTYPES:
 539                         return (unsigned char *) NULL;
 540
 541         }
 542         return NULL;
 543 }
 544
 545 static CONF_PARSER snmp_config[] = {
 546         { "smux_password", PW_TYPE_STRING_PTR, 0, &rad_snmp.smux_password, "" },
 547         { "snmp_write_access",  PW_TYPE_BOOLEAN, 0, &rad_snmp.snmp_write_access, "no" },
 548         { NULL, -1, 0, NULL, NULL }
 549 };
 550
 551
 552 /* Register RADIUS MIBs. */
 553 void
 554 radius_snmp_init (void) {
 555
 556         CONF_SECTION *cs;
 557
 558         /*
 559          *  Initialize the RADIUS SNMP data structure.
 560          */
 561         memset(&rad_snmp, 0, sizeof(rad_snmp));
 562
 563         rad_snmp.auth.ident = radiusd_version;
 564         rad_snmp.acct.ident = radiusd_version;
 565
 566         rad_snmp.smux_event = SMUX_NONE;
 567         rad_snmp.smux_password = NULL;
 568         rad_snmp.snmp_write_access = FALSE;
 569         rad_snmp.smux_fd = -1;
 570         rad_snmp.smux_max_failures = 3; /* FIXME! get from config */
 571         rad_snmp.smux_failures = 0;
 572
 573         /*
 574          *  We really should get better clock resolution..
 575          */
 576         rad_snmp.auth.start_time = time(NULL);
 577         rad_snmp.auth.last_reset_time = rad_snmp.auth.start_time;
 578
 579         rad_snmp.acct.start_time = rad_snmp.auth.start_time;
 580         rad_snmp.acct.last_reset_time = rad_snmp.auth.start_time;
 581
 582         /*
 583          *  Parse the SNMP configuration information.
 584          */
 585         cs = cf_section_find(NULL);
 586         if (cs != NULL)
 587                 cf_section_parse(cs, NULL, snmp_config);
 588
 589         /*
 590          *  Do SMUX initialization.
 591          */
 592         smux_init (radius_oid, sizeof (radius_oid) / sizeof (oid));
 593         REGISTER_MIB("mibII/radius-acc-server", radiusacc_variables, variable, radacc_oid);
 594         REGISTER_MIB("mibII/radius-auth-server", radiusauth_variables, variable, radauth_oid);
 595         smux_start ();
 596 }
 597
 598 #endif /* WITH_SNMP */