CLIClientImpl Class Reference

#include <CLIClientImpl.h>

Public Member Functions
void	printHostList ()
void	printDefaultHost ()
void	connect (std::string host, std::string user, std::string password, std::string group)
void	disconnect ()
void	showGroups (std::string host)
void	getStats ()
void	setUserData (ConnectPromptInfo &ConnectPrompt)
void	printGroupList (ConnectPromptInfo &ConnectPrompt)
std::wstring	convertMultiByteToWide (const std::string &sInputData)
void	EventAvailable ()
void	ProcessEvents ()
void	SetRequestType (RequestType e_RequestType)
Public Member Functions inherited from ClientIfc
bool	attach (ClientType clientType=ClientType_GUI, bool requestFullCapabilities=true, bool suppressAutoConnect=true)
void	detach ()
void	ProcessEvents ()
bool	hasFullCapabilities ()
bool	isConnected (bool bSilent=false)
bool	isAvailable ()
bool	isVPNServiceAvailable ()
bool	isOperatingMode (OperatingMode opMode)
std::list< tstring >	getHostNames ()
tstring	getDefaultHostName ()
bool	connect (tstring host)
bool	connect (tstring host, unsigned int origin)
bool	setNewTunnelGroup (const tstring &group)
void	disconnect ()
void	cancel ()
void	getState ()
void	getStats ()
void	resetStats ()
void	startStats ()
void	stopStats ()
void	exportStats (const tstring &tstrFilePath)
void	setBannerResponse (bool bAccepted)
void	setPreConnectReminderResponse ()
void	setCertBlockedResponse (bool bUnblock)
void	setCertWarningResponse (bool bConnect, bool bImportCert)
void	UserSubmit ()
std::shared_ptr< PreferenceInfo >	getPreferences ()
unsigned int	getPreferencesCount ()
bool	savePreferences (const std::shared_ptr< PreferenceInfo > &spPreferenceInfo)
tstring	getConnectHost ()
void	setLastVpnError (VPNError vpnError)
VPNError	getLastVpnError ()
bool	isConnectRequestActive ()

Protected Member Functions
void	StatsCB (VPNStats &stats)
void	StateCB (const VPNState state, const VPNSubState subState, const tstring stateString)
void	BannerCB (const tstring &banner)
void	PreConnectReminderCB (const tstring &rtstrPreConnectReminder)
void	NoticeCB (const tstring &notice, const MessageType type, const bool bSensitive=false)
void	ExitNoticeCB (const tstring &notice, const int returnCode)
void	ServiceReadyCB ()
void	UserPromptCB (ConnectPromptInfo &ConnectPrompt)
void	CertBlockedCB (const tstring &rtstrUntrustedServer)
void	CertWarningCB (const tstring &rtstrUntrustedServer, const std::list< tstring > &rltstrCertErrors, bool bAllowImport)
Protected Member Functions inherited from ClientIfcBase
virtual void	WMHintCB (const WMHint hint, const WMHintReason reason)
virtual void	deliverWebLaunchHostCB (const tstring &activeHost)
void	ResetQuarantinedReconnect ()
void	ClientIfcTransmigration ()
bool	attach (const ClientType clientType=ClientType_GUI, const bool requestFullCapabilities=true, const bool suppressAutoConnect=true, const bool bSuppressEventAvailableCB=false)
void	detach ()
void	ProcessEvents ()
bool	hasFullCapabilities ()
bool	isConnected (bool bSilent=false)
bool	isAvailable ()
std::list< tstring >	getHostNames ()
std::list< HostEntry >	getHostEntries ()
tstring	getDefaultHostName ()
bool	connect (tstring host)
bool	connect (tstring host, unsigned int origin)
bool	setNewTunnelGroup (const tstring &group)
void	disconnect ()
void	cancel ()
void	resetStats ()
void	getState ()
VPNState	getCurrentVPNState ()
VPNSubState	getCurrentVPNSubState ()
VPNSubState	getPreviousVPNSubState ()
STATE	getCurrentState ()
tstring	getStateText ()
void	setNetworkStates (NETENV_STATE netEnvState, NETCTRL_STATE netCtrlState, NETWORK_TYPE netType, bool bACBrowserForCPRemediation, bool bUpdateUI)
void	refreshOperatingModeForCurrentNetStates ()
NETENV_STATE	getCurrentNetEnvState ()
NETENV_STATE	getPreviousNetEnvState ()
NETCTRL_STATE	getCurrentNetCtrlState ()
NETWORK_TYPE	getCurrentNetType ()
bool	isACBrowserForCPRemediation ()
tstring	getNetworkStatusText (const VPNState state, const VPNSubState subState, const NETENV_STATE netEnvState, const NETCTRL_STATE netCtrlState)
PreferenceInfo &	getPreferences ()
bool	savePreferences ()
void	startStats ()
void	stopStats ()
void	UserSubmit ()
void	setBanner (const tstring &banner)
void	setBannerResponse (bool bResponse)
void	setPreConnectReminder (const tstring &tstrPreConnectReminder)
void	setPreConnectReminderResponse ()
bool	getUserResponse ()
bool	isUserResponseSet ()
void	setCertBlocked (const tstring &tstrUntrustedServer)
void	setCertWarning (const tstring &rtstrUntrustedServer, const std::list< tstring > &rltstrCertErrors, bool bAllowImport)
bool	getCertImportResponse ()
void	setUserPrompt (ConnectPromptInfo &ConnectPrompt)
void	setCertBlockedResponse (bool bUnlock)
void	setCertWarningResponse (bool bConnect, bool bImportCert)
void	insertStateToConnectPrompt (ConnectPromptInfo &ConnectPrompt)
void	ExitNotice (const tstring &tstrNotice, const int code=0)
void	notice (const tstring &tstrNotice, const MessageType type=MsgType_Info, bool bClearLastMsg=false, bool bForce=false, bool bStateMsg=false, bool bSensitiveMsg=false)
void	notice (MsgWithArg &notice, const MessageType type=MsgType_Info, bool bClearLastMsg=false, bool bForce=false, bool bStateMsg=false, bool bSensitiveMsg=false)
void	getStats (void)
void	setStats (VPNStats &stats)
void	exportStats (const tstring &tstrFilePath)
void	initState (VPNState state, VPNState previousState, VPNSubState subState)
void	setState (VPNState state, VPNState previousState, VPNSubState subState=VPNSS_NORMAL, bool bUpdateStateMsg=true, bool bOnlyUpdateUI=false)
void	setWMHint (WMHint hint, WMHintReason reason)
bool	isLastConnectType (const ConnectPromptType connPromptType)
bool	isOperatingMode (OperatingMode opMode)
void	setOperatingMode (OperatingMode opMode)
void	unsetOperatingMode (OperatingMode opMode)
bool	CanRemediateCaptivePortal ()
bool	policyAllowsCaptivePortalRemediation ()
bool	isEventShutdown ()
bool	isUsingEventModel ()
time_t	getLastDisconnectTime ()
ConnectPromptInfo	getConnectPromptInfo ()
void	resetConnectPromptPasswordData ()
void	setStandaloneConnection (bool isStandalone)
void	deliverActiveHost (const tstring &activeHost, ConnectProtocolType vpnProtocol=PROTOCOL_TYPE_UNKNOWN, bool bActiveHostFriendlyName=false)
bool	isVPNServiceReady ()
void	resetLastDisconnectTime (time_t time=1)
void	processMinimize ()
void	setEnrollClientCert (CertObj *pCert)
void	linuxCertImportWarnUser ()
void	linuxCertImportWarnUserResponse (bool bAccept)
void	setDefaultHost (tstring &host)
void	setLastVpnError (VPNError vpnError)
VPNError	getLastVpnError ()
bool	requestImportLocalization (const tstring tstrLocale, const std::vector< unsigned char > &MoFileData)
void	startAHS (const unsigned int uiReason, const ProxyIfc &proxy)
void	AHSSelectedHost (const unsigned int uiReason, const std::vector< tstring > &headendList, const long statusReturnCode, const tstring &extraInfo)
std::vector< tstring >	getAHSHostList ()
unsigned int	getAHSState ()
bool	isAHSHasRun ()
bool	IsAHSCachingRestricted ()
bool	suppressConnectionErrorPopups ()
tstring	getCaptivePortalDetectedMsg ()
void	setProxyAuthPrompts (ProxyIfc *pProxy, const tstring &promptMsg)
bool	handleIpcMessage (CIpcMessage *pIpcMessage)
void	signalDisconnectedToEventNtfctnThread ()
bool	IsCsdTokenVerified () const
void	activateConnectMgrTunnelInitiationCompletionEvent ()
bool	isConnectRequestActive ()
bool	isConnectRequestCleanup ()
bool	syncProfileChange (const tstring &profileName)
tstring	getConnectHost ()
tstring	getMgmtTunnelHostname ()
VPN_TUNNEL_SCOPE	getVpnTunnelScope ()
bool	isStandaloneConnection ()
void	sendSSoLogoutPrompt (ConnectPromptInfo &cpi)
void	setExternalSSOLogoutUrlFromAgent (const tstring &logoutUrl)

Additional Inherited Members
Static Protected Member Functions inherited from ClientIfcBase
static tstring	getNoticeTypeText (MessageType msgType)
static tstring	getStateText (VPNState state, VPNSubState subState=VPNSS_NORMAL, NETENV_STATE netEnvState=NES_NETWORK_ACCESSIBLE, const tstring &tstrConnectedHost=tstring())
static tstring	getNetCtrlText (NETCTRL_STATE netCtrlState)
static tstring	getNetEnvText (NETENV_STATE netEnvState, bool bSimple=false)
static tstring	getNetTypeText (NETWORK_TYPE netType)
static tstring	getQuarantinedStatusText ()
static tstring	getNetworkStatusSimpleText (const NETENV_STATE netEnvState, const NETCTRL_STATE netCtrlState)

Detailed Description

This is an example application demonstrating the implementation of the AnyConnect API

Constructor & Destructor Documentation

CLIClientImpl()

CLIClientImpl::CLIClientImpl

(

)

               : me_RequestType(REQ_END),
                 ms_user(),
                 ms_pswd(),
                 ms_group(),
                 mb_exit(false),
                 mb_eventAvailable(false),
                 mb_ConnectingStateReceived(false) { }

~CLIClientImpl()

CLIClientImpl::~CLIClientImpl ( )

virtual

{ }

Member Function Documentation

BannerCB()

void CLIClientImpl::BannerCB ( const tstring & banner )

protectedvirtual

If a banner needs to be acknowledged, this CB delivers the banner to the client.

NOTE: Connection establishment will block until the method setBannerResponse() is called.

In a GUI, a banner would typically be displayed in a modal dialog with an accept or decline button selection.

See also

setBannerResponse() to set the user response to the banner.

Implements ClientIfcBase.

{
        bool bBannerAccepted = true;
        setBannerResponse(bBannerAccepted);
}

CertBlockedCB()

void CLIClientImpl::CertBlockedCB ( const tstring & rtstrUntrustedServer )

protectedvirtual

This method is called when the preference to block untrusted servers is enabled and the current VPN server being connected to is untrusted. Clients should present an error to the user notifying them that the current connection to rtstrUntrustedServer is being blocked. The client should also provide a way for the user to change the preference to block untrusted servers.

The user response must be indicated using setCertBlockedResponse

Implements ClientIfcBase.

{
    setCertBlockedResponse(false);
}

CertWarningCB()

void CLIClientImpl::CertWarningCB ( const tstring & rtstrUntrustedServer, const std::list< tstring > & rltstrCertErrors, bool bAllowImport )

protectedvirtual

This method is called when connections to untrusted VPN servers is allowed by policies and the current VPN server being connected to is untrusted. Clients should present a warning to the user notifying them that the current connection to rtstrUntrustedServer is unsafe. The reason the VPN server is untrusted is provided in rltstrCertErrors. The client should provide a way for the user to connect once, connect and always trust or cancel the connection. If bAllowImport is set to false then the always trust option should not be presented to users.

The user response must be indicated using setCertWarningResponse

Implements ClientIfcBase.

{
    setCertWarningResponse(false, false);
}

connect()

void CLIClientImpl::connect	(	std::string	host,
		std::string	user,
		std::string	password,
		std::string	group )

{
    me_RequestType = REQ_CONNECT;
    // save these user input values until requested by the API.
    //
#ifdef UNICODE
    ms_user = convertMultiByteToWide(user);
    ms_pswd = convertMultiByteToWide(pswd);
    ms_group = convertMultiByteToWide(group);
#else
    ms_user = user;
    ms_pswd = pswd;
    ms_group = group;
#endif
 
    // This is the main method for initiating a VPN connection.
    // The method can be found in ClientIfc.
    //
#ifdef UNICODE
    ClientIfc::connect(convertMultiByteToWide(host));
#else
    ClientIfc::connect(host);
#endif
}

convertMultiByteToWide()

std::wstring CLIClientImpl::convertMultiByteToWide

(

const std::string &

sInputData

)

{
    std::wstring wsDataBuffer;
 
    // determine number of bytes that will be written
    //
#ifdef _WIN32
    int bufSize = MultiByteToWideChar(CP_UTF8, 0, sInputData.c_str(),
                                      -1, NULL, 0);
#else
    int bufSize = mbstowcs(NULL, sInputData.c_str(), 0);
#endif
 
    if (bufSize > 0)
    {
        wchar_t *wzTmpBuf = new wchar_t[bufSize];
#ifdef _WIN32
        int converted = MultiByteToWideChar(CP_UTF8, 0, sInputData.c_str(),
                                            -1, wzTmpBuf, bufSize);
        converted--;  // drop the terminating NULL.
#else
        int converted = mbstowcs(wzTmpBuf, sInputData.c_str(), bufSize);
#endif
        wsDataBuffer.assign(wzTmpBuf, converted);
        delete[] wzTmpBuf;
    }
    else
    {
        printf("convertMultiByteToWide : Conversion failed\n");
    }
 
    return wsDataBuffer;
}

disconnect()

void CLIClientImpl::disconnect

(

)

{
    me_RequestType = REQ_DISCONNECT;
    ClientIfc::disconnect();
        // To ensure VPN service receive the disconnect message, 
    // do a short sleep before CLI terminates.
    //
    // NOTE: This is done only for demonstration purposes and would not be
    // needed in a GUI or other program that runs continuously. A more elegant way
        // to handle this case is to terminate the CLI after checking the disconnect callback message
        // from API.
    //
#ifdef _WIN32
    Sleep(1500);
#else
    sleep(1);
#endif
}

EventAvailable()

void CLIClientImpl::EventAvailable ( )

virtual

This method should be overridden by the client application to exercise some control over the delivery of events from the other protected methods in this class.

This might be necessary in cases where a GUI/CLI is being written and the data from this API needs to be delivered in the GUI/CLI or main thread. In this case, you should override this method and when it is called by the API post an event to your event queue (message pump, etc.). After this event executes in your GUI/CLI or main thread, call the method ClientIfc::ProcessEvents to have events delivered to your client application.

Reimplemented from ClientIfcBase.

{
    mtx.lock();
    mb_eventAvailable = true;
    mtx.unlock();
}

ExitNoticeCB()

void CLIClientImpl::ExitNoticeCB ( const tstring & tstrNotice, const int returnCode )

protectedvirtual

This CB would likely occur only during a connection when it was detected that the software needed to be upgraded, or when Start Before Logon (SBL) is being used.

Unlike the other callback methods, this method provides a default implementation (calling the system's exit() function). If clients of the API wish to override this behavior, they are responsible for ensuring that the current running process exits with the return code specified by returnCode.

Caution: IF YOU OVERRIDE THIS METHOD AND DO NOT EXIT WITH THE PROPER CODE SOFTWARE UPDATE FUNCTIONALITY IN YOUR CLIENT WILL BREAK

Reimplemented from ClientIfcBase.

{
#ifdef UNICODE
    printf("ExitNoticeCB (%d): %S\n", returnCode, notice.c_str());
#else
    printf("ExitNoticeCB (%d): %s\n", returnCode, notice.c_str());
#endif
}

getStats()

void CLIClientImpl::getStats

(

void

)

This method demonstrates accessing the statistics data delivered via the ClientIfc::StatsCB method.

{
    me_RequestType = REQ_STATISTICS;
    if (isConnected())
    {
        // To ensure we receive the first set of stats before we try to print,
        // do a short sleep.
        //
        // NOTE: This is done only for demonstration purposes and would not be
        // needed in a GUI or other program that runs continuously.
        //
        ClientIfc::getStats();
    }
    else
    {
        printf("Tunnel not up, no stats to print.\n");
        mb_exit = true;
    }
}

NoticeCB()

void CLIClientImpl::NoticeCB ( const tstring & notice, const MessageType type, const bool bSensitive = false )

protectedvirtual

Messages are delivered via the NoticeCB and can come from multiple sources. There are four message types (error, warning, info and status). See the MessageType enum in api.h for the list.

Clients using the API as an embedded application (not user visible) might want to further characterize messages. One option here is to use the AnyConnect message catalog and assign message codes as the translations for various messages. An application could then track messages based on its own error code scheme.

Implements ClientIfcBase.

{
    std::string msgType;
    switch(type)
        {
            case MsgType_Error:
                msgType = "Error";
                break;
            case MsgType_Warn:
                msgType = "Warn";
                break;
            case MsgType_Info:
                msgType = "Info";
                break;
            default:
                msgType = "Unknown";
                break;
        }
 
#ifdef UNICODE
    printf("Notice (%s): %S\n", msgType.c_str(), notice.c_str());
#else
    printf("Notice (%s): %s\n", msgType.c_str(), notice.c_str());
#endif
}

PreConnectReminderCB()

void CLIClientImpl::PreConnectReminderCB ( const tstring & rtstrPreConnectReminder )

protectedvirtual

If a pre-connect reminder needs to be acknowledged, this CB delivers the pre-connect reminder to the client.

NOTE: Connection establishment will block until the method setPreConnectReminderResponse() is called.

In a GUI, a pre-connect reminder would typically be displayed in a modal dialog with an OK button selection.

See also

setPreConnectReminderResponse() to set the user acknowledgement to the pre-connect reminder message.

Reimplemented from ClientIfcBase.

{
#ifdef UNICODE
   printf("\n%S", rtstrPreConnectReminder.c_str());
#else
   printf("\n%s", rtstrPreConnectReminder.c_str());
#endif
 
    printf( "Press enter key to continue... " );
    std::cin.get();
    setPreConnectReminderResponse();
}

printDefaultHost()

void CLIClientImpl::printDefaultHost

(

)

{
#ifdef UNICODE
    printf("Default host: %S\n", getDefaultHostName().c_str());
#else
    printf("Default host: %s\n", getDefaultHostName().c_str());
#endif
}

printGroupList()

void CLIClientImpl::printGroupList

(

ConnectPromptInfo &

ConnectPrompt

)

{
    std::list<tstring> promptNames;
    // get the list of PromptEntry received.
    //
    ConnectPrompt.getListPromptNames(promptNames);
 
    std::list<tstring> :: iterator name_iter;
    for (name_iter = promptNames.begin();
                     name_iter != promptNames.end(); ++name_iter)
    {
        PromptEntry *entry = ConnectPrompt.getPromptEntry(*name_iter);
        // For this demo program, we'll assume any combo box is for
        // group selection.
        //
        if (entry->getPromptType() == Prompt_Combo)
        {
            tstring groupList;
            std::list<tstring>::const_iterator lo_Citer;
 
            for (lo_Citer = entry->getValueOptions().begin();
                 lo_Citer != entry->getValueOptions().end(); ++lo_Citer)
            {
                tstring value = *lo_Citer;
                groupList += SEP + (*lo_Citer);
            }
 
 
#ifdef UNICODE
            printf("Group List: %S\n", groupList.c_str());
#else
            printf("Group List: %s\n", groupList.c_str());
#endif
        }
 
    }
}

printHostList()

void CLIClientImpl::printHostList

(

)

{
    // getHostNames can be found in ClientIfc
    //
    std::list<tstring> hostList = getHostNames();
    std::list<tstring> :: iterator host_iter;
    tstring hosts;
    for (host_iter = hostList.begin();
         host_iter != hostList.end(); ++host_iter)
    {
        hosts += *host_iter + SEP;
    }
 
#ifdef UNICODE
    printf("Host List:\n\t%S\n", hosts.c_str());
#else
    printf("Host List:\n\t%s\n", hosts.c_str());
#endif
}

ProcessEvents()

void CLIClientImpl::ProcessEvents

(

)

{
    while (!mb_exit)
    {
        mtx.lock();
        if (mb_eventAvailable)
        {
            mb_eventAvailable = false;
            ClientIfc::ProcessEvents();
        }
        mtx.unlock();
        std::this_thread::sleep_for(std::chrono::milliseconds(20));
    }
}

ServiceReadyCB()

void CLIClientImpl::ServiceReadyCB ( )

protectedvirtual

Under normal operating conditions, this CB is called as soon as the attach method completes. In case the service (vpn agent) is not ready, this CB is not called until it is.

Any API calls made prior to this CB being called will result in a NoticeCB error message.

Implements ClientIfcBase.

{ }

SetRequestType()

void CLIClientImpl::SetRequestType

(

RequestType

e_RequestType

)

{
    me_RequestType = e_RequestType;
}

setUserData()

void CLIClientImpl::setUserData

(

ConnectPromptInfo &

ConnectPrompt

)

Method with example of parsing ConnectPromptInfo.

This method is triggered by an API call on the method UserPromptCB(ConnectPromptInfo &).

{
#ifdef UNICODE
    printf("User Message: %S\n", ConnectPrompt.getMessage().c_str());
#else
    printf("User Message: %s\n", ConnectPrompt.getMessage().c_str());
#endif
 
    // Create a list to hold the names of the individual PromptEntry objects.
    //
    std::list<tstring> promptNames;
    // Get the list of names associated with the PromptEntry objects.
    //
    ConnectPrompt.getListPromptNames(promptNames);
    // This set of code cycles through the list of names that reference the
    // individual PromptEntry objects.  As each name is accessed it can be used
    // to retrieve a specific instance of a PromptEntry object.  There is also a
    // method (ConnectPromptInfo::getListPromptEntry()) to retrieve the list of
    // PromptEntry objects directly, allowing the individual PromtpEntry object
    // to be accessed in a different manner if desired.
    //
    std::list<tstring> :: iterator name_iter;
    for (name_iter = promptNames.begin();
                     name_iter != promptNames.end(); ++name_iter)
    {
        // name_iter represents a single name from the promptNames list.
        //
        tstring promptName = *name_iter;
        PromptEntry *entry = ConnectPrompt.getPromptEntry(promptName);
 
        // For this demo program, we'll assume any combo box is for
        // group selection.
        //
        if (entry->getPromptType() == Prompt_Combo)
        {
            entry->setValue(ms_group);
        }
        tstring entryName = entry->getPromptName();
 
        // PromptEntry::Username and PromptEntry::Password are string currently
        // resolving to the wide char values "username" and "password".
        // 
        if (entryName == PromptEntry::Username)
        {
            entry->setValue(ms_user);
        }
        else if (entryName == PromptEntry::Password)
        {
            entry->setValue(ms_pswd);
        }
    }
}

showGroups()

void CLIClientImpl::showGroups

(

std::string

host

)

{
    me_RequestType = REQ_GROUPLIST;
#ifdef UNICODE
    ClientIfc::connect(convertMultiByteToWide(host));
#else
    ClientIfc::connect(host);
#endif
}

StateCB()

void CLIClientImpl::StateCB ( const VPNState state, const VPNSubState subState, const tstring stateString )

protectedvirtual

Callback used to deliver VPN state and state change string. The stateString delivered by this method is localized.

See the VPNState enum found in api.h for set of valid states.

Implements ClientIfcBase.

{
#ifdef UNICODE
   printf("Current State (%d): %S\n", state, stateString.c_str());
#else
   printf("Current State (%d): %s\n", state, stateString.c_str());
#endif
 
    switch(me_RequestType)
    {
        case REQ_STATE:
            mb_exit = true;
            break;
        case REQ_DISCONNECT:
            if (VPNState::DISCONNECTED == state)
            {
                mb_exit = true;
            }
            break;
        case REQ_CONNECT:
            if (VPNState::CONNECTED == state)
            {
                mb_exit = true;
            }
 
            // API may report the current state of VPN (ie., DISCONNECTED) when a connect request is received.
            // States reported after receiving CONNECTING state should be considered for the current connection
            // attempt. Exit the main processing loop for DISCONNECTED or CONNECTED states only after CONNECTING
            // state is received. 
            // 
            if (VPNState::CONNECTING == state)
            {
                mb_ConnectingStateReceived = true;
            }
 
            if (mb_ConnectingStateReceived && 
                ((VPNState::DISCONNECTED == state) || (VPNState::CONNECTED == state)))
            {
                mb_exit = true;
            }
            break;
        default:
            break;
    }
}

StatsCB()

void CLIClientImpl::StatsCB ( VPNStats & stats )

protectedvirtual

Callback used to deliver new statistics related to the VPN connection.

When a connection is active, a new set of statistics is delivered each second.

See also

resetStats(), stopStats() and startStats()

Implements ClientIfcBase.

{
    if (REQ_STATISTICS == me_RequestType)
    {
        tstring stats = SEP + VPNStats::getTranslatedLabel(VPNStats::State)
                            + rStats.getStatValue(VPNStats::State);
            stats += SEP + VPNStats::getTranslatedLabel(VPNStats::TunnelingMode)
                         + rStats.getStatValue(VPNStats::TunnelingMode);
            stats += SEP + VPNStats::getTranslatedLabel(VPNStats::TimeConnected)
                         + rStats.getStatValue(VPNStats::TimeConnected);
            stats += SEP + VPNStats::getTranslatedLabel(VPNStats::BytesSent)
                         + rStats.getStatValue(VPNStats::BytesSent);
            stats += SEP + VPNStats::getTranslatedLabel(VPNStats::BytesReceived)
                         + rStats.getStatValue(VPNStats::BytesReceived);
 
            // Now get the data for the active protocol.
            //
            // NOTE: There is also Secure and non-secure route information.  This
            //       data can be retrieved in a manner similar to protocolInfo
            //       using the methods getSecureRoutes() and getNonsecureRoutes()
            //
            std::list<ProtocolInfo *> protInfo = rStats.getProtocolInfo();
            for (std::list<ProtocolInfo *>::iterator iter = protInfo.begin();
                                                    iter != protInfo.end();
                                                    iter++)
            {
                if ((*iter)->isActive())
                {
                    stats += SEP + VPNStats::getTranslatedLabel(ProtocolInfo::Cipher)
                                +(*iter)->getProtocolValue(ProtocolInfo::Cipher);
                    stats += SEP + VPNStats::getTranslatedLabel(ProtocolInfo::Protocol)
                                +(*iter)->getProtocolValue(ProtocolInfo::Protocol);
                    stats += SEP + VPNStats::getTranslatedLabel(ProtocolInfo::Compression)
                                +(*iter)->getProtocolValue(ProtocolInfo::Compression);
                }
            }
 
#ifdef UNICODE
            printf("VPN Stats:%S\n",stats.c_str());
#else
            printf("VPN Stats:%s\n",stats.c_str());
#endif
        mb_exit = true;
    }
}

UserPromptCB()

void CLIClientImpl::UserPromptCB ( ConnectPromptInfo & ConnectPrompt )

protectedvirtual

This method supports prompting for single or multiple values. All prompts are considered mandatory.

The ConnectPromptInfo object contains a list of PromptEntry instances. The labels and their default values (if any) can be found in these instances. After the data has been collected from the user it can be set into these same instances. When ready, the client application should call the method UserSubmit() to have the responses read by the API.

Implements ClientIfcBase.

{
    if (me_RequestType == REQ_CONNECT)
    {
        // For example purposes, only allow one try at setting user data.
        //
        // Look for requested user input fields and fill in previously
        // stored values.
        //
        setUserData(ConnectPrompt);
        // Now that the user data has been entered, submit the response.
        //
        UserSubmit();
    }
    else if (me_RequestType == REQ_GROUPLIST)
    {
        printGroupList(ConnectPrompt);
        mb_exit = true;
    }
}