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