| AnyConnect Secure Mobility Client 5.1.9.113

- Main Page
- Related Pages
- Classes
- Files

- File List
- File Members

# include/ClientIfcBase.h

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