| AnyConnect Secure Mobility Client 5.0.01242

- Main Page
- Related Pages
- Classes
- Files

- File List
- File Members

# include/ClientIfcBase.h

    00001 /**************************************************************************
    00002 *   Copyright (c) 2006, 2021-2022 Cisco Systems, Inc.
    00003 *   All Rights Reserved. Cisco Highly Confidential.
    00004 ***************************************************************************
    00005 *
    00006 *   File:   ClientIfcBase.h
    00007 *   Author: Chris Fitzgerald
    00008 *   Date:   08/2007
    00009 *
    00010 ***************************************************************************
    00011 *   Client Interface Base class implementation for the Client API.
    00012 ***************************************************************************/
    00013
    00014 #ifndef _CLIENTIFCBASE_
    00015 #define _CLIENTIFCBASE_
    00016
    00017 #include <list>
    00018 #include <vector>
    00019 #include <memory>
    00020
    00021 #include "api.h"
    00022 #include "ClientIfcCommon.h" // Include prior to conditional compile directives, but after api.h.
    00023
    00024 #if defined(ANYCONNECT_USE_SNAK)
    00025 #include "SNAK_CertPlugin.h"
    00026 #endif
    00027
    00028 #if defined(HOST_DATA_SUPPORTED)
    00029 class IHostData;
    00030 #endif
    00031
    00032 class ConnectPromptInfo;
    00033 class MsgWithArg;
    00034 class VPNStats;
    00035 class PreferenceInfo;
    00036 class ProxyIfc;
    00037 class CIpcMessage;
    00038 class CertObj;
    00039 class HostEntry;
    00040 class CEventNotificationTlv;
    00041 class ClientIfcInternal;
    00042
    00043 #if defined(CREDENTIAL_PREFILL_SUPPORTED)
    00044 class CredentialPrefill;
    00045 #endif
    00046
    00047 #if (defined(ANYCONNECT_USE_SNAK) || defined(PLATFORM_APPLE_SSLVPN)) && !defined(PLATFORM_WIN_APP)
    00048 class ManagedCertificate;
    00049 #endif // ANYCONNECT_USE_SNAK || PLATFORM_APPLE_SSLVPN
    00050
    00051 #if defined(PROGRAM_DATA_IMPORT_SUPPORTED)
    00052 class IACImporterAsync;
    00053 class IACImporterAsyncCB;
    00054 #endif
    00055
    00056 class VPN_VPNAPI ClientIfcBase
    00057 {
    00058     friend class EventMgr;
    00059     friend class ClientIfcInternal;
    00060
    00061     protected:
    00062
    00063         ClientIfcBase();
    00064         virtual ~ClientIfcBase();
    00065
    00066         /**
    00067         * Callback used to deliver new statistics related to the VPN
    00068         * connection.
    00069         *
    00070         * When a connection is active, a new set of statistics is
    00071         * delivered each second.
    00072         *
    00073         * @see resetStats(), stopStats() and startStats()
    00074         *
    00075         */
    00076         virtual void StatsCB(VPNStats &stats) = 0;
    00077
    00078
    00079         /**
    00080         * Callback used to deliver VPN state and state change string.
    00081         * The stateString delivered by this method is localized.
    00082         *
    00083         * See the ::VPNState enum found in api.h for set of valid states.
    00084         */
    00085         virtual void StateCB(const VPNState state,
    00086                              const VPNSubState subState,
    00087                              const tstring stateString) = 0;
    00088
    00089
    00090         /**
    00091         * If a banner needs to be acknowledged, this CB delivers the banner
    00092         * to the client.
    00093         *
    00094         * NOTE: Connection establishment will block until the method
    00095         * setBannerResponse() is called.
    00096         *
    00097         * In a GUI, a banner would typically be displayed in a modal dialog
    00098         * with an accept or decline button selection.
    00099         *
    00100         * @see setBannerResponse() to set the user response to the banner.
    00101         */
    00102         virtual void BannerCB(const tstring &banner) = 0;
    00103
    00104         /**
    00105          * If a pre-connect reminder needs to be acknowledged, this CB delivers
    00106          * the pre-connect reminder to the client.
    00107          *
    00108          * NOTE: Connection establishment will block until the method
    00109          * setPreConnectReminderResponse() is called.
    00110          *
    00111          * In a GUI, a pre-connect reminder would typically be displayed in a modal
    00112          * dialog with an OK button selection.
    00113          *
    00114          * @see setPreConnectReminderResponse() to set the user acknowledgement to
    00115          * the pre-connect reminder message.
    00116          */
    00117         virtual void PreConnectReminderCB(const tstring &rtstrPreConnectReminder);
    00118
    00119         /**
    00120         * Messages are delivered via the NoticeCB and can come from multiple
    00121         * sources.  There are four message types (error, warning, info and
    00122         * status).  See the ::MessageType enum in api.h for the list.
    00123         *
    00124         * Clients using the API as an embedded application (not
    00125         * user visible) might want to further characterize
    00126         * messages.  One option here is to use the AnyConnect message
    00127         * catalog and assign message codes as the translations for
    00128         * various messages.  An application could then track messages based
    00129         * on its own error code scheme.
    00130         */
    00131         virtual void NoticeCB(const tstring &notice,
    00132                               const MessageType type,
    00133                               const bool bSensitive = false) = 0;
    00134
    00135 #if defined(PLATFORM_APPLE_SSLVPN) || defined(PLATFORM_ANDROID) || defined(PLATFORM_CHROMEBOOK)
    00136         virtual void CertBannerCB(const tstring &certBannerSummary,
    00137                                   const uint32_t nCertBannerCertLen,
    00138                                   const uint8_t *pCertBannerCertDer,
    00139                                   const std::list<tstring> &confirmReasons,
    00140                                   const std::list<CertConfirmReason> &confirmReasonEnums,
    00141                                   bool bImportAllowed = true) = 0;
    00142 #endif
    00143
    00144         /**
    00145         * This CB would likely occur only during a connection when it was
    00146         * detected that the software needed to be upgraded, or when Start
    00147         * Before Logon (SBL) is being used.
    00148         *
    00149         * Unlike the other callback methods, this method provides a default
    00150         * implementation (calling the system's exit() function).
    00151         * If clients of the API wish to override this behavior, they are
    00152         * responsible for ensuring that the current running process exits with
    00153         * the return code specified by returnCode.
    00154         *
    00155         * <b>Caution</b>: IF YOU OVERRIDE THIS METHOD AND DO NOT EXIT WITH
    00156         * THE PROPER CODE SOFTWARE UPDATE FUNCTIONALITY IN YOUR CLIENT WILL
    00157         * BREAK
    00158         */
    00159         virtual void ExitNoticeCB(const tstring &tstrNotice,
    00160                                   const int returnCode);
    00161
    00162
    00163         /**
    00164         * Under normal operating conditions, this CB is called as soon
    00165         * as the attach method completes.  In case the service (vpn agent)
    00166         * is not ready, this CB is not called until it is.
    00167         *
    00168         * Any API calls made prior to this CB being called will result in a
    00169         * NoticeCB error message.
    00170         */
    00171         virtual void ServiceReadyCB() = 0;
    00172
    00173
    00174
    00175         /**
    00176         * This method supports prompting for single or multiple values.  All
    00177         * prompts are considered mandatory.
    00178         *
    00179         * The ConnectPromptInfo object contains a list of PromptEntry
    00180         * instances.  The labels and their default values (if any) can be
    00181         * found in these instances.  After the data has been collected from the user
    00182         * it can be set into these same instances.  When ready, the client
    00183         * application should call the method UserSubmit() to have the
    00184         * responses read by the API.
    00185         */
    00186         virtual void UserPromptCB(ConnectPromptInfo &ConnectPrompt) = 0;
    00187
    00188
    00189         /**
    00190         * Use this method to provide Window Manager hints to GUI
    00191         * applications.  To receive these hints, the application must
    00192         * identify itself as a GUI in the attach method.  In addition, this
    00193         * method should be overridden to receive any generated events.
    00194         *
    00195         * Event that can be received include those indicating that a user is
    00196         * starting a second instance of the GUI application.  This information
    00197         * can be used to tell the already running application to un-minimize
    00198         * itself and let the new program know that it should Quit (since a GUI
    00199         * is already running).
    00200         */
    00201         virtual void WMHintCB(const WMHint hint,
    00202                               const WMHintReason reason);
    00203
    00204
    00205         /**
    00206         * This method is useful when the connection to the secure gateway
    00207         * has been established as part of a web-launch of the VPN tunnel.
    00208         *
    00209         * If the client application wishes to be notified of the secure
    00210         * gateway to which the VPN has been established, this method should
    00211         * be overridden.
    00212         *
    00213         * If the client application is started and a tunnel is already active,
    00214         * this method also delivers the name of the secure gateway host.
    00215         */
    00216         virtual void deliverWebLaunchHostCB(const tstring &activeHost);
    00217
    00218         /**
    00219         * This method is called when the preference to block untrusted
    00220         * servers is enabled and the current VPN server being connected
    00221         * to is untrusted. Clients should present an error to the user
    00222         * notifying them that the current connection to rtstrUntrustedServer
    00223         * is being blocked. The client should also provide a way for the
    00224         * user to change the preference to block untrusted servers.
    00225         *
    00226         * The user response must be indicated using setCertBlockedResponse
    00227         */
    00228         virtual void CertBlockedCB(const tstring &rtstrUntrustedServer) = 0;
    00229
    00230         /**
    00231         * This method is called when connections to untrusted VPN servers
    00232         * is allowed by policies and the current VPN server being connected
    00233         * to is untrusted. Clients should present a warning to the user
    00234         * notifying them that the current connection to rtstrUntrustedServer
    00235         * is unsafe. The reason the VPN server is untrusted is provided in
    00236         * rltstrCertErrors. The client should provide a way for the user to
    00237         * connect once, connect and always trust or cancel the connection.
    00238         * If bAllowImport is set to false then the always trust option should
    00239         * not be presented to users.
    00240         *
    00241         * The user response must be indicated using setCertWarningResponse
    00242         */
    00243         virtual void CertWarningCB(const tstring &rtstrUntrustedServer,
    00244                                    const std::list<tstring> &rltstrCertErrors,
    00245                                    bool bAllowImport) = 0;
    00246
    00247 #if defined(PLATFORM_WIN_APP)
    00248         /**
    00249         * Same as above but also passes the Server certificate DER for details display
    00250         */
    00251         virtual void CertWarningCB(const tstring &rtstrUntrustedServer,
    00252                                    const std::list<tstring> &rltstrCertErrors,
    00253                                    const std::vector<uint8_t> &rvServerCertDER,
    00254                                    bool bAllowImport) = 0;
    00255 #endif
    00256
    00257         /**
    00258         * This method should be overridden by the client application to
    00259         * exercise some control over the delivery of events from the other
    00260         * protected methods in this class.
    00261         *
    00262         * This might be necessary in cases where a GUI/CLI is being written and
    00263         * the data from this API needs to be delivered in the GUI/CLI or main
    00264         * thread.  In this case, you should override this method and when it
    00265         * is called by the API post an event to your event queue (message
    00266         * pump, etc.).  After this event executes in your GUI/CLI or main thread,
    00267         * call the method ClientIfc::ProcessEvents to have events delivered
    00268         * to your client application.
    00269         */
    00270         virtual void EventAvailable();
    00271
    00272 #ifdef MANUAL_PKCS12_IMPORT_SUPPORTED
    00273         virtual void ImportPKCS12ResultCB(const std::vector<uint8_t> &certHash,
    00274                                           const tstring &tstrError);
    00275 #endif
    00276 #ifdef PLATFORM_ANDROID
    00277         virtual void ClientCertificateCB(std::vector< std::pair<uint32_t, uint8_t*> > certList) = 0;
    00278         virtual void AgentDetachedCB();
    00279 #endif
    00280
    00281         /**
    00282         * Internal callback between ClientIfcBase and ClientIfc.
    00283         */
    00284         virtual void EventNotificationInternalCB(
    00285             const std::shared_ptr<CEventNotificationTlv>& spEventNtfctnTlv) = 0;
    00286
    00287
    00288         /**
    00289         * Internal method for use by ClientIfc.
    00290         */
    00291         void ClientIfcTransmigration();
    00292
    00293     public:
    00294
    00295         bool attach(const ClientType clientType = ClientType_GUI,
    00296                     const bool requestFullCapabilities = true,
    00297                     const bool suppressAutoConnect = true,
    00298                     const bool bSuppressEventAvailableCB = false);
    00299
    00300         void detach();
    00301
    00302         void ProcessEvents();
    00303
    00304         bool hasFullCapabilities();
    00305
    00306         bool isConnected(bool bSilent = false);
    00307
    00308         bool isAvailable();
    00309
    00310         std::list<tstring> getHostNames();
    00311
    00312         std::list<HostEntry> getHostEntries();
    00313
    00314         tstring getDefaultHostName();
    00315
    00316         bool connect(
    00317 #if defined(HOST_DATA_SUPPORTED)
    00318             const IHostData& host);
    00319 #else
    00320             tstring host);
    00321 #endif
    00322
    00323         bool connect(
    00324 #if defined(HOST_DATA_SUPPORTED)
    00325             const IHostData& host,
    00326 #else
    00327             tstring host,
    00328 #endif
    00329             unsigned int origin);
    00330
    00331         bool setNewTunnelGroup(const tstring & group);
    00332
    00333         void disconnect();
    00334
    00335         void cancel();
    00336
    00337         void resetStats();
    00338
    00339         void getState();
    00340
    00341         VPNState getCurrentState();
    00342         VPNSubState getCurrentSubState();
    00343         VPNSubState getPreviousSubState();
    00344
    00345         tstring getStateText();
    00346         static tstring getNoticeTypeText(MessageType msgType);
    00347
    00348         static tstring getStateText(VPNState state,
    00349                                     VPNSubState subState = VPNSS_NORMAL,
    00350                                     NETENV_STATE netEnvState = NES_NETWORK_ACCESSIBLE,
    00351                                     const tstring& tstrConnectedHost = tstring());
    00352
    00353         void setNetworkStates(NETENV_STATE netEnvState,
    00354                               NETCTRL_STATE netCtrlState,
    00355                               NETWORK_TYPE netType,
    00356                               bool bACBrowserForCPRemediation,
    00357                               bool bUpdateUI);
    00358         void refreshOperatingModeForCurrentNetStates();
    00359         NETENV_STATE getCurrentNetEnvState();
    00360         NETENV_STATE getPreviousNetEnvState();
    00361         NETCTRL_STATE getCurrentNetCtrlState();
    00362         NETWORK_TYPE getCurrentNetType();
    00363         bool isACBrowserForCPRemediation();
    00364
    00365         static tstring getNetCtrlText(NETCTRL_STATE netCtrlState);
    00366         static tstring getNetEnvText(NETENV_STATE netEnvState,
    00367                                      bool bSimple = false);
    00368         static tstring getNetTypeText(NETWORK_TYPE netType);
    00369         static tstring getQuarantinedStatusText();
    00370         static tstring getNetworkStatusSimpleText(const NETENV_STATE netEnvState,
    00371                                                   const NETCTRL_STATE netCtrlState);
    00372
    00373         // can't be static due to requiring operating mode information
    00374         tstring getNetworkStatusText(const VPNState state,
    00375                                      const VPNSubState subState,
    00376                                      const NETENV_STATE netEnvState,
    00377                                      const NETCTRL_STATE netCtrlState);
    00378
    00379         PreferenceInfo &getPreferences();
    00380
    00381         bool savePreferences();
    00382
    00383         void startStats();
    00384
    00385         void stopStats();
    00386
    00387         void UserSubmit();
    00388
    00389         void setBanner(const tstring &banner);
    00390         void setBannerResponse(bool bResponse);
    00391
    00392         void setPreConnectReminder(const tstring &tstrPreConnectReminder);
    00393         void setPreConnectReminderResponse();
    00394
    00395         bool getUserResponse();
    00396         bool isUserResponseSet();
    00397
    00398         void setCertBlocked(const tstring &tstrUntrustedServer);
    00399         void setCertWarning(const tstring &rtstrUntrustedServer,
    00400                             const std::list<tstring> &rltstrCertErrors,
    00401                             bool bAllowImport);
    00402 #if defined(PLATFORM_WIN_APP)
    00403         void setCertWarning(const tstring &rtstrUntrustedServer,
    00404                             const std::list<tstring> &rltstrCertErrors,
    00405                             const std::vector<uint8_t>& rvServerCertDER,
    00406                             bool bAllowImport);
    00407 #endif
    00408         bool getCertImportResponse();
    00409
    00410 #if defined(PLATFORM_APPLE_SSLVPN) || defined(PLATFORM_ANDROID) || defined(PLATFORM_CHROMEBOOK)
    00411         void setCertBanner(tstring tstrCertBannerSummary,
    00412                            uint32_t nCertBannerCertLen,
    00413                            const uint8_t *pCertBannerCertDer,
    00414                            const std::list<tstring> &confirmReasons,
    00415                            const std::list<CertConfirmReason> &confirmReasonEnums,
    00416                            bool bImportAllowed);
    00417
    00418         void setCertBannerResponse(bool bResponse, bool bImportCert);
    00419         void importServerCert(std::vector<uint8_t> certData);
    00420         bool setFipsMode(bool bEnableFips);
    00421 #if defined(PLATFORM_ANDROID)
    00422         bool setStrictMode(bool bEnableStrictMode);
    00423         bool setRevocationEnabled(bool bRevocationEnabled);
    00424         bool IsRevocationEnabled();
    00425 #endif // currently supported only for android
    00426 #endif
    00427
    00428         void setUserPrompt(ConnectPromptInfo &ConnectPrompt);
    00429
    00430 #ifdef PLATFORM_ANDROID
    00431         void setClientCertResponse(std::vector< std::pair<uint32_t, uint8_t*> > &derList);
    00432         void setAgentDetached();
    00433         bool getClientCertificates();
    00434 #endif
    00435
    00436 #if defined(PLATFORM_APPLE_SSLVPN) || defined(PLATFORM_ANDROID)
    00437         void setSCEPEnrollInProgress(bool bInProgress);
    00438         bool isSCEPEnrollInProgress();
    00439 #endif // PLATFORM_APPLE_SSLVPN || PLATFORM_ANDROID
    00440
    00441 #ifdef MANUAL_PKCS12_IMPORT_SUPPORTED
    00442         void setImportPKCS12Result(const std::vector<uint8_t> &certHash, const tstring &tstrError);
    00443         bool requestImportPKCS12(const std::vector<uint8_t> &data);
    00444         std::vector<uint8_t> importPKCS12WithPassword(const std::vector<uint8_t> &data, const tstring &password);
    00445 #endif
    00446
    00447         void setCertBlockedResponse(bool bUnlock);
    00448         void setCertWarningResponse(bool bConnect, bool bImportCert);
    00449
    00450         void insertStateToConnectPrompt(ConnectPromptInfo &ConnectPrompt);
    00451
    00452         void ExitNotice(const tstring &tstrNotice, const int code = 0);
    00453
    00454         void notice(const tstring &tstrNotice,
    00455                     const MessageType type = MsgType_Info,
    00456                     bool bClearLastMsg = false,
    00457                     bool bForce = false,
    00458                     bool bStateMsg = false,
    00459                     bool bSensitiveMsg = false);
    00460
    00461         void notice(MsgWithArg &notice,
    00462                     const MessageType type = MsgType_Info,
    00463                     bool bClearLastMsg = false,
    00464                     bool bForce = false,
    00465                     bool bStateMsg = false,
    00466                     bool bSensitiveMsg = false);
    00467
    00468         void getStats(void);
    00469
    00470         void setStats(VPNStats &stats);
    00471
    00472         void exportStats(const tstring &tstrFilePath);
    00473
    00474         void initState(VPNState state,
    00475                        VPNState previousState,
    00476                        VPNSubState subState);
    00477
    00478         void setState(VPNState state,
    00479                       VPNState previousState,
    00480                       VPNSubState subState = VPNSS_NORMAL,
    00481                       bool bUpdateStateMsg = true,
    00482                       bool bOnlyUpdateUI = false);
    00483
    00484 #ifdef PROGRAM_DATA_IMPORT_SUPPORTED
    00485         IACImporterAsync *createACImporter(IACImporterAsyncCB *pCallback);
    00486 #endif
    00487
    00488         void setWMHint(WMHint hint,
    00489                        WMHintReason reason);
    00490
    00491         bool isLastConnectType (const ConnectPromptType connPromptType);
    00492
    00493         bool isOperatingMode(OperatingMode opMode);
    00494         void setOperatingMode(OperatingMode opMode);
    00495         void unsetOperatingMode(OperatingMode opMode);
    00496
    00497         bool CanRemediateCaptivePortal();
    00498         bool policyAllowsCaptivePortalRemediation();
    00499
    00500         bool isEventShutdown();
    00501
    00502         bool isUsingEventModel();
    00503
    00504         time_t getLastDisconnectTime();
    00505
    00506         ConnectPromptInfo getConnectPromptInfo();
    00507         void resetConnectPromptPasswordData();
    00508
    00509         void setStandaloneConnection(bool isStandalone);
    00510
    00511         void deliverActiveHost(const tstring &activeHost,
    00512                                ConnectProtocolType vpnProtocol = PROTOCOL_TYPE_UNKNOWN,
    00513                                bool bActiveHostFriendlyName = false);
    00514
    00515         bool isVPNServiceReady();
    00516
    00517         // reset last disconnect time indicator.
    00518         //
    00519         void resetLastDisconnectTime(time_t time = 1);
    00520
    00521         void processMinimize();
    00522
    00523         // cert enrollment
    00524         void setEnrollClientCert(CertObj* pCert);
    00525
    00526         // Show user banner for cert import warning on linux
    00527         // SCEPIfc to ConnectMgr
    00528         void linuxCertImportWarnUser();
    00529
    00530         // Response to cert warning on linux
    00531         // ConnectMgr to SCEPIfc
    00532         void linuxCertImportWarnUserResponse(bool bAccept);
    00533
    00534         void setDefaultHost(tstring &host);
    00535
    00536 #if defined(HOST_DATA_SUPPORTED)
    00537         void setDefaultHostProfile(const IHostData &hostProfile);
    00538         IHostData* getDefaultHostData();
    00539 #endif // HOST_DATA_SUPPORTED
    00540
    00541         void setLastVpnError(VPNError vpnError);
    00542         VPNError getLastVpnError();
    00543
    00544 #ifdef PLATFORM_ANDROID
    00545         bool requestClientCertificates();
    00546 #endif
    00547
    00548         bool requestImportLocalization(const tstring tstrLocale,
    00549                                        const std::vector<unsigned char> &MoFileData);
    00550
    00551         // Start the Automatic Headend Selection operation
    00552         void startAHS(const unsigned int uiReason,
    00553                       const ProxyIfc& proxy);
    00554         // statusReturnCode is a long to match the current type of STATUSCODE.
    00555         // It is not using a STATUSCODE directly so that we do not have to
    00556         // expose the header files for STATUSCODEs to ClientIfcBase.h
    00557         void AHSSelectedHost(const unsigned int uiReason,
    00558                              const std::vector<tstring> &headendList,
    00559                              const long statusReturnCode,
    00560                              const tstring& extraInfo);
    00561         std::vector<tstring> getAHSHostList();
    00562         unsigned int getAHSState();
    00563         bool isAHSHasRun();
    00564
    00565         bool suppressConnectionErrorPopups();
    00566
    00567         tstring getCaptivePortalDetectedMsg();
    00568
    00569         void setProxyAuthPrompts(ProxyIfc* pProxy,
    00570                                  const tstring& promptMsg);
    00571
    00572 #if defined(INTERPROCESS_COMMUNICATION_SUPPORTED)
    00573         bool handleIpcMessage(CIpcMessage *pIpcMessage);
    00574 #endif
    00575         bool IsCsdTokenVerified() const;
    00576
    00577 #if defined(PLATFORM_APPLE_SSLVPN) || defined(PLATFORM_ANDROID)
    00578         virtual void SCEPEnrollStartCB();
    00579         virtual void SCEPEnrollExitCB();
    00580 #endif // PLATFORM_APPLE_SSLVPN || PLATFORM_ANDROID
    00581
    00582         void activateConnectMgrTunnelInitiationCompletionEvent();
    00583         bool isConnectRequestActive();
    00584 #if defined(PLATFORM_ANDROID) || defined(PLATFORM_CHROMEBOOK)
    00585         bool deleteProfileByName(const tstring &profileName);
    00586         tstring getProfileContents(const tstring &profileName);
    00587         bool importProfile(const tstring &profileName, const tstring &profileContents);
    00588 #endif // PLATFORM_ANDROID || PLATFORM_CHROMEBOOK
    00589
    00590         bool syncProfileChange(const tstring &profileName);
    00591
    00592 #if defined(CREDENTIAL_PREFILL_SUPPORTED)
    00593         bool hasPrefilledCredentials();
    00594         bool prefillCredentials(ConnectPromptInfo &connectPrompt);
    00595         void setPrefilledCredentials(CredentialPrefill *prefill);
    00596 #endif
    00597
    00598 #if defined(PLATFORM_ANDROID) || defined(PLATFORM_APPLE_SSLVPN)
    00599         std::list<ManagedCertificate *> enumerateCertificates(CertificateType certType);
    00600         bool deleteCertificates(CertificateType certType, const std::list<std::string> &idList);
    00601         bool deleteServerCertificates(const std::list<std::string> &idList);
    00602 #endif // ANYCONNECT_USE_SNAK || PLATFORM_APPLE_SSLVPN
    00603
    00604 #if defined(ANYCONNECT_USE_SNAK) && !defined(PLATFORM_WIN_APP)
    00605         std::list<ManagedCertificate *> enumerateSNAKCertificates(SNAK_CertType certType);
    00606         SNAK_CertType getSNAKCertType(CertificateType certType);
    00607         bool deleteClientCertificates(const std::list<std::string> &idList);
    00608 #endif // ANYCONNECT_USE_SNAK
    00609
    00610 #if defined(PLATFORM_APPLE_SSLVPN)
    00611         bool canUseBackupServers();
    00612
    00613 #endif //PLATFORM_APPLE_SSLVPN
    00614
    00615         tstring getConnectHost();
    00616
    00617         tstring getMgmtTunnelHostname();
    00618
    00619         VPN_TUNNEL_SCOPE getVpnTunnelScope();
    00620
    00621         bool isStandaloneConnection();
    00622
    00623         void sendSSoLogoutPrompt(ConnectPromptInfo &cpi);
    00624
    00625         void setExternalSSOLogoutUrlFromAgent(const tstring& logoutUrl);
    00626
    00627     private:
    00628
    00629         //
    00630         // Private Member Data
    00631         //
    00632
    00633         ClientIfcInternal* m_pClientIfcInternal;
    00634
    00635
    00636         //
    00637         // Private Member Methods
    00638         //
    00639
    00640         ClientIfcBase(const ClientIfcBase& other);
    00641         ClientIfcBase& operator=(const ClientIfcBase& other);
    00642
    00643 };
    00644
    00645
    00646 #endif // _CLIENTIFCBASE_