lookupctltable.c

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

        else
            DEBUGMSGTL(("lookupCtlTable", "error! \n"));


        gettimeofday(&tpstart, NULL);
        lookup = gethostbyaddr((char *) &addr_in6, 16, AF_INET6);
        gettimeofday(&tpend, NULL);
        timeuse = 1000000 * (tpend.tv_sec - tpstart.tv_sec) +
            tpend.tv_usec - tpstart.tv_usec;
        timeuse /= 1000;
        modify_lookupCtlTime(item, timeuse);
        modify_lookupCtlOperStatus(item, 3l);

        if (lookup == NULL) {
            DEBUGMSGTL(("lookupCtlTable",
                        "Can't get a network host entry for %s\n",
                        address));
            modify_lookupCtlRc(item, 1l);
            return;
        } else {
            modify_lookupCtlRc(item, 0l);
            if (lookup->h_name != NULL) {
                current = temp =
                    SNMP_MALLOC_STRUCT(lookupResultsTable_data);
                if (temp == NULL) {
                    exit(1);
                }
                temp->lookupResultsIndex = n;

                temp->lookupCtlOwnerIndex =
                    (char *) malloc(item->lookupCtlOwnerIndexLen + 1);
                if (temp->lookupCtlOwnerIndex == NULL) {
                    exit(1);
                }
                memcpy(temp->lookupCtlOwnerIndex,
                       item->lookupCtlOwnerIndex,
                       item->lookupCtlOwnerIndexLen + 1);
                temp->lookupCtlOwnerIndex[item->lookupCtlOwnerIndexLen] =
                    '\0';
                temp->lookupCtlOwnerIndexLen =
                    item->lookupCtlOwnerIndexLen;

                temp->lookupCtlOperationName =
                    (char *) malloc(item->lookupCtlOperationNameLen + 1);
                if (temp->lookupCtlOperationName == NULL) {
                    exit(1);
                }
                memcpy(temp->lookupCtlOperationName,
                       item->lookupCtlOperationName,
                       item->lookupCtlOperationNameLen + 1);
                temp->lookupCtlOperationName[item->
                                             lookupCtlOperationNameLen] =
                    '\0';
                temp->lookupCtlOperationNameLen =
                    item->lookupCtlOperationNameLen;

                temp->lookupResultsAddressType = 16;
                temp->lookupResultsAddress =
                    (char *) malloc(strlen(lookup->h_name) + 1);
                memcpy(temp->lookupResultsAddress, lookup->h_name,
                       strlen(lookup->h_name) + 1);
                temp->lookupResultsAddress[strlen(lookup->h_name)] = '\0';
                temp->lookupResultsAddressLen = strlen(lookup->h_name);
                item->ResultsTable = temp;
                n = n + 1;

            }

            i = 0;
            while (lookup->h_aliases[i]) {
                temp = SNMP_MALLOC_STRUCT(lookupResultsTable_data);
                if (temp == NULL) {
                    exit(1);
                }
                temp->lookupCtlOwnerIndex =
                    (char *) malloc(item->lookupCtlOwnerIndexLen + 1);
                if (temp->lookupCtlOwnerIndex == NULL) {
                    exit(1);
                }
                memcpy(temp->lookupCtlOwnerIndex,
                       item->lookupCtlOwnerIndex,
                       item->lookupCtlOwnerIndexLen + 1);
                temp->lookupCtlOwnerIndex[item->lookupCtlOwnerIndexLen] =
                    '\0';
                temp->lookupCtlOwnerIndexLen =
                    item->lookupCtlOwnerIndexLen;

                temp->lookupCtlOperationName =
                    (char *) malloc(item->lookupCtlOperationNameLen + 1);
                if (temp->lookupCtlOperationName == NULL) {
                    exit(1);
                }
                memcpy(temp->lookupCtlOperationName,
                       item->lookupCtlOperationName,
                       item->lookupCtlOperationNameLen + 1);
                temp->lookupCtlOperationName[item->
                                             lookupCtlOperationNameLen] =
                    '\0';
                temp->lookupCtlOperationNameLen =
                    item->lookupCtlOperationNameLen;

                temp->lookupResultsIndex = n;
                temp->lookupResultsAddressType = 16;
                temp->lookupResultsAddress =
                    (char *) malloc(strlen(lookup->h_aliases[i]) + 1);
                if (temp->lookupResultsAddress == NULL) {
                    exit(1);
                }
                memcpy(temp->lookupResultsAddress, lookup->h_aliases[i],
                       strlen(lookup->h_aliases[i]) + 1);
                temp->lookupResultsAddress[strlen(lookup->h_aliases[i])] =
                    '\0';
                temp->lookupResultsAddressLen =
                    strlen(lookup->h_aliases[i]);
                current->next = temp;
                current = temp;
                i = i + 1;
                n = n + 1;

            }

            if (item->ResultsTable != NULL)
                current->next = NULL;
            else
                current = NULL;

        }


        if (item->ResultsTable != NULL)
            if (lookupResultsTable_add(item) != SNMPERR_SUCCESS)
                DEBUGMSGTL(("lookupResultsTable",
                            "registered an entry error\n"));
        SNMP_FREE(address);
        address = NULL;
        return;
    } else {
        SNMP_FREE(address);
        address = NULL;
        return;
    }
}


int
modify_lookupCtlOperStatus(struct lookupTable_data *thedata, long val)
{
    netsnmp_variable_list *vars = NULL;
    struct lookupTable_data *StorageTmp = NULL;

    snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->lookupCtlOwnerIndex, thedata->lookupCtlOwnerIndexLen);   /* lookupCtlOwnerIndex */
    snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->lookupCtlOperationName, thedata->lookupCtlOperationNameLen);     /* lookupCtlOperationName */


    if ((StorageTmp =
         header_complex_get(lookupCtlTableStorage, vars)) == NULL) {
        snmp_free_varbind(vars);
        vars = NULL;
        return SNMP_ERR_NOSUCHNAME;
    }
    StorageTmp->lookupCtlOperStatus = val;

    snmp_free_varbind(vars);
    vars = NULL;

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

int
modify_lookupCtlTime(struct lookupTable_data *thedata, unsigned long val)
{
    netsnmp_variable_list *vars = NULL;
    struct lookupTable_data *StorageTmp = NULL;

    snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->lookupCtlOwnerIndex, thedata->lookupCtlOwnerIndexLen);   /* lookupCtlOwnerIndex */
    snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->lookupCtlOperationName, thedata->lookupCtlOperationNameLen);     /* lookupCtlOperationName */


    if ((StorageTmp =
         header_complex_get(lookupCtlTableStorage, vars)) == NULL) {
        snmp_free_varbind(vars);
        vars = NULL;
        return SNMP_ERR_NOSUCHNAME;
    }
    StorageTmp->lookupCtlTime = val;

    snmp_free_varbind(vars);
    vars = NULL;

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

int
modify_lookupCtlRc(struct lookupTable_data *thedata, long val)
{
    netsnmp_variable_list *vars = NULL;
    struct lookupTable_data *StorageTmp = NULL;

    snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->lookupCtlOwnerIndex, thedata->lookupCtlOwnerIndexLen);   /* lookupCtlOwnerIndex */
    snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->lookupCtlOperationName, thedata->lookupCtlOperationNameLen);     /* lookupCtlOperationName */


    if ((StorageTmp =
         header_complex_get(lookupCtlTableStorage, vars)) == NULL) {
        snmp_free_varbind(vars);
        vars = NULL;
        return SNMP_ERR_NOSUCHNAME;
    }
    StorageTmp->lookupCtlRc = val;

    snmp_free_varbind(vars);
    vars = NULL;
    DEBUGMSGTL(("lookupOperStatus", "done.\n"));
    return SNMPERR_SUCCESS;
}


int
lookupResultsTable_del(struct lookupTable_data *thedata)
{
    struct header_complex_index *hciptr2 = NULL;
    struct lookupResultsTable_data *StorageDel = NULL;
    netsnmp_variable_list *vars = NULL;
    oid             newoid[MAX_OID_LEN];
    size_t          newoid_len;

    snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->lookupCtlOwnerIndex, thedata->lookupCtlOwnerIndexLen);   /* lookupCtlOwnerIndex */
    snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, (char *) thedata->lookupCtlOperationName, thedata->lookupCtlOperationNameLen);     /* lookupCtlOperationName */
    bzero(newoid, MAX_OID_LEN * sizeof(oid));
    header_complex_generate_oid(newoid, &newoid_len, NULL, 0, vars);


    snmp_free_varbind(vars);
    vars = NULL;
    for (hciptr2 = lookupResultsTableStorage; hciptr2 != NULL;
         hciptr2 = hciptr2->next) {
        if (snmp_oid_compare(newoid, newoid_len, hciptr2->name, newoid_len)
            == 0) {
            StorageDel =
                header_complex_extract_entry(&lookupResultsTableStorage,
                                             hciptr2);
            if (StorageDel != NULL) {
                SNMP_FREE(StorageDel->lookupCtlOwnerIndex);
                SNMP_FREE(StorageDel->lookupCtlOperationName);
                SNMP_FREE(StorageDel->lookupResultsAddress);
                SNMP_FREE(StorageDel);
            }
            DEBUGMSGTL(("lookupResultsTable", "delete  success!\n"));

        }
    }
    return SNMPERR_SUCCESS;
}


int
write_lookupCtlTargetAddressType(int action,
                                 u_char * var_val,
                                 u_char var_val_type,
                                 size_t var_val_len,
                                 u_char * statP, oid * name,
                                 size_t name_len)
{
    static size_t   tmpvar;
    struct lookupTable_data *StorageTmp = NULL;
    static size_t   tmplen;
    size_t          newlen =
        name_len - (sizeof(lookupCtlTable_variables_oid) / sizeof(oid) +
                    3 - 1);

    if ((StorageTmp =
         header_complex(lookupCtlTableStorage, NULL,
                        &name[sizeof(lookupCtlTable_variables_oid) /
                              sizeof(oid) + 3 - 1], &newlen, 1, NULL,
                        NULL)) == NULL)
        return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */

    if (StorageTmp && StorageTmp->storagetype == ST_READONLY) {
        return SNMP_ERR_NOTWRITABLE;
    }

    if (StorageTmp && StorageTmp->lookupCtlRowStatus == RS_ACTIVE) {
        return SNMP_ERR_NOTWRITABLE;
    }
    switch (action) {
    case RESERVE1:
        if (var_val_type != ASN_INTEGER) {
            snmp_log(LOG_ERR,
                     "write to lookupCtlTargetAddressType not ASN_INTEGER\n");
            return SNMP_ERR_WRONGTYPE;
        }
        break;


    case RESERVE2:
        /*
         * memory reseveration, final preparation... 
         */
        break;


    case FREE:
        /*
         * Release any resources that have been allocated 
         */
        break;


    case ACTION:
        /*
         * The variable has been stored in objid for
         * you to use, and you have just been asked to do something with
         * it.  Note that anything done here must be reversable in the UNDO case 
         */
        tmpvar = StorageTmp->lookupCtlTargetAddressType;
        StorageTmp->lookupCtlTargetAddressType = *((long *) var_val);
        break;


    case UNDO:
        /*
         * Back out any changes made in the ACTION case 
         */
        StorageTmp->lookupCtlTargetAddressType = tmpvar;
        break;


    case COMMIT:
        /*
         * Things are working well, so it's now safe to make the change
         * permanently.  Make sure that anything done here can't fail! 
         */
        break;
    }
    return SNMP_ERR_NOERROR;
}



int
write_lookupCtlTargetAddress(int action,
                             u_char * var_val,
                             u_char var_val_type,
                             size_t var_val_len,
                             u_char * statP, oid * name, size_t name_len)
{
    static char    *tmpvar = NULL;
    static size_t   tmplen;
    struct lookupTable_data *StorageTmp = NULL;
    size_t          newlen =
        name_len - (sizeof(lookupCtlTable_variables_oid) / sizeof(oid) +
                    3 - 1);
    if ((StorageTmp =
         header_complex(lookupCtlTableStorage, NULL,
                        &name[sizeof(lookupCtlTable_variables_oid) /
                              sizeof(oid) + 3 - 1], &newlen, 1, NULL,
                        NULL)) == NULL)
        return SNMP_ERR_NOSUCHNAME;     /* remove if you support creation here */

    if (StorageTmp && StorageTmp->storagetype == ST_READONLY) {
        return SNMP_ERR_NOTWRITABLE;
    }

    if (StorageTmp && StorageTmp->lookupCtlRowStatus == RS_ACTIVE) {
        return SNMP_ERR_NOTWRITABLE;
    }

    switch (action) {
    case RESERVE1:
        if (var_val_type != ASN_OCTET_STR) {
            snmp_log(LOG_ERR,
                     "write to lookupCtlTargetAddress not ASN_OCTET_STR\n");
            return SNMP_ERR_WRONGTYPE;
        }

        break;


    case RESERVE2:
        /*
         * memory reseveration, final preparation... 
         */

        break;


    case FREE: