Remote Call Framework 3.1
ClientStub.hpp
Go to the documentation of this file.
1 
2 //******************************************************************************
3 // RCF - Remote Call Framework
4 //
5 // Copyright (c) 2005 - 2019, Delta V Software. All rights reserved.
6 // http://www.deltavsoft.com
7 //
8 // RCF is distributed under dual licenses - closed source or GPL.
9 // Consult your particular license for conditions of use.
10 //
11 // If you have not purchased a commercial license, you are using RCF
12 // under GPL terms.
13 //
14 // Version: 3.1
15 // Contact: support <at> deltavsoft.com
16 //
17 //******************************************************************************
18 
20 
21 #ifndef INCLUDE_RCF_CLIENTSTUB_HPP
22 #define INCLUDE_RCF_CLIENTSTUB_HPP
23 
24 #include <string>
25 #include <vector>
26 #include <memory>
27 
28 #include <RCF/ClientProgress.hpp>
29 #include <RCF/ClientTransport.hpp>
30 #include <RCF/Enums.hpp>
31 #include <RCF/Export.hpp>
32 #include <RCF/RcfClient.hpp>
33 #include <RCF/MethodInvocation.hpp>
34 #include <RCF/SerializationProtocol_Base.hpp>
35 #include <RCF/RcfFwd.hpp>
36 #include <RCF/RecursionLimiter.hpp>
37 #include <RCF/SerializationProtocol.hpp>
38 #include <RCF/Tchar.hpp>
39 
40 #if RCF_FEATURE_FILETRANSFER==1
41 #include <RCF/FileDownload.hpp>
42 #include <RCF/FileUpload.hpp>
43 #endif
44 
45 #ifdef RCF_WINDOWS
46 #include <windows.h>
47 #endif
48 
49 #ifdef RCF_WINDOWS
50 #include <wincred.h>
51 #endif
52 
53 namespace RCF {
54 
56 
59  class RCF_EXPORT HttpCookie
60  {
61  public:
62  HttpCookie();
63  HttpCookie(const std::string& name, const std::string& value);
64  std::string mName;
65  std::string mValue;
66  };
67 
68  class RCF_EXPORT CurrentClientStubSentry
69  {
70  public:
71  CurrentClientStubSentry(ClientStub & clientStub);
72  CurrentClientStubSentry(ClientStub * pClientStub);
73  ~CurrentClientStubSentry();
74 
75  private:
76  bool mEnabled;
77  };
78 
80 
82  class RCF_EXPORT ClientStub :
83  public ClientTransportCallback,
84  public std::enable_shared_from_this<ClientStub>
85  {
86 
87  public:
88  ClientStub(const std::string & interfaceName);
89  ClientStub(const std::string & interfaceName, const std::string &serverBindingName);
90  ClientStub(const ClientStub & rhs);
91  ~ClientStub();
92 
93  ClientStub &operator=(const ClientStub & rhs);
94 
95  private:
96  void init(const std::string & interfaceName, const std::string & serverBindingName);
97  void assign(const ClientStub & rhs);
98 
99  // Used internally only.
100  friend class I_RcfClient;
101  void setInterfaceName(const std::string & interfaceName);
102 
103 
104  public:
105 
109 
111 
113  void setServerEndpoint(const Endpoint &endpoint);
114 
116  void setServerEndpoint(EndpointPtr endpointPtr);
117 
119  EndpointPtr getServerEndpoint() const;
120 
122  void setTransport(ClientTransportUniquePtr transport);
123 
125  ClientTransport& getTransport();
126 
128  IpClientTransport & getIpTransport();
129 
131  ClientTransportUniquePtr releaseTransport();
132 
134  TransportType getTransportType();
135 
137  void connect();
138 
140  void disconnect();
141 
143  bool isConnected();
144 
146  FutureConverter<Void> ping();
147 
149 
154  void setAutoReconnect(bool autoReconnect);
155 
157  bool getAutoReconnect() const;
158 
160 
163  void setConnectTimeoutMs(unsigned int connectTimeoutMs);
164 
166  unsigned int getConnectTimeoutMs() const;
167 
169 
170  // Instantiates a client transport for this ClientStub, based on the endpoint type.
171  void instantiateTransport();
172 
173  // Sets the network endpoint at which the RCF server is located.
174  void setEndpoint(const Endpoint &endpoint);
175 
176  // Sets the network endpoint at which the RCF server is located.
177  void setEndpoint(EndpointPtr endpointPtr);
178 
179  // Gets the network endpoint at which the RCF server is located.
180  EndpointPtr getEndpoint() const;
181 
182 
186 
188 
190  void setTransportProtocol(TransportProtocol protocol);
191 
193  TransportProtocol getTransportProtocol() const;
194 
196 
198  void setUserName(const tstring & username);
199 
201  tstring getUserName() const;
202 
204 
206  void setPassword(const tstring & password);
207 
209  tstring getPassword() const;
210 
212 
213  // Only applicable to the Kerberos transport protocol.
214  void setKerberosSpn(const tstring & kerberosSpn);
215 
217  tstring getKerberosSpn() const;
218 
220 
222  void setEnableCompression(bool enableCompression);
223 
225  bool getEnableCompression() const;
226 
228  void setSspiMessageProtection(SspiMessageProtection sspiMessageProtection);
229 
231  SspiMessageProtection getSspiMessageProtection() const;
232 
234 
235 
238 
240 
242  const std::string & getInterfaceName();
243 
245  RemoteCallMode getRemoteCallMode() const;
246 
248  void setRemoteCallMode(RemoteCallMode defaultCallingSemantics);
249 
251  void setSerializationProtocol(SerializationProtocol protocol);
252 
254  SerializationProtocol getSerializationProtocol() const;
255 
257  void setEnableSfPointerTracking(bool enable);
258 
260  bool getEnableSfPointerTracking() const;
261 
263 
265  // and the archive version back to that of the RCF server, if the server reports a version mismatch.
267  void setAutoVersioning(bool autoVersioning);
268 
270  bool getAutoVersioning() const;
271 
273 
278  void setRuntimeVersion(std::uint32_t version);
279 
281  std::uint32_t getRuntimeVersion() const;
282 
284 
287  void setArchiveVersion(std::uint32_t version);
288 
290  std::uint32_t getArchiveVersion() const;
291 
293 
295  void setPingBackIntervalMs(int pingBackIntervalMs);
296 
298  int getPingBackIntervalMs();
299 
301 
303  void setRemoteCallTimeoutMs(unsigned int remoteCallTimeoutMs);
304 
306  unsigned int getRemoteCallTimeoutMs() const;
307 
310  void setRemoteCallProgressCallback(
311  RemoteCallProgressCallback progressCallback,
312  std::uint32_t callbackIntervalMs);
313 
314 
316 
317  // Gets the servant binding name to use on the RCF server.
318  const std::string & getServerBindingName() const;
319 
320  // Sets the servant binding name to use on the RCF server.
321  void setServerBindingName(const std::string &bindingName);
322 
323 
324 #if RCF_FEATURE_FILETRANSFER==1
325 
329 
331 
333  void downloadFile(
334  const std::string& downloadId,
335  const Path& downloadPath,
336  FileTransferOptions * pOptions = NULL);
337 
339  void uploadFile(
340  std::string& uploadId,
341  const Path& uploadPath,
342  FileTransferOptions * pOptions = NULL);
343 
345 
346 #endif
347 
348 
353 
355  void setRequestUserData(const std::string & userData);
356 
358  std::string getRequestUserData();
359 
361  void setResponseUserData(const std::string & userData);
362 
364  std::string getResponseUserData();
365 
367 
368  // Gets out-of-band data associated with the next request.
369  ByteBuffer getOutOfBandRequest();
370 
371  // Sets out-of-band data associated with the next request.
372  void setOutofBandRequest(ByteBuffer requestBuffer);
373 
374  // Gets out-of-band data associated with the previous response.
375  ByteBuffer getOutOfBandResponse();
376 
377  // Sets out-of-band data associated with the previous response.
378  void setOutofBandResponse(ByteBuffer responseBuffer);
379 
380 
383 
385 
387  void setHttpProxy(const std::string & httpProxy);
388 
390  std::string getHttpProxy() const;
391 
393  void setHttpProxyPort(int httpProxyPort);
394 
396  int getHttpProxyPort() const;
397 
399  void setHttpProxyUserName(const tstring & proxyUsername);
400 
402  tstring getHttpProxyUserName() const;
403 
405  void setHttpProxyPassword(const tstring & proxyPassword);
406 
408  tstring getHttpProxyPassword() const;
409 
411  void setHttpProxyRealm(const tstring & proxyRealm);
412 
414  tstring getHttpProxyRealm() const;
415 
417 
421  void setHttpCookies(const std::vector<HttpCookie> & cookies);
422 
424  std::vector<HttpCookie> getHttpCookies() const;
425 
427  void clearHttpCookies();
428 
430 
435 
437  void setCertificate(CertificatePtr certificatePtr);
438 
440  CertificatePtr getCertificate() const;
441 
443  void setCaCertificate(CertificatePtr certificatePtr);
444 
446  CertificatePtr getCaCertificate() const;
447 
449  void setOpenSslCipherSuite(const std::string & cipherSuite);
450 
452  std::string getOpenSslCipherSuite() const;
453 
455  void setEnableSchannelCertificateValidation(const tstring & peerName);
456 
458  tstring getEnableSchannelCertificateValidation() const;
459 
461  void setCertificateValidationCallback(CertificateValidationCallback certificateValidationCb);
462 
464  const CertificateValidationCallback & getCertificateValidationCallback() const;
465 
467  void setSslImplementation(SslImplementation sslImplementation);
468 
470  SslImplementation getSslImplementation() const;
471 
472 #if RCF_FEATURE_SSPI==1
473 
474  void setSchannelEnabledProtocols(DWORD enabledProtocols);
475  DWORD getSchannelEnabledProtocols() const;
476 
477  void setSchannelContextRequirements(ULONG contextRequirements);
478  ULONG getSchannelContextRequirements() const;
479 
482  PCtxtHandle getTransportSecurityContext() const;
483 
486  PCtxtHandle getTransportProtocolSecurityContext() const;
487 #endif
488 
490 
491 #ifdef RCF_WINDOWS
492  void setWindowsImpersonationToken(HANDLE hToken);
494 
496  HANDLE getWindowsImpersonationToken() const;
497 #endif
498 
499 
504 
506 
508  void enableBatching();
509 
511  void disableBatching(bool flush = true);
512 
514  void flushBatch(unsigned int timeoutMs = 0);
515 
517  void setMaxBatchMessageLength(std::uint32_t maxBatchMessageLength);
518 
520  std::uint32_t getMaxBatchMessageLength();
521 
523  std::uint32_t getBatchesSent();
524 
526  std::uint32_t getMessagesInCurrentBatch();
527 
529 
533 
535 
537  void connectAsync(std::function<void()> onCompletion);
538 
540  bool ready();
541 
543  void waitForReady(std::uint32_t timeoutMs = 0);
544 
546  void cancel();
547 
549  bool hasAsyncException();
550 
552  std::unique_ptr<Exception> getAsyncException();
553 
555 
556 
557  void wait(std::function<void()> onCompletion, std::uint32_t timeoutMs);
558 
559  void setTries(std::size_t tries);
560  std::size_t getTries() const;
561 
562 #if RCF_FEATURE_FILETRANSFER==1
563 
564  // Legacy file transfer API.
565 
566  void setFileProgressCallback(FileProgressCallback fileProgressCb);
567  void setFileProgressCallback() { setFileProgressCallback( FileProgressCallback() ); }
568  void runFileProgressNotifications(FileTransferProgress& progress);
569 
570  void uploadFiles(
571  const std::string & whichFile,
572  std::string & uploadId,
573  std::uint32_t chunkSize,
574  std::uint32_t transferRateBps,
575  std::uint32_t sessionLocalId);
576 
577  void uploadFiles(
578  const FileManifest & whichFile,
579  std::string & uploadId,
580  std::uint32_t chunkSize,
581  std::uint32_t transferRateBps,
582  std::uint32_t sessionLocalId);
583 
584  void downloadFiles(
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);
593 
594  std::uint32_t addUploadStream(FileUpload fileStream);
595  void processUploadStreams();
596 
597  std::uint32_t addDownloadStream(FileDownload fileStream);
598 
599  // For testing.
600  void setTransferWindowS(std::uint32_t transferWindowS);
601  std::uint32_t getTransferWindowS();
602 #endif
603 
604 
605  FutureConverter<Void> ping(const CallOptions & callOptions);
606 
607  FutureConverter<Void> doControlMessage(
608  const CallOptions & callOptions,
609  ByteBuffer controlRequest);
610 
611  //**********************************************************************
612 
613  public:
614 
615  std::size_t getPingBackCount();
616  std::uint32_t getPingBackTimeStamp();
617 
618  void clearParameters();
619 
620  SerializationProtocolIn & getSpIn();
621  SerializationProtocolOut & getSpOut();
622 
623  void setAsync(bool async);
624  bool getAsync();
625 
626  void setAsyncException(std::unique_ptr<Exception>);
627 
628  std::uint32_t generatePollingTimeout(std::uint32_t timeoutMs);
629  void onPollingTimeout();
630  void onUiMessage();
631 
632  void setSubRcfClientPtr(RcfClientPtr clientStubPtr);
633  RcfClientPtr getSubRcfClientPtr();
634 
635  void setEnableNativeWstringSerialization(bool enable);
636  bool getEnableNativeWstringSerialization() const;
637 
638  friend class CallOptions;
639 
640  private:
641 
642  friend class FutureConverterBase;
643  friend class FutureImplBase;
644 
645  template<
646  typename R,
647  typename A1,
648  typename A2,
649  typename A3,
650  typename A4,
651  typename A5,
652  typename A6,
653  typename A7,
654  typename A8,
655  typename A9,
656  typename A10,
657  typename A11,
658  typename A12,
659  typename A13,
660  typename A14,
661  typename A15>
662  friend class AllocateClientParameters;
663 
664  template<
665  typename R,
666  typename A1,
667  typename A2,
668  typename A3,
669  typename A4,
670  typename A5,
671  typename A6,
672  typename A7,
673  typename A8,
674  typename A9,
675  typename A10,
676  typename A11,
677  typename A12,
678  typename A13,
679  typename A14,
680  typename A15>
681  friend class ClientParameters;
682 
683  template<typename T>
684  friend class Future;
685 
686  void enrol(
687  I_Future *pFuture);
688 
689  void init(
690  int fnId,
691  RCF::RemoteCallMode rcs);
692 
693  void beginCall();
694 
695  void beginSend();
696 
697  void beginReceive();
698 
699  void call(
700  RCF::RemoteCallMode rcs);
701 
702  void onConnectCompleted(
703  bool alreadyConnected = false);
704 
705  void setupTransportProtocol();
706  void onSetupTransportProtocolCompleted();
707 
708  void doBatching();
709 
710  void onSendCompleted();
711 
712  void onReceiveCompleted();
713 
714  void onTimerExpired();
715 
716  void onError(
717  const std::exception &e);
718 
719  void setAsyncCallback(
720  std::function<void()> callback);
721 
722  void onException(
723  const Exception & e);
724 
725  void scheduleAmiNotification();
726 
727  void createFilterSequence(std::vector<FilterPtr> & filters);
728 
729  void setConnected(bool connected);
730 
731  virtual bool isClientStub() const;
732 
733 
734 
735  public:
736  // Old-style setting of transport and message filters. Leaving as public for now.
737 
738  // Synchronous transport filter requests.
739  void requestTransportFilters(const std::vector<FilterPtr> &filters);
740  void requestTransportFilters(FilterPtr filterPtr);
741  void requestTransportFilters();
742 
743  void clearTransportFilters();
744 
745  // Asynchronous transport filter requests.
746  void requestTransportFiltersAsync(
747  const std::vector<FilterPtr> & filters,
748  std::function<void()> onCompletion);
749 
750  void requestTransportFiltersAsync(
751  FilterPtr filterPtr,
752  std::function<void()> onCompletion);
753 
754  void setMessageFilters(const std::vector<FilterPtr> &filters);
755  void setMessageFilters();
756  void setMessageFilters(FilterPtr filterPtr);
757 
758  const std::vector<FilterPtr> &getMessageFilters();
759 
760  std::vector<char> & getRetValVec();
761 
762 
763  void setupProxiedConnection(const std::string& proxyEndpointName);
764 
765  private:
766  std::string mProxyEndpointName;
767 
768  private:
769 
770  RemoteCallMode mRemoteCallMode;
771  SerializationProtocol mProtocol;
772  std::string mEndpointName;
773  std::string mServerBindingName;
774  std::string mInterfaceName;
775 
776  unsigned int mRemoteCallTimeoutMs;
777  unsigned int mConnectTimeoutMs;
778  bool mAutoReconnect;
779  bool mConnected;
780  std::size_t mTries;
781 
782  EndpointPtr mEndpoint;
783  ClientTransportUniquePtr mTransport;
784 
785  std::vector<FilterPtr> mMessageFilters;
786 
787  RemoteCallProgressCallback mProgressCallback;
788  unsigned int mProgressCallbackIntervalMs = 0;
789 
790 
791  bool mAutoVersioning;
792  std::uint32_t mRuntimeVersion;
793  std::uint32_t mArchiveVersion;
794 
795  bool mEnableSfPointerTracking;
796  bool mEnableNativeWstringSerialization = false;
797 
798  std::vector<I_Future *> mFutures;
799 
800  MethodInvocationRequest mRequest;
801  SerializationProtocolIn mIn;
802  SerializationProtocolOut mOut;
803 
804  bool mAsync;
805  AsyncOpType mAsyncOpType;
806  std::function<void()> mAsyncCallback;
807  std::unique_ptr<Exception> mAsyncException;
808  unsigned int mEndTimeMs;
809  bool mRetry;
810  RemoteCallMode mRcs;
811  ByteBuffer mEncodedByteBuffer;
812  std::vector<ByteBuffer> mEncodedByteBuffers;
813 
814  std::vector<char> mRetValVec;
815  std::vector<char> mParametersVec;
816  I_Parameters * mpParameters;
817 
818  std::uint32_t mPingBackIntervalMs;
819  std::uint32_t mPingBackTimeStamp;
820  std::size_t mPingBackCount;
821 
822  std::uint32_t mNextTimerCallbackMs;
823  std::uint32_t mNextPingBackCheckMs;
824  std::uint32_t mPingBackCheckIntervalMs;
825 
826  MutexPtr mSignalledMutexPtr;
827  ConditionPtr mSignalledConditionPtr;
828  LockPtr mSignalledLockPtr;
829 
830  bool mSignalled;
831 
832  Mutex mSubRcfClientMutex;
833  RcfClientPtr mSubRcfClientPtr;
834 
835  bool mBatchMode;
836  ReallocBufferPtr mBatchBufferPtr;
837  ReallocBuffer mBatchBufferTemp;
838  std::uint32_t mBatchMaxMessageLength;
839  std::uint32_t mBatchCount;
840  std::uint32_t mBatchMessageCount;
841 
842  // Set to true if we need to set the transport protocol without disconnecting.
843  bool mSetTransportProtocol;
844 
845 
846 #if RCF_FEATURE_FILETRANSFER==1
847  FileProgressCallback mFileProgressCb;
848 
849  std::vector<FileUpload> mUploadStreams;
850  std::vector<FileDownload> mDownloadStreams;
851 #endif
852 
853  std::uint32_t mTransferWindowS;
854 
855  RecursionState<int, int> mRecursionState;
856 
857  public:
858 
859  std::string mCurrentCallMethodName;
860  std::string mCurrentCallDesc;
861  bool mCallInProgress;
862 
863 #ifdef RCF_WINDOWS
864  private:
865  std::unique_ptr<HANDLE> mWindowsImpersonationToken;
866 #endif
867 
868  private:
869  std::string mHttpProxy;
870  int mHttpProxyPort;
871  tstring mHttpProxyRealm;
872  std::map<std::string, HttpCookie> mHttpCookies;
873  TransportProtocol mTransportProtocol;
874  tstring mUsername;
875  tstring mPassword;
876  tstring mHttpProxyUsername;
877  tstring mHttpProxyPassword;
878  tstring mKerberosSpn;
879  bool mEnableCompression;
880  SspiMessageProtection mSspiMessageProtection = Smp_Encryption;
881 
882  CertificatePtr mCertificatePtr;
883  CertificatePtr mCaCertificatePtr;
884  CertificateValidationCallback mCertificateValidationCb;
885  tstring mSchannelCertificateValidation;
886 
887  std::string mOpenSslCipherSuite;
888 
889  SslImplementation mSslImplementation;
890 
891 #if RCF_FEATURE_SSPI==1
892  DWORD mSchannelEnabledProtocols = 0;
893  ULONG mSchannelContextRequirements = 0;
894 #endif
895 
896 
897  friend class HttpFrameFilter;
898  std::map<std::string, HttpCookie> & getCookieMap();
899 
900  private:
901  void requestTransportFilters_Legacy(const std::vector<FilterPtr> &filters);
902 
903  void requestTransportFiltersAsync_Legacy(
904  const std::vector<FilterPtr> &filters,
905  std::function<void()> onCompletion);
906  };
907 
908  class RCF_EXPORT CallOptions
909  {
910  public:
911  CallOptions();
912  CallOptions(RemoteCallMode rcs);
913  CallOptions(RemoteCallMode rcs, const std::function<void()> & callback);
914  CallOptions(std::function<void()> callback);
915  RemoteCallMode apply(ClientStub &clientStub) const;
916 
917  private:
918  bool mAsync;
919  bool mRcsSpecified;
920  RemoteCallMode mRcs;
921  std::function<void()> mCallback;
922  };
923 
924  class RCF_EXPORT AsyncTwoway : public CallOptions
925  {
926  public:
927  AsyncTwoway(const std::function<void()> & callback);
928  };
929 
930  class RCF_EXPORT AsyncOneway : public CallOptions
931  {
932  public:
933  AsyncOneway(const std::function<void()> & callback);
934  };
935 
936  class RestoreClientTransportGuard
937  {
938  public:
939 
940  RestoreClientTransportGuard(ClientStub &client, ClientStub &clientTemp);
941  ~RestoreClientTransportGuard();
942 
943  private:
944  ClientStub &mClient;
945  ClientStub &mClientTemp;
946  };
947 
948 } // namespace RCF
949 
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
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