#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include "rpcclt_openapi.h"
#include "proc_util.h"
#define PRINTSANITYRESULTS(result, test, msg, feat) \
if (result==OPEN_E_UNAVAIL) { printf("Sanity test skipped.\n"); } \
else if ((result==OPEN_E_NONE) && (test)) { printf("Sanity Success - %s - %s.\n", msg, feat); } \
else { printf("Sanity Failure - %s - %s.\n", msg, feat); }
#define PRINTBADRESULT(result, msg) \
if (result==OPEN_E_UNAVAIL) { printf("Feature not supported - %s (err %d).\n", msg, result); } \
else if (result!=OPEN_E_NONE) { printf("Test Failure - %s (err %d).\n", msg, result); }
#define ACL_COUNTERS_ENABLE 1
#define ACL_COUNTERS_DISABLE 0
char *aclName,
uint32_t *aclId)
{
char str[32];
uint32_t tmp1, tmp2;
strcpy(str, aclName);
aclDesc.
size = strlen(str) + 1;
PRINTBADRESULT(result, "openapiAclCreate");
{
PRINTBADRESULT(result, "openapiAclGet");
}
PRINTSANITYRESULTS(result, tmp1==tmp2, __func__, "");
*aclId = tmp2;
return (result);
}
char *aclName,
char *aclRename)
{
char aclNameStr[32];
char aclRenameStr[32];
char aclTmpStr[32];
uint32_t aclId;
strcpy(aclNameStr, aclName);
aclNameDesc.pstart = aclNameStr;
aclNameDesc.size = strlen(aclNameStr)+1;
strcpy(aclRenameStr, aclRename);
aclRenameDesc.pstart = aclRenameStr;
aclRenameDesc.size = strlen(aclRenameStr)+1;
aclTmpDesc.pstart = aclTmpStr;
aclTmpDesc.size = sizeof(aclTmpStr)-1;
{
result =
openapiAclGet(clientHandle, aclType, &aclNameDesc, &aclId);
}
{
PRINTBADRESULT(result, "openapiAclNameGet");
}
{
PRINTBADRESULT(result, "openapiAclRename");
PRINTSANITYRESULTS(result, (result ==
OPEN_E_NONE),
"Renamed", (
char *)aclRenameDesc.pstart);
}
}
{
uint32_t aclId;
uint32_t iTmp;
uint32_t i;
aclId = 0;
PRINTBADRESULT(result, "openapiAclGetFirst - IP ACL");
PRINTSANITYRESULTS(result, (aclId>0),"openapiAclGetFirst", "IP ACL");
result = testAclCreate(clientHandle, aclType, "another_test_ip", &iTmp);
PRINTBADRESULT(result, "testAclCreate - temporary");
PRINTSANITYRESULTS(result, (iTmp>0), "testAclCreate", "temporary");
i = 0;
aclId = 0;
PRINTSANITYRESULTS(result, (i>1), __func__, "openapiAclGetNext");
{
}
}
uint32_t aclId)
{
uint32_t aclRule;
uint32_t iVal, iTmp;
bool bTmp;
{
aclRule = 0;
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchEveryAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchEveryGet");
PRINTSANITYRESULTS(result, true==bTmp, __func__, "Every");
}
}
{
{
PRINTBADRESULT(result, "openapiAclRuleMatchAssignQueueAdd");
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchAssignQueueGet");
PRINTSANITYRESULTS(result, iVal==iTmp, __func__, "Assign Queue");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchLoggingAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchLoggingGet");
PRINTSANITYRESULTS(result, true==bTmp, __func__, "Logging");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchSflowSamplingAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchSflowSamplingGet");
PRINTSANITYRESULTS(result, true==bTmp, __func__, "sflow-remote-agent");
}
}
{
uint32_t intf;
PRINTBADRESULT(result, "openapiIfFirstGet");
{
PRINTBADRESULT(result, "openapiAclRuleMatchMirrorAdd");
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchMirrorGet");
PRINTSANITYRESULTS(result, intf==iTmp, __func__, "Packet Mirroring Interface");
}
}
{
aclRule++;
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
char *ipStr = "10.10.10.1";
char *maskStr = "255.255.255.255";
char ipStrBuff[32];
char maskStrBuff[32];
memset(&ipAddr, 0, sizeof(ipAddr));
inet_pton(AF_INET, ipStr, &(ipAddr.
addr.
ipv4));
memset(&maskAddr, 0, sizeof(maskAddr));
inet_pton(AF_INET, maskStr, &(maskAddr.addr.ipv4));
ipAddr.addr.ipv4 = ntohl(ipAddr.addr.ipv4);
maskAddr.addr.ipv4 = ntohl(maskAddr.addr.ipv4);
PRINTBADRESULT(result, "openapiAclRuleMatchIpSrcMaskAdd");
memset(&ipAddr, 0, sizeof(ipAddr));
memset(&maskAddr, 0, sizeof(maskAddr));
PRINTBADRESULT(result, "openapiAclRuleMatchIpSrcMaskGet");
{
ipAddr.addr.ipv4 = htonl(ipAddr.addr.ipv4);
maskAddr.addr.ipv4 = htonl(maskAddr.addr.ipv4);
inet_ntop(AF_INET, &(ipAddr.addr.ipv4), ipStrBuff, sizeof(ipStrBuff));
inet_ntop(AF_INET, &(maskAddr.addr.ipv4), maskStrBuff, sizeof(maskStrBuff));
PRINTSANITYRESULTS(result,
((strcmp(ipStr, ipStrBuff) == 0) && (strcmp(maskStr, maskStrBuff) == 0)),
__func__, "Source IPv4 Address/Mask");
}
}
{
char *ipStr = "20.20.20.1";
char *maskStr = "255.0.0.0";
char ipStrBuff[32];
char maskStrBuff[32];
memset(&ipAddr, 0, sizeof(ipAddr));
inet_pton(AF_INET, ipStr, &(ipAddr.addr.ipv4));
memset(&maskAddr, 0, sizeof(maskAddr));
inet_pton(AF_INET, maskStr, &(maskAddr.addr.ipv4));
ipAddr.addr.ipv4 = ntohl(ipAddr.addr.ipv4);
maskAddr.addr.ipv4 = ntohl(maskAddr.addr.ipv4);
PRINTBADRESULT(result, "openapiAclRuleMatchIpDstMaskAdd");
memset(&ipAddr, 0, sizeof(ipAddr));
memset(&maskAddr, 0, sizeof(maskAddr));
PRINTBADRESULT(result, "openapiAclRuleMatchIpDstMaskGet");
{
ipAddr.addr.ipv4 = htonl(ipAddr.addr.ipv4);
maskAddr.addr.ipv4 = htonl(maskAddr.addr.ipv4);
inet_ntop(AF_INET, &(ipAddr.addr.ipv4), ipStrBuff, sizeof(ipStrBuff));
inet_ntop(AF_INET, &(maskAddr.addr.ipv4), maskStrBuff, sizeof(maskStrBuff));
PRINTSANITYRESULTS(result,
((strcmp(ipStr, ipStrBuff) == 0) && (strcmp(maskStr, maskStrBuff) == 0)),
__func__, "Destination IPv4 Address/Mask");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolGet");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchDscpAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchDscpGet");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchFragmentsAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchFragmentsGet");
PRINTSANITYRESULTS(result, true==bTmp, __func__, "IP Fragments");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchPrecedenceAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchPrecedenceGet");
PRINTSANITYRESULTS(result, 7==iTmp, __func__, "Precedence Value");
}
}
{
char tosValStr[32];
char tosMaskStr[32];
char tmpTosValStr[32];
char tmpTosMaskStr[32];
strcpy(tosValStr,"a0");
tosValDesc.pstart = tosValStr;
tosValDesc.size = strlen(tosValStr)+1;
strcpy(tosMaskStr,"a2");
tosMaskDesc.pstart = tosMaskStr;
tosMaskDesc.size = strlen(tosMaskStr)+1;
tmpTosValDesc.pstart = tmpTosValStr;
tmpTosValDesc.size = sizeof(tmpTosValDesc)-1;
tmpTosMaskDesc.pstart = tmpTosMaskStr;
tmpTosMaskDesc.size = sizeof(tmpTosMaskDesc)-1;
PRINTBADRESULT(result, "openapiAclRuleMatchTosAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchTosGet");
PRINTSANITYRESULTS(result,
((strcmp(tosValDesc.pstart,tmpTosValDesc.pstart)==0)&&
(strcmp(tosMaskDesc.pstart,tmpTosMaskDesc.pstart)==0)),
__func__, "ToS and Tos Mask Value");
}
}
{
uint32_t intf;
PRINTBADRESULT(result, "openapiIfFirstGet");
{
PRINTBADRESULT(result, "openapiAclRuleMatchRedirectAdd");
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchRedirectGet");
PRINTSANITYRESULTS(result, intf==iTmp, __func__, "Packet Redirection Interface");
}
}
{
aclRule++;
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolGet");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchRedirectAgentAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchRedirectAgentGet");
PRINTSANITYRESULTS(result, 100==iTmp, __func__, "Packet Redirect External Agent");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchRateLimitAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchRateLimitGet");
PRINTSANITYRESULTS(result, (4294967295UL==iVal&&128==iTmp), __func__, "Simple traffic rate-limit policing");
}
}
{
char timeStr[32];
char tmpStr[32];
strcpy(timeStr, "ipv4-time-range-name");
timeDesc.pstart = timeStr;
timeDesc.size = strlen(timeStr) + 1;
tmpTimeDesc.pstart = timeStr;
tmpTimeDesc.size = sizeof(tmpStr)-1;
PRINTBADRESULT(result, "openapiAclRuleMatchTimeRangeAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchTimeRangeGet");
PRINTSANITYRESULTS(result, (strcmp(timeDesc.pstart,tmpTimeDesc.pstart)==0), __func__, "Time based activation");
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchTimeRangeStatusGet");
PRINTSANITYRESULTS(result, (status==status), __func__, "Time Range status");
}
}
{
aclRule++;
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolGet");
}
}
{
uint32_t ECHO_TYPE = 8;
uint32_t ECHO_CODE = 0;
bool addCode = true;
uint32_t tmpType;
uint32_t tmpCode;
PRINTBADRESULT(result, "openapiAclRuleMatchIcmpTypeCodeAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchIcmpTypeCodeGet");
PRINTSANITYRESULTS(result, (ECHO_TYPE==tmpType&&ECHO_CODE==tmpCode), __func__, "ICMP messaging for 'Echo'");
}
}
{
aclRule++;
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolGet");
}
}
{
uint32_t TRACE_TYPE = 30;
uint32_t tmpType;
PRINTBADRESULT(result, "openapiAclRuleMatchIgmpTypeAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchIgmpTypeGet");
PRINTSANITYRESULTS(result, (TRACE_TYPE==tmpType), __func__, "IGMP messaging for 'Multicast Traceroute'");
}
}
{
aclRule++;
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolGet");
}
}
{
uint32_t flagVal=0, flagMask=0;
uint32_t tmpVal, tmpMask;
PRINTBADRESULT(result, "openapiAclRuleMatchTcpFlagsAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchTcpFlagsGet");
PRINTSANITYRESULTS(result, ((flagVal==tmpVal)&&(flagMask==tmpMask)), __func__, "Miscellaneous TCP Flags test");
}
}
{
uint32_t tmpStartPort;
uint32_t tmpEndPort;
PRINTBADRESULT(result, "openapiAclRuleMatchL4SrcPortAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchL4SrcPortGet");
}
}
{
aclRule++;
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolGet");
}
}
{
uint32_t tmpStartPort;
uint32_t tmpEndPort;
PRINTBADRESULT(result, "openapiAclRuleMatchL4SrcPortAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchL4SrcPortGet");
}
}
{
uint32_t tmpStartPort;
uint32_t tmpEndPort;
PRINTBADRESULT(result, "openapiAclRuleMatchL4DstPortAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchL4DstPortGet");
}
}
{
aclRule = 0;
PRINTBADRESULT(result, "openapiAclRuleActionAdd - DENY");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - DENY");
PRINTSANITYRESULTS(result,
OPEN_ACL_DENY==iTmp, __func__,
"DENY");
}
}
}
uint32_t aclId)
{
uint32_t aclRule;
uint32_t iVal, iTmp;
bool bTmp;
{
aclRule = 0;
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchEveryAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchEveryGet");
PRINTSANITYRESULTS(result, true==bTmp, __func__, "Every");
}
}
{
{
PRINTBADRESULT(result, "openapiAclRuleMatchAssignQueueAdd");
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchAssignQueueGet");
PRINTSANITYRESULTS(result, iVal==iTmp, __func__, "Assign Queue");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchLoggingAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchLoggingGet");
PRINTSANITYRESULTS(result, true==bTmp, __func__, "Logging");
}
}
{
uint32_t intf;
PRINTBADRESULT(result, "openapiIfFirstGet");
{
PRINTBADRESULT(result, "openapiAclRuleMatchMirrorAdd");
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchMirrorGet");
PRINTSANITYRESULTS(result, intf==iTmp, __func__, "Packet Mirroring Interface");
}
}
{
aclRule++;
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolGet");
}
}
{
char *ipStr = "1001::";
uint32_t pfxLen = 24;
uint32_t tmpPfxLen;
char ipStrBuff[64];
memset(&ipAddr, 0, sizeof(ipAddr));
inet_pton(AF_INET6, ipStr, &(ipAddr.addr.
ipv6));
PRINTBADRESULT(result, "openapiAclRuleMatchIpv6SrcPfxAdd");
{
memset(&tmpIpAddr, 0, sizeof(tmpIpAddr));
tmpPfxLen = 0;
PRINTBADRESULT(result, "openapiAclRuleMatchIpv6SrcPfxGet");
{
inet_ntop(AF_INET6, &(tmpIpAddr.addr.ipv6), ipStrBuff, sizeof(ipStrBuff));
PRINTSANITYRESULTS(result,
((strcmp(ipStr, ipStrBuff) == 0) && (pfxLen == tmpPfxLen)),
__func__, "Source IPv6 Address/prefix");
}
}
}
{
char *ipStr = "2001::";
uint32_t pfxLen = 24;
uint32_t tmpPfxLen;
char ipStrBuff[64];
memset(&ipAddr, 0, sizeof(ipAddr));
inet_pton(AF_INET6, ipStr, &(ipAddr.addr.ipv6));
PRINTBADRESULT(result, "openapiAclRuleMatchIpv6DstPfxAdd");
{
memset(&tmpIpAddr, 0, sizeof(tmpIpAddr));
tmpPfxLen = 0;
PRINTBADRESULT(result, "openapiAclRuleMatchIpv6DstPfxGet");
{
inet_ntop(AF_INET6, &(tmpIpAddr.addr.ipv6), ipStrBuff, sizeof(ipStrBuff));
PRINTSANITYRESULTS(result,
((strcmp(ipStr, ipStrBuff) == 0) && (pfxLen == tmpPfxLen)),
__func__, "Destination IPv6 Address/prefix");
}
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchDscpAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchDscpGet");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchFragmentsAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchFragmentsGet");
PRINTSANITYRESULTS(result, true==bTmp, __func__, "IP Fragments");
}
}
{
uint32_t intf;
PRINTBADRESULT(result, "openapiIfFirstGet");
{
PRINTBADRESULT(result, "openapiAclRuleMatchRedirectAdd");
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchRedirectGet");
PRINTSANITYRESULTS(result, intf==iTmp, __func__, "Packet Redirection Interface");
}
}
{
aclRule++;
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolGet");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchRedirectAgentAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchRedirectAgentGet");
PRINTSANITYRESULTS(result, 100==iTmp, __func__, "Packet Redirect External Agent");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchRateLimitAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchRateLimitGet");
PRINTSANITYRESULTS(result, (4294967295UL==iVal&&128==iTmp), __func__, "Simple traffic rate-limit policing");
}
}
{
char timeStr[32];
char tmpStr[32];
strcpy(timeStr, "ipv6-time-range-name");
timeDesc.pstart = timeStr;
timeDesc.size = strlen(timeStr) + 1;
tmpTimeDesc.pstart = tmpStr;
tmpTimeDesc.size = sizeof(tmpStr);
PRINTBADRESULT(result, "openapiAclRuleMatchTimeRangeAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchTimeRangeGet");
PRINTSANITYRESULTS(result, (strcmp(timeDesc.pstart, tmpTimeDesc.pstart) == 0), __func__, "Time based activation");
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchTimeRangeStatusGet");
PRINTSANITYRESULTS(result,
OPEN_TRUE, __func__,
"Time Range status");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchFlowLabelAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchFlowLabelGet");
PRINTSANITYRESULTS(result, (1048575==iTmp), __func__, "Flow Label");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchRoutingAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchRoutingGet");
PRINTSANITYRESULTS(result, (true==bTmp), __func__, "Routing Flag");
}
}
{
aclRule++;
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolGet");
}
}
{
uint32_t UNREACH_TYPE = 1;
uint32_t UNREACH_CODE = 4;
bool addCode = true;
uint32_t tmpType;
uint32_t tmpCode;
PRINTBADRESULT(result, "openapiAclRuleMatchIcmpTypeCodeAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchIcmpTypeCodeGet");
PRINTSANITYRESULTS(result, (UNREACH_TYPE==tmpType&&UNREACH_CODE==tmpCode), __func__, "ICMPv6 messaging for 'Port-Unreachable'");
}
}
{
aclRule++;
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolGet");
}
}
{
uint32_t flagVal=0, flagMask=0;
uint32_t tmpVal, tmpMask;
PRINTBADRESULT(result, "openapiAclRuleMatchTcpFlagsAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchTcpFlagsGet");
PRINTSANITYRESULTS(result, ((flagVal==tmpVal)&&(flagMask==tmpMask)), __func__, "Miscellaneous TCP Flags test");
}
}
{
uint32_t tmpStartPort;
uint32_t tmpEndPort;
PRINTBADRESULT(result, "openapiAclRuleMatchL4SrcPortAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchL4SrcPortGet");
PRINTSANITYRESULTS(result,
__func__,
"Source Layer 4 port range 20000 - 20010");
}
}
{
uint32_t tmpStartPort;
uint32_t tmpEndPort;
PRINTBADRESULT(result, "openapiAclRuleMatchL4DstPortAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchL4DstPortGet");
}
}
{
aclRule = 0;
PRINTBADRESULT(result, "openapiAclRuleActionAdd - DENY");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - DENY");
PRINTSANITYRESULTS(result,
OPEN_ACL_DENY==iTmp, __func__,
"DENY");
}
}
}
uint32_t aclId)
{
uint32_t aclRule;
uint32_t iVal, iTmp;
bool bTmp;
{
aclRule = 0;
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchEveryAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchEveryGet");
PRINTSANITYRESULTS(result, true==bTmp, __func__, "Every");
}
}
{
{
PRINTBADRESULT(result, "openapiAclRuleMatchAssignQueueAdd");
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchAssignQueueGet");
PRINTSANITYRESULTS(result, iVal==iTmp, __func__, "Assign Queue");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchLoggingAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchLoggingGet");
PRINTSANITYRESULTS(result, true==bTmp, __func__, "Logging");
}
}
{
uint32_t intf;
PRINTBADRESULT(result, "openapiIfFirstGet");
{
PRINTBADRESULT(result, "openapiAclRuleMatchMirrorAdd");
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchMirrorGet");
PRINTSANITYRESULTS(result, intf==iTmp, __func__, "Packet Mirroring Interface");
}
}
{
aclRule++;
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
char macStr[18];
char maskStr[18];
char tmpMacStr[18];
char tmpMaskStr[18];
strcpy(macStr, "00:11:22:33:44:55");
strcpy(maskStr, "ff:ff:ff:00:00:00");
macDesc.pstart = macStr;
macDesc.size = strlen(macStr)+1;
maskDesc.pstart = maskStr;
maskDesc.size = strlen(maskStr)+1;
tmpMacDesc.pstart = tmpMacStr;
tmpMacDesc.size = sizeof(tmpMacStr);
tmpMaskDesc.pstart = tmpMaskStr;
tmpMaskDesc.size = sizeof(tmpMaskStr);
PRINTBADRESULT(result, "openapiAclRuleMatchMacSrcMacAdd");
PRINTBADRESULT(result, "openapiAclRuleMatchMacSrcMacGet");
{
PRINTSANITYRESULTS(result,
((strcmp(macDesc.pstart,tmpMacDesc.pstart)==0)&&(strcmp(maskDesc.pstart,tmpMaskDesc.pstart)==0)),
__func__, "Source MAC Address/Mask");
}
}
{
char macStr[18];
char maskStr[18];
char tmpMacStr[18];
char tmpMaskStr[18];
strcpy(macStr, "55:44:33:22:11:00");
strcpy(maskStr, "00:00:00:ff:ff:ff");
macDesc.pstart = macStr;
macDesc.size = strlen(macStr)+1;
maskDesc.pstart = maskStr;
maskDesc.size = strlen(maskStr)+1;
tmpMacDesc.pstart = tmpMacStr;
tmpMacDesc.size = sizeof(tmpMacStr);
tmpMaskDesc.pstart = tmpMaskStr;
tmpMaskDesc.size = sizeof(tmpMaskStr);
PRINTBADRESULT(result, "openapiAclRuleMatchMacDstMacAdd");
PRINTBADRESULT(result, "openapiAclRuleMatchMacDstMacGet");
{
PRINTSANITYRESULTS(result,
((strcmp(macDesc.pstart,tmpMacDesc.pstart)==0)&&(strcmp(maskDesc.pstart,tmpMaskDesc.pstart)==0)),
__func__, "Destination MAC Address/Mask");
}
}
{
uint32_t intf;
PRINTBADRESULT(result, "openapiIfFirstGet");
{
PRINTBADRESULT(result, "openapiAclRuleMatchRedirectAdd");
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchRedirectGet");
PRINTSANITYRESULTS(result, intf==iTmp, __func__, "Packet Redirection Interface");
}
}
{
aclRule++;
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchRedirectAgentAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchRedirectAgentGet");
PRINTSANITYRESULTS(result, 100==iTmp, __func__, "Packet Redirect External Agent");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchRateLimitAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchRateLimitGet");
PRINTSANITYRESULTS(result, (4294967295UL==iVal&&128==iTmp), __func__, "Simple traffic rate-limit policing");
}
}
{
char timeStr[32];
char tmpStr[32];
strcpy(timeStr, "mac-time-range-name");
timeDesc.pstart = timeStr;
timeDesc.size = strlen(timeStr) + 1;
tmpTimeDesc.pstart = timeStr;
tmpTimeDesc.size = sizeof(tmpStr)-1;
PRINTBADRESULT(result, "openapiAclRuleMatchTimeRangeAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchTimeRangeGet");
PRINTSANITYRESULTS(result, (strcmp(timeDesc.pstart,tmpTimeDesc.pstart)==0), __func__, "Time based activation");
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchTimeRangeStatusGet");
PRINTSANITYRESULTS(result, (status==status), __func__, "Time Range status");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchMacEtherTypeAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchMacEtherTypeGet");
PRINTSANITYRESULTS(result, (0x809B==iTmp), __func__, "Ethertype 0x809B");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchMacCosAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchMacCosGet");
PRINTSANITYRESULTS(result, (0==iTmp), __func__, "CoS 0");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchMacCos2Add");
{
PRINTBADRESULT(result, "openapiAclRuleMatchMacCos2Get");
PRINTSANITYRESULTS(result, (7==iTmp), __func__, "Secondary CoS 7");
}
}
{
uint32_t start = 2;
uint32_t end = 100;
uint32_t tStart;
uint32_t tEnd;
PRINTBADRESULT(result, "openapiAclRuleMatchMacVlanAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchMacVlanGet");
PRINTSANITYRESULTS(result, ((oper==tOper)&&(start==tStart)&&(end==tEnd)), __func__, "VLAN ID Range 2 - 100");
}
}
{
uint32_t start = 200;
uint32_t end = 0;
uint32_t tStart;
uint32_t tEnd;
PRINTBADRESULT(result, "openapiAclRuleMatchMacSecondaryVlanAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchMacSecondaryVlanGet");
PRINTSANITYRESULTS(result, ((oper==tOper)&&(start==tStart)), __func__, "Secondary VLAN ID 200");
}
}
{
aclRule = 0;
PRINTBADRESULT(result, "openapiAclRuleActionAdd - DENY");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - DENY");
PRINTSANITYRESULTS(result,
OPEN_ACL_DENY==iTmp, __func__,
"DENY");
}
}
}
char *aclName,
uint32_t intf,
uint32_t seqNum)
{
char aclNameStr[32];
char str[256];
uint32_t aclId;
strcpy(aclNameStr, aclName);
aclNameDesc.pstart = aclNameStr;
aclNameDesc.size = strlen(aclNameStr)+1;
{
result =
openapiAclGet(clientHandle, aclType, &aclNameDesc, &aclId);
PRINTBADRESULT(result, "openapiAclGet");
}
{
PRINTBADRESULT(result, "openapiAclIntfDirAdd");
sprintf(str, "ACL:%s intf:%d dir:%d seq:%d", (char *)aclNameDesc.pstart, intf, dir, seqNum);
PRINTSANITYRESULTS(result, result==
OPEN_E_NONE, __func__, str);
}
}
char *aclName,
uint32_t vlan,
uint32_t seqNum)
{
char aclNameStr[32];
char str[256];
uint32_t aclId;
strcpy(aclNameStr, aclName);
aclNameDesc.pstart = aclNameStr;
aclNameDesc.size = strlen(aclNameStr)+1;
{
result =
openapiAclGet(clientHandle, aclType, &aclNameDesc, &aclId);
PRINTBADRESULT(result, "openapiAclGet");
}
{
PRINTBADRESULT(result, "openapiAclVlanDirAdd");
sprintf(str, "ACL:%s VLAN:%d dir:%d seq:%d", (char *)aclNameDesc.pstart, vlan, dir, seqNum);
PRINTSANITYRESULTS(result, result==
OPEN_E_NONE, __func__, str);
}
}
char *aclName,
uint32_t intf,
{
char aclNameStr[32];
uint32_t aclId;
strcpy(aclNameStr, aclName);
aclNameDesc.pstart = aclNameStr;
aclNameDesc.size = strlen(aclNameStr)+1;
{
result =
openapiAclGet(clientHandle, aclType, &aclNameDesc, &aclId);
PRINTBADRESULT(result, "openapiAclGet");
}
{
PRINTBADRESULT(result, "openapiAclIntfDirDelete");
}
}
char *aclName,
uint32_t vlan,
{
char aclNameStr[32];
uint32_t aclId;
strcpy(aclNameStr, aclName);
aclNameDesc.pstart = aclNameStr;
aclNameDesc.size = strlen(aclNameStr)+1;
{
result =
openapiAclGet(clientHandle, aclType, &aclNameDesc, &aclId);
PRINTBADRESULT(result, "openapiAclGet");
}
{
PRINTBADRESULT(result, "openapiAclVlanDirDelete");
}
}
{
{
printf ("Unable to enable ACL counter mode\n");
}
else
{
printf ("Successfully enabled ACL counter mode\n");
}
printf ("Disable ACL counter mode ...\n");
{
printf ("Unable to disable ACL counter mode\n");
}
else
{
printf ("Successfully disabled ACL counter mode\n");
}
}
char *aclName,
uint32_t seqNum)
{
char aclNameStr[32];
char str[256];
uint32_t aclId;
uint32_t aclRule;
int asic = 0;
uint64_t hitPktCount = 0;
uint32_t nextRule;
strcpy(aclNameStr, aclName);
aclNameDesc.pstart = aclNameStr;
aclNameDesc.size = strlen(aclNameStr)+1;
PRINTBADRESULT(result, "openapiAclCountersAdminModeSet");
{
result =
openapiAclGet(clientHandle, aclType, &aclNameDesc, &aclId);
PRINTBADRESULT(result, "openapiAclGet");
}
{
PRINTBADRESULT(result, "openapiAclRuleGlobalApply");
sprintf(str, "ACL:%s seq:%d apply on all interfaces ", (char *)aclNameDesc.pstart, seqNum);
PRINTSANITYRESULTS(result, result==
OPEN_E_NONE, __func__, str);
}
{
{
if (aclRule != 0)
{
{
aclRule = nextRule;
}
}
}
if (0 == aclRule)
{
}
}
{
sprintf(str, "ACL:%s Get counters for rule %d", (char *)aclNameDesc.pstart, aclRule);
PRINTSANITYRESULTS(result, result==
OPEN_E_NONE, __func__, str);
}
{
sprintf(str, "ACL:%s Clear counters for rule %d", (char *)aclNameDesc.pstart, aclRule);
PRINTSANITYRESULTS(result, result==
OPEN_E_NONE, __func__, str);
}
{
sprintf(str, "ACL:%s Delete ACL rule %d", (char *)aclNameDesc.pstart, aclRule);
PRINTSANITYRESULTS(result, result==
OPEN_E_NONE, __func__, str);
}
{
PRINTBADRESULT(result, "openapiAclGlobalDelete");
sprintf(str, "ACL:%s delete on all interfaces", (char *)aclNameDesc.pstart);
PRINTSANITYRESULTS(result, result==
OPEN_E_NONE, __func__, str);
}
}
{
uint32_t intf = 0;
printf ("\nACL interface direction assignments");
printf ("\nInterface Direction");
printf ("\n--------- ---------");
{
{
{
}
}
}
}
uint32_t intf,
{
uint32_t idx;
{
printf (
"\n\nACL Interface %d, %s details", intf, (dir==
OPEN_ACL_INBOUND_ACL) ?
"Inbound" :
"Outbound");
printf ("\nACL id Type Seq Num");
printf ("\n------ ---- -------");
for (idx = 0; idx < listInfo.
count; idx++)
{
printf("\n%6d %4d %7d",
}
}
}
uint32_t vlan,
{
uint32_t idx;
{
printf ("\nACL id Type Seq Num");
printf ("\n------ ---- -------");
for (idx = 0; idx < listInfo.
count; idx++)
{
printf("\n%6d %4d %7d",
}
}
}
char *aclName,
{
char aclNameStr[32];
uint32_t aclId;
uint32_t idx;
strcpy(aclNameStr, aclName);
aclNameDesc.pstart = aclNameStr;
aclNameDesc.size = strlen(aclNameStr)+1;
{
result =
openapiAclGet(clientHandle, aclType, &aclNameDesc, &aclId);
PRINTBADRESULT(result, "openapiAclGet");
}
{
printf ("\nInterface");
printf ("\n---------");
for (idx = 0; idx < intfList.
count; idx++)
{
printf(
"\n%d", intfList.
intf[idx]);
}
}
}
char *aclName,
{
char aclNameStr[32];
uint32_t aclId;
uint32_t idx;
strcpy(aclNameStr, aclName);
aclNameDesc.pstart = aclNameStr;
aclNameDesc.size = strlen(aclNameStr)+1;
{
result =
openapiAclGet(clientHandle, aclType, &aclNameDesc, &aclId);
PRINTBADRESULT(result, "openapiAclGet");
}
{
printf ("\nVLAN");
printf ("\n---");
for (idx = 0; idx < vlanList.
count; idx++)
{
printf(
"\n%d", vlanList.
vlan[idx]);
}
}
}
char *aclName)
{
char aclNameStr[32];
uint32_t aclId;
uint32_t routePrefix = 0;
uint32_t routeMask = 0;
char *routePrefixStr = "10.10.10.1";
char *routeMaskStr = "0.0.0.0";
strcpy(aclNameStr, aclName);
aclNameDesc.pstart = aclNameStr;
aclNameDesc.size = strlen(aclNameStr)+1;
{
result =
openapiAclGet(clientHandle, aclType, &aclNameDesc, &aclId);
PRINTBADRESULT(result, "openapiAclGet");
}
inet_pton(AF_INET, routePrefixStr, &routePrefix);
inet_pton(AF_INET, routeMaskStr, &routeMask);
routePrefix = ntohl(routePrefix);
routeMask = ntohl(routeMask);
{
PRINTBADRESULT(result, "openapiAclRouteFilter - PERMIT");
PRINTSANITYRESULTS(result,
OPEN_ACL_PERMIT==aclAction, __func__,
"PERMIT");
}
}
{
char str[256];
uint32_t tmp;
printf("\n\n");
PRINTBADRESULT(result, "openapiCpuIntfGet");
sprintf(str, "CPU Control Plane Interface ... %d", tmp);
PRINTSANITYRESULTS(result, (1==1), "openapiCpuIntfGet", str);
PRINTBADRESULT(result, "openapiAclMaxAclIntfCountGet");
sprintf(str, "Number of allowed ACL Interfaces ... %d", tmp);
PRINTSANITYRESULTS(result, (1==1), "openapiAclMaxAclIntfCountGet", str);
PRINTBADRESULT(result, "openapiAclMaxAclVlanCountGet");
sprintf(str, "Number of allowed ACL VLANs ... %d", tmp);
PRINTSANITYRESULTS(result, (1==1), "openapiAclMaxAclVlanCountGet", str);
PRINTBADRESULT(result, "openapiAclCountGet");
sprintf(str, "Total number of configured ACLs ... %d", tmp);
PRINTSANITYRESULTS(result, (1==1), "openapiAclCountGet", str);
PRINTBADRESULT(result, "openapiAclMacCountGet");
sprintf(str, "Number of configured MAC ACLs ... %d", tmp);
PRINTSANITYRESULTS(result, (1==1), "openapiAclMacCountGet", str);
}
int main (int argc, char **argv)
{
uint32_t aclId = 0;
l7proc_crashlog_register();
if ((result =
{
printf ("\nFailed to initialize RPC to OpEN. Exiting (result = %d)\n", result);
exit (2);
}
{
sleep (1);
}
L7PROC_LOGF (L7PROC_LOG_SEVERITY_INFO, 0, "Starting ACL API example application");
printf ("\n");
printf ("Begin Sanity tests...\n");
printf ("Create named IP ACL...\n");
{
testAclAddIpRules(&clientHandle, aclId);
}
printf ("Create named IPv6 ACL...\n");
{
testAclAddIpv6Rules(&clientHandle, aclId);
}
printf ("Create named MAC ACL...\n");
{
testAclAddMacRules(&clientHandle, aclId);
}
printf ("Perform some generic retrieval tests...\n");
testAclRetrieval(&clientHandle);
printf ("Rename then Delete ACLs...\n");
printf ("Demonstrate traffic filter assignment for interfaces...\n");
printf ("Demonstrate traffic filter assignment for VLANs...\n");
printf ("Demonstrate traffic filter removal of interface...\n");
printf ("Demonstrate traffic filter removal of VLAN...\n");
printf ("Demonstrate route filter...\n");
printf ("Enable ACL counter mode ...\n");
testAclCountersAdminModeSet(&clientHandle);
printf ("Test ACL add & remove on all interfaces, stats get & clear and deleting of ACL rule...\n");
testAclStatsAndGlobalAddRemove(&clientHandle,
OPEN_ACL_TYPE_IP,
"test_ip_renamed", 900);
printf ("Display various ACL lists and information...\n");
testAclShowDirectionInterfaces(&clientHandle);
testAclShowSummary(&clientHandle);
printf ("\nComplete.\n");
L7PROC_LOGF (L7PROC_LOG_SEVERITY_INFO, 0, "Stopping ACL API example application");
return 0;
}