![]() |
AnyConnect Secure Mobility Client 5.1.9.113
|
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 ¬ice, 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 ¬ice, 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_