int
CcspTableHelperSetMibValues
(
ANSC_HANDLE hThisObject,
netsnmp_agent_request_info *reqinfo,
netsnmp_request_info *requests
)
{
PCCSP_TABLE_HELPER_OBJECT pThisObject = (PCCSP_TABLE_HELPER_OBJECT)hThisObject;
PCCSP_TABLE_ENTRY pEntry = (PCCSP_TABLE_ENTRY)NULL;
PCCSP_MIB_VALUE pMibValueObj = (PCCSP_MIB_VALUE)NULL;
netsnmp_request_info *request = NULL;
netsnmp_table_request_info* table_info = NULL;
netsnmp_tdata* table_data = NULL;
netsnmp_tdata_row* table_row = NULL;
netsnmp_variable_list *requestvb = NULL;
netsnmp_variable_list *next = NULL;
PCCSP_MIB_MAPPING pMapping = NULL;
oid subid = 0;
int ret = 0;
int i = 0;
ULONG indexes[8] = { 0 };
AnscTraceInfo(("Enter 'CcspTableHelperSetMibValues' with mode = %d\n", reqinfo->mode));
switch( reqinfo->mode)
{
case MODE_SET_RESERVE1:
for (request = requests; request != NULL; request = request->next)
{
if( request->processed != 0) { continue;}
pEntry = (PCCSP_TABLE_ENTRY)netsnmp_tdata_extract_entry(request);
table_info = netsnmp_extract_table_info(request);
requestvb = request->requestvb;
subid = table_info->colnum;
pMapping = CcspUtilLookforMibMapWithOid(&pThisObject->MibObjQueue, subid);
if( subid == pThisObject->uRowStatus)
{
ret = netsnmp_check_vb_rowstatus( requestvb, (pEntry? RS_ACTIVE: RS_NONEXISTENT));
if( ret != SNMP_ERR_NOERROR)
{
netsnmp_set_request_error(reqinfo, request, ret);
return SNMP_ERR_NOERROR;
}
/* somehow the Destroy was not checked correctly above */
if( pEntry == NULL && *requestvb->val.integer == RS_DESTROY)
{
netsnmp_set_request_error(reqinfo, request, SNMP_ERR_BADVALUE);
return SNMP_ERR_NOERROR;
}
}
else if( pMapping)
{
ret = verifyTypeAndValueInSetReserved1(request->requestvb, pMapping);
if( ret != SNMP_ERR_NOERROR)
{
netsnmp_set_request_error(reqinfo, request, ret);
return SNMP_ERR_NOERROR;
}
}
else
{
netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);
return SNMP_ERR_NOERROR;
}
}
break;
case MODE_SET_RESERVE2:
for (request = requests; request != NULL; request = request->next)
{
if( request->processed != 0) { continue;}
pEntry = (PCCSP_TABLE_ENTRY)netsnmp_tdata_extract_entry(request);
table_info = netsnmp_extract_table_info(request);
table_data = netsnmp_tdata_extract_table(request);
requestvb = request->requestvb;
subid = table_info->colnum;
if( subid == pThisObject->uRowStatus)
{
if( RS_CREATEANDGO == *requestvb->val.integer || RS_CREATEANDWAIT == *requestvb->val.integer)
{
next = table_info->indexes;
for( i = 0; i < table_info->number_indexes; i ++)
{
indexes[i] = *next->val.integer;
next = next->next_variable;
if( next == NULL) break;
}
table_row = CcspUtilCreateMibEntry( table_data, indexes, table_info->number_indexes, FALSE);
if( table_row)
{
/* create entry at CCSP back-end */
if(!CcspUtilCreateCosaEntry((ANSC_HANDLE)pThisObject, indexes, table_info->number_indexes))
{
AnscTraceError(("Failed to Add COSA Entry at back-end.\n"));
}
pEntry = (PCCSP_TABLE_ENTRY)table_row->data;
/* the indexes array is the array of CCSP instance numbers */
for( i = 0; i < table_info->number_indexes; i ++)
{
pEntry->IndexValue[i].Value.iValue = indexes[i];
}
pEntry->IndexCount = table_info->number_indexes;
/* init the value array */
CcspUtilInitMibValueArray(&pThisObject->MibObjQueue, &pEntry->MibValueQueue);
netsnmp_insert_tdata_row(request, table_row);
}
else
{
netsnmp_set_request_error(reqinfo, request, SNMP_ERR_RESOURCEUNAVAILABLE);
return SNMP_ERR_NOERROR;
}
}
}
}
/* collect all the updated values and call Cosa_SetParamValues with Commit = FALSE */
return tableGroupSetReserve2(hThisObject, reqinfo, requests);
break;
case MODE_SET_ACTION:
if( pThisObject->pCcspComp != NULL && pThisObject->pCcspPath)
{
/* commit the update */
if (pThisObject->bBackground)
{
Cosa_BackgroundCommit(pThisObject->pCcspComp, pThisObject->pCcspPath, TRUE);
pThisObject->bBackground = 0;
struct timespec delay = {0, 80000000};
nanosleep(&delay, NULL);
}
else
{
Cosa_SetCommit(pThisObject->pCcspComp, pThisObject->pCcspPath, TRUE);
}
}
for (request = requests; request != NULL; request = request->next)
{
if( request->processed != 0) { continue;}
pEntry = (PCCSP_TABLE_ENTRY)netsnmp_tdata_extract_entry(request);
if(pEntry)
{
table_info = netsnmp_extract_table_info(request);
table_row = netsnmp_tdata_extract_row(request);
table_data = netsnmp_tdata_extract_table(request);
requestvb = request->requestvb;
subid = table_info->colnum;
if( subid == pThisObject->uRowStatus)
{
pMibValueObj = CcspUtilLookforMibValueObjWithOid(&pEntry->MibValueQueue, subid);
switch(*requestvb->val.integer)
{
case RS_CREATEANDGO:
pEntry->valid = 1;
case RS_ACTIVE:
if( pMibValueObj) pMibValueObj->Value.uValue = RS_ACTIVE;
break;
case RS_CREATEANDWAIT:
pEntry->valid = 1;
case RS_NOTINSERVICE:
if( pMibValueObj) pMibValueObj->Value.uValue = RS_NOTINSERVICE;
break;
case RS_DESTROY:
for( i = 0; i < pEntry->IndexCount; i ++)
{
indexes[i] = pEntry->IndexValue[i].Value.uValue;
}
/* remove the entry at the back-end */
if(!CcspUtilDeleteCosaEntry((ANSC_HANDLE)pThisObject, indexes, pEntry->IndexCount))
{
AnscTraceWarning(("Failed to delete DM entry.\n"));
}
CcspUtilRemoveMibEntry(table_data,table_row);
break;
}
}
}
}
return SNMP_ERR_NOERROR;
case MODE_SET_FREE:
if( pThisObject->pCcspComp != NULL && pThisObject->pCcspPath)
{
/* don't commit the update */
Cosa_SetCommit(pThisObject->pCcspComp, pThisObject->pCcspPath, FALSE);
}
return tableGroupSetFree(hThisObject, reqinfo, requests);
case MODE_SET_COMMIT:
case MODE_SET_UNDO:
default:
/* we don't care about them */
return SNMP_ERR_NOERROR;
}
return SNMP_ERR_NOERROR;
}
/** handles requests for the tlstmCertToTSNTable table */
static int
tlstmCertToTSNTable_handler(netsnmp_mib_handler *handler,
netsnmp_handler_registration *reginfo,
netsnmp_agent_request_info *reqinfo,
netsnmp_request_info *requests)
{
oid tsnm[] = { SNMP_TLS_TM_BASE, 1, 1, 0 };
static const int tsnm_pos = OID_LENGTH(tsnm) - 1;
netsnmp_request_info *request = NULL;
netsnmp_table_request_info *info;
netsnmp_tdata *table;
netsnmp_tdata_row *row;
certToTSN_entry *entry;
int ret = SNMP_ERR_NOERROR;
DEBUGMSGTL(("tlstmCertToSN:handler", "Processing request (mode %s (%d))\n",
se_find_label_in_slist("agent_mode", reqinfo->mode),
reqinfo->mode));
switch (reqinfo->mode) {
/** ######################################################### GET #####
*
* Read-support (also covers GetNext requests)
*/
case MODE_GET:
for (request = requests; request; request = request->next) {
if (request->processed)
continue;
entry = (certToTSN_entry *) netsnmp_tdata_extract_entry(request);
info = netsnmp_extract_table_info(request);
netsnmp_assert(entry && info);
switch (info->colnum) {
case COL_SNMPTLSTMCERTTOTSN_FINGERPRINT:
{
/*
* build SnmpTLSFingerprint
*/
u_char bin[42], *ptr = bin;
size_t len = sizeof(bin);
int rc;
rc = netsnmp_tls_fingerprint_build(entry->hashType,
entry->fingerprint,
&ptr, &len, 0);
if (SNMPERR_SUCCESS != rc)
netsnmp_set_request_error(reqinfo, request,
SNMP_ERR_GENERR);
else
snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR,
bin, len);
}
break; /* case COL_SNMPTLSTMCERTTOTSN_FINGERPRINT */
case COL_SNMPTLSTMCERTTOTSN_MAPTYPE:
tsnm[tsnm_pos] = entry->mapType;
snmp_set_var_typed_value(request->requestvb, ASN_OBJECT_ID,
tsnm, sizeof(tsnm));
break; /* case COL_SNMPTLSTMCERTTOTSN_MAPTYPE */
case COL_SNMPTLSTMCERTTOTSN_DATA:
snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR,
entry->data, entry->data_len);
break; /* case COL_SNMPTLSTMCERTTOTSN_DATA */
case COL_SNMPTLSTMCERTTOTSN_STORAGETYPE:
snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
entry->storageType);
break; /* case COL_SNMPTLSTMCERTTOTSN_STORAGETYPE */
case COL_SNMPTLSTMCERTTOTSN_ROWSTATUS:
snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
entry->rowStatus);
break; /* case COL_SNMPTLSTMCERTTOTSN_ROWSTATUS */
default:
netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHOBJECT);
break;
} /* switch colnum */
} /* for requests */
break; /* case MODE_GET */
/*
* Write-support
*/
/** #################################################### RESERVE1 #####
*
* In RESERVE1 we are just checking basic ASN.1 size/type restrictions.
* You probably don't need to change any of this code. Don't change any
* of the column values here. Save that for the ACTION phase.
*
* The next phase is RESERVE2 or FREE.
*/
case MODE_SET_RESERVE1:
for (request = requests; request; request = request->next) {
netsnmp_assert(request->processed == 0);
entry = (certToTSN_entry *) netsnmp_tdata_extract_entry(request);
info = netsnmp_extract_table_info(request);
if ((NULL != entry) && (ST_READONLY == entry->storageType)) {
ret = SNMP_ERR_NOTWRITABLE;
break;
}
switch (info->colnum) {
case COL_SNMPTLSTMCERTTOTSN_FINGERPRINT:
ret = netsnmp_check_vb_type_and_max_size
(request->requestvb, ASN_OCTET_STR,
sizeof(entry->fingerprint));
/** check len/algorithm MIB requirements */
if (ret == SNMP_ERR_NOERROR)
ret = netsnmp_cert_check_vb_fingerprint(request->requestvb);
break; /* case COL_SNMPTLSTMCERTTOTSN_FINGERPRINT */
case COL_SNMPTLSTMCERTTOTSN_MAPTYPE:
ret = netsnmp_check_vb_type_and_max_size
(request->requestvb, ASN_OBJECT_ID,
SNMPTLSTMCERTTOTSN_MAPTYPE_MAX_SIZE);
if (ret == SNMP_ERR_NOERROR) {
if (_oid2type(request->requestvb->val.objid,
request->requestvb->val_len) >
TSNM_tlstmCert_MAX)
ret = SNMP_ERR_WRONGVALUE;
}
break; /* case COL_SNMPTLSTMCERTTOTSN_MAPTYPE */
case COL_SNMPTLSTMCERTTOTSN_DATA:
ret = netsnmp_check_vb_type_and_max_size
(request->requestvb, ASN_OCTET_STR, sizeof(entry->data));
break; /* case COL_SNMPTLSTMCERTTOTSN_DATA */
case COL_SNMPTLSTMCERTTOTSN_STORAGETYPE:
ret = netsnmp_check_vb_storagetype
(request->requestvb,(entry ? entry->storageType : ST_NONE));
break; /* case COL_SNMPTLSTMCERTTOTSN_STORAGETYPE */
case COL_SNMPTLSTMCERTTOTSN_ROWSTATUS:
ret = netsnmp_check_vb_rowstatus_with_storagetype
(request->requestvb,
(entry ? entry->rowStatus :RS_NONEXISTENT),
(entry ? entry->storageType :ST_NONE));
break; /* case COL_SNMPTLSTMCERTTOTSN_ROWSTATUS */
default:
ret = SNMP_ERR_NOTWRITABLE;
} /* switch colnum */
if (ret != SNMP_ERR_NOERROR)
break;
} /* for requests */
break; /* case MODE_SET_RESERVE1 */
/** #################################################### RESERVE2 #####
*
* RESERVE2 is for checking additional restrictions from the MIB.
* Since these restrictions are often in the description of the object,
* mib2c can't generate code. It's possible that you need to add
* additional checks here. However, don't change any of the column
* values here. Save that for the ACTION phase.
*
* The next phase is ACTION or FREE.
*/
case MODE_SET_RESERVE2:
for (request = requests; request; request = request->next) {
netsnmp_assert(request->processed == 0);
entry = (certToTSN_entry *) netsnmp_tdata_extract_entry(request);
table = netsnmp_tdata_extract_table(request);
info = netsnmp_extract_table_info(request);
/*
* if no row, create one
*/
if (!entry) {
row = tlstmCertToTSNTable_createEntry
(table,*info->indexes->val.integer);
if (!row) {
ret = SNMP_ERR_RESOURCEUNAVAILABLE;
break;
}
entry = row->data;
_allocUndo(entry);
if (!entry->undo) {
tlstmCertToTSNTable_removeEntry(table, row);
row = NULL;
ret = SNMP_ERR_RESOURCEUNAVAILABLE;
break;
}
entry->undo->fate = FATE_NEWLY_CREATED;
/** associate row with requests */
netsnmp_insert_tdata_row(request, row);
}
/** allocate undo structure, if needed */
if (!entry->undo) {
_allocUndo(entry);
if (!entry->undo) {
ret = SNMP_ERR_RESOURCEUNAVAILABLE;
break;
}
}
/*
* save request ptr for column. if we already
* have a value, bail.
*/
if (entry->undo->req[info->colnum]) {
DEBUGMSGT(("tlstmCertToSN:reserve2",
"multiple sets to col %d in request\n",
info->colnum));
if (FATE_NEWLY_CREATED == entry->undo->fate)
ret = SNMP_ERR_INCONSISTENTNAME;
else
ret = SNMP_ERR_INCONSISTENTVALUE;
break;
}
entry->undo->req[info->colnum] = request;
if (ret != SNMP_ERR_NOERROR)
break;
} /* for requests */
if (ret == SNMP_ERR_NOERROR) {
/** make sure rowstatus is used to create rows */
for (request = requests; request; request = request->next) {
if (request->processed)
continue;
entry = (certToTSN_entry *)
netsnmp_tdata_extract_entry(request);
if ((entry->undo->fate != FATE_NEWLY_CREATED) ||
(entry->undo->req[COL_SNMPTLSTMCERTTOTSN_ROWSTATUS]))
continue;
ret = SNMP_ERR_INCONSISTENTNAME;
break;
} /* creation for requests */
} /* no error */
break; /* case MODE_SET_RESERVE2 */
/** ######################################################## FREE #####
*
* FREE is for cleaning up after a failed request (during either
* RESERVE1 or RESERVE2). So any allocated resources need to be
* released.
*
* This the final phase for this path in the state machine.
*/
case MODE_SET_FREE:
/*
* release undo resources
* remove any newly created rows
*/
for (request = requests; request; request = request->next) {
table = netsnmp_tdata_extract_table(request);
row = netsnmp_tdata_extract_row(request);
entry = (certToTSN_entry *) netsnmp_tdata_extract_entry(request);
if (!entry || !entry->undo)
continue;
/** disassociate row with requests */
netsnmp_remove_tdata_row(request, row);
if (FATE_NEWLY_CREATED == entry->undo->fate)
tlstmCertToTSNTable_removeEntry(table, row);
else
_freeUndo(entry);
}
break; /* case MODE_SET_FREE */
/** ###################################################### ACTION #####
*
* In the ACTION phase, we perform any sets that can be undone.
* (Save anything that can't be undone for the COMMIT phase.)
*
* After individual columns have been done, you should check that the
* row as a whole is consistent.
*
* The next phase is UNDO or COMMIT.
*/
case MODE_SET_ACTION:
for (request = requests; request; request = request->next) {
entry = (certToTSN_entry *) netsnmp_tdata_extract_entry(request);
info = netsnmp_extract_table_info(request);
/** reserve2 should enforce this */
netsnmp_assert(request == entry->undo->req[info->colnum]);
/*
* for each col, save old value and the set new value
*/
switch (info->colnum) {
case COL_SNMPTLSTMCERTTOTSN_FINGERPRINT:
{
u_char *tmp = (u_char*)entry->fingerprint;
u_int size = sizeof(entry->fingerprint);
netsnmp_variable_list *vb = request->requestvb;
memcpy(entry->undo->fingerprint,
entry->fingerprint, sizeof(entry->fingerprint));
entry->undo->fingerprint_len = entry->fingerprint_len;
entry->undo->hashType = entry->hashType;
memset(entry->fingerprint, 0, sizeof(entry->fingerprint));
(void)netsnmp_tls_fingerprint_parse(vb->val.string, vb->val_len,
(char**)&tmp, &size, 0,
&entry->hashType);
entry->fingerprint_len = size;
if (0 == entry->fingerprint_len)
ret = SNMP_ERR_GENERR;
}
break; /* case COL_SNMPTLSTMCERTTOTSN_FINGERPRINT */
case COL_SNMPTLSTMCERTTOTSN_MAPTYPE:
entry->undo->mapType = entry->mapType;
entry->mapType = _oid2type(request->requestvb->val.objid,
request->requestvb->val_len);
break; /* case COL_SNMPTLSTMCERTTOTSN_MAPTYPE */
case COL_SNMPTLSTMCERTTOTSN_DATA:
memcpy(entry->undo->data, entry->data, sizeof(entry->data));
entry->undo->data_len = entry->data_len;
memset(entry->data, 0, sizeof(entry->data));
memcpy(entry->data, request->requestvb->val.string,
request->requestvb->val_len);
entry->data_len = request->requestvb->val_len;
break; /* case COL_SNMPTLSTMCERTTOTSN_DATA */
case COL_SNMPTLSTMCERTTOTSN_STORAGETYPE:
entry->undo->storageType = entry->storageType;
entry->storageType = *request->requestvb->val.integer;
break; /* case COL_SNMPTLSTMCERTTOTSN_STORAGETYPE */
case COL_SNMPTLSTMCERTTOTSN_ROWSTATUS:
entry->undo->rowStatus = entry->rowStatus;
entry->rowStatus = *request->requestvb->val.integer;
break; /* case COL_SNMPTLSTMCERTTOTSN_ROWSTATUS */
} /* switch colnum */
} /* set values for requests */
if (ret != SNMP_ERR_NOERROR)
break; /* skip consistency if we've already got error */
/*
* All columns now have their final values set. check the
* internal consistency of each row.
*/
for (request = requests; request; request = request->next) {
entry = (certToTSN_entry *) netsnmp_tdata_extract_entry(request);
info = netsnmp_extract_table_info(request);
if (entry->undo->is_consistent != -1)
continue; /* already checked */
/** assume consistency */
entry->undo->is_consistent = 1;
/*
* per mib, can't have empty fingerprint and must
* have data if indicated by map type.
*/
if (0 == entry->fingerprint_len) {
DEBUGMSGTL(("tlstmCertToTSNTable:inconsistent",
"fingerprint must not be empty\n"));
entry->undo->is_consistent = 0;
}
else if ((TSNM_tlstmCertSpecified == entry->mapType) &&
(0 == entry->data_len)) {
DEBUGMSGTL(("tlstmCertToTSNTable:inconsistent",
"must specify Data for CertSpecified identity\n"));
entry->undo->is_consistent = 0;
}
if ((RS_IS_ACTIVE(entry->rowStatus)) &&
((!entry->undo->req[COL_SNMPTLSTMCERTTOTSN_ROWSTATUS]) ||
(RS_IS_ACTIVE(entry->undo->rowStatus)))) {
/*
* per mib, can't modify these while row active
*/
char _cols[3] = { COL_SNMPTLSTMCERTTOTSN_FINGERPRINT,
COL_SNMPTLSTMCERTTOTSN_MAPTYPE, COL_SNMPTLSTMCERTTOTSN_DATA };
int i;
for (i=0; i < 3; ++i ) {
if (!entry->undo->req[i])
continue;
DEBUGMSGTL(("tlstmCertToTSNTable:inconsistent",
"can't modify row %d while active\n",
_cols[i]));
entry->undo->is_consistent = 0;
ret = SNMP_ERR_NOTWRITABLE;
request= entry->undo->req[i];
break;
}
} else if (RS_IS_GOING_ACTIVE(entry->rowStatus)) {
/*
* if going active, inconsistency is fatal
*/
if (!entry->undo->is_consistent) {
netsnmp_assert(entry->undo->req[COL_SNMPTLSTMCERTTOTSN_ROWSTATUS]);
if (FATE_NEWLY_CREATED == entry->undo->fate)
ret = SNMP_ERR_INCONSISTENTNAME;
else
ret = SNMP_ERR_INCONSISTENTVALUE;
request = entry->undo->req[COL_SNMPTLSTMCERTTOTSN_ROWSTATUS];
}
} else if (RS_DESTROY == entry->rowStatus) {
/*
* can't destroy active row
*/
if (RS_IS_ACTIVE(entry->undo->rowStatus)) {
DEBUGMSGTL(("tlstmCertToTSNTable:inconsistent",
"can't destroy active row\n"));
netsnmp_assert(entry->undo->req[COL_SNMPTLSTMCERTTOTSN_ROWSTATUS]);
ret = SNMP_ERR_INCONSISTENTVALUE;
request = entry->undo->req[COL_SNMPTLSTMCERTTOTSN_ROWSTATUS];
}
}
if (ret != SNMP_ERR_NOERROR)
break;
} /* consistency for requests */
break; /* case MODE_SET_ACTION */
/** ######################################################## UNDO #####
*
* UNDO is for cleaning up any failed requests that went through the
* ACTION phase.
*
* This the final phase for this path in the state machine.
*/
case MODE_SET_UNDO:
for (request = requests; request; request = request->next) {
row = netsnmp_tdata_extract_row(request);
entry = (certToTSN_entry *) netsnmp_tdata_extract_entry(request);
info = netsnmp_extract_table_info(request);
/*
* skip newly created rows, as we're going to delete
* them below anyways
*/
if (FATE_NEWLY_CREATED == entry->undo->fate)
continue;
/*
* restore values
*/
switch (info->colnum) {
case COL_SNMPTLSTMCERTTOTSN_FINGERPRINT:
memcpy(entry->fingerprint, entry->undo->fingerprint,
sizeof(entry->fingerprint));
entry->fingerprint_len = entry->undo->fingerprint_len;
entry->hashType = entry->undo->hashType;
break; /* case COL_SNMPTLSTMCERTTOTSN_FINGERPRINT */
case COL_SNMPTLSTMCERTTOTSN_MAPTYPE:
entry->mapType = entry->undo->mapType;
break; /* case COL_SNMPTLSTMCERTTOTSN_MAPTYPE */
case COL_SNMPTLSTMCERTTOTSN_DATA:
memcpy(entry->data, entry->undo->data, sizeof(entry->data));
entry->data_len = entry->undo->data_len;
break; /* case COL_SNMPTLSTMCERTTOTSN_DATA */
case COL_SNMPTLSTMCERTTOTSN_STORAGETYPE:
entry->storageType = entry->undo->storageType;
break; /* case COL_SNMPTLSTMCERTTOTSN_STORAGETYPE */
case COL_SNMPTLSTMCERTTOTSN_ROWSTATUS:
entry->rowStatus = entry->undo->rowStatus;
break; /* case COL_SNMPTLSTMCERTTOTSN_ROWSTATUS */
} /* switch colnum */
} /* for requests */
/*
* release undo data
* or remove any newly created rows
*/
for (request = requests; request; request = request->next) {
table = netsnmp_tdata_extract_table(request);
row = netsnmp_tdata_extract_row(request);
entry = (certToTSN_entry *) netsnmp_tdata_extract_entry(request);
if (!entry || !entry->undo)
continue;
/** disassociate row with requests */
netsnmp_remove_tdata_row(request, row);
if (FATE_NEWLY_CREATED == entry->undo->fate)
tlstmCertToTSNTable_removeEntry(table, row);
else
_freeUndo(entry);
} /* for requests */
break; /* case MODE_SET_UNDO */
/** ###################################################### COMMIT #####
*
* COMMIT is the final success state, when all changes are finalized.
* There is not recovery state should something faile here.
*
* This the final phase for this path in the state machine.
*/
case MODE_SET_COMMIT:
for (request = requests; request; request = request->next) {
row = netsnmp_tdata_extract_row(request);
table = netsnmp_tdata_extract_table(request);
info = netsnmp_extract_table_info(request);
entry = (certToTSN_entry *) netsnmp_tdata_extract_entry(request);
if ((RS_NOTREADY == entry->rowStatus) && entry->undo->is_consistent)
entry->rowStatus = RS_NOTINSERVICE;
else if ((RS_NOTINSERVICE == entry->rowStatus) &&
(0 == entry->undo->is_consistent))
entry->rowStatus = RS_NOTREADY;
/** release undo data for requests with no rowstatus */
if (entry->undo && !entry->undo->req[COL_SNMPTLSTMCERTTOTSN_ROWSTATUS]) {
_freeUndo(entry);
if ((0 == entry->map_flags) && (entry->rowStatus == RS_ACTIVE))
_cert_map_add(entry);
else if ((0 != entry->map_flags) &&
(entry->rowStatus == RS_DESTROY))
_cert_map_remove(entry);
}
switch (info->colnum) {
case COL_SNMPTLSTMCERTTOTSN_ROWSTATUS:
switch (entry->rowStatus) {
case RS_CREATEANDGO:
/** Fall-through */
case RS_ACTIVE:
netsnmp_assert(entry->undo->is_consistent);
entry->rowStatus = RS_ACTIVE;
if (0 == entry->map_flags)
_cert_map_add(entry);
break;
case RS_CREATEANDWAIT:
/** Fall-through */
case RS_NOTINSERVICE:
/** simply set status based on consistency */
if (entry->undo->is_consistent)
entry->rowStatus = RS_NOTINSERVICE;
else
entry->rowStatus = RS_NOTREADY;
if (0 != entry->map_flags)
_cert_map_remove(entry);
break;
case RS_DESTROY:
/** remove from cert map */
if (0 != entry->map_flags)
_cert_map_remove(entry);
/** disassociate row with requests */
netsnmp_remove_tdata_row(request, row);
tlstmCertToTSNTable_removeEntry(table, row);
row = NULL;
entry = NULL;
}
/** release undo data */
_freeUndo(entry);
break; /* case COL_SNMPTLSTMCERTTOTSN_ROWSTATUS */
case COL_SNMPTLSTMCERTTOTSN_STORAGETYPE:
if (RS_ACTIVE == entry->rowStatus)
_cert_map_tweak_storage(entry);
break; /* case COL_SNMPTLSTMCERTTOTSN_STORAGETYPE */
case COL_SNMPTLSTMCERTTOTSN_FINGERPRINT:
case COL_SNMPTLSTMCERTTOTSN_MAPTYPE:
case COL_SNMPTLSTMCERTTOTSN_DATA:
break;
} /* switch colnum */
} /* for requests */
/** update last changed */
_last_changed = netsnmp_get_agent_uptime();
/** set up to save persistent store */
snmp_store_needed(NULL);
break; /* case MODE_SET_COMMIT */
} /* switch (reqinfo->mode) */
if (ret != SNMP_ERR_NOERROR)
netsnmp_set_request_error(reqinfo, request, ret);
return SNMP_ERR_NOERROR;
}
static
int
tableGroupSetFree
(
ANSC_HANDLE hThisObject,
netsnmp_agent_request_info *reqinfo,
netsnmp_request_info *requests
)
{
PCCSP_TABLE_HELPER_OBJECT pThisObject = (PCCSP_TABLE_HELPER_OBJECT)hThisObject;
PCCSP_MIB_VALUE pMibValueObj = (PCCSP_MIB_VALUE)NULL;
netsnmp_request_info *request = NULL;
netsnmp_variable_list *requestvb = NULL;
oid subid = 0;
PCCSP_TABLE_ENTRY pEntry = (PCCSP_TABLE_ENTRY)NULL;
netsnmp_table_request_info* table_info = NULL;
netsnmp_tdata* table_data = NULL;
netsnmp_tdata_row* table_row = NULL;
ULONG indexes[8] = { 0 };
ULONG i = 0;
AnscTraceInfo(("Enter 'tableGroupSetFree'\n"));
#if 0
/* check whether Rowstatus is involved */
for (request = requests; request != NULL; request = request->next)
{
if( request->processed != 0) { continue;}
pEntry = (PCCSP_TABLE_ENTRY)netsnmp_tdata_extract_entry(request);
table_info = netsnmp_extract_table_info(request);
table_data = netsnmp_tdata_extract_table(request);
table_row = netsnmp_tdata_extract_row(request);
requestvb = request->requestvb;
subid = table_info->colnum;
if( subid == pThisObject->uRowStatus)
{
if( RS_CREATEANDGO == *requestvb->val.integer || RS_CREATEANDWAIT == *requestvb->val.integer)
{
if( pEntry != NULL && !pEntry->valid)
{
for( i = 0; i < pEntry->IndexCount; i ++)
{
indexes[i] = pEntry->IndexValue[i].Value.uValue;
}
/* remove the entry at the back-end */
if(!CcspUtilDeleteCosaEntry((ANSC_HANDLE)pThisObject, indexes, pEntry->IndexCount))
{
AnscTraceWarning(("Failed to delete DM entry.\n"));
}
CcspUtilRemoveMibEntry(table_data,table_row);
}
}
}
}
#endif
/* Copy back the saved values */
for (request = requests; request != NULL; request = request->next)
{
if( request->processed != 0) { continue;}
pEntry = (PCCSP_TABLE_ENTRY)netsnmp_tdata_extract_entry(request);
table_info = netsnmp_extract_table_info(request);
requestvb = request->requestvb;
subid = table_info->colnum;
if( pEntry == NULL) return SNMP_ERR_NOERROR;
pMibValueObj = CcspUtilLookforMibValueObjWithOid(&pEntry->MibValueQueue, subid);
if( pMibValueObj != NULL)
{
if( pMibValueObj->uType == ASN_OCTET_STR)
{
if( pMibValueObj->Value.pBuffer != NULL) AnscFreeMemory(pMibValueObj->Value.pBuffer);
pMibValueObj->Value.pBuffer = pMibValueObj->BackValue.pBuffer;
pMibValueObj->uSize = pMibValueObj->uBackSize;
pMibValueObj->BackValue.pBuffer = NULL;
pMibValueObj->uBackSize = 0;
}
else if( pMibValueObj->uType == ASN_BIT_STR)
{
if( pMibValueObj->Value.puBuffer != NULL) AnscFreeMemory(pMibValueObj->Value.puBuffer);
pMibValueObj->Value.puBuffer = pMibValueObj->BackValue.puBuffer;
pMibValueObj->uSize = pMibValueObj->uBackSize;
pMibValueObj->BackValue.puBuffer = NULL;
pMibValueObj->uBackSize = 0;
}
else
{
pMibValueObj->Value.uValue = pMibValueObj->BackValue.uValue;
pMibValueObj->uSize = pMibValueObj->uBackSize;
pMibValueObj->BackValue.uValue = 0;
pMibValueObj->uBackSize = pMibValueObj->uSize;
}
}
}
return SNMP_ERR_NOERROR;
}