int main(int argc, char *argv[])
{
char client_name[] = "ofdpa purge client";
OFDPA_ERROR_t rc;
uint32_t count;
ofdpaFlowEntry_t flow;
ofdpaFlowEntryStats_t flowStats;
uint32_t tableIdIndex;
OFDPA_FLOW_TABLE_ID_t flowTablePurgeOrderList[] = {OFDPA_FLOW_TABLE_ID_VLAN,
OFDPA_FLOW_TABLE_ID_TERMINATION_MAC,
OFDPA_FLOW_TABLE_ID_UNICAST_ROUTING,
OFDPA_FLOW_TABLE_ID_MULTICAST_ROUTING,
OFDPA_FLOW_TABLE_ID_BRIDGING,
OFDPA_FLOW_TABLE_ID_ACL_POLICY,
OFDPA_FLOW_TABLE_ID_INGRESS_PORT};
#define FLOW_TABLE_PURGE_LIST_NUM_ENTRIES (sizeof(flowTablePurgeOrderList)/sizeof(OFDPA_FLOW_TABLE_ID_t))
ofdpaGroupEntry_t group;
uint32_t tunnelPortId;
uint32_t ecmpNextHopId;
uint32_t nextHopId;
uint32_t tunnelId;
ofdpaPortEvent_t portEventData;
rc = ofdpaClientInitialize(client_name);
if (rc != OFDPA_E_NONE)
{
printf("\nFailure calling ofdpaClientInitialize(). rc = %d", rc);
return rc;
}
printf("Purging flow tables.\n");
for (tableIdIndex = 0; tableIdIndex < FLOW_TABLE_PURGE_LIST_NUM_ENTRIES; tableIdIndex++)
{
ofdpaFlowEntryInit(flowTablePurgeOrderList[tableIdIndex], &flow);
count = 0;
if ((ofdpaFlowStatsGet(&flow, &flowStats) == OFDPA_E_NONE) ||
(ofdpaFlowNextGet(&flow, &flow) == OFDPA_E_NONE))
{
do
{
if ((rc = ofdpaFlowDelete(&flow)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from odpaFlowDelete: rc = %d, tableId = %d\n",
rc, flow.tableId);
}
} while (ofdpaFlowNextGet(&flow, &flow) == OFDPA_E_NONE);
}
if (count != 0)
{
printf("\tDeleted %d flows from tableId %d\n", count, flow.tableId);
}
else
{
printf("\tNo entries found in tableId %d\n", flow.tableId);
}
}
printf("Purging group table.\n");
memset(&group, 0, sizeof(group));
count = 0;
while (ofdpaGroupNextGet(group.groupId, &group) == OFDPA_E_NONE)
{
if ((rc = ofdpaGroupDelete(group.groupId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaGroupDelete: rc = %d, groupId = 0x%08x\n",
rc, group.groupId);
}
}
if (count != 0)
{
printf("\tDeleted %d groups.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging logical tunnel port to tenant associations.\n");
tunnelPortId = 0;
ofdpaPortTypeSet(&tunnelPortId, OFDPA_PORT_TYPE_LOGICAL_TUNNEL);
while (ofdpaTunnelPortNextGet(tunnelPortId, &tunnelPortId) == OFDPA_E_NONE)
{
count = 0;
tunnelId = 0;
while (ofdpaTunnelPortTenantNextGet(tunnelPortId, tunnelId, &tunnelId) == OFDPA_E_NONE)
{
if ((rc = ofdpaTunnelPortTenantDelete(tunnelPortId, tunnelId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaTunnelPortTenantDelete: rc = %d, tunnelPortId = 0x%08x, tunnelId = %d\n",
rc, tunnelPortId, tunnelId);
}
}
if (count != 0)
{
printf("\tDeleted %d tunnel logical port to tenant associations for port 0x%08x.\n", count, tunnelPortId);
}
else
{
printf("\tNo entries found for port 0x%08x.\n", tunnelPortId);
}
}
printf("Purging logical tunnel ports.\n");
tunnelPortId = 0;
ofdpaPortTypeSet(&tunnelPortId, OFDPA_PORT_TYPE_LOGICAL_TUNNEL);
count = 0;
while (ofdpaTunnelPortNextGet(tunnelPortId, &tunnelPortId) == OFDPA_E_NONE)
{
if ((rc = ofdpaTunnelPortDelete(tunnelPortId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaTunnelPortDelete: rc = %d, tunnelPortId = 0x%08x\n",
rc, tunnelPortId);
}
}
if (count != 0)
{
printf("\tDeleted %d tunnel logical ports.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging tunnel ECMP next hop groups.\n");
ecmpNextHopId = 0;
count = 0;
while (ofdpaTunnelEcmpNextHopGroupNextGet(ecmpNextHopId, &ecmpNextHopId) == OFDPA_E_NONE)
{
/* remove any member next hops from this group */
nextHopId = 0;
while ((rc = ofdpaTunnelEcmpNextHopGroupMemberNextGet(ecmpNextHopId, nextHopId, &nextHopId)) == OFDPA_E_NONE)
{
if ((rc = ofdpaTunnelEcmpNextHopGroupMemberDelete(ecmpNextHopId, nextHopId)) != OFDPA_E_NONE)
{
printf("\tError returned from ofdpaTunnelEcmpNextHopGroupMemberDelete: rc = %d, ecmpNextHopId = %d, nextHopId = %d\n",
rc, ecmpNextHopId, nextHopId);
}
}
if ((rc = ofdpaTunnelEcmpNextHopGroupDelete(ecmpNextHopId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaTunnelEcmpNextHopGroupDelete: rc = %d, nextHopId = 0x%08x\n",
rc, nextHopId);
}
}
if (count != 0)
{
printf("\tDeleted %d ECMP next hop groups.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging tenants.\n");
tunnelId = 0;
count = 0;
while (ofdpaTunnelTenantNextGet(tunnelId, &tunnelId) == OFDPA_E_NONE)
{
if ((rc = ofdpaTunnelTenantDelete(tunnelId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaTunnelTenantDelete: rc = %d, tunnelId = %d\n",
rc, tunnelId);
}
}
if (count != 0)
{
printf("\tDeleted %d tenants.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging tunnel next hops.\n");
nextHopId = 0;
count = 0;
while (ofdpaTunnelNextHopNextGet(nextHopId, &nextHopId) == OFDPA_E_NONE)
{
if ((rc = ofdpaTunnelNextHopDelete(nextHopId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaTunnelNextHopDelete: rc = %d, nextHopId = %d\n",
rc, nextHopId);
}
}
if (count != 0)
{
printf("\tDeleted %d next hops.\n", count);
}
else
{
printf("\tNo entries found\n");
}
/* retrieve all port events to allow logical ports to actually be deleted from database */
memset(&portEventData, 0, sizeof(portEventData));
count = 0;
while (ofdpaPortEventNextGet(&portEventData) == OFDPA_E_NONE)
{
if (portEventData.eventMask & OFDPA_EVENT_PORT_DELETE)
{
count++;
}
}
if (count != 0)
{
printf("\tRetrieved %d port delete events.\n", count);
}
return(0);
}
/* Arguments as follows:
* argv[1] - how long to block on receive, in seconds. -1 to block forever.
*/
int main(int argc, char *argv[])
{
char client_name[] = "ofdpa event client";
OFDPA_ERROR_t rc;
int32_t wait;
struct timeval timeout;
struct timeval *tv = NULL;
time_t startTime;
time_t currentTime;
int32_t elapsedSeconds;
ofdpaGroupEntry_t l2IfaceGroup;
ofdpaGroupBucketEntry_t bucket;
ofdpaFlowEntry_t flow;
ofdpaFlowEvent_t flowEventData;
ofdpaPortEvent_t portEventData;
int i;
if (argc == 2)
{
wait = atoi(argv[1]);
}
else
{
wait = -1;
}
rc = ofdpaClientInitialize(client_name);
if (rc != OFDPA_E_NONE)
{
return rc;
}
rc = ofdpaClientEventSockBind();
if (rc != OFDPA_E_NONE)
{
return rc;
}
rc = ofdpaClientPktSockBind();
if (rc != OFDPA_E_NONE)
{
return rc;
}
if (wait >= 0)
{
timeout.tv_sec = wait;
timeout.tv_usec = 0;
tv = &timeout;
printf("\nclient_event: using wait time %d seconds for event\n", wait);
}
else
printf("\nclient_event: waiting indefinitely for events\n");
/* first clear out out any existing flows in the Bridging table */
memset(&flow, 0, sizeof(flow));
flow.tableId = OFDPA_FLOW_TABLE_ID_BRIDGING;
/* wait if OFDPA process not ready for RPC */
while (ofdpaFlowNextGet(&flow, &flow) == OFDPA_E_RPC)
{
printf("\nclient_event: waiting for OF-DPA RPC server to respond\n");
usleep(1000000);
}
do
{
(void)ofdpaFlowDelete(&flow);
} while (ofdpaFlowNextGet(&flow, &flow) == OFDPA_E_NONE);
/* build and add some flows with various hard timeout values */
/* bridging entries need an L2 Interface group */
ofdpaGroupTypeSet(&l2IfaceGroup.groupId, OFDPA_GROUP_ENTRY_TYPE_L2_INTERFACE);
ofdpaGroupVlanSet(&l2IfaceGroup.groupId, 10);
ofdpaGroupPortIdSet(&l2IfaceGroup.groupId, 1);
(void)ofdpaGroupDelete(l2IfaceGroup.groupId);
rc = ofdpaGroupAdd(&l2IfaceGroup);
if (rc != OFDPA_E_NONE)
{
printf("\nError creating required L2 Interface Group entry. rc = %d", rc);
return(3);
}
memset(&bucket, 0, sizeof(bucket));
bucket.groupId = l2IfaceGroup.groupId;
bucket.bucketIndex = 1;
bucket.bucketData.l2Interface.outputPort = 1;
rc = ofdpaGroupBucketEntryAdd(&bucket);
if (rc != OFDPA_E_NONE)
{
printf("\nError creating required L2 Interface Group entry bucket. rc = %d", rc);
return(3);
}
memset(&flow, 0, sizeof(flow));
flow.tableId = OFDPA_FLOW_TABLE_ID_BRIDGING;
flow.flowData.bridgingFlowEntry.gotoTableId = OFDPA_FLOW_TABLE_ID_ACL_POLICY;
flow.flowData.bridgingFlowEntry.match_criteria.destMac.addr[5] = 0x01;
flow.flowData.bridgingFlowEntry.match_criteria.destMacMask.addr[0] = 0xff;
flow.flowData.bridgingFlowEntry.match_criteria.destMacMask.addr[1] = 0xff;
flow.flowData.bridgingFlowEntry.match_criteria.destMacMask.addr[2] = 0xff;
flow.flowData.bridgingFlowEntry.match_criteria.destMacMask.addr[3] = 0xff;
flow.flowData.bridgingFlowEntry.match_criteria.destMacMask.addr[4] = 0xff;
flow.flowData.bridgingFlowEntry.match_criteria.destMacMask.addr[5] = 0xff;
flow.flowData.bridgingFlowEntry.match_criteria.vlanId = 100;
flow.flowData.bridgingFlowEntry.match_criteria.vlanIdMask = OFDPA_VID_PRESENT | OFDPA_VID_EXACT_MASK;
flow.flowData.bridgingFlowEntry.groupID = l2IfaceGroup.groupId;
flow.hard_time = 5;
if ((rc = ofdpaFlowAdd(&flow)) != OFDPA_E_NONE)
{
printf("client_event: ofdpaFlowAdd failed for first flow: rc = %d\n", rc);
/* no sense in continuing if we cannot add the first test flow */
return(-1);
}
/* build up a second flow with a later hard time value */
flow.flowData.bridgingFlowEntry.match_criteria.vlanId++;
flow.hard_time = 15;
if (ofdpaFlowAdd(&flow) != OFDPA_E_NONE)
{
printf("client_event: ofdpaFlowAdd failed for second flow: rc = %d\n", rc);
/* forge ahead */
}
/* build up a flow with a idle time value that expires before the second hard time flow */
flow.flowData.bridgingFlowEntry.match_criteria.vlanId++;
flow.hard_time = 0;
flow.idle_time = 10;
if (ofdpaFlowAdd(&flow) != OFDPA_E_NONE)
{
printf("client_event: ofdpaFlowAdd failed: rc = %d\n", rc);
/* forge ahead */
}
/* build up a flow with a idle time value AND a hard time value to see
if we can get both event types valid for the same flow simultaneously
*/
flow.flowData.bridgingFlowEntry.match_criteria.vlanId++;
flow.hard_time = 12;
flow.idle_time = 12;
if (ofdpaFlowAdd(&flow) != OFDPA_E_NONE)
{
printf("client_event: ofdpaFlowAdd failed: rc = %d\n", rc);
/* forge ahead */
}
flow.idle_time = 0;
/* build up a group of flows with the same hard time value to see if we can
generate multiple flow events sharing the same event notification
*/
flow.hard_time = 20;
for (i=0; i<10; i++)
{
flow.flowData.bridgingFlowEntry.match_criteria.vlanId++;
if (ofdpaFlowAdd(&flow) != OFDPA_E_NONE)
{
printf("client_event: ofdpaFlowAdd failed in flow add loop: rc = %d, i = %d\n", rc, i);
/* forge ahead */
}
}
printf("client_event: waiting for event notifications...\n");
time(&startTime);
while ((rc = ofdpaEventReceive(tv)) == OFDPA_E_NONE)
{
time(¤tTime);
elapsedSeconds = currentTime - startTime;
printf("client_event: received event notification (elapsed time: %d seconds)\n",
elapsedSeconds);
memset(&flowEventData, 0, sizeof(flowEventData));
flowEventData.flowMatch.tableId = OFDPA_FLOW_TABLE_ID_BRIDGING;
while (ofdpaFlowEventNextGet(&flowEventData) == OFDPA_E_NONE)
{
printf("client_event: retrieved aged flow: tableId = %d, eventMask = %x\n",
flowEventData.flowMatch.tableId, flowEventData.eventMask);
printf(" flow data: vlanId = %d\n",
flowEventData.flowMatch.flowData.bridgingFlowEntry.match_criteria.vlanId & OFDPA_VID_EXACT_MASK);
if ((rc = ofdpaFlowDelete(&flowEventData.flowMatch)) != OFDPA_E_NONE)
printf("client_event: ofdpaFlowDelete rc = %d\n", rc);
else
printf("client_event: successfully deleted aged flow\n");
}
memset(&portEventData, 0, sizeof(portEventData));
while (ofdpaPortEventNextGet(&portEventData) == OFDPA_E_NONE)
{
printf("client_event: retrieved port event: port no = %d [0x%x], eventMask = 0x%x, state = %d\n",
portEventData.portNum, portEventData.portNum, portEventData.eventMask, portEventData.state);
}
}
printf("client_event: ofdpaEventReceive rc = %d\n", rc);
/* clean up group entry */
(void)ofdpaGroupDelete(l2IfaceGroup.groupId);
return 0;
}
int main(int argc, char *argv[])
{
char client_name[] = "ofdpa purge client";
OFDPA_ERROR_t rc;
uint32_t count;
uint32_t atLeastOneGroupEntryDeleted;
uint32_t tableId;
ofdpaGroupEntry_t group;
uint32_t tunnelPortId;
uint32_t ecmpNextHopId;
uint32_t nextHopId;
uint32_t tunnelId;
uint32_t megIndex;
uint32_t lmepId;
uint32_t localMpId;
uint32_t rmpId;
uint32_t mlpIndex;
ofdpaPortEvent_t portEventData;
ofdpaRemarkActionEntry_t remarkEntry;
ofdpaDropStatusEntry_t dropEntry;
ofdpaMplsQosEntry_t mplsQosEntry;
uint32_t meterId;
rc = ofdpaClientInitialize(client_name);
if (rc != OFDPA_E_NONE)
{
printf("\nFailure calling ofdpaClientInitialize(). rc = %d", rc);
return rc;
}
printf("Purging flow tables.\n");
/* flow tables purged in phases to manage cross dependencies -
egress flows first, then ingress flows except Ingress Port, last Ingress Port Flow table */
for (tableId = OFDPA_FLOW_TABLE_ID_EGRESS_VLAN; tableId < 256; tableId++)
{
flowTablePurge(tableId);
}
for (tableId = (OFDPA_FLOW_TABLE_ID_INGRESS_PORT + 1); tableId < OFDPA_FLOW_TABLE_ID_EGRESS_VLAN; tableId++)
{
flowTablePurge(tableId);
}
flowTablePurge(OFDPA_FLOW_TABLE_ID_INGRESS_PORT);
printf("Purging logical tunnel port to tenant associations.\n");
tunnelPortId = 0;
ofdpaPortTypeSet(&tunnelPortId, OFDPA_PORT_TYPE_LOGICAL_TUNNEL);
while (ofdpaTunnelPortNextGet(tunnelPortId, &tunnelPortId) == OFDPA_E_NONE)
{
count = 0;
tunnelId = 0;
while (ofdpaTunnelPortTenantNextGet(tunnelPortId, tunnelId, &tunnelId) == OFDPA_E_NONE)
{
if ((rc = ofdpaTunnelPortTenantDelete(tunnelPortId, tunnelId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaTunnelPortTenantDelete: rc = %d, tunnelPortId = 0x%08x, tunnelId = %d\n",
rc, tunnelPortId, tunnelId);
}
}
if (count != 0)
{
printf("\tDeleted %d tunnel logical port to tenant associations for port 0x%08x.\n", count, tunnelPortId);
}
else
{
printf("\tNo entries found for port 0x%08x.\n", tunnelPortId);
}
}
printf("Purging logical tunnel ports.\n");
tunnelPortId = 0;
ofdpaPortTypeSet(&tunnelPortId, OFDPA_PORT_TYPE_LOGICAL_TUNNEL);
count = 0;
while (ofdpaTunnelPortNextGet(tunnelPortId, &tunnelPortId) == OFDPA_E_NONE)
{
if ((rc = ofdpaTunnelPortDelete(tunnelPortId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaTunnelPortDelete: rc = %d, tunnelPortId = 0x%08x\n",
rc, tunnelPortId);
}
}
if (count != 0)
{
printf("\tDeleted %d tunnel logical ports.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging tunnel ECMP next hop groups.\n");
ecmpNextHopId = 0;
count = 0;
while (ofdpaTunnelEcmpNextHopGroupNextGet(ecmpNextHopId, &ecmpNextHopId) == OFDPA_E_NONE)
{
/* remove any member next hops from this group */
nextHopId = 0;
while ((rc = ofdpaTunnelEcmpNextHopGroupMemberNextGet(ecmpNextHopId, nextHopId, &nextHopId)) == OFDPA_E_NONE)
{
if ((rc = ofdpaTunnelEcmpNextHopGroupMemberDelete(ecmpNextHopId, nextHopId)) != OFDPA_E_NONE)
{
printf("\tError returned from ofdpaTunnelEcmpNextHopGroupMemberDelete: rc = %d, ecmpNextHopId = %d, nextHopId = %d\n",
rc, ecmpNextHopId, nextHopId);
}
}
if ((rc = ofdpaTunnelEcmpNextHopGroupDelete(ecmpNextHopId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaTunnelEcmpNextHopGroupDelete: rc = %d, nextHopId = 0x%08x\n",
rc, nextHopId);
}
}
if (count != 0)
{
printf("\tDeleted %d ECMP next hop groups.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging tenants.\n");
tunnelId = 0;
count = 0;
while (ofdpaTunnelTenantNextGet(tunnelId, &tunnelId) == OFDPA_E_NONE)
{
if ((rc = ofdpaTunnelTenantDelete(tunnelId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaTunnelTenantDelete: rc = %d, tunnelId = %d\n",
rc, tunnelId);
}
}
if (count != 0)
{
printf("\tDeleted %d tenants.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging tunnel next hops.\n");
nextHopId = 0;
count = 0;
while (ofdpaTunnelNextHopNextGet(nextHopId, &nextHopId) == OFDPA_E_NONE)
{
if ((rc = ofdpaTunnelNextHopDelete(nextHopId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaTunnelNextHopDelete: rc = %d, nextHopId = %d\n",
rc, nextHopId);
}
}
if (count != 0)
{
printf("\tDeleted %d next hops.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging OAM Remote MP table.\n");
rmpId = 0;
count = 0;
while (ofdpaOamRemoteMpNextGet(rmpId, &rmpId) == OFDPA_E_NONE)
{
if ((rc = ofdpaOamRemoteMpDelete(rmpId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaOamRemoteMpDelete: rc = %d, rmpId = %d\n",
rc, rmpId);
}
}
if (count != 0)
{
printf("\tDeleted %d Remote MP entries.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging MLP Group table.\n");
mlpIndex = 0;
count = 0;
while (ofdpaOamMLPGroupNextGet(mlpIndex, &mlpIndex) == OFDPA_E_NONE)
{
lmepId = 0;
while (ofdpaOamMepProtectionNextGet(mlpIndex, lmepId, &lmepId) == OFDPA_E_NONE)
{
if ((rc = ofdpaOamMepProtectionRemove(mlpIndex, lmepId)) != OFDPA_E_NONE)
{
printf("\tError returned from ofdpaOamMepProtectionRemove: rc = %d, mlpIndex = %d, lmepId = %d\n",
rc, mlpIndex, lmepId);
}
}
if ((rc = ofdpaOamMLPGroupDelete(mlpIndex)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaOamMLPGroupDelete: rc = %d, mlpIndex = %d\n",
rc, mlpIndex);
}
}
if (count != 0)
{
printf("\tDeleted %d MLP Group entries.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging OAM MEP table.\n");
lmepId = 0;
count = 0;
while (ofdpaOamMepNextGet(lmepId, &lmepId) == OFDPA_E_NONE)
{
if ((rc = ofdpaOamMepDelete(lmepId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaOamMepDelete: rc = %d, lmepId = %d\n",
rc, lmepId);
}
}
if (count != 0)
{
printf("\tDeleted %d MEP entries.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging OAM MIP table.\n");
localMpId = 0;
count = 0;
while (ofdpaOamMipNextGet(localMpId, &localMpId) == OFDPA_E_NONE)
{
if ((rc = ofdpaOamMipDelete(localMpId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaOamMipDelete: rc = %d, localMpId = %d\n",
rc, localMpId);
}
}
if (count != 0)
{
printf("\tDeleted %d MIP entries.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging OAM MEG table.\n");
megIndex = 0;
count = 0;
while (ofdpaOamMegNextGet(megIndex, &megIndex) == OFDPA_E_NONE)
{
if ((rc = ofdpaOamMegDelete(megIndex)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaOamMegDelete: rc = %d, megIndex = %d\n",
rc, megIndex);
}
}
if (count != 0)
{
printf("\tDeleted %d MEG entries.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging Remark table.\n");
memset(&remarkEntry, 0, sizeof(remarkEntry));
count = 0;
while (ofdpaRemarkEntryNextGet(&remarkEntry, &remarkEntry) == OFDPA_E_NONE)
{
if ((rc = ofdpaRemarkActionDelete(&remarkEntry)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaRemarkActionDelete: rc = %d\n", rc);
}
}
if (count != 0)
{
printf("\tDeleted %d Remark entries.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging Drop Status table.\n");
memset(&dropEntry, 0, sizeof(dropEntry));
count = 0;
while (ofdpaDropStatusNextGet(0, &dropEntry) == OFDPA_E_NONE)
{
if ((rc = ofdpaDropStatusDelete(dropEntry.lmepId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaDropStatusDelete: rc = %d\n", rc);
}
}
if (count != 0)
{
printf("\tDeleted %d Drop entries.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging MPLS QoS table.\n");
memset(&mplsQosEntry, 0, sizeof(mplsQosEntry));
count = 0;
while (ofdpaMplsQosEntryNextGet(&mplsQosEntry, &mplsQosEntry) == OFDPA_E_NONE)
{
if ((rc = ofdpaMplsQosActionDelete(&mplsQosEntry)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaMplsQosActionDelete: rc = %d\n", rc);
}
}
if (count != 0)
{
printf("\tDeleted %d MPLS QoS entries.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging Meter table.\n");
meterId = 0;
count = 0;
while (ofdpaMeterNextGet(meterId, &meterId) == OFDPA_E_NONE)
{
if ((rc = ofdpaMeterDelete(meterId)) == OFDPA_E_NONE)
{
count++;
}
else
{
printf("\tError returned from ofdpaMeterDelete: rc = %d\n", rc);
}
}
if (count != 0)
{
printf("\tDeleted %d Meter entries.\n", count);
}
else
{
printf("\tNo entries found\n");
}
printf("Purging group table.\n");
count = 0;
do
{
memset(&group, 0, sizeof(group));
atLeastOneGroupEntryDeleted = 0;
while (ofdpaGroupNextGet(group.groupId, &group) == OFDPA_E_NONE)
{
if ((rc = ofdpaGroupDelete(group.groupId)) == OFDPA_E_NONE)
{
count++;
atLeastOneGroupEntryDeleted = 1;
}
}
} while (atLeastOneGroupEntryDeleted == 1);
if (count != 0)
{
printf("\tDeleted %d groups.\n", count);
}
else
{
printf("\tNo entries found\n");
}
/* retrieve all port events to allow logical ports to actually be deleted from database */
printf("Retrieving pending logical port delete events.\n");
memset(&portEventData, 0, sizeof(portEventData));
count = 0;
while (ofdpaPortEventNextGet(&portEventData) == OFDPA_E_NONE)
{
if (portEventData.eventMask & OFDPA_EVENT_PORT_DELETE)
{
count++;
}
}
if (count != 0)
{
printf("\tRetrieved %d port delete events.\n", count);
}
else
{
printf("\tNo events found\n");
}
return(0);
}
void
ind_ofdpa_port_event_receive(void)
{
of_port_desc_t *of_port_desc = 0;
of_port_status_t *of_port_status = 0;
ofdpaPortEvent_t portEventData;
int reason = 0;
LOG_TRACE("Reading Port Events");
memset(&portEventData, 0, sizeof(portEventData));
while (ofdpaPortEventNextGet(&portEventData) == OFDPA_E_NONE)
{
LOG_TRACE("client_event: retrieved port event: port no = %d, eventMask = 0x%x, state = %d\n",
portEventData.portNum, portEventData.eventMask, portEventData.state);
of_port_desc = of_port_desc_new(ofagent_of_version);
if (of_port_desc == 0)
{
LOG_ERROR("of_port_desc_new() failed");
break;
}
if ((ind_ofdpa_port_desc_set(portEventData.portNum, of_port_desc)) < 0)
{
LOG_ERROR("ind_ofdpa_port_desc_set() failed");
break;
}
of_port_status = of_port_status_new(ofagent_of_version);
if (of_port_status == 0)
{
LOG_ERROR("of_port_status_new() failed");
break;
}
if (portEventData.eventMask & OFDPA_EVENT_PORT_CREATE)
{
reason = OF_PORT_CHANGE_REASON_ADD;
}
else if (portEventData.eventMask & OFDPA_EVENT_PORT_DELETE)
{
reason = OF_PORT_CHANGE_REASON_DELETE;
}
else if (portEventData.eventMask & OFDPA_EVENT_PORT_STATE)
{
reason = OF_PORT_CHANGE_REASON_MODIFY;
}
of_port_status_reason_set(of_port_status, reason);
if (of_port_status_desc_set(of_port_status, of_port_desc) < 0) {
LOG_ERROR("Unexpected failure setting port desc");
break;
}
of_port_desc_delete(of_port_desc);
indigo_core_port_status_update(of_port_status);
of_port_desc = 0; /* No longer owned */
of_port_status = 0; /* No longer owned */
}
if (of_port_desc)
{
of_port_desc_delete(of_port_desc);
}
return;
}
