--- /dev/null
+/*!
+ * @file mibdata.h
+ * @brief mibdata module.
+ *
+ * L7VSD: Linux Virtual Server for Layer7 Load Balancing
+ * Copyright (C) 2010 NTT COMWARE Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ **********************************************************************/
+#ifndef __MIBDATA_H__
+#define __MIBDATA_H__
+
+#include "error_code.h"
+#include "l7vsd.h"
+#include "snmp_info.h"
+#include <vector>
+#include <net-snmp/net-snmp-config.h>
+#include <net-snmp/net-snmp-includes.h>
+#include <net-snmp/agent/net-snmp-agent-includes.h>
+
+#define L7VS_IPADDR_LEN (128)
+
+namespace l7vs
+{
+
+//! @class mibdata
+//! @brief this class is mib data cache class.
+ class mibdata : private boost::noncopyable
+ {
+ protected:
+ netsnmp_table_data_set* vs_table;
+ netsnmp_table_data_set* rs_table;
+ int vs_table_size;
+ int rs_table_size;
+ int replication_state;
+
+ mibdata() {};
+ ~mibdata() {};
+ mibdata(const mibdata &);
+ mibdata& operator=(const mibdata &);
+
+ /*!
+ * update virtual service table infomation.
+ *
+ * @param l7vsd * l7vsd pointer
+ * @param error_code & error code
+ * @retrun void
+ */
+ void update_vs_table(l7vsd *, error_code &);
+
+ /*!
+ * update real server table infomation.
+ *
+ * @param const std::vector<rsdata> & temporary real server list
+ * @param error_code & error code
+ * @retrun void
+ */
+ void update_rs_table(const std::vector<rsdata> &, error_code &);
+
+ /*!
+ * update replication state.
+ *
+ * @param l7vsd * l7vsd pointer
+ * @param error_code & error code
+ * @retrun void
+ */
+ void update_replication_state(l7vsd *, error_code &);
+
+ public:
+ /*!
+ * get mibdata instance.
+ *
+ * @retrun mibdata instance
+ */
+ static mibdata& get_instance();
+
+ /*!
+ * collect mibdata in l7vsd.
+ *
+ * @param l7vsd * l7vsd pointer
+ * @param error_code & error code
+ * @retrun void
+ */
+ void collect_mibdata(l7vsd *, error_code &);
+
+ /*!
+ * set virtual service data set.
+ *
+ * @param netsnmp_table_data_set * virtual service data set
+ * @retrun void
+ */
+ void set_vs_table(netsnmp_table_data_set *);
+
+ /*!
+ * set real server data set.
+ *
+ * @param netsnmp_table_data_set * real server data set
+ * @retrun void
+ */
+ void set_rs_table(netsnmp_table_data_set *);
+
+ /*!
+ * get virtual service table size
+ *
+ * @retrun int virtual service table size
+ */
+ inline int get_vs_table_size() {
+ return vs_table_size;
+ }
+
+ /*!
+ * get replication state.
+ *
+ * @retrun int replication state
+ */
+ inline int get_replication_state() {
+ return replication_state;
+ }
+ };
+}
+
+#endif //__MIBDATA_H__
--- /dev/null
+/*!
+ * @file snmp_info.h
+ * @brief snmp function common header.
+ *
+ * L7VSD: Linux Virtual Server for Layer7 Load Balancing
+ * Copyright (C) 2010 NTT COMWARE Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+#ifndef __SNMP_INFO_H__
+#define __SNMP_INFO_H__
+
+
+#include<boost/asio.hpp>
+#include <time.h>
+#include "logger.h"
+
+namespace l7vs
+{
+
+ struct snmp_info {
+ enum SNMP_OPTION_FLAG_TAG {
+ SNMP_ENABLE_OPTION_FLAG = 0x0001,
+ SNMP_LOGTRAP_OPTION_FLAG = 0x0002,
+ SNMP_LOGTRAP_LEVEL_OPTION_FLAG = 0x0004,
+ SNMP_INTERVAL_OPTION_FLAG = 0x0008,
+ SNMP_REFRESH_OPTION_FLAG = 0x0010,
+ SNMP_REFRESH_ALL_OPTION_FLAG = 0x0020,
+ SNMP_TCP_SERVICE_OPTION_FLAG = 0x0040,
+ SNMP_PROTOCOL_MODULE_OPTION_FLAG = 0x0080
+ };
+ unsigned int enabled;
+ unsigned int logtrap_enabled;
+ LOG_LEVEL_TAG logtrap_level;
+ unsigned int interval;
+ time_t start_date;
+ time_t request_last_date;
+ time_t trap_last_date;
+ unsigned long long snmp_get_requests;
+ unsigned long long snmp_set_requests;
+ unsigned long long snmp_trap_count;
+ boost::asio::ip::tcp::endpoint vs_endpoint;
+ std::string protocol;
+ int option_set_flag;
+
+ snmp_info() : enabled(0), logtrap_enabled(0), logtrap_level(LOG_LV_NONE),
+ interval(0), start_date(0),
+ request_last_date(0), trap_last_date(0),
+ snmp_get_requests(0ull), snmp_set_requests(0ull), snmp_trap_count(0ull),option_set_flag(0) {}
+ snmp_info(const snmp_info &in)
+ : enabled(in.enabled),
+ logtrap_enabled(in.logtrap_enabled),
+ logtrap_level(in.logtrap_level),
+ interval(in.interval),
+ start_date(in.start_date),
+ request_last_date(in.request_last_date),
+ trap_last_date(in.trap_last_date),
+ snmp_get_requests(in.snmp_get_requests),
+ snmp_set_requests(in.snmp_set_requests),
+ snmp_trap_count(in.snmp_trap_count),
+ vs_endpoint(in.vs_endpoint),
+ protocol(in.protocol),
+ option_set_flag(in.option_set_flag) {}
+ snmp_info &operator=(const snmp_info &in) {
+ enabled = in.enabled;
+ logtrap_enabled = in.logtrap_enabled;
+ logtrap_level = in.logtrap_level;
+ interval = in.interval;
+ start_date = in.start_date;
+ request_last_date = in.request_last_date;
+ trap_last_date = in.trap_last_date;
+ snmp_get_requests = in.snmp_get_requests;
+ snmp_set_requests = in.snmp_set_requests;
+ snmp_trap_count = in.snmp_trap_count;
+ vs_endpoint = in.vs_endpoint;
+ protocol = in.protocol;
+ option_set_flag = in.option_set_flag;
+
+ return *this;
+ }
+ template <typename Elem, typename Traits>
+ friend std::basic_ostream<Elem, Traits>& operator<<(
+ std::basic_ostream<Elem, Traits>& os,
+ const snmp_info &info) {
+ static const int MAX_TIME_LEN = 20;
+ char start_date[MAX_TIME_LEN] = {0};
+ char request_last_date[MAX_TIME_LEN] = {0};
+ char trap_last_date[MAX_TIME_LEN] = {0};
+ strftime(start_date, sizeof(start_date),
+ "%Y-%m-%d %H:%M:%S", gmtime(&(info.start_date)));
+ strftime(request_last_date, sizeof(request_last_date),
+ "%Y-%m-%d %H:%M:%S", gmtime(&(info.request_last_date)));
+ strftime(trap_last_date, sizeof(trap_last_date),
+ "%Y-%m-%d %H:%M:%S", gmtime(&(info.trap_last_date)));
+
+ os << "{";
+ os << boost::format("flag=%d; "
+ "logtrap=%d; "
+ "logtrap_level=%s; "
+ "interval=%d; "
+ "start_date=%s; "
+ "request_last_date = %s; "
+ "trap_last_date = %s ;"
+ "snmp_get_requests = %d ;"
+ "snmp_set_requests = %d ;"
+ "snmp_trap_count= %d; "
+ "vs_endpoint= %s:%d; "
+ "protocol = %s; "
+ "option_set_flag = %x }")
+ % info.enabled
+ % info.logtrap_enabled
+ % info.logtrap_level
+ % info.interval
+ % (info.start_date == 0 ? "none" : start_date)
+ % (info.request_last_date == 0 ? "none" : request_last_date)
+ % (info.trap_last_date == 0 ? "none" : trap_last_date)
+ % info.snmp_get_requests
+ % info.snmp_set_requests
+ % info.snmp_trap_count
+ % info.vs_endpoint.address().to_string()
+ % info.vs_endpoint.port()
+ % info.protocol
+ % info.option_set_flag;
+ return os;
+
+ }
+private:
+ friend class boost::serialization::access;
+ template <class Archive > void serialize(Archive &ar, const unsigned int version) {
+ ar & enabled;
+ ar & logtrap_enabled;
+ ar & logtrap_level;
+ ar & interval;
+ ar & start_date;
+ ar & request_last_date;
+ ar & trap_last_date;
+ ar & snmp_get_requests;
+ ar & snmp_set_requests;
+ ar & snmp_trap_count;
+ ar & vs_endpoint;
+ ar & protocol;
+ ar & option_set_flag;
+
+ }
+
+ };
+
+ struct rsdata {
+ int index;
+ int vs_index;
+ int address_type;
+ char address[128];
+ int port;
+ int forward;
+ int weigth;
+ int active_conn;
+ int inactive_conn;
+ };
+
+}
+
+#endif //__SNMP_INFO_H__
+
--- /dev/null
+/*!
+ * @file snmpagent.h
+ * @brief snmpagent module.
+ *
+ * L7VSD: Linux Virtual Server for Layer7 Load Balancing
+ * Copyright (C) 2010 NTT COMWARE Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ **********************************************************************/
+#ifndef __SNMPAGENT_H__
+#define __SNMPAGENT_H__
+
+#include "l7vsd.h"
+#include "snmpagent_impl.h"
+
+namespace l7vs
+{
+
+//! @class snmpagent
+//! @brief this class is snmpagent class.
+ class snmpagent : private boost::noncopyable
+ {
+ public:
+ /*!
+ * constructor.
+ *
+ * @param[in] l7vsd pointer
+ */
+ snmpagent(l7vsd *);
+
+ /*!
+ * destructor.
+ *
+ */
+ ~snmpagent() {};
+
+ /*!
+ * push the trap message into trap message queue.
+ *
+ * @param[in] in_trapmessage is trap message
+ * @param[in/out] err is error code
+ * @retrun void
+ */
+ static void push_trapmessage(trapmessage &in_trapmessage, error_code& err);
+
+ /*!
+ * set snmp function enable
+ *
+ * @retrun void
+ */
+ static void enable();
+
+ /*!
+ * set snmp function disable
+ *
+ * @retrun void
+ */
+ static void disable();
+
+ /*!
+ * set mib cache update interval.
+ *
+ * @param[in] in_interval is cache update interval
+ * @retrun void
+ */
+ static void set_interval(const unsigned int in_interval);
+
+ /*!
+ * set log trap enable
+ * @retrun void
+ */
+ static void logtrap_enable();
+
+ /*!
+ * set log trap disable
+ * @retrun void
+ */
+ static void logtrap_disable();
+
+ /*!
+ * set log trap level.
+ *
+ * @param[in] in_level is log trap level
+ * @retrun void
+ */
+ static void set_logtrap_level(const LOG_LEVEL_TAG in_level);
+
+ /*!
+ * get snmp infomation.
+ *
+ * @return snmp infomation
+ */
+ static snmp_info get_snmp_info();
+
+ /*!
+ * start snmp function.
+ *
+ * @param[in/out] error_code is error code
+ * @return void
+ */
+ static void start(error_code&);
+
+ /*!
+ * stop snmp function.
+ *
+ * @return void
+ */
+ static void stop();
+
+ /*!
+ * refresh all the statistics.
+ *
+ * @return void
+ */
+ static void refresh_all_statistics();
+
+ /*!
+ * refresh a special virtual service's statistics.
+ *
+ * @param[in] vs_endpoint is virtual service's endpoint
+ * @param[in] protocol is virtual service's protocol
+ * @return void
+ */
+ static void refresh_statistics(const boost::asio::ip::tcp::endpoint &vs_endpoint,
+ const std::string &protocol);
+ /*!
+ * finalize.
+ *
+ * @return void
+ */
+ void finalize();
+ protected:
+ /*!
+ * constructor.
+ *
+ */
+ snmpagent(){};
+
+ };
+}
+
+#endif //__SUBAGENT_H__
--- /dev/null
+/*!
+ * @file snmpagent_impl.h
+ * @brief snmpagent implement module.
+ *
+ * L7VSD: Linux Virtual Server for Layer7 Load Balancing
+ * Copyright (C) 2010 NTT COMWARE Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ **********************************************************************/
+#ifndef __SNMPAGENT_IMPL_H__
+#define __SNMPAGENT_IMPL_H__
+
+#include "l7vsd.h"
+#include "snmp_info.h"
+#include <boost/thread.hpp>
+#include <boost/thread/mutex.hpp>
+#include <map>
+#include <list>
+#include <time.h>
+#include <deque>
+#include "error_code.h"
+#include "boost/date_time/posix_time/posix_time.hpp"
+
+namespace l7vs
+{
+
+//! @class snmpagent_impl
+//! @brief this class is snmpagent implement class.
+ class snmpagent_impl : private boost::noncopyable
+ {
+
+ public:
+
+ //! trap function type
+ typedef int trapfunc(const std::string&);
+
+ //!trap function map type
+ typedef std::map<trapmessage::TRAP_TYPE_TAG, trapfunc*> trapfunc_type;
+
+ //!string log level map type
+ typedef std::map<std::string, LOG_LEVEL_TAG> string_loglevel_map_type;
+ protected:
+ bool initialized;
+ bool start_flag;
+ l7vsd *vsd;
+ trapfunc_type trapfunc_map;
+ atomic<unsigned int> trap_polling_interval;
+ atomic<unsigned int> trap_queue_max_size;
+ atomic<unsigned int> enabled;
+ unsigned int logtrap_enabled;
+ LOG_LEVEL_TAG logtrap_level;
+ atomic<unsigned int> interval;
+ atomic<time_t> start_date;
+ atomic<time_t> request_last_date;
+ atomic<time_t> trap_last_date;
+ atomic<unsigned long long> snmp_get_requests;
+ atomic<unsigned long long> snmp_set_requests;
+ atomic<unsigned long long> snmp_trap_count;
+ std::deque<trapmessage> trap_msg_queue;
+ boost::condition trap_msg_queue_condition;
+ boost::mutex trap_msg_queue_condition_mutex;
+ string_loglevel_map_type string_loglevel_map;
+ boost::posix_time::ptime mib_collect_last_time;
+ boost::thread trap_thread;
+ boost::thread process_mib_thread;
+
+ snmpagent_impl() {};
+ ~snmpagent_impl() {};
+ snmpagent_impl(const snmpagent_impl&);
+ snmpagent_impl& operator=(const snmpagent_impl &);
+
+ /*!
+ * process mib get item thread function.
+ *
+ * @retrun void
+ */
+ void process_mib_run();
+
+ /*!
+ * process trap thread function.
+ *
+ * @retrun void
+ */
+ void trap_run();
+
+ /*!
+ * check mib data timeout.
+ *
+ * @retrun void
+ */
+ bool check_timeout();
+
+ /*!
+ * load configure file setting.
+ *
+ * @retrun void
+ */
+ void load_config();
+
+ public:
+
+ /*!
+ * create and return a snmpagent_impl instance.
+ *
+ * @retrun snmpagent_impl & snmpagent_impl' instance
+ */
+ static snmpagent_impl &get_instance();
+
+ /*!
+ * snmpagent_impl class initialize.
+ *
+ * @param error_code & error code
+ * @retrun void
+ */
+ void init(error_code &);
+
+ /*!
+ * push the trap message into trap message queue.
+ *
+ * @param[in] in_trapmessage is trap message
+ * @param[in/out] err is error code
+ * @retrun void
+ */
+ void push_trapmessage(trapmessage &in_trapmessage, error_code& err);
+
+ /*!
+ * snmpagent function start.
+ *
+ * @param[in/out] error_code is error code
+ * @retrun void
+ */
+ void start(error_code&);
+
+ /*!
+ * snmpagent function stop.
+ *
+ * @retrun void
+ */
+ void stop();
+
+ /*!
+ * set snmp function enable
+ *
+ * @retrun void
+ */
+ void enable();
+
+ /*!
+ * set snmp function disable
+ *
+ * @retrun void
+ */
+ void disable();
+
+ /*!
+ * set log trap enable
+ * @retrun void
+ */
+ void logtrap_enable();
+
+ /*!
+ * set log trap disable
+ * @retrun void
+ */
+ void logtrap_disable();
+
+ /*!
+ * set log trap level.
+ *
+ * @param[in] in_level is log trap level
+ * @retrun void
+ */
+ void set_logtrap_level(const LOG_LEVEL_TAG in_level);
+
+ /*!
+ * set mib cache update interval.
+ *
+ * @param[in] in_interval is cache update interval
+ * @retrun void
+ */
+ void set_interval(const unsigned int in_interval);
+
+ /*!
+ * refresh all the statistics.
+ *
+ * @return void
+ */
+ void refresh_all_statistics();
+
+ /*!
+ * refresh a special virtual service's statistics.
+ *
+ * @param[in] vs_endpoint is virtual service's endpoint
+ * @param[in] protocol is virtual service's protocol
+ * @return void
+ */
+ void refresh_statistics(const boost::asio::ip::tcp::endpoint &vs_endpoint, const std::string &protocol);
+
+ /*!
+ * set vsd infomation.
+ *
+ * @param[in] vsd is vsd pointer.
+ * @retrun void
+ */
+ void set_vsd_info(l7vsd *vsd);
+
+ /*!
+ * get snmp infomation.
+ *
+ * @retrun snmp_info is snmp infomation.
+ */
+ snmp_info get_snmp_info();
+
+ /*!
+ * collect mib data.
+ *
+ * @param[in] error_code is err code.
+ * @retrun void
+ */
+ void collect_mibdata(error_code &);
+
+ /*!
+ * finalize.
+ *
+ * @retrun void
+ */
+ void finalize();
+
+ /*!
+ * increment get request count.
+ *
+ * @retrun void
+ */
+ void increment_getrequest_count();
+
+ /*!
+ * increment set request count.
+ *
+ * @retrun void
+ */
+ void increment_setrequest_count();
+ };
+
+}
+
+#endif //__SNMPAGENT_IMPL_H__
+
--- /dev/null
+/*!
+ * @file snmpfunc.h
+ * @brief snmp function module.
+ *
+ * L7VSD: Linux Virtual Server for Layer7 Load Balancing
+ * Copyright (C) 2010 NTT COMWARE Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+/*
+ * Note: this file originally auto-generated by mib2c using
+ * : mib2c.create-dataset.conf 17337 2009-01-01 14:28:29Z magfr $
+ * : mib2c.scalar.conf 17337 2009-01-01 14:28:29Z magfr $
+ * : mib2c.notify.conf 17455 2009-04-05 09:53:29Z magfr $
+ */
+#ifndef __SNMPFUNC_H__
+#define __SNMPFUNC_H__
+
+#include <error_code.h>
+#include <string>
+#include <net-snmp/net-snmp-config.h>
+#include <net-snmp/net-snmp-includes.h>
+#include <net-snmp/agent/net-snmp-agent-includes.h>
+
+using namespace l7vs;
+
+/*
+ * function declarations
+ */
+
+/*!
+ * handle for virtual service count.
+ *
+ */
+int handle_get_vstable_count(netsnmp_mib_handler *handler,
+ netsnmp_handler_registration *reginfo,
+ netsnmp_agent_request_info *reqinfo,
+ netsnmp_request_info *requests);
+
+/*!
+ * handle for replication state.
+ *
+ */
+int handle_get_rep_state(netsnmp_mib_handler *handler,
+ netsnmp_handler_registration *reginfo,
+ netsnmp_agent_request_info *reqinfo,
+ netsnmp_request_info *requests);
+
+/*!
+ * handle for virtual service table.
+ *
+ */
+int handle_get_vstable(netsnmp_mib_handler *handler,
+ netsnmp_handler_registration *reginfo,
+ netsnmp_agent_request_info *reqinfo,
+ netsnmp_request_info *requests);
+
+/*!
+ * handle for real server table.
+ *
+ */
+int handle_get_rstable(netsnmp_mib_handler *handler,
+ netsnmp_handler_registration *reginfo,
+ netsnmp_agent_request_info *reqinfo,
+ netsnmp_request_info *requests);
+
+/*!
+ * initialize snmp scaler and table data set handles.
+ *
+ * @param[in] error_code& is trap error code
+ * @retrun void
+ */
+void init_snmp_handles(error_code& err);
+
+/*!
+ * initialize virtual service table data set.
+ *
+ * @param[in] error_code& is trap error code
+ * @retrun void
+ */
+void initialize_virtual_service_table(error_code& err);
+
+/*!
+ * initialize real server table data set.
+ *
+ * @param[in] error_code& is trap error code
+ * @retrun void
+ */
+void initialize_real_server_table(error_code& err);
+
+/*!
+ * send service start trap.
+ *
+ * @param[in] const std::string& is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_service_start(const std::string&);
+
+/*!
+ * send service stop trap.
+ *
+ * @param[in] const std::string& is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_service_stop(const std::string&);
+
+/*!
+ * send virtual service add trap.
+ *
+ * @param[in] const std::string& is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_vs_add(const std::string&);
+
+/*!
+ * send virtual service change trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_vs_change(const std::string&);
+
+/*!
+ * send virtual service remove trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_vs_remove(const std::string&);
+
+/*!
+ * send real server add trap.
+ *
+ * @param[in] const std::string& is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_rs_add(const std::string&);
+
+/*!
+ * send real server change trap.
+ *
+ * @param[in] const std::string& is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_rs_change(const std::string&);
+
+/*!
+ * send real server remove trap.
+ *
+ * @param[in] const std::string& is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_rs_remove(const std::string&);
+
+/*!
+ * send upstream QoS alert on trap.
+ *
+ * @param[in] const std::string& is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_up_qos_alert_on(const std::string&);
+
+/*!
+ * send upstream QoS alert off trap.
+ *
+ * @param[in] const std::string& is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_up_qos_alert_off(const std::string&);
+
+/*!
+ * send downstream QoS alert on trap.
+ *
+ * @param[in] const std::string& is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_down_qos_alert_on(const std::string&);
+
+/*!
+ * send downstream QoS alert off trap.
+ *
+ * @param[in] const std::string& is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_down_qos_alert_off(const std::string&);
+
+/*!
+ * send session pool alert on trap.
+ *
+ * @param[in] const std::string& is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_sessionpool_alert_on(const std::string&);
+
+/*!
+ * send session pool alert off trap.
+ *
+ * @param[in] const std::string& is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_sessionpool_alert_off(const std::string&);
+
+/*!
+ * send fatal log trap.
+ *
+ * @param[in] const std::string& is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_fatal(const std::string&);
+
+/*!
+ * send error log trap.
+ *
+ * @param[in] const std::string& is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_error(const std::string&);
+
+/*!
+ * send warn log trap.
+ *
+ * @param[in] const std::string& is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_warn(const std::string&);
+
+/*!
+ * send info log trap.
+ *
+ * @param[in] const std::string& is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_info(const std::string&);
+
+/*!
+ * send debug log trap.
+ *
+ * @param[in] const std::string& is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int trap_debug(const std::string&);
+
+/*
+ * column number definitions for table l7vsVsTable
+ */
+#define COLUMN_L7VSVSINDEX (1)
+#define COLUMN_L7VSVSPROTOCOL (2)
+#define COLUMN_L7VSVSADDRTYPE (3)
+#define COLUMN_L7VSVSADDR (4)
+#define COLUMN_L7VSVSPORT (5)
+#define COLUMN_L7VSVSPROTOCOLMODULENAME (6)
+#define COLUMN_L7VSVSPROTOCOLMODULEOPTIONS (7)
+#define COLUMN_L7VSVSSCHEDULEMODULENAME (8)
+#define COLUMN_L7VSVSSCHEDULEMODULEOPTIONS (9)
+#define COLUMN_L7VSVSSORRYADDRTYPE (10)
+#define COLUMN_L7VSVSSORRYADDR (11)
+#define COLUMN_L7VSVSSORRYPORT (12)
+#define COLUMN_L7VSVSSORRYCONNLIMIT (13)
+#define COLUMN_L7VSVSSORRYFORCEENABLED (14)
+#define COLUMN_L7VSVSTHROUGHPUTUP (15)
+#define COLUMN_L7VSVSTHROUGHPUTDOWN (16)
+#define COLUMN_L7VSVSTHROUGHPUTUPQOS (17)
+#define COLUMN_L7VSVSTHROUGHPUTDOWNQOS (18)
+#define COLUMN_L7VSVSSSLFLAG (19)
+#define COLUMN_L7VSVSSESSIONPOOLCOUNT (20)
+#define COLUMN_L7VSVSSESSIONACTIVECOUNT (21)
+#define COLUMN_L7VSVSSESSIONWAITCOUNT (22)
+#define COLUMN_L7VSVSHTTPTOTALCOUNT (23)
+#define COLUMN_L7VSVSHTTPGETCOUNT (24)
+#define COLUMN_L7VSVSHTTPPOSTCOUNT (25)
+#define COLUMN_L7VSVSRSNUMBER (26)
+
+/*
+ * column number definitions for table l7vsRsTable
+ */
+#define COLUMN_L7VSRSINDEX (1)
+#define COLUMN_L7VSRSVSINDEX (2)
+#define COLUMN_L7VSRSADDRTYPE (3)
+#define COLUMN_L7VSRSADDR (4)
+#define COLUMN_L7VSRSPORT (5)
+#define COLUMN_L7VSRSFORWARD (6)
+#define COLUMN_L7VSRSWEIGHT (7)
+#define COLUMN_L7VSRSACTIVECONN (8)
+#define COLUMN_L7VSRSINACTIVECONN (9)
+
+#endif //__SNMPFUNC_H__
--- /dev/null
+/*!
+ * @file mibdata.cpp
+ * @brief mibdata module.
+ *
+ * L7VSD: Linux Virtual Server for Layer7 Load Balancing
+ * Copyright (C) 2010 NTT COMWARE Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ **********************************************************************/
+#include "mibdata.h"
+#include "snmpfunc.h"
+
+
+namespace l7vs
+{
+ /*!
+ * update virtual service table infomation.
+ *
+ * @param l7vsd * l7vsd pointer
+ * @param error_code & error code
+ * @retrun void
+ */
+ void mibdata::update_vs_table(l7vsd *in_vsd, error_code& err)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 63, "mibdata::update_vs_table", __FILE__, __LINE__);
+
+ if (in_vsd == NULL) {
+ std::string msg("in_vsd pointer is NULL.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 11, msg, __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg);
+ return;
+ }
+
+ if (vs_table == NULL) {
+ std::string msg("vs_table pointer is NULL.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 12, msg, __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg);
+ return;
+ }
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "mibdata::update_vs_table arguments:";
+ debugstr << boost::format("in_vsd=%p") % in_vsd;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 64, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ oid index[1] = {0};
+ netsnmp_table_row *row = NULL;
+ int vs_index = 0;
+ std::vector<rsdata> rs_vector;
+
+ int protocol = 0;
+ char vs_ipaddress[L7VS_IPADDR_LEN] = {0};
+ char sorry_ipaddress[L7VS_IPADDR_LEN] = {0};
+ int vs_ipaddress_type = 1;
+ int sorry_ipaddress_type = 1;
+ int vs_port = 0;
+ int sorry_port = 0;
+
+ struct counter64 sorry_maxconnection = {
+ 0
+ };
+ struct counter64 throughput_upstream = {
+ 0
+ };
+ struct counter64 throughput_downstream = {
+ 0
+ };
+ struct counter64 qos_upstream = {
+ 0
+ };
+ struct counter64 qos_downstream = {
+ 0
+ };
+ struct counter64 http_requests = {
+ 0
+ };
+ struct counter64 http_get_requests = {
+ 0
+ };
+ struct counter64 http_post_requests = {
+ 0
+ };
+
+ int pool_session_count = 0;
+ int active_session_count = 0;
+ int waiting_session_count = 0;
+
+ //get virtualservice list mutex
+ boost::mutex &virtualservice_list_mutex = in_vsd->get_virtualservice_list_mutex();
+ {
+ boost::mutex::scoped_lock lock(virtualservice_list_mutex);
+
+ l7vsd::vslist_type &virtualservice_list = in_vsd->get_virtualservice_list();
+
+ //delete the surplus data from vs table
+ if (virtualservice_list.size() < static_cast<size_t>(vs_table_size)) {
+ for (size_t i = vs_table_size; i > virtualservice_list.size(); i--) {
+ index[0] = i;
+ row = netsnmp_table_data_get_from_oid(vs_table->table, index, 1);
+ if (row == NULL) continue;
+ netsnmp_table_dataset_remove_and_delete_row(vs_table, row);
+ }
+ }
+
+ //set virtual service table size
+ vs_table_size = virtualservice_list.size();
+
+ //update virtual service table
+ for (l7vsd::vslist_type::iterator it = virtualservice_list.begin();
+ it != virtualservice_list.end(); it++) {
+ index[0] = vs_index;
+
+ //get row pointer
+ row = netsnmp_table_data_get_from_oid(vs_table->table, index, 1);
+ if (row == NULL) {
+ row = netsnmp_create_table_data_row();
+ if (row == NULL) {
+ std::string msg("create virtualservice table row failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 13, msg, __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg);
+ return;
+ } else {
+
+ netsnmp_table_row_add_index(row, ASN_INTEGER, (void*)index, sizeof(int));
+ netsnmp_table_dataset_add_row(vs_table, row);
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "function : mibdata::update_vs_table : vs_table add row.";
+ boost::format("vs_index=%d") % vs_index;
+
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 65, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+ }
+ }
+
+ virtualservice_element &srv = (*it)->get_element();
+
+ //get virtual service IP address infomation
+ if (srv.udpmode) {
+ protocol = IPPROTO_UDP;
+ if (srv.udp_recv_endpoint.address().is_v4()) {
+ strncpy(vs_ipaddress, srv.udp_recv_endpoint.address().to_v4().to_string().c_str(), L7VS_IPADDR_LEN);
+ } else {
+ strncpy(vs_ipaddress, srv.udp_recv_endpoint.address().to_v6().to_string().c_str(), L7VS_IPADDR_LEN);
+ vs_ipaddress_type = 2;
+ }
+ vs_port = srv.udp_recv_endpoint.port();
+ } else {
+ protocol = IPPROTO_TCP;
+ if (srv.tcp_accept_endpoint.address().is_v4()) {
+ strncpy(vs_ipaddress, srv.udp_recv_endpoint.address().to_v4().to_string().c_str(), L7VS_IPADDR_LEN);
+ } else {
+ strncpy(vs_ipaddress, srv.udp_recv_endpoint.address().to_v6().to_string().c_str(), L7VS_IPADDR_LEN);
+ vs_ipaddress_type = 2;
+ }
+ vs_port = srv.tcp_accept_endpoint.port();
+ }
+
+ //get sorry server IP address infomation
+ if (srv.sorry_endpoint.address().is_v4()) {
+ strncpy(sorry_ipaddress, srv.sorry_endpoint.address().to_v4().to_string().c_str(), L7VS_IPADDR_LEN);
+ } else {
+ strncpy(sorry_ipaddress, srv.sorry_endpoint.address().to_v6().to_string().c_str(), L7VS_IPADDR_LEN);
+ sorry_ipaddress_type = 2;
+ }
+ sorry_port = srv.sorry_endpoint.port();
+
+ //get protocol mudule option string
+ std::stringstream protocol_module_arg;
+ BOOST_FOREACH(std::string str, srv.protocol_args) {
+ protocol_module_arg << str << " ";
+ }
+
+ //set schedule module option string
+ std::string schedule_module_arg(" ");
+
+ //set ssl flag
+ int ssl_flag = srv.ssl_file_name == "" ? 0 : 1;
+
+ //set realserver size
+ int rs_size = srv.realserver_vector.size();
+
+ //get http statstics
+ protocol_module_base *protocol_module_ptr = (*it)->get_protocol_module();
+ stats_base& base_stats = protocol_module_ptr->get_stats();
+ if ( base_stats.get_mode() == stats_base::MODE_HTTP ) {
+ http_stats &httpstats = static_cast<http_stats&>(base_stats);
+ http_requests.low = httpstats.http_requests.get();
+ http_get_requests.low = httpstats.http_get_requests.get();
+ http_post_requests.low = httpstats.http_post_requests.get();
+ }
+
+ //set sorry max connection
+ sorry_maxconnection.low = srv.sorry_maxconnection;
+
+ //set throughput infomation
+ throughput_upstream.low = srv.throughput_upstream;
+ throughput_downstream.low = srv.throughput_downstream;
+ qos_upstream.low = srv.qos_upstream;
+ qos_downstream.low = srv.qos_downstream;
+
+ //set session infomation
+ pool_session_count = (*it)->get_pool_sessions_count();
+ active_session_count = (*it)->get_active_sessions_count();
+ waiting_session_count = (*it)->get_waiting_sessions_count();
+
+ //set vs table row infomation
+ netsnmp_set_row_column(row, COLUMN_L7VSVSINDEX, ASN_INTEGER, (char *)&vs_index, sizeof(int));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSPROTOCOL, ASN_INTEGER, (char *)&protocol, sizeof(int));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSADDRTYPE, ASN_INTEGER, (char *)&vs_ipaddress_type, sizeof(int));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSADDR, ASN_OCTET_STR, vs_ipaddress, strnlen(vs_ipaddress, L7VS_IPADDR_LEN));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSPORT, ASN_UNSIGNED, (char *)&vs_port, sizeof(int));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSPROTOCOLMODULENAME, ASN_OCTET_STR, (char *)srv.protocol_module_name.c_str(), srv.protocol_module_name.length());
+ netsnmp_set_row_column(row, COLUMN_L7VSVSPROTOCOLMODULEOPTIONS, ASN_OCTET_STR, (char *)protocol_module_arg.str().c_str(), protocol_module_arg.str().length());
+ netsnmp_set_row_column(row, COLUMN_L7VSVSSCHEDULEMODULENAME, ASN_OCTET_STR, (char *)srv.schedule_module_name.c_str(), srv.schedule_module_name.length());
+ netsnmp_set_row_column(row, COLUMN_L7VSVSSCHEDULEMODULEOPTIONS, ASN_OCTET_STR, (char *)schedule_module_arg.c_str(), schedule_module_arg.length());
+ netsnmp_set_row_column(row, COLUMN_L7VSVSSORRYADDRTYPE, ASN_INTEGER, (char *)&sorry_ipaddress_type,sizeof(int));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSSORRYADDR, ASN_OCTET_STR, (char *)sorry_ipaddress, strnlen(sorry_ipaddress, L7VS_IPADDR_LEN));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSSORRYPORT, ASN_INTEGER, (char *)&sorry_port, sizeof(int));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSSORRYCONNLIMIT, ASN_COUNTER64, (char *)&sorry_maxconnection, sizeof(struct counter64));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSSORRYFORCEENABLED, ASN_INTEGER, (char *)&srv.sorry_flag, sizeof(int));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSTHROUGHPUTUP, ASN_COUNTER64, (char *)&throughput_upstream, sizeof(struct counter64));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSTHROUGHPUTDOWN, ASN_COUNTER64, (char *)&throughput_downstream, sizeof(struct counter64));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSTHROUGHPUTUPQOS, ASN_COUNTER64, (char *)&qos_upstream, sizeof(struct counter64));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSTHROUGHPUTDOWNQOS, ASN_COUNTER64, (char *)&qos_downstream, sizeof(struct counter64));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSSSLFLAG, ASN_INTEGER, (char *)&ssl_flag, sizeof(int));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSSESSIONPOOLCOUNT, ASN_INTEGER, (char *)&pool_session_count, sizeof(int));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSSESSIONACTIVECOUNT, ASN_INTEGER, (char *)&active_session_count, sizeof(int));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSSESSIONWAITCOUNT, ASN_INTEGER, (char *)&waiting_session_count, sizeof(int));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSHTTPTOTALCOUNT, ASN_COUNTER64, (char *)&http_requests, sizeof(struct counter64));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSHTTPGETCOUNT, ASN_COUNTER64, (char *)&http_get_requests, sizeof(struct counter64));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSHTTPPOSTCOUNT, ASN_COUNTER64, (char *)&http_post_requests, sizeof(struct counter64));
+ netsnmp_set_row_column(row, COLUMN_L7VSVSRSNUMBER, ASN_INTEGER, (char *)&rs_size, sizeof(size_t));
+
+ //create temporary realserver data list
+ int rs_index = 0;
+ for (std::vector<realserver_element>::iterator rs_it = srv.realserver_vector.begin();
+ rs_it != srv.realserver_vector.end(); rs_it++) {
+ rsdata data;
+
+ //set realserver infomation
+ if (srv.udpmode) {
+ if ((*rs_it).udp_endpoint.address().is_v4()) {
+ strncpy(data.address, (*rs_it).udp_endpoint.address().to_v4().to_string().c_str(), L7VS_IPADDR_LEN);
+ data.address_type = 1;
+ } else {
+ strncpy(data.address,(*rs_it).udp_endpoint.address().to_v6().to_string().c_str(), L7VS_IPADDR_LEN);
+ data.address_type = 2;
+ }
+ data.port = (*rs_it).udp_endpoint.port();
+ } else {
+ if ((*rs_it).tcp_endpoint.address().is_v4()) {
+ strncpy(data.address, (*rs_it).tcp_endpoint.address().to_v4().to_string().c_str(), L7VS_IPADDR_LEN);
+ data.address_type = 1;
+ } else {
+ strncpy(data.address, (*rs_it).tcp_endpoint.address().to_v6().to_string().c_str(), L7VS_IPADDR_LEN);
+ data.address_type = 2;
+ }
+ data.port = (*rs_it).tcp_endpoint.port();
+ }
+
+ data.index = rs_index;
+ data.vs_index = vs_index;
+ data.forward = 1;
+ data.weigth = (*rs_it).weight;
+ data.active_conn = (*rs_it).get_active();
+ data.inactive_conn = (*rs_it).get_inact();
+
+ //push into realserver data list
+ rs_vector.push_back(data);
+ rs_index++;
+ }
+ vs_index++;
+ }
+ }
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "function : mibdata::update_vs_table : vs_table_size=";
+ debugstr << vs_table_size;
+
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 66, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ //update realserver infomation with temporary realserver data list
+ update_rs_table(rs_vector, err);
+ }
+
+ /*!
+ * update real server table infomation.
+ *
+ * @param const std::vector<rsdata> & temporary real server list
+ * @param error_code & error code
+ * @retrun void
+ */
+ void mibdata::update_rs_table(const std::vector<rsdata>& rs_table_tmp, error_code& err)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 67, "mibdata::update_rs_table", __FILE__, __LINE__);
+
+ oid index[1] = {0};
+ int rs_index = 0;
+ netsnmp_table_row *row = NULL;
+
+ //delete the surplus data from real server table
+ if (rs_table_tmp.size() < static_cast<size_t>(rs_table_size)) {
+ for (size_t i = rs_table_size; i > rs_table_tmp.size(); i--) {
+ index[0] = i;
+ row = netsnmp_table_data_get_from_oid(rs_table->table, index, 1);
+ if (row) continue;
+ netsnmp_table_dataset_remove_and_delete_row(rs_table, row);
+ }
+ }
+
+ rs_table_size = rs_table_tmp.size();
+
+ //update real server table
+ for (std::vector<rsdata>::const_iterator itr = rs_table_tmp.begin(); itr != rs_table_tmp.end(); itr++) {
+ index[0] = rs_index;
+ row = netsnmp_table_data_get_from_oid(rs_table->table, index, 1);
+ if (row == NULL) {
+ row = netsnmp_create_table_data_row();
+ if (row == NULL) {
+ std::string msg("create realserver table row failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 14, msg, __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg);
+ return ;
+ } else {
+ netsnmp_table_row_add_index(row, ASN_INTEGER, (void*)index, sizeof(int));
+ netsnmp_table_dataset_add_row(rs_table, row);
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "function : mibdata::update_rs_table : rs_table add row.";
+ boost::format("rs_index=%d") % (*itr).index;
+
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 68, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+ }
+ }
+
+ netsnmp_set_row_column(row, COLUMN_L7VSRSINDEX, ASN_INTEGER, (char *)&(*itr).index, sizeof(int));
+ netsnmp_set_row_column(row, COLUMN_L7VSRSVSINDEX, ASN_INTEGER, (char *)&(*itr).vs_index, sizeof(int));
+ netsnmp_set_row_column(row, COLUMN_L7VSRSADDRTYPE, ASN_INTEGER, (char *)&(*itr).address_type, sizeof(int));
+ netsnmp_set_row_column(row, COLUMN_L7VSRSADDR, ASN_OCTET_STR, (*itr).address, strlen((*itr).address));
+ netsnmp_set_row_column(row, COLUMN_L7VSRSPORT, ASN_UNSIGNED, (char *)&(*itr).port, sizeof(int));
+ netsnmp_set_row_column(row, COLUMN_L7VSRSFORWARD, ASN_INTEGER, (char *)&(*itr).forward, sizeof(int));
+ netsnmp_set_row_column(row, COLUMN_L7VSRSWEIGHT, ASN_INTEGER, (char *)&(*itr).weigth, sizeof(int));
+ netsnmp_set_row_column(row, COLUMN_L7VSRSACTIVECONN, ASN_INTEGER, (char *)&(*itr).active_conn, sizeof(int));
+ netsnmp_set_row_column(row, COLUMN_L7VSRSINACTIVECONN, ASN_INTEGER, (char *)&(*itr).inactive_conn, sizeof(int));
+
+ rs_index++;
+ }
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "function : mibdata::update_rs_table : rs_table_size=";
+ debugstr << rs_table_size;
+
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 69, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+ }
+
+ /*!
+ * update replication state.
+ *
+ * @param l7vsd * l7vsd pointer
+ * @param error_code & error code
+ * @retrun void
+ */
+ void mibdata::update_replication_state(l7vsd *in_vsd , error_code& err)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 70, "mibdata::update_replication_state", __FILE__, __LINE__);
+
+ if (in_vsd == NULL) {
+ std::string msg("in_vsd pointer is NULL.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 15, msg, __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg);
+ return;
+ }
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "mibdata::update_replication_state arguments:";
+ debugstr << boost::format("in_vsd=%p") % in_vsd;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 71, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ replication::REPLICATION_MODE_TAG state = in_vsd->get_replication_state();
+ replication_state = static_cast<int>(state);
+ }
+
+ /*!
+ * get mibdata instance.
+ *
+ * @retrun mibdata instance
+ */
+ mibdata& mibdata::get_instance()
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 72, "mibdata::get_instance", __FILE__, __LINE__);
+ static mibdata data;
+ return data;
+ }
+
+ /*!
+ * collect mibdata in l7vsd.
+ *
+ * @param l7vsd * l7vsd pointer
+ * @param error_code & error code
+ * @retrun void
+ */
+ void mibdata::collect_mibdata(l7vsd *in_vsd, error_code& err)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 73, "mibdata::collect_mibdata", __FILE__, __LINE__);
+
+ if (in_vsd == NULL) {
+ std::string msg("in_vsd pointer is NULL.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 16, msg, __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg);
+ return;
+ }
+
+ update_replication_state(in_vsd, err);
+
+ if (err) {
+ std::string msg("update replication state failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 17, msg, __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg);
+ return;
+ }
+
+ update_vs_table(in_vsd, err);
+
+ if (err) {
+ std::string msg("update virtual service table failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 18, msg, __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg);
+ return;
+ }
+ }
+
+ /*!
+ * set virtual service data set.
+ *
+ * @param netsnmp_table_data_set * virtual service data set
+ * @retrun void
+ */
+ void mibdata::set_vs_table(netsnmp_table_data_set* in_vs_table)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 74, "mibdata::set_vs_table", __FILE__, __LINE__);
+ vs_table = in_vs_table;
+ }
+
+ /*!
+ * set real server data set.
+ *
+ * @param netsnmp_table_data_set * real server data set
+ * @retrun void
+ */
+ void mibdata::set_rs_table(netsnmp_table_data_set* in_rs_table)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 75, "mibdata::set_rs_table", __FILE__, __LINE__);
+ rs_table = in_rs_table;
+ }
+}
--- /dev/null
+/*!
+ * @file snmpagent.cpp
+ * @brief snmpagent function class
+ *
+ * L7VSD: Linux Virtual Server for Layer7 Load Balancing
+ * Copyright (C) 2010 NTT COMWARE Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ **********************************************************************/
+
+#include "snmpagent.h"
+
+namespace l7vs
+{
+
+ /*!
+ * constructor.
+ *
+ * @param[in] l7vsd pointer
+ */
+ snmpagent::snmpagent(l7vsd *in_vsd)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 1, "snmpagent::snmpagent", __FILE__, __LINE__);
+
+ error_code err;
+ snmpagent_impl::get_instance().init(err);
+ if (err) {
+ std::string msg("snmpagent initialize failed.program exit.");
+ Logger::putLogFatal(LOG_CAT_L7VSD_SNMPAGENT, 1, msg, __FILE__, __LINE__);
+ exit(1);
+ }
+ snmpagent_impl::get_instance().set_vsd_info(in_vsd);
+ }
+
+ /*!
+ * push the trap message into trap message queue.
+ *
+ * @param[in] in_trapmessage is trap message
+ * @param[in/out] err is error code
+ * @retrun void
+ */
+ void snmpagent::push_trapmessage(trapmessage& in_trapmessage, error_code& err)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 2, "snmpagent::push_trapmessage", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpagent::push_trapmessage arguments:";
+ debugstr << boost::format("in_trapmessage.type=%d") % in_trapmessage.type;
+ debugstr << boost::format("in_trapmessage.message=%s") % in_trapmessage.message;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 3, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ snmpagent_impl::get_instance().push_trapmessage(in_trapmessage, err);
+ }
+
+ /*!
+ * set snmp function enable
+ *
+ * @retrun void
+ */
+ void snmpagent::enable() {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 4, "snmpagent::enable", __FILE__, __LINE__);
+
+ snmpagent_impl::get_instance().enable();
+ }
+
+ /*!
+ * set snmp function disable
+ *
+ * @retrun void
+ */
+ void snmpagent::disable() {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 5, "snmpagent::disable", __FILE__, __LINE__);
+
+ snmpagent_impl::get_instance().enable();
+ }
+
+ /*!
+ * set mib cache update interval.
+ *
+ * @param[in] in_interval is cache update interval
+ * @retrun void
+ */
+ void snmpagent::set_interval(const unsigned int in_interval)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 6, "snmpagent::set_interval", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpagent::set_interval arguments:";
+ debugstr << boost::format("in_interval=%d") % in_interval;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 7, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ snmpagent_impl::get_instance().set_interval(in_interval);
+ }
+
+ /*!
+ * set log trap enable
+ * @retrun void
+ */
+ void snmpagent::logtrap_enable() {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 8, "snmpagent_impl::logtrap_enable", __FILE__, __LINE__);
+
+ snmpagent_impl::get_instance().logtrap_enable();
+ }
+
+ /*!
+ * set log trap disable
+ * @retrun void
+ */
+ void snmpagent::logtrap_disable() {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 9, "snmpagent_impl::logtrap_disable", __FILE__, __LINE__);
+
+ snmpagent_impl::get_instance().logtrap_disable();
+ }
+
+ /*!
+ * set log trap level.
+ *
+ * @param[in] in_level is log trap level
+ * @retrun void
+ */
+ void snmpagent::set_logtrap_level(const LOG_LEVEL_TAG in_level)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 10, "snmpagent::set_logtrap_level", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpagent::set_logtrap_level arguments:";
+ debugstr << boost::format("in_level=%d") % in_level;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 11, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ snmpagent_impl::get_instance().set_logtrap_level(in_level);
+ }
+
+ /*!
+ * get snmp infomation.
+ *
+ * @return snmp infomation
+ */
+ snmp_info snmpagent::get_snmp_info()
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 12, "snmpagent::get_snmp_info", __FILE__, __LINE__);
+
+ return snmpagent_impl::get_instance().get_snmp_info();
+ }
+
+ /*!
+ * start snmp function.
+ *
+ * @param[in/out] error_code is error code
+ * @return void
+ */
+ void snmpagent::start(error_code& err)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 13, "snmpagent::start", __FILE__, __LINE__);
+ snmpagent_impl::get_instance().start(err);
+ }
+
+ /*!
+ * stop snmp function.
+ *
+ * @return void
+ */
+ void snmpagent::stop()
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 14, "snmpagent::stop", __FILE__, __LINE__);
+ snmpagent_impl::get_instance().stop();
+ }
+
+ /*!
+ * refresh all the statistics.
+ *
+ * @return void
+ */
+ void snmpagent::refresh_all_statistics()
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 15, "snmpagent::refresh_all_statistics", __FILE__, __LINE__);
+ snmpagent_impl::get_instance().refresh_all_statistics();
+ }
+
+ /*!
+ * refresh a special virtual service's statistics.
+ *
+ * @param[in] vs_endpoint is virtual service's endpoint
+ * @param[in] protocol is virtual service's protocol
+ * @return void
+ */
+ void snmpagent::refresh_statistics(const boost::asio::ip::tcp::endpoint& vs_endpoint, const std::string& protocol)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 16, "snmpagent::refresh_statistics", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpagent::refresh_statistics arguments:";
+ if (vs_endpoint.address().is_v6()) {
+ debugstr << boost::format("vs_endpoint=[%s]:%d") % vs_endpoint.address().to_string() % vs_endpoint.port();
+ } else {
+ debugstr << boost::format("vs_endpoint=%s:%d") % vs_endpoint.address().to_string() % vs_endpoint.port();
+ }
+ debugstr << boost::format("protocol=%s") % protocol;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 17, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+ snmpagent_impl::get_instance().refresh_statistics(vs_endpoint, protocol);
+ }
+
+ /*!
+ * finalize.
+ *
+ * @return void
+ */
+ void snmpagent::finalize()
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 18, "snmpagent::finalize", __FILE__, __LINE__);
+
+ snmpagent_impl::get_instance().finalize();
+ }
+
+}
--- /dev/null
+/*!
+ * @file snmpagent_impl.cpp
+ * @brief snmpagent implement module.
+ *
+ * L7VSD: Linux Virtual Server for Layer7 Load Balancing
+ * Copyright (C) 2010 NTT COMWARE Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ **********************************************************************/
+
+#include "l7vsd.h"
+#include "snmpagent_impl.h"
+#include "mibdata.h"
+#include "protocol_module_base.h"
+#include "snmpfunc.h"
+
+#define SNMP_SLEEP_NANO_TIME (1000000)
+#define SNMP_MAX_TRAP_POLLING_INTEVAL (1000000000)
+#define SNMP_DEFAULT_TRAP_POLLING_INTEVAL (100000000)
+#define SNMP_DEFAULT_TRAP_QUEUE_MAX_SIZE (1000)
+#define TRAP_TIME_STRING_MAX_SIZE (20)
+
+#ifndef FALSE
+#define FALSE (0)
+#endif
+#ifndef TRUE
+#define TRUE (1)
+#endif
+
+namespace l7vs
+{
+
+ /*!
+ * process mib get item thread function.
+ * @retrun void
+ */
+ void snmpagent_impl::process_mib_run()
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 19, "snmpagent_impl::process_mib_run", __FILE__, __LINE__);
+
+ //create wait time
+ timespec wait_val;
+ wait_val.tv_sec = 0;
+ wait_val.tv_nsec = SNMP_SLEEP_NANO_TIME;
+
+ //main loop
+ while (enabled.get() != FALSE) {
+ //agent check and process
+ agent_check_and_process(0);
+
+ //sleep a little time
+ nanosleep(&wait_val, NULL);
+ }
+ }
+
+ /*!
+ * process trap thread function.
+ * @retrun void
+ */
+ void snmpagent_impl::trap_run()
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 20, "snmpagent_impl::trap_run", __FILE__, __LINE__);
+
+ //create wait time
+ timespec wait_val;
+ wait_val.tv_sec = 0;
+ wait_val.tv_nsec = trap_polling_interval.get();
+
+ //main loop
+ while (enabled.get() != FALSE) {
+ //create trap message
+ trapmessage trapmsg;
+ {
+ boost::mutex::scoped_lock lock(trap_msg_queue_condition_mutex);
+
+ //loop until the trap message is not none
+ while (trap_msg_queue.size() == 0) {
+ trap_msg_queue_condition.wait(lock);
+ }
+
+ //get the first message in trap message
+ trapmsg = trap_msg_queue[0];
+
+ //pop the first message in trap message
+ trap_msg_queue.pop_front();
+ }
+
+ //find mapping in trap message map
+ trapfunc_type::iterator it = trapfunc_map.find(trapmsg.type);
+
+ if (it != trapfunc_map.end()) {
+ //send trap message
+ it->second(trapmsg.message);
+
+ //set trap last date to current time
+ trap_last_date = time(NULL);
+
+ //increment snmp trap count
+ snmp_trap_count++;
+ }
+
+ //sleep a little time
+ nanosleep(&wait_val, NULL);
+ }
+ }
+
+ /*!
+ * check mib data timeout.
+ * @retrun true: time not out
+ * false: time out
+ */
+ bool snmpagent_impl::check_timeout()
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 21, "snmpagent::check_timeout", __FILE__, __LINE__);
+
+ if (interval.get() == 0) {
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::string debugstr = "function : snmpagent_impl::check_timeout : timeout.";
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 22, debugstr, __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ //when interval is 0, return false(timeout)
+ return false;
+ } else {
+ //get current time
+ boost::posix_time::ptime now_time(boost::posix_time::second_clock::universal_time());
+
+ //calc time interval
+ boost::posix_time::time_duration td = boost::posix_time::seconds(interval.get());
+
+ if ((now_time - mib_collect_last_time) > td) {
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::string debugstr = "function : snmpagent_impl::check_timeout : timeout.";
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 23, debugstr, __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ //timeout
+ return false;
+ } else {
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::string debugstr = "function : snmpagent_impl::check_timeout : not timeout.";
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 24, debugstr, __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+ //not timeout
+ return true;
+ }
+ }
+ }
+
+ /*!
+ * create and return a snmpagent_impl instance.
+ *
+ * @retrun snmpagent_impl & snmpagent_impl' instance
+ */
+ snmpagent_impl& snmpagent_impl::get_instance()
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 25, "snmpagent::get_instance", __FILE__, __LINE__);
+
+ static snmpagent_impl agent_impl;
+ return agent_impl;
+ }
+
+ /*!
+ * snmpagent_impl class initialize.
+ *
+ * @param error_code & error code
+ * @retrun void
+ */
+ void snmpagent_impl::init(error_code& err)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 26, "snmpagent_impl::init", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpagent_impl::init arguments:";
+ debugstr << boost::format("err=%d") % (err ? true : false);
+ debugstr << boost::format("err.message=%s") % err.get_message();
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 27, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ try {
+ if (initialized == false) {
+ //set snmp start flag false
+ start_flag = false;
+
+ //mapping trap type and trap function
+ trapfunc_map[trapmessage::SERVICE_START] = &trap_service_start;
+ trapfunc_map[trapmessage::SERVICE_STOP] = &trap_service_stop;
+ trapfunc_map[trapmessage::VIRTUALSERVICE_ADD] = &trap_vs_add;
+ trapfunc_map[trapmessage::VIRTUALSERVICE_CHANGE] = &trap_vs_change;
+ trapfunc_map[trapmessage::VIRTUALSERVICE_REMOVE] = &trap_vs_remove;
+ trapfunc_map[trapmessage::REALSERVER_ADD] = &trap_rs_add;
+ trapfunc_map[trapmessage::REALSERVER_CHANGE] = &trap_rs_change;
+ trapfunc_map[trapmessage::REALSERVER_REMOVE] = &trap_rs_remove;
+ trapfunc_map[trapmessage::UPQOS_ALERT_ON] = &trap_up_qos_alert_on;
+ trapfunc_map[trapmessage::UPQOS_ALERT_OFF] = &trap_up_qos_alert_off;
+ trapfunc_map[trapmessage::DOWNQOS_ALERT_ON] = &trap_down_qos_alert_on;
+ trapfunc_map[trapmessage::DOWNQOS_ALERT_OFF] = &trap_down_qos_alert_off;
+ trapfunc_map[trapmessage::SESSIONPOOL_ALERT_ON] = &trap_sessionpool_alert_on;
+ trapfunc_map[trapmessage::SESSIONPOOL_ALERT_OFF] = &trap_sessionpool_alert_off;
+ trapfunc_map[trapmessage::FATAL_LOG] = &trap_fatal;
+ trapfunc_map[trapmessage::ERROR_LOG] = &trap_error;
+ trapfunc_map[trapmessage::WARN_LOG] = &trap_warn;
+ trapfunc_map[trapmessage::INFO_LOG] = &trap_info;
+ trapfunc_map[trapmessage::DEBUG_LOG] = &trap_debug;
+
+ //init member varable
+ mib_collect_last_time = boost::posix_time::ptime(boost::posix_time::min_date_time);
+ start_date = 0;
+ request_last_date = 0;
+ trap_last_date = 0;
+ snmp_get_requests = 0;
+ snmp_set_requests = 0;
+ snmp_trap_count = 0;
+
+ //mapping log string and log level
+ string_loglevel_map["debug"] = LOG_LV_DEBUG;
+ string_loglevel_map["info"] = LOG_LV_INFO;
+ string_loglevel_map["warn"] = LOG_LV_WARN;
+ string_loglevel_map["error"] = LOG_LV_ERROR;
+ string_loglevel_map["fatal"] = LOG_LV_FATAL;
+
+ //load config file setting
+ load_config();
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::string debugstr = "function : snmpagent_impl::init : call load_config().";
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 28, debugstr, __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_ds_set_boolean(NETSNMP_DS_APPLICATION_ID, NETSNMP_DS_AGENT_ROLE, 1);
+
+ //socket startup
+ SOCK_STARTUP;
+
+ //init l7vsAgent
+ int ret = init_agent("l7vsAgent");
+ if (ret) {
+ std::string msg("init_agent failed.");
+ Logger::putLogFatal(LOG_CAT_L7VSD_SNMPAGENT, 3, msg, __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg);
+ return;
+ }
+
+ init_snmp("l7vsAgent");
+
+ //regist snmp get item' handle
+ init_snmp_handles(err);
+
+ if (err) {
+ return;
+ }
+
+ //set initializ flag true
+ initialized = true;
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::string debugstr = "function : snmpagent_impl::init : initialize success.";
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 29, debugstr, __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+ }
+ } catch (const std::exception &e) {
+ std::stringstream msg;
+ msg << "init failed : " << e.what() << ".";
+ Logger::putLogFatal(LOG_CAT_L7VSD_SNMPAGENT, 2, msg.str(), __FILE__, __LINE__);
+ }
+ }
+
+ /*!
+ * push the trap message into trap message queue.
+ *
+ * @param[in] in_trapmessage is trap message
+ * @param[in/out] err is error code
+ * @retrun void
+ */
+ void snmpagent_impl::push_trapmessage(trapmessage& trapmessage, error_code& err)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 30, "snmpagent_impl::push_trapmessage", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpagent_impl::push_trapmessage arguments:";
+ debugstr << boost::format("trapmessage.type=%d") % trapmessage.type;
+ debugstr << boost::format("trapmessage.message=%s") % trapmessage.message;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 31, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+ try {
+ //snmp function is enable
+ if ((start_flag == true) && (enabled.get() == TRUE)) {
+ //get local time string
+ char time_buf[TRAP_TIME_STRING_MAX_SIZE] = {0};
+ time_t now = time(NULL);
+ struct tm *t = localtime(&now);
+ if (t) strftime(time_buf, sizeof(time_buf), "%Y/%m/%d %H:%M:%S", t);
+ //time string added in trap message
+ std::stringstream trap_buf;
+ trap_buf << time_buf << "," << trapmessage.message;
+
+ if (trapmessage.type < trapmessage::DEBUG_LOG) {
+ char buff[HOST_NAME_MAX] = {0};
+ gethostname(buff, HOST_NAME_MAX);
+ trap_buf << "," << buff;
+ }
+
+ trapmessage.message = trap_buf.str();
+
+ {
+ boost::mutex::scoped_lock lock(trap_msg_queue_condition_mutex);
+
+ //drap the message when the trap message queue is too large
+ if( trap_msg_queue.size() <= trap_queue_max_size.get())
+ {
+ //push the message into trap message queue
+ trap_msg_queue.push_back(trapmessage);
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "function : snmpagent_impl::push_trapmessage : trap message push back.";
+ debugstr << boost::format("trapmessage.type=%d") % trapmessage.type;
+ debugstr << boost::format("trapmessage.message=%s") % trapmessage.message;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 32, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+ }
+ else{
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::string debugstr = "function : snmpagent_impl::push_trapmessage : trap message queue is overflow.";
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 33, debugstr, __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+ }
+ }
+
+ //notify the trap main thread to process the message
+ trap_msg_queue_condition.notify_one();
+
+ }
+ }
+ catch (const std::exception &e) {
+ std::stringstream msg;
+ msg << "Push trap message failed : " << e.what() << ".";
+
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 1, msg.str(), __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg.str());
+ }
+
+ }
+
+ /*!
+ * snmpagent function start.
+ *
+ * @param[in/out] error_code is error code
+ * @retrun void
+ */
+ void snmpagent_impl::start(error_code& err)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 34, "snmpagent_impl::start", __FILE__, __LINE__);
+
+ if (vsd == NULL) {
+ //vsd pointer is NULL
+ std::string msg("vsd pointer is NULL.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 2, msg, __FILE__, __LINE__);
+ err.setter(false, msg);
+ return;
+ }
+
+ //check snmp enable state
+ if (enabled.get() == FALSE) {
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::string debugstr = "function : snmpagent_impl::start : snmp function was disabled.";
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 35, debugstr, __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+ return;
+ }
+
+ //check start state
+ if (start_flag) {
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::string debugstr = "function : snmpagent_impl::start : snmp function has already started.";
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 36, debugstr, __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+ return;
+ }
+
+ try {
+ //collect mib data first time
+ mibdata::get_instance().collect_mibdata(vsd, err);
+
+ if (err) {
+ //mib collect failed
+ std::string msg("thread start failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 3, msg, __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg);
+ return;
+ }
+
+ //start process mib run thread
+ process_mib_thread = boost::thread(&snmpagent_impl::process_mib_run, this);
+
+ //start trap run
+ trap_thread = boost::thread(&snmpagent_impl::trap_run, this);
+
+ //set start time and start flag
+ start_date = time(NULL);
+ start_flag = true;
+
+ std::string str = "snmp function start.";
+ Logger::putLogInfo(LOG_CAT_L7VSD_SNMPAGENT, 1, str, __FILE__, __LINE__);
+
+ } catch (const boost::thread_resource_error &e) {
+ std::stringstream msg;
+ msg << "snmp function start failed : " << e.what() << ".";
+
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 4, msg.str(), __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg.str());
+ }
+ }
+
+ /*!
+ * snmpagent function stop.
+ *
+ * @retrun void
+ */
+ void snmpagent_impl::stop()
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 37, "snmpagent_impl::stop", __FILE__, __LINE__);
+
+ enabled = FALSE;
+
+ if (!start_flag) {
+ std::string str = "snmp function has already stoped.";
+ Logger::putLogInfo(LOG_CAT_L7VSD_SNMPAGENT, 2, str, __FILE__, __LINE__);
+ return;
+ }
+
+ start_flag = false;
+
+ try {
+ trap_thread.interrupt();
+ process_mib_thread.join();
+ trap_thread.join();
+
+ std::string str = "snmp function stop.";
+ Logger::putLogInfo(LOG_CAT_L7VSD_SNMPAGENT, 3, str, __FILE__, __LINE__);
+
+ } catch (const boost::thread_interrupted&) {
+ std::stringstream msg;
+ msg << "thread interrupted exception.";
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 5, msg.str(), __FILE__, __LINE__);
+ }
+ }
+
+ /*!
+ * set snmp function enable
+ *
+ * @retrun void
+ */
+ void snmpagent_impl::enable() {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 38, "snmpagent_impl::enable", __FILE__, __LINE__);
+
+ //set snmp function enable flag
+ enabled = TRUE;
+ if (start_flag == false) {
+ error_code err;
+ start(err);
+
+ if (err) {
+ std::stringstream msg;
+ msg << "snmp function start failed.";
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 6, msg.str(), __FILE__, __LINE__);
+ }
+ }
+ else {
+ std::string str = "snmp function has already started.";
+ Logger::putLogInfo(LOG_CAT_L7VSD_SNMPAGENT, 4, str, __FILE__, __LINE__);
+ }
+ }
+
+ /*!
+ * set snmp function disable
+ *
+ * @retrun void
+ */
+ void snmpagent_impl::disable() {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 39, "snmpagent_impl::disable", __FILE__, __LINE__);
+
+ //set snmp function enable flag
+ enabled = FALSE;
+ if (start_flag == true) {
+ stop();
+ }
+ else {
+ std::string str = "snmp function has already stoped.";
+ Logger::putLogInfo(LOG_CAT_L7VSD_SNMPAGENT, 5, str, __FILE__, __LINE__);
+ }
+ }
+
+ /*!
+ * set log trap enable
+ * @retrun void
+ */
+ void snmpagent_impl::logtrap_enable() {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 40, "snmpagent_impl::logtrap_enable", __FILE__, __LINE__);
+
+ logtrap_enabled = TRUE;
+ Logger::logtrap_enable();
+ }
+
+ /*!
+ * set log trap disable
+ * @retrun void
+ */
+ void snmpagent_impl::logtrap_disable() {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 41, "snmpagent_impl::logtrap_disable", __FILE__, __LINE__);
+
+ logtrap_enabled = FALSE;
+ Logger::logtrap_disable();
+ }
+
+ /*!
+ * set log trap level.
+ *
+ * @param[in] in_level is log trap level
+ * @retrun void
+ */
+ void snmpagent_impl::set_logtrap_level(const LOG_LEVEL_TAG in_level)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 42, "snmpagent_impl::set_logtrap_level", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpagent_impl::set_logtrap_level arguments:";
+ debugstr << boost::format("in_level=%d") % in_level;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 43, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ logtrap_level = in_level;
+ Logger::set_logtrap_level(in_level);
+ }
+
+ /*!
+ * set mib cache update interval.
+ *
+ * @param[in] in_interval is cache update interval
+ * @retrun void
+ */
+ void snmpagent_impl::set_interval(const unsigned int in_interval)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 44, "snmpagent_impl::set_interval", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpagent_impl::set_interval arguments:";
+ debugstr << boost::format("in_interval=%d") % in_interval;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 45, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+ interval = in_interval;
+ }
+
+ /*!
+ * refresh all the statistics.
+ *
+ * @return void
+ */
+ void snmpagent_impl::refresh_all_statistics()
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 46, "snmpagent_impl::refresh_all_statistics", __FILE__, __LINE__);
+
+ if (vsd == NULL) {
+ //mib collect failed
+ std::string msg("vsd pointer is NULL.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 7, msg, __FILE__, __LINE__);
+ return;
+ }
+
+ boost::mutex &virtualservice_list_mutex = vsd->get_virtualservice_list_mutex();
+
+ boost::mutex::scoped_lock lock(virtualservice_list_mutex);
+
+ l7vsd::vslist_type &virtualservice_list = vsd->get_virtualservice_list();
+
+ for (l7vsd::vslist_type::iterator it = virtualservice_list.begin();
+ it != virtualservice_list.end(); it++) {
+
+ //clear real server inactive count
+ (*it)->clear_inact();
+ protocol_module_base *protocol_module_ptr = (*it)->get_protocol_module();
+ stats_base& bstats = protocol_module_ptr->get_stats();
+ if ( bstats.get_mode() == stats_base::MODE_HTTP ) {
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::string debugstr = "function : snmpagent_impl::refresh_all_statistics :"
+ "stats_base::MODE_HTTP mode virtual service.";
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 47, debugstr, __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ http_stats &hstats = static_cast<http_stats&>(bstats);
+ hstats.http_requests = 0ULL;
+ hstats.http_get_requests = 0ULL;
+ hstats.http_post_requests = 0ULL;
+ }
+ }
+ }
+
+ /*!
+ * refresh a special virtual service's statistics.
+ *
+ * @param[in] vs_endpoint is virtual service's endpoint
+ * @param[in] protocol is virtual service's protocol
+ * @return void
+ */
+ void snmpagent_impl::refresh_statistics(const boost::asio::ip::tcp::endpoint& vs_endpoint, const std::string& protocol)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 48, "snmpagent_impl::refresh_statistics", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpagent_impl::refresh_statistics arguments:";
+ if (vs_endpoint.address().is_v6()) {
+ debugstr << boost::format("vs_endpoint=[%s]:%d") % vs_endpoint.address().to_string() % vs_endpoint.port();
+ } else {
+ debugstr << boost::format("vs_endpoint=%s:%d") % vs_endpoint.address().to_string() % vs_endpoint.port();
+ }
+ debugstr << boost::format("protocol=%s") % protocol;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 49, debugstr.str(), __FILE__, __LINE__);
+ }
+
+ if (vsd == NULL) {
+ //mib collect failed
+ std::string msg("vsd pointer is NULL.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 8, msg, __FILE__, __LINE__);
+ return;
+ }
+
+ boost::mutex &virtualservice_list_mutex = vsd->get_virtualservice_list_mutex();
+
+ boost::mutex::scoped_lock lock(virtualservice_list_mutex);
+ l7vsd::vslist_type &virtualservice_list = vsd->get_virtualservice_list();
+
+ virtualservice_element in_vselement;
+ in_vselement.udpmode = 0;
+ in_vselement.protocol_module_name = protocol;
+ in_vselement.tcp_accept_endpoint = vs_endpoint;
+
+ l7vsd::vslist_type::iterator it = vsd->search_vslist(in_vselement, true);
+
+ if (it != virtualservice_list.end()) {
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::string debugstr = "function : snmpagent_impl::refresh_statistics :"
+ "input virtual service has found.";
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 50, debugstr, __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ //clear real server inactive count
+ (*it)->clear_inact();
+
+ protocol_module_base *protocol_module_ptr = (*it)->get_protocol_module();
+ stats_base& base_stats = protocol_module_ptr->get_stats();
+ if ( base_stats.get_mode() == stats_base::MODE_HTTP ) {
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::string debugstr = "function : snmpagent_impl::refresh_statistics :"
+ "stats_base::MODE_HTTP mode virtual service.";
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 51, debugstr, __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ http_stats &httpstats = static_cast<http_stats&>(base_stats);
+ //clear http statstics
+ httpstats.http_requests = 0ULL;
+ httpstats.http_get_requests = 0ULL;
+ httpstats.http_post_requests = 0ULL;
+
+ }
+ }
+ }
+
+ /*!
+ * set vsd infomation.
+ *
+ * @param[in] vsd is vsd pointer.
+ * @retrun void
+ */
+ void snmpagent_impl::set_vsd_info(l7vsd* in_vsd)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 52, "snmpagent_impl::set_vsd_info", __FILE__, __LINE__);
+
+ vsd = in_vsd;
+ }
+
+ /*!
+ * get snmp infomation.
+ *
+ * @retrun snmp_info is snmp infomation.
+ */
+ snmp_info snmpagent_impl::get_snmp_info()
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 53, "snmpagent_impl::get_snmp_info", __FILE__, __LINE__);
+ snmp_info snmpinfo;
+
+ //push the local variable into snmp info
+ snmpinfo.enabled = enabled.get();
+ snmpinfo.interval = interval.get();
+ snmpinfo.logtrap_enabled = logtrap_enabled;
+ snmpinfo.logtrap_level = logtrap_level;
+ snmpinfo.request_last_date = request_last_date.get();
+ snmpinfo.snmp_get_requests = snmp_get_requests.get();
+ snmpinfo.snmp_set_requests = snmp_set_requests.get();
+ snmpinfo.snmp_trap_count = snmp_trap_count.get();
+ snmpinfo.start_date = start_date.get();
+ snmpinfo.trap_last_date = trap_last_date.get();
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::ostringstream debugstr;
+ debugstr << "function : snmpagent_impl::get_snmp_info : snmpinfo : ";
+ debugstr << snmpinfo << ".";
+
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 54, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+ return snmpinfo;
+ }
+
+ /*!
+ * load configure file setting.
+ *
+ * @retrun void
+ */
+ void snmpagent_impl::load_config()
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 55, "snmpagent_impl::load_config", __FILE__, __LINE__);
+ l7vs::Parameter param;
+ l7vs::error_code err;
+
+ std::string tmp_str = param.get_string(l7vs::PARAM_COMP_SNMPAGENT, "enable", err);
+ if (!err) {
+ if (tmp_str == "true") {
+ enabled = TRUE;
+ } else if (tmp_str == "false") {
+ enabled = FALSE;
+ } else {
+ enabled = FALSE;
+ std::string msg("enable parameter value is invalid. Use default value.");
+ Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 1, msg, __FILE__, __LINE__);
+ }
+ } else {
+ enabled = FALSE;
+ std::string msg("enable parameter not found. Use default value.");
+ Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 2, msg, __FILE__, __LINE__);
+ }
+
+ int tmp_int = param.get_int(l7vs::PARAM_COMP_SNMPAGENT, "trap_queue_polling_interval", err);
+
+ if (!err) {
+ if ((tmp_int > 0) && (tmp_int < SNMP_MAX_TRAP_POLLING_INTEVAL)) {
+ trap_polling_interval = tmp_int;
+ } else {
+ trap_polling_interval = SNMP_DEFAULT_TRAP_POLLING_INTEVAL;
+ std::string msg("trap_queue_polling_interval parameter value is invalid. Use default value.");
+ Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 3, msg, __FILE__, __LINE__);
+ }
+ } else {
+ trap_polling_interval = SNMP_DEFAULT_TRAP_POLLING_INTEVAL;
+ std::string msg("trap_queue_polling_interval parameter not found. Use default value.");
+ Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 4, msg, __FILE__, __LINE__);
+ }
+
+ tmp_int = param.get_int(l7vs::PARAM_COMP_SNMPAGENT, "trap_queue_max_size", err);
+ if (!err) {
+ if (tmp_int > 0) {
+ trap_queue_max_size = tmp_int;
+ } else {
+ trap_queue_max_size = SNMP_DEFAULT_TRAP_QUEUE_MAX_SIZE;
+ std::string msg("trap_queue_max_size parameter value is invalid. Use default value.");
+ Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 5, msg, __FILE__, __LINE__);
+ }
+ } else {
+ trap_queue_max_size = SNMP_DEFAULT_TRAP_QUEUE_MAX_SIZE;
+ std::string msg("trap_queue_max_size parameter not found. Use default value.");
+ Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 6, msg, __FILE__, __LINE__);
+ }
+
+ tmp_int = param.get_int(l7vs::PARAM_COMP_SNMPAGENT, "cache_update_interval", err);
+ if (!err) {
+ if (tmp_int >= 0) {
+ interval = tmp_int;
+ } else {
+ interval = 1;
+ std::string msg("cache_update_interval parameter value is invalid. Use default value.");
+ Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 7, msg, __FILE__, __LINE__);
+ }
+ } else {
+ interval = 1;
+ std::string msg("cache_update_interval parameter not found. Use default value.");
+ Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 8, msg, __FILE__, __LINE__);
+ }
+
+ tmp_str = param.get_string(l7vs::PARAM_COMP_SNMPAGENT, "logtrap", err);
+ if (!err) {
+ if (tmp_str == "true") {
+ logtrap_enable();
+ } else {
+ logtrap_disable();
+ std::string msg("logtrap parameter value is invalid. Use default value.");
+ Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 9, msg, __FILE__, __LINE__);
+ }
+ } else {
+ logtrap_disable();
+ std::string msg("logtrap parameter not found. Use default value.");
+ Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 10, msg, __FILE__, __LINE__);
+ }
+
+ tmp_str = param.get_string(l7vs::PARAM_COMP_SNMPAGENT, "logtrap_level", err);
+ if (!err) {
+ string_loglevel_map_type::iterator itr = string_loglevel_map.find(tmp_str);
+ if (itr != string_loglevel_map.end()) {
+ set_logtrap_level(itr->second);
+ } else {
+ set_logtrap_level( LOG_LV_WARN);
+ std::string msg("logtrap_level parameter value is invalid. Use default value.");
+ Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 11, msg, __FILE__, __LINE__);
+ }
+ } else {
+ set_logtrap_level(LOG_LV_WARN);
+ std::string msg("logtrap_level parameter not found. Use default value.");
+ Logger::putLogWarn(LOG_CAT_L7VSD_SNMPAGENT, 12, msg, __FILE__, __LINE__);
+ }
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "function : snmpagent_impl::load_config : ";
+ debugstr << "enabled = [" << enabled.get() << "], ";
+ debugstr << "interval = [" << interval.get() << "], ";
+ debugstr << "logtrap_enabled = [" << logtrap_enabled << "], ";
+ debugstr << "logtrap_level = [" << static_cast<int>(logtrap_level) << "], ";
+ debugstr << "trap_polling_interval = [" << trap_polling_interval.get() << "], ";
+ debugstr << "trap_queue_max_size = [" << trap_queue_max_size.get() << "]. ";
+
+ Logger::putLogDebug(l7vs::LOG_CAT_L7VSD_SNMPAGENT, 56, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+ }
+
+ /*!
+ * collect mib data.
+ *
+ * @param[in] error_code is err code.
+ * @retrun void
+ */
+ void snmpagent_impl::collect_mibdata(error_code& err)
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 57, "snmpagent_impl::collect_mibdata", __FILE__, __LINE__);
+
+ //check vsd pointer
+ if (vsd == NULL) {
+ std::string msg("vsd pointer is NULL.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 9, msg, __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg);
+ return;
+ }
+
+ //check timeout
+ if (!check_timeout()) {
+
+ //collect mib data
+ mibdata::get_instance().collect_mibdata(vsd, err);
+
+ if (err) {
+ std::string msg("collect mib data failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 10, msg, __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg);
+ return;
+ }
+
+ boost::posix_time::ptime now_time(boost::posix_time::second_clock::local_time());
+ mib_collect_last_time = now_time;
+
+ }
+
+ //update last request date
+ request_last_date = time(NULL);
+ }
+
+ /*!
+ * finalize.
+ *
+ * @retrun void
+ */
+ void snmpagent_impl::finalize()
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 58, "snmpagent_impl::finalize", __FILE__, __LINE__);
+
+ if (start_flag == true) {
+ stop();
+ }
+ snmp_shutdown("l7vsAgent");
+ SOCK_CLEANUP;
+ }
+
+ /*!
+ * increment get request count.
+ *
+ * @retrun void
+ */
+ void snmpagent_impl::increment_getrequest_count()
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 59, "snmpagent_impl::increment_getrequest_count", __FILE__, __LINE__);
+ snmp_get_requests++;
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::ostringstream debugstr;
+ debugstr << "function : snmpagent_impl::increment_getrequest_count : snmp_get_requests = ";
+ debugstr << snmp_get_requests.get() << ".";
+
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 60, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+ }
+
+ /*!
+ * increment set request count.
+ *
+ * @retrun void
+ */
+ void snmpagent_impl::increment_setrequest_count()
+ {
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 61, "snmpagent_impl::increment_setrequest_count", __FILE__, __LINE__);
+ snmp_set_requests++;
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::ostringstream debugstr;
+ debugstr << "function : snmpagent_impl::increment_getrequest_count : snmp_set_requests = ";
+ debugstr << snmp_set_requests.get() << ".";
+
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 62, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+ }
+
+}
--- /dev/null
+/*!
+ * @file snmpfunc.cpp
+ * @brief snmp function module.
+ *
+ * L7VSD: Linux Virtual Server for Layer7 Load Balancing
+ * Copyright (C) 2010 NTT COMWARE Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ *
+ **********************************************************************/
+/*
+ * Note: this file originally auto-generated by mib2c using
+ * : mib2c.create-dataset.conf 17337 2009-01-01 14:28:29Z magfr $
+ * : mib2c.scalar.conf 17337 2009-01-01 14:28:29Z magfr $
+ * : mib2c.notify.conf 17455 2009-04-05 09:53:29Z magfr $
+ */
+#include "mibdata.h"
+#include "snmpagent_impl.h"
+#include "snmpfunc.h"
+
+static const oid snmptrap_oid[] = { 1, 3, 6, 1, 6, 3, 1, 1, 4, 1, 0 };
+netsnmp_table_data_set *vs_table;
+netsnmp_table_data_set *rs_table;
+
+
+/*!
+ * initialize snmp scaler and table data set handles.
+ *
+ * @param[in] error_code& is trap error code
+ * @retrun void
+ */
+void
+init_snmp_handles(error_code& err)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 76, "snmpfunc::init_snmp_handles", __FILE__, __LINE__);
+
+ oid l7vsVsNumber_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 1, 1, 1 };
+ oid l7vsReplicationMode_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 1, 1, 4 };
+
+ DEBUGMSGTL(("ultramonkey_l7", "init_snmp_handles\n"));
+
+ int ret = netsnmp_register_scalar(netsnmp_create_handler_registration
+ ("l7vsVsNumber", handle_get_vstable_count,
+ l7vsVsNumber_oid,
+ OID_LENGTH(l7vsVsNumber_oid),
+ HANDLER_CAN_RONLY));
+
+ if ( ret ) {
+ std::string msg("netsnmp_register_scalar failed.");
+ Logger::putLogFatal(LOG_CAT_L7VSD_SNMPAGENT, 4, msg, __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg);
+ return;
+ }
+
+ ret = netsnmp_register_scalar(netsnmp_create_handler_registration
+ ("l7vsReplicationMode",
+ handle_get_rep_state,
+ l7vsReplicationMode_oid,
+ OID_LENGTH(l7vsReplicationMode_oid),
+ HANDLER_CAN_RONLY));
+
+ if (ret) {
+ std::string msg("netsnmp_register_scalar failed.");
+ Logger::putLogFatal(LOG_CAT_L7VSD_SNMPAGENT, 5, msg, __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg);
+ return;
+ }
+
+ /*
+ * here we initialize all the tables we're planning on supporting
+ */
+ initialize_virtual_service_table(err);
+
+ if (ret) return;
+
+ initialize_real_server_table(err);
+
+ if (ret) return;
+}
+
+/*!
+ * handle for virtual service count.
+ *
+ */
+int
+handle_get_vstable_count(netsnmp_mib_handler *handler,
+ netsnmp_handler_registration *reginfo,
+ netsnmp_agent_request_info *reqinfo,
+ netsnmp_request_info *requests)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 77, "snmpfunc::handle_get_vstable_count", __FILE__, __LINE__);
+ /*
+ * 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: {
+ error_code err;
+ //collect mibdata
+ l7vs::snmpagent_impl::get_instance().collect_mibdata(err);
+
+ if (err) {
+ std::string msg("collect mib data failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 19, msg, __FILE__, __LINE__);
+
+ return SNMP_ERR_GENERR;
+ }
+
+ //get virtual serveice size
+ int rep_state = l7vs::mibdata::get_instance().get_vs_table_size();
+
+ //set value
+ int ret = snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
+ (u_char *)&rep_state,
+ sizeof(int));
+
+ if (ret) {
+ std::string msg("snmp_set_var_typed_value failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 20, msg, __FILE__, __LINE__);
+
+ return SNMP_ERR_GENERR;
+ }
+
+ snmpagent_impl::get_instance().increment_getrequest_count();
+ }
+ break;
+ default:
+ /*
+ * we should never get here, so this is a really bad error
+ */
+ snmp_log(LOG_ERR, "unknown mode (%d) in handle_get_vstable_count\n",
+ reqinfo->mode);
+ return SNMP_ERR_GENERR;
+ }
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * handle for replication state.
+ *
+ */
+int
+handle_get_rep_state(netsnmp_mib_handler *handler,
+ netsnmp_handler_registration *reginfo,
+ netsnmp_agent_request_info *reqinfo,
+ netsnmp_request_info *requests)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 78, "snmpfunc::handle_get_rep_state", __FILE__, __LINE__);
+
+ /*
+ * 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: {
+ error_code err;
+ //collect mibdata
+ l7vs::snmpagent_impl::get_instance().collect_mibdata(err);
+
+ if (err) {
+ std::string msg("collect mib data failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 21, msg, __FILE__, __LINE__);
+
+ return SNMP_ERR_GENERR;
+ }
+
+ //get replication state
+ int rep_state = l7vs::mibdata::get_instance().get_replication_state();
+
+
+ //set value
+ int ret = snmp_set_var_typed_value(requests->requestvb, ASN_INTEGER,
+ (u_char *)&rep_state,
+ sizeof(int));
+
+ if (ret) {
+ std::string msg("snmp_set_var_typed_value failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 22, msg, __FILE__, __LINE__);
+
+ return SNMP_ERR_GENERR;
+ }
+
+ snmpagent_impl::get_instance().increment_getrequest_count();
+ }
+ break;
+ default:
+ /*
+ * we should never get here, so this is a really bad error
+ */
+ snmp_log(LOG_ERR,
+ "unknown mode (%d) in handle_get_rep_state\n",
+ reqinfo->mode);
+ return SNMP_ERR_GENERR;
+ }
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * initialize virtual service table data set.
+ *
+ * @param[in] error_code& is trap error code
+ * @retrun void
+ */
+void
+initialize_virtual_service_table(error_code &err)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 79, "snmpfunc::initialize_virtual_service_table", __FILE__, __LINE__);
+
+ oid l7vsVsTable_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 1, 1, 2 };
+
+ /*
+ * create the table structure itself
+ */
+ vs_table = netsnmp_create_table_data_set("l7vsVsTable");
+
+ if (!vs_table) {
+ std::string msg("netsnmp create l7vsVsTable data set failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 23, msg, __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg);
+ return;
+ }
+
+ //set data set into mibdata
+ mibdata::get_instance().set_vs_table(vs_table);
+
+ /*
+ * comment this out or delete if you don't support creation of new rows
+ */
+ vs_table->allow_creation = 1;
+
+ /***************************************************
+ * Adding indexes
+ */
+ DEBUGMSGTL(("initialize_virtual_service_table",
+ "adding indexes to table l7vsVsTable\n"));
+ netsnmp_table_set_add_indexes(vs_table, ASN_INTEGER, /* index: l7vsVsIndex */
+ 0);
+
+ DEBUGMSGTL(("initialize_virtual_service_table",
+ "adding column types to table l7vsVsTable\n"));
+ netsnmp_table_set_multi_add_default_row(vs_table,
+ COLUMN_L7VSVSINDEX,
+ ASN_INTEGER, 0, NULL, 0,
+ COLUMN_L7VSVSPROTOCOL,
+ ASN_INTEGER, 0, NULL, 0,
+ COLUMN_L7VSVSADDRTYPE,
+ ASN_INTEGER, 0, NULL, 0,
+ COLUMN_L7VSVSADDR,
+ ASN_OCTET_STR, 0, NULL, 0,
+ COLUMN_L7VSVSPORT,
+ ASN_UNSIGNED, 0, NULL, 0,
+ COLUMN_L7VSVSPROTOCOLMODULENAME,
+ ASN_OCTET_STR, 0, NULL, 0,
+ COLUMN_L7VSVSPROTOCOLMODULEOPTIONS,
+ ASN_OCTET_STR, 0, NULL, 0,
+ COLUMN_L7VSVSSCHEDULEMODULENAME,
+ ASN_OCTET_STR, 0, NULL, 0,
+ COLUMN_L7VSVSSCHEDULEMODULEOPTIONS,
+ ASN_OCTET_STR, 0, NULL, 0,
+ COLUMN_L7VSVSSORRYADDRTYPE,
+ ASN_INTEGER, 0, NULL, 0,
+ COLUMN_L7VSVSSORRYADDR,
+ ASN_OCTET_STR, 0, NULL, 0,
+ COLUMN_L7VSVSSORRYPORT,
+ ASN_UNSIGNED, 0, NULL, 0,
+ COLUMN_L7VSVSSORRYCONNLIMIT,
+ ASN_COUNTER64, 0, NULL, 0,
+ COLUMN_L7VSVSSORRYFORCEENABLED,
+ ASN_INTEGER, 0, NULL, 0,
+ COLUMN_L7VSVSTHROUGHPUTUP,
+ ASN_COUNTER64, 0, NULL, 0,
+ COLUMN_L7VSVSTHROUGHPUTDOWN,
+ ASN_COUNTER64, 0, NULL, 0,
+ COLUMN_L7VSVSTHROUGHPUTUPQOS,
+ ASN_COUNTER64, 0, NULL, 0,
+ COLUMN_L7VSVSTHROUGHPUTDOWNQOS,
+ ASN_COUNTER64, 0, NULL, 0,
+ COLUMN_L7VSVSSSLFLAG,
+ ASN_INTEGER, 0, NULL, 0,
+ COLUMN_L7VSVSSESSIONPOOLCOUNT,
+ ASN_INTEGER, 0, NULL, 0,
+ COLUMN_L7VSVSSESSIONACTIVECOUNT,
+ ASN_INTEGER, 0, NULL, 0,
+ COLUMN_L7VSVSSESSIONWAITCOUNT,
+ ASN_INTEGER, 0, NULL, 0,
+ COLUMN_L7VSVSHTTPTOTALCOUNT,
+ ASN_COUNTER64, 0, NULL, 0,
+ COLUMN_L7VSVSHTTPGETCOUNT,
+ ASN_COUNTER64, 0, NULL, 0,
+ COLUMN_L7VSVSHTTPPOSTCOUNT,
+ ASN_COUNTER64, 0, NULL, 0,
+ COLUMN_L7VSVSRSNUMBER,
+ ASN_INTEGER, 0, NULL, 0, 0);
+
+ /*
+ * registering the table with the master agent
+ */
+ /*
+ * note: if you don't need a subhandler to deal with any aspects
+ * of the request, change handle_get_vstable to "NULL"
+ */
+ int ret = netsnmp_register_table_data_set(netsnmp_create_handler_registration
+ ("l7vsVsTable", handle_get_vstable,
+ l7vsVsTable_oid,
+ OID_LENGTH(l7vsVsTable_oid),
+ HANDLER_CAN_RWRITE), vs_table, NULL);
+
+ if (ret) {
+ std::string msg("netsnmp create l7vsVsTable data set failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 24, msg, __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg);
+ return;
+ }
+}
+
+/*!
+ * initialize real server table data set.
+ *
+ * @param[in] error_code& is trap error code
+ * @retrun void
+ */
+void
+initialize_real_server_table(error_code &err)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 80, "snmpfunc::initialize_real_server_table", __FILE__, __LINE__);
+
+ oid l7vsRsTable_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 1, 1, 3 };
+
+ /*
+ * create the table structure itself
+ */
+ rs_table = netsnmp_create_table_data_set("l7vsRsTable");
+
+ if (!rs_table) {
+ std::string msg("netsnmp create l7vsRsTable data set failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 25, msg, __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg);
+ return;
+ }
+
+ //set data set into mibdata
+ mibdata::get_instance().set_rs_table(rs_table);
+ /*
+ * comment this out or delete if you don't support creation of new rows
+ */
+ rs_table->allow_creation = 1;
+
+ /***************************************************
+ * Adding indexes
+ */
+ DEBUGMSGTL(("initialize_real_server_table",
+ "adding indexes to table l7vsRsTable\n"));
+ netsnmp_table_set_add_indexes(rs_table, ASN_INTEGER, /* index: l7vsRsIndex */
+ 0);
+
+ DEBUGMSGTL(("initialize_real_server_table",
+ "adding column types to table l7vsRsTable\n"));
+ netsnmp_table_set_multi_add_default_row(rs_table,
+ COLUMN_L7VSRSINDEX,
+ ASN_INTEGER, 0, NULL, 0,
+ COLUMN_L7VSRSVSINDEX,
+ ASN_INTEGER, 0, NULL, 0,
+ COLUMN_L7VSRSADDRTYPE,
+ ASN_INTEGER, 0, NULL, 0,
+ COLUMN_L7VSRSADDR,
+ ASN_OCTET_STR, 0, NULL, 0,
+ COLUMN_L7VSRSPORT,
+ ASN_UNSIGNED, 0, NULL, 0,
+ COLUMN_L7VSRSFORWARD,
+ ASN_INTEGER, 0, NULL, 0,
+ COLUMN_L7VSRSWEIGHT,
+ ASN_INTEGER, 0, NULL, 0,
+ COLUMN_L7VSRSACTIVECONN,
+ ASN_INTEGER, 0, NULL, 0,
+ COLUMN_L7VSRSINACTIVECONN,
+ ASN_INTEGER, 0, NULL, 0, 0);
+
+ /*
+ * registering the table with the master agent
+ */
+ /*
+ * note: if you don't need a subhandler to deal with any aspects
+ * of the request, change handle_get_rstable to "NULL"
+ */
+ int ret = netsnmp_register_table_data_set(netsnmp_create_handler_registration
+ ("l7vsRsTable", handle_get_rstable,
+ l7vsRsTable_oid,
+ OID_LENGTH(l7vsRsTable_oid),
+ HANDLER_CAN_RWRITE), rs_table, NULL);
+
+ if (ret) {
+ std::string msg("netsnmp create l7vsRsTable data set failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 26, msg, __FILE__, __LINE__);
+ //set error code
+ err.setter(true, msg);
+ return;
+ }
+
+}
+
+/*!
+ * handle for virtual service table.
+ *
+ */
+int
+handle_get_vstable(netsnmp_mib_handler *handler,
+ netsnmp_handler_registration *reginfo,
+ netsnmp_agent_request_info *reqinfo,
+ netsnmp_request_info *requests)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 81, "snmpfunc::handle_get_vstable", __FILE__, __LINE__);
+
+ /*
+ * perform anything here that you need to do. The requests have
+ * already been processed by the master table_dataset handler, but
+ * this gives you chance to act on the request in some other way
+ * if need be.
+ */
+ error_code err;
+ //collect mibdata
+ l7vs::snmpagent_impl::get_instance().collect_mibdata(err);
+
+ if (err) {
+ std::string msg("collect mib data failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 27, msg, __FILE__, __LINE__);
+
+ return SNMP_ERR_GENERR;
+ }
+
+ snmpagent_impl::get_instance().increment_getrequest_count();
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * handle for real server table.
+ *
+ */
+int
+handle_get_rstable(netsnmp_mib_handler *handler,
+ netsnmp_handler_registration *reginfo,
+ netsnmp_agent_request_info *reqinfo,
+ netsnmp_request_info *requests)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 82, "snmpfunc::handle_get_rstable", __FILE__, __LINE__);
+
+ /*
+ * perform anything here that you need to do. The requests have
+ * already been processed by the master table_dataset handler, but
+ * this gives you chance to act on the request in some other way
+ * if need be.
+ */
+ error_code err;
+ //collect mibdata
+ l7vs::snmpagent_impl::get_instance().collect_mibdata(err);
+
+ if (err) {
+ std::string msg("collect mib data failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 28, msg, __FILE__, __LINE__);
+
+ return SNMP_ERR_GENERR;
+ }
+
+ snmpagent_impl::get_instance().increment_getrequest_count();
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send service start trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_service_start(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 83, "snmpfunc::trap_service_start", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_service_start arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 84, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsServiceStart_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 1, 1 };
+
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid,
+ OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsServiceStart_oid,
+ sizeof(l7vsServiceStart_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 29, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsServiceStart_oid,
+ OID_LENGTH(l7vsServiceStart_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 30, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send service stop trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_service_stop(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 85, "snmpfunc::trap_service_stop", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_service_stop arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 86, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsServiceStop_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 1, 2 };
+
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid,
+ OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsServiceStop_oid,
+ sizeof(l7vsServiceStop_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 31, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsServiceStop_oid,
+ OID_LENGTH(l7vsServiceStop_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 32, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send virtual service add trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_vs_add(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 87, "snmpfunc::trap_vs_add", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_vs_add arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 88, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsBalancingVsAdd_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 1 };
+
+
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid, OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsBalancingVsAdd_oid,
+ sizeof(l7vsBalancingVsAdd_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 33, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsBalancingVsAdd_oid,
+ OID_LENGTH(l7vsBalancingVsAdd_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 34, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Add any extra (optional) objects here
+ */
+
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send virtual service change trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_vs_change(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 89, "snmpfunc::trap_vs_change", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_vs_change arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 90, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsBalancingVsChange_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 2 };
+
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid, OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsBalancingVsChange_oid,
+ sizeof(l7vsBalancingVsChange_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 35, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsBalancingVsChange_oid,
+ OID_LENGTH(l7vsBalancingVsChange_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 36, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Add any extra (optional) objects here
+ */
+
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send virtual service remove trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_vs_remove(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 91, "snmpfunc::trap_vs_remove", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_vs_remove arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 92, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsBalancingVsRemove_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 3 };
+
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid, OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsBalancingVsRemove_oid,
+ sizeof(l7vsBalancingVsRemove_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 37, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsBalancingVsRemove_oid,
+ OID_LENGTH(l7vsBalancingVsRemove_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 38, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Add any extra (optional) objects here
+ */
+
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send real server add trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_rs_add(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 93, "snmpfunc::trap_rs_add", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_rs_add arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 94, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsBalancingRsAdd_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 4 };
+
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid, OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsBalancingRsAdd_oid,
+ sizeof(l7vsBalancingRsAdd_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 39, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsBalancingRsAdd_oid,
+ OID_LENGTH(l7vsBalancingRsAdd_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 40, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Add any extra (optional) objects here
+ */
+
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send real server change trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_rs_change(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 95, "snmpfunc::trap_rs_change", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_rs_change arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 96, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsBalancingRsChange_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 5 };
+
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid, OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsBalancingRsChange_oid,
+ sizeof(l7vsBalancingRsChange_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 41, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsBalancingRsChange_oid,
+ OID_LENGTH(l7vsBalancingRsChange_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 42, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Add any extra (optional) objects here
+ */
+
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send real server remove trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_rs_remove(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 97, "snmpfunc::trap_rs_remove", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_rs_remove arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 98, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsBalancingRsRemove_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 6 };
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid, OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsBalancingRsRemove_oid,
+ sizeof(l7vsBalancingRsRemove_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 43, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsBalancingRsRemove_oid,
+ OID_LENGTH(l7vsBalancingRsRemove_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 44, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Add any extra (optional) objects here
+ */
+
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send upstream QoS alert on trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_up_qos_alert_on(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 99, "snmpfunc::trap_up_qos_alert_on", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_up_qos_alert_on arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 100, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsBalancingUpQoSAlertOn_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 7 };
+
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid, OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsBalancingUpQoSAlertOn_oid,
+ sizeof(l7vsBalancingUpQoSAlertOn_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 45, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsBalancingUpQoSAlertOn_oid,
+ OID_LENGTH(l7vsBalancingUpQoSAlertOn_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 46, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Add any extra (optional) objects here
+ */
+
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send upstream QoS alert off trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_up_qos_alert_off(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 101, "snmpfunc::trap_up_qos_alert_off", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_up_qos_alert_off arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 102, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsBalancingUpQoSAlertOff_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 8 };
+
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid, OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsBalancingUpQoSAlertOff_oid,
+ sizeof(l7vsBalancingUpQoSAlertOff_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 47, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsBalancingUpQoSAlertOff_oid,
+ OID_LENGTH(l7vsBalancingUpQoSAlertOff_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 48, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Add any extra (optional) objects here
+ */
+
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send downstream QoS alert on trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_down_qos_alert_on(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 103, "snmpfunc::trap_down_qos_alert_on", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_down_qos_alert_on arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 104, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsBalancingDownQoSAlertOn_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 9 };
+
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid, OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsBalancingDownQoSAlertOn_oid,
+ sizeof(l7vsBalancingDownQoSAlertOn_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 49, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsBalancingDownQoSAlertOn_oid,
+ OID_LENGTH(l7vsBalancingDownQoSAlertOn_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 50, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Add any extra (optional) objects here
+ */
+
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send downstream QoS alert off trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_down_qos_alert_off(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 105, "snmpfunc::trap_down_qos_alert_off", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_down_qos_alert_off arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 106, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsBalancingDownQoSAlertOff_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 10 };
+
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid, OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsBalancingDownQoSAlertOff_oid,
+ sizeof(l7vsBalancingDownQoSAlertOff_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 51, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsBalancingDownQoSAlertOff_oid,
+ OID_LENGTH(l7vsBalancingDownQoSAlertOff_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 52, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Add any extra (optional) objects here
+ */
+
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send session pool alert on trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_sessionpool_alert_on(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 107, "snmpfunc::trap_sessionpool_alert_on", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_sessionpool_alert_on arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 108, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsBalancingSessionPoolAlertOn_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 11 };
+
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid, OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsBalancingSessionPoolAlertOn_oid,
+ sizeof(l7vsBalancingSessionPoolAlertOn_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 53, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsBalancingSessionPoolAlertOn_oid,
+ OID_LENGTH(l7vsBalancingSessionPoolAlertOn_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 54, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Add any extra (optional) objects here
+ */
+
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send session pool alert off trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_sessionpool_alert_off(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 109, "snmpfunc::trap_sessionpool_alert_off", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_sessionpool_alert_off arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 110, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsBalancingSessionPoolAlertOff_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 2, 12 };
+
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid, OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsBalancingSessionPoolAlertOff_oid,
+ sizeof
+ (l7vsBalancingSessionPoolAlertOff_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 55, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsBalancingSessionPoolAlertOff_oid,
+ OID_LENGTH(l7vsBalancingSessionPoolAlertOff_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 56, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Add any extra (optional) objects here
+ */
+
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send fatal log trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_fatal(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 111, "snmpfunc::trap_fatal", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_fatal arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 112, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsLogFatal_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 3, 1 };
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid, OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsLogFatal_oid, sizeof(l7vsLogFatal_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 57, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsLogFatal_oid,
+ OID_LENGTH(l7vsLogFatal_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 58, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Add any extra (optional) objects here
+ */
+
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send error log trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_error(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 113, "snmpfunc::trap_error", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_error arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 114, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsLogError_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 3, 2 };
+
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid, OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsLogError_oid, sizeof(l7vsLogError_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 59, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsLogError_oid,
+ OID_LENGTH(l7vsLogError_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 60, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Add any extra (optional) objects here
+ */
+
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send warn log trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_warn(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 115, "snmpfunc::trap_warn", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_warn arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 116, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsLogWarn_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 3, 3 };
+
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid, OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsLogWarn_oid, sizeof(l7vsLogWarn_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 61, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsLogWarn_oid,
+ OID_LENGTH(l7vsLogWarn_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 62, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Add any extra (optional) objects here
+ */
+
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send info log trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_info(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 117, "snmpfunc::trap_info", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_info arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 118, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsLogInfo_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 3, 4 };
+
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid, OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsLogInfo_oid, sizeof(l7vsLogInfo_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 63, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsLogInfo_oid,
+ OID_LENGTH(l7vsLogInfo_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 64, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Add any extra (optional) objects here
+ */
+
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
+
+/*!
+ * send debug log trap.
+ *
+ * @param[in] std::string is trap message
+ * @retrun int success:SNMP_ERR_NOERROR failed:SNMP_ERR_GENERR
+ */
+int
+trap_debug(const std::string &in_trapmessage)
+{
+ Logger logger(LOG_CAT_L7VSD_SNMPAGENT, 119, "snmpfunc::trap_debug", __FILE__, __LINE__);
+
+ /*-------- DEBUG LOG --------*/
+ if (LOG_LV_DEBUG == Logger::getLogLevel(LOG_CAT_L7VSD_SNMPAGENT)) {
+ std::stringstream debugstr;
+ debugstr << "snmpfunc::trap_debug arguments:";
+ debugstr << boost::format("in_trapmessage=%s") % in_trapmessage;
+ Logger::putLogDebug(LOG_CAT_L7VSD_SNMPAGENT, 120, debugstr.str(), __FILE__, __LINE__);
+ }
+ /*------ DEBUG LOG END ------*/
+
+ netsnmp_variable_list *var_list = NULL;
+ netsnmp_variable_list *ret_list = NULL;
+ oid l7vsLogDebug_oid[] = { 1, 3, 6, 1, 4, 1, 32132, 1, 0, 3, 5 };
+
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ ret_list = snmp_varlist_add_variable(&var_list,
+ snmptrap_oid, OID_LENGTH(snmptrap_oid),
+ ASN_OBJECT_ID,
+ (u_char*)l7vsLogDebug_oid, sizeof(l7vsLogDebug_oid));
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 65, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+
+ ret_list = snmp_varlist_add_variable(&var_list,
+ l7vsLogDebug_oid,
+ OID_LENGTH(l7vsLogDebug_oid),
+ ASN_OCTET_STR,
+ (u_char*)in_trapmessage.c_str(),
+ in_trapmessage.length());
+ if (!ret_list) {
+ std::string msg("snmp_varlist_add_variable failed.");
+ Logger::putLogError(LOG_CAT_L7VSD_SNMPAGENT, 66, msg, __FILE__, __LINE__);
+ return SNMP_ERR_GENERR;
+ }
+ /*
+ * Add any extra (optional) objects here
+ */
+
+ /*
+ * Send the trap to the list of configured destinations
+ * and clean up
+ */
+ send_v2trap(var_list);
+ snmp_free_varbind(var_list);
+
+ return SNMP_ERR_NOERROR;
+}
OSDN Git Service
