AnyConnect Secure Mobility Client 5.1.9.113

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_