summaryrefslogtreecommitdiff
path: root/cleopatre/application/spidnetsnmp/agent
diff options
context:
space:
mode:
authorTom Yang2012-06-05 19:21:16 +0530
committerTom Yang2012-06-12 20:58:49 +0530
commitede22930c3829c743bea7303605721d0322c84c5 (patch)
tree2dd9fc0ffcdc03211a5a8c421e5c08465189e8a3 /cleopatre/application/spidnetsnmp/agent
parent34870abcd34a940dee0d51cedff53beb2ff0d6fd (diff)
cleo/app/snmp[eoc]: implement the alarmgroup of the SCCN-ALARM-MIB, closes #3151
Diffstat (limited to 'cleopatre/application/spidnetsnmp/agent')
-rw-r--r--cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib.h4
-rw-r--r--cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib.h3
-rw-r--r--cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNAlarmsAndTraps.c628
-rw-r--r--cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNAlarmsAndTraps.h40
-rw-r--r--cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNAlarmsAndTraps_interface.c1132
-rw-r--r--cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNAlarmsAndTraps_interface.h74
-rw-r--r--cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNTraps.h1
-rw-r--r--cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNTraps/eocSCCNTraps.c450
-rw-r--r--cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNTraps/eocSCCNTraps.h46
9 files changed, 2376 insertions, 2 deletions
diff --git a/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib.h b/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib.h
index b1bacc82cf..ac635d76c9 100644
--- a/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib.h
+++ b/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib.h
@@ -1,4 +1,4 @@
//config_add_mib(SCCN-EOC-MIB)
-//config_add_mib(SCCN-EOC-ALARMS-MIB)
-//config_require(mstar-sccn-mib/sccn-alarm-mib)
+config_add_mib(SCCN-EOC-ALARMS-MIB)
+config_require(mstar-sccn-mib/sccn-alarm-mib)
//config_require(mstar-sccn-mib/sccn-eoc-mib)
diff --git a/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib.h b/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib.h
new file mode 100644
index 0000000000..1aa6d1cf7b
--- /dev/null
+++ b/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib.h
@@ -0,0 +1,3 @@
+config_require(mstar-sccn-mib/sccn-alarm-mib/eocSCCNTraps)
+config_require(mstar-sccn-mib/sccn-alarm-mib/eocSCCNAlarmsAndTraps)
+config_require(mstar-sccn-mib/sccn-alarm-mib/eocSCCNAlarmsAndTraps_interface)
diff --git a/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNAlarmsAndTraps.c b/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNAlarmsAndTraps.c
new file mode 100644
index 0000000000..4b5d5a3946
--- /dev/null
+++ b/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNAlarmsAndTraps.c
@@ -0,0 +1,628 @@
+
+#include <net-snmp/net-snmp-config.h>
+#include <net-snmp/net-snmp-includes.h>
+#include <net-snmp/agent/net-snmp-agent-includes.h>
+
+#include "eocSCCNAlarmsAndTraps.h"
+#include "eocSCCNTraps/eocSCCNTraps.h"
+
+/* include header with interface functions */
+#include "eocSCCNAlarmsAndTraps_interface.h"
+
+/**
+ * global trap counter
+ * if trap is issued for the first time, add new rows to snmpNotifyTable
+ * snmpTargetAddrTable and snmpTargetParamsTable
+ * for subsequently issued traps, modify existing rows of these tables
+ */
+int eoc_sccn_trap_count = 0;
+
+/**
+ * global maximum current alarm counter
+ * used to ensure that no more than LIBSPID_CURRENT_ALARMS_MAX_NUM are
+ * stored in alarm info file
+ */
+int eoc_sccn_max_alarm_count = 0;
+
+int sccn_trap_ip_count = LIBSPID_EOC_TRAP_SERVER_MAX;
+int sccn_trap_port;
+libspid_eoc_trap_entry_t eoc_sccn_trap_entry[LIBSPID_EOC_TRAP_SERVER_MAX];
+
+extern eoc_sccn_cnu_alarm_info_t
+ eoc_sccn_cnu_alarm_info[LIBSPID_ONLINE_INFO_LINE_MAX_NB];
+
+void
+init_eocSCCNAlarmsAndTraps (void)
+{
+ int value = LIBSPID_FALSE;
+ char trap_port_str[5];
+
+ DEBUGMSGTL (("eocSCCNAlarmsAndTraps",
+ "initializing (setting callback alarm)\n"));
+ char buffer[LIBSPID_LINE_MAX_LEN];
+ memset (eoc_sccn_cnu_alarm_info, 0, sizeof (eoc_sccn_cnu_alarm_info));
+
+ if (LIBSPID_SUCCESS != libspid_system_nscrtv_eponeoc_mod_eoc (&value))
+ {
+ syslog (LOG_DEBUG,
+ "eocSCCNAlarmsAndTraps: error getting mod eoc version!\n");
+ }
+
+ /* get trap parameters for notify and target tables */
+ if (LIBSPID_SUCCESS !=
+ libspid_config_read_item (LIBSPID_SNMP_CONF_PATH,
+ LIBSPID_SNMP_CONF_LABEL_TRAP_SERVER_PORT,
+ trap_port_str, LIBSPID_KEY_MAX_LEN))
+ {
+ syslog (LOG_DEBUG, "eocSCCNCnuTraps: error, couldn't get port ");
+ /* alarm sccn trap port set to default value */
+ sccn_trap_port = TRAP_PORT_DEFAULT_VALUE;
+ }
+ else
+ {
+ /**
+ * if the buffer read from config file is not correct,
+ * use default value
+ */
+ if(0 == (sccn_trap_port = strtol (trap_port_str, NULL, 10)))
+ sccn_trap_port = TRAP_PORT_DEFAULT_VALUE;
+ }
+ /*get the trap info from trap.conf */
+ if (LIBSPID_SUCCESS !=
+ libspid_eoc_trap_get_list (eoc_sccn_trap_entry, &sccn_trap_ip_count))
+ {
+ snmp_log (LOG_ERR, "eocSCCNCnuTrap.c-registerEoCAlarm \
+ eocSCCNCnuTraps_read_trap_item retrun error\n");
+ return SNMP_ERR_GENERR;
+ }
+
+ if (LIBSPID_TRUE == value)
+ {
+
+ /* make sure current alarm and trap files are empty at init */
+ if (0 != clearEoCSCCNCurrentAlarms ())
+ {
+ syslog (LOG_DEBUG, "eocSCCNAlarmsAndTraps: error clearing current\
+ alarm file!\n");
+ }
+ if (0 != clearEoCSCCNCurrentTraps ())
+ {
+ syslog (LOG_DEBUG, "eocSCCNAlarmsAndTraps: error clearing current\
+ traps file!\n");
+ }
+ snmp_alarm_register (ALARM_CHECK_FREQUENCY, /* in seconds */
+ SA_REPEAT, /* callback is called repeatedly */
+ eoc_sccn_alarm_callback, /* our callback */
+ NULL);
+ }
+}
+
+/* callback function used for alarm registration */
+void
+eoc_sccn_alarm_callback (unsigned int clientreg, void *clientarg)
+{
+ if (eocSCCNAlarmsEnabled ())
+ checkAllEoCSCCNAlarms ();
+}
+
+/**
+ * function returns 1 if trap generation status is enabled and 0 if it is
+ * disabled
+ */
+int
+eocSCCNTrapsEnabled ()
+{
+ int trap_status;
+ char buffer[LIBSPID_LINE_MAX_LEN];
+ if (LIBSPID_SUCCESS !=
+ libspid_config_read_item (LIBSPID_SNMP_CONF_PATH,
+ LIBSPID_SNMP_CONF_LABEL_TRAP_ENABLE,
+ buffer, LIBSPID_LINE_MAX_LEN))
+ {
+ syslog (LOG_DEBUG, "eocSCCNAlarmsAndTraps: error reading trap\
+ enable \n");
+ snmp_log (LOG_ERR, "eocSCCNAlarmsAndTraps: error reading trap\
+ enable\n");
+ /* trap generation status set to disabled */
+ trap_status = 0;
+ }
+ else
+ {
+ /* parse trap enable settings from buffer */
+ if (!strncmp (buffer, LIBSPID_SNMP_CONF_VALUE_YES,
+ strlen (LIBSPID_SNMP_CONF_VALUE_YES)))
+ trap_status = 1;
+ else
+ trap_status = 0;
+ /* disabled trap generation status is presumed as default */
+ }
+ return trap_status;
+}
+
+/**
+ * function returns 1 if alarm detection is enabled or enabled with
+ * regeneration, and 0 otherwise
+ */
+int
+eocSCCNAlarmsEnabled ()
+{
+ admin_alarm_detect_t alarm_detect;
+ char buffer[LIBSPID_LINE_MAX_LEN];
+ if (LIBSPID_SUCCESS !=
+ libspid_config_read_item (LIBSPID_SNMP_CONF_PATH,
+ LIBSPID_SNMP_CONF_LABEL_ALARM_ENABLE,
+ buffer, LIBSPID_LINE_MAX_LEN))
+ {
+ syslog (LOG_DEBUG, "eocSCCNAlarmsAndTraps: error reading alarm\
+ detection\n");
+ /* AlarmDetection set to disabled */
+ alarm_detect = ADMIN_ALARM_DETECT_DISABLED;
+ }
+ else
+ {
+ /* parse alarm detection settings from buffer */
+ if (!strncmp (buffer, LIBSPID_SNMP_CONF_VALUE_YES,
+ strlen (LIBSPID_SNMP_CONF_VALUE_YES)))
+ {
+ alarm_detect = ADMIN_ALARM_DETECT_ENABLED;
+ }
+ else if (!strncmp (buffer, LIBSPID_SNMP_CONF_VALUE_REGENERATE,
+ strlen (LIBSPID_SNMP_CONF_VALUE_REGENERATE)))
+ {
+ alarm_detect = ADMIN_ALARM_DETECT_REGENERATE;
+ }
+ else
+ {
+ alarm_detect = ADMIN_ALARM_DETECT_DISABLED;
+ /* disabled alarm detection is presumed as default */
+ }
+ }
+ if ((alarm_detect == ADMIN_ALARM_DETECT_ENABLED) ||
+ (alarm_detect == ADMIN_ALARM_DETECT_REGENERATE))
+ return 1;
+ return 0;
+}
+
+void
+checkAllEoCSCCNAlarms ()
+{
+ eoc_sccn_max_alarm_count = 0;
+
+ /* clear old contents of current alarm file */
+ if (0 != clearEoCSCCNCurrentAlarms ())
+ {
+ syslog (LOG_DEBUG, "eocSCCNAlarmsAndTraps: error clearing old current\
+ alarm file!\n");
+ }
+ if (0 != handleEoCSCCNCnuAlarmOID ())
+ {
+ snmp_log (LOG_ERR, "handleEoCSCCNCnuAlarmOID error!\n");
+ syslog (LOG_DEBUG, "eocSCCNAlarmsAndTraps: eocSCCNCnuAlarm check\
+ error!\n");
+ }
+ if (0 != checkEoCSCCNCBatAlarms ())
+ {
+ snmp_log (LOG_ERR, "checkEoCSCCNCBatAlarms error\n");
+ syslog (LOG_DEBUG, "eocSCCNAlarmsAndTraps: eocSCCNCBatAlarm check \
+ error! \n");
+ }
+}
+
+int
+updateEoCSCCNCurrentTraps (char *trap_oid_str)
+{
+ const char delimiter = LIBSPID_TRAP_INFO_DELIMITER[0];
+ char key[LIBSPID_CONFIG_KEY_MAX_LEN] = { 0 };
+ unsigned int elt_number = LIBSPID_CONFIG_ELT_MAX_NB;
+ char *elt[LIBSPID_CONFIG_ELT_MAX_NB] = { 0 };
+ char buffer[LIBSPID_CONFIG_LINE_MAX_LEN] = { 0 };
+ /* string with current timestamp */
+ char curr_time_str[32];
+ /* old value of number of times a trap has been generated */
+ int times_old = 0;
+ /* string with new number of times a trap has been generated */
+ char times_new_str[32];
+ /* copy given OID string to key */
+ strcpy (key, trap_oid_str);
+ /* store current timestamp to string */
+ sprintf (curr_time_str, "%ld", time (NULL));
+ /* attempt to read line with given key from trap info file */
+ if (LIBSPID_SUCCESS !=
+ libspid_config_read_line (LIBSPID_TRAP_INFO_PATH,
+ LIBSPID_TRAP_INFO_DELIMITER, key,
+ &elt_number, elt, buffer,
+ LIBSPID_CONFIG_LINE_MAX_LEN))
+ {
+ /**
+ * in case line with trap OID as a key hasn't been read successfully,
+ * it is assumed that trap with this OID has never been issued and new
+ * line isadded
+ */
+ elt[0] = "1";
+ elt[1] = curr_time_str;
+ return libspid_config_write_line (LIBSPID_TRAP_INFO_PATH,
+ delimiter, key, 2, elt);
+ }
+ /* otherwise update existing line for current key
+ * parse old value of number of times */
+ if (1 != sscanf (elt[0], "%d", &times_old))
+ times_old = 0;
+ times_old++;
+ sprintf (times_new_str, "%d", times_old);
+ elt[0] = times_new_str;
+ elt[1] = curr_time_str;
+ return libspid_config_write_line (LIBSPID_TRAP_INFO_PATH, delimiter,
+ trap_oid_str, 2, elt);
+}
+
+int
+registerEoCSCCNAlarm (char *alarm_oid_str, int state, int value)
+{
+ int i = 0;
+ const char delimiter = LIBSPID_ALARM_INFO_DELIMITER[0];
+ char *elt[2];
+ char state_str[8];
+ char value_str[8];
+
+ unsigned char taddress[6];
+ char trap_ip_bin[4];
+
+ /* check OID string */
+ netsnmp_assert (NULL != alarm_oid_str);
+ sprintf (state_str, "%d", state);
+ sprintf (value_str, "%d", value);
+ elt[0] = state_str;
+ elt[1] = value_str;
+
+ /*
+ * register alarm in current alarm info file if
+ * maximum count not exceeded
+ */
+ if (eoc_sccn_max_alarm_count <= LIBSPID_CURRENT_ALARMS_MAX_NUM)
+ {
+ if (LIBSPID_SUCCESS !=
+ libspid_config_write_line (LIBSPID_ALARM_INFO_PATH, delimiter,
+ alarm_oid_str, 2, elt))
+ {
+ syslog (LOG_DEBUG, "eocSCCNCnuTraps: error, couldn't update \
+ current alarm file");
+ return SNMP_ERR_GENERR;
+ }
+ eoc_sccn_max_alarm_count++;
+ }
+
+
+ /**
+ * check if traps are allowed in snmp.conf file and verify that trap
+ * for particular OID has not reached maximum times and that the minimum
+ * interval has passed
+ */
+ if (eocSCCNTrapsEnabled () && eocSCCNTrapOIDAllowed (alarm_oid_str))
+ {
+ for (i = 0; i < sccn_trap_ip_count; i++)
+ {
+ memset (taddress, 0x0, sizeof (taddress));
+ libspid_ip_str_to_bin (eoc_sccn_trap_entry[i].ip_address,
+ trap_ip_bin);
+ memcpy (taddress, trap_ip_bin, 4);
+ taddress[5] = (uint16_t) sccn_trap_port;
+ if (eoc_sccn_trap_count == 0)
+ {
+ /**
+ * if current trap is first one to be issued, add new rows to
+ * snmpNotifyTable, snmpTargetAddrTable and
+ * snmpTargetParamsTable
+ */
+ initEoCSCCNNotifyAndTarget (taddress, 6,
+ eoc_sccn_trap_entry[i].community,
+ strlen (eoc_sccn_trap_entry[i].
+ community));
+ }
+ else
+ {
+
+ /**
+ * if traps were issued before the current one, modify rows in
+ * snmpNotifyTable, snmpTargetAddrTable and
+ * snmpTargetParamsTable
+ */
+ updateEoCSCCNNotifyAndTarget (
+ taddress, 6,
+ eoc_sccn_trap_entry[i].community,
+ strlen (eoc_sccn_trap_entry[i].community));
+ }
+
+ /* send trap */
+ issueEoCSCCNTrap (alarm_oid_str, value);
+ /* update global trap count */
+ eoc_sccn_trap_count++;
+ }
+ /**
+ * update trap count and registered time for current trap
+ * in trap.info file
+ */
+ updateEoCSCCNCurrentTraps (alarm_oid_str);
+ }
+ return SNMP_ERR_NOERROR;
+}
+
+int
+clearEoCSCCNCurrentAlarms ()
+{
+ const char delimiters[2] = LIBSPID_ALARM_INFO_DELIMITER "\0";
+ char key[LIBSPID_CONFIG_KEY_MAX_LEN];
+ unsigned int elt_number = LIBSPID_CONFIG_ELT_MAX_NB;
+ char *elt[LIBSPID_CONFIG_ELT_MAX_NB];
+ char buffer[LIBSPID_CONFIG_LINE_MAX_LEN];
+ libspid_error_t error = LIBSPID_SUCCESS;
+ int count = 0;
+ void *user_data = NULL;
+ char *oid_str[LIBSPID_CURRENT_ALARMS_MAX_NUM];
+ char *tmp;
+ int i;
+ int ret;
+
+ tmp = (char *) malloc (LIBSPID_CURRENT_ALARMS_MAX_NUM * 64);
+ if (tmp == NULL)
+ return 0;
+
+ for (i = 0; i < LIBSPID_CURRENT_ALARMS_MAX_NUM; i++)
+ {
+ oid_str[i] = tmp + i * 64;
+ }
+ memset (key, 0x0, sizeof (key));
+ error = libspid_config_read_line_repetitive (LIBSPID_ALARM_INFO_PATH,
+ delimiters, key, &elt_number,
+ elt, buffer,
+ LIBSPID_CONFIG_LINE_MAX_LEN,
+ &user_data);
+ if (LIBSPID_SUCCESS != error)
+ {
+ free (tmp);
+ return 0;
+ }
+
+ for (; count < LIBSPID_CURRENT_ALARMS_MAX_NUM
+ && strcmp (key, ""); (count)++)
+ {
+ /* Get a line from the conf file. */
+ elt_number = LIBSPID_CONFIG_ELT_MAX_NB;
+ error =
+ libspid_config_read_line_repetitive (LIBSPID_ALARM_INFO_PATH,
+ delimiters, key, &elt_number,
+ elt, buffer,
+ LIBSPID_CONFIG_LINE_MAX_LEN,
+ &user_data);
+ if (LIBSPID_SUCCESS != error)
+ {
+ free (tmp);
+ return 0;
+ }
+
+ strcpy (oid_str[count], buffer);
+ }
+ for (i = 0; i < count; i++)
+ {
+ if (!strncmp (oid_str[i], EOCSCCNOID, strlen (EOCSCCNOID)))
+ {
+
+ ret = libspid_config_remove_line (LIBSPID_ALARM_INFO_PATH,
+ LIBSPID_ALARM_INFO_DELIMITER,
+ oid_str[i]);
+
+ if (ret != LIBSPID_SUCCESS)
+ {
+ syslog (LOG_DEBUG,"%s: cannot remove alarm info(ret=%d)",
+ __FUNCTION__, ret);
+ free (tmp);
+ return ret;
+ }
+
+ }
+
+ }
+ free (tmp);
+ return 0;
+}
+
+int
+clearEoCSCCNCurrentTraps ()
+{
+ const char delimiter = LIBSPID_TRAP_INFO_DELIMITER[0];
+ char *header_key = "#<OID>";
+ char *header_elt[2] = { "<Number of times>", "<Last time>" };
+
+ /* remove current trap file */
+ if (0 != unlink (LIBSPID_TRAP_INFO_PATH))
+ return -1;
+
+ /* create current trap file and write header line */
+ if (LIBSPID_SUCCESS !=
+ libspid_config_write_line (LIBSPID_TRAP_INFO_PATH, delimiter,
+ header_key, 2, header_elt))
+ {
+ syslog (LOG_DEBUG, "eocSCCNAlarmsAndTraps: error, couldn't write \
+ header for current trap file");
+ }
+ return 0;
+}
+
+/**
+ * obtain trap maximum times and minimal interval necessary for checking
+ * whether generation of particular trap is allowed
+ * pointers to integers containing maximum times and minimal interval must
+ * be provided as arguments
+ */
+void
+getEoCSCCNTrapTimesAndInterval (int *max_times, int *min_interval)
+{
+ char buffer[LIBSPID_LINE_MAX_LEN];
+ int ret;
+ int value;
+ /* read buffer for max times from config file */
+ ret =
+ libspid_config_read_item (LIBSPID_SNMP_CONF_PATH,
+ LIBSPID_SNMP_CONF_LABEL_TRAP_MAX_TIMES,
+ buffer, LIBSPID_LINE_MAX_LEN);
+ if (LIBSPID_SUCCESS != ret)
+ {
+ snmp_log (LOG_ERR, "eocSCCNAlarmsAndTraps: libspid_config_read_item\
+ error for trap max times\n");
+ /* max times set to default value */
+ *max_times = TRAP_MAX_TIMES_DEFAULT_VALUE;
+ }
+ else
+ {
+ /* parse max times from buffer */
+ if (1 != sscanf (buffer, "%d", &value))
+ *max_times = TRAP_MAX_TIMES_DEFAULT_VALUE;
+ else if ((TRAP_MAX_TIMES_MIN <= value) &&
+ (TRAP_MAX_TIMES_MAX >= value))
+ *max_times = value;
+ else
+ *max_times = TRAP_MAX_TIMES_DEFAULT_VALUE;
+ }
+ /* read buffer for min interval from config file */
+ ret =
+ libspid_config_read_item (LIBSPID_SNMP_CONF_PATH,
+ LIBSPID_SNMP_CONF_LABEL_TRAP_MIN_INTERVAL,
+ buffer, LIBSPID_LINE_MAX_LEN);
+ if (LIBSPID_SUCCESS != ret)
+ {
+ snmp_log (LOG_ERR, "eocSCCNAlarmsAndTraps: libspid_config_read_item\
+ error for trap min interval\n");
+
+ /* min interval set to default value */
+ *min_interval = TRAP_MIN_INTERVAL_DEFAULT_VALUE;
+ }
+ else
+ {
+ /* parse min interval from buffer */
+ if (1 != sscanf (buffer, "%d", &value))
+ *min_interval = TRAP_MIN_INTERVAL_DEFAULT_VALUE;
+ else if (value >= 0)
+ *min_interval = value;
+ else
+ {
+ snmp_log (LOG_ERR, "eocSCCNAlarmsAndTraps: error: negative config\
+ file value for min interval: %d\n", value);
+ *min_interval = TRAP_MIN_INTERVAL_DEFAULT_VALUE;
+ }
+ }
+}
+
+
+/**
+ * add new rows to snmpNotifyTable, snmpTargetAddrTable and
+ * snmpTargetParamsTable
+ */
+int
+initEoCSCCNNotifyAndTarget (unsigned char *taddress, size_t taddress_len,
+ char *sec_name, size_t sec_name_len)
+{
+ addRow_eocSCCNNotifyTable ();
+ addRow_eocSCCNTargetAddrTable (taddress, taddress_len);
+ addRow_eocSCCNTargetParamsTable (sec_name, sec_name_len);
+ return 0;
+}
+
+
+/**
+ * modify trap destination address and security name in snmpNotifyTable,
+ * snmpTargetAddrTable and snmpTargetParamsTable
+ */
+int
+updateEoCSCCNNotifyAndTarget (unsigned char *taddress, size_t taddress_len,
+ char *sec_name, size_t sec_name_len)
+{
+ modifyRow_eocSCCNTargetAddrTable (taddress, taddress_len);
+ modifyRow_eocSCCNTargetParamsTable (sec_name, sec_name_len);
+ return 0;
+}
+
+
+/**
+ * function returns 1 if it is allowed to generate trap with given OID and
+ * 0 otherwise, based on number of time trap has already been issued, and
+ * interval from last occurrence
+ */
+int
+eocSCCNTrapOIDAllowed (char *trap_oid_str)
+{
+ const char delimiters[2] = LIBSPID_TRAP_INFO_DELIMITER "\0";
+ char key[LIBSPID_CONFIG_KEY_MAX_LEN] = { 0 };
+ unsigned int elt_number = LIBSPID_CONFIG_ELT_MAX_NB;
+ char *elt[LIBSPID_CONFIG_ELT_MAX_NB] = { 0 };
+ char buffer[LIBSPID_CONFIG_LINE_MAX_LEN] = { 0 };
+ libspid_error_t error;
+ /* current value of number of times a trap has been generated */
+ int times_curr;
+ /* current value of last timestamp of trap generation */
+ int last_time_curr;
+ /* value of maximum trap times from configuration file */
+ int max_times_conf;
+ /* value of minimal interval between traps from configuration file */
+ int min_interval_conf;
+ /* current interval of time passed from last generated timestamp */
+ int interval_curr;
+ /* copy given OID string to key */
+ strcpy (key, trap_oid_str);
+ /* attempt to read line with given key from trap info file */
+ if (LIBSPID_SUCCESS !=
+ (error = libspid_config_read_line (LIBSPID_TRAP_INFO_PATH,
+ delimiters, key,
+ &elt_number, elt,
+ buffer,
+ LIBSPID_CONFIG_LINE_MAX_LEN)))
+ {
+ /* in case line with trap OID as a key hasn't been read successfully
+ * , it is assumed that trap with this OID has never been issued
+ */
+ return 1;
+ }
+ /* parse current values of number of times and last timestamp */
+ if (elt[0] == NULL || 1 != sscanf (elt[0], "%d", &times_curr))
+ times_curr = 0;
+ if (elt[1] == NULL || 1 != sscanf (elt[1], "%d", &last_time_curr))
+ last_time_curr = 0;
+ interval_curr = time (NULL) - last_time_curr;
+ /* obtain values of maximum times and minimal interval from
+ * configuration file
+ */
+ getEoCSCCNTrapTimesAndInterval (&max_times_conf, &min_interval_conf);
+ /* compare time and interval values between info file and
+ * configuration and determine if a trap should be allowed
+ */
+ if ((times_curr >= max_times_conf) || (interval_curr < min_interval_conf))
+ return 0;
+ return 1;
+}
+
+/* send trap with alarm OID as parameter */
+int
+issueEoCSCCNTrap (char *alarm_oid_str, int value)
+{
+ if (!strncmp (alarm_oid_str, EOCSCCNCNUONLINE_OID_STR,
+ strlen (EOCSCCNCNUONLINE_OID_STR)))
+ {
+ send_eocSCCNCnuOnline_trap (alarm_oid_str, value, 1);
+ return SNMP_ERR_NOERROR;
+ }
+
+ else if (!strncmp (alarm_oid_str, EOCSCCNCNUOFFLINE_OID_STR,
+ strlen (EOCSCCNCNUOFFLINE_OID_STR)))
+ {
+ send_eocSCCNCnuOnline_trap (alarm_oid_str, value, 1);
+ return SNMP_ERR_NOERROR;
+ }
+ /*send EoCCBat traps */
+ if (!strcmp (alarm_oid_str, EOCSCCNCBATONLINEOID))
+ {
+ send_eocSCCNCbatOnline_trap ();
+ return SNMP_ERR_NOERROR;
+ }
+ return SNMP_ERR_NOERROR;
+}
+
+
+
diff --git a/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNAlarmsAndTraps.h b/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNAlarmsAndTraps.h
new file mode 100644
index 0000000000..d6fb897920
--- /dev/null
+++ b/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNAlarmsAndTraps.h
@@ -0,0 +1,40 @@
+#ifndef EOC_SCCNALARMSANDTRAPS_H
+#define EOC_SCCNALARMSANDTRAPS_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* include common header */
+#include "EoCCommon.h"
+
+/* function declarations */
+void init_eocSCCNAlarmsAndTraps (void);
+int eocSCCNAlarmsEnabled (void);
+int eocSCCNTrapsEnabled (void);
+SNMPAlarmCallback eoc_sccn_alarm_callback;
+void checkAllEoCSCCNAlarms (void);
+
+int registerEoCSCCNAlarm (char *alarm_oid, int state, int value);
+int updateEoCSCCNCurrentTraps (char *trap_oid_str);
+int clearEoCSCCNCurrentAlarms ();
+int clearEoCSCCNCurrentTraps ();
+void getEoCSCCNTrapTimesAndInterval (int *max_times, int *min_interval);
+int initEoCSCCNNotifyAndTarget (unsigned char *taddress,
+ size_t taddress_len, char *sec_name,
+ size_t sec_name_len);
+int updateEoCSCCNNotifyAndTarget (unsigned char *taddress,
+ size_t taddress_len, char *sec_name,
+ size_t sec_name_len);
+int eocSCCNTrapOIDAllowed (char *trap_oid_str);
+int issueEoCSCCNTrap (char *alarm_oid_str, int value);
+int storeEoCSCCNAlarmLog (const char *info);
+void clearEoCSCCNAlarmLogList ();
+int handleEoCSCCNCnuAlarmOID ();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* EOCSCCNALARMSANDTRAPS_H */
diff --git a/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNAlarmsAndTraps_interface.c b/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNAlarmsAndTraps_interface.c
new file mode 100644
index 0000000000..e50bb025f0
--- /dev/null
+++ b/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNAlarmsAndTraps_interface.c
@@ -0,0 +1,1132 @@
+#include <net-snmp/net-snmp-config.h>
+#include <net-snmp/net-snmp-includes.h>
+#include <net-snmp/agent/net-snmp-agent-includes.h>
+
+
+/* include header with interface functions */
+#include "eocSCCNAlarmsAndTraps_interface.h"
+
+/** These functions serve as interface between EoC module for alarms and
+ * traps and existing net-snmp support for trap destination and community.
+ * Functions are used to add necessary information defined in trap
+ * configuration file to snmpNotifyTable, snmpTargetAddrTable or
+ * eocSCCNTargetParamsTable,or to modify existing information.
+ * Note: since EoC trap configuration file defines only one trap destination
+ * and community, all functions add or modify single row of notify and target
+ * tables.
+ * For convenience, this row is indexed by constant string value hard-coded
+ * in interface header.
+ * ASCII representation of this index value is also embedded in defines for
+ * all OIDs necessary for manipulation of tables.
+ */
+
+/* constant values necessary for setting target and notifications parameters*/
+char *eocSCCN_index_str = EOCSCCN_TABLE_INDEX_STR;
+int eocSCCN_index_str_len = EOCSCCN_TABLE_INDEX_LEN;
+
+/*
+ * OID definitions
+ *
+ */
+
+/** eocSCCNNotifyTable OID definitions **/
+oid eocSCCNNotifyRowStatus_index_oid[] = { EOCSCCNNOTIFYROWSTATUSINDEX_OID };
+
+int eocSCCNNotifyRowStatus_index_oid_size =
+OID_LENGTH (eocSCCNNotifyRowStatus_index_oid);
+
+oid eocSCCNNotifyTag_index_oid[] = { EOCSCCNNOTIFYTAGINDEX_OID };
+
+int eocSCCNNotifyTag_index_oid_size = OID_LENGTH (eocSCCNNotifyTag_index_oid);
+
+oid eocSCCNNotifyType_index_oid[] = { EOCSCCNNOTIFYTYPEINDEX_OID };
+
+int eocSCCNNotifyType_index_oid_size =
+OID_LENGTH (eocSCCNNotifyType_index_oid);
+
+oid eocSCCNNotifyStorageType_index_oid[] =
+ { EOCSCCNNOTIFYSTORAGETYPEINDEX_OID };
+int eocSCCNNotifyStorageType_index_oid_size =
+OID_LENGTH (eocSCCNNotifyStorageType_index_oid);
+
+
+/* eocTargetAddrTable OID definitions */
+oid eocSCCNTargetAddrRowStatus_index_oid[] =
+ { EOCSCCNTARGETADDRROWSTATUSINDEX_OID };
+int eocSCCNTargetAddrRowStatus_index_oid_size =
+OID_LENGTH (eocSCCNTargetAddrRowStatus_index_oid);
+
+oid eocSCCNTargetAddrTDomain_index_oid[] =
+ { EOCSCCNTARGETADDRTDOMAININDEX_OID };
+int eocSCCNTargetAddrTDomain_index_oid_size =
+OID_LENGTH (eocSCCNTargetAddrTDomain_index_oid);
+
+/* represents UDP transport domain OID */
+oid eocSCCNTargetAddrTDomain_value_oid[] =
+ { EOCSCCNTARGETADDRTDOMAINUDP_OID };
+int eocSCCNTargetAddrTDomain_value_oid_size =
+OID_LENGTH (eocSCCNTargetAddrTDomain_value_oid);
+
+oid eocSCCNTargetAddrTAddress_index_oid[] =
+ { EOCSCCNTARGETADDRTADDRESSINDEX_OID };
+int eocSCCNTargetAddrTAddress_index_oid_size =
+OID_LENGTH (eocSCCNTargetAddrTAddress_index_oid);
+
+oid eocSCCNTargetAddrParams_index_oid[] =
+ { EOCSCCNTARGETADDRPARAMSINDEX_OID };
+int eocSCCNTargetAddrParams_index_oid_size =
+OID_LENGTH (eocSCCNTargetAddrParams_index_oid);
+
+oid eocSCCNTargetAddrTagList_index_oid[] =
+ { EOCSCCNTARGETADDRTAGLISTINDEX_OID };
+int eocSCCNTargetAddrTagList_index_oid_size =
+OID_LENGTH (eocSCCNTargetAddrTagList_index_oid);
+
+
+/** eocTargetParamsTable OID definitions **/
+oid eocSCCNTargetParamsRowStatus_index_oid[] =
+ { EOCSCCNTARGETPARAMSROWSTATUSINDEX_OID };
+int eocSCCNTargetParamsRowStatus_index_oid_size =
+OID_LENGTH (eocSCCNTargetParamsRowStatus_index_oid);
+
+oid eocSCCNTargetParamsMPModel_index_oid[] =
+ { EOCSCCNTARGETPARAMSMPMODELINDEX_OID };
+int eocSCCNTargetParamsMPModel_index_oid_size =
+OID_LENGTH (eocSCCNTargetParamsMPModel_index_oid);
+
+oid eocSCCNTargetParamsSecurityModel_index_oid[] =
+ { EOCSCCNTARGETPARAMSSECURITYMODELINDEX_OID };
+int eocSCCNTargetParamsSecurityModel_index_oid_size =
+OID_LENGTH (eocSCCNTargetParamsSecurityModel_index_oid);
+
+oid eocSCCNTargetParamsSecurityName_index_oid[] =
+ { EOCSCCNTARGETPARAMSSECURITYNAMEINDEX_OID };
+int eocSCCNTargetParamsSecurityName_index_oid_size =
+OID_LENGTH (eocSCCNTargetParamsSecurityName_index_oid);
+
+oid eocSCCNTargetParamsSecurityLevel_index_oid[] =
+ { EOCSCCNTARGETPARAMSSECURITYLEVELINDEX_OID };
+int eocSCCNTargetParamsSecurityLevel_index_oid_size =
+OID_LENGTH (eocSCCNTargetParamsSecurityLevel_index_oid);
+
+oid eocSCCNTargetParamsStorageType_index_oid[] =
+ { EOCSCCNTARGETPARAMSSTORAGETYPEINDEX_OID };
+int eocSCCNTargetParamsStorageType_index_oid_size =
+OID_LENGTH (eocSCCNTargetParamsStorageType_index_oid);
+
+/*** eocSCCNNotifyTable ***/
+/* set eocSCCNNotifyRowStatus to given value */
+int
+set_eocSCCNNotifyRowStatus (int row_status)
+{
+ if (SNMP_ERR_NOERROR != write_snmpNotifyRowStatus (
+ RESERVE1,
+ (u_char *) &row_status,
+ ASN_INTEGER,
+ sizeof (long), NULL,
+ eocSCCNNotifyRowStatus_index_oid,
+ eocSCCNNotifyRowStatus_index_oid_size))
+ {
+ DEBUGMSGTL (("EoCSCCNAlarmsAndTraps_interface",
+ "write_snmpNotifyRowStatus (RESERVE1) error\n"));
+ write_snmpNotifyRowStatus (FREE, (u_char *) &row_status, ASN_INTEGER,
+ sizeof (long), NULL,
+ eocSCCNNotifyRowStatus_index_oid,
+ eocSCCNNotifyRowStatus_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpNotifyRowStatus (
+ RESERVE2,
+ (u_char *) &row_status,
+ ASN_INTEGER,
+ sizeof (long), NULL,
+ eocSCCNNotifyRowStatus_index_oid,
+ eocSCCNNotifyRowStatus_index_oid_size))
+ {
+ DEBUGMSGTL (("EoCSCCNAlarmsAndTraps_interface",
+ "write_snmpNotifyRowStatus (RESERVE2) error\n"));
+ write_snmpNotifyRowStatus (FREE, (u_char *) &row_status, ASN_INTEGER,
+ sizeof (long), NULL,
+ eocSCCNNotifyRowStatus_index_oid,
+ eocSCCNNotifyRowStatus_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpNotifyRowStatus (
+ ACTION,
+ (u_char *) &row_status,
+ ASN_INTEGER,
+ sizeof (long), NULL,
+ eocSCCNNotifyRowStatus_index_oid,
+ eocSCCNNotifyRowStatus_index_oid_size))
+ {
+ DEBUGMSGTL (("EoCSCCNAlarmsAndTraps_interface",
+ "write_snmpNotifyRowStatus (ACTION) error\n"));
+ write_snmpNotifyRowStatus (UNDO, (u_char *) &row_status, ASN_INTEGER,
+ sizeof (long), NULL,
+ eocSCCNNotifyRowStatus_index_oid,
+ eocSCCNNotifyRowStatus_index_oid_size);
+ }
+
+ write_snmpNotifyRowStatus (COMMIT, (u_char *) &row_status, ASN_INTEGER,
+ sizeof (long), NULL,
+ eocSCCNNotifyRowStatus_index_oid,
+ eocSCCNNotifyRowStatus_index_oid_size);
+
+ return 0;
+}
+
+/* set eocSCCNNotifyTag to given value */
+int
+set_eocSCCNNotifyTag (char *tag, size_t tag_len)
+{
+
+ if (SNMP_ERR_NOERROR != write_snmpNotifyTag (
+ RESERVE1,
+ (u_char *) tag,
+ ASN_OCTET_STR, tag_len, NULL,
+ eocSCCNNotifyTag_index_oid,
+ eocSCCNNotifyTag_index_oid_size))
+ {
+ DEBUGMSGTL (("EoCSCCNAlarmsAndTraps_interface",
+ "write_snmpNotifyTag (RESERVE1) error\n"));
+ write_snmpNotifyTag (FREE, (u_char *) tag, ASN_OCTET_STR, tag_len,
+ NULL, eocSCCNNotifyTag_index_oid,
+ eocSCCNNotifyTag_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpNotifyTag (
+ RESERVE2, (u_char *) tag,
+ ASN_OCTET_STR, tag_len, NULL,
+ eocSCCNNotifyTag_index_oid,
+ eocSCCNNotifyTag_index_oid_size))
+ {
+ DEBUGMSGTL (("EoCSCCNAlarmsAndTraps_interface",
+ "write_snmpNotifyTag (RESERVE2) error\n"));
+ write_snmpNotifyTag (FREE, (u_char *) tag, ASN_OCTET_STR, tag_len,
+ NULL, eocSCCNNotifyTag_index_oid,
+ eocSCCNNotifyTag_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpNotifyTag (
+ ACTION, (u_char *) tag,
+ ASN_OCTET_STR, tag_len, NULL,
+ eocSCCNNotifyTag_index_oid,
+ eocSCCNNotifyTag_index_oid_size))
+ {
+ DEBUGMSGTL (("EoCSCCNAlarmsAndTraps_interface",
+ "write_snmpNotifyTag (ACTION) error\n"));
+ write_snmpNotifyTag (UNDO, (u_char *) tag, ASN_OCTET_STR,
+ tag_len, NULL, eocSCCNNotifyTag_index_oid,
+ eocSCCNNotifyTag_index_oid_size);
+ }
+
+ write_snmpNotifyTag (COMMIT, (u_char *) tag, ASN_OCTET_STR, tag_len,
+ NULL, eocSCCNNotifyTag_index_oid,
+ eocSCCNNotifyTag_index_oid_size);
+
+ return 0;
+}
+
+/* set eocSCCNNotifyType to given value */
+int
+set_eocSCCNNotifyType (int type)
+{
+
+ if (SNMP_ERR_NOERROR != write_snmpNotifyType (
+ RESERVE1, (u_char *) &type,
+ ASN_INTEGER, sizeof (long),
+ NULL,
+ eocSCCNNotifyType_index_oid,
+ eocSCCNNotifyType_index_oid_size))
+ {
+ DEBUGMSGTL (("EoCSCCNAlarmsAndTraps_interface",
+ "write_snmpNotifyType (RESERVE1) error\n"));
+ write_snmpNotifyType (FREE, (u_char *) &type, ASN_INTEGER,
+ sizeof (long), NULL,
+ eocSCCNNotifyType_index_oid,
+ eocSCCNNotifyType_index_oid_size);
+ }
+
+
+ if (SNMP_ERR_NOERROR != write_snmpNotifyType (
+ RESERVE2, (u_char *) &type,
+ ASN_INTEGER, sizeof (long),
+ NULL,
+ eocSCCNNotifyType_index_oid,
+ eocSCCNNotifyType_index_oid_size))
+ {
+ DEBUGMSGTL (("EoCSCCNAlarmsAndTraps_interface",
+ "write_snmpNotifyType (RESERVE2) error\n"));
+
+ write_snmpNotifyType (FREE, (u_char *) &type, ASN_INTEGER,
+ sizeof (long), NULL,
+ eocSCCNNotifyType_index_oid,
+ eocSCCNNotifyType_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpNotifyType (
+ ACTION, (u_char *) &type,
+ ASN_INTEGER, sizeof (long),
+ NULL,
+ eocSCCNNotifyType_index_oid,
+ eocSCCNNotifyType_index_oid_size))
+ {
+ DEBUGMSGTL (("example_notification",
+ "write_snmpNotifyType (ACTION) error\n"));
+ write_snmpNotifyType (UNDO, (u_char *) &type, ASN_INTEGER,
+ sizeof (long), NULL,
+ eocSCCNNotifyType_index_oid,
+ eocSCCNNotifyType_index_oid_size);
+ }
+
+
+ write_snmpNotifyType (COMMIT, (u_char *) &type, ASN_INTEGER,
+ sizeof (long), NULL, eocSCCNNotifyType_index_oid,
+ eocSCCNNotifyType_index_oid_size);
+
+ return 0;
+}
+
+/* set eocSCCNNotifyStorageType to given value */
+int
+set_eocSCCNNotifyStorageType (int storage_type)
+{
+
+ if (SNMP_ERR_NOERROR != write_snmpNotifyStorageType (
+ RESERVE1,
+ (u_char *) &storage_type,
+ ASN_INTEGER,
+ sizeof (long), NULL,
+ eocSCCNNotifyStorageType_index_oid,
+ eocSCCNNotifyStorageType_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpNotifyStorageType (RESERVE1) error\n"));
+ write_snmpNotifyStorageType (FREE, (u_char *) &storage_type,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNNotifyStorageType_index_oid,
+ eocSCCNNotifyStorageType_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpNotifyStorageType (
+ RESERVE2,
+ (u_char *) &storage_type,
+ ASN_INTEGER,
+ sizeof (long), NULL,
+ eocSCCNNotifyStorageType_index_oid,
+ eocSCCNNotifyStorageType_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpNotifyStorageType (RESERVE2) error\n"));
+ write_snmpNotifyStorageType (FREE, (u_char *) & storage_type,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNNotifyStorageType_index_oid,
+ eocSCCNNotifyStorageType_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpNotifyStorageType (
+ RESERVE1,
+ (u_char *) &storage_type,
+ ASN_INTEGER,
+ sizeof (long), NULL,
+ eocSCCNNotifyStorageType_index_oid,
+ eocSCCNNotifyStorageType_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpNotifyStorageType (ACTION) error\n"));
+ write_snmpNotifyStorageType (UNDO, (u_char *) &storage_type,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNNotifyStorageType_index_oid,
+ eocSCCNNotifyStorageType_index_oid_size);
+ }
+
+ write_snmpNotifyStorageType (RESERVE1, (u_char *) &storage_type,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNNotifyStorageType_index_oid,
+ eocSCCNNotifyStorageType_index_oid_size);
+
+ return 0;
+}
+
+int
+addRow_eocSCCNNotifyTable (void)
+{
+ set_eocSCCNNotifyRowStatus (RS_CREATEANDWAIT);
+ set_eocSCCNNotifyTag (eocSCCN_index_str, eocSCCN_index_str_len);
+ set_eocSCCNNotifyType (SNMPNOTIFYTYPE_TRAP);
+ set_eocSCCNNotifyStorageType (ST_VOLATILE);
+ set_eocSCCNNotifyRowStatus (RS_ACTIVE);
+
+ return 0;
+}
+
+/*** eocSCCNTargetAddrTable ***/
+/* set eocSCCNTargetAddrRowStatus to given value */
+int
+set_eocSCCNTargetAddrRowStatus (int row_status)
+{
+ if (SNMP_ERR_NOERROR != write_snmpTargetAddrRowStatus (
+ RESERVE1,
+ (u_char *) &row_status,
+ ASN_INTEGER,
+ sizeof (long),
+ NULL,
+ eocSCCNTargetAddrRowStatus_index_oid,
+ eocSCCNTargetAddrRowStatus_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetAddrRowStatus (RESERVE1) error\n"));
+ write_snmpTargetAddrRowStatus (
+ FREE, (u_char *) &row_status,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetAddrRowStatus_index_oid,
+ eocSCCNTargetAddrRowStatus_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetAddrRowStatus (
+ RESERVE2,
+ (u_char *) &row_status,
+ ASN_INTEGER,
+ sizeof (long),
+ NULL,
+ eocSCCNTargetAddrRowStatus_index_oid,
+ eocSCCNTargetAddrRowStatus_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetAddrRowStatus (RESERVE2) error\n"));
+ write_snmpTargetAddrRowStatus (
+ FREE, (u_char *) &row_status,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetAddrRowStatus_index_oid,
+ eocSCCNTargetAddrRowStatus_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetAddrRowStatus (
+ ACTION,
+ (u_char *) &row_status,
+ ASN_INTEGER,
+ sizeof (long),
+ NULL,
+ eocSCCNTargetAddrRowStatus_index_oid,
+ eocSCCNTargetAddrRowStatus_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetAddrRowStatus (ACTION) error\n"));
+ write_snmpTargetAddrRowStatus (
+ UNDO, (u_char *) &row_status,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetAddrRowStatus_index_oid,
+ eocSCCNTargetAddrRowStatus_index_oid_size);
+ }
+
+ write_snmpTargetAddrRowStatus (COMMIT, (u_char *) &row_status,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetAddrRowStatus_index_oid,
+ eocSCCNTargetAddrRowStatus_index_oid_size);
+
+ return 0;
+}
+
+/* set eocSCCNTargetAddrTDomain to given value */
+int
+set_eocSCCNTargetAddrTDomain (oid * tdomain, size_t tdomain_len)
+{
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetAddrTDomain (
+ RESERVE1,
+ (u_char *) tdomain,
+ ASN_OBJECT_ID,
+ tdomain_len * sizeof (oid), NULL,
+ eocSCCNTargetAddrTDomain_index_oid,
+ eocSCCNTargetAddrTDomain_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetAddrTDomain (RESERVE1) error\n"));
+ write_snmpTargetAddrTDomain (FREE, (u_char *) tdomain, ASN_OBJECT_ID,
+ tdomain_len * sizeof (oid), NULL,
+ eocSCCNTargetAddrTDomain_index_oid,
+ eocSCCNTargetAddrTDomain_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetAddrTDomain (
+ RESERVE2,
+ (u_char *) tdomain,
+ ASN_OBJECT_ID,
+ tdomain_len * sizeof (oid), NULL,
+ eocSCCNTargetAddrTDomain_index_oid,
+ eocSCCNTargetAddrTDomain_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetAddrTDomain (RESERVE2) error\n"));
+ write_snmpTargetAddrTDomain (FREE, (u_char *) tdomain, ASN_OBJECT_ID,
+ tdomain_len * sizeof (oid), NULL,
+ eocSCCNTargetAddrTDomain_index_oid,
+ eocSCCNTargetAddrTDomain_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetAddrTDomain (
+ ACTION,
+ (u_char *) tdomain,
+ ASN_OBJECT_ID,
+ tdomain_len * sizeof (oid), NULL,
+ eocSCCNTargetAddrTDomain_index_oid,
+ eocSCCNTargetAddrTDomain_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetAddrTDomain (ACTION) error\n"));
+ write_snmpTargetAddrTDomain (UNDO, (u_char *) tdomain, ASN_OBJECT_ID,
+ tdomain_len * sizeof (oid), NULL,
+ eocSCCNTargetAddrTDomain_index_oid,
+ eocSCCNTargetAddrTDomain_index_oid_size);
+
+ }
+
+ write_snmpTargetAddrTDomain (COMMIT, (u_char *) tdomain, ASN_OBJECT_ID,
+ tdomain_len * sizeof (oid), NULL,
+ eocSCCNTargetAddrTDomain_index_oid,
+ eocSCCNTargetAddrTDomain_index_oid_size);
+
+ return 0;
+}
+
+/* set eocSCCNTargetAddrTAddress to given value */
+int
+set_eocSCCNTargetAddrTAddress (unsigned char *taddress, size_t taddress_len)
+{
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetAddrTAddress (
+ RESERVE1,
+ (u_char *) taddress,
+ ASN_OCTET_STR,
+ taddress_len, NULL,
+ eocSCCNTargetAddrTAddress_index_oid,
+ eocSCCNTargetAddrTAddress_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetAddrTAddress (RESERVE1) error\n"));
+ write_snmpTargetAddrTAddress (
+ FREE, (u_char *) taddress,
+ ASN_OCTET_STR, taddress_len, NULL,
+ eocSCCNTargetAddrTAddress_index_oid,
+ eocSCCNTargetAddrTAddress_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetAddrTAddress (
+ RESERVE2,
+ (u_char *) taddress,
+ ASN_OCTET_STR,
+ taddress_len, NULL,
+ eocSCCNTargetAddrTAddress_index_oid,
+ eocSCCNTargetAddrTAddress_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetAddrTAddress (RESERVE2) error\n"));
+ write_snmpTargetAddrTAddress (
+ FREE, (u_char *) taddress,
+ ASN_OCTET_STR, taddress_len, NULL,
+ eocSCCNTargetAddrTAddress_index_oid,
+ eocSCCNTargetAddrTAddress_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetAddrTAddress (
+ ACTION,
+ (u_char *) taddress,
+ ASN_OCTET_STR,
+ taddress_len, NULL,
+ eocSCCNTargetAddrTAddress_index_oid,
+ eocSCCNTargetAddrTAddress_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetAddrTAddress (ACTION) error\n"));
+ write_snmpTargetAddrTAddress (
+ UNDO, (u_char *) taddress,
+ ASN_OCTET_STR, taddress_len, NULL,
+ eocSCCNTargetAddrTAddress_index_oid,
+ eocSCCNTargetAddrTAddress_index_oid_size);
+ }
+
+ write_snmpTargetAddrTAddress (COMMIT, (u_char *) taddress,
+ ASN_OCTET_STR, taddress_len, NULL,
+ eocSCCNTargetAddrTAddress_index_oid,
+ eocSCCNTargetAddrTAddress_index_oid_size);
+ return 0;
+}
+
+/* set eocSCCNTargetAddrParams to given value */
+int
+set_eocSCCNTargetAddrParams (char *params, size_t params_len)
+{
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetAddrParams (
+ RESERVE1,
+ (u_char *) params,
+ ASN_OCTET_STR,
+ params_len, NULL,
+ eocSCCNTargetAddrParams_index_oid,
+ eocSCCNTargetAddrParams_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetAddrAddrParams (RESERVE1) error\n"));
+ write_snmpTargetAddrParams (FREE, (u_char *) params,
+ ASN_OCTET_STR, params_len, NULL,
+ eocSCCNTargetAddrParams_index_oid,
+ eocSCCNTargetAddrParams_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetAddrParams (
+ RESERVE2,
+ (u_char *) params,
+ ASN_OCTET_STR,
+ params_len, NULL,
+ eocSCCNTargetAddrParams_index_oid,
+ eocSCCNTargetAddrParams_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetAddrAddrParams (RESERVE2) error\n"));
+ write_snmpTargetAddrParams (FREE, (u_char *) params,
+ ASN_OCTET_STR, params_len, NULL,
+ eocSCCNTargetAddrParams_index_oid,
+ eocSCCNTargetAddrParams_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetAddrParams (
+ ACTION,
+ (u_char *) params,
+ ASN_OCTET_STR,
+ params_len, NULL,
+ eocSCCNTargetAddrParams_index_oid,
+ eocSCCNTargetAddrParams_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetAddrAddrParams (ACTION) error\n"));
+ write_snmpTargetAddrParams (UNDO, (u_char *) params, ASN_OCTET_STR,
+ params_len, NULL,
+ eocSCCNTargetAddrParams_index_oid,
+ eocSCCNTargetAddrParams_index_oid_size);
+ }
+
+ write_snmpTargetAddrParams (COMMIT, (u_char *) params, ASN_OCTET_STR,
+ params_len, NULL,
+ eocSCCNTargetAddrParams_index_oid,
+ eocSCCNTargetAddrParams_index_oid_size);
+
+ return 0;
+}
+
+/* set eocSCCNTargetAddrTagList to given value */
+int
+set_eocSCCNTargetAddrTagList (char *tag_list, size_t tag_list_len)
+{
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetAddrTagList (
+ RESERVE1,
+ (u_char *) tag_list,
+ ASN_OCTET_STR,
+ tag_list_len, NULL,
+ eocSCCNTargetAddrTagList_index_oid,
+ eocSCCNTargetAddrTagList_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetAddrAddrTagList (RESERVE1) error\n"));
+ write_snmpTargetAddrTagList (FREE, (u_char *) tag_list,
+ ASN_OCTET_STR, tag_list_len, NULL,
+ eocSCCNTargetAddrTagList_index_oid,
+ eocSCCNTargetAddrTagList_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetAddrTagList (
+ RESERVE2,
+ (u_char *) tag_list,
+ ASN_OCTET_STR,
+ tag_list_len, NULL,
+ eocSCCNTargetAddrTagList_index_oid,
+ eocSCCNTargetAddrTagList_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetAddrAddrTagList (RESERVE2) error\n"));
+ write_snmpTargetAddrTagList (FREE, (u_char *) tag_list,
+ ASN_OCTET_STR, tag_list_len, NULL,
+ eocSCCNTargetAddrTagList_index_oid,
+ eocSCCNTargetAddrTagList_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetAddrTagList (
+ ACTION,
+ (u_char *) tag_list,
+ ASN_OCTET_STR,
+ tag_list_len, NULL,
+ eocSCCNTargetAddrTagList_index_oid,
+ eocSCCNTargetAddrTagList_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetAddrAddrTagList (ACTION) error\n"));
+ write_snmpTargetAddrTagList (UNDO, (u_char *) tag_list,
+ ASN_OCTET_STR, tag_list_len, NULL,
+ eocSCCNTargetAddrTagList_index_oid,
+ eocSCCNTargetAddrTagList_index_oid_size);
+ }
+
+ write_snmpTargetAddrTagList (COMMIT, (u_char *) tag_list,
+ ASN_OCTET_STR, tag_list_len, NULL,
+ eocSCCNTargetAddrTagList_index_oid,
+ eocSCCNTargetAddrTagList_index_oid_size);
+
+ return 0;
+}
+
+int
+addRow_eocSCCNTargetAddrTable (unsigned char *taddress, size_t taddress_len)
+{
+ set_eocSCCNTargetAddrRowStatus (RS_CREATEANDWAIT);
+ set_eocSCCNTargetAddrTDomain (eocSCCNTargetAddrTDomain_value_oid,
+ eocSCCNTargetAddrTDomain_value_oid_size);
+ set_eocSCCNTargetAddrTAddress (taddress, taddress_len);
+ set_eocSCCNTargetAddrParams (eocSCCN_index_str, eocSCCN_index_str_len);
+ set_eocSCCNTargetAddrTagList (eocSCCN_index_str, eocSCCN_index_str_len);
+ set_eocSCCNTargetAddrRowStatus (RS_ACTIVE);
+
+ return 0;
+}
+
+int
+modifyRow_eocSCCNTargetAddrTable (unsigned char *taddress,
+ size_t taddress_len)
+{
+ set_eocSCCNTargetAddrRowStatus (RS_NOTINSERVICE);
+ set_eocSCCNTargetAddrTAddress (taddress, taddress_len);
+ set_eocSCCNTargetAddrRowStatus (RS_ACTIVE);
+
+ return 0;
+}
+
+/*** eocSCCNTargetParamTable ***/
+/* set eocSCCNTargetParamsRowStatus to given value */
+int
+set_eocSCCNTargetParamsRowStatus (int row_status)
+{
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetParamsRowStatus (
+ RESERVE1,
+ (u_char *) &row_status,
+ ASN_INTEGER,
+ sizeof (long),
+ NULL,
+ eocSCCNTargetParamsRowStatus_index_oid,
+ eocSCCNTargetParamsRowStatus_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetParamsRowStatus (RESERVE1) error\n"));
+ write_snmpTargetParamsRowStatus (
+ FREE, (u_char *) &row_status,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsRowStatus_index_oid,
+ eocSCCNTargetParamsRowStatus_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetParamsRowStatus (
+ RESERVE2,
+ (u_char *) &row_status,
+ ASN_INTEGER,
+ sizeof (long),
+ NULL,
+ eocSCCNTargetParamsRowStatus_index_oid,
+ eocSCCNTargetParamsRowStatus_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetParamsRowStatus (RESERVE2) error\n"));
+ write_snmpTargetParamsRowStatus (
+ FREE, (u_char *) &row_status,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsRowStatus_index_oid,
+ eocSCCNTargetParamsRowStatus_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetParamsRowStatus (
+ ACTION,
+ (u_char *) &row_status,
+ ASN_INTEGER,
+ sizeof (long),
+ NULL,
+ eocSCCNTargetParamsRowStatus_index_oid,
+ eocSCCNTargetParamsRowStatus_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetParamsRowStatus (ACTION) error\n"));
+ write_snmpTargetParamsRowStatus (
+ UNDO, (u_char *) &row_status,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsRowStatus_index_oid,
+ eocSCCNTargetParamsRowStatus_index_oid_size);
+ }
+
+ write_snmpTargetParamsRowStatus (
+ COMMIT, (u_char *) &row_status,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsRowStatus_index_oid,
+ eocSCCNTargetParamsRowStatus_index_oid_size);
+
+ return 0;
+}
+
+/* eocSCCNTargetParamsMPModel */
+/* set eocSCCNTargetParamsMPModel to given value */
+int
+set_eocSCCNTargetParamsMPModel (int mp_model)
+{
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetParamsMPModel (
+ RESERVE1,
+ (u_char *) &mp_model,
+ ASN_INTEGER,
+ sizeof (long),
+ NULL,
+ eocSCCNTargetParamsMPModel_index_oid,
+ eocSCCNTargetParamsMPModel_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetParamsMPModel (RESERVE1) error\n"));
+ write_snmpTargetParamsMPModel (
+ FREE, (u_char *) &mp_model,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsMPModel_index_oid,
+ eocSCCNTargetParamsMPModel_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetParamsMPModel (
+ RESERVE2,
+ (u_char *) &mp_model,
+ ASN_INTEGER,
+ sizeof (long),
+ NULL,
+ eocSCCNTargetParamsMPModel_index_oid,
+ eocSCCNTargetParamsMPModel_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetParamsMPModel (RESERVE2) error\n"));
+ write_snmpTargetParamsMPModel (
+ FREE, (u_char *) &mp_model,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsMPModel_index_oid,
+ eocSCCNTargetParamsMPModel_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetParamsMPModel (
+ ACTION,
+ (u_char *) &mp_model,
+ ASN_INTEGER,
+ sizeof (long),
+ NULL,
+ eocSCCNTargetParamsMPModel_index_oid,
+ eocSCCNTargetParamsMPModel_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetParamsMPModel (ACTION) error\n"));
+ write_snmpTargetParamsMPModel (
+ UNDO, (u_char *) &mp_model,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsMPModel_index_oid,
+ eocSCCNTargetParamsMPModel_index_oid_size);
+ }
+
+ write_snmpTargetParamsMPModel (COMMIT, (u_char *) &mp_model,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsMPModel_index_oid,
+ eocSCCNTargetParamsMPModel_index_oid_size);
+
+ return 0;
+}
+
+/* set eocSCCNTargetParamsSecurityModel to given value */
+int
+set_eocSCCNTargetParamsSecurityModel (int sec_model)
+{
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetParamsSecModel (
+ RESERVE1,
+ (u_char *) &sec_model,
+ ASN_INTEGER,
+ sizeof (long),
+ NULL,
+ eocSCCNTargetParamsSecurityModel_index_oid,
+ eocSCCNTargetParamsSecurityModel_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetParamsSecModel (RESERVE1) error\n"));
+ write_snmpTargetParamsSecModel (
+ FREE, (u_char *) &sec_model,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsSecurityModel_index_oid,
+ eocSCCNTargetParamsSecurityModel_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetParamsSecModel (
+ RESERVE2,
+ (u_char *) &sec_model,
+ ASN_INTEGER,
+ sizeof (long),
+ NULL,
+ eocSCCNTargetParamsSecurityModel_index_oid,
+ eocSCCNTargetParamsSecurityModel_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetParamsSecModel (RESERVE2) error\n"));
+ write_snmpTargetParamsSecModel (
+ FREE, (u_char *) &sec_model,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsSecurityModel_index_oid,
+ eocSCCNTargetParamsSecurityModel_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetParamsSecModel (
+ ACTION,
+ (u_char *) &sec_model,
+ ASN_INTEGER,
+ sizeof (long),
+ NULL,
+ eocSCCNTargetParamsSecurityModel_index_oid,
+ eocSCCNTargetParamsSecurityModel_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetParamsSecModel (ACTION) error\n"));
+ write_snmpTargetParamsSecModel (
+ UNDO, (u_char *) &sec_model,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsSecurityModel_index_oid,
+ eocSCCNTargetParamsSecurityModel_index_oid_size);
+ }
+
+ write_snmpTargetParamsSecModel (
+ COMMIT, (u_char *) &sec_model,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsSecurityModel_index_oid,
+ eocSCCNTargetParamsSecurityModel_index_oid_size);
+
+ return 0;
+}
+
+/* set eocSCCNTargetParamsSecurityName to given value */
+int
+set_eocSCCNTargetParamsSecurityName (char *sec_name, size_t sec_name_len)
+{
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetParamsSecName (
+ RESERVE1,
+ (u_char *) sec_name,
+ ASN_OCTET_STR,
+ sec_name_len, NULL,
+ eocSCCNTargetParamsSecurityName_index_oid,
+ eocSCCNTargetParamsSecurityName_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetParamsSecName (RESERVE1) error\n"));
+ write_snmpTargetParamsSecName (
+ FREE, (u_char *) sec_name,
+ ASN_OCTET_STR, sec_name_len, NULL,
+ eocSCCNTargetParamsSecurityName_index_oid,
+ eocSCCNTargetParamsSecurityName_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetParamsSecName (
+ RESERVE2,
+ (u_char *) sec_name,
+ ASN_OCTET_STR,
+ sec_name_len, NULL,
+ eocSCCNTargetParamsSecurityName_index_oid,
+ eocSCCNTargetParamsSecurityName_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetParamsSecName (RESERVE2) error\n"));
+ write_snmpTargetParamsSecName (
+ FREE, (u_char *) sec_name,
+ ASN_OCTET_STR, sec_name_len, NULL,
+ eocSCCNTargetParamsSecurityName_index_oid,
+ eocSCCNTargetParamsSecurityName_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetParamsSecName (
+ ACTION,
+ (u_char *) sec_name,
+ ASN_OCTET_STR,
+ sec_name_len, NULL,
+ eocSCCNTargetParamsSecurityName_index_oid,
+ eocSCCNTargetParamsSecurityName_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetParamsSecName (ACTION) error\n"));
+ write_snmpTargetParamsSecName (
+ UNDO, (u_char *) sec_name,
+ ASN_OCTET_STR, sec_name_len, NULL,
+ eocSCCNTargetParamsSecurityName_index_oid,
+ eocSCCNTargetParamsSecurityName_index_oid_size);
+ }
+
+ write_snmpTargetParamsSecName (
+ COMMIT, (u_char *) sec_name,
+ ASN_OCTET_STR, sec_name_len, NULL,
+ eocSCCNTargetParamsSecurityName_index_oid,
+ eocSCCNTargetParamsSecurityName_index_oid_size);
+ return 0;
+
+}
+
+/* set eocSCCNTargetParamsSecurityLevel to given value */
+int
+set_eocSCCNTargetParamsSecurityLevel (int sec_level)
+{
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetParamsSecLevel (
+ RESERVE1,
+ (u_char *) &sec_level,
+ ASN_INTEGER,
+ sizeof (long),
+ NULL,
+ eocSCCNTargetParamsSecurityLevel_index_oid,
+ eocSCCNTargetParamsSecurityLevel_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetParamsSecLevel (RESERVE1) error\n"));
+ write_snmpTargetParamsSecLevel (
+ FREE, (u_char *) &sec_level,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsSecurityLevel_index_oid,
+ eocSCCNTargetParamsSecurityLevel_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetParamsSecLevel (
+ RESERVE2,
+ (u_char *) &sec_level,
+ ASN_INTEGER,
+ sizeof (long),
+ NULL,
+ eocSCCNTargetParamsSecurityLevel_index_oid,
+ eocSCCNTargetParamsSecurityLevel_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetParamsSecLevel (RESERVE2) error\n"));
+ write_snmpTargetParamsSecLevel (
+ FREE, (u_char *) &sec_level,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsSecurityLevel_index_oid,
+ eocSCCNTargetParamsSecurityLevel_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetParamsSecLevel (
+ ACTION,
+ (u_char *) &sec_level,
+ ASN_INTEGER,
+ sizeof (long),
+ NULL,
+ eocSCCNTargetParamsSecurityLevel_index_oid,
+ eocSCCNTargetParamsSecurityLevel_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetParamsSecLevel (ACTION) error\n"));
+ write_snmpTargetParamsSecLevel (
+ UNDO, (u_char *) &sec_level,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsSecurityLevel_index_oid,
+ eocSCCNTargetParamsSecurityLevel_index_oid_size);
+ }
+
+ write_snmpTargetParamsSecLevel (
+ COMMIT, (u_char *) &sec_level,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsSecurityLevel_index_oid,
+ eocSCCNTargetParamsSecurityLevel_index_oid_size);
+
+ return 0;
+
+}
+
+/* set eocSCCNTargetParamsStorageType to given value */
+int
+set_eocSCCNTargetParamsStorageType (int st_type)
+{
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetParamsStorageType (
+ RESERVE1,
+ (u_char *) &st_type,
+ ASN_INTEGER,
+ sizeof (long),
+ NULL,
+ eocSCCNTargetParamsStorageType_index_oid,
+ eocSCCNTargetParamsStorageType_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetParamsStorageType (RESERVE1) error\n"));
+ write_snmpTargetParamsStorageType (
+ FREE, (u_char *) &st_type,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsStorageType_index_oid,
+ eocSCCNTargetParamsStorageType_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetParamsStorageType (
+ RESERVE2,
+ (u_char *) &st_type,
+ ASN_INTEGER,
+ sizeof (long),
+ NULL,
+ eocSCCNTargetParamsStorageType_index_oid,
+ eocSCCNTargetParamsStorageType_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetParamsStorageType (RESERVE2) error\n"));
+ write_snmpTargetParamsStorageType (
+ FREE, (u_char *) &st_type,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsStorageType_index_oid,
+ eocSCCNTargetParamsStorageType_index_oid_size);
+ }
+
+ if (SNMP_ERR_NOERROR != write_snmpTargetParamsStorageType (
+ ACTION,
+ (u_char *) &st_type,
+ ASN_INTEGER,
+ sizeof (long),
+ NULL,
+ eocSCCNTargetParamsStorageType_index_oid,
+ eocSCCNTargetParamsStorageType_index_oid_size))
+ {
+ DEBUGMSGTL (("eocSCCNAlarmsAnsTraps_interface",
+ "write_snmpTargetParamsStorageType (ACTION) error\n"));
+ write_snmpTargetParamsStorageType (
+ UNDO, (u_char *) &st_type,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsStorageType_index_oid,
+ eocSCCNTargetParamsStorageType_index_oid_size);
+ }
+
+ write_snmpTargetParamsStorageType (
+ COMMIT, (u_char *) &st_type,
+ ASN_INTEGER, sizeof (long), NULL,
+ eocSCCNTargetParamsStorageType_index_oid,
+ eocSCCNTargetParamsStorageType_index_oid_size);
+
+ return 0;
+
+}
+
+int
+addRow_eocSCCNTargetParamsTable (char *sec_name, size_t sec_name_len)
+{
+ set_eocSCCNTargetParamsRowStatus (RS_CREATEANDWAIT);
+ set_eocSCCNTargetParamsMPModel (SNMP_MP_MODEL_SNMPv2c);
+ set_eocSCCNTargetParamsSecurityModel (SNMP_SEC_MODEL_SNMPv2c);
+ set_eocSCCNTargetParamsSecurityName (sec_name, sec_name_len);
+ set_eocSCCNTargetParamsSecurityLevel (SNMP_SEC_LEVEL_NOAUTH);
+ set_eocSCCNTargetParamsStorageType (ST_VOLATILE);
+ set_eocSCCNTargetParamsRowStatus (RS_ACTIVE);
+
+ return 0;
+}
+
+int
+modifyRow_eocSCCNTargetParamsTable (char *sec_name, size_t sec_name_len)
+{
+ set_eocSCCNTargetParamsRowStatus (RS_NOTINSERVICE);
+ set_eocSCCNTargetParamsSecurityName (sec_name, sec_name_len);
+ set_eocSCCNTargetParamsRowStatus (RS_ACTIVE);
+
+ return 0;
+}
diff --git a/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNAlarmsAndTraps_interface.h b/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNAlarmsAndTraps_interface.h
new file mode 100644
index 0000000000..12d357b2b3
--- /dev/null
+++ b/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNAlarmsAndTraps_interface.h
@@ -0,0 +1,74 @@
+#ifndef EOC_SCCNALARMSANDTRAPS_INTERFACE_H
+#define EOC_SCCNALARMSANDTRAPS_INTERFACE_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* include headers for notification and target tables */
+#include "notification/snmpNotifyTable.h"
+#include "target/snmpTargetAddrEntry.h"
+#include "target/snmpTargetParamsEntry.h"
+
+#define EOCSCCN_ROW_ADD 1
+#define EOCSCCN_ROW_MODIFY 2
+
+#define EOCSCCN_TABLE_INDEX_STR "addr1"
+#define EOCSCCN_TABLE_INDEX_LEN 5
+#define EOCSCCN_TABLE_INDEX_ASC 97, 100, 100, 114, 49
+
+/* definitions for OID strings */
+/** snmpNotifyTable **/
+#define EOCSCCNNOTIFYROWSTATUSINDEX_OID \
+1, 3, 6, 1, 6, 3, 13, 1, 1, 1, 5, EOCSCCN_TABLE_INDEX_ASC
+#define EOCSCCNNOTIFYTAGINDEX_OID \
+1, 3, 6, 1, 6, 3, 13, 1, 1, 1, 2, EOCSCCN_TABLE_INDEX_ASC
+#define EOCSCCNNOTIFYTYPEINDEX_OID \
+1, 3, 6, 1, 6, 3, 13, 1, 1, 1, 3, EOCSCCN_TABLE_INDEX_ASC
+#define EOCSCCNNOTIFYSTORAGETYPEINDEX_OID \
+1, 3, 6, 1, 6, 3, 13, 1, 1, 1, 4, EOCSCCN_TABLE_INDEX_ASC
+
+/** snmpTargetAddrTable **/
+#define EOCSCCNTARGETADDRROWSTATUSINDEX_OID \
+1, 3, 6, 1, 6, 3, 12, 1, 2, 1, 9, EOCSCCN_TABLE_INDEX_ASC
+#define EOCSCCNTARGETADDRTDOMAININDEX_OID \
+1, 3, 6, 1, 6, 3, 12, 1, 2, 1, 2, EOCSCCN_TABLE_INDEX_ASC
+#define EOCSCCNTARGETADDRTDOMAINUDP_OID \
+1, 3, 6, 1, 6, 1, 1
+#define EOCSCCNTARGETADDRTADDRESSINDEX_OID \
+1, 3, 6, 1, 6, 3, 12, 1, 2, 1, 3, EOCSCCN_TABLE_INDEX_ASC
+#define EOCSCCNTARGETADDRPARAMSINDEX_OID \
+1, 3, 6, 1, 6, 3, 12, 1, 2, 1, 7, EOCSCCN_TABLE_INDEX_ASC
+#define EOCSCCNTARGETADDRTAGLISTINDEX_OID \
+1, 3, 6, 1, 6, 3, 12, 1, 2, 1, 6, EOCSCCN_TABLE_INDEX_ASC
+
+/** snmpTargetParamsTable **/
+#define EOCSCCNTARGETPARAMSROWSTATUSINDEX_OID \
+1, 3, 6, 1, 6, 3, 12, 1, 3, 1, 7, EOCSCCN_TABLE_INDEX_ASC
+#define EOCSCCNTARGETPARAMSMPMODELINDEX_OID \
+1, 3, 6, 1, 6, 3, 12, 1, 3, 1, 2, EOCSCCN_TABLE_INDEX_ASC
+#define EOCSCCNTARGETPARAMSSECURITYMODELINDEX_OID \
+1, 3, 6, 1, 6, 3, 12, 1, 3, 1, 3, EOCSCCN_TABLE_INDEX_ASC
+#define EOCSCCNTARGETPARAMSSECURITYNAMEINDEX_OID \
+1, 3, 6, 1, 6, 3, 12, 1, 3, 1, 4, EOCSCCN_TABLE_INDEX_ASC
+#define EOCSCCNTARGETPARAMSSECURITYLEVELINDEX_OID \
+1, 3, 6, 1, 6, 3, 12, 1, 3, 1, 5, EOCSCCN_TABLE_INDEX_ASC
+#define EOCSCCNTARGETPARAMSSTORAGETYPEINDEX_OID \
+1, 3, 6, 1, 6, 3, 12, 1, 3, 1, 6, EOCSCCN_TABLE_INDEX_ASC
+
+/* function declarations */
+int addRow_eocSCCNNotifyTable (void);
+int addRow_eocSCCNTargetAddrTable (unsigned char *taddress,
+ size_t taddress_len);
+int modifyRow_eocSCCNTargetAddrTable (unsigned char *taddress,
+ size_t taddress_len);
+int addRow_eocSCCNTargetParamsTable (char *sec_name, size_t sec_name_len);
+int modifyRow_eocSCCNTargetParamsTable (char *sec_name,
+ size_t sec_name_len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* EOCALARMSANDTRAPS_INTERFACE_H */
diff --git a/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNTraps.h b/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNTraps.h
new file mode 100644
index 0000000000..daf16fba1e
--- /dev/null
+++ b/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNTraps.h
@@ -0,0 +1 @@
+config_require(mstar-sccn-mib/sccn-alarm-mib/eocSCCNTraps/eocSCCNTraps)
diff --git a/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNTraps/eocSCCNTraps.c b/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNTraps/eocSCCNTraps.c
new file mode 100644
index 0000000000..3a250cb96f
--- /dev/null
+++ b/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNTraps/eocSCCNTraps.c
@@ -0,0 +1,450 @@
+
+#include <net-snmp/net-snmp-config.h>
+#include <net-snmp/net-snmp-includes.h>
+#include <net-snmp/agent/net-snmp-agent-includes.h>
+
+#include "eocSCCNTraps.h"
+
+int cbat_online_flags = 0;
+
+
+/*sotre status for eocSCCN alarms*/
+eoc_sccn_cnu_alarm_info_t
+ eoc_sccn_cnu_alarm_info[LIBSPID_ONLINE_INFO_LINE_MAX_NB];
+
+/*
+ * definition of snmpTrapOID.0 object
+ */
+oid eoc_sccn_objid_snmptrap[] = { 1, 3, 6, 1, 6, 3, 1, 1, 4, 1, 0 };
+
+size_t eoc_sccn_objid_snmptrap_len = OID_LENGTH (eoc_sccn_objid_snmptrap);
+
+int
+set_eoc_sccn_cnu_alarm_list (int tei, int bit, int flag)
+{
+ int i = 0;
+ unsigned char value_char;
+ if (bit < 0)
+ return -1;
+ value_char = bit;
+ for (i = 0; i < LIBSPID_ONLINE_INFO_LINE_MAX_NB; i++)
+ {
+ if (eoc_sccn_cnu_alarm_info[i].tei == tei)
+ {
+ if (flag == 1)
+ eoc_sccn_cnu_alarm_info[i].state =
+ (eoc_sccn_cnu_alarm_info[i].state) | value_char;
+ else if ((eoc_sccn_cnu_alarm_info[i].state) & value_char)
+ {
+ eoc_sccn_cnu_alarm_info[i].state =
+ (eoc_sccn_cnu_alarm_info[i].state) ^ value_char;
+ }
+ return tei;
+ }
+ }
+ for (i = 0; i < LIBSPID_ONLINE_INFO_LINE_MAX_NB; i++)
+ {
+ if (eoc_sccn_cnu_alarm_info[i].tei == 0)
+ {
+ eoc_sccn_cnu_alarm_info[i].state = (flag == 1) ? bit : 0;
+ eoc_sccn_cnu_alarm_info[i].tei = tei;
+ return tei;
+ }
+ }
+ return -1;
+}
+
+int
+find_eoc_sccn_cnu_alarm_list (int tei)
+{
+ int i = 0;
+ for (i = 0; i < LIBSPID_ONLINE_INFO_LINE_MAX_NB; i++)
+ {
+ if (eoc_sccn_cnu_alarm_info[i].tei == tei)
+ return eoc_sccn_cnu_alarm_info[i].state;
+ }
+ return -1;
+}
+
+int
+check_eoc_sccn_cnu_alarm_list (int tei, int bit)
+{
+ unsigned char value;
+ int i;
+ if (bit < 0)
+ return -1;
+ value = bit;
+ for (i = 0; i < LIBSPID_ONLINE_INFO_LINE_MAX_NB; i++)
+ {
+ if (eoc_sccn_cnu_alarm_info[i].tei == tei)
+ {
+ if (eoc_sccn_cnu_alarm_info[i].state & value)
+ return 1;
+ return 0;
+ }
+ }
+ return 0;
+}
+
+/* we need to put the slave's tei into alarm_oid ,
+ * so first we should do this fun
+ */
+int
+handleEoCSCCNCnuAlarmOID ()
+{
+ int ret, i = 0;
+ eocSCCNCnuOnlineInfo_t
+ eocSCCNCnuOnlineInfo[LIBSPID_ONLINE_INFO_LINE_MAX_NB];
+ int online_mac_count = 0;
+ int value = 0, thr_value = 0;
+ char buffer[LIBSPID_LINE_MAX_LEN], key_buffer[LIBSPID_KEY_MAX_LEN];
+ const char delimiters[2] = LIBSPID_ONLINE_INFO_DELIMITER "\0";
+ unsigned int elt_number = LIBSPID_ELT_MAX_NB;
+ char *elt_buffer[LIBSPID_ELT_MAX_NB];
+ libspid_eoc_wl_entry_t eoc_wl_entry;
+ strcpy (key_buffer, "");
+ memset (eocSCCNCnuOnlineInfo, 0x0, sizeof (eocSCCNCnuOnlineInfo));
+ memset (&eoc_wl_entry, 0x0, sizeof (libspid_eoc_wl_entry_t));
+ ret =
+ libspid_config_read_line (LIBSPID_ONLINE_INFO_PATH, delimiters,
+ key_buffer, &elt_number, elt_buffer,
+ buffer, LIBSPID_LINE_MAX_LEN);
+ if (LIBSPID_SUCCESS != ret)
+ {
+ syslog (LOG_DEBUG, "eocSCCNCnuTraps:eocSCCNCnuTraps_read_online_item:\
+ error reading online entry for MAC address_count: %d\n",
+ online_mac_count);
+ return ret;
+ }
+ for (i = 0; i < LIBSPID_ONLINE_INFO_LINE_MAX_NB; i++)
+ {
+ /* check that eof is not reached */
+ if (!strcmp (key_buffer, ""))
+ {
+ DEBUGMSGTL (("eocSCCNCnuTraps:eocCnuTraps_read_online_item",
+ "eof reached for mac_address_count : %d \n", i));
+ break;
+ }
+ /* set number of remaining line elements to extract */
+ elt_number = LIBSPID_ELT_MAX_NB;
+ strncpy (eocSCCNCnuOnlineInfo[i].curAtn_macAddress, key_buffer,
+ sizeof (eocSCCNCnuOnlineInfo[i].curAtn_macAddress));
+ eocSCCNCnuOnlineInfo[i].curAtn_macAddress[strlen (key_buffer)] = '\0';
+ ret =
+ libspid_config_read_line (LIBSPID_ONLINE_INFO_PATH, delimiters,
+ key_buffer, &elt_number, elt_buffer,
+ buffer, LIBSPID_LINE_MAX_LEN);
+ if (LIBSPID_SUCCESS != ret)
+ {
+ snmp_log (LOG_ERR, "eocSCCNCnuTraps.c libspid_config_read_line \
+ for online info error param:%d\n", ret);
+ }
+ ret =
+ libspid_eoc_wl_get (eocSCCNCnuOnlineInfo[i].curAtn_macAddress,
+ &eoc_wl_entry);
+ if (LIBSPID_ERROR_NOT_FOUND == ret)
+ {
+ eocSCCNCnuOnlineInfo[i].tei = 0;
+ }
+ else if (LIBSPID_SUCCESS != 0)
+ {
+ snmp_log (LOG_NOTICE, "eocSCCNCnuTraps.c libspid_config_read_line\
+ for wl info error:%d\n", ret);
+ eocSCCNCnuOnlineInfo[i].tei = 0;
+ }
+ else
+ {
+ sscanf (eoc_wl_entry.tei, "%d", &eocSCCNCnuOnlineInfo[i].tei);
+ }
+ sscanf (elt_buffer[5], "%d", &eocSCCNCnuOnlineInfo[i].curAtn);
+ sscanf (elt_buffer[2], "%d", &eocSCCNCnuOnlineInfo[i].authorisation);
+ }
+ online_mac_count = i;
+ ret = checkEoCSCCNCnuAlarm (eocSCCNCnuOnlineInfo, online_mac_count);
+ return ret;
+}
+
+int
+getMacAddrByTei (int tei, char *mac_addr)
+{
+ int i;
+ int ret = 0;;
+ if (NULL == mac_addr)
+ return -1;
+ libspid_eoc_wl_entry_t eoc_wl_entry[LIBSPID_WHITE_LIST_MAX_STA_NUM];
+ int mac_address_count = 0;
+ if (LIBSPID_SUCCESS !=
+ (ret = libspid_eoc_wl_get_list (eoc_wl_entry, &mac_address_count)))
+ {
+ snmp_log (LOG_ERR, "libspid_eoc_wl_get_list error :%d\n", ret);
+ return ret;
+ }
+ for (i = 0; i < mac_address_count; i++)
+ {
+ if (atoi (eoc_wl_entry[i].tei) == tei)
+ {
+ if (NULL != strncpy (mac_addr, eoc_wl_entry[i].mac_addr,
+ LIBSPID_MAC_STR_LEN))
+ return 0;
+ }
+ }
+ return -1;
+}
+
+int
+checkCnuOnline (int tei)
+{
+ int i, ret;
+ const char delimiters[2] = LIBSPID_ONLINE_INFO_DELIMITER "\0";
+ char key[LIBSPID_CONFIG_KEY_MAX_LEN] = { 0 };
+ unsigned int elt_number = LIBSPID_CONFIG_ELT_MAX_NB;
+ char *elt[LIBSPID_CONFIG_ELT_MAX_NB];
+ char buffer[LIBSPID_CONFIG_LINE_MAX_LEN];
+ if (LIBSPID_SUCCESS == getMacAddrByTei (tei, key))
+ {
+ ret = libspid_config_read_line (LIBSPID_ONLINE_INFO_PATH, delimiters,
+ key, &elt_number, elt, buffer,
+ LIBSPID_CONFIG_LINE_MAX_LEN);
+ if (ret == LIBSPID_SUCCESS)
+ {
+ if (!strcmp ("1", elt[2]))
+ return 1;
+ else
+ return 0;
+ }
+ else if (ret == LIBSPID_ERROR_NOT_FOUND)
+ {
+ return 0;
+ }
+ else
+ {
+ snmp_log (LOG_ERR, "checkCnuOnline libspid_config_read_line\
+ error:%d\n", ret);
+ return -1;
+ }
+ }
+ else
+ {
+ snmp_log (LOG_ERR, "checkCnuOnline getMacAddrByTei error\n");
+ return -1;
+ }
+}
+
+int
+checkEoCSCCNCnuAlarm (eocSCCNCnuOnlineInfo_t * eocSCCNCnuOnlineInfo,
+ int online_mac_count)
+{
+ eocSCCNCnuOnlineInfo_t *temp;
+ char oid_str[LIBSPID_OID_MAX_LEN];
+ int i = 0;
+ unsigned char online_value = EOCSCCNCNUONLINE_BIT;
+ if (eocSCCNCnuOnlineInfo == NULL)
+ return SNMP_ERR_BADVALUE;
+ temp = eocSCCNCnuOnlineInfo;
+ /*to register alarm by the device value list */
+ for (i = 0; i < online_mac_count; i++, temp++)
+ {
+ memset (oid_str, 0x0, sizeof (oid_str));
+ /*check if we can create the authorisation slave first online alarm */
+ if ((1 == temp->authorisation) && (0 != temp->tei)
+ && !check_eoc_sccn_cnu_alarm_list (temp->tei,
+ EOCSCCNCNUONLINE_BIT))
+ {
+ sprintf (oid_str, "%s.0.%d", EOCSCCNCNUONLINE_OID_STR,
+ temp->tei - 2);
+ registerEoCSCCNAlarm (oid_str, 1, 1);
+ if (-1 == set_eoc_sccn_cnu_alarm_list (temp->tei,
+ EOCSCCNCNUONLINE_BIT, 1))
+ {
+ snmp_log (LOG_ERR, "set online failed\n");
+ return SNMP_ERR_GENERR;
+ }
+ }
+ }
+ for (i = 0; i < LIBSPID_ONLINE_INFO_LINE_MAX_NB; i++)
+ {
+ if ((eoc_sccn_cnu_alarm_info[i].tei != 0) &&
+ (eoc_sccn_cnu_alarm_info[i].state & online_value))
+ {
+ if (checkCnuOnline (eoc_sccn_cnu_alarm_info[i].tei) == 0)
+ {
+ sprintf (oid_str, "%s.0.%d", EOCSCCNCNUOFFLINE_OID_STR,
+ eoc_sccn_cnu_alarm_info[i].tei - 2);
+ registerEoCSCCNAlarm (oid_str, 1, 0);
+ if (-1 == set_eoc_sccn_cnu_alarm_list
+ (eoc_sccn_cnu_alarm_info[i].tei, EOCSCCNCNUONLINE_BIT, 0))
+ {
+ snmp_log (LOG_ERR, "set offline failed\n");
+ return SNMP_ERR_GENERR;
+ }
+ }
+ }
+ }
+ return SNMP_ERR_NOERROR;
+}
+
+int
+checkEoCSCCNCBatAlarms ()
+{
+ if (0 == cbat_online_flags)
+ {
+ registerEoCSCCNAlarm (EOCSCCNCBATONLINEOID, 1, 1);
+ cbat_online_flags = 1;
+ }
+ return SNMP_ERR_NOERROR;
+}
+
+int
+send_eocSCCNCnuOnline_trap (char *alarm_oid_str, int value, int state)
+{
+ netsnmp_variable_list *var_list = NULL;
+ oid eocSCCNCnuOnline_oid[] = { 1, 3, 6, 1, 4, 1, 17409, 2, 2, 1, 111, 1 };
+ oid eocSCCNCnuOffline_oid[] =
+ { 1, 3, 6, 1, 4, 1, 17409, 2, 2, 1, 111, 2 };
+ oid eocCBATCardMACAddress_oid[] =
+ { 1, 3, 6, 1, 4, 1, 17409, 2, 4, 3, 2, 1, 2 };
+ oid eocCNUMACAddress_oid[] =
+ { 1, 3, 6, 1, 4, 1, 17409, 2, 4, 5, 2, 4, 1, 3 };
+ oid eocCNUOnlineStatus_oid[] =
+ { 1, 3, 6, 1, 4, 1, 17409, 2, 4, 5, 2, 4, 1, 4 };
+ oid alarm_oid[LIBSPID_OID_MAX_LEN];
+ size_t alarm_oid_len = LIBSPID_OID_MAX_LEN;
+ int tei;
+ char cbat_mac_addr_str[LIBSPID_MAC_STR_LEN];
+ char cnu_mac_addr_str[LIBSPID_MAC_STR_LEN];
+ /* add alarm OID as trap variable */
+ if (LIBSPID_SUCCESS != libspid_network_get_mac ("br0", cbat_mac_addr_str))
+ {
+ snmp_log (LOG_ERR, "send_eocSCCNTraps: libspid_network_get_mac \
+ error\n");
+ strcpy (cbat_mac_addr_str, "00:00:00:00:00:00");
+ }
+ /*get tei from alarm_oid_str */
+ {
+ char *s;
+ s = strrchr (alarm_oid_str, '.');
+ tei = atoi (++s) + 2;
+ }
+
+ /* This mac not in the whitelis , so we do nothing */
+ if (getMacAddrByTei (tei, cnu_mac_addr_str) == -1)
+ return SNMP_ERR_NOERROR;
+
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ if (1 == value)
+ {
+ snmp_varlist_add_variable (&var_list, eoc_sccn_objid_snmptrap,
+ OID_LENGTH (eoc_sccn_objid_snmptrap),
+ ASN_OBJECT_ID,
+ (const u_char *) eocSCCNCnuOnline_oid,
+ sizeof (eocSCCNCnuOnline_oid));
+ }
+ else
+ {
+ snmp_varlist_add_variable (&var_list, eoc_sccn_objid_snmptrap,
+ OID_LENGTH (eoc_sccn_objid_snmptrap),
+ ASN_OBJECT_ID,
+ (const u_char *) eocSCCNCnuOffline_oid,
+ sizeof (eocSCCNCnuOffline_oid));
+ }
+ /* parse alarm OID from string representation */
+ if (!read_objid (alarm_oid_str, alarm_oid, &alarm_oid_len))
+ {
+ syslog (LOG_DEBUG, "eoSCCNCAlarmsAndTraps: error parsing alarm OID\
+ from string representation, setting OID to invalid\n");
+ read_objid ("0.0", alarm_oid, &alarm_oid_len);
+ }
+ else
+ {
+ /* check if length of parsed OID is within allowed range */
+ if (alarm_oid_len < 1 || alarm_oid_len > LIBSPID_OID_MAX_LEN)
+ {
+ syslog (LOG_DEBUG, "EoCSCCNAlarmsAndTraps: alarm OID length out\
+ of range, setting OID to invalid\n");
+ read_objid ("0.0", alarm_oid, &alarm_oid_len);
+ }
+ }
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ snmp_varlist_add_variable (&var_list, eoc_sccn_objid_snmptrap,
+ OID_LENGTH (eoc_sccn_objid_snmptrap),
+ ASN_OBJECT_ID,
+ (const u_char *) alarm_oid,
+ alarm_oid_len * sizeof (oid));
+
+ /*
+ * Add any objects from the trap definition
+ */
+ snmp_varlist_add_variable (&var_list, eocCBATCardMACAddress_oid,
+ OID_LENGTH (eocCBATCardMACAddress_oid),
+ ASN_OCTET_STR,
+ (u_char *) cbat_mac_addr_str,
+ sizeof (cbat_mac_addr_str));
+ snmp_varlist_add_variable (&var_list, eocCNUMACAddress_oid,
+ OID_LENGTH (eocCNUMACAddress_oid),
+ ASN_OCTET_STR,
+ (u_char *) cnu_mac_addr_str,
+ sizeof (cnu_mac_addr_str));
+ snmp_varlist_add_variable (&var_list, eocCNUOnlineStatus_oid,
+ OID_LENGTH (eocCNUOnlineStatus_oid),
+ ASN_INTEGER,
+ (u_char *) & value, sizeof (value));
+
+ /*
+ * 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;
+}
+
+int
+send_eocSCCNCbatOnline_trap (void)
+{
+ netsnmp_variable_list *var_list = NULL;
+ oid eocSCCNCbatOnline_oid[] =
+ { 1, 3, 6, 1, 4, 1, 17409, 2, 2, 1, 111, 4 };
+ oid eocCBATAdminMACAddress_oid[] =
+ { 1, 3, 6, 1, 4, 1, 17409, 2, 4, 1, 2, 1 };
+ oid eocCBATCardMACAddress_oid[] =
+ { 1, 3, 6, 1, 4, 1, 17409, 2, 4, 3, 2, 1, 2 };
+ int ret;
+ char cbat_mac_addr_str[LIBSPID_MAC_STR_LEN];
+ if (LIBSPID_SUCCESS != libspid_network_get_mac ("br0", cbat_mac_addr_str))
+ {
+ snmp_log (LOG_ERR, "eocCbatTraps: libspid_network_get_mac error\n");
+ strcpy (cbat_mac_addr_str, "00:00:00:00:00:00");
+ }
+ /*
+ * Set the snmpTrapOid.0 value
+ */
+ snmp_varlist_add_variable (&var_list, eoc_sccn_objid_snmptrap,
+ OID_LENGTH (eoc_sccn_objid_snmptrap),
+ ASN_OBJECT_ID,
+ (u_char *) eocSCCNCbatOnline_oid,
+ sizeof (eocSCCNCbatOnline_oid));
+ /*
+ * Add any objects from the trap definition
+ */
+ snmp_varlist_add_variable (&var_list, eocCBATAdminMACAddress_oid,
+ OID_LENGTH (eocCBATAdminMACAddress_oid),
+ ASN_OCTET_STR,
+ (u_char *) cbat_mac_addr_str,
+ sizeof (cbat_mac_addr_str));
+ snmp_varlist_add_variable (&var_list, eocCBATCardMACAddress_oid,
+ OID_LENGTH (eocCBATCardMACAddress_oid),
+ ASN_OCTET_STR,
+ (u_char *) cbat_mac_addr_str,
+ sizeof (cbat_mac_addr_str));
+ /*
+ * 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;
+}
diff --git a/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNTraps/eocSCCNTraps.h b/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNTraps/eocSCCNTraps.h
new file mode 100644
index 0000000000..18fdffade2
--- /dev/null
+++ b/cleopatre/application/spidnetsnmp/agent/mibgroup/mstar-sccn-mib/sccn-alarm-mib/eocSCCNTraps/eocSCCNTraps.h
@@ -0,0 +1,46 @@
+#ifndef EOC_SCCNTRAPS_H
+#define EOC_SCCNTRAPS_H
+
+
+/* include common header */
+#include "EoCCommon.h"
+
+/*eocSCCNTraps oid*/
+#define EOCSCCNOID ".1.3.6.1.4.1.17409.2.2.1.111"
+#define EOCSCCNCNUONLINE_OID_STR ".1.3.6.1.4.1.17409.2.2.1.111.1"
+#define EOCSCCNCNUOFFLINE_OID_STR ".1.3.6.1.4.1.17409.2.2.1.111.2"
+#define EOCSCCNCNULOOPBACK_OID_STR ".1.3.6.1.4.1.17409.2.2.1.111.3"
+#define EOCSCCNCBATONLINEOID ".1.3.6.1.4.1.17409.2.2.1.111.4"
+
+#define EOCSCCN_ALARM_LOG_INFO_MAX_LENGTH 255
+#define EOCSCCN_ALARM_LOG_SIZE 64
+#define EOCSCCN_ALARM_LOG_MAX_INDEX 32767
+
+/* state bit the 1 bit is for online:1,offline:0*/
+#define EOCSCCNCNUONLINE_BIT (1<<0)
+
+
+
+typedef struct
+{
+ unsigned int tei;
+ unsigned char state;
+} eoc_sccn_cnu_alarm_info_t;
+
+typedef struct eocSCCNCnuOnlineInfo
+{
+ char curAtn_macAddress[LIBSPID_MAC_STR_LEN];
+ int curAtn;
+ int authorisation;
+ int tei;
+} eocSCCNCnuOnlineInfo_t;
+
+
+int checkEoCSCCNCBatAlarms ();
+/*send funs for eocSCCNTraps */
+int send_eocSCCNCnuOnline_trap (char *alarm_oid_str, int value, int state);
+int send_eocSCCNCbatOnline_trap (void);
+
+
+
+#endif /* EOC_SCCNTRAPS_H */