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 |
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> |
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); |
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 |
/* ************************************************************************ */ |
/* ************************************************************************ */ |
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 |
|
|
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); |
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 |
|
|
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 |
|
|
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; |
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; |
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 |
|
|
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); |
366 |
} |
} |
367 |
|
|
368 |
Community * |
Community * |
369 |
snmp_find_community(str) |
snmp_find_community(char *str) |
|
char *str; |
|
370 |
{ |
{ |
371 |
Community *p; |
Community *p; |
372 |
|
|
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 |
|
|
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 |
|
|
432 |
} |
} |
433 |
|
|
434 |
void |
void |
435 |
free_acl(acl) |
free_acl(ACL *acl) |
|
ACL *acl; |
|
436 |
{ |
{ |
437 |
ACL *next; |
ACL *next; |
438 |
|
|
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 { |
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. |
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 */ |
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; |
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, |
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) { |
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; |
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 |
|
|
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 |
|
|
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 |
|
|
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; |
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; |
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; |
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; |
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 |
|
|
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; |
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: |
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: |
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: |
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; |
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; |
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(); |
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; |
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; |
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 |
|
|
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 |
|
|
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; |
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: |
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: |
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; |
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; |
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(); |
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; |
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 |
|
|
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 |
|
|
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; |
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: |
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; |
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; |
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, |
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 |
|
|
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; |
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; |
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 |
|
|
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; |
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 |
|
|
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 |
|
|
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; |
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; |
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; |
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; |
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: |
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 |
|
|
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; |
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; |
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, |
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, |
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, |
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, |
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(); |
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; |
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 |
|
|
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(); |
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; |
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(); |
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; |
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; |
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; |
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 |
|
|