#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include "rpcclt_openapi.h"
#include "proc_util.h"
#define REDIRECT_NOT_MIRROR 0
#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 TCAM_MAX_STR_LENGTH 256
#define MACADDR_STR_LEN 18
#define PKT_SIZE 96
int isprint ( int c );
{
uint32_t value, tst[6];
value = sscanf(macStr, "%x:%x:%x:%x:%x:%x",
&tst[0], &tst[1], &tst[2], &tst[3], &tst[4], &tst[5]);
if (6 == value)
{
for (value = 0; value < 6; value++)
{
if (tst[value] > 255)
{
break;
}
}
}
return result;
}
void pktCapPktDump(char *pkt, uint32_t len)
{
int row, column;
char c, buf[100];
uint32_t row_count, temp_len;
printf("======================================\n");
if (len < PKT_SIZE)
{
temp_len = len;
}
else
{
temp_len = PKT_SIZE;
}
row_count = temp_len / 16;
if (temp_len % 16)
{
row_count++;
}
for (row = 0; row < row_count; row++)
{
buf[0] = 0;
sprintf(&buf[strlen(buf)], "%02x ", row * 16);
for (column = 0; (column < 8) && ((row * 16 + column) < temp_len); column++)
{
sprintf(&buf[strlen(buf)], "%2.2x ", pkt[row * 16 + column]);
}
sprintf(&buf[strlen(buf)], " ");
for ( ; (column < 16) && ((row * 16 + column) < temp_len); column++)
{
sprintf(&buf[strlen(buf)], "%2.2x ", pkt[row * 16 + column]);
}
for ( ; column < 16; column++)
{
strcat(buf, " ");
}
sprintf(&buf[strlen(buf)], " ");
for (column = 0; (column < 16) && ((row * 16 + column) < temp_len); column++)
{
c = pkt[row * 16 + column];
if (isprint(c))
{
sprintf(&buf[strlen(buf)], "%c", c);
}
else
{
sprintf(&buf[strlen(buf)], ".");
}
}
printf("%s\n", buf);
}
printf("======================================\n");
}
void pktCapAclReceivePackets(uint32_t agentNum, uint32_t packetCount)
{
uint32_t pktCount, offset, bytesRcvd;
int sockfd = -1;
int maxfd, stdinfd, fd;
char agentName[] = "Test Agent";
fd_set readfds, masterfds;
struct timeval timeout;
int timed;
agentNameBuff.
pstart = agentName;
agentNameBuff.
size =
sizeof(agentName);
{
printf("Failed to register as rx agent: %d\n", rc);
return;
}
if (l7proc_extagentpkt_rxsockcreate(agentNum, &sockfd) != 0)
{
return;
}
printf("Waiting for packets. Press 'q'+<cr> to quit ...\n");
sleep(1);
pktCount = 0;
while (pktCount < packetCount)
{
memset(buffer, 0, sizeof(buffer));
timeout.tv_sec = 100;
timeout.tv_usec = 0;
FD_ZERO(&masterfds);
FD_SET(sockfd, &masterfds);
maxfd = stdinfd = fileno(stdin);
FD_SET(stdinfd, &masterfds);
if (sockfd > maxfd)
{
maxfd = sockfd;
}
memcpy(&readfds, &masterfds, sizeof(fd_set));
timed = 1;
if (select(maxfd+1, &readfds, NULL, NULL, &timeout) < 0)
{
if (EINTR == errno)
{
continue;
}
perror("on select");
exit(1);
}
for (fd = 0; fd <= maxfd; fd++)
{
if (FD_ISSET(fd, &readfds))
{
if (fd == stdinfd)
{
timed = 0;
fgets((char *)buffer, sizeof(buffer), stdin);
if ('q' == buffer[0])
{
printf(" Quit!\n");
pktCount = packetCount;
break;
}
}
else if (fd == sockfd)
{
timed = 0;
do
{
bytesRcvd = recvfrom(sockfd, buffer, sizeof(buffer), 0, 0, 0);
} while ((bytesRcvd < 0) && (EINTR == errno));
if (bytesRcvd <= 0)
{
continue;
}
pktCount++;
printf("Packet %d Received from ifNum %d, pktLen %d\n",
pktCount, pktDesc->
rxIfNum, pktDesc->
pktLength);
offset = pktDesc->
descLen;
pktCapPktDump((char *)&buffer[offset], pktDesc->pktLength);
}
else
{
printf("Unknown FD\n\n");
}
}
}
if (timed)
{
printf("Timeout\n");
pktCount = packetCount;
break;
}
}
l7proc_extagentpkt_rxsockclose(agentNum, sockfd);
exit(0);
return;
}
char *aclName, uint32_t *aclId)
{
char str[32];
uint32_t tmp1, tmp2;
strcpy(str, aclName);
aclDesc.pstart = str;
aclDesc.size = strlen(str) + 1;
PRINTBADRESULT(result, "openapiAclCreate");
{
PRINTBADRESULT(result, "openapiAclGet");
}
PRINTSANITYRESULTS(result, tmp1==tmp2, __func__, "");
*aclId = tmp2;
return (result);
}
uint32_t agentCookie, uint32_t aclId,
char *macStr, char *macMaskStr,
uint32_t isSrcRule, uint32_t *aclRule)
{
uint32_t temp;
char buff[80];
char tmpMacStr[MACADDR_STR_LEN];
char tmpMaskStr[MACADDR_STR_LEN];
macDesc.pstart = macStr;
macDesc.size = strlen(macStr)+1;
macMaskDesc.pstart = macMaskStr;
macMaskDesc.size = strlen(macMaskStr)+1;
if (0 == *aclRule)
{
{
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
}
if (isSrcRule)
{
PRINTBADRESULT(result, "openapiAclRuleMatchMacSrcMacAdd");
memset(&tmpMacStr, 0, MACADDR_STR_LEN);
memset(&tmpMaskStr, 0, MACADDR_STR_LEN);
macDesc.pstart = tmpMacStr;
macDesc.size = MACADDR_STR_LEN;
macMaskDesc.pstart = tmpMaskStr;
macMaskDesc.size = MACADDR_STR_LEN;
PRINTBADRESULT(result, "openapiAclRuleMatchMacSrcMacGet");
{
PRINTSANITYRESULTS(result,
((strcmp(macDesc.pstart, macStr) == 0) &&
(strcmp(macMaskDesc.pstart, macMaskStr) == 0)),
__func__, "Source MAC Address/Mask");
printf("Source MAC Address/Mask: %s/%s\n", macStr, macMaskStr);
}
}
else
{
PRINTBADRESULT(result, "openapiAclRuleMatchMacDstMacAdd");
memset(&tmpMacStr, 0, MACADDR_STR_LEN);
memset(&tmpMaskStr, 0, MACADDR_STR_LEN);
macDesc.pstart = tmpMacStr;
macDesc.size = MACADDR_STR_LEN;
macMaskDesc.pstart = tmpMaskStr;
macMaskDesc.size = MACADDR_STR_LEN;
PRINTBADRESULT(result, "openapiAclRuleMatchMacDstMacGet");
{
PRINTSANITYRESULTS(result,
((strcmp(macDesc.pstart, macStr) == 0) &&
(strcmp(macMaskDesc.pstart, macMaskStr) == 0)),
__func__, "Destination MAC Address/Mask");
printf("Destination MAC Address/Mask: %s/%s\n", macStr, macMaskStr);
}
}
{
#if REDIRECT_NOT_MIRROR
PRINTBADRESULT(result, "openapiAclRuleMatchRedirectAgentAdd");
#else
PRINTBADRESULT(result, "openapiAclRuleMatchMirrorAgentAdd");
#endif
{
#if REDIRECT_NOT_MIRROR
PRINTBADRESULT(result, "openapiAclRuleMatchRedirectGet");
sprintf(buff, "Packet Redirect to Extenal Agent: %d", temp);
#else
PRINTBADRESULT(result, "openapiAclRuleMatchMirrorAgentGet");
sprintf(buff, "Packet Mirror to Extenal Agent: %d", temp);
#endif
}
{
PRINTSANITYRESULTS(result, (agentCookie == temp), __func__, buff);
}
}
return result;
}
uint32_t agentCookie, uint32_t aclId,
uint32_t isSrcRule, uint32_t *aclRule)
{
uint32_t temp;
char buff[80];
if (0 == *aclRule)
{
{
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolGet");
}
}
}
if (isSrcRule)
{
PRINTBADRESULT(result, "openapiAclRuleMatchIpSrcMaskAdd");
memset(&ipAddr, 0, sizeof(ipAddr));
memset(&maskAddr, 0, sizeof(maskAddr));
PRINTBADRESULT(result, "openapiAclRuleMatchIpSrcMaskGet");
{
char ipDescStr[32];
char maskDescStr[32];
ipDesc.pstart = ipDescStr;
ipDesc.size = sizeof(ipDescStr)-1;
maskDesc.pstart = maskDescStr;
maskDesc.size = sizeof(maskDescStr)-1;
printf("Source IPv4 Address/Mask: %s/%s\n", (char *)ipDesc.pstart, (char *)maskDesc.pstart);
}
}
else
{
PRINTBADRESULT(result, "openapiAclRuleMatchIpDstMaskAdd");
memset(&ipAddr, 0, sizeof(ipAddr));
memset(&maskAddr, 0, sizeof(maskAddr));
PRINTBADRESULT(result, "openapiAclRuleMatchIpDstMaskGet");
{
char ipDescStr[32];
char maskDescStr[32];
ipDesc.pstart = ipDescStr;
ipDesc.size = sizeof(ipDescStr)-1;
maskDesc.pstart = maskDescStr;
maskDesc.size = sizeof(maskDescStr)-1;
printf("Destination IPv4 Address/Mask: %s/%s\n", (char *)ipDesc.pstart, (char *)maskDesc.pstart);
}
}
{
#if REDIRECT_NOT_MIRROR
PRINTBADRESULT(result, "openapiAclRuleMatchRedirectAgentAdd");
#else
PRINTBADRESULT(result, "openapiAclRuleMatchMirrorAgentAdd");
#endif
{
#if REDIRECT_NOT_MIRROR
PRINTBADRESULT(result, "openapiAclRuleMatchRedirectGet");
sprintf(buff, "Packet Redirect to Extenal Agent: %d", temp);
#else
PRINTBADRESULT(result, "openapiAclRuleMatchMirrorAgentGet");
sprintf(buff, "Packet Mirror to Extenal Agent: %d", temp);
#endif
}
{
PRINTSANITYRESULTS(result, (agentCookie == temp), __func__, buff);
}
}
return result;
}
uint32_t agentCookie, uint32_t aclId,
uint32_t *aclRule)
{
uint32_t temp;
char buff[80];
{
*aclRule = 0;
{
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolGet");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchMirrorAgentAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchMirrorAgentGet");
sprintf(buff, "Packet Mirror to Extenal Agent: %d", temp);
PRINTSANITYRESULTS(result, (agentCookie == temp), __func__, buff);
}
}
}
{
*aclRule = 0;
{
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__, "Oddball TCP Flags test");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchMirrorAgentAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchMirrorAgentGet");
sprintf(buff, "Packet Mirror to Extenal Agent: %d", temp);
PRINTSANITYRESULTS(result, (agentCookie == temp), __func__, buff);
}
}
}
{
*aclRule = 0;
{
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchProtocolGet");
}
}
{
uint32_t tmpStartPort;
uint32_t tmpEndPort;
PRINTBADRESULT(result, "openapiAclRuleMatchL4SrcPortAdd");
{
&tmpStartPort, &tmpEndPort);
PRINTBADRESULT(result, "openapiAclRuleMatchL4SrcPortGet");
PRINTSANITYRESULTS(result,
__func__, "Source Layer 4 port 53");
}
}
{
uint32_t tmpStartPort;
uint32_t tmpEndPort;
PRINTBADRESULT(result, "openapiAclRuleMatchL4DstPortAdd");
{
&tmpStartPort, &tmpEndPort);
PRINTBADRESULT(result, "openapiAclRuleMatchL4DstPortGet");
PRINTSANITYRESULTS(result,
__func__, "Source Layer 4 port 53");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchMirrorAgentAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchMirrorAgentGet");
sprintf(buff, "Packet Mirror to Extenal Agent: %d", temp);
PRINTSANITYRESULTS(result, (agentCookie == temp), __func__, buff);
}
}
}
return result;
}
uint32_t aclId, uint32_t *aclRule)
{
uint32_t temp;
{
PRINTBADRESULT(result, "openapiAclRuleActionAdd - PERMIT");
{
PRINTBADRESULT(result, "openapiAclRuleActionGet - PERMIT");
}
}
{
PRINTBADRESULT(result, "openapiAclRuleMatchEveryAdd");
{
PRINTBADRESULT(result, "openapiAclRuleMatchEveryGet");
PRINTSANITYRESULTS(result, (uint32_t)
OPEN_TRUE==temp, __func__,
"Every");
}
}
return result;
}
uint32_t *aclId)
{
uint32_t response;
uint32_t value;
char strSubnetMask[TCAM_MAX_STR_LENGTH];
char strIpaddr[TCAM_MAX_STR_LENGTH];
uint32_t aclRule;
char matchDstMac[TCAM_MAX_STR_LENGTH], matchSrcMac[TCAM_MAX_STR_LENGTH];
char maskDstMac[TCAM_MAX_STR_LENGTH], maskSrcMac[TCAM_MAX_STR_LENGTH];
uint16_t matchEthType;
printf("This selection will create %s ACL.\n",
allRule==
OPEN_TRUE?
"a simple":
"and add simple classifiers to an");
do
{
break;
response = 99;
printf("Enter classification type:\n"
"\t1\tto match Dest MAC\n"
"\t2\tto match Src MAC\n"
"\t3\tto match EtherType\n"
"\t4\tto match Dest IPv4 address\n"
"\t5\tto match Src IPv4 address\n"
"\t6\tto match canned oddball IPv4 options\n"
"\t0\tquit \n");
scanf("%d", &response);
switch (response)
{
case 1:
memset(matchDstMac, 0, sizeof(matchDstMac));
memset(maskDstMac, 0, sizeof(maskDstMac));
printf("Enter Mac address (i.e. 00:00:04:00:05:00) ");
scanf("%s", matchDstMac);
printf("Enter Mac address mask (i.e. 00:00:00:00:00:07) ");
scanf("%s", maskDstMac);
{
{
strcpy(maskDstMac, "00:00:00:00:00:00");
printf("Error: Incorrect Input. Using NULL mask: %s\n", maskDstMac);
}
}
else
{
printf("Error: Incorrect Input: %s\n", matchDstMac);
}
break;
case 2:
memset(matchSrcMac, 0, sizeof(matchSrcMac));
memset(maskSrcMac, 0, sizeof(maskSrcMac));
printf("Enter Mac address (i.e. 00:00:04:00:04:00) ");
scanf("%s", matchSrcMac);
printf("Enter Mac address mask (i.e. 00:00:00:00:00:07) ");
scanf("%s", maskSrcMac);
{
{
strcpy(maskSrcMac, "00:00:00:00:00:00");
printf("Error: Incorrect Input. Using NULL mask: %s\n", maskSrcMac);
}
}
else
{
printf("Error: Incorrect Input: %s\n", matchSrcMac);
}
break;
case 3:
printf("This option is not yet available.\n");
break;
printf("Enter ether type in hex\n");
scanf("%x",&value);
matchEthType = value;
printf("Match EType: %d\n", matchEthType);
break;
case 4:
printf("Enter Dest IP address \n");
scanf("%s", strIpaddr);
buffDesc.pstart = strIpaddr;
buffDesc.size = strlen(strIpaddr) + 1;
{
ipDstAddr.
addr.
ipv4 = ipDstAddr.addr.ipv4;
printf("Enter Mask \n");
scanf("%s", strSubnetMask);
buffDesc.pstart = strSubnetMask;
buffDesc.size = strlen(strSubnetMask) + 1;
{
maskDstIp.addr.ipv4 = 0;
printf("Incorrect Input, using mask 0.0.0.0\n");
}
maskDstIp.addr.ipv4 = maskDstIp.addr.ipv4;
}
else
{
printf("Error: Incorrect Input\n");
break;
}
break;
case 5:
printf("Enter Src IP address \n");
scanf("%s", strIpaddr);
buffDesc.pstart = strIpaddr;
buffDesc.size = strlen(strIpaddr) + 1;
{
ipSrcAddr.addr.ipv4 = ipSrcAddr.addr.ipv4;
printf("Enter Mask \n");
scanf("%s", strSubnetMask);
buffDesc.pstart = strSubnetMask;
buffDesc.size = strlen(strSubnetMask) + 1;
{
maskSrcIp.addr.ipv4 = 0;
printf("Incorrect Input, using mask 0.0.0.0\n");
}
maskSrcIp.addr.ipv4 = maskSrcIp.addr.ipv4;
}
else
{
printf("Error: Incorrect Input\n");
break;
}
break;
case 6:
break;
case 0:
default:
response = 0;
}
} while (response != 0);
if (isDstMac || isSrcMac)
{
{
aclRule = 0;
if (isDstMac)
{
result = pktCapAclMacRules(clientHandle, agentCookie, *aclId, matchDstMac, maskDstMac, 0, &aclRule);
}
{
result = pktCapAclMacRules(clientHandle, agentCookie, *aclId, matchSrcMac, maskSrcMac, 1, &aclRule);
}
}
}
else if (isDstIp || isSrcIp)
{
result = pktCapAclCreate(clientHandle,
OPEN_ACL_TYPE_IP,
"pkt_mirror_IP", aclId);
{
aclRule = 0;
if (isDstIp)
{
result = pktCapAclIpRules(clientHandle, agentCookie, *aclId, ipDstAddr, maskDstIp, 0, &aclRule);
}
{
result = pktCapAclIpRules(clientHandle, agentCookie, *aclId, ipSrcAddr, maskSrcIp, 1, &aclRule);
}
}
}
{
printf("\tip access-list odd_ball\n");
printf("\tpermit icmp any any mirrorExtAgent %d\n", agentCookie);
printf("\tpermit tcp any any flag +fin +syn mirrorExtAgent %d\n", agentCookie);
printf("\tpermit udp any eq domain any eq domain mirrorExtAgent %d\n", agentCookie);
printf("\tpermit ip any any\n");
printf("\texit\n");
{
aclRule = 0;
result = pktCapAclOddBallRules(clientHandle, agentCookie, *aclId, &aclRule);
}
}
else
{
strcpy(matchDstMac, "FF:FF:FF:FF:FF:FF");
strcpy(maskDstMac, "FF:FF:FF:FF:FF:FF");
{
result = pktCapAclMacRules(clientHandle, agentCookie, *aclId, matchDstMac, maskDstMac, 0, &aclRule);
}
}
{
aclRule = 0;
result = pktCapAclPermitRules(clientHandle, *aclId, &aclRule);
{
printf("ACL %d created.\n", *aclId);
}
}
return result;
}
uint32_t aclId, uint32_t intf,
uint32_t seqNum)
{
char str[256];
{
PRINTBADRESULT(result, "openapiAclIntfDirAdd");
sprintf(str, "ACL:%d intf:%d dir:%d seq:%d", aclId, intf, dir, seqNum);
PRINTSANITYRESULTS(result, result==
OPEN_E_NONE, __func__, str);
}
}
{
char str[256];
uint32_t tmp;
printf("\n");
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)
{
char switch_os_revision_string[100];
uint32_t packetCount = 0;
uint32_t agentCookie = 79;
char *intfString;
uint32_t intfNum;
if (argc == 2)
{
intfString = argv[1];
}
else if (argc == 3)
{
intfString = argv[1];
packetCount = atoi(argv[2]);
}
else if ((argc == 4) && (0 == strcmp("all", argv[3])))
{
intfString = argv[1];
packetCount = atoi(argv[2]);
}
else if ((argc == 4) && (0 == strcmp("none", argv[3])))
{
intfString = argv[1];
packetCount = atoi(argv[2]);
}
else
{
printf("\nUsage: %s\tinterface <count> <'all | none'>\nWhere:\n", argv[0]);
printf("\t\t\tinterface\tUSP of a valid physical interface (i.e. 1/0/5).\n");
printf("\t\t\tcount\tCount of the number of packet to capture (optional).\n");
printf("\t\t\t'all'\tTo captures ALL packets.\n");
printf("\t\t\t'none'\tTo predefine rules for capture.\n");
exit (1);
}
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 Packet Capture example application");
printf ("\n");
switch_os_revision.pstart = switch_os_revision_string;
switch_os_revision.size = sizeof (switch_os_revision_string);
{
printf ("Network OS version = %s\n", switch_os_revision_string);
}
else
{
printf ("Network OS version retrieve error\n");
}
printf ("\n");
buffDesc.size = strlen(intfString) + 1;
buffDesc.pstart = intfString;
printf("%s: (%d %d %d)\n", intfString, buffDesc.size, result, intfNum);
{
printf("Error: Incorrect interface name %s\n", intfString);
}
else
{
uint32_t aclId = 0;
{
if (
OPEN_E_NONE == pktCapAclAddClassifiers(&clientHandle, agentCookie, allRule, &aclId))
{
}
}
printf("Make sure 'PROTO_API' was selected. Check flex.h.\n");
pktCapAclShowSummary(&clientHandle);
pktCapAclReceivePackets(agentCookie, packetCount);
}
return (int)result;
}