21 #ifndef INCLUDE_RCF_CLIENTSTUB_HPP 22 #define INCLUDE_RCF_CLIENTSTUB_HPP 29 #include <RCF/ClientTransport.hpp> 31 #include <RCF/Export.hpp> 33 #include <RCF/MethodInvocation.hpp> 34 #include <RCF/SerializationProtocol_Base.hpp> 36 #include <RCF/RecursionLimiter.hpp> 37 #include <RCF/SerializationProtocol.hpp> 40 #if RCF_FEATURE_FILETRANSFER==1 41 #include <RCF/FileDownload.hpp> 42 #include <RCF/FileUpload.hpp> 63 HttpCookie(
const std::string& name,
const std::string& value);
68 class RCF_EXPORT CurrentClientStubSentry
71 CurrentClientStubSentry(
ClientStub & clientStub);
72 CurrentClientStubSentry(
ClientStub * pClientStub);
73 ~CurrentClientStubSentry();
83 public ClientTransportCallback,
84 public std::enable_shared_from_this<ClientStub>
89 ClientStub(
const std::string & interfaceName,
const std::string &serverBindingName);
96 void init(
const std::string & interfaceName,
const std::string & serverBindingName);
101 void setInterfaceName(
const std::string & interfaceName);
113 void setServerEndpoint(
const Endpoint &endpoint);
154 void setAutoReconnect(
bool autoReconnect);
157 bool getAutoReconnect()
const;
163 void setConnectTimeoutMs(
unsigned int connectTimeoutMs);
166 unsigned int getConnectTimeoutMs()
const;
171 void instantiateTransport();
174 void setEndpoint(
const Endpoint &endpoint);
198 void setUserName(
const tstring & username);
201 tstring getUserName()
const;
206 void setPassword(
const tstring & password);
209 tstring getPassword()
const;
214 void setKerberosSpn(
const tstring & kerberosSpn);
217 tstring getKerberosSpn()
const;
222 void setEnableCompression(
bool enableCompression);
225 bool getEnableCompression()
const;
242 const std::string & getInterfaceName();
257 void setEnableSfPointerTracking(
bool enable);
260 bool getEnableSfPointerTracking()
const;
267 void setAutoVersioning(
bool autoVersioning);
270 bool getAutoVersioning()
const;
295 void setPingBackIntervalMs(
int pingBackIntervalMs);
298 int getPingBackIntervalMs();
303 void setRemoteCallTimeoutMs(
unsigned int remoteCallTimeoutMs);
306 unsigned int getRemoteCallTimeoutMs()
const;
310 void setRemoteCallProgressCallback(
312 std::uint32_t callbackIntervalMs);
318 const std::string & getServerBindingName()
const;
321 void setServerBindingName(
const std::string &bindingName);
324 #if RCF_FEATURE_FILETRANSFER==1 334 const std::string& downloadId,
335 const Path& downloadPath,
340 std::string& uploadId,
341 const Path& uploadPath,
355 void setRequestUserData(
const std::string & userData);
358 std::string getRequestUserData();
361 void setResponseUserData(
const std::string & userData);
364 std::string getResponseUserData();
372 void setOutofBandRequest(
ByteBuffer requestBuffer);
378 void setOutofBandResponse(
ByteBuffer responseBuffer);
387 void setHttpProxy(
const std::string & httpProxy);
390 std::string getHttpProxy()
const;
393 void setHttpProxyPort(
int httpProxyPort);
396 int getHttpProxyPort()
const;
399 void setHttpProxyUserName(
const tstring & proxyUsername);
402 tstring getHttpProxyUserName()
const;
405 void setHttpProxyPassword(
const tstring & proxyPassword);
408 tstring getHttpProxyPassword()
const;
411 void setHttpProxyRealm(
const tstring & proxyRealm);
414 tstring getHttpProxyRealm()
const;
421 void setHttpCookies(
const std::vector<HttpCookie> & cookies);
424 std::vector<HttpCookie> getHttpCookies()
const;
427 void clearHttpCookies();
449 void setOpenSslCipherSuite(
const std::string & cipherSuite);
452 std::string getOpenSslCipherSuite()
const;
455 void setEnableSchannelCertificateValidation(
const tstring & peerName);
458 tstring getEnableSchannelCertificateValidation()
const;
472 #if RCF_FEATURE_SSPI==1 474 void setSchannelEnabledProtocols(DWORD enabledProtocols);
475 DWORD getSchannelEnabledProtocols()
const;
477 void setSchannelContextRequirements(ULONG contextRequirements);
478 ULONG getSchannelContextRequirements()
const;
482 PCtxtHandle getTransportSecurityContext()
const;
486 PCtxtHandle getTransportProtocolSecurityContext()
const;
492 void setWindowsImpersonationToken(HANDLE hToken);
496 HANDLE getWindowsImpersonationToken()
const;
508 void enableBatching();
511 void disableBatching(
bool flush =
true);
514 void flushBatch(
unsigned int timeoutMs = 0);
517 void setMaxBatchMessageLength(std::uint32_t maxBatchMessageLength);
520 std::uint32_t getMaxBatchMessageLength();
523 std::uint32_t getBatchesSent();
526 std::uint32_t getMessagesInCurrentBatch();
537 void connectAsync(std::function<
void()> onCompletion);
543 void waitForReady(std::uint32_t timeoutMs = 0);
549 bool hasAsyncException();
552 std::unique_ptr<Exception> getAsyncException();
557 void wait(std::function<
void()> onCompletion, std::uint32_t timeoutMs);
559 void setTries(std::size_t tries);
560 std::size_t getTries()
const;
562 #if RCF_FEATURE_FILETRANSFER==1 571 const std::string & whichFile,
572 std::string & uploadId,
573 std::uint32_t chunkSize,
574 std::uint32_t transferRateBps,
575 std::uint32_t sessionLocalId);
578 const FileManifest & whichFile,
579 std::string & uploadId,
580 std::uint32_t chunkSize,
581 std::uint32_t transferRateBps,
582 std::uint32_t sessionLocalId);
585 const Path& downloadToPath,
586 FileManifest & manifest,
587 std::uint32_t chunkSize,
588 std::uint32_t transferRateBps,
589 std::uint32_t sessionLocalId,
590 const std::string & downloadId,
591 std::uint64_t startPos = 0,
592 std::uint64_t endPos = -1);
594 std::uint32_t addUploadStream(FileUpload fileStream);
595 void processUploadStreams();
597 std::uint32_t addDownloadStream(FileDownload fileStream);
600 void setTransferWindowS(std::uint32_t transferWindowS);
601 std::uint32_t getTransferWindowS();
608 const CallOptions & callOptions,
615 std::size_t getPingBackCount();
616 std::uint32_t getPingBackTimeStamp();
618 void clearParameters();
620 SerializationProtocolIn & getSpIn();
621 SerializationProtocolOut & getSpOut();
623 void setAsync(
bool async);
626 void setAsyncException(std::unique_ptr<Exception>);
628 std::uint32_t generatePollingTimeout(std::uint32_t timeoutMs);
629 void onPollingTimeout();
632 void setSubRcfClientPtr(RcfClientPtr clientStubPtr);
633 RcfClientPtr getSubRcfClientPtr();
635 void setEnableNativeWstringSerialization(
bool enable);
636 bool getEnableNativeWstringSerialization()
const;
638 friend class CallOptions;
642 friend class FutureConverterBase;
643 friend class FutureImplBase;
662 friend class AllocateClientParameters;
681 friend class ClientParameters;
702 void onConnectCompleted(
703 bool alreadyConnected =
false);
705 void setupTransportProtocol();
706 void onSetupTransportProtocolCompleted();
710 void onSendCompleted();
712 void onReceiveCompleted();
714 void onTimerExpired();
717 const std::exception &e);
719 void setAsyncCallback(
720 std::function<
void()> callback);
725 void scheduleAmiNotification();
727 void createFilterSequence(std::vector<FilterPtr> & filters);
729 void setConnected(
bool connected);
731 virtual bool isClientStub()
const;
739 void requestTransportFilters(
const std::vector<FilterPtr> &filters);
740 void requestTransportFilters(FilterPtr filterPtr);
741 void requestTransportFilters();
743 void clearTransportFilters();
746 void requestTransportFiltersAsync(
747 const std::vector<FilterPtr> & filters,
748 std::function<
void()> onCompletion);
750 void requestTransportFiltersAsync(
752 std::function<
void()> onCompletion);
754 void setMessageFilters(
const std::vector<FilterPtr> &filters);
755 void setMessageFilters();
756 void setMessageFilters(FilterPtr filterPtr);
758 const std::vector<FilterPtr> &getMessageFilters();
760 std::vector<char> & getRetValVec();
763 void setupProxiedConnection(
const std::string& proxyEndpointName);
766 std::string mProxyEndpointName;
772 std::string mEndpointName;
773 std::string mServerBindingName;
774 std::string mInterfaceName;
776 unsigned int mRemoteCallTimeoutMs;
777 unsigned int mConnectTimeoutMs;
785 std::vector<FilterPtr> mMessageFilters;
788 unsigned int mProgressCallbackIntervalMs = 0;
791 bool mAutoVersioning;
792 std::uint32_t mRuntimeVersion;
793 std::uint32_t mArchiveVersion;
795 bool mEnableSfPointerTracking;
796 bool mEnableNativeWstringSerialization =
false;
798 std::vector<I_Future *> mFutures;
800 MethodInvocationRequest mRequest;
801 SerializationProtocolIn mIn;
802 SerializationProtocolOut mOut;
805 AsyncOpType mAsyncOpType;
806 std::function<void()> mAsyncCallback;
807 std::unique_ptr<Exception> mAsyncException;
808 unsigned int mEndTimeMs;
812 std::vector<ByteBuffer> mEncodedByteBuffers;
814 std::vector<char> mRetValVec;
815 std::vector<char> mParametersVec;
816 I_Parameters * mpParameters;
818 std::uint32_t mPingBackIntervalMs;
819 std::uint32_t mPingBackTimeStamp;
820 std::size_t mPingBackCount;
822 std::uint32_t mNextTimerCallbackMs;
823 std::uint32_t mNextPingBackCheckMs;
824 std::uint32_t mPingBackCheckIntervalMs;
826 MutexPtr mSignalledMutexPtr;
827 ConditionPtr mSignalledConditionPtr;
828 LockPtr mSignalledLockPtr;
832 Mutex mSubRcfClientMutex;
833 RcfClientPtr mSubRcfClientPtr;
836 ReallocBufferPtr mBatchBufferPtr;
837 ReallocBuffer mBatchBufferTemp;
838 std::uint32_t mBatchMaxMessageLength;
839 std::uint32_t mBatchCount;
840 std::uint32_t mBatchMessageCount;
843 bool mSetTransportProtocol;
846 #if RCF_FEATURE_FILETRANSFER==1 849 std::vector<FileUpload> mUploadStreams;
850 std::vector<FileDownload> mDownloadStreams;
853 std::uint32_t mTransferWindowS;
855 RecursionState<int, int> mRecursionState;
859 std::string mCurrentCallMethodName;
860 std::string mCurrentCallDesc;
861 bool mCallInProgress;
865 std::unique_ptr<HANDLE> mWindowsImpersonationToken;
869 std::string mHttpProxy;
871 tstring mHttpProxyRealm;
872 std::map<std::string, HttpCookie> mHttpCookies;
876 tstring mHttpProxyUsername;
877 tstring mHttpProxyPassword;
878 tstring mKerberosSpn;
879 bool mEnableCompression;
885 tstring mSchannelCertificateValidation;
887 std::string mOpenSslCipherSuite;
891 #if RCF_FEATURE_SSPI==1 892 DWORD mSchannelEnabledProtocols = 0;
893 ULONG mSchannelContextRequirements = 0;
897 friend class HttpFrameFilter;
898 std::map<std::string, HttpCookie> & getCookieMap();
901 void requestTransportFilters_Legacy(
const std::vector<FilterPtr> &filters);
903 void requestTransportFiltersAsync_Legacy(
904 const std::vector<FilterPtr> &filters,
905 std::function<
void()> onCompletion);
908 class RCF_EXPORT CallOptions
913 CallOptions(
RemoteCallMode rcs,
const std::function<
void()> & callback);
914 CallOptions(std::function<
void()> callback);
921 std::function<void()> mCallback;
924 class RCF_EXPORT AsyncTwoway :
public CallOptions
927 AsyncTwoway(
const std::function<
void()> & callback);
930 class RCF_EXPORT AsyncOneway :
public CallOptions
933 AsyncOneway(
const std::function<
void()> & callback);
936 class RestoreClientTransportGuard
941 ~RestoreClientTransportGuard();
950 #endif // ! INCLUDE_RCF_CLIENTSTUB_HPP SspiMessageProtection
Definition: Enums.hpp:207
RCF_FILESYSTEM_NS::path Path
Typedef for standard C++ path type.
Definition: FileSystem.hpp:35
RCF_EXPORT std::uint32_t getArchiveVersion()
Gets the RCF archive version number.
Base class of all RcfClient<> templates.
Definition: RcfClient.hpp:45
std::function< void(const RemoteCallProgressInfo &, RemoteCallAction &)> RemoteCallProgressCallback
Describes a user-provided callback function to be called periodically on the client side...
Definition: RcfFwd.hpp:83
Client side options for downloading and uploading files.
Definition: FileStream.hpp:371
Controls the client side of a RCF connection.
Definition: ClientStub.hpp:82
std::shared_ptr< Endpoint > EndpointPtr
Reference counted wrapper for RCF::Endpoint.
Definition: RcfFwd.hpp:117
std::shared_ptr< Certificate > CertificatePtr
Reference counted wrapper for RCF::Certificate.
Definition: RcfFwd.hpp:108
SerializationProtocol
Describes which serialization implementation to use when serializing data structures for a remote cal...
Definition: Enums.hpp:167
std::unique_ptr< ClientTransport > ClientTransportUniquePtr
Unique pointer wrapper for RCF::ClientTransport.
Definition: RcfFwd.hpp:43
Base class for all client transports.
Definition: ClientTransport.hpp:75
std::function< bool(Certificate *)> CertificateValidationCallback
Describes user-provided callback functions for validating a certificate.
Definition: RcfFwd.hpp:114
RemoteCallMode
Remote call mode.
Definition: Enums.hpp:141
Provides the ability for remote calls to be executed asynchronously.
Definition: Future.hpp:51
Base class for all RCF exceptions.
Definition: Exception.hpp:64
std::function< void(const FileTransferProgress &, RemoteCallAction &)> FileProgressCallback
Describes user-provided callback functions for client-side monitoring of a file transfer (download or...
Definition: RcfFwd.hpp:131
RCF_EXPORT void setArchiveVersion(std::uint32_t version)
Sets the RCF archive version number. Applies to all RCF clients and servers within the current proces...
RCF_EXPORT std::uint32_t getRuntimeVersion()
Gets the RCF runtime version number.
SslImplementation
Describes which SSL implementation to use.
Definition: Enums.hpp:85
Utility class used by RCF to determine whether a remote call should be performed synchronously or asy...
Definition: Future.hpp:35
Base class for all network endpoint types.
Definition: Endpoint.hpp:41
Base class for IP-based client transports. Provides IP-related functionality.
Definition: IpClientTransport.hpp:28
Represents an HTTP cookie, with a name and value.
Definition: ClientStub.hpp:59
Definition: ByteBuffer.hpp:40
TransportProtocol
Describes the transport protocols used by a RCF connection. Transport protocols are layered on top of...
Definition: Enums.hpp:63
Definition: AmiIoHandler.hpp:24
TransportType
Describes the transport types used by a RCF connection.
Definition: Enums.hpp:34
RCF_EXPORT void setRuntimeVersion(std::uint32_t version)
Sets the RCF runtime version number. Applies to all RCF clients and servers within the current proces...
RCF_EXPORT bool init(RcfConfigT *=nullptr)
Reference-counted initialization of RCF library. May be called multiple times (see deinit())...
Describes progress of a file download or upload.
Definition: FileStream.hpp:266