pingctltable.c

snmp的源代码,已经在我的ubuntu下编译通过

/*
 *Copyright(c)2004,Cisco URP imburses and Network Information Center in Beijing University of Posts and Telecommunications researches.
 *
 *All right reserved
 *
 *File Name:pingCtlTable.c
 *File Description:Rows of the pingCtlTable MIB add , delete and read.Rows of lookupResultsTable
 *              MIB add and delete.Rows of pingProbeHistoryTable MIB add and delete. 
 *              The main function is also here.
 *
 *Current Version:1.0
 *Author:ChenJing
 *Date:2004.8.20
 */

/*
 * This should always be included first before anything else 
 */

#if HAVE_STDLIB_H
#include <stdlib.h>
#endif
#if HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif

#include <netdb.h>
#include <netinet/in.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>


#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>

#include "pingCtlTable.h"
#include "pingResultsTable.h"
#include "pingProbeHistoryTable.h"
#include "header_complex.h"


/*
 *pingCtlTable_variables_oid:
 *                                                      
 */


oid             pingCtlTable_variables_oid[] =
    { 1, 3, 6, 1, 2, 1, 80, 1, 2 };

/* trap */
oid             pingProbeFailed[] = { 1, 3, 6, 1, 2, 1, 80, 0, 1 };
oid             pingTestFailed[] = { 1, 3, 6, 1, 2, 1, 80, 0, 2 };
oid             pingTestCompleted[] = { 1, 3, 6, 1, 2, 1, 80, 0, 3 };


struct variable2 pingCtlTable_variables[] = {
    /*
     * magic number        , variable type , ro/rw , callback fn  , L, oidsuffix 
     */
    {COLUMN_PINGCTLTARGETADDRESSTYPE, ASN_INTEGER, RWRITE, var_pingCtlTable, 2, {1, 3}},
    {COLUMN_PINGCTLTARGETADDRESS,   ASN_OCTET_STR, RWRITE, var_pingCtlTable, 2, {1, 4}},
    {COLUMN_PINGCTLDATASIZE,         ASN_UNSIGNED, RONLY, var_pingCtlTable, 2, {1, 5}},
    {COLUMN_PINGCTLTIMEOUT,          ASN_UNSIGNED, RONLY, var_pingCtlTable, 2, {1, 6}},
    {COLUMN_PINGCTLPROBECOUNT,       ASN_UNSIGNED, RONLY, var_pingCtlTable, 2, {1, 7}},
    {COLUMN_PINGCTLADMINSTATUS,       ASN_INTEGER, RWRITE, var_pingCtlTable, 2, {1, 8}},
    {COLUMN_PINGCTLDATAFILL,        ASN_OCTET_STR, RWRITE, var_pingCtlTable, 2, {1, 9}},
    {COLUMN_PINGCTLFREQUENCY,        ASN_UNSIGNED, RWRITE, var_pingCtlTable, 2, {1, 10}},
    {COLUMN_PINGCTLMAXROWS,          ASN_UNSIGNED, RWRITE, var_pingCtlTable, 2, {1, 11}},
    {COLUMN_PINGCTLSTORAGETYPE,       ASN_INTEGER, RWRITE, var_pingCtlTable, 2, {1, 12}},
    {COLUMN_PINGCTLTRAPGENERATION,  ASN_OCTET_STR, RWRITE, var_pingCtlTable, 2, {1, 13}},
    {COLUMN_PINGCTLTRAPPROBEFAILUREFILTER, ASN_UNSIGNED, RWRITE, var_pingCtlTable, 2, {1, 14}},
    {COLUMN_PINGCTLTRAPTESTFAILUREFILTER,  ASN_UNSIGNED, RWRITE, var_pingCtlTable, 2, {1, 15}},
    {COLUMN_PINGCTLTYPE,            ASN_OBJECT_ID, RWRITE, var_pingCtlTable, 2, {1, 16}},
    {COLUMN_PINGCTLDESCR,           ASN_OCTET_STR, RWRITE, var_pingCtlTable, 2, {1, 17}},
    {COLUMN_PINGCTLSOURCEADDRESSTYPE, ASN_INTEGER, RWRITE, var_pingCtlTable, 2, {1, 18}},
    {COLUMN_PINGCTLSOURCEADDRESS,   ASN_OCTET_STR, RWRITE, var_pingCtlTable, 2, {1, 19}},
    {COLUMN_PINGCTLIFINDEX,           ASN_INTEGER, RWRITE, var_pingCtlTable, 2, {1, 20}},
    {COLUMN_PINGCTLBYPASSROUTETABLE,  ASN_INTEGER, RWRITE, var_pingCtlTable, 2, {1, 21}},
    {COLUMN_PINGCTLDSFIELD,          ASN_UNSIGNED, RWRITE, var_pingCtlTable, 2, {1, 22}},
    {COLUMN_PINGCTLROWSTATUS,         ASN_INTEGER, RWRITE, var_pingCtlTable, 2, {1, 23}}
};




/*
 * global storage of our data, saved in and configured by header_complex() 
 */


struct header_complex_index *pingCtlTableStorage = NULL;
struct header_complex_index *pingResultsTableStorage = NULL;
struct header_complex_index *pingProbeHistoryTableStorage = NULL;

void
init_pingCtlTable(void)
{
    DEBUGMSGTL(("pingCtlTable", "initializing...  "));
    /*
     * register ourselves with the agent to handle our mib tree 
     */
    REGISTER_MIB("pingCtlTable", pingCtlTable_variables, variable2,
                 pingCtlTable_variables_oid);


    /*
     * register our config handler(s) to deal with registrations 
     */
    snmpd_register_config_handler("pingCtlTable", parse_pingCtlTable,
                                  NULL, NULL);

    /*
     * we need to be called back later to store our data 
     */
    snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
                           store_pingCtlTable, NULL);

    DEBUGMSGTL(("pingCtlTable", "done.\n"));
}

struct pingCtlTable_data *
create_pingCtlTable_data(void)
{
    struct pingCtlTable_data *StorageNew = NULL;
    StorageNew = SNMP_MALLOC_STRUCT(pingCtlTable_data);
    if (StorageNew == NULL) {
        exit(1);
    }
    StorageNew->pingCtlTargetAddressType = 1;
    StorageNew->pingCtlTargetAddress = strdup("");
    StorageNew->pingCtlTargetAddressLen = 0;
    StorageNew->pingCtlDataSize = 0;
    StorageNew->pingCtlTimeOut = 3;
    StorageNew->pingCtlProbeCount = 1;
    StorageNew->pingCtlAdminStatus = 2;
    StorageNew->pingCtlDataFill = (char *) malloc(strlen("00") + 1);
    if (StorageNew->pingCtlDataFill == NULL) {
        exit(1);
    }
    memcpy(StorageNew->pingCtlDataFill, "00", strlen("00") + 1);
    StorageNew->pingCtlDataFill[strlen("00")] = '\0';
    StorageNew->pingCtlDataFillLen = strlen(StorageNew->pingCtlDataFill);
    StorageNew->pingCtlFrequency = 0;
    StorageNew->pingCtlMaxRows = 50;
    StorageNew->pingCtlStorageType = 1;
    StorageNew->pingCtlTrapGeneration = strdup("");
    StorageNew->pingCtlTrapGenerationLen = 0;
    StorageNew->pingCtlTrapGenerationLen = 0;
    StorageNew->pingCtlTrapProbeFailureFilter = 1;
    StorageNew->pingCtlTrapTestFailureFilter = 1;
    StorageNew->pingCtlType = calloc(1, sizeof(oid) * sizeof(2));       /* 0.0 */
    StorageNew->pingCtlTypeLen = 2;
    StorageNew->pingCtlDescr = strdup("");
    StorageNew->pingCtlDescrLen = 0;
    StorageNew->pingCtlSourceAddressType = 1;
    StorageNew->pingCtlSourceAddress = strdup("");
    StorageNew->pingCtlSourceAddressLen = 0;
    StorageNew->pingCtlIfIndex = 0;
    StorageNew->pingCtlByPassRouteTable = 2;
    StorageNew->pingCtlDSField = 0;
    StorageNew->pingResults = NULL;
    StorageNew->pingProbeHis = NULL;

    StorageNew->storageType = ST_NONVOLATILE;
    StorageNew->pingProbeHistoryMaxIndex = 0;
    return StorageNew;
}

/*
 * pingCtlTable_add(): adds a structure node to our data set 
 */
int
pingCtlTable_add(struct pingCtlTable_data *thedata)
{
    netsnmp_variable_list *vars = NULL;


    DEBUGMSGTL(("pingCtlTable", "adding data...  "));
    /*
     * add the index variables to the varbind list, which is 
     * used by header_complex to index the data 
     */


    snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->pingCtlOwnerIndex, thedata->pingCtlOwnerIndexLen);       /* pingCtlOwnerIndex */
    snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->pingCtlTestName, thedata->pingCtlTestNameLen);   /* pingCtlOperationName */


    header_complex_add_data(&pingCtlTableStorage, vars, thedata);

    DEBUGMSGTL(("pingCtlTable", "registered an entry\n"));
    vars = NULL;
    DEBUGMSGTL(("pingCtlTable", "done.\n"));
    return SNMPERR_SUCCESS;
}

int
pingResultsTable_add(struct pingCtlTable_data *thedata)
{
    netsnmp_variable_list *vars_list = NULL;
    struct pingResultsTable_data *p = NULL;
    p = thedata->pingResults;
    if (thedata->pingResults != NULL) {

        snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) p->pingCtlOwnerIndex, p->pingCtlOwnerIndexLen);  /* pingCtlOwnerIndex */
        snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) p->pingCtlTestName, p->pingCtlTestNameLen);      /* pingCtlOperationName */

        /*
         * XXX: fill in default row values here into StorageNew 
         * 
         */


        DEBUGMSGTL(("pingResultsTable", "adding data...  "));
        /*
         * add the index variables to the varbind list, which is 
         * used by header_complex to index the data 
         */

        header_complex_add_data(&pingResultsTableStorage, vars_list, p);

        DEBUGMSGTL(("pingResultsTable", "out finished\n"));

    }

    DEBUGMSGTL(("pingResultsTable", "done.\n"));
    vars_list = NULL;
    return SNMPERR_SUCCESS;
}


int
pingProbeHistoryTable_add(struct pingProbeHistoryTable_data *thedata)
{
    netsnmp_variable_list *vars_list;
    vars_list = NULL;
    if (thedata != NULL) {
        snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) thedata->pingCtlOwnerIndex, thedata->pingCtlOwnerIndexLen);      /* pingCtlOwnerIndex */
        snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) thedata->pingCtlTestName, thedata->pingCtlTestNameLen);  /* pingCtlTestName */
        snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_UNSIGNED, (char *) &thedata->pingProbeHistoryIndex, sizeof(thedata->pingProbeHistoryIndex)); /* pingProbeHistoryIndex */

        /*
         * XXX: fill in default row values here into StorageNew 
         * 
         */


        DEBUGMSGTL(("pingProbeHistoryTable", "adding data...  "));
        /*
         * add the index variables to the varbind list, which is 
         * used by header_complex to index the data 
         */

        header_complex_add_data(&pingProbeHistoryTableStorage, vars_list,
                                thedata);
        DEBUGMSGTL(("pingProbeHistoryTable", "out finished\n"));
    }
    
    vars_list = NULL;
    DEBUGMSGTL(("pingProbeHistoryTable", "done.\n"));
    return SNMPERR_SUCCESS;
}

int
pingProbeHistoryTable_addall(struct pingCtlTable_data *thedata)
{
    netsnmp_variable_list *vars_list = NULL;
    struct pingProbeHistoryTable_data *p = NULL;
    p = thedata->pingProbeHis;
    if (thedata->pingProbeHis != NULL)
        do {
            snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) p->pingCtlOwnerIndex, p->pingCtlOwnerIndexLen);      /* pingCtlOwnerIndex */
            snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_OCTET_STR, (char *) p->pingCtlTestName, p->pingCtlTestNameLen);  /* pingCtlTestName */
            snmp_varlist_add_variable(&vars_list, NULL, 0, ASN_UNSIGNED, (char *) &p->pingProbeHistoryIndex, sizeof(p->pingProbeHistoryIndex)); /* pingProbeHistoryIndex */

            /*
             * XXX: fill in default row values here into StorageNew 
             * 
             */


            DEBUGMSGTL(("pingProbeHistoryTable", "adding data...  "));
            /*
             * add the index variables to the varbind list, which is 
             * used by header_complex to index the data 
             */

            header_complex_add_data(&pingProbeHistoryTableStorage,
                                    vars_list, p);


            DEBUGMSGTL(("pingProbeHistoryTable", "out finished\n"));
            vars_list = NULL;
            p = p->next;
        } while (p != NULL);

    DEBUGMSGTL(("pingProbeHistoryTable", "done.\n"));
    return SNMPERR_SUCCESS;
}

void
pingCtlTable_cleaner(struct header_complex_index *thestuff)
{
    struct header_complex_index *hciptr = NULL;
    struct pingCtlTable_data *StorageDel = NULL;
    DEBUGMSGTL(("pingProbeHistoryTable", "cleanerout  "));
    for (hciptr = thestuff; hciptr != NULL; hciptr = hciptr->next) {
        StorageDel =
            header_complex_extract_entry(&pingCtlTableStorage, hciptr);
        DEBUGMSGTL(("pingProbeHistoryTable", "cleaner  "));
    }
}

/*
 * parse_mteObjectsTable():
 *   parses .conf file entries needed to configure the mib.
 */
void
parse_pingCtlTable(const char *token, char *line)
{
    size_t          tmpint;
    struct pingCtlTable_data *StorageTmp =
        SNMP_MALLOC_STRUCT(pingCtlTable_data);

    DEBUGMSGTL(("pingCtlTable", "parsing config...  "));


    if (StorageTmp == NULL) {
        config_perror("malloc failure");
        return;
    }


    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->pingCtlOwnerIndex,
                              &StorageTmp->pingCtlOwnerIndexLen);
    if (StorageTmp->pingCtlOwnerIndex == NULL) {
        config_perror("invalid specification for pingCtlOwnerIndex");
        return;
    }

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->pingCtlTestName,
                              &StorageTmp->pingCtlTestNameLen);
    if (StorageTmp->pingCtlTestName == NULL) {
        config_perror("invalid specification for pingCtlTestName");
        return;
    }

    line =
        read_config_read_data(ASN_INTEGER, line,
                              &StorageTmp->pingCtlTargetAddressType,
                              &tmpint);

    line =
        read_config_read_data(ASN_OCTET_STR, line,
                              &StorageTmp->pingCtlTargetAddress,
                              &StorageTmp->pingCtlTargetAddressLen);
    if (StorageTmp->pingCtlTargetAddress == NULL) {
        config_perror("invalid specification for pingCtlTargetAddress");
        return;
    }

    line =