authmgr_example.c

/*********************************************************************
*
*  Copyright 2023 Broadcom.
*
*  Licensed under the Apache License, Version 2.0 (the "License");
*  you may not use this file except in compliance with the License.
*  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*
**********************************************************************
*
* @filename  authmgr_example.c
*
* @purpose   OpEN authmgr example.
*
* @component OpEN
*
* @create    02/23/2023
*
* @end
*
**********************************************************************/
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <ctype.h>

#include "rpcclt_openapi.h"
#include "proc_util.h"
#include "openapi_common.h"
#include "openapi_authmgr.h"
#include "openapi_dot1x.h"

/*
   OpEN API set functions are processed asynchronously. There may be some
   delay between when the set function call returns and when the system
   state is updated to reflect the change. These parameters control how
   long the test code retries the get functions to retrieve a change.
*/

#define DISP_BUF_SIZE 1024

/***************************************************************/
static void printAppMenu(char *name)
{
  printf("Usage: %s <test#> <arg1> <arg2> ... \n", name);
  printf("Test 1: Set the authentication manager Dynamic Vlan Creation Mode: %s 1 <dynamicVlanMode>\n", name);
  printf("Test 2: Set the authentication manager Vlan Assignment Mode: %s 2 <vlanAssignmentMode>\n", name);
  printf("Test 3: Set authentication manager method order: %s 3 <intIfNum><index><method>\n", name);
  printf("Test 4: Set authentication manager method priority: %s 4 <intIfNum><index><method>\n", name);
  printf("Test 5: Set the max users for the port: %s 5 <intIfNum><maxUsers>\n", name);
  printf("Test 6: Set the authentication fail action (Unauthenticated vlan) value: %s 6 <intIfNum><vlanId>\n", name);
  printf("Test 7: Display the authentication interface params: %s 7 <intIfNum>\n", name);
  printf("Test 8: Display the authenticated clients info: %s 8 <intIfNum>\n", name);
  printf("Test 9: Set authentication port configured control mode: %s 9 <intIfNum> <mode>\n", name);
  printf("Test 10: Set authentication manager admin mode: %s 10 <mode>\n", name);
  printf("Test 11: Set authentication manager host mode: %s 11 <intIfNum> <mode>\n", name);
  printf("Test 12: Set authentication manager port guest VLAN ID: %s 12 <intIfNum> <vlan>\n", name);
  printf("Test 13: Set authentication manager authentication periodic: %s 13 <intIfNum> <mode>\n", name);
  printf("Test 14: Set authentication manager reauthentication periodic: %s 14 <intIfNum> <mode>\n", name);
  printf("Test 15: Set authentication manager reauth period from server: %s 15 <intIfNum> <mode>\n", name);
  printf("Test 16: Set the max number of failed authentication attempts value on the specified port: %s 16 <intIfNum> <maxAuthAttempts>\n", name);
  printf("Test 17: Display the authentication manager authentication history table for all interfaces: %s 17\n", name);
  printf("Test 18: Display the authentication manager authentication history table for all interfaces in reverse order: %s 18\n", name);
  printf("Test 19: Display the authentication manager authentication history table on the specified port: %s 19 <intIfNum>\n", name);
  printf("Test 20: Clear the authentication manager authentication history table on all interfaces: %s 20\n", name);
  printf("Test 21: Clear the authentication manager authentication history table on the specified port: %s 21 <intIfNum>\n", name);
  printf("Test 22: Run API sanity checks: %s 22 \n", name);
  printf("Test 23: To initialize (or) re-authenticate the specific interface: %s 10 <intIfNum> <initialize>\n", name);
  printf("Test 24: Sets the authentication admin control direction on the specified port: %s 11 <intIfNum> <cntrlDir>\n", name);
  printf("Test 25: Gets Auth manager admin control direction on the specified port: %s 12 <intIfNum>\n", name);

  return;
}

/***********************************************************************/
static void runSanity(openapiClientHandle_t *clientHandle)
{
  open_error_t result;

  OPEN_AUTHMGR_STATES_t authState;
  uint32_t index = 1;
  uint32_t vlanType;
  uint32_t timeLeft;
  uint32_t clientsCount;
  uint32_t terminationAction;
  OPEN_AUTHMGR_PORT_STATUS_t authStatus;
  uint32_t vlanId;
  uint32_t maxAuthAttempts;
  uint32_t reAuthPeriod;
  uint32_t sessionTimeout;
  uint32_t sessionTime;
  OPEN_CONTROL_t dynamicVlanMode;
  OPEN_CONTROL_t reauthState;
  uint32_t maxUsers;
  OPEN_CONTROL_t vlanAssignmentMode;
  OPEN_AUTHMGR_METHOD_t method;
  uint32_t intIfNum = 100;
  uint32_t lIntIfNum;
  char buffer[128];
  uint32_t entryIndex = 0;
  uint32_t reasonCode = 0;
  OPEN_AUTHMGR_VLAN_ASSIGNED_MODE_t vlanAssignedType = OPEN_AUTHMGR_NOT_ASSIGNED;
  char strTimestamp[256];
  char reasonCodeStr[512];
  OPEN_AUTHMGR_PORT_DIRECTION_t cntrlDir;

  open_buffdesc buf, timeStamp, reasonCodeBuff;
  open_buffdesc zeroLenBuf;
  open_buffdesc badBufdescPointer;

  badBufdescPointer.pstart = (void *) NULL;
  badBufdescPointer.size = sizeof(buffer);

  buf.pstart = buffer;
  buf.size = sizeof(buffer);

  zeroLenBuf.pstart = buffer;
  zeroLenBuf.size = 0;

  timeStamp.pstart = strTimestamp;
  timeStamp.size = sizeof(strTimestamp);

  reasonCodeBuff.pstart = reasonCodeStr;
  reasonCodeBuff.size = sizeof(reasonCodeStr);

  printf("Testing authmgr OpEN APIs sanity:\n");

  printf("Testing openapiAuthMgrDynamicVlanCreationModeGet():\n");
  result = openapiAuthMgrDynamicVlanCreationModeGet(NULL, &dynamicVlanMode);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrDynamicVlanCreationModeGet(clientHandle, NULL);
  printf("NULL argument 2:(result = %d)\n", result);

  printf("Testing openapiAuthMgrVlanAssignmentModeGet():\n");
  result = openapiAuthMgrVlanAssignmentModeGet(NULL, &vlanAssignmentMode);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrVlanAssignmentModeGet(clientHandle, NULL);
  printf("NULL argument 2:(result = %d)\n", result);

  printf("Testing openapiAuthMgrPortAuthMethodOrderGet():\n");
  result = openapiAuthMgrPortAuthMethodOrderGet(NULL, intIfNum, index, &method);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrPortAuthMethodOrderGet(clientHandle, intIfNum, index, NULL);
  printf("NULL argument 4:(result = %d)\n", result);

  printf("Testing openapiAuthMgrPortAuthMethodPriorityGet():\n");
  result = openapiAuthMgrPortAuthMethodPriorityGet(NULL, intIfNum, index, &method);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrPortAuthMethodPriorityGet(clientHandle, intIfNum, index, NULL);
  printf("NULL argument 4:(result = %d)\n", result);

  printf("Testing openapiAuthMgrPortMaxUsersGet():\n");
  result = openapiAuthMgrPortMaxUsersGet(NULL, intIfNum, &maxUsers);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrPortMaxUsersGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthMgrPortUnauthenticatedVlanGet():\n");
  result = openapiAuthMgrPortUnauthenticatedVlanGet(NULL, intIfNum, &vlanId);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrPortUnauthenticatedVlanGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthMgrPortMaxAuthAttemptsGet():\n");
  result = openapiAuthMgrPortMaxAuthAttemptsGet(NULL, intIfNum, &maxAuthAttempts);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrPortMaxAuthAttemptsGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthMgrEnabledMethodGet():\n");
  result = openapiAuthMgrEnabledMethodGet(NULL, intIfNum, index, &method);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrEnabledMethodGet(clientHandle, intIfNum, index, NULL);
  printf("NULL argument 4:(result = %d)\n", result);

  printf("Testing openapiAuthMgrEnabledPriorityGet():\n");
  result = openapiAuthMgrEnabledPriorityGet(NULL, intIfNum, index, &method);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrEnabledPriorityGet(clientHandle, intIfNum, index, NULL);
  printf("NULL argument 4:(result = %d)\n", result);

  printf("Testing openapiAuthMgrNumClientsGet():\n");
  result = openapiAuthMgrNumClientsGet(NULL, intIfNum, &clientsCount);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrNumClientsGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthMgrLogicalPortClientMacAddrGet():\n");
  result = openapiAuthMgrLogicalPortClientMacAddrGet(NULL, intIfNum, &buf);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortClientMacAddrGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortClientMacAddrGet(clientHandle, intIfNum, &badBufdescPointer);
  printf("NULL buffdesc pstart argument 3:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortClientMacAddrGet(clientHandle, intIfNum, &zeroLenBuf);
  printf("buffdesc 0 length size argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthMgrLogicalPortClientAuthStatusGet():\n");
  result = openapiAuthMgrLogicalPortClientAuthStatusGet(NULL, intIfNum, &authStatus);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortClientAuthStatusGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthMgrLogicalPortClientAuthStateGet():\n");
  result = openapiAuthMgrLogicalPortClientAuthStateGet(NULL, intIfNum, &authState);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortClientAuthStateGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthMgrLogicalPortClientReauthStateGet():\n");
  result = openapiAuthMgrLogicalPortClientReauthStateGet(NULL, intIfNum, &reauthState);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortClientReauthStateGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthMgrLogicalPortUserNameGet():\n");
  result = openapiAuthMgrLogicalPortUserNameGet(NULL, intIfNum, &buf);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortUserNameGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortUserNameGet(clientHandle, intIfNum, &badBufdescPointer);
  printf("NULL buffdesc pstart argument 3:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortUserNameGet(clientHandle, intIfNum, &zeroLenBuf);
  printf("buffdesc 0 length size argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthMgrLogicalPortClientAuthenticatedMethodGet():\n");
  result = openapiAuthMgrLogicalPortClientAuthenticatedMethodGet(NULL, intIfNum, &method);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortClientAuthenticatedMethodGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthMgrLogicalPortClientVlanTypeGet():\n");
  result = openapiAuthMgrLogicalPortClientVlanTypeGet(NULL, intIfNum, &vlanType);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortClientVlanTypeGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthMgrLogicalPortSessionTimeGet():\n");
  result = openapiAuthMgrLogicalPortSessionTimeGet(NULL, intIfNum, &sessionTime);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortSessionTimeGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthMgrLogicalPortSessionTimeoutGet():\n");
  result = openapiAuthMgrLogicalPortSessionTimeoutGet(NULL, intIfNum, &sessionTimeout);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortSessionTimeoutGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthmgrLogicalPortTimeLeftForTerminateActionGet():\n");
  result = openapiAuthmgrLogicalPortTimeLeftForTerminateActionGet(NULL, intIfNum, &timeLeft);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthmgrLogicalPortTimeLeftForTerminateActionGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthMgrLogicalPortTerminationActionGet():\n");
  result = openapiAuthMgrLogicalPortTerminationActionGet(NULL, intIfNum, &terminationAction);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortTerminationActionGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthMgrLogicalPortFilterIdGet():\n");
  result = openapiAuthMgrLogicalPortFilterIdGet(NULL, intIfNum, &buf);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortFilterIdGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortFilterIdGet(clientHandle, intIfNum, &badBufdescPointer);
  printf("NULL buffdesc pstart argument 3:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortFilterIdGet(clientHandle, intIfNum, &zeroLenBuf);
  printf("buffdesc 0 length size argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthMgrAuthenticationReAuthPeriodFromSeverGet():\n");
  result = openapiAuthMgrAuthenticationReAuthPeriodFromSeverGet(NULL, intIfNum, &reAuthPeriod);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrAuthenticationReAuthPeriodFromSeverGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthMgrAuthenticationReAuthPeriodGet():\n");
  result = openapiAuthMgrAuthenticationReAuthPeriodGet(NULL, intIfNum, &reAuthPeriod);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrAuthenticationReAuthPeriodGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthMgrLogicalPortFirstGet():\n");
  result = openapiAuthMgrLogicalPortFirstGet(NULL, intIfNum, &lIntIfNum);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortFirstGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);

  printf("Testing openapiAuthMgrLogicalPortNextGet():\n");
  result = openapiAuthMgrLogicalPortNextGet(NULL, lIntIfNum, &intIfNum);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrLogicalPortNextGet(clientHandle, lIntIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);


  printf("Testing openapiAuthMgrHistoryLogIndexNextGet():\n");
  result = openapiAuthMgrHistoryLogIndexNextGet(NULL, &intIfNum, &entryIndex);
  printf("NULL argument 1(client handle) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogIndexNextGet(clientHandle, NULL, &entryIndex);
  printf("NULL argument 2(intIfNum):(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogIndexNextGet(clientHandle, &intIfNum, NULL);
  printf("NULL argument 3(entryIndex):(result = %d)\n", result);

  printf("Testing openapiAuthMgrHistoryLogReverseIndexNextGet():\n");
  result = openapiAuthMgrHistoryLogReverseIndexNextGet(NULL, &intIfNum, &entryIndex);
  printf("NULL argument 1(client handle) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogReverseIndexNextGet(clientHandle, NULL, &entryIndex);
  printf("NULL argument 2(intIfNum):(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogReverseIndexNextGet(clientHandle, &intIfNum, NULL);
  printf("NULL argument 3(entryIndex):(result = %d)\n", result);

  printf("Testing openapiAuthMgrHistoryLogEntryIsValid():\n");
  result = openapiAuthMgrHistoryLogEntryIsValid(NULL, intIfNum, entryIndex);
  printf("NULL argument 1(client handle) :(result = %d)\n", result);

  printf("Testing openapiAuthMgrHistoryLogInterfacePurge():\n");
  result = openapiAuthMgrHistoryLogInterfacePurge(NULL, intIfNum);
  printf("NULL argument 1(client handle) :(result = %d)\n", result);

  printf("Testing openapiAuthMgrHistoryLogPurgeAll():\n");
  result = openapiAuthMgrHistoryLogPurgeAll(NULL);
  printf("NULL argument 1(client handle) :(result = %d)\n", result);

  printf("Testing openapiAuthMgrHistoryLogTimestampGet():\n");
  result = openapiAuthMgrHistoryLogTimestampGet(NULL, intIfNum, entryIndex, &timeStamp);
  printf("NULL argument 1(client handle) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogTimestampGet(clientHandle, intIfNum, entryIndex, NULL);
  printf("NULL argument 4(timeStamp) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogTimestampGet(clientHandle, intIfNum, entryIndex, &badBufdescPointer);
  printf("NULL buffdesc pstart argument 4(timeStamp) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogTimestampGet(clientHandle, intIfNum, entryIndex, &zeroLenBuf);
  printf("buffdesc 0 length size argument 4(timeStamp) :(result = %d)\n", result);

  printf("Testing openapiAuthMgrHistoryLogMethodGet():\n");
  result = openapiAuthMgrHistoryLogMethodGet(NULL, intIfNum, entryIndex, &method);
  printf("NULL argument 1(client handle) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogMethodGet(clientHandle, intIfNum, entryIndex, NULL);
  printf("NULL argument 4(method) :(result = %d)\n", result);

  printf("Testing openapiAuthMgrHistoryLogReasonCodeGet():\n");
  result = openapiAuthMgrHistoryLogReasonCodeGet(NULL, intIfNum, entryIndex, &reasonCode);
  printf("NULL argument 1(client handle) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogReasonCodeGet(clientHandle, intIfNum, entryIndex, NULL);
  printf("NULL argument 4(reasonCode) :(result = %d)\n", result);

  printf("Testing openapiAuthMgrHistoryLogReasonStringGet():\n");
  result = openapiAuthMgrHistoryLogReasonStringGet(NULL, intIfNum, entryIndex,
                                                   reasonCode, &reasonCodeBuff);
  printf("NULL argument 1(client handle) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogReasonStringGet(clientHandle, intIfNum,
                                                   entryIndex, reasonCode, NULL);
  printf("NULL argument 5(reasonCodeStr) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogReasonStringGet(clientHandle, intIfNum,
                                                   entryIndex, reasonCode, &badBufdescPointer);
  printf("NULL buffdesc pstart argument 5(reasonCodeStr) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogReasonStringGet(clientHandle, intIfNum,
                                                   entryIndex, reasonCode, &zeroLenBuf);
  printf("buffdesc 0 length size argument 5(reasonCodeStr) :(result = %d)\n", result);

  printf("Testing openapiAuthMgrHistoryLogAuthStatusGet():\n");
  result = openapiAuthMgrHistoryLogAuthStatusGet(NULL, intIfNum, entryIndex, &authStatus);
  printf("NULL argument 1(client handle) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogAuthStatusGet(clientHandle, intIfNum, entryIndex, NULL);
  printf("NULL argument 4(authStatus) :(result = %d)\n", result);

  printf("Testing openapiAuthMgrHistoryLogClientMacAddressGet():\n");
  result = openapiAuthMgrHistoryLogClientMacAddressGet(NULL, intIfNum, entryIndex, &buf);
  printf("NULL argument 1(client handle) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogClientMacAddressGet(clientHandle, intIfNum, entryIndex, NULL);
  printf("NULL argument 4(macAddress) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogClientMacAddressGet(clientHandle, intIfNum, entryIndex,
                                                       &badBufdescPointer);
  printf("NULL buffdesc pstart argument 4(macAddress) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogClientMacAddressGet(clientHandle, intIfNum, entryIndex,
                                                       &zeroLenBuf);
  printf("buffdesc 0 length size argument 4(macAddress) :(result = %d)\n", result);

  printf("Testing openapiAuthMgrHistoryLogVlanIdGet():\n");
  result = openapiAuthMgrHistoryLogVlanIdGet(NULL, intIfNum, entryIndex, &vlanId);
  printf("NULL argument 1(client handle) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogVlanIdGet(clientHandle, intIfNum, entryIndex, NULL);
  printf("NULL argument 4(vlanId) :(result = %d)\n", result);

  printf("Testing openapiAuthMgrHistoryLogVlanAssignedTypeGet():\n");
  result = openapiAuthMgrHistoryLogVlanAssignedTypeGet(NULL, intIfNum, entryIndex,
                                                       &vlanAssignedType);
  printf("NULL argument 1(client handle) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogVlanAssignedTypeGet(clientHandle, intIfNum,
                                                       entryIndex, NULL);
  printf("NULL argument 4(vlanAssignedType):(result = %d)\n", result);

  printf("Testing openapiAuthMgrHistoryLogFilterIdGet():\n");
  result = openapiAuthMgrHistoryLogFilterIdGet(NULL, intIfNum, entryIndex, &buf);
  printf("NULL argument 1(client handle) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogFilterIdGet(clientHandle, intIfNum, entryIndex, NULL);
  printf("NULL argument 4(filterId) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogFilterIdGet(clientHandle, intIfNum, entryIndex,
                                               &badBufdescPointer);
  printf("NULL buffdesc pstart argument 4(filterId) :(result = %d)\n", result);
  result = openapiAuthMgrHistoryLogFilterIdGet(clientHandle, intIfNum, entryIndex,
                                               &zeroLenBuf);
  printf("buffdesc 0 length size argument 4(filterId) :(result = %d)\n", result);

  printf("Testing openapiAuthMgrPortAdminControlledDirectionsGet():\n");
  result = openapiAuthMgrPortAdminControlledDirectionsGet(NULL, intIfNum, &cntrlDir);
  printf("NULL client handle:(result = %d)\n", result);
  result = openapiAuthMgrPortAdminControlledDirectionsGet(clientHandle, intIfNum, NULL);
  printf("NULL argument 3:(result = %d)\n", result);
 

  printf("Authmgr OpEN APIs sanity done.\n");

  return;
}

/*****************************************************************/
void authMgrDynamicVlanCreationModeSet(openapiClientHandle_t *clientHandle, OPEN_CONTROL_t dynamicVlanMode)
{
  open_error_t result;

  if ((result = openapiAuthMgrDynamicVlanCreationModeSet(clientHandle, dynamicVlanMode)) != OPEN_E_NONE)
  {
    printf("Bad return code trying to set the authentication manager Dynamic Vlan Creation Mode (result = %d)\n", result);
  }
  else
  {
    printf("Authentication manager Dynamic Vlan Creation Mode is successfully %s\n", (OPEN_ENABLE == dynamicVlanMode) ? "enabled" : "disabled");
  }
  return;
}

/*****************************************************************/
void authMgrVlanAssignmentModeSet(openapiClientHandle_t *clientHandle, OPEN_CONTROL_t vlanAssignmentMode)
{
  open_error_t result;

  if ((result = openapiAuthMgrVlanAssignmentModeSet(clientHandle, vlanAssignmentMode)) != OPEN_E_NONE)
  {
    printf("Bad return code trying to set the authentication manager Vlan Assignment Mode (result = %d)\n", result);
  }
  else
  {
    printf("Authentication manager Vlan Assignment Mode is successfully %s\n", (OPEN_ENABLE == vlanAssignmentMode) ? "enabled" : "disabled");
  }
  return;
}

void authMgrPortAuthMethodOrderSet(openapiClientHandle_t *clientHandle, uint32_t intIfNum, uint32_t index, OPEN_AUTHMGR_METHOD_t method)
{
  open_error_t result;

  if ((result = openapiAuthMgrPortAuthMethodOrderSet(clientHandle, intIfNum, index, method)) != OPEN_E_NONE)
  {
    printf("Bad return code trying to set authentication manager method order (result = %d)\n", result);
  }
  else
  {
    printf("Authentication manager method order successfully set.\n");
  }
  return;
}

/*****************************************************************/
void authMgrPortAuthMethodPrioritySet(openapiClientHandle_t *clientHandle, uint32_t intIfNum, uint32_t index, OPEN_AUTHMGR_METHOD_t method)
{
  open_error_t result;

  if ((result = openapiAuthMgrPortAuthMethodPrioritySet(clientHandle, intIfNum, index, method)) != OPEN_E_NONE)
  {
    printf("Bad return code trying to set authentication manager method priority (result = %d)\n", result);
  }
  else
  {
    printf("Authentication manager method priority successfully set.\n");
  }
  return;
}


/*****************************************************************/
void authMgrPortMaxUsersSet(openapiClientHandle_t *clientHandle, uint32_t intIfNum, uint32_t maxUsers)
{
  open_error_t result;

  if ((result = openapiAuthMgrPortMaxUsersSet(clientHandle, intIfNum, maxUsers)) != OPEN_E_NONE)
  {
    printf("Bad return code trying to set the max users for the port (result = %d)\n", result);
  }
  else
  {
    printf("Setting of max users per port is succeeded. \n");
  }
  return;
}

/*****************************************************************/
void authMgrPortUnauthenticatedVlanSet(openapiClientHandle_t *clientHandle, uint32_t intIfNum, uint32_t vlanId)
{
  open_error_t result;

  if ((result = openapiAuthMgrPortUnauthenticatedVlanSet(clientHandle, intIfNum, vlanId)) != OPEN_E_NONE)
  {
    printf("Bad return code trying to set the Authentication fail action (Unauthenticated vlan) value (result = %d)\n", result);
  }
  else
  {
    printf("Authentication fail action (Unauthenticated vlan) value successfully set.\n");
  }
  return;
}

/*****************************************************************/
void authMgrPortMaxAuthAttemptsSet(openapiClientHandle_t *clientHandle, uint32_t intIfNum, uint32_t maxAuthAttempts)
{
  open_error_t result;

  if ((result = openapiAuthMgrPortMaxAuthAttemptsSet(clientHandle, intIfNum, maxAuthAttempts)) != OPEN_E_NONE)
  {
    printf("Bad return code trying to set the max number of failed authentication attempts value on the specified port (result = %d)\n", result);
  }
  else
  {
    printf("Max number of failed authentication attempts value successfully set.\n");
  }
  return;
}

/*****************************************************************/
void authMgrAuthenticationClientsShow(openapiClientHandle_t *client_handle, uint32_t lIntIfNum)
{
  char buf[100];
  char strFilter[256];
  char userName[OPEN_AUTHMGR_USER_NAME_LEN];
  open_buffdesc buffDesc, filterId;
  OPEN_AUTHMGR_VLAN_ASSIGNED_MODE_t vlanReason;
  uint32_t vlanId;
  uint32_t authStatus = 0, authState = 0, sessionTime = 0;
  OPEN_CONTROL_t reAuthState;
  OPEN_AUTHMGR_METHOD_t method = 0;
  uint32_t sessionTimeout = 0, timeLeft = 0, terminationAction = 0;

  memset(buf, '\0', sizeof(buf));
  buffDesc.pstart = buf;
  buffDesc.size = sizeof(buf);

  memset(strFilter, '\0', sizeof(strFilter));
  filterId.pstart = strFilter;
  filterId.size = sizeof(strFilter);

  /* mac-address */
  if (OPEN_E_NONE != openapiAuthMgrLogicalPortClientMacAddrGet(client_handle, lIntIfNum, &buffDesc))
  {
    printf ("Failed to get mac address for logical port %d \r\n", lIntIfNum);
    return;
  }

  printf ("\r\n");
  printf ("Mac address : %02X:%02X:%02X:%02X:%02X:%02X\r\n",
      buf[0], buf[1], buf[2], buf[3], buf[4], buf[5]);
  /* auth status */

  if (OPEN_E_NONE != openapiAuthMgrLogicalPortClientAuthStatusGet(client_handle, lIntIfNum, &authStatus))
  {
    printf ("Failed to get username for logical port %d \r\n", lIntIfNum);
    return;
  }

  if (authStatus == OPEN_AUTHMGR_PORT_STATUS_AUTHORIZED)
  {

    /* user-name */

    memset(userName, '\0', sizeof(userName));
    buffDesc.pstart = userName;
    buffDesc.size = sizeof(userName);

    if (OPEN_E_NONE != openapiAuthMgrLogicalPortUserNameGet(client_handle, lIntIfNum, &buffDesc))
    {
      printf ("Failed to get username for logical port %d \r\n", lIntIfNum);
      return;
    }

    printf("Username : %s\r\n", userName);


    /* auth state */

    if (OPEN_E_NONE != openapiAuthMgrLogicalPortClientAuthStateGet(client_handle, lIntIfNum, &authState))
    {
      printf ("Failed to get auth state for logical port %d \r\n", lIntIfNum);
      return;
    }

    printf ("Auth State : %s\r\n", (OPEN_AUTHMGR_AUTHENTICATED == authState) ? "Authenticated" : "In progress");

    /* client reauth state */

    if (OPEN_E_NONE != openapiAuthMgrLogicalPortClientReauthStateGet(client_handle, lIntIfNum, &reAuthState))
    {
      printf ("Failed to get reAuthState for logical port %d \r\n", lIntIfNum);
      return;
    }

    printf("Reauth State : %s \r\n", (reAuthState == OPEN_ENABLE) ? "True" : "False");

    /* client authenticated method */

    if (OPEN_E_NONE != openapiAuthMgrLogicalPortClientAuthenticatedMethodGet(client_handle, lIntIfNum, &method))
    {
      printf ("Failed to get authenticated method for logical port %d \r\n", lIntIfNum);
      return;
    }

    printf("Authenticated Method : %s \r\n", (method == OPEN_AUTHMGR_METHOD_8021X) ? "802.1X" : ((method == OPEN_AUTHMGR_METHOD_MAB) ? "MAB" : ((method == OPEN_AUTHMGR_METHOD_CP) ? "Captive-portal" : "None")));

    /* client Vlan id and assignment reason */

    if (OPEN_E_NONE != openapiAuthMgrLogicalPortVlanAssignmentGet(client_handle, lIntIfNum, &vlanId, &vlanReason))
    {
      printf ("Failed to get authenticated vlan and assignment reason for logical port %d \r\n", lIntIfNum);
      return;
    }
    printf("Vlan Id : %d \r\n", vlanId);
    printf("Vlan assignment reason : %s \r\n", (vlanReason == OPEN_AUTHMGR_RADIUS_ASSIGNED_VLAN) ? "RADIUS" : ((vlanReason == OPEN_AUTHMGR_UNAUTHENTICATED_VLAN) ? "UNAUTH" : ((vlanReason == OPEN_AUTHMGR_GUEST_VLAN) ? "Guest" : "None")));

    /* client session time */

    if (OPEN_E_NONE != openapiAuthMgrLogicalPortSessionTimeGet(client_handle, lIntIfNum, &sessionTime))
    {
      printf ("Failed to get authenticated client's session time for logical port %d \r\n", lIntIfNum);
      return;
    }

    printf("Session Time : %d \r\n", sessionTime);

    /* client session timeout */

    if (OPEN_E_NONE != openapiAuthMgrLogicalPortSessionTimeoutGet(client_handle, lIntIfNum, &sessionTimeout))
    {
      printf ("Failed to get authenticated client's session timeout for logical port %d \r\n", lIntIfNum);
      return;
    }
    printf("Session Timeout : %d \r\n", sessionTimeout);

    /* client termination action */

    if (OPEN_E_NONE != openapiAuthMgrLogicalPortTerminationActionGet(client_handle, lIntIfNum, &terminationAction))
    {
      printf ("Failed to get authenticated client's termination action for logical port %d \r\n", lIntIfNum);
      return;
    }
    printf("Termination Action : %s \r\n", (terminationAction == OPEN_AUTHMGR_TERMINATION_ACTION_RADIUS) ? "Reauthenticate" : "Default");

    /* client time leftout for termination action */

    if (OPEN_E_NONE != openapiAuthmgrLogicalPortTimeLeftForTerminateActionGet(client_handle, lIntIfNum, &timeLeft))
    {
      printf ("Failed to get time left for termination action for logical port %d \r\n", lIntIfNum);
      return;
    }
    printf("Time left for Termination action  : %d \r\n", timeLeft);

    /* client filter-id */

    if (OPEN_E_NONE != openapiAuthMgrLogicalPortFilterIdGet(client_handle, lIntIfNum, &filterId))
    {
      printf ("Failed to Filter-id for logical port %d \r\n", lIntIfNum);
      return;
    }
    printf("Filter-Id  : %s \r\n", (char *)filterId.pstart);
    printf ("\n=========================\r\n");
  }
  else
  {
    printf("The authentication is still in progress for this client\r\n");
  }
}

/*****************************************************************/
void authMgrAuthenticationClientsDisplay(openapiClientHandle_t *client_handle, uint32_t intIfNum)
{
  uint32_t lIntIfNum;
  if (OPEN_E_NONE != openapiAuthMgrLogicalPortFirstGet(client_handle, intIfNum, &lIntIfNum))
  {
    printf ("No clients are present on interface %d\r\n", intIfNum);
    return;
  }

  do 
  {
    authMgrAuthenticationClientsShow(client_handle, lIntIfNum);
  }while (OPEN_E_NONE == openapiAuthMgrLogicalPortNextGet(client_handle, lIntIfNum, &lIntIfNum));
}


/*****************************************************************/
void authMgrAuthenticationInterfaceShow(openapiClientHandle_t *client_handle, uint32_t intIfNum)
{
  open_error_t result;
  uint32_t adminMode = 0, reAuthPeriod, clientsCount = 0;
  OPEN_AUTHMGR_PORT_CONTROL_t portControl = 0;
  OPEN_AUTHMGR_HOST_CONTROL_t hostMode = 0;
  OPEN_AUTHMGR_METHOD_t method = 0;
  char val[DISP_BUF_SIZE];
  char *buf;
  uint32_t len = 0, remLen = 0, idx = 0;
  OPEN_BOOL_t mode = OPEN_FALSE;

  printf("Display the global and interface parameters of the port \n\n");
  printf("===== Global Parameters ===== \n");

  /* admin mode */
  result = openapiAuthMgrAdminModeGet(client_handle, &adminMode);
  if (OPEN_E_NONE != result)
  {
    printf("Bad return code trying to get the admin mode (result = %d)\n", result);
    return;
  }


  printf("\nAuthentication Enable : %s \n", (adminMode == OPEN_ENABLE)? "Enabled": "Disabled");

  /* Dynamic VLAN creation mode */
  adminMode = OPEN_DISABLE;
  result = openapiAuthMgrDynamicVlanCreationModeGet(client_handle, &adminMode);
  if (OPEN_E_NONE != result)
  {
    printf("Bad return code trying to get the dynamic VLAN creation mode (result = %d)\n", result);
    return;
  }


  printf("\nDynamic VLAN Creation Mode : %s \n", (adminMode == OPEN_ENABLE)? "Enabled": "Disabled");

  /* Dynamic Vlan Port assignment Mode */
  adminMode = OPEN_DISABLE;
  result = openapiAuthMgrVlanAssignmentModeGet(client_handle, &adminMode);
  if (OPEN_E_NONE != result)
  {
    printf("Bad return code trying to get the dynamic VLAN creation mode (result = %d)\n", result);
    return;
  }


  printf("\nDynamic VLAN-Port Assignment Mode : %s \n", (adminMode == OPEN_ENABLE)? "Enabled": "Disabled");



  /* port control mode */
  result = openapiAuthMgrPortControlModeGet(client_handle, intIfNum, &portControl);
  if (OPEN_E_NONE != result)
  {
    printf("Bad return code trying to get the port control mode (result = %d)\n", result);
    return;
  }

  memset(val, '\0', sizeof(val));

  switch (portControl)
  {
    case OPEN_AUTHMGR_PORT_AUTO:
      strncpy(val, "auto", strlen("auto")+1);
      break;
    case OPEN_AUTHMGR_PORT_FORCE_AUTHORIZED:
      strncpy(val, "force-authorized", strlen("force-authorized")+1);
      break;
    case OPEN_AUTHMGR_PORT_FORCE_UNAUTHORIZED:
      strncpy(val, "force-unauthorized", strlen("force-unauthorized")+1);
      break;
    default:
      strncpy(val, "none", strlen("none")+1);
      break;
  }

  printf("\nPort Control Mode : %s \r\n", val);


  /* host mode */
  result = openapiAuthMgrAuthenticationHostModeGet(client_handle, intIfNum, &hostMode);
  if (OPEN_E_NONE != result)
  {
    printf("Bad return code trying to get the port control mode (result = %d)\n", result);
    return;
  }

  memset(val, '\0', sizeof(DISP_BUF_SIZE));

  switch (hostMode)
  {
    case OPEN_AUTHMGR_SINGLE_AUTH_MODE:
      strncpy(val, "single-auth", strlen("single-auth")+1);
      break;
    case OPEN_AUTHMGR_MULTI_AUTH_MODE:
      strncpy(val, "multi-auth", strlen("multi-auth")+1);
      break;
    case OPEN_AUTHMGR_MULTI_HOST_MODE:
      strncpy(val, "multi-host", strlen("multi-host")+1);
      break;
    case OPEN_AUTHMGR_MULTI_DOMAIN_HOST_MODE:
      strncpy(val, "multi-domain-multi-host", strlen("multi-domain-multi-host")+1);
      break;
    default:
      strncpy(val, "none", strlen("none")+1);
      break;
  }

  printf("\nHost Mode : %s \r\n", val);

  /* configured order  */

  memset(val, '\0', sizeof(DISP_BUF_SIZE));
  remLen = DISP_BUF_SIZE -1;

  buf = &val[0];

  len = snprintf(buf, remLen, "Configured Methods : ");
  remLen = remLen - len;
  buf = buf + len;

  for (idx = 0; idx <= 2; idx++)
  {
    method = OPEN_AUTHMGR_METHOD_NONE;
    len = 0;
    if(openapiAuthMgrPortAuthMethodOrderGet(client_handle, intIfNum, idx, &method) == OPEN_E_NONE)
    {
      switch (method)
      {
        case OPEN_AUTHMGR_METHOD_8021X:
          len = snprintf(buf, remLen, "802.1X");
          break;
        case OPEN_AUTHMGR_METHOD_MAB:
          len = snprintf(buf, remLen, "MAB");
          break;
        case OPEN_AUTHMGR_METHOD_CP:
          len = snprintf(buf, remLen, "Captive-Portal");
          break;

        default:
          len = snprintf(buf, remLen, "undefined");
          break;
      }
    }

    buf += len;
    remLen = remLen - len;
    len = 0;
    len = snprintf(buf, remLen, " ");
    buf += len;
    remLen = remLen - len;
  }

  printf("\r\n %s \r\n", val);

  /* configured priority  */

  memset(val, '\0', sizeof(DISP_BUF_SIZE));
  remLen = DISP_BUF_SIZE -1;

  buf = &val[0];

  len = snprintf(buf, remLen, "Configured Priority : ");
  remLen = remLen - len;
  buf = buf + len;

  for (idx = 0; idx <= 2; idx++)
  {
    method = OPEN_AUTHMGR_METHOD_NONE;
    len = 0;
    if(openapiAuthMgrPortAuthMethodPriorityGet(client_handle, intIfNum, idx, &method) == OPEN_E_NONE)
    {
      switch (method)
      {
        case OPEN_AUTHMGR_METHOD_8021X:
          len = snprintf(buf, remLen, "802.1X");
          break;
        case OPEN_AUTHMGR_METHOD_MAB:
          len = snprintf(buf, remLen, "MAB");
          break;
        case OPEN_AUTHMGR_METHOD_CP:
          len = snprintf(buf, remLen, "Captive-Portal");
          break;

        default:
          len = snprintf(buf, remLen, "undefined");
          break;
      }
    }

    buf += len;
    remLen = remLen - len;
    len = 0;
    len = snprintf(buf, remLen, " ");
    buf += len;
    remLen = remLen - len;
  }

  printf("\r\n %s \r\n", val);


  /* Enabled methods  */

  memset(val, '\0', sizeof(DISP_BUF_SIZE));
  remLen = DISP_BUF_SIZE -1;

  buf = &val[0];

  len = snprintf(buf, remLen, "Enabled methods : ");
  remLen = remLen - len;
  buf = buf + len;

  for (idx = 0; idx <= 2; idx++)
  {
    method = OPEN_AUTHMGR_METHOD_NONE;
    len = 0;
    if(openapiAuthMgrEnabledMethodGet(client_handle, intIfNum, idx, &method) == OPEN_E_NONE)
    {
      switch (method)
      {
        case OPEN_AUTHMGR_METHOD_8021X:
          len = snprintf(buf, remLen, "802.1X");
          break;
        case OPEN_AUTHMGR_METHOD_MAB:
          len = snprintf(buf, remLen, "MAB");
          break;
        case OPEN_AUTHMGR_METHOD_CP:
          len = snprintf(buf, remLen, "Captive-Portal");
          break;

        default:
          len = snprintf(buf, remLen, "undefined");
          break;
      }
    }

    buf += len;
    remLen = remLen - len;
    len = 0;
    len = snprintf(buf, remLen, " ");
    buf += len;
    remLen = remLen - len;
  }

  printf("\r\n %s \r\n", val);

  /* Enabled priority  */

  memset(val, '\0', sizeof(DISP_BUF_SIZE));
  remLen = DISP_BUF_SIZE -1;

  buf = &val[0];

  len = snprintf(buf, remLen, "Enabled priority : ");
  remLen = remLen - len;
  buf = buf + len;

  for (idx = 0; idx <= 2; idx++)
  {
    method = OPEN_AUTHMGR_METHOD_NONE;
    len = 0;
    if(openapiAuthMgrEnabledPriorityGet(client_handle, intIfNum, idx, &method) == OPEN_E_NONE)
    {
      switch (method)
      {
        case OPEN_AUTHMGR_METHOD_8021X:
          len = snprintf(buf, remLen, "802.1X");
          break;
        case OPEN_AUTHMGR_METHOD_MAB:
          len = snprintf(buf, remLen, "MAB");
          break;
        case OPEN_AUTHMGR_METHOD_CP:
          len = snprintf(buf, remLen, "Captive-Portal");
          break;

        default:
          len = snprintf(buf, remLen, "undefined");
          break;
      }
    }

    buf += len;
    remLen = remLen - len;
    len = 0;
    len = snprintf(buf, remLen, " ");
    buf += len;
    remLen = remLen - len;
  }

  printf("\r\n %s \r\n", val);


  /* reauth status */
  mode = OPEN_FALSE;

  if ((result = openapiAuthMgrAuthenticationPeriodicGet(client_handle, intIfNum, &mode)) != OPEN_E_NONE)
  {
    printf("Bad return code trying to get the Reauthentication Periodic status  (result = %d)\n", result);
    return;
  }
  printf("\nReauthentication Enabled : %s\r\n", (OPEN_TRUE == mode) ? "True" : "False");



  /* reauthentication period */

  if ((result = openapiAuthMgrAuthenticationReAuthPeriodGet(client_handle, intIfNum, &reAuthPeriod)) != OPEN_E_NONE)
  {
    printf("Bad return code trying to get the Reauthentication Periodic (result = %d)\n", result);
    return;
  }

  printf("\nReauthentication Period : %d\r\n", reAuthPeriod);

  /* session timeout from Radius server Enabled */
  mode = OPEN_FALSE;
  if ((result = openapiAuthMgrAuthenticationReAuthPeriodFromSeverGet(client_handle, intIfNum, &mode)) != OPEN_E_NONE)
  {
    printf("Bad return code trying to get the session timeout from Radius Server (result = %d)\n", result);
    return;
  }
  printf("\nSession Timeout from Radius Server Enabled : %s\r\n", (OPEN_TRUE == mode) ? "True" : "False");

  /* Max-users */
  reAuthPeriod = 0;
  if (OPEN_E_NONE != openapiAuthMgrPortMaxUsersGet(client_handle, intIfNum, &reAuthPeriod))
  {
    printf("Bad return code trying to get the max users ");
    return;
  }

  printf("\nMax Users : %d\r\n", reAuthPeriod);

  /* Guest Vlan Id */
  reAuthPeriod = 0;
  if (OPEN_E_NONE != openapiAuthMgrPortGuestVlanGet(client_handle, intIfNum, &reAuthPeriod))
  {
    printf("Bad return code trying to get the Guest VLAN Id ");
    return;
  }

  printf("\nGuest VLAN Id : %d\r\n", reAuthPeriod);


  /* Unauth Vlan Id */
  reAuthPeriod = 0;
  if (OPEN_E_NONE != openapiAuthMgrPortUnauthenticatedVlanGet(client_handle, intIfNum, &reAuthPeriod))
  {
    printf("Bad return code trying to get the Unauth VLAN Id ");
    return;
  }

  printf("\nUnauth VLAN Id : %d\r\n", reAuthPeriod);


  /* Max auth re-try Attempts */
  reAuthPeriod = 0;
  if (OPEN_E_NONE != openapiAuthMgrPortMaxAuthAttemptsGet(client_handle, intIfNum, &reAuthPeriod))
  {
    printf("Bad return code trying to get the Max auth retry Attempts ");
    return;
  }

  printf("\nMax Auth retry attempts : %d\r\n", reAuthPeriod);

  /* number of clients authenticated */

  if (OPEN_E_NONE != openapiAuthMgrNumClientsGet(client_handle, intIfNum, &clientsCount))
  {
    printf ("Failed to get number of clients authenticated for logical port %d \r\n", intIfNum);
    return;
  }

  printf("\nNumber of Authenticated clients : %d \r\n", clientsCount);
  printf ("\n=========================\r\n");
  printf ("\r\n");

  return;
}

void portControlModeSet(openapiClientHandle_t *clientHandle, int argc, char **argv)
{
  open_error_t result;
  uint32_t ifNum;
  OPEN_AUTHMGR_PORT_CONTROL_t mode;

  if (argc < 4)
  {
    printf("Interface and mode parameters required.\n");
    return;
  }

  errno = 0;
  ifNum = strtoul(argv[2], NULL, 0);
  if (errno != 0)
  {
    printf("Invalid interface parameter: (%s)\n", argv[2]);
    return;
  }

  errno = 0;
  mode = strtoul(argv[3], NULL, 0);
  if (errno != 0)
  {
    printf("Invalid mode parameter: (%s)\n", argv[3]);
    return;
  }

  result = openapiAuthMgrPortControlModeSet(clientHandle, ifNum, mode);
  if (OPEN_E_NONE != result)
  {
    printf("Bad return code trying to set port control mode (result = %d)\n", result);
  }
  else
  {
    printf("port control mode set. (result = %d)\n", result);
  }
  return;
}

void authMgrAdminModeSet(openapiClientHandle_t *clientHandle, int argc, char **argv)
{
  open_error_t result;
  OPEN_CONTROL_t mode;

  printf("0 %s, 1 %s, 2 %s \n", argv[0], argv[1], argv[2]);
  if (argc < 3)
  {
    printf("Mode parameter required.\n");
    return;
  }
  errno = 0;

  mode = strtoul(argv[2], NULL, 0);
  if (errno != 0)
  {
    printf("Invalid mode parameter: (%s)\n", argv[2]);
    return;
  }

  result = openapiAuthMgrAdminModeSet(clientHandle, mode);
  if (OPEN_E_NONE != result)
  {
    printf("Bad return code trying to set authentication manager admin mode (result = %d)\n", result);
  }
  else
  {
    printf("authentication manager admin mode set. (result = %d)\n", result);
  }
  return;
}

void authHostModeSet(openapiClientHandle_t *clientHandle, int argc, char **argv)
{
  open_error_t result;
  uint32_t ifNum;
  OPEN_AUTHMGR_HOST_CONTROL_t mode;

  if (argc < 4)
  {
    printf("Interface and enable parameters required.\n");
    return;
  }

  errno = 0;
  ifNum = strtoul(argv[2], NULL, 0);
  if (errno != 0)
  {
    printf("Invalid interface parameter: (%s)\n", argv[2]);
    return;
  }

  errno = 0;
  mode = strtoul(argv[3], NULL, 0);
  if (errno != 0)
  {
    printf("Invalid mode parameter: (%s)\n", argv[3]);
    return;
  }

  result = openapiAuthMgrAuthenticationHostModeSet(clientHandle, ifNum, mode);
  if (OPEN_E_NONE != result)
  {
    printf("Bad return code trying to set port host mode configuration (result = %d)\n", result);
  }
  else
  {
    printf("Port host mode configuration set. (result = %d)\n", result);
  }
  return;
}

void portGuestVlanSet(openapiClientHandle_t *clientHandle, int argc, char **argv)
{
  open_error_t result;
  uint32_t ifNum;
  uint32_t vlan;

  if (argc < 4)
  {
    printf("Interface and VLAN ID parameters required.\n");
    return;
  }

  errno = 0;
  ifNum = strtoul(argv[2], NULL, 0);
  if (errno != 0)
  {
    printf("Invalid interface parameter: (%s)\n", argv[2]);
    return;
  }

  errno = 0;
  vlan = strtoul(argv[3], NULL, 0);
  if (errno != 0)
  {
    printf("Invalid VLAN ID parameter: (%s)\n", argv[3]);
    return;
  }

  result = openapiAuthMgrPortGuestVlanSet(clientHandle, ifNum, vlan);
  if (OPEN_E_NONE != result)
  {
    printf("Bad return code trying to set port guest VLAN ID (result = %d)\n", result);
  }
  else
  {
    printf("Port guest VLAN ID set. (result = %d)\n", result);
  }
  return;
}

void authenticationPeriodicSet(openapiClientHandle_t *clientHandle, int argc, char **argv)
{
  open_error_t result;
  uint32_t ifNum;
  OPEN_BOOL_t val;

  if (argc < 4)
  {
    printf("Interface and enable parameters required.\n");
    return;
  }

  errno = 0;
  ifNum = strtoul(argv[2], NULL, 0);
  if (errno != 0)
  {
    printf("Invalid interface parameter: (%s)\n", argv[2]);
    return;
  }

  errno = 0;
  val = strtoul(argv[3], NULL, 0);
  if (errno != 0)
  {
    printf("Invalid mode parameter: (%s)\n", argv[3]);
    return;
  }

  result = openapiAuthMgrAuthenticationPeriodicSet(clientHandle, ifNum, val);
  if (OPEN_E_NONE != result)
  {
    printf("Bad return code trying to set periodic authentication configuration (result = %d)\n", result);
  }
  else
  {
    printf("periodic authentication configuration set. (result = %d)\n", result);
  }
  return;
}

void reauthenticationPeriodSet(openapiClientHandle_t *clientHandle, int argc, char **argv)
{
  open_error_t result;
  uint32_t ifNum;
  uint32_t val;

  if (argc < 4)
  {
    printf("Interface and enable parameters required.\n");
    return;
  }

  errno = 0;
  ifNum = strtoul(argv[2], NULL, 0);
  if (errno != 0)
  {
    printf("Invalid interface parameter: (%s)\n", argv[2]);
    return;
  }

  errno = 0;
  val = strtoul(argv[3], NULL, 0);
  if (errno != 0)
  {
    printf("Invalid mode parameter: (%s)\n", argv[3]);
    return;
  }

  result = openapiAuthMgrAuthenticationReAuthPeriodSet(clientHandle, ifNum, val);
  if (OPEN_E_NONE != result)
  {
    printf("Bad return code trying to set reauthentication period configuration (result = %d)\n", result);
  }
  else
  {
    printf("Reauthentication period configuration set. (result = %d)\n", result);
  }
  return;
}

void reauthPeriodFromServerSet(openapiClientHandle_t *clientHandle, int argc, char **argv)
{
  open_error_t result;
  uint32_t ifNum;
  uint32_t val;

  if (argc < 4)
  {
    printf("Interface and enable parameters required.\n");
    return;
  }

  errno = 0;
  ifNum = strtoul(argv[2], NULL, 0);
  if (errno != 0)
  {
    printf("Invalid interface parameter: (%s)\n", argv[2]);
    return;
  }

  errno = 0;
  val = strtoul(argv[3], NULL, 0);
  if (errno != 0)
  {
    printf("Invalid mode parameter: (%s)\n", argv[3]);
    return;
  }

  result = openapiAuthMgrAuthenticationReAuthPeriodFromServerSet(clientHandle, ifNum, val);
  if (OPEN_E_NONE != result)
  {
    printf("Bad return code trying to set reauthentication period from server configuration (result = %d)\n", result);
  }
  else
  {
    printf("Reauthentication period from server configuration set. (result = %d)\n", result);
  }
  return;
}

/*****************************************************************/
void authMgrAuthenticationHistoryLogShow(openapiClientHandle_t *client_handle,
                                         uint32_t intIfNum,
                                         uint32_t entryIndex)
{
  char mac[100];
  char strFilter[256];
  char strTimeStamp[256];
  char strReason[512];
  char strVlanAssignedType[64];
  open_buffdesc buffDesc, timeStamp, filterId, reason;
  uint32_t vlanId = 0, reasonCode = 0, authStatus = 0;
  OPEN_AUTHMGR_VLAN_ASSIGNED_MODE_t vlanAssignedType = OPEN_AUTHMGR_NOT_ASSIGNED;
  OPEN_AUTHMGR_METHOD_t method = 0;
  open_error_t result;
  open_buffdesc intfName;
  char intfNameStr[256];

  memset(intfNameStr, 0, sizeof(intfNameStr));
  intfName.pstart = intfNameStr;
  intfName.size = sizeof(intfNameStr);


  memset(strVlanAssignedType, '\0', sizeof(strVlanAssignedType));

  memset(mac, '\0', sizeof(mac));
  buffDesc.pstart = mac;
  buffDesc.size = sizeof(mac);

  memset(strFilter, '\0', sizeof(strFilter));
  filterId.pstart = strFilter;
  filterId.size = sizeof(strFilter);

  memset(strTimeStamp, '\0', sizeof(strTimeStamp));
  timeStamp.pstart = strTimeStamp;
  timeStamp.size = sizeof(strTimeStamp);

  memset(strReason, '\0', sizeof(strReason));
  reason.pstart = strReason;
  reason.size = sizeof(strReason);

  if (OPEN_E_NONE != 
      (result = openapiIfNameGet(client_handle, intIfNum, &intfName)))
  {
    printf("Bad return code trying to get interface name for %d interface. "
           "(result = %d)\n", intIfNum, result);

    snprintf(intfNameStr, sizeof(intfNameStr), "%s", "Unknown");
  }

  result = openapiAuthMgrHistoryLogEntryIsValid(client_handle, intIfNum, entryIndex);
  if (OPEN_E_NONE != result)
  {
    printf("No valid authentication history is present for the specified port:%s(%d) "
           "and entry index:%d result:%d\r\n",
           intfNameStr, intIfNum, entryIndex, result);
    return;
  }

  printf ("\r\n");

  /* interface */
  printf ("Interface: %s(%d)\r\n", intfNameStr, intIfNum);

  /* time stamp */
  result = openapiAuthMgrHistoryLogTimestampGet(client_handle, intIfNum,
                                                entryIndex, &timeStamp);
  if (OPEN_E_NONE != result)
  {
    printf ("Failed to get time stamp for port:%s(%d) result:%d\r\n",
            intfNameStr, intIfNum, result);
    return;
  }

  printf ("Time Stamp : %s\r\n", strTimeStamp);

  /* mac-address */
  result = openapiAuthMgrHistoryLogClientMacAddressGet(client_handle, intIfNum,
                                                       entryIndex, &buffDesc);
  if (OPEN_E_NONE != result)
  {
    printf ("Failed to get MAC address for port:%s(%d) result:%d\r\n",
            intfNameStr, intIfNum, result);
    return;
  }

  printf ("\r\n");
  printf ("MAC address : %s\r\n", mac);

  /* auth-method */
  result = openapiAuthMgrHistoryLogMethodGet(client_handle, intIfNum, entryIndex, &method);
  if (OPEN_E_NONE != result)
  {
    printf ("Failed to get authentication method for port:%s(%d) result:%d\r\n",
            intfNameStr, intIfNum, result);
    return;
  }

  printf ("\r\n");
  printf("Authenticated Method : %s \r\n", (OPEN_AUTHMGR_METHOD_8021X == method) ? "802.1X" : ((OPEN_AUTHMGR_METHOD_MAB == method) ? "MAB" : ((OPEN_AUTHMGR_METHOD_CP == method) ? "Captive-portal" : "None")));

  /* auth status */
  result = openapiAuthMgrHistoryLogAuthStatusGet(client_handle, intIfNum, entryIndex, &authStatus);
  if (OPEN_E_NONE != result)
  {
    printf ("Failed to get authentication status for port:%s(%d) result:%d\r\n",
            intfNameStr, intIfNum, result);
    return;
  }

  printf ("\r\n");
  printf("Authenticated Status : %s \r\n", (OPEN_AUTHMGR_PORT_STATUS_AUTHORIZED == authStatus) ? "Authorized" : ((OPEN_AUTHMGR_PORT_STATUS_UNAUTHORIZED == authStatus) ? "Unauthorized" : "Unknown"));

  /* VLAN ID */
  result = openapiAuthMgrHistoryLogVlanIdGet(client_handle, intIfNum, entryIndex, &vlanId);
  if (OPEN_E_NONE != result)
  {
    printf ("Failed to get VLAN ID for port:%s(%d) result:%d\r\n",
            intfNameStr, intIfNum, result);
    return;
  }

  printf ("\r\n");
  printf("VLAN ID : %d \r\n", vlanId);

  result = openapiAuthMgrHistoryLogVlanAssignedTypeGet(client_handle, intIfNum,
                                                       entryIndex, &vlanAssignedType);
  if (OPEN_E_NONE != result)
  {
    printf ("Failed to get VLAN assigned type for port:%s(%d) result:%d\r\n",
            intfNameStr, intIfNum, result);
    return;
  }

  switch (vlanAssignedType)
  {
    case OPEN_AUTHMGR_DEFAULT_ASSIGNED_VLAN:
      snprintf(strVlanAssignedType, sizeof(strVlanAssignedType), "%s", "Default Assigned VLAN");
      break;
    case OPEN_AUTHMGR_RADIUS_ASSIGNED_VLAN:
      snprintf(strVlanAssignedType, sizeof(strVlanAssignedType), "%s", "Radius Assigned VLAN");
      break;
    case OPEN_AUTHMGR_UNAUTHENTICATED_VLAN:
      snprintf(strVlanAssignedType, sizeof(strVlanAssignedType), "%s", "Unauthenticated VLAN");
      break;
    case OPEN_AUTHMGR_CRITICAL_VLAN:
      snprintf(strVlanAssignedType, sizeof(strVlanAssignedType), "%s", "Critical VLAN");
      break;
    case OPEN_AUTHMGR_GUEST_VLAN:
      snprintf(strVlanAssignedType, sizeof(strVlanAssignedType), "%s", "Guest VLAN");
      break;
    case OPEN_AUTHMGR_VOICE_VLAN:
      snprintf(strVlanAssignedType, sizeof(strVlanAssignedType), "%s", "Voice VLAN");
      break;
    case OPEN_AUTHMGR_MONITOR_MODE_VLAN:
      snprintf(strVlanAssignedType, sizeof(strVlanAssignedType), "%s", "Monitor Mode VLAN");
      break;
    case OPEN_AUTHMGR_NOT_ASSIGNED:
    default:
      snprintf(strVlanAssignedType, sizeof(strVlanAssignedType), "%s", "Not Assigned");
      break;                         
  }
  printf ("\r\n");
  printf("Vlan Assigned Type : %s \r\n", strVlanAssignedType);

  /* Reason Code */
  result = openapiAuthMgrHistoryLogReasonCodeGet(client_handle, intIfNum,
                                                 entryIndex, &reasonCode);
  if (OPEN_E_NONE != result)
  {
    printf ("Failed to get reason code for port:%s(%d) result:%d\r\n",
            intfNameStr, intIfNum, result);
    return;
  }

  result = openapiAuthMgrHistoryLogReasonStringGet(client_handle, intIfNum,
                                                   entryIndex, reasonCode, &reason);
  if (OPEN_E_NONE != result)
  {
    printf ("Failed to get reason string for port:%s(%d)  for reason:%s result:%d\r\n",
            intfNameStr, intIfNum,(char*)reason.pstart, result);
    return;
  }
  printf ("\r\n");
  printf("Reason (code) : %s (%d) \r\n", strReason, reasonCode);
  
  /* client filter-id */
  result = openapiAuthMgrHistoryLogFilterIdGet(client_handle, intIfNum,
                                               entryIndex, &filterId);
  if (OPEN_E_NONE != result)
  {
    printf ("Failed to get Filter ID for port:%s(%d) result:%d\r\n",
            intfNameStr, intIfNum, result);
    return;
  }
  printf ("\r\n");
  printf("Filter ID: %s \r\n", strFilter);

  return;
}

/*****************************************************************/
void authMgrAuthenticationHistoryDisplayAll(openapiClientHandle_t *client_handle)
{
  uint32_t entryIndex = 0;
  uint32_t intIfNum = 0;

  if (OPEN_E_NONE != openapiAuthMgrHistoryLogIndexNextGet(client_handle,
                                                          &intIfNum, &entryIndex))
  {
    printf ("No authentication history is present on the switch.\r\n");
    return;
  }

  printf("\r\nAuthentication Manager Authentication History details:\r\n");
  do 
  {
    authMgrAuthenticationHistoryLogShow(client_handle, intIfNum, entryIndex);
    printf ("\r\n");
  }while (OPEN_E_NONE == openapiAuthMgrHistoryLogIndexNextGet(client_handle,
                                                              &intIfNum, &entryIndex));
}

/*****************************************************************/
void authMgrAuthenticationHistoryDisplay(openapiClientHandle_t *client_handle,
                                         uint32_t intIfNum)
{
  uint32_t entryIndex = 0;
  uint32_t intf = 0;

  if (OPEN_E_NONE != openapiAuthMgrHistoryLogIndexNextGet(client_handle,
                                                          &intf, &entryIndex))
  {
    printf ("No authentication history is present on the switch for port:%d.\r\n", intIfNum);
    return;
  }



  printf("\r\nAuthentication Manager Authentication History details:\r\n");
  do 
  {
    if (intf == intIfNum)
    {
      authMgrAuthenticationHistoryLogShow(client_handle, intIfNum, entryIndex);
      printf ("\r\n");
    }
  }while (OPEN_E_NONE == openapiAuthMgrHistoryLogIndexNextGet(client_handle,
                                                              &intf, &entryIndex));
}

/*****************************************************************/
void authMgrAuthenticationHistoryDisplayAllInReverseOrder(openapiClientHandle_t *client_handle)
{
  uint32_t entryIndex = 0;
  uint32_t intIfNum = 0;

  if (OPEN_E_NONE != openapiAuthMgrHistoryLogReverseIndexNextGet(client_handle,
                                                                 &intIfNum, &entryIndex))
  {
    printf ("No authentication history is present on the switch.\r\n");
    return;
  }

  printf("\r\nAuthentication Manager Authentication History details:\r\n");
  do 
  {
    authMgrAuthenticationHistoryLogShow(client_handle, intIfNum, entryIndex);
    printf ("\r\n");
  }while (OPEN_E_NONE == openapiAuthMgrHistoryLogReverseIndexNextGet(client_handle,
                                                                     &intIfNum, &entryIndex));
}

/*****************************************************************/
void authMgrHistoryLogInterfaceClear(openapiClientHandle_t *client_handle,
                                     uint32_t intIfNum)
{
  open_error_t result;

  if ((result = openapiAuthMgrHistoryLogInterfacePurge(client_handle, intIfNum)) != OPEN_E_NONE)
  {
    printf("Bad return code trying to clearing the history table for the "
           "port %d (result = %d)\r\n", intIfNum, result);
  }
  else
  {
    printf("Authentication history table is cleared on the port %d\r\n", intIfNum);
  }
  return;
}

/*****************************************************************/
void authMgrHistoryLogInterfaceClearAll(openapiClientHandle_t *client_handle)
{
  open_error_t result;

  if ((result = openapiAuthMgrHistoryLogPurgeAll(client_handle)) != OPEN_E_NONE)
  {
    printf("Bad return code trying to clearing the history table on all "
           "the ports (result = %d)\r\n", result);
  }
  else
  {
    printf("Authentication history table is cleared on all the ports.\r\n");
  }
  return;
}

/*****************************************************************/
void
authMgrPortInitializeSet(openapiClientHandle_t *client_handle,
                         uint32_t intIfNum, OPEN_BOOL_t initialize)
{
  open_error_t result;

  if (OPEN_E_NONE != 
      (result = openapiAuthMgrPortInitializeSet(client_handle, intIfNum, initialize)))
  {
    printf("Bad return code trying to to initialize (or) re-authenticate "
        "the specific interface. (result = %d)\n", result);
  }
  else
  {
    printf("Initialize (or) re-authenticate is successfully set on interface %d.\n",
            intIfNum);
  }
  return;
}


/*****************************************************************/
void
authMgrPortAdminControlledDirectionsSet(openapiClientHandle_t *client_handle,
                                        uint32_t intIfNum,
                                        OPEN_AUTHMGR_PORT_DIRECTION_t cntrlDir)
{
  open_error_t result;

  if (OPEN_E_NONE != 
      (result = openapiAuthMgrPortAdminControlledDirectionsSet(client_handle, intIfNum, cntrlDir)))
  {
    printf("Bad return code trying to sets the authentication admin control "
        "direction on the specified port. (result = %d)\n", result);
  }
  else
  {
    printf("Authentication admin control direction %d is successfully set on interface %d.\n",
           cntrlDir, intIfNum);
  }
  return;
}


/*****************************************************************/
void
authMgrPortAdminControlledDirectionsGet(openapiClientHandle_t *client_handle,
                                        uint32_t intIfNum,
                                        OPEN_AUTHMGR_PORT_DIRECTION_t *pCntrlDir)
{
  open_error_t result;

  if (OPEN_E_NONE != 
      (result = openapiAuthMgrPortAdminControlledDirectionsGet(client_handle, intIfNum, pCntrlDir)))
  {
    printf("Bad return code trying to gets Auth manager admin control "
        "direction on the specified port. (result = %d)\n", result);
  }
  else
  {
    printf("Auth manager admin control direction of %d is successfully fetched on interface %d.\n",
        *pCntrlDir, intIfNum);
  }
  return;
}

/***************************************************************/
int main(int argc, char **argv)
{
  openapiClientHandle_t clientHandle;
  open_error_t result;
  uint32_t testNum;
  open_buffdesc switch_os_revision;
  char switch_os_revision_string[100];
  int  show_help = 1;
  OPEN_CONTROL_t mode;
  uint32_t recvMode;
  OPEN_AUTHMGR_PORT_DIRECTION_t cntrlDir;

  if (argc < 2)
  {
    printAppMenu(argv[0]);
    return -1;
  }

  testNum = atoi(argv[1]);

  l7proc_crashlog_register();

  /* Register with OpEN */
  if ((result = openapiClientRegister("authmgr example", &clientHandle)) != OPEN_E_NONE)
  {
    printf("\nFailed to initialize RPC to OpEN. Exiting (result = %d)\n", result);
    return -1;
  }

  /* RPC call can fail until server starts. Keep trying */
  while (openapiConnectivityCheck(&clientHandle) != OPEN_E_NONE)
  {
    sleep(1);
  }

  L7PROC_LOGF(L7PROC_LOG_SEVERITY_INFO, 0, "Starting authmgr API example application");

  printf("\n");
  switch_os_revision.pstart = switch_os_revision_string;
  switch_os_revision.size = sizeof(switch_os_revision_string);
  if (openapiNetworkOSVersionGet(&clientHandle, &switch_os_revision) == OPEN_E_NONE)
    printf("Network OS version = %s\n", switch_os_revision_string);
  else
    printf("Network OS version retrieve error\n");

  printf("\n");

  switch (testNum)
  {
    case 1:
      if (argc == 3)
      {
        recvMode = atoi(argv[2]);
        if ((0 == recvMode) || (1 == recvMode))
        {
          mode = recvMode ? OPEN_ENABLE : OPEN_DISABLE;
          authMgrDynamicVlanCreationModeSet(&clientHandle, mode);
        }
        show_help = 0;
      }
      break;
    case 2:
      if (argc == 3)
      {
        recvMode = atoi(argv[2]);
        if ((0 == recvMode) || (1 == recvMode))
        {
          mode = recvMode ? OPEN_ENABLE : OPEN_DISABLE;
          authMgrVlanAssignmentModeSet(&clientHandle, mode);
        }
        show_help = 0;
      }
    case 3:
      if (argc == 5)
      {
        authMgrPortAuthMethodOrderSet(&clientHandle, atoi(argv[2]), atoi(argv[3]), atoi(argv[4]));
        show_help = 0;
      }
      break;
    case 4:
      if (argc == 5)
      {
        authMgrPortAuthMethodPrioritySet(&clientHandle, atoi(argv[2]), atoi(argv[3]), atoi(argv[4]));
        show_help = 0;
      }
      break;
    case 5:
      if (argc == 4)
      {
        authMgrPortMaxUsersSet(&clientHandle, atoi(argv[2]), atoi(argv[3]));
        show_help = 0;
      }
      break;
    case 6:
      if (argc == 4)
      {
        authMgrPortUnauthenticatedVlanSet(&clientHandle, atoi(argv[2]), atoi(argv[3]));
        show_help = 0;
      }
      break;
    case 7:
      if (argc == 3)
      {
        authMgrAuthenticationInterfaceShow(&clientHandle, atoi(argv[2]));
        show_help = 0;
      }
      break;
    case 8:
      if (argc == 3)
      {
        authMgrAuthenticationClientsDisplay(&clientHandle, atoi(argv[2]));
        show_help = 0;
      }
      break;
    case 9:
      if (argc == 4)
      {
        portControlModeSet(&clientHandle, argc, argv);
        show_help = 0;
      }
      break;
    case 10:
      if (argc == 3)
      {
        authMgrAdminModeSet(&clientHandle, argc, argv);
        show_help = 0;
      }
      break;
    case 11:
      if (argc == 4)
      {
        authHostModeSet(&clientHandle, argc, argv);
        show_help = 0;
      }
      break;
    case 12:
      if (argc == 4)
      {
        portGuestVlanSet(&clientHandle, argc, argv);
        show_help = 0;
      }
      break;
    case 13:
      if (argc == 4)
      {
        authenticationPeriodicSet(&clientHandle, argc, argv);
        show_help = 0;
      }
      break;
    case 14:
      if (argc == 4)
      {
        reauthenticationPeriodSet(&clientHandle, argc, argv);
        show_help = 0;
      }
      break;
    case 15:
      if (argc == 4)
      {
        reauthPeriodFromServerSet(&clientHandle, argc, argv);
        show_help = 0;
      }
      break;
    case 16:
      if (argc == 4)
      {
        authMgrPortMaxAuthAttemptsSet(&clientHandle, atoi(argv[2]), atoi(argv[3]));
        show_help = 0;
      }
      break;
    case 17:
      if (argc == 2)
      {
        authMgrAuthenticationHistoryDisplayAll(&clientHandle);
        show_help = 0;
      }
      break;
    case 18:
      if (argc == 2)
      {
        authMgrAuthenticationHistoryDisplayAllInReverseOrder(&clientHandle);
        show_help = 0;
      }
      break;
    case 19:
      if (argc == 3)
      {
        authMgrAuthenticationHistoryDisplay(&clientHandle, atoi(argv[2]));
        show_help = 0;
      }
      break;
    case 20:
      if (argc == 2)
      {
        authMgrHistoryLogInterfaceClearAll(&clientHandle);
        show_help = 0;
      }
      break;
    case 21:
      if (argc == 3)
      {
        authMgrHistoryLogInterfaceClear(&clientHandle, atoi(argv[2]));
        show_help = 0;
      }
      break;
    case 22:
      if (argc == 2)
      {
        runSanity(&clientHandle);
        show_help = 0;
      }
      break;
    case 23:
      if (argc == 4)
      {
        authMgrPortInitializeSet(&clientHandle, atoi(argv[2]), atoi(argv[3]));
        show_help = 0;
      }
      break;
    case 24:
      if (argc == 4)
      {
        authMgrPortAdminControlledDirectionsSet(&clientHandle, atoi(argv[2]), atoi(argv[3]));
        show_help = 0;
      }
      break;
    case 25:
      if (argc == 3)
      {
        authMgrPortAdminControlledDirectionsGet(&clientHandle, atoi(argv[2]), &cntrlDir);
        show_help = 0;
      }
      break;
    default:
      break;
  }

  if (show_help == 1)
  {
    printAppMenu(argv[0]);
  }

  /* Log goodbye message with OpEN */
  L7PROC_LOGF(L7PROC_LOG_SEVERITY_INFO, 0, "Stopping authmgr API example application");

  (void) openapiClientTearDown(&clientHandle);
  return 0;
}