diff options
Diffstat (limited to 'accel-pppd/extra/net-snmp')
29 files changed, 4320 insertions, 0 deletions
diff --git a/accel-pppd/extra/net-snmp/ACCEL-PPP-MIB.txt b/accel-pppd/extra/net-snmp/ACCEL-PPP-MIB.txt new file mode 100644 index 00000000..5af38e80 --- /dev/null +++ b/accel-pppd/extra/net-snmp/ACCEL-PPP-MIB.txt @@ -0,0 +1,326 @@ +ACCEL-PPP-MIB DEFINITIONS ::= BEGIN + +IMPORTS + MODULE-IDENTITY, OBJECT-TYPE, Gauge32 + NOTIFICATION-TYPE FROM SNMPv2-SMI + netSnmp FROM NET-SNMP-MIB + InetAddressIPv4 FROM INET-ADDRESS-MIB + IANAtunnelType FROM IANAifType-MIB +; + +accelPPP MODULE-IDENTITY + LAST-UPDATED "201108180000Z" + ORGANIZATION "accel-ppp.sourceforge.net" + CONTACT-INFO + "email: xeb@mail.ru" + DESCRIPTION + "MIB objects for accel-ppp" + REVISION "201108180000Z" + DESCRIPTION + "First draft" + ::= { netSnmp 100 } + +-- +-- top level structure +-- +accelPPPStat OBJECT IDENTIFIER ::= { accelPPP 1 } +accelPPPSessions OBJECT IDENTIFIER ::= { accelPPP 2 } +accelPPPAdmin OBJECT IDENTIFIER ::= { accelPPP 3 } +--accelPPPNotifications OBJECT IDENTIFIER ::= { accelPPP 4 } + +statCore OBJECT IDENTIFIER ::= { accelPPPStat 1 } +statPPP OBJECT IDENTIFIER ::= { accelPPPStat 2 } +statPPTP OBJECT IDENTIFIER ::= { accelPPPStat 3 } +statL2TP OBJECT IDENTIFIER ::= { accelPPPStat 4 } +statPPPOE OBJECT IDENTIFIER ::= { accelPPPStat 5 } +--statRadius OBJECT IDENTIFIER ::= { accelPPPStat 6 } + + +statCoreUpTime OBJECT-TYPE + SYNTAX Gauge32 + UNITS "seconds" + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "accel-ppp uptime" + ::= { statCore 1 } + +statCoreCPU OBJECT-TYPE + SYNTAX INTEGER (0..100) + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "cpu utilization" + ::= { statCore 2 } + +statCoreMemRss OBJECT-TYPE + SYNTAX INTEGER + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "memory rss size" + ::= { statCore 3 } + + +-- +-- PPP stats +-- + +statPPPStarting OBJECT-TYPE + SYNTAX INTEGER + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "count of sessions which are + in starting phase" + ::= { statPPP 1 } + +statPPPActive OBJECT-TYPE + SYNTAX INTEGER + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "count of active sessions" + ::= { statPPP 2 } + +statPPPFinishing OBJECT-TYPE + SYNTAX INTEGER + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "count of active which are + in finishing phase" + ::= { statPPP 3 } + +-- +-- PPTP stats +-- + +statPPTPStarting OBJECT-TYPE + SYNTAX INTEGER + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "count of connections which are + in starting phase" + ::= { statPPTP 1 } + +statPPTPActive OBJECT-TYPE + SYNTAX INTEGER + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "count of active connections" + ::= { statPPTP 2 } + +-- +-- L2TP stats +-- + +statL2TPStarting OBJECT-TYPE + SYNTAX INTEGER + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "count of connections which are + in starting phase" + ::= { statL2TP 1 } + +statL2TPActive OBJECT-TYPE + SYNTAX INTEGER + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "count of active connections" + ::= { statL2TP 2 } + +-- +-- PPPOE stats +-- + +statPPPOEStarting OBJECT-TYPE + SYNTAX INTEGER + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "count of connections which are + in starting phase" + ::= { statPPPOE 1 } + +statPPPOEActive OBJECT-TYPE + SYNTAX INTEGER + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "count of active connections" + ::= { statPPPOE 2 } + + +-- +-- PPP session table +-- + +sessionTable OBJECT-TYPE + SYNTAX SEQUENCE OF sessionEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "this table contains information about + connected sessions" + ::= { accelPPPSessions 1 } + +sessionEntry OBJECT-TYPE + SYNTAX sessionEntry + MAX-ACCESS not-accessible + STATUS current + DESCRIPTION + "A row describing a given session" + INDEX { sesSID } + ::= { sessionTable 1 } + +sessionEntry ::= SEQUENCE { + sesSID OCTET STRING, + sesIfName OCTET STRING, + sesUsername OCTET STRING, + sesIP InetAddress, + sesType IANAtunnelType, + sesState INTEGER, + sesUptime TimeTicks, + sesCallingSID OCTET STRING, + sesCalledSID OCTET STRING +} + +sesSID OBJECT-TYPE + SYNTAX OCTET STRING (SIZE(16)) + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Acct-Session-ID" + ::= { sessionEntry 1 } + +sesIfName OBJECT-TYPE + SYNTAX OCTET STRING + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "name of ppp interface" + ::= { sessionEntry 2 } + +sesUsername OBJECT-TYPE + SYNTAX OCTET STRING + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "session user name" + ::= { sessionEntry 3 } + +sesIP OBJECT-TYPE + SYNTAX InetAddressIPv4 + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "assigned IP address" + ::= { sessionEntry 4 } + +sesType OBJECT-TYPE + SYNTAX INTEGER { + pptp(1), + l2tp(2), + pppoe(3) + } + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "name of ppp interface" + ::= { sessionEntry 5 } + +sesState OBJECT-TYPE + SYNTAX INTEGER { + starting(1), + active(2), + finishing(3) + } + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "state of session" + ::= { sessionEntry 6 } + +sesUptime OBJECT-TYPE + SYNTAX Gauge32 + UNITS "seconds" + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "uptime of session" + ::= { sessionEntry 7 } + +sesCallingSID OBJECT-TYPE + SYNTAX OCTET STRING + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Calling-Station-ID" + ::= { sessionEntry 8 } + +sesCalledSID OBJECT-TYPE + SYNTAX OCTET STRING + MAX-ACCESS read-only + STATUS current + DESCRIPTION + "Called-Station-ID" + ::= { sessionEntry 9 } + +-- +-- Administration +-- + +terminate OBJECT IDENTIFIER ::= { accelPPPAdmin 1 } + +termBySID OBJECT-TYPE + SYNTAX OCTET STRING + MAX-ACCESS write-only + STATUS current + DESCRIPTION + "Terminate session softly identified by Acct-Session-ID" + ::= { terminate 1 } + +termByIfName OBJECT-TYPE + SYNTAX OCTET STRING + MAX-ACCESS write-only + STATUS current + DESCRIPTION + "Terminate session softly identified by interface name" + ::= { terminate 2 } + +termByIP OBJECT-TYPE + SYNTAX OCTET STRING + MAX-ACCESS write-only + STATUS current + DESCRIPTION + "Terminate session softly identified by Framed-IP-Address" + ::= { terminate 3 } + +termByUsername OBJECT-TYPE + SYNTAX OCTET STRING + MAX-ACCESS write-only + STATUS current + DESCRIPTION + "Terminate session softly identified by username" + ::= { terminate 4 } + + +shutdown OBJECT-TYPE + SYNTAX INTEGER { + normal(0), + soft(1), + hard(2), + cancel(3) + } + MAX-ACCESS write-only + STATUS current + DESCRIPTION + "shutdown accel-ppp" + ::= { accelPPPAdmin 2 } + +END diff --git a/accel-pppd/extra/net-snmp/CMakeLists.txt b/accel-pppd/extra/net-snmp/CMakeLists.txt new file mode 100644 index 00000000..4dadb2ce --- /dev/null +++ b/accel-pppd/extra/net-snmp/CMakeLists.txt @@ -0,0 +1,23 @@ +SET(sources + agent.c + sessionTable.c + sessionTable_data_access.c + sessionTable_data_get.c + sessionTable_data_set.c + sessionTable_interface.c + statCore.c + statL2TP.c + statPPP.c + statPPPOE.c + statPPTP.c + terminate.c + shutdown.c +) + +ADD_LIBRARY(net-snmp SHARED ${sources}) +TARGET_LINK_LIBRARIES(net-snmp netsnmpagent netsnmphelpers netsnmpmibs +netsnmp) + +INSTALL(TARGETS net-snmp + LIBRARY DESTINATION lib/accel-ppp +) diff --git a/accel-pppd/extra/net-snmp/agent.c b/accel-pppd/extra/net-snmp/agent.c new file mode 100644 index 00000000..dd38b446 --- /dev/null +++ b/accel-pppd/extra/net-snmp/agent.c @@ -0,0 +1,150 @@ +#include <pthread.h> +#include <signal.h> + +#include <net-snmp/net-snmp-config.h> +#include <net-snmp/net-snmp-includes.h> +#include <net-snmp/agent/net-snmp-agent-includes.h> + +#include "log.h" +#include "triton.h" + +#include "statCore.h" +#include "statPPP.h" +#include "statPPTP.h" +#include "statL2TP.h" +#include "statPPPOE.h" +#include "terminate.h" +#include "shutdown.h" +#include "sessionTable.h" + +static const char *conf_agent_name = "accel-ppp"; +static int conf_master = 0; +/*static const char *conf_oid_prefix = "1.3.6.1.4.1.8072.100"; + +static oid* oid_prefix; +static size_t oid_prefix_size;*/ + +static pthread_t snmp_thr; +static int snmp_term = 0; + +/*int accel_ppp_alloc_oid(oid tail, size_t size, oid **oid) +{ + *oid = malloc(sizeof(oid) * (oid_prefix_size + size)); + + memcpy(*oid, oid_prefix, oid_prefix_size); + memcpy((*oid) + oid_prefix_size, tail, size); + + return oid_prefix_size + size; +}*/ + +static int agent_log(int major, int minor, void *serv_arg, void *cl_arg) +{ + struct snmp_log_message *m = serv_arg; + + switch (m->priority) { + case LOG_EMERG: + log_emerg("net-snmp: %s", m->msg); + break; + case LOG_ALERT: + case LOG_CRIT: + case LOG_ERR: + log_error("net-snmp: %s", m->msg); + break; + case LOG_WARNING: + log_warn("net-snmp: %s", m->msg); + break; + case LOG_NOTICE: + log_info1("net-snmp: %s", m->msg); + break; + case LOG_INFO: + log_info2("net-snmp: %s", m->msg); + break; + case LOG_DEBUG: + log_debug("net-snmp: %s", m->msg); + break; + default: + log_msg("net-snmp: %s", m->msg); + } + return 0; +} + +static void *snmp_thread(void *a) +{ + sigset_t set; + + sigfillset(&set); + sigdelset(&set, SIGKILL); + sigdelset(&set, SIGSTOP); + pthread_sigmask(SIG_BLOCK, &set, NULL); + + snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_LOGGING, agent_log, NULL); + snmp_disable_log(); + snmp_enable_calllog(); + //snmp_set_do_debugging(1); + //netsnmp_ds_set_boolean(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_ROLE, 1); + + if (!conf_master) + netsnmp_enable_subagent(); + + init_agent(conf_agent_name); + + init_statCore(); + init_statPPP(); + init_statPPTP(); + init_statL2TP(); + init_statPPPOE(); + init_terminate(); + init_shutdown(); + init_sessionTable(); + + init_snmp(conf_agent_name); + + if (conf_master) + init_master_agent(); + + while (!snmp_term) { + agent_check_and_process(1); + } + + snmp_shutdown(conf_agent_name); + + SOCK_CLEANUP; + + return NULL; +} + +static void snmp_ctx_close(struct triton_context_t *ctx) +{ + snmp_term = 1; + snmp_shutdown(conf_agent_name); + triton_context_unregister(ctx); +} + +static struct triton_context_t ctx = { + .close = snmp_ctx_close, +}; + +static void init(void) +{ + const char *opt; + + opt = conf_get_opt("snmp", "master"); + if (opt) + conf_master = atoi(opt); + + opt = conf_get_opt("snmp", "agent-name"); + if (opt) + conf_agent_name = opt; + + /*opt = conf_get_opt("snmp", "oid-prefix") + if (opt) + conf_oid_prefix = opt;*/ + + pthread_create(&snmp_thr, NULL, snmp_thread, NULL); + triton_context_register(&ctx, NULL); + triton_context_wakeup(&ctx); + triton_collect_cpu_usage(); +} + +DEFINE_INIT(100, init); + diff --git a/accel-pppd/extra/net-snmp/sessionTable.c b/accel-pppd/extra/net-snmp/sessionTable.c new file mode 100644 index 00000000..dc7d62bd --- /dev/null +++ b/accel-pppd/extra/net-snmp/sessionTable.c @@ -0,0 +1,201 @@ +/* + * Note: this file originally auto-generated by mib2c using + * version : 14170 $ of $ + * + * $Id:$ + */ +/** \page MFD helper for sessionTable + * + * \section intro Introduction + * Introductory text. + * + */ +/* standard Net-SNMP includes */ +#include <net-snmp/net-snmp-config.h> +#include <net-snmp/net-snmp-includes.h> +#include <net-snmp/agent/net-snmp-agent-includes.h> + +/* include our parent header */ +#include "sessionTable.h" + +#include <net-snmp/agent/mib_modules.h> + +#include "sessionTable_interface.h" + +oid sessionTable_oid[] = { SESSIONTABLE_OID }; +int sessionTable_oid_size = OID_LENGTH(sessionTable_oid); + + sessionTable_registration sessionTable_user_context; + +void initialize_table_sessionTable(void); +void shutdown_table_sessionTable(void); + + +/** + * Initializes the sessionTable module + */ +void +init_sessionTable(void) +{ + DEBUGMSGTL(("verbose:sessionTable:init_sessionTable","called\n")); + + /* + * TODO:300:o: Perform sessionTable one-time module initialization. + */ + + /* + * here we initialize all the tables we're planning on supporting + */ + if (should_init("sessionTable")) + initialize_table_sessionTable(); + +} /* init_sessionTable */ + +/** + * Shut-down the sessionTable module (agent is exiting) + */ +void +shutdown_sessionTable(void) +{ + if (should_init("sessionTable")) + shutdown_table_sessionTable(); + +} + +/** + * Initialize the table sessionTable + * (Define its contents and how it's structured) + */ +void +initialize_table_sessionTable(void) +{ + sessionTable_registration * user_context; + u_long flags; + + DEBUGMSGTL(("verbose:sessionTable:initialize_table_sessionTable","called\n")); + + /* + * TODO:301:o: Perform sessionTable one-time table initialization. + */ + + /* + * TODO:302:o: |->Initialize sessionTable user context + * if you'd like to pass in a pointer to some data for this + * table, allocate or set it up here. + */ + /* + * a netsnmp_data_list is a simple way to store void pointers. A simple + * string token is used to add, find or remove pointers. + */ + user_context = netsnmp_create_data_list("sessionTable", NULL, NULL); + + /* + * No support for any flags yet, but in the future you would + * set any flags here. + */ + flags = 0; + + /* + * call interface initialization code + */ + _sessionTable_initialize_interface(user_context, flags); +} /* initialize_table_sessionTable */ + +/** + * Shutdown the table sessionTable + */ +void +shutdown_table_sessionTable(void) +{ + /* + * call interface shutdown code + */ + _sessionTable_shutdown_interface(&sessionTable_user_context); +} + +/** + * extra context initialization (eg default values) + * + * @param rowreq_ctx : row request context + * @param user_init_ctx : void pointer for user (parameter to rowreq_ctx_allocate) + * + * @retval MFD_SUCCESS : no errors + * @retval MFD_ERROR : error (context allocate will fail) + */ +int +sessionTable_rowreq_ctx_init(sessionTable_rowreq_ctx *rowreq_ctx, + void *user_init_ctx) +{ + DEBUGMSGTL(("verbose:sessionTable:sessionTable_rowreq_ctx_init","called\n")); + + netsnmp_assert(NULL != rowreq_ctx); + + /* + * TODO:210:o: |-> Perform extra sessionTable rowreq initialization. (eg DEFVALS) + */ + + return MFD_SUCCESS; +} /* sessionTable_rowreq_ctx_init */ + +/** + * extra context cleanup + * + */ +void sessionTable_rowreq_ctx_cleanup(sessionTable_rowreq_ctx *rowreq_ctx) +{ + DEBUGMSGTL(("verbose:sessionTable:sessionTable_rowreq_ctx_cleanup","called\n")); + + netsnmp_assert(NULL != rowreq_ctx); + + /* + * TODO:211:o: |-> Perform extra sessionTable rowreq cleanup. + */ +} /* sessionTable_rowreq_ctx_cleanup */ + +/** + * pre-request callback + * + * + * @retval MFD_SUCCESS : success. + * @retval MFD_ERROR : other error + */ +int +sessionTable_pre_request(sessionTable_registration * user_context) +{ + DEBUGMSGTL(("verbose:sessionTable:sessionTable_pre_request","called\n")); + + /* + * TODO:510:o: Perform sessionTable pre-request actions. + */ + + return MFD_SUCCESS; +} /* sessionTable_pre_request */ + +/** + * post-request callback + * + * Note: + * New rows have been inserted into the container, and + * deleted rows have been removed from the container and + * released. + * + * @param user_context + * @param rc : MFD_SUCCESS if all requests succeeded + * + * @retval MFD_SUCCESS : success. + * @retval MFD_ERROR : other error (ignored) + */ +int +sessionTable_post_request(sessionTable_registration * user_context, int rc) +{ + DEBUGMSGTL(("verbose:sessionTable:sessionTable_post_request","called\n")); + + /* + * TODO:511:o: Perform sessionTable post-request actions. + */ + + return MFD_SUCCESS; +} /* sessionTable_post_request */ + + +/** @{ */ diff --git a/accel-pppd/extra/net-snmp/sessionTable.h b/accel-pppd/extra/net-snmp/sessionTable.h new file mode 100644 index 00000000..f5619d98 --- /dev/null +++ b/accel-pppd/extra/net-snmp/sessionTable.h @@ -0,0 +1,195 @@ +/* + * Note: this file originally auto-generated by mib2c using + * version : 14170 $ of $ + * + * $Id:$ + */ +#ifndef SESSIONTABLE_H +#define SESSIONTABLE_H + +#ifdef __cplusplus +extern "C" { +#endif + + +/** @addtogroup misc misc: Miscellaneous routines + * + * @{ + */ +#include <net-snmp/library/asn1.h> + +#include "ppp.h" + +/* other required module components */ + /* *INDENT-OFF* */ +config_add_mib(ACCEL-PPP-MIB) +config_require(ACCEL-PPP-MIB/sessionTable/sessionTable_interface) +config_require(ACCEL-PPP-MIB/sessionTable/sessionTable_data_access) +config_require(ACCEL-PPP-MIB/sessionTable/sessionTable_data_get) +config_require(ACCEL-PPP-MIB/sessionTable/sessionTable_data_set) + /* *INDENT-ON* */ + +/* OID and column number definitions for sessionTable */ +#include "sessionTable_oids.h" + +/* enum definions */ +#include "sessionTable_enums.h" + +/* ********************************************************************* + * function declarations + */ +void init_sessionTable(void); +void shutdown_sessionTable(void); + +/* ********************************************************************* + * Table declarations + */ +/********************************************************************** + ********************************************************************** + *** + *** Table sessionTable + *** + ********************************************************************** + **********************************************************************/ +/* + * ACCEL-PPP-MIB::sessionTable is subid 1 of accelPPPSessions. + * Its status is Current. + * OID: .1.3.6.1.4.1.8072.100.2.1, length: 10 +*/ +/* ********************************************************************* + * When you register your mib, you get to provide a generic + * pointer that will be passed back to you for most of the + * functions calls. + * + * TODO:100:r: Review all context structures + */ + /* + * TODO:101:o: |-> Review sessionTable registration context. + */ +typedef netsnmp_data_list sessionTable_registration; + +/**********************************************************************/ +/* + * TODO:110:r: |-> Review sessionTable data context structure. + * This structure is used to represent the data for sessionTable. + */ +struct sessionTable_data_s +{ + char ifname[PPP_IFNAME_LEN]; + char *username; + in_addr_t peer_addr; + int type; + int state; + unsigned long uptime; + char *calling_sid; + char *called_sid; +}; +typedef struct sessionTable_data_s sessionTable_data; + + +/* + * TODO:120:r: |-> Review sessionTable mib index. + * This structure is used to represent the index for sessionTable. + */ +typedef struct sessionTable_mib_index_s { + + /* + * sesSID(1)/OCTETSTR/ASN_OCTET_STR/char(char)//L/A/w/e/R/d/h + */ + char sesSID[PPP_SESSIONID_LEN]; + size_t sesSID_len; + + +} sessionTable_mib_index; + + /* + * TODO:121:r: | |-> Review sessionTable max index length. + * If you KNOW that your indexes will never exceed a certain + * length, update this macro to that length. + * + * BE VERY CAREFUL TO TAKE INTO ACCOUNT THE MAXIMUM + * POSSIBLE LENGHT FOR EVERY VARIABLE LENGTH INDEX! + * Guessing 128 - col/entry(2) - oid len(10) +*/ +#define MAX_sessionTable_IDX_LEN PPP_SESSIONID_LEN + 1 + + +/* ********************************************************************* + * TODO:130:o: |-> Review sessionTable Row request (rowreq) context. + * When your functions are called, you will be passed a + * sessionTable_rowreq_ctx pointer. + */ +typedef struct sessionTable_rowreq_ctx_s { + + /** this must be first for container compare to work */ + netsnmp_index oid_idx; + oid oid_tmp[MAX_sessionTable_IDX_LEN]; + + sessionTable_mib_index tbl_idx; + + sessionTable_data * data; + + /* + * flags per row. Currently, the first (lower) 8 bits are reserved + * for the user. See mfd.h for other flags. + */ + u_int rowreq_flags; + + /* + * TODO:131:o: | |-> Add useful data to sessionTable rowreq context. + */ + + /* + * storage for future expansion + */ + netsnmp_data_list *sessionTable_data_list; + +} sessionTable_rowreq_ctx; + +typedef struct sessionTable_ref_rowreq_ctx_s { + sessionTable_rowreq_ctx *rowreq_ctx; +} sessionTable_ref_rowreq_ctx; + +/* ********************************************************************* + * function prototypes + */ + int sessionTable_pre_request(sessionTable_registration * user_context); + int sessionTable_post_request(sessionTable_registration * user_context, + int rc); + + int sessionTable_rowreq_ctx_init(sessionTable_rowreq_ctx *rowreq_ctx, + void *user_init_ctx); + void sessionTable_rowreq_ctx_cleanup(sessionTable_rowreq_ctx *rowreq_ctx); + + sessionTable_data * sessionTable_allocate_data(void); + void sessionTable_release_data(sessionTable_data *data); + + + sessionTable_rowreq_ctx * + sessionTable_row_find_by_mib_index(sessionTable_mib_index *mib_idx); + +extern oid sessionTable_oid[]; +extern int sessionTable_oid_size; + + +#include "sessionTable_interface.h" +#include "sessionTable_data_access.h" +#include "sessionTable_data_get.h" +#include "sessionTable_data_set.h" + +/* + * DUMMY markers, ignore + * + * TODO:099:x: ************************************************************* + * TODO:199:x: ************************************************************* + * TODO:299:x: ************************************************************* + * TODO:399:x: ************************************************************* + * TODO:499:x: ************************************************************* + */ + +#ifdef __cplusplus +} +#endif + +#endif /* SESSIONTABLE_H */ +/** @} */ diff --git a/accel-pppd/extra/net-snmp/sessionTable_data_access.c b/accel-pppd/extra/net-snmp/sessionTable_data_access.c new file mode 100644 index 00000000..847197af --- /dev/null +++ b/accel-pppd/extra/net-snmp/sessionTable_data_access.c @@ -0,0 +1,304 @@ +/* + * Note: this file originally auto-generated by mib2c using + * version : 14170 $ of $ + * + * $Id:$ + */ +/* standard Net-SNMP includes */ +#include <net-snmp/net-snmp-config.h> +#include <net-snmp/net-snmp-includes.h> +#include <net-snmp/agent/net-snmp-agent-includes.h> + +/* include our parent header */ +#include "sessionTable.h" + + +#include "sessionTable_data_access.h" + +#include "ppp.h" + +/** @ingroup interface + * @addtogroup data_access data_access: Routines to access data + * + * These routines are used to locate the data used to satisfy + * requests. + * + * @{ + */ +/********************************************************************** + ********************************************************************** + *** + *** Table sessionTable + *** + ********************************************************************** + **********************************************************************/ +/* + * ACCEL-PPP-MIB::sessionTable is subid 1 of accelPPPSessions. + * Its status is Current. + * OID: .1.3.6.1.4.1.8072.100.2.1, length: 10 +*/ + +/** + * initialization for sessionTable data access + * + * This function is called during startup to allow you to + * allocate any resources you need for the data table. + * + * @param sessionTable_reg + * Pointer to sessionTable_registration + * + * @retval MFD_SUCCESS : success. + * @retval MFD_ERROR : unrecoverable error. + */ +int +sessionTable_init_data(sessionTable_registration * sessionTable_reg) +{ + DEBUGMSGTL(("verbose:sessionTable:sessionTable_init_data","called\n")); + + /* + * TODO:303:o: Initialize sessionTable data-> + */ + /* + *************************************************** + *** START EXAMPLE CODE *** + ***---------------------------------------------***/ + /* + * if you are the sole writer for the file, you could + * open it here. However, as stated earlier, we are assuming + * the worst case, which in this case means that the file is + * written to by someone else, and might not even exist when + * we start up. So we can't do anything here. + */ + /* + ***---------------------------------------------*** + *** END EXAMPLE CODE *** + ***************************************************/ + + return MFD_SUCCESS; +} /* sessionTable_init_data */ + +/** + * container overview + * + */ + +/** + * container initialization + * + * @param container_ptr_ptr A pointer to a container pointer. If you + * create a custom container, use this parameter to return it + * to the MFD helper. If set to NULL, the MFD helper will + * allocate a container for you. + * + * This function is called at startup to allow you to customize certain + * aspects of the access method. For the most part, it is for advanced + * users. The default code should suffice for most cases. If no custom + * container is allocated, the MFD code will create one for your. + * + * @remark + * This would also be a good place to do any initialization needed + * for you data source. For example, opening a connection to another + * process that will supply the data, opening a database, etc. + */ +void +sessionTable_container_init(netsnmp_container **container_ptr_ptr, + netsnmp_cache *cache) +{ + DEBUGMSGTL(("verbose:sessionTable:sessionTable_container_init","called\n")); + + if (NULL == container_ptr_ptr) { + snmp_log(LOG_ERR,"bad container param to sessionTable_container_init\n"); + return; + } + + /* + * For advanced users, you can use a custom container. If you + * do not create one, one will be created for you. + */ + *container_ptr_ptr = NULL; + + if (NULL == cache) { + snmp_log(LOG_ERR,"bad cache param to sessionTable_container_init\n"); + return; + } + + /* + * TODO:345:A: Set up sessionTable cache properties. + * + * Also for advanced users, you can set parameters for the + * cache. Do not change the magic pointer, as it is used + * by the MFD helper. To completely disable caching, set + * cache->enabled to 0. + */ + cache->timeout = -1; /* seconds */ +} /* sessionTable_container_init */ + +/** + * container shutdown + * + * @param container_ptr A pointer to the container. + * + * This function is called at shutdown to allow you to customize certain + * aspects of the access method. For the most part, it is for advanced + * users. The default code should suffice for most cases. + * + * This function is called before sessionTable_container_free(). + * + * @remark + * This would also be a good place to do any cleanup needed + * for you data source. For example, closing a connection to another + * process that supplied the data, closing a database, etc. + */ +void +sessionTable_container_shutdown(netsnmp_container *container_ptr) +{ + DEBUGMSGTL(("verbose:sessionTable:sessionTable_container_shutdown","called\n")); + + if (NULL == container_ptr) { + snmp_log(LOG_ERR,"bad params to sessionTable_container_shutdown\n"); + return; + } + +} /* sessionTable_container_shutdown */ + +/** + * load initial data + * + * TODO:350:M: Implement sessionTable data load + * + * @param container container to which items should be inserted + * + * @retval MFD_SUCCESS : success. + * @retval MFD_RESOURCE_UNAVAILABLE : Can't access data source + * @retval MFD_ERROR : other error. + * + * This function is called to load the index(es) (and data, optionally) + * for the every row in the data set. + * + * @remark + * While loading the data, the only important thing is the indexes. + * If access to your data is cheap/fast (e.g. you have a pointer to a + * structure in memory), it would make sense to update the data here. + * If, however, the accessing the data invovles more work (e.g. parsing + * some other existing data, or peforming calculations to derive the data), + * then you can limit yourself to setting the indexes and saving any + * information you will need later. Then use the saved information in + * sessionTable_row_prep() for populating data-> + * + * @note + * If you need consistency between rows (like you want statistics + * for each row to be from the same time frame), you should set all + * data here. + * + */ +int +sessionTable_container_load(netsnmp_container *container) +{ + sessionTable_rowreq_ctx *rowreq_ctx; + size_t count = 0; + struct ppp_t *ppp; + time_t t; + + time(&t); + + DEBUGMSGTL(("verbose:sessionTable:sessionTable_container_load","called\n")); + + pthread_rwlock_rdlock(&ppp_lock); + list_for_each_entry(ppp, &ppp_list, entry) { + rowreq_ctx = sessionTable_allocate_rowreq_ctx(NULL, NULL); + if (NULL == rowreq_ctx) { + pthread_rwlock_unlock(&ppp_lock); + snmp_log(LOG_ERR, "memory allocation failed\n"); + return MFD_RESOURCE_UNAVAILABLE; + } + if(MFD_SUCCESS != sessionTable_indexes_set(rowreq_ctx + , ppp->sessionid, PPP_SESSIONID_LEN + )) { + snmp_log(LOG_ERR,"error setting index while loading " + "sessionTable data->\n"); + sessionTable_release_rowreq_ctx(rowreq_ctx); + continue; + } + + strcpy(rowreq_ctx->data->ifname, ppp->ifname); + + if (ppp->username) + rowreq_ctx->data->username = strdup(ppp->username); + else + ppp->username = strdup(""); + + rowreq_ctx->data->peer_addr = ppp->peer_ipaddr; + rowreq_ctx->data->type = ppp->ctrl->type; + rowreq_ctx->data->state = ppp->state; + rowreq_ctx->data->uptime = (ppp->stop_time ? ppp->stop_time : t) - ppp->start_time; + rowreq_ctx->data->calling_sid = strdup(ppp->ctrl->calling_station_id); + rowreq_ctx->data->called_sid = strdup(ppp->ctrl->called_station_id); + + CONTAINER_INSERT(container, rowreq_ctx); + ++count; + } + pthread_rwlock_unlock(&ppp_lock); + + DEBUGMSGT(("verbose:sessionTable:sessionTable_container_load", + "inserted %d records\n", count)); + + return MFD_SUCCESS; +} /* sessionTable_container_load */ + +/** + * container clean up + * + * @param container container with all current items + * + * This optional callback is called prior to all + * item's being removed from the container. If you + * need to do any processing before that, do it here. + * + * @note + * The MFD helper will take care of releasing all the row contexts. + * If you did not pass a data context pointer when allocating + * the rowreq context, the one that was allocated will be deleted. + * If you did pass one in, it will not be deleted and that memory + * is your responsibility. + * + */ +void +sessionTable_container_free(netsnmp_container *container) +{ + DEBUGMSGTL(("verbose:sessionTable:sessionTable_container_free","called\n")); + + /* + * TODO:380:M: Free sessionTable container data-> + */ +} /* sessionTable_container_free */ + +/** + * prepare row for processing. + * + * When the agent has located the row for a request, this function is + * called to prepare the row for processing. If you fully populated + * the data context during the index setup phase, you may not need to + * do anything. + * + * @param rowreq_ctx pointer to a context. + * + * @retval MFD_SUCCESS : success. + * @retval MFD_ERROR : other error. + */ +int +sessionTable_row_prep( sessionTable_rowreq_ctx *rowreq_ctx) +{ + DEBUGMSGTL(("verbose:sessionTable:sessionTable_row_prep","called\n")); + + netsnmp_assert(NULL != rowreq_ctx); + + /* + * TODO:390:o: Prepare row for request. + * If populating row data was delayed, this is the place to + * fill in the row for this request. + */ + + return MFD_SUCCESS; +} /* sessionTable_row_prep */ + +/** @} */ diff --git a/accel-pppd/extra/net-snmp/sessionTable_data_access.h b/accel-pppd/extra/net-snmp/sessionTable_data_access.h new file mode 100644 index 00000000..1c420cee --- /dev/null +++ b/accel-pppd/extra/net-snmp/sessionTable_data_access.h @@ -0,0 +1,76 @@ +/* + * Note: this file originally auto-generated by mib2c using + * version : 14170 $ of $ + * + * $Id:$ + */ +#ifndef SESSIONTABLE_DATA_ACCESS_H +#define SESSIONTABLE_DATA_ACCESS_H + +#ifdef __cplusplus +extern "C" { +#endif + + +/* ********************************************************************* + * function declarations + */ + +/* ********************************************************************* + * Table declarations + */ +/********************************************************************** + ********************************************************************** + *** + *** Table sessionTable + *** + ********************************************************************** + **********************************************************************/ +/* + * ACCEL-PPP-MIB::sessionTable is subid 1 of accelPPPSessions. + * Its status is Current. + * OID: .1.3.6.1.4.1.8072.100.2.1, length: 10 +*/ + + + int sessionTable_init_data(sessionTable_registration * sessionTable_reg); + + + /* + * TODO:180:o: Review sessionTable cache timeout. + * The number of seconds before the cache times out + */ +#define SESSIONTABLE_CACHE_TIMEOUT 60 + +void sessionTable_container_init(netsnmp_container **container_ptr_ptr, + netsnmp_cache *cache); +void sessionTable_container_shutdown(netsnmp_container *container_ptr); + +int sessionTable_container_load(netsnmp_container *container); +void sessionTable_container_free(netsnmp_container *container); + +int sessionTable_cache_load(netsnmp_container *container); +void sessionTable_cache_free(netsnmp_container *container); + + /* + *************************************************** + *** START EXAMPLE CODE *** + ***---------------------------------------------***/ +/* ********************************************************************* + * Since we have no idea how you really access your data, we'll go with + * a worst case example: a flat text file. + */ +#define MAX_LINE_SIZE 256 + /* + ***---------------------------------------------*** + *** END EXAMPLE CODE *** + ***************************************************/ + int sessionTable_row_prep( sessionTable_rowreq_ctx *rowreq_ctx); + + + +#ifdef __cplusplus +} +#endif + +#endif /* SESSIONTABLE_DATA_ACCESS_H */ diff --git a/accel-pppd/extra/net-snmp/sessionTable_data_get.c b/accel-pppd/extra/net-snmp/sessionTable_data_get.c new file mode 100644 index 00000000..1dcea1e8 --- /dev/null +++ b/accel-pppd/extra/net-snmp/sessionTable_data_get.c @@ -0,0 +1,696 @@ +/* + * Note: this file originally auto-generated by mib2c using + * version : 12088 $ of $ + * + * $Id:$ + */ +/* standard Net-SNMP includes */ +#include <net-snmp/net-snmp-config.h> +#include <net-snmp/net-snmp-includes.h> +#include <net-snmp/agent/net-snmp-agent-includes.h> + +/* include our parent header */ +#include "sessionTable.h" + + +/** @defgroup data_get data_get: Routines to get data + * + * TODO:230:M: Implement sessionTable get routines. + * TODO:240:M: Implement sessionTable mapping routines (if any). + * + * These routine are used to get the value for individual objects. The + * row context is passed, along with a pointer to the memory where the + * value should be copied. + * + * @{ + */ +/********************************************************************** + ********************************************************************** + *** + *** Table sessionTable + *** + ********************************************************************** + **********************************************************************/ +/* + * ACCEL-PPP-MIB::sessionTable is subid 1 of accelPPPSessions. + * Its status is Current. + * OID: .1.3.6.1.4.1.8072.100.2.1, length: 10 +*/ + +/* --------------------------------------------------------------------- + * TODO:200:r: Implement sessionTable data context functions. + */ +/* + * sessionTable_allocate_data + * + * Purpose: create new sessionTable_data-> + */ +sessionTable_data * +sessionTable_allocate_data(void) +{ + sessionTable_data *rtn = SNMP_MALLOC_TYPEDEF(sessionTable_data); + + DEBUGMSGTL(("verbose:sessionTable:sessionTable_allocate_data","called\n")); + + if(NULL == rtn) { + snmp_log(LOG_ERR, "unable to malloc memory for new " + "sessionTable_data->\n"); + } + + memset(rtn, 0, sizeof(*rtn)); + + return rtn; +} /* sessionTable_allocate_data */ + +/* + * sessionTable_release_data + * + * Purpose: release sessionTable data-> + */ +void +sessionTable_release_data(sessionTable_data *data) +{ + DEBUGMSGTL(("verbose:sessionTable:sessionTable_release_data","called\n")); + + if (data->username) + free(data->username); + + if (data->calling_sid) + free(data->calling_sid); + + if (data->called_sid) + free(data->called_sid); + + free(data); +} /* sessionTable_release_data */ + + + +/** + * set mib index(es) + * + * @param tbl_idx mib index structure + * @param sesSID_ptr + * @param sesSID_ptr_len + * + * @retval MFD_SUCCESS : success. + * @retval MFD_ERROR : other error. + * + * @remark + * This convenience function is useful for setting all the MIB index + * components with a single function call. It is assume that the C values + * have already been mapped from their native/rawformat to the MIB format. + */ +int +sessionTable_indexes_set_tbl_idx(sessionTable_mib_index *tbl_idx, char *sesSID_val_ptr, size_t sesSID_val_ptr_len) +{ + DEBUGMSGTL(("verbose:sessionTable:sessionTable_indexes_set_tbl_idx","called\n")); + + /* sesSID(1)/OCTETSTR/ASN_OCTET_STR/char(char)//L/A/w/e/R/d/h */ + tbl_idx->sesSID_len = sizeof(tbl_idx->sesSID)/sizeof(tbl_idx->sesSID[0]); /* max length */ + /** WARNING: this code might not work for struct sessionTable_data_s */ + /* + * make sure there is enough space for sesSID data + */ + if ((NULL == tbl_idx->sesSID) || + (tbl_idx->sesSID_len < + (sesSID_val_ptr_len))) { + snmp_log(LOG_ERR,"not enough space for value\n"); + return MFD_ERROR; + } + tbl_idx->sesSID_len = sesSID_val_ptr_len; + memcpy( tbl_idx->sesSID, sesSID_val_ptr, sesSID_val_ptr_len* sizeof(sesSID_val_ptr[0]) ); + + + return MFD_SUCCESS; +} /* sessionTable_indexes_set_tbl_idx */ + +/** + * @internal + * set row context indexes + * + * @param reqreq_ctx the row context that needs updated indexes + * + * @retval MFD_SUCCESS : success. + * @retval MFD_ERROR : other error. + * + * @remark + * This function sets the mib indexs, then updates the oid indexs + * from the mib index. + */ +int +sessionTable_indexes_set(sessionTable_rowreq_ctx *rowreq_ctx, char *sesSID_val_ptr, size_t sesSID_val_ptr_len) +{ + DEBUGMSGTL(("verbose:sessionTable:sessionTable_indexes_set","called\n")); + + if(MFD_SUCCESS != sessionTable_indexes_set_tbl_idx(&rowreq_ctx->tbl_idx + , sesSID_val_ptr, sesSID_val_ptr_len + )) + return MFD_ERROR; + + /* + * convert mib index to oid index + */ + rowreq_ctx->oid_idx.len = sizeof(rowreq_ctx->oid_tmp) / sizeof(oid); + if(0 != sessionTable_index_to_oid(&rowreq_ctx->oid_idx, + &rowreq_ctx->tbl_idx)) { + return MFD_ERROR; + } + + return MFD_SUCCESS; +} /* sessionTable_indexes_set */ + + +/*--------------------------------------------------------------------- + * ACCEL-PPP-MIB::sessionEntry.sesIfName + * sesIfName is subid 2 of sessionEntry. + * Its status is Current, and its access level is ReadOnly. + * OID: .1.3.6.1.4.1.8072.100.2.1.1.2 + * Description: +name of ppp interface + * + * Attributes: + * accessible 1 isscalar 0 enums 0 hasdefval 0 + * readable 1 iscolumn 1 ranges 0 hashint 0 + * settable 0 + * + * + * Its syntax is OCTETSTR (based on perltype OCTETSTR) + * The net-snmp type is ASN_OCTET_STR. The C type decl is char (char) + * This data type requires a length. + */ +/** + * Extract the current value of the sesIfName data-> + * + * Set a value using the data context for the row. + * + * @param rowreq_ctx + * Pointer to the row request context. + * @param sesIfName_val_ptr_ptr + * Pointer to storage for a char variable + * @param sesIfName_val_ptr_len_ptr + * Pointer to a size_t. On entry, it will contain the size (in bytes) + * pointed to by sesIfName. + * On exit, this value should contain the data size (in bytes). + * + * @retval MFD_SUCCESS : success + * @retval MFD_SKIP : skip this node (no value for now) + * @retval MFD_ERROR : Any other error +* + * @note If you need more than (*sesIfName_val_ptr_len_ptr) bytes of memory, + * allocate it using malloc() and update sesIfName_val_ptr_ptr. + * <b>DO NOT</b> free the previous pointer. + * The MFD helper will release the memory you allocate. + * + * @remark If you call this function yourself, you are responsible + * for checking if the pointer changed, and freeing any + * previously allocated memory. (Not necessary if you pass + * in a pointer to static memory, obviously.) + */ +int +sesIfName_get( sessionTable_rowreq_ctx *rowreq_ctx, char **sesIfName_val_ptr_ptr, size_t *sesIfName_val_ptr_len_ptr ) +{ + int len; + /** we should have a non-NULL pointer and enough storage */ + netsnmp_assert( (NULL != sesIfName_val_ptr_ptr) && (NULL != *sesIfName_val_ptr_ptr)); + netsnmp_assert( NULL != sesIfName_val_ptr_len_ptr ); + + + DEBUGMSGTL(("verbose:sessionTable:sesIfName_get","called\n")); + + netsnmp_assert(NULL != rowreq_ctx); + + len = strlen(rowreq_ctx->data->ifname); + + if ((NULL == (* sesIfName_val_ptr_ptr )) || + ((* sesIfName_val_ptr_len_ptr ) < len)) { + /* + * allocate space for sesIfName data + */ + (* sesIfName_val_ptr_ptr ) = malloc(len); + if(NULL == (* sesIfName_val_ptr_ptr )) { + snmp_log(LOG_ERR,"could not allocate memory\n"); + return MFD_ERROR; + } + } + (* sesIfName_val_ptr_len_ptr ) = len; + memcpy( (* sesIfName_val_ptr_ptr ), rowreq_ctx->data->ifname, len); + + return MFD_SUCCESS; +} /* sesIfName_get */ + +/*--------------------------------------------------------------------- + * ACCEL-PPP-MIB::sessionEntry.sesUsername + * sesUsername is subid 3 of sessionEntry. + * Its status is Current, and its access level is ReadOnly. + * OID: .1.3.6.1.4.1.8072.100.2.1.1.3 + * Description: +session user name + * + * Attributes: + * accessible 1 isscalar 0 enums 0 hasdefval 0 + * readable 1 iscolumn 1 ranges 0 hashint 0 + * settable 0 + * + * + * Its syntax is OCTETSTR (based on perltype OCTETSTR) + * The net-snmp type is ASN_OCTET_STR. The C type decl is char (char) + * This data type requires a length. + */ +/** + * Extract the current value of the sesUsername data-> + * + * Set a value using the data context for the row. + * + * @param rowreq_ctx + * Pointer to the row request context. + * @param sesUsername_val_ptr_ptr + * Pointer to storage for a char variable + * @param sesUsername_val_ptr_len_ptr + * Pointer to a size_t. On entry, it will contain the size (in bytes) + * pointed to by sesUsername. + * On exit, this value should contain the data size (in bytes). + * + * @retval MFD_SUCCESS : success + * @retval MFD_SKIP : skip this node (no value for now) + * @retval MFD_ERROR : Any other error +* + * @note If you need more than (*sesUsername_val_ptr_len_ptr) bytes of memory, + * allocate it using malloc() and update sesUsername_val_ptr_ptr. + * <b>DO NOT</b> free the previous pointer. + * The MFD helper will release the memory you allocate. + * + * @remark If you call this function yourself, you are responsible + * for checking if the pointer changed, and freeing any + * previously allocated memory. (Not necessary if you pass + * in a pointer to static memory, obviously.) + */ +int +sesUsername_get( sessionTable_rowreq_ctx *rowreq_ctx, char **sesUsername_val_ptr_ptr, size_t *sesUsername_val_ptr_len_ptr ) +{ + int len; + /** we should have a non-NULL pointer and enough storage */ + netsnmp_assert( (NULL != sesUsername_val_ptr_ptr) && (NULL != *sesUsername_val_ptr_ptr)); + netsnmp_assert( NULL != sesUsername_val_ptr_len_ptr ); + + + DEBUGMSGTL(("verbose:sessionTable:sesUsername_get","called\n")); + + netsnmp_assert(NULL != rowreq_ctx); + + len = strlen(rowreq_ctx->data->username); + + if ((NULL == (* sesUsername_val_ptr_ptr )) || + ((* sesUsername_val_ptr_len_ptr ) < len)) { + /* + * allocate space for sesIfName data + */ + (* sesUsername_val_ptr_ptr ) = malloc(len); + if(NULL == (* sesUsername_val_ptr_ptr )) { + snmp_log(LOG_ERR,"could not allocate memory\n"); + return MFD_ERROR; + } + } + (* sesUsername_val_ptr_len_ptr ) = len; + memcpy( (* sesUsername_val_ptr_ptr ), rowreq_ctx->data->username, len); + + return MFD_SUCCESS; +} /* sesUsername_get */ + +/*--------------------------------------------------------------------- + * ACCEL-PPP-MIB::sessionEntry.sesIP + * sesIP is subid 4 of sessionEntry. + * Its status is Current, and its access level is ReadOnly. + * OID: .1.3.6.1.4.1.8072.100.2.1.1.4 + * Description: +assigned IP address + * + * Attributes: + * accessible 1 isscalar 0 enums 0 hasdefval 0 + * readable 1 iscolumn 1 ranges 0 hashint 0 + * settable 0 + * + * + * Its syntax is OCTETSTR (based on perltype OCTETSTR) + * The net-snmp type is ASN_OCTET_STR. The C type decl is char (char) + * This data type requires a length. + */ +/** + * Extract the current value of the sesIP data-> + * + * Set a value using the data context for the row. + * + * @param rowreq_ctx + * Pointer to the row request context. + * @param sesIP_val_ptr_ptr + * Pointer to storage for a char variable + * @param sesIP_val_ptr_len_ptr + * Pointer to a size_t. On entry, it will contain the size (in bytes) + * pointed to by sesIP. + * On exit, this value should contain the data size (in bytes). + * + * @retval MFD_SUCCESS : success + * @retval MFD_SKIP : skip this node (no value for now) + * @retval MFD_ERROR : Any other error +* + * @note If you need more than (*sesIP_val_ptr_len_ptr) bytes of memory, + * allocate it using malloc() and update sesIP_val_ptr_ptr. + * <b>DO NOT</b> free the previous pointer. + * The MFD helper will release the memory you allocate. + * + * @remark If you call this function yourself, you are responsible + * for checking if the pointer changed, and freeing any + * previously allocated memory. (Not necessary if you pass + * in a pointer to static memory, obviously.) + */ +int +sesIP_get( sessionTable_rowreq_ctx *rowreq_ctx, char **sesIP_val_ptr_ptr, size_t *sesIP_val_ptr_len_ptr ) +{ + int len = 4; + /** we should have a non-NULL pointer and enough storage */ + netsnmp_assert( (NULL != sesIP_val_ptr_ptr) && (NULL != *sesIP_val_ptr_ptr)); + netsnmp_assert( NULL != sesIP_val_ptr_len_ptr ); + + + DEBUGMSGTL(("verbose:sessionTable:sesIP_get","called\n")); + + netsnmp_assert(NULL != rowreq_ctx); + + if ((NULL == (* sesIP_val_ptr_ptr )) || + ((* sesIP_val_ptr_len_ptr ) < len)) { + /* + * allocate space for sesIfName data + */ + (* sesIP_val_ptr_ptr ) = malloc(len); + if(NULL == (* sesIP_val_ptr_ptr )) { + snmp_log(LOG_ERR,"could not allocate memory\n"); + return MFD_ERROR; + } + } + (* sesIP_val_ptr_len_ptr ) = len; + memcpy( (* sesIP_val_ptr_ptr ), &rowreq_ctx->data->peer_addr, len); + + return MFD_SUCCESS; +} /* sesIP_get */ + +/*--------------------------------------------------------------------- + * ACCEL-PPP-MIB::sessionEntry.sesType + * sesType is subid 5 of sessionEntry. + * Its status is Current, and its access level is ReadOnly. + * OID: .1.3.6.1.4.1.8072.100.2.1.1.5 + * Description: +name of ppp interface + * + * Attributes: + * accessible 1 isscalar 0 enums 1 hasdefval 0 + * readable 1 iscolumn 1 ranges 0 hashint 0 + * settable 0 + * + * Enum range: 10/16. Values: other(1), direct(2), gre(3), minimal(4), l2tp(5), pptp(6), l2f(7), udp(8), atmp(9), msdp(10), sixToFour(11), sixOverFour(12), isatap(13), teredo(14) + * + * Its syntax is IANAtunnelType (based on perltype INTEGER) + * The net-snmp type is ASN_INTEGER. The C type decl is long (u_long) + */ +/** + * Extract the current value of the sesType data-> + * + * Set a value using the data context for the row. + * + * @param rowreq_ctx + * Pointer to the row request context. + * @param sesType_val_ptr + * Pointer to storage for a long variable + * + * @retval MFD_SUCCESS : success + * @retval MFD_SKIP : skip this node (no value for now) + * @retval MFD_ERROR : Any other error + */ +int +sesType_get( sessionTable_rowreq_ctx *rowreq_ctx, u_long * sesType_val_ptr ) +{ + /** we should have a non-NULL pointer */ + netsnmp_assert( NULL != sesType_val_ptr ); + + + DEBUGMSGTL(("verbose:sessionTable:sesType_get","called\n")); + + netsnmp_assert(NULL != rowreq_ctx); + + (* sesType_val_ptr ) = rowreq_ctx->data->type; + + return MFD_SUCCESS; +} /* sesType_get */ + +/*--------------------------------------------------------------------- + * ACCEL-PPP-MIB::sessionEntry.sesState + * sesState is subid 6 of sessionEntry. + * Its status is Current, and its access level is ReadOnly. + * OID: .1.3.6.1.4.1.8072.100.2.1.1.6 + * Description: +state of session + * + * Attributes: + * accessible 1 isscalar 0 enums 1 hasdefval 0 + * readable 1 iscolumn 1 ranges 0 hashint 0 + * settable 0 + * + * Enum range: 3/8. Values: starting(1), active(2), finishing(3) + * + * Its syntax is INTEGER (based on perltype INTEGER) + * The net-snmp type is ASN_INTEGER. The C type decl is long (u_long) + */ +/** + * Extract the current value of the sesState data-> + * + * Set a value using the data context for the row. + * + * @param rowreq_ctx + * Pointer to the row request context. + * @param sesState_val_ptr + * Pointer to storage for a long variable + * + * @retval MFD_SUCCESS : success + * @retval MFD_SKIP : skip this node (no value for now) + * @retval MFD_ERROR : Any other error + */ +int +sesState_get( sessionTable_rowreq_ctx *rowreq_ctx, u_long * sesState_val_ptr ) +{ + /** we should have a non-NULL pointer */ + netsnmp_assert( NULL != sesState_val_ptr ); + + + DEBUGMSGTL(("verbose:sessionTable:sesState_get","called\n")); + + netsnmp_assert(NULL != rowreq_ctx); + + (* sesState_val_ptr ) = rowreq_ctx->data->state; + + return MFD_SUCCESS; +} /* sesState_get */ + +/*--------------------------------------------------------------------- + * ACCEL-PPP-MIB::sessionEntry.sesUptime + * sesUptime is subid 7 of sessionEntry. + * Its status is Current, and its access level is ReadOnly. + * OID: .1.3.6.1.4.1.8072.100.2.1.1.7 + * Description: +uptime of session + * + * Attributes: + * accessible 1 isscalar 0 enums 0 hasdefval 0 + * readable 1 iscolumn 1 ranges 0 hashint 0 + * settable 0 + * + * + * Its syntax is TICKS (based on perltype TICKS) + * The net-snmp type is ASN_TIMETICKS. The C type decl is u_long (u_long) + */ +/** + * Extract the current value of the sesUptime data-> + * + * Set a value using the data context for the row. + * + * @param rowreq_ctx + * Pointer to the row request context. + * @param sesUptime_val_ptr + * Pointer to storage for a u_long variable + * + * @retval MFD_SUCCESS : success + * @retval MFD_SKIP : skip this node (no value for now) + * @retval MFD_ERROR : Any other error + */ +int +sesUptime_get( sessionTable_rowreq_ctx *rowreq_ctx, u_long * sesUptime_val_ptr ) +{ + /** we should have a non-NULL pointer */ + netsnmp_assert( NULL != sesUptime_val_ptr ); + + + DEBUGMSGTL(("verbose:sessionTable:sesUptime_get","called\n")); + + netsnmp_assert(NULL != rowreq_ctx); + + (* sesUptime_val_ptr ) = rowreq_ctx->data->uptime; + + return MFD_SUCCESS; +} /* sesUptime_get */ + +/*--------------------------------------------------------------------- + * ACCEL-PPP-MIB::sessionEntry.sesCallingSID + * sesCallingSID is subid 8 of sessionEntry. + * Its status is Current, and its access level is ReadOnly. + * OID: .1.3.6.1.4.1.8072.100.2.1.1.8 + * Description: +Calling-Station-ID + * + * Attributes: + * accessible 1 isscalar 0 enums 0 hasdefval 0 + * readable 1 iscolumn 1 ranges 0 hashint 0 + * settable 0 + * + * + * Its syntax is OCTETSTR (based on perltype OCTETSTR) + * The net-snmp type is ASN_OCTET_STR. The C type decl is char (char) + * This data type requires a length. + */ +/** + * Extract the current value of the sesCallingSID data-> + * + * Set a value using the data context for the row. + * + * @param rowreq_ctx + * Pointer to the row request context. + * @param sesCallingSID_val_ptr_ptr + * Pointer to storage for a char variable + * @param sesCallingSID_val_ptr_len_ptr + * Pointer to a size_t. On entry, it will contain the size (in bytes) + * pointed to by sesCallingSID. + * On exit, this value should contain the data size (in bytes). + * + * @retval MFD_SUCCESS : success + * @retval MFD_SKIP : skip this node (no value for now) + * @retval MFD_ERROR : Any other error +* + * @note If you need more than (*sesCallingSID_val_ptr_len_ptr) bytes of memory, + * allocate it using malloc() and update sesCallingSID_val_ptr_ptr. + * <b>DO NOT</b> free the previous pointer. + * The MFD helper will release the memory you allocate. + * + * @remark If you call this function yourself, you are responsible + * for checking if the pointer changed, and freeing any + * previously allocated memory. (Not necessary if you pass + * in a pointer to static memory, obviously.) + */ +int +sesCallingSID_get( sessionTable_rowreq_ctx *rowreq_ctx, char **sesCallingSID_val_ptr_ptr, size_t *sesCallingSID_val_ptr_len_ptr ) +{ + int len; + /** we should have a non-NULL pointer and enough storage */ + netsnmp_assert( (NULL != sesCallingSID_val_ptr_ptr) && (NULL != *sesCallingSID_val_ptr_ptr)); + netsnmp_assert( NULL != sesCallingSID_val_ptr_len_ptr ); + + + DEBUGMSGTL(("verbose:sessionTable:sesCallingSID_get","called\n")); + + netsnmp_assert(NULL != rowreq_ctx); + + len = strlen(rowreq_ctx->data->calling_sid); + + if ((NULL == (* sesCallingSID_val_ptr_ptr )) || + ((* sesCallingSID_val_ptr_len_ptr ) < len)) { + /* + * allocate space for sesCallingSID data + */ + (* sesCallingSID_val_ptr_ptr ) = malloc(len); + if(NULL == (* sesCallingSID_val_ptr_ptr )) { + snmp_log(LOG_ERR,"could not allocate memory\n"); + return MFD_ERROR; + } + } + (* sesCallingSID_val_ptr_len_ptr ) = len; + memcpy( (* sesCallingSID_val_ptr_ptr ), rowreq_ctx->data->calling_sid, len); + + return MFD_SUCCESS; +} /* sesCallingSID_get */ + +/*--------------------------------------------------------------------- + * ACCEL-PPP-MIB::sessionEntry.sesCalledSID + * sesCalledSID is subid 9 of sessionEntry. + * Its status is Current, and its access level is ReadOnly. + * OID: .1.3.6.1.4.1.8072.100.2.1.1.9 + * Description: +Called-Station-ID + * + * Attributes: + * accessible 1 isscalar 0 enums 0 hasdefval 0 + * readable 1 iscolumn 1 ranges 0 hashint 0 + * settable 0 + * + * + * Its syntax is OCTETSTR (based on perltype OCTETSTR) + * The net-snmp type is ASN_OCTET_STR. The C type decl is char (char) + * This data type requires a length. + */ +/** + * Extract the current value of the sesCalledSID data-> + * + * Set a value using the data context for the row. + * + * @param rowreq_ctx + * Pointer to the row request context. + * @param sesCalledSID_val_ptr_ptr + * Pointer to storage for a char variable + * @param sesCalledSID_val_ptr_len_ptr + * Pointer to a size_t. On entry, it will contain the size (in bytes) + * pointed to by sesCalledSID. + * On exit, this value should contain the data size (in bytes). + * + * @retval MFD_SUCCESS : success + * @retval MFD_SKIP : skip this node (no value for now) + * @retval MFD_ERROR : Any other error +* + * @note If you need more than (*sesCalledSID_val_ptr_len_ptr) bytes of memory, + * allocate it using malloc() and update sesCalledSID_val_ptr_ptr. + * <b>DO NOT</b> free the previous pointer. + * The MFD helper will release the memory you allocate. + * + * @remark If you call this function yourself, you are responsible + * for checking if the pointer changed, and freeing any + * previously allocated memory. (Not necessary if you pass + * in a pointer to static memory, obviously.) + */ +int +sesCalledSID_get( sessionTable_rowreq_ctx *rowreq_ctx, char **sesCalledSID_val_ptr_ptr, size_t *sesCalledSID_val_ptr_len_ptr ) +{ + int len; + + /** we should have a non-NULL pointer and enough storage */ + netsnmp_assert( (NULL != sesCalledSID_val_ptr_ptr) && (NULL != *sesCalledSID_val_ptr_ptr)); + netsnmp_assert( NULL != sesCalledSID_val_ptr_len_ptr ); + + + DEBUGMSGTL(("verbose:sessionTable:sesCalledSID_get","called\n")); + + netsnmp_assert(NULL != rowreq_ctx); + + len = strlen(rowreq_ctx->data->called_sid); + + if ((NULL == (* sesCalledSID_val_ptr_ptr )) || + ((* sesCalledSID_val_ptr_len_ptr ) < len)) { + /* + * allocate space for sesCalledSID data + */ + (* sesCalledSID_val_ptr_ptr ) = malloc(len); + if(NULL == (* sesCalledSID_val_ptr_ptr )) { + snmp_log(LOG_ERR,"could not allocate memory\n"); + return MFD_ERROR; + } + } + (* sesCalledSID_val_ptr_len_ptr ) = len; + memcpy( (* sesCalledSID_val_ptr_ptr ), rowreq_ctx->data->called_sid, len); + + return MFD_SUCCESS; +} /* sesCalledSID_get */ + +/** @} */ diff --git a/accel-pppd/extra/net-snmp/sessionTable_data_get.h b/accel-pppd/extra/net-snmp/sessionTable_data_get.h new file mode 100644 index 00000000..e5a3ae62 --- /dev/null +++ b/accel-pppd/extra/net-snmp/sessionTable_data_get.h @@ -0,0 +1,66 @@ +/* + * Note: this file originally auto-generated by mib2c using + * version : 12088 $ of $ + * + * $Id:$ + * + * @file sessionTable_data_get.h + * + * @addtogroup get + * + * Prototypes for get functions + * + * @{ + */ +#ifndef SESSIONTABLE_DATA_GET_H +#define SESSIONTABLE_DATA_GET_H + +#ifdef __cplusplus +extern "C" { +#endif + +/* ********************************************************************* + * GET function declarations + */ + +/* ********************************************************************* + * GET Table declarations + */ +/********************************************************************** + ********************************************************************** + *** + *** Table sessionTable + *** + ********************************************************************** + **********************************************************************/ +/* + * ACCEL-PPP-MIB::sessionTable is subid 1 of accelPPPSessions. + * Its status is Current. + * OID: .1.3.6.1.4.1.8072.100.2.1, length: 10 +*/ + /* + * indexes + */ + + int sesIfName_get( sessionTable_rowreq_ctx *rowreq_ctx, char **sesIfName_val_ptr_ptr, size_t *sesIfName_val_ptr_len_ptr ); + int sesUsername_get( sessionTable_rowreq_ctx *rowreq_ctx, char **sesUsername_val_ptr_ptr, size_t *sesUsername_val_ptr_len_ptr ); + int sesIP_get( sessionTable_rowreq_ctx *rowreq_ctx, char **sesIP_val_ptr_ptr, size_t *sesIP_val_ptr_len_ptr ); + int sesType_get( sessionTable_rowreq_ctx *rowreq_ctx, u_long * sesType_val_ptr ); + int sesState_get( sessionTable_rowreq_ctx *rowreq_ctx, u_long * sesState_val_ptr ); + int sesUptime_get( sessionTable_rowreq_ctx *rowreq_ctx, u_long * sesUptime_val_ptr ); + int sesCallingSID_get( sessionTable_rowreq_ctx *rowreq_ctx, char **sesCallingSID_val_ptr_ptr, size_t *sesCallingSID_val_ptr_len_ptr ); + int sesCalledSID_get( sessionTable_rowreq_ctx *rowreq_ctx, char **sesCalledSID_val_ptr_ptr, size_t *sesCalledSID_val_ptr_len_ptr ); + + +int sessionTable_indexes_set_tbl_idx(sessionTable_mib_index *tbl_idx, char *sesSID_val_ptr, size_t sesSID_val_ptr_len); +int sessionTable_indexes_set(sessionTable_rowreq_ctx *rowreq_ctx, char *sesSID_val_ptr, size_t sesSID_val_ptr_len); + + + + +#ifdef __cplusplus +} +#endif + +#endif /* SESSIONTABLE_DATA_GET_H */ +/** @} */ diff --git a/accel-pppd/extra/net-snmp/sessionTable_data_set.c b/accel-pppd/extra/net-snmp/sessionTable_data_set.c new file mode 100644 index 00000000..ebfeeeaa --- /dev/null +++ b/accel-pppd/extra/net-snmp/sessionTable_data_set.c @@ -0,0 +1,24 @@ +/* + * Note: this file originally auto-generated by mib2c using + * version : 12077 $ of $ + * + * $Id:$ + * + */ +/* standard Net-SNMP includes */ +#include <net-snmp/net-snmp-config.h> +#include <net-snmp/net-snmp-includes.h> +#include <net-snmp/agent/net-snmp-agent-includes.h> + +/* include our parent header */ +#include "sessionTable.h" + + +/** @defgroup data_set data_set: Routines to set data + * + * These routines are used to set the value for individual objects. The + * row context is passed, along with the new value. + * + * @{ + */ +/** @} */ diff --git a/accel-pppd/extra/net-snmp/sessionTable_data_set.h b/accel-pppd/extra/net-snmp/sessionTable_data_set.h new file mode 100644 index 00000000..70534baa --- /dev/null +++ b/accel-pppd/extra/net-snmp/sessionTable_data_set.h @@ -0,0 +1,27 @@ +/* + * Note: this file originally auto-generated by mib2c using + * version : 12077 $ of $ + * + * $Id:$ + */ +#ifndef SESSIONTABLE_DATA_SET_H +#define SESSIONTABLE_DATA_SET_H + +#ifdef __cplusplus +extern "C" { +#endif + +/* ********************************************************************* + * SET function declarations + */ + +/* ********************************************************************* + * SET Table declarations + */ + + +#ifdef __cplusplus +} +#endif + +#endif /* SESSIONTABLE_DATA_SET_H */ diff --git a/accel-pppd/extra/net-snmp/sessionTable_enums.h b/accel-pppd/extra/net-snmp/sessionTable_enums.h new file mode 100644 index 00000000..c7ce8450 --- /dev/null +++ b/accel-pppd/extra/net-snmp/sessionTable_enums.h @@ -0,0 +1,85 @@ +/* + * Note: this file originally auto-generated by mib2c using + * : generic-table-enums.m2c 12526 2005-07-15 22:41:16Z rstory $ + * + * $Id:$ + */ +#ifndef SESSIONTABLE_ENUMS_H +#define SESSIONTABLE_ENUMS_H + +#ifdef __cplusplus +extern "C" { +#endif + + /* + * NOTES on enums + * ============== + * + * Value Mapping + * ------------- + * If the values for your data type don't exactly match the + * possible values defined by the mib, you should map them + * below. For example, a boolean flag (1/0) is usually represented + * as a TruthValue in a MIB, which maps to the values (1/2). + * + */ +/************************************************************************* + ************************************************************************* + * + * enum definitions for table sessionTable + * + ************************************************************************* + *************************************************************************/ + +/************************************************************* + * constants for enums for the MIB node + * sesType (IANAtunnelType / ASN_INTEGER) + * + * since a Textual Convention may be referenced more than once in a + * MIB, protect againt redefinitions of the enum values. + */ +#ifndef IANATUNNELTYPE_ENUMS +#define IANATUNNELTYPE_ENUMS + +#define IANATUNNELTYPE_OTHER 1 +#define IANATUNNELTYPE_DIRECT 2 +#define IANATUNNELTYPE_GRE 3 +#define IANATUNNELTYPE_MINIMAL 4 +#define IANATUNNELTYPE_L2TP 5 +#define IANATUNNELTYPE_PPTP 6 +#define IANATUNNELTYPE_L2F 7 +#define IANATUNNELTYPE_UDP 8 +#define IANATUNNELTYPE_ATMP 9 +#define IANATUNNELTYPE_MSDP 10 +#define IANATUNNELTYPE_SIXTOFOUR 11 +#define IANATUNNELTYPE_SIXOVERFOUR 12 +#define IANATUNNELTYPE_ISATAP 13 +#define IANATUNNELTYPE_TEREDO 14 + +#endif /* IANATUNNELTYPE_ENUMS */ + + +/************************************************************* + * constants for enums for the MIB node + * sesState (INTEGER / ASN_INTEGER) + * + * since a Textual Convention may be referenced more than once in a + * MIB, protect againt redefinitions of the enum values. + */ +#ifndef SESSTATE_ENUMS +#define SESSTATE_ENUMS + +#define SESSTATE_STARTING 1 +#define SESSTATE_ACTIVE 2 +#define SESSTATE_FINISHING 3 + +#endif /* SESSTATE_ENUMS */ + + + + +#ifdef __cplusplus +} +#endif + +#endif /* SESSIONTABLE_ENUMS_H */ diff --git a/accel-pppd/extra/net-snmp/sessionTable_interface.c b/accel-pppd/extra/net-snmp/sessionTable_interface.c new file mode 100644 index 00000000..cf60f910 --- /dev/null +++ b/accel-pppd/extra/net-snmp/sessionTable_interface.c @@ -0,0 +1,946 @@ +/* + * Note: this file originally auto-generated by mib2c using + * version : 15899 $ of $ + * + * $Id:$ + */ +/* + * ********************************************************************* + * ********************************************************************* + * ********************************************************************* + * *** *** + * *** NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE *** + * *** *** + * *** *** + * *** THIS FILE DOES NOT CONTAIN ANY USER EDITABLE CODE. *** + * *** *** + * *** *** + * *** THE GENERATED CODE IS INTERNAL IMPLEMENTATION, AND *** + * *** *** + * *** *** + * *** IS SUBJECT TO CHANGE WITHOUT WARNING IN FUTURE RELEASES. *** + * *** *** + * *** *** + * ********************************************************************* + * ********************************************************************* + * ********************************************************************* + */ + +/* standard Net-SNMP includes */ +#include <net-snmp/net-snmp-config.h> +#include <net-snmp/net-snmp-includes.h> +#include <net-snmp/agent/net-snmp-agent-includes.h> + +/* include our parent header */ +#include "sessionTable.h" + + +#include <net-snmp/agent/table_container.h> +#include <net-snmp/library/container.h> + +#include "sessionTable_interface.h" + +#include <ctype.h> + +/********************************************************************** + ********************************************************************** + *** + *** Table sessionTable + *** + ********************************************************************** + **********************************************************************/ +/* + * ACCEL-PPP-MIB::sessionTable is subid 1 of accelPPPSessions. + * Its status is Current. + * OID: .1.3.6.1.4.1.8072.100.2.1, length: 10 +*/ +typedef struct sessionTable_interface_ctx_s { + + netsnmp_container *container; + netsnmp_cache *cache; + + sessionTable_registration * user_ctx; + + netsnmp_table_registration_info tbl_info; + + netsnmp_baby_steps_access_methods access_multiplexer; + +} sessionTable_interface_ctx; + +static sessionTable_interface_ctx sessionTable_if_ctx; + +static void _sessionTable_container_init( + sessionTable_interface_ctx *if_ctx); +static void _sessionTable_container_shutdown( + sessionTable_interface_ctx *if_ctx); + + +netsnmp_container * +sessionTable_container_get( void ) +{ + return sessionTable_if_ctx.container; +} + +sessionTable_registration * +sessionTable_registration_get( void ) +{ + return sessionTable_if_ctx.user_ctx; +} + +sessionTable_registration * +sessionTable_registration_set( sessionTable_registration * newreg ) +{ + sessionTable_registration * old = sessionTable_if_ctx.user_ctx; + sessionTable_if_ctx.user_ctx = newreg; + return old; +} + +int +sessionTable_container_size( void ) +{ + return CONTAINER_SIZE(sessionTable_if_ctx.container); +} + +/* + * mfd multiplexer modes + */ +static Netsnmp_Node_Handler _mfd_sessionTable_pre_request; +static Netsnmp_Node_Handler _mfd_sessionTable_post_request; +static Netsnmp_Node_Handler _mfd_sessionTable_object_lookup; +static Netsnmp_Node_Handler _mfd_sessionTable_get_values; +/** + * @internal + * Initialize the table sessionTable + * (Define its contents and how it's structured) + */ +void +_sessionTable_initialize_interface(sessionTable_registration * reg_ptr, u_long flags) +{ + netsnmp_baby_steps_access_methods *access_multiplexer = + &sessionTable_if_ctx.access_multiplexer; + netsnmp_table_registration_info *tbl_info = &sessionTable_if_ctx.tbl_info; + netsnmp_handler_registration *reginfo; + netsnmp_mib_handler *handler; + int mfd_modes = 0; + + DEBUGMSGTL(("internal:sessionTable:_sessionTable_initialize_interface","called\n")); + + + /************************************************* + * + * save interface context for sessionTable + */ + /* + * Setting up the table's definition + */ + netsnmp_table_helper_add_indexes(tbl_info, + ASN_OCTET_STR, /** index: sesSID */ + 0); + + /* Define the minimum and maximum accessible columns. This + optimizes retrival. */ + tbl_info->min_column = SESSIONTABLE_MIN_COL; + tbl_info->max_column = SESSIONTABLE_MAX_COL; + + /* + * save users context + */ + sessionTable_if_ctx.user_ctx = reg_ptr; + + /* + * call data access initialization code + */ + sessionTable_init_data(reg_ptr); + + /* + * set up the container + */ + _sessionTable_container_init(&sessionTable_if_ctx); + if (NULL == sessionTable_if_ctx.container) { + snmp_log(LOG_ERR,"could not initialize container for sessionTable\n"); + return; + } + + /* + * access_multiplexer: REQUIRED wrapper for get request handling + */ + access_multiplexer->object_lookup = _mfd_sessionTable_object_lookup; + access_multiplexer->get_values = _mfd_sessionTable_get_values; + + /* + * no wrappers yet + */ + access_multiplexer->pre_request = _mfd_sessionTable_pre_request; + access_multiplexer->post_request = _mfd_sessionTable_post_request; + + + /************************************************* + * + * Create a registration, save our reg data, register table. + */ + DEBUGMSGTL(("sessionTable:init_sessionTable", + "Registering sessionTable as a mibs-for-dummies table.\n")); + handler = netsnmp_baby_steps_access_multiplexer_get(access_multiplexer); + reginfo = netsnmp_handler_registration_create("sessionTable", handler, + sessionTable_oid, + sessionTable_oid_size, + HANDLER_CAN_BABY_STEP | + HANDLER_CAN_RONLY + ); + if(NULL == reginfo) { + snmp_log(LOG_ERR,"error registering table sessionTable\n"); + return; + } + reginfo->my_reg_void = &sessionTable_if_ctx; + + /************************************************* + * + * set up baby steps handler, create it and inject it + */ + if( access_multiplexer->object_lookup ) + mfd_modes |= BABY_STEP_OBJECT_LOOKUP; + if( access_multiplexer->set_values ) + mfd_modes |= BABY_STEP_SET_VALUES; + if( access_multiplexer->irreversible_commit ) + mfd_modes |= BABY_STEP_IRREVERSIBLE_COMMIT; + if( access_multiplexer->object_syntax_checks ) + mfd_modes |= BABY_STEP_CHECK_OBJECT; + + if( access_multiplexer->pre_request ) + mfd_modes |= BABY_STEP_PRE_REQUEST; + if( access_multiplexer->post_request ) + mfd_modes |= BABY_STEP_POST_REQUEST; + + if( access_multiplexer->undo_setup ) + mfd_modes |= BABY_STEP_UNDO_SETUP; + if( access_multiplexer->undo_cleanup ) + mfd_modes |= BABY_STEP_UNDO_CLEANUP; + if( access_multiplexer->undo_sets ) + mfd_modes |= BABY_STEP_UNDO_SETS; + + if( access_multiplexer->row_creation ) + mfd_modes |= BABY_STEP_ROW_CREATE; + if( access_multiplexer->consistency_checks ) + mfd_modes |= BABY_STEP_CHECK_CONSISTENCY; + if( access_multiplexer->commit ) + mfd_modes |= BABY_STEP_COMMIT; + if( access_multiplexer->undo_commit ) + mfd_modes |= BABY_STEP_UNDO_COMMIT; + + handler = netsnmp_baby_steps_handler_get(mfd_modes); + netsnmp_inject_handler(reginfo, handler); + + /************************************************* + * + * inject row_merge helper with prefix rootoid_len + 2 (entry.col) + */ + handler = netsnmp_get_row_merge_handler(reginfo->rootoid_len + 2); + netsnmp_inject_handler(reginfo, handler); + + /************************************************* + * + * inject container_table helper + */ + handler = + netsnmp_container_table_handler_get(tbl_info, + sessionTable_if_ctx.container, + TABLE_CONTAINER_KEY_NETSNMP_INDEX); + netsnmp_inject_handler( reginfo, handler ); + + /************************************************* + * + * inject cache helper + */ + if(NULL != sessionTable_if_ctx.cache) { + handler = netsnmp_cache_handler_get(sessionTable_if_ctx.cache); + netsnmp_inject_handler( reginfo, handler ); + } + + /* + * register table + */ + netsnmp_register_table(reginfo, tbl_info); + +} /* _sessionTable_initialize_interface */ + +/** + * @internal + * Shutdown the table sessionTable + */ +void +_sessionTable_shutdown_interface(sessionTable_registration * reg_ptr) +{ + /* + * shutdown the container + */ + _sessionTable_container_shutdown(&sessionTable_if_ctx); +} + +void +sessionTable_valid_columns_set(netsnmp_column_info *vc) +{ + sessionTable_if_ctx.tbl_info.valid_columns = vc; +} /* sessionTable_valid_columns_set */ + +/** + * @internal + * convert the index component stored in the context to an oid + */ +int +sessionTable_index_to_oid(netsnmp_index *oid_idx, + sessionTable_mib_index *mib_idx) +{ + int err = SNMP_ERR_NOERROR; + + /* + * temp storage for parsing indexes + */ + /* + * sesSID(1)/OCTETSTR/ASN_OCTET_STR/char(char)//L/A/w/e/R/d/h + */ + netsnmp_variable_list var_sesSID; + + /* + * set up varbinds + */ + memset( &var_sesSID, 0x00, sizeof(var_sesSID) ); + var_sesSID.type = ASN_OCTET_STR; + + /* + * chain temp index varbinds together + */ + var_sesSID.next_variable = NULL; + + + DEBUGMSGTL(("verbose:sessionTable:sessionTable_index_to_oid","called\n")); + + /* sesSID(1)/OCTETSTR/ASN_OCTET_STR/char(char)//L/A/w/e/R/d/h */ + snmp_set_var_value(&var_sesSID, (u_char*)&mib_idx->sesSID, + mib_idx->sesSID_len * sizeof(mib_idx->sesSID[0])); + + + err = build_oid_noalloc(oid_idx->oids, oid_idx->len, &oid_idx->len, + NULL, 0, &var_sesSID); + if(err) + snmp_log(LOG_ERR,"error %d converting index to oid\n", err); + + /* + * parsing may have allocated memory. free it. + */ + snmp_reset_var_buffers( &var_sesSID ); + + return err; +} /* sessionTable_index_to_oid */ + +/** + * extract sessionTable indexes from a netsnmp_index + * + * @retval SNMP_ERR_NOERROR : no error + * @retval SNMP_ERR_GENERR : error + */ +int +sessionTable_index_from_oid(netsnmp_index *oid_idx, + sessionTable_mib_index *mib_idx) +{ + int err = SNMP_ERR_NOERROR; + + /* + * temp storage for parsing indexes + */ + /* + * sesSID(1)/OCTETSTR/ASN_OCTET_STR/char(char)//L/A/w/e/R/d/h + */ + netsnmp_variable_list var_sesSID; + + /* + * set up varbinds + */ + memset( &var_sesSID, 0x00, sizeof(var_sesSID) ); + var_sesSID.type = ASN_OCTET_STR; + + /* + * chain temp index varbinds together + */ + var_sesSID.next_variable = NULL; + + + DEBUGMSGTL(("verbose:sessionTable:sessionTable_index_from_oid","called\n")); + + /* + * parse the oid into the individual index components + */ + err = parse_oid_indexes( oid_idx->oids, oid_idx->len, + &var_sesSID ); + if (err == SNMP_ERR_NOERROR) { + /* + * copy out values + */ + /* + * NOTE: val_len is in bytes, sesSID_len might not be + */ + if(var_sesSID.val_len > sizeof(mib_idx->sesSID)) + err = SNMP_ERR_GENERR; + else { + memcpy(mib_idx->sesSID, var_sesSID.val.string, var_sesSID.val_len); + mib_idx->sesSID_len = var_sesSID.val_len / sizeof(mib_idx->sesSID[0]); + } + + + } + + /* + * parsing may have allocated memory. free it. + */ + snmp_reset_var_buffers( &var_sesSID ); + + return err; +} /* sessionTable_index_from_oid */ + + +/* ********************************************************************* + * @internal + * allocate resources for a sessionTable_rowreq_ctx + */ +sessionTable_rowreq_ctx * +sessionTable_allocate_rowreq_ctx(sessionTable_data *data, void *user_init_ctx) +{ + sessionTable_rowreq_ctx *rowreq_ctx = + SNMP_MALLOC_TYPEDEF(sessionTable_rowreq_ctx); + + DEBUGMSGTL(("internal:sessionTable:sessionTable_allocate_rowreq_ctx","called\n")); + + if(NULL == rowreq_ctx) { + snmp_log(LOG_ERR,"Couldn't allocate memory for a " + "sessionTable_rowreq_ctx.\n"); + return NULL; + } + else { + if(NULL != data) { + /* + * track if we got data from user + */ + rowreq_ctx->rowreq_flags |= MFD_ROW_DATA_FROM_USER; + rowreq_ctx->data = data; + } + else if (NULL == (rowreq_ctx->data = sessionTable_allocate_data())) { + SNMP_FREE(rowreq_ctx); + return NULL; + } + } + + /* + * undo context will be allocated when needed (in *_undo_setup) + */ + + rowreq_ctx->oid_idx.oids = rowreq_ctx->oid_tmp; + + rowreq_ctx->sessionTable_data_list = NULL; + + /* + * if we allocated data, call init routine + */ + if (!(rowreq_ctx->rowreq_flags & MFD_ROW_DATA_FROM_USER)) { + if(SNMPERR_SUCCESS != + sessionTable_rowreq_ctx_init(rowreq_ctx, user_init_ctx)) { + sessionTable_release_rowreq_ctx(rowreq_ctx); + rowreq_ctx = NULL; + } + } + + return rowreq_ctx; +} /* sessionTable_allocate_rowreq_ctx */ + +/* + * @internal + * release resources for a sessionTable_rowreq_ctx + */ +void +sessionTable_release_rowreq_ctx(sessionTable_rowreq_ctx *rowreq_ctx) +{ + DEBUGMSGTL(("internal:sessionTable:sessionTable_release_rowreq_ctx","called\n")); + + netsnmp_assert(NULL != rowreq_ctx); + + sessionTable_rowreq_ctx_cleanup(rowreq_ctx); + + /* + * for non-transient data, don't free data we got from the user + */ + if ((rowreq_ctx->data) && + !(rowreq_ctx->rowreq_flags & MFD_ROW_DATA_FROM_USER)) + sessionTable_release_data(rowreq_ctx->data); + + /* + * free index oid pointer + */ + if(rowreq_ctx->oid_idx.oids != rowreq_ctx->oid_tmp) + free(rowreq_ctx->oid_idx.oids); + + SNMP_FREE(rowreq_ctx); +} /* sessionTable_release_rowreq_ctx */ + +/** + * @internal + * wrapper + */ +static int +_mfd_sessionTable_pre_request(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *agtreq_info, + netsnmp_request_info *requests) +{ + int rc; + + DEBUGMSGTL(("internal:sessionTable:_mfd_sessionTable_pre_request", + "called\n")); + + if (1 != netsnmp_row_merge_status_first(reginfo, agtreq_info)) { + DEBUGMSGTL(("internal:sessionTable", + "skipping additional pre_request\n")); + return SNMP_ERR_NOERROR; + } + + rc = sessionTable_pre_request(sessionTable_if_ctx.user_ctx); + if (MFD_SUCCESS != rc) { + /* + * nothing we can do about it but log it + */ + DEBUGMSGTL(("sessionTable","error %d from " + "sessionTable_pre_request\n", rc)); + netsnmp_request_set_error_all(requests, SNMP_VALIDATE_ERR(rc)); + } + + return SNMP_ERR_NOERROR; +} /* _mfd_sessionTable_pre_request */ + +/** + * @internal + * wrapper + */ +static int +_mfd_sessionTable_post_request(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *agtreq_info, + netsnmp_request_info *requests) +{ + sessionTable_rowreq_ctx *rowreq_ctx = + netsnmp_container_table_row_extract(requests); + int rc, packet_rc; + + DEBUGMSGTL(("internal:sessionTable:_mfd_sessionTable_post_request", + "called\n")); + + /* + * release row context, if deleted + */ + if (rowreq_ctx && (rowreq_ctx->rowreq_flags & MFD_ROW_DELETED)) + sessionTable_release_rowreq_ctx(rowreq_ctx); + + /* + * wait for last call before calling user + */ + if (1 != netsnmp_row_merge_status_last(reginfo, agtreq_info)) { + DEBUGMSGTL(("internal:sessionTable", + "waiting for last post_request\n")); + return SNMP_ERR_NOERROR; + } + + packet_rc = netsnmp_check_all_requests_error(agtreq_info->asp, 0); + rc = sessionTable_post_request(sessionTable_if_ctx.user_ctx,packet_rc); + if (MFD_SUCCESS != rc) { + /* + * nothing we can do about it but log it + */ + DEBUGMSGTL(("sessionTable","error %d from " + "sessionTable_post_request\n", rc)); + } + + return SNMP_ERR_NOERROR; +} /* _mfd_sessionTable_post_request */ + +/** + * @internal + * wrapper + */ +static int +_mfd_sessionTable_object_lookup(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *agtreq_info, + netsnmp_request_info *requests) +{ + int rc = SNMP_ERR_NOERROR; + sessionTable_rowreq_ctx *rowreq_ctx = + netsnmp_container_table_row_extract(requests); + + DEBUGMSGTL(("internal:sessionTable:_mfd_sessionTable_object_lookup","called\n")); + + /* + * get our context from mfd + * sessionTable_interface_ctx *if_ctx = + * (sessionTable_interface_ctx *)reginfo->my_reg_void; + */ + + if(NULL == rowreq_ctx) { + rc = SNMP_ERR_NOCREATION; + } + + if (MFD_SUCCESS != rc) + netsnmp_request_set_error_all(requests, rc); + else + sessionTable_row_prep(rowreq_ctx); + + return SNMP_VALIDATE_ERR(rc); +} /* _mfd_sessionTable_object_lookup */ + +/*********************************************************************** + * + * GET processing + * + ***********************************************************************/ +/* + * @internal + * Retrieve the value for a particular column + */ +NETSNMP_STATIC_INLINE int +_sessionTable_get_column( sessionTable_rowreq_ctx *rowreq_ctx, + netsnmp_variable_list *var, int column ) +{ + int rc = SNMPERR_SUCCESS; + + DEBUGMSGTL(("internal:sessionTable:_mfd_sessionTable_get_column", + "called for %d\n", column)); + + + netsnmp_assert(NULL != rowreq_ctx); + + switch(column) { + + /* (INDEX) sesSID(1)/OCTETSTR/ASN_OCTET_STR/char(char)//L/A/w/e/R/d/h */ + case COLUMN_SESSID: + var->type = ASN_OCTET_STR; + /* + * NOTE: val_len is in bytes, sesSID_len might not be (e.g. oids) + */ + if (var->val_len < (rowreq_ctx->tbl_idx.sesSID_len * + sizeof(rowreq_ctx->tbl_idx.sesSID[0]))) { + var->val.string = malloc(rowreq_ctx->tbl_idx.sesSID_len * + sizeof(rowreq_ctx->tbl_idx.sesSID[0])); + } + var->val_len = rowreq_ctx->tbl_idx.sesSID_len * sizeof(rowreq_ctx->tbl_idx.sesSID[0]); + memcpy( var->val.string, rowreq_ctx->tbl_idx.sesSID, var->val_len ); + break; + + /* sesIfName(2)/OCTETSTR/ASN_OCTET_STR/char(char)//L/A/w/e/r/d/h */ + case COLUMN_SESIFNAME: + var->type = ASN_OCTET_STR; +rc = sesIfName_get(rowreq_ctx, (char **)&var->val.string, &var->val_len ); + break; + + /* sesUsername(3)/OCTETSTR/ASN_OCTET_STR/char(char)//L/A/w/e/r/d/h */ + case COLUMN_SESUSERNAME: + var->type = ASN_OCTET_STR; +rc = sesUsername_get(rowreq_ctx, (char **)&var->val.string, &var->val_len ); + break; + + /* sesIP(4)/InetAddressIPv4/ASN_OCTET_STR/char(char)//L/A/w/e/R/d/H */ + case COLUMN_SESIP: + var->type = ASN_OCTET_STR; +rc = sesIP_get(rowreq_ctx, (char **)&var->val.string, &var->val_len ); + break; + + /* sesType(5)/INTEGER/ASN_INTEGER/long(u_long)//l/A/w/E/r/d/h */ + case COLUMN_SESTYPE: + var->val_len = sizeof(u_long); + var->type = ASN_INTEGER; +rc = sesType_get(rowreq_ctx, (u_long *)var->val.string ); + break; + + /* sesState(6)/INTEGER/ASN_INTEGER/long(u_long)//l/A/w/E/r/d/h */ + case COLUMN_SESSTATE: + var->val_len = sizeof(u_long); + var->type = ASN_INTEGER; +rc = sesState_get(rowreq_ctx, (u_long *)var->val.string ); + break; + + /* sesUptime(7)/GAUGE/ASN_GAUGE/u_long(u_long)//l/A/w/e/r/d/h */ + case COLUMN_SESUPTIME: + var->val_len = sizeof(u_long); + var->type = ASN_GAUGE; +rc = sesUptime_get(rowreq_ctx, (u_long *)var->val.string ); + break; + + /* sesCallingSID(8)/OCTETSTR/ASN_OCTET_STR/char(char)//L/A/w/e/r/d/h */ + case COLUMN_SESCALLINGSID: + var->type = ASN_OCTET_STR; +rc = sesCallingSID_get(rowreq_ctx, (char **)&var->val.string, &var->val_len ); + break; + + /* sesCalledSID(9)/OCTETSTR/ASN_OCTET_STR/char(char)//L/A/w/e/r/d/h */ + case COLUMN_SESCALLEDSID: + var->type = ASN_OCTET_STR; +rc = sesCalledSID_get(rowreq_ctx, (char **)&var->val.string, &var->val_len ); + break; + + default: + if (SESSIONTABLE_MIN_COL <= column && column <= SESSIONTABLE_MAX_COL) { + DEBUGMSGTL(("internal:sessionTable:_mfd_sessionTable_get_column", + "assume column %d is reserved\n", column)); + rc = MFD_SKIP; + } else { + snmp_log(LOG_ERR, + "unknown column %d in _sessionTable_get_column\n", column); + } + break; + } + + return rc; +} /* _sessionTable_get_column */ + +int +_mfd_sessionTable_get_values(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *agtreq_info, + netsnmp_request_info *requests) +{ + sessionTable_rowreq_ctx *rowreq_ctx = + netsnmp_container_table_row_extract(requests); + netsnmp_table_request_info * tri; + u_char * old_string; + void (*dataFreeHook)(void *); + int rc; + + DEBUGMSGTL(("internal:sessionTable:_mfd_sessionTable_get_values","called\n")); + + netsnmp_assert(NULL != rowreq_ctx); + + for(;requests; requests = requests->next) { + /* + * save old pointer, so we can free it if replaced + */ + old_string = requests->requestvb->val.string; + dataFreeHook = requests->requestvb->dataFreeHook; + if(NULL == requests->requestvb->val.string) { + requests->requestvb->val.string = requests->requestvb->buf; + requests->requestvb->val_len = sizeof(requests->requestvb->buf); + } + else if(requests->requestvb->buf == requests->requestvb->val.string) { + if(requests->requestvb->val_len != sizeof(requests->requestvb->buf)) + requests->requestvb->val_len = sizeof(requests->requestvb->buf); + } + + /* + * get column data + */ + tri = netsnmp_extract_table_info(requests); + if(NULL == tri) + continue; + + rc = _sessionTable_get_column(rowreq_ctx, requests->requestvb, tri->colnum); + if(rc) { + if(MFD_SKIP == rc) { + requests->requestvb->type = SNMP_NOSUCHINSTANCE; + rc = SNMP_ERR_NOERROR; + } + } + else if (NULL == requests->requestvb->val.string) { + snmp_log(LOG_ERR,"NULL varbind data pointer!\n"); + rc = SNMP_ERR_GENERR; + } + if(rc) + netsnmp_request_set_error(requests, SNMP_VALIDATE_ERR(rc)); + + /* + * if the buffer wasn't used previously for the old data (i.e. it + * was allcoated memory) and the get routine replaced the pointer, + * we need to free the previous pointer. + */ + if(old_string && (old_string != requests->requestvb->buf) && + (requests->requestvb->val.string != old_string)) { + if(dataFreeHook) + (*dataFreeHook)(old_string); + else + free(old_string); + } + } /* for results */ + + return SNMP_ERR_NOERROR; +} /* _mfd_sessionTable_get_values */ + + +/*********************************************************************** + * + * SET processing + * + ***********************************************************************/ + +/* + * SET PROCESSING NOT APPLICABLE (per MIB or user setting) + */ +/*********************************************************************** + * + * DATA ACCESS + * + ***********************************************************************/ +static void _container_free(netsnmp_container *container); + +/** + * @internal + */ +static int +_cache_load(netsnmp_cache *cache, void *vmagic) +{ + DEBUGMSGTL(("internal:sessionTable:_cache_load","called\n")); + + if((NULL == cache) || (NULL == cache->magic)) { + snmp_log(LOG_ERR, "invalid cache for sessionTable_cache_load\n"); + return -1; + } + + /** should only be called for an invalid or expired cache */ + netsnmp_assert((0 == cache->valid) || (1 == cache->expired)); + + /* + * call user code + */ + return sessionTable_container_load((netsnmp_container*)cache->magic); +} /* _cache_load */ + +/** + * @internal + */ +static void +_cache_free(netsnmp_cache *cache, void *magic) +{ + netsnmp_container *container; + + DEBUGMSGTL(("internal:sessionTable:_cache_free","called\n")); + + if((NULL == cache) || (NULL == cache->magic)) { + snmp_log(LOG_ERR, "invalid cache in sessionTable_cache_free\n"); + return; + } + + container = (netsnmp_container*)cache->magic; + + _container_free(container); +} /* _cache_free */ + +/** + * @internal + */ +static void +_container_item_free(sessionTable_rowreq_ctx *rowreq_ctx, void *context) +{ + DEBUGMSGTL(("internal:sessionTable:_container_item_free","called\n")); + + if(NULL == rowreq_ctx) + return; + + sessionTable_release_rowreq_ctx(rowreq_ctx); +} /* _container_item_free */ + +/** + * @internal + */ +static void +_container_free(netsnmp_container *container) +{ + DEBUGMSGTL(("internal:sessionTable:_container_free","called\n")); + + if (NULL == container) { + snmp_log(LOG_ERR, "invalid container in sessionTable_container_free\n"); + return; + } + + /* + * call user code + */ + sessionTable_container_free(container); + + /* + * free all items. inefficient, but easy. + */ + CONTAINER_CLEAR(container, + (netsnmp_container_obj_func *)_container_item_free, + NULL); +} /* _container_free */ + +/** + * @internal + * initialize the container with functions or wrappers + */ +void +_sessionTable_container_init(sessionTable_interface_ctx *if_ctx) +{ + DEBUGMSGTL(("internal:sessionTable:_sessionTable_container_init","called\n")); + + /* + * cache init + */ + if_ctx->cache = netsnmp_cache_create(30, /* timeout in seconds */ + _cache_load, _cache_free, + sessionTable_oid, + sessionTable_oid_size); + + if(NULL == if_ctx->cache) { + snmp_log(LOG_ERR, "error creating cache for sessionTable\n"); + return; + } + + if_ctx->cache->flags = NETSNMP_CACHE_DONT_INVALIDATE_ON_SET; + + sessionTable_container_init(&if_ctx->container, if_ctx->cache); + if(NULL == if_ctx->container) + if_ctx->container = netsnmp_container_find("sessionTable:table_container"); + if(NULL == if_ctx->container) { + snmp_log(LOG_ERR,"error creating container in " + "sessionTable_container_init\n"); + return; + } + + if (NULL != if_ctx->cache) + if_ctx->cache->magic = (void*)if_ctx->container; +} /* _sessionTable_container_init */ + +/** + * @internal + * shutdown the container with functions or wrappers + */ +void +_sessionTable_container_shutdown(sessionTable_interface_ctx *if_ctx) +{ + DEBUGMSGTL(("internal:sessionTable:_sessionTable_container_shutdown","called\n")); + + sessionTable_container_shutdown(if_ctx->container); + + _container_free(if_ctx->container); + +} /* _sessionTable_container_shutdown */ + + +sessionTable_rowreq_ctx * +sessionTable_row_find_by_mib_index(sessionTable_mib_index *mib_idx) +{ + sessionTable_rowreq_ctx *rowreq_ctx; + oid oid_tmp[MAX_OID_LEN]; + netsnmp_index oid_idx; + int rc; + + /* + * set up storage for OID + */ + oid_idx.oids = oid_tmp; + oid_idx.len = sizeof(oid_tmp)/sizeof(oid); + + /* + * convert + */ + rc = sessionTable_index_to_oid(&oid_idx, mib_idx); + if (MFD_SUCCESS != rc) + return NULL; + + rowreq_ctx = CONTAINER_FIND(sessionTable_if_ctx.container, &oid_idx); + + return rowreq_ctx; +} + diff --git a/accel-pppd/extra/net-snmp/sessionTable_interface.h b/accel-pppd/extra/net-snmp/sessionTable_interface.h new file mode 100644 index 00000000..ebd1143d --- /dev/null +++ b/accel-pppd/extra/net-snmp/sessionTable_interface.h @@ -0,0 +1,84 @@ +/* + * Note: this file originally auto-generated by mib2c using + * version : 15899 $ of $ + * + * $Id:$ + */ +/** @ingroup interface: Routines to interface to Net-SNMP + * + * \warning This code should not be modified, called directly, + * or used to interpret functionality. It is subject to + * change at any time. + * + * @{ + */ +/* + * ********************************************************************* + * ********************************************************************* + * ********************************************************************* + * *** *** + * *** NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE *** + * *** *** + * *** *** + * *** THIS FILE DOES NOT CONTAIN ANY USER EDITABLE CODE. *** + * *** *** + * *** *** + * *** THE GENERATED CODE IS INTERNAL IMPLEMENTATION, AND *** + * *** *** + * *** *** + * *** IS SUBJECT TO CHANGE WITHOUT WARNING IN FUTURE RELEASES. *** + * *** *** + * *** *** + * ********************************************************************* + * ********************************************************************* + * ********************************************************************* + */ +#ifndef SESSIONTABLE_INTERFACE_H +#define SESSIONTABLE_INTERFACE_H + +#ifdef __cplusplus +extern "C" { +#endif + + +#include "sessionTable.h" + + +/* ******************************************************************** + * Table declarations + */ + +/* PUBLIC interface initialization routine */ +void _sessionTable_initialize_interface(sessionTable_registration * user_ctx, + u_long flags); +void _sessionTable_shutdown_interface(sessionTable_registration * user_ctx); + +sessionTable_registration * +sessionTable_registration_get( void ); + +sessionTable_registration * +sessionTable_registration_set( sessionTable_registration * newreg ); + +netsnmp_container *sessionTable_container_get( void ); +int sessionTable_container_size( void ); + + sessionTable_rowreq_ctx * sessionTable_allocate_rowreq_ctx(sessionTable_data *, void *); +void sessionTable_release_rowreq_ctx(sessionTable_rowreq_ctx *rowreq_ctx); + +int sessionTable_index_to_oid(netsnmp_index *oid_idx, + sessionTable_mib_index *mib_idx); +int sessionTable_index_from_oid(netsnmp_index *oid_idx, + sessionTable_mib_index *mib_idx); + +/* + * access to certain internals. use with caution! + */ +void sessionTable_valid_columns_set(netsnmp_column_info *vc); + + +#ifdef __cplusplus +} +#endif + +#endif /* SESSIONTABLE_INTERFACE_H */ +/** @} */ diff --git a/accel-pppd/extra/net-snmp/sessionTable_oids.h b/accel-pppd/extra/net-snmp/sessionTable_oids.h new file mode 100644 index 00000000..42ec6e53 --- /dev/null +++ b/accel-pppd/extra/net-snmp/sessionTable_oids.h @@ -0,0 +1,46 @@ +/* + * Note: this file originally auto-generated by mib2c using + * : generic-table-oids.m2c 12855 2005-09-27 15:56:08Z rstory $ + * + * $Id:$ + */ +#ifndef SESSIONTABLE_OIDS_H +#define SESSIONTABLE_OIDS_H + +#ifdef __cplusplus +extern "C" { +#endif + + +/* column number definitions for table sessionTable */ +#define SESSIONTABLE_OID 1,3,6,1,4,1,8072,100,2,1 + +#define COLUMN_SESSID 1 + +#define COLUMN_SESIFNAME 2 + +#define COLUMN_SESUSERNAME 3 + +#define COLUMN_SESIP 4 + +#define COLUMN_SESTYPE 5 + +#define COLUMN_SESSTATE 6 + +#define COLUMN_SESUPTIME 7 + +#define COLUMN_SESCALLINGSID 8 + +#define COLUMN_SESCALLEDSID 9 + + +#define SESSIONTABLE_MIN_COL COLUMN_SESSID +#define SESSIONTABLE_MAX_COL COLUMN_SESCALLEDSID + + + +#ifdef __cplusplus +} +#endif + +#endif /* SESSIONTABLE_OIDS_H */ diff --git a/accel-pppd/extra/net-snmp/shutdown.c b/accel-pppd/extra/net-snmp/shutdown.c new file mode 100644 index 00000000..82f85407 --- /dev/null +++ b/accel-pppd/extra/net-snmp/shutdown.c @@ -0,0 +1,88 @@ +/* + * Note: this file originally auto-generated by mib2c using + * : mib2c.scalar.conf 11805 2005-01-07 09:37:18Z dts12 $ + */ + +#include <net-snmp/net-snmp-config.h> +#include <net-snmp/net-snmp-includes.h> +#include <net-snmp/agent/net-snmp-agent-includes.h> +#include "shutdown.h" + +/** Initializes the shutdown module */ +void +init_shutdown(void) +{ + static oid shutdown_oid[] = { 1,3,6,1,4,1,8072,100,3,2 }; + + DEBUGMSGTL(("shutdown", "Initializing\n")); + + netsnmp_register_scalar( + netsnmp_create_handler_registration("shutdown", handle_shutdown, + shutdown_oid, OID_LENGTH(shutdown_oid), + HANDLER_CAN_RWRITE + )); +} + +int +handle_shutdown(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *reqinfo, + netsnmp_request_info *requests) +{ + int ret; + /* We are never called for a GETNEXT if it's registered as a + "instance", as it's "magically" handled for us. */ + + /* a instance handler also only hands us one request at a time, so + we don't need to loop over a list of requests; we'll only get one. */ + + switch(reqinfo->mode) { + + case MODE_GET: + netsnmp_set_request_error(reqinfo, requests, SNMP_NOSUCHINSTANCE ); + break; + + /* + * SET REQUEST + * + * multiple states in the transaction. See: + * http://www.net-snmp.org/tutorial-5/toolkit/mib_module/set-actions.jpg + */ + case MODE_SET_RESERVE1: + /* or you could use netsnmp_check_vb_type_and_size instead */ + ret = netsnmp_check_vb_type(requests->requestvb, ASN_INTEGER); + if ( ret != SNMP_ERR_NOERROR ) { + netsnmp_set_request_error(reqinfo, requests, ret ); + } + break; + + case MODE_SET_RESERVE2: + /* XXX malloc "undo" storage buffer */ + break; + + case MODE_SET_FREE: + /* XXX: free resources allocated in RESERVE1 and/or + RESERVE2. Something failed somewhere, and the states + below won't be called. */ + break; + + case MODE_SET_ACTION: + /* XXX: perform the value change here */ + break; + + case MODE_SET_COMMIT: + /* XXX: delete temporary storage */ + break; + + case MODE_SET_UNDO: + /* XXX: UNDO and return to previous value for the object */ + break; + + default: + /* we should never get here, so this is a really bad error */ + snmp_log(LOG_ERR, "unknown mode (%d) in handle_shutdown\n", reqinfo->mode ); + return SNMP_ERR_GENERR; + } + + return SNMP_ERR_NOERROR; +} diff --git a/accel-pppd/extra/net-snmp/shutdown.h b/accel-pppd/extra/net-snmp/shutdown.h new file mode 100644 index 00000000..02bda945 --- /dev/null +++ b/accel-pppd/extra/net-snmp/shutdown.h @@ -0,0 +1,12 @@ +/* + * Note: this file originally auto-generated by mib2c using + * : mib2c.scalar.conf 11805 2005-01-07 09:37:18Z dts12 $ + */ +#ifndef SHUTDOWN_H +#define SHUTDOWN_H + +/* function declarations */ +void init_shutdown(void); +Netsnmp_Node_Handler handle_shutdown; + +#endif /* SHUTDOWN_H */ diff --git a/accel-pppd/extra/net-snmp/statCore.c b/accel-pppd/extra/net-snmp/statCore.c new file mode 100644 index 00000000..74a6b35b --- /dev/null +++ b/accel-pppd/extra/net-snmp/statCore.c @@ -0,0 +1,147 @@ +/* + * Note: this file originally auto-generated by mib2c using + * : mib2c.scalar.conf 11805 2005-01-07 09:37:18Z dts12 $ + */ + +#include <time.h> + +#include <net-snmp/net-snmp-config.h> +#include <net-snmp/net-snmp-includes.h> +#include <net-snmp/agent/net-snmp-agent-includes.h> + +#include "triton.h" +#include "statCore.h" + +/** Initializes the statCore module */ +void +init_statCore(void) +{ + static oid statCoreUpTime_oid[] = { 1,3,6,1,4,1,8072,100,1,1,1 }; + static oid statCoreCPU_oid[] = { 1,3,6,1,4,1,8072,100,1,1,2 }; + static oid statCoreMemRss_oid[] = { 1,3,6,1,4,1,8072,100,1,1,3 }; + + DEBUGMSGTL(("statCore", "Initializing\n")); + + netsnmp_register_scalar( + netsnmp_create_handler_registration("statCoreUpTime", handle_statCoreUpTime, + statCoreUpTime_oid, OID_LENGTH(statCoreUpTime_oid), + HANDLER_CAN_RONLY + )); + netsnmp_register_scalar( + netsnmp_create_handler_registration("statCoreCPU", handle_statCoreCPU, + statCoreCPU_oid, OID_LENGTH(statCoreCPU_oid), + HANDLER_CAN_RONLY + )); + netsnmp_register_scalar( + netsnmp_create_handler_registration("statCoreMemRss", handle_statCoreMemRss, + statCoreMemRss_oid, OID_LENGTH(statCoreMemRss_oid), + HANDLER_CAN_RONLY + )); +} + +int +handle_statCoreUpTime(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *reqinfo, + netsnmp_request_info *requests) +{ + struct timespec ts; + + clock_gettime(CLOCK_MONOTONIC, &ts); + ts.tv_sec -= triton_stat.start_time; + + /* We are never called for a GETNEXT if it's registered as a + "instance", as it's "magically" handled for us. */ + + /* a instance handler also only hands us one request at a time, so + we don't need to loop over a list of requests; we'll only get one. */ + + switch(reqinfo->mode) { + + case MODE_GET: + snmp_set_var_typed_value(requests->requestvb, ASN_GAUGE, + (u_char *)&ts.tv_sec /* XXX: a pointer to the scalar's data */, + sizeof(ts.tv_sec)/* XXX: the length of the data in bytes */); + break; + + + default: + /* we should never get here, so this is a really bad error */ + snmp_log(LOG_ERR, "unknown mode (%d) in handle_statCoreUpTime\n", reqinfo->mode ); + return SNMP_ERR_GENERR; + } + + return SNMP_ERR_NOERROR; +} +int +handle_statCoreCPU(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *reqinfo, + netsnmp_request_info *requests) +{ + /* We are never called for a GETNEXT if it's registered as a + "instance", as it's "magically" handled for us. */ + + /* a instance handler also only hands us one request at a time, so + we don't need to loop over a list of requests; we'll only get one. */ + + switch(reqinfo->mode) { + + case MODE_GET: + snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER, + (u_char *)&triton_stat.cpu /* XXX: a pointer to the scalar's data */, + sizeof(triton_stat.cpu)/* XXX: the length of the data in bytes */); + break; + + + default: + /* we should never get here, so this is a really bad error */ + snmp_log(LOG_ERR, "unknown mode (%d) in handle_statCoreCPU\n", reqinfo->mode ); + return SNMP_ERR_GENERR; + } + + return SNMP_ERR_NOERROR; +} +int +handle_statCoreMemRss(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *reqinfo, + netsnmp_request_info *requests) +{ + char statm_fname[128]; + FILE *f; + unsigned long vmsize = 0, vmrss = 0; + unsigned long page_size = sysconf(_SC_PAGE_SIZE); + + sprintf(statm_fname, "/proc/%i/statm", getpid()); + f = fopen(statm_fname, "r"); + if (f) { + fscanf(f, "%lu %lu", &vmsize, &vmrss); + fclose(f); + } + + vmrss *= page_size; + + /* We are never called for a GETNEXT if it's registered as a + "instance", as it's "magically" handled for us. */ + + /* a instance handler also only hands us one request at a time, so + we don't need to loop over a list of requests; we'll only get one. */ + + switch(reqinfo->mode) { + + case MODE_GET: + snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER, + (u_char *)&vmrss /* XXX: a pointer to the scalar's data */, + sizeof(vmrss)/* XXX: the length of the data in bytes */); + break; + + + default: + /* we should never get here, so this is a really bad error */ + snmp_log(LOG_ERR, "unknown mode (%d) in handle_statCoreMemRss\n", reqinfo->mode ); + return SNMP_ERR_GENERR; + } + + return SNMP_ERR_NOERROR; +} diff --git a/accel-pppd/extra/net-snmp/statCore.h b/accel-pppd/extra/net-snmp/statCore.h new file mode 100644 index 00000000..1a096854 --- /dev/null +++ b/accel-pppd/extra/net-snmp/statCore.h @@ -0,0 +1,14 @@ +/* + * Note: this file originally auto-generated by mib2c using + * : mib2c.scalar.conf 11805 2005-01-07 09:37:18Z dts12 $ + */ +#ifndef STATCORE_H +#define STATCORE_H + +/* function declarations */ +void init_statCore(void); +Netsnmp_Node_Handler handle_statCoreUpTime; +Netsnmp_Node_Handler handle_statCoreCPU; +Netsnmp_Node_Handler handle_statCoreMemRss; + +#endif /* STATCORE_H */ diff --git a/accel-pppd/extra/net-snmp/statL2TP.c b/accel-pppd/extra/net-snmp/statL2TP.c new file mode 100644 index 00000000..a91d336a --- /dev/null +++ b/accel-pppd/extra/net-snmp/statL2TP.c @@ -0,0 +1,94 @@ +/* + * Note: this file originally auto-generated by mib2c using + * : mib2c.int_watch.conf 13957 2005-12-20 15:33:08Z tanders $ + */ + +#include <net-snmp/net-snmp-config.h> +#include <net-snmp/net-snmp-includes.h> +#include <net-snmp/agent/net-snmp-agent-includes.h> + +#include "triton.h" +#include "statL2TP.h" + + +/* + * The variables we want to tie the relevant OIDs to. + * The agent will handle all GET and (if applicable) SET requests + * to these variables automatically, changing the values as needed. + */ + +void l2tp_get_stat(unsigned int **, unsigned int **); + +static unsigned int *stat_starting; +static unsigned int *stat_active; + +/* + * Our initialization routine, called automatically by the agent + * (Note that the function name must match init_FILENAME()) + */ +void +init_statL2TP(void) +{ + netsnmp_handler_registration *reg; + netsnmp_watcher_info *winfo; + + static oid statL2TPStarting_oid[] = { 1,3,6,1,4,1,8072,100,1,4,1 }; + static oid statL2TPActive_oid[] = { 1,3,6,1,4,1,8072,100,1,4,2 }; + + /* + * a debugging statement. Run the agent with -DstatL2TP to see + * the output of this debugging statement. + */ + DEBUGMSGTL(("statL2TP", "Initializing the statL2TP module\n")); + + if (!triton_module_loaded("l2tp")) + return; + + l2tp_get_stat(&stat_starting, &stat_active); + + /* + * Register scalar watchers for each of the MIB objects. + * The ASN type and RO/RW status are taken from the MIB definition, + * but can be adjusted if needed. + * + * In most circumstances, the scalar watcher will handle all + * of the necessary processing. But the NULL parameter in the + * netsnmp_create_handler_registration() call can be used to + * supply a user-provided handler if necessary. + * + * This approach can also be used to handle Counter64, string- + * and OID-based watched scalars (although variable-sized writeable + * objects will need some more specialised initialisation). + */ + DEBUGMSGTL(("statL2TP", + "Initializing statL2TPStarting scalar integer. Default value = %d\n", + 0)); + reg = netsnmp_create_handler_registration( + "statL2TPStarting", NULL, + statL2TPStarting_oid, OID_LENGTH(statL2TPStarting_oid), + HANDLER_CAN_RONLY); + winfo = netsnmp_create_watcher_info( + stat_starting, sizeof(*stat_starting), + ASN_INTEGER, WATCHER_FIXED_SIZE); + if (netsnmp_register_watched_scalar( reg, winfo ) < 0 ) { + snmp_log( LOG_ERR, "Failed to register watched statL2TPStarting" ); + } + + DEBUGMSGTL(("statL2TP", + "Initializing statL2TPActive scalar integer. Default value = %d\n", + 0)); + reg = netsnmp_create_handler_registration( + "statL2TPActive", NULL, + statL2TPActive_oid, OID_LENGTH(statL2TPActive_oid), + HANDLER_CAN_RONLY); + winfo = netsnmp_create_watcher_info( + stat_active, sizeof(*stat_active), + ASN_INTEGER, WATCHER_FIXED_SIZE); + if (netsnmp_register_watched_scalar( reg, winfo ) < 0 ) { + snmp_log( LOG_ERR, "Failed to register watched statL2TPActive" ); + } + + + DEBUGMSGTL(("statL2TP", + "Done initalizing statL2TP module\n")); +} diff --git a/accel-pppd/extra/net-snmp/statL2TP.h b/accel-pppd/extra/net-snmp/statL2TP.h new file mode 100644 index 00000000..e0389060 --- /dev/null +++ b/accel-pppd/extra/net-snmp/statL2TP.h @@ -0,0 +1,11 @@ +/* + * Note: this file originally auto-generated by mib2c using + * : mib2c.int_watch.conf 13957 2005-12-20 15:33:08Z tanders $ + */ +#ifndef STATL2TP_H +#define STATL2TP_H + +/* function declarations */ +void init_statL2TP(void); + +#endif /* STATL2TP_H */ diff --git a/accel-pppd/extra/net-snmp/statPPP.c b/accel-pppd/extra/net-snmp/statPPP.c new file mode 100644 index 00000000..7199b570 --- /dev/null +++ b/accel-pppd/extra/net-snmp/statPPP.c @@ -0,0 +1,93 @@ +/* + * Note: this file originally auto-generated by mib2c using + * : mib2c.int_watch.conf 13957 2005-12-20 15:33:08Z tanders $ + */ + +#include <net-snmp/net-snmp-config.h> +#include <net-snmp/net-snmp-includes.h> +#include <net-snmp/agent/net-snmp-agent-includes.h> +#include "statPPP.h" + +#include "ppp.h" + +/* + * Our initialization routine, called automatically by the agent + * (Note that the function name must match init_FILENAME()) + */ +void +init_statPPP(void) +{ + netsnmp_handler_registration *reg; + netsnmp_watcher_info *winfo; + + static oid statPPPStarting_oid[] = { 1,3,6,1,4,1,8072,100,1,2,1 }; + static oid statPPPActive_oid[] = { 1,3,6,1,4,1,8072,100,1,2,2 }; + static oid statPPPFinishing_oid[] = { 1,3,6,1,4,1,8072,100,1,2,3 }; + + /* + * a debugging statement. Run the agent with -DstatPPP to see + * the output of this debugging statement. + */ + DEBUGMSGTL(("statPPP", "Initializing the statPPP module\n")); + + + /* + * Register scalar watchers for each of the MIB objects. + * The ASN type and RO/RW status are taken from the MIB definition, + * but can be adjusted if needed. + * + * In most circumstances, the scalar watcher will handle all + * of the necessary processing. But the NULL parameter in the + * netsnmp_create_handler_registration() call can be used to + * supply a user-provided handler if necessary. + * + * This approach can also be used to handle Counter64, string- + * and OID-based watched scalars (although variable-sized writeable + * objects will need some more specialised initialisation). + */ + DEBUGMSGTL(("statPPP", + "Initializing statPPPStarting scalar integer. Default value = %d\n", + 0)); + reg = netsnmp_create_handler_registration( + "statPPPStarting", NULL, + statPPPStarting_oid, OID_LENGTH(statPPPStarting_oid), + HANDLER_CAN_RONLY); + winfo = netsnmp_create_watcher_info( + &ppp_stat.starting, sizeof(ppp_stat.starting), + ASN_INTEGER, WATCHER_FIXED_SIZE); + if (netsnmp_register_watched_scalar( reg, winfo ) < 0 ) { + snmp_log( LOG_ERR, "Failed to register watched statPPPStarting" ); + } + + DEBUGMSGTL(("statPPP", + "Initializing statPPPActive scalar integer. Default value = %d\n", + 0)); + reg = netsnmp_create_handler_registration( + "statPPPActive", NULL, + statPPPActive_oid, OID_LENGTH(statPPPActive_oid), + HANDLER_CAN_RONLY); + winfo = netsnmp_create_watcher_info( + &ppp_stat.active, sizeof(ppp_stat.active), + ASN_INTEGER, WATCHER_FIXED_SIZE); + if (netsnmp_register_watched_scalar( reg, winfo ) < 0 ) { + snmp_log( LOG_ERR, "Failed to register watched statPPPActive" ); + } + + DEBUGMSGTL(("statPPP", + "Initializing statPPPFinishing scalar integer. Default value = %d\n", + 0)); + reg = netsnmp_create_handler_registration( + "statPPPFinishing", NULL, + statPPPFinishing_oid, OID_LENGTH(statPPPFinishing_oid), + HANDLER_CAN_RONLY); + winfo = netsnmp_create_watcher_info( + &ppp_stat.finishing, sizeof(ppp_stat.finishing), + ASN_INTEGER, WATCHER_FIXED_SIZE); + if (netsnmp_register_watched_scalar( reg, winfo ) < 0 ) { + snmp_log( LOG_ERR, "Failed to register watched statPPPFinishing" ); + } + + + DEBUGMSGTL(("statPPP", + "Done initalizing statPPP module\n")); +} diff --git a/accel-pppd/extra/net-snmp/statPPP.h b/accel-pppd/extra/net-snmp/statPPP.h new file mode 100644 index 00000000..15a1bf36 --- /dev/null +++ b/accel-pppd/extra/net-snmp/statPPP.h @@ -0,0 +1,11 @@ +/* + * Note: this file originally auto-generated by mib2c using + * : mib2c.int_watch.conf 13957 2005-12-20 15:33:08Z tanders $ + */ +#ifndef STATPPP_H +#define STATPPP_H + +/* function declarations */ +void init_statPPP(void); + +#endif /* STATPPP_H */ diff --git a/accel-pppd/extra/net-snmp/statPPPOE.c b/accel-pppd/extra/net-snmp/statPPPOE.c new file mode 100644 index 00000000..0ca2dd86 --- /dev/null +++ b/accel-pppd/extra/net-snmp/statPPPOE.c @@ -0,0 +1,93 @@ +/* + * Note: this file originally auto-generated by mib2c using + * : mib2c.int_watch.conf 13957 2005-12-20 15:33:08Z tanders $ + */ + +#include <net-snmp/net-snmp-config.h> +#include <net-snmp/net-snmp-includes.h> +#include <net-snmp/agent/net-snmp-agent-includes.h> + +#include "triton.h" +#include "statPPPOE.h" + +/* + * The variables we want to tie the relevant OIDs to. + * The agent will handle all GET and (if applicable) SET requests + * to these variables automatically, changing the values as needed. + */ + +void pppoe_get_stat(unsigned int **, unsigned int **); + +static unsigned int *stat_starting; +static unsigned int *stat_active; + +/* + * Our initialization routine, called automatically by the agent + * (Note that the function name must match init_FILENAME()) + */ +void +init_statPPPOE(void) +{ + netsnmp_handler_registration *reg; + netsnmp_watcher_info *winfo; + + static oid statPPPOEStarting_oid[] = { 1,3,6,1,4,1,8072,100,1,5,1 }; + static oid statPPPOEActive_oid[] = { 1,3,6,1,4,1,8072,100,1,5,2 }; + + /* + * a debugging statement. Run the agent with -DstatPPPOE to see + * the output of this debugging statement. + */ + DEBUGMSGTL(("statPPPOE", "Initializing the statPPPOE module\n")); + + if (!triton_module_loaded("pppoe")) + return; + + pppoe_get_stat(&stat_starting, &stat_active); + + /* + * Register scalar watchers for each of the MIB objects. + * The ASN type and RO/RW status are taken from the MIB definition, + * but can be adjusted if needed. + * + * In most circumstances, the scalar watcher will handle all + * of the necessary processing. But the NULL parameter in the + * netsnmp_create_handler_registration() call can be used to + * supply a user-provided handler if necessary. + * + * This approach can also be used to handle Counter64, string- + * and OID-based watched scalars (although variable-sized writeable + * objects will need some more specialised initialisation). + */ + DEBUGMSGTL(("statPPPOE", + "Initializing statPPPOEStarting scalar integer. Default value = %d\n", + 0)); + reg = netsnmp_create_handler_registration( + "statPPPOEStarting", NULL, + statPPPOEStarting_oid, OID_LENGTH(statPPPOEStarting_oid), + HANDLER_CAN_RONLY); + winfo = netsnmp_create_watcher_info( + stat_starting, sizeof(*stat_starting), + ASN_INTEGER, WATCHER_FIXED_SIZE); + if (netsnmp_register_watched_scalar( reg, winfo ) < 0 ) { + snmp_log( LOG_ERR, "Failed to register watched statPPPOEStarting" ); + } + + DEBUGMSGTL(("statPPPOE", + "Initializing statPPPOEActive scalar integer. Default value = %d\n", + 0)); + reg = netsnmp_create_handler_registration( + "statPPPOEActive", NULL, + statPPPOEActive_oid, OID_LENGTH(statPPPOEActive_oid), + HANDLER_CAN_RONLY); + winfo = netsnmp_create_watcher_info( + stat_active, sizeof(*stat_active), + ASN_INTEGER, WATCHER_FIXED_SIZE); + if (netsnmp_register_watched_scalar( reg, winfo ) < 0 ) { + snmp_log( LOG_ERR, "Failed to register watched statPPPOEActive" ); + } + + + DEBUGMSGTL(("statPPPOE", + "Done initalizing statPPPOE module\n")); +} diff --git a/accel-pppd/extra/net-snmp/statPPPOE.h b/accel-pppd/extra/net-snmp/statPPPOE.h new file mode 100644 index 00000000..bb0bcc0b --- /dev/null +++ b/accel-pppd/extra/net-snmp/statPPPOE.h @@ -0,0 +1,11 @@ +/* + * Note: this file originally auto-generated by mib2c using + * : mib2c.int_watch.conf 13957 2005-12-20 15:33:08Z tanders $ + */ +#ifndef STATPPPOE_H +#define STATPPPOE_H + +/* function declarations */ +void init_statPPPOE(void); + +#endif /* STATPPPOE_H */ diff --git a/accel-pppd/extra/net-snmp/statPPTP.c b/accel-pppd/extra/net-snmp/statPPTP.c new file mode 100644 index 00000000..1a13ad06 --- /dev/null +++ b/accel-pppd/extra/net-snmp/statPPTP.c @@ -0,0 +1,92 @@ +/* + * Note: this file originally auto-generated by mib2c using + * : mib2c.int_watch.conf 13957 2005-12-20 15:33:08Z tanders $ + */ + +#include <net-snmp/net-snmp-config.h> +#include <net-snmp/net-snmp-includes.h> +#include <net-snmp/agent/net-snmp-agent-includes.h> +#include "statPPTP.h" + +#include "triton.h" + +/* + * The variables we want to tie the relevant OIDs to. + * The agent will handle all GET and (if applicable) SET requests + * to these variables automatically, changing the values as needed. + */ + +void pptp_get_stat(unsigned int **, unsigned int **); + +static unsigned int *stat_starting; +static unsigned int *stat_active; + +/* + * Our initialization routine, called automatically by the agent + * (Note that the function name must match init_FILENAME()) + */ +void +init_statPPTP(void) +{ + netsnmp_handler_registration *reg; + netsnmp_watcher_info *winfo; + + static oid statPPTPStarting_oid[] = { 1,3,6,1,4,1,8072,100,1,3,1 }; + static oid statPPTPActive_oid[] = { 1,3,6,1,4,1,8072,100,1,3,2 }; + + /* + * a debugging statement. Run the agent with -DstatPPTP to see + * the output of this debugging statement. + */ + DEBUGMSGTL(("statPPTP", "Initializing the statPPTP module\n")); + + if (!triton_module_loaded("pptp")) + return; + + pptp_get_stat(&stat_starting, &stat_active); + /* + * Register scalar watchers for each of the MIB objects. + * The ASN type and RO/RW status are taken from the MIB definition, + * but can be adjusted if needed. + * + * In most circumstances, the scalar watcher will handle all + * of the necessary processing. But the NULL parameter in the + * netsnmp_create_handler_registration() call can be used to + * supply a user-provided handler if necessary. + * + * This approach can also be used to handle Counter64, string- + * and OID-based watched scalars (although variable-sized writeable + * objects will need some more specialised initialisation). + */ + DEBUGMSGTL(("statPPTP", + "Initializing statPPTPStarting scalar integer. Default value = %d\n", + 0)); + reg = netsnmp_create_handler_registration( + "statPPTPStarting", NULL, + statPPTPStarting_oid, OID_LENGTH(statPPTPStarting_oid), + HANDLER_CAN_RONLY); + winfo = netsnmp_create_watcher_info( + stat_starting, sizeof(*stat_starting), + ASN_INTEGER, WATCHER_FIXED_SIZE); + if (netsnmp_register_watched_scalar( reg, winfo ) < 0 ) { + snmp_log( LOG_ERR, "Failed to register watched statPPTPStarting" ); + } + + DEBUGMSGTL(("statPPTP", + "Initializing statPPTPActive scalar integer. Default value = %d\n", + 0)); + reg = netsnmp_create_handler_registration( + "statPPTPActive", NULL, + statPPTPActive_oid, OID_LENGTH(statPPTPActive_oid), + HANDLER_CAN_RONLY); + winfo = netsnmp_create_watcher_info( + stat_active, sizeof(*stat_active), + ASN_INTEGER, WATCHER_FIXED_SIZE); + if (netsnmp_register_watched_scalar( reg, winfo ) < 0 ) { + snmp_log( LOG_ERR, "Failed to register watched statPPTPActive" ); + } + + + DEBUGMSGTL(("statPPTP", + "Done initalizing statPPTP module\n")); +} diff --git a/accel-pppd/extra/net-snmp/statPPTP.h b/accel-pppd/extra/net-snmp/statPPTP.h new file mode 100644 index 00000000..d3a9e0ac --- /dev/null +++ b/accel-pppd/extra/net-snmp/statPPTP.h @@ -0,0 +1,11 @@ +/* + * Note: this file originally auto-generated by mib2c using + * : mib2c.int_watch.conf 13957 2005-12-20 15:33:08Z tanders $ + */ +#ifndef STATPPTP_H +#define STATPPTP_H + +/* function declarations */ +void init_statPPTP(void); + +#endif /* STATPPTP_H */ diff --git a/accel-pppd/extra/net-snmp/terminate.c b/accel-pppd/extra/net-snmp/terminate.c new file mode 100644 index 00000000..bd385772 --- /dev/null +++ b/accel-pppd/extra/net-snmp/terminate.c @@ -0,0 +1,379 @@ +/* + * Note: this file originally auto-generated by mib2c using + * : mib2c.scalar.conf 11805 2005-01-07 09:37:18Z dts12 $ + */ + +#include <netinet/in.h> +#include <arpa/inet.h> + +#include <net-snmp/net-snmp-config.h> +#include <net-snmp/net-snmp-includes.h> +#include <net-snmp/agent/net-snmp-agent-includes.h> + +#include "triton.h" +#include "ppp.h" + +#include "terminate.h" + +static void __terminate(struct ppp_t *ppp) +{ + ppp_terminate(ppp, TERM_ADMIN_RESET, 0); +} + +static void terminate_by_sid(const char *val) +{ + struct ppp_t *ppp; + + pthread_rwlock_rdlock(&ppp_lock); + list_for_each_entry(ppp, &ppp_list, entry) { + if (strncmp(ppp->sessionid, val, PPP_SESSIONID_LEN)) + continue; + triton_context_call(ppp->ctrl->ctx, (triton_event_func)__terminate, ppp); + break; + } + pthread_rwlock_unlock(&ppp_lock); +} + +static void terminate_by_ifname(const char *val, size_t len) +{ + struct ppp_t *ppp; + size_t n; + + pthread_rwlock_rdlock(&ppp_lock); + list_for_each_entry(ppp, &ppp_list, entry) { + n = strlen(ppp->ifname); + if (n != len) + continue; + if (strncmp(ppp->ifname, val, len)) + continue; + triton_context_call(ppp->ctrl->ctx, (triton_event_func)__terminate, ppp); + break; + } + pthread_rwlock_unlock(&ppp_lock); +} + +static void terminate_by_ip(const char *val, size_t len) +{ + char str[len + 1]; + in_addr_t addr; + struct ppp_t *ppp; + + strncpy(str, val, len); + str[len] = 0; + + addr = inet_addr(str); + + pthread_rwlock_rdlock(&ppp_lock); + list_for_each_entry(ppp, &ppp_list, entry) { + if (ppp->peer_ipaddr != addr) + continue; + triton_context_call(ppp->ctrl->ctx, (triton_event_func)__terminate, ppp); + break; + } + pthread_rwlock_unlock(&ppp_lock); +} + +static void terminate_by_username(const char *val, size_t len) +{ + struct ppp_t *ppp; + size_t n; + + pthread_rwlock_rdlock(&ppp_lock); + list_for_each_entry(ppp, &ppp_list, entry) { + if (!ppp->username) + continue; + n = strlen(ppp->username); + if (n != len) + continue; + if (strncmp(ppp->username, val, len)) + continue; + triton_context_call(ppp->ctrl->ctx, (triton_event_func)__terminate, ppp); + } + pthread_rwlock_unlock(&ppp_lock); +} + + +/** Initializes the terminate module */ +void +init_terminate(void) +{ + static oid termBySID_oid[] = { 1,3,6,1,4,1,8072,100,3,1,1 }; + static oid termByIfName_oid[] = { 1,3,6,1,4,1,8072,100,3,1,2 }; + static oid termByIP_oid[] = { 1,3,6,1,4,1,8072,100,3,1,3 }; + static oid termByUsername_oid[] = { 1,3,6,1,4,1,8072,100,3,1,4 }; + + DEBUGMSGTL(("terminate", "Initializing\n")); + + netsnmp_register_scalar( + netsnmp_create_handler_registration("termBySID", handle_termBySID, + termBySID_oid, OID_LENGTH(termBySID_oid), + HANDLER_CAN_RWRITE + )); + netsnmp_register_scalar( + netsnmp_create_handler_registration("termByIfName", handle_termByIfName, + termByIfName_oid, OID_LENGTH(termByIfName_oid), + HANDLER_CAN_RWRITE + )); + netsnmp_register_scalar( + netsnmp_create_handler_registration("termByIP", handle_termByIP, + termByIP_oid, OID_LENGTH(termByIP_oid), + HANDLER_CAN_RWRITE + )); + netsnmp_register_scalar( + netsnmp_create_handler_registration("termByUsername", handle_termByUsername, + termByUsername_oid, OID_LENGTH(termByUsername_oid), + HANDLER_CAN_RWRITE + )); +} + +int +handle_termBySID(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *reqinfo, + netsnmp_request_info *requests) +{ + int ret; + /* We are never called for a GETNEXT if it's registered as a + "instance", as it's "magically" handled for us. */ + + /* a instance handler also only hands us one request at a time, so + we don't need to loop over a list of requests; we'll only get one. */ + + switch(reqinfo->mode) { + + case MODE_GET: + netsnmp_set_request_error(reqinfo, requests, SNMP_NOSUCHINSTANCE ); + break; + + /* + * SET REQUEST + * + * multiple states in the transaction. See: + * http://www.net-snmp.org/tutorial-5/toolkit/mib_module/set-actions.jpg + */ + case MODE_SET_RESERVE1: + /* or you could use netsnmp_check_vb_type_and_size instead */ + ret = netsnmp_check_vb_type_and_size(requests->requestvb, ASN_OCTET_STR, PPP_SESSIONID_LEN); + if ( ret != SNMP_ERR_NOERROR ) { + netsnmp_set_request_error(reqinfo, requests, ret ); + } + break; + + case MODE_SET_RESERVE2: + break; + + case MODE_SET_FREE: + /* XXX: free resources allocated in RESERVE1 and/or + RESERVE2. Something failed somewhere, and the states + below won't be called. */ + break; + + case MODE_SET_ACTION: + terminate_by_sid((char *)requests->requestvb->val.string); + /* XXX: perform the value change here */ + break; + + case MODE_SET_COMMIT: + break; + + case MODE_SET_UNDO: + break; + + default: + /* we should never get here, so this is a really bad error */ + snmp_log(LOG_ERR, "unknown mode (%d) in handle_termBySID\n", reqinfo->mode ); + return SNMP_ERR_GENERR; + } + + return SNMP_ERR_NOERROR; +} +int +handle_termByIfName(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *reqinfo, + netsnmp_request_info *requests) +{ + int ret; + /* We are never called for a GETNEXT if it's registered as a + "instance", as it's "magically" handled for us. */ + + /* a instance handler also only hands us one request at a time, so + we don't need to loop over a list of requests; we'll only get one. */ + + switch(reqinfo->mode) { + + case MODE_GET: + netsnmp_set_request_error(reqinfo, requests, SNMP_NOSUCHINSTANCE ); + break; + + /* + * SET REQUEST + * + * multiple states in the transaction. See: + * http://www.net-snmp.org/tutorial-5/toolkit/mib_module/set-actions.jpg + */ + case MODE_SET_RESERVE1: + /* or you could use netsnmp_check_vb_type_and_size instead */ + ret = netsnmp_check_vb_type(requests->requestvb, ASN_OCTET_STR); + if ( ret != SNMP_ERR_NOERROR ) { + netsnmp_set_request_error(reqinfo, requests, ret ); + } + break; + + case MODE_SET_RESERVE2: + /* XXX malloc "undo" storage buffer */ + break; + + case MODE_SET_FREE: + /* XXX: free resources allocated in RESERVE1 and/or + RESERVE2. Something failed somewhere, and the states + below won't be called. */ + break; + + case MODE_SET_ACTION: + terminate_by_ifname((char *)requests->requestvb->val.string, requests->requestvb->val_len); + /* XXX: perform the value change here */ + break; + + case MODE_SET_COMMIT: + break; + + case MODE_SET_UNDO: + break; + + default: + /* we should never get here, so this is a really bad error */ + snmp_log(LOG_ERR, "unknown mode (%d) in handle_termByIfName\n", reqinfo->mode ); + return SNMP_ERR_GENERR; + } + + return SNMP_ERR_NOERROR; +} +int +handle_termByIP(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *reqinfo, + netsnmp_request_info *requests) +{ + int ret; + /* We are never called for a GETNEXT if it's registered as a + "instance", as it's "magically" handled for us. */ + + /* a instance handler also only hands us one request at a time, so + we don't need to loop over a list of requests; we'll only get one. */ + + switch(reqinfo->mode) { + + case MODE_GET: + netsnmp_set_request_error(reqinfo, requests, SNMP_NOSUCHINSTANCE ); + break; + + /* + * SET REQUEST + * + * multiple states in the transaction. See: + * http://www.net-snmp.org/tutorial-5/toolkit/mib_module/set-actions.jpg + */ + case MODE_SET_RESERVE1: + /* or you could use netsnmp_check_vb_type_and_size instead */ + ret = netsnmp_check_vb_type(requests->requestvb, ASN_OCTET_STR); + if ( ret != SNMP_ERR_NOERROR ) { + netsnmp_set_request_error(reqinfo, requests, ret ); + } + break; + + case MODE_SET_RESERVE2: + /* XXX malloc "undo" storage buffer */ + break; + + case MODE_SET_FREE: + /* XXX: free resources allocated in RESERVE1 and/or + RESERVE2. Something failed somewhere, and the states + below won't be called. */ + break; + + case MODE_SET_ACTION: + terminate_by_ip((char *)requests->requestvb->val.string, requests->requestvb->val_len); + /* XXX: perform the value change here */ + break; + + case MODE_SET_COMMIT: + /* XXX: delete temporary storage */ + break; + + case MODE_SET_UNDO: + /* XXX: UNDO and return to previous value for the object */ + break; + + default: + /* we should never get here, so this is a really bad error */ + snmp_log(LOG_ERR, "unknown mode (%d) in handle_termByIP\n", reqinfo->mode ); + return SNMP_ERR_GENERR; + } + + return SNMP_ERR_NOERROR; +} +int +handle_termByUsername(netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *reqinfo, + netsnmp_request_info *requests) +{ + int ret; + /* We are never called for a GETNEXT if it's registered as a + "instance", as it's "magically" handled for us. */ + + /* a instance handler also only hands us one request at a time, so + we don't need to loop over a list of requests; we'll only get one. */ + + switch(reqinfo->mode) { + + case MODE_GET: + netsnmp_set_request_error(reqinfo, requests, SNMP_NOSUCHINSTANCE ); + break; + + /* + * SET REQUEST + * + * multiple states in the transaction. See: + * http://www.net-snmp.org/tutorial-5/toolkit/mib_module/set-actions.jpg + */ + case MODE_SET_RESERVE1: + /* or you could use netsnmp_check_vb_type_and_size instead */ + ret = netsnmp_check_vb_type(requests->requestvb, ASN_OCTET_STR); + if ( ret != SNMP_ERR_NOERROR ) { + netsnmp_set_request_error(reqinfo, requests, ret ); + } + break; + + case MODE_SET_RESERVE2: + /* XXX malloc "undo" storage buffer */ + break; + + case MODE_SET_FREE: + /* XXX: free resources allocated in RESERVE1 and/or + RESERVE2. Something failed somewhere, and the states + below won't be called. */ + break; + + case MODE_SET_ACTION: + terminate_by_username((char *)requests->requestvb->val.string, requests->requestvb->val_len); + /* XXX: perform the value change here */ + break; + + case MODE_SET_COMMIT: + /* XXX: delete temporary storage */ + break; + + case MODE_SET_UNDO: + /* XXX: UNDO and return to previous value for the object */ + break; + + default: + /* we should never get here, so this is a really bad error */ + snmp_log(LOG_ERR, "unknown mode (%d) in handle_termByUsername\n", reqinfo->mode ); + return SNMP_ERR_GENERR; + } + + return SNMP_ERR_NOERROR; +} diff --git a/accel-pppd/extra/net-snmp/terminate.h b/accel-pppd/extra/net-snmp/terminate.h new file mode 100644 index 00000000..70131823 --- /dev/null +++ b/accel-pppd/extra/net-snmp/terminate.h @@ -0,0 +1,15 @@ +/* + * Note: this file originally auto-generated by mib2c using + * : mib2c.scalar.conf 11805 2005-01-07 09:37:18Z dts12 $ + */ +#ifndef TERMINATE_H +#define TERMINATE_H + +/* function declarations */ +void init_terminate(void); +Netsnmp_Node_Handler handle_termBySID; +Netsnmp_Node_Handler handle_termByIfName; +Netsnmp_Node_Handler handle_termByIP; +Netsnmp_Node_Handler handle_termByUsername; + +#endif /* TERMINATE_H */ |