/[radius]/radius/radiusd/snmpserv.c
ViewVC logotype

Diff of /radius/radiusd/snmpserv.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.56 by gray, Fri Aug 2 11:18:43 2002 UTC revision 1.57 by gray, Sun Apr 27 17:07:45 2003 UTC
# Line 1  Line 1 
1  /* This file is part of GNU RADIUS.  /* This file is part of GNU Radius.
2     Copyright (C) 2000,2001, Sergey Poznyakoff     Copyright (C) 2000,2001,2002,2003 Sergey Poznyakoff
3        
4     This program is free software; you can redistribute it and/or modify     GNU Radius is free software; you can redistribute it and/or modify
5     it under the terms of the GNU General Public License as published by     it under the terms of the GNU General Public License as published by
6     the Free Software Foundation; either version 2 of the License, or     the Free Software Foundation; either version 2 of the License, or
7     (at your option) any later version.     (at your option) any later version.
8        
9     This program is distributed in the hope that it will be useful,     GNU Radius is distributed in the hope that it will be useful,
10     but WITHOUT ANY WARRANTY; without even the implied warranty of     but WITHOUT ANY WARRANTY; without even the implied warranty of
11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12     GNU General Public License for more details.     GNU General Public License for more details.
13        
14     You should have received a copy of the GNU General Public License     You should have received a copy of the GNU General Public License
15     along with this program; if not, write to the Free Software Foundation,     along with GNU Radius; if not, write to the Free Software Foundation,
16     Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */     Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
17    
18  #define RADIUS_MODULE_SNMPSERV_C  #define RADIUS_MODULE_SNMPSERV_C
# Line 22  Line 22 
22    
23  #ifdef USE_SNMP  #ifdef USE_SNMP
24    
 #ifndef lint  
 static char rcsid[] = "@(#) $Id$";  
 #endif  
   
25  #include <sys/types.h>  #include <sys/types.h>
26  #include <sys/socket.h>  #include <sys/socket.h>
27  #include <asn1.h>  #include <asn1.h>
# Line 42  static char rcsid[] = "@(#) $Id$"; Line 38  static char rcsid[] = "@(#) $Id$";
38  #define MAXOIDLEN 512  #define MAXOIDLEN 512
39    
40  struct snmp_pdu * snmp_agent_response(struct snmp_pdu *pdu, int access);  struct snmp_pdu * snmp_agent_response(struct snmp_pdu *pdu, int access);
 int snmp_decode(SNMP_REQ *req, u_char *buf, int len);  
41  int variable_cmp(struct snmp_var *v1, struct snmp_var *v2);  int variable_cmp(struct snmp_var *v1, struct snmp_var *v2);
42  static NAS *nas_lookup_index(int ind);  static NAS *nas_lookup_index(int ind);
43  static void snmpserv_before_config_hook(void *unused1, void *unused2);  static void snmpserv_before_config_hook(void *unused1, void *unused2);
# Line 51  static void snmp_tree_init(); Line 46  static void snmp_tree_init();
46    
47  ACL *snmp_acl, *snmp_acl_tail;  ACL *snmp_acl, *snmp_acl_tail;
48  Community *commlist, *commlist_tail;  Community *commlist, *commlist_tail;
49  Server_stat server_stat;  Server_stat *server_stat;
50  struct radstat radstat;  struct radstat radstat;
51    
52  /* ************************************************************************ */  /* ************************************************************************ */
# Line 66  struct netlist { Line 61  struct netlist {
61  static Netlist *netlist;  static Netlist *netlist;
62    
63  static ACL *  static ACL *
64  find_netlist(name)  find_netlist(char *name)
         char *name;  
65  {  {
66          Netlist *p;          Netlist *p;
67    
# Line 81  find_netlist(name) Line 75  find_netlist(name)
75  static int _opened_snmp_sockets;  static int _opened_snmp_sockets;
76    
77  int  int
78  snmp_stmt_begin(finish, data, up_data)  snmp_stmt_begin(int finish, void *data, void *up_data)
         int finish;  
         void *data;  
         void *up_data;  
79  {  {
80          if (!finish) {          if (!finish) {
81                  snmp_free_communities();                  snmp_free_communities();
82                  snmp_free_acl();                  snmp_free_acl();
83                  _opened_snmp_sockets = 0;                  _opened_snmp_sockets = 0;
84          } else if (radius_mode == MODE_DAEMON && !_opened_snmp_sockets)          } else if (radius_mode == MODE_DAEMON && !_opened_snmp_sockets)
85                  socket_list_add(&socket_first,                  udp_open(R_SNMP, INADDR_ANY, snmp_port, 1);
                                 R_SNMP,  
                                 INADDR_ANY, snmp_port);  
86          return 0;          return 0;
87  }  }
88    
89  static int  static int
90  snmp_cfg_ident(argc, argv, block_data, handler_data)  snmp_cfg_ident(int argc, cfg_value_t *argv, void *block_data,
91          int argc;                 void *handler_data)
         cfg_value_t *argv;  
         void *block_data;  
         void *handler_data;  
92  {  {
93          if (argc > 2) {          if (argc > 2) {
94                  cfg_argc_error(0);                  cfg_argc_error(0);
# Line 128  static struct keyword snmp_access[] = { Line 114  static struct keyword snmp_access[] = {
114  };  };
115    
116  static int  static int
117  snmp_cfg_community(argc, argv, block_data, handler_data)  snmp_cfg_community(int argc, cfg_value_t *argv,
118          int argc;                     void *block_data, void *handler_data)
         cfg_value_t *argv;  
         void *block_data;  
         void *handler_data;  
119  {  {
120          int access;          int access;
121    
# Line 163  snmp_cfg_community(argc, argv, block_dat Line 146  snmp_cfg_community(argc, argv, block_dat
146  }  }
147    
148  static void  static void
149  destroy_netlist(netlist)  destroy_netlist(void *np)
         Netlist *netlist;  
150  {  {
151            Netlist *netlist = np;
152          free_acl(netlist->acl);          free_acl(netlist->acl);
153          efree(netlist->name);          efree(netlist->name);
154  }  }
155    
156  int  int
157  snmp_cfg_listen(argc, argv, block_data, handler_data)  snmp_cfg_listen(int argc, cfg_value_t *argv,
158          int argc;                  void *block_data, void *handler_data)
         cfg_value_t *argv;  
         void *block_data;  
         void *handler_data;  
159  {  {
160          int i, errcnt = 0;          int i, errcnt = 0;
161                    
# Line 187  snmp_cfg_listen(argc, argv, block_data, Line 167  snmp_cfg_listen(argc, argv, block_data,
167                    
168          if (errcnt == 0 && radius_mode == MODE_DAEMON)          if (errcnt == 0 && radius_mode == MODE_DAEMON)
169                  for (i = 1; i < argc; i++)                  for (i = 1; i < argc; i++)
170                          socket_list_add(&socket_first,                          udp_open(R_SNMP,
171                                          R_SNMP,                                   argv[i].v.host.ipaddr,
172                                          argv[i].v.host.ipaddr,                                   argv[i].v.host.port > 0 ?
173                                          argv[i].v.host.port > 0 ?                                   argv[i].v.host.port : snmp_port,
174                                          argv[i].v.host.port : snmp_port);                                   1);
175          _opened_snmp_sockets++;          _opened_snmp_sockets++;
176          return 0;          return 0;
177  }  }
178    
179  static int  static int
180  snmp_cfg_network(argc, argv, block_data, handler_data)  snmp_cfg_network(int argc, cfg_value_t *argv,
181          int argc;                   void *block_data, void *handler_data)
         cfg_value_t *argv;  
         void *block_data;  
         void *handler_data;  
182  {  {
183          int i;          int i;
184          Netlist *p;          Netlist *p;
# Line 244  snmp_cfg_network(argc, argv, block_data, Line 221  snmp_cfg_network(argc, argv, block_data,
221  }  }
222    
223  static int  static int
224  snmp_cfg_allow(argc, argv, block_data, handler_data)  snmp_cfg_allow(int argc, cfg_value_t *argv,
225          int argc;                 void *block_data, void *handler_data)
         cfg_value_t *argv;  
         void *block_data;  
         void *handler_data;  
226  {  {
227          Community *comm;          Community *comm;
228          ACL *acl;          ACL *acl;
# Line 282  snmp_cfg_allow(argc, argv, block_data, h Line 256  snmp_cfg_allow(argc, argv, block_data, h
256  }  }
257    
258  static int  static int
259  snmp_cfg_deny(argc, argv, block_data, handler_data)  snmp_cfg_deny(int argc, cfg_value_t *argv,
260          int argc;                void *block_data, void *handler_data)
         cfg_value_t *argv;  
         void *block_data;  
         void *handler_data;  
261  {  {
262          ACL *acl;          ACL *acl;
263                    
# Line 338  struct cfg_stmt snmp_stmt[] = { Line 309  struct cfg_stmt snmp_stmt[] = {
309          { NULL, }          { NULL, }
310  };  };
311    
312  void  static void
313  snmpserv_before_config_hook(unused1, unused2)  snmpserv_before_config_hook(void *a ARG_UNUSED, void *b ARG_UNUSED)
         void *unused1;  
         void *unused2;  
314  {  {
315          server_stat.auth.status = serv_init;          if (server_stat) {
316          server_stat.acct.status = serv_init;                  server_stat->auth.status = serv_init;
317                    server_stat->acct.status = serv_init;
318            }
319  }  }
320    
321  void  static void
322  snmpserv_after_config_hook(arg, unused)  snmpserv_after_config_hook(void *arg, void *data ARG_UNUSED)
         void *arg;  
         void *unused;  
323  {  {
324          server_stat.auth.status = suspend_flag ? serv_suspended : serv_running;          if (server_stat) {
325          snmp_auth_server_reset();                  NAS *nas;
326                    
327          server_stat.acct.status = server_stat.auth.status;                  server_stat->auth.status =
328          snmp_acct_server_reset();                          suspend_flag ? serv_suspended : serv_running;
329                                    snmp_auth_server_reset();
330          *(serv_stat*)arg = server_stat.auth.status;  
331                    server_stat->acct.status = server_stat->auth.status;
332                    snmp_acct_server_reset();
333                    
334                    *(serv_stat*)arg = server_stat->auth.status;
335    
336                    for (nas = nas_next(NULL); nas; nas = nas_next(nas))
337                            snmp_attach_nas_stat(nas);
338                    snmp_sort_nas_stat();
339            }
340  }  }
341    
342  void  void
343  snmpserv_init(arg)  snmpserv_init(void *arg)
         void *arg;  
344  {  {
345          register_before_config_hook(snmpserv_before_config_hook, NULL);          stat_init();
346          register_after_config_hook(snmpserv_after_config_hook, arg);          radiusd_set_preconfig_hook(snmpserv_before_config_hook, NULL, 0);
347            radiusd_set_postconfig_hook(snmpserv_after_config_hook, arg, 0);
348          snmp_tree_init();          snmp_tree_init();
349            snmpserv_after_config_hook(arg, NULL);
350  }  }
351    
352  /* ************************************************************************ */  /* ************************************************************************ */
353  /* ACL fiddling */  /* ACL fiddling */
354    
355  void  void
356  snmp_add_community(str, access)  snmp_add_community(char *str, int access)
         char *str;  
         int access;  
357  {  {
358          Community *p = mem_alloc(sizeof(*p));          Community *p = mem_alloc(sizeof(*p));
359          p->name = estrdup(str);          p->name = estrdup(str);
# Line 389  snmp_add_community(str, access) Line 366  snmp_add_community(str, access)
366  }  }
367    
368  Community *  Community *
369  snmp_find_community(str)  snmp_find_community(char *str)
         char *str;  
370  {  {
371          Community *p;          Community *p;
372    
# Line 414  snmp_free_communities() Line 390  snmp_free_communities()
390  }  }
391    
392  int  int
393  check_acl(ip, community)  check_acl(UINT4 ip, char *community)
         UINT4 ip;  
         char *community;  
394  {  {
395          ACL *acl;          ACL *acl;
396    
# Line 432  check_acl(ip, community) Line 406  check_acl(ip, community)
406  }  }
407    
408  void  void
409  snmp_add_acl(acl, community)  snmp_add_acl(ACL *acl, Community *community)
         ACL *acl;  
         Community *community;  
410  {  {
411          ACL *new_acl;          ACL *new_acl;
412                    
# Line 460  snmp_free_acl() Line 432  snmp_free_acl()
432  }  }
433    
434  void  void
435  free_acl(acl)  free_acl(ACL *acl)
         ACL *acl;  
436  {  {
437          ACL *next;          ACL *next;
438    
# Line 557  union snmpserv_data { Line 528  union snmpserv_data {
528          struct mem_data mem;          struct mem_data mem;
529  };  };
530    
531  static pthread_once_t snmpserv_once = PTHREAD_ONCE_INIT;  static union snmpserv_data *__snmpserv_data;
 static pthread_key_t snmpserv_key;  
   
 static void  
 snmpserv_data_destroy(ptr)  
         void *ptr;  
 {  
         efree(ptr);  
 }  
   
 static void  
 snmpserv_data_create()  
 {  
         pthread_key_create(&snmpserv_key, snmpserv_data_destroy);  
 }  
532    
533  static void *  static void *
534  snmpserv_get_data()  snmpserv_get_data()
535  {  {
536          union snmpserv_data *p;          if (!__snmpserv_data) {
537          pthread_once(&snmpserv_once, snmpserv_data_create);                  __snmpserv_data = emalloc(sizeof(*__snmpserv_data));
538          p = pthread_getspecific(snmpserv_key);                  __snmpserv_data->auth_mib.nas_index = 1;
         if (!p) {  
                 p = emalloc(sizeof(*p));  
                 p->auth_mib.nas_index = 1;  
                 pthread_setspecific(snmpserv_key, p);  
539          }          }
540          return p;          return __snmpserv_data;
541  }  }
542    
543  static struct mib_data {  static struct mib_data {
# Line 819  snmp_auth_server_reset() Line 772  snmp_auth_server_reset()
772          struct timezone tz;          struct timezone tz;
773    
774          gettimeofday(&tv, &tz);          gettimeofday(&tv, &tz);
775          server_stat.auth.reset_time = tv;          server_stat->auth.reset_time = tv;
776  }  }
777    
778  /* Mark reset of the acct server. Again, no real work, please.  /* Mark reset of the acct server. Again, no real work, please.
# Line 831  snmp_acct_server_reset() Line 784  snmp_acct_server_reset()
784          struct timezone tz;          struct timezone tz;
785    
786          gettimeofday(&tv, &tz);          gettimeofday(&tv, &tz);
787          server_stat.acct.reset_time = tv;          server_stat->acct.reset_time = tv;
 }  
   
 static int              i_send_buffer[1024];  
 static char             *send_buffer = (char *)i_send_buffer;  
   
 /* Create and return SNMP request structure */  
 SNMP_REQ *  
 rad_snmp_respond(buf, len, sa)  
         u_char *buf;  
         int len;  
         struct sockaddr_in *sa;  
 {  
         SNMP_REQ *req;  
         char ipbuf[DOTTED_QUAD_LEN];  
   
         req = mem_alloc(sizeof *req);  
         req->sa = *sa;  
   
         debug(1,  
                 ("got %d bytes from %s",  
                  len,  
                  ip_iptostr(ntohl(req->sa.sin_addr.s_addr), ipbuf)));  
           
         if (snmp_decode(req, buf, len)) {  
                 mem_free(req);  
                 req = NULL;  
         }  
         return req;  
 }  
   
 /* Decode the SNMP request */  
 int  
 snmp_decode(req, buf, len)  
         SNMP_REQ *req;  
         u_char *buf;  
         int len;  
 {  
         struct snmp_pdu *pdu;  
         struct snmp_session sess;  
         int access;  
         char comm[128];  
         int comm_len;  
         char ipbuf[DOTTED_QUAD_LEN];  
           
         if ((pdu = snmp_pdu_create(0)) == NULL) {  
                 radlog(L_ERR,  
                        _("can't create SNMP PDU: %s"),  
                          snmp_strerror(snmp_errno));  
                 return -1;  
         }  
         comm_len = sizeof(comm);  
         if (snmp_decode_request(&sess, pdu, buf, len, comm, &comm_len)) {  
                 radlog(L_ERR,  
                        _("can't decode SNMP packet from %s: %s"),  
                          ip_iptostr(ntohl(req->sa.sin_addr.s_addr), ipbuf),  
                          snmp_strerror(snmp_errno));  
                 return -1;  
         }  
   
         access = check_acl(req->sa.sin_addr.s_addr, comm);  
         if (!access) {  
                 radlog(L_NOTICE,  
                        _("DENIED attempt to access community %s from %s"),  
                        comm,  
                        ip_iptostr(ntohl(req->sa.sin_addr.s_addr), ipbuf));  
                 return 1;  
         }  
         req->pdu = pdu;  
         req->community = estrdup(comm);  
         req->access = access;  
         return 0;  
 }  
   
 /* Compare two SNMP requests */  
 int  
 snmp_req_cmp(a, b)  
         SNMP_REQ *a, *b;  
 {  
         return !(a->sa.sin_addr.s_addr == b->sa.sin_addr.s_addr &&  
                  a->pdu->req_id == b->pdu->req_id);  
 }  
   
 /* Free the SNMP request */  
 void  
 snmp_req_free(req)  
         SNMP_REQ *req;  
 {  
         snmp_pdu_free(req->pdu);  
         efree(req->community);  
         mem_free(req);  
788  }  }
789    
 /*ARGSUSED*/  
 void  
 snmp_req_drop(type, req, orig, fd, status_str)  
         int type;  
         SNMP_REQ *req;  
         SNMP_REQ *orig;  
         int fd;  
         char *status_str;  
 {  
         char ipbuf[DOTTED_QUAD_LEN];  
   
         if (!req)  
                 req = orig;  
         radlog(L_NOTICE,  
                _("Dropping SNMP request from client %s: %s"),  
                ip_iptostr(ntohl(req->sa.sin_addr.s_addr), ipbuf),  
                status_str);  
 }  
   
 /* Answer the request */  
 int  
 snmp_answer(req, sock)  
         SNMP_REQ *req;  
         int sock;  
 {  
         struct snmp_session session;  
         struct snmp_pdu *pdu;  
         int len;  
   
         log_open(L_SNMP);  
         pdu = snmp_agent_response(req->pdu, req->access);  
         if (pdu) {  
                 session.version = SNMP_VERSION_1;  
                 session.community.str = req->community;  
                 session.community.len = strlen(req->community);  
                 len = sizeof(i_send_buffer);  
                 if (snmp_encode_request(&session, pdu, send_buffer, &len)==0) {  
                         sendto(sock,  
                                send_buffer, len,  
                                0, (struct sockaddr *) &req->sa,  
                                sizeof(req->sa));  
                 }  
                 snmp_pdu_free(pdu);  
         }  
         return 0;  
 }  
790    
791  /* ************************************************************************* */  /* ************************************************************************* */
792  /* FIXME: these belong to snmp_mib.c */  /* FIXME: these belong to snmp_mib.c */
# Line 989  void mib_reset(struct mib_node_t *node); Line 806  void mib_reset(struct mib_node_t *node);
806  /* For a given node generate its oid. Note: When not needed anymore, the  /* For a given node generate its oid. Note: When not needed anymore, the
807     oid should be freed by snmp_free */     oid should be freed by snmp_free */
808  oid_t  oid_t
809  mib_node_oid(node)  mib_node_oid(struct mib_node_t *node)
         struct mib_node_t *node;  
810  {  {
811          oid_t oid;          oid_t oid;
812          int i;          int i;
# Line 1010  mib_node_oid(node) Line 826  mib_node_oid(node)
826  }  }
827    
828  void  void
829  mib_reset(node)  mib_reset(struct mib_node_t *node)
         struct mib_node_t *node;  
830  {  {
831          if (node->subid == SUBID_X) {          if (node->subid == SUBID_X) {
832                  (*node->handler)(MIB_NODE_RESET, node->closure,                  (*node->handler)(MIB_NODE_RESET, node->closure,
# Line 1021  mib_reset(node) Line 836  mib_reset(node)
836  }  }
837                                    
838  int  int
839  mib_down(node, oid)  mib_down(struct mib_node_t *node, oid_t oid)
         struct mib_node_t *node;  
         oid_t oid;  
840  {  {
841          if (node->subid == SUBID_X) {          if (node->subid == SUBID_X) {
842                  if (OIDLEN(oid) <= node->index) {                  if (OIDLEN(oid) <= node->index) {
# Line 1046  mib_down(node, oid) Line 859  mib_down(node, oid)
859             errp[0]    -- Error status             errp[0]    -- Error status
860     Return: 0 -- OK */             Return: 0 -- OK */        
861  int  int
862  mib_get_next(node, varp, errp)  mib_get_next(struct mib_node_t *node, struct snmp_var **varp, int *errp)
         struct mib_node_t *node;  
         struct snmp_var **varp;  
         int *errp;  
863  {  {
864          int rc;          int rc;
865          oid_t oid = (*varp)->name;          oid_t oid = (*varp)->name;
# Line 1143  mib_get_next(node, varp, errp) Line 953  mib_get_next(node, varp, errp)
953             errp[0]    -- Error status             errp[0]    -- Error status
954     Return: 0 -- OK */             Return: 0 -- OK */        
955  int  int
956  mib_get(node, varp, errp)  mib_get(struct mib_node_t *node, struct snmp_var **varp, int *errp)
         struct mib_node_t *node;  
         struct snmp_var **varp;  
         int *errp;  
957  {  {
958          oid_t oid = (*varp)->name;          oid_t oid = (*varp)->name;
959                    
# Line 1167  mib_get(node, varp, errp) Line 974  mib_get(node, varp, errp)
974     Output:errp -- error status     Output:errp -- error status
975     Return: 0 -- OK */     Return: 0 -- OK */
976  int  int
977  mib_set_try(node, varp, errp)  mib_set_try(struct mib_node_t *node, struct snmp_var **varp, int *errp)
         struct mib_node_t *node;  
         struct snmp_var **varp;  
         int *errp;  
978  {  {
979          oid_t oid = (*varp)->name;          oid_t oid = (*varp)->name;
980                    
# Line 1194  mib_set_try(node, varp, errp) Line 998  mib_set_try(node, varp, errp)
998            varp[0][0] -- variable to be set            varp[0][0] -- variable to be set
999     Return: 0 -- OK */     Return: 0 -- OK */
1000  int  int
1001  mib_set(node, varp)  mib_set(struct mib_node_t *node, struct snmp_var **varp)
         struct mib_node_t *node;  
         struct snmp_var **varp;  
1002  {  {
1003          oid_t oid = (*varp)->name;          oid_t oid = (*varp)->name;
1004                    
# Line 1217  mib_set(node, varp) Line 1019  mib_set(node, varp)
1019            access -- Access rights            access -- Access rights
1020     Return:Response PDU, NULL on error */               Return:Response PDU, NULL on error */          
1021  struct snmp_pdu *  struct snmp_pdu *
1022  snmp_agent_response(pdu, access)  snmp_agent_response(struct snmp_pdu *pdu, int access)
         struct snmp_pdu *pdu;  
         int access;  
1023  {  {
1024          struct snmp_pdu *answer = NULL;          struct snmp_pdu *answer = NULL;
1025          struct snmp_var *vp, *vnew = NULL, **vpp;          struct snmp_var *vp, *vnew = NULL, **vpp;
# Line 1324  snmp_agent_response(pdu, access) Line 1124  snmp_agent_response(pdu, access)
1124                                  if (answer->err_stat != SNMP_ERR_NOERROR                                  if (answer->err_stat != SNMP_ERR_NOERROR
1125                                      || vnew == NULL) {                                      || vnew == NULL) {
1126                                          answer->err_ind = index;                                          answer->err_ind = index;
1127                                          debug(1, ("returning"));                                          debug(1, ("returning: err_stat=%d",
1128                                                      answer->err_stat));
1129                                          /* preserve the rest of vars */                                          /* preserve the rest of vars */
1130                                          *vresp = snmp_var_dup_list(vp);                                          *vresp = snmp_var_dup_list(vp);
1131                                          *vpp = NULL;                                          *vpp = NULL;
# Line 1350  snmp_agent_response(pdu, access) Line 1151  snmp_agent_response(pdu, access)
1151  /* ************************************************************************* */  /* ************************************************************************* */
1152    
1153  counter  counter
1154  timeval_diff(tva, tvb)  timeval_diff(struct timeval *tva, struct timeval *tvb)
         struct timeval *tva, *tvb;  
1155  {  {
1156          return  (tva->tv_sec - tvb->tv_sec)*100 +          return  (tva->tv_sec - tvb->tv_sec)*100 +
1157                  (tva->tv_usec - tvb->tv_usec)/10000;                  (tva->tv_usec - tvb->tv_usec)/10000;
# Line 1360  timeval_diff(tva, tvb) Line 1160  timeval_diff(tva, tvb)
1160  serv_stat  serv_stat
1161  abridge_server_state()  abridge_server_state()
1162  {  {
1163          switch (server_stat.auth.status) {          switch (server_stat->auth.status) {
1164          case serv_init:          case serv_init:
1165          case serv_running:          case serv_running:
1166                  return server_stat.auth.status;                  return server_stat->auth.status;
1167          case serv_other:          case serv_other:
1168          default:          default:
1169                  return serv_other;                  return serv_other;
# Line 1377  struct snmp_var *snmp_auth_var_get(subid Line 1177  struct snmp_var *snmp_auth_var_get(subid
1177  int snmp_auth_var_set(subid_t subid, struct snmp_var **vp, int *errp);  int snmp_auth_var_set(subid_t subid, struct snmp_var **vp, int *errp);
1178    
1179  /* Handler function for fixed oids from the authentication subtree */  /* Handler function for fixed oids from the authentication subtree */
 /*ARGSUSED*/  
1180  int  int
1181  snmp_auth_handler(cmd, closure, subid, varp, errp)  snmp_auth_handler(enum mib_node_cmd cmd, void *closure,
1182          enum mib_node_cmd cmd;                    subid_t subid, struct snmp_var **varp, int *errp)
         void *closure;  
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
1183  {  {
1184          oid_t oid = (*varp)->name;          oid_t oid = (*varp)->name;
1185                    
# Line 1412  snmp_auth_handler(cmd, closure, subid, v Line 1207  snmp_auth_handler(cmd, closure, subid, v
1207  }  }
1208    
1209  struct snmp_var *  struct snmp_var *
1210  snmp_auth_var_get(subid, oid, errp)  snmp_auth_var_get(subid_t subid, oid_t oid, int *errp)
         subid_t subid;  
         oid_t oid;  
         int *errp;  
1211  {  {
1212          struct snmp_var *ret;          struct snmp_var *ret;
1213          struct timeval tv;          struct timeval tv;
# Line 1439  snmp_auth_var_get(subid, oid, errp) Line 1231  snmp_auth_var_get(subid, oid, errp)
1231                  gettimeofday(&tv, &tz);                  gettimeofday(&tv, &tz);
1232                  ret->type = SMI_TIMETICKS;                  ret->type = SMI_TIMETICKS;
1233                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1234                  ret->var_int = timeval_diff(&tv, &server_stat.start_time);                  ret->var_int = timeval_diff(&tv, &server_stat->start_time);
1235                  break;                  break;
1236    
1237          case MIB_KEY_AuthServResetTime:          case MIB_KEY_AuthServResetTime:
# Line 1447  snmp_auth_var_get(subid, oid, errp) Line 1239  snmp_auth_var_get(subid, oid, errp)
1239                  ret->type = SMI_TIMETICKS;                  ret->type = SMI_TIMETICKS;
1240                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1241                  ret->var_int = timeval_diff(&tv,                  ret->var_int = timeval_diff(&tv,
1242                                              &server_stat.auth.reset_time);                                              &server_stat->auth.reset_time);
1243                  break;                  break;
1244    
1245          case MIB_KEY_AuthServConfigReset:          case MIB_KEY_AuthServConfigReset:
# Line 1459  snmp_auth_var_get(subid, oid, errp) Line 1251  snmp_auth_var_get(subid, oid, errp)
1251          case MIB_KEY_AuthServTotalAccessRequests:          case MIB_KEY_AuthServTotalAccessRequests:
1252                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1253                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1254                  ret->var_int = server_stat.auth.num_access_req;                  ret->var_int = server_stat->auth.num_access_req;
1255                  break;                  break;
1256    
1257          case MIB_KEY_AuthServTotalInvalidRequests:          case MIB_KEY_AuthServTotalInvalidRequests:
1258                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1259                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1260                  ret->var_int = server_stat.auth.num_invalid_req;                  ret->var_int = server_stat->auth.num_invalid_req;
1261                  break;                  break;
1262    
1263          case MIB_KEY_AuthServTotalDupAccessRequests:          case MIB_KEY_AuthServTotalDupAccessRequests:
1264                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1265                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1266                  ret->var_int = server_stat.auth.num_dup_req;                  ret->var_int = server_stat->auth.num_dup_req;
1267                  break;                  break;
1268    
1269          case MIB_KEY_AuthServTotalAccessAccepts:          case MIB_KEY_AuthServTotalAccessAccepts:
1270                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1271                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1272                  ret->var_int = server_stat.auth.num_accepts;                  ret->var_int = server_stat->auth.num_accepts;
1273                  break;                  break;
1274    
1275          case MIB_KEY_AuthServTotalAccessRejects:          case MIB_KEY_AuthServTotalAccessRejects:
1276                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1277                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1278                  ret->var_int = server_stat.auth.num_rejects;                  ret->var_int = server_stat->auth.num_rejects;
1279                  break;                  break;
1280    
1281          case MIB_KEY_AuthServTotalAccessChallenges:          case MIB_KEY_AuthServTotalAccessChallenges:
1282                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1283                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1284                  ret->var_int = server_stat.auth.num_challenges;                  ret->var_int = server_stat->auth.num_challenges;
1285                  break;                  break;
1286    
1287          case MIB_KEY_AuthServTotalMalformedAccessRequests:          case MIB_KEY_AuthServTotalMalformedAccessRequests:
1288                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1289                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1290                  ret->var_int = server_stat.auth.num_bad_req;                  ret->var_int = server_stat->auth.num_bad_req;
1291                  break;                  break;
1292    
1293          case MIB_KEY_AuthServTotalBadAuthenticators:          case MIB_KEY_AuthServTotalBadAuthenticators:
1294                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1295                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1296                  ret->var_int = server_stat.auth.num_bad_auth;                  ret->var_int = server_stat->auth.num_bad_auth;
1297                  break;                  break;
1298                                    
1299          case MIB_KEY_AuthServTotalPacketsDropped:          case MIB_KEY_AuthServTotalPacketsDropped:
1300                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1301                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1302                  ret->var_int = server_stat.auth.num_dropped;                  ret->var_int = server_stat->auth.num_dropped;
1303                  break;                  break;
1304    
1305          case MIB_KEY_AuthServTotalUnknownTypes:          case MIB_KEY_AuthServTotalUnknownTypes:
1306                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1307                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1308                  ret->var_int = server_stat.auth.num_unknowntypes;                  ret->var_int = server_stat->auth.num_unknowntypes;
1309                  break;                  break;
1310                                    
1311          default:          default:
# Line 1525  snmp_auth_var_get(subid, oid, errp) Line 1317  snmp_auth_var_get(subid, oid, errp)
1317  }  }
1318    
1319  int  int
1320  snmp_auth_var_set(subid, vp, errp)  snmp_auth_var_set(subid_t subid, struct snmp_var **vp, int *errp)
         subid_t subid;  
         struct snmp_var **vp;  
         int *errp;  
1321  {  {
1322          if (errp) { /* just test */          if (errp) { /* just test */
1323                  *errp = SNMP_ERR_NOERROR;                  *errp = SNMP_ERR_NOERROR;
# Line 1552  snmp_auth_var_set(subid, vp, errp) Line 1341  snmp_auth_var_set(subid, vp, errp)
1341                  switch (subid) {                  switch (subid) {
1342                                                    
1343                  case MIB_KEY_AccServConfigReset:                  case MIB_KEY_AccServConfigReset:
1344                          server_stat.auth.status = serv_init;                          server_stat->auth.status = serv_init;
1345                          radlog(L_INFO,                          radlog(L_INFO,
1346                               _("acct server re-initializing on SNMP request"));                               _("acct server re-initializing on SNMP request"));
1347                          break;                          break;
# Line 1574  int snmp_auth_var_next(subid_t subid, st Line 1363  int snmp_auth_var_next(subid_t subid, st
1363    
1364  /* Handler function for variable oid of the authentication subtree */  /* Handler function for variable oid of the authentication subtree */
1365  int  int
1366  snmp_auth_v_handler(cmd, unused, subid, varp, errp)  snmp_auth_v_handler(enum mib_node_cmd cmd, void *unused, subid_t subid,
1367          enum mib_node_cmd cmd;                      struct snmp_var **varp, int *errp)
         void *unused;  
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
1368  {  {
1369          struct auth_mib_data *data = (struct auth_mib_data *)          struct auth_mib_data *data = (struct auth_mib_data *)
1370                                              snmpserv_get_data();                                              snmpserv_get_data();
# Line 1615  snmp_auth_v_handler(cmd, unused, subid, Line 1400  snmp_auth_v_handler(cmd, unused, subid,
1400  }  }
1401    
1402  int  int
1403  snmp_auth_var_next(subid, closure)  snmp_auth_var_next(subid_t subid, struct auth_mib_data *closure)
         subid_t subid;  
         struct auth_mib_data *closure;  
1404  {  {
1405          if (!nas_lookup_index(subid))          if (!nas_lookup_index(subid))
1406                  return -1;                  return -1;
# Line 1627  snmp_auth_var_next(subid, closure) Line 1410  snmp_auth_var_next(subid, closure)
1410  }  }
1411    
1412  struct snmp_var *  struct snmp_var *
1413  snmp_auth_var_v_get(subid, var, errp)  snmp_auth_var_v_get(subid_t subid, struct snmp_var *var, int *errp)
         subid_t subid;  
         struct snmp_var *var;  
         int *errp;  
1414  {  {
1415          struct snmp_var *ret;          struct snmp_var *ret;
1416          subid_t key;          subid_t key;
# Line 1667  snmp_auth_var_v_get(subid, var, errp) Line 1447  snmp_auth_var_v_get(subid, var, errp)
1447  }  }
1448    
1449  void  void
1450  get_auth_nasstat(nas, var, key)  get_auth_nasstat(NAS *nas, struct snmp_var *var, int key)
         NAS *nas;  
         struct snmp_var *var;  
         int key;  
1451  {  {
1452          struct nas_stat *statp = nas->app_data;          struct nas_stat *statp = nas->app_data;
1453                    
# Line 1758  struct snmp_var *snmp_acct_var_get(subid Line 1535  struct snmp_var *snmp_acct_var_get(subid
1535  int snmp_acct_var_set(subid_t subid, struct snmp_var **vp, int *errp);  int snmp_acct_var_set(subid_t subid, struct snmp_var **vp, int *errp);
1536    
1537  /* Handler function for fixed oids from the authentication subtree */  /* Handler function for fixed oids from the authentication subtree */
1538  /*ARGSUSED*/  
1539  int  int
1540  snmp_acct_handler(cmd, closure, subid, varp, errp)  snmp_acct_handler(enum mib_node_cmd cmd, void *closure, subid_t subid,
1541          enum mib_node_cmd cmd;                    struct snmp_var **varp, int *errp)
         void *closure;  
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
1542  {  {
1543          oid_t oid = (*varp)->name;          oid_t oid = (*varp)->name;
1544                    
# Line 1793  snmp_acct_handler(cmd, closure, subid, v Line 1566  snmp_acct_handler(cmd, closure, subid, v
1566  }  }
1567    
1568  struct snmp_var *  struct snmp_var *
1569  snmp_acct_var_get(subid, oid, errp)  snmp_acct_var_get(subid_t subid, oid_t oid, int *errp)
         subid_t subid;  
         oid_t oid;  
         int *errp;  
1570  {  {
1571          struct snmp_var *ret;          struct snmp_var *ret;
1572          struct timeval tv;          struct timeval tv;
# Line 1820  snmp_acct_var_get(subid, oid, errp) Line 1590  snmp_acct_var_get(subid, oid, errp)
1590                  gettimeofday(&tv, &tz);                  gettimeofday(&tv, &tz);
1591                  ret->type = SMI_TIMETICKS;                  ret->type = SMI_TIMETICKS;
1592                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1593                  ret->var_int = timeval_diff(&tv, &server_stat.start_time);                  ret->var_int = timeval_diff(&tv, &server_stat->start_time);
1594                  break;                  break;
1595                                    
1596          case MIB_KEY_AccServResetTime:          case MIB_KEY_AccServResetTime:
1597                  gettimeofday(&tv, &tz);                  gettimeofday(&tv, &tz);
1598                  ret->type = SMI_TIMETICKS;                  ret->type = SMI_TIMETICKS;
1599                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1600                  ret->var_int = timeval_diff(&tv, &server_stat.acct.reset_time);                  ret->var_int = timeval_diff(&tv, &server_stat->acct.reset_time);
1601                  break;                  break;
1602    
1603          case MIB_KEY_AccServConfigReset:          case MIB_KEY_AccServConfigReset:
# Line 1839  snmp_acct_var_get(subid, oid, errp) Line 1609  snmp_acct_var_get(subid, oid, errp)
1609          case MIB_KEY_AccServTotalRequests:          case MIB_KEY_AccServTotalRequests:
1610                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1611                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1612                  ret->var_int = server_stat.acct.num_req;                  ret->var_int = server_stat->acct.num_req;
1613                  break;                  break;
1614                                    
1615          case MIB_KEY_AccServTotalInvalidRequests:          case MIB_KEY_AccServTotalInvalidRequests:
1616                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1617                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1618                  ret->var_int = server_stat.acct.num_invalid_req;                  ret->var_int = server_stat->acct.num_invalid_req;
1619                  break;                  break;
1620                                    
1621          case MIB_KEY_AccServTotalDupRequests:          case MIB_KEY_AccServTotalDupRequests:
1622                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1623                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1624                  ret->var_int = server_stat.acct.num_dup_req;                  ret->var_int = server_stat->acct.num_dup_req;
1625                  break;                  break;
1626                                    
1627          case MIB_KEY_AccServTotalResponses:          case MIB_KEY_AccServTotalResponses:
1628                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1629                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1630                  ret->var_int = server_stat.acct.num_resp;                  ret->var_int = server_stat->acct.num_resp;
1631                  break;                  break;
1632                                    
1633          case MIB_KEY_AccServTotalMalformedRequests:          case MIB_KEY_AccServTotalMalformedRequests:
1634                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1635                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1636                  ret->var_int = server_stat.acct.num_bad_req;                  ret->var_int = server_stat->acct.num_bad_req;
1637                  break;                  break;
1638                                    
1639          case MIB_KEY_AccServTotalBadAuthenticators:          case MIB_KEY_AccServTotalBadAuthenticators:
1640                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1641                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1642                  ret->var_int = server_stat.acct.num_bad_sign;                  ret->var_int = server_stat->acct.num_bad_sign;
1643                  break;                  break;
1644                                    
1645          case MIB_KEY_AccServTotalPacketsDropped:          case MIB_KEY_AccServTotalPacketsDropped:
1646                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1647                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1648                  ret->var_int = server_stat.acct.num_dropped;                  ret->var_int = server_stat->acct.num_dropped;
1649                  break;                  break;
1650                                    
1651          case MIB_KEY_AccServTotalNoRecords:          case MIB_KEY_AccServTotalNoRecords:
1652                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1653                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1654                  ret->var_int = server_stat.acct.num_norecords;                  ret->var_int = server_stat->acct.num_norecords;
1655                  break;                  break;
1656                                    
1657          case MIB_KEY_AccServTotalUnknownTypes:          case MIB_KEY_AccServTotalUnknownTypes:
1658                  ret->type = SMI_COUNTER32;                  ret->type = SMI_COUNTER32;
1659                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1660                  ret->var_int = server_stat.acct.num_unknowntypes;                  ret->var_int = server_stat->acct.num_unknowntypes;
1661                  break;                  break;
1662                                    
1663          default:          default:
# Line 1899  snmp_acct_var_get(subid, oid, errp) Line 1669  snmp_acct_var_get(subid, oid, errp)
1669  }  }
1670    
1671  int  int
1672  snmp_acct_var_set(subid, vp, errp)  snmp_acct_var_set(subid_t subid, struct snmp_var **vp, int *errp)
         subid_t subid;  
         struct snmp_var **vp;  
         int *errp;  
1673  {  {
1674          if (errp) { /* just test */          if (errp) { /* just test */
1675                  *errp = SNMP_ERR_NOERROR;                  *errp = SNMP_ERR_NOERROR;
# Line 1926  snmp_acct_var_set(subid, vp, errp) Line 1693  snmp_acct_var_set(subid, vp, errp)
1693                  switch (subid) {                  switch (subid) {
1694    
1695                  case MIB_KEY_AuthServConfigReset:                  case MIB_KEY_AuthServConfigReset:
1696                          server_stat.auth.status = serv_init;                          server_stat->auth.status = serv_init;
1697                          radlog(L_INFO,                          radlog(L_INFO,
1698                               _("auth server re-initializing on SNMP request"));                               _("auth server re-initializing on SNMP request"));
1699                          break;                          break;
# Line 1945  struct snmp_var *snmp_acct_var_v_get(sub Line 1712  struct snmp_var *snmp_acct_var_v_get(sub
1712    
1713  /* Handler function for variable oid of the authentication subtree */  /* Handler function for variable oid of the authentication subtree */
1714  int  int
1715  snmp_acct_v_handler(cmd, unused, subid, varp, errp)  snmp_acct_v_handler(enum mib_node_cmd cmd, void *unused, subid_t subid,
1716          enum mib_node_cmd cmd;                      struct snmp_var **varp, int *errp)
         void *unused;  
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
1717  {  {
1718          struct auth_mib_data *data = (struct auth_mib_data *)          struct auth_mib_data *data = (struct auth_mib_data *)
1719                                          snmpserv_get_data();                                          snmpserv_get_data();
# Line 1986  snmp_acct_v_handler(cmd, unused, subid, Line 1749  snmp_acct_v_handler(cmd, unused, subid,
1749  }  }
1750    
1751  struct snmp_var *  struct snmp_var *
1752  snmp_acct_var_v_get(subid, var, errp)  snmp_acct_var_v_get(subid_t subid, struct snmp_var *var, int *errp)
         subid_t subid;  
         struct snmp_var *var;  
         int *errp;  
1753  {  {
1754          struct snmp_var *ret;          struct snmp_var *ret;
1755          subid_t key;          subid_t key;
# Line 2025  snmp_acct_var_v_get(subid, var, errp) Line 1785  snmp_acct_var_v_get(subid, var, errp)
1785  }  }
1786    
1787  void  void
1788  get_acct_nasstat(nas, var, key)  get_acct_nasstat(NAS *nas, struct snmp_var *var, int key)
         NAS *nas;  
         struct snmp_var *var;  
         int key;  
1789  {  {
1790          struct nas_stat *statp = nas->app_data;          struct nas_stat *statp = nas->app_data;
1791                    
# Line 2108  struct snmp_var *snmp_serv_var_get(subid Line 1865  struct snmp_var *snmp_serv_var_get(subid
1865  int snmp_serv_var_set(subid_t subid, struct snmp_var **vp, int *errp);  int snmp_serv_var_set(subid_t subid, struct snmp_var **vp, int *errp);
1866    
1867  /* Handler function for fixed oids from the server subtree */  /* Handler function for fixed oids from the server subtree */
1868  /*ARGSUSED*/  
1869  int  int
1870  snmp_serv_handler(cmd, closure, subid, varp, errp)  snmp_serv_handler(enum mib_node_cmd cmd, void *closure,
1871          enum mib_node_cmd cmd;                    subid_t subid, struct snmp_var **varp, int *errp)
         void *closure;  
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
1872  {  {
1873          oid_t oid = (*varp)->name;          oid_t oid = (*varp)->name;
1874                    
# Line 2143  snmp_serv_handler(cmd, closure, subid, v Line 1896  snmp_serv_handler(cmd, closure, subid, v
1896  }  }
1897    
1898  struct snmp_var *  struct snmp_var *
1899  snmp_serv_var_get(subid, oid, errp)  snmp_serv_var_get(subid_t subid, oid_t oid, int *errp)
         subid_t subid;  
         oid_t oid;  
         int *errp;  
1900  {  {
1901          struct snmp_var *ret;          struct snmp_var *ret;
1902          struct timeval tv;          struct timeval tv;
# Line 2161  snmp_serv_var_get(subid, oid, errp) Line 1911  snmp_serv_var_get(subid, oid, errp)
1911                  gettimeofday(&tv, &tz);                  gettimeofday(&tv, &tz);
1912                  ret->type = SMI_TIMETICKS;                  ret->type = SMI_TIMETICKS;
1913                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1914                  ret->var_int = timeval_diff(&tv, &server_stat.start_time);                  ret->var_int = timeval_diff(&tv, &server_stat->start_time);
1915                  break;                  break;
1916    
1917          case MIB_KEY_radiusServerResetTime:          case MIB_KEY_radiusServerResetTime:
# Line 2169  snmp_serv_var_get(subid, oid, errp) Line 1919  snmp_serv_var_get(subid, oid, errp)
1919                  ret->type = SMI_TIMETICKS;                  ret->type = SMI_TIMETICKS;
1920                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1921                  ret->var_int = timeval_diff(&tv,                  ret->var_int = timeval_diff(&tv,
1922                                              &server_stat.auth.reset_time);                                              &server_stat->auth.reset_time);
1923                  break;                  break;
1924    
1925          case MIB_KEY_radiusServerState:          case MIB_KEY_radiusServerState:
1926                  ret->type = ASN_INTEGER;                  ret->type = ASN_INTEGER;
1927                  ret->val_length = sizeof(counter);                  ret->val_length = sizeof(counter);
1928                  ret->var_int = server_stat.auth.status;/*FIXME*/                  ret->var_int = server_stat->auth.status;/*FIXME*/
1929                  break;                  break;
1930          default:          default:
1931                  *errp = SNMP_ERR_NOSUCHNAME;                  *errp = SNMP_ERR_NOSUCHNAME;
# Line 2186  snmp_serv_var_get(subid, oid, errp) Line 1936  snmp_serv_var_get(subid, oid, errp)
1936  }  }
1937    
1938  int  int
1939  snmp_serv_var_set(subid, vp, errp)  snmp_serv_var_set(subid_t subid, struct snmp_var **vp, int *errp)
         subid_t subid;  
         struct snmp_var **vp;  
         int *errp;  
1940  {  {
1941          if (errp) { /* just test */          if (errp) { /* just test */
1942                  *errp = SNMP_ERR_NOERROR;                  *errp = SNMP_ERR_NOERROR;
# Line 2224  snmp_serv_var_set(subid, vp, errp) Line 1971  snmp_serv_var_set(subid, vp, errp)
1971                  switch (subid) {                  switch (subid) {
1972    
1973                  case MIB_KEY_radiusServerState:                  case MIB_KEY_radiusServerState:
1974                          server_stat.auth.status = (*vp)->var_int;                          server_stat->auth.status = (*vp)->var_int;
1975                          switch ((*vp)->var_int) {                          switch ((*vp)->var_int) {
1976                          case serv_reset:                          case serv_reset:
1977                                  radlog(L_NOTICE,                                  radlog(L_NOTICE,
# Line 2264  static struct snmp_var *snmp_queue_get_c Line 2011  static struct snmp_var *snmp_queue_get_c
2011  static void get_queue_stat_compat(int qno, struct snmp_var *var, subid_t key);  static void get_queue_stat_compat(int qno, struct snmp_var *var, subid_t key);
2012    
2013  int  int
2014  snmp_serv_queue_handler_compat(cmd, unused, subid, varp, errp)  snmp_serv_queue_handler_compat(enum mib_node_cmd cmd, void *unused,
2015          enum mib_node_cmd cmd;                                 subid_t subid, struct snmp_var **varp,
2016          void *unused;                                 int *errp)
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
2017  {  {
2018          struct queue_data *p = (struct queue_data *) snmpserv_get_data();          struct queue_data *p = (struct queue_data *) snmpserv_get_data();
2019                    
# Line 2309  snmp_serv_queue_handler_compat(cmd, unus Line 2053  snmp_serv_queue_handler_compat(cmd, unus
2053  }  }
2054    
2055  struct snmp_var *  struct snmp_var *
2056  snmp_queue_get_compat(subid, var, errp)  snmp_queue_get_compat(subid_t subid, struct snmp_var *var, int *errp)
         subid_t subid;  
         struct snmp_var *var;  
         int *errp;  
2057  {  {
2058          struct snmp_var *ret;          struct snmp_var *ret;
2059          subid_t key;          subid_t key;
# Line 2344  snmp_queue_get_compat(subid, var, errp) Line 2085  snmp_queue_get_compat(subid, var, errp)
2085  }  }
2086    
2087  void  void
2088  get_queue_stat_compat(qno, var, key)  get_queue_stat_compat(int qno, struct snmp_var *var, subid_t key)
         int qno;  
         struct snmp_var *var;  
         subid_t key;  
2089  {  {
2090          struct timeval tv;          struct timeval tv;
2091          struct timezone tz;          struct timezone tz;
# Line 2396  static struct snmp_var *snmp_queue_get(s Line 2134  static struct snmp_var *snmp_queue_get(s
2134  static void get_queue_stat(int qno, struct snmp_var *var, subid_t key);  static void get_queue_stat(int qno, struct snmp_var *var, subid_t key);
2135    
2136  int  int
2137  snmp_serv_queue_handler(cmd, unused, subid, varp, errp)  snmp_serv_queue_handler(enum mib_node_cmd cmd, void *unused,
2138          enum mib_node_cmd cmd;                          subid_t subid, struct snmp_var **varp, int *errp)
         void *unused;  
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
2139  {  {
2140          struct queue_data *p = (struct queue_data *) snmpserv_get_data();          struct queue_data *p = (struct queue_data *) snmpserv_get_data();
2141                    
# Line 2441  snmp_serv_queue_handler(cmd, unused, sub Line 2175  snmp_serv_queue_handler(cmd, unused, sub
2175  }  }
2176    
2177  struct snmp_var *  struct snmp_var *
2178  snmp_queue_get(subid, var, errp)  snmp_queue_get(subid_t subid, struct snmp_var *var, int *errp)
         subid_t subid;  
         struct snmp_var *var;  
         int *errp;  
2179  {  {
2180          struct snmp_var *ret;          struct snmp_var *ret;
2181          subid_t key;          subid_t key;
# Line 2477  snmp_queue_get(subid, var, errp) Line 2208  snmp_queue_get(subid, var, errp)
2208  }  }
2209    
2210  void  void
2211  get_queue_stat(qno, var, key)  get_queue_stat(int qno, struct snmp_var *var, subid_t key)
         int qno;  
         struct snmp_var *var;  
         subid_t key;  
2212  {  {
2213          QUEUE_STAT stat;          QUEUE_STAT stat;
2214                    
# Line 2535  static void get_class_stat(CLASS_STAT *s Line 2263  static void get_class_stat(CLASS_STAT *s
2263                             subid_t key);                             subid_t key);
2264    
2265  int  int
2266  snmp_serv_mem_summary(cmd, closure, subid, varp, errp)  snmp_serv_mem_summary(enum mib_node_cmd cmd, void *closure,
2267          enum mib_node_cmd cmd;                        subid_t subid, struct snmp_var **varp,
2268          void *closure;                        int *errp)
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
2269  {  {
2270          oid_t oid = (*varp)->name;          oid_t oid = (*varp)->name;
2271                    
# Line 2569  snmp_serv_mem_summary(cmd, closure, subi Line 2294  snmp_serv_mem_summary(cmd, closure, subi
2294  }  }
2295    
2296  struct snmp_var *  struct snmp_var *
2297  snmp_mem_get(subid, oid, errp)  snmp_mem_get(subid_t subid, oid_t oid, int *errp)
         subid_t subid;  
         oid_t oid;  
         int *errp;  
2298  {  {
2299          struct snmp_var *ret;          struct snmp_var *ret;
2300          MEM_STAT stat;          MEM_STAT stat;
# Line 2637  snmp_mem_get(subid, oid, errp) Line 2359  snmp_mem_get(subid, oid, errp)
2359  }  }
2360    
2361  static int  static int
2362  class_counter(stat, ret)  class_counter(CLASS_STAT *stat, CLASS_STAT *ret)
         CLASS_STAT *stat;  
         CLASS_STAT *ret;  
2363  {  {
2364          if (stat->index == ret->index) {          if (stat->index == ret->index) {
2365                  *ret = *stat;                  *ret = *stat;
# Line 2649  class_counter(stat, ret) Line 2369  class_counter(stat, ret)
2369  }  }
2370    
2371  int  int
2372  _mem_get_class(subid, stat)  _mem_get_class(subid_t subid, CLASS_STAT *stat)
         subid_t subid;  
         CLASS_STAT *stat;  
2373  {  {
2374          stat->index = subid;          stat->index = subid;
2375          return mem_stat_enumerate(class_counter, stat);          return mem_stat_enumerate(class_counter, stat);
2376  }  }
2377    
2378  int  int
2379  snmp_serv_class_handler(cmd, unused, subid, varp, errp)  snmp_serv_class_handler(enum mib_node_cmd cmd, void *unused,
2380          enum mib_node_cmd cmd;                          subid_t subid, struct snmp_var **varp,
2381          void *unused;                          int *errp)
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
2382  {  {
2383          struct mem_data *p = (struct mem_data *) snmpserv_get_data();          struct mem_data *p = (struct mem_data *) snmpserv_get_data();
2384          CLASS_STAT stat;          CLASS_STAT stat;
# Line 2704  snmp_serv_class_handler(cmd, unused, sub Line 2419  snmp_serv_class_handler(cmd, unused, sub
2419  }  }
2420    
2421  struct snmp_var *  struct snmp_var *
2422  snmp_class_get(subid, var, errp)  snmp_class_get(subid_t subid, struct snmp_var *var, int *errp)
         subid_t subid;  
         struct snmp_var *var;  
         int *errp;  
2423  {  {
2424          struct snmp_var *ret;          struct snmp_var *ret;
2425          subid_t key;          subid_t key;
# Line 2740  snmp_class_get(subid, var, errp) Line 2452  snmp_class_get(subid, var, errp)
2452  }  }
2453    
2454  void  void
2455  get_class_stat(stat, var, key)  get_class_stat(CLASS_STAT *stat, struct snmp_var *var, subid_t key)
         CLASS_STAT *stat;  
         struct snmp_var *var;  
         subid_t key;  
2456  {  {
2457          switch (key) {          switch (key) {
2458          case MIB_KEY_classIndex:          case MIB_KEY_classIndex:
# Line 2780  struct snmp_var *snmp_stat_var_get(subid Line 2489  struct snmp_var *snmp_stat_var_get(subid
2489  int snmp_stat_var_set(subid_t subid, struct snmp_var **vp, int *errp);  int snmp_stat_var_set(subid_t subid, struct snmp_var **vp, int *errp);
2490    
2491  /* Handler function for fixed oids from the authentication subtree */  /* Handler function for fixed oids from the authentication subtree */
2492  /*ARGSUSED*/  
2493  int  int
2494  snmp_stat_handler(cmd, closure, subid, varp, errp)  snmp_stat_handler(enum mib_node_cmd cmd, void *closure, subid_t subid,
2495          enum mib_node_cmd cmd;                    struct snmp_var **varp, int *errp)
         void *closure;  
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
2496  {  {
2497          oid_t oid = (*varp)->name;          oid_t oid = (*varp)->name;
2498                    
# Line 2815  snmp_stat_handler(cmd, closure, subid, v Line 2520  snmp_stat_handler(cmd, closure, subid, v
2520  }  }
2521    
2522  struct snmp_var *  struct snmp_var *
2523  snmp_stat_var_get(subid, oid, errp)  snmp_stat_var_get(subid_t subid, oid_t oid, int *errp)
         subid_t subid;  
         oid_t oid;  
         int *errp;  
2524  {  {
2525          struct snmp_var *ret;          struct snmp_var *ret;
2526          struct timeval tv;          struct timeval tv;
# Line 2882  snmp_stat_var_get(subid, oid, errp) Line 2584  snmp_stat_var_get(subid, oid, errp)
2584  }  }
2585    
2586  int  int
2587  snmp_stat_nas(num, cmd, closure, subid, varp, errp)  snmp_stat_nas(int num, enum mib_node_cmd cmd, struct nas_data *closure,
2588          int num;                subid_t subid, struct snmp_var **varp, int *errp)
         enum mib_node_cmd cmd;  
         struct nas_data *closure;  
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
2589  {  {
2590          NAS *nas;          NAS *nas;
2591          struct nas_stat *nsp;          struct nas_stat *nsp;
# Line 2979  snmp_stat_nas(num, cmd, closure, subid, Line 2676  snmp_stat_nas(num, cmd, closure, subid,
2676  }  }
2677    
2678  int  int
2679  snmp_stat_nas1(cmd, unused, subid, varp, errp)  snmp_stat_nas1(enum mib_node_cmd cmd, void *unused,
2680          enum mib_node_cmd cmd;                 subid_t subid, struct snmp_var **varp, int *errp)
         void *unused;  
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
2681  {  {
2682          return snmp_stat_nas(0, cmd,          return snmp_stat_nas(0, cmd,
2683                               (struct nas_data*)snmpserv_get_data(), subid,                               (struct nas_data*)snmpserv_get_data(), subid,
# Line 2992  snmp_stat_nas1(cmd, unused, subid, varp, Line 2685  snmp_stat_nas1(cmd, unused, subid, varp,
2685  }  }
2686    
2687  int  int
2688  snmp_stat_nas2(cmd, unused, subid, varp, errp)  snmp_stat_nas2(enum mib_node_cmd cmd, void *unused,
2689          enum mib_node_cmd cmd;                 subid_t subid, struct snmp_var **varp, int *errp)
         void *unused;  
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
2690  {  {
2691          return snmp_stat_nas(1, cmd,          return snmp_stat_nas(1, cmd,
2692                               (struct nas_data*)snmpserv_get_data(), subid,                               (struct nas_data*)snmpserv_get_data(), subid,
# Line 3005  snmp_stat_nas2(cmd, unused, subid, varp, Line 2694  snmp_stat_nas2(cmd, unused, subid, varp,
2694  }  }
2695    
2696  int  int
2697  snmp_stat_nas3(cmd, unused, subid, varp, errp)  snmp_stat_nas3(enum mib_node_cmd cmd, void *unused,
2698          enum mib_node_cmd cmd;                 subid_t subid, struct snmp_var **varp, int *errp)
         void *unused;  
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
2699  {  {
2700          return snmp_stat_nas(2, cmd,          return snmp_stat_nas(2, cmd,
2701                               (struct nas_data*)snmpserv_get_data(), subid,                               (struct nas_data*)snmpserv_get_data(), subid,
# Line 3018  snmp_stat_nas3(cmd, unused, subid, varp, Line 2703  snmp_stat_nas3(cmd, unused, subid, varp,
2703  }  }
2704    
2705  int  int
2706  snmp_stat_nas4(cmd, unused, subid, varp, errp)  snmp_stat_nas4(enum mib_node_cmd cmd, void *unused,
2707          enum mib_node_cmd cmd;                 subid_t subid, struct snmp_var **varp, int *errp)
         void *unused;  
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
2708  {  {
2709          return snmp_stat_nas(3, cmd,          return snmp_stat_nas(3, cmd,
2710                               (struct nas_data*)snmpserv_get_data(), subid,                               (struct nas_data*)snmpserv_get_data(), subid,
# Line 3035  void get_stat_nasstat(NAS *nas, struct s Line 2716  void get_stat_nasstat(NAS *nas, struct s
2716  struct snmp_var *snmp_nas_table_get(subid_t subid, oid_t oid, int *errp);  struct snmp_var *snmp_nas_table_get(subid_t subid, oid_t oid, int *errp);
2717    
2718  int  int
2719  snmp_nas_table(cmd, unused, subid, varp, errp)  snmp_nas_table(enum mib_node_cmd cmd, void *unused,
2720          enum mib_node_cmd cmd;                 subid_t subid, struct snmp_var **varp, int *errp)
         void *unused;  
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
2721  {  {
2722          struct nas_table_data *data = (struct nas_table_data*)          struct nas_table_data *data = (struct nas_table_data*)
2723                                           snmpserv_get_data();                                           snmpserv_get_data();
# Line 3084  snmp_nas_table(cmd, unused, subid, varp, Line 2761  snmp_nas_table(cmd, unused, subid, varp,
2761  }  }
2762    
2763  struct snmp_var *  struct snmp_var *
2764  snmp_nas_table_get(subid, oid, errp)  snmp_nas_table_get(subid_t subid, oid_t oid, int *errp)
         subid_t subid;  
         oid_t oid;  
         int *errp;  
2765  {  {
2766          struct snmp_var *ret;          struct snmp_var *ret;
2767          subid_t key;          subid_t key;
# Line 3116  snmp_nas_table_get(subid, oid, errp) Line 2790  snmp_nas_table_get(subid, oid, errp)
2790  }  }
2791    
2792  void  void
2793  get_stat_nasstat(nas, var, ind)  get_stat_nasstat(NAS *nas, struct snmp_var *var, int ind)
         NAS *nas;  
         struct snmp_var *var;  
         int ind;  
2794  {  {
2795          struct nas_stat *statp = nas->app_data;          struct nas_stat *statp = nas->app_data;
2796                    
# Line 3164  get_stat_nasstat(nas, var, ind) Line 2835  get_stat_nasstat(nas, var, ind)
2835    
2836  /*ARGSUSED*/  /*ARGSUSED*/
2837  int  int
2838  snmp_port_index1(cmd, unused, subid, varp, errp)  snmp_port_index1(enum mib_node_cmd cmd, void *unused,
2839          enum mib_node_cmd cmd;                   subid_t subid, struct snmp_var **varp, int *errp)
         void *unused;  
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
2840  {  {
2841          NAS *nas;          NAS *nas;
2842          struct port_data *pind = (struct port_data*)snmpserv_get_data();          struct port_data *pind = (struct port_data*)snmpserv_get_data();
# Line 3208  snmp_port_index1(cmd, unused, subid, var Line 2875  snmp_port_index1(cmd, unused, subid, var
2875  }  }
2876    
2877  int  int
2878  snmp_port_index2(cmd, unused, subid, varp, errp)  snmp_port_index2(enum mib_node_cmd cmd, void *unused,
2879          enum mib_node_cmd cmd;                   subid_t subid, struct snmp_var **varp, int *errp)
         void *unused;  
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
2880  {  {
2881          NAS *nas;          NAS *nas;
2882          int index;          int index;
# Line 3278  struct snmp_var *snmp_port_get(subid_t s Line 2941  struct snmp_var *snmp_port_get(subid_t s
2941  void get_port_stat(PORT_STAT *port, struct snmp_var *var, subid_t key);  void get_port_stat(PORT_STAT *port, struct snmp_var *var, subid_t key);
2942    
2943  int  int
2944  snmp_port_table(cmd, unused, subid, varp, errp)  snmp_port_table(enum mib_node_cmd cmd, void *unused,
2945          enum mib_node_cmd cmd;                  subid_t subid, struct snmp_var **varp, int *errp)
         void *unused;  
         subid_t subid;  
         struct snmp_var **varp;  
         int *errp;  
2946  {  {
2947          struct port_table_data *p = (struct port_table_data*)          struct port_table_data *p = (struct port_table_data*)
2948                                           snmpserv_get_data();                                           snmpserv_get_data();
# Line 3324  snmp_port_table(cmd, unused, subid, varp Line 2983  snmp_port_table(cmd, unused, subid, varp
2983  }  }
2984    
2985  struct snmp_var *  struct snmp_var *
2986  snmp_port_get(subid, var, errp)  snmp_port_get(subid_t subid, struct snmp_var *var, int *errp)
         subid_t subid;  
         struct snmp_var *var;  
         int *errp;  
2987  {  {
2988          struct snmp_var *ret;          struct snmp_var *ret;
2989          subid_t key;          subid_t key;
# Line 3372  snmp_port_get(subid, var, errp) Line 3028  snmp_port_get(subid, var, errp)
3028  #define TDIFF(tv, time) (tv.tv_sec - time)*100 + tv.tv_usec/10000;  #define TDIFF(tv, time) (tv.tv_sec - time)*100 + tv.tv_usec/10000;
3029    
3030  void  void
3031  get_port_stat(port, var, key)  get_port_stat(PORT_STAT *port, struct snmp_var *var, subid_t key)
         PORT_STAT *port;  
         struct snmp_var *var;  
         subid_t key;  
3032  {  {
3033          struct timeval tv;          struct timeval tv;
3034          struct timezone tz;          struct timezone tz;
# Line 3489  get_port_stat(port, var, key) Line 3142  get_port_stat(port, var, key)
3142  }  }
3143    
3144  NAS *  NAS *
3145  nas_lookup_index(ind)  nas_lookup_index(int ind)
         int ind;  
3146  {  {
3147          NAS *nas;          NAS *nas;
3148          struct nas_stat *ns;          struct nas_stat *ns;
# Line 3503  nas_lookup_index(ind) Line 3155  nas_lookup_index(ind)
3155          return nas;          return nas;
3156  }  }
3157    
3158    
3159    /* *********************** SNMP Protocol Interface ************************* */
3160    
3161    /* Decode the SNMP request */
3162    static int
3163    snmp_decode(SNMP_REQ *req, u_char *buf, size_t len)
3164    {
3165            struct snmp_pdu *pdu;
3166            struct snmp_session sess;
3167            int access;
3168            char comm[128];
3169            int comm_len;
3170            char ipbuf[DOTTED_QUAD_LEN];
3171            
3172            if ((pdu = snmp_pdu_create(0)) == NULL) {
3173                    radlog(L_ERR,
3174                           _("can't create SNMP PDU: %s"),
3175                             snmp_strerror(snmp_errno));
3176                    return -1;
3177            }
3178            comm_len = sizeof(comm);
3179            if (snmp_decode_request(&sess, pdu, buf, len, comm, &comm_len)) {
3180                    radlog(L_ERR,
3181                           _("can't decode SNMP packet from %s: %s"),
3182                           ip_iptostr(ntohl(req->addr.sin_addr.s_addr), ipbuf),
3183                           snmp_strerror(snmp_errno));
3184                    return -1;
3185            }
3186    
3187            access = check_acl(req->addr.sin_addr.s_addr, comm);
3188            if (!access) {
3189                    radlog(L_NOTICE,
3190                           _("DENIED attempt to access community %s from %s"),
3191                           comm,
3192                           ip_iptostr(ntohl(req->addr.sin_addr.s_addr), ipbuf));
3193                    return 1;
3194            }
3195            req->pdu = pdu;
3196            req->community = estrdup(comm);
3197            req->access = access;
3198            return 0;
3199    }
3200    
3201    int
3202    snmp_req_decode(struct sockaddr_in *sa,
3203                      void *input, size_t inputsize, void **output)
3204    {
3205            SNMP_REQ *req;
3206    
3207            req = mem_alloc(sizeof *req);
3208            req->addr = *sa;
3209            if (snmp_decode(req, input, inputsize)) {
3210                    mem_free(req);
3211                    return 1;
3212            }
3213            *output = req;
3214            return 0;
3215    }
3216    
3217    int
3218    snmp_req_cmp(void *ap, void *bp)
3219    {
3220            SNMP_REQ *a = ap, *b = bp;
3221            return (a->addr.sin_addr.s_addr == b->addr.sin_addr.s_addr &&
3222                    a->pdu->req_id == b->pdu->req_id) ? RCMP_EQ : RCMP_NE;
3223    }
3224    
3225    /* Free the SNMP request */
3226    void
3227    snmp_req_free(void *ptr)
3228    {
3229            SNMP_REQ *req = ptr;
3230            snmp_pdu_free(req->pdu);
3231            efree(req->community);
3232            mem_free(req);
3233    }
3234    
3235    void
3236    snmp_req_drop(int type, void *data, void *orig_data,
3237                  int fd, char *status_str)
3238    {
3239            SNMP_REQ *req = data ? data : orig_data;
3240            SNMP_REQ *orig = orig_data;
3241            char ipbuf[DOTTED_QUAD_LEN];
3242    
3243            radlog(L_NOTICE,
3244                   _("Dropping SNMP request from client %s: %s"),
3245                   ip_iptostr(ntohl(req->addr.sin_addr.s_addr), ipbuf),
3246                   status_str);
3247    }
3248    
3249    static u_char send_buffer[RAD_BUFFER_SIZE];
3250    
3251    int
3252    snmp_req_respond(REQUEST *request)
3253    {
3254            SNMP_REQ *req = request->data;
3255            struct snmp_session session;
3256            struct snmp_pdu *pdu;
3257            int len;
3258    
3259            log_open(L_SNMP);
3260            pdu = snmp_agent_response(req->pdu, req->access);
3261            if (pdu) {
3262                    session.version = SNMP_VERSION_1;
3263                    session.community.str = req->community;
3264                    session.community.len = strlen(req->community);
3265                    len = sizeof(send_buffer);
3266                    if (snmp_encode_request(&session, pdu, send_buffer, &len)==0) {
3267                            sendto(request->fd,
3268                                   send_buffer, len,
3269                                   0, (struct sockaddr *) &request->addr,
3270                                   sizeof(request->addr));
3271                    }
3272                    snmp_pdu_free(pdu);
3273            }
3274            return 0;
3275    }
3276    
3277  #endif  #endif
3278    

Legend:
Removed from v.1.56  
changed lines
  Added in v.1.57

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26