/*
 * Note: this file originally auto-generated by mib2c using
 *  : mib2c.table_data.conf 16004 2007-03-27 09:20:28Z dts12 $
 */

#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include <net-snmp/library/tools.h>
#include <net-snmp/agent/cache_handler.h>
#include <net-snmp/agent/table_tdata.h>
#include "lldpPortConfigTable.h"

static oid      lldpPortConfigTable_oid[] =
        { 1, 0, 8802, 1, 1, 2, 1, 1, 6 };
size_t          lldpPortConfigTable_oid_len =
        OID_LENGTH(lldpPortConfigTable_oid);

netsnmp_tdata_row * lldpPortConfigTable_createEntry(netsnmp_tdata * table_data,
                                long lldpPortConfigPortNum);

static char bits[] = {0x80, 0x40, 0x20, 0x10};
static char nullset = 0x00;

static port_tab_entry_t *tempNode;

int checkNumericRange(int min, int max, int newValue)
{
   if (newValue >= min &&
       newValue <= max)
       return(SNMP_ERR_NOERROR);
   else
      return(SNMP_ERR_WRONGVALUE);
}

int checkBoolean(int newValue)
{
   if (newValue == TRUE ||
       newValue == FALSE)
       return(SNMP_ERR_NOERROR);
   else
      return(SNMP_ERR_WRONGVALUE);
}

int checkTlvsBITS(int newVal)
{
    if (newVal == nullset ||
        newVal == bits[0] ||
        newVal == bits[1] ||
        newVal == bits[2] ||
        newVal == bits[3])
        return(SNMP_ERR_NOERROR);
    else
      return(SNMP_ERR_WRONGVALUE);	
} 

   /*
     * Typical data structure for a row entry 
     */
struct lldpPortConfigTable_entry {
    /*
     * Index values 
     */
    long            lldpPortConfigPortNum;

    /*
     * Column values 
     */
    long            lldpPortConfigAdminStatus;
    long            old_lldpPortConfigAdminStatus;
    long            lldpPortConfigNotificationEnable;
    long            old_lldpPortConfigNotificationEnable;
    char            lldpPortConfigTLVsTxEnable[1];
    size_t          lldpPortConfigTLVsTxEnable_len;
    char            old_lldpPortConfigTLVsTxEnable[1];
    size_t          old_lldpPortConfigTLVsTxEnable_len;

    int             valid;
};

/** Initializes the lldpPortConfigTable module */
void
init_lldpPortConfigTable(void)
{
    /*
     * here we initialize all the tables we're planning on supporting 
     */
    initialize_table_lldpPortConfigTable();
}

/*# Determine the first/last column names */

/** Initialize the lldpPortConfigTable table by defining its contents and how it's structured */
void
initialize_table_lldpPortConfigTable(void)
{
    static oid      lldpPortConfigTable_oid[] =
        { 1, 0, 8802, 1, 1, 2, 1, 1, 6 };
    size_t          lldpPortConfigTable_oid_len =
        OID_LENGTH(lldpPortConfigTable_oid);
    netsnmp_handler_registration *reg;
    netsnmp_tdata  *table_data;
    netsnmp_table_registration_info *table_info;
    netsnmp_cache  *cache;
    netsnmp_tdata_row *row; 
    short int i = 0;
    struct lldpPortConfigTable_entry * ent;
     
    //entry = SNMP_MALLOC_TYPEDEF(struct lldpPortConfigTable_entry);
    
    //if(!entry)
      //return 0;

 //   row = netsnmp_tdata_create_row();
    //if(!row) {
      //  SNMP_FREE(entry);
       // return 0;
//    }
//    row->data = entry;  
    DEBUGMSGTL(("lldpPortConfigTable", "initing table1\n"));
    if (alreadyReg > 0)
      return;

    DEBUGMSGTL(("lldpPortConfigTable", "initing table\n"));	


    reg =
        netsnmp_create_handler_registration("lldpPortConfigTable",
                                            lldpPortConfigTable_handler,
                                            lldpPortConfigTable_oid,
                                            lldpPortConfigTable_oid_len,
                                            HANDLER_CAN_RWRITE);

    table_data = netsnmp_tdata_create_table("lldpPortConfigTable", 0);
    table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
    netsnmp_table_helper_add_indexes(table_info, ASN_INTEGER,   /* index: lldpPortConfigPortNum */
                                     0);

    table_info->min_column = COLUMN_LLDPPORTCONFIGADMINSTATUS;
    table_info->max_column = COLUMN_LLDPPORTCONFIGTLVSTXENABLE;

    netsnmp_tdata_register(reg, table_data, table_info);
    cache = netsnmp_cache_create(LLDPPORTCONFIGTABLE_TIMEOUT,
                                 lldpPortConfigTable_load,
                                 lldpPortConfigTable_free,
                                 lldpPortConfigTable_oid,
                                 lldpPortConfigTable_oid_len);
    cache->magic = (void *) table_data;
    netsnmp_inject_handler_before(reg, netsnmp_cache_handler_get(cache), TABLE_TDATA_NAME);

        /*
         * Initialise the contents of the table here 
         */
    DEBUGMSGTL(("lldpPortConfigTable", "for loop\n"));

    tempNode = SNMP_MALLOC_TYPEDEF(port_tab_entry_t);
    for(i=0; i<4; i++)
    {
DEBUGMSGTL(("lldpPortConfigTable", "for loop%d\n", i));
       
       tempNode->port_tab_portnum = i+1;  
       tempNode->port_tab_status  = (i+1) % 5; /* 1 thru 4 */
       tempNode->port_tab_notify = i % 2;     /* true or false */
       tempNode->port_tab_tlvs     = bits[i];   /* 0 - 3 */
       row = lldpPortConfigTable_createEntry(table_data, tempNode->port_tab_portnum);

       ent = (struct lldpPortConfigTable_entry*) (row->data);
       ent->lldpPortConfigAdminStatus = tempNode->port_tab_status;
       ent->old_lldpPortConfigAdminStatus = 0;
       ent->lldpPortConfigNotificationEnable = tempNode->port_tab_notify;
       ent->old_lldpPortConfigAdminStatus = 0;
       ent->lldpPortConfigTLVsTxEnable[0] = tempNode->port_tab_tlvs;
       ent->lldpPortConfigTLVsTxEnable_len = 1;
       ent->old_lldpPortConfigTLVsTxEnable[0] = 0;
       ent->old_lldpPortConfigTLVsTxEnable_len = 1;
    }
    SNMP_FREE(tempNode);
    tempNode = NULL;
}

void  deinit_lldpPortConfigTable(void) {
     DEBUGMSGTL(("lldpPortConfigTable", "deiniting1 mibs\n"));
     if (alreadyDereg > 0)
	return;	
     DEBUGMSGTL(("lldpPortConfigTable", "deiniting mibs\n")); 	
     /* int unregister_mib(oid *, size_t); */
     unregister_mib(lldpPortConfigTable_oid, lldpPortConfigTable_oid_len); 
     alreadyDereg = 1;	
}

 

/*
 * create a new row in the table 
 */
netsnmp_tdata_row *lldpPortConfigTable_createEntry(netsnmp_tdata *
                                                   table_data,
                                                   long
                                                   lldpPortConfigPortNum) {
    struct lldpPortConfigTable_entry *entry;
    netsnmp_tdata_row *row;        
         
    entry = SNMP_MALLOC_TYPEDEF(struct lldpPortConfigTable_entry);
    if(!entry)
      return NULL;

    row = netsnmp_tdata_create_row();
    if(!row) {
        SNMP_FREE(entry);
        return NULL;
    }
    row->data = entry;
    entry->lldpPortConfigPortNum = lldpPortConfigPortNum;
// test ascending but not consecutive indexes 
//    entry->lldpPortConfigPortNum = 2*lldpPortConfigPortNum; 
// test unordered index
//    entry->lldpPortConfigPortNum = 60 - (8*lldpPortConfigPortNum);
    netsnmp_tdata_row_add_index(row, ASN_INTEGER,
                                &(entry->lldpPortConfigPortNum),
                                sizeof(entry->lldpPortConfigPortNum));
    /*****************************/
/*    entry->lldpPortConfigAdminStatus = tempNode->port_tab_status;
    entry->old_lldpPortConfigAdminStatus = 0;
    entry->lldpPortConfigNotificationEnable = tempNode->port_tab_notify;
    entry->old_lldpPortConfigAdminStatus = 0;
    entry->lldpPortConfigTLVsTxEnable[0] = tempNode->port_tab_tlvs;
    entry->lldpPortConfigTLVsTxEnable_len = 1;
    entry->old_lldpPortConfigTLVsTxEnable[0] = 0;
    entry->old_lldpPortConfigTLVsTxEnable_len = 1; */
/*****************************/
    netsnmp_tdata_add_row(table_data, row);
    return row;
}

/*
 * remove a row from the table 
 */
void    
    lldpPortConfigTable_removeEntry(netsnmp_tdata * table_data,
                                    netsnmp_tdata_row * row) {
    struct lldpPortConfigTable_entry *entry;

    if (!row)
        return;                 /* Nothing to remove */
    entry = (struct lldpPortConfigTable_entry *)
        netsnmp_tdata_remove_and_delete_row(table_data, row);
    if (entry)
        SNMP_FREE(entry);       /* XXX - release any other internal resources */
}

/*
 * Example cache handling - set up table_data list from a suitable file 
 */
int
    lldpPortConfigTable_load(netsnmp_cache * cache, void *vmagic) {
    netsnmp_tdata * table = (netsnmp_tdata *) vmagic;
    netsnmp_tdata_row *row;

    short int i;  
    struct lldpPortConfigTable_entry * ent;
     
/*    entry = SNMP_MALLOC_TYPEDEF(struct lldpPortConfigTable_entry);
    
    if(!entry)
      return 0;

    row = netsnmp_tdata_create_row();
    if(!row) {
        SNMP_FREE(entry);
        return 0;
    }
    row->data = entry; */
 
DEBUGMSGTL(("lldpPortConfigTable", "cache load\n"));  
         
     /*
         * Initialise the contents of the table here 
         */
    DEBUGMSGTL(("lldpPortConfigTable", "cache for loop\n"));

    tempNode = SNMP_MALLOC_TYPEDEF(port_tab_entry_t);
    for(i=4; i<8; i++)
    {
DEBUGMSGTL(("lldpPortConfigTable", "cache for loop%d\n", i));
       
       tempNode->port_tab_portnum = i+1;  
       tempNode->port_tab_status  = (i+1) % 4 + 1; /* 1 thru 4 */
       tempNode->port_tab_notify = i % 2;     /* true or false */
       tempNode->port_tab_tlvs     = bits[i % 4];   /* 0 - 3 */
       row = lldpPortConfigTable_createEntry(table, tempNode->port_tab_portnum);
       ent = row->data;
       ent->lldpPortConfigAdminStatus = tempNode->port_tab_status;
       ent->old_lldpPortConfigAdminStatus = 0;
       ent->lldpPortConfigNotificationEnable = tempNode->port_tab_notify;
       ent->old_lldpPortConfigAdminStatus = 0;
       ent->lldpPortConfigTLVsTxEnable[0] = tempNode->port_tab_tlvs;
       ent->lldpPortConfigTLVsTxEnable_len = 1;
       ent->old_lldpPortConfigTLVsTxEnable[0] = 0;
       ent->old_lldpPortConfigTLVsTxEnable_len = 1;
DEBUGMSGTL(("lldpPortConfigTable", "cache for loop bottom%d\n", i));
   }
   SNMP_FREE(tempNode); 
   tempNode = NULL;
DEBUGMSGTL(("lldpPortConfigTable", "cache after loop\n"));
   return(SNMP_ERR_NOERROR);
    
}

void 
    lldpPortConfigTable_free(netsnmp_cache * cache, void *vmagic) {
//    netsnmp_tdata * table = (netsnmp_tdata *) vmagic;
    netsnmp_tdata_row *this;
    netsnmp_tdata * table;
    table = (netsnmp_tdata *) vmagic;
DEBUGMSGTL(("lldpPortConfigTable", "cache free\n"));

/* change from netsnmp_tdata_get_first_row */
    while ((this = netsnmp_tdata_row_first(table))) {
DEBUGMSGTL(("lldpPortConfigTable", "cache free while\n"));        
        netsnmp_tdata_remove_and_delete_row(table, this);
DEBUGMSGTL(("lldpPortConfigTable", "cache free while2\n"));  
    }
}

/** handles requests for the lldpPortConfigTable table */
 int lldpPortConfigTable_handler(netsnmp_mib_handler *handler,
                                netsnmp_handler_registration *reginfo,
                                netsnmp_agent_request_info *reqinfo,
                                netsnmp_request_info *requests) {

    netsnmp_request_info *request;
    netsnmp_table_request_info *table_info;
    netsnmp_tdata * table_data;
    netsnmp_tdata_row *table_row;
    struct lldpPortConfigTable_entry *table_entry;
    int  ret;

    switch (reqinfo->mode) {
        /*
         * Read-support (also covers GetNext requests)
         */
    case MODE_GET:
        for (request = requests; request; request = request->next) {
            table_entry = (struct lldpPortConfigTable_entry *)
                netsnmp_tdata_extract_entry(request);
            table_info = netsnmp_extract_table_info(request);

            switch (table_info->colnum) {
            case COLUMN_LLDPPORTCONFIGADMINSTATUS:
                if (!table_entry) {
                    netsnmp_set_request_error(reqinfo, request,
                                              SNMP_NOSUCHINSTANCE);
                    continue;
                }
                snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
                                           table_entry->
                                           lldpPortConfigAdminStatus);
                break;
            case COLUMN_LLDPPORTCONFIGNOTIFICATIONENABLE:
                if (!table_entry) {
                    netsnmp_set_request_error(reqinfo, request,
                                              SNMP_NOSUCHINSTANCE);
                    continue;
                }
                snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
                                           table_entry->
                                           lldpPortConfigNotificationEnable);
                break;
            case COLUMN_LLDPPORTCONFIGTLVSTXENABLE:
                if (!table_entry) {
                    netsnmp_set_request_error(reqinfo, request,
                                              SNMP_NOSUCHINSTANCE);
                    continue;
                }
                snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR,
                                         (u_char *) table_entry->
                                         lldpPortConfigTLVsTxEnable,
                                         table_entry->
                                         lldpPortConfigTLVsTxEnable_len);
                break;
            default:
                netsnmp_set_request_error(reqinfo, request,
                                          SNMP_NOSUCHOBJECT);
                break;
            }
        }
        break;

        /*
         * Write-support
         */
    case MODE_SET_RESERVE1:
        for (request = requests; request; request = request->next) {
            table_entry = (struct lldpPortConfigTable_entry *)
                netsnmp_tdata_extract_entry(request);
            table_info = netsnmp_extract_table_info(request);

            switch (table_info->colnum) {
            case COLUMN_LLDPPORTCONFIGADMINSTATUS:
                /*
                 * or possibly 'netsnmp_check_vb_int_range' 
                 */
                ret = netsnmp_check_vb_int(request->requestvb);
                if (ret != SNMP_ERR_NOERROR) {
                    netsnmp_set_request_error(reqinfo, request, ret);
                    return SNMP_ERR_NOERROR;
                }

                ret = checkNumericRange(1, 4, *request->requestvb->val.integer);
                if (ret != SNMP_ERR_NOERROR) {
                    netsnmp_set_request_error(reqinfo, request, ret);
                    return SNMP_ERR_NOERROR;
                }
                break;
            case COLUMN_LLDPPORTCONFIGNOTIFICATIONENABLE:
                /*
                 * or possibly 'netsnmp_check_vb_int_range' 
                 */
                ret = netsnmp_check_vb_int(request->requestvb);
                if (ret != SNMP_ERR_NOERROR) {
                    netsnmp_set_request_error(reqinfo, request, ret);
                    return SNMP_ERR_NOERROR;
                }

                ret = checkBoolean(*request->requestvb->val.integer);
                if (ret != SNMP_ERR_NOERROR) {
                    netsnmp_set_request_error(reqinfo, request, ret);
                    return SNMP_ERR_NOERROR;
                } 
                break;
            case COLUMN_LLDPPORTCONFIGTLVSTXENABLE:
                /*
                 * or possiblc 'netsnmp_check_vb_type_and_size' 
                 */
                ret =
                    netsnmp_check_vb_type_and_max_size(request->requestvb,
                                                       ASN_OCTET_STR,
                                                       sizeof(table_entry->
                                                              lldpPortConfigTLVsTxEnable));
                if (ret != SNMP_ERR_NOERROR) {
                    netsnmp_set_request_error(reqinfo, request, ret);
                    return SNMP_ERR_NOERROR;
                }

                ret = checkTlvsBITS(*request->requestvb->val.string);
                if (ret != SNMP_ERR_NOERROR) {
                    netsnmp_set_request_error(reqinfo, request, ret);
                    return SNMP_ERR_NOERROR;
                }
                break;
            default:
                netsnmp_set_request_error(reqinfo, request,
                                          SNMP_ERR_NOTWRITABLE);
                return SNMP_ERR_NOERROR;
            }
        }
        break;

    case MODE_SET_RESERVE2:
        break;

    case MODE_SET_FREE:
        break;

    case MODE_SET_ACTION:
        for (request = requests; request; request = request->next) {
            table_entry = (struct lldpPortConfigTable_entry *)
                netsnmp_tdata_extract_entry(request);
            table_info = netsnmp_extract_table_info(request);

            switch (table_info->colnum) {
            case COLUMN_LLDPPORTCONFIGADMINSTATUS:
                table_entry->old_lldpPortConfigAdminStatus =
                    table_entry->lldpPortConfigAdminStatus;
                table_entry->lldpPortConfigAdminStatus =
                    *request->requestvb->val.integer;
                break;
            case COLUMN_LLDPPORTCONFIGNOTIFICATIONENABLE:
                table_entry->old_lldpPortConfigNotificationEnable =
                    table_entry->lldpPortConfigNotificationEnable;
                table_entry->lldpPortConfigNotificationEnable =
                    *request->requestvb->val.integer;
                break;
            case COLUMN_LLDPPORTCONFIGTLVSTXENABLE:
                memcpy(table_entry->old_lldpPortConfigTLVsTxEnable,
                       table_entry->lldpPortConfigTLVsTxEnable,
                       sizeof(table_entry->lldpPortConfigTLVsTxEnable));
                table_entry->old_lldpPortConfigTLVsTxEnable_len =
                    table_entry->lldpPortConfigTLVsTxEnable_len;
                memset(table_entry->lldpPortConfigTLVsTxEnable, 0,
                       sizeof(table_entry->lldpPortConfigTLVsTxEnable));
                memcpy(table_entry->lldpPortConfigTLVsTxEnable,
                       request->requestvb->val.string,
                       request->requestvb->val_len);
                table_entry->lldpPortConfigTLVsTxEnable_len =
                    request->requestvb->val_len;
                break;
            }
        }
        break;

    case MODE_SET_UNDO:
        for (request = requests; request; request = request->next) {
            table_entry = (struct lldpPortConfigTable_entry *)
                netsnmp_tdata_extract_entry(request);
            table_row = netsnmp_tdata_extract_row(request);
            table_data = netsnmp_tdata_extract_table(request);
            table_info = netsnmp_extract_table_info(request);

            switch (table_info->colnum) {
            case COLUMN_LLDPPORTCONFIGADMINSTATUS:
                table_entry->lldpPortConfigAdminStatus =
                    table_entry->old_lldpPortConfigAdminStatus;
                table_entry->old_lldpPortConfigAdminStatus = 0;
                break;
            case COLUMN_LLDPPORTCONFIGNOTIFICATIONENABLE:
                table_entry->lldpPortConfigNotificationEnable =
                    table_entry->old_lldpPortConfigNotificationEnable;
                table_entry->old_lldpPortConfigNotificationEnable = 0;
                break;
            case COLUMN_LLDPPORTCONFIGTLVSTXENABLE:
                memcpy(table_entry->lldpPortConfigTLVsTxEnable,
                       table_entry->old_lldpPortConfigTLVsTxEnable,
                       sizeof(table_entry->lldpPortConfigTLVsTxEnable));
                memset(table_entry->old_lldpPortConfigTLVsTxEnable, 0,
                       sizeof(table_entry->lldpPortConfigTLVsTxEnable));
                table_entry->lldpPortConfigTLVsTxEnable_len =
                    table_entry->old_lldpPortConfigTLVsTxEnable_len;
                break;
            }
        }
        break;

    case MODE_SET_COMMIT:
        break;
    }
    return SNMP_ERR_NOERROR;
}

