pingctltable.c

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

        read_config_read_data(ASN_UNSIGNED, line,
                              &StorageTmp->pingCtlDataSize, &tmpint);

    line =
        read_config_read_data(ASN_UNSIGNED, line,
                              &StorageTmp->pingCtlTimeOut, &tmpint);

    line =
        read_config_read_data(ASN_UNSIGNED, line,
                              &StorageTmp->pingCtlProbeCount, &tmpint);

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

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

    line =
        read_config_read_data(ASN_UNSIGNED, line,
                              &StorageTmp->pingCtlFrequency, &tmpint);

    line =
        read_config_read_data(ASN_UNSIGNED, line,
                              &StorageTmp->pingCtlMaxRows, &tmpint);

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

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

    line =
        read_config_read_data(ASN_UNSIGNED, line,
                              &StorageTmp->pingCtlTrapProbeFailureFilter,
                              &tmpint);

    line =
        read_config_read_data(ASN_UNSIGNED, line,
                              &StorageTmp->pingCtlTrapTestFailureFilter,
                              &tmpint);

    line =
        read_config_read_data(ASN_OBJECT_ID, line,
                              &StorageTmp->pingCtlType,
                              &StorageTmp->pingCtlTypeLen);
    if (StorageTmp->pingCtlType == NULL) {
        config_perror("invalid specification for pingCtlType");
        return;
    }

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

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

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

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

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

    line =
        read_config_read_data(ASN_UNSIGNED, line,
                              &StorageTmp->pingCtlDSField, &tmpint);

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

    line =
        read_config_read_data(ASN_UNSIGNED, line,
                              &StorageTmp->pingProbeHistoryMaxIndex,
                              &tmpint);

    StorageTmp->storageType = ST_NONVOLATILE;
    pingCtlTable_add(StorageTmp);
    /* pingCtlTable_cleaner(pingCtlTableStorage); */

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



/*
 * store_pingCtlTable():
 *   stores .conf file entries needed to configure the mib.
 */
int
store_pingCtlTable(int majorID, int minorID, void *serverarg,
                   void *clientarg)
{
    char            line[SNMP_MAXBUF];
    char           *cptr = NULL;
    size_t          tmpint;
    struct pingCtlTable_data *StorageTmp = NULL;
    struct header_complex_index *hcindex = NULL;


    DEBUGMSGTL(("pingCtlTable", "storing data...  "));


    for (hcindex = pingCtlTableStorage; hcindex != NULL;
         hcindex = hcindex->next) {
        StorageTmp = (struct pingCtlTable_data *) hcindex->data;

        if (StorageTmp->storageType != ST_READONLY) {
            memset(line, 0, sizeof(line));
            strcat(line, "pingCtlTable ");
            cptr = line + strlen(line);


            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->pingCtlOwnerIndex,
                                       &StorageTmp->pingCtlOwnerIndexLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->pingCtlTestName,
                                       &StorageTmp->pingCtlTestNameLen);
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->
                                       pingCtlTargetAddressType, &tmpint);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->pingCtlTargetAddress,
                                       &StorageTmp->
                                       pingCtlTargetAddressLen);
            cptr =
                read_config_store_data(ASN_UNSIGNED, cptr,
                                       &StorageTmp->pingCtlDataSize,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_UNSIGNED, cptr,
                                       &StorageTmp->pingCtlTimeOut,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_UNSIGNED, cptr,
                                       &StorageTmp->pingCtlProbeCount,
                                       &tmpint);

            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->pingCtlAdminStatus,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->pingCtlDataFill,
                                       &StorageTmp->pingCtlDataFillLen);

            cptr =
                read_config_store_data(ASN_UNSIGNED, cptr,
                                       &StorageTmp->pingCtlFrequency,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_UNSIGNED, cptr,
                                       &StorageTmp->pingCtlMaxRows,
                                       &tmpint);

            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->pingCtlStorageType,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->pingCtlTrapGeneration,
                                       &StorageTmp->
                                       pingCtlTrapGenerationLen);
            cptr =
                read_config_store_data(ASN_UNSIGNED, cptr,
                                       &StorageTmp->
                                       pingCtlTrapProbeFailureFilter,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_UNSIGNED, cptr,
                                       &StorageTmp->
                                       pingCtlTrapTestFailureFilter,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_OBJECT_ID, cptr,
                                       &StorageTmp->pingCtlType,
                                       &StorageTmp->pingCtlTypeLen);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->pingCtlDescr,
                                       &StorageTmp->pingCtlDescrLen);
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->
                                       pingCtlSourceAddressType, &tmpint);
            cptr =
                read_config_store_data(ASN_OCTET_STR, cptr,
                                       &StorageTmp->pingCtlSourceAddress,
                                       &StorageTmp->
                                       pingCtlSourceAddressLen);
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->pingCtlIfIndex,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->
                                       pingCtlByPassRouteTable, &tmpint);
            cptr =
                read_config_store_data(ASN_UNSIGNED, cptr,
                                       &StorageTmp->pingCtlDSField,
                                       &tmpint);

            if (StorageTmp->pingCtlRowStatus == RS_ACTIVE)
                StorageTmp->pingCtlRowStatus = RS_NOTINSERVICE;

            cptr =
                read_config_store_data(ASN_INTEGER, cptr,
                                       &StorageTmp->pingCtlRowStatus,
                                       &tmpint);
            cptr =
                read_config_store_data(ASN_UNSIGNED, cptr,
                                       &StorageTmp->
                                       pingProbeHistoryMaxIndex, &tmpint);



            snmpd_store_config(line);
        }
    }
    DEBUGMSGTL(("pingCtlTable", "done.\n"));
    return SNMPERR_SUCCESS;
}




/*
 * var_pingCtlTable():
 *   Handle this table separately from the scalar value case.
 *   The workings of this are basically the same as for var_mteObjectsTable above.
 */
unsigned char  *
var_pingCtlTable(struct variable *vp,
                 oid * name,
                 size_t *length,
                 int exact, size_t *var_len, WriteMethod ** write_method)
{


    struct pingCtlTable_data *StorageTmp = NULL;

    /*
     * this assumes you have registered all your data properly
     */
    if ((StorageTmp =
         header_complex(pingCtlTableStorage, vp, name, length, exact,
                        var_len, write_method)) == NULL) {
        if (vp->magic == COLUMN_PINGCTLROWSTATUS)
            *write_method = write_pingCtlRowStatus;
        return NULL;
    }

    /*
     * this is where we do the value assignments for the mib results.
     */
    switch (vp->magic) {


    case COLUMN_PINGCTLTARGETADDRESSTYPE:
        *write_method = write_pingCtlTargetAddressType;
        *var_len = sizeof(StorageTmp->pingCtlTargetAddressType);
        return (u_char *) & StorageTmp->pingCtlTargetAddressType;

    case COLUMN_PINGCTLTARGETADDRESS:
        *write_method = write_pingCtlTargetAddress;
        *var_len = (StorageTmp->pingCtlTargetAddressLen);

        return (u_char *) StorageTmp->pingCtlTargetAddress;

    case COLUMN_PINGCTLDATASIZE:
        *write_method = write_pingCtlDataSize;
        *var_len = sizeof(StorageTmp->pingCtlDataSize);

        return (u_char *) & StorageTmp->pingCtlDataSize;

    case COLUMN_PINGCTLTIMEOUT:
        *write_method = write_pingCtlTimeOut;
        *var_len = sizeof(StorageTmp->pingCtlTimeOut);

        return (u_char *) & StorageTmp->pingCtlTimeOut;

    case COLUMN_PINGCTLPROBECOUNT:
        *write_method = write_pingCtlProbeCount;
        *var_len = sizeof(StorageTmp->pingCtlProbeCount);

        return (u_char *) & StorageTmp->pingCtlProbeCount;

    case COLUMN_PINGCTLADMINSTATUS:
        *write_method = write_pingCtlAdminStatus;
        *var_len = sizeof(StorageTmp->pingCtlAdminStatus);

        return (u_char *) & StorageTmp->pingCtlAdminStatus;

    case COLUMN_PINGCTLDATAFILL:
        *write_method = write_pingCtlDataFill;
        *var_len = (StorageTmp->pingCtlDataFillLen);

        return (u_char *) StorageTmp->pingCtlDataFill;

    case COLUMN_PINGCTLFREQUENCY:
        *write_method = write_pingCtlFrequency;
        *var_len = sizeof(StorageTmp->pingCtlFrequency);

        return (u_char *) & StorageTmp->pingCtlFrequency;

    case COLUMN_PINGCTLMAXROWS:
        *write_method = write_pingCtlMaxRows;
        *var_len = sizeof(StorageTmp->pingCtlMaxRows);

        return (u_char *) & StorageTmp->pingCtlMaxRows;

    case COLUMN_PINGCTLSTORAGETYPE:
        *write_method = write_pingCtlStorageType;
        *var_len = sizeof(StorageTmp->pingCtlStorageType);

        return (u_char *) & StorageTmp->pingCtlStorageType;

    case COLUMN_PINGCTLTRAPGENERATION:
        *write_method = write_pingCtlTrapGeneration;
        *var_len = (StorageTmp->pingCtlTrapGenerationLen);

        return (u_char *) StorageTmp->pingCtlTrapGeneration;

    case COLUMN_PINGCTLTRAPPROBEFAILUREFILTER:
        *write_method = write_pingCtlTrapProbeFailureFilter;
        *var_len = sizeof(StorageTmp->pingCtlTrapProbeFailureFilter);

        return (u_char *) & StorageTmp->pingCtlTrapProbeFailureFilter;

    case COLUMN_PINGCTLTRAPTESTFAILUREFILTER:
        *write_method = write_pingCtlTrapTestFailureFilter;
        *var_len = sizeof(StorageTmp->pingCtlTrapTestFailureFilter);

        return (u_char *) & StorageTmp->pingCtlTrapTestFailureFilter;