lookupctltable.c

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

        /*
         * Release any resources that have been allocated 
         */

        break;


    case ACTION:
        /*
         * The variable has been stored in long_ret 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->lookupCtlTargetAddress;
        tmplen = StorageTmp->lookupCtlTargetAddressLen;

        if ((StorageTmp->lookupCtlTargetAddress =
             (char *) malloc(var_val_len + 1)) == NULL) {
            exit(1);
        }
        memcpy(StorageTmp->lookupCtlTargetAddress, var_val, var_val_len);
        StorageTmp->lookupCtlTargetAddress[var_val_len] = '\0';
        StorageTmp->lookupCtlTargetAddressLen = var_val_len;

        break;


    case UNDO:
        /*
         * Back out any changes made in the ACTION case 
         */
        free(StorageTmp->lookupCtlTargetAddress);
        StorageTmp->lookupCtlTargetAddress = NULL;
        StorageTmp->lookupCtlTargetAddress = tmpvar;
        StorageTmp->lookupCtlTargetAddressLen = tmplen;

        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! 
         */

        free(tmpvar);
        tmpvar = NULL;

        break;
    }
    return SNMP_ERR_NOERROR;
}






int
write_lookupCtlRowStatus(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)
{
    struct lookupTable_data *StorageTmp = NULL;
    static struct lookupTable_data *StorageNew, *StorageDel = NULL;
    size_t          newlen =
        name_len - (sizeof(lookupCtlTable_variables_oid) / sizeof(oid) +
                    3 - 1);
    static int      old_value;
    int             set_value;
    static netsnmp_variable_list *vars, *vp;
    struct header_complex_index *hciptr = NULL;

    StorageTmp =
        header_complex(lookupCtlTableStorage, NULL,
                       &name[sizeof(lookupCtlTable_variables_oid) /
                             sizeof(oid) + 3 - 1], &newlen, 1, NULL, NULL);

    if (var_val_type != ASN_INTEGER || var_val == NULL) {
        snmp_log(LOG_ERR, "write to lookupCtlRowStatus not ASN_INTEGER\n");
        return SNMP_ERR_WRONGTYPE;
    }
    if (StorageTmp && StorageTmp->storagetype == ST_READONLY) {
        return SNMP_ERR_NOTWRITABLE;
    }

    set_value = *((long *) var_val);


    /*
     * check legal range, and notReady is reserved for us, not a user 
     */
    if (set_value < 1 || set_value > 6 || set_value == RS_NOTREADY)
        return SNMP_ERR_INCONSISTENTVALUE;


    switch (action) {
    case RESERVE1:
        /*
         * stage one: test validity 
         */
        if (StorageTmp == NULL) {
            /*
             * create the row now? 
             */


            /*
             * ditch illegal values now 
             */
            if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE) {

                return SNMP_ERR_INCONSISTENTVALUE;
            }

            /*
             * destroying a non-existent row is actually legal 
             */
            if (set_value == RS_DESTROY) {
                return SNMP_ERR_NOERROR;
            }


            /*
             * illegal creation values 
             */
            if (set_value == RS_ACTIVE || set_value == RS_NOTINSERVICE) {
                return SNMP_ERR_INCONSISTENTVALUE;
            }
        } else {
            /*
             * row exists.  Check for a valid state change 
             */
            if (set_value == RS_CREATEANDGO
                || set_value == RS_CREATEANDWAIT) {
                /*
                 * can't create a row that exists 
                 */
                return SNMP_ERR_INCONSISTENTVALUE;
            }

            /*
             * XXX: interaction with row storage type needed 
             */

            if (StorageTmp->lookupCtlRowStatus == RS_ACTIVE &&
                set_value != RS_DESTROY) {
                /*
                 * "Once made active an entry may not be modified except to 
                 * delete it."  XXX: doesn't this in fact apply to ALL
                 * columns of the table and not just this one?  
                 */
                return SNMP_ERR_INCONSISTENTVALUE;
            }
            if (StorageTmp->storagetype != ST_NONVOLATILE)
                return SNMP_ERR_NOTWRITABLE;
        }
        break;




    case RESERVE2:
        /*
         * memory reseveration, final preparation... 
         */
        if (StorageTmp == NULL) {
            /*
             * creation 
             */
            if (set_value == RS_DESTROY) {
                return SNMP_ERR_NOERROR;
            }
            vars = NULL;

            /*
             * 将name为空的三个索引字段加到var变量列表的末尾 
             */
            snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, NULL, 0);  /* lookupCtlOwnerIndex */
            snmp_varlist_add_variable(&vars, NULL, 0, ASN_OCTET_STR, NULL, 0);  /* lookupCtlOperationName */

            if (header_complex_parse_oid
                (&
                 (name
                  [sizeof(lookupCtlTable_variables_oid) / sizeof(oid) +
                   2]), newlen, vars) != SNMPERR_SUCCESS) {
                /*
                 * XXX: free, zero vars 
                 */
                snmp_free_varbind(vars);
                vars = NULL;
                return SNMP_ERR_INCONSISTENTNAME;
            }
            vp = vars;
            StorageNew = create_lookupTable_data();
            StorageNew->lookupCtlOwnerIndex = malloc(vp->val_len + 1);
            memcpy(StorageNew->lookupCtlOwnerIndex, vp->val.string,
                   vp->val_len);
            StorageNew->lookupCtlOwnerIndex[vp->val_len] = '\0';
            StorageNew->lookupCtlOwnerIndexLen = vp->val_len;
            vp = vp->next_variable;

            StorageNew->lookupCtlOperationName = malloc(vp->val_len + 1);
            memcpy(StorageNew->lookupCtlOperationName, vp->val.string,
                   vp->val_len);
            StorageNew->lookupCtlOperationName[vp->val_len] = '\0';
            StorageNew->lookupCtlOperationNameLen = vp->val_len;
            vp = vp->next_variable;

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

            StorageNew->lookupCtlTargetAddressType = 1; /* ipv4 */

            StorageNew->lookupCtlRowStatus = set_value;

            snmp_free_varbind(vars);
            vars = NULL;

            /*
             * XXX: free, zero vars, no longer needed? 
             */
        }


        break;




    case FREE:
        /*
         * XXX: free, zero vars 
         */
        /*
         * Release any resources that have been allocated 
         */
        break;




    case ACTION:
        /*
         * The variable has been stored in set_value 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 
         */


        if (StorageTmp == NULL) {
            /*
             * row creation, so add it 
             */
            if (set_value == RS_DESTROY) {
                return SNMP_ERR_NOERROR;
            }
            if (StorageNew != NULL)
#if 1
                DEBUGMSGTL(("lookupCtlTable",
                            "write_lookupCtlRowStatus entering new=%d...  \n",
                            action));
#endif
            lookupCtlTable_add(StorageNew);
            /*
             * XXX: ack, and if it is NULL? 
             */
        } else if (set_value != RS_DESTROY) {
            /*
             * set the flag? 
             */
            old_value = StorageTmp->lookupCtlRowStatus;
            StorageTmp->lookupCtlRowStatus = *((long *) var_val);
        } else {
            /*
             * destroy...  extract it for now 
             */
            DEBUGMSGTL(("lookupCtlTable",
                        "write_lookupCtlTable_delete 1 \n"));
            hciptr =
                header_complex_find_entry(lookupCtlTableStorage,
                                          StorageTmp);

            StorageDel =
                header_complex_extract_entry(&lookupCtlTableStorage,
                                             hciptr);
            lookupResultsTable_del(StorageTmp);

            DEBUGMSGTL(("lookupCtlTable",
                        "write_lookupCtlTable_delete  \n"));

        }
        break;




    case UNDO:
        /*
         * Back out any changes made in the ACTION case 
         */
        if (StorageTmp == NULL) {
            /*
             * row creation, so remove it again 
             */
            hciptr =
                header_complex_find_entry(lookupCtlTableStorage,
                                          StorageTmp);
            StorageDel =
                header_complex_extract_entry(&lookupCtlTableStorage,
                                             hciptr);

            lookupResultsTable_del(StorageTmp);

            /*
             * XXX: free it 
             */
        } else if (StorageDel != NULL) {
            /*
             * row deletion, so add it again 
             */
            lookupCtlTable_add(StorageDel);
            lookupResultsTable_add(StorageDel);
        } else {
            StorageTmp->lookupCtlRowStatus = old_value;
        }
        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! 
         */
        if (StorageTmp == NULL) {
            if (set_value == RS_DESTROY) {
                return SNMP_ERR_NOERROR;
            }
        }

        if (StorageDel != NULL) {
            SNMP_FREE(StorageDel->lookupCtlOwnerIndex);
            StorageDel->lookupCtlOwnerIndex = NULL;
            SNMP_FREE(StorageDel->lookupCtlOperationName);
            StorageDel->lookupCtlOperationName = NULL;
            SNMP_FREE(StorageDel->lookupCtlTargetAddress);
            StorageDel->lookupCtlTargetAddress = NULL;
            SNMP_FREE(StorageDel);
            StorageDel = NULL;

            StorageDel = 0;
            /*
             * XXX: free it, its dead 
             */
        } else {
            if (StorageTmp
                && StorageTmp->lookupCtlRowStatus == RS_CREATEANDGO) {
                StorageTmp->lookupCtlRowStatus = RS_ACTIVE;
            } else if (StorageTmp &&
                       StorageTmp->lookupCtlRowStatus ==
                       RS_CREATEANDWAIT) {

                StorageTmp->lookupCtlRowStatus = RS_NOTINSERVICE;
            }
        }
        if (StorageTmp && StorageTmp->lookupCtlRowStatus == RS_ACTIVE) {
#if 1
            DEBUGMSGTL(("lookupCtlTable",
                        "write_lookupCtlRowStatus entering runbefore=%ld...  \n",
                        StorageTmp->lookupCtlTargetAddressType));

#endif
            modify_lookupCtlOperStatus(StorageTmp, 2l);
            run_lookup((struct lookupTable_data *) StorageTmp);

        }

        break;
    }
    return SNMP_ERR_NOERROR;
}