00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00039 #ifndef BLOCXX_SOCKET_HPP_INCLUDE_GUARD_
00040 #define BLOCXX_SOCKET_HPP_INCLUDE_GUARD_
00041 #include "blocxx/BLOCXX_config.h"
00042 #include "blocxx/CommonFwd.hpp"
00043 #include "blocxx/SelectableIFC.hpp"
00044 #include "blocxx/IOIFC.hpp"
00045 #include "blocxx/SocketBaseImpl.hpp"
00046 #include "blocxx/Types.hpp"
00047 #include "blocxx/UnnamedPipe.hpp"
00048 #include "blocxx/SocketFlags.hpp"
00049 #include "blocxx/NetworkTypes.hpp"
00050 #include "blocxx/SocketAddress.hpp"
00051 #include "blocxx/IntrusiveReference.hpp"
00052 #include "blocxx/Timeout.hpp"
00053 #include "blocxx/Exception.hpp"
00054 #include "blocxx/LazyGlobal.hpp"
00055
00056 #ifndef BLOCXX_NO_SSL
00057 #include <openssl/ssl.h>
00058 #endif
00059
00060
00061 namespace BLOCXX_NAMESPACE
00062 {
00063
00064 BLOCXX_DECLARE_APIEXCEPTION(SocketTimeout, BLOCXX_COMMON_API)
00065 class BLOCXX_COMMON_API Socket : public SelectableIFC, public IOIFC
00066 {
00067 public:
00071 Socket();
00076 Socket(const SSLClientCtxRef& sslCtx);
00081 Socket(SocketFlags::ESSLFlag isSSL) BLOCXX_DEPRECATED;
00089 Socket(SocketHandle_t fd, SocketAddress::AddressType addrType,
00090 SocketFlags::ESSLFlag isSSL = SocketFlags::E_NOT_SSL);
00099 Socket(const SocketAddress& addr, SocketFlags::ESSLFlag isSSL = SocketFlags::E_NOT_SSL);
00105 void connect(const SocketAddress& addr)
00106 { m_impl->connect(addr); }
00110 void disconnect() { m_impl->disconnect(); }
00111
00112 static const int INFINITE_TIMEOUT BLOCXX_DEPRECATED = -1;
00117 BLOCXX_DEPRECATED void setReceiveTimeout(int seconds) { m_impl->setReceiveTimeout(Timeout::relative(seconds));}
00122 void setReceiveTimeout(const Timeout& timeout) { m_impl->setReceiveTimeout(timeout);}
00127 Timeout getReceiveTimeout() const { return m_impl->getReceiveTimeout(); }
00132 BLOCXX_DEPRECATED void setSendTimeout(int seconds) { m_impl->setSendTimeout(Timeout::relative(seconds)); }
00137 void setSendTimeout(const Timeout& timeout) { m_impl->setSendTimeout(timeout); }
00142 Timeout getSendTimeout() const { return m_impl->getSendTimeout(); }
00147 BLOCXX_DEPRECATED void setConnectTimeout(int seconds) { m_impl->setConnectTimeout(Timeout::relative(seconds)); }
00152 void setConnectTimeout(const Timeout& timeout) { m_impl->setConnectTimeout(timeout); }
00157 Timeout getConnectTimeout() const { return m_impl->getConnectTimeout(); }
00162 BLOCXX_DEPRECATED void setTimeouts(int seconds) { m_impl->setTimeouts(Timeout::relative(seconds)); }
00167 void setTimeouts(const Timeout& timeout) { m_impl->setTimeouts(timeout); }
00172 bool receiveTimeOutExpired() const { return m_impl->receiveTimeOutExpired(); }
00181 int write(const void* dataOut, int dataOutLen, ErrorAction errorAsException = E_RETURN_ON_ERROR)
00182 { return m_impl->write(dataOut, dataOutLen, errorAsException); }
00191 int read(void* dataIn, int dataInLen, ErrorAction errorAsException = E_RETURN_ON_ERROR)
00192 { return m_impl->read(dataIn, dataInLen, errorAsException); }
00193
00200 BLOCXX_DEPRECATED bool waitForInput(int timeOutSecs)
00201 { return m_impl->waitForInput(Timeout::relative(timeOutSecs)); }
00202
00209 bool waitForInput(const Timeout& timeout = Timeout::infinite)
00210 { return m_impl->waitForInput(timeout); }
00211
00218 BLOCXX_DEPRECATED bool waitForOutput(int timeOutSecs)
00219 { return m_impl->waitForOutput(Timeout::relative(timeOutSecs)); }
00220
00227 bool waitForOutput(const Timeout& timeout = Timeout::infinite)
00228 { return m_impl->waitForOutput(timeout); }
00229
00234 SocketAddress getLocalAddress() const { return m_impl->getLocalAddress(); }
00239 SocketAddress getPeerAddress() const { return m_impl->getPeerAddress(); }
00245 std::istream& getInputStream()
00246 { return m_impl->getInputStream(); }
00252 std::ostream& getOutputStream()
00253 { return m_impl->getOutputStream(); }
00259 BLOCXX_DEPRECATED std::iostream& getIOStream()
00260 { return m_impl->getIOStream(); }
00264 Select_t getSelectObj() const { return m_impl->getSelectObj(); }
00269 SocketHandle_t getfd() { return m_impl->getfd(); }
00270
00274 bool isConnected() const { return m_impl->isConnected(); }
00275
00276 static void createShutDownMechanism();
00282 static void shutdownAllSockets();
00287 static bool gotShutDown() BLOCXX_DEPRECATED;
00288 static void deleteShutDownMechanism();
00289
00290 #if defined(BLOCXX_WIN32)
00291 typedef HANDLE ShutDownMechanism_t;
00292 #else
00293 typedef UnnamedPipeRef ShutDownMechanism_t;
00294 #endif
00295
00296 static ShutDownMechanism_t getShutDownMechanism()
00297 {
00298 return s_shutDownMechanism;
00299 }
00300
00301 #ifndef BLOCXX_NO_SSL
00302
00307 SSL* getSSL() const;
00308
00313 bool peerCertVerified() const;
00314 #endif
00315
00316 private:
00324 Socket(SocketHandle_t fd, SocketAddress::AddressType addrType,
00325 const SSLServerCtxRef& sslCtx);
00326
00327 #ifdef BLOCXX_WIN32
00328 #pragma warning (push)
00329 #pragma warning (disable: 4251)
00330 #endif
00331
00332 SocketBaseImplRef m_impl;
00333
00334 #ifdef BLOCXX_WIN32
00335 #pragma warning (pop)
00336 #endif
00337
00338 struct ShutDownMechanismFactory
00339 {
00340 static Socket::ShutDownMechanism_t* create(int initVal)
00341 {
00342 return new Socket::ShutDownMechanism_t();
00343 }
00344 };
00345 static LazyGlobal<Socket::ShutDownMechanism_t, int, ShutDownMechanismFactory> s_shutDownMechanism;
00346
00347 friend class ServerSocketImpl;
00348
00349 };
00350
00351 }
00352
00353 #endif